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

clang-format

Browse Source
This commit is contained in:
Sergio
2025-11-21 18:02:53 +01:00
parent d011a41d5a
commit 88ce6cd570
38 changed files with 484 additions and 413 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
source/core/audio/audio.hpp
View File

@@ -77,9 +77,9 @@ class Audio {
private: private:
// --- Tipos anidados --- // --- Tipos anidados ---
struct Music { struct Music {
MusicState state{MusicState::STOPPED}; // Estado actual de la música MusicState state{MusicState::STOPPED}; // Estado actual de la música
std::string name; // Última pista de música reproducida std::string name; // Última pista de música reproducida
bool loop{false}; // Indica si se reproduce en bucle bool loop{false}; // Indica si se reproduce en bucle
}; };
// --- Métodos --- // --- Métodos ---
@@ -90,8 +90,8 @@ class Audio {
// --- Variables miembro --- // --- Variables miembro ---
static Audio* instance; // Instancia única de Audio static Audio* instance; // Instancia única de Audio
Music music_; // Estado de la música Music music_; // Estado de la música
bool enabled_{true}; // Estado general del audio bool enabled_{true}; // Estado general del audio
bool sound_enabled_{true}; // Estado de los efectos de sonido bool sound_enabled_{true}; // Estado de los efectos de sonido
bool music_enabled_{true}; // Estado de la música bool music_enabled_{true}; // Estado de la música
}; };

2
source/core/input/global_inputs.cpp
View File

@@ -218,7 +218,7 @@ void handle() {
break; break;
case InputAction::TOGGLE_DEBUG: case InputAction::TOGGLE_DEBUG:
//handleToggleDebug(); // handleToggleDebug();
break; break;
#ifdef _DEBUG #ifdef _DEBUG

70
source/core/input/input.hpp
View File

@@ -9,7 +9,7 @@
#include <utility> // Para pair #include <utility> // Para pair
#include <vector> // Para vector #include <vector> // Para vector
#include "core/input/input_types.hpp" // for InputAction #include "core/input/input_types.hpp" // for InputAction
// --- Clase Input: gestiona la entrada de teclado y mandos (singleton) --- // --- Clase Input: gestiona la entrada de teclado y mandos (singleton) ---
class Input { class Input {
@@ -27,17 +27,17 @@ class Input {
// --- Estructuras --- // --- Estructuras ---
struct KeyState { struct KeyState {
Uint8 scancode{0}; // Scancode asociado Uint8 scancode{0}; // Scancode asociado
bool is_held{false}; // Está pulsada ahora mismo bool is_held{false}; // Está pulsada ahora mismo
bool just_pressed{false}; // Se acaba de pulsar en este fotograma bool just_pressed{false}; // Se acaba de pulsar en este fotograma
}; };
struct ButtonState { struct ButtonState {
int button{static_cast<int>(SDL_GAMEPAD_BUTTON_INVALID)}; // GameControllerButton asociado int button{static_cast<int>(SDL_GAMEPAD_BUTTON_INVALID)}; // GameControllerButton asociado
bool is_held{false}; // Está pulsada ahora mismo bool is_held{false}; // Está pulsada ahora mismo
bool just_pressed{false}; // Se acaba de pulsar en este fotograma bool just_pressed{false}; // Se acaba de pulsar en este fotograma
bool axis_active{false}; // Estado del eje bool axis_active{false}; // Estado del eje
bool trigger_active{false}; // Estado del trigger como botón digital bool trigger_active{false}; // Estado del trigger como botón digital
}; };
struct Keyboard { struct Keyboard {
@@ -45,33 +45,33 @@ class Input {
}; };
struct Gamepad { struct Gamepad {
SDL_Gamepad* pad{nullptr}; // Puntero al gamepad SDL SDL_Gamepad* pad{nullptr}; // Puntero al gamepad SDL
SDL_JoystickID instance_id{0}; // ID de instancia del joystick SDL_JoystickID instance_id{0}; // ID de instancia del joystick
std::string name; // Nombre del gamepad std::string name; // Nombre del gamepad
std::string path; // Ruta del dispositivo std::string path; // Ruta del dispositivo
std::unordered_map<Action, ButtonState> bindings; // Mapa de acciones a estados de botón std::unordered_map<Action, ButtonState> bindings; // Mapa de acciones a estados de botón
explicit Gamepad(SDL_Gamepad* gamepad) explicit Gamepad(SDL_Gamepad* gamepad)
: pad(gamepad), : pad(gamepad),
instance_id(SDL_GetJoystickID(SDL_GetGamepadJoystick(gamepad))), instance_id(SDL_GetJoystickID(SDL_GetGamepadJoystick(gamepad))),
name(std::string(SDL_GetGamepadName(gamepad))), name(std::string(SDL_GetGamepadName(gamepad))),
path(std::string(SDL_GetGamepadPath(pad))), path(std::string(SDL_GetGamepadPath(pad))),
bindings{ bindings{
// Movimiento del jugador // Movimiento del jugador
{Action::LEFT, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_DPAD_LEFT)}}, {Action::LEFT, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_DPAD_LEFT)}},
{Action::RIGHT, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_DPAD_RIGHT)}}, {Action::RIGHT, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_DPAD_RIGHT)}},
{Action::JUMP, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_WEST)}}} {} {Action::JUMP, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_WEST)}}} {}
~Gamepad() { ~Gamepad() {
if (pad != nullptr) { if (pad != nullptr) {
SDL_CloseGamepad(pad); SDL_CloseGamepad(pad);
}
} }
}
// Reasigna un botón a una acción // Reasigna un botón a una acción
void rebindAction(Action action, SDL_GamepadButton new_button) { void rebindAction(Action action, SDL_GamepadButton new_button) {
bindings[action].button = static_cast<int>(new_button); bindings[action].button = static_cast<int>(new_button);
} }
}; };
// --- Tipos --- // --- Tipos ---
@@ -134,7 +134,7 @@ class Input {
// --- Variables miembro --- // --- Variables miembro ---
static Input* instance; // Instancia única del singleton static Input* instance; // Instancia única del singleton
Gamepads gamepads_; // Lista de gamepads conectados Gamepads gamepads_; // Lista de gamepads conectados
Keyboard keyboard_{}; // Estado del teclado Keyboard keyboard_{}; // Estado del teclado
std::string gamepad_mappings_file_; // Ruta al archivo de mappings std::string gamepad_mappings_file_; // Ruta al archivo de mappings
}; };

94
source/core/rendering/screen.hpp
View File

