SavedGame.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 <map>
#include <vector>
#include <string>
#include <time.h>
#include <stdint.h>
#include "GameTime.h"
#include "../Mod/RuleAlienMission.h"
#include "../Savegame/Craft.h"

namespace OpenXcom
{

class Mod;
class GameTime;
class Country;
class Base;
class Region;
class Ufo;
class Waypoint;
class SavedBattleGame;
class TextList;
class Language;
class RuleResearch;
class ResearchProject;
class Soldier;
class RuleManufacture;
class MissionSite;
class AlienBase;
class AlienStrategy;
class AlienMission;
class Target;
class Soldier;
class Craft;
struct MissionStatistics;
struct BattleUnitKills;

enum GameDifficulty { DIFF_BEGINNER = 0, DIFF_EXPERIENCED, DIFF_VETERAN, DIFF_GENIUS, DIFF_SUPERHUMAN };

enum SaveType { SAVE_DEFAULT, SAVE_QUICK, SAVE_AUTO_GEOSCAPE, SAVE_AUTO_BATTLESCAPE, SAVE_IRONMAN, SAVE_IRONMAN_END };

enum GameEnding { END_NONE, END_WIN, END_LOSE };

struct SaveInfo
{
    std::string fileName;
    std::wstring displayName;
    time_t timestamp;
    std::wstring isoDate, isoTime;
    std::wstring details;
    std::vector<std::string> mods;
    bool reserved;
};

struct PromotionInfo
{
    int totalCommanders;
    int totalColonels;
    int totalCaptains;
    int totalSergeants;
    PromotionInfo(): totalCommanders(0), totalColonels(0), totalCaptains(0), totalSergeants(0){}
};

class SavedGame
{
private:
    std::wstring _name;
    GameDifficulty _difficulty;
    GameEnding _end;
    bool _ironman;
    GameTime *_time;
    std::vector<int> _researchScores;
    std::vector<int64_t> _funds, _maintenance, _incomes, _expenditures;
    double _globeLon, _globeLat;
    int _globeZoom;
    std::map<std::string, int> _ids;
    std::vector<Country*> _countries;
    std::vector<Region*> _regions;
    std::vector<Base*> _bases;
    std::vector<Ufo*> _ufos;
    std::vector<Waypoint*> _waypoints;
    std::vector<MissionSite*> _missionSites;
    std::vector<AlienBase*> _alienBases;
    AlienStrategy *_alienStrategy;
    SavedBattleGame *_battleGame;
    std::vector<const RuleResearch*> _discovered;
    std::vector<AlienMission*> _activeMissions;
    bool _debug, _warned;
    int _monthsPassed;
    std::string _graphRegionToggles;
    std::string _graphCountryToggles;
    std::string _graphFinanceToggles;
    std::vector<const RuleResearch*> _poppedResearch;
    std::vector<Soldier*> _deadSoldiers;
    size_t _selectedBase;
    std::string _lastselectedArmor; //contains the last selected armour
    std::vector<MissionStatistics*> _missionStatistics;

