2 files changed, 533 insertions, 595 deletions

@@ -96,15 +96,6 @@ void PonderingSystem::tickBody(
     return;
   }
 
-  auto& realizable = game_.getEntityManager().
-    getComponent<RealizableComponent>(
-      game_.getSystemManager().getSystem<RealizingSystem>().getSingleton());
-
-  id_type mapEntity = realizable.activeMap;
-
-  auto& mappable = game_.getEntityManager().
-    getComponent<MappableComponent>(mapEntity);
-
   auto& transformable = game_.getEntityManager().
     getComponent<TransformableComponent>(entity);
 
@@ -121,14 +112,9 @@ void PonderingSystem::tickBody(
     }
   }
 
-  const double oldX = transformable.x;
-  const double oldY = transformable.y;
-  const double oldRight = oldX + transformable.w;
-  const double oldBottom = oldY + transformable.h;
-
-  CollisionResult result;
-  result.newX = transformable.x;
-  result.newY = transformable.y;
+  // Move
+  double newX = transformable.x;
+  double newY = transformable.y;
 
   if (!ponderable.frozen)
   {
@@ -137,692 +123,626 @@ void PonderingSystem::tickBody(
       auto& ferryTrans = game_.getEntityManager().
         getComponent<TransformableComponent>(ponderable.ferry);
 
-      result.newX = ferryTrans.x + ponderable.relX;
-      result.newY = ferryTrans.y + ponderable.relY;
+      newX = ferryTrans.x + ponderable.relX;
+      newY = ferryTrans.y + ponderable.relY;
     }
 
-    result.newX += ponderable.velX * dt;
-    result.newY += ponderable.velY * dt;
+    newX += ponderable.velX * dt;
+    newY += ponderable.velY * dt;
   }
 
-  bool oldGrounded = ponderable.grounded;
-  ponderable.grounded = false;
+  CollisionResult result =
+    moveBody(
+      entity,
+      newX,
+      newY);
 
