Beginning save manager implement

src/dawn/CMakeLists.txt

@@ -30,7 +30,7 @@ add_subdirectory(game)
 add_subdirectory(locale)
 add_subdirectory(prefab)
 # add_subdirectory(physics)
-# add_subdirectory(save)
+add_subdirectory(save)
 add_subdirectory(scene)
 # add_subdirectory(state)
 add_subdirectory(time)

src/dawn/game/Game.cpp

@@ -16,6 +16,7 @@ Game::Game() {
 void Game::init() {
   renderHost.init(shared_from_this());
   inputManager.init(shared_from_this());
+  saveManager.init(shared_from_this());
 
   auto initialScene = GameInit::getInitialScene();
   nextFrameScene = std::make_shared<Scene>(shared_from_this(), initialScene);

src/dawn/game/Game.hpp

@@ -10,6 +10,7 @@
 #include "time/TimeManager.hpp"
 #include "asset/AssetManager.hpp"
 #include "locale/LocaleManager.hpp"
+#include "save/SaveManager.hpp"
 
 namespace Dawn {
   class Scene;
@@ -25,6 +26,7 @@ namespace Dawn {
       TimeManager timeManager;
       AssetManager assetManager;
       LocaleManager localeManager;
+      SaveManager saveManager;
 
       /**
        * Constructs the game instance, does not initialize anything.

src/dawn/save/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    SaveFile.cpp
+    SaveManager.cpp
+)

src/dawn/save/SaveFile.cpp

@@ -0,0 +1,124 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SaveFile.hpp"
+#include "assert/assert.hpp"
+
+using namespace Dawn;
+
+SaveFile::SaveFile() {
+
+}
+
+bool_t SaveFile::doesSaveHaveChanges() {
+  return this->hasChanges;
+}
+
+bool_t SaveFile::has(const std::string &key) {
+  assertFalse(key.empty(), "Key cannot be empty.");
+  return this->data.find(key) != this->data.end();
+}
+
+// String (raw)
+template<>
+std::string SaveFile::get<std::string>(const std::string &key) {
+  assertFalse(key.empty(), "Key cannot be empty.");
+  if(!this->has(key)) return "";
+  return this->data[key];
+}
+
+template<>
+void SaveFile::set<std::string>(
+  const std::string &key,
+  const std::string value
+) {
+  assertFalse(key.empty(), "Key cannot be empty.");
+  this->data[key] = value;
+  this->hasChanges = true;
+}
+
+// int32_t
+template<>
+int32_t SaveFile::get<int32_t>(const std::string &key) {
+  assertFalse(key.empty(), "Key cannot be empty.");
+  if(!this->has(key)) return 0;
+  return std::stoi(this->data[key]);
+}
+
+template<>
+void SaveFile::set<int32_t>(
+  const std::string &key,
+  const int32_t value
+) {
+  this->set<std::string>(key, std::to_string(value));
+}
+
+// uint32_t
+template<>
+uint32_t SaveFile::get<uint32_t>(const std::string &key) {
+  assertFalse(key.empty(), "Key cannot be empty.");
+  if(!this->has(key)) return 0;
+  return std::stoul(this->data[key]);
+}
+
+template<>
+void SaveFile::set<uint32_t>(
+  const std::string &key,
+  const uint32_t value
+) {
+  this->set<std::string>(key, std::to_string(value));
+}
+
+// int64_t
+template<>
+int64_t SaveFile::get<int64_t>(const std::string &key) {
+  assertFalse(key.empty(), "Key cannot be empty.");
+  if(!this->has(key)) return 0;
+  return std::stoll(this->data[key]);
+}
+
+template<>
+void SaveFile::set<int64_t>(
+  const std::string &key,
+  const int64_t value
+) {
+  this->set<std::string>(key, std::to_string(value));
+}
+
+// uint64_t
+template<>
+uint64_t SaveFile::get<uint64_t>(const std::string &key) {
+  assertFalse(key.empty(), "Key cannot be empty.");
+  if(!this->has(key)) return 0;
+  return std::stoull(this->data[key]);
+}
+
+template<>
+void SaveFile::set<uint64_t>(
+  const std::string &key,
+  const uint64_t value
+) {
+  this->set<std::string>(key, std::to_string(value));
+}
+
+// float_t
+template<>
+float_t SaveFile::get<float_t>(const std::string &key) {
+  assertFalse(key.empty(), "Key cannot be empty.");
+  if(!this->has(key)) return 0.0f;
+  return std::stof(this->data[key]);
+}
+
+template<>
+void SaveFile::set<float_t>(
+  const std::string &key,
+  const float_t value
+) {
+  this->set<std::string>(key, std::to_string(value));
+}
+
+SaveFile::~SaveFile() {
+
+}

src/dawn/save/SaveFile.hpp

@@ -0,0 +1,63 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  class SaveManager;
+
+  struct SaveFile final {
+    private:
+      std::unordered_map<std::string, std::string> data;
+      bool_t hasChanges = false;
+
+    public:
+      /**
+       * Creates a new SaveFile.
+       */
+      SaveFile();
+
+      /**
+       * Returns true if the SaveFile has unsaved changes.
+       * 
+       * @return True if the SaveFile has changes.
+       */
+      bool_t doesSaveHaveChanges();
+
+      /**
+       * Returns true if the key exists.
+       * 
+       * @param key Key to check.
+       * @return True if the key exists.
+       */
+      bool_t has(const std::string &key);
+
+      /**
+       * Returns the value of the key.
+       * 
+       * @param key Key to get the value of.
+       * @return The value of the key.
+       */
+      template<typename T>
+      T get(const std::string &key);
+
+      /**
+       * Sets the value of the key.
+       * 
+       * @param key Key to set the value of.
+       * @param value Value to set the key to.
+       */
+      template<typename T>
+      void set(const std::string &key, const T value);
+
+      /**
+       * Destroys the SaveFile.
+       */
+      virtual ~SaveFile();
+
+      friend class SaveManager;
+  };
+}

src/dawn/save/SaveManager.cpp

@@ -0,0 +1,15 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SaveManager.hpp"
+#include "assert/assert.hpp"
+
+using namespace Dawn;
+
+void SaveManager::init(std::shared_ptr<Game> game) {
+  assertNotNull(game, "Game instance cannot be null!");
+  this->game = game;
+}
+

src/dawn/save/SaveManager.hpp

@@ -0,0 +1,77 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "save/SaveFile.hpp"
+
+namespace Dawn {
+  class Game;
+  
+  enum class SaveResult {
+    SUCCESS,
+    FAILURE
+  };
+  
+  enum class LoadResult {
+    SUCCESS,
+    FAILURE
+  };
+
+  class SaveManager final {
+    private:
+      std::weak_ptr<Game> game;
+      struct SaveFile saveFile;
+      int8_t currentSlot = -1;
+
+    public:
+      /**
+       * Initializes the save manager and prepares it for use.
+       * 
+       * @param game The game to initialize the save manager for.
+       */
+      void init(std::shared_ptr<Game> game);
+
+      /**
+       * Immediately save the game to the given file. This will invoke the 
+       * game's custom writer to write the output data to the save file.
+       */
+      enum SaveResult save();
+
+      /**
+       * Loads the current slotted save file. Invokes the internal managers read
+       * function.
+       */
+      enum LoadResult load();
+      
+      /**
+       * Deletes the given slot.
+       * 
+       * @param slot Slot to delete.
+       */
+      void deleteSlot(int8_t slot);
+
+      /**
+       * Returns the current slotted save file.
+       * 
+       * @returns The current slotted save file.
+       */
+      int8_t getCurrentSlot();
+
+      /**
+       * Sets the current slotted save file.
+       * 
+       * @param slot The slot to set.
+       */
+      void useSlot(int8_t slot);
+
+      /**
+       * Returns a list of used save slots, does not confirm if they are corrupt
+       * or not, just whether they are in existance or not.
+       * 
+       * @return List of used save slots.
+       */
+      std::vector<int8_t> getSlots();
+  };
+}