Merge branch 'basic-spritesheet' into 'main'

Basic spritesheet

See merge request !2

.gitignore

@@ -54,6 +54,8 @@ Thumbs.db
 *.gcov
 coverage/
 
+*.png
+
 docs/generated/
 
 bin/

src/engine.cpp

@@ -36,10 +36,12 @@ Engine::Engine(Window &window) : window(window), quit(false) {
 
 void Engine::set_scene(Scene &scene) { this->scene = &scene; }
 
-void Engine::set_spritesheet(Spritesheet spritesheet) {
-  this->spritesheet = spritesheet;
+void Engine::set_spritesheet(Spritesheet &spritesheet) {
+  this->spritesheet = &spritesheet;
 }
 
+Spritesheet *Engine::get_spritesheet() { return spritesheet.value(); }
+
 void Engine::pump() {
   SDL_Event e;
   while (SDL_PollEvent(&e)) {
@@ -63,7 +65,7 @@ void Engine::render() {
     return;
   }
 
-  this->scene.value()->render(this->sdl_renderer, this->events);
+  this->scene.value()->render(*this, this->events);
 
   SDL_RenderPresent(this->sdl_renderer);
 }

src/engine.hpp

@@ -26,7 +26,9 @@ public:
 
   void set_scene(Scene &scene);
 
-  void set_spritesheet(Spritesheet spritesheet);
+  void set_spritesheet(Spritesheet &spritesheet);
+
+  Spritesheet *get_spritesheet();
 
   void render();
 
@@ -38,7 +40,7 @@ private:
   Window &window;
   SDL_Renderer *sdl_renderer;
   std::optional<Scene *> scene;
-  std::optional<Spritesheet> spritesheet;
+  std::optional<Spritesheet *> spritesheet;
   std::vector<SDL_Event> events;
   bool quit;
 };

src/level.cpp

 #include "level.hpp"
+#include "SDL_error.h"
 #include "building.hpp"
+#include "engine.hpp"
+#include "spritesheet.hpp"
 #include "unit.hpp"
-#include <string>
-#include <iostream>
 #include <SDL.h>
+#include <iostream>
+#include <string>
 
 namespace advanced_wars
 {
 
-    Level::Level(std::string name, int width, int height, std::vector<Tile> tiles, std::vector<Building> buildings, std::vector<Unit> units): name(name), width(width), height(height), buildings(buildings), units(units) {};
+  Level::Level(std::string name, int width, int height, std::vector<Tile> tiles,
+               std::vector<Building> buildings, std::vector<Unit> units)
+      : name(name), width(width), height(height), buildings(buildings),
+        units(units) {
+          /* Commented for testing purposes
+          if ((size_t)(width * height) != tiles.size()) {
+            throw std::runtime_error("level tile mismatch");
+          }
+          */
+        };
+
+  void Level::render(Engine &engine, std::vector<SDL_Event> &events)
+  {
+    const int RENDERING_SCALE = 3;
 
-    void Level::render(SDL_Renderer *renderer, std::vector<SDL_Event> &events) {
     // Iterate over all events
-        while (!events.empty()) {
+    while (!events.empty())
+    {
       events.erase(events.begin());
     }
 
-        // Set background color for renderer
-        if(SDL_SetRenderDrawColor(renderer, 255, 0, 0, 0))
+    for (int y = 0; y < this->height; y++)
     {
-            std::cout << "Could not set render draw color: " << SDL_GetError() << std::endl;
+      for (int x = 0; x < this->width; x++)
+      {
+        Spritesheet *spritesheet = engine.get_spritesheet();
+
+        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;
+
+        if (spritesheet->render_tile(engine.renderer(), 0, 0, &dst) != 0)
+        {
+          throw std::runtime_error("error while rendering a tile: " +
+                                   std::string(SDL_GetError()));
+        }
       }
     }
 
+    // Set background color for renderer
+    if (SDL_SetRenderDrawColor(engine.renderer(), 255, 0, 0, 0))
+    {
+      std::cout << "Could not set render draw color: " << SDL_GetError()
+                << std::endl;
     }
+  }
+
+} // namespace advanced_wars

src/level.hpp

 #pragma once
 
 #include "building.hpp"
+#include "engine.hpp"
 #include "scene.hpp"
 #include "tile.hpp"
 #include "unit.hpp"
@@ -18,7 +19,7 @@ public:
   Level(std::string name, int width, int height, std::vector<Tile> tiles,
         std::vector<Building> buildings, std::vector<Unit> units);
 
-  void render(SDL_Renderer *renderer, std::vector<SDL_Event> &events);
+  void render(Engine &engine, std::vector<SDL_Event> &events);
 
 private:
   std::string name;

src/main.cpp

 #include "engine.hpp"
 #include "level.hpp"
 #include "spritesheet.hpp"
+#include "tile.hpp"
 #include "window.hpp"
 #include <vector>
 
 using namespace advanced_wars;
 
-int main() {
+int main()
+{
 
-  Window window("Advanced Wars", 800, 600);
+  Window window("Advanced Wars", 960, 960);
 
   Engine engine(window);
 
@@ -17,11 +19,12 @@ int main() {
 
   engine.set_scene(level);
 
-  Spritesheet spritesheet("../test.png", engine);
+  Spritesheet spritesheet("../tiles.png", engine);
 
   engine.set_spritesheet(spritesheet);
 
-  while (!engine.exited()) {
+  while (!engine.exited())
+  {
     engine.pump();
     engine.render();
   }

src/scene.hpp

@@ -5,9 +5,11 @@
 
 namespace advanced_wars {
 
+// Forward declaration
+class Engine;
+
 class Scene {
 public:
-  virtual void render(SDL_Renderer *renderer,
-                      std::vector<SDL_Event> &events) = 0;
+  virtual void render(Engine &engine, std::vector<SDL_Event> &events) = 0;
 };
 } // namespace advanced_wars

src/spritesheet.cpp

@@ -6,23 +6,33 @@
 #include <SDL_image.h>
 #include <stdexcept>
 
-namespace advanced_wars {
+namespace advanced_wars
+{
 
-Spritesheet::Spritesheet(std::string path, Engine &engine) {
+  Spritesheet::Spritesheet(std::string path, Engine &engine)
+  {
     SDL_Surface *loadedSurface = IMG_Load(path.c_str());
-  if (loadedSurface == nullptr) {
+    if (loadedSurface == nullptr)
+    {
       throw std::runtime_error("Fehler beim Laden des Bildes " + path + ": " +
                                std::string(IMG_GetError()));
     }
 
     texture = SDL_CreateTextureFromSurface(engine.renderer(), loadedSurface);
 
-  if (texture == nullptr) {
+    if (texture == nullptr)
+    {
       throw std::runtime_error("Fehler beim Erstellen der Textur: " +
                                std::string(SDL_GetError()));
     }
 
     SDL_FreeSurface(loadedSurface);
+
+    // Temporary
+    this->tile_width = 16;
+    this->tile_height = 16;
+    this->tiles.push_back(std::pair(0, 1));
+    this->tiles.push_back(std::pair(1, 4));
   }
 
   int Spritesheet::get_tile_steps(int tile) { return tiles.at(tile).second; }
@@ -32,8 +42,10 @@ 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) {
-  if (step >= this->get_tile_steps(tile) || step < 0) {
+                               SDL_Rect *rect)
+  {
+    if (step >= this->get_tile_steps(tile) || step < 0)
+    {
       throw std::runtime_error("Tried to access step " + std::to_string(step) +
                                " for tile " + std::to_string(tile));
     }
@@ -44,6 +56,11 @@ int Spritesheet::render_tile(SDL_Renderer *renderer, int tile, int step,
     src.w = tile_width;
     src.h = tile_height;
 
+    /*
+       std::cout << rect->x << " " << rect->y << " " << rect->w << " " << rect->h
+                << std::endl;
+      */
+
     return SDL_RenderCopyEx(renderer, texture, &src, rect, 0, NULL,
                             SDL_FLIP_NONE);
   }

src/spritesheet.hpp

@@ -16,6 +16,10 @@ public:
 
   ~Spritesheet();
 
+  Spritesheet(const Spritesheet &) = delete;
+
+  Spritesheet &operator=(const Spritesheet &) = delete;
+
   // Tiles
   int get_tile_steps(int tile);