-  if (ponderable.collidable)
+  // Perform cleanup for orientable entites
+  bool groundedChanged = (ponderable.grounded != result.grounded);
+  ponderable.grounded = result.grounded;
+
+  if (game_.getEntityManager().hasComponent<OrientableComponent>(entity))
   {
-    // Find horizontal collisions.
-    if (result.newX < oldX)
-    {
-      bool boundaryCollision = false;
-      auto it = mappable.leftBoundaries.lower_bound(oldX);
+    auto& orientable = game_.getEntityManager().
+      getComponent<OrientableComponent>(entity);
 
-      // Find the axis distance of the closest environmental boundary.
-      for (;
-          (it != std::end(mappable.leftBoundaries)) &&
-            (it->first >= result.newX);
-          it++)
+    // Handle changes in groundedness
+    if (groundedChanged)
+    {
+      if (ponderable.grounded)
       {
-        // Check that the boundary is in range for the other axis.
-        if ((oldBottom > it->second.lower) && (oldY < it->second.upper))
-        {
-          // We have a collision!
-          boundaryCollision = true;
-
-          break;
-        }
+        game_.getSystemManager().getSystem<OrientingSystem>().land(entity);
+      } else {
+        game_.getSystemManager().
+          getSystem<OrientingSystem>().startFalling(entity);
       }
+    }
 
-      // Find a list of potential colliders, sorted so that the closest is
-      // first.
-      std::vector<id_type> colliders;
+    // Complete dropping, if necessary
+    if (orientable.getDropState() == OrientableComponent::DropState::active)
+    {
+      orientable.setDropState(OrientableComponent::DropState::none);
+    }
+  }
 
-      for (id_type collider : entities)
-      {
-        // Can't collide with self.
-        if (collider == entity)
-        {
-          continue;
-        }
+  // Ferry or unferry as necessary
+  if ((ponderable.type == PonderableComponent::Type::freefalling) &&
+      groundedChanged)
+  {
+    if (ponderable.grounded &&
+        game_.getEntityManager().
+          hasComponent<PonderableComponent>(result.groundEntity))
+    {
+      // The body is now being ferried
+      auto& ferryPonder = game_.getEntityManager().
+        getComponent<PonderableComponent>(result.groundEntity);
+
+      ponderable.ferried = true;
+      ponderable.ferry = result.groundEntity;
 
-        auto& colliderPonder = game_.getEntityManager().
-          getComponent<PonderableComponent>(collider);
+      ferryPonder.passengers.insert(entity);
+    } else if (ponderable.ferried)
+    {
+      // The body is no longer being ferried
+      unferry(entity);
+    }
+  }
 
-        // Only check objects that are active and collidable.
-        if (!colliderPonder.active || !colliderPonder.collidable)
-        {
-          continue;
-        }
+  // Update a ferry passenger's relative position
+  if (ponderable.ferried)
+  {
+    auto& ferryTrans = game_.getEntityManager().
+      getComponent<TransformableComponent>(ponderable.ferry);
 
-        auto& colliderTrans = game_.getEntityManager().
-          getComponent<TransformableComponent>(collider);
-
-        // Check if the entity would move into the potential collider,
-        if ((colliderTrans.x + colliderTrans.w > result.newX) &&
-            // that it wasn't already colliding,
-            (colliderTrans.x + colliderTrans.w <= oldX) &&
-            // that the position on the other axis is in range,
-            (colliderTrans.y + colliderTrans.h > oldY) &&
-            (colliderTrans.y < oldBottom) &&
-            // and that the collider is not farther away than the environmental
-            // boundary.
-            (!boundaryCollision ||
-              (colliderTrans.x + colliderTrans.w >= it->first)))
-        {
-          colliders.push_back(collider);
-        }
-      }
+    ponderable.relX = transformable.x - ferryTrans.x;
+    ponderable.relY = transformable.y - ferryTrans.y;
+  }
 
-      std::sort(
-        std::begin(colliders),
-        std::end(colliders),
-        [&] (id_type left, id_type right) {
-          auto& leftTrans = game_.getEntityManager().
-            getComponent<TransformableComponent>(left);
+  // Handle ferry passengers
+  std::set<id_type> passengers = ponderable.passengers;
 
-          auto& rightTrans = game_.getEntityManager().
-            getComponent<TransformableComponent>(right);
+  for (id_type passenger : passengers)
+  {
+    tickBody(
+      passenger,
+      dt,
+      entities);
+  }
 
-          return (rightTrans.x < leftTrans.x);
-        });
+  // Move to an adjacent map, if necessary
+  if (result.adjacentlyWarping)
+  {
+    double warpX = result.newX;
+    double warpY = result.newY;
 
-      for (id_type collider : colliders)
+    switch (result.adjWarpDir)
+    {
+      case Direction::left:
       {
-        auto& colliderTrans = game_.getEntityManager().
-          getComponent<TransformableComponent>(collider);
-
-        // Check if the entity would still move into the potential collider.
-        if (colliderTrans.x + colliderTrans.w <= result.newX)
-        {
-          break;
-        }
+        warpX = GAME_WIDTH + WALL_GAP - transformable.w;
 
-        auto& colliderPonder = game_.getEntityManager().
-          getComponent<PonderableComponent>(collider);
+        break;
+      }
 
-        processCollision(
-          entity,
-          collider,
-          Direction::left,
-          colliderPonder.colliderType,
-          colliderTrans.x + colliderTrans.w,
-          colliderTrans.y,
-          colliderTrans.y + colliderTrans.h,
-          result);
+      case Direction::right:
+      {
+        warpX = -WALL_GAP;
 
-        if (result.stopProcessing)
-        {
-          break;
-        }
+        break;
       }
 
-      // If movement hasn't been stopped by an intermediary object, and
-      // collision checking hasn't been stopped, process the environmental
-      // boundaries closest to the entity.
-      if (!result.stopProcessing && !result.touchedWall && boundaryCollision)
+      case Direction::up:
       {
-        double boundaryAxis = it->first;
+        warpY = MAP_HEIGHT * TILE_HEIGHT - transformable.h;
 
-        for (;
-            (it != std::end(mappable.leftBoundaries)) &&
-              (it->first == boundaryAxis);
-            it++)
-        {
-          if ((oldBottom > it->second.lower) && (oldY < it->second.upper))
-          {
-            processCollision(
-              entity,
-              mapEntity,
-              Direction::left,
-              it->second.type,
-              it->first,
-              it->second.lower,
-              it->second.upper,
-              result);
-
-            if (result.stopProcessing)
-            {
-              break;
-            }
-          }
-        }
+        break;
       }
-    } else if (result.newX > oldX)
-    {
-      bool boundaryCollision = false;
-      auto it = mappable.rightBoundaries.lower_bound(oldRight);
 
-      // Find the axis distance of the closest environmental boundary.
-      for (;
-          (it != std::end(mappable.rightBoundaries))
-            && (it->first <= (result.newX + transformable.w));
-          it++)
+      case Direction::down:
       {
-        // Check that the boundary is in range for the other axis.
-        if ((oldBottom > it->second.lower) && (oldY < it->second.upper))
-        {
-          // We have a collision!
-          boundaryCollision = true;
+        warpY = -WALL_GAP;
 
-          break;
-        }
+        break;
       }
+    }
 
-      // Find a list of potential colliders, sorted so that the closest is
-      // first.
-      std::vector<id_type> colliders;
-
-      for (id_type collider : entities)
-      {
-        // Can't collide with self.
-        if (collider == entity)
-        {
-          continue;
-        }
+    game_.getSystemManager().getSystem<PlayingSystem>().
+      changeMap(
+        entity,
+        result.adjWarpMapId,
+        warpX,
+        warpY);
+  }
+}
 
-        auto& colliderPonder = game_.getEntityManager().
-          getComponent<PonderableComponent>(collider);
+CollisionResult PonderingSystem::moveBody(
+  id_type entity,
+  double x,
+  double y)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
 
-        // Only check objects that are active and collidable.
-        if (!colliderPonder.active || !colliderPonder.collidable)
-        {
-          continue;
-        }
+  auto& transformable = game_.getEntityManager().
+    getComponent<TransformableComponent>(entity);
 
-        auto& colliderTrans = game_.getEntityManager().
-          getComponent<TransformableComponent>(collider);
-
-        // Check if the entity would move into the potential collider,
-        if ((colliderTrans.x < result.newX + transformable.w) &&
-            // that it wasn't already colliding,
-            (colliderTrans.x >= oldRight) &&
-            // that the position on the other axis is in range,
-            (colliderTrans.y + colliderTrans.h > oldY) &&
-            (colliderTrans.y < oldBottom) &&
-            // and that the collider is not farther away than the environmental
-            // boundary.
-            (!boundaryCollision || (colliderTrans.x <= it->first)))
-        {
-          colliders.push_back(collider);
-        }
-      }
+  const double oldX = transformable.x;
+  const double oldY = transformable.y;
+  const double oldRight = oldX + transformable.w;
+  const double oldBottom = oldY + transformable.h;
 
