Clean up tileset.
This commit is contained in:
parent
ac760fba42
commit
f48eb02fa5
27 changed files with 553 additions and 561 deletions
src
action
editor
game
include
map
sound
tolua
ui
unit
|
@ -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"
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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__
|
||||
|
|
|
@ -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;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
|
|
|
@ -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)) {
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
//@}
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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"
|
||||
|
|
Loading…
Add table
Reference in a new issue