Tile.h

/*
 * Copyright 2010-2014 OpenXcom Developers.
 *
 * This file is part of OpenXcom.
 *
 * OpenXcom is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * OpenXcom is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with OpenXcom.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef OPENXCOM_TILE_H
#define OPENXCOM_TILE_H

#include <string>
#include <vector>
#include "../Battlescape/Position.h"
#include "../Ruleset/MapData.h"
#include "BattleUnit.h"

#include <SDL_types.h> // for Uint8

namespace OpenXcom
{

class Surface;
class MapData;
class BattleUnit;
class BattleItem;
class RuleInventory;

class Tile
{
public:
    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;

protected:
    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;
    Position _pos;
    BattleUnit *_unit;
    std::vector<BattleItem *> _inventory;
    int _animationOffset;
    int _markerColor;
    int _visible;
    int _preview;
    int _TUMarker;
    int _overlaps;
    bool _danger;
public:
    Tile(const Position& pos);
    ~Tile();
    void load(const YAML::Node &node);
    void loadBinary(Uint8 *buffer, Tile::SerializationKey& serializationKey);
    YAML::Node save() const;
    void saveBinary(Uint8** buffer) const;

    MapData *getMapData(int part) const
    {
        if (0 > part || 3 < part)
        {
            return NULL;
        }
        return _objects[part];
    }

    void setMapData(MapData *dat, int mapDataID, int mapDataSetID, int part);
    void getMapData(int *mapDataID, int *mapDataSetID, int part) const;
    bool isVoid() const;
    int getTUCost(int part, MovementType movementType) const;
    bool hasNoFloor(Tile *tileBelow) const;
    bool isBigWall() const;
    int getTerrainLevel() const;

    const Position& getPosition() const
    {
        return _pos;
    }

    int getFootstepSound(Tile *tileBelow) const;
    int openDoor(int part, BattleUnit *Unit = 0, BattleActionType reserve = BA_NONE);

    bool isUfoDoorOpen(int part) const
    {
        return (_objects[part] && _objects[part]->isUFODoor() && _currentFrame[part] != 0);
    }

    int closeUfoDoor();
    void setDiscovered(bool flag, int part);
    bool isDiscovered(int part) const;
    void resetLight(int layer);
    void addLight(int light, int layer);
    int getShade() const;
    bool destroy(int part);
    bool damage(int part, int power);
    void setExplosive(int power, bool force = false);
    int getExplosive() const;
    void animate();
    Surface *getSprite(int part) const;
    void setUnit(BattleUnit *unit, Tile *tileBelow = 0);
    BattleUnit *getUnit() const
    {
        return _unit;
    }
    void setFire(int fire);
    int getFire() const;
    void addSmoke(int smoke);
    void setSmoke(int smoke);
    int getSmoke() const;
    int getFlammability() const;
    int getFuel() const;
    void ignite(int power);
    int getAnimationOffset() const;
    void addItem(BattleItem *item, RuleInventory *ground);
    void removeItem(BattleItem *item);
    int getTopItemSprite();
    void prepareNewTurn();
    std::vector<BattleItem *> *getInventory();
    void setMarkerColor(int color);
    int getMarkerColor();
    void setVisible(int visibility);
    int getVisible();
    void setPreview(int dir);
    int getPreview() const;
    void setTUMarker(int tu);
    int getTUMarker() const;
    int getOverlaps() const;
    void addOverlap();
    void setDangerous();
    bool getDangerous();

};

}

#endif