Map changing!

Also removed some dependencies on the Renderer. More changes need to be made. Fading to black before the change would be good. And making sure the characters are facing the right direction. Maybe that code shouldn't live in Game, either. Later we also want to combine the tilesets for these two maps (and any others that are on Tanetane).

16 files changed, 119 insertions, 66 deletions

@@ -6,7 +6,7 @@
 #include "vector.h"
 #include "util.h"
 
-void AnimationSystem::initSprite(int spriteId, std::string_view filename, Renderer& renderer) {
+void AnimationSystem::initSprite(int spriteId, std::string_view filename) {
   std::ifstream datafile(filename.data());
   if (!datafile.is_open()) {
     throw std::invalid_argument(std::string("Could not find sprite datafile: ") + std::string(filename));
@@ -18,9 +18,7 @@ void AnimationSystem::initSprite(int spriteId, std::string_view filename, Render
   char ch;
   std::string line;
 
-  std::string imagename;
-  datafile >> imagename;
-  sprite.textureId = renderer.loadImageFromFile(imagename);
+  datafile >> sprite.spritesheet;
 
   std::string framefilename;
   datafile >> framefilename;
@@ -7,7 +7,6 @@
 #include "timer.h"
 
 class Game;
-class Renderer;
 
 class AnimationSystem : public System {
 public:
@@ -18,7 +17,7 @@ public:
 
   void tick(double dt) override;
 
-  void initSprite(int spriteId, std::string_view filename, Renderer& renderer);
+  void initSprite(int spriteId, std::string_view filename);
 
   void setSpriteDirection(int spriteId, Direction dir);
 
@@ -4,7 +4,7 @@
 #include "map.h"
 
 void CameraSystem::tick(double dt) {
-  if (!locked_) {
+  if (!locked_ && followingSprite_ != -1) {
     const Sprite& follow = game_.getSprite(followingSprite_);
     const Map& map = game_.getMap();
     vec2i mapBounds = map.getMapSize() * map.getTileSize();
@@ -25,3 +25,7 @@ void CameraSystem::tick(double dt) {
     }
   }
 }
+
+void CameraSystem::clearSpriteCache() {
+  followingSprite_ = -1;
+}
@@ -26,12 +26,14 @@ public:
 
   void tick(double dt) override;
 
+  void clearSpriteCache() override;
+
 private:
   Game& game_;
 
   vec2i pos_;
   vec2i fov_ { CANVAS_WIDTH, CANVAS_HEIGHT };
-  int followingSprite_;
+  int followingSprite_ = -1;
   bool locked_ = true;
 };
 
@@ -1,4 +1,8 @@
 #include "game.h"
+#include "transform_system.h"
+#include "animation_system.h"
+#include "character_system.h"
+#include "camera_system.h"
 
 int Game::emplaceSprite(std::string alias) {
   int id = sprites_.size();
@@ -7,3 +11,59 @@ int Game::emplaceSprite(std::string alias) {
   spritesByAlias_[alias] = id;
   return id;
 }
+
+void Game::clearSprites() {
+  sprites_.clear();
+  spriteIds_.clear();
+  spritesByAlias_.clear();
+
+  for (std::unique_ptr<System>& system : systems_) {
+    system->clearSpriteCache();
+  }
+}
+
+void Game::loadMap(std::string filename, std::string warpPoint) {
+  clearSprites();
+
+  map_ = std::make_unique<Map>(filename);
+
+  int lucasSprite = emplaceSprite("lucas");
+  getSystem<TransformSystem>().initSprite(lucasSprite, map_->getWarpPoint(warpPoint));
+  getSystem<TransformSystem>().setUpCollision(lucasSprite, {-8, -8}, {12, 8}, true);
+  getSystem<AnimationSystem>().initSprite(lucasSprite, "../res/sprites/lucas_anim.txt");
+  getSprite(lucasSprite).controllable = true;
+  getSystem<CharacterSystem>().initSprite(lucasSprite);
+
+  int kumaSprite = emplaceSprite("kuma");
+  getSystem<TransformSystem>().initSprite(kumaSprite, {32, 32});
+  getSystem<AnimationSystem>().initSprite(kumaSprite, "../res/sprites/kuma_anim.txt");
+  getSystem<CharacterSystem>().addSpriteToParty(lucasSprite, kumaSprite);
+
+  int dusterSprite = emplaceSprite("duster");
+  getSystem<TransformSystem>().initSprite(dusterSprite, {32, 32});
+  getSystem<AnimationSystem>().initSprite(dusterSprite, "../res/sprites/duster_anim.txt");
+  getSystem<CharacterSystem>().addSpriteToParty(lucasSprite, dusterSprite);
+
+  int boneySprite = emplaceSprite("boney");
+  getSystem<TransformSystem>().initSprite(boneySprite, {32, 32});
+  getSystem<AnimationSystem>().initSprite(boneySprite, "../res/sprites/boney_anim.txt");
+  getSystem<CharacterSystem>().addSpriteToParty(lucasSprite, boneySprite);
+
+  for (const Prototype& p : map_->getPrototypes()) {
+    int spriteId = emplaceSprite(p.name);
+    getSystem<TransformSystem>().initSprite(spriteId, p.pos);
+    getSystem<TransformSystem>().setUpCollision(spriteId, p.collisionOffset, p.collisionSize, true);
+    getSystem<AnimationSystem>().initSprite(spriteId, p.animationFilename);
+    getSprite(spriteId).interactionScript = p.interactionScript;
+  }
+
+  for (const Trigger& t : map_->getTriggers()) {
+    int spriteId = emplaceSprite(t.name);
+    getSystem<TransformSystem>().initSprite(spriteId, t.pos);
+    getSystem<TransformSystem>().setUpCollision(spriteId, {0, 0}, t.size, false);
+    getSprite(spriteId).walkthroughScript = t.script;
+  }
+
+  getSystem<CameraSystem>().setFollowingSprite(lucasSprite);
+  getSystem<CameraSystem>().unlockCamera();
+}
@@ -73,7 +73,7 @@ public:
     });
   }
 
-  void setMap(std::unique_ptr<Map> map) { map_ = std::move(map); }
+  void loadMap(std::string filename, std::string warpPoint);
 
   const Map& getMap() const { return *map_; }
 
@@ -81,6 +81,8 @@ public:
 
 private:
 
+  void clearSprites();
+
   Mixer mixer_;
   bool shouldQuit_ = false;
 
@@ -22,48 +22,7 @@ void loop(Renderer& renderer) {
   game.emplaceSystem<MessageSystem>();
   game.emplaceSystem<ScriptSystem>();
 
-  auto map = std::make_unique<Map>("../res/maps/map1.tmx", renderer);
-  game.setMap(std::move(map));
-
-  int lucasSprite = game.emplaceSprite("lucas");
-  game.getSystem<TransformSystem>().initSprite(lucasSprite, game.getMap().getWarpPoint("spawn"));
-  game.getSystem<TransformSystem>().setUpCollision(lucasSprite, {-8, -8}, {12, 8}, true);
-  game.getSystem<AnimationSystem>().initSprite(lucasSprite, "../res/sprites/lucas_anim.txt", renderer);
-  game.getSprite(lucasSprite).controllable = true;
-  game.getSystem<CharacterSystem>().initSprite(lucasSprite);
-
-  int kumaSprite = game.emplaceSprite("kuma");
-  game.getSystem<TransformSystem>().initSprite(kumaSprite, {32, 32});
-  game.getSystem<AnimationSystem>().initSprite(kumaSprite, "../res/sprites/kuma_anim.txt", renderer);
-  game.getSystem<CharacterSystem>().addSpriteToParty(lucasSprite, kumaSprite);
-
-  int dusterSprite = game.emplaceSprite("duster");
-  game.getSystem<TransformSystem>().initSprite(dusterSprite, {32, 32});
-  game.getSystem<AnimationSystem>().initSprite(dusterSprite, "../res/sprites/duster_anim.txt", renderer);
-  game.getSystem<CharacterSystem>().addSpriteToParty(lucasSprite, dusterSprite);
-
-  int boneySprite = game.emplaceSprite("boney");
-  game.getSystem<TransformSystem>().initSprite(boneySprite, {32, 32});
-  game.getSystem<AnimationSystem>().initSprite(boneySprite, "../res/sprites/boney_anim.txt", renderer);
-  game.getSystem<CharacterSystem>().addSpriteToParty(lucasSprite, boneySprite);
-
-  for (const Prototype& p : game.getMap().getPrototypes()) {
-    int spriteId = game.emplaceSprite(p.name);
-    game.getSystem<TransformSystem>().initSprite(spriteId, p.pos);
-    game.getSystem<TransformSystem>().setUpCollision(spriteId, p.collisionOffset, p.collisionSize, true);
-    game.getSystem<AnimationSystem>().initSprite(spriteId, p.animationFilename, renderer);
-    game.getSprite(spriteId).interactionScript = p.interactionScript;
-  }
-
-  for (const Trigger& t : game.getMap().getTriggers()) {
-    int spriteId = game.emplaceSprite(t.name);
-    game.getSystem<TransformSystem>().initSprite(spriteId, t.pos);
-    game.getSystem<TransformSystem>().setUpCollision(spriteId, {0, 0}, t.size, false);
-    game.getSprite(spriteId).walkthroughScript = t.script;
-  }
-
-  game.getSystem<CameraSystem>().setFollowingSprite(lucasSprite);
-  game.getSystem<CameraSystem>().unlockCamera();
+  game.loadMap("../res/maps/map1.tmx", "spawn");
 
   renderer.render(game);
 
@@ -4,9 +4,8 @@
 #include <tmxlite/Property.hpp>
 #include <tmxlite/TileLayer.hpp>
 #include <tmxlite/Tileset.hpp>
-#include "renderer.h"
 
-Map::Map(std::string_view filename, Renderer& renderer) {
+Map::Map(std::string_view filename) : filename_(filename) {
   tmx::Map mapfile;
   if (!mapfile.load(filename.data())) {
     throw std::invalid_argument("Could not find map file: " + std::string(filename));
@@ -24,7 +23,7 @@ Map::Map(std::string_view filename, Renderer& renderer) {
   // There should only be one tileset.
   const tmx::Tileset& tileset = mapfile.getTilesets()[0];
   firstGID = tileset.getFirstGID();
-  tilesetTextureId_ = renderer.loadImageFromFile(tileset.getImagePath());
+  tilesetFilename_ = tileset.getImagePath();
   tilesetColumns_ = tileset.getColumnCount();
 
   for (const auto& layer : mapfile.getLayers()) {
@@ -5,12 +5,9 @@
 #include <string>
 #include <string_view>
 #include <vector>
-#include "renderer.h"
 #include "vector.h"
 #include "step_type.h"
 
-class Renderer;
-
 struct Tile {
   unsigned int id = 0;
   bool flipHorizontal = false;
@@ -38,7 +35,9 @@ struct Trigger {
 class Map {
 public:
 
-  Map(std::string_view filename, Renderer& renderer);
+  explicit Map(std::string_view filename);
+
+  const std::string& getName() const { return filename_; }
 
   const vec2i& getMapSize() const { return mapSize_; }
 
@@ -46,7 +45,7 @@ public:
 
   const std::vector<std::vector<Tile>>& getLayers() const { return layers_; }
 
-  int getTilesetTextureId() const { return tilesetTextureId_; }
+  const std::string& getTilesetFilename() const { return tilesetFilename_; }
 
   int getTilesetColumns() const { return tilesetColumns_; }
 
@@ -62,10 +61,11 @@ public:
 
 private:
 
+  std::string filename_;
   vec2i mapSize_;
   vec2i tileSize_;
   std::vector<std::vector<Tile>> layers_;
-  int tilesetTextureId_;
+  std::string tilesetFilename_;
   int tilesetColumns_;
   std::vector<Prototype> prototypes_;
   std::map<std::string, vec2i> warpPoints_;
@@ -35,6 +35,16 @@ Renderer::Renderer() {
 }
 
 texture_ptr Renderer::renderMapLayer(const Map& map, int layer) {
+  if (cachedTilesetName_ != map.getTilesetFilename()) {
+    surface_ptr pfs(IMG_Load(map.getTilesetFilename().c_str()));
+    if (!pfs) {
+      throw img_error();
+    }
+
+    tilesetTex_ = texture_ptr(SDL_CreateTextureFromSurface(ren_.get(), pfs.get()));
+    cachedTilesetName_ = map.getTilesetFilename();
+  }
+
   vec2i mapBounds = map.getMapSize() * map.getTileSize();
 
   texture_ptr canvas(
@@ -77,7 +87,7 @@ texture_ptr Renderer::renderMapLayer(const Map& map, int layer) {
       } else if (tile.flipVertical) {
         flip = SDL_FLIP_VERTICAL;
       }
-      SDL_RenderCopyEx(ren_.get(), textures_[map.getTilesetTextureId()].get(), &srcRect, &destRect, 0, nullptr, flip);
+      SDL_RenderCopyEx(ren_.get(), tilesetTex_.get(), &srcRect, &destRect, 0, nullptr, flip);
     }
   }
 
@@ -85,10 +95,9 @@ texture_ptr Renderer::renderMapLayer(const Map& map, int layer) {
 }
 
 void Renderer::render(Game& game) {
-  if (!renLay1_) {
+  if (cachedMapName_ != game.getMap().getName()) {
+    cachedMapName_ = game.getMap().getName();
     renLay1_ = renderMapLayer(game.getMap(), 0);
-  }
-  if (!renLay0_) {
     renLay0_ = renderMapLayer(game.getMap(), 1);
   }
 
@@ -118,7 +127,7 @@ void Renderer::render(Game& game) {
       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.textureId).get(), &src, &dest);
+      SDL_RenderCopy(ren_.get(), textures_.at(loadImageFromFile(sprite.spritesheet)).get(), &src, &dest);
     }
   }
 
@@ -136,6 +136,9 @@ private:
   // Map rendering
   texture_ptr renderMapLayer(const Map& map, int layer);
 
+  std::string cachedMapName_;
+  std::string cachedTilesetName_;
+  texture_ptr tilesetTex_;
   texture_ptr renLay0_;
   texture_ptr renLay1_;
 
@@ -50,6 +50,12 @@ ScriptSystem::ScriptSystem(Game& game) : game_(game) {
       return game_.getSpriteByAlias(alias);
     });
 
+  engine_.set_function(
+    "loadMap",
+    [&] (std::string filename, std::string warpPoint) {
+      game_.loadMap(filename, warpPoint);
+    });
+
   engine_.script_file("../res/scripts/common.lua");
 }
 
@@ -42,7 +42,7 @@ public:
 
   // Animation
   bool isAnimated = false;
-  int textureId;
+  std::string spritesheet;
   Direction dir = Direction::down;
   std::string animationName = "still";
   int animationId = 0;
@@ -15,6 +15,8 @@ class System {
 public:
 
   virtual void tick(double dt) {}
+
+  virtual void clearSpriteCache() {}
 };
 
 #endif /* end of include guard: SYSTEM_H_6B40E1B9 */
@@ -209,3 +209,11 @@ void TransformSystem::removeCollidable(int spriteId) {
   upCollidables_.erase({ colDR.y(), spriteId });
   downCollidables_.erase({ colUL.y(), spriteId });
 }
+
+void TransformSystem::clearSpriteCache() {
+  spritesByY_.clear();
+  leftCollidables_.clear();
+  rightCollidables_.clear();
+  upCollidables_.clear();
+  downCollidables_.clear();
+}
@@ -43,6 +43,8 @@ public:
 
   CollisionResult checkCollision(int spriteId, vec2i newLoc, Direction dir);
 
+  void clearSpriteCache() override;
+
 private:
 
   Game& game_;