Implement tile generation

src/Game.cpp

@@ -20,6 +20,8 @@ void Game::update()
 
         renderer.redraw();
 
+        map.check_bounds(player.x, player.y);
+
         std::this_thread::sleep_for(16666us);
     }
 }

src/Map.cpp

@@ -10,16 +10,66 @@ 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);
+
+    int y = renderer->screen_height / tile_size / 2;
+    for (int x = 0; x < tiles.size(); x++) {
+        if (rand() % 2 == 0) y += rand() % 3 - 1;
+
+        tiles[x][y] = 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;
+
+        tiles[x][y] = path;
+    }
 }
 
-void Map::generate_row() const
+std::vector<Tile> Map::generate_tiles(std::vector<Tile> prev_tiles) const
 {
+    std::vector<Tile> new_tiles;
 
+    for (int i = 0; i < prev_tiles.size(); i++) {
+        Tile new_tile = grass;
+
+        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);
+    }
+
+    return new_tiles;
 }
 
-void Map::generate_col() const
+void Map::check_bounds(int player_x, int player_y)
 {
+    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--;
+    }
 
+    if (tile_offset_y * tile_size + renderer->screen_height > player_y) {
+        std::vector<Tile> prev_tiles;
+        for (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 (int x = 0; x < tiles.size(); x++) {
+            tiles[x].insert(tiles[x].begin(), new_tiles[x]);
+        }
+
+        tile_offset_y--;
+    }
 }
 
 void Map::draw(int player_x, int player_y) const

src/Map.hpp

@@ -18,14 +18,14 @@ private:
     Sprite grass_sprite;
     Sprite path_sprite;
 
-    void generate_row() const;
-
-    void generate_col() const;
+    std::vector<Tile> generate_tiles(std::vector<Tile> prev_tiles) const;
 
 public:
     Map(GameRenderer *renderer, int tile_size);
 
     void draw(int player_x, int player_y) const;
+
+    void check_bounds(int player_x, int player_y);
 };
 
 #endif

src/Player.hpp

@@ -16,7 +16,7 @@ public:
     double x_vel = 0;
     double y_vel = 0;
 
-    const double speed = 0.9;
+    const double speed = 1.5;
 
     Player(GameRenderer *renderer);
 

src/main.cpp

@@ -1,7 +1,10 @@
+#include <ctime>
 #include "Game.hpp"
 
 int main()
 {
+	srand(time(nullptr));
+
 	Game game = Game();
 
 	game.run();