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:
// --- Tipos anidados ---
struct Music {
MusicState state{MusicState::STOPPED}; // Estado actual de la música
std::string name; // Última pista de música reproducida
bool loop{false}; // Indica si se reproduce en bucle
MusicState state{MusicState::STOPPED}; // Estado actual de la música
std::string name; // Última pista de música reproducida
bool loop{false}; // Indica si se reproduce en bucle
};
// --- Métodos ---
@@ -90,8 +90,8 @@ class Audio {
// --- Variables miembro ---
static Audio* instance; // Instancia única de Audio
Music music_; // Estado de la música
bool enabled_{true}; // Estado general del audio
bool sound_enabled_{true}; // Estado de los efectos de sonido
bool music_enabled_{true}; // Estado de la música
Music music_; // Estado de la música
bool enabled_{true}; // Estado general del audio
bool sound_enabled_{true}; // Estado de los efectos de sonido
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;
case InputAction::TOGGLE_DEBUG:
//handleToggleDebug();
// handleToggleDebug();
break;
#ifdef _DEBUG

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

@@ -9,7 +9,7 @@
#include <utility> // Para pair
#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) ---
class Input {
@@ -27,17 +27,17 @@ class Input {
// --- Estructuras ---
struct KeyState {
Uint8 scancode{0}; // Scancode asociado
bool is_held{false}; // Está pulsada ahora mismo
bool just_pressed{false}; // Se acaba de pulsar en este fotograma
Uint8 scancode{0}; // Scancode asociado
bool is_held{false}; // Está pulsada ahora mismo
bool just_pressed{false}; // Se acaba de pulsar en este fotograma
};
struct ButtonState {
int button{static_cast<int>(SDL_GAMEPAD_BUTTON_INVALID)}; // GameControllerButton asociado
bool is_held{false}; // Está pulsada ahora mismo
bool just_pressed{false}; // Se acaba de pulsar en este fotograma
bool axis_active{false}; // Estado del eje
bool trigger_active{false}; // Estado del trigger como botón digital
int button{static_cast<int>(SDL_GAMEPAD_BUTTON_INVALID)}; // GameControllerButton asociado
bool is_held{false}; // Está pulsada ahora mismo
bool just_pressed{false}; // Se acaba de pulsar en este fotograma
bool axis_active{false}; // Estado del eje
bool trigger_active{false}; // Estado del trigger como botón digital
};
struct Keyboard {
@@ -45,33 +45,33 @@ class Input {
};
struct Gamepad {
SDL_Gamepad* pad{nullptr}; // Puntero al gamepad SDL
SDL_JoystickID instance_id{0}; // ID de instancia del joystick
std::string name; // Nombre del gamepad
std::string path; // Ruta del dispositivo
std::unordered_map<Action, ButtonState> bindings; // Mapa de acciones a estados de botón
SDL_Gamepad* pad{nullptr}; // Puntero al gamepad SDL
SDL_JoystickID instance_id{0}; // ID de instancia del joystick
std::string name; // Nombre del gamepad
std::string path; // Ruta del dispositivo
std::unordered_map<Action, ButtonState> bindings; // Mapa de acciones a estados de botón
explicit Gamepad(SDL_Gamepad* gamepad)
: pad(gamepad),
instance_id(SDL_GetJoystickID(SDL_GetGamepadJoystick(gamepad))),
name(std::string(SDL_GetGamepadName(gamepad))),
path(std::string(SDL_GetGamepadPath(pad))),
bindings{
// Movimiento del jugador
{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::JUMP, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_WEST)}}} {}
explicit Gamepad(SDL_Gamepad* gamepad)
: pad(gamepad),
instance_id(SDL_GetJoystickID(SDL_GetGamepadJoystick(gamepad))),
name(std::string(SDL_GetGamepadName(gamepad))),
path(std::string(SDL_GetGamepadPath(pad))),
bindings{
// Movimiento del jugador
{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::JUMP, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_WEST)}}} {}
~Gamepad() {
if (pad != nullptr) {
SDL_CloseGamepad(pad);
~Gamepad() {
if (pad != nullptr) {
SDL_CloseGamepad(pad);
}
}
}
// Reasigna un botón a una acción
void rebindAction(Action action, SDL_GamepadButton new_button) {
bindings[action].button = static_cast<int>(new_button);
}
// Reasigna un botón a una acción
void rebindAction(Action action, SDL_GamepadButton new_button) {
bindings[action].button = static_cast<int>(new_button);
}
};
// --- Tipos ---
@@ -134,7 +134,7 @@ class Input {
// --- Variables miembro ---
static Input* instance; // Instancia única del singleton
Gamepads gamepads_; // Lista de gamepads conectados
Keyboard keyboard_{}; // Estado del teclado
std::string gamepad_mappings_file_; // Ruta al archivo de mappings
Gamepads gamepads_; // Lista de gamepads conectados
Keyboard keyboard_{}; // Estado del teclado
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
static void init(); // Crea el singleton
static void destroy(); // Destruye el singleton
static void init(); // Crea el singleton
static void destroy(); // Destruye el singleton
static auto get() -> Screen*; // Obtiene el singleton
// Renderizado
@@ -35,32 +35,32 @@ class Screen {
void update(float delta_time); // Actualiza la lógica de la clase
// Video y ventana
void setVideoMode(bool mode); // Establece el modo de video
void toggleVideoMode(); // Cambia entre pantalla completa y ventana
void toggleIntegerScale(); // Alterna entre activar y desactivar el escalado entero
void toggleVSync(); // Alterna entre activar y desactivar el V-Sync
auto decWindowZoom() -> bool; // Reduce el tamaño de la ventana
auto incWindowZoom() -> bool; // Aumenta el tamaño de la ventana
void show(); // Muestra la ventana
void hide(); // Oculta la ventana
void setVideoMode(bool mode); // Establece el modo de video
void toggleVideoMode(); // Cambia entre pantalla completa y ventana
void toggleIntegerScale(); // Alterna entre activar y desactivar el escalado entero
void toggleVSync(); // Alterna entre activar y desactivar el V-Sync
auto decWindowZoom() -> bool; // Reduce el tamaño de la ventana
auto incWindowZoom() -> bool; // Aumenta el tamaño de la ventana
void show(); // Muestra la ventana
void hide(); // Oculta la ventana
// Borde
void setBorderColor(Uint8 color); // Cambia el color del borde
static void setBorderWidth(int width); // Establece el ancho 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
void toggleBorder(); // Cambia entre borde visible y no visible
void setBorderColor(Uint8 color); // Cambia el color del borde
static void setBorderWidth(int width); // Establece el ancho 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
void toggleBorder(); // Cambia entre borde visible y no visible
// Paletas y shaders
void nextPalette(); // Cambia a la siguiente paleta
void previousPalette(); // Cambia a la paleta anterior
void setPalete(); // Establece la paleta actual
void toggleShaders(); // Cambia el estado de los shaders
void nextPalette(); // Cambia a la siguiente paleta
void previousPalette(); // Cambia a la paleta anterior
void setPalete(); // Establece la paleta actual
void toggleShaders(); // Cambia el estado de los shaders
// Surfaces y notificaciones
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 toggleDebugInfo(); // Activa o desactiva la información de debug
void setNotificationsEnabled(bool value); // Establece la visibilidad de las notificaciones
void toggleDebugInfo(); // Activa o desactiva la información de debug
// Getters
auto getRenderer() -> SDL_Renderer*;
@@ -78,22 +78,22 @@ class Screen {
};
struct FPS {
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 last_value{0}; // Número de frames calculado en el último segundo
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 last_value{0}; // Número de frames calculado en el último segundo
void increment() {
frame_count++;
}
auto calculate(Uint32 current_ticks) -> int {
if (current_ticks - ticks >= 1000) {
last_value = frame_count;
frame_count = 0;
ticks = current_ticks;
void increment() {
frame_count++;
}
auto calculate(Uint32 current_ticks) -> int {
if (current_ticks - ticks >= 1000) {
last_value = frame_count;
frame_count = 0;
ticks = current_ticks;
}
return last_value;
}
return last_value;
}
};
// Constantes
@@ -123,8 +123,8 @@ class Screen {
~Screen();
// Objetos SDL
SDL_Window* window_{nullptr}; // Ventana de la aplicación
SDL_Renderer* renderer_{nullptr}; // Renderizador de la ventana
SDL_Window* window_{nullptr}; // Ventana de la aplicación
SDL_Renderer* renderer_{nullptr}; // Renderizador de la ventana
SDL_Texture* game_texture_{nullptr}; // Textura donde se dibuja el 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
// Configuración de ventana y pantalla
int window_width_{0}; // Ancho 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
int window_width_{0}; // Ancho 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
// Paletas y colores
Uint8 border_color_{0}; // Color del borde
std::vector<std::string> palettes_; // Listado de ficheros de paleta disponibles
Uint8 current_palette_{0}; // Índice para el vector de paletas
Uint8 border_color_{0}; // Color del borde
std::vector<std::string> palettes_; // Listado de ficheros de paleta disponibles
Uint8 current_palette_{0}; // Índice para el vector de paletas
// Estado y configuración
bool notifications_enabled_{false}; // Indica si se muestran las notificaciones
@@ -151,12 +151,12 @@ class Screen {
DisplayMonitor display_monitor_; // Información de la pantalla
// Shaders
std::string info_resolution_; // Texto con la información de la pantalla
std::string vertex_shader_source_; // Almacena el vertex shader
std::string fragment_shader_source_; // Almacena el fragment shader
std::string info_resolution_; // Texto con la información de la pantalla
std::string vertex_shader_source_; // Almacena el vertex shader
std::string fragment_shader_source_; // Almacena el fragment shader
#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
bool show_debug_info_{false}; // Indica si ha de mostrar la información de debug
#endif

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

@@ -8,7 +8,7 @@
#include <vector> // Para vector
#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;

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

@@ -19,8 +19,8 @@ class SurfaceSprite {
virtual ~SurfaceSprite() = default;
// Actualización y renderizado
virtual void update(float delta_time); // Actualiza el estado del sprite (time-based)
virtual void render(); // Muestra el sprite por pantalla
virtual void update(float delta_time); // Actualiza el estado del sprite (time-based)
virtual void render(); // Muestra el sprite por pantalla
virtual void render(Uint8 source_color, Uint8 target_color); // Renderiza con reemplazo de color
// 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 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 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 writeCentered(int x, int y, const std::string& text, int kerning = 1, int lenght = -1); // Escribe el texto centrado en un punto x
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 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 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
[[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

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

@@ -9,24 +9,24 @@ struct Color; // lines 11-11
class Texture {
public:
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 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(Color color); // Establece el color para la modulacion
void setBlendMode(SDL_BlendMode blending); // Establece el blending
void setAlpha(Uint8 alpha); // Establece el alpha para la modulación
void setAsRenderTarget(SDL_Renderer* renderer); // Establece la textura como objetivo de renderizado
void setColor(Color color); // Establece el color para la modulacion
void setBlendMode(SDL_BlendMode blending); // Establece el blending
void setAlpha(Uint8 alpha); // Establece el alpha para la modulación
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
[[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
auto getSDLTexture() -> SDL_Texture*; // Obtiene la textura
auto getRenderer() -> SDL_Renderer*; // Obtiene el renderizador
auto getSDLTexture() -> SDL_Texture*; // Obtiene la textura
auto getRenderer() -> SDL_Renderer*; // Obtiene el renderizador
private:
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 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 getSurface(const std::string& name) -> std::shared_ptr<Surface>;
auto getPalette(const std::string& name) -> Palette;
@@ -86,8 +86,8 @@ class Cache {
std::vector<AnimationResource> animations_; // Vector con las animaciones
std::vector<RoomResource> rooms_; // Vector con las habitaciones
ResourceCount count_{}; // Contador de recursos
std::shared_ptr<Text> loading_text_; // Texto para la pantalla de carga
ResourceCount count_{}; // Contador de recursos
std::shared_ptr<Text> loading_text_; // Texto para la pantalla de carga
};
} // 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 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 validatePack() const -> bool; // Validate pack integrity
[[nodiscard]] auto loadAssetsConfig() const -> std::string; // Load assets.yaml from pack
[[nodiscard]] auto validatePack() const -> bool; // Validate pack integrity
[[nodiscard]] auto loadAssetsConfig() const -> std::string; // Load assets.yaml from pack
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;
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,
.offset = data_.size(),
.size = file_data.size(),
.checksum = calculateChecksum(file_data)
};
.checksum = calculateChecksum(file_data)};
// Append file data to the data block
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
struct ResourceEntry {
std::string filename; // Relative path within pack
uint64_t offset{0}; // Byte offset in data block
uint64_t size{0}; // Size in bytes
uint32_t checksum{0}; // CRC32 checksum for verification
std::string filename; // Relative path within pack
uint64_t offset{0}; // Byte offset in data block
uint64_t size{0}; // Size in bytes
uint32_t checksum{0}; // CRC32 checksum for verification
};
// Resource pack file format
@@ -28,7 +28,7 @@ class Pack {
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;
Pack(Pack&&) = delete;
auto operator=(Pack&&) -> Pack& = delete;
@@ -43,7 +43,7 @@ class Pack {
auto hasResource(const std::string& filename) const -> bool;
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 getDataSize() const -> size_t { return data_.size(); }
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
struct ResourcePalette {
std::string name; // Nombre de la surface
Palette palette{}; // Paleta
std::string name; // Nombre de la surface
Palette palette{}; // Paleta
};
// Estructura para almacenar ficheros TextFile y su nombre

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

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

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

@@ -27,8 +27,8 @@ class Enemy {
explicit Enemy(const Data& enemy); // Constructor
~Enemy() = default; // Destructor
void render(); // Pinta el enemigo en pantalla
void update(float delta_time); // Actualiza las variables del objeto
void render(); // Pinta el enemigo en pantalla
void update(float delta_time); // Actualiza las variables del objeto
auto getRect() -> SDL_FRect; // Devuelve el rectangulo que contiene al 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
// Variables
Uint8 color_{0}; // Color del enemigo
std::string color_string_; // Color del enemigo en formato texto
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 y1_{0}; // Limite superior 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
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
Uint8 color_{0}; // Color del enemigo
std::string color_string_; // Color del enemigo en formato texto
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 y1_{0}; // Limite superior 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
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
};

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

@@ -22,7 +22,7 @@ class Item {
explicit Item(const Data& item); // Constructor
~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 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
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)
std::shared_ptr<SurfaceSprite> sprite_; // SSprite del objeto
// Variables
std::vector<Uint8> color_; // Vector con los colores del objeto
float time_accumulator_{0.0F}; // Acumulador de tiempo para cambio de color
SDL_FRect collider_{}; // Rectangulo de colisión
bool is_paused_{false}; // Indica si el item está pausado
std::vector<Uint8> color_; // Vector con los colores del objeto
float time_accumulator_{0.0F}; // Acumulador de tiempo para cambio de color
SDL_FRect collider_{}; // Rectangulo de colisión
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:
// 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
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
@@ -24,10 +24,10 @@ class Cheevos {
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
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
@@ -39,10 +39,10 @@ class Cheevos {
static Cheevos* cheevos; // [SINGLETON] Objeto privado
// 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
void loadFromFile(); // Carga el estado de los logros desde un fichero
void saveToFile(); // Guarda el estado de los logros en un fichero
void loadFromFile(); // Carga el estado de los logros desde un fichero
void saveToFile(); // Guarda el estado de los logros en un fichero
// Constructor y destructor privados [SINGLETON]
explicit Cheevos(std::string file);

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

@@ -5,13 +5,13 @@
#ifdef _DEBUG
#include "core/system/debug.hpp" // Para Debug
#endif
#include "utils/defines.hpp" // Para Collision
#include "utils/defines.hpp" // Para Collision
// Constructor
CollisionMap::CollisionMap(std::vector<int> tile_map, int tile_set_width, int conveyor_belt_direction)
: tile_map_(std::move(tile_map))
, tile_set_width_(tile_set_width)
, conveyor_belt_direction_(conveyor_belt_direction) {
: tile_map_(std::move(tile_map)),
tile_set_width_(tile_set_width),
conveyor_belt_direction_(conveyor_belt_direction) {
// Inicializa todas las superficies de colisión
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)
// --- 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 checkConveyorBelts(const SDL_FPoint& p) -> bool; // Colisión punto con conveyor belts
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
// --- Queries de colisión con rampas ---
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 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 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 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
[[nodiscard]] auto getSlopeAtPoint(const SDL_FPoint& p) const -> const LineDiagonal*; // Obtiene puntero a slope en un punto
// --- Métodos estáticos ---
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 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
// --- Getters ---
[[nodiscard]] auto getConveyorBeltDirection() const -> int { return conveyor_belt_direction_; }
@@ -83,14 +83,14 @@ class CollisionMap {
private:
// --- Constantes ---
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_HEIGHT = 16; // Alto del mapa en tiles
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_HEIGHT = 16; // Alto del mapa en tiles
// --- Datos 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 conveyor_belt_direction_; // Dirección de conveyor belts
std::vector<int> tile_map_; // Índices de tiles de la habitación
int tile_set_width_; // Ancho del tileset en tiles
int conveyor_belt_direction_; // Dirección de conveyor belts
// --- Geometría de colisión ---
std::vector<LineHorizontal> bottom_floors_; // Superficies inferiores (suelos)
@@ -111,11 +111,11 @@ class CollisionMap {
// Construcción de geometría
static void buildHorizontalLines(const std::vector<int>& tiles, std::vector<LineHorizontal>& lines, bool is_bottom_surface);
void setBottomSurfaces(); // Calcula superficies inferiores
void setTopSurfaces(); // Calcula superficies superiores
void setLeftSurfaces(); // Calcula paredes izquierdas
void setRightSurfaces(); // Calcula paredes derechas
void setLeftSlopes(); // Calcula rampas izquierdas
void setRightSlopes(); // Calcula rampas derechas
void setAutoSurfaces(); // Calcula conveyor belts
void setBottomSurfaces(); // Calcula superficies inferiores
void setTopSurfaces(); // Calcula superficies superiores
void setLeftSurfaces(); // Calcula paredes izquierdas
void setRightSurfaces(); // Calcula paredes derechas
void setLeftSlopes(); // Calcula rampas izquierdas
void setRightSlopes(); // Calcula rampas derechas
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 "utils/utils.hpp" // Para checkCollision
#include "game/entities/enemy.hpp" // Para Enemy
#include "utils/utils.hpp" // Para checkCollision
// Añade un enemigo a la colección
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
void addEnemy(std::shared_ptr<Enemy> enemy); // Añade un enemigo a la colección
void clear(); // Elimina todos los enemigos
void removeLastEnemy(); // Elimina el último enemigo de la colección
[[nodiscard]] auto isEmpty() const -> bool; // Comprueba si no hay enemigos
void clear(); // Elimina todos los enemigos
void removeLastEnemy(); // Elimina el último enemigo de la colección
[[nodiscard]] auto isEmpty() const -> bool; // Comprueba si no hay enemigos
// Actualización y renderizado
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 "core/audio/audio.hpp" // Para Audio
#include "utils/utils.hpp" // Para checkCollision
#include "game/entities/item.hpp" // Para Item
#include "item_tracker.hpp" // Para ItemTracker
#include "scoreboard.hpp" // Para Scoreboard::Data
#include "game/options.hpp" // Para Options
#include "core/audio/audio.hpp" // Para Audio
#include "game/entities/item.hpp" // Para Item
#include "game/options.hpp" // Para Options
#include "item_tracker.hpp" // Para ItemTracker
#include "scoreboard.hpp" // Para Scoreboard::Data
#include "utils/utils.hpp" // Para checkCollision
// Constructor
ItemManager::ItemManager(std::string room_name, std::shared_ptr<Scoreboard::Data> scoreboard_data)
: room_name_(std::move(room_name))
, data_(std::move(scoreboard_data)) {
: room_name_(std::move(room_name)),
data_(std::move(scoreboard_data)) {
}
// 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
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
void update(float delta_time); // Actualiza todos los items
@@ -63,7 +63,7 @@ class ItemManager {
auto checkCollision(SDL_FRect& rect) -> bool;
private:
std::vector<std::shared_ptr<Item>> items_; // Colección de items
std::string room_name_; // Nombre de la habitación
std::shared_ptr<Scoreboard::Data> data_; // Datos del scoreboard
std::vector<std::shared_ptr<Item>> items_; // Colección de items
std::string room_name_; // Nombre de la habitación
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
// 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
// Constructor y destructor privados [SINGLETON]

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

@@ -6,12 +6,12 @@
#include <string> // Para string
#include <vector> // Para vector
#include "game/entities/enemy.hpp" // Para EnemyData
#include "game/entities/item.hpp" // Para ItemData
#include "game/entities/enemy.hpp" // Para EnemyData
#include "game/entities/item.hpp" // Para ItemData
#include "game/gameplay/scoreboard.hpp" // Para Scoreboard::Data
#include "utils/utils.hpp" // Para LineHorizontal, LineDiagonal, LineVertical
class SurfaceSprite; // lines 12-12
class Surface; // lines 13-13
#include "utils/utils.hpp" // Para LineHorizontal, LineDiagonal, LineVertical
class SurfaceSprite; // lines 12-12
class Surface; // lines 13-13
class EnemyManager;
class ItemManager;
class CollisionMap;
@@ -38,21 +38,21 @@ class Room {
};
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
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<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::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
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<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
@@ -60,37 +60,37 @@ class Room {
~Room(); // Definido en .cpp para poder usar unique_ptr con forward declarations
// --- Funciones ---
[[nodiscard]] auto getName() const -> const std::string& { return name_; } // Devuelve el nombre de la habitación
[[nodiscard]] auto getBGColor() const -> Uint8 { return stringToColor(bg_color_); } // Devuelve el color de la habitación
[[nodiscard]] auto getBorderColor() const -> Uint8 { return stringToColor(border_color_); } // Devuelve el color del borde
void renderMap(); // Dibuja el mapa en pantalla
void renderEnemies(); // Dibuja los enemigos en pantalla
void renderItems(); // Dibuja los objetos en pantalla
[[nodiscard]] auto getName() const -> const std::string& { return name_; } // Devuelve el nombre de la habitación
[[nodiscard]] auto getBGColor() const -> Uint8 { return stringToColor(bg_color_); } // Devuelve el color de la habitación
[[nodiscard]] auto getBorderColor() const -> Uint8 { return stringToColor(border_color_); } // Devuelve el color del borde
void renderMap(); // Dibuja el mapa en pantalla
void renderEnemies(); // Dibuja los enemigos en pantalla
void renderItems(); // Dibuja los objetos en pantalla
#ifdef _DEBUG
void redrawMap(); // Redibuja el mapa (para actualizar modo debug)
void redrawMap(); // Redibuja el mapa (para actualizar modo debug)
#endif
void update(float delta_time); // Actualiza las variables y objetos de la habitación
auto getRoom(Border border) -> std::string; // Devuelve la cadena del fichero de la habitación contigua segun el borde
auto getTile(SDL_FPoint point) -> Tile; // Devuelve el tipo de tile que hay en ese pixel
auto 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 itemCollision(SDL_FRect& rect) -> bool; // Indica si hay colision con un objeto a partir de un rectangulo
static auto getTileSize() -> int { return TILE_SIZE; } // Obten el tamaño del tile
static auto getSlopeHeight(SDL_FPoint p, Tile slope) -> int; // Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
auto checkRightSurfaces(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 checkBottomSurfaces(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 checkConveyorBelts(const SDL_FPoint& p) -> bool; // Comprueba las colisiones
auto checkLeftSlopes(const LineVertical& line) -> int; // 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 SDL_FPoint& p) -> bool; // Comprueba las colisiones
[[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
[[nodiscard]] auto getConveyorBeltDirection() const -> int { return conveyor_belt_direction_; } // Obten la direccion de las superficies automaticas
void update(float delta_time); // Actualiza las variables y objetos de la habitación
auto getRoom(Border border) -> std::string; // Devuelve la cadena del fichero de la habitación contigua segun el borde
auto getTile(SDL_FPoint point) -> Tile; // Devuelve el tipo de tile que hay en ese pixel
auto 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 itemCollision(SDL_FRect& rect) -> bool; // Indica si hay colision con un objeto a partir de un rectangulo
static auto getTileSize() -> int { return TILE_SIZE; } // Obten el tamaño del tile
static auto getSlopeHeight(SDL_FPoint p, Tile slope) -> int; // Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
auto checkRightSurfaces(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 checkBottomSurfaces(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 checkConveyorBelts(const SDL_FPoint& p) -> bool; // Comprueba las colisiones
auto checkLeftSlopes(const LineVertical& line) -> int; // 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 SDL_FPoint& p) -> bool; // Comprueba las colisiones
[[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
[[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)
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
// --- Variables ---
std::string number_; // Numero de la habitación
std::string name_; // Nombre de la habitación
std::string bg_color_; // Color de fondo de la habitación
std::string border_color_; // Color del borde de la pantalla
std::string item_color1_; // Color 1 para los items de la habitación
std::string item_color2_; // Color 2 para los items de la habitación
std::string upper_room_; // Identificador de la habitación que se encuentra arriba
std::string lower_room_; // Identificador de la habitación que se encuentra abajp
std::string left_room_; // Identificador de la habitación que se encuentra a la izquierda
std::string right_room_; // Identificador de la habitación que se encuentra a la derecha
std::string tile_set_file_; // Imagen con los graficos para la habitación
std::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
bool is_paused_{false}; // Indica si el mapa esta en modo pausa
int tile_set_width_{0}; // Ancho del tileset en tiles
std::string number_; // Numero de la habitación
std::string name_; // Nombre de la habitación
std::string bg_color_; // Color de fondo de la habitación
std::string border_color_; // Color del borde de la pantalla
std::string item_color1_; // Color 1 para los items de la habitación
std::string item_color2_; // Color 2 para los items de la habitación
std::string upper_room_; // Identificador de la habitación que se encuentra arriba
std::string lower_room_; // Identificador de la habitación que se encuentra abajp
std::string left_room_; // Identificador de la habitación que se encuentra a la izquierda
std::string right_room_; // Identificador de la habitación que se encuentra a la derecha
std::string tile_set_file_; // Imagen con los graficos para la habitación
std::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
bool is_paused_{false}; // Indica si el mapa esta en modo pausa
int tile_set_width_{0}; // Ancho del tileset en tiles
// --- Funciones ---
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 <iostream> // Para cout, cerr
#include "external/fkyaml_node.hpp" // Para fkyaml::node
#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/utils.hpp" // Para stringToColor

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

@@ -18,10 +18,10 @@ class Stats {
// Variables
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> list_; // Lista con las estadisticas completas por habitación
std::string buffer_path_; // Fichero con las estadísticas temporales
std::string file_path_; // Fichero con las estadísticas completas
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::string buffer_path_; // Fichero con las estadísticas temporales
std::string file_path_; // Fichero con las estadísticas completas
// Busca una entrada en la lista por nombre
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 ---
#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
#else
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::options = SceneManager::Options::NONE;
// Inicializa los textos
iniTexts();
iniTexts(); // Inicializa los textos
iniPics(); // Inicializa las imagenes
iniScenes(); // Inicializa las escenas
// Inicializa las imagenes
iniPics();
// 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();
Screen::get()->setBorderColor(static_cast<Uint8>(PaletteColor::BLACK)); // Cambia el color del borde
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
}
// Actualiza el objeto
@@ -446,55 +436,55 @@ void Ending::updateSpriteCovers() {
const float PIXELS_REVEALED = TIME_SINCE_TRIGGER * TEXT_REVEAL_SPEED;
// 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
const float INITIAL_HEIGHT = SPRITE_TEXT.image_surface->getHeight();
const float Y_INITIAL = SPRITE_TEXT.image_sprite->getY();
const float INITIAL_HEIGHT = sprite_text.image_surface->getHeight();
const float Y_INITIAL = sprite_text.image_sprite->getY();
// Fase 1: Revelar malla decorativa (8 píxeles)
if (PIXELS_REVEALED < 8.0F) {
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_sprite->setY(Y_INITIAL);
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_sprite->setY(Y_INITIAL);
}
// Fase 2: Revelar contenido
else {
SPRITE_TEXT.cover_clip_desp = 0;
sprite_text.cover_clip_desp = 0;
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_sprite->setY(Y_INITIAL + static_cast<int>(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->setClip(
sprite_text.cover_sprite->setClip(
0,
SPRITE_TEXT.cover_clip_desp,
SPRITE_TEXT.cover_sprite->getWidth(),
SPRITE_TEXT.cover_clip_height);
sprite_text.cover_clip_desp,
sprite_text.cover_sprite->getWidth(),
sprite_text.cover_clip_height);
}
}
// 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 INITIAL_HEIGHT = SPRITE_PICS.image_surface->getHeight();
const float Y_INITIAL = SPRITE_PICS.image_sprite->getY();
const float INITIAL_HEIGHT = sprite_pics.image_surface->getHeight();
const float Y_INITIAL = sprite_pics.image_sprite->getY();
// Fase 1: Revelar malla decorativa (8 píxeles)
if (PIXELS_REVEALED < 8.0F) {
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_sprite->setY(Y_INITIAL);
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_sprite->setY(Y_INITIAL);
}
// Fase 2: Revelar contenido
else {
SPRITE_PICS.cover_clip_desp = 0;
sprite_pics.cover_clip_desp = 0;
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_sprite->setY(Y_INITIAL + static_cast<int>(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->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

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

@@ -87,16 +87,16 @@ class Ending {
// --- Variables miembro ---
// Objetos y punteros a recursos
std::shared_ptr<Surface> cover_surface_; // Surface para cubrir el texto
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_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::shared_ptr<Surface> cover_surface_; // Surface para cubrir el texto
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_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
// Variables de estado
State state_{State::WARMING_UP}; // 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 fadeout_time_{0.0F}; // Tiempo acumulado para el fade-out
int current_scene_{0}; // Escena actual (0-4)
State state_{State::WARMING_UP}; // 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 fadeout_time_{0.0F}; // Tiempo acumulado para el fade-out
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() {
Input::get()->update();
// Inputs globales siempre funcionan
if (Input::get()->checkAction(InputAction::TOGGLE_MUSIC, Input::DO_NOT_ALLOW_REPEAT)) {
board_->music = !board_->music;
board_->music ? Audio::get()->resumeMusic() : Audio::get()->pauseMusic();
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();
Notifier::get()->show({std::string(paused_ ? "GAME PAUSED" : "GAME RUNNING")});
}
@@ -124,28 +132,18 @@ void Game::update() {
Debug::get()->clear();
#endif
// 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();
// Dispatch por estado
switch (state_) {
case State::PLAYING:
updatePlaying(DELTA_TIME);
break;
case Mode::DEMO:
demoCheckRoomChange(DELTA_TIME);
case State::FADE_TO_ENDING:
updateFadeToEnding(DELTA_TIME);
break;
case State::POST_FADE_ENDING:
updatePostFadeEnding(DELTA_TIME);
break;
}
scoreboard_->update(DELTA_TIME);
keepMusicPlaying();
updateBlackScreen(DELTA_TIME);
Audio::update(); // Actualiza el objeto Audio
Screen::get()->update(DELTA_TIME); // Actualiza el objeto Screen
@@ -155,6 +153,73 @@ void Game::update() {
#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
void Game::render() {
// Prepara para dibujar el frame
@@ -434,7 +499,9 @@ auto Game::checkEndGame() -> bool {
// Comprueba los logros de completar el juego
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;
}

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

@@ -23,6 +23,12 @@ class 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 ---
explicit Game(Mode mode);
~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 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 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 ---
struct DemoData {
float time_accumulator{0.0F}; // Acumulador de tiempo para el modo demo
int room_index{0}; // Índice para el vector de habitaciones
std::vector<std::string> rooms; // Listado con los mapas de la demo
float time_accumulator{0.0F}; // Acumulador de tiempo para el modo demo
int room_index{0}; // Índice para el vector de habitaciones
std::vector<std::string> rooms; // Listado con los mapas de la demo
};
// --- Métodos ---
@@ -49,6 +57,10 @@ class Game {
void render(); // Pinta los objetos en pantalla
void handleEvents(); // Comprueba los eventos de la cola
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
void handleInput(); // Comprueba el teclado
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
Mode mode_; // Modo del juego
State state_{State::PLAYING}; // Estado actual de la escena
DeltaTimer delta_timer_; // Timer para calcular delta time
std::string current_room_; // Fichero de la habitación actual
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
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
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
// Variables de estado de la escena
State state_{State::WAITING}; // Estado actual de la escena
float elapsed_time_{0.0F}; // Tiempo transcurrido en el estado actual
State state_{State::WAITING}; // Estado actual de la escena
float elapsed_time_{0.0F}; // Tiempo transcurrido en el estado actual
// Variables de efectos visuales
std::vector<Uint8> colors_; // Vector con los colores para el fade
Uint8 color_{0}; // Color actual para texto y sprites
std::vector<Uint8> colors_; // Vector con los colores para el fade
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) ---
static constexpr float SILENT1_DURATION = 2.0F; // Pausa inicial
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 HEADER2_DURATION = 2.0F; // Cabecera pantalla
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
// Variables de estado de la secuencia
State state_{State::SILENT1}; // Estado actual de la secuencia
float state_time_{0.0F}; // Tiempo acumulado en el estado actual
Border current_border_type_{Border::NONE}; // Tipo de borde actual
State state_{State::SILENT1}; // Estado actual de la secuencia
float state_time_{0.0F}; // Tiempo acumulado en el estado actual
Border current_border_type_{Border::NONE}; // Tipo de borde actual
// 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
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
Noise noise_; // Variaciones de ruido durante los silencios
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
Carrier carrier_; // Estructura para los efectos de la carga de cabeceras
Noise noise_; // Variaciones de ruido durante los silencios
// Variables de seguimiento para evitar saltos de pasos/bloques
int last_mono_step_{-1}; // Último paso mono dibujado
int last_color_block_{-1}; // Último bloque color dibujado
int last_mono_step_{-1}; // Último paso mono 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
// --- Métodos ---
void update(); // Actualiza las variables
void render(); // Dibuja en pantalla
static void handleEvents(); // Comprueba el manejador de eventos
static void handleInput(); // Comprueba las entradas
void updateJAILGAMES(float delta_time); // Gestiona el logo de JAILGAME (time-based)
void updateTextureColors(); // Gestiona el color de las texturas
void updateState(float delta_time); // Actualiza el estado actual
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)
static void endSection(); // Termina la sección
void initColors(); // Inicializa el vector de colores
void initSprites(); // Crea los sprites de cada linea
void update(); // Actualiza las variables
void render(); // Dibuja en pantalla
static void handleEvents(); // Comprueba el manejador de eventos
static void handleInput(); // Comprueba las entradas
void updateJAILGAMES(float delta_time); // Gestiona el logo de JAILGAME (time-based)
void updateTextureColors(); // Gestiona el color de las texturas
void updateState(float delta_time); // Actualiza el estado actual
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)
static void endSection(); // Termina la sección
void initColors(); // Inicializa el vector de colores
void initSprites(); // Crea los sprites de cada linea
// --- Variables miembro ---
// Objetos y punteros a recursos
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::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::shared_ptr<SurfaceSprite> since_1998_sprite_; // SSprite para manejar la textura2
std::unique_ptr<DeltaTimer> delta_timer_; // Timer para delta time
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::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::shared_ptr<SurfaceSprite> since_1998_sprite_; // SSprite para manejar la textura2
std::unique_ptr<DeltaTimer> delta_timer_; // Timer para delta time
// Variables de estado de colores
std::vector<Uint8> color_; // Vector con los colores para el fade
Uint8 jailgames_color_{0}; // Color para el sprite de "JAILGAMES"
Uint8 since_1998_color_{0}; // Color para el sprite de "Since 1998"
std::vector<Uint8> color_; // Vector con los colores para el fade
Uint8 jailgames_color_{0}; // Color para el sprite de "JAILGAMES"
Uint8 since_1998_color_{0}; // Color para el sprite de "Since 1998"
// Variables de estado de la secuencia
State state_{State::INITIAL}; // Estado actual de la secuencia
float state_time_{0.0F}; // Tiempo acumulado en el estado actual
EasingFunction easing_function_; // Función de easing para la animación del logo
State state_{State::INITIAL}; // Estado actual de la secuencia
float state_time_{0.0F}; // Tiempo acumulado en el estado actual
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
// Variables para redefinir controles
bool is_remapping_keyboard_{false}; // True si estamos redefiniendo teclado
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)
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::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
bool remap_completed_{false}; // True cuando se completa el remap (mostrar antes de guardar)
bool is_remapping_keyboard_{false}; // True si estamos redefiniendo teclado
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)
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::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
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;
}
} // namespace Easing
} // namespace Easing

46
source/utils/utils.hpp
View File

@@ -74,41 +74,41 @@ struct Color {
};
// COLISIONES Y GEOMETRÍA
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 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_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 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 Line& l1, const Line& l2) -> SDL_Point; // Colisión línea-línea (intersección)
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 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_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 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 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 SDL_FPoint& p, const LineDiagonal& l) -> bool; // Colisión punto-diagonal
void normalizeLine(LineDiagonal& l); // Normaliza línea diagonal (x1 < x2)
auto checkCollision(const SDL_FPoint& p, const LineDiagonal& l) -> bool; // Colisión punto-diagonal
void normalizeLine(LineDiagonal& l); // Normaliza línea diagonal (x1 < x2)
// CONVERSIONES DE TIPOS SDL
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 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
// CONVERSIONES DE STRING
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 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 toLower(const std::string& str) -> std::string; // String a minúsculas
auto toUpper(const std::string& str) -> std::string; // String a mayúsculas
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 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 toLower(const std::string& str) -> std::string; // String a minúsculas
auto toUpper(const std::string& str) -> std::string; // String a mayúsculas
// OPERACIONES CON STRINGS
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
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
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 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
// RENDERIZADO
void fillTextureWithColor(SDL_Renderer* renderer, SDL_Texture* texture, Uint8 r, Uint8 g, Uint8 b, Uint8 a); // Rellena textura