Implement shooting arrows

Makefile

@@ -2,6 +2,7 @@ OBJS= \
 	build/src/main.o \
 	build/src/Map.o \
 	build/src/Game.o \
+	build/src/Arrow.o \
 	build/src/Player.o \
 	build/src/GameRenderer.o
 

src/Game.cpp

@@ -1,31 +1,51 @@
 #include <thread>
 #include <functional>
-#include <iostream>
 #include "GameRenderer.hpp"
 #include "Player.hpp"
 #include "Game.hpp"
 
 using namespace std::literals::chrono_literals;
 
+Game::~Game()
+{
+    for (const Arrow *arrow : arrows) {
+        delete arrow;
+    }
+}
+
 void Game::update(std::stop_token stop_token)
 {
     while (!stop_token.stop_requested()) {
+        game_mutex.lock();
+
         player.update();
 
+        for (Arrow *arrow : arrows) {
+            arrow->update();
+        }
+
         renderer.redraw();
 
         map.check_bounds(player.x, player.y);
 
+        game_mutex.unlock();
+
         std::this_thread::sleep_for(16666us);
     }
 }
 
-void Game::draw() const
+void Game::draw()
 {
+    const std::lock_guard lock(game_mutex);
+
     renderer.clear_screen(0x80, 0x40, 0xFF, 0xFF);
 
     map.draw(player.x, player.y);
 
+    for (const Arrow *arrow : arrows) {
+        arrow->draw(player.x, player.y);
+    }
+
     player.draw();
 
     renderer.flush();
@@ -81,6 +101,10 @@ void Game::run()
             }
         }
 
+        if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == 1) {
+            arrows.push_back(new Arrow(&renderer, 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);

src/Game.hpp

@@ -2,6 +2,8 @@
 #define GAME_HPP
 
 #include <thread>
+#include <vector>
+#include "Arrow.hpp"
 #include "GameRenderer.hpp"
 #include "Player.hpp"
 #include "Map.hpp"
@@ -12,19 +14,21 @@ private:
     GameRenderer renderer;
     Player player;
     Map map;
+    std::vector<Arrow*> arrows;
 
     std::jthread update_thread;
+    std::mutex game_mutex;
 
     void update(std::stop_token stop_token);
 
 public:
     Game() : renderer("Zombo Shooter", 800, 450), player(&renderer), map(&renderer, 40) {}
 
-    ~Game() = default;
+    ~Game();
 
     void run();
 
-    void draw() const;
+    void draw();
 };
 
 #endif

src/Map.cpp

@@ -5,8 +5,8 @@ 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),
+    tile_offset_x(-renderer->screen_width / tile_size / 2.0),
-    tile_offset_y(-renderer->screen_height / tile_size / 2)
+    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);
@@ -69,13 +69,13 @@ void Map::check_bounds(const double player_x, const double player_y)
     }
 
     // Generate to the right
-    if (player_x > (int)(tile_offset_x * tile_size + tiles.size() * tile_size - renderer->screen_width / 2)) {
+    if (player_x > tile_offset_x * tile_size + 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 > (int)(tile_offset_y * tile_size + tiles[0].size() * tile_size - renderer->screen_height / 2)) {
+    if (player_y > tile_offset_y * tile_size + 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());
@@ -92,8 +92,8 @@ 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 = tile_x * tile_size + tile_offset_x * tile_size + renderer->screen_width / 2 - (int)player_x;
+            int screen_x = (int)(tile_x * tile_size + tile_offset_x * tile_size + renderer->screen_width / 2.0 - player_x);
-            int screen_y = tile_y * tile_size + tile_offset_y * tile_size + renderer->screen_height / 2 - (int)player_y;
+            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 ||

src/Map.hpp

@@ -10,10 +10,7 @@ class Map
 {
 private:
     GameRenderer *renderer;
-    int tile_size;
     std::vector<std::vector<Tile>> tiles;
-    int tile_offset_x;
-    int tile_offset_y;
 
     Sprite grass_sprite;
     Sprite path_sprite;
@@ -21,6 +18,10 @@ private:
     [[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;
+
     Map(GameRenderer *renderer, int tile_size);
 
     void draw(double player_x, double player_y) const;