GameSave.hpp

Go to the documentation of this file.

#ifndef CORE_FILES_GAMESAVE_HPP
#define CORE_FILES_GAMESAVE_HPP
 
#include <BLIB/Events.hpp>
#include <BLIB/Serialization/JSON.hpp>
#include <BLIB/Tilemap/Position.hpp>
#include <Core/Peoplemon/OwnedPeoplemon.hpp>
#include <Core/Player/Bag.hpp>
#include <Core/Player/Gender.hpp>
#include <Core/Player/StorageSystem.hpp>
#include <Core/Systems/Clock.hpp>
#include <Core/Systems/Trainers.hpp>
 
namespace core
{
namespace file
{
struct GameSave {
    unsigned long long saveTime;
 
    std::string saveName;
 
    struct InteractDataPointers {
        std::unordered_map<std::string, std::unordered_set<std::string>>* talkedto;
        std::unordered_set<std::string>* convFlags;
    } interaction;
 
    struct PlayerDataPointers {
        std::string* playerName;
        player::Gender* sex;
        player::Bag* inventory;
        long* monei;
        std::vector<pplmn::OwnedPeoplemon>* peoplemon;
        std::string* whiteoutMap;
        unsigned int* whiteoutSpawn;
        unsigned int* repelSteps;
        std::array<std::vector<pplmn::StoredPeoplemon>, player::StorageSystem::BoxCount>* storage;
        std::unordered_set<std::string>* visitedTowns;
        std::unordered_map<pplmn::Id, std::uint32_t>* seenPeoplemon;
        std::unordered_map<pplmn::Id, std::string>* firstSightingLocations;
    } player;
 
    struct WorldDataPointers {
        std::string* currentMap;
        std::string* prevMap;
        bl::tmap::Position* playerPos;
        bl::tmap::Position* prevPlayerPos;
    } world;
 
    struct ScriptDataPointers {
        std::unordered_map<std::string, bl::script::Value>* entries;
    } scripts;
 
    struct ClockPointers {
        system::Clock::Time* time;
    } clock;
 
    struct TrainerPointers {
        std::unordered_set<std::string>* defeated;
    } trainers;
 
    GameSave();
 
    static void listSaves(std::vector<GameSave>& result);
 
    static bool saveGame(const std::string& name);
 
    static bool loadFromFile(const std::string& sourceFile);
 
    bool load();
 
    void editorSave();
 
    bool remove() const;
 
    bool operator<(const GameSave& rhs) const;
 
    void useLocalData();
 
    static std::string filename(const std::string& saveName);
 
private:
    struct Data {
        std::unordered_map<std::string, std::unordered_set<std::string>> talkedto;
        std::unordered_set<std::string> convFlags;
        std::string playerName;
        player::Gender sex;
        player::Bag inventory;
        long monei;
        std::vector<pplmn::OwnedPeoplemon> peoplemon;
        std::string whiteoutMap;
        unsigned int whiteoutSpawn;
        unsigned int repelSteps;
        std::array<std::vector<pplmn::StoredPeoplemon>, player::StorageSystem::BoxCount> storage;
        std::unordered_set<std::string> visitedTowns;
        std::string currentMap;
        std::string prevMap;
        bl::tmap::Position playerPos;
        bl::tmap::Position prevPlayerPos;
        std::unordered_map<std::string, bl::script::Value> entries;
        system::Clock::Time clockTime;
        std::unordered_set<std::string> defeatedTrainers;
        std::unordered_map<pplmn::Id, std::uint32_t> seenPeoplemon;
        std::unordered_map<pplmn::Id, std::string> firstSightingLocations;
    };
 
    std::optional<Data> localData;
    std::string sourceFile;
};
 
} // namespace file
} // namespace core
 
namespace bl
{
namespace serial
{
template<>
struct SerializableObject<core::file::GameSave::InteractDataPointers>
: public SerializableObjectBase {
    using I = core::file::GameSave::InteractDataPointers;
    using M = std::unordered_map<std::string, std::unordered_set<std::string>>;
    using F = std::unordered_set<std::string>;
 
    SerializableField<1, I, M*> talkedTo;
    SerializableField<2, I, F*> flags;
 
    SerializableObject()
    : SerializableObjectBase("GameSaveInteraction")
    , talkedTo("talked", *this, &I::talkedto, SerializableFieldBase::Required{})
    , flags("flags", *this, &I::convFlags, SerializableFieldBase::Required{}) {}
};
 
template<>
struct SerializableObject<core::file::GameSave::WorldDataPointers> : SerializableObjectBase {
    using World = core::file::GameSave::WorldDataPointers;
    using Pos   = bl::tmap::Position;
 
    SerializableField<1, World, std::string*> currentMap;
    SerializableField<2, World, std::string*> prevMap;
    SerializableField<3, World, Pos*> playerPos;
    SerializableField<4, World, Pos*> prevPlayerPos;
 
