{

static struct SerializationKey

{

// how many bytes to store for each variable or each member of array of the same name

Uint8 index; // for indexing the actual tile array

Uint8 _mapDataSetID;

Uint8 _mapDataID;

Uint8 _smoke;

Uint8 _fire;

Uint8 boolFields;

Uint32 totalBytes; // per structure, including any data not mentioned here and accounting for all array members!

} serializationKey;

static const int NOT_CALCULATED = -1;

static const int LIGHTLAYERS = 3;

MapData *_objects[4];

int _mapDataID[4];

int _mapDataSetID[4];

int _currentFrame[4];

bool _discovered[3];

int _light[LIGHTLAYERS], _lastLight[LIGHTLAYERS];

int _smoke;

int _fire;

int _explosive;

int _explosiveType;

Position _pos;

BattleUnit *_unit;

std::vector<BattleItem *> _inventory;

int _animationOffset;

int _markerColor;

int _visible;

int _preview;

int _TUMarker;

int _overlaps;

bool _danger;

std::list<Particle*> _particles;

int _obstacle;

/// Creates a tile.

Tile(Position pos);

/// Cleans up a tile.

~Tile();

/// Load the tile from yaml

void load(const YAML::Node &node);

/// Load the tile from binary buffer in memory

void loadBinary(Uint8 *buffer, Tile::SerializationKey& serializationKey);

/// Saves the tile to yaml

YAML::Node save() const;

/// Saves the tile to binary

void saveBinary(Uint8** buffer) const;

/**

MapData *getMapData(TilePart part) const

{

return _objects[part];

}

/// Sets the pointer to the mapdata for a specific part of the tile

void setMapData(MapData *dat, int mapDataID, int mapDataSetID, TilePart part);

/// Gets the IDs to the mapdata for a specific part of the tile

void getMapData(int *mapDataID, int *mapDataSetID, TilePart part) const;

/// Gets whether this tile has no objects

bool isVoid() const;

/// Get the TU cost to walk over a certain part of the tile.

int getTUCost(int part, MovementType movementType) const;

/// Checks if this tile has a floor.

bool hasNoFloor(Tile *tileBelow) const;

/// Checks if this tile is a big wall.

bool isBigWall() const;

/// Get terrain level.

int getTerrainLevel() const;

/**

Position getPosition() const

{

return _pos;

}

/// Gets the floor object footstep sound.

int getFootstepSound(Tile *tileBelow) const;

/// Open a door, returns the ID, 0(normal), 1(ufo) or -1 if no door opened.

int openDoor(TilePart part, BattleUnit *unit = 0, BattleActionType reserve = BA_NONE);

/**

bool isUfoDoorOpen(TilePart tp) const

{

int part = (int)tp;

return (_objects[part] && _objects[part]->isUFODoor() && _currentFrame[part] != 0);

}

/// Close ufo door.

int closeUfoDoor();

/// Sets the black fog of war status of this tile.

void setDiscovered(bool flag, int part);

/// Gets the black fog of war status of this tile.

bool isDiscovered(int part) const;

/// Reset light to zero for this tile.

void resetLight(int layer);

/// Add light to this tile.

void addLight(int light, int layer);

/// Get the shade amount.

int getShade() const;

/// Destroy a tile part.

bool destroy(TilePart part, SpecialTileType type);

/// Damage a tile part.

bool damage(TilePart part, int power, SpecialTileType type);

/// Set a "virtual" explosive on this tile, to detonate later.

void setExplosive(int power, int damageType, bool force = false);

/// Get explosive power of this tile.

int getExplosive() const;

/// Get explosive power of this tile.

int getExplosiveType() const;

/// Animated the tile parts.

void animate();

/// Get object sprites.

Surface *getSprite(int part) const;

/// Set a unit on this tile.

void setUnit(BattleUnit *unit, Tile *tileBelow = 0);

/**

BattleUnit *getUnit() const

{

return _unit;

}

/// Set fire, does not increment overlaps.

void setFire(int fire);

/// Get fire.

int getFire() const;

/// Add smoke, increments overlap.

void addSmoke(int smoke);

/// Set smoke, does not increment overlaps.

void setSmoke(int smoke);

/// Get smoke.

int getSmoke() const;

/// Get flammability.

int getFlammability() const;

/// Get turns to burn

int getFuel() const;

/// Get flammability of part.

int getFlammability(TilePart part) const;

/// Get turns to burn of part

int getFuel(TilePart part) const;

/// attempt to set the tile on fire, sets overlaps to one if successful.

void ignite(int power);

/// Get fire and smoke animation offset.

int getAnimationOffset() const;

/// Add item

void addItem(BattleItem *item, RuleInventory *ground);

/// Remove item

void removeItem(BattleItem *item);

/// Get top-most item

int getTopItemSprite();

/// New turn preparations.

void prepareNewTurn(bool smokeDamage);

/// Get inventory on this tile.

std::vector<BattleItem *> *getInventory();

/// Set the tile marker color.

void setMarkerColor(int color);

/// Get the tile marker color.

int getMarkerColor() const;

/// Set the tile visible flag.

void setVisible(int visibility);

/// Get the tile visible flag.

int getVisible() const;

/// set the direction (used for path previewing)

void setPreview(int dir);

/// retrieve the direction stored by the pathfinding.

int getPreview() const;

/// set the number to be displayed for pathfinding preview.

void setTUMarker(int tu);

/// get the number to be displayed for pathfinding preview.

int getTUMarker() const;

/// how many times has this tile been overlapped with smoke/fire (runtime only)

int getOverlaps() const;

/// increment the overlap value on this tile.

void addOverlap();

/// set the danger flag on this tile (so the AI will avoid it).

void setDangerous(bool danger);

/// check the danger flag on this tile.

bool getDangerous() const;

/// adds a particle to this tile's array.

void addParticle(Particle *particle);

/// gets a pointer to this tile's particle array.

std::list<Particle *> *getParticleCloud();

/// sets single obstacle flag.

void setObstacle(int part);

/// gets single obstacle flag.

bool getObstacle(int part) const

{

return _obstacle & (1 << part);

}

/// does the tile have obstacle flag set for at least one part?

bool isObstacle(void) const

{

return _obstacle != 0;

}

/// reset obstacle flags

void resetObstacle(void);