    void getDependableResearchBasic (std::vector<RuleResearch*> & dependables, const RuleResearch *research, const Mod *mod, Base *base) const;
    static SaveInfo getSaveInfo(const std::string &file, Language *lang);
public:
    static const std::string AUTOSAVE_GEOSCAPE, AUTOSAVE_BATTLESCAPE, QUICKSAVE;
    SavedGame();
    ~SavedGame();
    static std::vector<SaveInfo> getList(Language *lang, bool autoquick);
    void load(const std::string &filename, Mod *mod);
    void save(const std::string &filename) const;
    std::wstring getName() const;
    void setName(const std::wstring &name);
    GameDifficulty getDifficulty() const;
    void setDifficulty(GameDifficulty difficulty);
    int getDifficultyCoefficient() const;
    GameEnding getEnding() const;
    void setEnding(GameEnding end);
    bool isIronman() const;
    void setIronman(bool ironman);
    int64_t getFunds() const;
    std::vector<int64_t> &getFundsList();
    void setFunds(int64_t funds);
    double getGlobeLongitude() const;
    void setGlobeLongitude(double lon);
    double getGlobeLatitude() const;
    void setGlobeLatitude(double lat);
    int getGlobeZoom() const;
    void setGlobeZoom(int zoom);
    void monthlyFunding();
    GameTime *getTime() const;
    void setTime(const GameTime& time);
    int getId(const std::string &name);
    const std::map<std::string, int> &getAllIds() const;
    void setAllIds(const std::map<std::string, int> &ids);
    std::vector<Country*> *getCountries();
    int getCountryFunding() const;
    std::vector<Region*> *getRegions();
    std::vector<Base*> *getBases();
    const std::vector<Base*> *getBases() const;
    int getBaseMaintenance() const;
    std::vector<Ufo*> *getUfos();
    std::vector<Waypoint*> *getWaypoints();
    std::vector<MissionSite*> *getMissionSites();
    SavedBattleGame *getSavedBattle();
    void setBattleGame(SavedBattleGame *battleGame);
    void addFinishedResearch(const RuleResearch *r, const Mod *mod = 0, bool score = true);
    const std::vector<const RuleResearch*> & getDiscoveredResearch() const;
    void getAvailableResearchProjects(std::vector<RuleResearch*> & projects, const Mod *mod, Base *base) const;
    void getAvailableProductions(std::vector<RuleManufacture*> & productions, const Mod *mod, Base *base) const;
    void getDependableResearch(std::vector<RuleResearch*> & dependables, const RuleResearch *research, const Mod *mod, Base *base) const;
    void getDependableManufacture(std::vector<RuleManufacture*> & dependables, const RuleResearch *research, const Mod *mod, Base *base) const;
    bool isResearchAvailable(RuleResearch *r, const std::vector<const RuleResearch*> & unlocked, const Mod *mod) const;
    bool isResearched(const std::string &research) const;
    bool isResearched(const std::vector<std::string> &research) const;
    Soldier *getSoldier(int id) const;
    bool handlePromotions(std::vector<Soldier*> &participants);
    void processSoldier(Soldier *soldier, PromotionInfo &soldierData);
    Soldier *inspectSoldiers(std::vector<Soldier*> &soldiers, std::vector<Soldier*> &participants, int rank);
    std::vector<AlienBase*> *getAlienBases();
    void setDebugMode();
    bool getDebugMode() const;
    std::vector<int64_t> &getMaintenances();
    void addResearchScore(int score);
    std::vector<int> &getResearchScores();
    std::vector<int64_t> &getIncomes();
    std::vector<int64_t> &getExpenditures();
    bool getWarned() const;
    void setWarned(bool warned);
    AlienStrategy &getAlienStrategy() { return *_alienStrategy; }
    const AlienStrategy &getAlienStrategy() const { return *_alienStrategy; }
    std::vector<AlienMission*> &getAlienMissions() { return _activeMissions; }
    const std::vector<AlienMission*> &getAlienMissions() const { return _activeMissions; }
    AlienMission *findAlienMission(const std::string &region, MissionObjective objective) const;
    Region *locateRegion(double lon, double lat) const;
    Region *locateRegion(const Target &target) const;
    int getMonthsPassed() const;
    const std::string &getGraphRegionToggles() const;
    const std::string &getGraphCountryToggles() const;
    const std::string &getGraphFinanceToggles() const;
    void setGraphRegionToggles(const std::string &value);
    void setGraphCountryToggles(const std::string &value);
    void setGraphFinanceToggles(const std::string &value);
    void addMonth();
    void addPoppedResearch(const RuleResearch* research);
    bool wasResearchPopped(const RuleResearch* research);
    void removePoppedResearch(const RuleResearch* research);
    std::vector<Soldier*> *getDeadSoldiers();
    Base *getSelectedBase();
    void setSelectedBase(size_t base);
    int getSoldierScore(Soldier *soldier);
    void setLastSelectedArmor(const std::string &value);
    std::string getLastSelectedArmor() const;
    Craft *findCraftByUniqueId(const CraftId& craftId) const;
    std::vector<MissionStatistics*> *getMissionStatistics();
    std::vector<Soldier*>::iterator killSoldier(Soldier *soldier, BattleUnitKills *cause = 0);
};

}