    SerializableObject()
    : SerializableObjectBase("GameSaveWorld")
    , currentMap("current", *this, &World::currentMap, SerializableFieldBase::Required{})
    , prevMap("previous", *this, &World::prevMap, SerializableFieldBase::Required{})
    , playerPos("position", *this, &World::playerPos, SerializableFieldBase::Required{})
    , prevPlayerPos("prevPos", *this, &World::prevPlayerPos, SerializableFieldBase::Required{}) {}
};
 
template<>
struct SerializableObject<core::file::GameSave::PlayerDataPointers>
: public SerializableObjectBase {
    using Player = core::file::GameSave::PlayerDataPointers;
 
    SerializableField<1, Player, std::string*> name;
    SerializableField<2, Player, core::player::Gender*> gender;
    SerializableField<3, Player, core::player::Bag*> bag;
    SerializableField<4, Player, std::vector<core::pplmn::OwnedPeoplemon>*> peoplemon;
    SerializableField<5, Player, long*> money;
    SerializableField<6, Player, std::string*> whiteoutMap;
    SerializableField<7, Player, unsigned int*> whiteoutSpawn;
    SerializableField<8, Player, unsigned int*> repelSteps;
    SerializableField<9, Player,
                      std::array<std::vector<core::pplmn::StoredPeoplemon>,
                                 core::player::StorageSystem::BoxCount>*>
        storage;
    SerializableField<10, Player, std::unordered_set<std::string>*> visitedTowns;
    SerializableField<11, Player, std::unordered_map<core::pplmn::Id, std::uint32_t>*> seenCounts;
    SerializableField<12, Player, std::unordered_map<core::pplmn::Id, std::string>*> seenSpots;
 
    SerializableObject()
    : SerializableObjectBase("GameSavePlayer")
    , name("name", *this, &Player::playerName, SerializableFieldBase::Required{})
    , gender("gender", *this, &Player::sex, SerializableFieldBase::Required{})
    , bag("bag", *this, &Player::inventory, SerializableFieldBase::Required{})
    , peoplemon("peoplemon", *this, &Player::peoplemon, SerializableFieldBase::Required{})
    , money("money", *this, &Player::monei, SerializableFieldBase::Required{})
    , whiteoutMap("whiteoutMap", *this, &Player::whiteoutMap, SerializableFieldBase::Required{})
    , whiteoutSpawn("whiteoutSpawn", *this, &Player::whiteoutSpawn,
                    SerializableFieldBase::Required{})
    , repelSteps("repelSteps", *this, &Player::repelSteps, SerializableFieldBase::Required{})
    , storage("storage", *this, &Player::storage, SerializableFieldBase::Optional{})
    , visitedTowns("visitedTowns", *this, &Player::visitedTowns, SerializableFieldBase::Optional{})
    , seenCounts("seenPeoplemon", *this, &Player::seenPeoplemon, SerializableFieldBase::Optional{})
    , seenSpots("seenSpots", *this, &Player::firstSightingLocations,
                SerializableFieldBase::Optional{}) {}
};
 
template<>
struct SerializableObject<core::file::GameSave::ScriptDataPointers>
: public SerializableObjectBase {
    using S = core::file::GameSave::ScriptDataPointers;
    using M = std::unordered_map<std::string, bl::script::Value>;
 
    SerializableField<1, S, M*> entries;
 
    SerializableObject()
    : SerializableObjectBase("GameSaveScript")
    , entries("saveEntries", *this, &S::entries, SerializableFieldBase::Required{}) {}
};
 
template<>
struct SerializableObject<core::file::GameSave::ClockPointers> : public SerializableObjectBase {
    using C = core::file::GameSave::ClockPointers;
    using T = core::system::Clock::Time;
 
    SerializableField<1, C, T*> time;
 
    SerializableObject()
    : SerializableObjectBase("GameSaveTime")
    , time("time", *this, &C::time, SerializableFieldBase::Required{}) {}
};
 
template<>
struct SerializableObject<core::file::GameSave::TrainerPointers> : public SerializableObjectBase {
    using T = core::file::GameSave::TrainerPointers;
    using D = std::unordered_set<std::string>;
 
    SerializableField<1, T, D*> defeated;
 
    SerializableObject()
    : SerializableObjectBase("GameSaveTrainer")
    , defeated("defeated", *this, &T::defeated, SerializableFieldBase::Required{}) {}
};
 
template<>
struct SerializableObject<core::file::GameSave> : public SerializableObjectBase {
    using GS = core::file::GameSave;
    SerializableField<1, GS, unsigned long long> saveTime;
    SerializableField<2, GS, GS::PlayerDataPointers> player;
    SerializableField<3, GS, GS::InteractDataPointers> interaction;
    SerializableField<4, GS, GS::WorldDataPointers> world;
    SerializableField<5, GS, GS::ScriptDataPointers> script;
    SerializableField<6, GS, GS::ClockPointers> clock;
 
    SerializableObject()
    : SerializableObjectBase("GameSave")
    , saveTime("saveTime", *this, &GS::saveTime, SerializableFieldBase::Required{})
    , player("player", *this, &GS::player, SerializableFieldBase::Required{})
    , interaction("interaction", *this, &GS::interaction, SerializableFieldBase::Required{})
    , world("world", *this, &GS::world, SerializableFieldBase::Required{})
    , script("script", *this, &GS::scripts, SerializableFieldBase::Required{})
    , clock("clock", *this, &GS::clock, SerializableFieldBase::Required{}) {}
};
 
} // namespace serial
} // namespace bl
 
#endif