Simplified positions/sizes with vectors

Positions and sizes are now stored as vectors (of doubles and ints, respectively). This allows for at least minor code simplification in many places, and cleans up the CollisionParams code in PonderingSystem quite a bit.

14 files changed, 285 insertions, 275 deletions

@@ -4,6 +4,7 @@
 #include "component.h"
 #include <vector>
 #include <random>
+#include "vector.h"
 
 class AutomatableComponent : public Component {
 public:
@@ -18,8 +19,7 @@ public:
      * The horizontal and vertical speed, in pixels/sec, that the entity should
      * move at.
      */
-    double speedX;
-    double speedY;
+    vec2d speed;
 
     /**
      * The duration of the action in seconds.
@@ -3,6 +3,7 @@
 
 #include "component.h"
 #include "entity_manager.h"
+#include "vector.h"
 
 class PlayableComponent : public Component {
 public:
@@ -24,8 +25,7 @@ public:
    * @managed_by PlayingSystem
    */
   size_t checkpointMapId;
-  double checkpointX;
-  double checkpointY;
+  vec2d checkpointPos;
 
 };
 
@@ -4,6 +4,7 @@
 #include <set>
 #include "component.h"
 #include "entity_manager.h"
+#include "vector.h"
 
 class PonderableComponent : public Component {
 public:
@@ -45,14 +46,12 @@ public:
   /**
    * The velocity of the body.
    */
-  double velX = 0.0;
-  double velY = 0.0;
+  vec2d vel = { 0.0, 0.0 };
 
   /**
    * The acceleration of the body.
    */
-  double accelX = 0.0;
-  double accelY = 0.0;
+  vec2d accel = { 0.0, 0.0 };
 
   /**
    * The type of physical body that the entity is meant to assume. The body will
@@ -89,8 +88,7 @@ public:
    *
    * @managed_by PonderingSystem
    */
-  double relX;
-  double relY;
+  vec2d rel = { 0.0, 0.0 };
 
   /**
    * The bodies that are being ferried by this body.
@@ -5,6 +5,7 @@
 #include <set>
 #include <map>
 #include "entity_manager.h"
+#include "vector.h"
 
 class RealizableComponent : public Component {
 public:
@@ -31,8 +32,7 @@ public:
    * @managed_by RealizingSystem
    */
   int startingMapId;
-  int startingX;
-  int startingY;
+  vec2i startingPos;
 
   /**
    * The set of map entities loaded by this entity. It is only intended for
@@ -2,6 +2,7 @@
 #define LOCATABLE_H_39E526CA
 
 #include "component.h"
+#include "vector.h"
 
 class TransformableComponent : public Component {
 public:
@@ -15,24 +16,20 @@ public:
    * so, use PonderingSystem::unferry on the body to ensure that it is not
    * ferried.
    */
-  double x;
-  double y;
+  vec2d pos;
 
   /**
    * The size of the entity.
    */
-  int w;
-  int h;
+  vec2i size;
 
   /**
    * For prototypes, the original coordinates and size of the entity.
    *
    * @managed_by RealizingSystem
    */
-  double origX;
-  double origY;
-  int origW;
-  int origH;
+  vec2d origPos;
+  vec2i origSize;
 };
 
 #endif /* end of include guard: LOCATABLE_H_39E526CA */
@@ -64,10 +64,10 @@ void AnimatingSystem::render(Texture& texture)
       }
 
       Rectangle dstrect {
-        static_cast<int>(transform.x),
-        static_cast<int>(transform.y),
-        transform.w,
-        transform.h};
+        static_cast<int>(transform.pos.x()),
+        static_cast<int>(transform.pos.y()),
+        transform.size.w(),
+        transform.size.h()};
 
       const AnimationSet& aset = sprite.animationSet;
       game_.getRenderer().blit(
@@ -54,8 +54,7 @@ void AutomatingSystem::tick(double dt)
     auto& ponderable = game_.getEntityManager().
       getComponent<PonderableComponent>(entity);
 
-    ponderable.velX = curAction.speedX;
-    ponderable.velY = curAction.speedY;
+    ponderable.vel = curAction.speed;
 
     automatable.remaining -= dt;
   }
