Added player death and event scheduling

Also added ability to make sprites flicker, to freeze physics for an entity, and to freeze progression of a sprite's animation loop.

15 files changed, 346 insertions, 19 deletions

@@ -51,12 +51,45 @@ public:
     animation_ = std::move(animation);
   }
 
+  inline bool isFlickering() const
+  {
+    return flickering_;
+  }
+
+  inline void setFlickering(bool v)
+  {
+    flickering_ = v;
+  }
+
+  inline size_t getFlickerTimer() const
+  {
+    return flickerTimer_;
+  }
+
+  inline void setFlickerTimer(size_t v)
+  {
+    flickerTimer_ = v;
+  }
+
+  inline bool isFrozen() const
+  {
+    return frozen_;
+  }
+
+  inline void setFrozen(bool v)
+  {
+    frozen_ = v;
+  }
+
 private:
 
   AnimationSet animationSet_;
   std::string animation_;
   size_t frame_ = 0;
   size_t countdown_ = 0;
+  bool flickering_ = false;
+  size_t flickerTimer_ = 0;
+  bool frozen_ = false;
 };
 
 #endif /* end of include guard: SPRITE_RENDERABLE_H_D3AACBBF */
@@ -2,14 +2,23 @@
 #define PLAYABLE_H_DDC566C3
 
 #include "component.h"
+#include <functional>
 
 class PlayableComponent : public Component {
 public:
 
+  using MapChangeCallback = std::function<void()>;
+
   bool changingMap = false;
   int newMapId = -1;
   double newMapX = 0;
   double newMapY = 0;
+  MapChangeCallback newMapCallback;
+
+  int checkpointMapId = -1;
+  double checkpointX = 0;
+  double checkpointY = 0;
+
 };
 
 #endif /* end of include guard: PLAYABLE_H_DDC566C3 */
@@ -70,6 +70,26 @@ public:
     grounded_ = v;
   }
 
+  inline bool isFrozen() const
+  {
+    return frozen_;
+  }
+
+  inline void setFrozen(bool v)
+  {
+    frozen_ = v;
+  }
+
+  inline bool isCollidable() const
+  {
+    return collidable_;
+  }
+
+  inline void setCollidable(bool v)
+  {
+    collidable_ = v;
+  }
+
 private:
 
   double velX_ = 0.0;
@@ -78,6 +98,8 @@ private:
   double accelY_ = 0.0;
   Type type_ = Type::vacuumed;
   bool grounded_ = false;
+  bool frozen_ = false;
+  bool collidable_ = true;
 };
 
 #endif /* end of include guard: TANGIBLE_H_746DB3EE */
@@ -0,0 +1,21 @@
+#ifndef SCHEDULABLE_H_1DA3FA2A
+#define SCHEDULABLE_H_1DA3FA2A
+
+#include "component.h"
+#include <tuple>
+#include <list>
+#include <functional>
+#include "entity_manager.h"
+
+class SchedulableComponent : public Component {
+public:
+
+  using id_type = EntityManager::id_type;
+
+  using Callback = std::function<void(id_type)>;
+  using Action = std::tuple<double, Callback>;
+
+  std::list<Action> actions;
+};
+
+#endif /* end of include guard: SCHEDULABLE_H_1DA3FA2A */
@@ -10,6 +10,7 @@
 #include "systems/mapping.h"
 #include "systems/orienting.h"
 #include "systems/playing.h"
+#include "systems/scheduling.h"
 #include "animation.h"
 #include "consts.h"
 
@@ -30,6 +31,7 @@ void key_callback(GLFWwindow* window, int key, int, int action, int)
 Game::Game() : world_("res/maps.xml")
 {
   systemManager_.emplaceSystem<PlayingSystem>(*this);
+  systemManager_.emplaceSystem<SchedulingSystem>(*this);
   systemManager_.emplaceSystem<ControllingSystem>(*this);
   systemManager_.emplaceSystem<OrientingSystem>(*this);
   systemManager_.emplaceSystem<PonderingSystem>(*this);
@@ -13,7 +13,10 @@ void AnimatingSystem::tick(double)
     auto& sprite = game_.getEntityManager().
       getComponent<AnimatableComponent>(entity);
 
-    sprite.setCountdown(sprite.getCountdown() + 1);
+    if (!sprite.isFrozen())
+    {
+      sprite.setCountdown(sprite.getCountdown() + 1);
+    }
 
     const Animation& anim = sprite.getAnimation();
     if (sprite.getCountdown() >= anim.getDelay())
@@ -26,6 +29,11 @@ void AnimatingSystem::tick(double)
         sprite.setFrame(anim.getFirstFrame());
       }
     }
+
+    if (sprite.isFlickering())
+    {
+      sprite.setFlickerTimer((sprite.getFlickerTimer() + 1) % 6);
+    }
   }
 }
 
@@ -44,6 +52,12 @@ void AnimatingSystem::render(Texture& texture)
     auto& transform = game_.getEntityManager().
       getComponent<TransformableComponent>(entity);
 
+    double alpha = 1.0;
+    if (sprite.isFlickering() && (sprite.getFlickerTimer() < 3))
+    {
+      alpha = 0.0;
+    }
+
     Rectangle dstrect {
       static_cast<int>(transform.getX()),
       static_cast<int>(transform.getY()),
@@ -55,7 +69,8 @@ void AnimatingSystem::render(Texture& texture)
       aset.getTexture(),
       texture,
       aset.getFrameRect(sprite.getFrame()),
-      dstrect);
+      dstrect,
+      alpha);
   }
 }
 
@@ -105,3 +105,32 @@ void ControllingSystem::input(int key, int action)
 {
   actions_.push(std::make_pair(key, action));
 }
+
+void ControllingSystem::freeze(id_type entity)
+{
+  auto& controllable = game_.getEntityManager().
+    getComponent<ControllableComponent>(entity);
+
+  controllable.setFrozen(true);
+}
+
+void ControllingSystem::unfreeze(id_type entity)
+{
+  auto& controllable = game_.getEntityManager().
+    getComponent<ControllableComponent>(entity);
+
+  if (controllable.isFrozen())
+  {
+    controllable.setFrozen(false);
+
+    auto& orienting = game_.getSystemManager().getSystem<OrientingSystem>();
+
+    if (controllable.isHoldingLeft())
+    {
+      orienting.moveLeft(entity);
+    } else if (controllable.isHoldingRight())
+    {
+      orienting.moveRight(entity);
+    }
+  }
+}
@@ -12,8 +12,13 @@ public:
   }
 
   void tick(double dt);
+
   void input(int key, int action);
 
+  void freeze(id_type entity);
+
+  void unfreeze(id_type entity);
+
 private:
 
   std::queue<std::pair<int,int>> actions_;
@@ -167,11 +167,32 @@ void MappingSystem::loadMap(size_t mapId)
     } else if (tile == 42)
     {
       addBoundary(
+        mappable.getRightBoundaries(),
+        x * TILE_WIDTH,
+        y * TILE_HEIGHT,
+        (y+1) * TILE_HEIGHT,
+        MappableComponent::Boundary::Type::danger);
+
+      addBoundary(
+        mappable.getLeftBoundaries(),
+        (x+1) * TILE_WIDTH,
+        y * TILE_HEIGHT,
+        (y+1) * TILE_HEIGHT,
+        MappableComponent::Boundary::Type::danger);
+
+      addBoundary(
         mappable.getDownBoundaries(),
         y * TILE_HEIGHT,
         x * TILE_WIDTH,
         (x+1) * TILE_WIDTH,
         MappableComponent::Boundary::Type::danger);
+
+      addBoundary(
+        mappable.getUpBoundaries(),
+        (y+1) * TILE_HEIGHT,
+        x * TILE_WIDTH,
+        (x+1) * TILE_WIDTH,
+        MappableComponent::Boundary::Type::danger);
     }
   }
 }
@@ -93,24 +93,18 @@ 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);
 
-  if (ponderable.isGrounded())
-  {
-    auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
 
-    if (orientable.isFacingRight())
-    {
-      animating.startAnimation(entity, "stillRight");
-    } else {
-      animating.startAnimation(entity, "stillLeft");
-    }
+  if (orientable.isFacingRight())
+  {
+    animating.startAnimation(entity, "stillRight");
+  } else {
+    animating.startAnimation(entity, "stillLeft");
   }
 }
 
@@ -7,13 +7,18 @@
 #include "components/orientable.h"
 #include "systems/mapping.h"
 #include "systems/pondering.h"
+#include "systems/orienting.h"
+#include "systems/scheduling.h"
+#include "systems/controlling.h"
 #include "animation.h"
+#include "muxer.h"
 
 void PlayingSystem::tick(double)
 {
   // Check if we need to change the map
   auto players = game_.getEntityManager().getEntitiesWithComponents<
-    PlayableComponent>();
+    PlayableComponent,
+    TransformableComponent>();
 
   for (id_type player : players)
   {
@@ -44,6 +49,12 @@ void PlayingSystem::tick(double)
 
       playable.changingMap = false;
 
+      if (playable.newMapCallback)
+      {
+        playable.newMapCallback();
+        playable.newMapCallback = nullptr;
+      }
+
       break;
     }
   }
@@ -66,7 +77,10 @@ void PlayingSystem::initPlayer()
 
   game_.getEntityManager().emplaceComponent<TransformableComponent>(
     player,
-    203, 44, 10, 12);
+    game_.getWorld().getStartingX(),
+    game_.getWorld().getStartingY(),
+    10,
+    12);
 
   game_.getSystemManager().getSystem<PonderingSystem>().initializeBody(
     player,
@@ -74,13 +88,20 @@ void PlayingSystem::initPlayer()
 
   game_.getEntityManager().emplaceComponent<ControllableComponent>(player);
   game_.getEntityManager().emplaceComponent<OrientableComponent>(player);
-  game_.getEntityManager().emplaceComponent<PlayableComponent>(player);
+
+  auto& playable = game_.getEntityManager().
+    emplaceComponent<PlayableComponent>(player);
+
+  playable.checkpointMapId = game_.getWorld().getStartingMapId();
+  playable.checkpointX = game_.getWorld().getStartingX();
+  playable.checkpointY = game_.getWorld().getStartingY();
 }
 
 void PlayingSystem::changeMap(
   size_t mapId,
   double x,
-  double y)
+  double y,
+  PlayableComponent::MapChangeCallback callback)
 {
   auto players = game_.getEntityManager().getEntitiesWithComponents<
     PlayableComponent>();
@@ -94,5 +115,61 @@ void PlayingSystem::changeMap(
     playable.newMapId = mapId;
     playable.newMapX = x;
     playable.newMapY = y;
+    playable.newMapCallback = std::move(callback);
+  }
+}
+
+void PlayingSystem::die()
+{
+  playSound("res/Hit_Hurt5.wav", 0.25);
+
+  auto players = game_.getEntityManager().getEntitiesWithComponents<
+    OrientableComponent,
+    ControllableComponent,
+    AnimatableComponent,
+    PonderableComponent,
+    PlayableComponent>();
+
+  for (id_type player : players)
+  {
+    auto& animatable = game_.getEntityManager().
+      getComponent<AnimatableComponent>(player);
+
+    auto& ponderable = game_.getEntityManager().
+      getComponent<PonderableComponent>(player);
+
+    auto& controlling = game_.getSystemManager().getSystem<ControllingSystem>();
+    controlling.freeze(player);
+
+    animatable.setFrozen(true);
+    animatable.setFlickering(true);
+    ponderable.setFrozen(true);
+    ponderable.setCollidable(false);
+
+    auto& scheduling = game_.getSystemManager().getSystem<SchedulingSystem>();
+
+    scheduling.schedule(player, 0.75, [&] (id_type player) {
+      auto& playable = game_.getEntityManager().
+        getComponent<PlayableComponent>(player);
+
+      changeMap(
+        playable.checkpointMapId,
+        playable.checkpointX,
+        playable.checkpointY,
+        [&, player] () {
+          animatable.setFrozen(false);
+          animatable.setFlickering(false);
+          ponderable.setFrozen(false);
+          ponderable.setCollidable(true);
+
+          // Reset the walk state, and then potentially let the
+          // ControllingSystem set it again.
+          auto& orienting = game_.getSystemManager().
+            getSystem<OrientingSystem>();
+          orienting.stopWalking(player);
+
+          controlling.unfreeze(player);
+        });
+    });
   }
 }
@@ -2,6 +2,7 @@
 #define PLAYING_H_70A54F7D
 
 #include "system.h"
+#include "components/playable.h"
 
 class PlayingSystem : public System {
 public:
@@ -14,7 +15,13 @@ public:
 
   void initPlayer();
 
-  void changeMap(size_t mapId, double x, double y);
+  void changeMap(
+    size_t mapId,
+    double x,
+    double y,
+    PlayableComponent::MapChangeCallback callback = nullptr);
+
+  void die();
 
 };
 
@@ -27,6 +27,11 @@ void PonderingSystem::tick(double dt)
     auto& ponderable = game_.getEntityManager().
       getComponent<PonderableComponent>(entity);
 
+    if (ponderable.isFrozen())
+    {
+      continue;
+    }
+
     // Accelerate
     ponderable.setVelocityX(
       ponderable.getVelocityX() + ponderable.getAccelX() * dt);
@@ -289,6 +294,17 @@ void PonderingSystem::tick(double dt)
               break;
             }
           }
+
+          break;
+        }
+
+        case Collision::Type::danger:
+        {
+          game_.getSystemManager().getSystem<PlayingSystem>().die();
+
+          stopProcessing = true;
+
+          break;
         }
 
         default:
@@ -0,0 +1,54 @@
+#include "scheduling.h"
+#include "game.h"
+#include "components/schedulable.h"
+#include "util.h"
+
+void SchedulingSystem::tick(double dt)
+{
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    SchedulableComponent>();
+
+  for (id_type entity : entities)
+  {
+    auto& schedulable = game_.getEntityManager().
+      getComponent<SchedulableComponent>(entity);
+
+    for (auto& action : schedulable.actions)
+    {
+      std::get<0>(action) -= dt;
+
+      if (std::get<0>(action) < 0)
+      {
+        std::get<1>(action)(entity);
+      }
+    }
+
+    erase_if(schedulable.actions,
+      [] (const SchedulableComponent::Action& action) {
+        return (std::get<0>(action) < 0);
+      });
+
+    if (schedulable.actions.empty())
+    {
+      game_.getEntityManager().removeComponent<SchedulableComponent>(entity);
+    }
+  }
+}
+
+void SchedulingSystem::schedule(
+  id_type entity,
+  double length,
+  std::function<void(id_type)> action)
+{
+  if (!game_.getEntityManager().hasComponent<SchedulableComponent>(entity))
+  {
+    game_.getEntityManager().emplaceComponent<SchedulableComponent>(entity);
+  }
+
+  auto& schedulable = game_.getEntityManager().
+    getComponent<SchedulableComponent>(entity);
+
+  schedulable.actions.emplace_back(
+    length,
+    std::move(action));
+}
@@ -0,0 +1,22 @@
+#ifndef SCHEDULING_H_7B02E3E3
+#define SCHEDULING_H_7B02E3E3
+
+#include "system.h"
+
+class SchedulingSystem : public System {
+public:
+
+  SchedulingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void schedule(
+    id_type entity,
+    double length,
+    std::function<void(id_type)> action);
+
+};
+
+#endif /* end of include guard: SCHEDULING_H_7B02E3E3 */