-      std::sort(
-        std::begin(colliders),
-        std::end(colliders),
-        [&] (id_type left, id_type right) {
-          auto& leftTrans = game_.getEntityManager().
-            getComponent<TransformableComponent>(left);
+  CollisionResult result;
 
-          auto& rightTrans = game_.getEntityManager().
-            getComponent<TransformableComponent>(right);
+  if (ponderable.collidable)
+  {
+    result = detectCollisions(entity, x, y);
+  } else {
+    result.newX = x;
+    result.newY = y;
+  }
 
-          return (leftTrans.x < rightTrans.x);
-        });
+  // Move
+  if (!ponderable.frozen)
+  {
+    transformable.x = result.newX;
+    transformable.y = result.newY;
+  }
 
-      for (id_type collider : colliders)
-      {
-        auto& colliderTrans = game_.getEntityManager().
-          getComponent<TransformableComponent>(collider);
+  return result;
+}
 
-        // Check if the entity would still move into the potential collider.
-        if (colliderTrans.x >= result.newX + transformable.w)
-        {
-          break;
-        }
+namespace CollisionParams {
 
-        auto& colliderPonder = game_.getEntityManager().
-          getComponent<PonderableComponent>(collider);
+  template <typename HorizVert>
+  class Desc : public HorizVert {
+  public:
 
-        processCollision(
-          entity,
-          collider,
-          Direction::right,
-          colliderPonder.colliderType,
-          colliderTrans.x,
-          colliderTrans.y,
-          colliderTrans.y + colliderTrans.h,
-          result);
+    inline static bool AtLeastInAxisSweep(
+      double boundaryAxis,
+      double entityAxis)
+    {
+      return (boundaryAxis >= entityAxis);
+    }
 
-        if (result.stopProcessing)
-        {
-          break;
-        }
-      }
+    inline static bool IsPastAxis(
+      double colliderAxis,
+      double entityAxis)
+    {
+      return (colliderAxis > entityAxis);
+    }
 
-      // If movement hasn't been stopped by an intermediary object, and
-      // collision checking hasn't been stopped, process the environmental
-      // boundaries closest to the entity.
-      if (!result.stopProcessing && !result.touchedWall && boundaryCollision)
-      {
-        double boundaryAxis = it->first;
+    inline static double OldAxis(const TransformableComponent& transformable)
+    {
+      return HorizVert::AxisOldLower(transformable);
+    }
 
-        for (;
-            (it != std::end(mappable.rightBoundaries)) &&
-              (it->first == boundaryAxis);
-            it++)
-        {
-          if ((oldBottom > it->second.lower) && (oldY < it->second.upper))
-          {
-            processCollision(
-              entity,
-              mapEntity,
-              Direction::right,
-              it->second.type,
-              it->first,
-              it->second.lower,
-              it->second.upper,
-              result);
-
-            if (result.stopProcessing)
-            {
-              break;
-            }
-          }
-        }
-      }
+    inline static double NewAxis(
+      const CollisionResult& result,
+      const TransformableComponent&)
+    {
+      return HorizVert::AxisNewLower(result);
     }
-  }
 
