Introduced animated sprites

Also restyled a lot of the code.

8 files changed, 217 insertions, 90 deletions

@@ -0,0 +1,38 @@
+#include "animating.h"
+#include "game.h"
+#include "components/animatable.h"
+
+void AnimatingSystem::tick(double)
+{
+  std::set<id_type> spriteEntities =
+    game_.getEntityManager().getEntitiesWithComponents<AnimatableComponent>();
+
+  for (id_type entity : spriteEntities)
+  {
+    auto& sprite = game_.getEntityManager().
+      getComponent<AnimatableComponent>(entity);
+
+    sprite.setCountdown(sprite.getCountdown() + 1);
+
+    const Animation& anim = sprite.getAnimation();
+    if (sprite.getCountdown() >= anim.getDelay())
+    {
+      sprite.setFrame(sprite.getFrame() + 1);
+      sprite.setCountdown(0);
+
+      if (sprite.getFrame() >= anim.getFirstFrame() + anim.getNumFrames())
+      {
+        sprite.setFrame(anim.getFirstFrame());
+      }
+    }
+  }
+}
+
+void AnimatingSystem::startAnimation(id_type entity, std::string animation)
+{
+  auto& sprite = game_.getEntityManager().
+    getComponent<AnimatableComponent>(entity);
+
+  sprite.setAnimation(animation);
+  sprite.setFrame(sprite.getAnimation().getFirstFrame());
+}
@@ -0,0 +1,20 @@
+#ifndef ANIMATING_H_5BBF0094
+#define ANIMATING_H_5BBF0094
+
+#include "system.h"
+#include <string>
+
+class AnimatingSystem : public System {
+public:
+
+  AnimatingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void startAnimation(id_type entity, std::string animation);
+
+};
+
+#endif /* end of include guard: ANIMATING_H_5BBF0094 */
@@ -4,21 +4,30 @@
 #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"
 
-void ControllingSystem::tick(double dt)
+void ControllingSystem::tick(double)
 {
-  while (!actions.empty())
+  while (!actions_.empty())
   {
-    int key = actions.front().first;
-    int action = actions.front().second;
+    int key = actions_.front().first;
+    int action = actions_.front().second;
+
+    auto entities = game_.getEntityManager().getEntitiesWithComponents<
+      ControllableComponent,
+      PonderableComponent,
+      AnimatableComponent,
+      DroppableComponent,
+      OrientableComponent>();
 
-    auto entities = game.getEntityManager().getEntitiesWithComponents<ControllableComponent, PonderableComponent, AnimatableComponent, DroppableComponent>();
     for (auto entity : entities)
     {
-      auto& controllable = game.getEntityManager().getComponent<ControllableComponent>(entity);
+      auto& controllable = game_.getEntityManager().
+        getComponent<ControllableComponent>(entity);
 
       if (action == GLFW_PRESS)
       {
@@ -95,74 +104,107 @@ void ControllingSystem::tick(double dt)
       }
     }
 
-    actions.pop();
+    actions_.pop();
   }
 }
 
 void ControllingSystem::input(int key, int action)
 {
-  actions.push(std::make_pair(key, action));
+  actions_.push(std::make_pair(key, action));
 }
 
-void ControllingSystem::walkLeft(int entity)
+void ControllingSystem::walkLeft(id_type entity)
 {
-  auto& ponderable = game.getEntityManager().getComponent<PonderableComponent>(entity);
-  auto& animatable = game.getEntityManager().getComponent<AnimatableComponent>(entity);
-  
+  auto& ponderable = game_.getEntityManager().getComponent<PonderableComponent>(entity);
+  auto& orientable = game_.getEntityManager().getComponent<OrientableComponent>(entity);
+
+  orientable.setFacingRight(false);
   ponderable.setVelocityX(-90);
-  
-  animatable.setDirection(Direction::Left);
-  animatable.setWalking(true);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+
+  if (ponderable.getState() == PonderableComponent::state::grounded)
+  {
+    animating.startAnimation(entity, "walkingLeft");
+  } else {
+    animating.startAnimation(entity, "stillLeft");
+  }
 }
 
-void ControllingSystem::walkRight(int entity)
+void ControllingSystem::walkRight(id_type entity)
 {
-  auto& ponderable = game.getEntityManager().getComponent<PonderableComponent>(entity);
-  auto& animatable = game.getEntityManager().getComponent<AnimatableComponent>(entity);
-  
+  auto& ponderable = game_.getEntityManager().getComponent<PonderableComponent>(entity);
+  auto& orientable = game_.getEntityManager().getComponent<OrientableComponent>(entity);
+
+  orientable.setFacingRight(true);
   ponderable.setVelocityX(90);
 
-  animatable.setDirection(Direction::Right);
-  animatable.setWalking(true);
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+
+  if (ponderable.getState() == PonderableComponent::state::grounded)
+  {
+    animating.startAnimation(entity, "walkingRight");
+  } else {
+    animating.startAnimation(entity, "stillRight");
+  }
 }
 
-void ControllingSystem::stopWalking(int entity)
+void ControllingSystem::stopWalking(id_type entity)
 {
-  auto& ponderable = game.getEntityManager().getComponent<PonderableComponent>(entity);
-  auto& animatable = game.getEntityManager().getComponent<AnimatableComponent>(entity);
-  
+  auto& ponderable = game_.getEntityManager().getComponent<PonderableComponent>(entity);
+  auto& orientable = game_.getEntityManager().getComponent<OrientableComponent>(entity);
+
   ponderable.setVelocityX(0);
-  
-  animatable.setWalking(false);
+
+  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(int entity)
+void ControllingSystem::jump(id_type entity)
 {
-  auto& ponderable = game.getEntityManager().getComponent<PonderableComponent>(entity);
-  auto& animatable = game.getEntityManager().getComponent<AnimatableComponent>(entity);
-  
-  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));
-  
-  animatable.setJumping(true);
+  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(int entity)
+void ControllingSystem::stopJumping(id_type entity)
 {
-  auto& ponderable = game.getEntityManager().getComponent<PonderableComponent>(entity);
-  auto& animatable = game.getEntityManager().getComponent<AnimatableComponent>(entity);
-  
-  ponderable.setAccelY(JUMP_GRAVITY(TILE_HEIGHT*3.5, 0.233));
-  animatable.setJumping(false);
+  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(int entity, bool start)
+void ControllingSystem::drop(id_type entity, bool start)
 {
-  auto& animatable = game.getEntityManager().getComponent<AnimatableComponent>(entity);
-  auto& droppable = game.getEntityManager().getComponent<DroppableComponent>(entity);
-  
+  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);
-  animatable.setCrouching(start);
 }
@@ -3,24 +3,28 @@
 
 #include "system.h"
 #include <queue>
+#include "entity_manager.h"
 
 class ControllingSystem : public System {
-  public:
-    ControllingSystem(Game& game)
-      : System(game) {}
-
-    void tick(double dt);
-    void input(int key, int action);
-
-  private:
-    void walkLeft(int entity);
-    void walkRight(int entity);
-    void stopWalking(int entity);
-    void jump(int entity);
-    void stopJumping(int entity);
-    void drop(int entity, bool start);
-
-    std::queue<std::pair<int,int>> actions;
+public:
+
+  ControllingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+  void input(int key, int action);
+
+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_;
 };
 
 #endif /* end of include guard: CONTROLLING_H_80B1BB8D */
@@ -5,12 +5,14 @@
 
 void PonderingSystem::tick(double dt)
 {
-  auto entities = game.getEntityManager().getEntitiesWithComponents<PonderableComponent, TransformableComponent>();
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    PonderableComponent,
+    TransformableComponent>();
 
-  for (auto entity : entities)
+  for (id_type entity : entities)
   {
-    auto& transformable = game.getEntityManager().getComponent<TransformableComponent>(entity);
-    auto& ponderable = game.getEntityManager().getComponent<PonderableComponent>(entity);
+    auto& transformable = game_.getEntityManager().getComponent<TransformableComponent>(entity);
+    auto& ponderable = game_.getEntityManager().getComponent<PonderableComponent>(entity);
 
     // Accelerate
     ponderable.setVelocityX(ponderable.getVelocityX() + ponderable.getAccelX() * dt);
@@ -4,11 +4,13 @@
 #include "system.h"
 
 class PonderingSystem : public System {
-  public:
-    PonderingSystem(Game& game)
-      : System(game) {}
+public:
 
-    void tick(double dt);
+  PonderingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
 };
 
 #endif /* end of include guard: PONDERING_H_F2530E0E */
@@ -3,19 +3,35 @@
 #include "components/animatable.h"
 #include "components/transformable.h"
 
-void RenderingSystem::tick(double dt)
+void RenderingSystem::tick(double)
 {
-  texture.fill(texture.entirety(), 0, 0, 0);
-  
-  std::set<int> spriteEntities = game.getEntityManager().getEntitiesWithComponents<AnimatableComponent, TransformableComponent>();
-  for (int entity : spriteEntities)
+  texture_.fill(texture_.entirety(), 0, 0, 0);
+
+  std::set<id_type> spriteEntities =
+    game_.getEntityManager().getEntitiesWithComponents<
+      AnimatableComponent,
+      TransformableComponent>();
+
+  for (id_type entity : spriteEntities)
   {
-    auto& sprite = game.getEntityManager().getComponent<AnimatableComponent>(entity);
-    auto& transform = game.getEntityManager().getComponent<TransformableComponent>(entity);
-    Rectangle dstrect {(int) transform.getX(), (int) transform.getY(), transform.getW(), transform.getH()};
-    
-    texture.blit(sprite.getTexture(), sprite.getFrameRect(), dstrect);
+    auto& sprite = game_.getEntityManager().
+      getComponent<AnimatableComponent>(entity);
+
+    auto& transform = game_.getEntityManager().
+      getComponent<TransformableComponent>(entity);
+
+    Rectangle dstrect {
+      static_cast<int>(transform.getX()),
+      static_cast<int>(transform.getY()),
+      transform.getW(),
+      transform.getH()};
+
+    const AnimationSet& aset = sprite.getAnimationSet();
+    texture_.blit(
+      aset.getTexture(),
+      aset.getFrameRect(sprite.getFrame()),
+      dstrect);
   }
-  
-  texture.renderScreen();
+
+  texture_.renderScreen();
 }
@@ -6,14 +6,17 @@
 #include "consts.h"
 
 class RenderingSystem : public System {
-  public:
-    RenderingSystem(Game& game)
-      : System(game) {}
+public:
 
-    void tick(double dt);
+  RenderingSystem(Game& game) : System(game)
+  {
+  }
 
-  private:
-    Texture texture {GAME_WIDTH, GAME_HEIGHT};
+  void tick(double dt);
+
+private:
+
+  Texture texture_ {GAME_WIDTH, GAME_HEIGHT};
 };
 
 #endif /* end of include guard: RENDERING_H_76ABC02A */