1 files changed, 102 insertions, 118 deletions

@@ -5,61 +5,17 @@
 #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"
 #include "systems/scheduling.h"
 #include "systems/controlling.h"
+#include "systems/animating.h"
+#include "systems/realizing.h"
 #include "animation.h"
 #include "muxer.h"
 
-void PlayingSystem::tick(double)
-{
-  // Check if we need to change the map
-  auto players = game_.getEntityManager().getEntitiesWithComponents<
-    PlayableComponent,
-    TransformableComponent>();
-
-  for (id_type player : players)
-  {
-    auto& playable = game_.getEntityManager().
-      getComponent<PlayableComponent>(player);
-
-    if (playable.changingMap)
-    {
-      // Change the map!
-      auto entities = game_.getEntityManager().getEntities();
-
-      for (id_type entity : entities)
-      {
-        if (entity != player)
-        {
-          game_.getEntityManager().deleteEntity(entity);
-        }
-      }
-
-      game_.getSystemManager().getSystem<MappingSystem>().
-        loadMap(playable.newMapId);
-
-      auto& transformable = game_.getEntityManager().
-        getComponent<TransformableComponent>(player);
-
-      transformable.setX(playable.newMapX);
-      transformable.setY(playable.newMapY);
-
-      playable.changingMap = false;
-
-      if (playable.newMapCallback)
-      {
-        playable.newMapCallback();
-        playable.newMapCallback = nullptr;
-      }
-
-      break;
-    }
-  }
-}
-
 void PlayingSystem::initPlayer()
 {
   id_type player = game_.getEntityManager().emplaceEntity();
@@ -72,15 +28,24 @@ void PlayingSystem::initPlayer()
 
   game_.getEntityManager().emplaceComponent<AnimatableComponent>(
     player,
-    std::move(playerGraphics),
-    "stillLeft");
+    std::move(playerGraphics));
 
-  game_.getEntityManager().emplaceComponent<TransformableComponent>(
+  game_.getSystemManager().getSystem<AnimatingSystem>().startAnimation(
     player,
-    game_.getWorld().getStartingX(),
-    game_.getWorld().getStartingY(),
-    10,
-    12);
+    "stillLeft");
+
+  auto& realizing = game_.getSystemManager().getSystem<RealizingSystem>();
+
+  auto& realizable = game_.getEntityManager().
+    getComponent<RealizableComponent>(realizing.getSingleton());
+
+  auto& transformable = game_.getEntityManager().
+    emplaceComponent<TransformableComponent>(player);
+
+  transformable.x = realizable.startingX;
+  transformable.y = realizable.startingY;
+  transformable.w = 10;
+  transformable.h = 12;
 
   game_.getSystemManager().getSystem<PonderingSystem>().initializeBody(
     player,
@@ -92,84 +57,103 @@ void PlayingSystem::initPlayer()
   auto& playable = game_.getEntityManager().
     emplaceComponent<PlayableComponent>(player);
 
-  playable.checkpointMapId = game_.getWorld().getStartingMapId();
-  playable.checkpointX = game_.getWorld().getStartingX();
-  playable.checkpointY = game_.getWorld().getStartingY();
+  playable.mapId = realizable.activeMap;
+  playable.checkpointMapId = realizable.startingMapId;
+  playable.checkpointX = realizable.startingX;
+  playable.checkpointY = realizable.startingY;
+
+  realizing.enterActiveMap(player);
+
+  realizable.activePlayer = player;
 }
 
 void PlayingSystem::changeMap(
+  id_type player,
   size_t mapId,
   double x,
-  double y,
-  PlayableComponent::MapChangeCallback callback)
+  double y)
 {
-  auto players = game_.getEntityManager().getEntitiesWithComponents<
-    PlayableComponent>();
+  auto& playable = game_.getEntityManager().
+    getComponent<PlayableComponent>(player);
 
-  for (id_type player : players)
+  auto& transformable = game_.getEntityManager().
+    getComponent<TransformableComponent>(player);
+
+  auto& animatable = game_.getEntityManager().
+    getComponent<AnimatableComponent>(player);
+
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(player);
+
+  auto& realizing = game_.getSystemManager().getSystem<RealizingSystem>();
+
+  auto& realizable = game_.getEntityManager().
+    getComponent<RealizableComponent>(realizing.getSingleton());
+
+  id_type newMapEntity = realizable.entityByMapId[mapId];
+
+  if (playable.mapId != newMapEntity)
   {
-    auto& playable = game_.getEntityManager().
-      getComponent<PlayableComponent>(player);
+    if (playable.mapId == realizable.activeMap)
+    {
+      realizing.leaveActiveMap(player);
+    } else if (newMapEntity == realizable.activeMap)
+    {
+      realizing.enterActiveMap(player);
+    }
 
-    playable.changingMap = true;
-    playable.newMapId = mapId;
-    playable.newMapX = x;
-    playable.newMapY = y;
-    playable.newMapCallback = std::move(callback);
+    playable.mapId = newMapEntity;
+  }
+
+  transformable.x = x;
+  transformable.y = y;
+
+  if (realizable.activePlayer == player)
+  {
+    realizing.loadMap(newMapEntity);
   }
 }
 
-void PlayingSystem::die()
+void PlayingSystem::die(id_type player)
 {
   playSound("res/Hit_Hurt5.wav", 0.25);
 
-  auto players = game_.getEntityManager().getEntitiesWithComponents<
-    OrientableComponent,
-    ControllableComponent,
-    AnimatableComponent,
-    PonderableComponent,
-    PlayableComponent>();
+  auto& animatable = game_.getEntityManager().
+    getComponent<AnimatableComponent>(player);
 
-  for (id_type player : players)
-  {
-    auto& animatable = game_.getEntityManager().
-      getComponent<AnimatableComponent>(player);
-
-    auto& ponderable = game_.getEntityManager().
-      getComponent<PonderableComponent>(player);
-
-    auto& controlling = game_.getSystemManager().getSystem<ControllingSystem>();
-    controlling.freeze(player);
-
-    animatable.setFrozen(true);
-    animatable.setFlickering(true);
-    ponderable.setFrozen(true);
-    ponderable.setCollidable(false);
-
-    auto& scheduling = game_.getSystemManager().getSystem<SchedulingSystem>();
-
-    scheduling.schedule(player, 0.75, [&] (id_type player) {
-      auto& playable = game_.getEntityManager().
-        getComponent<PlayableComponent>(player);
-
-      changeMap(
-        playable.checkpointMapId,
-        playable.checkpointX,
-        playable.checkpointY,
-        [&, player] () {
-          animatable.setFrozen(false);
-          animatable.setFlickering(false);
-          ponderable.setFrozen(false);
-          ponderable.setCollidable(true);
-
-          // Reset the walk state, and then potentially let the
-          // ControllingSystem set it again.
-          auto& orienting = game_.getSystemManager().
-            getSystem<OrientingSystem>();
-          orienting.stopWalking(player);
-
-          controlling.unfreeze(player);
-        });
-    });
-  }
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(player);
+
+  auto& controlling = game_.getSystemManager().getSystem<ControllingSystem>();
+  controlling.freeze(player);
+
+  animatable.frozen = true;
+  animatable.flickering = true;
+  ponderable.frozen = true;
+  ponderable.collidable = false;
+
+  auto& scheduling = game_.getSystemManager().getSystem<SchedulingSystem>();
+
+  scheduling.schedule(player, 0.75, [&] (id_type player) {
+    auto& playable = game_.getEntityManager().
+      getComponent<PlayableComponent>(player);
+
+    changeMap(
+      player,
+      playable.checkpointMapId,
+      playable.checkpointX,
+      playable.checkpointY);
+
+    animatable.frozen = false;
+    animatable.flickering = false;
+    ponderable.frozen = false;
+    ponderable.collidable = true;
+
+    // Reset the walk state, and then potentially let the
+    // ControllingSystem set it again.
+    auto& orienting = game_.getSystemManager().getSystem<OrientingSystem>();
+    orienting.stopWalking(player);
+
+    controlling.unfreeze(player);
+  });
 }