-  // Find vertical collisions
-  if (ponderable.collidable && !result.stopProcessing)
-  {
-    result.touchedWall = false;
+    inline static double ObjectAxis(const TransformableComponent& transformable)
+    {
+      return HorizVert::AxisOldUpper(transformable);
+    }
 
-    if (result.newY < oldY)
+    inline static bool Closer(double left, double right)
     {
-      bool boundaryCollision = false;
-      auto it = mappable.upBoundaries.lower_bound(oldY);
+      return right < left;
+    }
+  };
 
-      // Find the axis distance of the closest environmental boundary.
-      for (;
-          (it != std::end(mappable.upBoundaries)) &&
-            (it->first >= result.newY);
-          it++)
-      {
-        // Check that the boundary is in range for the other axis.
-        if ((result.newX + transformable.w > it->second.lower) &&
-            (result.newX < it->second.upper))
-        {
-          // We have a collision!
-          boundaryCollision = true;
+  template <typename HorizVert>
+  class Asc : public HorizVert {
+  public:
 
-          break;
-        }
-      }
+    inline static bool AtLeastInAxisSweep(
+      double boundaryAxis,
+      double entityAxis)
+    {
+      return (boundaryAxis <= entityAxis);
+    }
 
-      // Find a list of potential colliders, sorted so that the closest is
-      // first.
-      std::vector<id_type> colliders;
+    inline static bool IsPastAxis(
+      double colliderAxis,
+      double entityAxis)
+    {
+      return (colliderAxis < entityAxis);
+    }
 
-      for (id_type collider : entities)
-      {
-        // Can't collide with self.
-        if (collider == entity)
-        {
-          continue;
-        }
+    inline static double OldAxis(const TransformableComponent& transformable)
+    {
+      return HorizVert::AxisOldUpper(transformable);
+    }
 
-        auto& colliderPonder = game_.getEntityManager().
-          getComponent<PonderableComponent>(collider);
+    inline static double NewAxis(
+      const CollisionResult& result,
+      const TransformableComponent& transformable)
+    {
+      return HorizVert::AxisNewUpper(result, transformable);
+    }
 
-        // Only check objects that are active and collidable.
-        if (!colliderPonder.active || !colliderPonder.collidable)
-        {
-          continue;
-        }
+    inline static double ObjectAxis(const TransformableComponent& transformable)
+    {
+      return HorizVert::AxisOldLower(transformable);
+    }
 
-        auto& colliderTrans = game_.getEntityManager().
-          getComponent<TransformableComponent>(collider);
-
-        // Check if the entity would move into the potential collider,
-        if ((colliderTrans.y + colliderTrans.h > result.newY) &&
-            // that it wasn't already colliding,
-            (colliderTrans.y + colliderTrans.h <= oldY) &&
-            // that the position on the other axis is in range,
-            (colliderTrans.x + colliderTrans.w > result.newX) &&
-            (colliderTrans.x < result.newX + transformable.w) &&
-            // and that the collider is not farther away than the environmental
-            // boundary.
-            (!boundaryCollision ||
-              (colliderTrans.y + colliderTrans.h >= it->first)))
-        {
-          colliders.push_back(collider);
-        }
-      }
+    inline static bool Closer(double left, double right)
+    {
+      return left < right;
+    }
+  };
 
-      std::sort(
-        std::begin(colliders),
-        std::end(colliders),
-        [&] (id_type left, id_type right) {
-          auto& leftTrans = game_.getEntityManager().
-            getComponent<TransformableComponent>(left);
+  class Horizontal {
+  public:
 
-          auto& rightTrans = game_.getEntityManager().
-            getComponent<TransformableComponent>(right);
+    inline static double AxisOldLower(
+      const TransformableComponent& transformable)
+    {
+      return transformable.x;
+    }
 
-          return (rightTrans.y < leftTrans.y);
-        });
+    inline static double AxisOldUpper(
+      const TransformableComponent& transformable)
+    {
+      return transformable.x + transformable.w;
+    }
 
-      for (id_type collider : colliders)
-      {
-        auto& colliderTrans = game_.getEntityManager().
-          getComponent<TransformableComponent>(collider);
+    inline static double AxisNewLower(const CollisionResult& result)
+    {
+      return result.newX;
+    }
 
-        // Check if the entity would still move into the potential collider.
-        if (colliderTrans.y + colliderTrans.h <= result.newY)
-        {
-          break;
-        }
+    inline static double AxisNewUpper(
+      const CollisionResult& result,
+      const TransformableComponent& transformable)
+    {
+      return result.newX + transformable.w;
+    }
 
-        auto& colliderPonder = game_.getEntityManager().
-          getComponent<PonderableComponent>(collider);
+    inline static double NonAxisOldLower(
+      const TransformableComponent& transformable)
+    {
+      return transformable.y;
+    }
 
-        processCollision(
-          entity,
-          collider,
-          Direction::up,
-          colliderPonder.colliderType,
-          colliderTrans.y + colliderTrans.h,
-          colliderTrans.x,
-          colliderTrans.x + colliderTrans.w,
-          result);
+    inline static double NonAxisOldUpper(
+      const TransformableComponent& transformable)
+    {
+      return transformable.y + transformable.h;
+    }
 
-        if (result.stopProcessing)
-        {
-          break;
-        }
-      }
+    inline static double NonAxisNewLower(
+      const CollisionResult& result,
+      const TransformableComponent& transformable)
+    {
+      return result.newY;
+    }
 
-      // If movement hasn't been stopped by an intermediary object, and
-      // collision checking hasn't been stopped, process the environmental
-      // boundaries closest to the entity.
-      if (!result.stopProcessing && !result.touchedWall && boundaryCollision)
-      {
-        double boundaryAxis = it->first;
+    inline static double NonAxisNewUpper(
+      const CollisionResult& result,
+      const TransformableComponent& transformable)
+    {
+      return result.newY + transformable.h;
+    }
+  };
 
-        for (;
-            (it != std::end(mappable.upBoundaries)) &&
-              (it->first == boundaryAxis);
-            it++)
-        {
-          if ((result.newX + transformable.w > it->second.lower) &&
-              (result.newX < it->second.upper))
-          {
-            processCollision(
-              entity,
-              mapEntity,
-              Direction::up,
-              it->second.type,
-              it->first,
-              it->second.lower,
-              it->second.upper,
-              result);
-
-            if (result.stopProcessing)
-            {
-              break;
-            }
-          }
-        }
-      }
-    } else if (result.newY > oldY)
+  class Vertical {
+  public:
+
+    inline static double AxisOldLower(
+      const TransformableComponent& transformable)
     {
-      bool boundaryCollision = false;
-      auto it = mappable.downBoundaries.lower_bound(oldBottom);
+      return transformable.y;
+    }
 
-      // Find the axis distance of the closest environmental boundary.
-      for (;
-          (it != std::end(mappable.downBoundaries))
-            && (it->first <= (result.newY + transformable.h));
-          it++)
-      {
-        // Check that the boundary is in range for the other axis.
-        if ((result.newX + transformable.w > it->second.lower) &&
-            (result.newX < it->second.upper))
-        {
-          // We have a collision!
-          boundaryCollision = true;
+    inline static double AxisOldUpper(
+      const TransformableComponent& transformable)
+    {
+      return transformable.y + transformable.h;
+    }
 
-          break;
-        }
-      }
+    inline static double AxisNewLower(const CollisionResult& result)
+    {
+      return result.newY;
+    }
 
-      // Find a list of potential colliders, sorted so that the closest is
-      // first.
-      std::vector<id_type> colliders;
+    inline static double AxisNewUpper(
+      const CollisionResult& result,
+      const TransformableComponent& transformable)
+    {
+      return result.newY + transformable.h;
+    }
 
-      for (id_type collider : entities)
-      {
-        // Can't collide with self.
-        if (collider == entity)
-        {
-          continue;
-        }
+    inline static double NonAxisOldLower(
+      const TransformableComponent& transformable)
+    {
+      return transformable.x;
+    }
 
-        auto& colliderPonder = game_.getEntityManager().
-          getComponent<PonderableComponent>(collider);
+    inline static double NonAxisOldUpper(
+      const TransformableComponent& transformable)
+    {
+      return transformable.x + transformable.w;
+    }
 
-        // Only check objects that are active and collidable.
-        if (!colliderPonder.active || !colliderPonder.collidable)
-        {
-          continue;
-        }
+    inline static double NonAxisNewLower(
+      const CollisionResult& result,
+      const TransformableComponent& transformable)
+    {
+      return result.newX;
+    }
 
-        auto& colliderTrans = game_.getEntityManager().
-          getComponent<TransformableComponent>(collider);
-
-        // Check if the entity would move into the potential collider,
-        if ((colliderTrans.y < result.newY + transformable.h) &&
-            // that it wasn't already colliding,
-            (colliderTrans.y >= oldBottom) &&
-            // that the position on the other axis is in range,
-            (colliderTrans.x + colliderTrans.w > result.newX) &&
-            (colliderTrans.x < result.newX + transformable.w) &&
-            // and that the collider is not farther away than the environmental
-            // boundary.
-            (!boundaryCollision || (colliderTrans.y <= it->first)))
-        {
-          colliders.push_back(collider);
-        }
-      }
+    inline static double NonAxisNewUpper(
+      const CollisionResult& result,
+      const TransformableComponent& transformable)
+    {
+      return result.newX + transformable.w;
+    }
+  };
 
