SavedBattleGame.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_SAVEDBATTLEGAME_H
#define OPENXCOM_SAVEDBATTLEGAME_H

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <SDL.h>
#include <yaml-cpp/yaml.h>
#include "BattleUnit.h"

namespace OpenXcom
{

class Tile;
class SavedGame;
class MapDataSet;
class Node;
class Game;
class BattlescapeState;
class Position;
class Pathfinding;
class TileEngine;
class BattleItem;
class Ruleset;

class SavedBattleGame
{
private:
    BattlescapeState *_battleState;
    int _mapsize_x, _mapsize_y, _mapsize_z;
    std::vector<MapDataSet*> _mapDataSets;
    Tile **_tiles;
    BattleUnit *_selectedUnit, *_lastSelectedUnit;
    std::vector<Node*> _nodes;
    std::vector<BattleUnit*> _units;
    std::vector<BattleItem*> _items, _deleted;
    Pathfinding *_pathfinding;
    TileEngine *_tileEngine;
    std::string _missionType;
    int _globalShade;
    UnitFaction _side;
    int _turn;
    bool _debugMode;
    bool _aborted;
    int _itemId;
    bool _objectiveDestroyed;
    std::vector<BattleUnit*> _exposedUnits;
    std::list<BattleUnit*> _fallingUnits;
    bool _unitsFalling, _cheating;
    std::vector<Position> _tileSearch, _storageSpace;
    BattleActionType _tuReserved;
    bool _kneelReserved;
    std::vector< std::vector<std::pair<int, int> > > _baseModules;
    BattleUnit *selectPlayerUnit(int dir, bool checkReselect = false, bool setReselect = false, bool checkInventory = false);
public:
    SavedBattleGame();
    ~SavedBattleGame();
    void load(const YAML::Node& node, Ruleset *rule, SavedGame* savedGame);
    YAML::Node save() const;
    void initMap(int mapsize_x, int mapsize_y, int mapsize_z);
    void initUtilities(ResourcePack *res);
    std::vector<MapDataSet*> *getMapDataSets();
    void setMissionType(const std::string &missionType);
    std::string getMissionType() const;
    void setGlobalShade(int shade);
    int getGlobalShade() const;
    Tile **getTiles() const;
    std::vector<Node*> *getNodes();
    std::vector<BattleItem*> *getItems();
    std::vector<BattleUnit*> *getUnits();
    int getMapSizeX() const;
    int getMapSizeY() const;
    int getMapSizeZ() const;
    int getMapSizeXYZ() const;

    inline int getTileIndex(const Position& pos) const
    {
        return pos.z * _mapsize_y * _mapsize_x + pos.y * _mapsize_x + pos.x;
    }

    void getTileCoords(int index, int *x, int *y, int *z) const;

    inline Tile *getTile(const Position& pos) const
    {
        if (pos.x < 0 || pos.y < 0 || pos.z < 0
            || pos.x >= _mapsize_x || pos.y >= _mapsize_y || pos.z >= _mapsize_z)
            return 0;

        return _tiles[getTileIndex(pos)];
    }

    BattleUnit *getSelectedUnit() const;
    void setSelectedUnit(BattleUnit *unit);
    BattleUnit *selectPreviousPlayerUnit(bool checkReselect = false, bool setReselect = false, bool checkInventory = false);
    BattleUnit *selectNextPlayerUnit(bool checkReselect = false, bool setReselect = false, bool checkInventory = false);
    BattleUnit *selectUnit(const Position& pos);
    Pathfinding *getPathfinding() const;
    TileEngine *getTileEngine() const;
    UnitFaction getSide() const;
    int getTurn() const;
    void endTurn();
    void setDebugMode();
    bool getDebugMode() const;
    void loadMapResources(Game *game);
    void resetUnitTiles();
    void removeItem(BattleItem *item);
    void setAborted(bool flag);
    bool isAborted() const;
    void setObjectiveDestroyed(bool flag);
    bool isObjectiveDestroyed();
    int *getCurrentItemId();
    Node *getSpawnNode(int nodeRank, BattleUnit *unit);
    Node *getPatrolNode(bool scout, BattleUnit *unit, Node *fromNode);
    void prepareNewTurn();
    void reviveUnconsciousUnits();
    void removeUnconsciousBodyItem(BattleUnit *bu);
    bool setUnitPosition(BattleUnit *bu, const Position &position, bool testOnly = false);
    bool addFallingUnit(BattleUnit* unit);
    std::list<BattleUnit*> *getFallingUnits();
    void setUnitsFalling(bool fall);
    bool getUnitsFalling() const;
    BattlescapeState *getBattleState();
    BattlescapeGame *getBattleGame();
    void setBattleState(BattlescapeState *bs);
    BattleUnit* getHighestRankedXCom();
    int getMoraleModifier(BattleUnit* unit = 0);
    bool eyesOnTarget(UnitFaction faction, BattleUnit* unit);
    bool placeUnitNearPosition(BattleUnit *unit, Position entryPoint);
    void resetTurnCounter();
    void resetTiles();
    const std::vector<Position> getTileSearch();
    bool isCheating();
    BattleActionType getTUReserved() const;
    void setTUReserved(BattleActionType reserved);
    bool getKneelReserved() const;
    void setKneelReserved(bool reserved);
    std::vector<Position> &getStorageSpace();
    void randomizeItemLocations(Tile *t);
    std::vector< std::vector<std::pair<int, int> > > &getModuleMap();
    void calculateModuleMap();
    SavedGame *getGeoscapeSave();

};

}

#endif