Hook up MessageDispatchService to Entity Registry

meisekimiu · Aug 27, 2024 · 7789811 · 7789811
1 parent 9c05d98
commit 7789811
Show file tree

Hide file tree

Showing 5 changed files with 84 additions and 65 deletions.
diff --git a/src/state/EntityGameState.cpp b/src/state/EntityGameState.cpp
@@ -2,41 +2,49 @@
 #include <stdexcept>
 
 namespace Adagio {
-void EntityGameState::registerSystem(SystemFn system) {
-  if (!system) {
-    throw std::invalid_argument("System cannot be null.");
-  }
-  systems.push_back(system);
-}
-
-void EntityGameState::registerRenderer(RendererFn renderer) {
-  if (!renderer) {
-    throw std::invalid_argument("Renderer cannot be null.");
-  }
-  renderers.push_back(renderer);
-}
-
-void EntityGameState::update(GameStats &stats, StateMachine *gameStates) {
-  if (!gameStates) {
-    throw std::invalid_argument("StateMachine cannot be null.");
-  }
-  for (SystemFn system : systems) {
-    system(registry, stats, gameStates);
-  }
-}
-
-void EntityGameState::draw(SpriteBatch &spriteBatch,
-                           RenderingServices &services) {
-  for (RendererFn renderer : renderers) {
-    renderer(registry, spriteBatch, services);
-  }
-}
-
-const std::vector<SystemFn> *EntityGameState::getSystems() const {
-  return &systems;
-}
-
-const std::vector<RendererFn> *EntityGameState::getRenderers() const {
-  return &renderers;
-}
+    void EntityGameState::registerSystem(SystemFn system) {
+        if (!system) {
+            throw std::invalid_argument("System cannot be null.");
+        }
+        systems.push_back(system);
+    }
+
+    void EntityGameState::registerRenderer(RendererFn renderer) {
+        if (!renderer) {
+            throw std::invalid_argument("Renderer cannot be null.");
+        }
+        renderers.push_back(renderer);
+    }
+
+    void EntityGameState::update(GameStats &stats, StateMachine *gameStates) {
+        if (!gameStates) {
+            throw std::invalid_argument("StateMachine cannot be null.");
+        }
+        for (SystemFn system: systems) {
+            system(registry, stats, gameStates);
+        }
+    }
+
+    void EntityGameState::draw(SpriteBatch &spriteBatch,
+                               RenderingServices &services) {
+        for (RendererFn renderer: renderers) {
+            renderer(registry, spriteBatch, services);
+        }
+    }
+
+    const std::vector<SystemFn> *EntityGameState::getSystems() const {
+        return &systems;
+    }
+
+    const std::vector<RendererFn> *EntityGameState::getRenderers() const {
+        return &renderers;
+    }
+
+    void EntityGameState::initializeRegistryContext() {
+        registry.ctx().emplace<Adagio::MessageDispatchService *>(&messageService);
+    }
+
+    EntityGameState::EntityGameState() {
+        initializeRegistryContext();
+    }
 } // namespace Adagio
diff --git a/src/state/EntityGameState.h b/src/state/EntityGameState.h
@@ -2,35 +2,42 @@
 #define GL_ADAGIO_ENTITYGAMESTATE_H
 
 #include "./GameState.h"
