Add class CTile : regroups CTileset::NumTiles Table, FlagsTable, Tiles into CTileset::tiles.
Remove useless code. Fix minimap of Editor.
This commit is contained in:
joris
parent
41969f7e94
commit
69246a0896
9 changed files with 192 additions and 210 deletions
|
|
@ -189,6 +189,7 @@ static void EditTile(const Vec2i &pos, int tile)
|
|||
const int tileIndex = tileset.getTileNumber(baseTileIndex, TileToolRandom, TileToolDecoration);
|
||||
CMapField &mf = *Map.Field(pos);
|
||||
mf.setTileIndex(tileset, tileIndex, 0);
|
||||
mf.playerInfo.SeenTile = mf.Tile;
|
||||
|
||||
UI.Minimap.UpdateSeenXY(pos);
|
||||
UI.Minimap.UpdateXY(pos);
|
||||
|
|
@ -648,7 +649,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->tiles[tilenum].tile, x, y);
|
||||
|
||||
if (flags & IconSelected) {
|
||||
Video.DrawRectangleClip(ColorGreen, x, y, PixelTileSize.x, PixelTileSize.y);
|
||||
|
|
@ -959,9 +960,9 @@ static void DrawEditorInfo()
|
|||
const CTileset &tileset = *Map.Tileset;
|
||||
const int index = tileset.findTileIndexByTile(mf.Tile);
|
||||
Assert(index != -1);
|
||||
const int baseTerrainIdx = tileset.Tiles[index].BaseTerrain;
|
||||
const int baseTerrainIdx = tileset.tiles[index].tileinfo.BaseTerrain;
|
||||
const char *baseTerrainStr = tileset.getTerrainName(baseTerrainIdx).c_str();
|
||||
const int mixTerrainIdx = tileset.Tiles[index].MixTerrain;
|
||||
const int mixTerrainIdx = tileset.tiles[index].tileinfo.MixTerrain;
|
||||
const char *mixTerrainStr = mixTerrainIdx ? tileset.getTerrainName(mixTerrainIdx).c_str() : "";
|
||||
snprintf(buf, sizeof(buf), "%s %s", baseTerrainStr, mixTerrainStr);
|
||||
CLabel(GetGameFont()).Draw(UI.StatusLine.TextX + 250, UI.StatusLine.TextY, buf);
|
||||
|
|
@ -1558,7 +1559,7 @@ static bool EditorCallbackMouse_EditTileArea(const PixelPos &screenPos)
|
|||
&& by < screenPos.y && screenPos.y < by + PixelTileSize.y) {
|
||||
const int tile = Editor.ShownTileTypes[i];
|
||||
const int tileindex = Map.Tileset->findTileIndexByTile(tile);
|
||||
const int base = Map.Tileset->Tiles[tileindex].BaseTerrain;
|
||||
const int base = Map.Tileset->tiles[tileindex].tileinfo.BaseTerrain;
|
||||
UI.StatusLine.Set(Map.Tileset->getTerrainName(base));
|
||||
Editor.CursorTileIndex = i;
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -101,6 +101,7 @@ static void EditorChangeTile(const Vec2i &pos, int tileIndex, int d)
|
|||
// Change the flags
|
||||
CMapField &mf = *Map.Field(pos);
|
||||
mf.setTileIndex(*Map.Tileset, tileIndex, 0);
|
||||
mf.playerInfo.SeenTile = mf.Tile;
|
||||
|
||||
UI.Minimap.UpdateSeenXY(pos);
|
||||
UI.Minimap.UpdateXY(pos);
|
||||
|
|
@ -220,12 +221,6 @@ static void TileFill(const Vec2i &pos, int tile, int size)
|
|||
}
|
||||
}
|
||||
|
||||
#define WATER_TILE 0x10
|
||||
#define COAST_TILE 0x30
|
||||
#define GRASS_TILE 0x50
|
||||
#define WOOD_TILE 0x70
|
||||
#define ROCK_TILE 0x80
|
||||
|
||||
/**
|
||||
** Randomize tiles and fill in map
|
||||
**
|
||||
|
|
@ -251,6 +246,12 @@ static void EditorRandomizeTile(int tile, int count, int max_size)
|
|||
}
|
||||
}
|
||||
|
||||
#define WATER_TILE 0x10
|
||||
#define COAST_TILE 0x30
|
||||
#define GRASS_TILE 0x50
|
||||
#define WOOD_TILE 0x70
|
||||
#define ROCK_TILE 0x80
|
||||
|
||||
/**
|
||||
** Add a unit to random locations on the map, unit will be neutral
|
||||
**
|
||||
|
|
|
|||
|
|
@ -469,9 +469,10 @@ int WriteMapSetup(const char *mapSetup, CMap &map, int writeTerrain)
|
|||
f->printf("-- Tiles Map\n");
|
||||
for (int i = 0; i < map.Info.MapHeight; ++i) {
|
||||
for (int j = 0; j < map.Info.MapWidth; ++j) {
|
||||
const int tile = map.Fields[j + i * map.Info.MapWidth].Tile;
|
||||
const CMapField &mf = map.Fields[j + i * map.Info.MapWidth];
|
||||
const int tile = mf.Tile;
|
||||
const int n = map.Tileset->findTileIndexByTile(tile);
|
||||
const int value = map.Fields[j + i * map.Info.MapWidth].Value;
|
||||
const int value = mf.Value;
|
||||
f->printf("SetTile(%3d, %d, %d, %d)\n", n, j, i, value);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -335,12 +335,11 @@ extern void MapFixSeenWallNeighbors(const Vec2i &pos);
|
|||
extern void MapFixWallTile(const Vec2i &pos);
|
||||
|
||||
//
|
||||
// in script_map.c
|
||||
// in script_map.cpp
|
||||
//
|
||||
/// Set a tile
|
||||
extern void SetTile(int tile, const Vec2i &pos, int value = 0);
|
||||
|
||||
inline void SetTile(int tile, int x, int y, int value = 0)
|
||||
extern void SetTile(unsigned int tile, const Vec2i &pos, int value = 0);
|
||||
inline void SetTile(unsigned int tile, int x, int y, int value = 0)
|
||||
{
|
||||
const Vec2i pos(x, y);
|
||||
SetTile(tile, pos, value);
|
||||
|
|
|
|||
|
|
@ -59,13 +59,18 @@ enum TileType {
|
|||
};
|
||||
|
||||
/// Single tile definition
|
||||
struct TileInfo {
|
||||
struct CTileInfo {
|
||||
public:
|
||||
bool operator ==(const TileInfo &rhs) const
|
||||
CTileInfo() : BaseTerrain(0), MixTerrain(0)
|
||||
{}
|
||||
CTileInfo(unsigned char base, unsigned char mix) : BaseTerrain(base), MixTerrain(mix)
|
||||
{}
|
||||
|
||||
bool operator ==(const CTileInfo &rhs) const
|
||||
{
|
||||
return BaseTerrain == rhs.BaseTerrain && MixTerrain == rhs.MixTerrain;
|
||||
}
|
||||
bool operator !=(const TileInfo &rhs) const { return !(*this == rhs); }
|
||||
bool operator !=(const CTileInfo &rhs) const { return !(*this == rhs); }
|
||||
|
||||
public:
|
||||
unsigned char BaseTerrain; /// Basic terrain of the tile
|
||||
|
|
@ -78,11 +83,22 @@ struct SolidTerrainInfo {
|
|||
// TODO: When drawing with the editor add some kind fo probabilities for every tile.
|
||||
};
|
||||
|
||||
class CTile
|
||||
{
|
||||
public:
|
||||
unsigned short tile; /// graphical pos
|
||||
unsigned short flag; /// Flag
|
||||
CTileInfo tileinfo; /// Tile descriptions
|
||||
};
|
||||
|
||||
/// Tileset definition
|
||||
class CTileset
|
||||
{
|
||||
public:
|
||||
void clear();
|
||||
|
||||
unsigned int getTileCount() const { return tiles.size(); }
|
||||
|
||||
bool isAWallTile(unsigned tileIndex) const;
|
||||
bool isARaceWallTile(unsigned tileIndex, bool human) const;
|
||||
bool isAWoodTile(unsigned tileIndex) const;
|
||||
|
|
@ -134,16 +150,15 @@ public:
|
|||
std::string Name; /// Nice name to display
|
||||
std::string ImageFile; /// File containing image data
|
||||
|
||||
int NumTiles; /// Number of tiles in the tables
|
||||
std::vector<unsigned short> Table; /// Pud to Internal conversion table
|
||||
std::vector<unsigned short> FlagsTable; /// Flag table for editor
|
||||
std::vector<TileInfo> Tiles; /// Tile descriptions
|
||||
public:
|
||||
std::vector<CTile> tiles;
|
||||
|
||||
// TODO: currently hardcoded
|
||||
std::vector<unsigned char> TileTypeTable; /// For fast lookup of tile type
|
||||
private:
|
||||
PixelSize pixelTileSize; /// Size of a tile in pixel
|
||||
std::vector<SolidTerrainInfo> solidTerrainTypes; /// Information about solid terrains.
|
||||
#if 1
|
||||
std::vector<int> mixedLookupTable; /// Lookup for what part of tile used
|
||||
unsigned topOneTreeTile; /// Tile for one tree top
|
||||
unsigned midOneTreeTile; /// Tile for one tree middle
|
||||
|
|
@ -157,6 +172,7 @@ private:
|
|||
int rockTable[20]; /// Removed rock placement table
|
||||
unsigned humanWallTable[16]; /// Human wall placement table
|
||||
unsigned orcWallTable[16]; /// Orc wall placement table
|
||||
#endif
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -77,17 +77,18 @@ bool CMapField::IsTerrainResourceOnMap() const
|
|||
|
||||
void CMapField::setTileIndex(const CTileset &tileset, unsigned int tileIndex, int value)
|
||||
{
|
||||
this->Tile = tileset.Table[tileIndex];
|
||||
const CTile &tile = tileset.tiles[tileIndex];
|
||||
this->Tile = tile.tile;
|
||||
this->Value = value;
|
||||
#if 0
|
||||
this->Flags = tileset.FlagsTable[tileIndex];
|
||||
this->Flags = tile.flag;
|
||||
#else
|
||||
this->Flags &= ~(MapFieldHuman | MapFieldLandAllowed | MapFieldCoastAllowed |
|
||||
MapFieldWaterAllowed | MapFieldNoBuilding | MapFieldUnpassable |
|
||||
MapFieldWall | MapFieldRocks | MapFieldForest);
|
||||
this->Flags |= tileset.FlagsTable[tileIndex];
|
||||
this->Flags |= tile.flag;
|
||||
#endif
|
||||
this->Cost = 1 << (tileset.FlagsTable[tileIndex] & MapFieldSpeedMask);
|
||||
this->Cost = 1 << (tile.flag & MapFieldSpeedMask);
|
||||
#ifdef DEBUG
|
||||
this->TilesetTile = tileIndex;
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -339,13 +339,13 @@ static int CclSetFogOfWarGraphics(lua_State *l)
|
|||
** @param pos coordinate
|
||||
** @param value Value of the tile
|
||||
*/
|
||||
void SetTile(int tileIndex, const Vec2i &pos, int value)
|
||||
void SetTile(unsigned int tileIndex, const Vec2i &pos, int value)
|
||||
{
|
||||
if (!Map.Info.IsPointOnMap(pos)) {
|
||||
fprintf(stderr, "Invalid map coordonate : (%d, %d)\n", pos.x, pos.y);
|
||||
return;
|
||||
}
|
||||
if (tileIndex < 0 || tileIndex >= Map.Tileset->NumTiles) {
|
||||
if (Map.Tileset->getTileCount() <= tileIndex) {
|
||||
fprintf(stderr, "Invalid tile number: %d\n", tileIndex);
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -46,19 +46,6 @@
|
|||
-- Functions
|
||||
----------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
** Extend tables of the tileset.
|
||||
**
|
||||
** @param tileset Tileset to be extended.
|
||||
** @param newsize New total number of tiles.
|
||||
*/
|
||||
static void ExtendTilesetTables(CTileset *tileset, unsigned int newsize)
|
||||
{
|
||||
tileset->Table.resize(newsize);
|
||||
tileset->FlagsTable.resize(newsize);
|
||||
tileset->Tiles.resize(newsize);
|
||||
}
|
||||
|
||||
static bool ModifyFlag(const char *flagName, unsigned int *flag)
|
||||
{
|
||||
const struct {
|
||||
|
|
@ -212,10 +199,10 @@ void CTileset::parseSpecial(lua_State *l)
|
|||
*/
|
||||
void CTileset::parseSolid(lua_State *l)
|
||||
{
|
||||
const int index = NumTiles;
|
||||
const int index = tiles.size();
|
||||
int j = 0;
|
||||
|
||||
ExtendTilesetTables(this, index + 16);
|
||||
this->tiles.resize(index + 16);
|
||||
if (!lua_istable(l, -1)) {
|
||||
LuaError(l, "incorrect argument");
|
||||
}
|
||||
|
|
@ -243,7 +230,7 @@ void CTileset::parseSolid(lua_State *l)
|
|||
ParseTilesetTileFlags(l, &tile_flag, &k);
|
||||
--j;
|
||||
lua_pop(l, 1);
|
||||
FlagsTable[index + j] = tile_flag;
|
||||
tiles[index + j].flag = tile_flag;
|
||||
continue;
|
||||
}
|
||||
const int pud = LuaToNumber(l, -1);
|
||||
|
|
@ -251,22 +238,16 @@ void CTileset::parseSolid(lua_State *l)
|
|||
|
||||
// ugly hack for sc tilesets, remove when fixed
|
||||
if (j > 15) {
|
||||
ExtendTilesetTables(this, index + j);
|
||||
this->tiles.resize(index + j);
|
||||
}
|
||||
Table[index + j] = pud;
|
||||
FlagsTable[index + j] = f;
|
||||
Tiles[index + j].BaseTerrain = basic_name;
|
||||
Tiles[index + j].MixTerrain = 0;
|
||||
CTile &tile = tiles[index + j];
|
||||
|
||||
tile.tile = pud;
|
||||
tile.flag = f;
|
||||
tile.tileinfo.BaseTerrain = basic_name;
|
||||
tile.tileinfo.MixTerrain = 0;
|
||||
}
|
||||
lua_pop(l, 1);
|
||||
|
||||
for (int i = j; i < 16; ++i) {
|
||||
Table[index + i] = 0;
|
||||
FlagsTable[index + i] = 0;
|
||||
Tiles[index + i].BaseTerrain = 0;
|
||||
Tiles[index + i].MixTerrain = 0;
|
||||
}
|
||||
NumTiles = index + std::max(16, j);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -276,10 +257,8 @@ void CTileset::parseSolid(lua_State *l)
|
|||
*/
|
||||
void CTileset::parseMixed(lua_State *l)
|
||||
{
|
||||
int index = NumTiles;
|
||||
const int new_index = index + 256;
|
||||
NumTiles = new_index;
|
||||
ExtendTilesetTables(this, index + 256);
|
||||
int index = tiles.size();
|
||||
tiles.resize(index + 256);
|
||||
|
||||
if (!lua_istable(l, -1)) {
|
||||
LuaError(l, "incorrect argument");
|
||||
|
|
@ -309,28 +288,16 @@ void CTileset::parseMixed(lua_State *l)
|
|||
lua_rawgeti(l, -1, i + 1);
|
||||
const int pud = LuaToNumber(l, -1);
|
||||
lua_pop(l, 1);
|
||||
Table[index + i] = pud;
|
||||
FlagsTable[index + i] = f;
|
||||
Tiles[index + i].BaseTerrain = basic_name;
|
||||
Tiles[index + i].MixTerrain = mixed_name;
|
||||
}
|
||||
// Fill missing slots
|
||||
for (int i = len; i < 16; ++i) {
|
||||
Table[index + i] = 0;
|
||||
FlagsTable[index + i] = 0;
|
||||
Tiles[index + i].BaseTerrain = 0;
|
||||
Tiles[index + i].MixTerrain = 0;
|
||||
CTile &tile = tiles[index + i];
|
||||
|
||||
tile.tile = pud;
|
||||
tile.flag = f;
|
||||
tile.tileinfo.BaseTerrain = basic_name;
|
||||
tile.tileinfo.MixTerrain = mixed_name;
|
||||
}
|
||||
index += 16;
|
||||
lua_pop(l, 1);
|
||||
}
|
||||
while (index < new_index) {
|
||||
Table[index] = 0;
|
||||
FlagsTable[index] = 0;
|
||||
Tiles[index].BaseTerrain = 0;
|
||||
Tiles[index].MixTerrain = 0;
|
||||
++index;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -341,7 +308,7 @@ void CTileset::parseMixed(lua_State *l)
|
|||
*/
|
||||
void CTileset::parseSlots(lua_State *l, int t)
|
||||
{
|
||||
NumTiles = 0;
|
||||
tiles.clear();
|
||||
|
||||
// Parse the list: (still everything could be changed!)
|
||||
const int args = lua_rawlen(l, t);
|
||||
|
|
@ -435,33 +402,32 @@ static int CclBuildTilesetTables(lua_State *l)
|
|||
void CTileset::buildTable(lua_State *l)
|
||||
{
|
||||
// Calculate number of tiles in graphic tile
|
||||
const int n = NumTiles;
|
||||
const int n = tiles.size();
|
||||
|
||||
mixedLookupTable.clear();
|
||||
mixedLookupTable.resize(n, 0);
|
||||
// Build the TileTypeTable
|
||||
TileTypeTable.resize(n, 0);
|
||||
|
||||
const std::vector<unsigned short> &table = Table;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
const int tile = table[i];
|
||||
const int tile = tiles[i].tile;
|
||||
if (tile == 0) {
|
||||
continue;
|
||||
}
|
||||
unsigned flags = FlagsTable[i];
|
||||
if (flags & MapFieldWaterAllowed) {
|
||||
const unsigned flag = tiles[i].flag;
|
||||
if (flag & MapFieldWaterAllowed) {
|
||||
TileTypeTable[tile] = TileTypeWater;
|
||||
} else if (flags & MapFieldCoastAllowed) {
|
||||
} else if (flag & MapFieldCoastAllowed) {
|
||||
TileTypeTable[tile] = TileTypeCoast;
|
||||
} else if (flags & MapFieldWall) {
|
||||
if (flags & MapFieldHuman) {
|
||||
} else if (flag & MapFieldWall) {
|
||||
if (flag & MapFieldHuman) {
|
||||
TileTypeTable[tile] = TileTypeHumanWall;
|
||||
} else {
|
||||
TileTypeTable[tile] = TileTypeOrcWall;
|
||||
}
|
||||
} else if (flags & MapFieldRocks) {
|
||||
} else if (flag & MapFieldRocks) {
|
||||
TileTypeTable[tile] = TileTypeRock;
|
||||
} else if (flags & MapFieldForest) {
|
||||
} else if (flag & MapFieldForest) {
|
||||
TileTypeTable[tile] = TileTypeWood;
|
||||
}
|
||||
}
|
||||
|
|
@ -489,14 +455,16 @@ void CTileset::buildTable(lua_State *l)
|
|||
int solid = 0;
|
||||
int mixed = 0;
|
||||
for (int i = 0; i < n;) {
|
||||
if (Tiles[i].BaseTerrain && Tiles[i].MixTerrain) {
|
||||
if (FlagsTable[i] & MapFieldForest) {
|
||||
const CTile &tile = tiles[i];
|
||||
const CTileInfo &tileinfo = tile.tileinfo;
|
||||
if (tileinfo.BaseTerrain && tileinfo.MixTerrain) {
|
||||
if (tile.flag & MapFieldForest) {
|
||||
mixed = i;
|
||||
}
|
||||
i += 256;
|
||||
} else {
|
||||
if (Tiles[i].BaseTerrain != 0 && Tiles[i].MixTerrain == 0) {
|
||||
if (FlagsTable[i] & MapFieldForest) {
|
||||
if (tileinfo.BaseTerrain != 0 && tileinfo.MixTerrain == 0) {
|
||||
if (tile.flag & MapFieldForest) {
|
||||
solid = i;
|
||||
}
|
||||
}
|
||||
|
|
@ -504,21 +472,21 @@ void CTileset::buildTable(lua_State *l)
|
|||
}
|
||||
}
|
||||
woodTable[ 0] = -1;
|
||||
woodTable[ 1] = table[mixed + 0x30];
|
||||
woodTable[ 2] = table[mixed + 0x70];
|
||||
woodTable[ 3] = table[mixed + 0xB0];
|
||||
woodTable[ 4] = table[mixed + 0x10];
|
||||
woodTable[ 5] = table[mixed + 0x50];
|
||||
woodTable[ 6] = table[mixed + 0x90];
|
||||
woodTable[ 7] = table[mixed + 0xD0];
|
||||
woodTable[ 8] = table[mixed + 0x00];
|
||||
woodTable[ 9] = table[mixed + 0x40];
|
||||
woodTable[10] = table[mixed + 0x80];
|
||||
woodTable[11] = table[mixed + 0xC0];
|
||||
woodTable[12] = table[mixed + 0x20];
|
||||
woodTable[13] = table[mixed + 0x60];
|
||||
woodTable[14] = table[mixed + 0xA0];
|
||||
woodTable[15] = table[solid];
|
||||
woodTable[ 1] = tiles[mixed + 0x30].tile;
|
||||
woodTable[ 2] = tiles[mixed + 0x70].tile;
|
||||
woodTable[ 3] = tiles[mixed + 0xB0].tile;
|
||||
woodTable[ 4] = tiles[mixed + 0x10].tile;
|
||||
woodTable[ 5] = tiles[mixed + 0x50].tile;
|
||||
woodTable[ 6] = tiles[mixed + 0x90].tile;
|
||||
woodTable[ 7] = tiles[mixed + 0xD0].tile;
|
||||
woodTable[ 8] = tiles[mixed + 0x00].tile;
|
||||
woodTable[ 9] = tiles[mixed + 0x40].tile;
|
||||
woodTable[10] = tiles[mixed + 0x80].tile;
|
||||
woodTable[11] = tiles[mixed + 0xC0].tile;
|
||||
woodTable[12] = tiles[mixed + 0x20].tile;
|
||||
woodTable[13] = tiles[mixed + 0x60].tile;
|
||||
woodTable[14] = tiles[mixed + 0xA0].tile;
|
||||
woodTable[15] = tiles[solid].tile;
|
||||
woodTable[16] = -1;
|
||||
woodTable[17] = botOneTreeTile;
|
||||
woodTable[18] = topOneTreeTile;
|
||||
|
|
@ -533,27 +501,27 @@ void CTileset::buildTable(lua_State *l)
|
|||
//16 Bottom Tree Tile
|
||||
//32 Top Tree Tile
|
||||
for (int i = solid; i < solid + 16; ++i) {
|
||||
mixedLookupTable[table[i]] = 15;
|
||||
mixedLookupTable[tiles[i].tile] = 15;
|
||||
}
|
||||
for (int i = mixed; i < mixed + 256; ++i) {
|
||||
int check = (int)((i - mixed) / 16);
|
||||
|
||||
switch (check) {
|
||||
case 0: mixedLookupTable[table[i]] = 8; break;
|
||||
case 1: mixedLookupTable[table[i]] = 4; break;
|
||||
case 2: mixedLookupTable[table[i]] = 8 + 4; break;
|
||||
case 3: mixedLookupTable[table[i]] = 1; break;
|
||||
case 4: mixedLookupTable[table[i]] = 8 + 1; break;
|
||||
case 5: mixedLookupTable[table[i]] = 4 + 1; break;
|
||||
case 6: mixedLookupTable[table[i]] = 8 + 4 + 1; break;
|
||||
case 7: mixedLookupTable[table[i]] = 2; break;
|
||||
case 8: mixedLookupTable[table[i]] = 8 + 2; break;
|
||||
case 9: mixedLookupTable[table[i]] = 4 + 2; break;
|
||||
case 10: mixedLookupTable[table[i]] = 8 + 4 + 2; break;
|
||||
case 11: mixedLookupTable[table[i]] = 2 + 1; break;
|
||||
case 12: mixedLookupTable[table[i]] = 8 + 2 + 1; break;
|
||||
case 13: mixedLookupTable[table[i]] = 4 + 2 + 1; break;
|
||||
default: mixedLookupTable[table[i]] = 0; break;
|
||||
case 0: mixedLookupTable[tiles[i].tile] = 8; break;
|
||||
case 1: mixedLookupTable[tiles[i].tile] = 4; break;
|
||||
case 2: mixedLookupTable[tiles[i].tile] = 8 + 4; break;
|
||||
case 3: mixedLookupTable[tiles[i].tile] = 1; break;
|
||||
case 4: mixedLookupTable[tiles[i].tile] = 8 + 1; break;
|
||||
case 5: mixedLookupTable[tiles[i].tile] = 4 + 1; break;
|
||||
case 6: mixedLookupTable[tiles[i].tile] = 8 + 4 + 1; break;
|
||||
case 7: mixedLookupTable[tiles[i].tile] = 2; break;
|
||||
case 8: mixedLookupTable[tiles[i].tile] = 8 + 2; break;
|
||||
case 9: mixedLookupTable[tiles[i].tile] = 4 + 2; break;
|
||||
case 10: mixedLookupTable[tiles[i].tile] = 8 + 4 + 2; break;
|
||||
case 11: mixedLookupTable[tiles[i].tile] = 2 + 1; break;
|
||||
case 12: mixedLookupTable[tiles[i].tile] = 8 + 2 + 1; break;
|
||||
case 13: mixedLookupTable[tiles[i].tile] = 4 + 2 + 1; break;
|
||||
default: mixedLookupTable[tiles[i].tile] = 0; break;
|
||||
}
|
||||
}
|
||||
//16 Bottom Tree Special
|
||||
|
|
@ -567,14 +535,16 @@ void CTileset::buildTable(lua_State *l)
|
|||
mixed = 0;
|
||||
solid = 0;
|
||||
for (int i = 0; i < n;) {
|
||||
if (Tiles[i].BaseTerrain && Tiles[i].MixTerrain) {
|
||||
if (FlagsTable[i] & MapFieldRocks) {
|
||||
const CTile &tile = tiles[i];
|
||||
const CTileInfo &tileinfo = tile.tileinfo;
|
||||
if (tileinfo.BaseTerrain && tileinfo.MixTerrain) {
|
||||
if (tile.flag & MapFieldRocks) {
|
||||
mixed = i;
|
||||
}
|
||||
i += 256;
|
||||
} else {
|
||||
if (Tiles[i].BaseTerrain != 0 && Tiles[i].MixTerrain == 0) {
|
||||
if (FlagsTable[i] & MapFieldRocks) {
|
||||
if (tileinfo.BaseTerrain != 0 && tileinfo.MixTerrain == 0) {
|
||||
if (tile.flag & MapFieldRocks) {
|
||||
solid = i;
|
||||
}
|
||||
}
|
||||
|
|
@ -589,26 +559,26 @@ void CTileset::buildTable(lua_State *l)
|
|||
//4 Top Right
|
||||
//8 Top Left
|
||||
for (int i = solid; i < solid + 16; ++i) {
|
||||
mixedLookupTable[table[i]] = 15;
|
||||
mixedLookupTable[tiles[i].tile] = 15;
|
||||
}
|
||||
for (int i = mixed; i < mixed + 256; ++i) {
|
||||
int check = (int)((i - mixed) / 16);
|
||||
switch (check) {
|
||||
case 0: mixedLookupTable[table[i]] = 8; break;
|
||||
case 1: mixedLookupTable[table[i]] = 4; break;
|
||||
case 2: mixedLookupTable[table[i]] = 8 + 4; break;
|
||||
case 3: mixedLookupTable[table[i]] = 1; break;
|
||||
case 4: mixedLookupTable[table[i]] = 8 + 1; break;
|
||||
case 5: mixedLookupTable[table[i]] = 4 + 1; break;
|
||||
case 6: mixedLookupTable[table[i]] = 8 + 4 + 1; break;
|
||||
case 7: mixedLookupTable[table[i]] = 2; break;
|
||||
case 8: mixedLookupTable[table[i]] = 8 + 2; break;
|
||||
case 9: mixedLookupTable[table[i]] = 4 + 2; break;
|
||||
case 10: mixedLookupTable[table[i]] = 8 + 4 + 2; break;
|
||||
case 11: mixedLookupTable[table[i]] = 2 + 1; break;
|
||||
case 12: mixedLookupTable[table[i]] = 8 + 2 + 1; break;
|
||||
case 13: mixedLookupTable[table[i]] = 4 + 2 + 1; break;
|
||||
default: mixedLookupTable[table[i]] = 0; break;
|
||||
case 0: mixedLookupTable[tiles[i].tile] = 8; break;
|
||||
case 1: mixedLookupTable[tiles[i].tile] = 4; break;
|
||||
case 2: mixedLookupTable[tiles[i].tile] = 8 + 4; break;
|
||||
case 3: mixedLookupTable[tiles[i].tile] = 1; break;
|
||||
case 4: mixedLookupTable[tiles[i].tile] = 8 + 1; break;
|
||||
case 5: mixedLookupTable[tiles[i].tile] = 4 + 1; break;
|
||||
case 6: mixedLookupTable[tiles[i].tile] = 8 + 4 + 1; break;
|
||||
case 7: mixedLookupTable[tiles[i].tile] = 2; break;
|
||||
case 8: mixedLookupTable[tiles[i].tile] = 8 + 2; break;
|
||||
case 9: mixedLookupTable[tiles[i].tile] = 4 + 2; break;
|
||||
case 10: mixedLookupTable[tiles[i].tile] = 8 + 4 + 2; break;
|
||||
case 11: mixedLookupTable[tiles[i].tile] = 2 + 1; break;
|
||||
case 12: mixedLookupTable[tiles[i].tile] = 8 + 2 + 1; break;
|
||||
case 13: mixedLookupTable[tiles[i].tile] = 4 + 2 + 1; break;
|
||||
default: mixedLookupTable[tiles[i].tile] = 0; break;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -617,21 +587,21 @@ void CTileset::buildTable(lua_State *l)
|
|||
mixedLookupTable[midOneRockTile] = 15 + 48;
|
||||
|
||||
rockTable[ 0] = -1;
|
||||
rockTable[ 1] = table[mixed + 0x30];
|
||||
rockTable[ 2] = table[mixed + 0x70];
|
||||
rockTable[ 3] = table[mixed + 0xB0];
|
||||
rockTable[ 4] = table[mixed + 0x10];
|
||||
rockTable[ 5] = table[mixed + 0x50];
|
||||
rockTable[ 6] = table[mixed + 0x90];
|
||||
rockTable[ 7] = table[mixed + 0xD0];
|
||||
rockTable[ 8] = table[mixed + 0x00];
|
||||
rockTable[ 9] = table[mixed + 0x40];
|
||||
rockTable[10] = table[mixed + 0x80];
|
||||
rockTable[11] = table[mixed + 0xC0];
|
||||
rockTable[12] = table[mixed + 0x20];
|
||||
rockTable[13] = table[mixed + 0x60];
|
||||
rockTable[14] = table[mixed + 0xA0];
|
||||
rockTable[15] = table[solid];
|
||||
rockTable[ 1] = tiles[mixed + 0x30].tile;
|
||||
rockTable[ 2] = tiles[mixed + 0x70].tile;
|
||||
rockTable[ 3] = tiles[mixed + 0xB0].tile;
|
||||
rockTable[ 4] = tiles[mixed + 0x10].tile;
|
||||
rockTable[ 5] = tiles[mixed + 0x50].tile;
|
||||
rockTable[ 6] = tiles[mixed + 0x90].tile;
|
||||
rockTable[ 7] = tiles[mixed + 0xD0].tile;
|
||||
rockTable[ 8] = tiles[mixed + 0x00].tile;
|
||||
rockTable[ 9] = tiles[mixed + 0x40].tile;
|
||||
rockTable[10] = tiles[mixed + 0x80].tile;
|
||||
rockTable[11] = tiles[mixed + 0xC0].tile;
|
||||
rockTable[12] = tiles[mixed + 0x20].tile;
|
||||
rockTable[13] = tiles[mixed + 0x60].tile;
|
||||
rockTable[14] = tiles[mixed + 0xA0].tile;
|
||||
rockTable[15] = tiles[solid].tile;
|
||||
rockTable[16] = -1;
|
||||
rockTable[17] = botOneRockTile;
|
||||
rockTable[18] = topOneRockTile;
|
||||
|
|
@ -681,24 +651,24 @@ void CTileset::buildWallReplacementTable()
|
|||
for (int i = 0; i < 16; ++i) {
|
||||
int n = 0;
|
||||
unsigned int tile = humanWallTable[i];
|
||||
while (Table[tile]) { // Skip good tiles
|
||||
while (tiles[tile].tile) { // Skip good tiles
|
||||
++tile;
|
||||
++n;
|
||||
}
|
||||
while (!Table[tile]) { // Skip separator
|
||||
while (!tiles[tile].tile) { // Skip separator
|
||||
++tile;
|
||||
++n;
|
||||
}
|
||||
while (Table[tile]) { // Skip good tiles
|
||||
while (tiles[tile].tile) { // Skip good tiles
|
||||
++tile;
|
||||
++n;
|
||||
}
|
||||
while (!Table[tile]) { // Skip separator
|
||||
while (!tiles[tile].tile) { // Skip separator
|
||||
++tile;
|
||||
++n;
|
||||
}
|
||||
while (n < 16 && Table[tile]) {
|
||||
TileTypeTable[Table[tile]] = TileTypeUnknown;
|
||||
while (n < 16 && tiles[tile].tile) {
|
||||
TileTypeTable[tiles[tile].tile] = TileTypeUnknown;
|
||||
++tile;
|
||||
++n;
|
||||
}
|
||||
|
|
@ -715,16 +685,16 @@ static int CclSetTileFlags(lua_State *l)
|
|||
if (lua_gettop(l) < 2) {
|
||||
LuaError(l, "No flags defined");
|
||||
}
|
||||
const int tilenumber = LuaToNumber(l, 1);
|
||||
const unsigned int tilenumber = LuaToNumber(l, 1);
|
||||
|
||||
if (tilenumber >= Map.Tileset->NumTiles) {
|
||||
if (tilenumber >= Map.Tileset->tiles.size()) {
|
||||
LuaError(l, "Accessed a tile that's not defined");
|
||||
}
|
||||
int j = 0;
|
||||
int flags = 0;
|
||||
|
||||
ParseTilesetTileFlags(l, &flags, &j);
|
||||
Map.Tileset->FlagsTable[tilenumber] = flags;
|
||||
Map.Tileset->tiles[tilenumber].flag = flags;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -54,17 +54,13 @@
|
|||
**
|
||||
** 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
|
||||
** CTileset::Flags
|
||||
**
|
||||
** Table of the tile flags used by the editor.
|
||||
** @see CMapField::Flags
|
||||
|
|
@ -212,11 +208,8 @@ void CTileset::clear()
|
|||
{
|
||||
Name.clear();
|
||||
ImageFile.clear();
|
||||
NumTiles = 0;
|
||||
pixelTileSize.x = pixelTileSize.y = 0;
|
||||
Table.clear();
|
||||
FlagsTable.clear();
|
||||
Tiles.clear();
|
||||
tiles.clear();
|
||||
TileTypeTable.clear();
|
||||
solidTerrainTypes.clear();
|
||||
topOneTreeTile = 0;
|
||||
|
|
@ -299,14 +292,14 @@ unsigned int CTileset::getSolidTerrainCount() const
|
|||
|
||||
int CTileset::findTileIndex(unsigned char baseTerrain, unsigned char mixTerrain) const
|
||||
{
|
||||
const TileInfo tileInfo = {baseTerrain, mixTerrain};
|
||||
const CTileInfo tileInfo(baseTerrain, mixTerrain);
|
||||
|
||||
for (int i = 0; i != NumTiles;) {
|
||||
if (Tiles[i] == tileInfo) {
|
||||
for (size_t i = 0; i != tiles.size();) {
|
||||
if (tiles[i].tileinfo == tileInfo) {
|
||||
return i;
|
||||
}
|
||||
// Advance solid or mixed.
|
||||
if (!Tiles[i].MixTerrain) {
|
||||
if (!tiles[i].tileinfo.MixTerrain) {
|
||||
i += 16;
|
||||
} else {
|
||||
i += 256;
|
||||
|
|
@ -359,12 +352,12 @@ int CTileset::findTilePath(int base, int goal, int length, std::vector<char> &ma
|
|||
}
|
||||
// Find any mixed tile
|
||||
int l = INT_MAX;
|
||||
for (int i = 0; i < NumTiles;) {
|
||||
for (size_t i = 0; i != tiles.size();) {
|
||||
int j = 0;
|
||||
if (base == Tiles[i].BaseTerrain) {
|
||||
j = Tiles[i].MixTerrain;
|
||||
} else if (base == Tiles[i].MixTerrain) {
|
||||
j = Tiles[i].BaseTerrain;
|
||||
if (base == tiles[i].tileinfo.BaseTerrain) {
|
||||
j = tiles[i].tileinfo.MixTerrain;
|
||||
} else if (base == tiles[i].tileinfo.MixTerrain) {
|
||||
j = tiles[i].tileinfo.BaseTerrain;
|
||||
}
|
||||
if (j != 0 && marks[j] == 0) { // possible path found
|
||||
marks[j] = j;
|
||||
|
|
@ -377,7 +370,7 @@ int CTileset::findTilePath(int base, int goal, int length, std::vector<char> &ma
|
|||
}
|
||||
}
|
||||
// Advance solid or mixed.
|
||||
if (Tiles[i].MixTerrain == 0) {
|
||||
if (tiles[i].tileinfo.MixTerrain == 0) {
|
||||
i += 16;
|
||||
} else {
|
||||
i += 256;
|
||||
|
|
@ -458,7 +451,7 @@ int CTileset::tileFromQuad(unsigned fixed, unsigned quad) const
|
|||
Assert(res != -1);
|
||||
return res;
|
||||
}
|
||||
if (type1 == Tiles[tileIndex].MixTerrain) {
|
||||
if (type1 == tiles[tileIndex].tileinfo.MixTerrain) {
|
||||
// Other mixed
|
||||
std::swap(type1, type2);
|
||||
}
|
||||
|
|
@ -537,8 +530,8 @@ bool CTileset::isEquivalentTile(unsigned int tile1, unsigned int tile2) const
|
|||
|
||||
int CTileset::findTileIndexByTile(unsigned int tile) const
|
||||
{
|
||||
for (int i = 0; i != NumTiles; ++i) {
|
||||
if (tile == Table[i]) {
|
||||
for (size_t i = 0; i != tiles.size(); ++i) {
|
||||
if (tile == tiles[i].tile) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
|
@ -562,7 +555,7 @@ unsigned int CTileset::getTileNumber(int basic, bool random, bool filler) const
|
|||
if (random) {
|
||||
int n = 0;
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
if (!Table[tile + i]) {
|
||||
if (!tiles[tile + i].tile) {
|
||||
if (!filler) {
|
||||
break;
|
||||
}
|
||||
|
|
@ -573,7 +566,7 @@ unsigned int CTileset::getTileNumber(int basic, bool random, bool filler) const
|
|||
n = MyRand() % n;
|
||||
int i = -1;
|
||||
do {
|
||||
while (++i < 16 && !Table[tile + i]) {
|
||||
while (++i < 16 && !tiles[tile + i].tile) {
|
||||
}
|
||||
} while (i < 16 && n--);
|
||||
Assert(i != 16);
|
||||
|
|
@ -581,9 +574,9 @@ unsigned int CTileset::getTileNumber(int basic, bool random, bool filler) const
|
|||
}
|
||||
if (filler) {
|
||||
int i = 0;
|
||||
for (; i < 16 && Table[tile + i]; ++i) {
|
||||
for (; i < 16 && tiles[tile + i].tile; ++i) {
|
||||
}
|
||||
for (; i < 16 && !Table[tile + i]; ++i) {
|
||||
for (; i < 16 && !tiles[tile + i].tile; ++i) {
|
||||
}
|
||||
if (i != 16) {
|
||||
return tile + i;
|
||||
|
|
@ -612,8 +605,8 @@ unsigned CTileset::getQuadFromTile(unsigned int tile) const
|
|||
const int tileIndex = findTileIndexByTile(tile);
|
||||
Assert(tileIndex != -1);
|
||||
|
||||
unsigned base = Tiles[tileIndex].BaseTerrain;
|
||||
unsigned mix = Tiles[tileIndex].MixTerrain;
|
||||
const unsigned base = tiles[tileIndex].tileinfo.BaseTerrain;
|
||||
const unsigned mix = tiles[tileIndex].tileinfo.MixTerrain;
|
||||
|
||||
if (mix == 0) { // a solid tile
|
||||
return base | (base << 8) | (base << 16) | (base << 24);
|
||||
|
|
@ -639,13 +632,13 @@ unsigned CTileset::getQuadFromTile(unsigned int tile) const
|
|||
return base | (base << 8) | (base << 16) | (base << 24);
|
||||
}
|
||||
|
||||
void CTileset::fillSolidTiles(std::vector<unsigned int> *tiles) const
|
||||
void CTileset::fillSolidTiles(std::vector<unsigned int> *solidTiles) const
|
||||
{
|
||||
for (int i = 16; i < NumTiles; i += 16) {
|
||||
const TileInfo &info = Tiles[i];
|
||||
for (size_t i = 16; i < tiles.size(); i += 16) {
|
||||
const CTileInfo &info = tiles[i].tileinfo;
|
||||
|
||||
if (info.BaseTerrain && info.MixTerrain == 0) {
|
||||
tiles->push_back(Table[i]);
|
||||
solidTiles->push_back(tiles[i].tile);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -654,22 +647,22 @@ void CTileset::fillSolidTiles(std::vector<unsigned int> *tiles) const
|
|||
unsigned CTileset::getHumanWallTile(int index) const
|
||||
{
|
||||
unsigned tile = humanWallTable[index];
|
||||
tile = Table[tile];
|
||||
tile = tiles[tile].tile;
|
||||
return tile;
|
||||
}
|
||||
unsigned CTileset::getOrcWallTile(int index) const
|
||||
{
|
||||
unsigned tile = orcWallTable[index];
|
||||
tile = Table[tile];
|
||||
tile = tiles[tile].tile;
|
||||
return tile;
|
||||
}
|
||||
|
||||
static unsigned int NextSection(const CTileset &tileset, unsigned int tile)
|
||||
{
|
||||
while (tileset.Table[tile]) { // Skip good tiles
|
||||
while (tileset.tiles[tile].tile) { // Skip good tiles
|
||||
++tile;
|
||||
}
|
||||
while (!tileset.Table[tile]) { // Skip separator
|
||||
while (!tileset.tiles[tile].tile) { // Skip separator
|
||||
++tile;
|
||||
}
|
||||
return tile;
|
||||
|
|
@ -679,14 +672,14 @@ unsigned CTileset::getHumanWallTile_broken(int index) const
|
|||
{
|
||||
unsigned tile = humanWallTable[index];
|
||||
tile = NextSection(*this, tile);
|
||||
tile = Table[tile];
|
||||
tile = tiles[tile].tile;
|
||||
return tile;
|
||||
}
|
||||
unsigned CTileset::getOrcWallTile_broken(int index) const
|
||||
{
|
||||
unsigned tile = orcWallTable[index];
|
||||
tile = NextSection(*this, tile);
|
||||
tile = Table[tile];
|
||||
tile = tiles[tile].tile;
|
||||
return tile;
|
||||
}
|
||||
unsigned CTileset::getHumanWallTile_destroyed(int index) const
|
||||
|
|
@ -694,7 +687,7 @@ unsigned CTileset::getHumanWallTile_destroyed(int index) const
|
|||
unsigned tile = humanWallTable[index];
|
||||
tile = NextSection(*this, tile);
|
||||
tile = NextSection(*this, tile);
|
||||
tile = Table[tile];
|
||||
tile = tiles[tile].tile;
|
||||
return tile;
|
||||
}
|
||||
unsigned CTileset::getOrcWallTile_destroyed(int index) const
|
||||
|
|
@ -702,7 +695,7 @@ unsigned CTileset::getOrcWallTile_destroyed(int index) const
|
|||
unsigned tile = orcWallTable[index];
|
||||
tile = NextSection(*this, tile);
|
||||
tile = NextSection(*this, tile);
|
||||
tile = Table[tile];
|
||||
tile = tiles[tile].tile;
|
||||
return tile;
|
||||
}
|
||||
//@}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue