Makefile

@@ -2,7 +2,6 @@ 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,51 +1,31 @@
 #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()
+void Game::draw() const
 {
-    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();
@@ -101,10 +81,6 @@ 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,8 +2,6 @@
 #define GAME_HPP
 
 #include <thread>
-#include <vector>
-#include "Arrow.hpp"
 #include "GameRenderer.hpp"
 #include "Player.hpp"
 #include "Map.hpp"
@@ -14,21 +12,19 @@ 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();
+    ~Game() = default;
 
     void run();
 
-    void draw();
+    void draw() const;
 };
 
 #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.0),
-    tile_offset_y(-renderer->screen_height / tile_size / 2.0)
+    tile_offset_x(-renderer->screen_width / tile_size / 2),
+    tile_offset_y(-renderer->screen_height / tile_size / 2)
 {
     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 > tile_offset_x * tile_size + tiles.size() * tile_size - renderer->screen_width / 2) {
+    if (player_x > (int)(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 > tile_offset_y * tile_size + tiles[0].size() * tile_size - renderer->screen_height / 2) {
+    if (player_y > (int)(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 = (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);
+            int screen_x = tile_x * tile_size + tile_offset_x * tile_size + renderer->screen_width / 2 - (int)player_x;
+            int screen_y = tile_y * tile_size + tile_offset_y * tile_size + renderer->screen_height / 2 - (int)player_y;
 
             if (
                 screen_x < -tile_size || screen_y < -tile_size ||

src/Map.hpp

@@ -10,7 +10,10 @@ 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;
@@ -18,10 +21,6 @@ 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;