Integrated RealizableComponent into RealizingSystem

9 files changed, 126 insertions, 211 deletions

@@ -1,74 +0,0 @@
-#ifndef REALIZABLE_H_36D8D71E
-#define REALIZABLE_H_36D8D71E
-
-#include "component.h"
-#include <set>
-#include <map>
-#include "entity_manager.h"
-#include "vector.h"
-
-class RealizableComponent : public Component {
-public:
-
-  using id_type = EntityManager::id_type;
-
-  /**
-   * Path to the XML file containing the world definition.
-   *
-   * @managed_by RealizingSystem
-   */
-  std::string worldFile;
-
-  /**
-   * Path to the XML file containing the map object prototype definitions.
-   *
-   * @managed_by RealizingSystem
-   */
-  std::string prototypeFile;
-
-  /**
-   * Starting map and player location for a new game.
-   *
-   * @managed_by RealizingSystem
-   */
-  int startingMapId;
-  vec2i startingPos;
-
-  /**
-   * The set of map entities loaded by this entity. It is only intended for
-   * there to be one realizable entity, so this should contain all loaded maps.
-   * The realizable entity has ownership of the loaded maps.
-   *
-   * @managed_by RealizingSystem
-   */
-  std::set<id_type> maps;
-
-  /**
-   * A lookup table that translates a map ID to the entity representing that
-   * loaded map.
-   *
-   * @managed_by RealizingSystem
-   */
-  std::map<size_t, id_type> entityByMapId;
-
-  /**
-   * The entity ID of the currently active map.
-   *
-   * @managed_by RealizingSystem
-   */
-  id_type activeMap;
-
-  /**
-   * Whether or not a map has been activated yet.
-   *
-   * @managed_by RealizingSystem
-   */
-  bool hasActiveMap = false;
-
-  /**
-   * The entity ID of the currently active player.
-   */
-  id_type activePlayer;
-};
-
-#endif /* end of include guard: REALIZABLE_H_36D8D71E */
@@ -32,7 +32,6 @@ void key_callback(GLFWwindow* window, int key, int, int action, int)
 
 Game::Game(std::mt19937& rng) : rng_(rng)
 {
-  systemManager_.emplaceSystem<RealizingSystem>(*this);
   systemManager_.emplaceSystem<PlayingSystem>(*this);
   systemManager_.emplaceSystem<SchedulingSystem>(*this);
   systemManager_.emplaceSystem<ControllingSystem>(*this);
@@ -42,7 +41,7 @@ Game::Game(std::mt19937& rng) : rng_(rng)
   systemManager_.emplaceSystem<MappingSystem>(*this);
   systemManager_.emplaceSystem<AnimatingSystem>(*this);
 
-  systemManager_.getSystem<RealizingSystem>().initSingleton(
+  systemManager_.emplaceSystem<RealizingSystem>(*this,
     "res/maps.xml",
     "res/entities.xml");
 
@@ -1,6 +1,5 @@
 #include "mapping.h"
 #include "components/mappable.h"
-#include "components/realizable.h"
 #include "systems/realizing.h"
 #include "game.h"
 #include "consts.h"
@@ -20,11 +19,8 @@ inline void addBoundary(
 
 void MappingSystem::render(Texture& texture)
 {
-  auto& realizable = game_.getEntityManager().
-    getComponent<RealizableComponent>(
-      game_.getSystemManager().getSystem<RealizingSystem>().getSingleton());
-
-  id_type map = realizable.activeMap;
+  id_type map =
+    game_.getSystemManager().getSystem<RealizingSystem>().getActiveMap();
 
   auto& mappable = game_.getEntityManager().
     getComponent<MappableComponent>(map);
@@ -5,7 +5,6 @@
 #include "components/playable.h"
 #include "components/controllable.h"
 #include "components/orientable.h"
-#include "components/realizable.h"
 #include "systems/mapping.h"
 #include "systems/pondering.h"
 #include "systems/orienting.h"
@@ -36,13 +35,10 @@ void PlayingSystem::initPlayer()
 
   auto& realizing = game_.getSystemManager().getSystem<RealizingSystem>();
 
-  auto& realizable = game_.getEntityManager().
-    getComponent<RealizableComponent>(realizing.getSingleton());
-
   auto& transformable = game_.getEntityManager().
     emplaceComponent<TransformableComponent>(player);
 
-  transformable.pos = realizable.startingPos;
+  transformable.pos = realizing.getStartingPos();
   transformable.size.w() = 10;
   transformable.size.h() = 12;
 
@@ -56,13 +52,13 @@ void PlayingSystem::initPlayer()
   auto& playable = game_.getEntityManager().
     emplaceComponent<PlayableComponent>(player);
 
-  playable.mapId = realizable.activeMap;
-  playable.checkpointMapId = realizable.startingMapId;
-  playable.checkpointPos = realizable.startingPos;
+  playable.mapId = realizing.getActiveMap();
+  playable.checkpointMapId = realizing.getStartingMapId();
+  playable.checkpointPos = realizing.getStartingPos();
 
   realizing.enterActiveMap(player);
 
-  realizable.activePlayer = player;
+  realizing.setActivePlayer(player);
 }
 
 void PlayingSystem::changeMap(
@@ -77,20 +73,16 @@ void PlayingSystem::changeMap(
     getComponent<TransformableComponent>(player);
 
   auto& pondering = game_.getSystemManager().getSystem<PonderingSystem>();
-
   auto& realizing = game_.getSystemManager().getSystem<RealizingSystem>();
 
-  auto& realizable = game_.getEntityManager().
-    getComponent<RealizableComponent>(realizing.getSingleton());
-
-  id_type newMapEntity = realizable.entityByMapId[mapId];
+  id_type newMapEntity = realizing.getEntityByMapId(mapId);
 
   if (playable.mapId != newMapEntity)
   {
-    if (playable.mapId == realizable.activeMap)
+    if (playable.mapId == realizing.getActiveMap())
     {
       realizing.leaveActiveMap(player);
-    } else if (newMapEntity == realizable.activeMap)
+    } else if (newMapEntity == realizing.getActiveMap())
     {
       realizing.enterActiveMap(player);
     }
@@ -102,7 +94,7 @@ void PlayingSystem::changeMap(
 
   transformable.pos = warpPos;
 
-  if (realizable.activePlayer == player)
+  if (realizing.getActivePlayer() == player)
   {
     realizing.loadMap(newMapEntity);
   }
@@ -6,7 +6,6 @@
 #include "components/transformable.h"
 #include "components/orientable.h"
 #include "components/mappable.h"
-#include "components/realizable.h"
 #include "components/playable.h"
 #include "systems/orienting.h"
 #include "systems/playing.h"
@@ -485,11 +484,8 @@ void PonderingSystem::detectCollisionsInDirection(
   CollisionResult& result)
 {
   // Get map data.
-  auto& realizable = game_.getEntityManager().
-    getComponent<RealizableComponent>(
-      game_.getSystemManager().getSystem<RealizingSystem>().getSingleton());
-
-  id_type mapEntity = realizable.activeMap;
+  id_type mapEntity =
+    game_.getSystemManager().getSystem<RealizingSystem>().getActiveMap();
 
   auto& mappable = game_.getEntityManager().
     getComponent<MappableComponent>(mapEntity);
@@ -6,7 +6,6 @@
 #include "game.h"
 #include "consts.h"
 #include "animation.h"
-#include "components/realizable.h"
 #include "components/mappable.h"
 #include "components/animatable.h"
 #include "components/playable.h"
@@ -30,25 +29,21 @@ inline xmlChar* getProp(xmlNodePtr node, const char* attr)
 }
 
 // TODO: neither the XML doc nor any of the emplaced entities are properly
-// destroyed if this method throws an exception.
-EntityManager::id_type RealizingSystem::initSingleton(
+// destroyed if this constructor throws an exception.
+RealizingSystem::RealizingSystem(
+  Game& game,
   std::string worldFile,
-  std::string prototypeFile)
+  std::string prototypeFile) :
+    System(game),
+    worldFile_(std::move(worldFile)),
+    prototypeFile_(std::move(prototypeFile))
 {
-  id_type world = game_.getEntityManager().emplaceEntity();
-
-  auto& realizable = game_.getEntityManager().
-    emplaceComponent<RealizableComponent>(world);
-
-  realizable.worldFile = worldFile;
-  realizable.prototypeFile = prototypeFile;
-
   auto& mapping = game_.getSystemManager().getSystem<MappingSystem>();
 
   xmlChar* key = nullptr;
 
   // Create a mapping between prototype names and the XML trees defining them.
-  xmlDocPtr protoXml = xmlParseFile(prototypeFile.c_str());
+  xmlDocPtr protoXml = xmlParseFile(prototypeFile_.c_str());
   if (protoXml == nullptr)
   {
     throw std::invalid_argument("Cannot find prototypes file");
@@ -82,7 +77,7 @@ EntityManager::id_type RealizingSystem::initSingleton(
   }
 
   // Create entities from the world definition.
-  xmlDocPtr doc = xmlParseFile(worldFile.c_str());
+  xmlDocPtr doc = xmlParseFile(worldFile_.c_str());
   if (doc == nullptr)
   {
     throw std::invalid_argument("Cannot find world file");
@@ -100,15 +95,15 @@ EntityManager::id_type RealizingSystem::initSingleton(
   }
 
   key = getProp(top, "startx");
-  realizable.startingPos.x() = atoi(reinterpret_cast<char*>(key));
+  startingPos_.x() = atoi(reinterpret_cast<char*>(key));
   xmlFree(key);
 
   key = getProp(top, "starty");
-  realizable.startingPos.y() = atoi(reinterpret_cast<char*>(key));
+  startingPos_.y() = atoi(reinterpret_cast<char*>(key));
   xmlFree(key);
 
   key = getProp(top, "startmap");
-  realizable.startingMapId = atoi(reinterpret_cast<char*>(key));
+  startingMapId_ = atoi(reinterpret_cast<char*>(key));
   xmlFree(key);
 
   for (xmlNodePtr node = top->xmlChildrenNode;
@@ -291,78 +286,62 @@ EntityManager::id_type RealizingSystem::initSingleton(
 
       mapping.generateBoundaries(map);
 
-      realizable.maps.insert(map);
-      realizable.entityByMapId[mappable.mapId] = map;
+      entityByMapId_[mappable.mapId] = map;
     }
   }
 
   xmlFreeDoc(doc);
   xmlFreeDoc(protoXml);
 
-  loadMap(realizable.entityByMapId[realizable.startingMapId]);
-
-  return world;
+  activateMap(entityByMapId_[startingMapId_]);
 }
 
-EntityManager::id_type RealizingSystem::getSingleton() const
+void RealizingSystem::loadMap(id_type mapEntity)
 {
-  std::set<id_type> result =
-    game_.getEntityManager().getEntitiesWithComponents<
-      RealizableComponent>();
-
-  if (result.empty())
-  {
-    throw std::logic_error("No realizable entity found");
-  } else if (result.size() > 1)
-  {
-    throw std::logic_error("Multiple realizable entities found");
-  }
-
-  return *std::begin(result);
+  deactivateMap();
+  activateMap(mapEntity);
 }
 
-void RealizingSystem::loadMap(id_type mapEntity)
+void RealizingSystem::deactivateMap()
 {
-  id_type world = getSingleton();
+  id_type oldMap = activeMap_;
 
-  auto& realizable = game_.getEntityManager().
-    getComponent<RealizableComponent>(world);
+  auto& oldMappable = game_.getEntityManager().
+    getComponent<MappableComponent>(oldMap);
 
-  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
-  auto& pondering = game_.getSystemManager().getSystem<PonderingSystem>();
+  // Deactivate any map objects from the old map.
+  for (id_type prototype : oldMappable.objects)
+  {
+    leaveActiveMap(prototype);
+  }
 
+  // Deactivate players that were on the old map.
   std::set<id_type> players =
     game_.getEntityManager().getEntitiesWithComponents<
       PlayableComponent>();
 
-  if (realizable.hasActiveMap)
+  for (id_type player : players)
   {
-    id_type oldMap = realizable.activeMap;
-
-    auto& oldMappable = game_.getEntityManager().
-      getComponent<MappableComponent>(oldMap);
+    auto& playable = game_.getEntityManager().
+      getComponent<PlayableComponent>(player);
 
-    // Deactivate any map objects from the old map.
-    for (id_type prototype : oldMappable.objects)
+    if (playable.mapId == oldMap)
     {
-      leaveActiveMap(prototype);
+      leaveActiveMap(player);
     }
+  }
+}
 
-    // Deactivate players that were on the old map.
-    for (id_type player : players)
-    {
-      auto& playable = game_.getEntityManager().
-        getComponent<PlayableComponent>(player);
+void RealizingSystem::activateMap(id_type mapEntity)
+{
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+  auto& pondering = game_.getSystemManager().getSystem<PonderingSystem>();
 
-      if (playable.mapId == oldMap)
-      {
-        leaveActiveMap(player);
-      }
-    }
-  }
+  std::set<id_type> players =
+    game_.getEntityManager().getEntitiesWithComponents<
+      PlayableComponent>();
 
-  realizable.hasActiveMap = true;
-  realizable.activeMap = mapEntity;
+  activeMap_ = mapEntity;
 
   auto& mappable = game_.getEntityManager().
     getComponent<MappableComponent>(mapEntity);
@@ -2,29 +2,56 @@
 #define REALIZING_H_6853748C
 
 #include <string>
+#include <map>
 #include "system.h"
+#include "vector.h"
 
 class RealizingSystem : public System {
 public:
 
-  RealizingSystem(Game& game) : System(game)
-  {
-  }
-
   /**
-   * Creates the singleton realizable entity and initializes it with the
-   * provided world definition and map object prototype definition.
+   * Constructs the realizing system.
+   *
+   * Note that this must be constructed after the following system:
+   * - Mapping
+   * - Animating
+   * - Pondering
+   * - Scripting
    */
-  id_type initSingleton(
+  RealizingSystem(
+    Game& game,
     std::string worldFile,
     std::string prototypeFile);
 
-  /**
-   * Helper method that returns the entity ID of the (assumed) singleton entity
-   * with a RealizableComponent. Throws an exception if the number of realizable
-   * entities is not exactly one.
-   */
-  id_type getSingleton() const;
+  id_type getActiveMap() const
+  {
+    return activeMap_;
+  }
+
+  int getStartingMapId() const
+  {
+    return startingMapId_;
+  }
+
+  vec2i getStartingPos() const
+  {
+    return startingPos_;
+  }
+
+  id_type getEntityByMapId(size_t mapId) const
+  {
+    return entityByMapId_.at(mapId);
+  }
+
+  id_type getActivePlayer() const
+  {
+    return activePlayer_;
+  }
+
+  void setActivePlayer(id_type entity)
+  {
+    activePlayer_ = entity;
+  }
 
   /**
    * Loads the given map.
@@ -41,6 +68,19 @@ public:
    */
   void leaveActiveMap(id_type entity);
 
+private:
+
+  void deactivateMap();
+
+  void activateMap(id_type mapEntity);
+
+  std::string worldFile_;
+  std::string prototypeFile_;
+  int startingMapId_;
+  vec2i startingPos_;
+  std::map<size_t, id_type> entityByMapId_;
+  id_type activeMap_;
+  id_type activePlayer_;
 };
 
 #endif /* end of include guard: REALIZING_H_6853748C */
@@ -2,7 +2,6 @@
 #include "game.h"
 #include "components/runnable.h"
 #include "components/ponderable.h"
-#include "components/realizable.h"
 #include "components/transformable.h"
 #include "components/playable.h"
 #include "components/mappable.h"
@@ -24,9 +23,9 @@ ScriptingSystem::ScriptingSystem(Game& game) : System(game)
 {
   id_type entity = game_.getEntityManager().emplaceEntity();
 
-  engine.open_libraries(sol::lib::base, sol::lib::coroutine);
+  engine_.open_libraries(sol::lib::base, sol::lib::coroutine);
 
-  engine.new_usertype<vec2d>(
+  engine_.new_usertype<vec2d>(
     "vec2d",
     sol::constructors<vec2d(), vec2d(double, double)>(),
     "x", sol::property(
@@ -36,13 +35,13 @@ ScriptingSystem::ScriptingSystem(Game& game) : System(game)
       [] (vec2d& v) -> double { return v.y(); },
       [] (vec2d& v, double y) { v.y() = y; }));
 
-  engine.new_usertype<vec2i>(
+  engine_.new_usertype<vec2i>(
     "vec2i",
     sol::constructors<vec2i(), vec2i(int, int)>(),
     "x", [] (vec2i& v) -> int& { return v.x(); },
     "y", [] (vec2i& v) -> int& { return v.y(); });
 
-  engine.new_usertype<script_entity>(
+  engine_.new_usertype<script_entity>(
     "entity",
     sol::constructors<script_entity(id_type)>(),
     "id", &script_entity::id,
@@ -66,62 +65,50 @@ ScriptingSystem::ScriptingSystem(Game& game) : System(game)
         return game_.getEntityManager().
           getComponent<PlayableComponent>(entity.id);
       },
-    "realizable",
-      [&] (script_entity& entity) -> RealizableComponent& {
-        return game_.getEntityManager().
-          getComponent<RealizableComponent>(entity.id);
-      },
     "prototypable",
       [&] (script_entity& entity) -> PrototypableComponent& {
         return game_.getEntityManager().
           getComponent<PrototypableComponent>(entity.id);
       });
 
-  engine.new_usertype<TransformableComponent>(
+  engine_.new_usertype<TransformableComponent>(
     "transformable",
     "pos", &TransformableComponent::pos);
 
-  engine.new_usertype<PonderableComponent>(
+  engine_.new_usertype<PonderableComponent>(
     "ponderable",
     "vel", &PonderableComponent::vel,
     "accel", &PonderableComponent::accel);
 
-  engine.new_usertype<MappableComponent>(
+  engine_.new_usertype<MappableComponent>(
     "mappable",
     "mapId", &MappableComponent::mapId);
 
-  engine.new_usertype<PlayableComponent>(
+  engine_.new_usertype<PlayableComponent>(
     "playable",
     "checkpointPos", &PlayableComponent::checkpointPos,
     "checkpointMapId", &PlayableComponent::checkpointMapId,
     "checkpointMapObject", &PlayableComponent::checkpointMapObject,
     "checkpointMapObjectIndex", &PlayableComponent::checkpointMapObjectIndex);
 
-  engine.new_usertype<RealizableComponent>(
-    "realizable",
-    "activeMap", &RealizableComponent::activeMap);
-
-  engine.new_usertype<PrototypableComponent>(
+  engine_.new_usertype<PrototypableComponent>(
     "prototypable",
     "mapObjectIndex", &PrototypableComponent::mapObjectIndex,
     "prototypeId", &PrototypableComponent::prototypeId);
 
-  engine.new_usertype<RealizingSystem>(
+  engine_.new_usertype<RealizingSystem>(
     "realizing",
-    "singleton",
-      [&] (RealizingSystem& realizing) -> script_entity {
-        return realizing.getSingleton();
-      });
+    "activeMap", sol::property(&RealizingSystem::getActiveMap));
 
-  engine.set_function(
+  engine_.set_function(
     "realizing",
     [&] () {
       return game_.getSystemManager().getSystem<RealizingSystem>();
     });
 
-  engine.script_file("scripts/common.lua");
-  engine.script_file("scripts/movplat.lua");
-  engine.script_file("scripts/checkpoint.lua");
+  engine_.script_file("scripts/common.lua");
+  engine_.script_file("scripts/movplat.lua");
+  engine_.script_file("scripts/checkpoint.lua");
 }
 
 void ScriptingSystem::tick(double dt)
@@ -177,7 +164,7 @@ EntityManager::id_type ScriptingSystem::runScript(
     std::unique_ptr<sol::thread>(
       new sol::thread(
         sol::thread::create(
-          engine.lua_state())));
+          engine_.lua_state())));
 
   runnable.callable =
     std::unique_ptr<sol::coroutine>(
@@ -22,7 +22,7 @@ private:
   template <typename... Args>
   id_type runScript(std::string event, id_type entity, Args&&... args);
 
-  sol::state engine;
+  sol::state engine_;
 };
 
 #endif /* end of include guard: AUTOMATING_H_E6E5D76E */