4 files changed, 61 insertions, 28 deletions

@@ -56,6 +56,11 @@ public:
   vec2d accel = { 0.0, 0.0 };
 
   /**
+   * The target velocity of the body.
+   */
+  vec2d targetVel = { 0.0, 0.0 };
+
+  /**
    * The type of physical body that the entity is meant to assume. The body will
    * be acted upon differently based on this. See the enumeration above for more
    * details.
@@ -20,30 +20,6 @@ void OrientingSystem::tick(double)
     auto& ponderable = game_.getEntityManager().
       getComponent<PonderableComponent>(entity);
 
-    switch (orientable.getWalkState())
-    {
-      case OrientableComponent::WalkState::still:
-      {
-        ponderable.vel.x() = 0.0;
-
-        break;
-      }
-
-      case OrientableComponent::WalkState::left:
-      {
-        ponderable.vel.x() = -WALK_SPEED;
-
-        break;
-      }
-
-      case OrientableComponent::WalkState::right:
-      {
-        ponderable.vel.x() = WALK_SPEED;
-
-        break;
-      }
-    }
-
     if (orientable.isJumping() && (ponderable.vel.y() > 0))
     {
       orientable.setJumping(false);
@@ -62,6 +38,8 @@ void OrientingSystem::moveLeft(id_type entity)
   orientable.setFacingRight(false);
   orientable.setWalkState(OrientableComponent::WalkState::left);
 
+  ponderable.targetVel.x() = -WALK_SPEED;
+
   auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
   if (ponderable.grounded)
   {
@@ -82,6 +60,8 @@ void OrientingSystem::moveRight(id_type entity)
   orientable.setFacingRight(true);
   orientable.setWalkState(OrientableComponent::WalkState::right);
 
+  ponderable.targetVel.x() = WALK_SPEED;
+
   auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
   if (ponderable.grounded)
   {
@@ -93,10 +73,14 @@ void OrientingSystem::moveRight(id_type entity)
 
 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);
+  ponderable.targetVel.x() = 0;
 
   auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
 
@@ -5,6 +5,7 @@
 #include "components/playable.h"
 #include "components/controllable.h"
 #include "components/orientable.h"
+#include "components/ponderable.h"
 #include "systems/mapping.h"
 #include "systems/pondering.h"
 #include "systems/orienting.h"
@@ -46,6 +47,10 @@ void PlayingSystem::initPlayer()
     player,
     PonderableComponent::Type::freefalling);
 
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(player);
+  ponderable.accel.x() = 720;
+
   game_.getEntityManager().emplaceComponent<ControllableComponent>(player);
   game_.getEntityManager().emplaceComponent<OrientableComponent>(player);
 
@@ -44,6 +44,7 @@ void PonderingSystem::initializeBody(
 
   if (type == PonderableComponent::Type::freefalling)
   {
+    ponderable.targetVel.y() = TERMINAL_VELOCITY;
     ponderable.accel.y() = NORMAL_GRAVITY;
   }
 }
@@ -57,6 +58,8 @@ void PonderingSystem::initPrototype(id_type prototype)
   ponderable.vel.y() = 0.0;
   ponderable.accel.x() = 0.0;
   ponderable.accel.y() = 0.0;
+  ponderable.targetVel.x() = 0.0;
+  ponderable.targetVel.y() = 0.0;
   ponderable.grounded = false;
   ponderable.frozen = false;
   ponderable.collidable = true;
@@ -98,12 +101,48 @@ void PonderingSystem::tickBody(
   // Accelerate
   if (!ponderable.frozen)
   {
-    ponderable.vel += ponderable.accel * dt;
+    // Determine the effective acceleration, which should be in the direction of
+    // the target velocity.
+    vec2d effAcc = ponderable.accel;
 
-    if ((ponderable.type == PonderableComponent::Type::freefalling)
-      && (ponderable.vel.y() > TERMINAL_VELOCITY))
+    if (ponderable.vel.x() == ponderable.targetVel.x())
     {
-      ponderable.vel.y() = TERMINAL_VELOCITY;
+      effAcc.x() = 0.0;
+    }
+    else if ((ponderable.accel.x() > 0 &&
+              ponderable.targetVel.x() < ponderable.vel.x()) ||
+             (ponderable.accel.x() < 0 &&
+              ponderable.targetVel.x() > ponderable.vel.x()))
+    {
+      effAcc.x() = -effAcc.x();
+    }
+
+    if (ponderable.vel.y() == ponderable.targetVel.y())
+    {
+      effAcc.y() = 0.0;
+    }
+    else if ((ponderable.accel.y() > 0 &&
+              ponderable.targetVel.y() < ponderable.vel.y()) ||
+             (ponderable.accel.y() < 0 &&
+              ponderable.targetVel.y() > ponderable.vel.y()))
+    {
+      effAcc.y() = -effAcc.y();
+    }
+
+    // Accelerate
+    ponderable.vel += effAcc * dt;
+
+    // If the velocity crossed the target velocity, set it to the target
+    if ((effAcc.x() > 0 && ponderable.vel.x() > ponderable.targetVel.x()) ||
+        (effAcc.x() < 0 && ponderable.vel.x() < ponderable.targetVel.x()))
+    {
+      ponderable.vel.x() = ponderable.targetVel.x();
+    }
+
+    if ((effAcc.y() > 0 && ponderable.vel.y() > ponderable.targetVel.y()) ||
+        (effAcc.y() < 0 && ponderable.vel.y() < ponderable.targetVel.y()))
+    {
+      ponderable.vel.y() = ponderable.targetVel.y();
     }
   }