@@ -23,8 +23,8 @@ class Screen {
}; };
// Singleton // Singleton
static void init(); // Crea el singleton static void init(); // Crea el singleton
static void destroy(); // Destruye el singleton static void destroy(); // Destruye el singleton
static auto get() -> Screen*; // Obtiene el singleton static auto get() -> Screen*; // Obtiene el singleton
// Renderizado // Renderizado
@@ -35,32 +35,32 @@ class Screen {
void update(float delta_time); // Actualiza la lógica de la clase void update(float delta_time); // Actualiza la lógica de la clase
// Video y ventana // Video y ventana
void setVideoMode(bool mode); // Establece el modo de video void setVideoMode(bool mode); // Establece el modo de video
void toggleVideoMode(); // Cambia entre pantalla completa y ventana void toggleVideoMode(); // Cambia entre pantalla completa y ventana
void toggleIntegerScale(); // Alterna entre activar y desactivar el escalado entero void toggleIntegerScale(); // Alterna entre activar y desactivar el escalado entero
void toggleVSync(); // Alterna entre activar y desactivar el V-Sync void toggleVSync(); // Alterna entre activar y desactivar el V-Sync
auto decWindowZoom() -> bool; // Reduce el tamaño de la ventana auto decWindowZoom() -> bool; // Reduce el tamaño de la ventana
auto incWindowZoom() -> bool; // Aumenta el tamaño de la ventana auto incWindowZoom() -> bool; // Aumenta el tamaño de la ventana
void show(); // Muestra la ventana void show(); // Muestra la ventana
void hide(); // Oculta la ventana void hide(); // Oculta la ventana
// Borde // Borde
void setBorderColor(Uint8 color); // Cambia el color del borde void setBorderColor(Uint8 color); // Cambia el color del borde
static void setBorderWidth(int width); // Establece el ancho del borde static void setBorderWidth(int width); // Establece el ancho del borde
static void setBorderHeight(int height); // Establece el alto del borde static void setBorderHeight(int height); // Establece el alto del borde
static void setBorderEnabled(bool value); // Establece si se ha de ver el borde static void setBorderEnabled(bool value); // Establece si se ha de ver el borde
void toggleBorder(); // Cambia entre borde visible y no visible void toggleBorder(); // Cambia entre borde visible y no visible
// Paletas y shaders // Paletas y shaders
void nextPalette(); // Cambia a la siguiente paleta void nextPalette(); // Cambia a la siguiente paleta
void previousPalette(); // Cambia a la paleta anterior void previousPalette(); // Cambia a la paleta anterior
void setPalete(); // Establece la paleta actual void setPalete(); // Establece la paleta actual
void toggleShaders(); // Cambia el estado de los shaders void toggleShaders(); // Cambia el estado de los shaders
// Surfaces y notificaciones // Surfaces y notificaciones
void setRendererSurface(const std::shared_ptr<Surface>& surface = nullptr); // Establece el renderizador para las surfaces void setRendererSurface(const std::shared_ptr<Surface>& surface = nullptr); // Establece el renderizador para las surfaces
void setNotificationsEnabled(bool value); // Establece la visibilidad de las notificaciones void setNotificationsEnabled(bool value); // Establece la visibilidad de las notificaciones
void toggleDebugInfo(); // Activa o desactiva la información de debug void toggleDebugInfo(); // Activa o desactiva la información de debug
// Getters // Getters
auto getRenderer() -> SDL_Renderer*; auto getRenderer() -> SDL_Renderer*;
@@ -78,22 +78,22 @@ class Screen {
}; };
struct FPS { struct FPS {
Uint32 ticks{0}; // Tiempo en milisegundos desde que se comenzó a contar Uint32 ticks{0}; // Tiempo en milisegundos desde que se comenzó a contar
int frame_count{0}; // Número acumulado de frames en el intervalo int frame_count{0}; // Número acumulado de frames en el intervalo
int last_value{0}; // Número de frames calculado en el último segundo int last_value{0}; // Número de frames calculado en el último segundo
void increment() { void increment() {
frame_count++; frame_count++;
} }
auto calculate(Uint32 current_ticks) -> int { auto calculate(Uint32 current_ticks) -> int {
if (current_ticks - ticks >= 1000) { if (current_ticks - ticks >= 1000) {
last_value = frame_count; last_value = frame_count;
frame_count = 0; frame_count = 0;
ticks = current_ticks; ticks = current_ticks;
}
return last_value;
} }
return last_value;
}
}; };
// Constantes // Constantes
@@ -123,8 +123,8 @@ class Screen {
~Screen(); ~Screen();
// Objetos SDL // Objetos SDL
SDL_Window* window_{nullptr}; // Ventana de la aplicación SDL_Window* window_{nullptr}; // Ventana de la aplicación
SDL_Renderer* renderer_{nullptr}; // Renderizador de la ventana SDL_Renderer* renderer_{nullptr}; // Renderizador de la ventana
SDL_Texture* game_texture_{nullptr}; // Textura donde se dibuja el juego SDL_Texture* game_texture_{nullptr}; // Textura donde se dibuja el juego
SDL_Texture* border_texture_{nullptr}; // Textura donde se dibuja el borde del juego SDL_Texture* border_texture_{nullptr}; // Textura donde se dibuja el borde del juego
@@ -136,14 +136,14 @@ class Screen {
std::shared_ptr<Text> text_; // Objeto para escribir texto std::shared_ptr<Text> text_; // Objeto para escribir texto
// Configuración de ventana y pantalla // Configuración de ventana y pantalla
int window_width_{0}; // Ancho de la pantalla o ventana int window_width_{0}; // Ancho de la pantalla o ventana
int window_height_{0}; // Alto de la pantalla o ventana int window_height_{0}; // Alto de la pantalla o ventana
SDL_FRect game_surface_dstrect_; // Coordenadas donde se dibuja la textura del juego SDL_FRect game_surface_dstrect_; // Coordenadas donde se dibuja la textura del juego
// Paletas y colores // Paletas y colores
Uint8 border_color_{0}; // Color del borde Uint8 border_color_{0}; // Color del borde
std::vector<std::string> palettes_; // Listado de ficheros de paleta disponibles std::vector<std::string> palettes_; // Listado de ficheros de paleta disponibles
Uint8 current_palette_{0}; // Índice para el vector de paletas Uint8 current_palette_{0}; // Índice para el vector de paletas
// Estado y configuración // Estado y configuración
bool notifications_enabled_{false}; // Indica si se muestran las notificaciones bool notifications_enabled_{false}; // Indica si se muestran las notificaciones
@@ -151,12 +151,12 @@ class Screen {
DisplayMonitor display_monitor_; // Información de la pantalla DisplayMonitor display_monitor_; // Información de la pantalla
// Shaders // Shaders
std::string info_resolution_; // Texto con la información de la pantalla std::string info_resolution_; // Texto con la información de la pantalla
std::string vertex_shader_source_; // Almacena el vertex shader std::string vertex_shader_source_; // Almacena el vertex shader
std::string fragment_shader_source_; // Almacena el fragment shader std::string fragment_shader_source_; // Almacena el fragment shader
#ifdef _DEBUG #ifdef _DEBUG
bool show_debug_info_{true}; // Indica si ha de mostrar la información de debug bool show_debug_info_{true}; // Indica si ha de mostrar la información de debug
#else #else
bool show_debug_info_{false}; // Indica si ha de mostrar la información de debug bool show_debug_info_{false}; // Indica si ha de mostrar la información de debug
#endif #endif

2
source/core/rendering/surface_animated_sprite.hpp
View File

@@ -8,7 +8,7 @@
#include <vector> // Para vector #include <vector> // Para vector
#include "core/rendering/surface_moving_sprite.hpp" // Para SMovingSprite #include "core/rendering/surface_moving_sprite.hpp" // Para SMovingSprite
#include "core/resources/resource_types.hpp" // Para AnimationResource #include "core/resources/resource_types.hpp" // Para AnimationResource
class Surface; class Surface;

4
source/core/rendering/surface_sprite.hpp
View File

@@ -19,8 +19,8 @@ class SurfaceSprite {
virtual ~SurfaceSprite() = default; virtual ~SurfaceSprite() = default;
// Actualización y renderizado // Actualización y renderizado
virtual void update(float delta_time); // Actualiza el estado del sprite (time-based) virtual void update(float delta_time); // Actualiza el estado del sprite (time-based)
virtual void render(); // Muestra el sprite por pantalla virtual void render(); // Muestra el sprite por pantalla
virtual void render(Uint8 source_color, Uint8 target_color); // Renderiza con reemplazo de color virtual void render(Uint8 source_color, Uint8 target_color); // Renderiza con reemplazo de color
// Gestión de estado // Gestión de estado

12
source/core/rendering/text.hpp
View File

@@ -36,17 +36,17 @@ class Text {
static constexpr int CENTER_FLAG = 4; static constexpr int CENTER_FLAG = 4;
static constexpr int STROKE_FLAG = 8; static constexpr int STROKE_FLAG = 8;
void write(int x, int y, const std::string& text, int kerning = 1, int lenght = -1); // Escribe el texto en pantalla void write(int x, int y, const std::string& text, int kerning = 1, int lenght = -1); // Escribe el texto en pantalla
void writeColored(int x, int y, const std::string& text, Uint8 color, int kerning = 1, int lenght = -1); // Escribe el texto con colores void writeColored(int x, int y, const std::string& text, Uint8 color, int kerning = 1, int lenght = -1); // Escribe el texto con colores
void writeShadowed(int x, int y, const std::string& text, Uint8 color, Uint8 shadow_distance = 1, int kerning = 1, int lenght = -1); // Escribe el texto con sombra void writeShadowed(int x, int y, const std::string& text, Uint8 color, Uint8 shadow_distance = 1, int kerning = 1, int lenght = -1); // Escribe el texto con sombra
void writeCentered(int x, int y, const std::string& text, int kerning = 1, int lenght = -1); // Escribe el texto centrado en un punto x void writeCentered(int x, int y, const std::string& text, int kerning = 1, int lenght = -1); // Escribe el texto centrado en un punto x
void writeDX(Uint8 flags, int x, int y, const std::string& text, int kerning = 1, Uint8 text_color = Uint8(), Uint8 shadow_distance = 1, Uint8 shadow_color = Uint8(), int lenght = -1); // Escribe texto con extras void writeDX(Uint8 flags, int x, int y, const std::string& text, int kerning = 1, Uint8 text_color = Uint8(), Uint8 shadow_distance = 1, Uint8 shadow_color = Uint8(), int lenght = -1); // Escribe texto con extras
auto writeToSurface(const std::string& text, int zoom = 1, int kerning = 1) -> std::shared_ptr<Surface>; // Escribe el texto en una textura auto writeToSurface(const std::string& text, int zoom = 1, int kerning = 1) -> std::shared_ptr<Surface>; // Escribe el texto en una textura
auto writeDXToSurface(Uint8 flags, const std::string& text, int kerning = 1, Uint8 text_color = Uint8(), Uint8 shadow_distance = 1, Uint8 shadow_color = Uint8(), int lenght = -1) -> std::shared_ptr<Surface>; // Escribe el texto con extras en una textura auto writeDXToSurface(Uint8 flags, const std::string& text, int kerning = 1, Uint8 text_color = Uint8(), Uint8 shadow_distance = 1, Uint8 shadow_color = Uint8(), int lenght = -1) -> std::shared_ptr<Surface>; // Escribe el texto con extras en una textura
[[nodiscard]] auto length(const std::string& text, int kerning = 1) const -> int; // Obtiene la longitud en pixels de una cadena [[nodiscard]] auto length(const std::string& text, int kerning = 1) const -> int; // Obtiene la longitud en pixels de una cadena
[[nodiscard]] auto getCharacterSize() const -> int; // Devuelve el tamaño del caracter [[nodiscard]] auto getCharacterSize() const -> int; // Devuelve el tamaño del caracter
void setFixedWidth(bool value); // Establece si se usa un tamaño fijo de letra void setFixedWidth(bool value); // Establece si se usa un tamaño fijo de letra

20
source/core/rendering/texture.hpp
View File

@@ -9,24 +9,24 @@ struct Color; // lines 11-11
class Texture { class Texture {
public: public:
explicit Texture(SDL_Renderer* renderer, std::string path = std::string()); // Constructor explicit Texture(SDL_Renderer* renderer, std::string path = std::string()); // Constructor
~Texture(); // Destructor ~Texture(); // Destructor
auto loadFromFile(const std::string& path) -> bool; // Carga una imagen desde un fichero auto loadFromFile(const std::string& path) -> bool; // Carga una imagen desde un fichero
auto createBlank(int width, int height, SDL_PixelFormat format = SDL_PIXELFORMAT_RGBA8888, SDL_TextureAccess access = SDL_TEXTUREACCESS_STREAMING) -> bool; // Crea una textura en blanco auto createBlank(int width, int height, SDL_PixelFormat format = SDL_PIXELFORMAT_RGBA8888, SDL_TextureAccess access = SDL_TEXTUREACCESS_STREAMING) -> bool; // Crea una textura en blanco
auto reLoad() -> bool; // Recarga la textura auto reLoad() -> bool; // Recarga la textura
void setColor(Uint8 red, Uint8 green, Uint8 blue); // Establece el color para la modulacion void setColor(Uint8 red, Uint8 green, Uint8 blue); // Establece el color para la modulacion
void setColor(Color color); // Establece el color para la modulacion void setColor(Color color); // Establece el color para la modulacion
void setBlendMode(SDL_BlendMode blending); // Establece el blending void setBlendMode(SDL_BlendMode blending); // Establece el blending
void setAlpha(Uint8 alpha); // Establece el alpha para la modulación void setAlpha(Uint8 alpha); // Establece el alpha para la modulación
void setAsRenderTarget(SDL_Renderer* renderer); // Establece la textura como objetivo de renderizado void setAsRenderTarget(SDL_Renderer* renderer); // Establece la textura como objetivo de renderizado
void render(float x, float y, SDL_FRect* clip = nullptr, float zoom_w = 1, float zoom_h = 1, double angle = 0.0, SDL_FPoint* center = nullptr, SDL_FlipMode flip = SDL_FLIP_NONE); // Renderiza la textura en un punto específico void render(float x, float y, SDL_FRect* clip = nullptr, float zoom_w = 1, float zoom_h = 1, double angle = 0.0, SDL_FPoint* center = nullptr, SDL_FlipMode flip = SDL_FLIP_NONE); // Renderiza la textura en un punto específico
[[nodiscard]] auto getWidth() const -> int { return width_; } // Obtiene el ancho de la imagen [[nodiscard]] auto getWidth() const -> int { return width_; } // Obtiene el ancho de la imagen
[[nodiscard]] auto getHeight() const -> int { return height_; } // Obtiene el alto de la imagen [[nodiscard]] auto getHeight() const -> int { return height_; } // Obtiene el alto de la imagen
auto getSDLTexture() -> SDL_Texture*; // Obtiene la textura auto getSDLTexture() -> SDL_Texture*; // Obtiene la textura
auto getRenderer() -> SDL_Renderer*; // Obtiene el renderizador auto getRenderer() -> SDL_Renderer*; // Obtiene el renderizador
private: private:
void unloadTexture(); // Libera la memoria de la textura void unloadTexture(); // Libera la memoria de la textura

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

@@ -15,7 +15,7 @@ class Cache {
static void destroy(); // Destrucción singleton static void destroy(); // Destrucción singleton
static auto get() -> Cache*; // Acceso al singleton static auto get() -> Cache*; // Acceso al singleton
auto getSound(const std::string& name) -> JA_Sound_t*; // Getters de recursos auto getSound(const std::string& name) -> JA_Sound_t*; // Getters de recursos
auto getMusic(const std::string& name) -> JA_Music_t*; auto getMusic(const std::string& name) -> JA_Music_t*;
auto getSurface(const std::string& name) -> std::shared_ptr<Surface>; auto getSurface(const std::string& name) -> std::shared_ptr<Surface>;
auto getPalette(const std::string& name) -> Palette; auto getPalette(const std::string& name) -> Palette;
@@ -86,8 +86,8 @@ class Cache {
std::vector<AnimationResource> animations_; // Vector con las animaciones std::vector<AnimationResource> animations_; // Vector con las animaciones
std::vector<RoomResource> rooms_; // Vector con las habitaciones std::vector<RoomResource> rooms_; // Vector con las habitaciones
ResourceCount count_{}; // Contador de recursos ResourceCount count_{}; // Contador de recursos
std::shared_ptr<Text> loading_text_; // Texto para la pantalla de carga std::shared_ptr<Text> loading_text_; // Texto para la pantalla de carga
}; };
} // namespace Resource } // namespace Resource

8
source/core/resources/resource_loader.hpp
View File

@@ -21,14 +21,14 @@ class Loader {
auto loadResource(const std::string& filename) -> std::vector<uint8_t>; // Load resource data auto loadResource(const std::string& filename) -> std::vector<uint8_t>; // Load resource data
auto resourceExists(const std::string& filename) -> bool; // Check resource availability auto resourceExists(const std::string& filename) -> bool; // Check resource availability
[[nodiscard]] auto isPackLoaded() const -> bool; // Pack status queries [[nodiscard]] auto isPackLoaded() const -> bool; // Pack status queries
[[nodiscard]] auto getPackResourceCount() const -> size_t; [[nodiscard]] auto getPackResourceCount() const -> size_t;
[[nodiscard]] auto validatePack() const -> bool; // Validate pack integrity [[nodiscard]] auto validatePack() const -> bool; // Validate pack integrity
[[nodiscard]] auto loadAssetsConfig() const -> std::string; // Load assets.yaml from pack [[nodiscard]] auto loadAssetsConfig() const -> std::string; // Load assets.yaml from pack
void shutdown(); // Cleanup void shutdown(); // Cleanup
Loader(const Loader&) = delete; // Deleted copy/move constructors Loader(const Loader&) = delete; // Deleted copy/move constructors
auto operator=(const Loader&) -> Loader& = delete; auto operator=(const Loader&) -> Loader& = delete;
Loader(Loader&&) = delete; Loader(Loader&&) = delete;
auto operator=(Loader&&) -> Loader& = delete; auto operator=(Loader&&) -> Loader& = delete;

3
source/core/resources/resource_pack.cpp
View File

@@ -68,8 +68,7 @@ auto Pack::addFile(const std::string& filepath, const std::string& pack_name)
.filename = pack_name, .filename = pack_name,
.offset = data_.size(), .offset = data_.size(),
.size = file_data.size(), .size = file_data.size(),
.checksum = calculateChecksum(file_data) .checksum = calculateChecksum(file_data)};
};
// Append file data to the data block // Append file data to the data block
data_.insert(data_.end(), file_data.begin(), file_data.end()); data_.insert(data_.end(), file_data.begin(), file_data.end());

12
source/core/resources/resource_pack.hpp
View File

@@ -13,10 +13,10 @@ namespace Resource {
// Entry metadata for each resource in the pack // Entry metadata for each resource in the pack
struct ResourceEntry { struct ResourceEntry {
std::string filename; // Relative path within pack std::string filename; // Relative path within pack
uint64_t offset{0}; // Byte offset in data block uint64_t offset{0}; // Byte offset in data block
uint64_t size{0}; // Size in bytes uint64_t size{0}; // Size in bytes
uint32_t checksum{0}; // CRC32 checksum for verification uint32_t checksum{0}; // CRC32 checksum for verification
}; };
// Resource pack file format // Resource pack file format
@@ -28,7 +28,7 @@ class Pack {
Pack() = default; Pack() = default;
~Pack() = default; ~Pack() = default;
Pack(const Pack&) = delete; // Deleted copy/move constructors Pack(const Pack&) = delete; // Deleted copy/move constructors
auto operator=(const Pack&) -> Pack& = delete; auto operator=(const Pack&) -> Pack& = delete;
Pack(Pack&&) = delete; Pack(Pack&&) = delete;
auto operator=(Pack&&) -> Pack& = delete; auto operator=(Pack&&) -> Pack& = delete;
@@ -43,7 +43,7 @@ class Pack {
auto hasResource(const std::string& filename) const -> bool; auto hasResource(const std::string& filename) const -> bool;
auto getResourceList() const -> std::vector<std::string>; auto getResourceList() const -> std::vector<std::string>;
auto isLoaded() const -> bool { return loaded_; } // Status queries auto isLoaded() const -> bool { return loaded_; } // Status queries
auto getResourceCount() const -> size_t { return resources_.size(); } auto getResourceCount() const -> size_t { return resources_.size(); }
auto getDataSize() const -> size_t { return data_.size(); } auto getDataSize() const -> size_t { return data_.size(); }
auto calculatePackChecksum() const -> uint32_t; // Validation auto calculatePackChecksum() const -> uint32_t; // Validation

4
source/core/resources/resource_types.hpp
View File

@@ -33,8 +33,8 @@ struct SurfaceResource {
// Estructura para almacenar objetos Palette y su nombre // Estructura para almacenar objetos Palette y su nombre
struct ResourcePalette { struct ResourcePalette {
std::string name; // Nombre de la surface std::string name; // Nombre de la surface
Palette palette{}; // Paleta Palette palette{}; // Paleta
}; };
// Estructura para almacenar ficheros TextFile y su nombre // Estructura para almacenar ficheros TextFile y su nombre

4
source/core/system/director.hpp
View File

@@ -8,8 +8,8 @@
class Director { class Director {
public: public:
explicit Director(std::vector<std::string> const& args); // Constructor explicit Director(std::vector<std::string> const& args); // Constructor
~Director(); // Destructor ~Director(); // Destructor
static auto run() -> int; // Bucle principal static auto run() -> int; // Bucle principal
private: private:
// --- Variables --- // --- Variables ---

22
source/game/entities/enemy.hpp
View File

@@ -27,8 +27,8 @@ class Enemy {
explicit Enemy(const Data& enemy); // Constructor explicit Enemy(const Data& enemy); // Constructor
~Enemy() = default; // Destructor ~Enemy() = default; // Destructor
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
auto getRect() -> SDL_FRect; // Devuelve el rectangulo que contiene al enemigo auto getRect() -> SDL_FRect; // Devuelve el rectangulo que contiene al enemigo
auto getCollider() -> SDL_FRect&; // Obtiene el rectangulo de colision del enemigo auto getCollider() -> SDL_FRect&; // Obtiene el rectangulo de colision del enemigo
@@ -39,13 +39,13 @@ class Enemy {
std::shared_ptr<SurfaceAnimatedSprite> sprite_; // Sprite del enemigo std::shared_ptr<SurfaceAnimatedSprite> sprite_; // Sprite del enemigo
// Variables // Variables
Uint8 color_{0}; // Color del enemigo Uint8 color_{0}; // Color del enemigo
std::string color_string_; // Color del enemigo en formato texto std::string color_string_; // Color del enemigo en formato texto
int x1_{0}; // Limite izquierdo de la ruta en el eje X int x1_{0}; // Limite izquierdo de la ruta en el eje X
int x2_{0}; // Limite derecho de la ruta en el eje X int x2_{0}; // Limite derecho de la ruta en el eje X
int y1_{0}; // Limite superior de la ruta en el eje Y int y1_{0}; // Limite superior de la ruta en el eje Y
int y2_{0}; // Limite inferior de la ruta en el eje Y int y2_{0}; // Limite inferior de la ruta en el eje Y
SDL_FRect collider_{}; // Caja de colisión SDL_FRect collider_{}; // Caja de colisión
bool should_flip_{false}; // Indica si el enemigo hace flip al terminar su ruta bool should_flip_{false}; // Indica si el enemigo hace flip al terminar su ruta
bool should_mirror_{false}; // Indica si el enemigo se dibuja volteado verticalmente bool should_mirror_{false}; // Indica si el enemigo se dibuja volteado verticalmente
}; };

12
source/game/entities/item.hpp
View File

@@ -22,7 +22,7 @@ class Item {
explicit Item(const Data& item); // Constructor explicit Item(const Data& item); // Constructor
~Item() = default; // Destructor ~Item() = default; // Destructor
void render() const; // Pinta el objeto en pantalla void render() const; // Pinta el objeto en pantalla
void update(float delta_time); // Actualiza las variables del objeto void update(float delta_time); // Actualiza las variables del objeto
void setPaused(bool paused) { is_paused_ = paused; } // Pausa/despausa el item void setPaused(bool paused) { is_paused_ = paused; } // Pausa/despausa el item
@@ -31,14 +31,14 @@ class Item {
void setColors(Uint8 col1, Uint8 col2); // Asigna los colores del objeto void setColors(Uint8 col1, Uint8 col2); // Asigna los colores del objeto
private: private:
static constexpr float ITEM_SIZE = 8.0F; // Tamaño del item en pixels static constexpr float ITEM_SIZE = 8.0F; // Tamaño del item en pixels
static constexpr float COLOR_CHANGE_INTERVAL = 0.06F; // Intervalo de cambio de color en segundos (4 frames a 66.67fps) static constexpr float COLOR_CHANGE_INTERVAL = 0.06F; // Intervalo de cambio de color en segundos (4 frames a 66.67fps)
std::shared_ptr<SurfaceSprite> sprite_; // SSprite del objeto std::shared_ptr<SurfaceSprite> sprite_; // SSprite del objeto
// Variables // Variables
std::vector<Uint8> color_; // Vector con los colores del objeto std::vector<Uint8> color_; // Vector con los colores del objeto
float time_accumulator_{0.0F}; // Acumulador de tiempo para cambio de color float time_accumulator_{0.0F}; // Acumulador de tiempo para cambio de color
SDL_FRect collider_{}; // Rectangulo de colisión SDL_FRect collider_{}; // Rectangulo de colisión
bool is_paused_{false}; // Indica si el item está pausado bool is_paused_{false}; // Indica si el item está pausado
}; };

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

@@ -8,12 +8,12 @@ class Cheevos {
public: public:
// Tipos anidados (públicos porque se usan en la interfaz) // Tipos anidados (públicos porque se usan en la interfaz)
struct Achievement { struct Achievement {
int id{0}; // Identificador del logro int id{0}; // Identificador del logro
std::string caption; // Texto con el nombre del logro std::string caption; // Texto con el nombre del logro
std::string description; // Texto que describe el logro std::string description; // Texto que describe el logro
int icon{0}; // Indice del icono a utilizar en la notificación int icon{0}; // Indice del icono a utilizar en la notificación
bool completed{false}; // Indica si se ha obtenido el logro bool completed{false}; // Indica si se ha obtenido el logro
bool obtainable{true}; // Indica si se puede obtener el logro bool obtainable{true}; // Indica si se puede obtener el logro
}; };
using Achievements = std::vector<Achievement>; // Type alias para vector de logros using Achievements = std::vector<Achievement>; // Type alias para vector de logros
@@ -24,10 +24,10 @@ class Cheevos {
static auto get() -> Cheevos*; // Acceso al singleton static auto get() -> Cheevos*; // Acceso al singleton
// Gestión de logros // Gestión de logros
void unlock(int id); // Desbloquea un logro void unlock(int id); // Desbloquea un logro
void setUnobtainable(int id); // Invalida un logro void setUnobtainable(int id); // Invalida un logro
void clearUnobtainableState(); // Elimina el estado "no obtenible" void clearUnobtainableState(); // Elimina el estado "no obtenible"
void enable(bool value) { enabled_ = value; } // Habilita o deshabilita los logros void enable(bool value) { enabled_ = value; } // Habilita o deshabilita los logros
// Consultas // Consultas
[[nodiscard]] auto list() const -> const Achievements& { return cheevos_list_; } // Lista los logros [[nodiscard]] auto list() const -> const Achievements& { return cheevos_list_; } // Lista los logros
@@ -39,10 +39,10 @@ class Cheevos {
static Cheevos* cheevos; // [SINGLETON] Objeto privado static Cheevos* cheevos; // [SINGLETON] Objeto privado
// Métodos privados // Métodos privados
void init(); // Inicializa los logros void init(); // Inicializa los logros
auto find(int id) -> int; // Busca un logro por id y devuelve el índice 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 loadFromFile(); // Carga el estado de los logros desde un fichero
void saveToFile(); // Guarda el estado de los logros en un fichero void saveToFile(); // Guarda el estado de los logros en un fichero
// Constructor y destructor privados [SINGLETON] // Constructor y destructor privados [SINGLETON]
explicit Cheevos(std::string file); explicit Cheevos(std::string file);

8
source/game/gameplay/collision_map.cpp
View File

@@ -5,13 +5,13 @@
#ifdef _DEBUG #ifdef _DEBUG
#include "core/system/debug.hpp" // Para Debug #include "core/system/debug.hpp" // Para Debug
#endif #endif
#include "utils/defines.hpp" // Para Collision #include "utils/defines.hpp" // Para Collision
// Constructor // Constructor
CollisionMap::CollisionMap(std::vector<int> tile_map, int tile_set_width, int conveyor_belt_direction) CollisionMap::CollisionMap(std::vector<int> tile_map, int tile_set_width, int conveyor_belt_direction)
: tile_map_(std::move(tile_map)) : tile_map_(std::move(tile_map)),
, tile_set_width_(tile_set_width) tile_set_width_(tile_set_width),
, conveyor_belt_direction_(conveyor_belt_direction) { conveyor_belt_direction_(conveyor_belt_direction) {
// Inicializa todas las superficies de colisión // Inicializa todas las superficies de colisión
initializeSurfaces(); initializeSurfaces();
} }

42
source/game/gameplay/collision_map.hpp
View File

@@ -55,19 +55,19 @@ class CollisionMap {
auto checkBottomSurfaces(const SDL_FRect& rect) -> int; // Colisión con suelos (retorna Y) auto checkBottomSurfaces(const SDL_FRect& rect) -> int; // Colisión con suelos (retorna Y)
// --- Queries de colisión con superficies automáticas (conveyor belts) --- // --- Queries de colisión con superficies automáticas (conveyor belts) ---
auto checkAutoSurfaces(const SDL_FRect& rect) -> int; // Colisión con conveyor belts (retorna Y) auto checkAutoSurfaces(const SDL_FRect& rect) -> int; // Colisión con conveyor belts (retorna Y)
auto checkConveyorBelts(const SDL_FPoint& p) -> bool; // Colisión punto con conveyor belts auto checkConveyorBelts(const SDL_FPoint& p) -> bool; // Colisión punto con conveyor belts
// --- Queries de colisión con rampas --- // --- Queries de colisión con rampas ---
auto checkLeftSlopes(const LineVertical& line) -> int; // Colisión línea con rampas izquierdas (retorna Y) auto checkLeftSlopes(const LineVertical& line) -> int; // Colisión línea con rampas izquierdas (retorna Y)
auto checkLeftSlopes(const SDL_FPoint& p) -> bool; // Colisión punto con rampas izquierdas auto checkLeftSlopes(const SDL_FPoint& p) -> bool; // Colisión punto con rampas izquierdas
auto checkRightSlopes(const LineVertical& line) -> int; // Colisión línea con rampas derechas (retorna Y) auto checkRightSlopes(const LineVertical& line) -> int; // Colisión línea con rampas derechas (retorna Y)
auto checkRightSlopes(const SDL_FPoint& p) -> bool; // Colisión punto con rampas derechas auto checkRightSlopes(const SDL_FPoint& p) -> bool; // Colisión punto con rampas derechas
[[nodiscard]] auto getSlopeAtPoint(const SDL_FPoint& p) const -> const LineDiagonal*; // Obtiene puntero a slope en un punto [[nodiscard]] auto getSlopeAtPoint(const SDL_FPoint& p) const -> const LineDiagonal*; // Obtiene puntero a slope en un punto
// --- Métodos estáticos --- // --- Métodos estáticos ---
static auto getTileSize() -> int { return TILE_SIZE; } // Tamaño del tile en pixels static auto getTileSize() -> int { return TILE_SIZE; } // Tamaño del tile en pixels
static auto getSlopeHeight(SDL_FPoint p, Tile slope) -> int; // Altura de rampa en un punto static auto getSlopeHeight(SDL_FPoint p, Tile slope) -> int; // Altura de rampa en un punto
// --- Getters --- // --- Getters ---
[[nodiscard]] auto getConveyorBeltDirection() const -> int { return conveyor_belt_direction_; } [[nodiscard]] auto getConveyorBeltDirection() const -> int { return conveyor_belt_direction_; }
@@ -83,14 +83,14 @@ class CollisionMap {
private: private:
// --- Constantes --- // --- Constantes ---
static constexpr int TILE_SIZE = 8; // Tamaño del tile en pixels static constexpr int TILE_SIZE = 8; // Tamaño 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
// --- Datos de la habitación --- // --- Datos de la habitación ---
std::vector<int> tile_map_; // Índices de tiles de la habitación std::vector<int> tile_map_; // Índices de tiles de la habitación
int tile_set_width_; // Ancho del tileset en tiles int tile_set_width_; // Ancho del tileset en tiles
int conveyor_belt_direction_; // Dirección de conveyor belts int conveyor_belt_direction_; // Dirección de conveyor belts
// --- Geometría de colisión --- // --- Geometría de colisión ---
std::vector<LineHorizontal> bottom_floors_; // Superficies inferiores (suelos) std::vector<LineHorizontal> bottom_floors_; // Superficies inferiores (suelos)
@@ -111,11 +111,11 @@ class CollisionMap {
// Construcción de geometría // Construcción de geometría
static void buildHorizontalLines(const std::vector<int>& tiles, std::vector<LineHorizontal>& lines, bool is_bottom_surface); static void buildHorizontalLines(const std::vector<int>& tiles, std::vector<LineHorizontal>& lines, bool is_bottom_surface);
void setBottomSurfaces(); // Calcula superficies inferiores void setBottomSurfaces(); // Calcula superficies inferiores
void setTopSurfaces(); // Calcula superficies superiores void setTopSurfaces(); // Calcula superficies superiores
void setLeftSurfaces(); // Calcula paredes izquierdas void setLeftSurfaces(); // Calcula paredes izquierdas
void setRightSurfaces(); // Calcula paredes derechas void setRightSurfaces(); // Calcula paredes derechas
void setLeftSlopes(); // Calcula rampas izquierdas void setLeftSlopes(); // Calcula rampas izquierdas
void setRightSlopes(); // Calcula rampas derechas void setRightSlopes(); // Calcula rampas derechas
void setAutoSurfaces(); // Calcula conveyor belts void setAutoSurfaces(); // Calcula conveyor belts
}; };

2
source/game/gameplay/enemy_manager.cpp
View File

@@ -2,8 +2,8 @@
#include <algorithm> // Para std::ranges::any_of #include <algorithm> // Para std::ranges::any_of
#include "utils/utils.hpp" // Para checkCollision
#include "game/entities/enemy.hpp" // Para Enemy #include "game/entities/enemy.hpp" // Para Enemy
#include "utils/utils.hpp" // Para checkCollision
// Añade un enemigo a la colección // Añade un enemigo a la colección
void EnemyManager::addEnemy(std::shared_ptr<Enemy> enemy) { void EnemyManager::addEnemy(std::shared_ptr<Enemy> enemy) {

6
source/game/gameplay/enemy_manager.hpp
View File

@@ -29,9 +29,9 @@ class EnemyManager {
// Gestión de enemigos // Gestión de enemigos
void addEnemy(std::shared_ptr<Enemy> enemy); // Añade un enemigo a la colección void addEnemy(std::shared_ptr<Enemy> enemy); // Añade un enemigo a la colección
void clear(); // Elimina todos los enemigos void clear(); // Elimina todos los enemigos
void removeLastEnemy(); // Elimina el último enemigo de la colección void removeLastEnemy(); // Elimina el último enemigo de la colección
[[nodiscard]] auto isEmpty() const -> bool; // Comprueba si no hay enemigos [[nodiscard]] auto isEmpty() const -> bool; // Comprueba si no hay enemigos
// Actualización y renderizado // Actualización y renderizado
void update(float delta_time); // Actualiza todos los enemigos void update(float delta_time); // Actualiza todos los enemigos

16
source/game/gameplay/item_manager.cpp
View File

@@ -1,16 +1,16 @@
#include "item_manager.hpp" #include "item_manager.hpp"
#include "core/audio/audio.hpp" // Para Audio #include "core/audio/audio.hpp" // Para Audio
#include "utils/utils.hpp" // Para checkCollision #include "game/entities/item.hpp" // Para Item
#include "game/entities/item.hpp" // Para Item #include "game/options.hpp" // Para Options
#include "item_tracker.hpp" // Para ItemTracker #include "item_tracker.hpp" // Para ItemTracker
#include "scoreboard.hpp" // Para Scoreboard::Data #include "scoreboard.hpp" // Para Scoreboard::Data
#include "game/options.hpp" // Para Options #include "utils/utils.hpp" // Para checkCollision
// Constructor // Constructor
ItemManager::ItemManager(std::string room_name, std::shared_ptr<Scoreboard::Data> scoreboard_data) ItemManager::ItemManager(std::string room_name, std::shared_ptr<Scoreboard::Data> scoreboard_data)
: room_name_(std::move(room_name)) : room_name_(std::move(room_name)),
, data_(std::move(scoreboard_data)) { data_(std::move(scoreboard_data)) {
} }
// Añade un item a la colección // Añade un item a la colección

8
source/game/gameplay/item_manager.hpp
View File

@@ -38,7 +38,7 @@ class ItemManager {
// Gestión de items // Gestión de items
void addItem(std::shared_ptr<Item> item); // Añade un item a la colección void addItem(std::shared_ptr<Item> item); // Añade un item a la colección
void clear(); // Elimina todos los items void clear(); // Elimina todos los items
// Actualización y renderizado // Actualización y renderizado
void update(float delta_time); // Actualiza todos los items void update(float delta_time); // Actualiza todos los items
@@ -63,7 +63,7 @@ class ItemManager {
auto checkCollision(SDL_FRect& rect) -> bool; auto checkCollision(SDL_FRect& rect) -> bool;
private: private:
std::vector<std::shared_ptr<Item>> items_; // Colección de items std::vector<std::shared_ptr<Item>> items_; // Colección de items
std::string room_name_; // Nombre de la habitación std::string room_name_; // Nombre de la habitación
std::shared_ptr<Scoreboard::Data> data_; // Datos del scoreboard std::shared_ptr<Scoreboard::Data> data_; // Datos del scoreboard
}; };

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

@@ -37,7 +37,7 @@ class ItemTracker {
static ItemTracker* item_tracker; // [SINGLETON] Objeto privado static ItemTracker* item_tracker; // [SINGLETON] Objeto privado
// Métodos privados // Métodos privados
auto findByName(const std::string& name) -> int; // Busca una entrada en la lista por nombre 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 auto findByPos(int index, SDL_FPoint pos) -> int; // Busca una entrada en la lista por posición
// Constructor y destructor privados [SINGLETON] // Constructor y destructor privados [SINGLETON]

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

@@ -6,12 +6,12 @@
#include <string> // Para string #include <string> // Para string
#include <vector> // Para vector #include <vector> // Para vector
#include "game/entities/enemy.hpp" // Para EnemyData #include "game/entities/enemy.hpp" // Para EnemyData
#include "game/entities/item.hpp" // Para ItemData #include "game/entities/item.hpp" // Para ItemData
#include "game/gameplay/scoreboard.hpp" // Para Scoreboard::Data #include "game/gameplay/scoreboard.hpp" // Para Scoreboard::Data
#include "utils/utils.hpp" // Para LineHorizontal, LineDiagonal, LineVertical #include "utils/utils.hpp" // Para LineHorizontal, LineDiagonal, LineVertical
class SurfaceSprite; // lines 12-12 class SurfaceSprite; // lines 12-12
class Surface; // lines 13-13 class Surface; // lines 13-13
class EnemyManager; class EnemyManager;
class ItemManager; class ItemManager;
class CollisionMap; class CollisionMap;
@@ -38,21 +38,21 @@ class Room {
}; };
struct Data { struct Data {
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 abajo 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 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 gráficos para la habitación std::string tile_set_file; // Imagen con los gráficos para 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<int> tile_map; // Índice de los tiles a dibujar en la habitación (embebido desde YAML) std::vector<int> tile_map; // Índice de los tiles a dibujar en la habitación (embebido desde YAML)
std::vector<Enemy::Data> enemies; // Listado con los enemigos de 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 std::vector<Item::Data> items; // Listado con los items que hay en la habitación
}; };
// Constructor y destructor // Constructor y destructor
@@ -60,37 +60,37 @@ class Room {
~Room(); // Definido en .cpp para poder usar unique_ptr con forward declarations ~Room(); // Definido en .cpp para poder usar unique_ptr con forward declarations
// --- Funciones --- // --- Funciones ---
[[nodiscard]] auto getName() const -> const std::string& { return name_; } // Devuelve el nombre de la habitación [[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 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 [[nodiscard]] auto getBorderColor() const -> Uint8 { return stringToColor(border_color_); } // Devuelve el color del borde
void renderMap(); // Dibuja el mapa en pantalla void renderMap(); // Dibuja el mapa en pantalla
void renderEnemies(); // Dibuja los enemigos en pantalla void renderEnemies(); // Dibuja los enemigos en pantalla
void renderItems(); // Dibuja los objetos en pantalla void renderItems(); // Dibuja los objetos en pantalla
#ifdef _DEBUG #ifdef _DEBUG
void redrawMap(); // Redibuja el mapa (para actualizar modo debug) void redrawMap(); // Redibuja el mapa (para actualizar modo debug)
#endif #endif
void update(float delta_time); // Actualiza las variables y objetos de la habitación 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 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 getTile(SDL_FPoint point) -> Tile; // Devuelve el tipo de tile que hay en ese pixel
auto getTile(int index) -> Tile; // Devuelve el tipo de tile en un índice del tilemap auto getTile(int index) -> Tile; // Devuelve el tipo de tile en un índice del tilemap
auto enemyCollision(SDL_FRect& rect) -> bool; // Indica si hay colision con un enemigo a partir de un rectangulo 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 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 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 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(const SDL_FRect& rect) -> int; // Comprueba las colisiones auto checkRightSurfaces(const SDL_FRect& rect) -> int; // Comprueba las colisiones
auto checkLeftSurfaces(const SDL_FRect& rect) -> int; // Comprueba las colisiones auto checkLeftSurfaces(const SDL_FRect& rect) -> int; // Comprueba las colisiones
auto checkTopSurfaces(const SDL_FRect& rect) -> int; // Comprueba las colisiones auto checkTopSurfaces(const SDL_FRect& rect) -> int; // Comprueba las colisiones
auto checkBottomSurfaces(const SDL_FRect& rect) -> int; // Comprueba las colisiones auto checkBottomSurfaces(const SDL_FRect& rect) -> int; // Comprueba las colisiones
auto checkAutoSurfaces(const SDL_FRect& rect) -> int; // Comprueba las colisiones auto checkAutoSurfaces(const SDL_FRect& rect) -> int; // Comprueba las colisiones
auto checkTopSurfaces(const SDL_FPoint& p) -> bool; // Comprueba las colisiones auto checkTopSurfaces(const SDL_FPoint& p) -> bool; // Comprueba las colisiones
auto checkConveyorBelts(const SDL_FPoint& p) -> bool; // Comprueba las colisiones auto checkConveyorBelts(const SDL_FPoint& p) -> bool; // Comprueba las colisiones
auto checkLeftSlopes(const LineVertical& line) -> int; // Comprueba las colisiones auto checkLeftSlopes(const LineVertical& line) -> int; // Comprueba las colisiones
auto checkLeftSlopes(const SDL_FPoint& p) -> bool; // Comprueba las colisiones auto checkLeftSlopes(const SDL_FPoint& p) -> bool; // Comprueba las colisiones
auto checkRightSlopes(const LineVertical& line) -> int; // Comprueba las colisiones auto checkRightSlopes(const LineVertical& line) -> int; // Comprueba las colisiones
auto checkRightSlopes(const SDL_FPoint& p) -> bool; // Comprueba las colisiones auto checkRightSlopes(const SDL_FPoint& p) -> bool; // Comprueba las colisiones
[[nodiscard]] auto getSlopeAtPoint(const SDL_FPoint& p) const -> const LineDiagonal*; // Obtiene puntero a slope en un punto [[nodiscard]] auto getSlopeAtPoint(const SDL_FPoint& p) const -> const LineDiagonal*; // Obtiene puntero a slope en un punto
void setPaused(bool value); // Pone el mapa en modo pausa void setPaused(bool value); // Pone el mapa en modo pausa
[[nodiscard]] auto getConveyorBeltDirection() const -> int { return conveyor_belt_direction_; } // Obten la direccion de las superficies automaticas [[nodiscard]] auto getConveyorBeltDirection() const -> int { return conveyor_belt_direction_; } // Obten la direccion de las superficies automaticas
// Método de carga de archivos YAML (delegado a RoomLoader) // Método de carga de archivos YAML (delegado a RoomLoader)
static auto loadYAML(const std::string& file_path, bool verbose = false) -> Data; // Carga habitación desde archivo YAML unificado static auto loadYAML(const std::string& file_path, bool verbose = false) -> Data; // Carga habitación desde archivo YAML unificado
@@ -110,21 +110,21 @@ class Room {
std::shared_ptr<Scoreboard::Data> data_; // Puntero a los datos del marcador std::shared_ptr<Scoreboard::Data> 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::vector<int> tile_map_; // Indice de los tiles a dibujar en la habitación (embebido desde YAML) std::vector<int> tile_map_; // Indice de los tiles a dibujar en la habitación (embebido desde YAML)
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
bool is_paused_{false}; // Indica si el mapa esta en modo pausa bool is_paused_{false}; // Indica si el mapa esta en modo pausa
int tile_set_width_{0}; // Ancho del tileset en tiles int tile_set_width_{0}; // Ancho del tileset en tiles
// --- Funciones --- // --- Funciones ---
void initializeRoom(const Data& room); // Inicializa los valores void initializeRoom(const Data& room); // Inicializa los valores

2
source/game/gameplay/room_loader.cpp
View File

@@ -2,9 +2,9 @@
#include <exception> // Para exception #include <exception> // Para exception
#include <iostream> // Para cout, cerr #include <iostream> // Para cout, cerr
#include "external/fkyaml_node.hpp" // Para fkyaml::node
#include "core/resources/resource_helper.hpp" // Para Resource::Helper #include "core/resources/resource_helper.hpp" // Para Resource::Helper
#include "external/fkyaml_node.hpp" // Para fkyaml::node
#include "utils/defines.hpp" // Para Tile::SIZE #include "utils/defines.hpp" // Para Tile::SIZE
#include "utils/utils.hpp" // Para stringToColor #include "utils/utils.hpp" // Para stringToColor

8
source/game/gameplay/stats.hpp
View File

@@ -18,10 +18,10 @@ class Stats {
// Variables // Variables
std::vector<Dictionary> dictionary_; // Lista con la equivalencia nombre-numero de habitacion std::vector<Dictionary> dictionary_; // Lista con la equivalencia nombre-numero de habitacion
std::vector<RoomData> buffer_list_; // Lista con las estadisticas temporales por habitación std::vector<RoomData> buffer_list_; // Lista con las estadisticas temporales por habitación
std::vector<RoomData> list_; // Lista con las estadisticas completas por habitación std::vector<RoomData> list_; // Lista con las estadisticas completas por habitación
std::string buffer_path_; // Fichero con las estadísticas temporales std::string buffer_path_; // Fichero con las estadísticas temporales
std::string file_path_; // Fichero con las estadísticas completas std::string file_path_; // Fichero con las estadísticas completas
// Busca una entrada en la lista por nombre // Busca una entrada en la lista por nombre
static auto findByName(const std::string& name, const std::vector<RoomData>& list) -> int; static auto findByName(const std::string& name, const std::vector<RoomData>& list) -> int;

2
source/game/scene_manager.hpp
View File

@@ -34,7 +34,7 @@ enum class Options {
// --- Variables de estado globales --- // --- Variables de estado globales ---
#ifdef _DEBUG #ifdef _DEBUG
inline Scene current = Scene::GAME; // Escena actual inline Scene current = Scene::GAME; // Escena actual
inline Options options = Options::LOGO_TO_LOADING_SCREEN; // Opciones de la escena actual inline Options options = Options::LOGO_TO_LOADING_SCREEN; // Opciones de la escena actual
#else #else
inline Scene current = Scene::LOGO; // Escena actual inline Scene current = Scene::LOGO; // Escena actual

68
source/game/scenes/ending.cpp
View File

@@ -25,23 +25,13 @@ Ending::Ending()
SceneManager::current = SceneManager::Scene::ENDING; SceneManager::current = SceneManager::Scene::ENDING;
SceneManager::options = SceneManager::Options::NONE; SceneManager::options = SceneManager::Options::NONE;
// Inicializa los textos iniTexts(); // Inicializa los textos
iniTexts(); iniPics(); // Inicializa las imagenes
iniScenes(); // Inicializa las escenas
// Inicializa las imagenes Screen::get()->setBorderColor(static_cast<Uint8>(PaletteColor::BLACK)); // Cambia el color del borde
iniPics(); cover_surface_ = std::make_shared<Surface>(Options::game.width, Options::game.height + 8); // Crea la textura para cubrir el texto
fillCoverTexture(); // Rellena la textura para la cortinilla
// Inicializa las escenas
iniScenes();
// Cambia el color del borde
Screen::get()->setBorderColor(static_cast<Uint8>(PaletteColor::BLACK));
// Crea la textura para cubrir el texto
cover_surface_ = std::make_shared<Surface>(Options::game.width, Options::game.height + 8);
// Rellena la textura para la cortinilla
fillCoverTexture();
} }
// Actualiza el objeto // Actualiza el objeto
@@ -446,55 +436,55 @@ void Ending::updateSpriteCovers() {
const float PIXELS_REVEALED = TIME_SINCE_TRIGGER * TEXT_REVEAL_SPEED; const float PIXELS_REVEALED = TIME_SINCE_TRIGGER * TEXT_REVEAL_SPEED;
// Obtiene el sprite // Obtiene el sprite
auto SPRITE_TEXT = sprite_texts_.at(ti.index); auto sprite_text = sprite_texts_.at(ti.index);
// Obtener altura inicial de la superficie // Obtener altura inicial de la superficie
const float INITIAL_HEIGHT = SPRITE_TEXT.image_surface->getHeight(); const float INITIAL_HEIGHT = sprite_text.image_surface->getHeight();
const float Y_INITIAL = SPRITE_TEXT.image_sprite->getY(); const float Y_INITIAL = sprite_text.image_sprite->getY();
// Fase 1: Revelar malla decorativa (8 píxeles) // Fase 1: Revelar malla decorativa (8 píxeles)
if (PIXELS_REVEALED < 8.0F) { if (PIXELS_REVEALED < 8.0F) {
SPRITE_TEXT.cover_clip_desp = static_cast<int>(8.0F - PIXELS_REVEALED); sprite_text.cover_clip_desp = static_cast<int>(8.0F - PIXELS_REVEALED);
SPRITE_TEXT.cover_clip_height = static_cast<int>(INITIAL_HEIGHT); sprite_text.cover_clip_height = static_cast<int>(INITIAL_HEIGHT);
SPRITE_TEXT.cover_sprite->setY(Y_INITIAL); sprite_text.cover_sprite->setY(Y_INITIAL);
} }
// Fase 2: Revelar contenido // Fase 2: Revelar contenido
else { else {
SPRITE_TEXT.cover_clip_desp = 0; sprite_text.cover_clip_desp = 0;
const int CONTENT_PIXELS = PIXELS_REVEALED - 8.0F; const int CONTENT_PIXELS = PIXELS_REVEALED - 8.0F;
SPRITE_TEXT.cover_clip_height = std::max(0, static_cast<int>(INITIAL_HEIGHT - CONTENT_PIXELS)); sprite_text.cover_clip_height = std::max(0, static_cast<int>(INITIAL_HEIGHT - CONTENT_PIXELS));
SPRITE_TEXT.cover_sprite->setY(Y_INITIAL + static_cast<int>(CONTENT_PIXELS)); sprite_text.cover_sprite->setY(Y_INITIAL + static_cast<int>(CONTENT_PIXELS));
} }
SPRITE_TEXT.cover_sprite->setClip( sprite_text.cover_sprite->setClip(
0, 0,
SPRITE_TEXT.cover_clip_desp, sprite_text.cover_clip_desp,
SPRITE_TEXT.cover_sprite->getWidth(), sprite_text.cover_sprite->getWidth(),
SPRITE_TEXT.cover_clip_height); sprite_text.cover_clip_height);
} }
} }
// Actualiza la cortinilla de las imágenes (revelación continua desde el inicio de la escena) // Actualiza la cortinilla de las imágenes (revelación continua desde el inicio de la escena)
auto SPRITE_PICS = sprite_pics_.at(current_scene_); auto sprite_pics = sprite_pics_.at(current_scene_);
const float PIXELS_REVEALED = state_time_ * IMAGE_REVEAL_SPEED; const float PIXELS_REVEALED = state_time_ * IMAGE_REVEAL_SPEED;
const float INITIAL_HEIGHT = SPRITE_PICS.image_surface->getHeight(); const float INITIAL_HEIGHT = sprite_pics.image_surface->getHeight();
const float Y_INITIAL = SPRITE_PICS.image_sprite->getY(); const float Y_INITIAL = sprite_pics.image_sprite->getY();
// Fase 1: Revelar malla decorativa (8 píxeles) // Fase 1: Revelar malla decorativa (8 píxeles)
if (PIXELS_REVEALED < 8.0F) { if (PIXELS_REVEALED < 8.0F) {
SPRITE_PICS.cover_clip_desp = static_cast<int>(8.0F - PIXELS_REVEALED); sprite_pics.cover_clip_desp = static_cast<int>(8.0F - PIXELS_REVEALED);
SPRITE_PICS.cover_clip_height = static_cast<int>(INITIAL_HEIGHT); sprite_pics.cover_clip_height = static_cast<int>(INITIAL_HEIGHT);
SPRITE_PICS.cover_sprite->setY(Y_INITIAL); sprite_pics.cover_sprite->setY(Y_INITIAL);
} }
// Fase 2: Revelar contenido // Fase 2: Revelar contenido
else { else {
SPRITE_PICS.cover_clip_desp = 0; sprite_pics.cover_clip_desp = 0;
const int CONTENT_PIXELS = PIXELS_REVEALED - 8.0F; const int CONTENT_PIXELS = PIXELS_REVEALED - 8.0F;
SPRITE_PICS.cover_clip_height = std::max(0, static_cast<int>(INITIAL_HEIGHT - CONTENT_PIXELS)); sprite_pics.cover_clip_height = std::max(0, static_cast<int>(INITIAL_HEIGHT - CONTENT_PIXELS));
SPRITE_PICS.cover_sprite->setY(Y_INITIAL + static_cast<int>(CONTENT_PIXELS)); sprite_pics.cover_sprite->setY(Y_INITIAL + static_cast<int>(CONTENT_PIXELS));
} }
SPRITE_PICS.cover_sprite->setClip(0, SPRITE_PICS.cover_clip_desp, SPRITE_PICS.cover_sprite->getWidth(), SPRITE_PICS.cover_clip_height); sprite_pics.cover_sprite->setClip(0, sprite_pics.cover_clip_desp, sprite_pics.cover_sprite->getWidth(), sprite_pics.cover_clip_height);
} }
// Comprueba si se ha de cambiar de escena // Comprueba si se ha de cambiar de escena

20
source/game/scenes/ending.hpp
View File

@@ -87,16 +87,16 @@ class Ending {
// --- Variables miembro --- // --- Variables miembro ---
// Objetos y punteros a recursos // Objetos y punteros a recursos
std::shared_ptr<Surface> cover_surface_; // Surface para cubrir el texto std::shared_ptr<Surface> cover_surface_; // Surface para cubrir el texto
std::unique_ptr<DeltaTimer> delta_timer_; // Timer para time-based update std::unique_ptr<DeltaTimer> delta_timer_; // Timer para time-based update
std::vector<EndingSurface> sprite_texts_; // Vector con los sprites de texto con su cortinilla std::vector<EndingSurface> sprite_texts_; // Vector con los sprites de texto con su cortinilla
std::vector<EndingSurface> sprite_pics_; // Vector con los sprites de imágenes con su cortinilla std::vector<EndingSurface> sprite_pics_; // Vector con los sprites de imágenes con su cortinilla
std::vector<SceneData> scenes_; // Vector con los textos e imágenes de cada escena std::vector<SceneData> scenes_; // Vector con los textos e imágenes de cada escena
// Variables de estado // Variables de estado
State state_{State::WARMING_UP}; // Estado actual State state_{State::WARMING_UP}; // Estado actual
float state_time_{0.0F}; // Tiempo acumulado en el estado actual float state_time_{0.0F}; // Tiempo acumulado en el estado actual
float total_time_{0.0F}; // Tiempo total acumulado desde el inicio float total_time_{0.0F}; // Tiempo total acumulado desde el inicio
float fadeout_time_{0.0F}; // Tiempo acumulado para el fade-out float fadeout_time_{0.0F}; // Tiempo acumulado para el fade-out
int current_scene_{0}; // Escena actual (0-4) int current_scene_{0}; // Escena actual (0-4)
}; };

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

@@ -82,13 +82,21 @@ void Game::handleEvents() {
void Game::handleInput() { void Game::handleInput() {
Input::get()->update(); Input::get()->update();
// Inputs globales siempre funcionan
if (Input::get()->checkAction(InputAction::TOGGLE_MUSIC, Input::DO_NOT_ALLOW_REPEAT)) { if (Input::get()->checkAction(InputAction::TOGGLE_MUSIC, Input::DO_NOT_ALLOW_REPEAT)) {
board_->music = !board_->music; board_->music = !board_->music;
board_->music ? Audio::get()->resumeMusic() : Audio::get()->pauseMusic(); board_->music ? Audio::get()->resumeMusic() : Audio::get()->pauseMusic();
Notifier::get()->show({"MUSIC " + std::string(board_->music ? "ENABLED" : "DISABLED")}); Notifier::get()->show({"MUSIC " + std::string(board_->music ? "ENABLED" : "DISABLED")});
} }
else if (Input::get()->checkAction(InputAction::PAUSE, Input::DO_NOT_ALLOW_REPEAT)) { // Durante fade/postfade, solo procesar inputs globales
if (state_ != State::PLAYING) {
GlobalInputs::handle();
return;
}
// Input de pausa solo en estado PLAYING
if (Input::get()->checkAction(InputAction::PAUSE, Input::DO_NOT_ALLOW_REPEAT)) {
togglePause(); togglePause();
Notifier::get()->show({std::string(paused_ ? "GAME PAUSED" : "GAME RUNNING")}); Notifier::get()->show({std::string(paused_ ? "GAME PAUSED" : "GAME RUNNING")});
} }
@@ -124,28 +132,18 @@ void Game::update() {
Debug::get()->clear(); Debug::get()->clear();
#endif #endif
// Actualiza los objetos // Dispatch por estado
room_->update(DELTA_TIME); switch (state_) {
switch (mode_) { case State::PLAYING:
case Mode::GAME: updatePlaying(DELTA_TIME);
player_->update(DELTA_TIME);
checkPlayerIsOnBorder();
checkPlayerAndItems();
checkPlayerAndEnemies();
checkIfPlayerIsAlive();
checkGameOver();
checkEndGame();
checkRestoringJail(DELTA_TIME);
checkSomeCheevos();
break; break;
case State::FADE_TO_ENDING:
case Mode::DEMO: updateFadeToEnding(DELTA_TIME);
demoCheckRoomChange(DELTA_TIME); break;
case State::POST_FADE_ENDING:
updatePostFadeEnding(DELTA_TIME);
break; break;
} }
scoreboard_->update(DELTA_TIME);
keepMusicPlaying();
updateBlackScreen(DELTA_TIME);
Audio::update(); // Actualiza el objeto Audio Audio::update(); // Actualiza el objeto Audio
Screen::get()->update(DELTA_TIME); // Actualiza el objeto Screen Screen::get()->update(DELTA_TIME); // Actualiza el objeto Screen
@@ -155,6 +153,73 @@ void Game::update() {
#endif #endif
} }
// Actualiza el juego en estado PLAYING
void Game::updatePlaying(float delta_time) {
// Actualiza los objetos
room_->update(delta_time);
switch (mode_) {
case Mode::GAME:
player_->update(delta_time);
checkPlayerIsOnBorder();
checkPlayerAndItems();
checkPlayerAndEnemies();
checkIfPlayerIsAlive();
checkGameOver();
checkEndGame();
checkRestoringJail(delta_time);
checkSomeCheevos();
break;
case Mode::DEMO:
demoCheckRoomChange(delta_time);
break;
}
scoreboard_->update(delta_time);
keepMusicPlaying();
updateBlackScreen(delta_time);
}
// Actualiza el juego en estado FADE_TO_ENDING
void Game::updateFadeToEnding(float delta_time) {
// Actualiza room, enemies, items (todo sigue funcionando)
room_->update(delta_time);
// NO actualizar player (congelar movimiento)
// player_->update(delta_time); -- COMENTADO INTENCIONALMENTE
// Actualiza scoreboard
scoreboard_->update(delta_time);
keepMusicPlaying();
// Aplica el fade progresivo
fade_accumulator_ += delta_time;
if (fade_accumulator_ >= FADE_STEP_INTERVAL) {
fade_accumulator_ = 0.0F;
if (Screen::get()->getRendererSurface()->fadeSubPalette()) {
// Fade completado, transicionar a POST_FADE
transitionToState(State::POST_FADE_ENDING);
}
}
}
// Actualiza el juego en estado POST_FADE_ENDING
void Game::updatePostFadeEnding(float delta_time) {
// Pantalla negra estática, acumular tiempo
state_time_ += delta_time;
// Después del delay, cambiar a la escena de ending
if (state_time_ >= POST_FADE_DELAY) {
SceneManager::current = SceneManager::Scene::ENDING;
}
}
// Cambia al estado especificado y resetea los timers
void Game::transitionToState(State new_state) {
state_ = new_state;
state_time_ = 0.0F;
fade_accumulator_ = 0.0F;
}
// Pinta los objetos en pantalla // Pinta los objetos en pantalla
void Game::render() { void Game::render() {
// Prepara para dibujar el frame // Prepara para dibujar el frame
@@ -434,7 +499,9 @@ auto Game::checkEndGame() -> bool {
// Comprueba los logros de completar el juego // Comprueba los logros de completar el juego
checkEndGameCheevos(); checkEndGameCheevos();
SceneManager::current = SceneManager::Scene::ENDING; // Iniciar transición de fade en vez de cambio inmediato de escena
transitionToState(State::FADE_TO_ENDING);
Audio::get()->fadeOutMusic(1000); // Fade out de música en 1 segundo
return true; return true;
} }

21
source/game/scenes/game.hpp
View File

@@ -23,6 +23,12 @@ class Game {
GAME GAME
}; };
enum class State {
PLAYING, // Normal gameplay
FADE_TO_ENDING, // Fade out transition
POST_FADE_ENDING, // Black screen delay before ending
};
// --- Constructor y Destructor --- // --- Constructor y Destructor ---
explicit Game(Mode mode); explicit Game(Mode mode);
~Game(); ~Game();
@@ -36,12 +42,14 @@ class Game {
static constexpr float GAME_OVER_THRESHOLD = 0.255F; // Tiempo antes del game over en segundos (17 frames a 66.67fps) static constexpr float GAME_OVER_THRESHOLD = 0.255F; // Tiempo antes del game over en segundos (17 frames a 66.67fps)
static constexpr float DEMO_ROOM_DURATION = 6.0F; // Duración de cada habitación en modo demo en segundos (400 frames) static constexpr float DEMO_ROOM_DURATION = 6.0F; // Duración de cada habitación en modo demo en segundos (400 frames)
static constexpr float JAIL_RESTORE_INTERVAL = 1.5F; // Intervalo de restauración de vidas en la Jail en segundos (100 frames) static constexpr float JAIL_RESTORE_INTERVAL = 1.5F; // Intervalo de restauración de vidas en la Jail en segundos (100 frames)
static constexpr float FADE_STEP_INTERVAL = 0.05F; // Intervalo entre pasos de fade en segundos
static constexpr float POST_FADE_DELAY = 1.0F; // Duración de la pantalla negra después del fade
// --- Estructuras --- // --- Estructuras ---
struct DemoData { struct DemoData {
float time_accumulator{0.0F}; // Acumulador de tiempo para el modo demo float time_accumulator{0.0F}; // Acumulador de tiempo para el modo demo
int room_index{0}; // Índice para el vector de habitaciones int room_index{0}; // Índice para el vector de habitaciones
std::vector<std::string> rooms; // Listado con los mapas de la demo std::vector<std::string> rooms; // Listado con los mapas de la demo
}; };
// --- Métodos --- // --- Métodos ---
@@ -49,6 +57,10 @@ class Game {
void render(); // Pinta los objetos en pantalla void render(); // Pinta los objetos en pantalla
void handleEvents(); // Comprueba los eventos de la cola void handleEvents(); // Comprueba los eventos de la cola
void renderRoomName(); // Escribe el nombre de la pantalla void renderRoomName(); // Escribe el nombre de la pantalla
void transitionToState(State new_state); // Cambia al estado especificado y resetea los timers
void updatePlaying(float delta_time); // Actualiza el juego en estado PLAYING
void updateFadeToEnding(float delta_time); // Actualiza el juego en estado FADE_TO_ENDING
void updatePostFadeEnding(float delta_time); // Actualiza el juego en estado POST_FADE_ENDING
auto changeRoom(const std::string& room_path) -> bool; // Cambia de habitación auto changeRoom(const std::string& room_path) -> bool; // Cambia de habitación
void handleInput(); // Comprueba el teclado void handleInput(); // Comprueba el teclado
void checkPlayerIsOnBorder(); // Comprueba si el jugador esta en el borde de la pantalla y actua void checkPlayerIsOnBorder(); // Comprueba si el jugador esta en el borde de la pantalla y actua
@@ -92,11 +104,14 @@ class Game {
// Variables de estado del juego // Variables de estado del juego
Mode mode_; // Modo del juego Mode mode_; // Modo del juego
State state_{State::PLAYING}; // Estado actual de la escena
DeltaTimer delta_timer_; // Timer para calcular delta time DeltaTimer delta_timer_; // Timer para calcular delta time
std::string current_room_; // Fichero de la habitación actual std::string current_room_; // Fichero de la habitación actual
Player::SpawnData spawn_data_; // Lugar de la habitación donde aparece el jugador Player::SpawnData spawn_data_; // Lugar de la habitación donde aparece el jugador
int total_items_; // Cantidad total de items que hay en el mapeado del juego int total_items_; // Cantidad total de items que hay en el mapeado del juego
bool paused_{false}; // Indica si el juego se encuentra en pausa bool paused_{false}; // Indica si el juego se encuentra en pausa
float state_time_{0.0F}; // Tiempo acumulado en el estado actual
float fade_accumulator_{0.0F}; // Acumulador de tiempo para el fade
// Variables de demo mode // Variables de demo mode
DemoData demo_; // Variables para el modo demo DemoData demo_; // Variables para el modo demo

8
source/game/scenes/game_over.hpp
View File

@@ -60,10 +60,10 @@ class GameOver {
std::shared_ptr<DeltaTimer> delta_timer_; // Timer para time-based logic std::shared_ptr<DeltaTimer> delta_timer_; // Timer para time-based logic
// Variables de estado de la escena // Variables de estado de la escena
State state_{State::WAITING}; // Estado actual de la escena State state_{State::WAITING}; // Estado actual de la escena
float elapsed_time_{0.0F}; // Tiempo transcurrido en el estado actual float elapsed_time_{0.0F}; // Tiempo transcurrido en el estado actual
// Variables de efectos visuales // Variables de efectos visuales
std::vector<Uint8> colors_; // Vector con los colores para el fade std::vector<Uint8> colors_; // Vector con los colores para el fade
Uint8 color_{0}; // Color actual para texto y sprites Uint8 color_{0}; // Color actual para texto y sprites
}; };

20
source/game/scenes/loading_screen.hpp
View File

@@ -61,7 +61,7 @@ class LoadingScreen {
// --- Constantes de tiempo (en segundos) --- // --- Constantes de tiempo (en segundos) ---
static constexpr float SILENT1_DURATION = 2.0F; // Pausa inicial static constexpr float SILENT1_DURATION = 2.0F; // Pausa inicial
static constexpr float HEADER1_DURATION = 4.0F; // Cabecera static constexpr float HEADER1_DURATION = 4.0F; // Cabecera
static constexpr float DATA1_DURATION = 0.18F; // Datos static constexpr float DATA1_DURATION = 0.18F; // Datos
static constexpr float SILENT2_DURATION = 1.6F; // Segunda pausa static constexpr float SILENT2_DURATION = 1.6F; // Segunda pausa
static constexpr float HEADER2_DURATION = 2.0F; // Cabecera pantalla static constexpr float HEADER2_DURATION = 2.0F; // Cabecera pantalla
static constexpr float LOADING_MONO_DURATION = 16.0F; // Duración total de la carga monocromática static constexpr float LOADING_MONO_DURATION = 16.0F; // Duración total de la carga monocromática
@@ -107,17 +107,17 @@ class LoadingScreen {
std::unique_ptr<DeltaTimer> delta_timer_; // Timer para delta time std::unique_ptr<DeltaTimer> delta_timer_; // Timer para delta time
// Variables de estado de la secuencia // Variables de estado de la secuencia
State state_{State::SILENT1}; // Estado actual de la secuencia State state_{State::SILENT1}; // Estado actual de la secuencia
float state_time_{0.0F}; // Tiempo acumulado en el estado actual float state_time_{0.0F}; // Tiempo acumulado en el estado actual
Border current_border_type_{Border::NONE}; // Tipo de borde actual Border current_border_type_{Border::NONE}; // Tipo de borde actual
// Arrays y estructuras auxiliares // Arrays y estructuras auxiliares
std::array<int, MONO_TOTAL_LINES> line_index_; // El orden en el que se procesan las 192 líneas de la pantalla de carga std::array<int, MONO_TOTAL_LINES> line_index_; // El orden en el que se procesan las 192 líneas de la pantalla de carga
SDL_FRect load_rect_{0.0F, 0.0F, 0.0F, 1.0F}; // Rectángulo para dibujar la pantalla de carga SDL_FRect load_rect_{0.0F, 0.0F, 0.0F, 1.0F}; // Rectángulo para dibujar la pantalla de carga
Carrier carrier_; // Estructura para los efectos de la carga de cabeceras Carrier carrier_; // Estructura para los efectos de la carga de cabeceras
Noise noise_; // Variaciones de ruido durante los silencios Noise noise_; // Variaciones de ruido durante los silencios
// Variables de seguimiento para evitar saltos de pasos/bloques // Variables de seguimiento para evitar saltos de pasos/bloques
int last_mono_step_{-1}; // Último paso mono dibujado int last_mono_step_{-1}; // Último paso mono dibujado
int last_color_block_{-1}; // Último bloque color dibujado int last_color_block_{-1}; // Último bloque color dibujado
}; };

48
source/game/scenes/logo.hpp
View File

@@ -44,35 +44,35 @@ class Logo {
static constexpr int JAILGAMES_DEST_X = 37; // Posición X de destino para JAILGAMES static constexpr int JAILGAMES_DEST_X = 37; // Posición X de destino para JAILGAMES
// --- Métodos --- // --- Métodos ---
void update(); // Actualiza las variables void update(); // Actualiza las variables
void render(); // Dibuja en pantalla void render(); // Dibuja en pantalla
static void handleEvents(); // Comprueba el manejador de eventos static void handleEvents(); // Comprueba el manejador de eventos
static void handleInput(); // Comprueba las entradas static void handleInput(); // Comprueba las entradas
void updateJAILGAMES(float delta_time); // Gestiona el logo de JAILGAME (time-based) void updateJAILGAMES(float delta_time); // Gestiona el logo de JAILGAME (time-based)
void updateTextureColors(); // Gestiona el color de las texturas void updateTextureColors(); // Gestiona el color de las texturas
void updateState(float delta_time); // Actualiza el estado actual void updateState(float delta_time); // Actualiza el estado actual
void transitionToState(State new_state); // Transiciona a un nuevo estado void transitionToState(State new_state); // Transiciona a un nuevo estado
[[nodiscard]] auto getColorIndex(float progress) const -> int; // Calcula el índice de color según el progreso (0.0-1.0) [[nodiscard]] auto getColorIndex(float progress) const -> int; // Calcula el índice de color según el progreso (0.0-1.0)
static void endSection(); // Termina la sección static void endSection(); // Termina la sección
void initColors(); // Inicializa el vector de colores void initColors(); // Inicializa el vector de colores
void initSprites(); // Crea los sprites de cada linea void initSprites(); // Crea los sprites de cada linea
// --- Variables miembro --- // --- Variables miembro ---
// Objetos y punteros a recursos // Objetos y punteros a recursos
std::shared_ptr<Surface> jailgames_surface_; // Textura con los graficos "JAILGAMES" std::shared_ptr<Surface> jailgames_surface_; // Textura con los graficos "JAILGAMES"
std::shared_ptr<Surface> since_1998_surface_; // Textura con los graficos "Since 1998" std::shared_ptr<Surface> since_1998_surface_; // Textura con los graficos "Since 1998"
std::vector<std::shared_ptr<SurfaceSprite>> jailgames_sprite_; // Vector con los sprites de cada linea que forman el bitmap JAILGAMES std::vector<std::shared_ptr<SurfaceSprite>> jailgames_sprite_; // Vector con los sprites de cada linea que forman el bitmap JAILGAMES
std::vector<int> jailgames_initial_x_; // Posiciones X iniciales de cada línea (para interpolación con easing) std::vector<int> jailgames_initial_x_; // Posiciones X iniciales de cada línea (para interpolación con easing)
std::shared_ptr<SurfaceSprite> since_1998_sprite_; // SSprite para manejar la textura2 std::shared_ptr<SurfaceSprite> since_1998_sprite_; // SSprite para manejar la textura2
std::unique_ptr<DeltaTimer> delta_timer_; // Timer para delta time std::unique_ptr<DeltaTimer> delta_timer_; // Timer para delta time
// Variables de estado de colores // Variables de estado de colores
std::vector<Uint8> color_; // Vector con los colores para el fade std::vector<Uint8> color_; // Vector con los colores para el fade
Uint8 jailgames_color_{0}; // Color para el sprite de "JAILGAMES" Uint8 jailgames_color_{0}; // Color para el sprite de "JAILGAMES"
Uint8 since_1998_color_{0}; // Color para el sprite de "Since 1998" Uint8 since_1998_color_{0}; // Color para el sprite de "Since 1998"
// Variables de estado de la secuencia // Variables de estado de la secuencia
State state_{State::INITIAL}; // Estado actual de la secuencia State state_{State::INITIAL}; // Estado actual de la secuencia
float state_time_{0.0F}; // Tiempo acumulado en el estado actual float state_time_{0.0F}; // Tiempo acumulado en el estado actual
EasingFunction easing_function_; // Función de easing para la animación del logo EasingFunction easing_function_; // Función de easing para la animación del logo
}; };

16
source/game/scenes/title.hpp
View File

@@ -122,12 +122,12 @@ class Title {
SceneManager::Scene exit_scene_{SceneManager::Scene::GAME}; // Escena de destino al salir del título SceneManager::Scene exit_scene_{SceneManager::Scene::GAME}; // Escena de destino al salir del título
// Variables para redefinir controles // Variables para redefinir controles
bool is_remapping_keyboard_{false}; // True si estamos redefiniendo teclado bool is_remapping_keyboard_{false}; // True si estamos redefiniendo teclado
bool is_remapping_joystick_{false}; // True si estamos redefiniendo joystick bool is_remapping_joystick_{false}; // True si estamos redefiniendo joystick
int remap_step_{0}; // Paso actual en la redefinicion (0=LEFT, 1=RIGHT, 2=JUMP) int remap_step_{0}; // Paso actual en la redefinicion (0=LEFT, 1=RIGHT, 2=JUMP)
std::array<SDL_Scancode, 3> temp_keys_; // Almacenamiento temporal de teclas capturadas std::array<SDL_Scancode, 3> temp_keys_; // Almacenamiento temporal de teclas capturadas
std::array<int, 3> temp_buttons_; // Almacenamiento temporal de botones de gamepad capturados std::array<int, 3> temp_buttons_; // Almacenamiento temporal de botones de gamepad capturados
std::string remap_error_message_; // Mensaje de error si la tecla/boton es invalido std::string remap_error_message_; // Mensaje de error si la tecla/boton es invalido
float axis_cooldown_{0.0F}; // Cooldown para evitar múltiples capturas de ejes float axis_cooldown_{0.0F}; // Cooldown para evitar múltiples capturas de ejes
bool remap_completed_{false}; // True cuando se completa el remap (mostrar antes de guardar) bool remap_completed_{false}; // True cuando se completa el remap (mostrar antes de guardar)
}; };

2
source/utils/easing_functions.hpp
View File

@@ -248,4 +248,4 @@ inline auto bounceInOut(float t) -> float {
return (0.5F * bounceOut((2.0F * t) - 1.0F)) + 0.5F; return (0.5F * bounceOut((2.0F * t) - 1.0F)) + 0.5F;
} }
} // namespace Easing } // namespace Easing

46
source/utils/utils.hpp
View File

@@ -74,41 +74,41 @@ struct Color {
}; };
// COLISIONES Y GEOMETRÍA // COLISIONES Y GEOMETRÍA
auto distanceSquared(int x1, int y1, int x2, int y2) -> double; // Distancia² entre dos puntos auto distanceSquared(int x1, int y1, int x2, int y2) -> double; // Distancia² entre dos puntos
auto checkCollision(const Circle& a, const Circle& b) -> bool; // Colisión círculo-círculo auto checkCollision(const Circle& a, const Circle& b) -> bool; // Colisión círculo-círculo
auto checkCollision(const Circle& a, const SDL_FRect& rect) -> bool; // Colisión círculo-rectángulo auto checkCollision(const Circle& a, const SDL_FRect& rect) -> bool; // Colisión círculo-rectángulo
auto checkCollision(const SDL_FRect& a, const SDL_FRect& b) -> bool; // Colisión rectángulo-rectángulo auto checkCollision(const SDL_FRect& a, const SDL_FRect& b) -> bool; // Colisión rectángulo-rectángulo
auto checkCollision(const SDL_FPoint& p, const SDL_FRect& r) -> bool; // Colisión punto-rectángulo auto checkCollision(const SDL_FPoint& p, const SDL_FRect& r) -> bool; // Colisión punto-rectángulo
auto checkCollision(const LineHorizontal& l, const SDL_FRect& r) -> bool; // Colisión línea horizontal-rectángulo auto checkCollision(const LineHorizontal& l, const SDL_FRect& r) -> bool; // Colisión línea horizontal-rectángulo
auto checkCollision(const LineVertical& l, const SDL_FRect& r) -> bool; // Colisión línea vertical-rectángulo auto checkCollision(const LineVertical& l, const SDL_FRect& r) -> bool; // Colisión línea vertical-rectángulo
auto checkCollision(const LineHorizontal& l, const SDL_FPoint& p) -> bool; // Colisión línea horizontal-punto auto checkCollision(const LineHorizontal& l, const SDL_FPoint& p) -> bool; // Colisión línea horizontal-punto
auto checkCollision(const Line& l1, const Line& l2) -> SDL_Point; // Colisión línea-línea (intersección) auto checkCollision(const Line& l1, const Line& l2) -> SDL_Point; // Colisión línea-línea (intersección)
auto checkCollision(const LineDiagonal& l1, const LineVertical& l2) -> SDL_Point; // Colisión diagonal-vertical auto checkCollision(const LineDiagonal& l1, const LineVertical& l2) -> SDL_Point; // Colisión diagonal-vertical
auto checkCollision(const SDL_FPoint& p, const LineDiagonal& l) -> bool; // Colisión punto-diagonal auto checkCollision(const SDL_FPoint& p, const LineDiagonal& l) -> bool; // Colisión punto-diagonal
void normalizeLine(LineDiagonal& l); // Normaliza línea diagonal (x1 < x2) void normalizeLine(LineDiagonal& l); // Normaliza línea diagonal (x1 < x2)
// CONVERSIONES DE TIPOS SDL // CONVERSIONES DE TIPOS SDL
auto toSDLRect(const SDL_FRect& frect) -> SDL_Rect; // Convierte SDL_FRect a SDL_Rect auto toSDLRect(const SDL_FRect& frect) -> SDL_Rect; // Convierte SDL_FRect a SDL_Rect
auto toSDLPoint(const SDL_FPoint& fpoint) -> SDL_Point; // Convierte SDL_FPoint a SDL_Point auto toSDLPoint(const SDL_FPoint& fpoint) -> SDL_Point; // Convierte SDL_FPoint a SDL_Point
// CONVERSIONES DE STRING // CONVERSIONES DE STRING
auto stringToColor(const std::string& str) -> Uint8; // String a índice de paleta auto stringToColor(const std::string& str) -> Uint8; // String a índice de paleta
auto safeStoi(const std::string& value, int default_value = 0) -> int; // String a int seguro (sin excepciones) auto safeStoi(const std::string& value, int default_value = 0) -> int; // String a int seguro (sin excepciones)
auto stringToBool(const std::string& str) -> bool; // String a bool (true/1/yes/on) auto stringToBool(const std::string& str) -> bool; // String a bool (true/1/yes/on)
auto boolToString(bool value) -> std::string; // Bool a string (1/0) auto boolToString(bool value) -> std::string; // Bool a string (1/0)
auto toLower(const std::string& str) -> std::string; // String a minúsculas auto toLower(const std::string& str) -> std::string; // String a minúsculas
auto toUpper(const std::string& str) -> std::string; // String a mayúsculas auto toUpper(const std::string& str) -> std::string; // String a mayúsculas
// OPERACIONES CON STRINGS // OPERACIONES CON STRINGS
auto stringInVector(const std::vector<std::string>& vec, const std::string& str) -> bool; // Busca string en vector auto stringInVector(const std::vector<std::string>& vec, const std::string& str) -> bool; // Busca string en vector
auto spaceBetweenLetters(const std::string& input) -> std::string; // Añade espacios entre letras auto spaceBetweenLetters(const std::string& input) -> std::string; // Añade espacios entre letras
// OPERACIONES CON COLORES // OPERACIONES CON COLORES
auto colorAreEqual(Color color1, Color color2) -> bool; // Compara dos colores RGB auto colorAreEqual(Color color1, Color color2) -> bool; // Compara dos colores RGB
// OPERACIONES CON FICHEROS // OPERACIONES CON FICHEROS
auto getFileName(const std::string& path) -> std::string; // Extrae nombre de fichero de ruta auto getFileName(const std::string& path) -> std::string; // Extrae nombre de fichero de ruta
auto getPath(const std::string& full_path) -> std::string; // Extrae directorio de ruta completa auto getPath(const std::string& full_path) -> std::string; // Extrae directorio de ruta completa
// RENDERIZADO // RENDERIZADO
void fillTextureWithColor(SDL_Renderer* renderer, SDL_Texture* texture, Uint8 r, Uint8 g, Uint8 b, Uint8 a); // Rellena textura void fillTextureWithColor(SDL_Renderer* renderer, SDL_Texture* texture, Uint8 r, Uint8 g, Uint8 b, Uint8 a); // Rellena textura