jaildesigner-jailgames/jaildoctors_dilemma
1
0
Fork 2
Code Issues 1 Pull Requests Projects Releases 20 Wiki 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

8
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 // 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; }); auto it = std::ranges::find_if(rooms_, [&name](const auto& r) { return r.name == name; });
if (it != rooms_.end()) { if (it != rooms_.end()) {
@@ -278,7 +278,7 @@ void Resource::loadTileMaps() {
for (const auto& l : list) { for (const auto& l : list) {
auto name = getFileName(l); auto name = getFileName(l);
tile_maps_.emplace_back(name, loadRoomTileFile(l)); tile_maps_.emplace_back(name, Room::loadRoomTileFile(l));
printWithDots("TileMap : ", name, "[ LOADED ]"); printWithDots("TileMap : ", name, "[ LOADED ]");
updateLoadingProgress(); updateLoadingProgress();
} }
@@ -292,7 +292,7 @@ void Resource::loadRooms() {
for (const auto& l : list) { for (const auto& l : list) {
auto name = getFileName(l); 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 ]"); printWithDots("Room : ", name, "[ LOADED ]");
updateLoadingProgress(); updateLoadingProgress();
} }
@@ -300,7 +300,7 @@ void Resource::loadRooms() {
void Resource::createText() { void Resource::createText() {
struct ResourceInfo { 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 texture_file; // Nombre del archivo de textura
std::string text_file; // Nombre del archivo de texto std::string text_file; // Nombre del archivo de texto

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

@@ -91,7 +91,7 @@ struct ResourceAnimation {
// Estructura para almacenar ficheros con el mapa de tiles de una habitación y su nombre // Estructura para almacenar ficheros con el mapa de tiles de una habitación y su nombre
struct ResourceTileMap { struct ResourceTileMap {
std::string name; // Nombre del mapa de tiles std::string name; // Nombre del mapa de tiles
std::vector<int> tile_map; // Vector con los indices del mapa de tiles std::vector<int> tile_map; // Vector con los indices del mapa de tiles
// Constructor // Constructor
@@ -102,11 +102,11 @@ struct ResourceTileMap {
// Estructura para almacenar habitaciones y su nombre // Estructura para almacenar habitaciones y su nombre
struct ResourceRoom { struct ResourceRoom {
std::string name; // Nombre de la habitación std::string name; // Nombre de la habitación
std::shared_ptr<RoomData> room; // Habitación std::shared_ptr<Room::Data> room; // Habitación
// Constructor // Constructor
ResourceRoom(std::string name, std::shared_ptr<RoomData> room) ResourceRoom(std::string name, std::shared_ptr<Room::Data> room)
: name(std::move(name)), : name(std::move(name)),
room(std::move(std::move(room))) {} room(std::move(std::move(room))) {}
}; };
@@ -248,7 +248,7 @@ class Resource {
auto getTileMap(const std::string& name) -> std::vector<int>&; auto getTileMap(const std::string& name) -> std::vector<int>&;
// Obtiene la habitación a partir de un nombre // 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 // Obtiene todas las habitaciones
auto getRooms() -> std::vector<ResourceRoom>&; 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 // Comprueba si está situado en alguno de los cuatro bordes de la habitación
void Player::checkBorders() { void Player::checkBorders() {
if (x_ < PLAY_AREA_LEFT) { if (x_ < PLAY_AREA_LEFT) {
border_ = RoomBorder::LEFT; border_ = Room::Border::LEFT;
is_on_border_ = true; is_on_border_ = true;
} }
else if (x_ + WIDTH > PLAY_AREA_RIGHT) { else if (x_ + WIDTH > PLAY_AREA_RIGHT) {
border_ = RoomBorder::RIGHT; border_ = Room::Border::RIGHT;
is_on_border_ = true; is_on_border_ = true;
} }
else if (y_ < PLAY_AREA_TOP) { else if (y_ < PLAY_AREA_TOP) {
border_ = RoomBorder::TOP; border_ = Room::Border::TOP;
is_on_border_ = true; is_on_border_ = true;
} }
else if (y_ + HEIGHT > PLAY_AREA_BOTTOM) { else if (y_ + HEIGHT > PLAY_AREA_BOTTOM) {
border_ = RoomBorder::BOTTOM; border_ = Room::Border::BOTTOM;
is_on_border_ = true; 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 // Cambia al jugador de un borde al opuesto. Util para el cambio de pantalla
void Player::switchBorders() { void Player::switchBorders() {
switch (border_) { switch (border_) {
case RoomBorder::TOP: case Room::Border::TOP:
y_ = PLAY_AREA_BOTTOM - HEIGHT - BLOCK; y_ = PLAY_AREA_BOTTOM - HEIGHT - BLOCK;
setState(State::STANDING); setState(State::STANDING);
break; break;
case RoomBorder::BOTTOM: case Room::Border::BOTTOM:
y_ = PLAY_AREA_TOP; y_ = PLAY_AREA_TOP;
setState(State::STANDING); setState(State::STANDING);
break; break;
case RoomBorder::RIGHT: case Room::Border::RIGHT:
x_ = PLAY_AREA_LEFT; x_ = PLAY_AREA_LEFT;
break; break;
case RoomBorder::LEFT: case Room::Border::LEFT:
x_ = PLAY_AREA_RIGHT - WIDTH; x_ = PLAY_AREA_RIGHT - WIDTH;
break; break;
@@ -561,7 +561,7 @@ auto Player::checkKillingTiles() -> bool {
// Comprueba si hay contacto con algún tile que mata // Comprueba si hay contacto con algún tile que mata
if (std::ranges::any_of(collider_points_, [this](const auto& c) { 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 is_alive_ = false; // Mata al jugador inmediatamente
return true; // Retorna en cuanto se detecta una colisión 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 render(); // Pinta el enemigo en pantalla
void update(float delta_time); // Actualiza las variables del objeto 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 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 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 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 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_alive_ = true; // Indica si el jugador esta vivo o no
bool is_paused_ = false; // Indica si el jugador esta en modo pausa 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 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 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 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 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/defines.hpp" // Para BLOCK, PLAY_AREA_HEIGHT, PLAY_AREA_WIDTH
#include "utils/utils.hpp" // Para LineHorizontal, LineDiagonal, LineVertical #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 // Constructor
Room::Room(const std::string& room_path, std::shared_ptr<ScoreboardData> data) Room::Room(const std::string& room_path, std::shared_ptr<ScoreboardData> data)
: data_(std::move(std::move(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_)); Screen::get()->setBorderColor(stringToColor(border_color_));
} }
void Room::initializeRoom(const RoomData& room) { void Room::initializeRoom(const Data& room) {
// Asignar valores a las variables miembro // Asignar valores a las variables miembro
number_ = room.number; number_ = room.number;
name_ = room.name; 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 // 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) { switch (border) {
case RoomBorder::TOP: case Border::TOP:
return upper_room_; return upper_room_;
break; break;
case RoomBorder::BOTTOM: case Border::BOTTOM:
return lower_room_; return lower_room_;
break; break;
case RoomBorder::RIGHT: case Border::RIGHT:
return right_room_; return right_room_;
break; break;
case RoomBorder::LEFT: case Border::LEFT:
return left_room_; return left_room_;
break; break;
@@ -520,49 +251,49 @@ auto Room::getRoom(RoomBorder border) -> std::string {
} }
// Devuelve el tipo de tile que hay en ese pixel // 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); const int POS = ((point.y / TILE_SIZE) * MAP_WIDTH) + (point.x / TILE_SIZE);
return getTile(POS); return getTile(POS);
} }
// Devuelve el tipo de tile que hay en ese indice // 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 onRange = (index > -1) && (index < mapWidth * mapHeight);
const bool ON_RANGE = (index > -1) && (index < (int)tile_map_.size()); const bool ON_RANGE = (index > -1) && (index < (int)tile_map_.size());
if (ON_RANGE) { if (ON_RANGE) {
// Las filas 0-8 son de tiles t_wall // Las filas 0-8 son de tiles t_wall
if ((tile_map_[index] >= 0) && (tile_map_[index] < 9 * tile_set_width_)) { 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 // Las filas 9-17 son de tiles t_passable
if ((tile_map_[index] >= 9 * tile_set_width_) && (tile_map_[index] < 18 * tile_set_width_)) { 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 // Las filas 18-20 es de tiles t_animated
if ((tile_map_[index] >= 18 * tile_set_width_) && (tile_map_[index] < 21 * tile_set_width_)) { 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 // La fila 21 es de tiles t_slope_r
if ((tile_map_[index] >= 21 * tile_set_width_) && (tile_map_[index] < 22 * tile_set_width_)) { 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 // La fila 22 es de tiles t_slope_l
if ((tile_map_[index] >= 22 * tile_set_width_) && (tile_map_[index] < 23 * tile_set_width_)) { 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 // La fila 23 es de tiles t_kill
if ((tile_map_[index] >= 23 * tile_set_width_) && (tile_map_[index] < 24 * tile_set_width_)) { 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 // 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 // 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 // Calcula la base del tile
int base = ((p.y / TILE_SIZE) * TILE_SIZE) + TILE_SIZE; int base = ((p.y / TILE_SIZE) * TILE_SIZE) + TILE_SIZE;
#ifdef _DEBUG #ifdef _DEBUG
@@ -603,7 +334,7 @@ auto Room::getSlopeHeight(SDL_FPoint p, TileType slope) -> int {
#endif #endif
// Se resta a la base la cantidad de pixeles pos en funcion de la rampa // 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; base -= POS + 1;
#ifdef _DEBUG #ifdef _DEBUG
Debug::get()->add("BASE_R = " + std::to_string(base)); 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 // 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) // 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) { 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); tile.push_back(i);
// Si llega al final de la fila, introduce un separador // 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 // 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) // 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) { 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); tile.push_back(i);
// Si llega al final de la fila, introduce un separador // 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 i = 1; i < MAP_WIDTH; ++i) {
for (int j = 0; j < MAP_HEIGHT; ++j) { for (int j = 0; j < MAP_HEIGHT; ++j) {
const int POS = ((j * MAP_WIDTH) + i); 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); tile.push_back(POS);
} }
} }
@@ -765,7 +496,7 @@ void Room::setRightSurfaces() {
for (int i = 0; i < MAP_WIDTH - 1; ++i) { for (int i = 0; i < MAP_WIDTH - 1; ++i) {
for (int j = 0; j < MAP_HEIGHT; ++j) { for (int j = 0; j < MAP_HEIGHT; ++j) {
const int POS = ((j * MAP_WIDTH) + i); 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); 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 // Recorre la habitación entera por filas buscando tiles de tipo t_slope_l
std::vector<int> found; std::vector<int> found;
for (int i = 0; i < (int)tile_map_.size(); ++i) { 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); 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 // Recorre la habitación entera por filas buscando tiles de tipo t_slope_r
std::vector<int> found; std::vector<int> found;
for (int i = 0; i < (int)tile_map_.size(); ++i) { 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); found.push_back(i);
} }
} }
@@ -874,7 +605,7 @@ auto Room::collectAnimatedTiles() -> std::vector<int> {
// Busca todos los tiles de tipo animado // Busca todos los tiles de tipo animado
// Hay que recorrer la habitación por filas (excepto los de la primera fila) // 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) { 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); tile.push_back(i);
// Si llega al final de la fila, introduce un separador // Si llega al final de la fila, introduce un separador
@@ -901,7 +632,7 @@ void Room::setAutoSurfaces() {
void Room::setAnimatedTiles() { void Room::setAnimatedTiles() {
// Recorre la habitación entera por filas buscando tiles de tipo t_animated // Recorre la habitación entera por filas buscando tiles de tipo t_animated
for (int i = 0; i < (int)tile_map_.size(); ++i) { 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 // La i es la ubicación
const int X = (i % MAP_WIDTH) * TILE_SIZE; const int X = (i % MAP_WIDTH) * TILE_SIZE;
const int Y = (i / MAP_WIDTH) * TILE_SIZE; const int Y = (i / MAP_WIDTH) * TILE_SIZE;
@@ -1079,4 +810,273 @@ void Room::initRoomSurfaces() {
setLeftSlopes(); setLeftSlopes();
setRightSlopes(); setRightSlopes();
setAutoSurfaces(); 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;
} }

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

@@ -13,241 +13,152 @@ class SurfaceSprite; // lines 12-12
class Surface; // lines 13-13 class Surface; // lines 13-13
struct ScoreboardData; // lines 15-15 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<SurfaceSprite> 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<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
};
// 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<int>;
// 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 { 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<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 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;
};
// Constructor y destructor
Room(const std::string& room_path, std::shared_ptr<ScoreboardData> 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<int>; // Carga las variables y texturas desde un fichero de mapa de tiles
private: private:
// Constantes // --- Constantes ---
static constexpr int TILE_SIZE = 8; // Ancho del tile en pixels 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_WIDTH = 32; // Ancho del mapa en tiles
static constexpr int MAP_HEIGHT = 16; // Alto 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<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::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> 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<Surface> map_surface_; // Textura para dibujar el mapa de la habitación
std::shared_ptr<ScoreboardData> data_; // Puntero a los datos del marcador std::shared_ptr<ScoreboardData> data_; // Puntero a los datos del marcador
// Variables // --- Variables ---
std::string number_; // Numero de la habitación std::string number_{}; // Numero de la habitación
std::string name_; // Nombre 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 bg_color_{}; // Color de fondo de la habitación
std::string border_color_; // Color del borde de la pantalla 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_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 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 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 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 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 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_set_file_{}; // Imagen con los graficos para la habitación
std::string tile_map_file_; // Fichero con el mapa de indices de tile 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 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 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> 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<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> 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<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> 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 std::vector<LineDiagonal> right_slopes_{}; // Lista con todas las rampas que suben hacia la derecha
int counter_; // Contador para lo que haga falta int counter_ = 0; // Contador para lo que haga falta
bool is_paused_; // Indica si el mapa esta en modo pausa 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<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 std::vector<LineHorizontal> conveyor_belt_floors_{}; // Lista con las superficies automaticas de la habitación
int tile_set_width_; // Ancho del tileset en tiles int tile_set_width_ = 0; // Ancho del tileset en tiles
void initializeRoom(const RoomData& room); // --- Funciones ---
void initializeRoom(const Data& room); // Inicializa los valores
// Pinta el mapa de la habitación en la textura void fillMapTexture(); // Pinta el mapa de la habitación en la textura
void fillMapTexture(); auto collectBottomTiles() -> std::vector<int>; // Helper para recopilar tiles inferiores
auto collectTopTiles() -> std::vector<int>; // Helper para recopilar tiles superiores
// Helper para recopilar tiles inferiores auto collectAnimatedTiles() -> std::vector<int>; // Helper para recopilar tiles animados (para superficies automaticas)
auto collectBottomTiles() -> std::vector<int>; 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
// Helper para recopilar tiles superiores void setTopSurfaces(); // Calcula las superficies superiores
auto collectTopTiles() -> std::vector<int>; void setLeftSurfaces(); // Calcula las superficies laterales izquierdas
void setRightSurfaces(); // Calcula las superficies laterales derechas
// Helper para recopilar tiles animados (para superficies automaticas) void setLeftSlopes(); // Encuentra todas las rampas que suben hacia la izquierda
auto collectAnimatedTiles() -> std::vector<int>; void setRightSlopes(); // Encuentra todas las rampas que suben hacia la derecha
void setAutoSurfaces(); // Calcula las superficies automaticas
// Helper para construir lineas horizontales a partir de tiles consecutivos void setAnimatedTiles(); // Localiza todos los tiles animados de la habitación
static void buildHorizontalLines(const std::vector<int>& tiles, std::vector<LineHorizontal>& lines, bool is_bottom_surface); void updateAnimatedTiles(); // Actualiza los tiles animados
void renderAnimatedTiles(); // Pinta los tiles animados en pantalla
// Calcula las superficies inferiores auto getTile(int index) -> Tile; // Devuelve el tipo de tile que hay en ese indice
void setBottomSurfaces(); void openTheJail(); // Abre la jail para poder entrar
void initRoomSurfaces(); // Inicializa las superficies de colision
// Calcula las superficies superiores static auto setRoom(Data* room, const std::string& key, const std::string& value) -> bool; // Asigna variables a una estructura RoomData
void setTopSurfaces(); 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
// Calcula las superficies laterales izquierdas static auto parseKeyValue(const std::string& line) -> std::pair<std::string, std::string>;
void setLeftSurfaces(); 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;
// Calcula las superficies laterales derechas static auto loadItemFromFile(std::ifstream& file, const std::string& file_name, bool verbose) -> Item::Data;
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_; }
}; };

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

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