-      std::sort(
-        std::begin(colliders),
-        std::end(colliders),
-        [&] (id_type left, id_type right) {
-          auto& leftTrans = game_.getEntityManager().
-            getComponent<TransformableComponent>(left);
+  template <Direction dir, typename AscDesc>
+  class DetectCollisions : public AscDesc {
+  public:
 
-          auto& rightTrans = game_.getEntityManager().
-            getComponent<TransformableComponent>(right);
+    static const Direction Dir = dir;
+  };
 
-          return (leftTrans.y < rightTrans.y);
-        });
+  class Left : public DetectCollisions<Direction::left, Desc<Horizontal>> {
+  public:
 
-      for (id_type collider : colliders)
-      {
-        auto& colliderTrans = game_.getEntityManager().
-          getComponent<TransformableComponent>(collider);
+    inline static const MappableComponent::desc_boundaries_type& MapBoundaries(
+      const MappableComponent& mappable)
+    {
+      return mappable.leftBoundaries;
+    }
+  };
 
-        // Check if the entity would still move into the potential collider.
-        if (colliderTrans.y >= result.newY + transformable.h)
-        {
-          break;
-        }
+  class Right : public DetectCollisions<Direction::right, Asc<Horizontal>> {
+  public:
 
-        auto& colliderPonder = game_.getEntityManager().
-          getComponent<PonderableComponent>(collider);
+    inline static const MappableComponent::asc_boundaries_type& MapBoundaries(
+      const MappableComponent& mappable)
+    {
+      return mappable.rightBoundaries;
+    }
+  };
 
-        processCollision(
-          entity,
-          collider,
-          Direction::down,
-          colliderPonder.colliderType,
-          colliderTrans.y,
-          colliderTrans.x,
-          colliderTrans.x + colliderTrans.w,
-          result);
+  class Up : public DetectCollisions<Direction::up, Desc<Vertical>> {
+  public:
 
-        if (result.stopProcessing)
-        {
-          break;
-        }
-      }
+    inline static const MappableComponent::desc_boundaries_type& MapBoundaries(
+      const MappableComponent& mappable)
+    {
+      return mappable.upBoundaries;
+    }
+  };
 
-      // If movement hasn't been stopped by an intermediary object, and
-      // collision checking hasn't been stopped, process the environmental
-      // boundaries closest to the entity.
-      if (!result.stopProcessing && !result.touchedWall && boundaryCollision)
-      {
-        double boundaryAxis = it->first;
+  class Down : public DetectCollisions<Direction::down, Asc<Vertical>> {
+  public:
 
-        for (;
-            (it != std::end(mappable.downBoundaries)) &&
-              (it->first == boundaryAxis);
-            it++)
-        {
-          if ((result.newX + transformable.w > it->second.lower) &&
-              (result.newX < it->second.upper))
-          {
-            processCollision(
-              entity,
-              mapEntity,
-              Direction::down,
-              it->second.type,
-              it->first,
-              it->second.lower,
-              it->second.upper,
-              result);
-
-            if (result.stopProcessing)
-            {
-              break;
-            }
-          }
-        }
-      }
+    inline static const MappableComponent::asc_boundaries_type& MapBoundaries(
+      const MappableComponent& mappable)
+    {
+      return mappable.downBoundaries;
     }
-  }
+  };
+};
 
