Spawn zombos outside of game screen

src/Arrow.cpp

@@ -1,26 +1,19 @@
 #include <cmath>
 #include <numbers>
-#include <memory>
 #include "Arrow.hpp"
 
-Arrow::Arrow(GameRenderer *renderer, const double x, const double y, const double angle)
-    : renderer(renderer), x(x), y(y), angle(angle)
+void Arrow::draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const
 {
-    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,
-        (int)(x - sprite->width / 2 + renderer->screen_width / 2 - player_x),
-        (int)(y - sprite->height / 2 + renderer->screen_height / 2 - player_y),
-        angle * 180 / std::numbers::pi
-    );
+	renderer->draw_sprite_rotated(
+		sprite,
+		(int)(x - sprite.width / 2 + renderer->screen_width / 2 - player_x),
+		(int)(y - sprite.height / 2 + renderer->screen_height / 2 - player_y),
+		angle * 180 / std::numbers::pi
+	);
 }
 
 void Arrow::update()
 {
-    x += std::cos(angle) * speed;
-    y += std::sin(angle) * speed;
+	x += std::cos(angle) * speed;
+	y += std::sin(angle) * speed;
 }

src/Arrow.hpp

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

src/Game.cpp

@@ -6,116 +6,122 @@
 
 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()) {
-        game_mutex.lock();
+	while (!stop_token.stop_requested()) {
+		game_mutex.lock();
 
-        ticks++;
+		ticks++;
 
-        player.update();
+		player.update();
 
-        for (Arrow &arrow : arrows) {
-            arrow.update();
-        }
+		for (Arrow &arrow : arrows) {
+			arrow.update();
+		}
 
-        for (Zombo &zombo : zombos) {
-            zombo.update(player.x, player.y);
-        }
+		for (Zombo &zombo : zombos) {
+			zombo.update(player.x, player.y);
+		}
 
-        if (ticks % 100 == 0 && zombos.size() < 20) {
-            zombos.emplace_back(&renderer, 20.0, 20.0);
-        }
+		if (ticks % 100 == 0 && zombos.size() < 20) {
+			zombos.emplace_back(&renderer, *zombo_sprite, player.x, player.y);
+		}
 
-        renderer.redraw();
+		renderer.redraw();
 
-        map.check_bounds(player.x, player.y);
+		map.check_bounds(player.x, player.y);
 
-        game_mutex.unlock();
+		game_mutex.unlock();
 
-        std::this_thread::sleep_for(16666us);
-    }
+		std::this_thread::sleep_for(16666us);
+	}
 }
 
 void Game::draw()
 {
-    const std::lock_guard lock(game_mutex);
+	const std::lock_guard lock(game_mutex);
 
-    renderer.clear_screen(0x80, 0x40, 0xFF, 0xFF);
+	renderer.clear_screen(0x80, 0x40, 0xFF, 0xFF);
 
-    map.draw(player.x, player.y);
+	map.draw(player.x, player.y);
 
-    for (const Zombo &zombo : zombos) {
-        zombo.draw(player.x, player.y);
-    }
+	for (const Zombo &zombo : zombos) {
+		zombo.draw(&renderer, *zombo_sprite, player.x, player.y);
+	}
 
-    for (const Arrow &arrow : arrows) {
-        arrow.draw(player.x, player.y);
-    }
+	for (const Arrow &arrow : arrows) {
+		arrow.draw(&renderer, *arrow_sprite, player.x, player.y);
+	}
 
-    player.draw();
+	player.draw();
 
-    renderer.flush();
+	renderer.flush();
 }
 
 void Game::run()
 {
-    std::jthread update_thread = std::jthread(std::bind_front(&Game::update, this));
+	std::jthread update_thread = std::jthread(std::bind_front(&Game::update, this));
 
-    while (true) {
-        SDL_Event e;
-        SDL_WaitEvent(&e);
+	while (true) {
+		SDL_Event e;
+		SDL_WaitEvent(&e);
 
-        if (e.type == SDL_QUIT) {
-            break;
-        }
+		if (e.type == SDL_QUIT) {
+			break;
+		}
 
-        if (e.type == SDL_KEYDOWN) {
-            switch (e.key.keysym.sym) {
-                case SDLK_RIGHT:
-                case SDLK_d:
-                    player.x_vel = player.speed;
-                    break;
-                case SDLK_LEFT:
-                case SDLK_a:
-                    player.x_vel = -player.speed;
-                    break;
-                case SDLK_DOWN:
-                case SDLK_s:
-                    player.y_vel = player.speed;
-                    break;
-                case SDLK_UP:
-                case SDLK_w:
-                    player.y_vel = -player.speed;
-                    break;
-            }
-        }
+		if (e.type == SDL_KEYDOWN) {
+			switch (e.key.keysym.sym) {
+				case SDLK_RIGHT:
+				case SDLK_d:
+					player.x_vel = player.speed;
+					break;
+				case SDLK_LEFT:
+				case SDLK_a:
+					player.x_vel = -player.speed;
+					break;
+				case SDLK_DOWN:
+				case SDLK_s:
+					player.y_vel = player.speed;
+					break;
+				case SDLK_UP:
+				case SDLK_w:
+					player.y_vel = -player.speed;
+					break;
+			}
+		}
 
-        if (e.type == SDL_KEYUP) {
-            switch (e.key.keysym.sym) {
-                case SDLK_RIGHT:
-                case SDLK_d:
-                case SDLK_LEFT:
-                case SDLK_a:
-                    player.x_vel = 0;
-                    break;
-                case SDLK_DOWN:
-                case SDLK_s:
-                case SDLK_UP:
-                case SDLK_w:
-                    player.y_vel = 0;
-                    break;
-            }
-        }
+		if (e.type == SDL_KEYUP) {
+			switch (e.key.keysym.sym) {
+				case SDLK_RIGHT:
+				case SDLK_d:
+				case SDLK_LEFT:
+				case SDLK_a:
+					player.x_vel = 0;
+					break;
+				case SDLK_DOWN:
+				case SDLK_s:
+				case SDLK_UP:
+				case SDLK_w:
+					player.y_vel = 0;
+					break;
+			}
+		}
 
-        if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == 1) {
-            arrows.emplace_back(&renderer, player.x, player.y, player.angle);
-        }
+		if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == 1) {
+			arrows.emplace_back(player.x, player.y, player.angle);
+		}
 
-        int mouse_x, mouse_y;
-        SDL_GetMouseState(&mouse_x, &mouse_y);
-        player.angle = std::atan2(mouse_y - renderer.screen_height / 2, mouse_x - renderer.screen_width / 2);
+		int mouse_x, mouse_y;
+		SDL_GetMouseState(&mouse_x, &mouse_y);
+		player.angle = std::atan2(mouse_y - renderer.screen_height / 2, mouse_x - renderer.screen_width / 2);
 
-        draw();
-    }
+		draw();
+	}
 }

src/Game.hpp

@@ -12,25 +12,26 @@
 class Game
 {
 private:
-    GameRenderer renderer;
-    Player player;
-    Map map;
-    std::vector<Arrow> arrows;
-    std::vector<Zombo> zombos;
+	GameRenderer renderer;
+	Player player;
+	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;
+	std::mutex game_mutex;
+	unsigned int ticks = 0;
 
-    void update(std::stop_token stop_token);
+	void update(std::stop_token stop_token);
 
 public:
-    Game() : renderer("Zombo Shooter", 800, 450), player(&renderer), map(&renderer, 40) {}
+	Game();
 
-    ~Game() = default;
+	~Game() = default;
 
-    void run();
+	void run();
 
-    void draw();
+	void draw();
 };
 
 #endif

src/GameRenderer.cpp

@@ -51,6 +51,12 @@ 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

@@ -9,30 +9,32 @@
 class GameRenderer
 {
 private:
-    SDL_Renderer *renderer;
-    SDL_Window *window;
+	SDL_Renderer *renderer;
+	SDL_Window *window;
 
-    std::string title;
+	std::string title;
 
 public:
-    int screen_width;
-    int screen_height;
+	int screen_width;
+	int screen_height;
 
-    GameRenderer(const std::string &title, int screen_width, int screen_height);
+	GameRenderer(const std::string &title, int screen_width, int screen_height);
 
-    ~GameRenderer();
+	~GameRenderer();
 
-    std::unique_ptr<Sprite> load_sprite(const std::string &file, int width, int height) const;
+	std::unique_ptr<Sprite> load_sprite(const std::string &file, int width, int height) const;
 
-    void draw_sprite(const Sprite &sprite, int x, int y) const;
+	void draw_sprite(const Sprite &sprite, int x, int y) const;
 
-    void draw_sprite_rotated(const Sprite &sprite, int x, int y, double angle) const;
+	void draw_sprite_flipped(const Sprite &sprite, int x, int y) const;
 
-    void clear_screen(uint8_t r, uint8_t g, uint8_t b, uint8_t a) const;
+	void draw_sprite_rotated(const Sprite &sprite, int x, int y, double angle) const;
 
-    void flush() const;
+	void clear_screen(uint8_t r, uint8_t g, uint8_t b, uint8_t a) const;
 
-    void redraw() const;
+	void flush() const;
+
+	void redraw() const;
 };
 
-#endif
+#endif

src/Map.cpp

@@ -2,110 +2,110 @@
 #include "Map.hpp"
 
 Map::Map(GameRenderer *renderer, int tile_size) :
-    renderer(renderer),
-    tile_size(tile_size),
-    tiles(renderer->screen_width / tile_size, std::vector(renderer->screen_height / tile_size, Tile::grass)),
-    tile_offset_x(-renderer->screen_width / tile_size / 2.0),
-    tile_offset_y(-renderer->screen_height / tile_size / 2.0)
+	renderer(renderer),
+	tile_size(tile_size),
+	tiles(renderer->screen_width / tile_size, std::vector(renderer->screen_height / tile_size, Tile::grass)),
+	tile_offset_x(-renderer->screen_width / tile_size / 2.0),
+	tile_offset_y(-renderer->screen_height / tile_size / 2.0)
 {
-    grass_sprite = renderer->load_sprite("./assets/grass_tile.png", tile_size, tile_size);
-    path_sprite = renderer->load_sprite("./assets/path_tile.png", tile_size, tile_size);
+	grass_sprite = renderer->load_sprite("./assets/grass_tile.png", tile_size, tile_size);
+	path_sprite = renderer->load_sprite("./assets/path_tile.png", tile_size, tile_size);
 
-    // Create horizontal starting path
-    int y = renderer->screen_height / tile_size / 2;
-    for (unsigned int x = 0; x < tiles.size(); x++) {
-        if (rand() % 2 == 0) y += rand() % 3 - 1;
+	// Create horizontal starting path
+	int y = renderer->screen_height / tile_size / 2;
+	for (unsigned int x = 0; x < tiles.size(); x++) {
+		if (rand() % 2 == 0) y += rand() % 3 - 1;
 
-        tiles[x][y] = Tile::path;
-    }
+		tiles[x][y] = Tile::path;
+	}
 
-    // Create vertical starting path
-    int x = renderer->screen_width / tile_size / 2;
-    for (unsigned int y = 0; y < tiles[x].size(); y++) {
-        if (rand() % 2 == 0) x += rand() % 3 - 1;
+	// Create vertical starting path
+	int x = renderer->screen_width / tile_size / 2;
+	for (unsigned int y = 0; y < tiles[x].size(); y++) {
+		if (rand() % 2 == 0) x += rand() % 3 - 1;
 
-        tiles[x][y] = Tile::path;
-    }
+		tiles[x][y] = Tile::path;
+	}
 }
 
 std::vector<Tile> Map::generate_tiles(const std::vector<Tile> &prev_tiles) const
 {
-    std::vector<Tile> new_tiles = std::vector(prev_tiles.size(), Tile::grass);
+	std::vector<Tile> new_tiles = std::vector(prev_tiles.size(), Tile::grass);
 
-    int path_idx = 0;
-    for (unsigned int i = 0; i < prev_tiles.size(); i++) {
-        if (prev_tiles[i] == Tile::path) path_idx = i;
-    }
+	int path_idx = 0;
+	for (unsigned int i = 0; i < prev_tiles.size(); i++) {
+		if (prev_tiles[i] == Tile::path) path_idx = i;
+	}
 
-    if (rand() % 2 == 0) path_idx += rand() % 3 - 1;
+	if (rand() % 2 == 0) path_idx += rand() % 3 - 1;
 
-    new_tiles[path_idx] = Tile::path;
+	new_tiles[path_idx] = Tile::path;
 
-    return new_tiles;
+	return new_tiles;
 }
 
 void Map::check_bounds(const double player_x, const double player_y)
 {
-    // Generate to the left
-    if (tile_offset_x * tile_size + renderer->screen_width > player_x) {
-        const std::vector<Tile> new_tiles = generate_tiles(tiles[0]);
-        tiles.insert(tiles.begin(), new_tiles);
-        tile_offset_x--;
-    }
+	// Generate to the left
+	if (tile_offset_x * tile_size + renderer->screen_width > player_x) {
+		const std::vector<Tile> new_tiles = generate_tiles(tiles[0]);
+		tiles.insert(tiles.begin(), new_tiles);
+		tile_offset_x--;
+	}
 
-    // Generate upwards
-    if (tile_offset_y * tile_size + renderer->screen_height > player_y) {
-        std::vector<Tile> prev_tiles;
-        for (unsigned int x = 0; x < tiles.size(); x++) {
-            prev_tiles.push_back(tiles[x][0]);
-        }
+	// Generate upwards
+	if (tile_offset_y * tile_size + renderer->screen_height > player_y) {
+		std::vector<Tile> prev_tiles;
+		for (unsigned int x = 0; x < tiles.size(); x++) {
+			prev_tiles.push_back(tiles[x][0]);
+		}
 
-        const std::vector<Tile> new_tiles = generate_tiles(prev_tiles);
-        for (unsigned int x = 0; x < tiles.size(); x++) {
-            tiles[x].insert(tiles[x].begin(), new_tiles[x]);
-        }
+		const std::vector<Tile> new_tiles = generate_tiles(prev_tiles);
+		for (unsigned int x = 0; x < tiles.size(); x++) {
+			tiles[x].insert(tiles[x].begin(), new_tiles[x]);
+		}
 
-        tile_offset_y--;
-    }
+		tile_offset_y--;
+	}
 
-    // Generate to the right
-    if (player_x > tile_offset_x * tile_size + (double)tiles.size() * tile_size - renderer->screen_width / 2) {
-        const std::vector<Tile> new_tiles = generate_tiles(tiles.back());
-        tiles.push_back(new_tiles);
-    }
+	// Generate to the right
+	if (player_x > tile_offset_x * tile_size + (double)tiles.size() * tile_size - renderer->screen_width / 2) {
+		const std::vector<Tile> new_tiles = generate_tiles(tiles.back());
+		tiles.push_back(new_tiles);
+	}
 
-    // Generate downwards
-    if (player_y > tile_offset_y * tile_size + (double)tiles[0].size() * tile_size - renderer->screen_height / 2) {
-        std::vector<Tile> prev_tiles;
-        for (unsigned int x = 0; x < tiles.size(); x++) {
-            prev_tiles.push_back(tiles[x].back());
-        }
+	// Generate downwards
+	if (player_y > tile_offset_y * tile_size + (double)tiles[0].size() * tile_size - renderer->screen_height / 2) {
+		std::vector<Tile> prev_tiles;
+		for (unsigned int x = 0; x < tiles.size(); x++) {
+			prev_tiles.push_back(tiles[x].back());
+		}
 
-        const std::vector<Tile> new_tiles = generate_tiles(prev_tiles);
-        for (unsigned int x = 0; x < tiles.size(); x++) {
-            tiles[x].push_back(new_tiles[x]);
-        }
-    }
+		const std::vector<Tile> new_tiles = generate_tiles(prev_tiles);
+		for (unsigned int x = 0; x < tiles.size(); x++) {
+			tiles[x].push_back(new_tiles[x]);
+		}
+	}
 }
 
 void Map::draw(const double player_x, const double player_y) const
 {
-    for (unsigned int tile_x = 0; tile_x < tiles.size(); tile_x++) {
-        for (unsigned int tile_y = 0; tile_y < tiles[tile_x].size(); tile_y++) {
-            int screen_x = (int)(tile_x * tile_size + tile_offset_x * tile_size + renderer->screen_width / 2.0 - player_x);
-            int screen_y = (int)(tile_y * tile_size + tile_offset_y * tile_size + renderer->screen_height / 2.0 - player_y);
+	for (unsigned int tile_x = 0; tile_x < tiles.size(); tile_x++) {
+		for (unsigned int tile_y = 0; tile_y < tiles[tile_x].size(); tile_y++) {
+			int screen_x = (int)(tile_x * tile_size + tile_offset_x * tile_size + renderer->screen_width / 2.0 - player_x);
+			int screen_y = (int)(tile_y * tile_size + tile_offset_y * tile_size + renderer->screen_height / 2.0 - player_y);
 
-            if (
-                screen_x < -tile_size || screen_y < -tile_size ||
-                screen_x > renderer->screen_width || screen_y > renderer->screen_height
-            ) {
-                continue;
-            }
+			if (
+				screen_x < -tile_size || screen_y < -tile_size ||
+				screen_x > renderer->screen_width || screen_y > renderer->screen_height
+			) {
+				continue;
+			}
 
-            switch (tiles[tile_x][tile_y]) {
-                case Tile::grass: renderer->draw_sprite(*grass_sprite, screen_x, screen_y); break;
-                case Tile::path:  renderer->draw_sprite(*path_sprite,  screen_x, screen_y); break;
-            }
-        }
-    }
+			switch (tiles[tile_x][tile_y]) {
+				case Tile::grass: renderer->draw_sprite(*grass_sprite, screen_x, screen_y); break;
+				case Tile::path:  renderer->draw_sprite(*path_sprite,  screen_x, screen_y); break;
+			}
+		}
+	}
 }

src/Map.hpp

@@ -10,25 +10,25 @@
 class Map
 {
 private:
-    GameRenderer *renderer;
-    std::vector<std::vector<Tile>> tiles;
+	GameRenderer *renderer;
+	std::vector<std::vector<Tile>> tiles;
 
-    std::unique_ptr<Sprite> grass_sprite, path_sprite;
+	std::unique_ptr<Sprite> grass_sprite, path_sprite;
 
-    [[nodiscard]] std::vector<Tile> generate_tiles(const std::vector<Tile> &prev_tiles) const;
+	[[nodiscard]] std::vector<Tile> generate_tiles(const std::vector<Tile> &prev_tiles) const;
 
 public:
-    double tile_offset_x;
-    double tile_offset_y;
-    int tile_size;
+	double tile_offset_x;
+	double tile_offset_y;
+	int tile_size;
 
-    Map(GameRenderer *renderer, int tile_size);
+	Map(GameRenderer *renderer, int tile_size);
 
-    ~Map() = default;
+	~Map() = default;
 
-    void draw(double player_x, double player_y) const;
+	void draw(double player_x, double player_y) const;
 
-    void check_bounds(double player_x, double player_y);
+	void check_bounds(double player_x, double player_y);
 };
 
 #endif

src/Player.cpp

