11 files changed, 136 insertions, 113 deletions

@@ -1,22 +1,26 @@
-#include "sprite.h"
-#include <SDL_image.h>
+#include "animation_system.h"
 #include <fstream>
+#include <string>
 #include <list>
-#include <regex>
+#include "game.h"
+#include "vector.h"
 #include "util.h"
 
-Sprite::Sprite(std::string_view filename, Renderer& renderer) {
+void AnimationSystem::initSprite(int spriteId, std::string_view filename, Renderer& renderer) {
   std::ifstream datafile(filename.data());
   if (!datafile.is_open()) {
     throw std::invalid_argument(std::string("Could not find sprite datafile: ") + std::string(filename));
   }
 
+  Sprite& sprite = game_.getSprite(spriteId);
+  sprite.isAnimated = true;
+
   char ch;
   std::string line;
 
   std::string imagename;
   datafile >> imagename;
-  textureId_ = renderer.loadImageFromFile(imagename);
+  sprite.textureId = renderer.loadImageFromFile(imagename);
 
   std::string framefilename;
   datafile >> framefilename;
@@ -57,7 +61,7 @@ Sprite::Sprite(std::string_view filename, Renderer& renderer) {
     f.srcRect.w = f.size.w();
     f.srcRect.h = f.size.h();
 
-    frames_.push_back(std::move(f));
+    sprite.frames.push_back(std::move(f));
   }
 
   std::string animLine;
@@ -73,38 +77,46 @@ Sprite::Sprite(std::string_view filename, Renderer& renderer) {
       frames.push_back(std::stoi(f));
     }
 
-    int animId = animations_.size();
-    animations_.push_back(std::move(frames));
+    int animId = sprite.animations.size();
+    sprite.animations.push_back(std::move(frames));
 
     Direction dir = directionFromString(std::string(m[2]));
-    stateDirToAnim_[m[1]][dir] = animId;
+    sprite.nameDirToAnim[m[1]][dir] = animId;
   }
 
-  updateAnimation();
+  updateAnimation(spriteId);
 }
 
-void Sprite::setDirection(Direction dir) {
-  if (curDir_ != dir) {
-    curDir_ = dir;
-    updateAnimation();
+void AnimationSystem::tick(double dt) {
+  animTimer_.accumulate(dt);
+  while (animTimer_.step()) {
+    for (Sprite& sprite : game_.getSprites() | game_.spriteView()) {
+      sprite.animationFrame++;
+      if (sprite.animationFrame >= sprite.animations[sprite.animationId].size()) {
+        sprite.animationFrame = 0;
+      }
+    }
   }
 }
 
-void Sprite::setState(std::string state) {
-  if (state_ != state) {
-    state_ = state;
-    updateAnimation();
+void AnimationSystem::setSpriteDirection(int spriteId, Direction dir) {
+  Sprite& sprite = game_.getSprite(spriteId);
+  if (sprite.dir != dir) {
+    sprite.dir = dir;
+    updateAnimation(spriteId);
   }
 }
 
-void Sprite::updateAnimation() {
-  curAnim_ = stateDirToAnim_[state_][curDir_];
-  curFrame_ = 0;
+void AnimationSystem::setSpriteAnimation(int spriteId, std::string_view name) {
+  Sprite& sprite = game_.getSprite(spriteId);
+  if (sprite.animationName != name) {
+    sprite.animationName = name;
+    updateAnimation(spriteId);
+  }
 }
 
-void Sprite::tickAnim() {
-  curFrame_++;
-  if (curFrame_ >= animations_[curAnim_].size()) {
-    curFrame_ = 0;
-  }
-}
\ No newline at end of file
+void AnimationSystem::updateAnimation(int spriteId) {
+  Sprite& sprite = game_.getSprite(spriteId);
+  sprite.animationId = sprite.nameDirToAnim[sprite.animationName][sprite.dir];
+  sprite.animationFrame = 0;
+}
@@ -0,0 +1,35 @@
+#ifndef ANIMATION_SYSTEM_H_CCCC7CB8
+#define ANIMATION_SYSTEM_H_CCCC7CB8
+
+#include <string_view>
+#include "direction.h"
+#include "system.h"
+#include "timer.h"
+
+class Game;
+class Renderer;
+
+class AnimationSystem : public System {
+public:
+
+  static constexpr SystemKey Key = SystemKey::Animation;
+
+  AnimationSystem(Game& game) : game_(game) {}
+
+  void tick(double dt) override;
+
+  void initSprite(int spriteId, std::string_view filename, Renderer& renderer);
+
+  void setSpriteDirection(int spriteId, Direction dir);
+
+  void setSpriteAnimation(int spriteId, std::string_view name);
+
+private:
+
+  void updateAnimation(int spriteId);
+
+  Game& game_;
+  Timer animTimer_ {1000/5};//30fps * 1000 t/s;;
+};
+
+#endif /* end of include guard: ANIMATION_SYSTEM_H_CCCC7CB8 */
@@ -9,7 +9,7 @@ void CameraSystem::tick(double dt) {
     const Map& map = game_.getMap();
     vec2i mapBounds = map.getMapSize() * map.getTileSize();
 
-    pos_ = follow.loc() - (fov_ / 2);
+    pos_ = follow.loc - (fov_ / 2);
 
     if (pos_.x() < 0) {
       pos_.x() = 0;
@@ -1,8 +1,8 @@
 #include "game.h"
 
-int Game::addSprite(Sprite sprite) {
+int Game::emplaceSprite() {
   int id = sprites_.size();
-  sprites_.push_back(std::move(sprite));
+  sprites_.emplace_back();
   spriteIds_.push_back(id);
   return id;
 }
@@ -38,7 +38,7 @@ public:
     });
   }
 
-  int addSprite(Sprite sprite);
+  int emplaceSprite();
 
   const Sprite& getSprite(int id) const {
     return sprites_.at(id);
@@ -58,18 +58,10 @@ public:
     });
   }
 
-  void setSpriteState(int id, std::string state) {
-    sprites_[id].setState(std::move(state));
-  }
-
-  void setSpriteDirection(int id, Direction dir) {
-    sprites_[id].setDirection(dir);
-  }
-
-  void tickSpriteAnim() {
-    for (Sprite& sprite : sprites_) {
-      sprite.tickAnim();
-    }
+  auto spriteView() {
+    return ranges::views::transform([&] (int id) -> Sprite& {
+      return sprites_.at(id);
+    });
   }
 
   void setMap(std::unique_ptr<Map> map) { map_ = std::move(map); }
@@ -8,26 +8,34 @@
 #include "mixer.h"
 #include "transform_system.h"
 #include "camera_system.h"
+#include "animation_system.h"
 
 void loop(Renderer& renderer, Mixer& mixer) {
   Game game;
   game.emplaceSystem<TransformSystem>();
   game.emplaceSystem<CameraSystem>();
+  game.emplaceSystem<AnimationSystem>();
 
   Input keystate;
 
   auto map = std::make_unique<Map>("../res/map1.tmx", renderer);
   game.setMap(std::move(map));
 
-  int lucasSprite = game.addSprite(Sprite("../res/lucas_anim.txt", renderer));
-  int kumaSprite = game.addSprite(Sprite("../res/kuma_anim.txt", renderer));
-  int dusterSprite = game.addSprite(Sprite("../res/duster_anim.txt", renderer));
-  int boneySprite = game.addSprite(Sprite("../res/boney_anim.txt", renderer));
-
+  int lucasSprite = game.emplaceSprite();
   game.getSystem<TransformSystem>().initSprite(lucasSprite, {32, 32});
+  game.getSystem<AnimationSystem>().initSprite(lucasSprite, "../res/lucas_anim.txt", renderer);
+
+  int kumaSprite = game.emplaceSprite();
   game.getSystem<TransformSystem>().initSprite(kumaSprite, {32, 32});
+  game.getSystem<AnimationSystem>().initSprite(kumaSprite, "../res/kuma_anim.txt", renderer);
+
+  int dusterSprite = game.emplaceSprite();
   game.getSystem<TransformSystem>().initSprite(dusterSprite, {32, 32});
+  game.getSystem<AnimationSystem>().initSprite(dusterSprite, "../res/duster_anim.txt", renderer);
+
+  int boneySprite = game.emplaceSprite();
   game.getSystem<TransformSystem>().initSprite(boneySprite, {32, 32});
+  game.getSystem<AnimationSystem>().initSprite(boneySprite, "../res/boney_anim.txt", renderer);
 
   Party party;
   party.addMember(game, lucasSprite);
@@ -41,7 +49,6 @@ void loop(Renderer& renderer, Mixer& mixer) {
   renderer.render(game);
 
   Timer inputTimer(33);
-  Timer animTimer(1000/5);//30fps * 1000 t/s;
 
   size_t lastTime = SDL_GetTicks();
 
@@ -72,11 +79,6 @@ void loop(Renderer& renderer, Mixer& mixer) {
       party.move(game, mixer, keystate);
     }
 
-    animTimer.accumulate(frameTime);
-    while (animTimer.step()) {
-      game.tickSpriteAnim();
-    }
-
     for (System& system : game.systems()) {
       system.tick(frameTime);
     }
@@ -2,6 +2,7 @@
 #include "consts.h"
 #include "mixer.h"
 #include "transform_system.h"
+#include "animation_system.h"
 
 void Party::addMember(Game& game, int spriteId) {
   int index = members_.size();
@@ -12,12 +13,12 @@ void Party::addMember(Game& game, int spriteId) {
   if (index > 0) {
     const Sprite& sprite = game.getSprite(spriteId);
 
-    newMember.movement = std::deque<Movement>(PARTY_FRAME_DELAY * index, {.pos = sprite.loc(), .dir = sprite.getDirection()});
+    newMember.movement = std::deque<Movement>(PARTY_FRAME_DELAY * index, {.pos = sprite.loc, .dir = sprite.dir});
   }
 
   members_.push_back(std::move(newMember));
 
-  game.setSpriteState(spriteId, "still");
+  game.getSystem<AnimationSystem>().setSpriteAnimation(spriteId, "still");
 }
 
 void Party::move(Game& game, Mixer& mixer, const Input& keystate) {
@@ -33,7 +34,7 @@ void Party::move(Game& game, Mixer& mixer, const Input& keystate) {
     } else {
       if (state_ == State::Normal) {
         for (int i = 0; i < members_.size(); i++) {
-          game.setSpriteState(members_[i].spriteId, "still");
+          game.getSystem<AnimationSystem>().setSpriteAnimation(members_[i].spriteId, "still");
         }
       }
 
@@ -72,16 +73,16 @@ void Party::move(Game& game, Mixer& mixer, const Input& keystate) {
   lastDir_ = dir;
 
   const Sprite& p1 = game.getSprite(members_[0].spriteId);
-  vec2i pLoc = p1.loc();
+  vec2i pLoc = p1.loc;
 
   if (state_ == State::Crouching) {
     for (int i = 0; i < members_.size(); i++) {
-      game.setSpriteDirection(members_[i].spriteId, dir);
+      game.getSystem<AnimationSystem>().setSpriteDirection(members_[i].spriteId, dir);
     }
 
     return;
   } else {
-    game.setSpriteDirection(members_[0].spriteId, dir);
+    game.getSystem<AnimationSystem>().setSpriteDirection(members_[0].spriteId, dir);
   }
 
   int speed = MOVEMENT_SPEED;
@@ -89,7 +90,7 @@ void Party::move(Game& game, Mixer& mixer, const Input& keystate) {
     speed *= 2;
   } else {
     for (int i = 0; i < members_.size(); i++) {
-      game.setSpriteState(members_[i].spriteId, "walk");
+      game.getSystem<AnimationSystem>().setSpriteAnimation(members_[i].spriteId, "walk");
     }
   }
 
@@ -101,9 +102,9 @@ void Party::move(Game& game, Mixer& mixer, const Input& keystate) {
 
   const vec2i UL_COL_BOX = { 8, 8 };
   const vec2i DR_COL_BOX = { 4, 0 };
-  vec2i oldColPosUL = (p1.loc() - UL_COL_BOX) / map.getTileSize();
+  vec2i oldColPosUL = (p1.loc - UL_COL_BOX) / map.getTileSize();
   vec2i newColPosUL = (pLoc - UL_COL_BOX) / map.getTileSize();
-  vec2i oldColPosDR = (p1.loc() + DR_COL_BOX) / map.getTileSize();
+  vec2i oldColPosDR = (p1.loc + DR_COL_BOX) / map.getTileSize();
   vec2i newColPosDR = (pLoc + DR_COL_BOX) / map.getTileSize();
 
   if (dirHasDir(dir, Direction::right) &&
@@ -111,7 +112,7 @@ void Party::move(Game& game, Mixer& mixer, const Input& keystate) {
     for (int y = newColPosUL.y(); y <= newColPosDR.y(); y++) {
       if (map.isBlocked(newColPosDR.x(), y)) {
         blocked = true;
-        pLoc.x() = p1.loc().x();//(newColPosDR * map.getTileSize() - (collisionBox / 2)).x() - 1;
+        pLoc.x() = p1.loc.x();//(newColPosDR * map.getTileSize() - (collisionBox / 2)).x() - 1;
         break;
       }
     }
@@ -122,7 +123,7 @@ void Party::move(Game& game, Mixer& mixer, const Input& keystate) {
     for (int y = newColPosUL.y(); y <= newColPosDR.y(); y++) {
       if (map.isBlocked(newColPosUL.x(), y)) {
         blocked = true;
-        pLoc.x() = p1.loc().x();//(newColPosDR * map.getTileSize() - (collisionBox / 2)).x() - 1;
+        pLoc.x() = p1.loc.x();//(newColPosDR * map.getTileSize() - (collisionBox / 2)).x() - 1;
         break;
       }
     }
@@ -133,7 +134,7 @@ void Party::move(Game& game, Mixer& mixer, const Input& keystate) {
     for (int x = newColPosUL.x(); x <= newColPosDR.x(); x++) {
       if (map.isBlocked(x, newColPosDR.y())) {
         blocked = true;
-        pLoc.y() = p1.loc().y();//(newColPosDR * map.getTileSize() - (collisionBox / 2)).x() - 1;
+        pLoc.y() = p1.loc.y();//(newColPosDR * map.getTileSize() - (collisionBox / 2)).x() - 1;
         break;
       }
     }
@@ -144,7 +145,7 @@ void Party::move(Game& game, Mixer& mixer, const Input& keystate) {
     for (int x = newColPosUL.x(); x <= newColPosDR.x(); x++) {
       if (map.isBlocked(x, newColPosUL.y())) {
         blocked = true;
-        pLoc.y() = p1.loc().y();//(newColPosDR * map.getTileSize() - (collisionBox / 2)).x() - 1;
+        pLoc.y() = p1.loc.y();//(newColPosDR * map.getTileSize() - (collisionBox / 2)).x() - 1;
         break;
       }
     }
@@ -156,14 +157,14 @@ void Party::move(Game& game, Mixer& mixer, const Input& keystate) {
   }
 
   // Move everything
-  if (pLoc != p1.loc()) {
+  if (pLoc != p1.loc) {
     game.getSystem<TransformSystem>().moveSprite(members_[0].spriteId, pLoc);
 
     for (int i = 1; i < members_.size(); i++) {
       const Sprite& pNext = game.getSprite(members_[i].spriteId);
       const Movement& posdir = members_[i].movement.front();
       game.getSystem<TransformSystem>().moveSprite(members_[i].spriteId, posdir.pos);
-      game.setSpriteDirection(members_[i].spriteId, posdir.dir);
+      game.getSystem<AnimationSystem>().setSpriteDirection(members_[i].spriteId, posdir.dir);
 
       members_[i].movement.pop_front();
       members_[i].movement.push_back({.pos = pLoc, .dir = dir});
@@ -178,7 +179,7 @@ void Party::beginCrouch(Game& game) {
     state_ = State::Crouching;
 
     for (int i = 0; i < members_.size(); i++) {
-      game.setSpriteState(members_[i].spriteId, "crouch");
+      game.getSystem<AnimationSystem>().setSpriteAnimation(members_[i].spriteId, "crouch");
     }
   }
 }
@@ -188,7 +189,7 @@ void Party::endCrouch(Game& game) {
     state_ = State::Running;
 
     for (int i = 0; i < members_.size(); i++) {
-      game.setSpriteState(members_[i].spriteId, "run");
+      game.getSystem<AnimationSystem>().setSpriteAnimation(members_[i].spriteId, "run");
 
       // Halve the movement buffer for the followers.
       if (i > 0) {
@@ -212,7 +213,7 @@ void Party::stopRunning(Game& game) {
   // Double the movement buffer for the followers.
   for (int i = 1; i < members_.size(); i++) {
     std::deque<Movement> newMove;
-    vec2i lastPos = game.getSprite(members_[i].spriteId).loc();
+    vec2i lastPos = game.getSprite(members_[i].spriteId).loc;
 
     while (!members_[i].movement.empty()) {
       Movement m1 = members_[i].movement.front();
@@ -112,10 +112,10 @@ void Renderer::render(Game& game) {
   SDL_RenderCopy(ren_.get(), renLay1_.get(), nullptr, nullptr);
 
   for (const Sprite& sprite : game.getSystem<TransformSystem>().getSpritesByY() | game.spriteView()) {
-    const SpriteFrame& frame = sprite.getFrame();
+    const SpriteFrame& frame = sprite.frames.at(sprite.animations.at(sprite.animationId).at(sprite.animationFrame));
     const SDL_Rect& src = frame.srcRect;
-    SDL_Rect dest { sprite.loc().x() - frame.center.x(), sprite.loc().y() - frame.center.y(), frame.size.w(), frame.size.h() };
-    SDL_RenderCopy(ren_.get(), textures_.at(sprite.getTextureId()).get(), &src, &dest);
+    SDL_Rect dest { sprite.loc.x() - frame.center.x(), sprite.loc.y() - frame.center.y(), frame.size.w(), frame.size.h() };
+    SDL_RenderCopy(ren_.get(), textures_.at(sprite.textureId).get(), &src, &dest);
   }
 
   SDL_RenderCopy(ren_.get(), renLay0_.get(), nullptr, nullptr);
@@ -17,39 +17,19 @@ struct SpriteFrame {
 class Sprite {
 public:
 
-  Sprite(std::string_view filename, Renderer& renderer);
-
-  int getTextureId() const {
-    return textureId_;
-  }
-
-  const vec2i& loc() const { return loc_; }
-
-  vec2i& loc() { return loc_; }
-
-  const SpriteFrame& getFrame() const { return frames_.at(animations_[curAnim_][curFrame_]); }
-
-  void setDirection(Direction dir);
-
-  Direction getDirection() const { return curDir_; }
-
-  void setState(std::string state);
-
-  void tickAnim();
-
-private:
-
-  void updateAnimation();
-
-  int textureId_;
-  vec2i loc_ { 0, 0 };
-  Direction curDir_ = Direction::down;
-  std::string state_;
-  int curAnim_ = 0;
-  int curFrame_ = 0;
-  std::vector<SpriteFrame> frames_;
-  std::vector<std::vector<int>> animations_;
-  std::map<std::string, std::map<Direction, int>> stateDirToAnim_;
+  // Transform
+  vec2i loc { 0, 0 };
+
+  // Animation
+  bool isAnimated = false;
+  int textureId;
+  Direction dir = Direction::down;
+  std::string animationName;
+  int animationId = 0;
+  int animationFrame = 0;
+  std::vector<SpriteFrame> frames;
+  std::vector<std::vector<int>> animations;
+  std::map<std::string, std::map<Direction, int>> nameDirToAnim;
 };
 
 #endif /* end of include guard: SPRITE_H_70503825 */
@@ -3,7 +3,8 @@
 
 enum class SystemKey {
   Transform,
-  Camera
+  Camera,
+  Animation
 };
 
 class System {
@@ -3,17 +3,17 @@
 
 void TransformSystem::initSprite(int spriteId, vec2i loc) {
   Sprite& sprite = game_.getSprite(spriteId);
-  sprite.loc() = loc;
+  sprite.loc = loc;
   spritesByY_.emplace(loc.y(), spriteId);
 }
 
 void TransformSystem::moveSprite(int spriteId, vec2i newLoc) {
   Sprite& sprite = game_.getSprite(spriteId);
-  bool changedY = (sprite.loc().y() != newLoc.y());
+  bool changedY = (sprite.loc.y() != newLoc.y());
   if (changedY) {
-    spritesByY_.erase(std::make_tuple(sprite.loc().y(), spriteId));
+    spritesByY_.erase(std::make_tuple(sprite.loc.y(), spriteId));
   }
-  sprite.loc() = newLoc;
+  sprite.loc = newLoc;
   if (changedY) {
     spritesByY_.emplace(newLoc.y(), spriteId);
   }