-  // Move
-  if (!ponderable.frozen)
+CollisionResult PonderingSystem::detectCollisions(
+  id_type entity,
+  double x,
+  double y)
+{
+  auto& transformable = game_.getEntityManager().
+    getComponent<TransformableComponent>(entity);
+
+  CollisionResult result;
+  result.newX = x;
+  result.newY = transformable.y;
+
+  // Find horizontal collisions.
+  if (result.newX < transformable.x)
   {
-    transformable.x = result.newX;
-    transformable.y = result.newY;
+    detectCollisionsInDirection<CollisionParams::Left>(entity, result);
+  } else if (result.newX > transformable.x)
+  {
+    detectCollisionsInDirection<CollisionParams::Right>(entity, result);
   }
 
-  // Perform cleanup for orientable entites
-  if (game_.getEntityManager().hasComponent<OrientableComponent>(entity))
+  // Find vertical collisions
+  if (!result.stopProcessing)
   {
-    auto& orientable = game_.getEntityManager().
-      getComponent<OrientableComponent>(entity);
+    result.newY = y;
+    result.touchedWall = false;
 
-    // Handle changes in groundedness
-    if (ponderable.grounded != oldGrounded)
+    if (result.newY < transformable.y)
     {
-      if (ponderable.grounded)
-      {
-        game_.getSystemManager().getSystem<OrientingSystem>().land(entity);
-      } else {
-        game_.getSystemManager().
-          getSystem<OrientingSystem>().startFalling(entity);
-      }
+      detectCollisionsInDirection<CollisionParams::Up>(entity, result);
+    } else if (result.newY > transformable.y)
+    {
+      detectCollisionsInDirection<CollisionParams::Down>(entity, result);
     }
+  }
 
-    // Complete dropping, if necessary
-    if (orientable.getDropState() == OrientableComponent::DropState::active)
+  return result;
+}
+
+template <typename Param>
+void PonderingSystem::detectCollisionsInDirection(
+  id_type entity,
+  CollisionResult& result)
+{
+  // Get map data.
+  auto& realizable = game_.getEntityManager().
+    getComponent<RealizableComponent>(
+      game_.getSystemManager().getSystem<RealizingSystem>().getSingleton());
+
+  id_type mapEntity = realizable.activeMap;
+
+  auto& mappable = game_.getEntityManager().
+    getComponent<MappableComponent>(mapEntity);
+
+  // Get old location.
+  auto& transformable = game_.getEntityManager().
+    getComponent<TransformableComponent>(entity);
+
+  bool boundaryCollision = false;
+
+  auto boundaries = Param::MapBoundaries(mappable);
+  auto it = boundaries.lower_bound(Param::OldAxis(transformable));
+
+  // Find the axis distance of the closest environmental boundary.
+  for (;
+      (it != std::end(boundaries)) &&
+        Param::AtLeastInAxisSweep(
+          it->first,
+          Param::NewAxis(result, transformable));
+      it++)
+  {
+    // Check that the boundary is in range for the other axis.
+    if ((Param::NonAxisNewUpper(result, transformable) > it->second.lower) &&
+        (Param::NonAxisNewLower(result, transformable) < it->second.upper))
     {
-      orientable.setDropState(OrientableComponent::DropState::none);
+      // We have a collision!
+      boundaryCollision = true;
+
+      break;
     }
   }
 
-  // Ferry or unferry as necessary
-  if ((ponderable.type == PonderableComponent::Type::freefalling) &&
-      (ponderable.grounded != oldGrounded))
+  // Find a list of potential colliders, sorted so that the closest is
+  // first.
+  std::vector<id_type> colliders;
+
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    PonderableComponent,
+    TransformableComponent>();
+
+  for (id_type collider : entities)
   {
-    if (ponderable.grounded &&
-        game_.getEntityManager().
-          hasComponent<PonderableComponent>(result.groundEntity))
+    // Can't collide with self.
+    if (collider == entity)
     {
-      // The body is now being ferried
-      auto& ferryPonder = game_.getEntityManager().
-        getComponent<PonderableComponent>(result.groundEntity);
+      continue;
+    }
 
-      ponderable.ferried = true;
-      ponderable.ferry = result.groundEntity;
+    auto& colliderPonder = game_.getEntityManager().
+      getComponent<PonderableComponent>(collider);
 
-      ferryPonder.passengers.insert(entity);
-    } else if (ponderable.ferried)
+    // Only check objects that are active and collidable.
+    if (!colliderPonder.active || !colliderPonder.collidable)
     {
-      // The body is no longer being ferried
-      unferry(entity);
+      continue;
     }
-  }
-
-  // Update a ferry passenger's relative position
-  if (ponderable.ferried)
-  {
-    auto& ferryTrans = game_.getEntityManager().
-      getComponent<TransformableComponent>(ponderable.ferry);
 
-    ponderable.relX = transformable.x - ferryTrans.x;
-    ponderable.relY = transformable.y - ferryTrans.y;
+    auto& colliderTrans = game_.getEntityManager().
+      getComponent<TransformableComponent>(collider);
+
+    // Check if the entity would move into the potential collider,
+    if (Param::IsPastAxis(
+          Param::ObjectAxis(colliderTrans),
+          Param::NewAxis(result, transformable)) &&
+        // that it wasn't already colliding,
+        !Param::IsPastAxis(
+          Param::ObjectAxis(colliderTrans),
+          Param::OldAxis(transformable)) &&
+        // that the position on the non-axis is in range,
+        (Param::NonAxisOldUpper(colliderTrans) >
+          Param::NonAxisNewLower(result, transformable)) &&
+        (Param::NonAxisOldLower(colliderTrans) <
+          Param::NonAxisNewUpper(result, transformable)) &&
+        // and that the collider is not farther away than the environmental
+        // boundary.
+        (!boundaryCollision ||
+          Param::AtLeastInAxisSweep(
+            Param::ObjectAxis(colliderTrans),
+            it->first)))
+    {
+      colliders.push_back(collider);
+    }
   }
 
