Refactor Tile Rendering from Spritesheet to Tiles themselves

src/engine.cpp

@@ -55,6 +55,8 @@ void Engine::pump() {
 
 bool Engine::exited() { return this->quit; }
 
+int Engine::get_stage() { return this->stage; }
+
 void Engine::render() {
   if (SDL_RenderClear(this->sdl_renderer) != 0) {
     throw std::runtime_error("Could not clear renderer: " +
@@ -65,6 +67,8 @@ void Engine::render() {
     return;
   }
 
+  stage = SDL_GetTicks() / 300;
+
   this->scene.value()->render(*this, this->events);
 
   SDL_RenderPresent(this->sdl_renderer);

src/engine.hpp

@@ -30,6 +30,8 @@ public:
 
   Spritesheet *get_spritesheet();
 
+  int get_stage();
+
   void render();
 
   SDL_Renderer *renderer();
@@ -43,6 +45,7 @@ private:
   std::optional<Spritesheet *> spritesheet;
   std::vector<SDL_Event> events;
   bool quit;
+  int stage;
 };
 
 } // namespace advanced_wars

src/level.cpp

@@ -35,26 +35,9 @@ void Level::render(Engine &engine, std::vector<SDL_Event> &events) {
   Spritesheet *spritesheet = engine.get_spritesheet();
 
   // Tiles
-  for (int y = 0; y < this->height; y++) {
-    for (int x = 0; x < this->width; x++) {
-
-      SDL_Rect dst;
-      dst.x = x * spritesheet->get_tile_width() * RENDERING_SCALE;
-      dst.y = y * spritesheet->get_tile_height() * RENDERING_SCALE;
-      dst.w = spritesheet->get_tile_width() * RENDERING_SCALE;
-      dst.h = spritesheet->get_tile_height() * RENDERING_SCALE;
-
-      int tile_id = static_cast<int>(tiles.at(idx).id);
-
-      if (spritesheet->render_tile(engine.renderer(), tile_id,
-                                   stage % spritesheet->get_tile_steps(tile_id),
-                                   &dst) != 0) {
-        throw std::runtime_error("error while rendering a tile: " +
-                                 std::string(SDL_GetError()));
-      }
-
-      idx += 1;
-    }
+  for(Tile t : tiles)
+  {
+    t.render(engine, events);
   }
 
   // Buildings

src/main.cpp

@@ -17,34 +17,40 @@ int main() {
   Engine engine(window);
 
   // Construct a level
-  std::vector<Tile> tiles(20 * 20, Tile(TileId::PLAIN));
+  std::vector<Tile> tiles;
+  for(int y = 0; y < 20; y++) {
+    for(int x = 0; x < 20; x++) {
+      tiles.push_back(Tile(TileId::PLAIN, x, y));
+    }
+  }
+
 
   // Fill the edges with water
   for (size_t n = 0; n < 20; n++) {
     // Vertical
-    tiles.at(n * 20) = Tile(TileId::WATER);
-    tiles.at(n * 20 + 19) = Tile(TileId::WATER);
+    tiles.at(n * 20) = Tile(TileId::WATER, 0, n);
+    tiles.at(n * 20 + 19) = Tile(TileId::WATER, 19, n);
     // Horizontal
-    tiles.at(n) = Tile(TileId::WATER);
-    tiles.at(19 * 20 + n) = Tile(TileId::WATER);
+    tiles.at(n) = Tile(TileId::WATER, n, 0);
+    tiles.at(19 * 20 + n) = Tile(TileId::WATER, n, 19);
   }
 
   // Make the edges cliffs
   for (size_t n = 1; n < 19; n++) {
     // Vertical
-    tiles.at(n * 20 + 1) = Tile(TileId::CLIFF_RIGHT);
-    tiles.at(n * 20 + 18) = Tile(TileId::CLIFF_LEFT);
+    tiles.at(n * 20 + 1) = Tile(TileId::CLIFF_RIGHT, 1, n);
+    tiles.at(n * 20 + 18) = Tile(TileId::CLIFF_LEFT, 18, n);
 
     // Horizontal
-    tiles.at(20 + n) = Tile(TileId::CLIFF_BOTTOM);
-    tiles.at(18 * 20 + n) = Tile(TileId::CLIFF_TOP);
+    tiles.at(20 + n) = Tile(TileId::CLIFF_BOTTOM, n, 1);
+    tiles.at(18 * 20 + n) = Tile(TileId::CLIFF_TOP, n, 18);
   }
 
   // Fix the corners
-  tiles.at(20 + 1) = Tile(TileId::CLIFF_CORNER_TOP_LEFT);
-  tiles.at(20 + 18) = Tile(TileId::CLIFF_CORNER_TOP_RIGHT);
-  tiles.at(18 * 20 + 1) = Tile(TileId::CLIFF_CORNER_BOTTOM_LEFT);
-  tiles.at(18 * 20 + 18) = Tile(TileId::CLIFF_CORNER_BOTTOM_RIGHT);
+  tiles.at(20 + 1) = Tile(TileId::CLIFF_CORNER_TOP_LEFT, 1, 1);
+  tiles.at(20 + 18) = Tile(TileId::CLIFF_CORNER_TOP_RIGHT, 18, 1);
+  tiles.at(18 * 20 + 1) = Tile(TileId::CLIFF_CORNER_BOTTOM_LEFT, 1, 18);
+  tiles.at(18 * 20 + 18) = Tile(TileId::CLIFF_CORNER_BOTTOM_RIGHT, 18, 18);
 
   // Buildings
   std::vector<Building> buildings;

src/spritesheet.cpp

@@ -128,26 +128,9 @@ int Spritesheet::get_tile_width() { return tile_width; }
 
 int Spritesheet::get_tile_height() { return tile_height; }
 
-int Spritesheet::render_tile(SDL_Renderer *renderer, int tile, int step,
-                             SDL_Rect *rect) {
-  int max_steps = this->get_tile_steps(tile);
+std::vector<std::pair<int, int>> Spritesheet::get_tiles() { return tiles; }
 
-  if (step >= max_steps || step < 0) {
-    throw std::runtime_error("Tried to access step " + std::to_string(step) +
-                             " for tile " + std::to_string(tile));
-  }
-
-  int offset = tiles.at(tile).first;
-
-  SDL_Rect src;
-  src.x = offset * tile_width + step * tile_width;
-  src.y = 0;
-  src.w = tile_width;
-  src.h = tile_height;
-
-  return SDL_RenderCopyEx(renderer, tile_texture, &src, rect, 0, NULL,
-                          SDL_FLIP_NONE);
-}
+SDL_Texture *Spritesheet::get_tile_texture() { return tile_texture; }
 
 // Buildings
 int Spritesheet::get_building_width() { return this->building_width; }

src/spritesheet.hpp

@@ -29,7 +29,9 @@ public:
 
   int get_tile_height();
 
-  int render_tile(SDL_Renderer *renderer, int tile, int step, SDL_Rect *rect);
+  std::vector<std::pair<int, int>> get_tiles();
+
+  SDL_Texture* get_tile_texture();
 
   // Buildings: TODO
   int get_building_width();

src/tile.cpp

 #include "tile.hpp"
+#include <stdexcept>
+#include <vector>
+#include "spritesheet.hpp"
 
-Tile::Tile(TileId id)
-    : id(id) {
+namespace advanced_wars {
+
+Tile::Tile(TileId id, int x, int y)
+    : id(id), x(x) , y(y){
 
       };
+
+void Tile::render(Engine& engine, std::vector<SDL_Event>& events)
+{ 
+  Spritesheet* spritesheet = engine.get_spritesheet();
+  int max_steps = spritesheet->get_tile_steps(static_cast<int>(id));
+
+  int step = engine.get_stage() % max_steps;
+
+  if (step >= max_steps || step < 0) {
+    throw std::runtime_error("Tried to access step " + std::to_string(step) +
+                             " for tile " + std::to_string(this->id));
+  }
+
+  std::vector<std::pair<int, int>> tiles = spritesheet->get_tiles();
+
+  int offset = tiles.at(id).first;
+
+  SDL_Rect src;
+  src.x = offset * spritesheet->get_tile_width() + step * spritesheet->get_tile_width();
+  src.y = 0;
+  src.w = spritesheet->get_tile_width();
+  src.h = spritesheet->get_tile_height();
+
+  SDL_Rect dest;
+  dest.x = x * spritesheet->get_tile_width() * 3;
+  dest.y = y * spritesheet->get_tile_height() * 3;
+  dest.w = spritesheet->get_tile_width() * 3;
+  dest.h = spritesheet->get_tile_height() * 3;
+
+  SDL_RenderCopyEx(engine.renderer(), spritesheet->get_tile_texture(), &src, &dest, 0, NULL, SDL_FLIP_NONE);
+
+}
+
+} // namespace advanced_wars
\ No newline at end of file

src/tile.hpp

 #pragma once
 
+#include "scene.hpp"
+#include "engine.hpp"
+
+namespace advanced_wars {
+
 enum TileId {
   PLAIN = 0,
   WATER = 1,
@@ -24,8 +29,14 @@ enum TileId {
   CLIFF_INVERSE_CORNER_BOTTOM_RIGHT = 20,
 };
 
-class Tile {
+class Tile : public Scene{
 public:
-  Tile(TileId id);
+  Tile(TileId id, int x, int y);
   TileId id;
+  int x;
+  int y;
+
+  void render(Engine &engine, std::vector<SDL_Event>& events) override;
 };
+
+} // namespace advanced_wars
\ No newline at end of file