diff --git a/source/core/resources/resource.cpp b/source/core/resources/resource.cpp index 87d4947..d82b9d6 100644 --- a/source/core/resources/resource.cpp +++ b/source/core/resources/resource.cpp @@ -164,7 +164,7 @@ auto Resource::getTileMap(const std::string& name) -> std::vector& { } // Obtiene la habitación a partir de un nombre -auto Resource::getRoom(const std::string& name) -> std::shared_ptr { +auto Resource::getRoom(const std::string& name) -> std::shared_ptr { 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(loadRoomFile(l))); + rooms_.emplace_back(name, std::make_shared(Room::loadRoomFile(l))); printWithDots("Room : ", name, "[ LOADED ]"); updateLoadingProgress(); } @@ -300,7 +300,7 @@ void Resource::loadRooms() { void Resource::createText() { struct ResourceInfo { - std::string key; // Identificador del recurso + std::string key; // Identificador del recurso std::string texture_file; // Nombre del archivo de textura std::string text_file; // Nombre del archivo de texto diff --git a/source/core/resources/resource.hpp b/source/core/resources/resource.hpp index 4ae6011..9c9c2eb 100644 --- a/source/core/resources/resource.hpp +++ b/source/core/resources/resource.hpp @@ -91,7 +91,7 @@ struct ResourceAnimation { // Estructura para almacenar ficheros con el mapa de tiles de una habitación y su nombre struct ResourceTileMap { - std::string name; // Nombre del mapa de tiles + std::string name; // Nombre del mapa de tiles std::vector tile_map; // Vector con los indices del mapa de tiles // Constructor @@ -102,11 +102,11 @@ struct ResourceTileMap { // Estructura para almacenar habitaciones y su nombre struct ResourceRoom { - std::string name; // Nombre de la habitación - std::shared_ptr room; // Habitación + std::string name; // Nombre de la habitación + std::shared_ptr room; // Habitación // Constructor - ResourceRoom(std::string name, std::shared_ptr room) + ResourceRoom(std::string name, std::shared_ptr 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&; // Obtiene la habitación a partir de un nombre - auto getRoom(const std::string& name) -> std::shared_ptr; + auto getRoom(const std::string& name) -> std::shared_ptr; // Obtiene todas las habitaciones auto getRooms() -> std::vector&; diff --git a/source/game/entities/player.cpp b/source/game/entities/player.cpp index 2065508..2b9ad75 100644 --- a/source/game/entities/player.cpp +++ b/source/game/entities/player.cpp @@ -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 diff --git a/source/game/entities/player.hpp b/source/game/entities/player.hpp index c931d58..a4f91d1 100644 --- a/source/game/entities/player.hpp +++ b/source/game/entities/player.hpp @@ -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 jumping_sound_; // Vecor con todos los sonidos del salto diff --git a/source/game/gameplay/room.cpp b/source/game/gameplay/room.cpp index e1e0c02..d033a4c 100644 --- a/source/game/gameplay/room.cpp +++ b/source/game/gameplay/room.cpp @@ -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 { - std::vector 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 != "") { // 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 { - 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 data) : data_(std::move(std::move(data))) { @@ -313,7 +44,7 @@ Room::Room(const std::string& room_path, std::shared_ptr 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 { // 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 { // 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 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 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 { // 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; @@ -1079,4 +810,273 @@ void Room::initRoomSurfaces() { setLeftSlopes(); 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 { + std::vector 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 != "") { // 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 { + 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; } \ No newline at end of file diff --git a/source/game/gameplay/room.hpp b/source/game/gameplay/room.hpp index 251efdf..9714008 100644 --- a/source/game/gameplay/room.hpp +++ b/source/game/gameplay/room.hpp @@ -13,241 +13,152 @@ class SurfaceSprite; // lines 12-12 class Surface; // lines 13-13 struct ScoreboardData; // lines 15-15 -enum class TileType { - EMPTY, - WALL, - PASSABLE, - SLOPE_L, - SLOPE_R, - KILL, - ANIMATED -}; - -enum class RoomBorder : int { - TOP = 0, - RIGHT = 1, - BOTTOM = 2, - LEFT = 3 -}; - -struct AnimatedTile { - std::shared_ptr sprite; // SSprite para dibujar el tile - int x_orig; // Poicion X donde se encuentra el primer tile de la animacion 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 tile_map; // Indice de los tiles a dibujar en la habitación - std::vector enemies; // Listado con los enemigos de la habitación - std::vector items; // Listado con los items que hay en la habitación -}; - -// Carga las variables desde un fichero de mapa -auto loadRoomFile(const std::string& file_path, bool verbose = false) -> RoomData; - -// Carga las variables y texturas desde un fichero de mapa de tiles -auto loadRoomTileFile(const std::string& file_path, bool verbose = false) -> std::vector; - -// 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 { + public: + // -- Enumeraciones y estructuras --- + enum class Border : int { + TOP = 0, + RIGHT = 1, + BOTTOM = 2, + LEFT = 3 + }; + + enum class Tile { + EMPTY, + WALL, + PASSABLE, + SLOPE_L, + SLOPE_R, + KILL, + ANIMATED + }; + + struct AnimatedTile { + std::shared_ptr 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 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 tile_map{}; // Índice de los tiles a dibujar en la habitación + std::vector enemies{}; // Listado con los enemigos de la habitación + std::vector items{}; // Listado con los items que hay en la habitación + + // Constructor por defecto + Data() = default; + }; + + // Constructor y destructor + Room(const std::string& room_path, std::shared_ptr data); + ~Room() = default; + + // --- 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; // Carga las variables y texturas desde un fichero de mapa de tiles + 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> enemies_; // Listado con los enemigos de la habitación std::vector> items_; // Listado con los items que hay en la habitación std::shared_ptr surface_; // Textura con los graficos de la habitación std::shared_ptr map_surface_; // Textura para dibujar el mapa de la habitación std::shared_ptr 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 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 bottom_floors_; // Lista con las superficies inferiores de la habitación - std::vector top_floors_; // Lista con las superficies superiores de la habitación - std::vector left_walls_; // Lista con las superficies laterales de la parte izquierda de la habitación - std::vector right_walls_; // Lista con las superficies laterales de la parte derecha de la habitación - std::vector left_slopes_; // Lista con todas las rampas que suben hacia la izquierda - std::vector 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 animated_tiles_; // Vector con los indices de tiles animados - std::vector 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 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 bottom_floors_{}; // Lista con las superficies inferiores de la habitación + std::vector top_floors_{}; // Lista con las superficies superiores de la habitación + std::vector left_walls_{}; // Lista con las superficies laterales de la parte izquierda de la habitación + std::vector right_walls_{}; // Lista con las superficies laterales de la parte derecha de la habitación + std::vector left_slopes_{}; // Lista con todas las rampas que suben hacia la izquierda + std::vector 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 animated_tiles_{}; // Vector con los indices de tiles animados + std::vector 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; - - // Helper para recopilar tiles superiores - auto collectTopTiles() -> std::vector; - - // Helper para recopilar tiles animados (para superficies automaticas) - auto collectAnimatedTiles() -> std::vector; - - // Helper para construir lineas horizontales a partir de tiles consecutivos - static void buildHorizontalLines(const std::vector& tiles, std::vector& 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 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; // Helper para recopilar tiles inferiores + auto collectTopTiles() -> std::vector; // Helper para recopilar tiles superiores + auto collectAnimatedTiles() -> std::vector; // Helper para recopilar tiles animados (para superficies automaticas) + static void buildHorizontalLines(const std::vector& tiles, std::vector& 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; + 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; }; \ No newline at end of file diff --git a/source/game/scenes/game.cpp b/source/game/scenes/game.cpp index 7e62784..d5f94e4 100644 --- a/source/game/scenes/game.cpp +++ b/source/game/scenes/game.cpp @@ -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: