Using tmxlite instead of Tileson

7 files changed, 140 insertions, 40 deletions

@@ -4,8 +4,9 @@
 #include <set>
 #include <range/v3/all.hpp>
 #include <vector>
-#include <tileson.hpp>
+#include <memory>
 #include "sprite.h"
+#include "map.h"
 
 struct Input {
   bool left = false;
@@ -55,18 +56,15 @@ public:
     }
   }
 
-  void loadMapFromFile(std::string_view filename) {
-    tson::Tileson t;
-    map_ = t.parse(fs::path(filename));
-  }
+  void setMap(std::unique_ptr<Map> map) { map_ = std::move(map); }
 
-  tson::Map* getMap() const { return map_.get(); }
+  const Map& getMap() const { return *map_; }
 
 private:
 
   std::vector<Sprite> sprites_;
   std::set<std::tuple<int, int>> spritesByY_;
-  std::unique_ptr<tson::Map> map_;
+  std::unique_ptr<Map> map_;
 };
 
 #endif /* end of include guard: GAME_H_E6F1396E */
@@ -1,14 +1,17 @@
 #include <iostream>
+#include <memory>
 #include "renderer.h"
 #include "game.h"
 #include "party.h"
 #include "timer.h"
+#include "map.h"
 
 void loop(Renderer& renderer) {
   Game game;
   Input keystate;
 
-  game.loadMapFromFile("../res/map1.json");
+  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));
@@ -0,0 +1,46 @@
+#include "map.h"
+#include <tmxlite/Map.hpp>
+#include <tmxlite/Layer.hpp>
+#include <tmxlite/TileLayer.hpp>
+#include <tmxlite/Tileset.hpp>
+#include "renderer.h"
+
+Map::Map(std::string_view filename, Renderer& renderer) {
+  tmx::Map mapfile;
+  if (!mapfile.load(filename.data())) {
+    throw std::invalid_argument("Could not find map file: " + std::string(filename));
+  }
+
+  const tmx::Vector2u& mapSize = mapfile.getTileCount();
+  mapSize_.x() = mapSize.x;
+  mapSize_.y() = mapSize.y;
+
+  const tmx::Vector2u& tileSize = mapfile.getTileSize();
+  tileSize_.x() = tileSize.x;
+  tileSize_.y() = tileSize.y;
+
+  int firstGID = 0;
+  // There should only be one tileset.
+  for (const tmx::Tileset& tileset : mapfile.getTilesets()) {
+    firstGID = tileset.getFirstGID();
+    tilesetTextureId_ = renderer.loadImageFromFile(tileset.getImagePath());
+    tilesetColumns_ = tileset.getColumnCount();
+  }
+
+  for (const auto& layer : mapfile.getLayers()) {
+    if (layer->getType() == tmx::Layer::Type::Tile) {
+      const auto& tileLayer = layer->getLayerAs<tmx::TileLayer>();
+
+      std::vector<Tile> tilesToStore;
+
+      for (const auto& maptile : tileLayer.getTiles()) {
+        tilesToStore.push_back(Tile {
+          .id = maptile.ID - firstGID,
+          .flipHorizontal = (maptile.flipFlags & tmx::TileLayer::Horizontal) != 0,
+          .flipVertical = (maptile.flipFlags & tmx::TileLayer::Vertical) != 0 });
+      }
+
+      layers_.push_back(std::move(tilesToStore));
+    }
+  }
+}
@@ -0,0 +1,41 @@
+#ifndef MAP_H_D95D6D47
+#define MAP_H_D95D6D47
+
+#include <string_view>
+#include <vector>
+#include "renderer.h"
+#include "vector.h"
+
+class Renderer;
+
+struct Tile {
+  unsigned int id = 0;
+  bool flipHorizontal = false;
+  bool flipVertical = false;
+};
+
+class Map {
+public:
+
+  Map(std::string_view filename, Renderer& renderer);
+
+  const vec2i& getMapSize() const { return mapSize_; }
+
+  const vec2i& getTileSize() const { return tileSize_; }
+
+  const std::vector<std::vector<Tile>>& getLayers() const { return layers_; }
+
+  int getTilesetTextureId() const { return tilesetTextureId_; }
+
+  int getTilesetColumns() const { return tilesetColumns_; }
+
+private:
+
+  vec2i mapSize_;
+  vec2i tileSize_;
+  std::vector<std::vector<Tile>> layers_;
+  int tilesetTextureId_;
+  int tilesetColumns_;
+};
+
+#endif /* end of include guard: MAP_H_D95D6D47 */
@@ -1,6 +1,7 @@
 #include "renderer.h"
 #include "consts.h"
 #include "game.h"
+#include "map.h"
 
 Renderer::Renderer() {
   win_ = window_ptr(
@@ -29,14 +30,16 @@ Renderer::Renderer() {
   }
 }
 
-texture_ptr Renderer::renderMapLayer(const tson::Layer& layer) {
+texture_ptr Renderer::renderMapLayer(const Map& map, int layer) {
+  vec2i mapBounds = map.getMapSize() * map.getTileSize();
+
   texture_ptr canvas(
     SDL_CreateTexture(
       ren_.get(),
       SDL_PIXELFORMAT_RGBA8888,
       SDL_TEXTUREACCESS_TARGET,
-      layer.getMap()->getSize().x * layer.getMap()->getTileSize().x,
-      layer.getMap()->getSize().y * layer.getMap()->getTileSize().y));
+      mapBounds.w(),
+      mapBounds.h()));
 
   SDL_SetTextureBlendMode(canvas.get(), SDL_BLENDMODE_BLEND);
 
@@ -45,38 +48,44 @@ texture_ptr Renderer::renderMapLayer(const tson::Layer& layer) {
   SDL_SetRenderDrawColor(ren_.get(), 255, 255, 255, 0);
   SDL_RenderClear(ren_.get());
 
-  for (auto& [pos, tileObject] : layer.getTileObjects()) {
-    int x = tileObject.getPosition().x;
-    int y = tileObject.getPosition().y;
-    tson::Rect tileDestRect = tileObject.getDrawingRect();
-    SDL_Rect srcRect { tileDestRect.x, tileDestRect.y, tileDestRect.width, tileDestRect.height };
-    SDL_Rect destRect {
-      x, y, tileObject.getTile()->getTileSize().x, tileObject.getTile()->getTileSize().y };
-
-    SDL_RendererFlip flip = SDL_FLIP_NONE;
-    if (tileObject.getTile()->hasFlipFlags(tson::TileFlipFlags::Horizontally | tson::TileFlipFlags::Vertically)) {
-      flip = static_cast<SDL_RendererFlip>(SDL_FLIP_HORIZONTAL | SDL_FLIP_VERTICAL);
-    } else if (tileObject.getTile()->hasFlipFlags(tson::TileFlipFlags::Horizontally)) {
-      flip = SDL_FLIP_HORIZONTAL;
-    } else if (tileObject.getTile()->hasFlipFlags(tson::TileFlipFlags::Vertically)) {
-      flip = SDL_FLIP_VERTICAL;
+  const std::vector<Tile>& tiles = map.getLayers().at(layer);
+  for (int y = 0; y < map.getMapSize().h(); y++) {
+    for (int x = 0; x < map.getMapSize().w(); x++) {
+      const Tile& tile = tiles.at(x + y * map.getMapSize().w());
+
+      SDL_Rect srcRect {
+        static_cast<int>((tile.id % map.getTilesetColumns()) * map.getTileSize().w()),
+        static_cast<int>((tile.id / map.getTilesetColumns()) * map.getTileSize().h()),
+        map.getTileSize().w(),
+        map.getTileSize().h() };
+
+      SDL_Rect destRect {
+        x * map.getTileSize().w(),
+        y * map.getTileSize().h(),
+        map.getTileSize().w(),
+        map.getTileSize().h() };
+
+      SDL_RendererFlip flip = SDL_FLIP_NONE;
+      if (tile.flipHorizontal && tile.flipVertical) {
+        flip = static_cast<SDL_RendererFlip>(SDL_FLIP_HORIZONTAL | SDL_FLIP_VERTICAL);
+      } else if (tile.flipHorizontal) {
+        flip = SDL_FLIP_HORIZONTAL;
+      } 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(), textures_[tilesetTexId_].get(), &srcRect, &destRect, 0, nullptr, flip);
   }
 
   return canvas;
 }
 
 void Renderer::render(Game& game) {
-  if (tilesetTexId_ == -1) {
-    tilesetTexId_ = loadImageFromFile(game.getMap()->getTileset("fromRom")->getImage().c_str());
-  }
-
   if (!renLay1_) {
-    renLay1_ = renderMapLayer(*game.getMap()->getLayer("Layer 1"));
+    renLay1_ = renderMapLayer(game.getMap(), 0);
   }
   if (!renLay0_) {
-    renLay0_ = renderMapLayer(*game.getMap()->getLayer("Layer 0"));
+    renLay0_ = renderMapLayer(game.getMap(), 1);
   }
 
   texture_ptr canvas(
@@ -91,15 +100,15 @@ void Renderer::render(Game& game) {
     throw sdl_error();
   }
 
-
-
   SDL_SetRenderTarget(ren_.get(), canvas.get());
   SDL_SetRenderDrawBlendMode(ren_.get(), SDL_BLENDMODE_NONE);
   SDL_SetRenderDrawColor(ren_.get(), 255, 255, 255, 255);
   SDL_RenderClear(ren_.get());
 
+  vec2i mapBounds = game.getMap().getMapSize() * game.getMap().getTileSize();
+
   {
-    SDL_Rect dest { -80, -80, game.getMap()->getSize().x * game.getMap()->getTileSize().x, game.getMap()->getSize().y * game.getMap()->getTileSize().y };
+    SDL_Rect dest { -80, -80, mapBounds.w(), mapBounds.h() };
     SDL_RenderCopy(ren_.get(), renLay1_.get(), nullptr, &dest);
   }
 
@@ -111,7 +120,7 @@ void Renderer::render(Game& game) {
   }
 
   {
-    SDL_Rect dest { -80, -80, game.getMap()->getSize().x * game.getMap()->getTileSize().x, game.getMap()->getSize().y * game.getMap()->getTileSize().y };
+    SDL_Rect dest { -80, -80, mapBounds.w(), mapBounds.h() };
     SDL_RenderCopy(ren_.get(), renLay0_.get(), nullptr, &dest);
   }
 
@@ -7,9 +7,9 @@
 #include <memory>
 #include <string_view>
 #include <vector>
-#include <tileson.hpp>
 
 class Game;
+class Map;
 
 class sdl_error : public std::logic_error {
 public:
@@ -122,7 +122,7 @@ public:
 
 private:
 
-  texture_ptr renderMapLayer(const tson::Layer& layer);
+  texture_ptr renderMapLayer(const Map& map, int layer);
 
   sdl_wrapper sdl_;
   img_wrapper img_;
@@ -130,7 +130,6 @@ private:
   renderer_ptr ren_;
 
   std::vector<texture_ptr> textures_;
-  int tilesetTexId_ = -1;
   texture_ptr renLay0_;
   texture_ptr renLay1_;
 };
@@ -91,6 +91,10 @@ public:
     return *this;
   }
 
+  vec2 operator*(const vec2& other) const {
+    return vec2(x() * other.x(), y() * other.y());
+  }
+
   bool operator==(const vec2& other) const {
     return std::tie(x(), other.x()) == std::tie(y(), other.y());
   }