@@ -24,27 +24,27 @@ void OrientingSystem::tick(double)
     {
       case OrientableComponent::WalkState::still:
       {
-        ponderable.velX = 0.0;
+        ponderable.vel.x() = 0.0;
 
         break;
       }
 
       case OrientableComponent::WalkState::left:
       {
-        ponderable.velX = -WALK_SPEED;
+        ponderable.vel.x() = -WALK_SPEED;
 
         break;
       }
 
       case OrientableComponent::WalkState::right:
       {
-        ponderable.velX = WALK_SPEED;
+        ponderable.vel.x() = WALK_SPEED;
 
         break;
       }
     }
 
-    if (orientable.isJumping() && (ponderable.velY > 0))
+    if (orientable.isJumping() && (ponderable.vel.y() > 0))
     {
       orientable.setJumping(false);
     }
@@ -122,8 +122,8 @@ void OrientingSystem::jump(id_type entity)
 
     playSound("res/Randomize87.wav", 0.25);
 
-    ponderable.velY = JUMP_VELOCITY;
-    ponderable.accelY = JUMP_GRAVITY;
+    ponderable.vel.y() = JUMP_VELOCITY;
+    ponderable.accel.y() = JUMP_GRAVITY;
 
     auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
     if (orientable.isFacingRight())
@@ -147,7 +147,7 @@ void OrientingSystem::stopJumping(id_type entity)
     auto& ponderable = game_.getEntityManager().
       getComponent<PonderableComponent>(entity);
 
-    ponderable.accelY = NORMAL_GRAVITY;
+    ponderable.accel.y() = NORMAL_GRAVITY;
   }
 }
 
@@ -42,10 +42,9 @@ void PlayingSystem::initPlayer()
   auto& transformable = game_.getEntityManager().
     emplaceComponent<TransformableComponent>(player);
 
