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_;