@@ -4,28 +4,28 @@
 
 Player::Player(GameRenderer *renderer) : renderer(renderer)
 {
-    hero_sprite = renderer->load_sprite("./assets/hero_front.png", 40, 40);
-    bow_sprite = renderer->load_sprite("./assets/bow_arrow.png", 22, 32);
+	hero_sprite = renderer->load_sprite("./assets/hero_front.png", 40, 40);
+	bow_sprite = renderer->load_sprite("./assets/bow_arrow.png", 22, 32);
 }
 
 void Player::draw() const
 {
-    renderer->draw_sprite(
-        *hero_sprite,
-        renderer->screen_width / 2 - hero_sprite->width / 2,
-        renderer->screen_height / 2 - hero_sprite->height / 2
-    );
+	renderer->draw_sprite(
+		*hero_sprite,
+		renderer->screen_width / 2 - hero_sprite->width / 2,
+		renderer->screen_height / 2 - hero_sprite->height / 2
+	);
 
-    renderer->draw_sprite_rotated(
-        *bow_sprite,
-        (int)(renderer->screen_width / 2 - bow_sprite->width / 2 + std::cos(angle) * 30),
-        (int)(renderer->screen_height / 2 - bow_sprite->height / 2 + std::sin(angle) * 30),
-        angle * 180 / std::numbers::pi
-    );
+	renderer->draw_sprite_rotated(
+		*bow_sprite,
+		(int)(renderer->screen_width / 2 - bow_sprite->width / 2 + std::cos(angle) * 30),
+		(int)(renderer->screen_height / 2 - bow_sprite->height / 2 + std::sin(angle) * 30),
+		angle * 180 / std::numbers::pi
+	);
 }
 
 void Player::update()
 {
-    x += x_vel;
-    y += y_vel;
+	x += x_vel;
+	y += y_vel;
 }

src/Player.hpp

@@ -7,27 +7,27 @@
 class Player
 {
 private:
-    GameRenderer *renderer;
-    std::unique_ptr<Sprite> hero_sprite, bow_sprite;
+	GameRenderer *renderer;
+	std::unique_ptr<Sprite> hero_sprite, bow_sprite;
 
 public:
-    double x = 0;
-    double y = 0;
+	double x = 0;
+	double y = 0;
 
-    double x_vel = 0;
-    double y_vel = 0;
+	double x_vel = 0;
+	double y_vel = 0;
 
-    double angle = 0.0;
+	double angle = 0.0;
 
-    static constexpr double speed = 1.5;
+	static constexpr double speed = 1.5;
 
-    Player(GameRenderer *renderer);
+	Player(GameRenderer *renderer);
 
-    ~Player() = default;
+	~Player() = default;
 
-    void draw() const;
+	void draw() const;
 
-    void update();
+	void update();
 };
 
-#endif
+#endif

src/Sprite.cpp

@@ -1,14 +1,13 @@
 #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)
 {
-    texture = IMG_LoadTexture(renderer, file.c_str());
+	texture = IMG_LoadTexture(renderer, file.c_str());
 }
 
 Sprite::~Sprite()
 {
-    SDL_DestroyTexture(texture);
+	SDL_DestroyTexture(texture);
 }

src/Sprite.hpp

@@ -6,18 +6,18 @@
 
 class Sprite {
 public:
-    SDL_Texture *texture;
-    int width;
-    int height;
+	SDL_Texture *texture;
+	int width;
+	int height;
 
-    Sprite(SDL_Renderer *renderer, const std::string &file, int width, int height);
+	Sprite(SDL_Renderer *renderer, const std::string &file, int width, int height);
 
-    ~Sprite();
+	~Sprite();
 
-    Sprite(const Sprite&) = delete;
-    Sprite operator=(const Sprite&) = delete;
-    Sprite(Sprite&&) = delete;
-    Sprite operator=(Sprite&&) = delete;
+	Sprite(const Sprite&) = delete;
+	Sprite operator=(const Sprite&) = delete;
+	Sprite(Sprite&&) = delete;
+	Sprite operator=(Sprite&&) = delete;
 };
 
 #endif

src/Tile.hpp

@@ -3,8 +3,8 @@
 
 enum class Tile
 {
-    grass,
-    path,
+	grass,
+	path,
 };
 
-#endif
+#endif

src/Zombo.cpp

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

src/Zombo.hpp

@@ -1,27 +1,23 @@
 #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;
 
-    double x;
-    double y;
-
-    static constexpr double speed = 0.5;
+	static constexpr double speed = 0.5;
 
 public:
-    Zombo(GameRenderer *renderer, double x, double y);
+	Zombo(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y);
 
-    void update(double player_x, double player_y);
+	void update(double player_x, double player_y);
 
-    void draw(double player_x, double player_y) const;
+	void draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const;
 };
 
 #endif