Clean up tileset.
This commit is contained in:
joris
parent
0a96f73811
commit
8f06b9bf13
5 changed files with 253 additions and 317 deletions
|
|
@ -39,6 +39,8 @@
|
|||
#include "vec2i.h"
|
||||
#include <vector>
|
||||
|
||||
struct lua_State;
|
||||
|
||||
/**
|
||||
** These are used for lookup tiles types
|
||||
** mainly used for the FOW implementation of the seen woods/rocks
|
||||
|
|
@ -75,12 +77,25 @@ public:
|
|||
void Clear();
|
||||
bool IsSeenTile(unsigned short type, unsigned short seen) const;
|
||||
|
||||
unsigned int getOrAddSolidTileIndexByName(const std::string &name);
|
||||
|
||||
|
||||
unsigned getBottomOneTreeTile() const { return BotOneTree; }
|
||||
unsigned getTopOneTreeTile() const { return TopOneTree; }
|
||||
|
||||
unsigned getHumanWallTile(int index) const;
|
||||
unsigned getOrcWallTile(int index) const;
|
||||
unsigned getHumanWallTile_broken(int index) const;
|
||||
unsigned getOrcWallTile_broken(int index) const;
|
||||
unsigned getHumanWallTile_destroyed(int index) const;
|
||||
unsigned getOrcWallTile_destroyed(int index) const;
|
||||
public:
|
||||
void parse(lua_State *l);
|
||||
void buildTable(lua_State *l);
|
||||
|
||||
//private:
|
||||
void buildWallReplacementTable();
|
||||
void parseSpecial(lua_State *l);
|
||||
public:
|
||||
std::string Name; /// Nice name to display
|
||||
std::string ImageFile; /// File containing image data
|
||||
|
|
@ -95,20 +110,23 @@ public:
|
|||
std::vector<unsigned char> TileTypeTable; /// For fast lookup of tile type
|
||||
|
||||
std::vector<SolidTerrainInfo> SolidTerrainTypes; /// Information about solid terrains.
|
||||
|
||||
std::vector<int> MixedLookupTable; /// Lookup for what part of tile used
|
||||
private:
|
||||
unsigned TopOneTree; /// Tile for one tree top
|
||||
unsigned MidOneTree; /// Tile for one tree middle
|
||||
unsigned BotOneTree; /// Tile for one tree bottom
|
||||
public:
|
||||
int RemovedTree; /// Tile placed where trees are gone
|
||||
unsigned GrowingTree[2]; /// Growing tree tiles
|
||||
int WoodTable[20]; /// Table for tree removable
|
||||
std::vector<int> MixedLookupTable; /// Lookup for what part of tile used
|
||||
private:
|
||||
unsigned TopOneRock; /// Tile for one rock top
|
||||
unsigned MidOneRock; /// Tile for one rock middle
|
||||
unsigned BotOneRock; /// Tile for one rock bottom
|
||||
public:
|
||||
int RemovedRock; /// Tile placed where rocks are gone
|
||||
int RockTable[20]; /// Removed rock placement table
|
||||
//private:
|
||||
private:
|
||||
unsigned HumanWallTable[16]; /// Human wall placement table
|
||||
unsigned OrcWallTable[16]; /// Orc wall placement table
|
||||
};
|
||||
|
|
@ -117,7 +135,6 @@ public:
|
|||
-- Functions
|
||||
----------------------------------------------------------------------------*/
|
||||
|
||||
extern void LoadTileset(); /// Load tileset definition
|
||||
extern void CleanTilesets(); /// Cleanup the tileset module
|
||||
extern void TilesetCclRegister(); /// Register CCL features for tileset
|
||||
|
||||
|
|
|
|||
|
|
@ -104,9 +104,9 @@ void CMap::MarkSeenTile(CMapField &mf)
|
|||
FixNeighbors(MapFieldForest, 1, pos);
|
||||
|
||||
// Handle rock changes.
|
||||
} else if (seentile != this->Tileset->RemovedRock && tile == Map.Tileset->RemovedRock) {
|
||||
} else if (seentile != Tileset->RemovedRock && tile == Tileset->RemovedRock) {
|
||||
FixNeighbors(MapFieldRocks, 1, pos);
|
||||
} else if (seentile == this->Tileset->RemovedRock && tile != Map.Tileset->RemovedRock) {
|
||||
} else if (seentile == Tileset->RemovedRock && tile != Tileset->RemovedRock) {
|
||||
FixTile(MapFieldRocks, 1, pos);
|
||||
} else if (mf.RockOnMap()) {
|
||||
FixTile(MapFieldRocks, 1, pos);
|
||||
|
|
@ -675,11 +675,11 @@ void CMap::RegenerateForestTile(const Vec2i &pos)
|
|||
&& topMf.Value >= ForestRegeneration
|
||||
&& !(topMf.Flags & occupedFlag)) {
|
||||
DebugPrint("Real place wood\n");
|
||||
topMf.Tile = this->Tileset->TopOneTree;
|
||||
topMf.Tile = this->Tileset->getTopOneTreeTile();
|
||||
topMf.Value = 0;
|
||||
topMf.Flags |= MapFieldForest | MapFieldUnpassable;
|
||||
|
||||
mf.Tile = this->Tileset->BotOneTree;
|
||||
mf.Tile = this->Tileset->getBottomOneTreeTile();
|
||||
mf.Value = 0;
|
||||
mf.Flags |= MapFieldForest | MapFieldUnpassable;
|
||||
if (mf.playerInfo.IsTeamVisible(*ThisPlayer)) {
|
||||
|
|
|
|||
|
|
@ -42,14 +42,6 @@
|
|||
#include "player.h"
|
||||
#include "unittype.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
-- Declarations
|
||||
----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
-- Variables
|
||||
----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
-- Functions
|
||||
----------------------------------------------------------------------------*/
|
||||
|
|
|
|||
|
|
@ -39,6 +39,8 @@
|
|||
|
||||
#include "map.h"
|
||||
#include "script.h"
|
||||
#include "ui.h"
|
||||
#include "video.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
-- Functions
|
||||
|
|
@ -58,27 +60,6 @@ static void ExtendTilesetTables(CTileset *tileset, unsigned int oldtiles, unsign
|
|||
tileset->Tiles.resize(oldtiles + newtiles);
|
||||
}
|
||||
|
||||
/**
|
||||
** Parse the name field in tileset definition.
|
||||
**
|
||||
** @param l Lua state.
|
||||
** @param tileset Tileset currently parsed.
|
||||
*/
|
||||
static int TilesetParseName(lua_State *l, CTileset *tileset)
|
||||
{
|
||||
const char *ident = LuaToString(l, -1);
|
||||
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;
|
||||
s.TerrainName = ident;
|
||||
tileset->SolidTerrainTypes.push_back(s);
|
||||
return tileset->SolidTerrainTypes.size() - 1;
|
||||
}
|
||||
|
||||
/**
|
||||
** Parse the flag section of a tile definition.
|
||||
**
|
||||
|
|
@ -150,9 +131,8 @@ static void ParseTilesetTileFlags(lua_State *l, int *back, int *j)
|
|||
** Parse the special slot part of a tileset definition
|
||||
**
|
||||
** @param l Lua state.
|
||||
** @param tileset Tileset to be filled.
|
||||
*/
|
||||
static void DefineTilesetParseSpecial(lua_State *l, CTileset *tileset)
|
||||
void CTileset::parseSpecial(lua_State *l)
|
||||
{
|
||||
if (!lua_istable(l, -1)) {
|
||||
LuaError(l, "incorrect argument");
|
||||
|
|
@ -167,22 +147,22 @@ static void DefineTilesetParseSpecial(lua_State *l, CTileset *tileset)
|
|||
if (!strcmp(value, "top-one-tree")) {
|
||||
++j;
|
||||
lua_rawgeti(l, -1, j + 1);
|
||||
tileset->TopOneTree = LuaToNumber(l, -1);
|
||||
TopOneTree = LuaToNumber(l, -1);
|
||||
lua_pop(l, 1);
|
||||
} else if (!strcmp(value, "mid-one-tree")) {
|
||||
++j;
|
||||
lua_rawgeti(l, -1, j + 1);
|
||||
tileset->MidOneTree = LuaToNumber(l, -1);
|
||||
MidOneTree = LuaToNumber(l, -1);
|
||||
lua_pop(l, 1);
|
||||
} else if (!strcmp(value, "bot-one-tree")) {
|
||||
++j;
|
||||
lua_rawgeti(l, -1, j + 1);
|
||||
tileset->BotOneTree = LuaToNumber(l, -1);
|
||||
BotOneTree = LuaToNumber(l, -1);
|
||||
lua_pop(l, 1);
|
||||
} else if (!strcmp(value, "removed-tree")) {
|
||||
++j;
|
||||
lua_rawgeti(l, -1, j + 1);
|
||||
tileset->RemovedTree = LuaToNumber(l, -1);
|
||||
RemovedTree = LuaToNumber(l, -1);
|
||||
lua_pop(l, 1);
|
||||
} else if (!strcmp(value, "growing-tree")) {
|
||||
++j;
|
||||
|
|
@ -195,29 +175,29 @@ static void DefineTilesetParseSpecial(lua_State *l, CTileset *tileset)
|
|||
}
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
lua_rawgeti(l, -1, i + 1);
|
||||
tileset->GrowingTree[i] = LuaToNumber(l, -1);
|
||||
GrowingTree[i] = LuaToNumber(l, -1);
|
||||
lua_pop(l, 1);
|
||||
}
|
||||
lua_pop(l, 1);
|
||||
} else if (!strcmp(value, "top-one-rock")) {
|
||||
++j;
|
||||
lua_rawgeti(l, -1, j + 1);
|
||||
tileset->TopOneRock = LuaToNumber(l, -1);
|
||||
TopOneRock = LuaToNumber(l, -1);
|
||||
lua_pop(l, 1);
|
||||
} else if (!strcmp(value, "mid-one-rock")) {
|
||||
++j;
|
||||
lua_rawgeti(l, -1, j + 1);
|
||||
tileset->MidOneRock = LuaToNumber(l, -1);
|
||||
MidOneRock = LuaToNumber(l, -1);
|
||||
lua_pop(l, 1);
|
||||
} else if (!strcmp(value, "bot-one-rock")) {
|
||||
++j;
|
||||
lua_rawgeti(l, -1, j + 1);
|
||||
tileset->BotOneRock = LuaToNumber(l, -1);
|
||||
BotOneRock = LuaToNumber(l, -1);
|
||||
lua_pop(l, 1);
|
||||
} else if (!strcmp(value, "removed-rock")) {
|
||||
++j;
|
||||
lua_rawgeti(l, -1, j + 1);
|
||||
tileset->RemovedRock = LuaToNumber(l, -1);
|
||||
RemovedRock = LuaToNumber(l, -1);
|
||||
lua_pop(l, 1);
|
||||
} else {
|
||||
LuaError(l, "special: unsupported tag: %s" _C_ value);
|
||||
|
|
@ -245,7 +225,7 @@ static int DefineTilesetParseSolid(lua_State *l, CTileset *tileset, int index)
|
|||
|
||||
lua_rawgeti(l, -1, j + 1);
|
||||
++j;
|
||||
const int basic_name = TilesetParseName(l, tileset);
|
||||
const int basic_name = tileset->getOrAddSolidTileIndexByName(LuaToString(l, -1));
|
||||
lua_pop(l, 1);
|
||||
|
||||
ParseTilesetTileFlags(l, &f, &j);
|
||||
|
|
@ -319,11 +299,11 @@ static int DefineTilesetParseMixed(lua_State *l, CTileset *tileset, int index)
|
|||
const int args = lua_rawlen(l, -1);
|
||||
lua_rawgeti(l, -1, j + 1);
|
||||
++j;
|
||||
const int basic_name = TilesetParseName(l, tileset);
|
||||
const int basic_name = tileset->getOrAddSolidTileIndexByName(LuaToString(l, -1));;
|
||||
lua_pop(l, 1);
|
||||
lua_rawgeti(l, -1, j + 1);
|
||||
++j;
|
||||
const int mixed_name = TilesetParseName(l, tileset);
|
||||
const int mixed_name = tileset->getOrAddSolidTileIndexByName(LuaToString(l, -1));;
|
||||
lua_pop(l, 1);
|
||||
|
||||
ParseTilesetTileFlags(l, &f, &j);
|
||||
|
|
@ -392,7 +372,7 @@ static void DefineTilesetParseSlot(lua_State *l, CTileset *tileset, int t)
|
|||
|
||||
if (!strcmp(value, "special")) {
|
||||
lua_rawgeti(l, t, j + 1);
|
||||
DefineTilesetParseSpecial(l, tileset);
|
||||
tileset->parseSpecial(l);
|
||||
lua_pop(l, 1);
|
||||
} else if (!strcmp(value, "solid")) {
|
||||
lua_rawgeti(l, t, j + 1);
|
||||
|
|
@ -416,10 +396,25 @@ static void DefineTilesetParseSlot(lua_State *l, CTileset *tileset, int t)
|
|||
*/
|
||||
static int CclDefineTileset(lua_State *l)
|
||||
{
|
||||
Map.Tileset->Clear();
|
||||
Map.Tileset->parse(l);
|
||||
|
||||
Map.Tileset->PixelTileSize.x = 32;
|
||||
Map.Tileset->PixelTileSize.y = 32;
|
||||
// Load and prepare the tileset
|
||||
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);
|
||||
Map.TileGraphic->Load();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void CTileset::parse(lua_State *l)
|
||||
{
|
||||
Clear();
|
||||
|
||||
this->PixelTileSize.x = 32;
|
||||
this->PixelTileSize.y = 32;
|
||||
|
||||
const int args = lua_gettop(l);
|
||||
for (int j = 1; j < args; ++j) {
|
||||
|
|
@ -427,36 +422,34 @@ static int CclDefineTileset(lua_State *l)
|
|||
++j;
|
||||
|
||||
if (!strcmp(value, "name")) {
|
||||
Map.Tileset->Name = LuaToString(l, j);
|
||||
this->Name = LuaToString(l, j);
|
||||
} else if (!strcmp(value, "image")) {
|
||||
Map.Tileset->ImageFile = LuaToString(l, j);
|
||||
this->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);
|
||||
this->PixelTileSize.x = LuaToNumber(l, -1);
|
||||
lua_pop(l, 1);
|
||||
lua_rawgeti(l, j, 2);
|
||||
Map.Tileset->PixelTileSize.y = LuaToNumber(l, -1);
|
||||
this->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, this, j);
|
||||
} else {
|
||||
LuaError(l, "Unsupported tag: %s" _C_ value);
|
||||
}
|
||||
}
|
||||
LoadTileset();
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
** Build tileset tables like HumanWallTable or MixedLookupTable
|
||||
**
|
||||
** Called after LoadTileset and only for tilesets that have wall,
|
||||
** Called after DefineTileset and only for tilesets that have wall,
|
||||
** trees and rocks. This function will be deleted when removing
|
||||
** support of walls and alike in the tileset.
|
||||
*/
|
||||
|
|
@ -464,104 +457,103 @@ static int CclBuildTilesetTables(lua_State *l)
|
|||
{
|
||||
LuaCheckArgs(l, 0);
|
||||
|
||||
CTileset &tileset = *Map.Tileset;
|
||||
Map.Tileset->buildTable(l);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void CTileset::buildTable(lua_State *l)
|
||||
{
|
||||
// Calculate number of tiles in graphic tile
|
||||
int n = tileset.NumTiles;
|
||||
|
||||
tileset.MixedLookupTable.resize(n, 0);
|
||||
const int n = NumTiles;
|
||||
|
||||
MixedLookupTable.resize(n, 0);
|
||||
// Build the TileTypeTable
|
||||
tileset.TileTypeTable.resize(n, 0);
|
||||
TileTypeTable.resize(n, 0);
|
||||
|
||||
const std::vector<unsigned short> &table = tileset.Table;
|
||||
int tile;
|
||||
const std::vector<unsigned short> &table = Table;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
if ((tile = table[i])) {
|
||||
unsigned flags;
|
||||
const int tile = table[i];
|
||||
if (tile == 0) {
|
||||
continue;
|
||||
}
|
||||
//Initialize all Lookup Items to zero
|
||||
MixedLookupTable[tile] = 0;
|
||||
|
||||
//Initialize all Lookup Items to zero
|
||||
tileset.MixedLookupTable[table[i]] = 0;
|
||||
|
||||
flags = tileset.FlagsTable[i];
|
||||
if (flags & MapFieldWaterAllowed) {
|
||||
tileset.TileTypeTable[tile] = TileTypeWater;
|
||||
} else if (flags & MapFieldCoastAllowed) {
|
||||
tileset.TileTypeTable[tile] = TileTypeCoast;
|
||||
} else if (flags & MapFieldWall) {
|
||||
if (flags & MapFieldHuman) {
|
||||
tileset.TileTypeTable[tile] = TileTypeHumanWall;
|
||||
} else {
|
||||
tileset.TileTypeTable[tile] = TileTypeOrcWall;
|
||||
}
|
||||
} else if (flags & MapFieldRocks) {
|
||||
tileset.TileTypeTable[tile] = TileTypeRock;
|
||||
} else if (flags & MapFieldForest) {
|
||||
tileset.TileTypeTable[tile] = TileTypeWood;
|
||||
unsigned flags = FlagsTable[i];
|
||||
if (flags & MapFieldWaterAllowed) {
|
||||
TileTypeTable[tile] = TileTypeWater;
|
||||
} else if (flags & MapFieldCoastAllowed) {
|
||||
TileTypeTable[tile] = TileTypeCoast;
|
||||
} else if (flags & MapFieldWall) {
|
||||
if (flags & MapFieldHuman) {
|
||||
TileTypeTable[tile] = TileTypeHumanWall;
|
||||
} else {
|
||||
TileTypeTable[tile] = TileTypeOrcWall;
|
||||
}
|
||||
} else if (flags & MapFieldRocks) {
|
||||
TileTypeTable[tile] = TileTypeRock;
|
||||
} else if (flags & MapFieldForest) {
|
||||
TileTypeTable[tile] = TileTypeWood;
|
||||
}
|
||||
}
|
||||
|
||||
// mark the special tiles
|
||||
if ((tile = tileset.TopOneTree)) {
|
||||
tileset.TileTypeTable[tile] = TileTypeWood;
|
||||
if (TopOneTree) {
|
||||
TileTypeTable[TopOneTree] = TileTypeWood;
|
||||
}
|
||||
if ((tile = tileset.MidOneTree)) {
|
||||
tileset.TileTypeTable[tile] = TileTypeWood;
|
||||
if (MidOneTree) {
|
||||
TileTypeTable[MidOneTree] = TileTypeWood;
|
||||
}
|
||||
if ((tile = tileset.BotOneTree)) {
|
||||
tileset.TileTypeTable[tile] = TileTypeWood;
|
||||
if (BotOneTree) {
|
||||
TileTypeTable[BotOneTree] = TileTypeWood;
|
||||
}
|
||||
if ((tile = tileset.TopOneRock)) {
|
||||
tileset.TileTypeTable[tile] = TileTypeRock;
|
||||
if (TopOneRock) {
|
||||
TileTypeTable[TopOneRock] = TileTypeRock;
|
||||
}
|
||||
if ((tile = tileset.MidOneRock)) {
|
||||
tileset.TileTypeTable[tile] = TileTypeRock;
|
||||
if (MidOneRock) {
|
||||
TileTypeTable[MidOneRock] = TileTypeRock;
|
||||
}
|
||||
if ((tile = tileset.BotOneRock)) {
|
||||
tileset.TileTypeTable[tile] = TileTypeRock;
|
||||
if (BotOneRock) {
|
||||
TileTypeTable[BotOneRock] = TileTypeRock;
|
||||
}
|
||||
|
||||
// Build wood removement table.
|
||||
int solid = 0;
|
||||
int mixed = 0;
|
||||
n = tileset.NumTiles;
|
||||
for (int i = 0; i < n;) {
|
||||
if (tileset.Tiles[i].BaseTerrain
|
||||
&& tileset.Tiles[i].MixTerrain) {
|
||||
if (tileset.FlagsTable[i] & MapFieldForest) {
|
||||
if (Tiles[i].BaseTerrain && Tiles[i].MixTerrain) {
|
||||
if (FlagsTable[i] & MapFieldForest) {
|
||||
mixed = i;
|
||||
}
|
||||
i += 256;
|
||||
} else {
|
||||
if (tileset.Tiles[i].BaseTerrain != 0 &&
|
||||
tileset.Tiles[i].MixTerrain == 0) {
|
||||
if (tileset.FlagsTable[i] & MapFieldForest) {
|
||||
if (Tiles[i].BaseTerrain != 0 && Tiles[i].MixTerrain == 0) {
|
||||
if (FlagsTable[i] & MapFieldForest) {
|
||||
solid = i;
|
||||
}
|
||||
}
|
||||
i += 16;
|
||||
}
|
||||
}
|
||||
tileset.WoodTable[ 0] = -1;
|
||||
tileset.WoodTable[ 1] = table[mixed + 0x30];
|
||||
tileset.WoodTable[ 2] = table[mixed + 0x70];
|
||||
tileset.WoodTable[ 3] = table[mixed + 0xB0];
|
||||
tileset.WoodTable[ 4] = table[mixed + 0x10];
|
||||
tileset.WoodTable[ 5] = table[mixed + 0x50];
|
||||
tileset.WoodTable[ 6] = table[mixed + 0x90];
|
||||
tileset.WoodTable[ 7] = table[mixed + 0xD0];
|
||||
tileset.WoodTable[ 8] = table[mixed + 0x00];
|
||||
tileset.WoodTable[ 9] = table[mixed + 0x40];
|
||||
tileset.WoodTable[10] = table[mixed + 0x80];
|
||||
tileset.WoodTable[11] = table[mixed + 0xC0];
|
||||
tileset.WoodTable[12] = table[mixed + 0x20];
|
||||
tileset.WoodTable[13] = table[mixed + 0x60];
|
||||
tileset.WoodTable[14] = table[mixed + 0xA0];
|
||||
tileset.WoodTable[15] = table[solid];
|
||||
tileset.WoodTable[16] = -1;
|
||||
tileset.WoodTable[17] = tileset.BotOneTree;
|
||||
tileset.WoodTable[18] = tileset.TopOneTree;
|
||||
tileset.WoodTable[19] = tileset.MidOneTree;
|
||||
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[16] = -1;
|
||||
WoodTable[17] = BotOneTree;
|
||||
WoodTable[18] = TopOneTree;
|
||||
WoodTable[19] = MidOneTree;
|
||||
|
||||
//Mark which corners of each tile has tree in it.
|
||||
//All corners for solid tiles. (Same for rocks)
|
||||
|
|
@ -572,81 +564,48 @@ static int CclBuildTilesetTables(lua_State *l)
|
|||
//16 Bottom Tree Tile
|
||||
//32 Top Tree Tile
|
||||
for (int i = solid; i < solid + 16; ++i) {
|
||||
tileset.MixedLookupTable[table[i]] = 15;
|
||||
MixedLookupTable[table[i]] = 15;
|
||||
}
|
||||
for (int i = mixed; i < mixed + 256; ++i) {
|
||||
int check;
|
||||
int check = (int)((i - mixed) / 16);
|
||||
|
||||
check = (int)((i - mixed) / 16);
|
||||
switch (check) {
|
||||
case 0:
|
||||
tileset.MixedLookupTable[table[i]] = 8;
|
||||
break;
|
||||
case 1:
|
||||
tileset.MixedLookupTable[table[i]] = 4;
|
||||
break;
|
||||
case 2:
|
||||
tileset.MixedLookupTable[table[i]] = 8 + 4;
|
||||
break;
|
||||
case 3:
|
||||
tileset.MixedLookupTable[table[i]] = 1;
|
||||
break;
|
||||
case 4:
|
||||
tileset.MixedLookupTable[table[i]] = 8 + 1;
|
||||
break;
|
||||
case 5:
|
||||
tileset.MixedLookupTable[table[i]] = 4 + 1;
|
||||
break;
|
||||
case 6:
|
||||
tileset.MixedLookupTable[table[i]] = 8 + 4 + 1;
|
||||
break;
|
||||
case 7:
|
||||
tileset.MixedLookupTable[table[i]] = 2;
|
||||
break;
|
||||
case 8:
|
||||
tileset.MixedLookupTable[table[i]] = 8 + 2;
|
||||
break;
|
||||
case 9:
|
||||
tileset.MixedLookupTable[table[i]] = 4 + 2;
|
||||
break;
|
||||
case 10:
|
||||
tileset.MixedLookupTable[table[i]] = 8 + 4 + 2;
|
||||
break;
|
||||
case 11:
|
||||
tileset.MixedLookupTable[table[i]] = 2 + 1;
|
||||
break;
|
||||
case 12:
|
||||
tileset.MixedLookupTable[table[i]] = 8 + 2 + 1;
|
||||
break;
|
||||
case 13:
|
||||
tileset.MixedLookupTable[table[i]] = 4 + 2 + 1;
|
||||
break;
|
||||
default:
|
||||
tileset.MixedLookupTable[table[i]] = 0;
|
||||
break;
|
||||
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;
|
||||
}
|
||||
}
|
||||
//16 Bottom Tree Special
|
||||
//32 Top Tree Special
|
||||
//64 Mid tree special - differentiate with mixed tiles.
|
||||
tileset.MixedLookupTable[tileset.BotOneTree] = 12 + 16;
|
||||
tileset.MixedLookupTable[tileset.TopOneTree] = 3 + 32;
|
||||
tileset.MixedLookupTable[tileset.MidOneTree] = 15 + 48;
|
||||
MixedLookupTable[BotOneTree] = 12 + 16;
|
||||
MixedLookupTable[TopOneTree] = 3 + 32;
|
||||
MixedLookupTable[MidOneTree] = 15 + 48;
|
||||
|
||||
// Build rock removement table.
|
||||
mixed = 0;
|
||||
solid = 0;
|
||||
for (int i = 0; i < n;) {
|
||||
if (tileset.Tiles[i].BaseTerrain
|
||||
&& tileset.Tiles[i].MixTerrain) {
|
||||
if (tileset.FlagsTable[i] & MapFieldRocks) {
|
||||
if (Tiles[i].BaseTerrain && Tiles[i].MixTerrain) {
|
||||
if (FlagsTable[i] & MapFieldRocks) {
|
||||
mixed = i;
|
||||
}
|
||||
i += 256;
|
||||
} else {
|
||||
if (tileset.Tiles[i].BaseTerrain != 0 &&
|
||||
tileset.Tiles[i].MixTerrain == 0) {
|
||||
if (tileset.FlagsTable[i] & MapFieldRocks) {
|
||||
if (Tiles[i].BaseTerrain != 0 && Tiles[i].MixTerrain == 0) {
|
||||
if (FlagsTable[i] & MapFieldRocks) {
|
||||
solid = i;
|
||||
}
|
||||
}
|
||||
|
|
@ -661,146 +620,120 @@ static int CclBuildTilesetTables(lua_State *l)
|
|||
//4 Top Right
|
||||
//8 Top Left
|
||||
for (int i = solid; i < solid + 16; ++i) {
|
||||
tileset.MixedLookupTable[table[i]] = 15;
|
||||
MixedLookupTable[table[i]] = 15;
|
||||
}
|
||||
for (int i = mixed; i < mixed + 256; ++i) {
|
||||
int check = (int)((i - mixed) / 16);
|
||||
switch (check) {
|
||||
case 0:
|
||||
tileset.MixedLookupTable[table[i]] = 8;
|
||||
break;
|
||||
case 1:
|
||||
tileset.MixedLookupTable[table[i]] = 4;
|
||||
break;
|
||||
case 2:
|
||||
tileset.MixedLookupTable[table[i]] = 8 + 4;
|
||||
break;
|
||||
case 3:
|
||||
tileset.MixedLookupTable[table[i]] = 1;
|
||||
break;
|
||||
case 4:
|
||||
tileset.MixedLookupTable[table[i]] = 8 + 1;
|
||||
break;
|
||||
case 5:
|
||||
tileset.MixedLookupTable[table[i]] = 4 + 1;
|
||||
break;
|
||||
case 6:
|
||||
tileset.MixedLookupTable[table[i]] = 8 + 4 + 1;
|
||||
break;
|
||||
case 7:
|
||||
tileset.MixedLookupTable[table[i]] = 2;
|
||||
break;
|
||||
case 8:
|
||||
tileset.MixedLookupTable[table[i]] = 8 + 2;
|
||||
break;
|
||||
case 9:
|
||||
tileset.MixedLookupTable[table[i]] = 4 + 2;
|
||||
break;
|
||||
case 10:
|
||||
tileset.MixedLookupTable[table[i]] = 8 + 4 + 2;
|
||||
break;
|
||||
case 11:
|
||||
tileset.MixedLookupTable[table[i]] = 2 + 1;
|
||||
break;
|
||||
case 12:
|
||||
tileset.MixedLookupTable[table[i]] = 8 + 2 + 1;
|
||||
break;
|
||||
case 13:
|
||||
tileset.MixedLookupTable[table[i]] = 4 + 2 + 1;
|
||||
break;
|
||||
default:
|
||||
tileset.MixedLookupTable[table[i]] = 0;
|
||||
break;
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
tileset.MixedLookupTable[tileset.BotOneRock] = 12 + 16;
|
||||
tileset.MixedLookupTable[tileset.TopOneRock] = 3 + 32;
|
||||
tileset.MixedLookupTable[tileset.MidOneRock] = 15 + 48;
|
||||
MixedLookupTable[BotOneRock] = 12 + 16;
|
||||
MixedLookupTable[TopOneRock] = 3 + 32;
|
||||
MixedLookupTable[MidOneRock] = 15 + 48;
|
||||
|
||||
tileset.RockTable[ 0] = -1;
|
||||
tileset.RockTable[ 1] = table[mixed + 0x30];
|
||||
tileset.RockTable[ 2] = table[mixed + 0x70];
|
||||
tileset.RockTable[ 3] = table[mixed + 0xB0];
|
||||
tileset.RockTable[ 4] = table[mixed + 0x10];
|
||||
tileset.RockTable[ 5] = table[mixed + 0x50];
|
||||
tileset.RockTable[ 6] = table[mixed + 0x90];
|
||||
tileset.RockTable[ 7] = table[mixed + 0xD0];
|
||||
tileset.RockTable[ 8] = table[mixed + 0x00];
|
||||
tileset.RockTable[ 9] = table[mixed + 0x40];
|
||||
tileset.RockTable[10] = table[mixed + 0x80];
|
||||
tileset.RockTable[11] = table[mixed + 0xC0];
|
||||
tileset.RockTable[12] = table[mixed + 0x20];
|
||||
tileset.RockTable[13] = table[mixed + 0x60];
|
||||
tileset.RockTable[14] = table[mixed + 0xA0];
|
||||
tileset.RockTable[15] = table[solid];
|
||||
tileset.RockTable[16] = -1;
|
||||
tileset.RockTable[17] = tileset.BotOneRock;
|
||||
tileset.RockTable[18] = tileset.TopOneRock;
|
||||
tileset.RockTable[19] = tileset.MidOneRock;
|
||||
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[16] = -1;
|
||||
RockTable[17] = BotOneRock;
|
||||
RockTable[18] = TopOneRock;
|
||||
RockTable[19] = MidOneRock;
|
||||
|
||||
buildWallReplacementTable();
|
||||
}
|
||||
|
||||
void CTileset::buildWallReplacementTable()
|
||||
{
|
||||
// FIXME: Build wall replacement tables
|
||||
tileset.HumanWallTable[ 0] = 0x090;
|
||||
tileset.HumanWallTable[ 1] = 0x830;
|
||||
tileset.HumanWallTable[ 2] = 0x810;
|
||||
tileset.HumanWallTable[ 3] = 0x850;
|
||||
tileset.HumanWallTable[ 4] = 0x800;
|
||||
tileset.HumanWallTable[ 5] = 0x840;
|
||||
tileset.HumanWallTable[ 6] = 0x820;
|
||||
tileset.HumanWallTable[ 7] = 0x860;
|
||||
tileset.HumanWallTable[ 8] = 0x870;
|
||||
tileset.HumanWallTable[ 9] = 0x8B0;
|
||||
tileset.HumanWallTable[10] = 0x890;
|
||||
tileset.HumanWallTable[11] = 0x8D0;
|
||||
tileset.HumanWallTable[12] = 0x880;
|
||||
tileset.HumanWallTable[13] = 0x8C0;
|
||||
tileset.HumanWallTable[14] = 0x8A0;
|
||||
tileset.HumanWallTable[15] = 0x0B0;
|
||||
HumanWallTable[ 0] = 0x090;
|
||||
HumanWallTable[ 1] = 0x830;
|
||||
HumanWallTable[ 2] = 0x810;
|
||||
HumanWallTable[ 3] = 0x850;
|
||||
HumanWallTable[ 4] = 0x800;
|
||||
HumanWallTable[ 5] = 0x840;
|
||||
HumanWallTable[ 6] = 0x820;
|
||||
HumanWallTable[ 7] = 0x860;
|
||||
HumanWallTable[ 8] = 0x870;
|
||||
HumanWallTable[ 9] = 0x8B0;
|
||||
HumanWallTable[10] = 0x890;
|
||||
HumanWallTable[11] = 0x8D0;
|
||||
HumanWallTable[12] = 0x880;
|
||||
HumanWallTable[13] = 0x8C0;
|
||||
HumanWallTable[14] = 0x8A0;
|
||||
HumanWallTable[15] = 0x0B0;
|
||||
|
||||
tileset.OrcWallTable[ 0] = 0x0A0;
|
||||
tileset.OrcWallTable[ 1] = 0x930;
|
||||
tileset.OrcWallTable[ 2] = 0x910;
|
||||
tileset.OrcWallTable[ 3] = 0x950;
|
||||
tileset.OrcWallTable[ 4] = 0x900;
|
||||
tileset.OrcWallTable[ 5] = 0x940;
|
||||
tileset.OrcWallTable[ 6] = 0x920;
|
||||
tileset.OrcWallTable[ 7] = 0x960;
|
||||
tileset.OrcWallTable[ 8] = 0x970;
|
||||
tileset.OrcWallTable[ 9] = 0x9B0;
|
||||
tileset.OrcWallTable[10] = 0x990;
|
||||
tileset.OrcWallTable[11] = 0x9D0;
|
||||
tileset.OrcWallTable[12] = 0x980;
|
||||
tileset.OrcWallTable[13] = 0x9C0;
|
||||
tileset.OrcWallTable[14] = 0x9A0;
|
||||
tileset.OrcWallTable[15] = 0x0C0;
|
||||
OrcWallTable[ 0] = 0x0A0;
|
||||
OrcWallTable[ 1] = 0x930;
|
||||
OrcWallTable[ 2] = 0x910;
|
||||
OrcWallTable[ 3] = 0x950;
|
||||
OrcWallTable[ 4] = 0x900;
|
||||
OrcWallTable[ 5] = 0x940;
|
||||
OrcWallTable[ 6] = 0x920;
|
||||
OrcWallTable[ 7] = 0x960;
|
||||
OrcWallTable[ 8] = 0x970;
|
||||
OrcWallTable[ 9] = 0x9B0;
|
||||
OrcWallTable[10] = 0x990;
|
||||
OrcWallTable[11] = 0x9D0;
|
||||
OrcWallTable[12] = 0x980;
|
||||
OrcWallTable[13] = 0x9C0;
|
||||
OrcWallTable[14] = 0x9A0;
|
||||
OrcWallTable[15] = 0x0C0;
|
||||
|
||||
// Set destroyed walls to TileTypeUnknown
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
n = 0;
|
||||
tile = tileset.HumanWallTable[i];
|
||||
while (tileset.Table[tile]) { // Skip good tiles
|
||||
int n = 0;
|
||||
unsigned int tile = HumanWallTable[i];
|
||||
while (Table[tile]) { // Skip good tiles
|
||||
++tile;
|
||||
++n;
|
||||
}
|
||||
while (!tileset.Table[tile]) { // Skip separator
|
||||
while (!Table[tile]) { // Skip separator
|
||||
++tile;
|
||||
++n;
|
||||
}
|
||||
while (tileset.Table[tile]) { // Skip good tiles
|
||||
while (Table[tile]) { // Skip good tiles
|
||||
++tile;
|
||||
++n;
|
||||
}
|
||||
while (!tileset.Table[tile]) { // Skip separator
|
||||
while (!Table[tile]) { // Skip separator
|
||||
++tile;
|
||||
++n;
|
||||
}
|
||||
while (n < 16 && tileset.Table[tile]) {
|
||||
tileset.TileTypeTable[tileset.Table[tile]] = TileTypeUnknown;
|
||||
while (n < 16 && Table[tile]) {
|
||||
TileTypeTable[Table[tile]] = TileTypeUnknown;
|
||||
++tile;
|
||||
++n;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -203,7 +203,6 @@
|
|||
#include "tileset.h"
|
||||
|
||||
#include "map.h"
|
||||
#include "ui.h"
|
||||
#include "video.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
|
|
@ -220,23 +219,6 @@ PixelSize PixelTileSize(32, 32);
|
|||
-- Functions
|
||||
----------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
** Load tileset and setup ::Map for this tileset.
|
||||
**
|
||||
** @see Map @see Map.Tileset.
|
||||
*/
|
||||
void LoadTileset()
|
||||
{
|
||||
// Load and prepare the tileset
|
||||
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);
|
||||
Map.TileGraphic->Load();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
** Cleanup the tileset module.
|
||||
**
|
||||
|
|
@ -246,9 +228,7 @@ void CleanTilesets()
|
|||
{
|
||||
Map.Tileset->Clear();
|
||||
|
||||
//
|
||||
// Should this be done by the map?
|
||||
//
|
||||
CGraphic::Free(Map.TileGraphic);
|
||||
Map.TileGraphic = NULL;
|
||||
}
|
||||
|
|
@ -295,6 +275,20 @@ bool CTileset::IsSeenTile(unsigned short type, unsigned short seen) const
|
|||
return false;
|
||||
}
|
||||
|
||||
unsigned int CTileset::getOrAddSolidTileIndexByName(const std::string &name)
|
||||
{
|
||||
for (size_t i = 0; i != SolidTerrainTypes.size(); ++i) {
|
||||
if (SolidTerrainTypes[i].TerrainName == name) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
// Can't find it, then we add another solid terrain type.
|
||||
SolidTerrainInfo s;
|
||||
s.TerrainName = name;
|
||||
SolidTerrainTypes.push_back(s);
|
||||
return SolidTerrainTypes.size() - 1;
|
||||
}
|
||||
|
||||
unsigned CTileset::getHumanWallTile(int index) const
|
||||
{
|
||||
unsigned tile = HumanWallTable[index];
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue