src/Arrow.cpp

@@ -1,13 +1,20 @@
 #include <cmath>
 #include <numbers>
+#include <memory>
 #include "Arrow.hpp"
 
-void Arrow::draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const
+Arrow::Arrow(GameRenderer *renderer, const double x, const double y, const double angle)
+    : renderer(renderer), x(x), y(y), angle(angle)
+{
+    sprite = renderer->load_sprite("./assets/arrow.png", 22, 8);
+}
+
+void Arrow::draw(const double player_x, const double player_y) const
 {
     renderer->draw_sprite_rotated(
-		sprite,
+        *sprite,
-		(int)(x - sprite.width / 2 + renderer->screen_width / 2 - player_x),
+        (int)(x - sprite->width / 2 + renderer->screen_width / 2 - player_x),
-		(int)(y - sprite.height / 2 + renderer->screen_height / 2 - player_y),
+        (int)(y - sprite->height / 2 + renderer->screen_height / 2 - player_y),
         angle * 180 / std::numbers::pi
     );
 }

src/Arrow.hpp

@@ -8,6 +8,9 @@
 class Arrow
 {
 private:
+    GameRenderer *renderer;
+    std::unique_ptr<Sprite> sprite;
+
     double x;
     double y;
     double angle;
@@ -15,9 +18,9 @@ private:
     static constexpr int speed = 5;
 
 public:
-	Arrow(double x, double y, double angle) : x(x), y(y), angle(angle) {}
+    Arrow(GameRenderer *renderer, double x, double y, double angle);
 
-	void draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const;
+    void draw(double offset_x, double offset_y) const;
 
     void update();
 };

src/Game.cpp

@@ -6,12 +6,6 @@
 
 using namespace std::literals::chrono_literals;
 
-Game::Game() : renderer("Zombo Shooter", 800, 450), player(&renderer), map(&renderer, 40)
-{
-	arrow_sprite = renderer.load_sprite("./assets/arrow.png", 22, 8);
-	zombo_sprite = renderer.load_sprite("./assets/zombo.png", 40, 40);
-}
-
 void Game::update(std::stop_token stop_token)
 {
     while (!stop_token.stop_requested()) {
@@ -30,7 +24,7 @@ void Game::update(std::stop_token stop_token)
         }
 
         if (ticks % 100 == 0 && zombos.size() < 20) {
-			zombos.emplace_back(&renderer, *zombo_sprite, player.x, player.y);
+            zombos.emplace_back(&renderer, 20.0, 20.0);
         }
 
         renderer.redraw();
@@ -52,11 +46,11 @@ void Game::draw()
     map.draw(player.x, player.y);
 
     for (const Zombo &zombo : zombos) {
-		zombo.draw(&renderer, *zombo_sprite, player.x, player.y);
+        zombo.draw(player.x, player.y);
     }
 
     for (const Arrow &arrow : arrows) {
-		arrow.draw(&renderer, *arrow_sprite, player.x, player.y);
+        arrow.draw(player.x, player.y);
     }
 
     player.draw();
@@ -115,7 +109,7 @@ void Game::run()
         }
 
         if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == 1) {
-			arrows.emplace_back(player.x, player.y, player.angle);
+            arrows.emplace_back(&renderer, player.x, player.y, player.angle);
         }
 
         int mouse_x, mouse_y;

src/Game.hpp

@@ -17,7 +17,6 @@ private:
     Map map;
     std::vector<Arrow> arrows;
     std::vector<Zombo> zombos;
-	std::unique_ptr<Sprite> arrow_sprite, zombo_sprite;
 
     std::mutex game_mutex;
     unsigned int ticks = 0;
@@ -25,7 +24,7 @@ private:
     void update(std::stop_token stop_token);
 
 public:
-	Game();
+    Game() : renderer("Zombo Shooter", 800, 450), player(&renderer), map(&renderer, 40) {}
 
     ~Game() = default;
 

src/GameRenderer.cpp

@@ -51,12 +51,6 @@ void GameRenderer::draw_sprite(const Sprite &sprite, const int x, const int y) c
 	SDL_RenderCopy(renderer, sprite.texture, nullptr, &rect);
 }
 
-void GameRenderer::draw_sprite_flipped(const Sprite &sprite, const int x, const int y) const
-{
-	const SDL_Rect rect = { .x = x, .y = y, .w = sprite.width, .h = sprite.height };
-	SDL_RenderCopyEx(renderer, sprite.texture, nullptr, &rect, 0, nullptr, SDL_FLIP_HORIZONTAL);
-}
-
 void GameRenderer::draw_sprite_rotated(const Sprite &sprite, const int x, const int y, const double angle) const
 {
 	const SDL_Rect rect = { .x = x, .y = y, .w = sprite.width, .h = sprite.height };

src/GameRenderer.hpp

@@ -26,8 +26,6 @@ public:
 
     void draw_sprite(const Sprite &sprite, int x, int y) const;
 
-	void draw_sprite_flipped(const Sprite &sprite, int x, int y) const;
-
     void draw_sprite_rotated(const Sprite &sprite, int x, int y, double angle) const;
 
     void clear_screen(uint8_t r, uint8_t g, uint8_t b, uint8_t a) const;

src/Sprite.cpp

@@ -1,6 +1,7 @@
 #include <SDL2/SDL_render.h>
 #include <SDL2/SDL_image.h>
 #include "Sprite.hpp"
+#include <iostream>
 
 Sprite::Sprite(SDL_Renderer *renderer, const std::string &file, int width, int height) : width(width), height(height)
 {

src/Zombo.cpp

@@ -1,19 +1,8 @@
 #include "Zombo.hpp"
 
-Zombo::Zombo(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y)
+Zombo::Zombo(GameRenderer *renderer, const double x, const double y) : renderer(renderer), x(x), y(y)
 {
-	if (rand() % 2 == 0) {
+    sprite = renderer->load_sprite("./assets/zombo.png", 40, 40);
-		x = rand() % renderer->screen_width - renderer->screen_width / 2;
-		y = renderer->screen_height / 2 + sprite.height;
-		if (rand() % 2 == 0) y = -y;
-	} else {
-		x = renderer->screen_width / 2 + sprite.width;
-		y = rand() % renderer->screen_height - renderer->screen_height / 2;
-		if (rand() % 2 == 0) x = -x;
-	}
-
-	x += player_x;
-	y += player_y;
 }
 
 void Zombo::update(const double player_x, const double player_y)
@@ -24,13 +13,11 @@ void Zombo::update(const double player_x, const double player_y)
     y += std::sin(angle) * speed;
 }
 
-void Zombo::draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const
+void Zombo::draw(const double player_x, const double player_y) const
 {
-	int draw_x = (int)(x - sprite.width / 2 + renderer->screen_width / 2 - player_x);
+    renderer->draw_sprite(
-	int draw_y = (int)(y - sprite.height / 2 + renderer->screen_height / 2 - player_y);
+        *sprite,
-
+        (int)(x - sprite->width / 2.0 + renderer->screen_width / 2.0 - player_x),
-	if (x < player_x)
+        (int)(y - sprite->height / 2.0 + renderer->screen_height / 2.0 - player_y)
-		renderer->draw_sprite(sprite, draw_x, draw_y);
+    );
-	else
-		renderer->draw_sprite_flipped(sprite, draw_x, draw_y);
 }

src/Zombo.hpp

@@ -1,23 +1,27 @@
 #ifndef ZOMBO_HPP
 #define ZOMBO_HPP
 
+#include <memory>
 #include "Sprite.hpp"
 #include "GameRenderer.hpp"
 
 class Zombo
 {
 private:
+    GameRenderer *renderer;
+    std::unique_ptr<Sprite> sprite;
+
     double x;
     double y;
 
     static constexpr double speed = 0.5;
 
 public:
-	Zombo(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y);
+    Zombo(GameRenderer *renderer, double x, double y);
 
     void update(double player_x, double player_y);
 
-	void draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const;
+    void draw(double player_x, double player_y) const;
 };
 
 #endif