Techwizz/Gobligine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Clean up tileset.

Browse source
This commit is contained in:
joris 2013-04-16 19:55:29 +02:00
parent ac760fba42
commit f48eb02fa5
27 changed files with 553 additions and 561 deletions

1
src/action/action_build.cpp
View file

@ -46,7 +46,6 @@
#include "pathfinder.h"
#include "player.h"
#include "script.h"
#include "tileset.h"
#include "translate.h"
#include "ui.h"
#include "unit.h"

1
src/action/action_still.cpp
View file

@ -45,7 +45,6 @@
#include "player.h"
#include "script.h"
#include "spells.h"
#include "tileset.h"
#include "unit.h"
#include "unit_find.h"
#include "unittype.h"

1
src/action/command.cpp
View file

@ -42,7 +42,6 @@
#include "pathfinder.h"
#include "player.h"
#include "spells.h"
#include "tileset.h"
#include "translate.h"
#include "upgrade.h"
#include "ui.h"

34
src/editor/editloop.cpp
View file

@ -191,7 +191,7 @@ static int GetTileNumber(int basic, int random, int filler)
if (random) {
int i, n;
for (n = i = 0; i < 16; ++i) {
if (!Map.Tileset.Table[tile + i]) {
if (!Map.Tileset->Table[tile + i]) {
if (!filler) {
break;
}
@ -202,7 +202,7 @@ static int GetTileNumber(int basic, int random, int filler)
n = MyRand() % n;
i = -1;
do {
while (++i < 16 && !Map.Tileset.Table[tile + i]) {
while (++i < 16 && !Map.Tileset->Table[tile + i]) {
}
} while (i < 16 && n--);
Assert(i != 16);
@ -210,9 +210,9 @@ static int GetTileNumber(int basic, int random, int filler)
}
if (filler) {
int i = 0;
for (; i < 16 && Map.Tileset.Table[tile + i]; ++i) {
for (; i < 16 && Map.Tileset->Table[tile + i]; ++i) {
}
for (; i < 16 && !Map.Tileset.Table[tile + i]; ++i) {
for (; i < 16 && !Map.Tileset->Table[tile + i]; ++i) {
}
if (i != 16) {
return tile + i;
@ -241,7 +241,7 @@ void EditTile(const Vec2i &pos, int tile)
MapFieldWaterAllowed | MapFieldNoBuilding | MapFieldUnpassable |
MapFieldWall | MapFieldRocks | MapFieldForest);
mf->Flags |= Map.Tileset.FlagsTable[GetTileNumber(tile, 0, 0)];
mf->Flags |= Map.Tileset->FlagsTable[GetTileNumber(tile, 0, 0)];
UI.Minimap.UpdateSeenXY(pos);
UI.Minimap.UpdateXY(pos);
@ -701,7 +701,7 @@ static void DrawTileIcon(unsigned tilenum, unsigned x, unsigned y, unsigned flag
x += 4;
y += 4;
Map.TileGraphic->DrawFrameClip(Map.Tileset.Table[tilenum], x, y);
Map.TileGraphic->DrawFrameClip(Map.Tileset->Table[tilenum], x, y);
if (flags & IconSelected) {
Video.DrawRectangleClip(ColorGreen, x, y, PixelTileSize.x, PixelTileSize.y);
@ -760,7 +760,7 @@ static void DrawTileIcons()
}
tile = Editor.ShownTileTypes[i];
Map.TileGraphic->DrawFrameClip(Map.Tileset.Table[tile], x, y);
Map.TileGraphic->DrawFrameClip(Map.Tileset->Table[tile], x, y);
Video.DrawRectangleClip(ColorGray, x, y, PixelTileSize.x, PixelTileSize.y);
if (i == Editor.SelectedTileIndex) {
@ -906,7 +906,7 @@ static void DrawMapCursor()
const PixelPos screenPos = UI.MouseViewport->TilePosToScreen_TopLeft(tilePos);
if (Editor.State == EditorEditTile && Editor.SelectedTileIndex != -1) {
const unsigned short frame = Map.Tileset.Table[Editor.ShownTileTypes[Editor.SelectedTileIndex]];
const unsigned short frame = Map.Tileset->Table[Editor.ShownTileTypes[Editor.SelectedTileIndex]];
PushClipping();
UI.MouseViewport->SetClipping();
@ -1015,13 +1015,13 @@ static void DrawEditorInfo()
//
const int tile = mf->Tile;
int i;
for (i = 0; i < Map.Tileset.NumTiles; ++i) {
if (tile == Map.Tileset.Table[i]) {
for (i = 0; i < Map.Tileset->NumTiles; ++i) {
if (tile == Map.Tileset->Table[i]) {
break;
}
}
Assert(i != Map.Tileset.NumTiles);
Assert(i != Map.Tileset->NumTiles);
/*snprintf(buf, sizeof(buf), "%d %s %s", tile,
Map.Tileset.SolidTerrainTypes[Map.Tileset.Tiles[i].BaseTerrain].TerrainName,
@ -1746,8 +1746,8 @@ static void EditorCallbackMouse(const PixelPos &pos)
}
if (bx < screenPos.x && screenPos.x < bx + PixelTileSize.x
&& by < screenPos.y && screenPos.y < by + PixelTileSize.y) {
int base = Map.Tileset.Tiles[Editor.ShownTileTypes[i]].BaseTerrain;
UI.StatusLine.Set(Map.Tileset.SolidTerrainTypes[base].TerrainName);
int base = Map.Tileset->Tiles[Editor.ShownTileTypes[i]].BaseTerrain;
UI.StatusLine.Set(Map.Tileset->SolidTerrainTypes[base].TerrainName);
Editor.CursorTileIndex = i;
return;
}
@ -1869,8 +1869,8 @@ static void EditorCallbackExit()
*/
static void CreateTileIcons()
{
for (int i = 0; 0x10 + i < Map.Tileset.NumTiles; i += 16) {
TileInfo *info = &Map.Tileset.Tiles[0x10 + i];
for (int i = 0; 0x10 + i < Map.Tileset->NumTiles; i += 16) {
TileInfo *info = &Map.Tileset->Tiles[0x10 + i];
if (info->BaseTerrain && !info->MixTerrain) {
Editor.ShownTileTypes.push_back(0x10 + i);
}
@ -1935,9 +1935,9 @@ void CEditor::Init()
const int defaultTile = 0x50;
for (int i = 0; i < Map.Info.MapWidth * Map.Info.MapHeight; ++i) {
Map.Fields[i].Tile = Map.Tileset.Table[defaultTile];
Map.Fields[i].Tile = Map.Tileset->Table[defaultTile];
Map.Fields[i].playerInfo.SeenTile = Map.Fields[i].Tile;
Map.Fields[i].Flags = Map.Tileset.FlagsTable[defaultTile];
Map.Fields[i].Flags = Map.Tileset->FlagsTable[defaultTile];
}
GameSettings.Resources = SettingsPresetMapDefault;
CreateGame("", &Map);

70
src/editor/edmap.cpp
View file

@ -92,15 +92,15 @@ static unsigned QuadFromTile(const Vec2i &pos)
// find the abstact tile number
//
const int tile = Map.Field(pos)->Tile;
for (i = 0; i < Map.Tileset.NumTiles; ++i) {
if (tile == Map.Tileset.Table[i]) {
for (i = 0; i < Map.Tileset->NumTiles; ++i) {
if (tile == Map.Tileset->Table[i]) {
break;
}
}
Assert(i != Map.Tileset.NumTiles);
Assert(i != Map.Tileset->NumTiles);
unsigned base = Map.Tileset.Tiles[i].BaseTerrain;
unsigned mix = Map.Tileset.Tiles[i].MixTerrain;
unsigned base = Map.Tileset->Tiles[i].BaseTerrain;
unsigned mix = Map.Tileset->Tiles[i].MixTerrain;
if (!mix) { // a solid tile
return base | (base << 8) | (base << 16) | (base << 24);
@ -160,24 +160,24 @@ static int FindTilePath(int base, int goal, int length, char *marks, int *tile)
// Find any mixed tile
//
int l = INT_MAX;
for (int i = 0; i < Map.Tileset.NumTiles;) {
for (int i = 0; i < Map.Tileset->NumTiles;) {
// goal found.
if (base == Map.Tileset.Tiles[i].BaseTerrain
&& goal == Map.Tileset.Tiles[i].MixTerrain) {
if (base == Map.Tileset->Tiles[i].BaseTerrain
&& goal == Map.Tileset->Tiles[i].MixTerrain) {
*tile = i;
return length;
}
// goal found.
if (goal == Map.Tileset.Tiles[i].BaseTerrain
&& base == Map.Tileset.Tiles[i].MixTerrain) {
if (goal == Map.Tileset->Tiles[i].BaseTerrain
&& base == Map.Tileset->Tiles[i].MixTerrain) {
*tile = i;
return length;
}
// possible path found
if (base == Map.Tileset.Tiles[i].BaseTerrain
&& Map.Tileset.Tiles[i].MixTerrain) {
const int j = Map.Tileset.Tiles[i].MixTerrain;
if (base == Map.Tileset->Tiles[i].BaseTerrain
&& Map.Tileset->Tiles[i].MixTerrain) {
const int j = Map.Tileset->Tiles[i].MixTerrain;
if (!marks[j]) {
marks[j] = j;
n = FindTilePath(j, goal, length + 1, marks, &n);
@ -188,9 +188,9 @@ static int FindTilePath(int base, int goal, int length, char *marks, int *tile)
}
}
// possible path found
} else if (Map.Tileset.Tiles[i].BaseTerrain
&& base == Map.Tileset.Tiles[i].MixTerrain) {
const int j = Map.Tileset.Tiles[i].BaseTerrain;
} else if (Map.Tileset->Tiles[i].BaseTerrain
&& base == Map.Tileset->Tiles[i].MixTerrain) {
const int j = Map.Tileset->Tiles[i].BaseTerrain;
if (!marks[j]) {
marks[j] = j;
n = FindTilePath(j, goal, length + 1, marks, &n);
@ -202,7 +202,7 @@ static int FindTilePath(int base, int goal, int length, char *marks, int *tile)
}
}
// Advance solid or mixed.
if (!Map.Tileset.Tiles[i].MixTerrain) {
if (!Map.Tileset->Tiles[i].MixTerrain) {
i += 16;
} else {
i += 256;
@ -250,25 +250,25 @@ find_solid:
//
// Find the solid tile
//
for (i = 0; i < Map.Tileset.NumTiles;) {
if (type1 == Map.Tileset.Tiles[i].BaseTerrain &&
!Map.Tileset.Tiles[i].MixTerrain) {
for (i = 0; i < Map.Tileset->NumTiles;) {
if (type1 == Map.Tileset->Tiles[i].BaseTerrain &&
!Map.Tileset->Tiles[i].MixTerrain) {
break;
}
// Advance solid or mixed.
if (!Map.Tileset.Tiles[i].MixTerrain) {
if (!Map.Tileset->Tiles[i].MixTerrain) {
i += 16;
} else {
i += 256;
}
}
Assert(i < Map.Tileset.NumTiles);
Assert(i < Map.Tileset->NumTiles);
return i;
}
} else {
char *marks = new char[Map.Tileset.NumTerrainTypes];
char *marks = new char[Map.Tileset->SolidTerrainTypes.size()];
memset(marks, 0, Map.Tileset.NumTerrainTypes);
memset(marks, 0, Map.Tileset->SolidTerrainTypes.size());
marks[type1] = type1;
marks[type2] = type2;
@ -318,11 +318,11 @@ find_solid:
//
// Need a mixed tile
//
for (i = 0; i < Map.Tileset.NumTiles;) {
if (type1 == Map.Tileset.Tiles[i].BaseTerrain && type2 == Map.Tileset.Tiles[i].MixTerrain) {
for (i = 0; i < Map.Tileset->NumTiles;) {
if (type1 == Map.Tileset->Tiles[i].BaseTerrain && type2 == Map.Tileset->Tiles[i].MixTerrain) {
break;
}
if (type2 == Map.Tileset.Tiles[i].BaseTerrain && type1 == Map.Tileset.Tiles[i].MixTerrain) {
if (type2 == Map.Tileset->Tiles[i].BaseTerrain && type1 == Map.Tileset->Tiles[i].MixTerrain) {
// Other mixed
type1 ^= type2;
type2 ^= type1;
@ -330,26 +330,26 @@ find_solid:
break;
}
// Advance solid or mixed.
if (!Map.Tileset.Tiles[i].MixTerrain) {
if (!Map.Tileset->Tiles[i].MixTerrain) {
i += 16;
} else {
i += 256;
}
}
if (i >= Map.Tileset.NumTiles) {
if (i >= Map.Tileset->NumTiles) {
//
// Find the best tile path.
//
char *marks = new char[Map.Tileset.NumTerrainTypes];
memset(marks, 0, Map.Tileset.NumTerrainTypes);
char *marks = new char[Map.Tileset->SolidTerrainTypes.size()];
memset(marks, 0, Map.Tileset->SolidTerrainTypes.size());
marks[type1] = type1;
if (FindTilePath(type1, type2, 0, marks, &i) == INT_MAX) {
DebugPrint("Huch, no mix found!!!!!!!!!!!\n");
delete[] marks;
goto find_solid;
}
if (type1 == Map.Tileset.Tiles[i].MixTerrain) {
if (type1 == Map.Tileset->Tiles[i].MixTerrain) {
// Other mixed
type1 ^= type2;
type2 ^= type1;
@ -390,10 +390,10 @@ find_solid:
void ChangeTile(const Vec2i &pos, int tile)
{
Assert(Map.Info.IsPointOnMap(pos));
Assert(tile >= 0 && tile < Map.Tileset.NumTiles);
Assert(tile >= 0 && tile < Map.Tileset->NumTiles);
CMapField *mf = Map.Field(pos);
mf->Tile = Map.Tileset.Table[tile];
mf->Tile = Map.Tileset->Table[tile];
mf->playerInfo.SeenTile = mf->Tile;
}
@ -423,7 +423,7 @@ static void EditorChangeTile(const Vec2i &pos, int tile, int d)
| MapFieldWaterAllowed | MapFieldNoBuilding | MapFieldUnpassable
| MapFieldWall | MapFieldRocks | MapFieldForest);
mf->Flags |= Map.Tileset.FlagsTable[tile];
mf->Flags |= Map.Tileset->FlagsTable[tile];
UI.Minimap.UpdateSeenXY(pos);
UI.Minimap.UpdateXY(pos);

3
src/game/game.cpp
View file

@ -65,6 +65,7 @@
#include "sound.h"
#include "sound_server.h"
#include "spells.h"
#include "tileset.h"
#include "translate.h"
#include "trigger.h"
#include "ui.h"
@ -470,7 +471,7 @@ int WriteMapSetup(const char *mapSetup, CMap &map, int writeTerrain)
for (int j = 0; j < map.Info.MapWidth; ++j) {
const int tile = map.Fields[j + i * map.Info.MapWidth].Tile;
int n;
for (n = 0; n < map.Tileset.NumTiles && tile != map.Tileset.Table[n]; ++n) {
for (n = 0; n < map.Tileset->NumTiles && tile != map.Tileset->Table[n]; ++n) {
}
const int value = map.Fields[j + i * map.Info.MapWidth].Value;
f->printf("SetTile(%3d, %d, %d, %d)\n", n, j, i, value);

1
src/game/loadgame.cpp
View file

@ -51,6 +51,7 @@
#include "sound.h"
#include "sound_server.h"
#include "spells.h"
#include "tileset.h"
#include "trigger.h"
#include "ui.h"
#include "unit.h"

10
src/include/map.h
View file

@ -84,10 +84,6 @@
#include <string>
#ifndef __TILESET_H__
#include "tileset.h"
#endif
#ifndef __MAP_TILE_H__
#include "tile.h"
#endif
@ -102,6 +98,7 @@
class CGraphic;
class CPlayer;
class CFile;
class CTileset;
class CUnit;
class CUnitType;
@ -150,6 +147,9 @@ public:
class CMap
{
public:
CMap();
~CMap();
unsigned int getIndex(int x, int y) const {
return x + y * this->Info.MapWidth;
}
@ -248,7 +248,7 @@ public:
CMapField *Fields; /// fields on map
bool NoFogOfWar; /// fog of war disabled
CTileset Tileset; /// tileset data
CTileset *Tileset; /// tileset data
std::string TileModelsFileName; /// lua filename that loads all tilemodels
CGraphic *TileGraphic; /// graphic for all the tiles
static CGraphic *FogGraphic; /// graphic for fog of war

8
src/include/tile.h
View file

@ -136,6 +136,8 @@
#include "unit_cache.h"
#endif
#include <vec2i.h>
class CFile;
class CPlayer;
@ -154,7 +156,9 @@ class CPlayer;
#define MapFieldNoBuilding 0x0080 /// No buildings allowed
#define MapFieldUnpassable 0x0100 /// Field is movement blocked
//#define MapFieldWall 0x0200 /// defined in tileset.h
#define MapFieldWall 0x0200 /// Field contains wall
#define MapFieldRocks 0x0400 /// Field contains rocks
#define MapFieldForest 0x0800 /// Field contains forest
#define MapFieldLandUnit 0x1000 /// Land unit on field
#define MapFieldAirUnit 0x2000 /// Air unit on field
@ -251,6 +255,8 @@ public:
CMapFieldPlayerInfo playerInfo; /// stuff related to player
};
extern PixelSize PixelTileSize; /// Size of a tile in pixels
//@}
#endif // !__MAP_TILE_H__

227
src/include/tileset.h
View file

@ -32,179 +32,12 @@
//@{
/*----------------------------------------------------------------------------
-- Documentation
----------------------------------------------------------------------------*/
/**
** @class CTileset tileset.h
**
** \#include "tileset.h"
**
** This structure contains information about the tileset of the map.
** It defines the look and properties of the tiles. Currently only one
** tileset per map is supported. In the future it is planned to support
** multiple tilesets on the same map. Also it is planned to support animated
** tiles.
**
** The tileset structure members:
**
** CTileset::Name
**
** Long name of the tileset. Can be used by the level editor.
**
** CTileset::ImageFile
**
** Name of the graphic file, containing all tiles.
**
** CTileset::NumTiles
**
** The number of different tiles in the tables.
**
** CTileset::Table
**
** Table to map the abstract level (PUD) tile numbers, to tile
** numbers in the graphic file (CTileset::File).
** FE. 16 (solid light water) in pud to 328 in png.
**
** CTileset::FlagsTable
**
** Table of the tile flags used by the editor.
** @see CMapField::Flags
**
** CTileset::BasicNameTable
**
** Index to name of the basic tile type. FE. "light-water".
** If the index is 0, the tile is not used.
** @see CTileset::TileNames
**
** CTileset::MixedNameTable
**
** Index to name of the mixed tile type. FE. "light-water".
** If this index is 0, the tile is a solid tile.
** @see CTileset::TileNames
**
** CTileset::TileTypeTable
**
** Lookup table of the tile type. Maps the graphic file tile
** number back to a tile type (::TileTypeWood, ::TileTypeWater,
** ...)
**
** @note The creation of this table is currently hardcoded in
** the engine. It should be calculated from the flags in the
** tileset configuration (CCL). And it is created for the map
** and not for the tileset.
**
** @note I'm not sure if this table is needed in the future.
**
** @see TileType.
**
** CTileset::NumNames
**
** Number of different tile names.
**
** CTileset::TileNames
**
** The different tile names. FE "light-grass", "dark-water".
**
** CTileset::TopOneTree
**
** The tile number of tile only containing the top part of a tree.
** Is created on the map by lumber chopping.
**
** CTileset::MidOneTree
**
** The tile number of tile only containing the connection of
** the top part to the bottom part of tree.
** Is created on the map by lumber chopping.
**
** CTileset::BotOneTree
**
** The tile number of tile only containing the bottom part of a
** tree. Is created on the map by lumber chopping.
**
** CTileset::RemovedTree
**
** The tile number of the tile placed where trees are removed.
** Is created on the map by lumber chopping.
**
** CTileset::GrowingTree[2]
**
** Contains the tile numbers of a growing tree from small to big.
** @note Not yet used.
**
** CTilset::WoodTable[20]
**
** Table for wood removable. This table contains the tile which
** is placed after a tree removement, depending on the surrounding.
**
** CTileset::MixedLookupTable[]
** Table for finding what part of the tile contains wood/rock,
** and which part is grass or bare ground.
**
** CTileset::TopOneRock
**
** The tile number of tile only containing the top part of a rock.
** Is created on the map by destroying rocks.
**
** CTileset::MidOneRock
**
** The tile number of tile only containing the connection of
** the top part to the bottom part of a rock.
** Is created on the map by destroying rocks.
**
** CTileset::BotOneRock
**
** The tile number of tile only containing the bottom part of a
** rock. Is created on the map by destroying rocks.
**
** CTileset::RemovedRock
**
** The tile number of the tile placed where rocks are removed.
** Is created on the map by destroying rocks.
**
** CTileset::RockTable[20]
**
** Table for rock removable. Depending on the surrinding this
** table contains the new tile to be placed.
**
** @todo Johns: I don't think this table or routines look correct.
** But they work correct.
**
** CTileset::HumanWallTable
**
** Table of human wall tiles, index depends on the surroundings.
**
** CTileset::OrcWallTable
**
** Table of orc wall tiles, index depends on the surroundings.
**
**
** @struct TileInfo tileset.h
**
** \#include "tileset.h"
**
** This structure includes everything about a specific tile from the tileset.
**
** TileInfo::BaseTerrain
**
** This is the base terrain type of a tile. Only 15 of those
** are currently supported.
**
** TileInfo::MixTerrain
**
** @todo This is the terrain the tile is mixed with. This is 0 for
** a solid tile, we should make it equal to BaseTerrain
*/
/*----------------------------------------------------------------------------
-- Declarations
----------------------------------------------------------------------------*/
#include "vec2i.h"
extern PixelSize PixelTileSize; /// Size of a tile in pixels
#include <vector>
/**
** These are used for lookup tiles types
@ -235,46 +68,14 @@ struct SolidTerrainInfo {
// TODO: When drawing with the editor add some kind fo probabilities for every tile.
};
#define MapFieldWall 0x0200 /// Field contains wall
#define MapFieldRocks 0x0400 /// Field contains rocks
#define MapFieldForest 0x0800 /// Field contains forest
/// Tileset definition
class CTileset
{
public:
void Clear() {
Name.clear();
ImageFile.clear();
NumTiles = 0;
PixelTileSize.x = PixelTileSize.y = 0;
delete[] Table;
Table = NULL;
delete[] FlagsTable;
FlagsTable = NULL;
delete[] Tiles;
Tiles = NULL;
delete[] TileTypeTable;
TileTypeTable = NULL;
delete[] SolidTerrainTypes;
SolidTerrainTypes = NULL;
NumTerrainTypes = 0;
TopOneTree = 0;
MidOneTree = 0;
BotOneTree = 0;
RemovedTree = 0;
memset(GrowingTree, 0, sizeof(GrowingTree));
memset(WoodTable, 0, sizeof(WoodTable));
delete[] MixedLookupTable;
MixedLookupTable = NULL;
TopOneRock = 0;
MidOneRock = 0;
BotOneRock = 0;
RemovedRock = 0;
memset(RockTable, 0, sizeof(RockTable));
memset(HumanWallTable, 0, sizeof(HumanWallTable));
memset(OrcWallTable, 0, sizeof(OrcWallTable));
}
void Clear();
bool IsSeenTile(unsigned short type, unsigned short seen) const;
public:
std::string Name; /// Nice name to display
std::string ImageFile; /// File containing image data
@ -288,8 +89,7 @@ public:
// TODO: currently hardcoded
unsigned char *TileTypeTable; /// For fast lookup of tile type
unsigned int NumTerrainTypes; /// Number of different terrain types
SolidTerrainInfo *SolidTerrainTypes; /// Information about solid terrains.
std::vector<SolidTerrainInfo> SolidTerrainTypes; /// Information about solid terrains.
unsigned TopOneTree; /// Tile for one tree top
unsigned MidOneTree; /// Tile for one tree middle
@ -306,21 +106,6 @@ public:
unsigned HumanWallTable[16]; /// Human wall placement table
unsigned OrcWallTable[16]; /// Orc wall placement table
bool IsSeenTile(unsigned short type, unsigned short seen) const {
if (TileTypeTable) {
switch (type) {
case MapFieldForest:
return TileTypeTable[seen] == TileTypeWood;
case MapFieldRocks:
return TileTypeTable[seen] == TileTypeRock;
default:
return false;
}
}
return false;
};
};
/*----------------------------------------------------------------------------

74
src/map/map.cpp
View file

@ -85,7 +85,7 @@ void CMap::MarkSeenTile(CMapField &mf)
const Vec2i pos = {x, y}
#endif
if (this->Tileset.TileTypeTable) {
if (this->Tileset->TileTypeTable) {
#ifndef MINIMAP_UPDATE
//rb - GRRRRRRRRRRRR
const unsigned int index = &mf - Map.Fields;
@ -95,28 +95,28 @@ void CMap::MarkSeenTile(CMapField &mf)
#endif
// Handle wood changes. FIXME: check if for growing wood correct?
if (seentile != this->Tileset.RemovedTree && tile == this->Tileset.RemovedTree) {
if (seentile != this->Tileset->RemovedTree && tile == this->Tileset->RemovedTree) {
FixNeighbors(MapFieldForest, 1, pos);
} else if (seentile == this->Tileset.RemovedTree && tile != this->Tileset.RemovedTree) {
} else if (seentile == this->Tileset->RemovedTree && tile != this->Tileset->RemovedTree) {
FixTile(MapFieldForest, 1, pos);
} else if (mf.ForestOnMap()) {
FixTile(MapFieldForest, 1, pos);
FixNeighbors(MapFieldForest, 1, pos);
// Handle rock changes.
} else if (seentile != this->Tileset.RemovedRock && tile == Map.Tileset.RemovedRock) {
} else if (seentile != this->Tileset->RemovedRock && tile == Map.Tileset->RemovedRock) {
FixNeighbors(MapFieldRocks, 1, pos);
} else if (seentile == this->Tileset.RemovedRock && tile != Map.Tileset.RemovedRock) {
} else if (seentile == this->Tileset->RemovedRock && tile != Map.Tileset->RemovedRock) {
FixTile(MapFieldRocks, 1, pos);
} else if (mf.RockOnMap()) {
FixTile(MapFieldRocks, 1, pos);
FixNeighbors(MapFieldRocks, 1, pos);
// Handle Walls changes.
} else if (this->Tileset.TileTypeTable[tile] == TileTypeHumanWall
|| this->Tileset.TileTypeTable[tile] == TileTypeOrcWall
|| this->Tileset.TileTypeTable[seentile] == TileTypeHumanWall
|| this->Tileset.TileTypeTable[seentile] == TileTypeOrcWall) {
} else if (this->Tileset->TileTypeTable[tile] == TileTypeHumanWall
|| this->Tileset->TileTypeTable[tile] == TileTypeOrcWall
|| this->Tileset->TileTypeTable[seentile] == TileTypeHumanWall
|| this->Tileset->TileTypeTable[seentile] == TileTypeOrcWall) {
MapFixSeenWallTile(pos);
MapFixSeenWallNeighbors(pos);
}
@ -344,7 +344,7 @@ void PreprocessMap()
}
}
// it is required for fixing the wood that all tiles are marked as seen!
if (Map.Tileset.TileTypeTable) {
if (Map.Tileset->TileTypeTable) {
Vec2i pos;
for (pos.x = 0; pos.x < Map.Info.MapWidth; ++pos.x) {
for (pos.y = 0; pos.y < Map.Info.MapHeight; ++pos.y) {
@ -368,6 +368,16 @@ void CMapInfo::Clear()
this->MapUID = 0;
}
CMap::CMap() : Fields(NULL), NoFogOfWar(false), TileGraphic(NULL)
{
Tileset = new CTileset;
}
CMap::~CMap()
{
delete Tileset;
}
/**
** Alocate and initialise map table
*/
@ -400,7 +410,7 @@ void CMap::Clean()
this->Info.Clear();
this->Fields = NULL;
this->NoFogOfWar = false;
this->Tileset.Clear();
this->Tileset->Clear();
this->TileModelsFileName.clear();
this->TileGraphic = NULL;
@ -431,7 +441,7 @@ void CMap::FixTile(unsigned short type, int seen, const Vec2i &pos)
unsigned int index = getIndex(pos);
CMapField &mf = *this->Field(index);
if (seen && !Tileset.IsSeenTile(type, mf.playerInfo.SeenTile)) {
if (seen && !Tileset->IsSeenTile(type, mf.playerInfo.SeenTile)) {
return;
} else if (!seen && !(mf.Flags & type)) {
return;
@ -443,13 +453,13 @@ void CMap::FixTile(unsigned short type, int seen, const Vec2i &pos)
int flags;
switch (type) {
case MapFieldForest:
lookuptable = this->Tileset.WoodTable;
removedtile = this->Tileset.RemovedTree;
lookuptable = this->Tileset->WoodTable;
removedtile = this->Tileset->RemovedTree;
flags = (MapFieldForest | MapFieldUnpassable);
break;
case MapFieldRocks:
lookuptable = this->Tileset.RockTable;
removedtile = this->Tileset.RemovedRock;
lookuptable = this->Tileset->RockTable;
removedtile = this->Tileset->RemovedRock;
flags = (MapFieldRocks | MapFieldUnpassable);
break;
default:
@ -471,9 +481,9 @@ void CMap::FixTile(unsigned short type, int seen, const Vec2i &pos)
} else {
CMapField &new_mf = *(&mf - this->Info.MapWidth);
if (seen) {
ttup = this->Tileset.MixedLookupTable[new_mf.playerInfo.SeenTile];
ttup = this->Tileset->MixedLookupTable[new_mf.playerInfo.SeenTile];
} else {
ttup = this->Tileset.MixedLookupTable[new_mf.Tile];
ttup = this->Tileset->MixedLookupTable[new_mf.Tile];
}
}
if (pos.x + 1 >= this->Info.MapWidth) {
@ -481,9 +491,9 @@ void CMap::FixTile(unsigned short type, int seen, const Vec2i &pos)
} else {
CMapField &new_mf = *(&mf + 1);
if (seen) {
ttright = this->Tileset.MixedLookupTable[new_mf.playerInfo.SeenTile];
ttright = this->Tileset->MixedLookupTable[new_mf.playerInfo.SeenTile];
} else {
ttright = this->Tileset.MixedLookupTable[new_mf.Tile];
ttright = this->Tileset->MixedLookupTable[new_mf.Tile];
}
}
if (pos.y + 1 >= this->Info.MapHeight) {
@ -491,9 +501,9 @@ void CMap::FixTile(unsigned short type, int seen, const Vec2i &pos)
} else {
CMapField &new_mf = *(&mf + this->Info.MapWidth);
if (seen) {
ttdown = this->Tileset.MixedLookupTable[new_mf.playerInfo.SeenTile];
ttdown = this->Tileset->MixedLookupTable[new_mf.playerInfo.SeenTile];
} else {
ttdown = this->Tileset.MixedLookupTable[new_mf.Tile];
ttdown = this->Tileset->MixedLookupTable[new_mf.Tile];
}
}
if (pos.x - 1 < 0) {
@ -501,9 +511,9 @@ void CMap::FixTile(unsigned short type, int seen, const Vec2i &pos)
} else {
CMapField &new_mf = *(&mf - 1);
if (seen) {
ttleft = this->Tileset.MixedLookupTable[new_mf.playerInfo.SeenTile];
ttleft = this->Tileset->MixedLookupTable[new_mf.playerInfo.SeenTile];
} else {
ttleft = this->Tileset.MixedLookupTable[new_mf.Tile];
ttleft = this->Tileset->MixedLookupTable[new_mf.Tile];
}
}
@ -554,8 +564,8 @@ void CMap::FixTile(unsigned short type, int seen, const Vec2i &pos)
mf.Value = 0;
UI.Minimap.UpdateXY(pos);
}
} else if (seen && this->Tileset.MixedLookupTable[mf.playerInfo.SeenTile] ==
this->Tileset.MixedLookupTable[tile]) { //Same Type
} else if (seen && this->Tileset->MixedLookupTable[mf.playerInfo.SeenTile] ==
this->Tileset->MixedLookupTable[tile]) { //Same Type
return;
} else {
if (seen) {
@ -608,11 +618,11 @@ void CMap::ClearTile(unsigned short type, const Vec2i &pos)
// Select Table to lookup
switch (type) {
case MapFieldForest:
removedtile = this->Tileset.RemovedTree;
removedtile = this->Tileset->RemovedTree;
flags = (MapFieldForest | MapFieldUnpassable);
break;
case MapFieldRocks:
removedtile = this->Tileset.RemovedRock;
removedtile = this->Tileset->RemovedRock;
flags = (MapFieldRocks | MapFieldUnpassable);
break;
default:
@ -642,7 +652,7 @@ void CMap::RegenerateForestTile(const Vec2i &pos)
Assert(Map.Info.IsPointOnMap(pos));
CMapField &mf = *this->Field(pos);
if (mf.Tile != this->Tileset.RemovedTree) {
if (mf.Tile != this->Tileset->RemovedTree) {
return;
}
@ -661,15 +671,15 @@ void CMap::RegenerateForestTile(const Vec2i &pos)
return;
}
CMapField &topMf = *(&mf - this->Info.MapWidth);
if (topMf.Tile == this->Tileset.RemovedTree
if (topMf.Tile == this->Tileset->RemovedTree
&& topMf.Value >= ForestRegeneration
&& !(topMf.Flags & occupedFlag)) {
DebugPrint("Real place wood\n");
topMf.Tile = this->Tileset.TopOneTree;
topMf.Tile = this->Tileset->TopOneTree;
topMf.Value = 0;
topMf.Flags |= MapFieldForest | MapFieldUnpassable;
mf.Tile = this->Tileset.BotOneTree;
mf.Tile = this->Tileset->BotOneTree;
mf.Value = 0;
mf.Flags |= MapFieldForest | MapFieldUnpassable;
if (mf.playerInfo.IsTeamVisible(*ThisPlayer)) {

1
src/map/map_draw.cpp
View file

@ -39,7 +39,6 @@
#include "particle.h"
#include "pathfinder.h"
#include "player.h"
#include "tileset.h"
#include "unit.h"
#include "unittype.h"
#include "ui.h"

1
src/map/map_fog.cpp
View file

@ -42,7 +42,6 @@
#include "actions.h"
#include "minimap.h"
#include "player.h"
#include "tileset.h"
#include "ui.h"
#include "unit.h"
#include "unit_manager.h"

44
src/map/map_wall.cpp
View file

@ -77,7 +77,7 @@
*/
static int MapIsSeenTileWall(int x, int y, int walltype)
{
int t = Map.Tileset.TileTypeTable[Map.Field(x, y)->playerInfo.SeenTile];
int t = Map.Tileset->TileTypeTable[Map.Field(x, y)->playerInfo.SeenTile];
if (walltype == -1) {
return t == TileTypeHumanWall || t == TileTypeOrcWall;
@ -97,7 +97,7 @@ void MapFixSeenWallTile(const Vec2i &pos)
return;
}
CMapField &mf = *Map.Field(pos);
int t = Map.Tileset.TileTypeTable[mf.playerInfo.SeenTile];
int t = Map.Tileset->TileTypeTable[mf.playerInfo.SeenTile];
if (t != TileTypeHumanWall && t != TileTypeOrcWall) {
return;
}
@ -120,35 +120,35 @@ void MapFixSeenWallTile(const Vec2i &pos)
}
if (t == TileTypeHumanWall) {
tile = Map.Tileset.HumanWallTable[tile];
tile = Map.Tileset->HumanWallTable[tile];
if (UnitTypeHumanWall && mf.Value <= UnitTypeHumanWall->DefaultStat.Variables[HP_INDEX].Max / 2) {
while (Map.Tileset.Table[tile]) { // Skip good tiles
while (Map.Tileset->Table[tile]) { // Skip good tiles
++tile;
}
while (!Map.Tileset.Table[tile]) { // Skip separator
while (!Map.Tileset->Table[tile]) { // Skip separator
++tile;
}
}
} else {
tile = Map.Tileset.OrcWallTable[tile];
tile = Map.Tileset->OrcWallTable[tile];
if (UnitTypeOrcWall && mf.Value <= UnitTypeOrcWall->DefaultStat.Variables[HP_INDEX].Max / 2) {
while (Map.Tileset.Table[tile]) { // Skip good tiles
while (Map.Tileset->Table[tile]) { // Skip good tiles
++tile;
}
while (!Map.Tileset.Table[tile]) { // Skip separator
while (!Map.Tileset->Table[tile]) { // Skip separator
++tile;
}
}
}
if (mf.Value == 0) {
while (Map.Tileset.Table[tile]) { // Skip good tiles
while (Map.Tileset->Table[tile]) { // Skip good tiles
++tile;
}
while (!Map.Tileset.Table[tile]) { // Skip separator
while (!Map.Tileset->Table[tile]) { // Skip separator
++tile;
}
}
tile = Map.Tileset.Table[tile];
tile = Map.Tileset->Table[tile];
if (mf.playerInfo.SeenTile != tile) { // Already there!
mf.playerInfo.SeenTile = tile;
@ -213,35 +213,35 @@ void MapFixWallTile(const Vec2i &pos)
}
if (t & MapFieldHuman) {
tile = Map.Tileset.HumanWallTable[tile];
tile = Map.Tileset->HumanWallTable[tile];
if (UnitTypeHumanWall && mf.Value <= UnitTypeHumanWall->DefaultStat.Variables[HP_INDEX].Max / 2) {
while (Map.Tileset.Table[tile]) { // Skip good tiles
while (Map.Tileset->Table[tile]) { // Skip good tiles
++tile;
}
while (!Map.Tileset.Table[tile]) { // Skip separator
while (!Map.Tileset->Table[tile]) { // Skip separator
++tile;
}
}
} else {
tile = Map.Tileset.OrcWallTable[tile];
tile = Map.Tileset->OrcWallTable[tile];
if (UnitTypeOrcWall && mf.Value <= UnitTypeOrcWall->DefaultStat.Variables[HP_INDEX].Max / 2) {
while (Map.Tileset.Table[tile]) { // Skip good tiles
while (Map.Tileset->Table[tile]) { // Skip good tiles
++tile;
}
while (!Map.Tileset.Table[tile]) { // Skip separator
while (!Map.Tileset->Table[tile]) { // Skip separator
++tile;
}
}
}
if (mf.Value == 0) {
while (Map.Tileset.Table[tile]) { // Skip good tiles
while (Map.Tileset->Table[tile]) { // Skip good tiles
++tile;
}
while (!Map.Tileset.Table[tile]) { // Skip separator
while (!Map.Tileset->Table[tile]) { // Skip separator
++tile;
}
}
tile = Map.Tileset.Table[tile];
tile = Map.Tileset->Table[tile];
if (mf.Tile != tile) {
mf.Tile = tile;
@ -306,12 +306,12 @@ void CMap::SetWall(const Vec2i &pos, int humanwall)
// FIXME: support more walls of different races.
if (humanwall) {
// FIXME: Set random walls
mf.Tile = this->Tileset.Table[this->Tileset.HumanWallTable[0]];
mf.Tile = this->Tileset->Table[this->Tileset->HumanWallTable[0]];
mf.Flags |= MapFieldWall | MapFieldUnpassable | MapFieldHuman;
mf.Value = UnitTypeHumanWall->DefaultStat.Variables[HP_INDEX].Max;
} else {
// FIXME: Set random walls
mf.Tile = this->Tileset.Table[this->Tileset.OrcWallTable[0]];
mf.Tile = this->Tileset->Table[this->Tileset->OrcWallTable[0]];
mf.Flags |= MapFieldWall | MapFieldUnpassable;
mf.Value = UnitTypeOrcWall->DefaultStat.Variables[HP_INDEX].Max;
}

9
src/map/script_map.cpp
View file

@ -39,6 +39,7 @@
#include "iolib.h"
#include "script.h"
#include "tileset.h"
#include "ui.h"
#include "unit.h"
#include "version.h"
@ -409,7 +410,7 @@ void SetTile(int tile, const Vec2i &pos, int value)
fprintf(stderr, "Invalid map coordonate : (%d, %d)\n", pos.x, pos.y);
return;
}
if (tile < 0 || tile >= Map.Tileset.NumTiles) {
if (tile < 0 || tile >= Map.Tileset->NumTiles) {
fprintf(stderr, "Invalid tile number: %d\n", tile);
return;
}
@ -421,10 +422,10 @@ void SetTile(int tile, const Vec2i &pos, int value)
if (Map.Fields) {
CMapField &mf = *Map.Field(pos);
mf.Tile = Map.Tileset.Table[tile];
mf.Tile = Map.Tileset->Table[tile];
mf.Value = value;
mf.Flags = Map.Tileset.FlagsTable[tile];
mf.Cost = 1 << (Map.Tileset.FlagsTable[tile] & MapFieldSpeedMask);
mf.Flags = Map.Tileset->FlagsTable[tile];
mf.Cost = 1 << (Map.Tileset->FlagsTable[tile] & MapFieldSpeedMask);
#ifdef DEBUG
mf.TilesetTile = tile;
#endif

392
src/map/script_tileset.cpp
View file

@ -89,25 +89,17 @@ static void ExtendTilesetTables(CTileset *tileset, unsigned int oldtiles, unsign
*/
static int TilesetParseName(lua_State *l, CTileset *tileset)
{
unsigned int i;
const char *ident = LuaToString(l, -1);
for (i = 0; i < tileset->NumTerrainTypes; ++i) {
if (!strcmp(ident, tileset->SolidTerrainTypes[i].TerrainName.c_str())) {
for (size_t i = 0; i != tileset->SolidTerrainTypes.size(); ++i) {
if (tileset->SolidTerrainTypes[i].TerrainName == ident) {
return i;
}
}
// Can't find it, then we add another solid terrain type.
SolidTerrainInfo *s = new SolidTerrainInfo[tileset->NumTerrainTypes + 1];
for (unsigned int j = 0; j < tileset->NumTerrainTypes; ++j) {
s[j] = tileset->SolidTerrainTypes[j];
}
delete[] tileset->SolidTerrainTypes;
tileset->SolidTerrainTypes = s;
tileset->SolidTerrainTypes[tileset->NumTerrainTypes].TerrainName = ident;
++tileset->NumTerrainTypes;
return i;
SolidTerrainInfo s;
s.TerrainName = ident;
tileset->SolidTerrainTypes.push_back(s);
return tileset->SolidTerrainTypes.size() - 1;
}
/**
@ -435,9 +427,9 @@ static void DefineTilesetParseSlot(lua_State *l, CTileset *tileset, int t)
tileset->Table = new unsigned short[16];
tileset->FlagsTable = new unsigned short[16];
tileset->Tiles = new TileInfo[16];
tileset->SolidTerrainTypes = new SolidTerrainInfo[1];
tileset->SolidTerrainTypes[0].TerrainName = "unused";
tileset->NumTerrainTypes = 1;
SolidTerrainInfo solidTerrainInfo;
solidTerrainInfo.TerrainName = "unused";
tileset->SolidTerrainTypes.push_back(solidTerrainInfo);
// Parse the list: (still everything could be changed!)
const int args = lua_rawlen(l, t);
@ -482,10 +474,10 @@ static void DefineTilesetParseSlot(lua_State *l, CTileset *tileset, int t)
*/
static int CclDefineTileset(lua_State *l)
{
Map.Tileset.Clear();
Map.Tileset->Clear();
Map.Tileset.PixelTileSize.x = 32;
Map.Tileset.PixelTileSize.y = 32;
Map.Tileset->PixelTileSize.x = 32;
Map.Tileset->PixelTileSize.y = 32;
//
// Parse the list: (still everything could be changed!)
@ -496,24 +488,24 @@ static int CclDefineTileset(lua_State *l)
++j;
if (!strcmp(value, "name")) {
Map.Tileset.Name = LuaToString(l, j);
Map.Tileset->Name = LuaToString(l, j);
} else if (!strcmp(value, "image")) {
Map.Tileset.ImageFile = LuaToString(l, j);
Map.Tileset->ImageFile = LuaToString(l, j);
} else if (!strcmp(value, "size")) {
if (!lua_istable(l, j)) {
LuaError(l, "incorrect argument");
}
lua_rawgeti(l, j, 1);
Map.Tileset.PixelTileSize.x = LuaToNumber(l, -1);
Map.Tileset->PixelTileSize.x = LuaToNumber(l, -1);
lua_pop(l, 1);
lua_rawgeti(l, j, 2);
Map.Tileset.PixelTileSize.y = LuaToNumber(l, -1);
Map.Tileset->PixelTileSize.y = LuaToNumber(l, -1);
lua_pop(l, 1);
} else if (!strcmp(value, "slots")) {
if (!lua_istable(l, j)) {
LuaError(l, "incorrect argument");
}
DefineTilesetParseSlot(l, &Map.Tileset, j);
DefineTilesetParseSlot(l, Map.Tileset, j);
} else {
LuaError(l, "Unsupported tag: %s" _C_ value);
}
@ -531,111 +523,107 @@ static int CclDefineTileset(lua_State *l)
*/
static int CclBuildTilesetTables(lua_State *l)
{
int n;
int tile;
int solid;
int mixed;
const unsigned short *table;
int i;
LuaCheckArgs(l, 0);
// Calculate number of tiles in graphic tile
n = Map.Tileset.NumTiles;
int n = Map.Tileset->NumTiles;
Map.Tileset.MixedLookupTable = new int[n];
memset(Map.Tileset.MixedLookupTable, 0, n * sizeof(int));
Map.Tileset->MixedLookupTable = new int[n];
memset(Map.Tileset->MixedLookupTable, 0, n * sizeof(int));
// Build the TileTypeTable
Map.Tileset.TileTypeTable = new unsigned char[n];
memset(Map.Tileset.TileTypeTable, 0, n * sizeof(unsigned char));
Map.Tileset->TileTypeTable = new unsigned char[n];
memset(Map.Tileset->TileTypeTable, 0, n * sizeof(unsigned char));
table = Map.Tileset.Table;
for (i = 0; i < n; ++i) {
const unsigned short *table = Map.Tileset->Table;
int tile;
for (int i = 0; i < n; ++i) {
if ((tile = table[i])) {
unsigned flags;
//Initialize all Lookup Items to zero
Map.Tileset.MixedLookupTable[table[i]] = 0;
Map.Tileset->MixedLookupTable[table[i]] = 0;
flags = Map.Tileset.FlagsTable[i];
flags = Map.Tileset->FlagsTable[i];
if (flags & MapFieldWaterAllowed) {
Map.Tileset.TileTypeTable[tile] = TileTypeWater;
Map.Tileset->TileTypeTable[tile] = TileTypeWater;
} else if (flags & MapFieldCoastAllowed) {
Map.Tileset.TileTypeTable[tile] = TileTypeCoast;
Map.Tileset->TileTypeTable[tile] = TileTypeCoast;
} else if (flags & MapFieldWall) {
if (flags & MapFieldHuman) {
Map.Tileset.TileTypeTable[tile] = TileTypeHumanWall;
Map.Tileset->TileTypeTable[tile] = TileTypeHumanWall;
} else {
Map.Tileset.TileTypeTable[tile] = TileTypeOrcWall;
Map.Tileset->TileTypeTable[tile] = TileTypeOrcWall;
}
} else if (flags & MapFieldRocks) {
Map.Tileset.TileTypeTable[tile] = TileTypeRock;
Map.Tileset->TileTypeTable[tile] = TileTypeRock;
} else if (flags & MapFieldForest) {
Map.Tileset.TileTypeTable[tile] = TileTypeWood;
Map.Tileset->TileTypeTable[tile] = TileTypeWood;
}
}
}
// mark the special tiles
if ((tile = Map.Tileset.TopOneTree)) {
Map.Tileset.TileTypeTable[tile] = TileTypeWood;
if ((tile = Map.Tileset->TopOneTree)) {
Map.Tileset->TileTypeTable[tile] = TileTypeWood;
}
if ((tile = Map.Tileset.MidOneTree)) {
Map.Tileset.TileTypeTable[tile] = TileTypeWood;
if ((tile = Map.Tileset->MidOneTree)) {
Map.Tileset->TileTypeTable[tile] = TileTypeWood;
}
if ((tile = Map.Tileset.BotOneTree)) {
Map.Tileset.TileTypeTable[tile] = TileTypeWood;
if ((tile = Map.Tileset->BotOneTree)) {
Map.Tileset->TileTypeTable[tile] = TileTypeWood;
}
if ((tile = Map.Tileset.TopOneRock)) {
Map.Tileset.TileTypeTable[tile] = TileTypeRock;
if ((tile = Map.Tileset->TopOneRock)) {
Map.Tileset->TileTypeTable[tile] = TileTypeRock;
}
if ((tile = Map.Tileset.MidOneRock)) {
Map.Tileset.TileTypeTable[tile] = TileTypeRock;
if ((tile = Map.Tileset->MidOneRock)) {
Map.Tileset->TileTypeTable[tile] = TileTypeRock;
}
if ((tile = Map.Tileset.BotOneRock)) {
Map.Tileset.TileTypeTable[tile] = TileTypeRock;
if ((tile = Map.Tileset->BotOneRock)) {
Map.Tileset->TileTypeTable[tile] = TileTypeRock;
}
// Build wood removement table.
n = Map.Tileset.NumTiles;
for (mixed = solid = i = 0; i < n;) {
if (Map.Tileset.Tiles[i].BaseTerrain
&& Map.Tileset.Tiles[i].MixTerrain) {
if (Map.Tileset.FlagsTable[i] & MapFieldForest) {
int solid = 0;
int mixed = 0;
n = Map.Tileset->NumTiles;
for (int i = 0; i < n;) {
if (Map.Tileset->Tiles[i].BaseTerrain
&& Map.Tileset->Tiles[i].MixTerrain) {
if (Map.Tileset->FlagsTable[i] & MapFieldForest) {
mixed = i;
}
i += 256;
} else {
if (Map.Tileset.Tiles[i].BaseTerrain != 0 &&
Map.Tileset.Tiles[i].MixTerrain == 0) {
if (Map.Tileset.FlagsTable[i] & MapFieldForest) {
if (Map.Tileset->Tiles[i].BaseTerrain != 0 &&
Map.Tileset->Tiles[i].MixTerrain == 0) {
if (Map.Tileset->FlagsTable[i] & MapFieldForest) {
solid = i;
}
}
i += 16;
}
}
Map.Tileset.WoodTable[ 0] = -1;
Map.Tileset.WoodTable[ 1] = table[mixed + 0x30];
Map.Tileset.WoodTable[ 2] = table[mixed + 0x70];
Map.Tileset.WoodTable[ 3] = table[mixed + 0xB0];
Map.Tileset.WoodTable[ 4] = table[mixed + 0x10];
Map.Tileset.WoodTable[ 5] = table[mixed + 0x50];
Map.Tileset.WoodTable[ 6] = table[mixed + 0x90];
Map.Tileset.WoodTable[ 7] = table[mixed + 0xD0];
Map.Tileset.WoodTable[ 8] = table[mixed + 0x00];
Map.Tileset.WoodTable[ 9] = table[mixed + 0x40];
Map.Tileset.WoodTable[10] = table[mixed + 0x80];
Map.Tileset.WoodTable[11] = table[mixed + 0xC0];
Map.Tileset.WoodTable[12] = table[mixed + 0x20];
Map.Tileset.WoodTable[13] = table[mixed + 0x60];
Map.Tileset.WoodTable[14] = table[mixed + 0xA0];
Map.Tileset.WoodTable[15] = table[solid];
Map.Tileset.WoodTable[16] = -1;
Map.Tileset.WoodTable[17] = Map.Tileset.BotOneTree;
Map.Tileset.WoodTable[18] = Map.Tileset.TopOneTree;
Map.Tileset.WoodTable[19] = Map.Tileset.MidOneTree;
Map.Tileset->WoodTable[ 0] = -1;
Map.Tileset->WoodTable[ 1] = table[mixed + 0x30];
Map.Tileset->WoodTable[ 2] = table[mixed + 0x70];
Map.Tileset->WoodTable[ 3] = table[mixed + 0xB0];
Map.Tileset->WoodTable[ 4] = table[mixed + 0x10];
Map.Tileset->WoodTable[ 5] = table[mixed + 0x50];
Map.Tileset->WoodTable[ 6] = table[mixed + 0x90];
Map.Tileset->WoodTable[ 7] = table[mixed + 0xD0];
Map.Tileset->WoodTable[ 8] = table[mixed + 0x00];
Map.Tileset->WoodTable[ 9] = table[mixed + 0x40];
Map.Tileset->WoodTable[10] = table[mixed + 0x80];
Map.Tileset->WoodTable[11] = table[mixed + 0xC0];
Map.Tileset->WoodTable[12] = table[mixed + 0x20];
Map.Tileset->WoodTable[13] = table[mixed + 0x60];
Map.Tileset->WoodTable[14] = table[mixed + 0xA0];
Map.Tileset->WoodTable[15] = table[solid];
Map.Tileset->WoodTable[16] = -1;
Map.Tileset->WoodTable[17] = Map.Tileset->BotOneTree;
Map.Tileset->WoodTable[18] = Map.Tileset->TopOneTree;
Map.Tileset->WoodTable[19] = Map.Tileset->MidOneTree;
//Mark which corners of each tile has tree in it.
//All corners for solid tiles. (Same for rocks)
@ -645,80 +633,82 @@ static int CclBuildTilesetTables(lua_State *l)
//8 Top Left
//16 Bottom Tree Tile
//32 Top Tree Tile
for (i = solid; i < solid + 16; ++i) {
Map.Tileset.MixedLookupTable[table[i]] = 15;
for (int i = solid; i < solid + 16; ++i) {
Map.Tileset->MixedLookupTable[table[i]] = 15;
}
for (i = mixed; i < mixed + 256; ++i) {
for (int i = mixed; i < mixed + 256; ++i) {
int check;
check = (int)((i - mixed) / 16);
switch (check) {
case 0:
Map.Tileset.MixedLookupTable[table[i]] = 8;
Map.Tileset->MixedLookupTable[table[i]] = 8;
break;
case 1:
Map.Tileset.MixedLookupTable[table[i]] = 4;
Map.Tileset->MixedLookupTable[table[i]] = 4;
break;
case 2:
Map.Tileset.MixedLookupTable[table[i]] = 8 + 4;
Map.Tileset->MixedLookupTable[table[i]] = 8 + 4;
break;
case 3:
Map.Tileset.MixedLookupTable[table[i]] = 1;
Map.Tileset->MixedLookupTable[table[i]] = 1;
break;
case 4:
Map.Tileset.MixedLookupTable[table[i]] = 8 + 1;
Map.Tileset->MixedLookupTable[table[i]] = 8 + 1;
break;
case 5:
Map.Tileset.MixedLookupTable[table[i]] = 4 + 1;
Map.Tileset->MixedLookupTable[table[i]] = 4 + 1;
break;
case 6:
Map.Tileset.MixedLookupTable[table[i]] = 8 + 4 + 1;
Map.Tileset->MixedLookupTable[table[i]] = 8 + 4 + 1;
break;
case 7:
Map.Tileset.MixedLookupTable[table[i]] = 2;
Map.Tileset->MixedLookupTable[table[i]] = 2;
break;
case 8:
Map.Tileset.MixedLookupTable[table[i]] = 8 + 2;
Map.Tileset->MixedLookupTable[table[i]] = 8 + 2;
break;
case 9:
Map.Tileset.MixedLookupTable[table[i]] = 4 + 2;
Map.Tileset->MixedLookupTable[table[i]] = 4 + 2;
break;
case 10:
Map.Tileset.MixedLookupTable[table[i]] = 8 + 4 + 2;
Map.Tileset->MixedLookupTable[table[i]] = 8 + 4 + 2;
break;
case 11:
Map.Tileset.MixedLookupTable[table[i]] = 2 + 1;
Map.Tileset->MixedLookupTable[table[i]] = 2 + 1;
break;
case 12:
Map.Tileset.MixedLookupTable[table[i]] = 8 + 2 + 1;
Map.Tileset->MixedLookupTable[table[i]] = 8 + 2 + 1;
break;
case 13:
Map.Tileset.MixedLookupTable[table[i]] = 4 + 2 + 1;
Map.Tileset->MixedLookupTable[table[i]] = 4 + 2 + 1;
break;
default:
Map.Tileset.MixedLookupTable[table[i]] = 0;
Map.Tileset->MixedLookupTable[table[i]] = 0;
break;
}
}
//16 Bottom Tree Special
//32 Top Tree Special
//64 Mid tree special - differentiate with mixed tiles.
Map.Tileset.MixedLookupTable[Map.Tileset.BotOneTree] = 12 + 16;
Map.Tileset.MixedLookupTable[Map.Tileset.TopOneTree] = 3 + 32;
Map.Tileset.MixedLookupTable[Map.Tileset.MidOneTree] = 15 + 48;
Map.Tileset->MixedLookupTable[Map.Tileset->BotOneTree] = 12 + 16;
Map.Tileset->MixedLookupTable[Map.Tileset->TopOneTree] = 3 + 32;
Map.Tileset->MixedLookupTable[Map.Tileset->MidOneTree] = 15 + 48;
// Build rock removement table.
for (mixed = solid = i = 0; i < n;) {
if (Map.Tileset.Tiles[i].BaseTerrain
&& Map.Tileset.Tiles[i].MixTerrain) {
if (Map.Tileset.FlagsTable[i] & MapFieldRocks) {
mixed = 0;
solid = 0;
for (int i = 0; i < n;) {
if (Map.Tileset->Tiles[i].BaseTerrain
&& Map.Tileset->Tiles[i].MixTerrain) {
if (Map.Tileset->FlagsTable[i] & MapFieldRocks) {
mixed = i;
}
i += 256;
} else {
if (Map.Tileset.Tiles[i].BaseTerrain != 0 &&
Map.Tileset.Tiles[i].MixTerrain == 0) {
if (Map.Tileset.FlagsTable[i] & MapFieldRocks) {
if (Map.Tileset->Tiles[i].BaseTerrain != 0 &&
Map.Tileset->Tiles[i].MixTerrain == 0) {
if (Map.Tileset->FlagsTable[i] & MapFieldRocks) {
solid = i;
}
}
@ -732,145 +722,143 @@ static int CclBuildTilesetTables(lua_State *l)
//2 Bottom Right
//4 Top Right
//8 Top Left
for (i = solid; i < solid + 16; ++i) {
Map.Tileset.MixedLookupTable[table[i]] = 15;
for (int i = solid; i < solid + 16; ++i) {
Map.Tileset->MixedLookupTable[table[i]] = 15;
}
for (i = mixed; i < mixed + 256; ++i) {
int check;
check = (int)((i - mixed) / 16);
for (int i = mixed; i < mixed + 256; ++i) {
int check = (int)((i - mixed) / 16);
switch (check) {
case 0:
Map.Tileset.MixedLookupTable[table[i]] = 8;
Map.Tileset->MixedLookupTable[table[i]] = 8;
break;
case 1:
Map.Tileset.MixedLookupTable[table[i]] = 4;
Map.Tileset->MixedLookupTable[table[i]] = 4;
break;
case 2:
Map.Tileset.MixedLookupTable[table[i]] = 8 + 4;
Map.Tileset->MixedLookupTable[table[i]] = 8 + 4;
break;
case 3:
Map.Tileset.MixedLookupTable[table[i]] = 1;
Map.Tileset->MixedLookupTable[table[i]] = 1;
break;
case 4:
Map.Tileset.MixedLookupTable[table[i]] = 8 + 1;
Map.Tileset->MixedLookupTable[table[i]] = 8 + 1;
break;
case 5:
Map.Tileset.MixedLookupTable[table[i]] = 4 + 1;
Map.Tileset->MixedLookupTable[table[i]] = 4 + 1;
break;
case 6:
Map.Tileset.MixedLookupTable[table[i]] = 8 + 4 + 1;
Map.Tileset->MixedLookupTable[table[i]] = 8 + 4 + 1;
break;
case 7:
Map.Tileset.MixedLookupTable[table[i]] = 2;
Map.Tileset->MixedLookupTable[table[i]] = 2;
break;
case 8:
Map.Tileset.MixedLookupTable[table[i]] = 8 + 2;
Map.Tileset->MixedLookupTable[table[i]] = 8 + 2;
break;
case 9:
Map.Tileset.MixedLookupTable[table[i]] = 4 + 2;
Map.Tileset->MixedLookupTable[table[i]] = 4 + 2;
break;
case 10:
Map.Tileset.MixedLookupTable[table[i]] = 8 + 4 + 2;
Map.Tileset->MixedLookupTable[table[i]] = 8 + 4 + 2;
break;
case 11:
Map.Tileset.MixedLookupTable[table[i]] = 2 + 1;
Map.Tileset->MixedLookupTable[table[i]] = 2 + 1;
break;
case 12:
Map.Tileset.MixedLookupTable[table[i]] = 8 + 2 + 1;
Map.Tileset->MixedLookupTable[table[i]] = 8 + 2 + 1;
break;
case 13:
Map.Tileset.MixedLookupTable[table[i]] = 4 + 2 + 1;
Map.Tileset->MixedLookupTable[table[i]] = 4 + 2 + 1;
break;
default:
Map.Tileset.MixedLookupTable[table[i]] = 0;
Map.Tileset->MixedLookupTable[table[i]] = 0;
break;
}
}
Map.Tileset.MixedLookupTable[Map.Tileset.BotOneRock] = 12 + 16;
Map.Tileset.MixedLookupTable[Map.Tileset.TopOneRock] = 3 + 32;
Map.Tileset.MixedLookupTable[Map.Tileset.MidOneRock] = 15 + 48;
Map.Tileset->MixedLookupTable[Map.Tileset->BotOneRock] = 12 + 16;
Map.Tileset->MixedLookupTable[Map.Tileset->TopOneRock] = 3 + 32;
Map.Tileset->MixedLookupTable[Map.Tileset->MidOneRock] = 15 + 48;
Map.Tileset.RockTable[ 0] = -1;
Map.Tileset.RockTable[ 1] = table[mixed + 0x30];
Map.Tileset.RockTable[ 2] = table[mixed + 0x70];
Map.Tileset.RockTable[ 3] = table[mixed + 0xB0];
Map.Tileset.RockTable[ 4] = table[mixed + 0x10];
Map.Tileset.RockTable[ 5] = table[mixed + 0x50];
Map.Tileset.RockTable[ 6] = table[mixed + 0x90];
Map.Tileset.RockTable[ 7] = table[mixed + 0xD0];
Map.Tileset.RockTable[ 8] = table[mixed + 0x00];
Map.Tileset.RockTable[ 9] = table[mixed + 0x40];
Map.Tileset.RockTable[10] = table[mixed + 0x80];
Map.Tileset.RockTable[11] = table[mixed + 0xC0];
Map.Tileset.RockTable[12] = table[mixed + 0x20];
Map.Tileset.RockTable[13] = table[mixed + 0x60];
Map.Tileset.RockTable[14] = table[mixed + 0xA0];
Map.Tileset.RockTable[15] = table[solid];
Map.Tileset.RockTable[16] = -1;
Map.Tileset.RockTable[17] = Map.Tileset.BotOneRock;
Map.Tileset.RockTable[18] = Map.Tileset.TopOneRock;
Map.Tileset.RockTable[19] = Map.Tileset.MidOneRock;
Map.Tileset->RockTable[ 0] = -1;
Map.Tileset->RockTable[ 1] = table[mixed + 0x30];
Map.Tileset->RockTable[ 2] = table[mixed + 0x70];
Map.Tileset->RockTable[ 3] = table[mixed + 0xB0];
Map.Tileset->RockTable[ 4] = table[mixed + 0x10];
Map.Tileset->RockTable[ 5] = table[mixed + 0x50];
Map.Tileset->RockTable[ 6] = table[mixed + 0x90];
Map.Tileset->RockTable[ 7] = table[mixed + 0xD0];
Map.Tileset->RockTable[ 8] = table[mixed + 0x00];
Map.Tileset->RockTable[ 9] = table[mixed + 0x40];
Map.Tileset->RockTable[10] = table[mixed + 0x80];
Map.Tileset->RockTable[11] = table[mixed + 0xC0];
Map.Tileset->RockTable[12] = table[mixed + 0x20];
Map.Tileset->RockTable[13] = table[mixed + 0x60];
Map.Tileset->RockTable[14] = table[mixed + 0xA0];
Map.Tileset->RockTable[15] = table[solid];
Map.Tileset->RockTable[16] = -1;
Map.Tileset->RockTable[17] = Map.Tileset->BotOneRock;
Map.Tileset->RockTable[18] = Map.Tileset->TopOneRock;
Map.Tileset->RockTable[19] = Map.Tileset->MidOneRock;
// FIXME: Build wall replacement tables
Map.Tileset.HumanWallTable[ 0] = 0x090;
Map.Tileset.HumanWallTable[ 1] = 0x830;
Map.Tileset.HumanWallTable[ 2] = 0x810;
Map.Tileset.HumanWallTable[ 3] = 0x850;
Map.Tileset.HumanWallTable[ 4] = 0x800;
Map.Tileset.HumanWallTable[ 5] = 0x840;
Map.Tileset.HumanWallTable[ 6] = 0x820;
Map.Tileset.HumanWallTable[ 7] = 0x860;
Map.Tileset.HumanWallTable[ 8] = 0x870;
Map.Tileset.HumanWallTable[ 9] = 0x8B0;
Map.Tileset.HumanWallTable[10] = 0x890;
Map.Tileset.HumanWallTable[11] = 0x8D0;
Map.Tileset.HumanWallTable[12] = 0x880;
Map.Tileset.HumanWallTable[13] = 0x8C0;
Map.Tileset.HumanWallTable[14] = 0x8A0;
Map.Tileset.HumanWallTable[15] = 0x0B0;
Map.Tileset->HumanWallTable[ 0] = 0x090;
Map.Tileset->HumanWallTable[ 1] = 0x830;
Map.Tileset->HumanWallTable[ 2] = 0x810;
Map.Tileset->HumanWallTable[ 3] = 0x850;
Map.Tileset->HumanWallTable[ 4] = 0x800;
Map.Tileset->HumanWallTable[ 5] = 0x840;
Map.Tileset->HumanWallTable[ 6] = 0x820;
Map.Tileset->HumanWallTable[ 7] = 0x860;
Map.Tileset->HumanWallTable[ 8] = 0x870;
Map.Tileset->HumanWallTable[ 9] = 0x8B0;
Map.Tileset->HumanWallTable[10] = 0x890;
Map.Tileset->HumanWallTable[11] = 0x8D0;
Map.Tileset->HumanWallTable[12] = 0x880;
Map.Tileset->HumanWallTable[13] = 0x8C0;
Map.Tileset->HumanWallTable[14] = 0x8A0;
Map.Tileset->HumanWallTable[15] = 0x0B0;
Map.Tileset.OrcWallTable[ 0] = 0x0A0;
Map.Tileset.OrcWallTable[ 1] = 0x930;
Map.Tileset.OrcWallTable[ 2] = 0x910;
Map.Tileset.OrcWallTable[ 3] = 0x950;
Map.Tileset.OrcWallTable[ 4] = 0x900;
Map.Tileset.OrcWallTable[ 5] = 0x940;
Map.Tileset.OrcWallTable[ 6] = 0x920;
Map.Tileset.OrcWallTable[ 7] = 0x960;
Map.Tileset.OrcWallTable[ 8] = 0x970;
Map.Tileset.OrcWallTable[ 9] = 0x9B0;
Map.Tileset.OrcWallTable[10] = 0x990;
Map.Tileset.OrcWallTable[11] = 0x9D0;
Map.Tileset.OrcWallTable[12] = 0x980;
Map.Tileset.OrcWallTable[13] = 0x9C0;
Map.Tileset.OrcWallTable[14] = 0x9A0;
Map.Tileset.OrcWallTable[15] = 0x0C0;
Map.Tileset->OrcWallTable[ 0] = 0x0A0;
Map.Tileset->OrcWallTable[ 1] = 0x930;
Map.Tileset->OrcWallTable[ 2] = 0x910;
Map.Tileset->OrcWallTable[ 3] = 0x950;
Map.Tileset->OrcWallTable[ 4] = 0x900;
Map.Tileset->OrcWallTable[ 5] = 0x940;
Map.Tileset->OrcWallTable[ 6] = 0x920;
Map.Tileset->OrcWallTable[ 7] = 0x960;
Map.Tileset->OrcWallTable[ 8] = 0x970;
Map.Tileset->OrcWallTable[ 9] = 0x9B0;
Map.Tileset->OrcWallTable[10] = 0x990;
Map.Tileset->OrcWallTable[11] = 0x9D0;
Map.Tileset->OrcWallTable[12] = 0x980;
Map.Tileset->OrcWallTable[13] = 0x9C0;
Map.Tileset->OrcWallTable[14] = 0x9A0;
Map.Tileset->OrcWallTable[15] = 0x0C0;
// Set destroyed walls to TileTypeUnknown
for (i = 0; i < 16; ++i) {
for (int i = 0; i < 16; ++i) {
n = 0;
tile = Map.Tileset.HumanWallTable[i];
while (Map.Tileset.Table[tile]) { // Skip good tiles
tile = Map.Tileset->HumanWallTable[i];
while (Map.Tileset->Table[tile]) { // Skip good tiles
++tile;
++n;
}
while (!Map.Tileset.Table[tile]) { // Skip separator
while (!Map.Tileset->Table[tile]) { // Skip separator
++tile;
++n;
}
while (Map.Tileset.Table[tile]) { // Skip good tiles
while (Map.Tileset->Table[tile]) { // Skip good tiles
++tile;
++n;
}
while (!Map.Tileset.Table[tile]) { // Skip separator
while (!Map.Tileset->Table[tile]) { // Skip separator
++tile;
++n;
}
while (n < 16 && Map.Tileset.Table[tile]) {
Map.Tileset.TileTypeTable[
Map.Tileset.Table[tile]] = TileTypeUnknown;
while (n < 16 && Map.Tileset->Table[tile]) {
Map.Tileset->TileTypeTable[
Map.Tileset->Table[tile]] = TileTypeUnknown;
++tile;
++n;
}
@ -896,12 +884,12 @@ static int CclSetTileFlags(lua_State *l)
tilenumber = LuaToNumber(l, 1);
if (tilenumber >= Map.Tileset.NumTiles) {
if (tilenumber >= Map.Tileset->NumTiles) {
LuaError(l, "Accessed a tile that's not defined");
}
ParseTilesetTileFlags(l, &flags, &j);
Map.Tileset.FlagsTable[tilenumber] = flags;
Map.Tileset->FlagsTable[tilenumber] = flags;
return 0;
}

222
src/map/tileset.cpp
View file

@ -29,6 +29,171 @@
//@{
/*----------------------------------------------------------------------------
-- Documentation
----------------------------------------------------------------------------*/
/**
** @class CTileset tileset.h
**
** \#include "tileset.h"
**
** This structure contains information about the tileset of the map.
** It defines the look and properties of the tiles. Currently only one
** tileset per map is supported. In the future it is planned to support
** multiple tilesets on the same map. Also it is planned to support animated
** tiles.
**
** The tileset structure members:
**
** CTileset::Name
**
** Long name of the tileset. Can be used by the level editor.
**
** CTileset::ImageFile
**
** Name of the graphic file, containing all tiles.
**
** CTileset::NumTiles
**
** The number of different tiles in the tables.
**
** CTileset::Table
**
** Table to map the abstract level (PUD) tile numbers, to tile
** numbers in the graphic file (CTileset::File).
** FE. 16 (solid light water) in pud to 328 in png.
**
** CTileset::FlagsTable
**
** Table of the tile flags used by the editor.
** @see CMapField::Flags
**
** CTileset::BasicNameTable
**
** Index to name of the basic tile type. FE. "light-water".
** If the index is 0, the tile is not used.
** @see CTileset::TileNames
**
** CTileset::MixedNameTable
**
** Index to name of the mixed tile type. FE. "light-water".
** If this index is 0, the tile is a solid tile.
** @see CTileset::TileNames
**
** CTileset::TileTypeTable
**
** Lookup table of the tile type. Maps the graphic file tile
** number back to a tile type (::TileTypeWood, ::TileTypeWater,
** ...)
**
** @note The creation of this table is currently hardcoded in
** the engine. It should be calculated from the flags in the
** tileset configuration (CCL). And it is created for the map
** and not for the tileset.
**
** @note I'm not sure if this table is needed in the future.
**
** @see TileType.
**
** CTileset::NumNames
**
** Number of different tile names.
**
** CTileset::TileNames
**
** The different tile names. FE "light-grass", "dark-water".
**
** CTileset::TopOneTree
**
** The tile number of tile only containing the top part of a tree.
** Is created on the map by lumber chopping.
**
** CTileset::MidOneTree
**
** The tile number of tile only containing the connection of
** the top part to the bottom part of tree.
** Is created on the map by lumber chopping.
**
** CTileset::BotOneTree
**
** The tile number of tile only containing the bottom part of a
** tree. Is created on the map by lumber chopping.
**
** CTileset::RemovedTree
**
** The tile number of the tile placed where trees are removed.
** Is created on the map by lumber chopping.
**
** CTileset::GrowingTree[2]
**
** Contains the tile numbers of a growing tree from small to big.
** @note Not yet used.
**
** CTilset::WoodTable[20]
**
** Table for wood removable. This table contains the tile which
** is placed after a tree removement, depending on the surrounding.
**
** CTileset::MixedLookupTable[]
** Table for finding what part of the tile contains wood/rock,
** and which part is grass or bare ground.
**
** CTileset::TopOneRock
**
** The tile number of tile only containing the top part of a rock.
** Is created on the map by destroying rocks.
**
** CTileset::MidOneRock
**
** The tile number of tile only containing the connection of
** the top part to the bottom part of a rock.
** Is created on the map by destroying rocks.
**
** CTileset::BotOneRock
**
** The tile number of tile only containing the bottom part of a
** rock. Is created on the map by destroying rocks.
**
** CTileset::RemovedRock
**
** The tile number of the tile placed where rocks are removed.
** Is created on the map by destroying rocks.
**
** CTileset::RockTable[20]
**
** Table for rock removable. Depending on the surrinding this
** table contains the new tile to be placed.
**
** @todo Johns: I don't think this table or routines look correct.
** But they work correct.
**
** CTileset::HumanWallTable
**
** Table of human wall tiles, index depends on the surroundings.
**
** CTileset::OrcWallTable
**
** Table of orc wall tiles, index depends on the surroundings.
**
**
** @struct TileInfo tileset.h
**
** \#include "tileset.h"
**
** This structure includes everything about a specific tile from the tileset.
**
** TileInfo::BaseTerrain
**
** This is the base terrain type of a tile. Only 15 of those
** are currently supported.
**
** TileInfo::MixTerrain
**
** @todo This is the terrain the tile is mixed with. This is 0 for
** a solid tile, we should make it equal to BaseTerrain
*/
/*----------------------------------------------------------------------------
-- Includes
----------------------------------------------------------------------------*/
@ -63,11 +228,11 @@ PixelSize PixelTileSize(32, 32);
void LoadTileset()
{
// Load and prepare the tileset
PixelTileSize = Map.Tileset.PixelTileSize;
PixelTileSize = Map.Tileset->PixelTileSize;
ShowLoadProgress("Tileset `%s'", Map.Tileset.ImageFile.c_str());
//Map.TileGraphic = CGraphic::New(Map.Tileset.ImageFile);
Map.TileGraphic = CGraphic::New(Map.Tileset.ImageFile, PixelTileSize.x, PixelTileSize.y);
ShowLoadProgress("Tileset `%s'", Map.Tileset->ImageFile.c_str());
//Map.TileGraphic = CGraphic::New(Map.Tileset->ImageFile);
Map.TileGraphic = CGraphic::New(Map.Tileset->ImageFile, PixelTileSize.x, PixelTileSize.y);
Map.TileGraphic->Load();
}
@ -79,7 +244,7 @@ void LoadTileset()
*/
void CleanTilesets()
{
Map.Tileset.Clear();
Map.Tileset->Clear();
//
// Should this be done by the map?
@ -88,4 +253,51 @@ void CleanTilesets()
Map.TileGraphic = NULL;
}
void CTileset::Clear()
{
Name.clear();
ImageFile.clear();
NumTiles = 0;
PixelTileSize.x = PixelTileSize.y = 0;
delete[] Table;
Table = NULL;
delete[] FlagsTable;
FlagsTable = NULL;
delete[] Tiles;
Tiles = NULL;
delete[] TileTypeTable;
TileTypeTable = NULL;
SolidTerrainTypes.clear();
TopOneTree = 0;
MidOneTree = 0;
BotOneTree = 0;
RemovedTree = 0;
memset(GrowingTree, 0, sizeof(GrowingTree));
memset(WoodTable, 0, sizeof(WoodTable));
delete[] MixedLookupTable;
MixedLookupTable = NULL;
TopOneRock = 0;
MidOneRock = 0;
BotOneRock = 0;
RemovedRock = 0;
memset(RockTable, 0, sizeof(RockTable));
memset(HumanWallTable, 0, sizeof(HumanWallTable));
memset(OrcWallTable, 0, sizeof(OrcWallTable));
}
bool CTileset::IsSeenTile(unsigned short type, unsigned short seen) const
{
if (TileTypeTable) {
switch (type) {
case MapFieldForest:
return TileTypeTable[seen] == TileTypeWood;
case MapFieldRocks:
return TileTypeTable[seen] == TileTypeRock;
default:
return false;
}
}
return false;
}
//@}

1
src/sound/unitsound.cpp
View file

@ -43,7 +43,6 @@
#include "player.h"
#include "sound.h"
#include "sound_server.h"
#include "tileset.h"
#include "unit.h"
#include "unittype.h"
#include "video.h"

4
src/tolua/map.pkg
View file

@ -1,3 +1,5 @@
$#include "tileset.h"
class CMapInfo
{
string Description;
@ -15,7 +17,7 @@ class CTileset
class CMap
{
CMapInfo Info;
CTileset Tileset;
CTileset *Tileset;
};
extern CMap Map;

1
src/ui/interface.cpp
View file

@ -47,7 +47,6 @@
#include "replay.h"
#include "sound.h"
#include "sound_server.h"
#include "tileset.h"
#include "translate.h"
#include "ui.h"
#include "unit.h"

1
src/ui/mainscr.cpp
View file

@ -49,7 +49,6 @@
#include "player.h"
#include "sound.h"
#include "spells.h"
#include "tileset.h"
#include "translate.h"
#include "trigger.h"
#include "ui/contenttype.h"

1
src/ui/mouse.cpp
View file

@ -56,7 +56,6 @@
#include "player.h"
#include "sound.h"
#include "spells.h"
#include "tileset.h"
#include "translate.h"
#include "unit.h"
#include "unit_find.h"

1
src/ui/ui.cpp
View file

@ -43,7 +43,6 @@
#include "iolib.h"
#include "map.h"
#include "menus.h"
#include "tileset.h"
#include "title.h"
#include "ui/contenttype.h"
#include "ui/popup.h"

1
src/unit/script_unittype.cpp
View file

@ -47,7 +47,6 @@
#include "script.h"
#include "sound.h"
#include "spells.h"
#include "tileset.h"
#include "ui.h"
#include "unit.h"
#include "unitsound.h"

3
src/unit/unit.cpp
View file

@ -55,7 +55,6 @@
#include "sound.h"
#include "sound_server.h"
#include "spells.h"
#include "tileset.h"
#include "translate.h"
#include "ui.h"
#include "unit_find.h"
@ -2687,7 +2686,7 @@ void HitUnit(CUnit *attacker, CUnit &target, int damage, const Missile *missile)
missile->Type->OnImpact->pushInteger(damage);
missile->Type->OnImpact->run();
}
}
}
HitUnit_ShowImpactMissile(target);

1
src/unit/unit_draw.cpp
View file

@ -50,7 +50,6 @@
#include "player.h"
#include "script.h"
#include "sound.h"
#include "tileset.h"
#include "unit.h"
#include "unit_find.h"
#include "unitsound.h"

1
src/unit/unittype.cpp
View file

@ -49,7 +49,6 @@
#include "script.h"
#include "sound.h"
#include "spells.h"
#include "tileset.h"
#include "translate.h"
#include "ui.h"
#include "unitsound.h"