-  transformable.x = realizable.startingX;
-  transformable.y = realizable.startingY;
-  transformable.w = 10;
-  transformable.h = 12;
+  transformable.pos = realizable.startingPos;
+  transformable.size.w() = 10;
+  transformable.size.h() = 12;
 
   game_.getSystemManager().getSystem<PonderingSystem>().initializeBody(
     player,
@@ -59,8 +58,7 @@ void PlayingSystem::initPlayer()
 
   playable.mapId = realizable.activeMap;
   playable.checkpointMapId = realizable.startingMapId;
-  playable.checkpointX = realizable.startingX;
-  playable.checkpointY = realizable.startingY;
+  playable.checkpointPos = realizable.startingPos;
 
   realizing.enterActiveMap(player);
 
@@ -70,8 +68,7 @@ void PlayingSystem::initPlayer()
 void PlayingSystem::changeMap(
   id_type player,
   size_t mapId,
-  double x,
-  double y)
+  vec2d warpPos)
 {
   auto& playable = game_.getEntityManager().
     getComponent<PlayableComponent>(player);
@@ -103,8 +100,7 @@ void PlayingSystem::changeMap(
 
   pondering.unferry(player);
 
-  transformable.x = x;
-  transformable.y = y;
+  transformable.pos = warpPos;
 
   if (realizable.activePlayer == player)
   {
@@ -139,8 +135,7 @@ void PlayingSystem::die(id_type player)
     changeMap(
       player,
       playable.checkpointMapId,
-      playable.checkpointX,
-      playable.checkpointY);
+      playable.checkpointPos);
 
     animatable.frozen = false;
     animatable.flickering = false;
@@ -2,6 +2,7 @@
 #define PLAYING_H_70A54F7D
 
 #include "system.h"
+#include "vector.h"
 
 class PlayingSystem : public System {
 public:
@@ -15,8 +16,7 @@ public:
   void changeMap(
     id_type player,
     size_t mapId,
-    double x,
-    double y);
+    vec2d warpPos);
 
   void die(id_type player);
 
@@ -47,7 +47,7 @@ void PonderingSystem::initializeBody(
 
   if (type == PonderableComponent::Type::freefalling)
   {
-    ponderable.accelY = NORMAL_GRAVITY;
+    ponderable.accel.y() = NORMAL_GRAVITY;
   }
 }
 
@@ -56,10 +56,10 @@ 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.vel.x() = 0.0;
+  ponderable.vel.y() = 0.0;
+  ponderable.accel.x() = 0.0;
+  ponderable.accel.y() = 0.0;
   ponderable.grounded = false;
   ponderable.frozen = false;
   ponderable.collidable = true;
@@ -102,19 +102,17 @@ void PonderingSystem::tickBody(
   // Accelerate
   if (!ponderable.frozen)
   {
-    ponderable.velX += ponderable.accelX * dt;
-    ponderable.velY += ponderable.accelY * dt;
+    ponderable.vel += ponderable.accel * dt;
 
     if ((ponderable.type == PonderableComponent::Type::freefalling)
-      && (ponderable.velY > TERMINAL_VELOCITY))
+      && (ponderable.vel.y() > TERMINAL_VELOCITY))
     {
-      ponderable.velY = TERMINAL_VELOCITY;
+      ponderable.vel.y() = TERMINAL_VELOCITY;
     }
   }
 
   // Move
-  double newX = transformable.x;
-  double newY = transformable.y;
+  vec2d newPos = transformable.pos;
 
   if (!ponderable.frozen)
   {
@@ -123,19 +121,13 @@ void PonderingSystem::tickBody(
       auto& ferryTrans = game_.getEntityManager().
         getComponent<TransformableComponent>(ponderable.ferry);
 
-      newX = ferryTrans.x + ponderable.relX;
-      newY = ferryTrans.y + ponderable.relY;
+      newPos = ferryTrans.pos + ponderable.rel;
     }
 
-    newX += ponderable.velX * dt;
-    newY += ponderable.velY * dt;
+    newPos += ponderable.vel * dt;
   }
 
-  CollisionResult result =
-    moveBody(
-      entity,
-      newX,
-      newY);
+  CollisionResult result = moveBody(entity, newPos);
 
   // Perform cleanup for orientable entites
   bool groundedChanged = (ponderable.grounded != result.grounded);
@@ -194,8 +186,7 @@ void PonderingSystem::tickBody(
     auto& ferryTrans = game_.getEntityManager().
       getComponent<TransformableComponent>(ponderable.ferry);
 
-    ponderable.relX = transformable.x - ferryTrans.x;
-    ponderable.relY = transformable.y - ferryTrans.y;
+    ponderable.rel = transformable.pos - ferryTrans.pos;
   }
 
   // Handle ferry passengers
@@ -212,35 +203,34 @@ void PonderingSystem::tickBody(
   // Move to an adjacent map, if necessary
   if (result.adjacentlyWarping)
   {
-    double warpX = result.newX;
-    double warpY = result.newY;
+    vec2d warpPos = result.pos;
 
     switch (result.adjWarpDir)
     {
       case Direction::left:
       {
-        warpX = GAME_WIDTH + WALL_GAP - transformable.w;
+        warpPos.x() = GAME_WIDTH + WALL_GAP - transformable.size.w();
 
         break;
       }
 
       case Direction::right:
       {
-        warpX = -WALL_GAP;
+        warpPos.x() = -WALL_GAP;
 
         break;
       }
 
       case Direction::up:
       {
-        warpY = MAP_HEIGHT * TILE_HEIGHT - transformable.h;
+        warpPos.y() = MAP_HEIGHT * TILE_HEIGHT - transformable.size.h();
 
         break;
       }
 
       case Direction::down:
       {
-        warpY = -WALL_GAP;
+        warpPos.y() = -WALL_GAP;
 
         break;
       }
@@ -250,15 +240,13 @@ void PonderingSystem::tickBody(
       changeMap(
         entity,
         result.adjWarpMapId,
-        warpX,
-        warpY);
+        warpPos);
   }
 }
 
-CollisionResult PonderingSystem::moveBody(
+PonderingSystem::CollisionResult PonderingSystem::moveBody(
   id_type entity,
-  double x,
-  double y)
+  vec2d newPos)
 {
   auto& ponderable = game_.getEntityManager().
     getComponent<PonderableComponent>(entity);
@@ -266,26 +254,29 @@ CollisionResult PonderingSystem::moveBody(
   auto& transformable = game_.getEntityManager().
     getComponent<TransformableComponent>(entity);
 
-  const double oldX = transformable.x;
-  const double oldY = transformable.y;
-  const double oldRight = oldX + transformable.w;
-  const double oldBottom = oldY + transformable.h;
-
   CollisionResult result;
 
   if (ponderable.collidable)
   {
-    result = detectCollisions(entity, x, y);
+    result = detectCollisions(entity, newPos);
   } else {
-    result.newX = x;
-    result.newY = y;
+    result.pos = newPos;
   }
 
   // Move
   if (!ponderable.frozen)
   {
-    transformable.x = result.newX;
-    transformable.y = result.newY;
+    transformable.pos = result.pos;
+
+    if (result.blockedHoriz)
+    {
+      ponderable.vel.x() = 0.0;
+    }
+
+    if (result.blockedVert)
+    {
+      ponderable.vel.y() = 0.0;
+    }
   }
 
   return result;
@@ -311,21 +302,14 @@ namespace CollisionParams {
       return (colliderAxis > entityAxis);
     }
 
-    inline static double OldAxis(const TransformableComponent& transformable)
+    inline static double EntityAxis(const vec2d& pos, const vec2i& size)
     {
-      return HorizVert::AxisOldLower(transformable);
+      return HorizVert::AxisLower(pos);
     }
 
-    inline static double NewAxis(
-      const CollisionResult& result,
-      const TransformableComponent&)
+    inline static double ObjectAxis(const vec2d& pos, const vec2i& size)
     {
-      return HorizVert::AxisNewLower(result);
-    }
-
-    inline static double ObjectAxis(const TransformableComponent& transformable)
-    {
-      return HorizVert::AxisOldUpper(transformable);
+      return HorizVert::AxisUpper(pos, size);
     }
 
     inline static bool Closer(double left, double right)
@@ -352,21 +336,14 @@ namespace CollisionParams {
       return (colliderAxis < entityAxis);
     }
 
-    inline static double OldAxis(const TransformableComponent& transformable)
+    inline static double EntityAxis(const vec2d& pos, const vec2i& size)
     {
-      return HorizVert::AxisOldUpper(transformable);
+      return HorizVert::AxisUpper(pos, size);
     }
 
-    inline static double NewAxis(
-      const CollisionResult& result,
-      const TransformableComponent& transformable)
+    inline static double ObjectAxis(const vec2d& pos, const vec2i& size)
     {
-      return HorizVert::AxisNewUpper(result, transformable);
-    }
-
-    inline static double ObjectAxis(const TransformableComponent& transformable)
-    {
-      return HorizVert::AxisOldLower(transformable);
+      return HorizVert::AxisLower(pos);
     }
 
     inline static bool Closer(double left, double right)
@@ -375,121 +352,62 @@ namespace CollisionParams {
     }
   };
 
-  class Horizontal {
+  template <size_t Axis, size_t NonAxis>
+  class HorizVert {
   public:
 
-    inline static double AxisOldLower(
-      const TransformableComponent& transformable)
+    inline static double AxisLower(const vec2d& pos)
     {
-      return transformable.x;
+      return pos.coords[Axis];
     }
 
-    inline static double AxisOldUpper(
-      const TransformableComponent& transformable)
+    inline static double AxisUpper(const vec2d& pos, const vec2i& size)
     {
-      return transformable.x + transformable.w;
+      return pos.coords[Axis] + size.coords[Axis];
     }
 
-    inline static double AxisNewLower(const CollisionResult& result)
+    inline static double NonAxisLower(const vec2d& pos)
     {
-      return result.newX;
+      return pos.coords[NonAxis];
     }
 
-    inline static double AxisNewUpper(
-      const CollisionResult& result,
-      const TransformableComponent& transformable)
+    inline static double NonAxisUpper(const vec2d& pos, const vec2i& size)
     {
-      return result.newX + transformable.w;
+      return pos.coords[NonAxis] + size.coords[NonAxis];
     }
 
-    inline static double NonAxisOldLower(
-      const TransformableComponent& transformable)
-    {
-      return transformable.y;
-    }
-
-    inline static double NonAxisOldUpper(
-      const TransformableComponent& transformable)
-    {
-      return transformable.y + transformable.h;
-    }
-
-    inline static double NonAxisNewLower(
-      const CollisionResult& result,
-      const TransformableComponent& transformable)
-    {
-      return result.newY;
-    }
-
-    inline static double NonAxisNewUpper(
-      const CollisionResult& result,
-      const TransformableComponent& transformable)
-    {
-      return result.newY + transformable.h;
-    }
   };
 
-  class Vertical {
-  public:
-
-    inline static double AxisOldLower(
-      const TransformableComponent& transformable)
-    {
-      return transformable.y;
-    }
-
-    inline static double AxisOldUpper(
-      const TransformableComponent& transformable)
-    {
-      return transformable.y + transformable.h;
-    }
+  using Horizontal = HorizVert<0, 1>;
+  using Vertical = HorizVert<1, 0>;
 
-    inline static double AxisNewLower(const CollisionResult& result)
-    {
-      return result.newY;
-    }
+  template <Direction dir, typename AscDesc>
+  class DetectCollisions : public AscDesc {
+  public:
 
-    inline static double AxisNewUpper(
-      const CollisionResult& result,
-      const TransformableComponent& transformable)
-    {
-      return result.newY + transformable.h;
-    }
+    static const Direction Dir = dir;
 
-    inline static double NonAxisOldLower(
-      const TransformableComponent& transformable)
+    inline static double EntityAxis(const vec2d& pos, const vec2i& size)
     {
-      return transformable.x;
+      return AscDesc::EntityAxis(pos, size);
     }
 
-    inline static double NonAxisOldUpper(
-      const TransformableComponent& transformable)
+    inline static double ObjectAxis(const vec2d& pos, const vec2i& size)
     {
-      return transformable.x + transformable.w;
+      return AscDesc::ObjectAxis(pos, size);
     }
 
-    inline static double NonAxisNewLower(
-      const CollisionResult& result,
-      const TransformableComponent& transformable)
+    inline static double EntityAxis(const TransformableComponent& transformable)
     {
-      return result.newX;
+      return AscDesc::EntityAxis(transformable.pos, transformable.size);
     }
 
-    inline static double NonAxisNewUpper(
-      const CollisionResult& result,
-      const TransformableComponent& transformable)
+    inline static double ObjectAxis(const TransformableComponent& transformable)
     {
-      return result.newX + transformable.w;
+      return AscDesc::ObjectAxis(transformable.pos, transformable.size);
     }
   };
 
-  template <Direction dir, typename AscDesc>
-  class DetectCollisions : public AscDesc {
-  public:
-
-    static const Direction Dir = dir;
-  };
-
   class Left : public DetectCollisions<Direction::left, Desc<Horizontal>> {
   public:
 
@@ -531,23 +449,22 @@ namespace CollisionParams {
   };
 };
 
-CollisionResult PonderingSystem::detectCollisions(
+PonderingSystem::CollisionResult PonderingSystem::detectCollisions(
   id_type entity,
-  double x,
-  double y)
+  vec2d newPos)
 {
   auto& transformable = game_.getEntityManager().
     getComponent<TransformableComponent>(entity);
 
   CollisionResult result;
-  result.newX = x;
-  result.newY = transformable.y;
+  result.pos.x() = newPos.x();
+  result.pos.y() = transformable.pos.y();
 
   // Find horizontal collisions.
-  if (result.newX < transformable.x)
+  if (result.pos.x() < transformable.pos.x())
   {
     detectCollisionsInDirection<CollisionParams::Left>(entity, result);
-  } else if (result.newX > transformable.x)
+  } else if (result.pos.x() > transformable.pos.x())
   {
     detectCollisionsInDirection<CollisionParams::Right>(entity, result);
   }
@@ -555,13 +472,13 @@ CollisionResult PonderingSystem::detectCollisions(
   // Find vertical collisions
   if (!result.stopProcessing)
   {
-    result.newY = y;
+    result.pos.y() = newPos.y();
     result.touchedWall = false;
 
-    if (result.newY < transformable.y)
+    if (result.pos.y() < transformable.pos.y())
     {
       detectCollisionsInDirection<CollisionParams::Up>(entity, result);
-    } else if (result.newY > transformable.y)
+    } else if (result.pos.y() > transformable.pos.y())
     {
       detectCollisionsInDirection<CollisionParams::Down>(entity, result);
     }
@@ -586,25 +503,25 @@ void PonderingSystem::detectCollisionsInDirection(
     getComponent<MappableComponent>(mapEntity);
 
   // Get old location.
-  auto& transformable = game_.getEntityManager().
+  auto& transform = game_.getEntityManager().
     getComponent<TransformableComponent>(entity);
 
   bool boundaryCollision = false;
 
   auto boundaries = Param::MapBoundaries(mappable);
-  auto it = boundaries.lower_bound(Param::OldAxis(transformable));
+  auto it = boundaries.lower_bound(Param::EntityAxis(transform));
 
   // Find the axis distance of the closest environmental boundary.
   for (;
       (it != std::end(boundaries)) &&
         Param::AtLeastInAxisSweep(
           it->first,
-          Param::NewAxis(result, transformable));
+          Param::EntityAxis(result.pos, transform.size));
       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))
+    if ((Param::NonAxisUpper(result.pos, transform.size) > it->second.lower) &&
+        (Param::NonAxisLower(result.pos) < it->second.upper))
     {
       // We have a collision!
       boundaryCollision = true;
@@ -644,16 +561,16 @@ void PonderingSystem::detectCollisionsInDirection(
     // Check if the entity would move into the potential collider,
     if (Param::IsPastAxis(
           Param::ObjectAxis(colliderTrans),
-          Param::NewAxis(result, transformable)) &&
+          Param::EntityAxis(result.pos, transform.size)) &&
         // that it wasn't already colliding,
         !Param::IsPastAxis(
           Param::ObjectAxis(colliderTrans),
-          Param::OldAxis(transformable)) &&
+          Param::EntityAxis(transform)) &&
         // that the position on the non-axis is in range,
-        (Param::NonAxisOldUpper(colliderTrans) >
-          Param::NonAxisNewLower(result, transformable)) &&
-        (Param::NonAxisOldLower(colliderTrans) <
-          Param::NonAxisNewUpper(result, transformable)) &&
+        (Param::NonAxisUpper(colliderTrans.pos, colliderTrans.size) >
+          Param::NonAxisLower(result.pos)) &&
+        (Param::NonAxisLower(colliderTrans.pos) <
+          Param::NonAxisUpper(result.pos, transform.size)) &&
         // and that the collider is not farther away than the environmental
         // boundary.
         (!boundaryCollision ||
@@ -688,7 +605,7 @@ void PonderingSystem::detectCollisionsInDirection(
     // Check if the entity would still move into the potential collider.
     if (!Param::IsPastAxis(
           Param::ObjectAxis(colliderTrans),
-          Param::NewAxis(result, transformable)))
+          Param::EntityAxis(result.pos, transform.size)))
     {
       break;
     }
@@ -702,8 +619,8 @@ void PonderingSystem::detectCollisionsInDirection(
       Param::Dir,
       colliderPonder.colliderType,
       Param::ObjectAxis(colliderTrans),
-      Param::NonAxisOldLower(colliderTrans),
-      Param::NonAxisOldUpper(colliderTrans),
+      Param::NonAxisLower(colliderTrans.pos),
+      Param::NonAxisUpper(colliderTrans.pos, colliderTrans.size),
       result);
 
     if (result.stopProcessing)
@@ -724,8 +641,8 @@ void PonderingSystem::detectCollisionsInDirection(
           (it->first == boundaryAxis);
         it++)
     {
-      if ((Param::NonAxisNewUpper(result, transformable) > it->second.lower) &&
-          (Param::NonAxisNewLower(result, transformable) < it->second.upper))
+      if ((Param::NonAxisLower(result.pos) < it->second.upper) &&
+          (Param::NonAxisUpper(result.pos, transform.size) > it->second.lower))
       {
         processCollision(
           entity,
@@ -756,9 +673,6 @@ void PonderingSystem::processCollision(
   double upper,
   CollisionResult& result)
 {
-  auto& ponderable = game_.getEntityManager().
-    getComponent<PonderableComponent>(entity);
-
   auto& transformable = game_.getEntityManager().
     getComponent<TransformableComponent>(entity);
 
@@ -823,29 +737,29 @@ void PonderingSystem::processCollision(
           {
             case Direction::left:
             {
-              result.newX = GAME_WIDTH + WALL_GAP - transformable.w;
+              result.pos.x() = GAME_WIDTH + WALL_GAP - transformable.size.w();
 
               break;
             }
 
             case Direction::right:
             {
-              result.newX = -WALL_GAP;
+              result.pos.x() = -WALL_GAP;
 
               break;
             }
 
             case Direction::up:
             {
-              result.newY =
-                MAP_HEIGHT * TILE_HEIGHT + WALL_GAP - transformable.h;
+              result.pos.y() =
+                MAP_HEIGHT * TILE_HEIGHT + WALL_GAP - transformable.pos.h();
 
               break;
             }
 
             case Direction::down:
             {
-              result.newY = -WALL_GAP;
+              result.pos.y() = -WALL_GAP;
 
               break;
             }
@@ -905,33 +819,33 @@ void PonderingSystem::processCollision(
     {
       case Direction::left:
       {
-        result.newX = axis;
-        ponderable.velX = 0.0;
+        result.pos.x() = axis;
+        result.blockedHoriz = true;
 
         break;
       }
 
       case Direction::right:
       {
-        result.newX = axis - transformable.w;
-        ponderable.velX = 0.0;
+        result.pos.x() = axis - transformable.size.w();
+        result.blockedHoriz = true;
 
         break;
       }
 
       case Direction::up:
       {
-        result.newY = axis;
-        ponderable.velY = 0.0;
+        result.pos.y() = axis;
+        result.blockedVert = true;
 
         break;
       }
 
       case Direction::down:
       {
-        result.newY = axis - transformable.h;
+        result.pos.y() = axis - transformable.size.h();
+        result.blockedVert = true;
         result.groundEntity = collider;
-        ponderable.velY = 0.0;
         result.grounded = true;
 
         break;
@@ -4,19 +4,7 @@
 #include "system.h"
 #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;
-};
+#include "vector.h"
 
 class PonderingSystem : public System {
 public:
@@ -47,7 +35,19 @@ public:
 
 private:
 
-
+  struct CollisionResult
+  {
+    vec2d pos;
+    bool stopProcessing = false;
+    bool touchedWall = false;
+    bool blockedHoriz = false;
+    bool blockedVert = false;
+    bool adjacentlyWarping = false;
+    Direction adjWarpDir;
+    size_t adjWarpMapId;
+    bool grounded = false;
+    id_type groundEntity;
+  };
 
   void tickBody(
     id_type entity,
@@ -56,13 +56,11 @@ private:
 
   CollisionResult moveBody(
     id_type entity,
-    double x,
-    double y);
+    vec2d newPos);
 
   CollisionResult detectCollisions(
     id_type entity,
-    double x,
-    double y);
+    vec2d newPos);
 
   template <typename Param>
   void detectCollisionsInDirection(
@@ -93,20 +93,20 @@ void parseAI(
 
     if (direction == "left")
     {
-      action.speedX = -speed;
-      action.speedY = 0;
+      action.speed.x() = -speed;
+      action.speed.y() = 0;
     } else if (direction == "right")
     {
-      action.speedX = speed;
-      action.speedY = 0;
+      action.speed.x() = speed;
+      action.speed.y() = 0;
     } else if (direction == "up")
     {
-      action.speedX = 0;
-      action.speedY = -speed;
+      action.speed.x() = 0;
+      action.speed.y() = -speed;
     } else if (direction == "down")
     {
-      action.speedX = 0;
-      action.speedY = speed;
+      action.speed.x() = 0;
+      action.speed.y() = speed;
     }
 
     action.dur = length / speed;
@@ -186,11 +186,11 @@ EntityManager::id_type RealizingSystem::initSingleton(
   }
 
   key = getProp(top, "startx");
-  realizable.startingX = atoi(reinterpret_cast<char*>(key));
+  realizable.startingPos.x() = atoi(reinterpret_cast<char*>(key));
   xmlFree(key);
 
   key = getProp(top, "starty");
-  realizable.startingY = atoi(reinterpret_cast<char*>(key));
+  realizable.startingPos.y() = atoi(reinterpret_cast<char*>(key));
   xmlFree(key);
 
   key = getProp(top, "startmap");
@@ -260,11 +260,11 @@ EntityManager::id_type RealizingSystem::initSingleton(
             emplaceComponent<TransformableComponent>(mapObject);
 
           key = getProp(mapNode, "x");
-          transformable.origX = atoi(reinterpret_cast<char*>(key));
+          transformable.origPos.x() = atoi(reinterpret_cast<char*>(key));
           xmlFree(key);
 
           key = getProp(mapNode, "y");
-          transformable.origY = atoi(reinterpret_cast<char*>(key));
+          transformable.origPos.y() = atoi(reinterpret_cast<char*>(key));
           xmlFree(key);
 
           // Set the sprite and size using the prototype definition.
@@ -273,17 +273,17 @@ EntityManager::id_type RealizingSystem::initSingleton(
           xmlFree(key);
 
           key = getProp(prototypeNode, "width");
-          transformable.origW = atoi(reinterpret_cast<char*>(key));
+          transformable.origSize.w() = atoi(reinterpret_cast<char*>(key));
           xmlFree(key);
 
           key = getProp(prototypeNode, "height");
-          transformable.origH = atoi(reinterpret_cast<char*>(key));
+          transformable.origSize.h() = atoi(reinterpret_cast<char*>(key));
           xmlFree(key);
 
           AnimationSet objectAnim(
             spritePath.c_str(),
-            transformable.origW,
-            transformable.origH,
+            transformable.origSize.w(),
+            transformable.origSize.h(),
             1);
 
           objectAnim.emplaceAnimation("static", 0, 1, 1);
@@ -503,10 +503,8 @@ void RealizingSystem::loadMap(id_type mapEntity)
       auto& transformable = game_.getEntityManager().
         getComponent<TransformableComponent>(prototype);
 
-      transformable.x = transformable.origX;
-      transformable.y = transformable.origY;
-      transformable.w = transformable.origW;
-      transformable.h = transformable.origH;
+      transformable.pos = transformable.origPos;
+      transformable.size = transformable.origSize;
     }
 
     if (game_.getEntityManager().hasComponent<AnimatableComponent>(prototype))
@@ -0,0 +1,111 @@
+#ifndef COORDINATES_H_A45D34FB
+#define COORDINATES_H_A45D34FB
+
+template <typename T>
+class vec2 {
+public:
+
+  T coords[2];
+
+  vec2() = default;
+
+  vec2(double x, double y) : coords{x, y}
+  {
+  }
+
+  inline T& x()
+  {
+    return coords[0];
+  }
+
+  inline const T& x() const
+  {
+    return coords[0];
+  }
+
+  inline T& w()
+  {
+    return coords[0];
+  }
+
+  inline const T& w() const
+  {
+    return coords[0];
+  }
+
+  inline T& y()
+  {
+    return coords[1];
+  }
+
+  inline const T& y() const
+  {
+    return coords[1];
+  }
+
+  inline T& h()
+  {
+    return coords[1];
+  }
+
+  inline const T& h() const
+  {
+    return coords[1];
+  }
+
+  template <typename R>
+  operator vec2<R>() const
+  {
+    return vec2<R>(x(), y());
+  }
+
+  vec2 operator+(const vec2& other) const
+  {
+    return vec2(x() + other.x(), y() + other.y());
+  }
+
+  vec2& operator+=(const vec2& other)
+  {
+    x() += other.x();
+    y() += other.y();
+
+    return *this;
+  }
+
+  vec2 operator-(const vec2& other) const
+  {
+    return vec2(x() - other.x(), y() - other.y());
+  }
+
+  vec2 operator-=(const vec2& other)
+  {
+    x() -= other.x();
+    y() -= other.y();
+
+    return *this;
+  }
+
+  vec2 operator-() const
+  {
+    return vec2(-x(), -y());
+  }
+
+  vec2 operator*(double s) const
+  {
+    return vec2(x() * s, y() * s);
+  }
+
+  vec2& operator*=(double s)
+  {
+    x() *= s;
+    y() *= s;
+
+    return *this;
+  }
+
+};
+
+using vec2d = vec2<double>;
+using vec2i = vec2<int>;
+
+#endif /* end of include guard: COORDINATES_H_A45D34FB */