Add bow

src/Game.cpp

@@ -87,6 +87,10 @@ void Game::run()
             }
         }
 
+        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();
     }
 }

src/GameRenderer.cpp

@@ -54,6 +54,12 @@ void GameRenderer::draw_sprite(const Sprite sprite, const int x, const int y) co
 	SDL_RenderCopy(renderer, sprite.texture, nullptr, &rect);
 }
 
+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 };
+	SDL_RenderCopyEx(renderer, sprite.texture, nullptr, &rect, angle, nullptr, SDL_FLIP_NONE);
+}
+
 void GameRenderer::clear_screen(const int r, const int g, const int b, const int a) const
 {
 	SDL_SetRenderDrawColor(renderer, r, g, b, a);

src/GameRenderer.hpp

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

src/Map.cpp

@@ -11,6 +11,7 @@ Map::Map(GameRenderer *renderer, int 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 (int x = 0; x < tiles.size(); x++) {
         if (rand() % 2 == 0) y += rand() % 3 - 1;
@@ -18,6 +19,7 @@ Map::Map(GameRenderer *renderer, int tile_size) :
         tiles[x][y] = path;
     }
 
+    // Create vertical starting path
     int x = renderer->screen_width / tile_size / 2;
     for (int y = 0; y < tiles[x].size(); y++) {
         if (rand() % 2 == 0) x += rand() % 3 - 1;
@@ -28,35 +30,30 @@ Map::Map(GameRenderer *renderer, int tile_size) :
 
 std::vector<Tile> Map::generate_tiles(std::vector<Tile> prev_tiles) const
 {
-    std::vector<Tile> new_tiles;
+    std::vector<Tile> new_tiles = std::vector(prev_tiles.size(), grass);
 
+    int path_idx = 0;
     for (int i = 0; i < prev_tiles.size(); i++) {
-        Tile new_tile = grass;
+        if (prev_tiles[i] == path) path_idx = i;
-
-        if (
-            (i > 0 && prev_tiles[i-1] == path) ||
-            prev_tiles[i] == path ||
-            (i < prev_tiles.size() - 1 && prev_tiles[i+1]) == path
-        ) {
-            if (rand() % 2 == 0) {
-                new_tile = path;
-            }
-        }
-
-        new_tiles.push_back(new_tile);
     }
 
+    if (rand() % 2 == 0) path_idx += rand() % 3 - 1;
+
+    new_tiles[path_idx] = path;
+
     return new_tiles;
 }
 
 void Map::check_bounds(int player_x, int 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 upwards
     if (tile_offset_y * tile_size + renderer->screen_height > player_y) {
         std::vector<Tile> prev_tiles;
         for (int x = 0; x < tiles.size(); x++) {
@@ -70,6 +67,25 @@ void Map::check_bounds(int player_x, int player_y)
 
         tile_offset_y--;
     }
+
+    // Generate to the right
+    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 > (int)(tile_offset_y * tile_size + tiles[0].size() * tile_size - renderer->screen_height / 2)) {
+        std::vector<Tile> prev_tiles;
+        for (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 (int x = 0; x < tiles.size(); x++) {
+            tiles[x].push_back(new_tiles[x]);
+        }
+    }
 }
 
 void Map::draw(int player_x, int player_y) const

src/Player.cpp

@@ -4,6 +4,7 @@
 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);
 }
 
 void Player::draw() const
@@ -13,6 +14,13 @@ void Player::draw() const
         renderer->screen_width / 2 - hero_sprite.width / 2,
         renderer->screen_height / 2 - hero_sprite.height / 2
     );
+
+    renderer->draw_sprite_rotated(
+        bow_sprite,
+        renderer->screen_width / 2 - bow_sprite.width / 2 + std::cos(angle) * 30,
+        renderer->screen_height / 2 - bow_sprite.height / 2 + std::sin(angle) * 30,
+        angle * 180 / M_PI
+    );
 }
 
 void Player::update()

src/Player.hpp

@@ -7,7 +7,7 @@ class Player
 {
 private:
     GameRenderer *renderer;
-    Sprite hero_sprite;
+    Sprite hero_sprite, bow_sprite;
 
 public:
     double x = 0;
@@ -16,6 +16,8 @@ public:
     double x_vel = 0;
     double y_vel = 0;
 
+    double angle = 0.0;
+
     const double speed = 1.5;
 
     Player(GameRenderer *renderer);