jailers/jaildoctors_dilemma
5
0
Fork 0
forked from jaildesigner-jailgames/jaildoctors_dilemma
Code Pull Requests Activity

style: organitzada la capçalera de Room

Browse Source
This commit is contained in:
Sergio
2025-10-29 09:58:49 +01:00
parent cd836862c0
commit 8bf9da5fb6
7 changed files with 453 additions and 542 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
source/core/resources/resource.cpp
View File

@@ -164,7 +164,7 @@ auto Resource::getTileMap(const std::string& name) -> std::vector<int>& {
}
// Obtiene la habitación a partir de un nombre
auto Resource::getRoom(const std::string& name) -> std::shared_ptr<RoomData> {
auto Resource::getRoom(const std::string& name) -> std::shared_ptr<Room::Data> {
auto it = std::ranges::find_if(rooms_, [&name](const auto& r) { return r.name == name; });
if (it != rooms_.end()) {
@@ -278,7 +278,7 @@ void Resource::loadTileMaps() {
for (const auto& l : list) {
auto name = getFileName(l);
tile_maps_.emplace_back(name, loadRoomTileFile(l));
tile_maps_.emplace_back(name, Room::loadRoomTileFile(l));
printWithDots("TileMap : ", name, "[ LOADED ]");
updateLoadingProgress();
}
@@ -292,7 +292,7 @@ void Resource::loadRooms() {
for (const auto& l : list) {
auto name = getFileName(l);
rooms_.emplace_back(name, std::make_shared<RoomData>(loadRoomFile(l)));
rooms_.emplace_back(name, std::make_shared<Room::Data>(Room::loadRoomFile(l)));
printWithDots("Room : ", name, "[ LOADED ]");
updateLoadingProgress();
}

6
source/core/resources/resource.hpp
View File

@@ -103,10 +103,10 @@ struct ResourceTileMap {
// Estructura para almacenar habitaciones y su nombre
struct ResourceRoom {
std::string name; // Nombre de la habitación
std::shared_ptr<RoomData> room; // Habitación
std::shared_ptr<Room::Data> room; // Habitación
// Constructor
ResourceRoom(std::string name, std::shared_ptr<RoomData> room)
ResourceRoom(std::string name, std::shared_ptr<Room::Data> room)
: name(std::move(name)),
room(std::move(std::move(room))) {}
};
@@ -248,7 +248,7 @@ class Resource {
auto getTileMap(const std::string& name) -> std::vector<int>&;
// Obtiene la habitación a partir de un nombre
auto getRoom(const std::string& name) -> std::shared_ptr<RoomData>;
auto getRoom(const std::string& name) -> std::shared_ptr<Room::Data>;
// Obtiene todas las habitaciones
auto getRooms() -> std::vector<ResourceRoom>&;

18
source/game/entities/player.cpp
View File

@@ -117,22 +117,22 @@ void Player::checkInput(float delta_time) {
// Comprueba si está situado en alguno de los cuatro bordes de la habitación
void Player::checkBorders() {
if (x_ < PLAY_AREA_LEFT) {
border_ = RoomBorder::LEFT;
border_ = Room::Border::LEFT;
is_on_border_ = true;
}
else if (x_ + WIDTH > PLAY_AREA_RIGHT) {
border_ = RoomBorder::RIGHT;
border_ = Room::Border::RIGHT;
is_on_border_ = true;
}
else if (y_ < PLAY_AREA_TOP) {
border_ = RoomBorder::TOP;
border_ = Room::Border::TOP;
is_on_border_ = true;
}
else if (y_ + HEIGHT > PLAY_AREA_BOTTOM) {
border_ = RoomBorder::BOTTOM;
border_ = Room::Border::BOTTOM;
is_on_border_ = true;
}
@@ -179,21 +179,21 @@ void Player::checkState(float delta_time) {
// Cambia al jugador de un borde al opuesto. Util para el cambio de pantalla
void Player::switchBorders() {
switch (border_) {
case RoomBorder::TOP:
case Room::Border::TOP:
y_ = PLAY_AREA_BOTTOM - HEIGHT - BLOCK;
setState(State::STANDING);
break;
case RoomBorder::BOTTOM:
case Room::Border::BOTTOM:
y_ = PLAY_AREA_TOP;
setState(State::STANDING);
break;
case RoomBorder::RIGHT:
case Room::Border::RIGHT:
x_ = PLAY_AREA_LEFT;
break;
case RoomBorder::LEFT:
case Room::Border::LEFT:
x_ = PLAY_AREA_RIGHT - WIDTH;
break;
@@ -561,7 +561,7 @@ auto Player::checkKillingTiles() -> bool {
// Comprueba si hay contacto con algún tile que mata
if (std::ranges::any_of(collider_points_, [this](const auto& c) {
return room_->getTile(c) == TileType::KILL;
return room_->getTile(c) == Room::Tile::KILL;
})) {
is_alive_ = false; // Mata al jugador inmediatamente
return true; // Retorna en cuanto se detecta una colisión

4
source/game/entities/player.hpp
View File

@@ -70,7 +70,7 @@ class Player {
void render(); // Pinta el enemigo en pantalla
void update(float delta_time); // Actualiza las variables del objeto
[[nodiscard]] auto getOnBorder() const -> bool { return is_on_border_; } // Indica si el jugador esta en uno de los cuatro bordes de la pantalla
[[nodiscard]] auto getBorder() const -> RoomBorder { return border_; } // Indica en cual de los cuatro bordes se encuentra
[[nodiscard]] auto getBorder() const -> Room::Border { return border_; } // Indica en cual de los cuatro bordes se encuentra
void switchBorders(); // Cambia al jugador de un borde al opuesto. Util para el cambio de pantalla
auto getRect() -> SDL_FRect { return {x_, y_, WIDTH, HEIGHT}; } // Obtiene el rectangulo que delimita al jugador
auto getCollider() -> SDL_FRect& { return collider_box_; } // Obtiene el rectangulo de colision del jugador
@@ -115,7 +115,7 @@ class Player {
bool is_alive_ = true; // Indica si el jugador esta vivo o no
bool is_paused_ = false; // Indica si el jugador esta en modo pausa
bool auto_movement_ = false; // Indica si esta siendo arrastrado por una superficie automatica
RoomBorder border_ = RoomBorder::TOP; // Indica en cual de los cuatro bordes se encuentra
Room::Border border_ = Room::Border::TOP; // Indica en cual de los cuatro bordes se encuentra
SDL_FRect last_position_; // Contiene la ultima posición del jugador, por si hay que deshacer algun movimiento
int jump_init_pos_; // Valor del eje Y en el que se inicia el salto
std::vector<JA_Sound_t*> jumping_sound_; // Vecor con todos los sonidos del salto

588
source/game/gameplay/room.cpp
View File

@@ -19,275 +19,6 @@
#include "utils/defines.hpp" // Para BLOCK, PLAY_AREA_HEIGHT, PLAY_AREA_WIDTH
#include "utils/utils.hpp" // Para LineHorizontal, LineDiagonal, LineVertical
// Carga las variables y texturas desde un fichero de mapa de tiles
auto loadRoomTileFile(const std::string& file_path, bool verbose) -> std::vector<int> {
std::vector<int> tile_map_file;
const std::string FILENAME = file_path.substr(file_path.find_last_of("\\/") + 1);
std::ifstream file(file_path);
// El fichero se puede abrir
if (file.good()) {
std::string line;
// Procesa el fichero linea a linea
while (std::getline(file, line)) { // Lee el fichero linea a linea
if (line.find("data encoding") != std::string::npos) {
// Lee la primera linea
std::getline(file, line);
while (line != "</data>") { // Procesa lineas mientras haya
std::stringstream ss(line);
std::string tmp;
while (getline(ss, tmp, ',')) {
tile_map_file.push_back(std::stoi(tmp) - 1);
}
// Lee la siguiente linea
std::getline(file, line);
}
}
}
// Cierra el fichero
if (verbose) {
std::cout << "TileMap loaded: " << FILENAME.c_str() << '\n';
}
file.close();
}
else { // El fichero no se puede abrir
if (verbose) {
std::cout << "Warning: Unable to open " << FILENAME.c_str() << " file" << '\n';
}
}
return tile_map_file;
}
// Parsea una línea en key y value separados por '='
auto parseKeyValue(const std::string& line) -> std::pair<std::string, std::string> {
int pos = line.find('=');
std::string key = line.substr(0, pos);
std::string value = line.substr(pos + 1, line.length());
return {key, value};
}
// Muestra un warning de parámetro desconocido
void logUnknownParameter(const std::string& file_name, const std::string& key, bool verbose) {
if (verbose) {
std::cout << "Warning: file " << file_name.c_str() << "\n, unknown parameter \"" << key.c_str() << "\"" << '\n';
}
}
// Carga un bloque [enemy]...[/enemy] desde un archivo
auto loadEnemyFromFile(std::ifstream& file, const std::string& file_name, bool verbose) -> Enemy::Data {
Enemy::Data enemy;
enemy.flip = false;
enemy.mirror = false;
enemy.frame = -1;
std::string line;
do {
std::getline(file, line);
auto [key, value] = parseKeyValue(line);
if (!setEnemy(&enemy, key, value)) {
logUnknownParameter(file_name, key, verbose);
}
} while (line != "[/enemy]");
return enemy;
}
// Carga un bloque [item]...[/item] desde un archivo
auto loadItemFromFile(std::ifstream& file, const std::string& file_name, bool verbose) -> Item::Data {
Item::Data item;
item.counter = 0;
item.color1 = stringToColor("yellow");
item.color2 = stringToColor("magenta");
std::string line;
do {
std::getline(file, line);
auto [key, value] = parseKeyValue(line);
if (!setItem(&item, key, value)) {
logUnknownParameter(file_name, key, verbose);
}
} while (line != "[/item]");
return item;
}
// Carga las variables desde un fichero de mapa
auto loadRoomFile(const std::string& file_path, bool verbose) -> RoomData {
RoomData room;
room.item_color1 = "yellow";
room.item_color2 = "magenta";
room.conveyor_belt_direction = 1;
const std::string FILE_NAME = file_path.substr(file_path.find_last_of("\\/") + 1);
room.number = FILE_NAME.substr(0, FILE_NAME.find_last_of('.'));
std::ifstream file(file_path);
// El fichero se puede abrir
if (file.good()) {
std::string line;
// Procesa el fichero linea a linea
while (std::getline(file, line)) {
// Si la linea contiene el texto [enemy] se realiza el proceso de carga de un enemigo
if (line == "[enemy]") {
room.enemies.push_back(loadEnemyFromFile(file, FILE_NAME, verbose));
}
// Si la linea contiene el texto [item] se realiza el proceso de carga de un item
else if (line == "[item]") {
room.items.push_back(loadItemFromFile(file, FILE_NAME, verbose));
}
// En caso contrario se parsea el fichero para buscar las variables y los valores
else {
auto [key, value] = parseKeyValue(line);
if (!setRoom(&room, key, value)) {
logUnknownParameter(FILE_NAME, key, verbose);
}
}
}
// Cierra el fichero
if (verbose) {
std::cout << "Room loaded: " << FILE_NAME.c_str() << '\n';
}
file.close();
}
// El fichero no se puede abrir
else {
std::cout << "Warning: Unable to open " << FILE_NAME.c_str() << " file" << '\n';
}
return room;
}
// Asigna variables a una estructura RoomData
auto setRoom(RoomData* room, const std::string& key, const std::string& value) -> bool {
// Indicador de éxito en la asignación
bool success = true;
try {
if (key == "tileMapFile") {
room->tile_map_file = value;
} else if (key == "name") {
room->name = value;
} else if (key == "bgColor") {
room->bg_color = value;
} else if (key == "border") {
room->border_color = value;
} else if (key == "itemColor1") {
room->item_color1 = value;
} else if (key == "itemColor2") {
room->item_color2 = value;
} else if (key == "tileSetFile") {
room->tile_set_file = value;
} else if (key == "roomUp") {
room->upper_room = value;
} else if (key == "roomDown") {
room->lower_room = value;
} else if (key == "roomLeft") {
room->left_room = value;
} else if (key == "roomRight") {
room->right_room = value;
} else if (key == "autoSurface") {
room->conveyor_belt_direction = (value == "right") ? 1 : -1;
} else if (key.empty() || key.substr(0, 1) == "#") {
// No se realiza ninguna acción para estas claves
} else {
success = false;
}
} catch (const std::exception& e) {
std::cerr << "Error al asignar la clave " << key << " con valor " << value << ": " << e.what() << '\n';
success = false;
}
return success;
}
// Asigna variables a una estructura EnemyData
auto setEnemy(Enemy::Data* enemy, const std::string& key, const std::string& value) -> bool {
// Indicador de éxito en la asignación
bool success = true;
try {
if (key == "tileSetFile") {
enemy->surface_path = value;
} else if (key == "animation") {
enemy->animation_path = value;
} else if (key == "width") {
enemy->w = std::stoi(value);
} else if (key == "height") {
enemy->h = std::stoi(value);
} else if (key == "x") {
enemy->x = std::stof(value) * BLOCK;
} else if (key == "y") {
enemy->y = std::stof(value) * BLOCK;
} else if (key == "vx") {
enemy->vx = std::stof(value);
} else if (key == "vy") {
enemy->vy = std::stof(value);
} else if (key == "x1") {
enemy->x1 = std::stoi(value) * BLOCK;
} else if (key == "x2") {
enemy->x2 = std::stoi(value) * BLOCK;
} else if (key == "y1") {
enemy->y1 = std::stoi(value) * BLOCK;
} else if (key == "y2") {
enemy->y2 = std::stoi(value) * BLOCK;
} else if (key == "flip") {
enemy->flip = stringToBool(value);
} else if (key == "mirror") {
enemy->mirror = stringToBool(value);
} else if (key == "color") {
enemy->color = value;
} else if (key == "frame") {
enemy->frame = std::stoi(value);
} else if (key == "[/enemy]" || key == "tileSetFile" || key.substr(0, 1) == "#") {
// No se realiza ninguna acción para estas claves
} else {
success = false;
}
} catch (const std::exception& e) {
std::cerr << "Error al asignar la clave " << key << " con valor " << value << ": " << e.what() << '\n';
success = false;
}
return success;
}
// Asigna variables a una estructura ItemData
auto setItem(Item::Data* item, const std::string& key, const std::string& value) -> bool {
// Indicador de éxito en la asignación
bool success = true;
try {
if (key == "tileSetFile") {
item->tile_set_file = value;
} else if (key == "counter") {
item->counter = std::stoi(value);
} else if (key == "x") {
item->x = std::stof(value) * BLOCK;
} else if (key == "y") {
item->y = std::stof(value) * BLOCK;
} else if (key == "tile") {
item->tile = std::stof(value);
} else if (key == "[/item]") {
// No se realiza ninguna acción para esta clave
} else {
success = false;
}
} catch (const std::exception& e) {
std::cerr << "Error al asignar la clave " << key << " con valor " << value << ": " << e.what() << '\n';
success = false;
}
return success;
}
// Constructor
Room::Room(const std::string& room_path, std::shared_ptr<ScoreboardData> data)
: data_(std::move(std::move(data))) {
@@ -313,7 +44,7 @@ Room::Room(const std::string& room_path, std::shared_ptr<ScoreboardData> data)
Screen::get()->setBorderColor(stringToColor(border_color_));
}
void Room::initializeRoom(const RoomData& room) {
void Room::initializeRoom(const Data& room) {
// Asignar valores a las variables miembro
number_ = room.number;
name_ = room.name;
@@ -495,21 +226,21 @@ void Room::update(float delta_time) {
}
// Devuelve la cadena del fichero de la habitación contigua segun el borde
auto Room::getRoom(RoomBorder border) -> std::string {
auto Room::getRoom(Border border) -> std::string {
switch (border) {
case RoomBorder::TOP:
case Border::TOP:
return upper_room_;
break;
case RoomBorder::BOTTOM:
case Border::BOTTOM:
return lower_room_;
break;
case RoomBorder::RIGHT:
case Border::RIGHT:
return right_room_;
break;
case RoomBorder::LEFT:
case Border::LEFT:
return left_room_;
break;
@@ -520,49 +251,49 @@ auto Room::getRoom(RoomBorder border) -> std::string {
}
// Devuelve el tipo de tile que hay en ese pixel
auto Room::getTile(SDL_FPoint point) -> TileType {
auto Room::getTile(SDL_FPoint point) -> Tile {
const int POS = ((point.y / TILE_SIZE) * MAP_WIDTH) + (point.x / TILE_SIZE);
return getTile(POS);
}
// Devuelve el tipo de tile que hay en ese indice
auto Room::getTile(int index) -> TileType {
auto Room::getTile(int index) -> Tile {
// const bool onRange = (index > -1) && (index < mapWidth * mapHeight);
const bool ON_RANGE = (index > -1) && (index < (int)tile_map_.size());
if (ON_RANGE) {
// Las filas 0-8 son de tiles t_wall
if ((tile_map_[index] >= 0) && (tile_map_[index] < 9 * tile_set_width_)) {
return TileType::WALL;
return Tile::WALL;
}
// Las filas 9-17 son de tiles t_passable
if ((tile_map_[index] >= 9 * tile_set_width_) && (tile_map_[index] < 18 * tile_set_width_)) {
return TileType::PASSABLE;
return Tile::PASSABLE;
}
// Las filas 18-20 es de tiles t_animated
if ((tile_map_[index] >= 18 * tile_set_width_) && (tile_map_[index] < 21 * tile_set_width_)) {
return TileType::ANIMATED;
return Tile::ANIMATED;
}
// La fila 21 es de tiles t_slope_r
if ((tile_map_[index] >= 21 * tile_set_width_) && (tile_map_[index] < 22 * tile_set_width_)) {
return TileType::SLOPE_R;
return Tile::SLOPE_R;
}
// La fila 22 es de tiles t_slope_l
if ((tile_map_[index] >= 22 * tile_set_width_) && (tile_map_[index] < 23 * tile_set_width_)) {
return TileType::SLOPE_L;
return Tile::SLOPE_L;
}
// La fila 23 es de tiles t_kill
if ((tile_map_[index] >= 23 * tile_set_width_) && (tile_map_[index] < 24 * tile_set_width_)) {
return TileType::KILL;
return Tile::KILL;
}
}
return TileType::EMPTY;
return Tile::EMPTY;
}
// Indica si hay colision con un enemigo a partir de un rectangulo
@@ -589,7 +320,7 @@ auto Room::itemCollision(SDL_FRect& rect) -> bool {
}
// Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
auto Room::getSlopeHeight(SDL_FPoint p, TileType slope) -> int {
auto Room::getSlopeHeight(SDL_FPoint p, Tile slope) -> int {
// Calcula la base del tile
int base = ((p.y / TILE_SIZE) * TILE_SIZE) + TILE_SIZE;
#ifdef _DEBUG
@@ -603,7 +334,7 @@ auto Room::getSlopeHeight(SDL_FPoint p, TileType slope) -> int {
#endif
// Se resta a la base la cantidad de pixeles pos en funcion de la rampa
if (slope == TileType::SLOPE_R) {
if (slope == Tile::SLOPE_R) {
base -= POS + 1;
#ifdef _DEBUG
Debug::get()->add("BASE_R = " + std::to_string(base));
@@ -625,7 +356,7 @@ auto Room::collectBottomTiles() -> std::vector<int> {
// Busca todos los tiles de tipo muro que no tengan debajo otro muro
// Hay que recorrer la habitación por filas (excepto los de la última fila)
for (int i = 0; i < (int)tile_map_.size() - MAP_WIDTH; ++i) {
if (getTile(i) == TileType::WALL && getTile(i + MAP_WIDTH) != TileType::WALL) {
if (getTile(i) == Tile::WALL && getTile(i + MAP_WIDTH) != Tile::WALL) {
tile.push_back(i);
// Si llega al final de la fila, introduce un separador
@@ -647,7 +378,7 @@ auto Room::collectTopTiles() -> std::vector<int> {
// Busca todos los tiles de tipo muro o pasable que no tengan encima un muro
// Hay que recorrer la habitación por filas (excepto los de la primera fila)
for (int i = MAP_WIDTH; i < (int)tile_map_.size(); ++i) {
if ((getTile(i) == TileType::WALL || getTile(i) == TileType::PASSABLE) && getTile(i - MAP_WIDTH) != TileType::WALL) {
if ((getTile(i) == Tile::WALL || getTile(i) == Tile::PASSABLE) && getTile(i - MAP_WIDTH) != Tile::WALL) {
tile.push_back(i);
// Si llega al final de la fila, introduce un separador
@@ -725,7 +456,7 @@ void Room::setLeftSurfaces() {
for (int i = 1; i < MAP_WIDTH; ++i) {
for (int j = 0; j < MAP_HEIGHT; ++j) {
const int POS = ((j * MAP_WIDTH) + i);
if (getTile(POS) == TileType::WALL && getTile(POS - 1) != TileType::WALL) {
if (getTile(POS) == Tile::WALL && getTile(POS - 1) != Tile::WALL) {
tile.push_back(POS);
}
}
@@ -765,7 +496,7 @@ void Room::setRightSurfaces() {
for (int i = 0; i < MAP_WIDTH - 1; ++i) {
for (int j = 0; j < MAP_HEIGHT; ++j) {
const int POS = ((j * MAP_WIDTH) + i);
if (getTile(POS) == TileType::WALL && getTile(POS + 1) != TileType::WALL) {
if (getTile(POS) == Tile::WALL && getTile(POS + 1) != Tile::WALL) {
tile.push_back(POS);
}
}
@@ -801,7 +532,7 @@ void Room::setLeftSlopes() {
// Recorre la habitación entera por filas buscando tiles de tipo t_slope_l
std::vector<int> found;
for (int i = 0; i < (int)tile_map_.size(); ++i) {
if (getTile(i) == TileType::SLOPE_L) {
if (getTile(i) == Tile::SLOPE_L) {
found.push_back(i);
}
}
@@ -836,7 +567,7 @@ void Room::setRightSlopes() {
// Recorre la habitación entera por filas buscando tiles de tipo t_slope_r
std::vector<int> found;
for (int i = 0; i < (int)tile_map_.size(); ++i) {
if (getTile(i) == TileType::SLOPE_R) {
if (getTile(i) == Tile::SLOPE_R) {
found.push_back(i);
}
}
@@ -874,7 +605,7 @@ auto Room::collectAnimatedTiles() -> std::vector<int> {
// Busca todos los tiles de tipo animado
// Hay que recorrer la habitación por filas (excepto los de la primera fila)
for (int i = MAP_WIDTH; i < (int)tile_map_.size(); ++i) {
if (getTile(i) == TileType::ANIMATED) {
if (getTile(i) == Tile::ANIMATED) {
tile.push_back(i);
// Si llega al final de la fila, introduce un separador
@@ -901,7 +632,7 @@ void Room::setAutoSurfaces() {
void Room::setAnimatedTiles() {
// Recorre la habitación entera por filas buscando tiles de tipo t_animated
for (int i = 0; i < (int)tile_map_.size(); ++i) {
if (getTile(i) == TileType::ANIMATED) {
if (getTile(i) == Tile::ANIMATED) {
// La i es la ubicación
const int X = (i % MAP_WIDTH) * TILE_SIZE;
const int Y = (i / MAP_WIDTH) * TILE_SIZE;
@@ -1080,3 +811,272 @@ void Room::initRoomSurfaces() {
setRightSlopes();
setAutoSurfaces();
}
// Asigna variables a una estructura RoomData
auto Room::setRoom(Data* room, const std::string& key, const std::string& value) -> bool {
// Indicador de éxito en la asignación
bool success = true;
try {
if (key == "tileMapFile") {
room->tile_map_file = value;
} else if (key == "name") {
room->name = value;
} else if (key == "bgColor") {
room->bg_color = value;
} else if (key == "border") {
room->border_color = value;
} else if (key == "itemColor1") {
room->item_color1 = value;
} else if (key == "itemColor2") {
room->item_color2 = value;
} else if (key == "tileSetFile") {
room->tile_set_file = value;
} else if (key == "roomUp") {
room->upper_room = value;
} else if (key == "roomDown") {
room->lower_room = value;
} else if (key == "roomLeft") {
room->left_room = value;
} else if (key == "roomRight") {
room->right_room = value;
} else if (key == "autoSurface") {
room->conveyor_belt_direction = (value == "right") ? 1 : -1;
} else if (key.empty() || key.substr(0, 1) == "#") {
// No se realiza ninguna acción para estas claves
} else {
success = false;
}
} catch (const std::exception& e) {
std::cerr << "Error al asignar la clave " << key << " con valor " << value << ": " << e.what() << '\n';
success = false;
}
return success;
}
// Asigna variables a una estructura EnemyData
auto Room::setEnemy(Enemy::Data* enemy, const std::string& key, const std::string& value) -> bool {
// Indicador de éxito en la asignación
bool success = true;
try {
if (key == "tileSetFile") {
enemy->surface_path = value;
} else if (key == "animation") {
enemy->animation_path = value;
} else if (key == "width") {
enemy->w = std::stoi(value);
} else if (key == "height") {
enemy->h = std::stoi(value);
} else if (key == "x") {
enemy->x = std::stof(value) * BLOCK;
} else if (key == "y") {
enemy->y = std::stof(value) * BLOCK;
} else if (key == "vx") {
enemy->vx = std::stof(value);
} else if (key == "vy") {
enemy->vy = std::stof(value);
} else if (key == "x1") {
enemy->x1 = std::stoi(value) * BLOCK;
} else if (key == "x2") {
enemy->x2 = std::stoi(value) * BLOCK;
} else if (key == "y1") {
enemy->y1 = std::stoi(value) * BLOCK;
} else if (key == "y2") {
enemy->y2 = std::stoi(value) * BLOCK;
} else if (key == "flip") {
enemy->flip = stringToBool(value);
} else if (key == "mirror") {
enemy->mirror = stringToBool(value);
} else if (key == "color") {
enemy->color = value;
} else if (key == "frame") {
enemy->frame = std::stoi(value);
} else if (key == "[/enemy]" || key == "tileSetFile" || key.substr(0, 1) == "#") {
// No se realiza ninguna acción para estas claves
} else {
success = false;
}
} catch (const std::exception& e) {
std::cerr << "Error al asignar la clave " << key << " con valor " << value << ": " << e.what() << '\n';
success = false;
}
return success;
}
// Asigna variables a una estructura ItemData
auto Room::setItem(Item::Data* item, const std::string& key, const std::string& value) -> bool {
// Indicador de éxito en la asignación
bool success = true;
try {
if (key == "tileSetFile") {
item->tile_set_file = value;
} else if (key == "counter") {
item->counter = std::stoi(value);
} else if (key == "x") {
item->x = std::stof(value) * BLOCK;
} else if (key == "y") {
item->y = std::stof(value) * BLOCK;
} else if (key == "tile") {
item->tile = std::stof(value);
} else if (key == "[/item]") {
// No se realiza ninguna acción para esta clave
} else {
success = false;
}
} catch (const std::exception& e) {
std::cerr << "Error al asignar la clave " << key << " con valor " << value << ": " << e.what() << '\n';
success = false;
}
return success;
}
// Carga las variables y texturas desde un fichero de mapa de tiles
auto Room::loadRoomTileFile(const std::string& file_path, bool verbose) -> std::vector<int> {
std::vector<int> tile_map_file;
const std::string FILENAME = file_path.substr(file_path.find_last_of("\\/") + 1);
std::ifstream file(file_path);
// El fichero se puede abrir
if (file.good()) {
std::string line;
// Procesa el fichero linea a linea
while (std::getline(file, line)) { // Lee el fichero linea a linea
if (line.find("data encoding") != std::string::npos) {
// Lee la primera linea
std::getline(file, line);
while (line != "</data>") { // Procesa lineas mientras haya
std::stringstream ss(line);
std::string tmp;
while (getline(ss, tmp, ',')) {
tile_map_file.push_back(std::stoi(tmp) - 1);
}
// Lee la siguiente linea
std::getline(file, line);
}
}
}
// Cierra el fichero
if (verbose) {
std::cout << "TileMap loaded: " << FILENAME.c_str() << '\n';
}
file.close();
}
else { // El fichero no se puede abrir
if (verbose) {
std::cout << "Warning: Unable to open " << FILENAME.c_str() << " file" << '\n';
}
}
return tile_map_file;
}
// Carga las variables desde un fichero de mapa
auto Room::loadRoomFile(const std::string& file_path, bool verbose) -> Data {
Data room;
room.item_color1 = "yellow";
room.item_color2 = "magenta";
room.conveyor_belt_direction = 1;
const std::string FILE_NAME = file_path.substr(file_path.find_last_of("\\/") + 1);
room.number = FILE_NAME.substr(0, FILE_NAME.find_last_of('.'));
std::ifstream file(file_path);
// El fichero se puede abrir
if (file.good()) {
std::string line;
// Procesa el fichero linea a linea
while (std::getline(file, line)) {
// Si la linea contiene el texto [enemy] se realiza el proceso de carga de un enemigo
if (line == "[enemy]") {
room.enemies.push_back(loadEnemyFromFile(file, FILE_NAME, verbose));
}
// Si la linea contiene el texto [item] se realiza el proceso de carga de un item
else if (line == "[item]") {
room.items.push_back(loadItemFromFile(file, FILE_NAME, verbose));
}
// En caso contrario se parsea el fichero para buscar las variables y los valores
else {
auto [key, value] = parseKeyValue(line);
if (!setRoom(&room, key, value)) {
logUnknownParameter(FILE_NAME, key, verbose);
}
}
}
// Cierra el fichero
if (verbose) {
std::cout << "Room loaded: " << FILE_NAME.c_str() << '\n';
}
file.close();
}
// El fichero no se puede abrir
else {
std::cout << "Warning: Unable to open " << FILE_NAME.c_str() << " file" << '\n';
}
return room;
}
// Parsea una línea en key y value separados por '='
auto Room::parseKeyValue(const std::string& line) -> std::pair<std::string, std::string> {
int pos = line.find('=');
std::string key = line.substr(0, pos);
std::string value = line.substr(pos + 1, line.length());
return {key, value};
}
// Muestra un warning de parámetro desconocido
void Room::logUnknownParameter(const std::string& file_name, const std::string& key, bool verbose) {
if (verbose) {
std::cout << "Warning: file " << file_name.c_str() << "\n, unknown parameter \"" << key.c_str() << "\"" << '\n';
}
}
// Carga un bloque [enemy]...[/enemy] desde un archivo
auto Room::loadEnemyFromFile(std::ifstream& file, const std::string& file_name, bool verbose) -> Enemy::Data {
Enemy::Data enemy;
enemy.flip = false;
enemy.mirror = false;
enemy.frame = -1;
std::string line;
do {
std::getline(file, line);
auto [key, value] = parseKeyValue(line);
if (!setEnemy(&enemy, key, value)) {
logUnknownParameter(file_name, key, verbose);
}
} while (line != "[/enemy]");
return enemy;
}
// Carga un bloque [item]...[/item] desde un archivo
auto Room::loadItemFromFile(std::ifstream& file, const std::string& file_name, bool verbose) -> Item::Data {
Item::Data item;
item.counter = 0;
item.color1 = stringToColor("yellow");
item.color2 = stringToColor("magenta");
std::string line;
do {
std::getline(file, line);
auto [key, value] = parseKeyValue(line);
if (!setItem(&item, key, value)) {
logUnknownParameter(file_name, key, verbose);
}
} while (line != "[/item]");
return item;
}

329
source/game/gameplay/room.hpp
View File

@@ -13,7 +13,17 @@ class SurfaceSprite; // lines 12-12
class Surface; // lines 13-13
struct ScoreboardData; // lines 15-15
enum class TileType {
class Room {
public:
// -- Enumeraciones y estructuras ---
enum class Border : int {
TOP = 0,
RIGHT = 1,
BOTTOM = 2,
LEFT = 3
};
enum class Tile {
EMPTY,
WALL,
PASSABLE,
@@ -23,231 +33,132 @@ enum class TileType {
ANIMATED
};
enum class RoomBorder : int {
TOP = 0,
RIGHT = 1,
BOTTOM = 2,
LEFT = 3
};
struct AnimatedTile {
std::shared_ptr<SurfaceSprite> sprite; // SSprite para dibujar el tile
int x_orig; // Poicion X donde se encuentra el primer tile de la animacion en la tilesheet
std::shared_ptr<SurfaceSprite> sprite{}; // SurfaceSprite para dibujar el tile
int x_orig = 0; // Posición X donde se encuentra el primer tile de la animación en la tilesheet
};
struct RoomData {
std::string number; // Numero de la habitación
std::string name; // Nombre de la habitación
std::string bg_color; // Color de fondo de la habitación
std::string border_color; // Color del borde de la pantalla
std::string item_color1; // Color 1 para los items de la habitación
std::string item_color2; // Color 2 para los items de la habitación
std::string upper_room; // Identificador de la habitación que se encuentra arriba
std::string lower_room; // Identificador de la habitación que se encuentra abajp
std::string left_room; // Identificador de la habitación que se encuentra a la izquierda
std::string right_room; // Identificador de la habitación que se encuentra a la derecha
std::string tile_set_file; // Imagen con los graficos para la habitación
std::string tile_map_file; // Fichero con el mapa de indices de tile
int conveyor_belt_direction; // Sentido en el que arrastran las superficies automáticas de la habitación
std::vector<int> tile_map; // Indice de los tiles a dibujar en la habitación
std::vector<Enemy::Data> enemies; // Listado con los enemigos de la habitación
std::vector<Item::Data> items; // Listado con los items que hay en la habitación
struct Data {
std::string number{}; // Numero de la habitación
std::string name{}; // Nombre de la habitación
std::string bg_color{}; // Color de fondo de la habitación
std::string border_color{}; // Color del borde de la pantalla
std::string item_color1{}; // Color 1 para los items de la habitación
std::string item_color2{}; // Color 2 para los items de la habitación
std::string upper_room{}; // Identificador de la habitación que se encuentra arriba
std::string lower_room{}; // Identificador de la habitación que se encuentra abajo
std::string left_room{}; // Identificador de la habitación que se encuentra a la izquierda
std::string right_room{}; // Identificador de la habitación que se encuentra a la derecha
std::string tile_set_file{}; // Imagen con los gráficos para la habitación
std::string tile_map_file{}; // Fichero con el mapa de índices de tile
int conveyor_belt_direction = 0; // Sentido en el que arrastran las superficies automáticas de la habitación
std::vector<int> tile_map{}; // Índice de los tiles a dibujar en la habitación
std::vector<Enemy::Data> enemies{}; // Listado con los enemigos de la habitación
std::vector<Item::Data> items{}; // Listado con los items que hay en la habitación
// Constructor por defecto
Data() = default;
};
// Carga las variables desde un fichero de mapa
auto loadRoomFile(const std::string& file_path, bool verbose = false) -> RoomData;
// Constructor y destructor
Room(const std::string& room_path, std::shared_ptr<ScoreboardData> data);
~Room() = default;
// Carga las variables y texturas desde un fichero de mapa de tiles
auto loadRoomTileFile(const std::string& file_path, bool verbose = false) -> std::vector<int>;
// --- Funciones ---
[[nodiscard]] auto getName() const -> const std::string& { return name_; } // Devuelve el nombre de la habitación
[[nodiscard]] auto getBGColor() const -> Uint8 { return stringToColor(bg_color_); } // Devuelve el color de la habitación
[[nodiscard]] auto getBorderColor() const -> Uint8 { return stringToColor(border_color_); } // Devuelve el color del borde
void renderMap(); // Dibuja el mapa en pantalla
void renderEnemies(); // Dibuja los enemigos en pantalla
void renderItems(); // Dibuja los objetos en pantalla
void update(float delta_time); // Actualiza las variables y objetos de la habitación
auto getRoom(Border border) -> std::string; // Devuelve la cadena del fichero de la habitación contigua segun el borde
auto getTile(SDL_FPoint point) -> Tile; // Devuelve el tipo de tile que hay en ese pixel
auto enemyCollision(SDL_FRect& rect) -> bool; // Indica si hay colision con un enemigo a partir de un rectangulo
auto itemCollision(SDL_FRect& rect) -> bool; // Indica si hay colision con un objeto a partir de un rectangulo
static auto getTileSize() -> int { return TILE_SIZE; } // Obten el tamaño del tile
static auto getSlopeHeight(SDL_FPoint p, Tile slope) -> int; // Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
auto checkRightSurfaces(SDL_FRect* rect) -> int; // Comprueba las colisiones
auto checkLeftSurfaces(SDL_FRect* rect) -> int; // Comprueba las colisiones
auto checkTopSurfaces(SDL_FRect* rect) -> int; // Comprueba las colisiones
auto checkBottomSurfaces(SDL_FRect* rect) -> int; // Comprueba las colisiones
auto checkAutoSurfaces(SDL_FRect* rect) -> int; // Comprueba las colisiones
auto checkTopSurfaces(SDL_FPoint* p) -> bool; // Comprueba las colisiones
auto checkAutoSurfaces(SDL_FPoint* p) -> bool; // Comprueba las colisiones
auto checkLeftSlopes(const LineVertical* line) -> int; // Comprueba las colisiones
auto checkLeftSlopes(SDL_FPoint* p) -> bool; // Comprueba las colisiones
auto checkRightSlopes(const LineVertical* line) -> int; // Comprueba las colisiones
auto checkRightSlopes(SDL_FPoint* p) -> bool; // Comprueba las colisiones
void setPaused(bool value) { is_paused_ = value; }; // Pone el mapa en modo pausa
[[nodiscard]] auto getAutoSurfaceDirection() const -> int { return conveyor_belt_direction_; } // Obten la direccion de las superficies automaticas
static auto loadRoomFile(const std::string& file_path, bool verbose = false) -> Data; // Carga las variables desde un fichero de mapa
static auto loadRoomTileFile(const std::string& file_path, bool verbose = false) -> std::vector<int>; // Carga las variables y texturas desde un fichero de mapa de tiles
// Asigna variables a una estructura RoomData
auto setRoom(RoomData* room, const std::string& key, const std::string& value) -> bool;
// Asigna variables a una estructura EnemyData
auto setEnemy(Enemy::Data* enemy, const std::string& key, const std::string& value) -> bool;
// Asigna variables a una estructura ItemData
auto setItem(Item::Data* item, const std::string& key, const std::string& value) -> bool;
class Room {
private:
// Constantes
// --- Constantes ---
static constexpr int TILE_SIZE = 8; // Ancho del tile en pixels
static constexpr int MAP_WIDTH = 32; // Ancho del mapa en tiles
static constexpr int MAP_HEIGHT = 16; // Alto del mapa en tiles
// Objetos y punteros
// --- Objetos y punteros ---
std::vector<std::shared_ptr<Enemy>> enemies_; // Listado con los enemigos de la habitación
std::vector<std::shared_ptr<Item>> items_; // Listado con los items que hay en la habitación
std::shared_ptr<Surface> surface_; // Textura con los graficos de la habitación
std::shared_ptr<Surface> map_surface_; // Textura para dibujar el mapa de la habitación
std::shared_ptr<ScoreboardData> data_; // Puntero a los datos del marcador
// Variables
std::string number_; // Numero de la habitación
std::string name_; // Nombre de la habitación
std::string bg_color_; // Color de fondo de la habitación
std::string border_color_; // Color del borde de la pantalla
std::string item_color1_; // Color 1 para los items de la habitación
std::string item_color2_; // Color 2 para los items de la habitación
std::string upper_room_; // Identificador de la habitación que se encuentra arriba
std::string lower_room_; // Identificador de la habitación que se encuentra abajp
std::string left_room_; // Identificador de la habitación que se encuentra a la izquierda
std::string right_room_; // Identificador de la habitación que se encuentra a la derecha
std::string tile_set_file_; // Imagen con los graficos para la habitación
std::string tile_map_file_; // Fichero con el mapa de indices de tile
std::vector<int> tile_map_; // Indice de los tiles a dibujar en la habitación
int conveyor_belt_direction_; // Sentido en el que arrastran las superficies automáticas de la habitación
std::vector<LineHorizontal> bottom_floors_; // Lista con las superficies inferiores de la habitación
std::vector<LineHorizontal> top_floors_; // Lista con las superficies superiores de la habitación
std::vector<LineVertical> left_walls_; // Lista con las superficies laterales de la parte izquierda de la habitación
std::vector<LineVertical> right_walls_; // Lista con las superficies laterales de la parte derecha de la habitación
std::vector<LineDiagonal> left_slopes_; // Lista con todas las rampas que suben hacia la izquierda
std::vector<LineDiagonal> right_slopes_; // Lista con todas las rampas que suben hacia la derecha
int counter_; // Contador para lo que haga falta
bool is_paused_; // Indica si el mapa esta en modo pausa
std::vector<AnimatedTile> animated_tiles_; // Vector con los indices de tiles animados
std::vector<LineHorizontal> conveyor_belt_floors_; // Lista con las superficies automaticas de la habitación
int tile_set_width_; // Ancho del tileset en tiles
// --- Variables ---
std::string number_{}; // Numero de la habitación
std::string name_{}; // Nombre de la habitación
std::string bg_color_{}; // Color de fondo de la habitación
std::string border_color_{}; // Color del borde de la pantalla
std::string item_color1_{}; // Color 1 para los items de la habitación
std::string item_color2_{}; // Color 2 para los items de la habitación
std::string upper_room_{}; // Identificador de la habitación que se encuentra arriba
std::string lower_room_{}; // Identificador de la habitación que se encuentra abajp
std::string left_room_{}; // Identificador de la habitación que se encuentra a la izquierda
std::string right_room_{}; // Identificador de la habitación que se encuentra a la derecha
std::string tile_set_file_{}; // Imagen con los graficos para la habitación
std::string tile_map_file_{}; // Fichero con el mapa de indices de tile
std::vector<int> tile_map_{}; // Indice de los tiles a dibujar en la habitación
int conveyor_belt_direction_ = 0; // Sentido en el que arrastran las superficies automáticas de la habitación
std::vector<LineHorizontal> bottom_floors_{}; // Lista con las superficies inferiores de la habitación
std::vector<LineHorizontal> top_floors_{}; // Lista con las superficies superiores de la habitación
std::vector<LineVertical> left_walls_{}; // Lista con las superficies laterales de la parte izquierda de la habitación
std::vector<LineVertical> right_walls_{}; // Lista con las superficies laterales de la parte derecha de la habitación
std::vector<LineDiagonal> left_slopes_{}; // Lista con todas las rampas que suben hacia la izquierda
std::vector<LineDiagonal> right_slopes_{}; // Lista con todas las rampas que suben hacia la derecha
int counter_ = 0; // Contador para lo que haga falta
bool is_paused_ = false; // Indica si el mapa esta en modo pausa
std::vector<AnimatedTile> animated_tiles_{}; // Vector con los indices de tiles animados
std::vector<LineHorizontal> conveyor_belt_floors_{}; // Lista con las superficies automaticas de la habitación
int tile_set_width_ = 0; // Ancho del tileset en tiles
void initializeRoom(const RoomData& room);
// Pinta el mapa de la habitación en la textura
void fillMapTexture();
// Helper para recopilar tiles inferiores
auto collectBottomTiles() -> std::vector<int>;
// Helper para recopilar tiles superiores
auto collectTopTiles() -> std::vector<int>;
// Helper para recopilar tiles animados (para superficies automaticas)
auto collectAnimatedTiles() -> std::vector<int>;
// Helper para construir lineas horizontales a partir de tiles consecutivos
static void buildHorizontalLines(const std::vector<int>& tiles, std::vector<LineHorizontal>& lines, bool is_bottom_surface);
// Calcula las superficies inferiores
void setBottomSurfaces();
// Calcula las superficies superiores
void setTopSurfaces();
// Calcula las superficies laterales izquierdas
void setLeftSurfaces();
// Calcula las superficies laterales derechas
void setRightSurfaces();
// Encuentra todas las rampas que suben hacia la izquierda
void setLeftSlopes();
// Encuentra todas las rampas que suben hacia la derecha
void setRightSlopes();
// Calcula las superficies automaticas
void setAutoSurfaces();
// Localiza todos los tiles animados de la habitación
void setAnimatedTiles();
// Actualiza los tiles animados
void updateAnimatedTiles();
// Pinta los tiles animados en pantalla
void renderAnimatedTiles();
// Devuelve el tipo de tile que hay en ese indice
auto getTile(int index) -> TileType;
// Abre la jail para poder entrar
void openTheJail();
// Inicializa las superficies de colision
void initRoomSurfaces();
public:
// Constructor
Room(const std::string& room_path, std::shared_ptr<ScoreboardData> data);
// Destructor
~Room() = default;
// Devuelve el nombre de la habitación
[[nodiscard]] auto getName() const -> const std::string& { return name_; }
// Devuelve el color de la habitación
[[nodiscard]] auto getBGColor() const -> Uint8 { return stringToColor(bg_color_); }
// Devuelve el color del borde
[[nodiscard]] auto getBorderColor() const -> Uint8 { return stringToColor(border_color_); }
// Dibuja el mapa en pantalla
void renderMap();
// Dibuja los enemigos en pantalla
void renderEnemies();
// Dibuja los objetos en pantalla
void renderItems();
// Actualiza las variables y objetos de la habitación
void update(float delta_time);
// Devuelve la cadena del fichero de la habitación contigua segun el borde
auto getRoom(RoomBorder border) -> std::string;
// Devuelve el tipo de tile que hay en ese pixel
auto getTile(SDL_FPoint point) -> TileType;
// Indica si hay colision con un enemigo a partir de un rectangulo
auto enemyCollision(SDL_FRect& rect) -> bool;
// Indica si hay colision con un objeto a partir de un rectangulo
auto itemCollision(SDL_FRect& rect) -> bool;
// Obten el tamaño del tile
static auto getTileSize() -> int { return TILE_SIZE; }
// Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
static auto getSlopeHeight(SDL_FPoint p, TileType slope) -> int;
// Comprueba las colisiones
auto checkRightSurfaces(SDL_FRect* rect) -> int;
// Comprueba las colisiones
auto checkLeftSurfaces(SDL_FRect* rect) -> int;
// Comprueba las colisiones
auto checkTopSurfaces(SDL_FRect* rect) -> int;
// Comprueba las colisiones
auto checkBottomSurfaces(SDL_FRect* rect) -> int;
// Comprueba las colisiones
auto checkAutoSurfaces(SDL_FRect* rect) -> int;
// Comprueba las colisiones
auto checkTopSurfaces(SDL_FPoint* p) -> bool;
// Comprueba las colisiones
auto checkAutoSurfaces(SDL_FPoint* p) -> bool;
// Comprueba las colisiones
auto checkLeftSlopes(const LineVertical* line) -> int;
// Comprueba las colisiones
auto checkLeftSlopes(SDL_FPoint* p) -> bool;
// Comprueba las colisiones
auto checkRightSlopes(const LineVertical* line) -> int;
// Comprueba las colisiones
auto checkRightSlopes(SDL_FPoint* p) -> bool;
// Pone el mapa en modo pausa
void setPaused(bool value) { is_paused_ = value; };
// Obten la direccion de las superficies automaticas
[[nodiscard]] auto getAutoSurfaceDirection() const -> int { return conveyor_belt_direction_; }
// --- Funciones ---
void initializeRoom(const Data& room); // Inicializa los valores
void fillMapTexture(); // Pinta el mapa de la habitación en la textura
auto collectBottomTiles() -> std::vector<int>; // Helper para recopilar tiles inferiores
auto collectTopTiles() -> std::vector<int>; // Helper para recopilar tiles superiores
auto collectAnimatedTiles() -> std::vector<int>; // Helper para recopilar tiles animados (para superficies automaticas)
static void buildHorizontalLines(const std::vector<int>& tiles, std::vector<LineHorizontal>& lines, bool is_bottom_surface); // Helper para construir lineas horizontales a partir de tiles consecutivos
void setBottomSurfaces(); // Calcula las superficies inferiores
void setTopSurfaces(); // Calcula las superficies superiores
void setLeftSurfaces(); // Calcula las superficies laterales izquierdas
void setRightSurfaces(); // Calcula las superficies laterales derechas
void setLeftSlopes(); // Encuentra todas las rampas que suben hacia la izquierda
void setRightSlopes(); // Encuentra todas las rampas que suben hacia la derecha
void setAutoSurfaces(); // Calcula las superficies automaticas
void setAnimatedTiles(); // Localiza todos los tiles animados de la habitación
void updateAnimatedTiles(); // Actualiza los tiles animados
void renderAnimatedTiles(); // Pinta los tiles animados en pantalla
auto getTile(int index) -> Tile; // Devuelve el tipo de tile que hay en ese indice
void openTheJail(); // Abre la jail para poder entrar
void initRoomSurfaces(); // Inicializa las superficies de colision
static auto setRoom(Data* room, const std::string& key, const std::string& value) -> bool; // Asigna variables a una estructura RoomData
static auto setEnemy(Enemy::Data* enemy, const std::string& key, const std::string& value) -> bool; // Asigna variables a una estructura EnemyData
static auto setItem(Item::Data* item, const std::string& key, const std::string& value) -> bool; // Asigna variables a una estructura ItemData
static auto parseKeyValue(const std::string& line) -> std::pair<std::string, std::string>;
static void logUnknownParameter(const std::string& file_name, const std::string& key, bool verbose);
static auto loadEnemyFromFile(std::ifstream& file, const std::string& file_name, bool verbose) -> Enemy::Data;
static auto loadItemFromFile(std::ifstream& file, const std::string& file_name, bool verbose) -> Item::Data;
};

8
source/game/scenes/game.cpp
View File

@@ -228,19 +228,19 @@ void Game::checkDebugEvents(const SDL_Event& event) {
break;
case SDL_SCANCODE_W:
changeRoom(room_->getRoom(RoomBorder::TOP));
changeRoom(room_->getRoom(Room::Border::TOP));
break;
case SDL_SCANCODE_A:
changeRoom(room_->getRoom(RoomBorder::LEFT));
changeRoom(room_->getRoom(Room::Border::LEFT));
break;
case SDL_SCANCODE_S:
changeRoom(room_->getRoom(RoomBorder::BOTTOM));
changeRoom(room_->getRoom(Room::Border::BOTTOM));
break;
case SDL_SCANCODE_D:
changeRoom(room_->getRoom(RoomBorder::RIGHT));
changeRoom(room_->getRoom(Room::Border::RIGHT));
break;
case SDL_SCANCODE_7: