11 files changed, 392 insertions, 207 deletions

@@ -1,24 +0,0 @@
-#ifndef DROPPABLE_H_5DB254EF
-#define DROPPABLE_H_5DB254EF
-
-#include "component.h"
-
-class DroppableComponent : public Component {
-public:
-
-  inline bool isDroppable() const
-  {
-    return droppable_;
-  }
-
-  inline void setDroppable(bool can)
-  {
-    droppable_ = can;
-  }
-
-private:
-
-  bool droppable_ = false;
-};
-
-#endif /* end of include guard: DROPPABLE_H_5DB254EF */
@@ -6,6 +6,18 @@
 class OrientableComponent : public Component {
 public:
 
+  enum class WalkState {
+    still,
+    left,
+    right
+  };
+
+  enum class DropState {
+    none,
+    ready,
+    active
+  };
+
   inline bool isFacingRight() const
   {
     return facingRight_;
@@ -16,9 +28,42 @@ public:
     facingRight_ = v;
   }
 
+  inline WalkState getWalkState() const
+  {
+    return walkState_;
+  }
+
+  inline void setWalkState(WalkState v)
+  {
+    walkState_ = v;
+  }
+
+  inline bool isJumping() const
+  {
+    return jumping_;
+  }
+
+  inline void setJumping(bool v)
+  {
+    jumping_ = v;
+  }
+
+  inline DropState getDropState() const
+  {
+    return dropState_;
+  }
+
+  inline void setDropState(DropState v)
+  {
+    dropState_ = v;
+  }
+
 private:
 
   bool facingRight_ = false;
+  WalkState walkState_ = WalkState::still;
+  bool jumping_ = false;
+  DropState dropState_ = DropState::none;
 };
 
 #endif /* end of include guard: ORIENTABLE_H_EDB6C4A1 */
@@ -11,13 +11,6 @@ public:
     freefalling
   };
 
-  enum class State {
-    grounded,
-    jumping,
-    falling,
-    dropping
-  };
-
   PonderableComponent(Type type) : type_(type)
   {
   }
@@ -67,14 +60,14 @@ public:
     accelY_ = v;
   }
 
-  inline State getState() const
+  inline bool isGrounded() const
   {
-    return state_;
+    return grounded_;
   }
 
-  inline void setState(State arg)
+  inline void setGrounded(bool v)
   {
-    state_ = arg;
+    grounded_ = v;
   }
 
 private:
@@ -84,7 +77,7 @@ private:
   double accelX_ = 0.0;
   double accelY_ = 0.0;
   Type type_ = Type::vacuumed;
-  State state_ = State::grounded;
+  bool grounded_ = false;
 };
 
 #endif /* end of include guard: TANGIBLE_H_746DB3EE */
@@ -14,7 +14,13 @@ const int FONT_COLS = 16;
 const int FRAMES_PER_SECOND = 60;
 const double SECONDS_PER_FRAME = 1.0 / FRAMES_PER_SECOND;
 
-#define JUMP_VELOCITY(h, l) (-2 * (h) / (l))
-#define JUMP_GRAVITY(h, l) (2 * ((h) / (l)) / (l))
+#define CALC_VELOCITY(h, l) (-2 * (h) / (l))
+#define CALC_GRAVITY(h, l) (2 * ((h) / (l)) / (l))
+
+const double NORMAL_GRAVITY = CALC_GRAVITY(TILE_HEIGHT*3.5, 0.233);
+const double JUMP_GRAVITY = CALC_GRAVITY(TILE_HEIGHT*4.5, 0.3);
+const double JUMP_VELOCITY = CALC_VELOCITY(TILE_HEIGHT*4.5, 0.3);
+
+const double WALK_SPEED = 90;
 
 #endif
@@ -2,13 +2,13 @@
 #include "components/animatable.h"
 #include "components/transformable.h"
 #include "components/controllable.h"
-#include "components/droppable.h"
 #include "components/ponderable.h"
 #include "components/orientable.h"
 #include "systems/controlling.h"
 #include "systems/pondering.h"
 #include "systems/animating.h"
 #include "systems/mapping.h"
+#include "systems/orienting.h"
 #include "animation.h"
 #include "renderer.h"
 #include "consts.h"
@@ -33,6 +33,7 @@ Game::Game(
     world_("res/maps.xml")
 {
   systemManager_.emplaceSystem<ControllingSystem>(*this);
+  systemManager_.emplaceSystem<OrientingSystem>(*this);
   systemManager_.emplaceSystem<PonderingSystem>(*this);
   systemManager_.emplaceSystem<MappingSystem>(*this);
   systemManager_.emplaceSystem<AnimatingSystem>(*this);
@@ -58,7 +59,6 @@ Game::Game(
     player,
     PonderableComponent::Type::freefalling);
 
-  entityManager_.emplaceComponent<DroppableComponent>(player);
   entityManager_.emplaceComponent<ControllableComponent>(player);
   entityManager_.emplaceComponent<OrientableComponent>(player);
 
@@ -1,14 +1,8 @@
 #include "controlling.h"
 #include "game.h"
 #include "components/controllable.h"
-#include "components/ponderable.h"
-#include "components/animatable.h"
-#include "components/droppable.h"
 #include "components/orientable.h"
-#include "systems/animating.h"
-#include "direction.h"
-#include "muxer.h"
-#include "consts.h"
+#include "systems/orienting.h"
 
 void ControllingSystem::tick(double)
 {
@@ -19,9 +13,6 @@ void ControllingSystem::tick(double)
 
     auto entities = game_.getEntityManager().getEntitiesWithComponents<
       ControllableComponent,
-      PonderableComponent,
-      AnimatableComponent,
-      DroppableComponent,
       OrientableComponent>();
 
     for (auto entity : entities)
@@ -29,6 +20,8 @@ void ControllingSystem::tick(double)
       auto& controllable = game_.getEntityManager().
         getComponent<ControllableComponent>(entity);
 
+      auto& orienting = game_.getSystemManager().getSystem<OrientingSystem>();
+
       if (action == GLFW_PRESS)
       {
         if (key == controllable.getLeftKey())
@@ -37,7 +30,7 @@ void ControllingSystem::tick(double)
 
           if (!controllable.isFrozen())
           {
-            walkLeft(entity);
+            orienting.moveLeft(entity);
           }
         } else if (key == controllable.getRightKey())
         {
@@ -45,19 +38,19 @@ void ControllingSystem::tick(double)
 
           if (!controllable.isFrozen())
           {
-            walkRight(entity);
+            orienting.moveRight(entity);
           }
         } else if (key == controllable.getJumpKey())
         {
           if (!controllable.isFrozen())
           {
-            jump(entity);
+            orienting.jump(entity);
           }
         } else if (key == controllable.getDropKey())
         {
           if (!controllable.isFrozen())
           {
-            drop(entity, true);
+            orienting.drop(entity);
           }
         }
       } else if (action == GLFW_RELEASE)
@@ -70,9 +63,9 @@ void ControllingSystem::tick(double)
           {
             if (controllable.isHoldingRight())
             {
-              walkRight(entity);
+              orienting.moveRight(entity);
             } else {
-              stopWalking(entity);
+              orienting.stopWalking(entity);
             }
           }
         } else if (key == controllable.getRightKey())
@@ -83,22 +76,22 @@ void ControllingSystem::tick(double)
           {
             if (controllable.isHoldingLeft())
             {
-              walkLeft(entity);
+              orienting.moveLeft(entity);
             } else {
-              stopWalking(entity);
+              orienting.stopWalking(entity);
             }
           }
         } else if (key == controllable.getDropKey())
         {
           if (!controllable.isFrozen())
           {
-            drop(entity, false);
+            orienting.stopDropping(entity);
           }
         } else if (key == controllable.getJumpKey())
         {
           if (!controllable.isFrozen())
           {
-            stopJumping(entity);
+            orienting.stopJumping(entity);
           }
         }
       }
@@ -112,99 +105,3 @@ void ControllingSystem::input(int key, int action)
 {
   actions_.push(std::make_pair(key, action));
 }
-
-void ControllingSystem::walkLeft(id_type entity)
-{
-  auto& ponderable = game_.getEntityManager().getComponent<PonderableComponent>(entity);
-  auto& orientable = game_.getEntityManager().getComponent<OrientableComponent>(entity);
-
-  orientable.setFacingRight(false);
-  ponderable.setVelocityX(-90);
-
-  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
-
-  if (ponderable.getState() == PonderableComponent::State::grounded)
-  {
-    animating.startAnimation(entity, "walkingLeft");
-  } else {
-    animating.startAnimation(entity, "stillLeft");
-  }
-}
-
-void ControllingSystem::walkRight(id_type entity)
-{
-  auto& ponderable = game_.getEntityManager().getComponent<PonderableComponent>(entity);
-  auto& orientable = game_.getEntityManager().getComponent<OrientableComponent>(entity);
-
-  orientable.setFacingRight(true);
-  ponderable.setVelocityX(90);
-
-  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
-
-  if (ponderable.getState() == PonderableComponent::State::grounded)
-  {
-    animating.startAnimation(entity, "walkingRight");
-  } else {
-    animating.startAnimation(entity, "stillRight");
-  }
-}
-
-void ControllingSystem::stopWalking(id_type entity)
-{
-  auto& ponderable = game_.getEntityManager().getComponent<PonderableComponent>(entity);
-  auto& orientable = game_.getEntityManager().getComponent<OrientableComponent>(entity);
-
-  ponderable.setVelocityX(0);
-
-  if (ponderable.getState() == PonderableComponent::State::grounded)
-  {
-    auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
-
-    if (orientable.isFacingRight())
-    {
-      animating.startAnimation(entity, "stillRight");
-    } else {
-      animating.startAnimation(entity, "stillLeft");
-    }
-  }
-}
-
-void ControllingSystem::jump(id_type entity)
-{
-  auto& ponderable = game_.getEntityManager().getComponent<PonderableComponent>(entity);
-
-  if (ponderable.getState() == PonderableComponent::State::grounded)
-  {
-    playSound("res/Randomize87.wav", 0.25);
-
-    ponderable.setVelocityY(JUMP_VELOCITY(TILE_HEIGHT*4.5, 0.3));
-    ponderable.setAccelY(JUMP_GRAVITY(TILE_HEIGHT*4.5, 0.3));
-    ponderable.setState(PonderableComponent::State::jumping);
-  }
-}
-
-void ControllingSystem::stopJumping(id_type entity)
-{
-  auto& ponderable = game_.getEntityManager().getComponent<PonderableComponent>(entity);
-
-  if (ponderable.getState() == PonderableComponent::State::jumping)
-  {
-    ponderable.setAccelY(JUMP_GRAVITY(TILE_HEIGHT*3.5, 0.233));
-    ponderable.setState(PonderableComponent::State::falling);
-  }
-}
-
-void ControllingSystem::drop(id_type entity, bool start)
-{
-  auto& droppable = game_.getEntityManager().getComponent<DroppableComponent>(entity);
-  auto& ponderable = game_.getEntityManager().getComponent<PonderableComponent>(entity);
-
-  if (start && (ponderable.getState() == PonderableComponent::State::grounded))
-  {
-    ponderable.setState(PonderableComponent::State::dropping);
-  } else if ((!start) && (ponderable.getState() == PonderableComponent::State::dropping))
-  {
-    ponderable.setState(PonderableComponent::State::grounded);
-  }
-  droppable.setDroppable(start);
-}
@@ -3,7 +3,6 @@
 
 #include "system.h"
 #include <queue>
-#include "entity_manager.h"
 
 class ControllingSystem : public System {
 public:
@@ -17,13 +16,6 @@ public:
 
 private:
 
-  void walkLeft(id_type entity);
-  void walkRight(id_type entity);
-  void stopWalking(id_type entity);
-  void jump(id_type entity);
-  void stopJumping(id_type entity);
-  void drop(id_type entity, bool start);
-
   std::queue<std::pair<int,int>> actions_;
 };
 
@@ -3,8 +3,6 @@
 #include "game.h"
 #include "consts.h"
 
-#include <iostream>
-
 template <typename Storage>
 inline void addBoundary(
   Storage& boundaries,
@@ -0,0 +1,236 @@
+#include "orienting.h"
+#include "game.h"
+#include "components/orientable.h"
+#include "components/ponderable.h"
+#include "systems/animating.h"
+#include "consts.h"
+#include "muxer.h"
+
+void OrientingSystem::tick(double)
+{
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    OrientableComponent,
+    PonderableComponent>();
+
+  for (id_type entity : entities)
+  {
+    auto& orientable = game_.getEntityManager().
+      getComponent<OrientableComponent>(entity);
+
+    auto& ponderable = game_.getEntityManager().
+      getComponent<PonderableComponent>(entity);
+
+    switch (orientable.getWalkState())
+    {
+      case OrientableComponent::WalkState::still:
+      {
+        ponderable.setVelocityX(0);
+
+        break;
+      }
+
+      case OrientableComponent::WalkState::left:
+      {
+        ponderable.setVelocityX(-WALK_SPEED);
+
+        break;
+      }
+
+      case OrientableComponent::WalkState::right:
+      {
+        ponderable.setVelocityX(WALK_SPEED);
+
+        break;
+      }
+    }
+
+    if (orientable.isJumping() && (ponderable.getVelocityY() > 0))
+    {
+      orientable.setJumping(false);
+    }
+  }
+}
+
+void OrientingSystem::moveLeft(id_type entity)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  orientable.setFacingRight(false);
+  orientable.setWalkState(OrientableComponent::WalkState::left);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+  if (ponderable.isGrounded())
+  {
+    animating.startAnimation(entity, "walkingLeft");
+  } else {
+    animating.startAnimation(entity, "stillLeft");
+  }
+}
+
+void OrientingSystem::moveRight(id_type entity)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  orientable.setFacingRight(true);
+  orientable.setWalkState(OrientableComponent::WalkState::right);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+  if (ponderable.isGrounded())
+  {
+    animating.startAnimation(entity, "walkingRight");
+  } else {
+    animating.startAnimation(entity, "stillRight");
+  }
+}
+
+void OrientingSystem::stopWalking(id_type entity)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  orientable.setWalkState(OrientableComponent::WalkState::still);
+
+  if (ponderable.isGrounded())
+  {
+    auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+
+    if (orientable.isFacingRight())
+    {
+      animating.startAnimation(entity, "stillRight");
+    } else {
+      animating.startAnimation(entity, "stillLeft");
+    }
+  }
+}
+
+void OrientingSystem::jump(id_type entity)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  if (ponderable.isGrounded())
+  {
+    auto& orientable = game_.getEntityManager().
+      getComponent<OrientableComponent>(entity);
+
+    orientable.setJumping(true);
+
+    playSound("res/Randomize87.wav", 0.25);
+
+    ponderable.setVelocityY(JUMP_VELOCITY);
+    ponderable.setAccelY(JUMP_GRAVITY);
+
+    auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+    if (orientable.isFacingRight())
+    {
+      animating.startAnimation(entity, "stillRight");
+    } else {
+      animating.startAnimation(entity, "stillLeft");
+    }
+  }
+}
+
+void OrientingSystem::stopJumping(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  if (orientable.isJumping())
+  {
+    orientable.setJumping(false);
+
+    auto& ponderable = game_.getEntityManager().
+      getComponent<PonderableComponent>(entity);
+
+    ponderable.setAccelY(NORMAL_GRAVITY);
+  }
+}
+
+void OrientingSystem::land(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+
+  switch (orientable.getWalkState())
+  {
+    case OrientableComponent::WalkState::still:
+    {
+      if (orientable.isFacingRight())
+      {
+        animating.startAnimation(entity, "stillRight");
+      } else {
+        animating.startAnimation(entity, "stillLeft");
+      }
+
+      break;
+    }
+
+    case OrientableComponent::WalkState::left:
+    {
+      animating.startAnimation(entity, "walkingLeft");
+
+      break;
+    }
+
+    case OrientableComponent::WalkState::right:
+    {
+      animating.startAnimation(entity, "walkingRight");
+
+      break;
+    }
+  }
+}
+
+void OrientingSystem::startFalling(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+
+  if (orientable.isFacingRight())
+  {
+    animating.startAnimation(entity, "stillRight");
+  } else {
+    animating.startAnimation(entity, "stillLeft");
+  }
+}
+
+void OrientingSystem::drop(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  if (ponderable.isGrounded()
+    && (orientable.getDropState() == OrientableComponent::DropState::none))
+  {
+    orientable.setDropState(OrientableComponent::DropState::ready);
+  }
+}
+
+void OrientingSystem::stopDropping(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  if (orientable.getDropState() == OrientableComponent::DropState::ready)
+  {
+    orientable.setDropState(OrientableComponent::DropState::none);
+  }
+}
@@ -0,0 +1,35 @@
+#ifndef ORIENTING_H_099F0C23
+#define ORIENTING_H_099F0C23
+
+#include "system.h"
+
+class OrientingSystem : public System {
+public:
+
+  OrientingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void moveLeft(id_type entity);
+
+  void moveRight(id_type entity);
+
+  void stopWalking(id_type entity);
+
+  void jump(id_type entity);
+
+  void stopJumping(id_type entity);
+
+  void land(id_type entity);
+
+  void startFalling(id_type entity);
+
+  void drop(id_type entity);
+
+  void stopDropping(id_type entity);
+
+};
+
+#endif /* end of include guard: ORIENTING_H_099F0C23 */
@@ -2,7 +2,9 @@
 #include "game.h"
 #include "components/ponderable.h"
 #include "components/transformable.h"
-#include "components/droppable.h"
+#include "components/orientable.h"
+#include "components/mappable.h"
+#include "systems/orienting.h"
 #include "consts.h"
 
 void PonderingSystem::tick(double dt)
@@ -37,10 +39,8 @@ void PonderingSystem::tick(double dt)
     double newX = oldX + ponderable.getVelocityX() * dt;
     double newY = oldY + ponderable.getVelocityY() * dt;
 
-    if (ponderable.getVelocityY() > 0.0)
-    {
-      ponderable.setState(PonderableComponent::State::falling);
-    }
+    bool oldGrounded = ponderable.isGrounded();
+    ponderable.setGrounded(false);
 
     for (id_type mapEntity : maps)
     {
@@ -64,8 +64,6 @@ void PonderingSystem::tick(double dt)
               newY,
               it->first,
               it->second.getType());
-
-            break;
           }
         }
       } else if (newX > oldX)
@@ -86,8 +84,6 @@ void PonderingSystem::tick(double dt)
               newY,
               it->first,
               it->second.getType());
-
-            break;
           }
         }
       }
@@ -109,8 +105,6 @@ void PonderingSystem::tick(double dt)
               newY,
               it->first,
               it->second.getType());
-
-            break;
           }
         }
       } else if (newY > oldY)
@@ -131,8 +125,6 @@ void PonderingSystem::tick(double dt)
               newY,
               it->first,
               it->second.getType());
-
-            break;
           }
         }
       }
@@ -141,6 +133,31 @@ void PonderingSystem::tick(double dt)
     // Move
     transformable.setX(newX);
     transformable.setY(newY);
+
+    // Perform cleanup for orientable entites
+    if (game_.getEntityManager().hasComponent<OrientableComponent>(entity))
+    {
+      auto& orientable = game_.getEntityManager().
+        getComponent<OrientableComponent>(entity);
+
+      // Handle changes in groundedness
+      if (ponderable.isGrounded() != oldGrounded)
+      {
+        if (ponderable.isGrounded())
+        {
+          game_.getSystemManager().getSystem<OrientingSystem>().land(entity);
+        } else {
+          game_.getSystemManager().
+            getSystem<OrientingSystem>().startFalling(entity);
+        }
+      }
+
+      // Complete dropping, if necessary
+      if (orientable.getDropState() == OrientableComponent::DropState::active)
+      {
+        orientable.setDropState(OrientableComponent::DropState::none);
+      }
+    }
   }
 }
 
@@ -153,8 +170,7 @@ void PonderingSystem::initializeBody(
 
   if (type == PonderableComponent::Type::freefalling)
   {
-    ponderable.setAccelY(JUMP_GRAVITY(TILE_HEIGHT*3.5, 0.233));
-    ponderable.setState(PonderableComponent::State::falling);
+    ponderable.setAccelY(NORMAL_GRAVITY);
   }
 }
 
@@ -172,6 +188,8 @@ void PonderingSystem::processCollision(
   auto& transformable = game_.getEntityManager().
     getComponent<TransformableComponent>(entity);
 
+  bool touchedGround = false;
+
   switch (type)
   {
     case MappableComponent::Boundary::Type::wall:
@@ -204,13 +222,7 @@ void PonderingSystem::processCollision(
 
         case Direction::down:
         {
-          newY = axis - transformable.getH();
-          ponderable.setVelocityY(0.0);
-
-          if (ponderable.getState() == PonderableComponent::State::falling)
-          {
-            ponderable.setState(PonderableComponent::State::grounded);
-          }
+          touchedGround = true;
 
           break;
         }
@@ -221,31 +233,19 @@ void PonderingSystem::processCollision(
 
     case MappableComponent::Boundary::Type::platform:
     {
-      if (game_.getEntityManager().hasComponent<DroppableComponent>(entity))
+      if (game_.getEntityManager().hasComponent<OrientableComponent>(entity))
       {
-        auto& droppable = game_.getEntityManager().
-          getComponent<DroppableComponent>(entity);
+        auto& orientable = game_.getEntityManager().
+          getComponent<OrientableComponent>(entity);
 
-        if (droppable.isDroppable())
+        if (orientable.getDropState() != OrientableComponent::DropState::none)
         {
-          droppable.setDroppable(false);
+          orientable.setDropState(OrientableComponent::DropState::active);
         } else {
-          newY = axis - transformable.getH();
-          ponderable.setVelocityY(0.0);
-
-          if (ponderable.getState() == PonderableComponent::State::falling)
-          {
-            ponderable.setState(PonderableComponent::State::grounded);
-          }
+          touchedGround = true;
         }
       } else {
-        newY = axis - transformable.getH();
-        ponderable.setVelocityY(0.0);
-
-        if (ponderable.getState() == PonderableComponent::State::falling)
-        {
-          ponderable.setState(PonderableComponent::State::grounded);
-        }
+        touchedGround = true;
       }
 
       break;
@@ -258,4 +258,11 @@ void PonderingSystem::processCollision(
       break;
     }
   }
+
+  if (touchedGround)
+  {
+    newY = axis - transformable.getH();
+    ponderable.setVelocityY(0.0);
+    ponderable.setGrounded(true);
+  }
 }