112 lines
3.9 KiB
C++
112 lines
3.9 KiB
C++
#include <vector>
|
|
#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)
|
|
{
|
|
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;
|
|
|
|
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;
|
|
|
|
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);
|
|
|
|
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;
|
|
|
|
new_tiles[path_idx] = Tile::path;
|
|
|
|
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 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]);
|
|
}
|
|
|
|
tile_offset_y--;
|
|
}
|
|
|
|
// Generate to the right
|
|
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 > 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());
|
|
}
|
|
|
|
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);
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
}
|