1 files changed, 199 insertions, 155 deletions

@@ -5,149 +5,153 @@
 #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"
+#include "systems/realizing.h"
 #include "consts.h"
 #include "collision.h"
 
 void PonderingSystem::tick(double dt)
 {
+  auto& realizable = game_.getEntityManager().
+    getComponent<RealizableComponent>(
+      game_.getSystemManager().getSystem<RealizingSystem>().getSingleton());
+
+  id_type mapEntity = realizable.activeMap;
+
+  auto& mappable = game_.getEntityManager().
+    getComponent<MappableComponent>(mapEntity);
+
   auto entities = game_.getEntityManager().getEntitiesWithComponents<
     PonderableComponent,
     TransformableComponent>();
 
-  auto maps = game_.getEntityManager().getEntitiesWithComponents<
-    MappableComponent>();
-
   for (id_type entity : entities)
   {
-    auto& transformable = game_.getEntityManager().
-      getComponent<TransformableComponent>(entity);
-
     auto& ponderable = game_.getEntityManager().
       getComponent<PonderableComponent>(entity);
 
-    if (ponderable.isFrozen())
+    if (!ponderable.active || ponderable.frozen)
     {
       continue;
     }
 
-    // Accelerate
-    ponderable.setVelocityX(
-      ponderable.getVelocityX() + ponderable.getAccelX() * dt);
+    auto& transformable = game_.getEntityManager().
+      getComponent<TransformableComponent>(entity);
 
-    ponderable.setVelocityY(
-      ponderable.getVelocityY() + ponderable.getAccelY() * dt);
+    // Accelerate
+    ponderable.velX += ponderable.accelX * dt;
+    ponderable.velY += ponderable.accelY * dt;
 
-    if ((ponderable.getType() == PonderableComponent::Type::freefalling)
-      && (ponderable.getVelocityY() > TERMINAL_VELOCITY))
+    if ((ponderable.type == PonderableComponent::Type::freefalling)
+      && (ponderable.velY > TERMINAL_VELOCITY))
     {
-      ponderable.setVelocityY(TERMINAL_VELOCITY);
+      ponderable.velY = TERMINAL_VELOCITY;
     }
 
-    const double oldX = transformable.getX();
-    const double oldY = transformable.getY();
-    const double oldRight = oldX + transformable.getW();
-    const double oldBottom = oldY + transformable.getH();
+    const double oldX = transformable.x;
+    const double oldY = transformable.y;
+    const double oldRight = oldX + transformable.w;
+    const double oldBottom = oldY + transformable.h;
 
-    double newX = oldX + ponderable.getVelocityX() * dt;
-    double newY = oldY + ponderable.getVelocityY() * dt;
+    double newX = oldX + ponderable.velX * dt;
+    double newY = oldY + ponderable.velY * dt;
 
-    bool oldGrounded = ponderable.isGrounded();
-    ponderable.setGrounded(false);
+    bool oldGrounded = ponderable.grounded;
+    ponderable.grounded = false;
 
     std::priority_queue<Collision> collisions;
 
     // Find collisions
-    for (id_type mapEntity : maps)
+    if (newX < oldX)
     {
-      auto& mappable = game_.getEntityManager().
-        getComponent<MappableComponent>(mapEntity);
-
-      if (newX < oldX)
+      for (auto it = mappable.leftBoundaries.lower_bound(oldX);
+        (it != std::end(mappable.leftBoundaries)) && (it->first >= newX);
+        it++)
       {
-        for (auto it = mappable.getLeftBoundaries().lower_bound(oldX);
-          (it != std::end(mappable.getLeftBoundaries())) && (it->first >= newX);
-          it++)
+        if ((oldBottom > it->second.lower)
+          && (oldY < it->second.upper))
         {
-          if ((oldBottom > it->second.getLower())
-            && (oldY < it->second.getUpper()))
-          {
-            // We have a collision!
-            collisions.emplace(
-              mapEntity,
-              Direction::left,
-              it->second.getType(),
-              it->first,
-              it->second.getLower(),
-              it->second.getUpper());
-          }
+          // We have a collision!
+          collisions.emplace(
+            mapEntity,
+            Direction::left,
+            it->second.type,
+            it->first,
+            it->second.lower,
+            it->second.upper);
         }
-      } else if (newX > oldX)
+      }
+    } else if (newX > oldX)
+    {
+      for (auto it = mappable.rightBoundaries.lower_bound(oldRight);
+        (it != std::end(mappable.rightBoundaries))
+          && (it->first <= (newX + transformable.w));
+        it++)
       {
-        for (auto it = mappable.getRightBoundaries().lower_bound(oldRight);
-          (it != std::end(mappable.getRightBoundaries()))
-            && (it->first <= (newX + transformable.getW()));
-          it++)
+        if ((oldBottom > it->second.lower)
+          && (oldY < it->second.upper))
         {
-          if ((oldBottom > it->second.getLower())
-            && (oldY < it->second.getUpper()))
-          {
-            // We have a collision!
-            collisions.emplace(
-              mapEntity,
-              Direction::right,
-              it->second.getType(),
-              it->first,
-              it->second.getLower(),
-              it->second.getUpper());
-          }
+          // We have a collision!
+          collisions.emplace(
+            mapEntity,
+            Direction::right,
+            it->second.type,
+            it->first,
+            it->second.lower,
+            it->second.upper);
         }
       }
+    }
 
-      if (newY < oldY)
+    if (newY < oldY)
+    {
+      for (auto it = mappable.upBoundaries.lower_bound(oldY);
+        (it != std::end(mappable.upBoundaries)) && (it->first >= newY);
+        it++)
       {
-        for (auto it = mappable.getUpBoundaries().lower_bound(oldY);
-          (it != std::end(mappable.getUpBoundaries())) && (it->first >= newY);
-          it++)
+        if ((oldRight > it->second.lower)
+          && (oldX < it->second.upper))
         {
-          if ((oldRight > it->second.getLower())
-            && (oldX < it->second.getUpper()))
-          {
-            // We have a collision!
-            collisions.emplace(
-              mapEntity,
-              Direction::up,
-              it->second.getType(),
-              it->first,
-              it->second.getLower(),
-              it->second.getUpper());
-          }
+          // We have a collision!
+          collisions.emplace(
+            mapEntity,
+            Direction::up,
+            it->second.type,
+            it->first,
+            it->second.lower,
+            it->second.upper);
         }
-      } else if (newY > oldY)
+      }
+    } else if (newY > oldY)
+    {
+      for (auto it = mappable.downBoundaries.lower_bound(oldBottom);
+        (it != std::end(mappable.downBoundaries))
+          && (it->first <= (newY + transformable.h));
+        it++)
       {
-        for (auto it = mappable.getDownBoundaries().lower_bound(oldBottom);
-          (it != std::end(mappable.getDownBoundaries()))
-            && (it->first <= (newY + transformable.getH()));
-          it++)
+        if ((oldRight > it->second.lower)
+          && (oldX < it->second.upper))
         {
-          if ((oldRight > it->second.getLower())
-            && (oldX < it->second.getUpper()))
-          {
-            // We have a collision!
-            collisions.emplace(
-              mapEntity,
-              Direction::down,
-              it->second.getType(),
-              it->first,
-              it->second.getLower(),
-              it->second.getUpper());
-          }
+          // We have a collision!
+          collisions.emplace(
+            mapEntity,
+            Direction::down,
+            it->second.type,
+            it->first,
+            it->second.lower,
+            it->second.upper);
         }
       }
     }
 
     // Process collisions in order of priority
+    bool adjacentlyWarping = false;
+    Direction adjWarpDir;
+    size_t adjWarpMapId;
+
     while (!collisions.empty())
     {
       Collision collision = collisions.top();
@@ -157,8 +161,8 @@ void PonderingSystem::tick(double dt)
       if (!collision.isColliding(
         newX,
         newY,
-        transformable.getW(),
-        transformable.getH()))
+        transformable.w,
+        transformable.h))
       {
         continue;
       }
@@ -201,33 +205,33 @@ void PonderingSystem::tick(double dt)
         {
           auto& mappable = game_.getEntityManager().
             getComponent<MappableComponent>(collision.getCollider());
-          const Map& map = game_.getWorld().getMap(mappable.getMapId());
-          auto& adj = [&] () -> const Map::Adjacent& {
+
+          auto& adj = [&] () -> const MappableComponent::Adjacent& {
               switch (collision.getDirection())
               {
-                case Direction::left: return map.getLeftAdjacent();
-                case Direction::right: return map.getRightAdjacent();
-                case Direction::up: return map.getUpAdjacent();
-                case Direction::down: return map.getDownAdjacent();
+                case Direction::left: return mappable.leftAdjacent;
+                case Direction::right: return mappable.rightAdjacent;
+                case Direction::up: return mappable.upAdjacent;
+                case Direction::down: return mappable.downAdjacent;
               }
             }();
 
-          switch (adj.getType())
+          switch (adj.type)
           {
-            case Map::Adjacent::Type::wall:
+            case MappableComponent::Adjacent::Type::wall:
             {
               touchedWall = true;
 
               break;
             }
 
-            case Map::Adjacent::Type::wrap:
+            case MappableComponent::Adjacent::Type::wrap:
             {
               switch (collision.getDirection())
               {
                 case Direction::left:
                 {
-                  newX = GAME_WIDTH + WALL_GAP - transformable.getW();
+                  newX = GAME_WIDTH + WALL_GAP - transformable.w;
 
                   break;
                 }
@@ -241,8 +245,7 @@ void PonderingSystem::tick(double dt)
 
                 case Direction::up:
                 {
-                  newY = MAP_HEIGHT * TILE_HEIGHT + WALL_GAP -
-                    transformable.getH();
+                  newY = MAP_HEIGHT * TILE_HEIGHT + WALL_GAP - transformable.h;
 
                   break;
                 }
@@ -256,46 +259,22 @@ void PonderingSystem::tick(double dt)
               }
             }
 
-            case Map::Adjacent::Type::warp:
+            case MappableComponent::Adjacent::Type::warp:
             {
-              double warpX = newX;
-              double warpY = newY;
-
-              switch (collision.getDirection())
+              if (game_.getEntityManager().
+                hasComponent<PlayableComponent>(entity))
               {
-                case Direction::left:
-                {
-                  warpX = GAME_WIDTH + WALL_GAP - transformable.getW();
-
-                  break;
-                }
-
-                case Direction::right:
-                {
-                  warpX = -WALL_GAP;
-
-                  break;
-                }
-
-                case Direction::up:
-                {
-                  warpY = MAP_HEIGHT * TILE_HEIGHT - transformable.getH();
-
-                  break;
-                }
-
-                case Direction::down:
-                {
-                  warpY = -WALL_GAP;
-
-                  break;
-                }
+                adjacentlyWarping = true;
+                adjWarpDir = collision.getDirection();
+                adjWarpMapId = adj.mapId;
               }
 
-              game_.getSystemManager().getSystem<PlayingSystem>().
-                changeMap(adj.getMapId(), warpX, warpY);
+              break;
+            }
 
-              stopProcessing = true;
+            case MappableComponent::Adjacent::Type::reverse:
+            {
+              // TODO: not yet implemented.
 
               break;
             }
@@ -306,7 +285,13 @@ void PonderingSystem::tick(double dt)
 
         case Collision::Type::danger:
         {
-          game_.getSystemManager().getSystem<PlayingSystem>().die();
+          if (game_.getEntityManager().
+            hasComponent<PlayableComponent>(entity))
+          {
+            game_.getSystemManager().getSystem<PlayingSystem>().die(entity);
+
+            adjacentlyWarping = false;
+          }
 
           stopProcessing = true;
 
@@ -333,15 +318,15 @@ void PonderingSystem::tick(double dt)
           case Direction::left:
           {
             newX = collision.getAxis();
-            ponderable.setVelocityX(0.0);
+            ponderable.velX = 0.0;
 
             break;
           }
 
           case Direction::right:
           {
-            newX = collision.getAxis() - transformable.getW();
-            ponderable.setVelocityX(0.0);
+            newX = collision.getAxis() - transformable.w;
+            ponderable.velX = 0.0;
 
             break;
           }
@@ -349,16 +334,16 @@ void PonderingSystem::tick(double dt)
           case Direction::up:
           {
             newY = collision.getAxis();
-            ponderable.setVelocityY(0.0);
+            ponderable.velY = 0.0;
 
             break;
           }
 
           case Direction::down:
           {
-            newY = collision.getAxis() - transformable.getH();
-            ponderable.setVelocityY(0.0);
-            ponderable.setGrounded(true);
+            newY = collision.getAxis() - transformable.h;
+            ponderable.velY = 0.0;
+            ponderable.grounded = true;
 
             break;
           }
@@ -367,8 +352,8 @@ void PonderingSystem::tick(double dt)
     }
 
     // Move
-    transformable.setX(newX);
-    transformable.setY(newY);
+    transformable.x = newX;
+    transformable.y = newY;
 
     // Perform cleanup for orientable entites
     if (game_.getEntityManager().hasComponent<OrientableComponent>(entity))
@@ -377,9 +362,9 @@ void PonderingSystem::tick(double dt)
         getComponent<OrientableComponent>(entity);
 
       // Handle changes in groundedness
-      if (ponderable.isGrounded() != oldGrounded)
+      if (ponderable.grounded != oldGrounded)
       {
-        if (ponderable.isGrounded())
+        if (ponderable.grounded)
         {
           game_.getSystemManager().getSystem<OrientingSystem>().land(entity);
         } else {
@@ -394,6 +379,51 @@ void PonderingSystem::tick(double dt)
         orientable.setDropState(OrientableComponent::DropState::none);
       }
     }
+
+    // Move to an adjacent map, if necessary
+    if (adjacentlyWarping)
+    {
+      double warpX = newX;
+      double warpY = newY;
+
+      switch (adjWarpDir)
+      {
+        case Direction::left:
+        {
+          warpX = GAME_WIDTH + WALL_GAP - transformable.w;
+
+          break;
+        }
+
+        case Direction::right:
+        {
+          warpX = -WALL_GAP;
+
+          break;
+        }
+
+        case Direction::up:
+        {
+          warpY = MAP_HEIGHT * TILE_HEIGHT - transformable.h;
+
+          break;
+        }
+
+        case Direction::down:
+        {
+          warpY = -WALL_GAP;
+
+          break;
+        }
+      }
+
+      game_.getSystemManager().getSystem<PlayingSystem>().
+        changeMap(
+          entity,
+          adjWarpMapId,
+          warpX,
+          warpY);
+    }
   }
 }
 
@@ -406,6 +436,20 @@ void PonderingSystem::initializeBody(
 
   if (type == PonderableComponent::Type::freefalling)
   {
-    ponderable.setAccelY(NORMAL_GRAVITY);
+    ponderable.accelY = NORMAL_GRAVITY;
   }
 }
+
+void PonderingSystem::initPrototype(id_type prototype)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(prototype);
+
+  ponderable.velX = 0.0;
+  ponderable.velY = 0.0;
+  ponderable.accelX = 0.0;
+  ponderable.accelY = 0.0;
+  ponderable.grounded = false;
+  ponderable.frozen = false;
+  ponderable.collidable = true;
+}