Persistence and time management refactor

alfredo/src/main.mm

@@ -10,6 +10,7 @@
 #import "platform/MacInputManager.h"
 #import "platform/MacLifecycleManager.h"
 #import "platform/MacLogger.h"
+#import "platform/MacSaveManager.h"
 #import "platform/MacTimeManager.h"
 
 using namespace linguine;
@@ -31,8 +32,9 @@ int main(int argc, const char *argv[]) {
     auto inputManager = std::make_shared<MacInputManager>();
     auto lifecycleManager = std::make_shared<MacLifecycleManager>();
     auto renderer = std::shared_ptr<Renderer>(appDelegate.metalRenderer);
+    auto saveManager = std::make_shared<MacSaveManager>();
     auto timeManager = std::make_shared<MacTimeManager>();
-    auto engine = Engine(logger, audioManager, inputManager, lifecycleManager, renderer, timeManager);
+    auto engine = Engine(logger, audioManager, inputManager, lifecycleManager, renderer, saveManager, timeManager);
 
     engine.run();
 

alfredo/src/platform/MacSaveManager.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "SaveManager.h"
+
+namespace linguine::alfredo {
+
+class MacSaveManager : public SaveManager {
+  public:
+    MacSaveManager() : SaveManager() {
+      load();
+    }
+
+    ~MacSaveManager() override = default;
+
+  protected:
+    void load() override {
+      _points = 0;
+      _upgradeRanks[0] = 0;
+      _upgradeRanks[1] = 0;
+      _upgradeRanks[2] = 0;
+      _upgradeRanks[3] = 0;
+    }
+
+    void save() override {}
+};
+
+}  // namespace linguine::alfredo

linguine/include/Engine.h

@@ -19,6 +19,7 @@ class Engine : public ServiceLocator, SceneManager {
            const std::shared_ptr<InputManager>& inputManager,
            const std::shared_ptr<LifecycleManager>& lifecycleManager,
            const std::shared_ptr<Renderer>& renderer,
+           const std::shared_ptr<SaveManager>& saveManager,
            const std::shared_ptr<TimeManager>& timeManager);
 
     virtual ~Engine() = default;
@@ -53,7 +54,7 @@ class Engine : public ServiceLocator, SceneManager {
     }
 
     SaveManager& getSaveManager() override {
-      return _saveManager;
+      return *_saveManager;
     }
 
     SceneManager& getSceneManager() override {
@@ -70,10 +71,9 @@ class Engine : public ServiceLocator, SceneManager {
     const std::shared_ptr<LifecycleManager> _lifecycleManager;
     const std::shared_ptr<Logger> _logger;
     const std::shared_ptr<Renderer> _renderer;
+    const std::shared_ptr<SaveManager> _saveManager;
     const std::shared_ptr<TimeManager> _timeManager;
 
-    SaveManager _saveManager;
-
     void load(std::unique_ptr<Scene> scene) override {
       _pendingScene = std::move(scene);
     }
@@ -84,9 +84,6 @@ class Engine : public ServiceLocator, SceneManager {
     void update(float deltaTime);
 
     void fixedUpdate(float fixedDeltaTime);
-
-    time_t _currentTime = _timeManager->currentTime();
-    float _accumulator = 0.0f;
 };
 
 }  // namespace linguine

linguine/include/SaveManager.h

@@ -7,37 +7,40 @@ namespace linguine {
 
 class SaveManager {
   public:
+    SaveManager() = default;
+
+    virtual ~SaveManager() = default;
+
     void addPoints(int32_t points) {
       _points += points;
+      save();
     }
 
     void removePoints(int32_t points) {
       _points -= points;
+      save();
     }
 
-    uint8_t getRank(uint8_t upgradeId) const {
-      if (_upgradeRanks.find(upgradeId) != _upgradeRanks.end()) {
-        return _upgradeRanks.at(upgradeId);
-      } else {
-        return 0;
-      }
+    [[nodiscard]] uint8_t getRank(uint8_t upgradeId) const {
+      return _upgradeRanks.at(upgradeId);
     }
 
     void increaseRank(uint8_t upgradeId) {
-      if (_upgradeRanks.find(upgradeId) != _upgradeRanks.end()) {
-        _upgradeRanks[upgradeId]++;
-      } else {
-        _upgradeRanks[upgradeId] = 1;
-      }
+      _upgradeRanks[upgradeId]++;
+      save();
     }
 
-    int32_t getPoints() const {
+    [[nodiscard]] int32_t getPoints() const {
       return _points;
     }
 
-  private:
+  protected:
     int32_t _points{};
     std::unordered_map<uint8_t, uint8_t> _upgradeRanks;
+
+    virtual void load() = 0;
+
+    virtual void save() = 0;
 };
 
 }  // namespace linguine

linguine/include/TimeManager.h

@@ -6,26 +6,71 @@ namespace linguine {
 
 class TimeManager {
   public:
-    explicit TimeManager(time_t startTime) : _startTime(startTime) {}
+    explicit TimeManager(time_t startTime)
+        : _startTime(startTime),
+          _lastTickTime(startTime),
+          _currentTickTime(startTime) {}
 
     virtual ~TimeManager() = default;
 
     [[nodiscard]] virtual time_t currentTime() const = 0;
 
     [[nodiscard]] virtual float durationInSeconds(time_t from, time_t to) const = 0;
 
-    [[nodiscard]] float runtimeInSeconds() const {
+    [[nodiscard]] inline float scaledDuration(time_t from, time_t to) const {
+      return durationInSeconds(from, to) * _timeScale;
+    }
+
+    [[nodiscard]] inline float runtimeInSeconds() const {
       return durationInSeconds(_startTime, currentTime());
     }
 
-    [[nodiscard]] float getFixedTimeStep() const {
+    [[nodiscard]] inline float getTimeStep() const {
+      return scaledDuration(_lastTickTime, _currentTickTime);
+    }
+
+    [[nodiscard]] inline float getFixedTimeStep() const {
       return _fixedDeltaTime;
     }
 
+    inline void reset() {
+      _lastTickTime = currentTime();
+      _currentTickTime = _lastTickTime;
+      _accumulator = 0.0f;
+    }
+
+    inline float tick() {
+      _lastTickTime = _currentTickTime;
+      _currentTickTime = currentTime();
+
+      auto deltaTime = getTimeStep();
+      _accumulator += deltaTime;
+
+      return deltaTime;
+    }
+
+    [[nodiscard]] inline bool fixedTick() {
+      if (_accumulator >= _fixedDeltaTime) {
+        _accumulator -= _fixedDeltaTime;
+        return true;
+      }
+
+      return false;
+    }
+
+    inline void setTimeScale(float timeScale) {
+      _timeScale = timeScale;
+    }
+
   private:
     constexpr static float _fixedDeltaTime = 0.02f;
 
+    float _accumulator = 0.0f;
+    float _timeScale = 1.0f;
+
     time_t _startTime;
+    time_t _lastTickTime;
+    time_t _currentTickTime;
 };
 
 }  // namespace linguine

linguine/src/Engine.cpp

@@ -11,19 +11,19 @@ Engine::Engine(
     const std::shared_ptr<InputManager>& inputManager,
     const std::shared_ptr<LifecycleManager>& lifecycleManager,
     const std::shared_ptr<Renderer>& renderer,
+    const std::shared_ptr<SaveManager>& saveManager,
     const std::shared_ptr<TimeManager>& timeManager)
     : _entityManagerFactory(std::make_unique<archetype::ArchetypeEntityManagerFactory>()),
       _audioManager(audioManager),
       _inputManager(inputManager),
       _lifecycleManager(lifecycleManager),
       _logger(logger),
       _renderer(renderer),
+      _saveManager(saveManager),
       _timeManager(timeManager),
       _currentScene(std::make_unique<ShopScene>(*this)) {}
 
 void Engine::run() {
-  _currentTime = _timeManager->currentTime();
-
   while (_lifecycleManager->isRunning()) {
     tick();
   }
@@ -32,16 +32,10 @@ void Engine::run() {
 void Engine::tick() {
   _inputManager->pollEvents();
 
-  auto newTime = _timeManager->currentTime();
-  auto deltaTime = _timeManager->durationInSeconds(_currentTime, newTime);
-  _currentTime = newTime;
-  _accumulator += deltaTime;
-
-  const auto fixedDeltaTime = _timeManager->getFixedTimeStep();
+  auto deltaTime = _timeManager->tick();
 
-  while (_accumulator >= fixedDeltaTime) {
-    fixedUpdate(fixedDeltaTime);
-    _accumulator -= fixedDeltaTime;
+  while (_timeManager->fixedTick()) {
+    fixedUpdate(_timeManager->getFixedTimeStep());
   }
 
   update(deltaTime);
@@ -53,9 +47,7 @@ void Engine::tick() {
     _pendingScene = {};
 
     _renderer->reset();
-
-    _currentTime = _timeManager->currentTime();
-    _accumulator = 0.0f;
+    _timeManager->reset();
   }
 }
 

pesto/src/main.cpp

@@ -10,6 +10,7 @@
 #include "platform/WebLogger.h"
 #include "platform/WebOpenALFileLoader.h"
 #include "platform/WebOpenGLFileLoader.h"
+#include "platform/WebSaveManager.h"
 #include "platform/WebTimeManager.h"
 
 using namespace linguine;
@@ -27,6 +28,7 @@ int main() {
   auto audioManager = std::make_shared<audio::OpenALAudioManager>(
       std::make_unique<WebOpenALFileLoader>());
   auto lifecycleManager = std::make_shared<WebLifecycleManager>();
+  auto saveManager = std::make_shared<WebSaveManager>();
   auto timeManager = std::make_shared<WebTimeManager>();
 
   EmscriptenWebGLContextAttributes attributes;
@@ -63,7 +65,8 @@ int main() {
   auto inputManager = std::make_shared<WebInputManager>(renderer->getViewport());
 
   engine = std::make_unique<Engine>(logger, audioManager, inputManager,
-                                    lifecycleManager, renderer, timeManager);
+                                    lifecycleManager, renderer, saveManager,
+                                    timeManager);
 
   emscripten_set_main_loop(tick, 0, false);
   return 0;

pesto/src/platform/WebSaveManager.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "SaveManager.h"
+
+namespace linguine::pesto {
+
+class WebSaveManager : public SaveManager {
+  public:
+    WebSaveManager() : SaveManager() {
+      load();
+    }
+
+    ~WebSaveManager() override = default;
+
+  protected:
+    void load() override {
+      _points = 0;
+      _upgradeRanks[0] = 0;
+      _upgradeRanks[1] = 0;
+      _upgradeRanks[2] = 0;
+      _upgradeRanks[3] = 0;
+    }
+
+    void save() override {}
+};
+
+}  // namespace linguine::pesto

pesto/src/platform/WebTimeManager.cpp

@@ -1,9 +1,25 @@
 #include "WebTimeManager.h"
 
 #include <emscripten/emscripten.h>
+#include <emscripten/html5.h>
 
 namespace linguine::pesto {
 
+WebTimeManager::WebTimeManager() : TimeManager(currentTime()) {
+  emscripten_set_visibilitychange_callback(this, false, [](int eventType, const EmscriptenVisibilityChangeEvent* visibilityChangeEvent, void* userData) -> EM_BOOL {
+    auto& timeManager = *static_cast<WebTimeManager*>(userData);
+
+    if (visibilityChangeEvent->visibilityState == EMSCRIPTEN_VISIBILITY_VISIBLE) {
+      timeManager.setTimeScale(1.0f);
+      timeManager.reset();
+    } else {
+      timeManager.setTimeScale(0.0f);
+    }
+
+    return true;
+  });
+}
+
 time_t WebTimeManager::currentTime() const {
   return static_cast<time_t>(emscripten_get_now() * 1'000'000.0f);
 }

pesto/src/platform/WebTimeManager.h

@@ -6,7 +6,7 @@ namespace linguine::pesto {
 
 class WebTimeManager : public TimeManager {
   public:
-    WebTimeManager() : TimeManager(currentTime()) {}
+    WebTimeManager();
 
     ~WebTimeManager() override = default;
 

scampi/CMakeLists.txt

@@ -19,6 +19,7 @@ add_executable(scampi
         src/platform/IosInputManager.cpp
         src/platform/IosLifecycleManager.cpp
         src/platform/IosMetalTextureLoader.mm
+        src/platform/IosSaveManager.mm
         src/platform/IosTimeManager.cpp
         src/platform/NSLogger.mm
         src/uikit/ScampiAppDelegate.mm

scampi/src/platform/IosSaveManager.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "SaveManager.h"
+
+namespace linguine::scampi {
+
+class IosSaveManager : public SaveManager {
+  public:
+    IosSaveManager();
+
+    ~IosSaveManager() override = default;
+
+  protected:
+    void load() override;
+
+    void save() override;
+};
+
+}  // namespace linguine::scampi