SavedBattleGame.h

#pragma once
/*
 * Copyright 2010-2016 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/>.
 */
#include <vector>
#include <string>
#include <yaml-cpp/yaml.h>
#include "BattleUnit.h"
#include "../Mod/AlienDeployment.h"

namespace OpenXcom
{

class Tile;
class SavedGame;
class MapDataSet;
class Node;
class BattlescapeState;
class Position;
class Pathfinding;
class TileEngine;
class BattleItem;
class Mod;
class State;

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;
    int _objectiveType, _objectivesDestroyed, _objectivesNeeded;
    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;
    int _depth, _ambience;
    double _ambientVolume;
    std::vector<BattleItem*> _recoverGuaranteed, _recoverConditional;
    std::string _music;
    int _turnLimit, _cheatTurn;
    ChronoTrigger _chronoTrigger;
    bool _beforeGame;
    BattleUnit *selectPlayerUnit(int dir, bool checkReselect = false, bool setReselect = false, bool checkInventory = false);
public:
    SavedBattleGame();
    ~SavedBattleGame();
    void load(const YAML::Node& node, Mod *mod, SavedGame* savedGame);
    YAML::Node save() const;
    void initMap(int mapsize_x, int mapsize_y, int mapsize_z);
    void initUtilities(Mod *mod);
    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(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(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(Position pos);
    Pathfinding *getPathfinding() const;
    TileEngine *getTileEngine() const;
    UnitFaction getSide() const;
    int getTurn() const;
    void endTurn();
    void setDebugMode();
    bool getDebugMode() const;
    void loadMapResources(Mod *mod);
    void resetUnitTiles();
    void removeItem(BattleItem *item);
    void setAborted(bool flag);
    bool isAborted() const;
    void setObjectiveCount(int counter);
    void addDestroyedObjective();
    bool allObjectivesDestroyed() const;
    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, 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, const Position& entryPoint, bool largeFriend);
    void resetTurnCounter();
    void resetTiles();
    const std::vector<Position> &getTileSearch() const;
    bool isCheating() const;
    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();
    int getDepth() const;
    void setDepth(int depth);
    void setPaletteByDepth(State *state);
    void setAmbientSound(int sound);
    int getAmbientSound() const;
    std::vector<BattleItem*> *getGuaranteedRecoveredItems();
    std::vector<BattleItem*> *getConditionalRecoveredItems();
    std::string &getMusic();
    void setMusic(const std::string& track);
    void setObjectiveType(int type);
    SpecialTileType getObjectiveType() const;
    void setAmbientVolume(double volume);
    double getAmbientVolume() const;
    int getTurnLimit() const;
    ChronoTrigger getChronoTrigger() const;
    void setTurnLimit(int limit);
    void setChronoTrigger(ChronoTrigger trigger);
    void setCheatTurn(int turn);
    bool isBeforeGame() const;
};

}