+#include "../event/MessageDispatchService.h"
 #include "entt/entt.hpp"
 
 namespace Adagio {
-typedef void (*SystemFn)(entt::registry &, GameStats &, StateMachine *);
+    typedef void (*SystemFn)(entt::registry &, GameStats &, StateMachine *);
 
-typedef void (*RendererFn)(entt::registry &, SpriteBatch &,
-                           RenderingServices &);
+    typedef void (*RendererFn)(entt::registry &, SpriteBatch &,
+                               RenderingServices &);
 
-class EntityGameState : public GameState {
-public:
-  void registerSystem(SystemFn);
+    class EntityGameState : public GameState {
+    public:
+        entt::registry registry;
 
-  void registerRenderer(RendererFn);
+        EntityGameState();
 
-  void update(GameStats &stats, StateMachine *gameStates) override;
+        void registerSystem(SystemFn);
 
-  void draw(SpriteBatch &spriteBatch, RenderingServices &services) override;
+        void registerRenderer(RendererFn);
 
-protected:
-  entt::registry registry;
+        void update(GameStats &stats, StateMachine *gameStates) override;
 
-  [[nodiscard]] const std::vector<SystemFn> *getSystems() const;
+        void draw(SpriteBatch &spriteBatch, RenderingServices &services) override;
 
-  [[nodiscard]] const std::vector<RendererFn> *getRenderers() const;
+    protected:
+        MessageDispatchService messageService;
 
-private:
-  std::vector<SystemFn> systems;
-  std::vector<RendererFn> renderers;
-};
+        void initializeRegistryContext();
+
+        [[nodiscard]] const std::vector<SystemFn> *getSystems() const;
+
+        [[nodiscard]] const std::vector<RendererFn> *getRenderers() const;
+
+    private:
+        std::vector<SystemFn> systems;
+        std::vector<RendererFn> renderers;
+    };
 } // namespace Adagio
 
 #endif // GL_ADAGIO_ENTITYGAMESTATE_H
diff --git a/test/event/EcsHooks.test.cpp b/test/event/EcsHooks.test.cpp
@@ -5,8 +5,8 @@
 #include <catch2/catch.hpp>
 
 TEST_CASE("MessageInbox ECS Hooks", "[event]") {
-    Adagio::MessageDispatchService messageService;
     EcsTestingHarness harness;
+    auto &messageService = harness.messageService;
     auto &registry = harness.registry;
     registry.ctx().emplace<Adagio::MessageDispatchService *>(&messageService);
     registry.on_construct<MessageInbox>().connect<&RegisterInboxWithMessageService>();

diff --git a/test/game/EcsTestingHarness.cpp b/test/game/EcsTestingHarness.cpp
@@ -3,6 +3,7 @@
 EcsTestingHarness::EcsTestingHarness() {
     renderingServices = {&spriteBatch, graphicsDevice.getTextureManager(), &stats};
     stateMachine = new Adagio::StateMachine(&spriteBatch, &renderingServices);
+    registry.ctx().emplace<Adagio::MessageDispatchService *>(&messageService);
 }
 
 void EcsTestingHarness::reset() {

diff --git a/test/game/EcsTestingHarness.h b/test/game/EcsTestingHarness.h
@@ -5,25 +5,28 @@
 #include "../../src/state/EntityGameState.h"
 #include "../../src/state/RenderingServices.h"
 #include "../../src/state/StateMachine.h"
+#include "../../src/event/MessageDispatchService.h"
 #include "entt/entt.hpp"
 #include "harness/EcsMockGraphicsDevice.h"
 #include "harness/MockGameStats.h"
 
 class EcsTestingHarness {
 public:
-  EcsMockGraphicsDevice graphicsDevice;
-  Adagio::SpriteBatch spriteBatch{&graphicsDevice};
-  MockGameStats stats;
-  entt::registry registry;
-  Adagio::RenderingServices renderingServices{};
-  Adagio::StateMachine *stateMachine;
+    EcsMockGraphicsDevice graphicsDevice;
+    Adagio::SpriteBatch spriteBatch{&graphicsDevice};
+    MockGameStats stats;
+    entt::registry registry;
+    Adagio::RenderingServices renderingServices{};
+    Adagio::StateMachine *stateMachine;
+    Adagio::MessageDispatchService messageService;
 
-  EcsTestingHarness();
+    EcsTestingHarness();
 
-  void reset();
+    void reset();
 
-  void testRendererFrame(Adagio::RendererFn renderer);
-  void testSystemFrame(Adagio::SystemFn system);
+    void testRendererFrame(Adagio::RendererFn renderer);
+
+    void testSystemFrame(Adagio::SystemFn system);
 };
 
 #endif // GL_ADAGIO_ECSTESTINGHARNESS_H