9 files changed, 182 insertions, 35 deletions

@@ -65,7 +65,7 @@ void AnimationSystem::initSprite(int spriteId, std::string_view filename) {
   std::string animLine;
   std::getline(datafile, animLine); // blank
   while (std::getline(datafile, animLine)) {
-    std::regex re(R"(([a-z!_]+)\[([a-z_]+)\]: ([0-9,]+))");
+    std::regex re(R"(([a-z!._]+)\[([a-z_]+)\]: ([0-9,]+))");
     std::smatch m;
     std::regex_match(animLine, m, re);
 
@@ -78,6 +78,8 @@ void AnimationSystem::initSprite(int spriteId, std::string_view filename) {
 
     if (animName.back() == '!') {
       anim.looping = false;
+    } else if (animName.back() == '.') {
+      anim.manual = true;
     }
 
     int animId = sprite.animations.size();
@@ -96,7 +98,7 @@ void AnimationSystem::tick(double dt) {
   animTimer_.accumulate(dt);
   while (animTimer_.step()) {
     for (Sprite& sprite : game_.getSprites() | game_.spriteView()) {
-      if (sprite.isAnimated && !sprite.animFinished) {
+      if (sprite.isAnimated && !sprite.animFinished && !sprite.animPaused) {
         sprite.animationFrame++;
 
         if (sprite.animationFrame >= sprite.animations[sprite.animationId].frameIndices.size()) {
@@ -112,6 +114,19 @@ void AnimationSystem::tick(double dt) {
   }
 }
 
+void AnimationSystem::advanceAnimation(int spriteId) {
+  Sprite& sprite = game_.getSprite(spriteId);
+  Animation& animation = sprite.animations[sprite.animationId];
+
+  if (animation.manual) {
+    sprite.animationFrame++;
+
+    if (sprite.animationFrame >= animation.frameIndices.size()) {
+      sprite.animationFrame = 0;
+    }
+  }
+}
+
 void AnimationSystem::setSpriteDirection(int spriteId, Direction dir) {
   Sprite& sprite = game_.getSprite(spriteId);
   if (sprite.dir != dir) {
@@ -133,4 +148,5 @@ void AnimationSystem::updateAnimation(int spriteId) {
   sprite.animationId = sprite.nameDirToAnim[sprite.animationName][sprite.dir];
   sprite.animationFrame = 0;
   sprite.animFinished = false;
+  sprite.animPaused = false;
 }
@@ -17,6 +17,9 @@ public:
 
   void tick(double dt) override;
 
+  // Advances animation by a frame. Only to be used on manual animations.
+  void advanceAnimation(int spriteId);
+
   void initSprite(int spriteId, std::string_view filename);
 
   void setSpriteDirection(int spriteId, Direction dir);
@@ -34,7 +34,7 @@ void CharacterSystem::addSpriteToParty(int leaderId, int followerId) {
 
   for (int i=0; i<truePartyDelay; i++) {
     vec2i tween = ((follower.loc - targetPos) * i) / static_cast<double>(truePartyDelay) + targetPos;
-    follower.trail.push_front({.pos = tween, .dir = toFace});
+    follower.trail.push_front({.pos = tween, .dir = toFace, .medium = CharacterMedium::Normal});
   }
 
   leader.followers.push_back(followerId);
@@ -70,14 +70,31 @@ void CharacterSystem::transplantParty(int leaderId, vec2i pos, Direction dir) {
 
 void CharacterSystem::moveInDirection(int spriteId, Direction dir) {
   Sprite& sprite = game_.getSprite(spriteId);
+  sprite.movementDir = dir;
 
-  game_.getSystem<AnimationSystem>().setSpriteDirection(spriteId, dir);
+  switch (sprite.characterMedium) {
+    case CharacterMedium::Normal: {
+      game_.getSystem<AnimationSystem>().setSpriteDirection(spriteId, dir);
+      break;
+    }
+    case CharacterMedium::Ladder: {
+      if (dirHasDir(dir, Direction::up)) {
+        game_.getSystem<AnimationSystem>().setSpriteDirection(spriteId, Direction::up);
+      } else if (dirHasDir(dir, Direction::down)) {
+        game_.getSystem<AnimationSystem>().setSpriteDirection(spriteId, Direction::down);
+      }
+      break;
+    }
+  }
 
   if (sprite.characterState == CharacterState::Still) {
     setPartyState(spriteId, CharacterState::Walking);
   } else if (sprite.characterState == CharacterState::Crouching) {
     for (int followerId : sprite.followers) {
-      game_.getSystem<AnimationSystem>().setSpriteDirection(followerId, dir);
+      Sprite& follower = game_.getSprite(followerId);
+      if (follower.characterMedium == CharacterMedium::Normal) {
+        game_.getSystem<AnimationSystem>().setSpriteDirection(followerId, dir);
+      }
     }
   }
 }
@@ -107,14 +124,18 @@ void CharacterSystem::tick(double dt) {
         }
 
         int speed = sprite.movementSpeed;
-        if (sprite.characterState == CharacterState::Running) {
+        if (sprite.characterState == CharacterState::Running && sprite.characterMedium == CharacterMedium::Normal) {
           speed *= 2;
         }
 
-        pLoc += (unitVecInDirection(sprite.dir) * speed);
+        if (sprite.characterMedium == CharacterMedium::Ladder) {
+          //game_.getSystem<AnimationSystem>().advanceAnimation(spriteId);
+        }
+
+        pLoc += (unitVecInDirection(sprite.movementDir) * speed);
 
         // Check collision.
-        CollisionResult collision = game_.getSystem<TransformSystem>().checkCollision(spriteId, pLoc, sprite.dir);
+        CollisionResult collision = game_.getSystem<TransformSystem>().checkCollision(spriteId, pLoc, sprite.movementDir);
         bool blocked = collision.horiz.blocked || collision.vert.blocked;
 
         if (collision.horiz.blocked && !sprite.clipping) {
@@ -146,6 +167,12 @@ void CharacterSystem::tick(double dt) {
         if (pLoc != sprite.loc) {
           game_.getSystem<TransformSystem>().moveSprite(spriteId, pLoc);
 
+          CharacterMedium newMedium = game_.getSystem<TransformSystem>().getMediumAtPosition(spriteId, pLoc);
+          if (newMedium != sprite.characterMedium) {
+            sprite.characterMedium = newMedium;
+            setAnimationFor(spriteId, sprite.characterState);
+          }
+
           if (sprite.characterState == CharacterState::Running) {
             const Map& map = game_.getMap();
 
@@ -164,12 +191,20 @@ void CharacterSystem::tick(double dt) {
 
           for (int followerId : sprite.followers) {
             Sprite& pNext = game_.getSprite(followerId);
+            if (pNext.characterMedium == CharacterMedium::Ladder) {
+              //game_.getSystem<AnimationSystem>().advanceAnimation(followerId);
+            }
+
             const Movement& posdir = pNext.trail.front();
             game_.getSystem<TransformSystem>().moveSprite(followerId, posdir.pos);
             game_.getSystem<AnimationSystem>().setSpriteDirection(followerId, posdir.dir);
+            if (posdir.medium != pNext.characterMedium) {
+              pNext.characterMedium = posdir.medium;
+              setAnimationFor(followerId, sprite.characterState);
+            }
 
             pNext.trail.pop_front();
-            pNext.trail.push_back({.pos = pLoc, .dir = sprite.dir});
+            pNext.trail.push_back({.pos = pLoc, .dir = sprite.dir, .medium = sprite.characterMedium});
           }
         }
       }
@@ -180,6 +215,10 @@ void CharacterSystem::tick(double dt) {
 void CharacterSystem::beginCrouch(int spriteId) {
   Sprite& sprite = game_.getSprite(spriteId);
 
+  if (sprite.characterMedium == CharacterMedium::Ladder) {
+    return;
+  }
+
   if (sprite.characterState == CharacterState::Running) {
     stopRunning(spriteId);
   } else {
@@ -242,32 +281,12 @@ void CharacterSystem::stopRunning(int spriteId) {
 }
 
 void CharacterSystem::setPartyState(int spriteId, CharacterState state) {
-  std::string animName;
-  switch (state) {
-    case CharacterState::Still: {
-      animName = "still";
-      break;
-    }
-    case CharacterState::Walking: {
-      animName = "walk";
-      break;
-    }
-    case CharacterState::Crouching: {
-      animName = "crouch";
-      break;
-    }
-    case CharacterState::Running: {
-      animName = "run";
-      break;
-    }
-  }
-
   Sprite& sprite = game_.getSprite(spriteId);
   sprite.characterState = state;
 
-  game_.getSystem<AnimationSystem>().setSpriteAnimation(spriteId, animName);
+  setAnimationFor(spriteId, state);
   for (int followerId : sprite.followers) {
-    game_.getSystem<AnimationSystem>().setSpriteAnimation(followerId, animName);
+    setAnimationFor(followerId, state);
   }
 }
 
@@ -297,3 +316,48 @@ void CharacterSystem::destroySprite(int spriteId) {
     stopRunningSound(sprite);
   }
 }
+
+void CharacterSystem::setAnimationFor(int spriteId, CharacterState state) {
+  Sprite& sprite = game_.getSprite(spriteId);
+  std::string animName;
+
+  switch (sprite.characterMedium) {
+    case CharacterMedium::Normal: {
+      std::string animName;
+
+      switch (state) {
+        case CharacterState::Still: {
+          animName = "still";
+          break;
+        }
+        case CharacterState::Walking: {
+          animName = "walk";
+          break;
+        }
+        case CharacterState::Crouching: {
+          animName = "crouch";
+          break;
+        }
+        case CharacterState::Running: {
+          animName = "run";
+          break;
+        }
+      }
+
+      game_.getSystem<AnimationSystem>().setSpriteAnimation(spriteId, animName);
+
+      break;
+    }
+    case CharacterMedium::Ladder: {
+      game_.getSystem<AnimationSystem>().setSpriteAnimation(spriteId, "climb.");
+
+      if (state == CharacterState::Still || state == CharacterState::Crouching) {
+        sprite.animPaused = true;
+      } else {
+        sprite.animPaused = false;
+      }
+
+      break;
+    }
+  }
+}
@@ -47,6 +47,9 @@ private:
 
   void stopRunningSound(Sprite& sprite);
 
+  // state should be the party leader's state
+  void setAnimationFor(int spriteId, CharacterState state);
+
   Game& game_;
   Timer inputTimer_ {33};
 };
@@ -44,6 +44,10 @@ Map::Map(std::string_view name) : name_(name) {
             tile.blocked = true;
           } else if (property.getName() == "runSound") {
             tile.step = stepTypeFromString(property.getStringValue());
+          } else if (property.getName() == "medium") {
+            if (property.getStringValue() == "ladder") {
+              tile.medium = CharacterMedium::Ladder;
+            }
           }
         }
 
@@ -178,3 +182,21 @@ StepType Map::getStepType(int x, int y) const {
 
   return StepType::none;
 }
+
+CharacterMedium Map::getMedium(int x, int y) const {
+  CharacterMedium ret = CharacterMedium::Normal;
+
+  if (x < 0 || y < 0 || x >= mapSize_.w() || y >= mapSize_.h()) {
+    return ret;
+  }
+
+  int i = x + y * mapSize_.w();
+
+  for (const std::vector<Tile>& layer : lowerLayers_) {
+    if (layer.at(i).medium > ret) {
+      ret = layer.at(i).medium;
+    }
+  }
+
+  return ret;
+}
@@ -7,6 +7,7 @@
 #include <vector>
 #include "vector.h"
 #include "step_type.h"
+#include "sprite.h"
 
 struct Tile {
   unsigned int id = 0;
@@ -14,6 +15,7 @@ struct Tile {
   bool flipVertical = false;
   bool blocked = false;
   StepType step = StepType::none;
+  CharacterMedium medium = CharacterMedium::Normal;
 };
 
 struct Prototype {
@@ -64,6 +66,8 @@ public:
 
   StepType getStepType(int x, int y) const;
 
+  CharacterMedium getMedium(int x, int y) const;
+
   const std::vector<Prototype>& getPrototypes() const { return prototypes_; }
 
   const vec2i& getWarpPoint(const std::string& name) const { return warpPoints_.at(name); }
@@ -23,6 +23,7 @@ struct SpriteFrame {
 
 struct Animation {
   bool looping = true;
+  bool manual = false;
   std::vector<int> frameIndices;
 };
 
@@ -33,9 +34,15 @@ enum class CharacterState {
   Running
 };
 
+enum class CharacterMedium {
+  Normal,
+  Ladder
+};
+
 struct Movement {
   vec2i pos;
   Direction dir;
+  CharacterMedium medium;
 };
 
 class Sprite {
@@ -68,6 +75,7 @@ public:
   std::map<std::string, std::map<Direction, int>> nameDirToAnim;
   bool animFinished = false;
   bool hasShadow = false;
+  bool animPaused = false;
 
   // Character
   bool orientable = false;
@@ -75,6 +83,8 @@ public:
   std::vector<int> followers;
   std::deque<Movement> trail;
   CharacterState characterState = CharacterState::Still;
+  CharacterMedium characterMedium = CharacterMedium::Normal;
+  Direction movementDir = Direction::down;
   StepType stepType = StepType::none;
   int runningSfxChannel = -1;
   bool clipping = false;
@@ -72,7 +72,7 @@ CollisionResult TransformSystem::checkCollision(int spriteId, vec2i newLoc, Dire
     enclosureZone = &map.getZone(sprite.enclosureZone);
   }
 
-  if (dirHasDir(sprite.dir, Direction::right)) {
+  if (dirHasDir(dir, Direction::right)) {
     if (newTileDR.x() > oldTileDR.x() &&
         newColDR.x() < mapBounds.w()) {
       for (int y = newTileUL.y(); y <= newTileDR.y(); y++) {
@@ -113,7 +113,7 @@ CollisionResult TransformSystem::checkCollision(int spriteId, vec2i newLoc, Dire
     }
   }
 
-  if (dirHasDir(sprite.dir, Direction::left)) {
+  if (dirHasDir(dir, Direction::left)) {
     if (newTileUL.x() < oldTileUL.x() &&
         newColUL.x() >= 0) {
       for (int y = newTileUL.y(); y <= newTileDR.y(); y++) {
@@ -154,7 +154,7 @@ CollisionResult TransformSystem::checkCollision(int spriteId, vec2i newLoc, Dire
     }
   }
 
-  if (dirHasDir(sprite.dir, Direction::down)) {
+  if (dirHasDir(dir, Direction::down)) {
     if (newTileDR.y() > oldTileDR.y() &&
         newColDR.y() < mapBounds.h()) {
       for (int x = newTileUL.x(); x <= newTileDR.x(); x++) {
@@ -195,7 +195,7 @@ CollisionResult TransformSystem::checkCollision(int spriteId, vec2i newLoc, Dire
     }
   }
 
-  if (dirHasDir(sprite.dir, Direction::up)) {
+  if (dirHasDir(dir, Direction::up)) {
     if (newTileUL.y() < oldTileUL.y() &&
         newColUL.y() >= 0) {
       for (int x = newTileUL.x(); x <= newTileDR.x(); x++) {
@@ -239,6 +239,29 @@ CollisionResult TransformSystem::checkCollision(int spriteId, vec2i newLoc, Dire
   return result;
 }
 
+CharacterMedium TransformSystem::getMediumAtPosition(int spriteId, vec2i newLoc) {
+  Sprite& sprite = game_.getSprite(spriteId);
+
+  const Map& map = game_.getMap();
+
+  vec2i newColUL = newLoc + sprite.collisionOffset;
+  vec2i newColDR = newColUL + sprite.collisionSize;
+  vec2i newTileUL = newColUL / map.getTileSize();
+  vec2i newTileDR = newColDR / map.getTileSize();
+
+  CharacterMedium result = CharacterMedium::Normal;
+  for (int y=newTileUL.y(); y<=newTileDR.y(); y++) {
+    for (int x=newTileUL.x(); x<=newTileDR.x(); x++) {
+      CharacterMedium tileMedium = map.getMedium(x, y);
+      if (tileMedium > result) {
+        result = tileMedium;
+      }
+    }
+  }
+
+  return result;
+}
+
 void TransformSystem::addCollidable(int spriteId) {
   Sprite& sprite = game_.getSprite(spriteId);
 
@@ -47,6 +47,8 @@ public:
 
   CollisionResult checkCollision(int spriteId, vec2i newLoc, Direction dir);
 
+  CharacterMedium getMediumAtPosition(int spriteId, vec2i newLoc);
+
   void destroySprite(int spriteId) override;
 
 private: