jaildesigner-jailgames/jaildoctors_dilemma
1
0
Fork 2
Code Issues 1 Pull Requests Projects Releases 20 Wiki Activity

style: deixant guapetes les capçaleres de les classes

Browse Source
This commit is contained in:
Sergio
2025-11-10 13:53:29 +01:00
parent 5dd463ad5a
commit b70b728b75
23 changed files with 492 additions and 595 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
source/game/gameplay/cheevos.cpp
View File

@@ -44,18 +44,18 @@ Cheevos::~Cheevos() {
// Inicializa los logros
void Cheevos::init() {
cheevos_list_.clear();
cheevos_list_.emplace_back(1, "SHINY THINGS", "Get 25% of the items", 2);
cheevos_list_.emplace_back(2, "HALF THE WORK", "Get 50% of the items", 2);
cheevos_list_.emplace_back(3, "GETTING THERE", "Get 75% of the items", 2);
cheevos_list_.emplace_back(4, "THE COLLECTOR", "Get 100% of the items", 2);
cheevos_list_.emplace_back(5, "WANDERING AROUND", "Visit 20 rooms", 2);
cheevos_list_.emplace_back(6, "I GOT LOST", "Visit 40 rooms", 2);
cheevos_list_.emplace_back(7, "I LIKE TO EXPLORE", "Visit all rooms", 2);
cheevos_list_.emplace_back(8, "FINISH THE GAME", "Complete the game", 2);
cheevos_list_.emplace_back(9, "I WAS SUCKED BY A HOLE", "Complete the game without entering the jail", 2);
cheevos_list_.emplace_back(10, "MY LITTLE PROJECTS", "Complete the game with all items", 2);
cheevos_list_.emplace_back(11, "I LIKE MY MULTICOLOURED FRIENDS", "Complete the game without dying", 2);
cheevos_list_.emplace_back(12, "SHIT PROJECTS DONE FAST", "Complete the game in under 30 minutes", 2);
cheevos_list_.emplace_back(Achievement{.id = 1, .caption = "SHINY THINGS", .description = "Get 25% of the items", .icon = 2});
cheevos_list_.emplace_back(Achievement{.id = 2, .caption = "HALF THE WORK", .description = "Get 50% of the items", .icon = 2});
cheevos_list_.emplace_back(Achievement{.id = 3, .caption = "GETTING THERE", .description = "Get 75% of the items", .icon = 2});
cheevos_list_.emplace_back(Achievement{.id = 4, .caption = "THE COLLECTOR", .description = "Get 100% of the items", .icon = 2});
cheevos_list_.emplace_back(Achievement{.id = 5, .caption = "WANDERING AROUND", .description = "Visit 20 rooms", .icon = 2});
cheevos_list_.emplace_back(Achievement{.id = 6, .caption = "I GOT LOST", .description = "Visit 40 rooms", .icon = 2});
cheevos_list_.emplace_back(Achievement{.id = 7, .caption = "I LIKE TO EXPLORE", .description = "Visit all rooms", .icon = 2});
cheevos_list_.emplace_back(Achievement{.id = 8, .caption = "FINISH THE GAME", .description = "Complete the game", .icon = 2});
cheevos_list_.emplace_back(Achievement{.id = 9, .caption = "I WAS SUCKED BY A HOLE", .description = "Complete the game without entering the jail", .icon = 2});
cheevos_list_.emplace_back(Achievement{.id = 10, .caption = "MY LITTLE PROJECTS", .description = "Complete the game with all items", .icon = 2});
cheevos_list_.emplace_back(Achievement{.id = 11, .caption = "I LIKE MY MULTICOLOURED FRIENDS", .description = "Complete the game without dying", .icon = 2});
cheevos_list_.emplace_back(Achievement{.id = 12, .caption = "SHIT PROJECTS DONE FAST", .description = "Complete the game in under 30 minutes", .icon = 2});
}
// Busca un logro por id y devuelve el indice
@@ -82,7 +82,7 @@ void Cheevos::unlock(int id) {
cheevos_list_.at(INDEX).completed = true;
// Mostrar notificación en la pantalla
Notifier::get()->show({"ACHIEVEMENT UNLOCKED!", cheevos_list_.at(INDEX).caption}, NotificationText::CENTER, CHEEVO_NOTIFICATION_DURATION /*, cheevos_list_.at(INDEX).icon*/);
Notifier::get()->show({"ACHIEVEMENT UNLOCKED!", cheevos_list_.at(INDEX).caption}, Notifier::TextAlign::CENTER, Notifier::DURATION_CHEEVO /*, cheevos_list_.at(INDEX).icon*/);
// Guardar el estado de los logros
saveToFile();
@@ -160,8 +160,7 @@ void Cheevos::saveToFile() {
// Devuelve el número total de logros desbloqueados
auto Cheevos::getTotalUnlockedAchievements() -> int {
return std::count_if(cheevos_list_.begin(), cheevos_list_.end(),
[](const auto& cheevo) { return cheevo.completed; });
return std::count_if(cheevos_list_.begin(), cheevos_list_.end(), [](const auto& cheevo) { return cheevo.completed; });
}
// Elimina el estado "no obtenible"

118
source/game/gameplay/cheevos.hpp
View File

@@ -4,88 +4,52 @@
#include <utility>
#include <vector> // Para vector
// Struct para los logros
struct Achievement {
int id; // Identificador del logro
std::string caption; // Texto con el nombre del logro
std::string description; // Texto que describe el logro
int icon; // Indice del icono a utilizar en la notificación
bool completed; // Indica si se ha obtenido el logro
bool obtainable; // Indica si se puede obtener el logro
// Constructor vacío
Achievement()
: id(0),
icon(0),
completed(false),
obtainable(true) {}
// Constructor parametrizado
Achievement(int id, std::string caption, std::string description, int icon, bool completed = false, bool obtainable = true)
: id(id),
caption(std::move(caption)),
description(std::move(description)),
icon(icon),
completed(completed),
obtainable(obtainable) {}
};
class Cheevos {
public:
// Tipos anidados (públicos porque se usan en la interfaz)
struct Achievement {
int id{0}; // Identificador del logro
std::string caption{}; // Texto con el nombre del logro
std::string description{}; // Texto que describe el logro
int icon{0}; // Indice del icono a utilizar en la notificación
bool completed{false}; // Indica si se ha obtenido el logro
bool obtainable{true}; // Indica si se puede obtener el logro
};
using Achievements = std::vector<Achievement>; // Type alias para vector de logros
// Gestión singleton
static void init(const std::string& file); // Inicialización
static void destroy(); // Destrucción
static auto get() -> Cheevos*; // Acceso al singleton
// Gestión de logros
void unlock(int id); // Desbloquea un logro
void setUnobtainable(int id); // Invalida un logro
void clearUnobtainableState(); // Elimina el estado "no obtenible"
void enable(bool value) { enabled_ = value; } // Habilita o deshabilita los logros
// Consultas
[[nodiscard]] auto list() const -> const Achievements& { return cheevos_list_; } // Lista los logros
auto getTotalUnlockedAchievements() -> int; // Devuelve logros desbloqueados
auto size() -> int { return cheevos_list_.size(); } // Devuelve número total de logros
private:
// [SINGLETON] Objeto privado
static Cheevos* cheevos;
// Constantes singleton
static Cheevos* cheevos; // [SINGLETON] Objeto privado
// Variables
std::vector<Achievement> cheevos_list_; // Listado de logros
bool enabled_ = true; // Indica si los logros se pueden obtener
std::string file_; // Fichero donde leer/almacenar el estado de los logros
// Métodos privados
void init(); // Inicializa los logros
auto find(int id) -> int; // Busca un logro por id y devuelve el índice
void loadFromFile(); // Carga el estado de los logros desde un fichero
void saveToFile(); // Guarda el estado de los logros en un fichero
// Inicializa los logros
void init();
// Busca un logro por id y devuelve el índice
auto find(int id) -> int;
// Carga el estado de los logros desde un fichero
void loadFromFile();
// Guarda el estado de los logros en un fichero
void saveToFile();
// Constructor
// Constructor y destructor privados [SINGLETON]
explicit Cheevos(std::string file);
// Destructor
~Cheevos();
public:
// [SINGLETON] Crearemos el objeto con esta función estática
static void init(const std::string& file);
// [SINGLETON] Destruiremos el objeto con esta función estática
static void destroy();
// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
static auto get() -> Cheevos*;
// Desbloquea un logro
void unlock(int id);
// Invalida un logro
void setUnobtainable(int id);
// Elimina el estado "no obtenible"
void clearUnobtainableState();
// Habilita o deshabilita los logros
void enable(bool value) { enabled_ = value; }
// Lista los logros
[[nodiscard]] auto list() const -> const std::vector<Achievement>& { return cheevos_list_; }
// Devuelve el número total de logros desbloqueados
auto getTotalUnlockedAchievements() -> int;
// Devuelve el número total de logros
auto size() -> int { return cheevos_list_.size(); }
// Variables miembro
Achievements cheevos_list_; // Listado de logros
bool enabled_{true}; // Indica si los logros se pueden obtener
std::string file_; // Fichero donde leer/almacenar el estado de los logros
};

22
source/game/gameplay/item_tracker.cpp
View File

@@ -21,9 +21,9 @@ auto ItemTracker::get() -> ItemTracker* {
// Comprueba si el objeto ya ha sido cogido
auto ItemTracker::hasBeenPicked(const std::string& name, SDL_FPoint pos) -> bool {
// Primero busca si ya hay una entrada con ese nombre
if (const int INDEX = findByName(name); INDEX != -1) {
if (const int INDEX = findByName(name); INDEX != NOT_FOUND) {
// Luego busca si existe ya una entrada con esa posición
if (findByPos(INDEX, pos) != -1) {
if (findByPos(INDEX, pos) != NOT_FOUND) {
return true;
}
}
@@ -36,12 +36,12 @@ void ItemTracker::addItem(const std::string& name, SDL_FPoint pos) {
// Comprueba si el objeto no ha sido recogido con anterioridad
if (!hasBeenPicked(name, pos)) {
// Primero busca si ya hay una entrada con ese nombre
if (const int INDEX = findByName(name); INDEX != -1) {
item_list_.at(INDEX).pos.push_back(pos);
if (const int INDEX = findByName(name); INDEX != NOT_FOUND) {
items_.at(INDEX).pos.push_back(pos);
}
// En caso contrario crea la entrada
else {
item_list_.emplace_back(name, pos);
items_.emplace_back(name, pos);
}
}
}
@@ -50,26 +50,26 @@ void ItemTracker::addItem(const std::string& name, SDL_FPoint pos) {
auto ItemTracker::findByName(const std::string& name) -> int {
int i = 0;
for (const auto& l : item_list_) {
if (l.name == name) {
for (const auto& item : items_) {
if (item.name == name) {
return i;
}
i++;
}
return -1;
return NOT_FOUND;
}
// Busca una entrada en la lista por posición
auto ItemTracker::findByPos(int index, SDL_FPoint pos) -> int {
int i = 0;
for (const auto& l : item_list_[index].pos) {
if ((l.x == pos.x) && (l.y == pos.y)) {
for (const auto& item : items_[index].pos) {
if ((item.x == pos.x) && (item.y == pos.y)) {
return i;
}
i++;
}
return -1;
return NOT_FOUND;
}

68
source/game/gameplay/item_tracker.hpp
View File

@@ -6,50 +6,44 @@
#include <utility>
#include <vector> // Para vector
struct ItemTrackerData {
std::string name; // Nombre de la habitación donde se encuentra el objeto
std::vector<SDL_FPoint> pos; // Lista de objetos cogidos de la habitación
// Constructor
ItemTrackerData(std::string name, const SDL_FPoint& position)
: name(std::move(name)) {
pos.push_back(position);
}
};
class ItemTracker {
public:
// Gestión singleton
static void init(); // Inicialización
static void destroy(); // Destrucción
static auto get() -> ItemTracker*; // Acceso al singleton
// Gestión de items
auto hasBeenPicked(const std::string& name, SDL_FPoint pos) -> bool; // Comprueba si el objeto ya ha sido cogido
void addItem(const std::string& name, SDL_FPoint pos); // Añade el objeto a la lista
private:
// [SINGLETON] Objeto privado
static ItemTracker* item_tracker;
// Tipos anidados privados
struct Data {
std::string name{}; // Nombre de la habitación donde se encuentra el objeto
std::vector<SDL_FPoint> pos{}; // Lista de objetos cogidos de la habitación
// Variables
std::vector<ItemTrackerData> item_list_; // Lista con todos los objetos recogidos
// Constructor para facilitar creación con posición inicial
Data(std::string name, const SDL_FPoint& position)
: name(std::move(name)) {
pos.push_back(position);
}
};
// Busca una entrada en la lista por nombre
auto findByName(const std::string& name) -> int;
// Constantes privadas
static constexpr int NOT_FOUND = -1; // Valor de retorno cuando no se encuentra un elemento
// Busca una entrada en la lista por posición
auto findByPos(int index, SDL_FPoint pos) -> int;
// Constantes singleton
static ItemTracker* item_tracker; // [SINGLETON] Objeto privado
// Constructor
// Métodos privados
auto findByName(const std::string& name) -> int; // Busca una entrada en la lista por nombre
auto findByPos(int index, SDL_FPoint pos) -> int; // Busca una entrada en la lista por posición
// Constructor y destructor privados [SINGLETON]
ItemTracker() = default;
// Destructor
~ItemTracker() = default;
public:
// [SINGLETON] Crearemos el objeto con esta función estática
static void init();
// [SINGLETON] Destruiremos el objeto con esta función estática
static void destroy();
// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
static auto get() -> ItemTracker*;
// Comprueba si el objeto ya ha sido cogido
auto hasBeenPicked(const std::string& name, SDL_FPoint pos) -> bool;
// Añade el objeto a la lista de objetos cogidos
void addItem(const std::string& name, SDL_FPoint pos);
// Variables miembro
std::vector<Data> items_; // Lista con todos los objetos recogidos
};

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

@@ -26,23 +26,12 @@ Room::Room(const std::string& room_path, std::shared_ptr<ScoreboardData> data)
auto room = Resource::get()->getRoom(room_path);
initializeRoom(*room);
// Abre la Jail si se da el caso
openTheJail();
// Inicializa las superficies de colision
initRoomSurfaces();
// Busca los tiles animados
setAnimatedTiles();
// Crea la textura para el mapa de tiles de la habitación
map_surface_ = std::make_shared<Surface>(PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT);
// Pinta el mapa de la habitación en la textura
fillMapTexture();
// Establece el color del borde
Screen::get()->setBorderColor(stringToColor(border_color_));
openTheJail(); // Abre la Jail si se da el caso
initRoomSurfaces(); // Inicializa las superficies de colision
setAnimatedTiles(); // Busca los tiles animados
map_surface_ = std::make_shared<Surface>(PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT); // Crea la textura para el mapa de tiles de la habitación
fillMapTexture(); // Pinta el mapa de la habitación en la textura
Screen::get()->setBorderColor(stringToColor(border_color_)); // Establece el color del borde
}
void Room::initializeRoom(const Data& room) {
@@ -867,17 +856,8 @@ auto Room::setEnemy(Enemy::Data* enemy, const std::string& key, const std::strin
bool success = true;
try {
/*if (key == "tileSetFile") {
enemy->surface_path = value;
} else */
if (key == "animation") {
enemy->animation_path = value;
/* [DOC:29/10/2025] w i h ja no fan falta, se pilla del .ANI
} else if (key == "width") {
enemy->w = std::stoi(value);
} else if (key == "height") {
enemy->h = std::stoi(value);
[/DOC] */
} else if (key == "x") {
enemy->x = std::stof(value) * TILE_SIZE;
} else if (key == "y") {

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

@@ -33,31 +33,23 @@ class Room {
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;
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 y destructor
@@ -95,12 +87,19 @@ class Room {
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:
// --- Constantes ---
// Tipos anidados privados
struct AnimatedTile {
std::shared_ptr<SurfaceSprite> sprite{nullptr}; // 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
};
// 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
static constexpr float CONVEYOR_FRAME_DURATION = 0.05F; // Duración de cada frame de conveyor belt (3 frames @ 60fps)
// --- Objetos y punteros ---
// Objetos y punteros
std::vector<std::shared_ptr<Enemy>> enemies_; // Listado con los enemigos de la habitación
std::vector<std::shared_ptr<Item>> items_; // Listado con los items que hay en la habitación
std::shared_ptr<Surface> surface_; // Textura con los graficos de la habitación
@@ -121,21 +120,18 @@ class Room {
std::string tile_set_file_; // Imagen con los graficos para la habitación
std::string tile_map_file_; // Fichero con el mapa de indices de tile
std::vector<int> tile_map_; // Indice de los tiles a dibujar en la habitación
int conveyor_belt_direction_ = 0; // Sentido en el que arrastran las superficies automáticas de la habitación
int conveyor_belt_direction_{0}; // Sentido en el que arrastran las superficies automáticas de la habitación
std::vector<LineHorizontal> bottom_floors_; // Lista con las superficies inferiores de la habitación
std::vector<LineHorizontal> top_floors_; // Lista con las superficies superiores de la habitación
std::vector<LineVertical> left_walls_; // Lista con las superficies laterales de la parte izquierda de la habitación
std::vector<LineVertical> right_walls_; // Lista con las superficies laterales de la parte derecha de la habitación
std::vector<LineDiagonal> left_slopes_; // Lista con todas las rampas que suben hacia la izquierda
std::vector<LineDiagonal> right_slopes_; // Lista con todas las rampas que suben hacia la derecha
float time_accumulator_ = 0.0F; // Acumulador de tiempo para animaciones (time-based)
bool is_paused_ = false; // Indica si el mapa esta en modo pausa
// Constantes de tiempo
static constexpr float CONVEYOR_FRAME_DURATION = 0.05F; // Duración de cada frame de conveyor belt (3 frames @ 60fps)
std::vector<AnimatedTile> animated_tiles_; // Vector con los indices de tiles animados
std::vector<LineHorizontal> conveyor_belt_floors_; // Lista con las superficies automaticas de la habitación
int tile_set_width_ = 0; // Ancho del tileset en tiles
float time_accumulator_{0.0F}; // Acumulador de tiempo para animaciones (time-based)
bool is_paused_{false}; // Indica si el mapa esta en modo pausa
std::vector<AnimatedTile> animated_tiles_; // Vector con los indices de tiles animados
std::vector<LineHorizontal> conveyor_belt_floors_; // Lista con las superficies automaticas de la habitación
int tile_set_width_{0}; // Ancho del tileset en tiles
// --- Funciones ---
void initializeRoom(const Data& room); // Inicializa los valores

4
source/game/gameplay/room_tracker.cpp
View File

@@ -4,7 +4,7 @@
// Comprueba si la habitación ya ha sido visitada
auto RoomTracker::hasBeenVisited(const std::string& name) -> bool {
return std::ranges::any_of(list_, [&name](const auto& l) { return l == name; });
return std::ranges::any_of(rooms_, [&name](const auto& l) { return l == name; });
}
// Añade la habitación a la lista
@@ -12,7 +12,7 @@ auto RoomTracker::addRoom(const std::string& name) -> bool {
// Comprueba si la habitación ya ha sido visitada
if (!hasBeenVisited(name)) {
// En caso contrario añádela a la lista
list_.push_back(name);
rooms_.push_back(name);
return true;
}

20
source/game/gameplay/room_tracker.hpp
View File

@@ -4,20 +4,14 @@
#include <vector> // Para vector
class RoomTracker {
private:
// Variables
std::vector<std::string> list_; // Lista con las habitaciones visitadas
// Comprueba si la habitación ya ha sido visitada
auto hasBeenVisited(const std::string& name) -> bool;
public:
// Constructor
RoomTracker() = default;
RoomTracker() = default; // Constructor
~RoomTracker() = default; // Destructor
// Destructor
~RoomTracker() = default;
auto addRoom(const std::string& name) -> bool; // Añade la habitación a la lista
// Añade la habitación a la lista
auto addRoom(const std::string& name) -> bool;
private:
auto hasBeenVisited(const std::string& name) -> bool; // Comprueba si ya ha sido visitada
std::vector<std::string> rooms_; // Lista con habitaciones visitadas
};