96 lines
3.0 KiB
C++
96 lines
3.0 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, grass)),
|
|
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);
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
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::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
|
|
{
|
|
for (int tile_x = 0; tile_x < tiles.size(); tile_x++) {
|
|
for (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 - player_x;
|
|
int screen_y = tile_y * tile_size + tile_offset_y * tile_size + renderer->screen_height / 2 - 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 grass: renderer->draw_sprite(grass_sprite, screen_x, screen_y); break;
|
|
case path: renderer->draw_sprite(path_sprite, screen_x, screen_y); break;
|
|
}
|
|
}
|
|
}
|
|
}
|