Save/Load System

[DCCoder90]

There should be a save/load system in place to allow the storing of the game's current state and for it to be loaded back into memory at a later date.

[DCCoder90]

So after working on the serialization aspect for a while a few issues are popping up thats showing this is slightly more complex than I originally thought it would be. I did, however, find a useful article here that outlined a simple system. Contents of the answer are provided below just because. But it's looking like I may need to create a similar system and add a Save/Load function to the GameLevel file.

Answer from post

You can either write your own save format and save file reader & writer, or use an existing parser like an XML or JSON one. You can store the save data in a GameSave class at runtime either as a tree of the file format you chose, or inside direct member variables. I myself us the latter, as then it's easier to save data (while reading becomes a bit more tricky). It also abstracts setting of the save data with the writing of the save data.

class GameSave
{
public:
    GameSave() { }
    GameSave(const std::string& filename) 
    { 
        // Load save data...
    }

    void Write(const std::string& filename)
    {
        // Write save data...
    }

    std::string CurrentLevel;
    std::vector<std::pair<std::string, int>> Inventory;

    // More save data...
protected:
private:
}

Here's a very basic example of what your save class could look like. The details or writing and loading and the filename management depends on if you want to support multiple saves or not, and if you want to predefine a few save slots or allow the player to chooce their own filenames etc.

So, when the player saves the game, you need to write the required data to the file. This can be done in a few ways: you could ask each object to save its own data to the file, or you could have a parent object (like your level / gamestate) save the required data. Since your data needs seem quite small, I'd go with the latter option and write something along the lines of:

void GameplayState::SaveGame()
{
    GameSave save;

    save.CurrentLevel = m_Level->GetName();
    Player* player = m_Level->FindPlayerEntity()->GetLevel();
    save.PlayerLevel = player->GetLevel();
    for (InventoryItem* item : player->GetInventory()->GetItems())
        save.Inventory.push_back(std::make_pair(item->Name, item->Amount));

    save.KilledEnemyCount = GameStatManager::KilledEnemyCount;

    save.Write(AskPlayerForSaveSelection());
}

Finally, to continue from a save, you just have to load the data in and pass it to the correct owners. This could be done by passing the whole GameSave around, or simply by passing the required members of the save to the constructors/methods.

void GameplayState::Continue(GameSave* save)
{
    // Use save data:
    m_Level = new Level(save->CurrentLevel);
    m_Level->CreatePlayer(save->PlayerLevel, save->Inventory);
}

This is the basic high-level architecture of a basic game save setup that I've found that worked well enough for me, when the data that I need to save is quite small and can be handled as such. Were you need more data and more dynamic data, then you'd have to start assigning unique identifiers to objects and allowing each object to save/load its own data.

[DCCoder90]

Left the TODO's in place

//TODO: Deserialize the GO name

But ultimately it looks like I just need to ensure the names are being serialized, as now on deserialization a runtime error is being thrown here:

GameLevel.cpp

    auto it = std::find_if(objects.begin(), objects.end(),
                           [&](std::shared_ptr<GameObject>& go2){

        return go2->HasComponent(componentName); });

This is because when the GOs are de/serialized, it's not re/storing the names and as such it can't find the player. I probably also need to ensure the components are serializable.

If the components were serializable I could modify the serialize function in GameObject to be something like this:

std::vector<char> GameObject::serialize() const {
    std::vector<char> nameData(name.begin(), name.end());

    std::vector<char> componentsData;
    for (const auto* component : components) {
        std::vector<char> componentSerializedData = component->serialize();
        componentsData.insert(componentsData.end(), componentSerializedData.begin(), componentSerializedData.end());
    }

    size_t bufferSize = nameData.size() + 8 + componentsData.size();

    std::vector<char> buffer(bufferSize);
    char* bufferPtr = buffer.data();

    std::memcpy(bufferPtr, nameData.data(), nameData.size());
    bufferPtr += nameData.size();

    std::memset(bufferPtr, 0, 8);
    bufferPtr += 8;

    std::memcpy(bufferPtr, componentsData.data(), componentsData.size());

    return buffer;
}

This would allow me to serialize the GO name and have it at the beginning of the buffer followed by 8 bytes of null space to separate the name from the components (will make it easier to split the data during deserialization)