-  // Handle ferry passengers
-  std::set<id_type> passengers = ponderable.passengers;
+  std::sort(
+    std::begin(colliders),
+    std::end(colliders),
+    [&] (id_type left, id_type right) {
+      auto& leftTrans = game_.getEntityManager().
+        getComponent<TransformableComponent>(left);
 
-  for (id_type passenger : passengers)
-  {
-    tickBody(
-      passenger,
-      dt,
-      entities);
-  }
+      auto& rightTrans = game_.getEntityManager().
+        getComponent<TransformableComponent>(right);
 
-  // Move to an adjacent map, if necessary
-  if (result.adjacentlyWarping)
+      return Param::Closer(
+        Param::ObjectAxis(leftTrans),
+        Param::ObjectAxis(rightTrans));
+    });
+
+  for (id_type collider : colliders)
   {
-    double warpX = result.newX;
-    double warpY = result.newY;
+    auto& colliderTrans = game_.getEntityManager().
+      getComponent<TransformableComponent>(collider);
 
-    switch (result.adjWarpDir)
+    // Check if the entity would still move into the potential collider.
+    if (!Param::IsPastAxis(
+          Param::ObjectAxis(colliderTrans),
+          Param::NewAxis(result, transformable)))
     {
-      case Direction::left:
-      {
-        warpX = GAME_WIDTH + WALL_GAP - transformable.w;
-
-        break;
-      }
-
-      case Direction::right:
-      {
-        warpX = -WALL_GAP;
+      break;
+    }
 
-        break;
-      }
+    auto& colliderPonder = game_.getEntityManager().
+      getComponent<PonderableComponent>(collider);
 
-      case Direction::up:
-      {
-        warpY = MAP_HEIGHT * TILE_HEIGHT - transformable.h;
+    processCollision(
+      entity,
+      collider,
+      Param::Dir,
+      colliderPonder.colliderType,
+      Param::ObjectAxis(colliderTrans),
+      Param::NonAxisOldLower(colliderTrans),
+      Param::NonAxisOldUpper(colliderTrans),
+      result);
+
+    if (result.stopProcessing)
+    {
+      break;
+    }
+  }
 
-        break;
-      }
+  // If movement hasn't been stopped by an intermediary object, and
+  // collision checking hasn't been stopped, process the environmental
+  // boundaries closest to the entity.
+  if (!result.stopProcessing && !result.touchedWall && boundaryCollision)
+  {
+    double boundaryAxis = it->first;
 
-      case Direction::down:
+    for (;
+        (it != std::end(boundaries)) &&
+          (it->first == boundaryAxis);
+        it++)
+    {
+      if ((Param::NonAxisNewUpper(result, transformable) > it->second.lower) &&
+          (Param::NonAxisNewLower(result, transformable) < it->second.upper))
       {
-        warpY = -WALL_GAP;
+        processCollision(
+          entity,
+          mapEntity,
+          Param::Dir,
+          it->second.type,
+          it->first,
+          it->second.lower,
+          it->second.upper,
+          result);
 
-        break;
+        if (result.stopProcessing)
+        {
+          break;
+        }
       }
     }
-
-    game_.getSystemManager().getSystem<PlayingSystem>().
-      changeMap(
-        entity,
-        result.adjWarpMapId,
-        warpX,
-        warpY);
   }
 }
 
@@ -1012,7 +932,7 @@ void PonderingSystem::processCollision(
         result.newY = axis - transformable.h;
         result.groundEntity = collider;
         ponderable.velY = 0.0;
-        ponderable.grounded = true;
+        result.grounded = true;
 
         break;
       }
@@ -5,6 +5,19 @@
 #include "components/ponderable.h"
 #include "direction.h"
 
+struct CollisionResult
+{
+  double newX;
+  double newY;
+  bool stopProcessing = false;
+  bool touchedWall = false;
+  bool adjacentlyWarping = false;
+  Direction adjWarpDir;
+  size_t adjWarpMapId;
+  bool grounded = false;
+  EntityManager::id_type groundEntity;
+};
+
 class PonderingSystem : public System {
 public:
 
@@ -34,23 +47,28 @@ public:
 
 private:
 
-  struct CollisionResult
-  {
-    double newX;
-    double newY;
-    bool stopProcessing = false;
-    bool touchedWall = false;
-    bool adjacentlyWarping = false;
-    Direction adjWarpDir;
-    size_t adjWarpMapId;
-    id_type groundEntity;
-  };
+
 
   void tickBody(
     id_type entity,
     double dt,
     const std::set<id_type>& entities);
 
+  CollisionResult moveBody(
+    id_type entity,
+    double x,
+    double y);
+
+  CollisionResult detectCollisions(
+    id_type entity,
+    double x,
+    double y);
+
+  template <typename Param>
+  void detectCollisionsInDirection(
+    id_type entity,
+    CollisionResult& result);
+
   void processCollision(
     id_type entity,
     id_type collider,