jaildesigner-jailgames/coffee_crisis_arcade_edition
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 13 Wiki Activity

clang-tidy readability-function-cognitive-complexity

Browse Source 
clang-format
This commit is contained in:
Sergio
2025-07-20 16:12:27 +02:00
parent f2915aa4b4
commit 2620a76865
56 changed files with 2376 additions and 2295 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
source/animated_sprite.cpp
View File

@@ -13,7 +13,7 @@
#include "utils.h" // Para printWithDots #include "utils.h" // Para printWithDots
// Carga las animaciones en un vector(Animations) desde un fichero // Carga las animaciones en un vector(Animations) desde un fichero
auto loadAnimationsFromFile(const std::string &file_path) -> AnimationsFileBuffer { auto loadAnimationsFromFile(const std::string& file_path) -> AnimationsFileBuffer {
std::ifstream file(file_path); std::ifstream file(file_path);
if (!file) { if (!file) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", file_path.c_str()); SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", file_path.c_str());
@@ -34,7 +34,7 @@ auto loadAnimationsFromFile(const std::string &file_path) -> AnimationsFileBuffe
} }
// Constructor // Constructor
AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const std::string &file_path) AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const std::string& file_path)
: MovingSprite(texture) { : MovingSprite(texture) {
// Carga las animaciones // Carga las animaciones
if (!file_path.empty()) { if (!file_path.empty()) {
@@ -44,7 +44,7 @@ AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const std::stri
} }
// Constructor // Constructor
AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const AnimationsFileBuffer &animations) AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const AnimationsFileBuffer& animations)
: MovingSprite(texture) { : MovingSprite(texture) {
if (!animations.empty()) { if (!animations.empty()) {
loadFromAnimationsFileBuffer(animations); loadFromAnimationsFileBuffer(animations);
@@ -52,7 +52,7 @@ AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const Animation
} }
// Obtiene el índice de la animación a partir del nombre // Obtiene el índice de la animación a partir del nombre
auto AnimatedSprite::getIndex(const std::string &name) -> int { auto AnimatedSprite::getIndex(const std::string& name) -> int {
auto iterator = animation_indices_.find(name); auto iterator = animation_indices_.find(name);
if (iterator != animation_indices_.end()) { if (iterator != animation_indices_.end()) {
// Si se encuentra la animación en el mapa, devuelve su índice // Si se encuentra la animación en el mapa, devuelve su índice
@@ -100,7 +100,7 @@ auto AnimatedSprite::animationIsCompleted() -> bool {
} }
// Establece la animacion actual // Establece la animacion actual
void AnimatedSprite::setCurrentAnimation(const std::string &name, bool reset) { void AnimatedSprite::setCurrentAnimation(const std::string& name, bool reset) {
const auto NEW_ANIMATION = getIndex(name); const auto NEW_ANIMATION = getIndex(name);
if (current_animation_ != NEW_ANIMATION) { if (current_animation_ != NEW_ANIMATION) {
const auto OLD_ANIMATION = current_animation_; const auto OLD_ANIMATION = current_animation_;
@@ -149,22 +149,22 @@ void AnimatedSprite::resetAnimation() {
} }
// Carga la animación desde un vector de cadenas // Carga la animación desde un vector de cadenas
void AnimatedSprite::loadFromAnimationsFileBuffer(const AnimationsFileBuffer &source) { void AnimatedSprite::loadFromAnimationsFileBuffer(const AnimationsFileBuffer& source) {
AnimationConfig config; AnimationConfig config;
size_t index = 0; size_t index = 0;
while (index < source.size()) { while (index < source.size()) {
const std::string& line = source.at(index); const std::string& line = source.at(index);
if (line == "[animation]") { if (line == "[animation]") {
index = processAnimationBlock(source, index, config); index = processAnimationBlock(source, index, config);
} else { } else {
processConfigLine(line, config); processConfigLine(line, config);
} }
index++; index++;
} }
// Pone un valor por defecto // Pone un valor por defecto
setWidth(config.frame_width); setWidth(config.frame_width);
setHeight(config.frame_height); setHeight(config.frame_height);
@@ -176,10 +176,10 @@ void AnimatedSprite::processConfigLine(const std::string& line, AnimationConfig&
if (pos == std::string::npos) { if (pos == std::string::npos) {
return; return;
} }
std::string key = line.substr(0, pos); std::string key = line.substr(0, pos);
int value = std::stoi(line.substr(pos + 1)); int value = std::stoi(line.substr(pos + 1));
if (key == "frame_width") { if (key == "frame_width") {
config.frame_width = value; config.frame_width = value;
updateFrameCalculations(config); updateFrameCalculations(config);
@@ -202,25 +202,25 @@ void AnimatedSprite::updateFrameCalculations(AnimationConfig& config) {
// Procesa un bloque completo de animación // Procesa un bloque completo de animación
auto AnimatedSprite::processAnimationBlock(const AnimationsFileBuffer& source, size_t start_index, const AnimationConfig& config) -> size_t { auto AnimatedSprite::processAnimationBlock(const AnimationsFileBuffer& source, size_t start_index, const AnimationConfig& config) -> size_t {
Animation animation; Animation animation;
size_t index = start_index + 1; // Salta la línea "[animation]" size_t index = start_index + 1; // Salta la línea "[animation]"
while (index < source.size()) { while (index < source.size()) {
const std::string& line = source.at(index); const std::string& line = source.at(index);
if (line == "[/animation]") { if (line == "[/animation]") {
break; break;
} }
processAnimationParameter(line, animation, config); processAnimationParameter(line, animation, config);
index++; index++;
} }
// Añade la animación al vector de animaciones // Añade la animación al vector de animaciones
animations_.emplace_back(animation); animations_.emplace_back(animation);
// Rellena el mapa con el nombre y el nuevo índice // Rellena el mapa con el nombre y el nuevo índice
animation_indices_[animation.name] = animations_.size() - 1; animation_indices_[animation.name] = animations_.size() - 1;
return index; return index;
} }
@@ -230,10 +230,10 @@ void AnimatedSprite::processAnimationParameter(const std::string& line, Animatio
if (pos == std::string::npos) { if (pos == std::string::npos) {
return; return;
} }
std::string key = line.substr(0, pos); std::string key = line.substr(0, pos);
std::string value = line.substr(pos + 1); std::string value = line.substr(pos + 1);
if (key == "name") { if (key == "name") {
animation.name = value; animation.name = value;
} else if (key == "speed") { } else if (key == "speed") {
@@ -252,7 +252,7 @@ void AnimatedSprite::parseFramesParameter(const std::string& frames_str, Animati
std::stringstream stream(frames_str); std::stringstream stream(frames_str);
std::string tmp; std::string tmp;
SDL_FRect rect = {0, 0, config.frame_width, config.frame_height}; SDL_FRect rect = {0, 0, config.frame_width, config.frame_height};
while (getline(stream, tmp, ',')) { while (getline(stream, tmp, ',')) {
const int NUM_TILE = std::stoi(tmp); const int NUM_TILE = std::stoi(tmp);
if (NUM_TILE <= config.max_tiles) { if (NUM_TILE <= config.max_tiles) {

88
source/animated_sprite.h
View File

@@ -15,24 +15,24 @@ class Texture;
// Estructura de Animación // Estructura de Animación
struct Animation { struct Animation {
static constexpr int DEFAULT_SPEED = 5; static constexpr int DEFAULT_SPEED = 5;
std::string name; // Nombre de la animación std::string name; // Nombre de la animación
std::vector<SDL_FRect> frames; // Frames que componen la animación std::vector<SDL_FRect> frames; // Frames que componen la animación
int speed{DEFAULT_SPEED}; // Velocidad de reproducción int speed{DEFAULT_SPEED}; // Velocidad de reproducción
int loop{0}; // Frame de vuelta al terminar (-1 para no repetir) int loop{0}; // Frame de vuelta al terminar (-1 para no repetir)
bool completed{false}; // Indica si la animación ha finalizado bool completed{false}; // Indica si la animación ha finalizado
size_t current_frame{0}; // Frame actual en reproducción size_t current_frame{0}; // Frame actual en reproducción
int counter{0}; // Contador para la animación int counter{0}; // Contador para la animación
Animation() = default; Animation() = default;
}; };
struct AnimationConfig { struct AnimationConfig {
float frame_width = 1.0F; float frame_width = 1.0F;
float frame_height = 1.0F; float frame_height = 1.0F;
int frames_per_row = 1; int frames_per_row = 1;
int max_tiles = 1; int max_tiles = 1;
}; };
// Alias de tipo para buffer de animaciones // Alias de tipo para buffer de animaciones
@@ -43,41 +43,41 @@ auto loadAnimationsFromFile(const std::string& file_path) -> AnimationsFileBuffe
// Clase AnimatedSprite: Sprite animado que hereda de MovingSprite // Clase AnimatedSprite: Sprite animado que hereda de MovingSprite
class AnimatedSprite : public MovingSprite { class AnimatedSprite : public MovingSprite {
public: public:
// --- Constructores y destructor --- // --- Constructores y destructor ---
AnimatedSprite(std::shared_ptr<Texture> texture, const std::string& file_path); AnimatedSprite(std::shared_ptr<Texture> texture, const std::string& file_path);
AnimatedSprite(std::shared_ptr<Texture> texture, const AnimationsFileBuffer& animations); AnimatedSprite(std::shared_ptr<Texture> texture, const AnimationsFileBuffer& animations);
explicit AnimatedSprite(std::shared_ptr<Texture> texture) : MovingSprite(texture) {} explicit AnimatedSprite(std::shared_ptr<Texture> texture) : MovingSprite(texture) {}
~AnimatedSprite() override = default; ~AnimatedSprite() override = default;
// --- Métodos principales --- // --- Métodos principales ---
void update() override; // Actualiza la animación void update() override; // Actualiza la animación
// --- Control de animaciones --- // --- Control de animaciones ---
void setCurrentAnimation(const std::string& name = "default", bool reset = true); // Establece la animación por nombre void setCurrentAnimation(const std::string& name = "default", bool reset = true); // Establece la animación por nombre
void setCurrentAnimation(int index = 0, bool reset = true); // Establece la animación por índice void setCurrentAnimation(int index = 0, bool reset = true); // Establece la animación por índice
void resetAnimation(); // Reinicia la animación actual void resetAnimation(); // Reinicia la animación actual
void setAnimationSpeed(size_t value); // Establece la velocidad de la animación void setAnimationSpeed(size_t value); // Establece la velocidad de la animación
auto getAnimationSpeed() const -> size_t { return animations_[current_animation_].speed; } // Obtiene la velocidad de la animación actual auto getAnimationSpeed() const -> size_t { return animations_[current_animation_].speed; } // Obtiene la velocidad de la animación actual
// --- Consultas --- // --- Consultas ---
auto animationIsCompleted() -> bool; // Comprueba si la animación ha terminado auto animationIsCompleted() -> bool; // Comprueba si la animación ha terminado
auto getIndex(const std::string& name) -> int; // Obtiene el índice de una animación por nombre auto getIndex(const std::string& name) -> int; // Obtiene el índice de una animación por nombre
protected: protected:
// --- Datos de animación --- // --- Datos de animación ---
std::vector<Animation> animations_; // Vector de animaciones disponibles std::vector<Animation> animations_; // Vector de animaciones disponibles
int current_animation_ = 0; // Índice de la animación activa int current_animation_ = 0; // Índice de la animación activa
// --- Mapa para búsqueda rápida de animaciones por nombre --- // --- Mapa para búsqueda rápida de animaciones por nombre ---
std::unordered_map<std::string, int> animation_indices_; std::unordered_map<std::string, int> animation_indices_;
// --- Métodos internos --- // --- Métodos internos ---
void animate(); // Calcula el frame correspondiente a la animación void animate(); // Calcula el frame correspondiente a la animación
void loadFromAnimationsFileBuffer(const AnimationsFileBuffer& source); // Carga la animación desde un vector de cadenas void loadFromAnimationsFileBuffer(const AnimationsFileBuffer& source); // Carga la animación desde un vector de cadenas
void processConfigLine(const std::string& line, AnimationConfig& config); // Procesa una línea de configuración void processConfigLine(const std::string& line, AnimationConfig& config); // Procesa una línea de configuración
void updateFrameCalculations(AnimationConfig& config); // Actualiza los cálculos basados en las dimensiones del frame void updateFrameCalculations(AnimationConfig& config); // Actualiza los cálculos basados en las dimensiones del frame
auto processAnimationBlock(const AnimationsFileBuffer& source, size_t start_index, const AnimationConfig& config) -> size_t; // Procesa un bloque completo de animación auto processAnimationBlock(const AnimationsFileBuffer& source, size_t start_index, const AnimationConfig& config) -> size_t; // Procesa un bloque completo de animación
static void processAnimationParameter(const std::string& line, Animation& animation, const AnimationConfig& config); // Procesa un parámetro individual de animación static void processAnimationParameter(const std::string& line, Animation& animation, const AnimationConfig& config); // Procesa un parámetro individual de animación
static void parseFramesParameter(const std::string& frames_str, Animation& animation, const AnimationConfig& config); // Parsea el parámetro de frames (lista separada por comas) static void parseFramesParameter(const std::string& frames_str, Animation& animation, const AnimationConfig& config); // Parsea el parámetro de frames (lista separada por comas)
}; };

68
source/asset.h
View File

@@ -20,45 +20,45 @@ enum class AssetType : int {
// Clase Asset: gestor de recursos (singleton) // Clase Asset: gestor de recursos (singleton)
class Asset { // Gestor de recursos (singleton) class Asset { // Gestor de recursos (singleton)
public: public:
// --- Métodos de singleton --- // --- Métodos de singleton ---
static void init(const std::string &executable_path); // Inicializa el objeto Asset static void init(const std::string &executable_path); // Inicializa el objeto Asset
static void destroy(); // Libera el objeto Asset static void destroy(); // Libera el objeto Asset
static auto get() -> Asset *; // Obtiene el puntero al objeto Asset static auto get() -> Asset *; // Obtiene el puntero al objeto Asset
Asset(const Asset &) = delete; // No se permite copiar Asset(const Asset &) = delete; // No se permite copiar
auto operator=(const Asset &) -> Asset & = delete; // No se permite asignar auto operator=(const Asset &) -> Asset & = delete; // No se permite asignar
// --- Métodos para la gestión de recursos --- // --- Métodos para la gestión de recursos ---
void add(const std::string &file, AssetType type, bool required = true, bool absolute = false); // Añade un recurso a la lista void add(const std::string &file, AssetType type, bool required = true, bool absolute = false); // Añade un recurso a la lista
[[nodiscard]] auto get(const std::string &text) const -> std::string; // Obtiene la ruta completa de un recurso a partir de su nombre [[nodiscard]] auto get(const std::string &text) const -> std::string; // Obtiene la ruta completa de un recurso a partir de su nombre
[[nodiscard]] auto check() const -> bool; // Verifica la existencia de todos los recursos requeridos [[nodiscard]] auto check() const -> bool; // Verifica la existencia de todos los recursos requeridos
[[nodiscard]] auto getListByType(AssetType type) const -> std::vector<std::string>; // Devuelve una lista de archivos de un tipo concreto [[nodiscard]] auto getListByType(AssetType type) const -> std::vector<std::string>; // Devuelve una lista de archivos de un tipo concreto
private: private:
// --- Estructura interna para almacenar información de cada recurso --- // --- Estructura interna para almacenar información de cada recurso ---
struct AssetItem { // Estructura para cada recurso struct AssetItem { // Estructura para cada recurso
std::string file; // Ruta del fichero desde la raíz del directorio std::string file; // Ruta del fichero desde la raíz del directorio
AssetType type; // Tipo de recurso AssetType type; // Tipo de recurso
bool required; // Indica si el fichero es obligatorio bool required; // Indica si el fichero es obligatorio
AssetItem(std::string file_path, AssetType asset_type, bool is_required) AssetItem(std::string file_path, AssetType asset_type, bool is_required)
: file(std::move(file_path)), type(asset_type), required(is_required) {} // Constructor : file(std::move(file_path)), type(asset_type), required(is_required) {} // Constructor
}; };
// --- Variables internas --- // --- Variables internas ---
int longest_name_ = 0; // Longitud del nombre más largo int longest_name_ = 0; // Longitud del nombre más largo
std::vector<AssetItem> file_list_; // Lista con todas las rutas de recursos std::vector<AssetItem> file_list_; // Lista con todas las rutas de recursos
std::string executable_path_; // Ruta del ejecutable std::string executable_path_; // Ruta del ejecutable
// --- Métodos internos --- // --- Métodos internos ---
[[nodiscard]] static auto checkFile(const std::string &path) -> bool; // Verifica si un archivo existe (interno) [[nodiscard]] static auto checkFile(const std::string &path) -> bool; // Verifica si un archivo existe (interno)
[[nodiscard]] static auto getTypeName(AssetType type) -> std::string; // Devuelve el nombre textual del tipo de recurso (interno) [[nodiscard]] static auto getTypeName(AssetType type) -> std::string; // Devuelve el nombre textual del tipo de recurso (interno)
// --- Patrón Singleton --- // --- Patrón Singleton ---
explicit Asset(std::string executable_path) explicit Asset(std::string executable_path)
: executable_path_(std::move(executable_path)) {} // Constructor privado : executable_path_(std::move(executable_path)) {} // Constructor privado
~Asset() = default; // Destructor ~Asset() = default; // Destructor
// --- Singleton --- // --- Singleton ---
static Asset *instance; // Instancia singleton static Asset *instance; // Instancia singleton
}; };

138
source/audio.h
View File

@@ -5,90 +5,90 @@
// Clase Audio: gestor de audio (singleton) // Clase Audio: gestor de audio (singleton)
class Audio { class Audio {
public: public:
enum class Group : int { enum class Group : int {
ALL = -1, ALL = -1,
GAME = 0, GAME = 0,
INTERFACE = 1 INTERFACE = 1
}; };
// --- Constantes --- // --- Constantes ---
static constexpr int MAX_VOLUME = 100; static constexpr int MAX_VOLUME = 100;
static constexpr int MIN_VOLUME = 0; static constexpr int MIN_VOLUME = 0;
static constexpr int FREQUENCY = 48000; static constexpr int FREQUENCY = 48000;
// --- Métodos de singleton --- // --- Métodos de singleton ---
static void init(); // Inicializa el objeto Audio static void init(); // Inicializa el objeto Audio
static void destroy(); // Libera el objeto Audio static void destroy(); // Libera el objeto Audio
static auto get() -> Audio *; // Obtiene el puntero al objeto Audio static auto get() -> Audio *; // Obtiene el puntero al objeto Audio
Audio(const Audio &) = delete; // Evitar copia Audio(const Audio &) = delete; // Evitar copia
auto operator=(const Audio &) -> Audio & = delete; // Evitar asignación auto operator=(const Audio &) -> Audio & = delete; // Evitar asignación
// --- Control de Música --- // --- Control de Música ---
void playMusic(const std::string &name, int loop = -1); // Reproducir música en bucle void playMusic(const std::string &name, int loop = -1); // Reproducir música en bucle
void pauseMusic(); // Pausar reproducción de música void pauseMusic(); // Pausar reproducción de música
void stopMusic(); // Detener completamente la música void stopMusic(); // Detener completamente la música
void fadeOutMusic(int milliseconds) const; // Fundido de salida de la música void fadeOutMusic(int milliseconds) const; // Fundido de salida de la música
// --- Control de Sonidos --- // --- Control de Sonidos ---
void playSound(const std::string &name, Group group = Group::GAME) const; // Reproducir sonido puntual void playSound(const std::string &name, Group group = Group::GAME) const; // Reproducir sonido puntual
void stopAllSounds() const; // Detener todos los sonidos void stopAllSounds() const; // Detener todos los sonidos
// --- Configuración General --- // --- Configuración General ---
void enable(bool value); // Establecer estado general void enable(bool value); // Establecer estado general
void toggleEnabled() { enabled_ = !enabled_; } // Alternar estado general void toggleEnabled() { enabled_ = !enabled_; } // Alternar estado general
void applySettings(); // Aplica la configuración void applySettings(); // Aplica la configuración
// --- Configuración de Sonidos --- // --- Configuración de Sonidos ---
void enableSound() { sound_enabled_ = true; } // Habilitar sonidos void enableSound() { sound_enabled_ = true; } // Habilitar sonidos
void disableSound() { sound_enabled_ = false; } // Deshabilitar sonidos void disableSound() { sound_enabled_ = false; } // Deshabilitar sonidos
void enableSound(bool value) { sound_enabled_ = value; } // Establecer estado de sonidos void enableSound(bool value) { sound_enabled_ = value; } // Establecer estado de sonidos
void toggleSound() { sound_enabled_ = !sound_enabled_; } // Alternar estado de sonidos void toggleSound() { sound_enabled_ = !sound_enabled_; } // Alternar estado de sonidos
// --- Configuración de Música --- // --- Configuración de Música ---
void enableMusic() { music_enabled_ = true; } // Habilitar música void enableMusic() { music_enabled_ = true; } // Habilitar música
void disableMusic() { music_enabled_ = false; } // Deshabilitar música void disableMusic() { music_enabled_ = false; } // Deshabilitar música
void enableMusic(bool value) { music_enabled_ = value; } // Establecer estado de música void enableMusic(bool value) { music_enabled_ = value; } // Establecer estado de música
void toggleMusic() { music_enabled_ = !music_enabled_; } // Alternar estado de música void toggleMusic() { music_enabled_ = !music_enabled_; } // Alternar estado de música
// --- Control de Volumen --- // --- Control de Volumen ---
void setSoundVolume(int volume, Group group = Group::ALL) const; // Ajustar volumen de efectos void setSoundVolume(int volume, Group group = Group::ALL) const; // Ajustar volumen de efectos
void setMusicVolume(int volume) const; // Ajustar volumen de música void setMusicVolume(int volume) const; // Ajustar volumen de música
private: private:
enum class MusicState { enum class MusicState {
PLAYING, PLAYING,
PAUSED, PAUSED,
STOPPED, STOPPED,
}; };
struct Music { struct Music {
MusicState state; // Estado actual de la música (reproduciendo, detenido, en pausa) MusicState state; // Estado actual de la música (reproduciendo, detenido, en pausa)
std::string name; // Última pista de música reproducida std::string name; // Última pista de música reproducida
bool loop; // Indica si la última pista de música se debe reproducir en bucle bool loop; // Indica si la última pista de música se debe reproducir en bucle
// Constructor para inicializar la música con valores predeterminados // Constructor para inicializar la música con valores predeterminados
Music() : state(MusicState::STOPPED), loop(false) {} Music() : state(MusicState::STOPPED), loop(false) {}
// Constructor para inicializar con valores específicos // Constructor para inicializar con valores específicos
Music(MusicState init_state, std::string init_name, bool init_loop) Music(MusicState init_state, std::string init_name, bool init_loop)
: state(init_state), name(std::move(init_name)), loop(init_loop) {} : state(init_state), name(std::move(init_name)), loop(init_loop) {}
}; };
Music music_; Music music_;
// --- Variables de Estado --- // --- Variables de Estado ---
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
// --- Inicializa SDL Audio --- // --- Inicializa SDL Audio ---
void initSDLAudio(); void initSDLAudio();
// --- Patrón Singleton --- // --- Patrón Singleton ---
Audio(); // Constructor privado Audio(); // Constructor privado
~Audio(); // Destructor privado ~Audio(); // Destructor privado
// --- Singleton --- // --- Singleton ---
static Audio *instance; static Audio *instance;
}; };

16
source/balloon.h
View File

@@ -169,13 +169,13 @@ class Balloon {
bool sound_enabled_ = true; // Indica si los globos deben hacer algun sonido bool sound_enabled_ = true; // Indica si los globos deben hacer algun sonido
// --- Métodos internos --- // --- Métodos internos ---
void shiftColliders(); // Alinea el círculo de colisión void shiftColliders(); // Alinea el círculo de colisión
void shiftSprite(); // Alinea el sprite void shiftSprite(); // Alinea el sprite
void zoomSprite(); // Establece el nivel de zoom del sprite void zoomSprite(); // Establece el nivel de zoom del sprite
void enableBounce(); // Activa el efecto de rebote void enableBounce(); // Activa el efecto de rebote
void disableBounce(); // Detiene el efecto de rebote void disableBounce(); // Detiene el efecto de rebote
void updateBounce(); // Aplica el efecto de rebote void updateBounce(); // Aplica el efecto de rebote
void updateState(); // Actualiza los estados del globo void updateState(); // Actualiza los estados del globo
void setAnimation(); // Establece la animación correspondiente void setAnimation(); // Establece la animación correspondiente
void playSound(const std::string &name) const; // Reproduce sonido void playSound(const std::string &name) const; // Reproduce sonido
}; };

72
source/balloon_formations.h
View File

@@ -12,56 +12,56 @@ constexpr int NUMBER_OF_STAGES = 10;
// --- Estructuras de datos --- // --- Estructuras de datos ---
struct BalloonFormationParams { struct BalloonFormationParams {
int x = 0; // Posición en el eje X donde crear el globo int x = 0; // Posición en el eje X donde crear el globo
int y = 0; // Posición en el eje Y donde crear el globo int y = 0; // Posición en el eje Y donde crear el globo
float vel_x = 0.0F; // Velocidad inicial en el eje X float vel_x = 0.0F; // Velocidad inicial en el eje X
BalloonType type = BalloonType::BALLOON; // Tipo de globo BalloonType type = BalloonType::BALLOON; // Tipo de globo
BalloonSize size = BalloonSize::SIZE1; // Tamaño de globo BalloonSize size = BalloonSize::SIZE1; // Tamaño de globo
int creation_counter = 0; // Temporizador para la creación del globo int creation_counter = 0; // Temporizador para la creación del globo
// Constructor por defecto // Constructor por defecto
BalloonFormationParams() = default; BalloonFormationParams() = default;
// Constructor con parámetros // Constructor con parámetros
BalloonFormationParams(int x_val, int y_val, float vel_x_val, BalloonType type_val, BalloonSize size_val, int creation_counter_val) BalloonFormationParams(int x_val, int y_val, float vel_x_val, BalloonType type_val, BalloonSize size_val, int creation_counter_val)
: x(x_val), y(y_val), vel_x(vel_x_val), type(type_val), size(size_val), creation_counter(creation_counter_val) {} : x(x_val), y(y_val), vel_x(vel_x_val), type(type_val), size(size_val), creation_counter(creation_counter_val) {}
}; };
struct BalloonFormationUnit { struct BalloonFormationUnit {
int number_of_balloons; // Cantidad de globos que forman la formación int number_of_balloons; // Cantidad de globos que forman la formación
std::vector<BalloonFormationParams> init; // Vector con todas las inicializaciones de los globos de la formación std::vector<BalloonFormationParams> init; // Vector con todas las inicializaciones de los globos de la formación
// Constructor con parámetros // Constructor con parámetros
BalloonFormationUnit(int num_balloons, const std::vector<BalloonFormationParams> &init_params) BalloonFormationUnit(int num_balloons, const std::vector<BalloonFormationParams> &init_params)
: number_of_balloons(num_balloons), init(init_params) {} : number_of_balloons(num_balloons), init(init_params) {}
// Constructor por defecto // Constructor por defecto
BalloonFormationUnit() : number_of_balloons(0) {} BalloonFormationUnit() : number_of_balloons(0) {}
}; };
using BalloonFormationPool = std::vector<const BalloonFormationUnit *>; using BalloonFormationPool = std::vector<const BalloonFormationUnit *>;
// --- Clase BalloonFormations --- // --- Clase BalloonFormations ---
class BalloonFormations { class BalloonFormations {
public: public:
// --- Constructor y destructor --- // --- Constructor y destructor ---
BalloonFormations() { BalloonFormations() {
initBalloonFormations(); initBalloonFormations();
initBalloonFormationPools(); initBalloonFormationPools();
} }
~BalloonFormations() = default; ~BalloonFormations() = default;
// --- Getters --- // --- Getters ---
auto getPool(int pool) -> const BalloonFormationPool & { return balloon_formation_pool_.at(pool); } auto getPool(int pool) -> const BalloonFormationPool & { return balloon_formation_pool_.at(pool); }
auto getSet(int pool, int set) -> const BalloonFormationUnit & { return *balloon_formation_pool_.at(pool).at(set); } auto getSet(int pool, int set) -> const BalloonFormationUnit & { return *balloon_formation_pool_.at(pool).at(set); }
[[nodiscard]] auto getSet(int set) const -> const BalloonFormationUnit & { return balloon_formation_.at(set); } [[nodiscard]] auto getSet(int set) const -> const BalloonFormationUnit & { return balloon_formation_.at(set); }
private: private:
// --- Datos --- // --- Datos ---
std::vector<BalloonFormationUnit> balloon_formation_; // Vector con todas las formaciones enemigas std::vector<BalloonFormationUnit> balloon_formation_; // Vector con todas las formaciones enemigas
std::vector<BalloonFormationPool> balloon_formation_pool_; // Conjuntos de formaciones enemigas std::vector<BalloonFormationPool> balloon_formation_pool_; // Conjuntos de formaciones enemigas
// --- Métodos internos de inicialización --- // --- Métodos internos de inicialización ---
void initBalloonFormations(); void initBalloonFormations();
void initBalloonFormationPools(); void initBalloonFormationPools();
}; };

142
source/balloon_manager.h
View File

@@ -18,90 +18,90 @@ using Balloons = std::vector<std::shared_ptr<Balloon>>;
// Clase BalloonManager // Clase BalloonManager
class BalloonManager { class BalloonManager {
public: public:
// Constructor y Destructor // Constructor y Destructor
BalloonManager(); BalloonManager();
~BalloonManager() = default; ~BalloonManager() = default;
// Actualización y Renderizado // Actualización y Renderizado
void update(); // Actualiza el estado de los globos void update(); // Actualiza el estado de los globos
void render(); // Renderiza los globos en pantalla void render(); // Renderiza los globos en pantalla
// Gestión de globos // Gestión de globos
void freeBalloons(); // Libera globos que ya no sirven void freeBalloons(); // Libera globos que ya no sirven
// Creación de formaciones enemigas // Creación de formaciones enemigas
void deployBalloonFormation(int stage); // Crea una formación de enemigos aleatoria void deployBalloonFormation(int stage); // Crea una formación de enemigos aleatoria
void deploySet(int set); // Crea una formación específica void deploySet(int set); // Crea una formación específica
void deploySet(int set, int y); // Crea una formación específica con coordenadas void deploySet(int set, int y); // Crea una formación específica con coordenadas
// Creación de globos // Creación de globos
auto createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int creation_timer) -> std::shared_ptr<Balloon>; // Crea un nuevo globo auto createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int creation_timer) -> std::shared_ptr<Balloon>; // Crea un nuevo globo
void createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction); // Crea un globo a partir de otro void createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction); // Crea un globo a partir de otro
void createPowerBall(); // Crea una PowerBall void createPowerBall(); // Crea una PowerBall
void createTwoBigBalloons(); // Crea dos globos grandes void createTwoBigBalloons(); // Crea dos globos grandes
void createRandomBalloons(); // Crea una disposición aleatoria de globos void createRandomBalloons(); // Crea una disposición aleatoria de globos
// Control de velocidad y despliegue // Control de velocidad y despliegue
void setBalloonSpeed(float speed); // Ajusta la velocidad de los globos void setBalloonSpeed(float speed); // Ajusta la velocidad de los globos
void setDefaultBalloonSpeed(float speed) { default_balloon_speed_ = speed; }; // Establece la velocidad base void setDefaultBalloonSpeed(float speed) { default_balloon_speed_ = speed; }; // Establece la velocidad base
void resetBalloonSpeed() { setBalloonSpeed(default_balloon_speed_); }; // Restablece la velocidad de los globos void resetBalloonSpeed() { setBalloonSpeed(default_balloon_speed_); }; // Restablece la velocidad de los globos
void updateBalloonDeployCounter(); // Actualiza el contador de despliegue void updateBalloonDeployCounter(); // Actualiza el contador de despliegue
auto canPowerBallBeCreated() -> bool; // Indica si se puede crear una PowerBall auto canPowerBallBeCreated() -> bool; // Indica si se puede crear una PowerBall
auto calculateScreenPower() -> int; // Calcula el poder de los globos en pantalla auto calculateScreenPower() -> int; // Calcula el poder de los globos en pantalla
// Manipulación de globos existentes // Manipulación de globos existentes
auto popBalloon(std::shared_ptr<Balloon> balloon) -> int; // Explosiona un globo, creando otros si aplica auto popBalloon(std::shared_ptr<Balloon> balloon) -> int; // Explosiona un globo, creando otros si aplica
auto destroyBalloon(std::shared_ptr<Balloon> &balloon) -> int; // Explosiona un globo sin crear otros auto destroyBalloon(std::shared_ptr<Balloon> &balloon) -> int; // Explosiona un globo sin crear otros
auto destroyAllBalloons() -> int; // Destruye todos los globos auto destroyAllBalloons() -> int; // Destruye todos los globos
void stopAllBalloons(); // Detiene el movimiento de los globos void stopAllBalloons(); // Detiene el movimiento de los globos
void startAllBalloons(); // Reactiva el movimiento de los globos void startAllBalloons(); // Reactiva el movimiento de los globos
// Cambios de apariencia // Cambios de apariencia
void reverseColorsToAllBalloons(); // Invierte los colores de los globos void reverseColorsToAllBalloons(); // Invierte los colores de los globos
void normalColorsToAllBalloons(); // Restaura los colores originales void normalColorsToAllBalloons(); // Restaura los colores originales
// Configuración de sonido // Configuración de sonido
void setSounds(bool value); // Activa o desactiva los sonidos de los globos void setSounds(bool value); // Activa o desactiva los sonidos de los globos
void setBouncingSounds(bool value); // Activa o desactiva los sonidos de rebote los globos void setBouncingSounds(bool value); // Activa o desactiva los sonidos de rebote los globos
void setPoppingSounds(bool value); // Activa o desactiva los sonidos de los globos al explotar void setPoppingSounds(bool value); // Activa o desactiva los sonidos de los globos al explotar
// Configuración de juego // Configuración de juego
void setPlayArea(SDL_FRect play_area) { play_area_ = play_area; }; // Define el área de juego void setPlayArea(SDL_FRect play_area) { play_area_ = play_area; }; // Define el área de juego
void setCreationTimeEnabled(bool value) { creation_time_enabled_ = value; }; // Activa o desactiva el tiempo de creación de globos void setCreationTimeEnabled(bool value) { creation_time_enabled_ = value; }; // Activa o desactiva el tiempo de creación de globos
void enableBalloonDeployment(bool value) { can_deploy_balloons_ = value; }; // Activa o desactiva la generación de globos void enableBalloonDeployment(bool value) { can_deploy_balloons_ = value; }; // Activa o desactiva la generación de globos
// Obtención de información // Obtención de información
auto getMenace() -> int; // Obtiene el nivel de amenaza generado por los globos auto getMenace() -> int; // Obtiene el nivel de amenaza generado por los globos
[[nodiscard]] auto getBalloonSpeed() const -> float { return balloon_speed_; } [[nodiscard]] auto getBalloonSpeed() const -> float { return balloon_speed_; }
auto getBalloons() -> Balloons & { return balloons_; } auto getBalloons() -> Balloons & { return balloons_; }
[[nodiscard]] auto getNumBalloons() const -> int { return balloons_.size(); } [[nodiscard]] auto getNumBalloons() const -> int { return balloons_.size(); }
private: private:
Balloons balloons_; // Vector con los globos activos Balloons balloons_; // Vector con los globos activos
std::unique_ptr<Explosions> explosions_; // Objeto para gestionar explosiones std::unique_ptr<Explosions> explosions_; // Objeto para gestionar explosiones
std::unique_ptr<BalloonFormations> balloon_formations_; // Objeto para manejar formaciones enemigas std::unique_ptr<BalloonFormations> balloon_formations_; // Objeto para manejar formaciones enemigas
std::vector<std::shared_ptr<Texture>> balloon_textures_; // Texturas de los globos std::vector<std::shared_ptr<Texture>> balloon_textures_; // Texturas de los globos
std::vector<std::shared_ptr<Texture>> explosions_textures_; // Texturas de explosiones std::vector<std::shared_ptr<Texture>> explosions_textures_; // Texturas de explosiones
std::vector<std::vector<std::string>> balloon_animations_; // Animaciones de los globos std::vector<std::vector<std::string>> balloon_animations_; // Animaciones de los globos
std::vector<std::vector<std::string>> explosions_animations_; // Animaciones de las explosiones std::vector<std::vector<std::string>> explosions_animations_; // Animaciones de las explosiones
// Variables de control de globos // Variables de control de globos
float balloon_speed_ = BALLOON_SPEED[0]; float balloon_speed_ = BALLOON_SPEED[0];
float default_balloon_speed_ = BALLOON_SPEED[0]; float default_balloon_speed_ = BALLOON_SPEED[0];
int balloon_deploy_counter_ = 0; int balloon_deploy_counter_ = 0;
bool power_ball_enabled_ = false; bool power_ball_enabled_ = false;
int power_ball_counter_ = 0; int power_ball_counter_ = 0;
int last_balloon_deploy_ = 0; int last_balloon_deploy_ = 0;
SDL_FRect play_area_ = param.game.play_area.rect; SDL_FRect play_area_ = param.game.play_area.rect;
bool creation_time_enabled_ = true; bool creation_time_enabled_ = true;
bool can_deploy_balloons_ = true; bool can_deploy_balloons_ = true;
bool bouncing_sound_enabled_ = false; // Si debe sonar el globo al rebotar bool bouncing_sound_enabled_ = false; // Si debe sonar el globo al rebotar
bool poping_sound_enabled_ = true; // Si debe sonar el globo al explotar bool poping_sound_enabled_ = true; // Si debe sonar el globo al explotar
bool sound_enabled_ = true; // Indica si los globos deben hacer algun sonido bool sound_enabled_ = true; // Indica si los globos deben hacer algun sonido
// Metodos privados // Metodos privados
void init(); void init();
}; };

11
source/bullet.cpp
View File

@@ -13,16 +13,15 @@ Bullet::Bullet(float x, float y, BulletType bullet_type, bool powered, int owner
pos_y_(y), pos_y_(y),
bullet_type_(bullet_type), bullet_type_(bullet_type),
owner_(owner) { owner_(owner) {
vel_x_ = calculateVelocity(bullet_type_); vel_x_ = calculateVelocity(bullet_type_);
sprite_->setCurrentAnimation(buildAnimationString(bullet_type_, powered)); sprite_->setCurrentAnimation(buildAnimationString(bullet_type_, powered));
collider_.r = WIDTH / 2; collider_.r = WIDTH / 2;
shiftColliders(); shiftColliders();
} }
// Calcula la velocidad horizontal de la bala basada en su tipo // Calcula la velocidad horizontal de la bala basada en su tipo
float Bullet::calculateVelocity(BulletType bullet_type) { auto Bullet::calculateVelocity(BulletType bullet_type) -> float {
switch (bullet_type) { switch (bullet_type) {
case BulletType::LEFT: case BulletType::LEFT:
return VEL_X_LEFT; return VEL_X_LEFT;
@@ -34,9 +33,9 @@ float Bullet::calculateVelocity(BulletType bullet_type) {
} }
// Construye el string de animación basado en el tipo de bala y si está potenciada // Construye el string de animación basado en el tipo de bala y si está potenciada
std::string Bullet::buildAnimationString(BulletType bullet_type, bool powered) { auto Bullet::buildAnimationString(BulletType bullet_type, bool powered) -> std::string {
std::string animation_string = powered ? "powered_" : "normal_"; std::string animation_string = powered ? "powered_" : "normal_";
switch (bullet_type) { switch (bullet_type) {
case BulletType::UP: case BulletType::UP:
animation_string += "up"; animation_string += "up";
@@ -50,7 +49,7 @@ std::string Bullet::buildAnimationString(BulletType bullet_type, bool powered) {
default: default:
break; break;
} }
return animation_string; return animation_string;
} }

10
source/bullet.h
View File

@@ -63,9 +63,9 @@ class Bullet {
Circle collider_; // Círculo de colisión Circle collider_; // Círculo de colisión
// Métodos internos // Métodos internos
void shiftColliders(); // Ajusta el círculo de colisión void shiftColliders(); // Ajusta el círculo de colisión
void shiftSprite(); // Ajusta el sprite void shiftSprite(); // Ajusta el sprite
auto move() -> BulletMoveStatus; // Mueve la bala y devuelve su estado auto move() -> BulletMoveStatus; // Mueve la bala y devuelve su estado
float calculateVelocity(BulletType bullet_type); // Calcula la velocidad horizontal de la bala basada en su tipo static auto calculateVelocity(BulletType bullet_type) -> float; // Calcula la velocidad horizontal de la bala basada en su tipo
std::string buildAnimationString(BulletType bullet_type, bool powered); // Construye el string de animación basado en el tipo de bala y si está potenciada static auto buildAnimationString(BulletType bullet_type, bool powered) -> std::string; // Construye el string de animación basado en el tipo de bala y si está potenciada
}; };

2
source/director.cpp
View File

@@ -588,7 +588,7 @@ void Director::reset() {
Lang::setLanguage(Options::settings.language); Lang::setLanguage(Options::settings.language);
Audio::get()->stopMusic(); Audio::get()->stopMusic();
Audio::get()->stopAllSounds(); Audio::get()->stopAllSounds();
if (true) { {
Resource::get()->reload(); Resource::get()->reload();
} }
Input::get()->discoverGameControllers(); Input::get()->discoverGameControllers();

72
source/director.h
View File

@@ -1,54 +1,54 @@
#pragma once #pragma once
#include <string> // Para manejar cadenas de texto
#include <span> #include <span>
#include <string> // Para manejar cadenas de texto
namespace Lang { namespace Lang {
enum class Code : int; enum class Code : int;
} }
class Director { class Director {
public: public:
// --- Constructor y destructor --- // --- Constructor y destructor ---
Director(int argc, std::span<char*> argv); Director(int argc, std::span<char *> argv);
~Director(); ~Director();
// --- Bucle principal --- // --- Bucle principal ---
auto run() -> int; auto run() -> int;
private: private:
// --- Variables internas --- // --- Variables internas ---
std::string executable_path_; // Ruta del ejecutable std::string executable_path_; // Ruta del ejecutable
std::string system_folder_; // Carpeta del sistema para almacenar datos std::string system_folder_; // Carpeta del sistema para almacenar datos
// --- Inicialización y cierre del sistema --- // --- Inicialización y cierre del sistema ---
void init(); // Inicializa la aplicación void init(); // Inicializa la aplicación
void close(); // Cierra y libera recursos static void close(); // Cierra y libera recursos
// --- Configuración inicial --- // --- Configuración inicial ---
static void loadParams(); // Carga los parámetros del programa static void loadParams(); // Carga los parámetros del programa
static void loadScoreFile(); // Carga el fichero de puntuaciones static void loadScoreFile(); // Carga el fichero de puntuaciones
void createSystemFolder(const std::string &folder); // Crea la carpeta del sistema void createSystemFolder(const std::string &folder); // Crea la carpeta del sistema
// --- Gestión de entrada y archivos --- // --- Gestión de entrada y archivos ---
static void bindInputs(); // Asigna botones y teclas al sistema de entrada static void bindInputs(); // Asigna botones y teclas al sistema de entrada
void setFileList(); // Crea el índice de archivos disponibles void setFileList(); // Crea el índice de archivos disponibles
void checkProgramArguments(int argc, std::span<char*> argv); // Verifica los parámetros del programa // NOLINT(modernize-avoid-c-arrays) void checkProgramArguments(int argc, std::span<char *> argv); // Verifica los parámetros del programa // NOLINT(modernize-avoid-c-arrays)
// --- Secciones del programa --- // --- Secciones del programa ---
static void runLogo(); // Ejecuta la pantalla con el logo static void runLogo(); // Ejecuta la pantalla con el logo
static void runIntro(); // Ejecuta la introducción del juego static void runIntro(); // Ejecuta la introducción del juego
static void runTitle(); // Ejecuta la pantalla de título static void runTitle(); // Ejecuta la pantalla de título
static void runGame(); // Inicia el juego static void runGame(); // Inicia el juego
static void runInstructions(); // Muestra las instrucciones static void runInstructions(); // Muestra las instrucciones
static void runCredits(); // Muestra los créditos del juego static void runCredits(); // Muestra los créditos del juego
static void runHiScoreTable(); // Muestra la tabla de puntuaciones static void runHiScoreTable(); // Muestra la tabla de puntuaciones
static void runDemoGame(); // Ejecuta el modo demo static void runDemoGame(); // Ejecuta el modo demo
void reset(); // Reinicia objetos y vuelve a la sección inicial static void reset(); // Reinicia objetos y vuelve a la sección inicial
// --- Gestión de archivos de idioma --- // --- Gestión de archivos de idioma ---
auto getLangFile(Lang::Code code) -> std::string; // Obtiene un fichero de idioma según el código auto getLangFile(Lang::Code code) -> std::string; // Obtiene un fichero de idioma según el código
// --- Apagado del sistema --- // --- Apagado del sistema ---
static void shutdownSystem(bool should_shutdown); // Apaga el sistema static void shutdownSystem(bool should_shutdown); // Apaga el sistema
}; };

44
source/enter_name.h
View File

@@ -11,32 +11,32 @@ constexpr size_t NAME_SIZE = 5;
// Clase EnterName // Clase EnterName
class EnterName { class EnterName {
public: public:
EnterName(); EnterName();
~EnterName() = default; ~EnterName() = default;
void init(const std::string &name = ""); // Inicializa con un nombre opcional void init(const std::string &name = ""); // Inicializa con un nombre opcional
void incPosition(); // Incrementa la posición del carácter actual void incPosition(); // Incrementa la posición del carácter actual
void decPosition(); // Decrementa la posición del carácter actual void decPosition(); // Decrementa la posición del carácter actual
void incIndex(); // Incrementa el índice del carácter en la lista void incIndex(); // Incrementa el índice del carácter en la lista
void decIndex(); // Decrementa el índice del carácter en la lista void decIndex(); // Decrementa el índice del carácter en la lista
auto getFinalName() -> std::string; // Obtiene el nombre final introducido auto getFinalName() -> std::string; // Obtiene el nombre final introducido
[[nodiscard]] auto getCurrentName() const -> std::string { return trim(name_); } // Obtiene el nombre actual en proceso [[nodiscard]] auto getCurrentName() const -> std::string { return trim(name_); } // Obtiene el nombre actual en proceso
[[nodiscard]] auto getPosition() const -> int { return position_; } // Posición actual del carácter editado [[nodiscard]] auto getPosition() const -> int { return position_; } // Posición actual del carácter editado
[[nodiscard]] auto getPositionOverflow() const -> bool { return position_overflow_; } // Indica si la posición excede el límite [[nodiscard]] auto getPositionOverflow() const -> bool { return position_overflow_; } // Indica si la posición excede el límite
private: private:
std::string character_list_; // Lista de caracteres permitidos std::string character_list_; // Lista de caracteres permitidos
std::string name_; // Nombre en proceso std::string name_; // Nombre en proceso
size_t position_ = 0; // Índice del carácter que se edita size_t position_ = 0; // Índice del carácter que se edita
bool position_overflow_ = false; // Flag para exceder límite bool position_overflow_ = false; // Flag para exceder límite
std::array<int, NAME_SIZE> character_index_; // Índices a "character_list_" std::array<int, NAME_SIZE> character_index_; // Índices a "character_list_"
void updateNameFromCharacterIndex(); // Actualiza "name_" según "character_index_" void updateNameFromCharacterIndex(); // Actualiza "name_" según "character_index_"
void initCharacterIndex(const std::string &name); // Inicializa índices desde el nombre void initCharacterIndex(const std::string &name); // Inicializa índices desde el nombre
[[nodiscard]] auto findIndex(char character) const -> int; // Busca el índice de un carácter en "character_list_" [[nodiscard]] auto findIndex(char character) const -> int; // Busca el índice de un carácter en "character_list_"
static auto getRandomName() -> std::string; // Devuelve un nombre al azar static auto getRandomName() -> std::string; // Devuelve un nombre al azar
}; };

52
source/explosions.h
View File

@@ -11,43 +11,43 @@ class Texture;
// Estructura para almacenar la información de una textura de explosión // Estructura para almacenar la información de una textura de explosión
struct ExplosionTexture { struct ExplosionTexture {
int size; // Tamaño de la explosión int size; // Tamaño de la explosión
std::shared_ptr<Texture> texture; // Textura para la explosión std::shared_ptr<Texture> texture; // Textura para la explosión
std::vector<std::string> animation; // Animación para la textura std::vector<std::string> animation; // Animación para la textura
ExplosionTexture(int sz, std::shared_ptr<Texture> tex, const std::vector<std::string> &anim) ExplosionTexture(int sz, std::shared_ptr<Texture> tex, const std::vector<std::string> &anim)
: size(sz), texture(std::move(tex)), animation(anim) {} : size(sz), texture(std::move(tex)), animation(anim) {}
}; };
// Clase Explosions // Clase Explosions
class Explosions { class Explosions {
public: public:
// Constructor y destructor // Constructor y destructor
Explosions() = default; Explosions() = default;
~Explosions() = default; ~Explosions() = default;
// Actualiza la lógica de la clase // Actualiza la lógica de la clase
void update(); void update();
// Dibuja el objeto en pantalla // Dibuja el objeto en pantalla
void render(); void render();
// Añade texturas al objeto // Añade texturas al objeto
void addTexture(int size, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation); void addTexture(int size, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
// Añade una explosión // Añade una explosión
void add(int x, int y, int size); void add(int x, int y, int size);
private: private:
// Vector con las texturas a utilizar // Vector con las texturas a utilizar
std::vector<ExplosionTexture> textures_; std::vector<ExplosionTexture> textures_;
// Lista con todas las explosiones // Lista con todas las explosiones
std::vector<std::unique_ptr<AnimatedSprite>> explosions_; std::vector<std::unique_ptr<AnimatedSprite>> explosions_;
// Vacia el vector de elementos finalizados // Vacia el vector de elementos finalizados
void freeExplosions(); void freeExplosions();
// Busca una textura a partir del tamaño // Busca una textura a partir del tamaño
auto getIndexBySize(int size) -> int; auto getIndexBySize(int size) -> int;
}; };

2
source/external/.clang-format vendored Normal file
View File

@@ -0,0 +1,2 @@
DisableFormat: true
SortIncludes: Never

94
source/fade.h
View File

@@ -30,61 +30,61 @@ enum class FadeState : Uint8 {
}; };
class Fade { class Fade {
public: public:
// --- Constructores y destructor --- // --- Constructores y destructor ---
Fade(); Fade();
~Fade(); ~Fade();
// --- Métodos principales --- // --- Métodos principales ---
void reset(); // Resetea variables para reutilizar el fade void reset(); // Resetea variables para reutilizar el fade
void render(); // Dibuja la transición en pantalla void render(); // Dibuja la transición en pantalla
void update(); // Actualiza el estado interno void update(); // Actualiza el estado interno
void activate(); // Activa el fade void activate(); // Activa el fade
// --- Configuración --- // --- Configuración ---
void setColor(Uint8 r, Uint8 g, Uint8 b); void setColor(Uint8 r, Uint8 g, Uint8 b);
void setColor(Color color); void setColor(Color color);
void setType(FadeType type) { type_ = type; } void setType(FadeType type) { type_ = type; }
void setMode(FadeMode mode) { mode_ = mode; } void setMode(FadeMode mode) { mode_ = mode; }
void setPostDuration(int value) { post_duration_ = value; } void setPostDuration(int value) { post_duration_ = value; }
void setPreDuration(int value) { pre_duration_ = value; } void setPreDuration(int value) { pre_duration_ = value; }
// --- Getters --- // --- Getters ---
[[nodiscard]] auto getValue() const -> int { return value_; } [[nodiscard]] auto getValue() const -> int { return value_; }
[[nodiscard]] auto isEnabled() const -> bool { return state_ != FadeState::NOT_ENABLED; } [[nodiscard]] auto isEnabled() const -> bool { return state_ != FadeState::NOT_ENABLED; }
[[nodiscard]] auto hasEnded() const -> bool { return state_ == FadeState::FINISHED; } [[nodiscard]] auto hasEnded() const -> bool { return state_ == FadeState::FINISHED; }
private: private:
// --- Objetos y punteros --- // --- Objetos y punteros ---
SDL_Renderer *renderer_; // Renderizador de la ventana SDL_Renderer *renderer_; // Renderizador de la ventana
SDL_Texture *backbuffer_; // Backbuffer para efectos SDL_Texture *backbuffer_; // Backbuffer para efectos
// --- Variables de estado --- // --- Variables de estado ---
FadeType type_; // Tipo de fade FadeType type_; // Tipo de fade
FadeMode mode_; // Modo de fade FadeMode mode_; // Modo de fade
FadeState state_ = FadeState::NOT_ENABLED; // Estado actual FadeState state_ = FadeState::NOT_ENABLED; // Estado actual
Uint16 counter_; // Contador interno Uint16 counter_; // Contador interno
// --- Parámetros de color y geometría --- // --- Parámetros de color y geometría ---
Uint8 r_, g_, b_, a_; // Color del fade Uint8 r_, g_, b_, a_; // Color del fade
SDL_FRect rect1_, rect2_; // Rectángulos para efectos SDL_FRect rect1_, rect2_; // Rectángulos para efectos
// --- Parámetros para RANDOM_SQUARE --- // --- Parámetros para RANDOM_SQUARE ---
int num_squares_width_; // Cuadrados en horizontal int num_squares_width_; // Cuadrados en horizontal
int num_squares_height_; // Cuadrados en vertical int num_squares_height_; // Cuadrados en vertical
std::vector<SDL_FRect> square_; // Vector de cuadrados std::vector<SDL_FRect> square_; // Vector de cuadrados
int fade_random_squares_delay_; // Delay entre cuadrados int fade_random_squares_delay_; // Delay entre cuadrados
int fade_random_squares_mult_; // Cuadrados por paso int fade_random_squares_mult_; // Cuadrados por paso
// --- Temporizadores --- // --- Temporizadores ---
int post_duration_ = 0, post_counter_ = 0; int post_duration_ = 0, post_counter_ = 0;
int pre_duration_ = 0, pre_counter_ = 0; int pre_duration_ = 0, pre_counter_ = 0;
// --- Valor de progreso --- // --- Valor de progreso ---
int value_ = 0; // Estado del fade (0-100) int value_ = 0; // Estado del fade (0-100)
// --- Métodos internos --- // --- Métodos internos ---
void init(); // Inicializa variables void init(); // Inicializa variables
void cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a); // Limpia el backbuffer void cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a); // Limpia el backbuffer
static auto calculateValue(int min, int max, int current) -> int; // Calcula el valor del fade static auto calculateValue(int min, int max, int current) -> int; // Calcula el valor del fade
}; };

116
source/game_logo.h
View File

@@ -10,73 +10,73 @@ class Texture;
// Clase GameLogo // Clase GameLogo
class GameLogo { class GameLogo {
public: public:
// --- Constructores y destructor --- // --- Constructores y destructor ---
GameLogo(int x, int y); GameLogo(int x, int y);
~GameLogo() = default; ~GameLogo() = default;
// --- Métodos principales --- // --- Métodos principales ---
void render(); // Pinta la clase en pantalla void render(); // Pinta la clase en pantalla
void update(); // Actualiza la lógica de la clase void update(); // Actualiza la lógica de la clase
void enable(); // Activa la clase void enable(); // Activa la clase
// --- Getters --- // --- Getters ---
[[nodiscard]] auto hasFinished() const -> bool; // Indica si ha terminado la animación [[nodiscard]] auto hasFinished() const -> bool; // Indica si ha terminado la animación
private: private:
// --- Tipos internos --- // --- Tipos internos ---
enum class Status { enum class Status {
DISABLED, DISABLED,
MOVING, MOVING,
SHAKING, SHAKING,
FINISHED, FINISHED,
}; };
struct Shake { struct Shake {
int desp = 1; // Pixels de desplazamiento para agitar la pantalla en el eje x int desp = 1; // Pixels de desplazamiento para agitar la pantalla en el eje x
int delay = 2; // Retraso entre cada desplazamiento de la pantalla al agitarse int delay = 2; // Retraso entre cada desplazamiento de la pantalla al agitarse
int lenght = 8; // Cantidad de desplazamientos a realizar int lenght = 8; // Cantidad de desplazamientos a realizar
int remaining = lenght; // Cantidad de desplazamientos pendientes a realizar int remaining = lenght; // Cantidad de desplazamientos pendientes a realizar
int counter = delay; // Contador para el retraso int counter = delay; // Contador para el retraso
int origin = 0; // Valor inicial de la pantalla para dejarla igual tras el desplazamiento int origin = 0; // Valor inicial de la pantalla para dejarla igual tras el desplazamiento
Shake() = default; Shake() = default;
Shake(int d, int de, int l, int o) Shake(int d, int de, int l, int o)
: desp(d), delay(de), lenght(l), remaining(l), counter(de), origin(o) {} : desp(d), delay(de), lenght(l), remaining(l), counter(de), origin(o) {}
void init(int d, int de, int l, int o) { void init(int d, int de, int l, int o) {
desp = d; desp = d;
delay = de; delay = de;
lenght = l; lenght = l;
remaining = l; remaining = l;
counter = de; counter = de;
origin = o; origin = o;
} }
}; };
// --- Objetos y punteros --- // --- Objetos y punteros ---
std::shared_ptr<Texture> dust_texture_; // Textura con los graficos del polvo std::shared_ptr<Texture> dust_texture_; // Textura con los graficos del polvo
std::shared_ptr<Texture> coffee_texture_; // Textura con los graficos de la palabra "COFFEE" std::shared_ptr<Texture> coffee_texture_; // Textura con los graficos de la palabra "COFFEE"
std::shared_ptr<Texture> crisis_texture_; // Textura con los graficos de la palabra "CRISIS" std::shared_ptr<Texture> crisis_texture_; // Textura con los graficos de la palabra "CRISIS"
std::shared_ptr<Texture> arcade_edition_texture_; // Textura con los graficos de "Arcade Edition" std::shared_ptr<Texture> arcade_edition_texture_; // Textura con los graficos de "Arcade Edition"
std::unique_ptr<AnimatedSprite> dust_left_sprite_; // Sprite del polvo (izquierda) std::unique_ptr<AnimatedSprite> dust_left_sprite_; // Sprite del polvo (izquierda)
std::unique_ptr<AnimatedSprite> dust_right_sprite_; // Sprite del polvo (derecha) std::unique_ptr<AnimatedSprite> dust_right_sprite_; // Sprite del polvo (derecha)
std::unique_ptr<SmartSprite> coffee_sprite_; // Sprite de "COFFEE" std::unique_ptr<SmartSprite> coffee_sprite_; // Sprite de "COFFEE"
std::unique_ptr<SmartSprite> crisis_sprite_; // Sprite de "CRISIS" std::unique_ptr<SmartSprite> crisis_sprite_; // Sprite de "CRISIS"
std::unique_ptr<Sprite> arcade_edition_sprite_; // Sprite de "Arcade Edition" std::unique_ptr<Sprite> arcade_edition_sprite_; // Sprite de "Arcade Edition"
// --- Variables de estado --- // --- Variables de estado ---
float x_; // Posición X del logo float x_; // Posición X del logo
float y_; // Posición Y del logo float y_; // Posición Y del logo
float zoom_ = 1.0F; // Zoom aplicado al texto "ARCADE EDITION" float zoom_ = 1.0F; // Zoom aplicado al texto "ARCADE EDITION"
int post_finished_counter_ = 1; // Contador final tras animaciones int post_finished_counter_ = 1; // Contador final tras animaciones
Status coffee_crisis_status_ = Status::DISABLED; // Estado de "COFFEE CRISIS" Status coffee_crisis_status_ = Status::DISABLED; // Estado de "COFFEE CRISIS"
Status arcade_edition_status_ = Status::DISABLED; // Estado de "ARCADE EDITION" Status arcade_edition_status_ = Status::DISABLED; // Estado de "ARCADE EDITION"
Shake shake_; // Efecto de agitación Shake shake_; // Efecto de agitación
// --- Métodos internos --- // --- Métodos internos ---
void init(); // Inicializa las variables void init(); // Inicializa las variables
[[nodiscard]] auto getInitialVerticalDesp() const -> int; // Calcula el desplazamiento vertical inicial [[nodiscard]] auto getInitialVerticalDesp() const -> int; // Calcula el desplazamiento vertical inicial
}; };

10
source/input.h
View File

@@ -80,7 +80,7 @@ class Input {
void bindGameControllerButton(int controller_index, InputAction input_target, InputAction input_source); // Asigna inputs a otros inputs del mando void bindGameControllerButton(int controller_index, InputAction input_target, InputAction input_source); // Asigna inputs a otros inputs del mando
// --- Métodos de consulta de entrada --- // --- Métodos de consulta de entrada ---
void update(); // Comprueba fisicamente los botones y teclas que se han pulsado void update(); // Comprueba fisicamente los botones y teclas que se han pulsado
auto checkInput(InputAction input, bool repeat = true, InputDevice device = InputDevice::ANY, int controller_index = 0) -> bool; // Comprueba si un input está activo auto checkInput(InputAction input, bool repeat = true, InputDevice device = InputDevice::ANY, int controller_index = 0) -> bool; // Comprueba si un input está activo
auto checkAnyInput(InputDevice device = InputDevice::ANY, int controller_index = 0) -> bool; // Comprueba si hay al menos un input activo auto checkAnyInput(InputDevice device = InputDevice::ANY, int controller_index = 0) -> bool; // Comprueba si hay al menos un input activo
auto checkAnyButton(bool repeat = INPUT_DO_NOT_ALLOW_REPEAT) -> int; // Comprueba si hay algún botón pulsado auto checkAnyButton(bool repeat = INPUT_DO_NOT_ALLOW_REPEAT) -> int; // Comprueba si hay algún botón pulsado
@@ -93,7 +93,7 @@ class Input {
[[nodiscard]] auto getJoyIndex(SDL_JoystickID id) const -> int; // Obtiene el índice del controlador a partir de un event.id [[nodiscard]] auto getJoyIndex(SDL_JoystickID id) const -> int; // Obtiene el índice del controlador a partir de un event.id
// --- Métodos de consulta y utilidades --- // --- Métodos de consulta y utilidades ---
void printBindings(InputDevice device = InputDevice::KEYBOARD, int controller_index = 0) const; // Muestra por consola los controles asignados void printBindings(InputDevice device = InputDevice::KEYBOARD, int controller_index = 0) const; // Muestra por consola los controles asignados
[[nodiscard]] auto getControllerBinding(int controller_index, InputAction input) const -> SDL_GamepadButton; // Obtiene el SDL_GamepadButton asignado a un input [[nodiscard]] auto getControllerBinding(int controller_index, InputAction input) const -> SDL_GamepadButton; // Obtiene el SDL_GamepadButton asignado a un input
[[nodiscard]] static auto inputToString(InputAction input) -> std::string; // Convierte un InputAction a std::string [[nodiscard]] static auto inputToString(InputAction input) -> std::string; // Convierte un InputAction a std::string
[[nodiscard]] static auto stringToInput(const std::string &name) -> InputAction; // Convierte un std::string a InputAction [[nodiscard]] static auto stringToInput(const std::string &name) -> InputAction; // Convierte un std::string a InputAction
@@ -138,12 +138,12 @@ class Input {
std::string game_controller_db_path_; // Ruta al archivo gamecontrollerdb.txt std::string game_controller_db_path_; // Ruta al archivo gamecontrollerdb.txt
// --- Métodos internos --- // --- Métodos internos ---
void initSDLGamePad(); // Inicializa SDL para la gestión de mandos void initSDLGamePad(); // Inicializa SDL para la gestión de mandos
auto checkAxisInput(InputAction input, int controller_index, bool repeat) -> bool; // Comprueba el eje del mando auto checkAxisInput(InputAction input, int controller_index, bool repeat) -> bool; // Comprueba el eje del mando
// --- Constructor y destructor --- // --- Constructor y destructor ---
explicit Input(std::string game_controller_db_path); // Constructor privado explicit Input(std::string game_controller_db_path); // Constructor privado
~Input() = default; // Destructor privado ~Input() = default; // Destructor privado
// --- Singleton --- // --- Singleton ---
static Input *instance; static Input *instance;

4
source/item.cpp
View File

@@ -184,12 +184,12 @@ auto Item::getCoffeeMachineSpawn(int player_x, int item_width, int area_width, i
return rand() % (exclude_left - LEFT_BOUND) + LEFT_BOUND; return rand() % (exclude_left - LEFT_BOUND) + LEFT_BOUND;
} // Lado derecho } // Lado derecho
return rand() % (RIGHT_BOUND - exclude_right) + exclude_right; return rand() % (RIGHT_BOUND - exclude_right) + exclude_right;
} }
if (can_spawn_left) { if (can_spawn_left) {
// Solo lado izquierdo disponible // Solo lado izquierdo disponible
return rand() % (exclude_left - LEFT_BOUND) + LEFT_BOUND; return rand() % (exclude_left - LEFT_BOUND) + LEFT_BOUND;
} else if (can_spawn_right) { }
if (can_spawn_right) {
// Solo lado derecho disponible // Solo lado derecho disponible
return rand() % (RIGHT_BOUND - exclude_right) + exclude_right; return rand() % (RIGHT_BOUND - exclude_right) + exclude_right;
} else { } else {

120
source/item.h
View File

@@ -27,78 +27,78 @@ enum class ItemType : int {
// Clase Item. // Clase Item.
// Representa un objeto en el juego, con sus propiedades y métodos para gestionar su comportamiento. // Representa un objeto en el juego, con sus propiedades y métodos para gestionar su comportamiento.
class Item { class Item {
public: public:
// Constantes // Constantes
static constexpr int COFFEE_MACHINE_WIDTH = 30; static constexpr int COFFEE_MACHINE_WIDTH = 30;
static constexpr int COFFEE_MACHINE_HEIGHT = 39; static constexpr int COFFEE_MACHINE_HEIGHT = 39;
// Constructor. Inicializa un objeto Item con el tipo, posición, área de juego, textura y animación. // Constructor. Inicializa un objeto Item con el tipo, posición, área de juego, textura y animación.
Item(ItemType type, float x, float y, SDL_FRect &play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation); Item(ItemType type, float x, float y, SDL_FRect &play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
// Destructor. // Destructor.
~Item() = default; ~Item() = default;
// Centra el objeto en la posición X indicada, asegurando que no se salga del área de juego. // Centra el objeto en la posición X indicada, asegurando que no se salga del área de juego.
void alignTo(int x); void alignTo(int x);
// Renderiza el objeto en pantalla si está habilitado. // Renderiza el objeto en pantalla si está habilitado.
// Si el tiempo de vida es mayor que 200, renderiza el sprite. // Si el tiempo de vida es mayor que 200, renderiza el sprite.
// Si es menor o igual a 200, renderiza el sprite de forma intermitente. // Si es menor o igual a 200, renderiza el sprite de forma intermitente.
void render(); void render();
// Desactiva el objeto estableciendo su estado enabled_ a false. // Desactiva el objeto estableciendo su estado enabled_ a false.
void disable(); void disable();
// Actualiza la posición, animación y contadores del objeto. // Actualiza la posición, animación y contadores del objeto.
// Llama a move(), sprite_->update() y updateTimeToLive(). // Llama a move(), sprite_->update() y updateTimeToLive().
void update(); void update();
// Getters // Getters
[[nodiscard]] auto getPosX() const -> float { return pos_x_; } [[nodiscard]] auto getPosX() const -> float { return pos_x_; }
[[nodiscard]] auto getPosY() const -> float { return pos_y_; } [[nodiscard]] auto getPosY() const -> float { return pos_y_; }
[[nodiscard]] auto getWidth() const -> int { return width_; } [[nodiscard]] auto getWidth() const -> int { return width_; }
[[nodiscard]] auto getHeight() const -> int { return height_; } [[nodiscard]] auto getHeight() const -> int { return height_; }
[[nodiscard]] auto getType() const -> ItemType { return type_; } [[nodiscard]] auto getType() const -> ItemType { return type_; }
[[nodiscard]] auto isEnabled() const -> bool { return enabled_; } [[nodiscard]] auto isEnabled() const -> bool { return enabled_; }
[[nodiscard]] auto isOnFloor() const -> bool { return floor_collision_; } [[nodiscard]] auto isOnFloor() const -> bool { return floor_collision_; }
auto getCollider() -> Circle & { return collider_; } auto getCollider() -> Circle & { return collider_; }
private: private:
// Objetos y punteros // Objetos y punteros
std::unique_ptr<AnimatedSprite> sprite_; // Sprite con los gráficos del objeto std::unique_ptr<AnimatedSprite> sprite_; // Sprite con los gráficos del objeto
// Variables de estado y físicas // Variables de estado y físicas
float pos_x_; // Posición X del objeto float pos_x_; // Posición X del objeto
float pos_y_; // Posición Y del objeto float pos_y_; // Posición Y del objeto
int width_; // Ancho del objeto int width_; // Ancho del objeto
int height_; // Alto del objeto int height_; // Alto del objeto
float vel_x_; // Velocidad en el eje X float vel_x_; // Velocidad en el eje X
float vel_y_; // Velocidad en el eje Y float vel_y_; // Velocidad en el eje Y
float accel_x_ = 0.0F; // Aceleración en el eje X float accel_x_ = 0.0F; // Aceleración en el eje X
float accel_y_; // Aceleración en el eje Y float accel_y_; // Aceleración en el eje Y
bool floor_collision_ = false; // Indica si el objeto colisiona con el suelo bool floor_collision_ = false; // Indica si el objeto colisiona con el suelo
ItemType type_; // Tipo de objeto ItemType type_; // Tipo de objeto
bool enabled_ = true; // Indica si el objeto está habilitado bool enabled_ = true; // Indica si el objeto está habilitado
Circle collider_; // Círculo de colisión del objeto Circle collider_; // Círculo de colisión del objeto
SDL_FRect play_area_; // Rectángulo con la zona de juego SDL_FRect play_area_; // Rectángulo con la zona de juego
Uint16 time_to_live_ = 600; // Tiempo que el objeto está presente Uint16 time_to_live_ = 600; // Tiempo que el objeto está presente
// Alinea el círculo de colisión con la posición del objeto. // Alinea el círculo de colisión con la posición del objeto.
// Actualiza las coordenadas X e Y del colisionador. // Actualiza las coordenadas X e Y del colisionador.
void shiftColliders(); void shiftColliders();
// Coloca el sprite en la posición del objeto. // Coloca el sprite en la posición del objeto.
// Actualiza las coordenadas X e Y del sprite. // Actualiza las coordenadas X e Y del sprite.
void shiftSprite(); void shiftSprite();
// Actualiza la posición y estados del objeto. // Actualiza la posición y estados del objeto.
// Controla las colisiones con los límites del área de juego y actualiza sprite y colisionador. // Controla las colisiones con los límites del área de juego y actualiza sprite y colisionador.
void move(); void move();
// Actualiza el contador de tiempo de vida del objeto. // Actualiza el contador de tiempo de vida del objeto.
// Si el tiempo de vida es mayor a 0, lo decrementa. Si llega a 0, desactiva el objeto. // Si el tiempo de vida es mayor a 0, lo decrementa. Si llega a 0, desactiva el objeto.
void updateTimeToLive(); void updateTimeToLive();
// Calcula la zona de aparición de la máquina de café // Calcula la zona de aparición de la máquina de café
static auto getCoffeeMachineSpawn(int player_x, int item_width, int area_width, int margin = 2) -> int; static auto getCoffeeMachineSpawn(int player_x, int item_width, int area_width, int margin = 2) -> int;
}; };

10
source/lang.h
View File

@@ -13,12 +13,12 @@ enum class Code : int {
// Estructura que representa un idioma // Estructura que representa un idioma
struct Language { struct Language {
Code code; // Código que identifica al idioma Code code; // Código que identifica al idioma
std::string name; // Nombre que identifica el idioma std::string name; // Nombre que identifica el idioma
std::string file_name; // Nombre del fichero con los textos std::string file_name; // Nombre del fichero con los textos
Language(Code c, std::string n, std::string fn) Language(Code c, std::string n, std::string fn)
: code(c), name(std::move(n)), file_name(std::move(fn)) {} : code(c), name(std::move(n)), file_name(std::move(fn)) {}
}; };
// Carga los textos desde el fichero JSON especificado // Carga los textos desde el fichero JSON especificado

50
source/manage_hiscore_table.h
View File

@@ -13,41 +13,41 @@
// --- Estructura para las entradas de la tabla de records --- // --- Estructura para las entradas de la tabla de records ---
struct HiScoreEntry { struct HiScoreEntry {
std::string name; // Nombre std::string name; // Nombre
int score; // Puntuación int score; // Puntuación
bool one_credit_complete; // Indica si se ha conseguido 1CC bool one_credit_complete; // Indica si se ha conseguido 1CC
// Constructor // Constructor
explicit HiScoreEntry(const std::string &n = "", int s = 0, bool occ = false) explicit HiScoreEntry(const std::string &n = "", int s = 0, bool occ = false)
: name(n.substr(0, 6)), score(s), one_credit_complete(occ) {} : name(n.substr(0, 6)), score(s), one_credit_complete(occ) {}
}; };
// --- Clase ManageHiScoreTable --- // --- Clase ManageHiScoreTable ---
class ManageHiScoreTable { class ManageHiScoreTable {
public: public:
// Constructor // Constructor
explicit ManageHiScoreTable(std::vector<HiScoreEntry> &table) explicit ManageHiScoreTable(std::vector<HiScoreEntry> &table)
: table_(table) {} : table_(table) {}
// Destructor // Destructor
~ManageHiScoreTable() = default; ~ManageHiScoreTable() = default;
// Resetea la tabla a los valores por defecto // Resetea la tabla a los valores por defecto
void clear(); void clear();
// Añade un elemento a la tabla (devuelve la posición en la que se inserta) // Añade un elemento a la tabla (devuelve la posición en la que se inserta)
auto add(const HiScoreEntry &entry) -> int; auto add(const HiScoreEntry &entry) -> int;
// Carga la tabla con los datos de un fichero // Carga la tabla con los datos de un fichero
auto loadFromFile(const std::string &file_path) -> bool; auto loadFromFile(const std::string &file_path) -> bool;
// Guarda la tabla en un fichero // Guarda la tabla en un fichero
auto saveToFile(const std::string &file_path) -> bool; auto saveToFile(const std::string &file_path) -> bool;
private: private:
// Referencia a la tabla con los records // Referencia a la tabla con los records
std::vector<HiScoreEntry> &table_; std::vector<HiScoreEntry> &table_;
// Ordena la tabla internamente // Ordena la tabla internamente
void sort(); void sort();
}; };

136
source/moving_sprite.h
View File

@@ -11,85 +11,85 @@ class Texture;
// Clase MovingSprite. Añade movimiento y efectos de rotación, zoom y flip al sprite // Clase MovingSprite. Añade movimiento y efectos de rotación, zoom y flip al sprite
class MovingSprite : public Sprite { class MovingSprite : public Sprite {
public: public:
// --- Estructura para la rotación --- // --- Estructura para la rotación ---
struct Rotate { struct Rotate {
bool enabled{false}; // Indica si ha de rotar bool enabled{false}; // Indica si ha de rotar
int counter{0}; // Contador int counter{0}; // Contador
int speed{1}; // Velocidad de giro int speed{1}; // Velocidad de giro
double angle{0.0}; // Ángulo para dibujarlo double angle{0.0}; // Ángulo para dibujarlo
float amount{0.0F}; // Cantidad de grados a girar en cada iteración float amount{0.0F}; // Cantidad de grados a girar en cada iteración
SDL_FPoint center; // Centro de rotación SDL_FPoint center; // Centro de rotación
Rotate() : center({0.0F, 0.0F}) {} Rotate() : center({0.0F, 0.0F}) {}
}; };
// --- Constructores y destructor --- // --- Constructores y destructor ---
MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos, MovingSprite::Rotate rotate, float zoom_w, float zoom_h, SDL_FlipMode flip); MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos, MovingSprite::Rotate rotate, float zoom_w, float zoom_h, SDL_FlipMode flip);
MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos); MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos);
explicit MovingSprite(std::shared_ptr<Texture> texture); explicit MovingSprite(std::shared_ptr<Texture> texture);
~MovingSprite() override = default; ~MovingSprite() override = default;
// --- Métodos principales --- // --- Métodos principales ---
virtual void update(); // Actualiza las variables internas del objeto virtual void update(); // Actualiza las variables internas del objeto
void clear() override; // Reinicia todas las variables a cero void clear() override; // Reinicia todas las variables a cero
void render() override; // Muestra el sprite por pantalla void render() override; // Muestra el sprite por pantalla
// --- Getters de posición y movimiento --- // --- Getters de posición y movimiento ---
[[nodiscard]] auto getPosX() const -> float { return x_; } [[nodiscard]] auto getPosX() const -> float { return x_; }
[[nodiscard]] auto getPosY() const -> float { return y_; } [[nodiscard]] auto getPosY() const -> float { return y_; }
[[nodiscard]] auto getVelX() const -> float { return vx_; } [[nodiscard]] auto getVelX() const -> float { return vx_; }
[[nodiscard]] auto getVelY() const -> float { return vy_; } [[nodiscard]] auto getVelY() const -> float { return vy_; }
[[nodiscard]] auto getAccelX() const -> float { return ax_; } [[nodiscard]] auto getAccelX() const -> float { return ax_; }
[[nodiscard]] auto getAccelY() const -> float { return ay_; } [[nodiscard]] auto getAccelY() const -> float { return ay_; }
// --- Setters de movimiento --- // --- Setters de movimiento ---
void setVelX(float value) { vx_ = value; } void setVelX(float value) { vx_ = value; }
void setVelY(float value) { vy_ = value; } void setVelY(float value) { vy_ = value; }
void setAccelX(float value) { ax_ = value; } void setAccelX(float value) { ax_ = value; }
void setAccelY(float value) { ay_ = value; } void setAccelY(float value) { ay_ = value; }
// --- Rotación --- // --- Rotación ---
[[nodiscard]] auto isRotating() const -> bool { return rotate_.enabled; } [[nodiscard]] auto isRotating() const -> bool { return rotate_.enabled; }
void setZoomW(float value) { zoom_w_ = value; } void setZoomW(float value) { zoom_w_ = value; }
void setZoomH(float value) { zoom_h_ = value; } void setZoomH(float value) { zoom_h_ = value; }
void setAngle(double value) { rotate_.angle = value; } void setAngle(double value) { rotate_.angle = value; }
void setRotatingCenter(SDL_FPoint point) { rotate_.center = point; } void setRotatingCenter(SDL_FPoint point) { rotate_.center = point; }
void setRotate(bool enable); // Activa o desactiva el efecto de rotación void setRotate(bool enable); // Activa o desactiva el efecto de rotación
void setRotateSpeed(int value) { rotate_.speed = std::max(1, value); } void setRotateSpeed(int value) { rotate_.speed = std::max(1, value); }
void setRotateAmount(double value) { rotate_.amount = value; } void setRotateAmount(double value) { rotate_.amount = value; }
void switchRotate() { rotate_.amount *= -1; } // Cambia el sentido de la rotación void switchRotate() { rotate_.amount *= -1; } // Cambia el sentido de la rotación
// --- Flip --- // --- Flip ---
void setFlip(SDL_FlipMode flip) { flip_ = flip; } void setFlip(SDL_FlipMode flip) { flip_ = flip; }
void flip() { flip_ = (flip_ == SDL_FLIP_HORIZONTAL) ? SDL_FLIP_NONE : SDL_FLIP_HORIZONTAL; } void flip() { flip_ = (flip_ == SDL_FLIP_HORIZONTAL) ? SDL_FLIP_NONE : SDL_FLIP_HORIZONTAL; }
auto getFlip() -> SDL_FlipMode { return flip_; } auto getFlip() -> SDL_FlipMode { return flip_; }
// --- Posición y tamaño --- // --- Posición y tamaño ---
void setPos(SDL_FRect rect); // Establece la posición y el tamaño del objeto void setPos(SDL_FRect rect); // Establece la posición y el tamaño del objeto
void setPos(float pos_x, float pos_y); // Establece la posición del objeto void setPos(float pos_x, float pos_y); // Establece la posición del objeto
void setPosX(float pos_x); // Establece la posición X void setPosX(float pos_x); // Establece la posición X
void setPosY(float pos_y); // Establece la posición Y void setPosY(float pos_y); // Establece la posición Y
protected: protected:
// --- Variables de posición y movimiento --- // --- Variables de posición y movimiento ---
float x_ = 0.0F; // Posición en el eje X float x_ = 0.0F; // Posición en el eje X
float y_ = 0.0F; // Posición en el eje Y float y_ = 0.0F; // Posición en el eje Y
float vx_ = 0.0F; // Velocidad en el eje X. Cantidad de píxeles a desplazarse float vx_ = 0.0F; // Velocidad en el eje X. Cantidad de píxeles a desplazarse
float vy_ = 0.0F; // Velocidad en el eje Y. Cantidad de píxeles a desplazarse float vy_ = 0.0F; // Velocidad en el eje Y. Cantidad de píxeles a desplazarse
float ax_ = 0.0F; // Aceleración en el eje X. Variación de la velocidad float ax_ = 0.0F; // Aceleración en el eje X. Variación de la velocidad
float ay_ = 0.0F; // Aceleración en el eje Y. Variación de la velocidad float ay_ = 0.0F; // Aceleración en el eje Y. Variación de la velocidad
// --- Efectos visuales --- // --- Efectos visuales ---
Rotate rotate_; // Variables usadas para controlar la rotación del sprite Rotate rotate_; // Variables usadas para controlar la rotación del sprite
float zoom_w_; // Zoom aplicado a la anchura float zoom_w_; // Zoom aplicado a la anchura
float zoom_h_; // Zoom aplicado a la altura float zoom_h_; // Zoom aplicado a la altura
SDL_FlipMode flip_; // Indica cómo se voltea el sprite SDL_FlipMode flip_; // Indica cómo se voltea el sprite
// --- Métodos internos --- // --- Métodos internos ---
void updateAngle() { rotate_.angle += rotate_.amount; } // Incrementa el valor del ángulo void updateAngle() { rotate_.angle += rotate_.amount; } // Incrementa el valor del ángulo
void move(); // Mueve el sprite según velocidad y aceleración void move(); // Mueve el sprite según velocidad y aceleración
void rotate(); // Rota el sprite según los parámetros de rotación void rotate(); // Rota el sprite según los parámetros de rotación
}; };

19
source/notifier.cpp
View File

@@ -56,12 +56,9 @@ void Notifier::update() {
clearFinishedNotifications(); clearFinishedNotifications();
} }
bool Notifier::shouldProcessNotification(int index) const { auto Notifier::shouldProcessNotification(int index) const -> bool {
// Si la notificación anterior está "saliendo", no hagas nada // Si la notificación anterior está "saliendo", no hagas nada
if (index > 0 && notifications_[index - 1].state == NotificationStatus::RISING) { return !(index > 0 && notifications_[index - 1].state == NotificationStatus::RISING);
return false;
}
return true;
} }
void Notifier::processNotification(int index) { void Notifier::processNotification(int index) {
@@ -103,11 +100,11 @@ void Notifier::updateNotificationState(int index) {
void Notifier::handleRisingState(int index) { void Notifier::handleRisingState(int index) {
auto& notification = notifications_[index]; auto& notification = notifications_[index];
const float step = (float)notification.counter / notification.travel_dist; const float STEP = (float)notification.counter / notification.travel_dist;
const int alpha = 255 * step; const int ALPHA = 255 * STEP;
moveNotificationVertically(notification, param.notification.pos_v == NotifyPosition::TOP ? 1 : -1); moveNotificationVertically(notification, param.notification.pos_v == NotifyPosition::TOP ? 1 : -1);
notification.texture->setAlpha(alpha); notification.texture->setAlpha(ALPHA);
if (notification.rect.y == notification.y) { if (notification.rect.y == notification.y) {
transitionToStayState(index); transitionToStayState(index);
@@ -126,11 +123,11 @@ void Notifier::handleStayState(int index) {
void Notifier::handleVanishingState(int index) { void Notifier::handleVanishingState(int index) {
auto& notification = notifications_[index]; auto& notification = notifications_[index];
const float step = notification.counter / (float)notification.travel_dist; const float STEP = notification.counter / (float)notification.travel_dist;
const int alpha = 255 * (1 - step); const int ALPHA = 255 * (1 - STEP);
moveNotificationVertically(notification, param.notification.pos_v == NotifyPosition::TOP ? -1 : 1); moveNotificationVertically(notification, param.notification.pos_v == NotifyPosition::TOP ? -1 : 1);
notification.texture->setAlpha(alpha); notification.texture->setAlpha(ALPHA);
if (notification.rect.y == notification.y - notification.travel_dist) { if (notification.rect.y == notification.y - notification.travel_dist) {
notification.state = NotificationStatus::FINISHED; notification.state = NotificationStatus::FINISHED;

22
source/notifier.h
View File

@@ -75,17 +75,17 @@ class Notifier {
bool has_icons_; // Indica si el notificador tiene textura para iconos bool has_icons_; // Indica si el notificador tiene textura para iconos
// --- Métodos internos --- // --- Métodos internos ---
void clearFinishedNotifications(); // Elimina las notificaciones cuyo estado es FINISHED void clearFinishedNotifications(); // Elimina las notificaciones cuyo estado es FINISHED
void clearAllNotifications(); // Elimina todas las notificaciones activas, sin importar el estado void clearAllNotifications(); // Elimina todas las notificaciones activas, sin importar el estado
bool shouldProcessNotification(int index) const; // Determina si una notificación debe ser procesada (según su estado y posición) [[nodiscard]] auto shouldProcessNotification(int index) const -> bool; // Determina si una notificación debe ser procesada (según su estado y posición)
void processNotification(int index); // Procesa una notificación en la posición dada: actualiza su estado y comportamiento visual void processNotification(int index); // Procesa una notificación en la posición dada: actualiza su estado y comportamiento visual
void playNotificationSoundIfNeeded(const Notification &notification); // Reproduce sonido asociado si es necesario (dependiendo del estado o contenido) static void playNotificationSoundIfNeeded(const Notification &notification); // Reproduce sonido asociado si es necesario (dependiendo del estado o contenido)
void updateNotificationState(int index); // Actualiza el estado interno de una notificación (ej. de RISING a STAY) void updateNotificationState(int index); // Actualiza el estado interno de una notificación (ej. de RISING a STAY)
void handleRisingState(int index); // Lógica de animación para el estado RISING (apareciendo) void handleRisingState(int index); // Lógica de animación para el estado RISING (apareciendo)
void handleStayState(int index); // Lógica para mantener una notificación visible en el estado STAY void handleStayState(int index); // Lógica para mantener una notificación visible en el estado STAY
void handleVanishingState(int index); // Lógica de animación para el estado VANISHING (desapareciendo) void handleVanishingState(int index); // Lógica de animación para el estado VANISHING (desapareciendo)
void moveNotificationVertically(Notification &notification, int direction); // Mueve verticalmente una notificación en una dirección dada (útil para animación en apilamiento) static void moveNotificationVertically(Notification &notification, int direction); // Mueve verticalmente una notificación en una dirección dada (útil para animación en apilamiento)
void transitionToStayState(int index); // Cambia el estado de una notificación de RISING a STAY cuando ha alcanzado su posición final void transitionToStayState(int index); // Cambia el estado de una notificación de RISING a STAY cuando ha alcanzado su posición final
// --- Constructor y destructor --- // --- Constructor y destructor ---
Notifier(std::string icon_file, std::shared_ptr<Text> text); // Constructor privado Notifier(std::string icon_file, std::shared_ptr<Text> text); // Constructor privado

20
source/param.cpp
View File

@@ -131,7 +131,7 @@ void loadParamsFromFile(const std::string& file_path) {
} }
auto setParams(const std::string& var, const std::string& value) -> bool { auto setParams(const std::string& var, const std::string& value) -> bool {
static const std::unordered_map<std::string, std::function<void(const std::string&)>> intParams = { static const std::unordered_map<std::string, std::function<void(const std::string&)>> INT_PARAMS = {
{"game.width", [](const std::string& v) { param.game.width = std::stoi(v); }}, {"game.width", [](const std::string& v) { param.game.width = std::stoi(v); }},
{"game.height", [](const std::string& v) { param.game.height = std::stoi(v); }}, {"game.height", [](const std::string& v) { param.game.height = std::stoi(v); }},
{"game.item_size", [](const std::string& v) { param.game.item_size = std::stoi(v); }}, {"game.item_size", [](const std::string& v) { param.game.item_size = std::stoi(v); }},
@@ -159,7 +159,7 @@ auto setParams(const std::string& var, const std::string& value) -> bool {
{"title.title_c_c_position", [](const std::string& v) { param.title.title_c_c_position = std::stoi(v); }}, {"title.title_c_c_position", [](const std::string& v) { param.title.title_c_c_position = std::stoi(v); }},
{"intro.text_distance_from_bottom", [](const std::string& v) { param.intro.text_distance_from_bottom = std::stoi(v); }}}; {"intro.text_distance_from_bottom", [](const std::string& v) { param.intro.text_distance_from_bottom = std::stoi(v); }}};
static const std::unordered_map<std::string, std::function<void(const std::string&)>> colorParams = { static const std::unordered_map<std::string, std::function<void(const std::string&)>> COLOR_PARAMS = {
{"fade.color", [](const std::string& v) { param.fade.color = Color::fromHex(v); }}, {"fade.color", [](const std::string& v) { param.fade.color = Color::fromHex(v); }},
{"scoreboard.separator_color", [](const std::string& v) { param.scoreboard.separator_color = Color::fromHex(v); }}, {"scoreboard.separator_color", [](const std::string& v) { param.scoreboard.separator_color = Color::fromHex(v); }},
{"scoreboard.easy_color", [](const std::string& v) { param.scoreboard.easy_color = Color::fromHex(v); }}, {"scoreboard.easy_color", [](const std::string& v) { param.scoreboard.easy_color = Color::fromHex(v); }},
@@ -180,7 +180,7 @@ auto setParams(const std::string& var, const std::string& value) -> bool {
{"debug.color", [](const std::string& v) { param.debug.color = Color::fromHex(v); }}, {"debug.color", [](const std::string& v) { param.debug.color = Color::fromHex(v); }},
{"resource.color", [](const std::string& v) { param.resource.color = Color::fromHex(v); }}}; {"resource.color", [](const std::string& v) { param.resource.color = Color::fromHex(v); }}};
static const std::unordered_map<std::string, std::function<void(const std::string&)>> boolParams = { static const std::unordered_map<std::string, std::function<void(const std::string&)>> BOOL_PARAMS = {
{"game.hit_stop", [](const std::string& v) { param.game.hit_stop = stringToBool(v); }}, {"game.hit_stop", [](const std::string& v) { param.game.hit_stop = stringToBool(v); }},
{"scoreboard.separator_autocolor", [](const std::string& v) { param.scoreboard.separator_autocolor = stringToBool(v); }}, {"scoreboard.separator_autocolor", [](const std::string& v) { param.scoreboard.separator_autocolor = stringToBool(v); }},
{"scoreboard.text_autocolor", [](const std::string& v) { param.scoreboard.text_autocolor = stringToBool(v); }}, {"scoreboard.text_autocolor", [](const std::string& v) { param.scoreboard.text_autocolor = stringToBool(v); }},
@@ -188,7 +188,7 @@ auto setParams(const std::string& var, const std::string& value) -> bool {
{"notification.sound", [](const std::string& v) { param.notification.sound = stringToBool(v); }}, {"notification.sound", [](const std::string& v) { param.notification.sound = stringToBool(v); }},
{"service_menu.drop_shadow", [](const std::string& v) { param.service_menu.drop_shadow = stringToBool(v); }}}; {"service_menu.drop_shadow", [](const std::string& v) { param.service_menu.drop_shadow = stringToBool(v); }}};
static const std::unordered_map<std::string, std::function<void(const std::string&)>> floatParams = { static const std::unordered_map<std::string, std::function<void(const std::string&)>> FLOAT_PARAMS = {
{"balloon.settings[0].vel", [](const std::string& v) { param.balloon.settings.at(0).vel = std::stof(v); }}, {"balloon.settings[0].vel", [](const std::string& v) { param.balloon.settings.at(0).vel = std::stof(v); }},
{"balloon.settings[0].grav", [](const std::string& v) { param.balloon.settings.at(0).grav = std::stof(v); }}, {"balloon.settings[0].grav", [](const std::string& v) { param.balloon.settings.at(0).grav = std::stof(v); }},
{"balloon.settings[1].vel", [](const std::string& v) { param.balloon.settings.at(1).vel = std::stof(v); }}, {"balloon.settings[1].vel", [](const std::string& v) { param.balloon.settings.at(1).vel = std::stof(v); }},
@@ -198,24 +198,24 @@ auto setParams(const std::string& var, const std::string& value) -> bool {
{"balloon.settings[3].vel", [](const std::string& v) { param.balloon.settings.at(3).vel = std::stof(v); }}, {"balloon.settings[3].vel", [](const std::string& v) { param.balloon.settings.at(3).vel = std::stof(v); }},
{"balloon.settings[3].grav", [](const std::string& v) { param.balloon.settings.at(3).grav = std::stof(v); }}}; {"balloon.settings[3].grav", [](const std::string& v) { param.balloon.settings.at(3).grav = std::stof(v); }}};
static const std::unordered_map<std::string, std::function<void(const std::string&)>> stringParams = { static const std::unordered_map<std::string, std::function<void(const std::string&)>> STRING_PARAMS = {
{"balloon.color[0]", [](const std::string& v) { param.balloon.color.at(0) = v; }}, {"balloon.color[0]", [](const std::string& v) { param.balloon.color.at(0) = v; }},
{"balloon.color[1]", [](const std::string& v) { param.balloon.color.at(1) = v; }}, {"balloon.color[1]", [](const std::string& v) { param.balloon.color.at(1) = v; }},
{"balloon.color[2]", [](const std::string& v) { param.balloon.color.at(2) = v; }}, {"balloon.color[2]", [](const std::string& v) { param.balloon.color.at(2) = v; }},
{"balloon.color[3]", [](const std::string& v) { param.balloon.color.at(3) = v; }}}; {"balloon.color[3]", [](const std::string& v) { param.balloon.color.at(3) = v; }}};
// Intentar cada mapa de parámetros // Intentar cada mapa de parámetros
auto tryMap = [&](const auto& paramMap) -> bool { auto try_map = [&](const auto& param_map) -> bool {
auto it = paramMap.find(var); auto it = param_map.find(var);
if (it != paramMap.end()) { if (it != param_map.end()) {
it->second(value); it->second(value);
return true; return true;
} }
return false; return false;
}; };
if (tryMap(intParams) || tryMap(colorParams) || tryMap(boolParams) || if (try_map(INT_PARAMS) || try_map(COLOR_PARAMS) || try_map(BOOL_PARAMS) ||
tryMap(floatParams) || tryMap(stringParams)) { try_map(FLOAT_PARAMS) || try_map(STRING_PARAMS)) {
return true; return true;
} }

144
source/param.h
View File

@@ -9,125 +9,125 @@
// --- Parámetros del juego --- // --- Parámetros del juego ---
struct ParamGame { struct ParamGame {
float width; // Ancho de la resolución nativa del juego float width; // Ancho de la resolución nativa del juego
float height; // Alto de la resolución nativa del juego float height; // Alto de la resolución nativa del juego
float item_size; // Tamaño de los ítems del juego float item_size; // Tamaño de los ítems del juego
Zone play_area; // Rectángulo con la posición de la zona de juego Zone play_area; // Rectángulo con la posición de la zona de juego
Zone game_area; // Rectángulo con las dimensiones del juego Zone game_area; // Rectángulo con las dimensiones del juego
int name_entry_idle_time; // Segundos para introducir el nombre al finalizar la partida si no se pulsa nada int name_entry_idle_time; // Segundos para introducir el nombre al finalizar la partida si no se pulsa nada
int name_entry_total_time; // Segundos totales para introducir el nombre al finalizar la partida int name_entry_total_time; // Segundos totales para introducir el nombre al finalizar la partida
Uint32 speed; // Velocidad a la que transcurre el juego Uint32 speed; // Velocidad a la que transcurre el juego
bool hit_stop; // Indica si debe haber un paro cuando el jugador es golpeado por un globo bool hit_stop; // Indica si debe haber un paro cuando el jugador es golpeado por un globo
Uint32 hit_stop_ms; // Cantidad de milisegundos que dura el hit_stop Uint32 hit_stop_ms; // Cantidad de milisegundos que dura el hit_stop
}; };
// --- Parámetros del fade --- // --- Parámetros del fade ---
struct ParamFade { struct ParamFade {
Color color; // Color del fade Color color; // Color del fade
float num_squares_width; // Cantidad total de cuadraditos en horizontal para el FadeType::RANDOM_SQUARE float num_squares_width; // Cantidad total de cuadraditos en horizontal para el FadeType::RANDOM_SQUARE
float num_squares_height; // Cantidad total de cuadraditos en vertical para el FadeType::RANDOM_SQUARE float num_squares_height; // Cantidad total de cuadraditos en vertical para el FadeType::RANDOM_SQUARE
int random_squares_delay; // Duración entre cada pintado de cuadrados int random_squares_delay; // Duración entre cada pintado de cuadrados
int random_squares_mult; // Cantidad de cuadrados que se pintarán cada vez int random_squares_mult; // Cantidad de cuadrados que se pintarán cada vez
int post_duration; // Duración final del fade int post_duration; // Duración final del fade
float venetian_size; // Altura de los rectángulos para FadeType::VENETIAN float venetian_size; // Altura de los rectángulos para FadeType::VENETIAN
}; };
// --- Parámetros de la pantalla de título --- // --- Parámetros de la pantalla de título ---
struct ParamTitle { struct ParamTitle {
int press_start_position; // Posición del texto para empezar a jugar int press_start_position; // Posición del texto para empezar a jugar
int title_duration; // Tiempo de inactividad del título int title_duration; // Tiempo de inactividad del título
int arcade_edition_position; // Posición del bitmap "Arcade Edition" int arcade_edition_position; // Posición del bitmap "Arcade Edition"
int title_c_c_position; // Posición del bitmap "Coffee Crisis" int title_c_c_position; // Posición del bitmap "Coffee Crisis"
Color bg_color; // Color para los tiles de fondo Color bg_color; // Color para los tiles de fondo
}; };
// --- Parámetros del fondo --- // --- Parámetros del fondo ---
struct ParamBackground { struct ParamBackground {
Color attenuate_color; // Color para atenuar el fondo Color attenuate_color; // Color para atenuar el fondo
}; };
// --- Parámetros de los globos --- // --- Parámetros de los globos ---
struct ParamBalloon { struct ParamBalloon {
struct Settings { struct Settings {
float grav; // Aceleración en el eje Y. Modifica la velocidad float grav; // Aceleración en el eje Y. Modifica la velocidad
float vel; // Velocidad inicial al rebotar contra el suelo float vel; // Velocidad inicial al rebotar contra el suelo
// Constructor // Constructor
explicit Settings(float grav_val = 0.0F, float vel_val = 0.0F) explicit Settings(float grav_val = 0.0F, float vel_val = 0.0F)
: grav(grav_val), vel(vel_val) {} : grav(grav_val), vel(vel_val) {}
}; };
std::array<Settings, 4> settings; std::array<Settings, 4> settings;
std::array<std::string, 4> color; std::array<std::string, 4> color;
bool bouncing_sound; // Indica si los globos hacer sonido al rebotar bool bouncing_sound; // Indica si los globos hacer sonido al rebotar
}; };
// --- Parámetros de las notificaciones --- // --- Parámetros de las notificaciones ---
struct ParamNotification { struct ParamNotification {
NotifyPosition pos_h; // Ubicación horizontal de las notificaciones en pantalla NotifyPosition pos_h; // Ubicación horizontal de las notificaciones en pantalla
NotifyPosition pos_v; // Ubicación vertical de las notificaciones en pantalla NotifyPosition pos_v; // Ubicación vertical de las notificaciones en pantalla
bool sound; // Indica si las notificaciones suenan bool sound; // Indica si las notificaciones suenan
Color color; // Color de las notificaciones Color color; // Color de las notificaciones
}; };
// --- Parámetros del marcador --- // --- Parámetros del marcador ---
struct ParamScoreboard { struct ParamScoreboard {
SDL_FRect rect; // Posición y tamaño del marcador SDL_FRect rect; // Posición y tamaño del marcador
bool separator_autocolor; // El separado establece su color de forma automatica bool separator_autocolor; // El separado establece su color de forma automatica
Color separator_color; // Color del separador si se pone de forma manual Color separator_color; // Color del separador si se pone de forma manual
Color easy_color; // Color del marcador segun la dificultad Color easy_color; // Color del marcador segun la dificultad
Color normal_color; // Color del marcador segun la dificultad Color normal_color; // Color del marcador segun la dificultad
Color hard_color; // Color del marcador segun la dificultad Color hard_color; // Color del marcador segun la dificultad
bool text_autocolor; // El texto establece su color de forma automatica bool text_autocolor; // El texto establece su color de forma automatica
Color text_color1; // Color del texto Color text_color1; // Color del texto
Color text_color2; // Color del texto Color text_color2; // Color del texto
int skip_countdown_value; // Valor a partir del cual se puede saltar la cuenta atras int skip_countdown_value; // Valor a partir del cual se puede saltar la cuenta atras
}; };
// --- Parámetros del menú de servicio --- // --- Parámetros del menú de servicio ---
struct ParamServiceMenu { struct ParamServiceMenu {
Color title_color; Color title_color;
Color text_color; Color text_color;
Color selected_color; Color selected_color;
Color bg_color; Color bg_color;
bool drop_shadow; bool drop_shadow;
}; };
// --- Parámetros de la intro --- // --- Parámetros de la intro ---
struct ParamIntro { struct ParamIntro {
Color bg_color; Color bg_color;
Color card_color; Color card_color;
Color shadow_color; Color shadow_color;
int text_distance_from_bottom; int text_distance_from_bottom;
}; };
// --- Parámetros para Debug --- // --- Parámetros para Debug ---
struct ParamDebug { struct ParamDebug {
Color color; Color color;
}; };
// --- Parámetros para Resource --- // --- Parámetros para Resource ---
struct ParamResource { struct ParamResource {
Color color; Color color;
}; };
// --- Estructura principal para almacenar todos los parámetros del juego --- // --- Estructura principal para almacenar todos los parámetros del juego ---
struct Param { struct Param {
ParamGame game; // Parámetros del juego ParamGame game; // Parámetros del juego
ParamFade fade; // Parámetros del fade ParamFade fade; // Parámetros del fade
ParamScoreboard scoreboard; // Rectángulo del marcador ParamScoreboard scoreboard; // Rectángulo del marcador
ParamTitle title; // Parámetros de la pantalla de título ParamTitle title; // Parámetros de la pantalla de título
ParamBackground background; // Parámetros del fondo ParamBackground background; // Parámetros del fondo
ParamBalloon balloon; // Parámetros de los globos ParamBalloon balloon; // Parámetros de los globos
ParamNotification notification; // Parámetros de las notificaciones ParamNotification notification; // Parámetros de las notificaciones
ParamServiceMenu service_menu; // Parámetros del menú de servicio ParamServiceMenu service_menu; // Parámetros del menú de servicio
ParamIntro intro; // Parámetros de la intro ParamIntro intro; // Parámetros de la intro
ParamDebug debug; // Parámetros para Debug ParamDebug debug; // Parámetros para Debug
ParamResource resource; // Parámetros para Resource ParamResource resource; // Parámetros para Resource
// Constructor // Constructor
Param() Param()
: game(), fade(), scoreboard(), title(), background(), balloon(), notification(), service_menu(), intro(), debug(), resource() {} : game(), fade(), scoreboard(), title(), background(), balloon(), notification(), service_menu(), intro(), debug(), resource() {}
}; };
// --- Variable global con los parámetros del juego --- // --- Variable global con los parámetros del juego ---

68
source/path_sprite.h
View File

@@ -25,15 +25,15 @@ enum class PathCentered {
// --- Estructura Path: define un recorrido para el sprite --- // --- Estructura Path: define un recorrido para el sprite ---
struct Path { struct Path {
std::vector<SDL_FPoint> spots; // Puntos por los que se desplazará el sprite std::vector<SDL_FPoint> spots; // Puntos por los que se desplazará el sprite
int waiting_counter; // Tiempo de espera una vez en el destino int waiting_counter; // Tiempo de espera una vez en el destino
bool on_destination = false; // Indica si ha llegado al destino bool on_destination = false; // Indica si ha llegado al destino
bool finished = false; // Indica si ha terminado de esperarse bool finished = false; // Indica si ha terminado de esperarse
int counter = 0; // Contador interno int counter = 0; // Contador interno
// Constructor // Constructor
Path(const std::vector<SDL_FPoint> &spots_init, int waiting_counter_init) Path(const std::vector<SDL_FPoint> &spots_init, int waiting_counter_init)
: spots(spots_init), waiting_counter(waiting_counter_init) {} : spots(spots_init), waiting_counter(waiting_counter_init) {}
}; };
// Devuelve un vector con los puntos que conforman la ruta // Devuelve un vector con los puntos que conforman la ruta
@@ -41,36 +41,36 @@ auto createPath(float start, float end, PathType type, float fixed_pos, int step
// --- Clase PathSprite: Sprite que sigue uno o varios recorridos --- // --- Clase PathSprite: Sprite que sigue uno o varios recorridos ---
class PathSprite : public Sprite { class PathSprite : public Sprite {
public: public:
// --- Constructor y destructor --- // --- Constructor y destructor ---
explicit PathSprite(std::shared_ptr<Texture> texture) explicit PathSprite(std::shared_ptr<Texture> texture)
: Sprite(texture) {} : Sprite(texture) {}
~PathSprite() override = default; ~PathSprite() override = default;
// --- Métodos principales --- // --- Métodos principales ---
void update(); // Actualiza la posición del sprite según el recorrido void update(); // Actualiza la posición del sprite según el recorrido
void render() override; // Muestra el sprite por pantalla void render() override; // Muestra el sprite por pantalla
// --- Gestión de recorridos --- // --- Gestión de recorridos ---
void addPath(Path path, bool centered = false); // Añade un recorrido (Path) void addPath(Path path, bool centered = false); // Añade un recorrido (Path)
void addPath(std::vector<SDL_FPoint> spots, int waiting_counter = 0); // Añade un recorrido a partir de puntos void addPath(std::vector<SDL_FPoint> spots, int waiting_counter = 0); // Añade un recorrido a partir de puntos
void addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easing_function, int waiting_counter = 0); // Añade un recorrido generado void addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easing_function, int waiting_counter = 0); // Añade un recorrido generado
// --- Estado y control --- // --- Estado y control ---
void enable(); // Habilita el objeto void enable(); // Habilita el objeto
[[nodiscard]] auto hasFinished() const -> bool; // Indica si ha terminado todos los recorridos [[nodiscard]] auto hasFinished() const -> bool; // Indica si ha terminado todos los recorridos
// --- Getters --- // --- Getters ---
[[nodiscard]] auto getCurrentPath() const -> int { return current_path_; } // Devuelve el índice del recorrido actual [[nodiscard]] auto getCurrentPath() const -> int { return current_path_; } // Devuelve el índice del recorrido actual
private: private:
// --- Variables internas --- // --- Variables internas ---
bool enabled_ = false; // Indica si el objeto está habilitado bool enabled_ = false; // Indica si el objeto está habilitado
bool has_finished_ = false; // Indica si el objeto ha finalizado el recorrido bool has_finished_ = false; // Indica si el objeto ha finalizado el recorrido
int current_path_ = 0; // Recorrido que se está recorriendo actualmente int current_path_ = 0; // Recorrido que se está recorriendo actualmente
std::vector<Path> paths_; // Caminos a recorrer por el sprite std::vector<Path> paths_; // Caminos a recorrer por el sprite
// --- Métodos internos --- // --- Métodos internos ---
void moveThroughCurrentPath(); // Coloca el sprite en los diferentes puntos del recorrido void moveThroughCurrentPath(); // Coloca el sprite en los diferentes puntos del recorrido
void goToNextPathOrDie(); // Cambia de recorrido o finaliza void goToNextPathOrDie(); // Cambia de recorrido o finaliza
}; };

500
source/player.cpp
View File

@@ -147,182 +147,217 @@ void Player::setInputEnteringName(InputAction input) {
// Mueve el jugador a la posición y animación que le corresponde // Mueve el jugador a la posición y animación que le corresponde
void Player::move() { void Player::move() {
switch (playing_state_) { switch (playing_state_) {
case PlayerState::PLAYING: { case PlayerState::PLAYING:
// Mueve el jugador a derecha o izquierda handlePlayingMovement();
pos_x_ += vel_x_;
// Si el jugador abandona el area de juego por los laterales, restaura su posición
const float MIN_X = play_area_.x - 5;
const float MAX_X = play_area_.w + 5 - WIDTH;
pos_x_ = std::clamp(pos_x_, MIN_X, MAX_X);
shiftSprite();
break; break;
} case PlayerState::ROLLING:
case PlayerState::ROLLING: { handleRollingMovement();
// Si el jugador abandona el area de juego por los laterales lo hace rebotar
const int X = player_sprite_->getPosX();
const int MIN_X = play_area_.x;
const int MAX_X = play_area_.x + play_area_.w - WIDTH;
if ((X < MIN_X) || (X > MAX_X)) {
player_sprite_->setPosX(std::clamp(X, MIN_X, MAX_X));
player_sprite_->setVelX(-player_sprite_->getVelX());
playSound("jump.wav");
}
// Si el jugador toca el suelo rebota y si tiene poca velocidad, se detiene y cambia de estado
if (player_sprite_->getPosY() > play_area_.h - HEIGHT) {
if (player_sprite_->getVelY() < 2.0F) {
// Si la velocidad de rebote es baja, lo detiene y cambia de estado
const auto NEXT_PLAYER_STATUS = isEligibleForHighScore() ? PlayerState::ENTERING_NAME : PlayerState::CONTINUE;
demo_ ? setPlayingState(PlayerState::LYING_ON_THE_FLOOR_FOREVER) : setPlayingState(NEXT_PLAYER_STATUS);
pos_x_ = player_sprite_->getPosX();
pos_y_ = default_pos_y_;
player_sprite_->clear();
shiftSprite();
playSound("jump.wav");
} else {
// Decrementa las velocidades de rebote
player_sprite_->setPosY(play_area_.h - HEIGHT);
player_sprite_->setVelY(player_sprite_->getVelY() * -0.5F);
player_sprite_->setVelX(player_sprite_->getVelX() * 0.75F);
player_sprite_->setAnimationSpeed(player_sprite_->getAnimationSpeed() * 2);
playSound("jump.wav");
}
}
break; break;
} case PlayerState::TITLE_ANIMATION:
case PlayerState::TITLE_ANIMATION: { handleTitleAnimation();
// Si el jugador abandona el area de juego por los laterales lo detiene
/*const int X = player_sprite_->getPosX();
const int MIN_X = play_area_.x - WIDTH;
const int MAX_X = play_area_.x + play_area_.w;
if ((X < MIN_X) || (X > MAX_X))
{
setPlayingState(PlayerState::TITLE_HIDDEN);
}
// Si el jugador toca el suelo rebota lo detiene
if (player_sprite_->getPosY() > play_area_.h)
{
setPlayingState(PlayerState::TITLE_HIDDEN);
}*/
switch (id_) {
case 1:
setInputPlaying(InputAction::LEFT);
break;
case 2:
setInputPlaying(InputAction::RIGHT);
break;
default:
break;
}
pos_x_ += vel_x_ * 2.0F;
const float MIN_X = -WIDTH;
const float MAX_X = play_area_.w;
pos_x_ = std::clamp(pos_x_, MIN_X, MAX_X);
shiftSprite();
if (pos_x_ == MIN_X || pos_x_ == MAX_X) {
setPlayingState(PlayerState::TITLE_HIDDEN);
}
break; break;
} case PlayerState::CONTINUE_TIME_OUT:
case PlayerState::CONTINUE_TIME_OUT: { handleContinueTimeOut();
// Si el cadaver desaparece por el suelo, cambia de estado
if (player_sprite_->getPosY() > play_area_.h) {
setPlayingState(PlayerState::WAITING);
}
break; break;
} case PlayerState::LEAVING_SCREEN:
case PlayerState::LEAVING_SCREEN: { handleLeavingScreen();
++step_counter_;
if (step_counter_ % 10 == 0) {
playSound("walk.wav");
}
switch (id_) {
case 1:
setInputPlaying(InputAction::LEFT);
break;
case 2:
setInputPlaying(InputAction::RIGHT);
break;
default:
break;
}
pos_x_ += vel_x_;
const float MIN_X = -WIDTH;
const float MAX_X = play_area_.w;
pos_x_ = std::clamp(pos_x_, MIN_X, MAX_X);
shiftSprite();
if (pos_x_ == MIN_X || pos_x_ == MAX_X) {
setPlayingState(PlayerState::GAME_OVER);
}
break; break;
} case PlayerState::ENTERING_SCREEN:
case PlayerState::ENTERING_SCREEN: { handleEnteringScreen();
++step_counter_;
if (step_counter_ % 10 == 0) {
playSound("walk.wav");
}
switch (id_) {
case 1:
setInputPlaying(InputAction::RIGHT);
pos_x_ += vel_x_;
if (pos_x_ > default_pos_x_) {
pos_x_ = default_pos_x_;
setPlayingState(PlayerState::PLAYING);
setInvulnerable(false);
}
break;
case 2:
setInputPlaying(InputAction::LEFT);
pos_x_ += vel_x_;
if (pos_x_ < default_pos_x_) {
pos_x_ = default_pos_x_;
setPlayingState(PlayerState::PLAYING);
setInvulnerable(false);
}
break;
default:
break;
}
shiftSprite();
break; break;
} case PlayerState::CREDITS:
case PlayerState::CREDITS: { handleCreditsMovement();
pos_x_ += vel_x_ / 2.0F;
if (vel_x_ > 0) {
// setInputPlaying(InputAction::RIGHT);
if (pos_x_ > param.game.game_area.rect.w - WIDTH) {
pos_x_ = param.game.game_area.rect.w - WIDTH;
vel_x_ *= -1;
}
} else {
// setInputPlaying(InputAction::LEFT);
if (pos_x_ < param.game.game_area.rect.x) {
pos_x_ = param.game.game_area.rect.x;
vel_x_ *= -1;
}
}
if (pos_x_ > param.game.game_area.center_x - WIDTH / 2) {
setWalkingState(PlayerState::WALKING_LEFT);
} else {
setWalkingState(PlayerState::WALKING_RIGHT);
}
shiftSprite();
break; break;
}
default: default:
break; break;
} }
} }
void Player::handlePlayingMovement() {
// Mueve el jugador a derecha o izquierda
pos_x_ += vel_x_;
// Si el jugador abandona el area de juego por los laterales, restaura su posición
const float MIN_X = play_area_.x - 5;
const float MAX_X = play_area_.w + 5 - WIDTH;
pos_x_ = std::clamp(pos_x_, MIN_X, MAX_X);
shiftSprite();
}
void Player::handleRollingMovement() {
handleRollingBoundaryCollision();
handleRollingGroundCollision();
}
void Player::handleRollingBoundaryCollision() {
const int X = player_sprite_->getPosX();
const int MIN_X = play_area_.x;
const int MAX_X = play_area_.x + play_area_.w - WIDTH;
if ((X < MIN_X) || (X > MAX_X)) {
player_sprite_->setPosX(std::clamp(X, MIN_X, MAX_X));
player_sprite_->setVelX(-player_sprite_->getVelX());
playSound("jump.wav");
}
}
void Player::handleRollingGroundCollision() {
if (player_sprite_->getPosY() <= play_area_.h - HEIGHT) {
return;
}
if (player_sprite_->getVelY() < 2.0F) {
handleRollingStop();
} else {
handleRollingBounce();
}
}
void Player::handleRollingStop() {
const auto NEXT_PLAYER_STATUS = isEligibleForHighScore() ? PlayerState::ENTERING_NAME : PlayerState::CONTINUE;
const auto NEXT_STATE = demo_ ? PlayerState::LYING_ON_THE_FLOOR_FOREVER : NEXT_PLAYER_STATUS;
setPlayingState(NEXT_STATE);
pos_x_ = player_sprite_->getPosX();
pos_y_ = default_pos_y_;
player_sprite_->clear();
shiftSprite();
playSound("jump.wav");
}
void Player::handleRollingBounce() {
player_sprite_->setPosY(play_area_.h - HEIGHT);
player_sprite_->setVelY(player_sprite_->getVelY() * -0.5F);
player_sprite_->setVelX(player_sprite_->getVelX() * 0.75F);
player_sprite_->setAnimationSpeed(player_sprite_->getAnimationSpeed() * 2);
playSound("jump.wav");
}
void Player::handleTitleAnimation() {
setInputBasedOnPlayerId();
pos_x_ += vel_x_ * 2.0F;
const float MIN_X = -WIDTH;
const float MAX_X = play_area_.w;
pos_x_ = std::clamp(pos_x_, MIN_X, MAX_X);
shiftSprite();
if (pos_x_ == MIN_X || pos_x_ == MAX_X) {
setPlayingState(PlayerState::TITLE_HIDDEN);
}
}
void Player::handleContinueTimeOut() {
// Si el cadaver desaparece por el suelo, cambia de estado
if (player_sprite_->getPosY() > play_area_.h) {
setPlayingState(PlayerState::WAITING);
}
}
void Player::handleLeavingScreen() {
updateStepCounter();
setInputBasedOnPlayerId();
pos_x_ += vel_x_;
const float MIN_X = -WIDTH;
const float MAX_X = play_area_.w;
pos_x_ = std::clamp(pos_x_, MIN_X, MAX_X);
shiftSprite();
if (pos_x_ == MIN_X || pos_x_ == MAX_X) {
setPlayingState(PlayerState::GAME_OVER);
}
}
void Player::handleEnteringScreen() {
updateStepCounter();
if (id_ == 1) {
handlePlayer1Entering();
} else if (id_ == 2) {
handlePlayer2Entering();
}
shiftSprite();
}
void Player::handlePlayer1Entering() {
setInputPlaying(InputAction::RIGHT);
pos_x_ += vel_x_;
if (pos_x_ > default_pos_x_) {
pos_x_ = default_pos_x_;
setPlayingState(PlayerState::PLAYING);
setInvulnerable(false);
}
}
void Player::handlePlayer2Entering() {
setInputPlaying(InputAction::LEFT);
pos_x_ += vel_x_;
if (pos_x_ < default_pos_x_) {
pos_x_ = default_pos_x_;
setPlayingState(PlayerState::PLAYING);
setInvulnerable(false);
}
}
void Player::handleCreditsMovement() {
pos_x_ += vel_x_ / 2.0F;
if (vel_x_ > 0) {
handleCreditsRightMovement();
} else {
handleCreditsLeftMovement();
}
updateWalkingStateForCredits();
shiftSprite();
}
void Player::handleCreditsRightMovement() {
if (pos_x_ > param.game.game_area.rect.w - WIDTH) {
pos_x_ = param.game.game_area.rect.w - WIDTH;
vel_x_ *= -1;
}
}
void Player::handleCreditsLeftMovement() {
if (pos_x_ < param.game.game_area.rect.x) {
pos_x_ = param.game.game_area.rect.x;
vel_x_ *= -1;
}
}
void Player::updateWalkingStateForCredits() {
if (pos_x_ > param.game.game_area.center_x - WIDTH / 2) {
setWalkingState(PlayerState::WALKING_LEFT);
} else {
setWalkingState(PlayerState::WALKING_RIGHT);
}
}
void Player::setInputBasedOnPlayerId() {
switch (id_) {
case 1:
setInputPlaying(InputAction::LEFT);
break;
case 2:
setInputPlaying(InputAction::RIGHT);
break;
default:
break;
}
}
void Player::updateStepCounter() {
++step_counter_;
if (step_counter_ % 10 == 0) {
playSound("walk.wav");
}
}
// Pinta el jugador en pantalla // Pinta el jugador en pantalla
void Player::render() { void Player::render() {
if (power_up_ && isPlaying()) { if (power_up_ && isPlaying()) {
@@ -404,63 +439,88 @@ void Player::setAnimation() {
// Actualiza el valor de la variable // Actualiza el valor de la variable
void Player::updateCooldown() { void Player::updateCooldown() {
if (playing_state_ == PlayerState::PLAYING) { if (playing_state_ != PlayerState::PLAYING) {
if (cant_fire_counter_ > 0) { return;
cooling_state_counter_ = COOLING_DURATION;
// La mitad del tiempo que no puede disparar tiene el brazo arriba (PlayerState::FIRING)
// y la otra mitad en retroceso (PlayerState::RECOILING)
if (cant_fire_counter_ == recoiling_state_duration_ / 2) {
switch (firing_state_) {
case PlayerState::FIRING_LEFT:
setFiringState(PlayerState::RECOILING_LEFT);
break;
case PlayerState::FIRING_RIGHT:
setFiringState(PlayerState::RECOILING_RIGHT);
break;
case PlayerState::FIRING_UP:
setFiringState(PlayerState::RECOILING_UP);
break;
default:
break;
}
}
--cant_fire_counter_;
if (cant_fire_counter_ == 0) {
recoiling_state_counter_ = recoiling_state_duration_;
}
} else {
if (recoiling_state_counter_ > 0) {
--recoiling_state_counter_;
} else {
if (cooling_state_counter_ > COOLING_COMPLETE) {
if (cooling_state_counter_ == COOLING_DURATION) {
switch (firing_state_) {
case PlayerState::RECOILING_LEFT:
setFiringState(PlayerState::COOLING_LEFT);
break;
case PlayerState::RECOILING_RIGHT:
setFiringState(PlayerState::COOLING_RIGHT);
break;
case PlayerState::RECOILING_UP:
setFiringState(PlayerState::COOLING_UP);
break;
default:
break;
}
}
--cooling_state_counter_;
}
if (cooling_state_counter_ == COOLING_COMPLETE) {
setFiringState(PlayerState::FIRING_NONE);
cooling_state_counter_ = -1;
}
}
}
} }
if (cant_fire_counter_ > 0) {
handleFiringCooldown();
} else {
handleRecoilAndCooling();
}
}
void Player::handleFiringCooldown() {
cooling_state_counter_ = COOLING_DURATION;
// Transition to recoiling state at halfway point
if (cant_fire_counter_ == recoiling_state_duration_ / 2) {
transitionToRecoiling();
}
--cant_fire_counter_;
if (cant_fire_counter_ == 0) {
recoiling_state_counter_ = recoiling_state_duration_;
}
}
void Player::handleRecoilAndCooling() {
if (recoiling_state_counter_ > 0) {
--recoiling_state_counter_;
return;
}
handleCoolingState();
}
void Player::handleCoolingState() {
if (cooling_state_counter_ > COOLING_COMPLETE) {
if (cooling_state_counter_ == COOLING_DURATION) {
transitionToCooling();
}
--cooling_state_counter_;
}
if (cooling_state_counter_ == COOLING_COMPLETE) {
completeCooling();
}
}
void Player::transitionToRecoiling() {
switch (firing_state_) {
case PlayerState::FIRING_LEFT:
setFiringState(PlayerState::RECOILING_LEFT);
break;
case PlayerState::FIRING_RIGHT:
setFiringState(PlayerState::RECOILING_RIGHT);
break;
case PlayerState::FIRING_UP:
setFiringState(PlayerState::RECOILING_UP);
break;
default:
break;
}
}
void Player::transitionToCooling() {
switch (firing_state_) {
case PlayerState::RECOILING_LEFT:
setFiringState(PlayerState::COOLING_LEFT);
break;
case PlayerState::RECOILING_RIGHT:
setFiringState(PlayerState::COOLING_RIGHT);
break;
case PlayerState::RECOILING_UP:
setFiringState(PlayerState::COOLING_UP);
break;
default:
break;
}
}
void Player::completeCooling() {
setFiringState(PlayerState::FIRING_NONE);
cooling_state_counter_ = -1;
} }
// Actualiza al jugador a su posicion, animación y controla los contadores // Actualiza al jugador a su posicion, animación y controla los contadores

24
source/player.h
View File

@@ -228,4 +228,28 @@ class Player {
void playSound(const std::string &name) const; // Hace sonar un sonido void playSound(const std::string &name) const; // Hace sonar un sonido
[[nodiscard]] auto isRenderable() const -> bool; // Indica si se puede dibujar el objeto [[nodiscard]] auto isRenderable() const -> bool; // Indica si se puede dibujar el objeto
void addScoreToScoreBoard() const; // Añade una puntuación a la tabla de records void addScoreToScoreBoard() const; // Añade una puntuación a la tabla de records
void handleFiringCooldown(); // Gestiona el tiempo de espera después de disparar antes de permitir otro disparo
void handleRecoilAndCooling(); // Procesa simultáneamente el retroceso del arma y la transición al estado de enfriamiento si aplica
void handleCoolingState(); // Actualiza la lógica interna mientras el sistema está en estado de enfriamiento
void transitionToRecoiling(); // Cambia el estado actual al de retroceso después de disparar
void transitionToCooling(); // Cambia el estado actual al de enfriamiento (por ejemplo, tras una ráfaga o sobrecalentamiento)
void completeCooling(); // Finaliza el proceso de enfriamiento y restablece el estado listo para disparar
void handlePlayingMovement(); // Gestiona el movimiento del personaje u objeto durante el estado de juego activo
void handleRollingMovement(); // Actualiza la lógica de movimiento de "rodar" (posiblemente tras impacto o acción especial)
void handleRollingBoundaryCollision(); // Detecta y maneja colisiones del objeto rodante con los límites de la pantalla
void handleRollingGroundCollision(); // Gestiona la interacción del objeto rodante con el suelo (rebotes, frenado, etc.)
void handleRollingStop(); // Detiene el movimiento del objeto rodante cuando se cumplen las condiciones necesarias
void handleRollingBounce(); // Aplica una lógica de rebote al colisionar con superficies durante el rodamiento
void handleTitleAnimation(); // Ejecuta la animación del título en pantalla (ej. entrada, parpadeo o desplazamiento)
void handleContinueTimeOut(); // Gestiona el tiempo de espera en la pantalla de "Continuar" y decide si pasar a otro estado
void handleLeavingScreen(); // Lógica para salir de la pantalla actual (transición visual o cambio de escena)
void handleEnteringScreen(); // Lógica para entrar en una nueva pantalla, posiblemente con animación o retraso
void handlePlayer1Entering(); // Controla la animación o posición de entrada del Jugador 1 en pantalla
void handlePlayer2Entering(); // Controla la animación o posición de entrada del Jugador 2 en pantalla
void handleCreditsMovement(); // Movimiento general en la pantalla de créditos (desplazamiento vertical u horizontal)
void handleCreditsRightMovement(); // Lógica específica para mover los créditos hacia la derecha
void handleCreditsLeftMovement(); // Lógica específica para mover los créditos hacia la izquierda
void updateWalkingStateForCredits(); // Actualiza el estado de caminata de algún personaje u elemento animado en los créditos
void setInputBasedOnPlayerId(); // Asocia las entradas de control en función del identificador del jugador (teclas, mando, etc.)
void updateStepCounter(); // Incrementa o ajusta el contador de pasos para animaciones o mecánicas relacionadas con movimiento
}; };

212
source/resource.h
View File

@@ -18,133 +18,133 @@ struct JA_Sound_t;
// --- Clase Resource: gestiona todos los recursos del juego (singleton) --- // --- Clase Resource: gestiona todos los recursos del juego (singleton) ---
class Resource { class Resource {
public: public:
// --- Métodos de singleton --- // --- Métodos de singleton ---
static void init(); // Inicializa el objeto Resource static void init(); // Inicializa el objeto Resource
static void destroy(); // Libera el objeto Resource static void destroy(); // Libera el objeto Resource
static auto get() -> Resource *; // Obtiene el puntero al objeto Resource static auto get() -> Resource *; // Obtiene el puntero al objeto Resource
// --- Métodos de acceso a recursos --- // --- Métodos de acceso a recursos ---
auto getSound(const std::string &name) -> JA_Sound_t *; // Obtiene el sonido por nombre auto getSound(const std::string &name) -> JA_Sound_t *; // Obtiene el sonido por nombre
auto getMusic(const std::string &name) -> JA_Music_t *; // Obtiene la música por nombre auto getMusic(const std::string &name) -> JA_Music_t *; // Obtiene la música por nombre
auto getTexture(const std::string &name) -> std::shared_ptr<Texture>; // Obtiene la textura por nombre auto getTexture(const std::string &name) -> std::shared_ptr<Texture>; // Obtiene la textura por nombre
auto getTextFile(const std::string &name) -> std::shared_ptr<TextFile>; // Obtiene el fichero de texto por nombre auto getTextFile(const std::string &name) -> std::shared_ptr<TextFile>; // Obtiene el fichero de texto por nombre
auto getText(const std::string &name) -> std::shared_ptr<Text>; // Obtiene el objeto de texto por nombre auto getText(const std::string &name) -> std::shared_ptr<Text>; // Obtiene el objeto de texto por nombre
auto getAnimation(const std::string &name) -> AnimationsFileBuffer &; // Obtiene la animación por nombre auto getAnimation(const std::string &name) -> AnimationsFileBuffer &; // Obtiene la animación por nombre
auto getDemoData(int index) -> DemoData &; // Obtiene los datos de demo por índice auto getDemoData(int index) -> DemoData &; // Obtiene los datos de demo por índice
// --- Métodos de recarga de recursos --- // --- Métodos de recarga de recursos ---
void reload(); // Recarga todos los recursos void reload(); // Recarga todos los recursos
void reloadTextures(); // Recarga solo las texturas void reloadTextures(); // Recarga solo las texturas
private: private:
// --- Estructuras para recursos individuales --- // --- Estructuras para recursos individuales ---
struct ResourceSound { struct ResourceSound {
std::string name; // Nombre del sonido std::string name; // Nombre del sonido
JA_Sound_t *sound; // Objeto con el sonido JA_Sound_t *sound; // Objeto con el sonido
ResourceSound(std::string name, JA_Sound_t *sound) ResourceSound(std::string name, JA_Sound_t *sound)
: name(std::move(name)), sound(sound) {} : name(std::move(name)), sound(sound) {}
}; };
struct ResourceMusic { struct ResourceMusic {
std::string name; // Nombre de la música std::string name; // Nombre de la música
JA_Music_t *music; // Objeto con la música JA_Music_t *music; // Objeto con la música
ResourceMusic(std::string name, JA_Music_t *music) ResourceMusic(std::string name, JA_Music_t *music)
: name(std::move(name)), music(music) {} : name(std::move(name)), music(music) {}
}; };
struct ResourceTexture { struct ResourceTexture {
std::string name; // Nombre de la textura std::string name; // Nombre de la textura
std::shared_ptr<Texture> texture; // Objeto con la textura std::shared_ptr<Texture> texture; // Objeto con la textura
ResourceTexture(std::string name, std::shared_ptr<Texture> texture) ResourceTexture(std::string name, std::shared_ptr<Texture> texture)
: name(std::move(name)), texture(std::move(texture)) {} : name(std::move(name)), texture(std::move(texture)) {}
}; };
struct ResourceTextFile { struct ResourceTextFile {
std::string name; // Nombre del fichero std::string name; // Nombre del fichero
std::shared_ptr<TextFile> text_file; // Objeto con los descriptores de la fuente de texto std::shared_ptr<TextFile> text_file; // Objeto con los descriptores de la fuente de texto
ResourceTextFile(std::string name, std::shared_ptr<TextFile> text_file) ResourceTextFile(std::string name, std::shared_ptr<TextFile> text_file)
: name(std::move(name)), text_file(std::move(text_file)) {} : name(std::move(name)), text_file(std::move(text_file)) {}
}; };
struct ResourceText { struct ResourceText {
std::string name; // Nombre del objeto std::string name; // Nombre del objeto
std::shared_ptr<Text> text; // Objeto de texto std::shared_ptr<Text> text; // Objeto de texto
ResourceText(std::string name, std::shared_ptr<Text> text) ResourceText(std::string name, std::shared_ptr<Text> text)
: name(std::move(name)), text(std::move(text)) {} : name(std::move(name)), text(std::move(text)) {}
}; };
struct ResourceAnimation { struct ResourceAnimation {
std::string name; // Nombre de la animación std::string name; // Nombre de la animación
AnimationsFileBuffer animation; // Objeto con las animaciones AnimationsFileBuffer animation; // Objeto con las animaciones
ResourceAnimation(std::string name, AnimationsFileBuffer animation) ResourceAnimation(std::string name, AnimationsFileBuffer animation)
: name(std::move(name)), animation(std::move(animation)) {} : name(std::move(name)), animation(std::move(animation)) {}
}; };
// --- Estructura para el progreso de carga --- // --- Estructura para el progreso de carga ---
struct ResourceCount { struct ResourceCount {
size_t total; // Número total de recursos size_t total; // Número total de recursos
size_t loaded; // Número de recursos cargados size_t loaded; // Número de recursos cargados
ResourceCount() : total(0), loaded(0) {} ResourceCount() : total(0), loaded(0) {}
ResourceCount(size_t total) : total(total), loaded(0) {} ResourceCount(size_t total) : total(total), loaded(0) {}
void add(size_t amount) { loaded += amount; } void add(size_t amount) { loaded += amount; }
void increase() { loaded++; } void increase() { loaded++; }
[[nodiscard]] auto getPercentage() const -> float { [[nodiscard]] auto getPercentage() const -> float {
return total > 0 ? static_cast<float>(loaded) / static_cast<float>(total) : 0.0F; return total > 0 ? static_cast<float>(loaded) / static_cast<float>(total) : 0.0F;
} }
}; };
// --- Vectores de recursos --- // --- Vectores de recursos ---
std::vector<ResourceSound> sounds_; // Vector con los sonidos std::vector<ResourceSound> sounds_; // Vector con los sonidos
std::vector<ResourceMusic> musics_; // Vector con las músicas std::vector<ResourceMusic> musics_; // Vector con las músicas
std::vector<ResourceTexture> textures_; // Vector con las texturas std::vector<ResourceTexture> textures_; // Vector con las texturas
std::vector<ResourceTextFile> text_files_; // Vector con los ficheros de texto std::vector<ResourceTextFile> text_files_; // Vector con los ficheros de texto
std::vector<ResourceText> texts_; // Vector con los objetos de texto std::vector<ResourceText> texts_; // Vector con los objetos de texto
std::vector<ResourceAnimation> animations_; // Vector con las animaciones std::vector<ResourceAnimation> animations_; // Vector con las animaciones
std::vector<DemoData> demos_; // Vector con los ficheros de datos para el modo demostración std::vector<DemoData> demos_; // Vector con los ficheros de datos para el modo demostración
// --- Progreso de carga --- // --- Progreso de carga ---
ResourceCount loading_count_; // Contador de recursos cargados ResourceCount loading_count_; // Contador de recursos cargados
std::shared_ptr<Text> loading_text_; // Texto para escribir en pantalla std::shared_ptr<Text> loading_text_; // Texto para escribir en pantalla
std::string loading_resource_name_; // Nombre del recurso que se está cargando std::string loading_resource_name_; // Nombre del recurso que se está cargando
SDL_FRect loading_wired_rect_; SDL_FRect loading_wired_rect_;
SDL_FRect loading_full_rect_; SDL_FRect loading_full_rect_;
// --- Métodos internos de carga y gestión --- // --- Métodos internos de carga y gestión ---
void loadSounds(); // Carga los sonidos void loadSounds(); // Carga los sonidos
void loadMusics(); // Carga las músicas void loadMusics(); // Carga las músicas
void loadTextures(); // Carga las texturas void loadTextures(); // Carga las texturas
void loadTextFiles(); // Carga los ficheros de texto void loadTextFiles(); // Carga los ficheros de texto
void loadAnimations(); // Carga las animaciones void loadAnimations(); // Carga las animaciones
void loadDemoData(); // Carga los datos para el modo demostración void loadDemoData(); // Carga los datos para el modo demostración
void addPalettes(); // Añade paletas a las texturas void addPalettes(); // Añade paletas a las texturas
void createTextures(); // Crea las texturas a partir de los datos cargados void createTextures(); // Crea las texturas a partir de los datos cargados
void createText(); // Crea los objetos de texto void createText(); // Crea los objetos de texto
void clear(); // Vacía todos los vectores de recursos void clear(); // Vacía todos los vectores de recursos
void load(); // Carga todos los recursos void load(); // Carga todos los recursos
void clearSounds(); // Vacía el vector de sonidos void clearSounds(); // Vacía el vector de sonidos
void clearMusics(); // Vacía el vector de músicas void clearMusics(); // Vacía el vector de músicas
// --- Métodos internos para gestionar el progreso --- // --- Métodos internos para gestionar el progreso ---
void calculateTotalResources(); // Calcula el número de recursos para cargar void calculateTotalResources(); // Calcula el número de recursos para cargar
void renderProgress(); // Muestra el progreso de carga void renderProgress(); // Muestra el progreso de carga
static void checkEvents(); // Comprueba los eventos durante la carga static void checkEvents(); // Comprueba los eventos durante la carga
void updateLoadingProgress(std::string name); // Actualiza el progreso de carga void updateLoadingProgress(std::string name); // Actualiza el progreso de carga
void initProgressBar(); // Inicializa los rectangulos que definen la barra de progreso void initProgressBar(); // Inicializa los rectangulos que definen la barra de progreso
void updateProgressBar(); // Actualiza la barra de estado void updateProgressBar(); // Actualiza la barra de estado
// --- Constructores y destructor privados (singleton) --- // --- Constructores y destructor privados (singleton) ---
Resource(); // Constructor privado Resource(); // Constructor privado
~Resource(); // Destructor privado ~Resource(); // Destructor privado
// --- Instancia singleton --- // --- Instancia singleton ---
static Resource *instance; // Instancia única de Resource static Resource *instance; // Instancia única de Resource
}; };

62
source/scoreboard.cpp
View File

@@ -160,10 +160,10 @@ void Scoreboard::fillPanelTextures() {
SDL_SetRenderTarget(renderer_, temp); SDL_SetRenderTarget(renderer_, temp);
} }
void Scoreboard::renderPanelContent(size_t panelIndex) { void Scoreboard::renderPanelContent(size_t panel_index) {
switch (panel_[panelIndex].mode) { switch (panel_[panel_index].mode) {
case ScoreboardMode::SCORE: case ScoreboardMode::SCORE:
renderScoreMode(panelIndex); renderScoreMode(panel_index);
break; break;
case ScoreboardMode::DEMO: case ScoreboardMode::DEMO:
renderDemoMode(); renderDemoMode();
@@ -178,30 +178,30 @@ void Scoreboard::renderPanelContent(size_t panelIndex) {
renderStageInfoMode(); renderStageInfoMode();
break; break;
case ScoreboardMode::CONTINUE: case ScoreboardMode::CONTINUE:
renderContinueMode(panelIndex); renderContinueMode(panel_index);
break; break;
case ScoreboardMode::ENTER_NAME: case ScoreboardMode::ENTER_NAME:
renderEnterNameMode(panelIndex); renderEnterNameMode(panel_index);
break; break;
case ScoreboardMode::SHOW_NAME: case ScoreboardMode::SHOW_NAME:
renderShowNameMode(panelIndex); renderShowNameMode(panel_index);
break; break;
case ScoreboardMode::GAME_COMPLETED: case ScoreboardMode::GAME_COMPLETED:
renderGameCompletedMode(panelIndex); renderGameCompletedMode(panel_index);
break; break;
default: default:
break; break;
} }
} }
void Scoreboard::renderScoreMode(size_t panelIndex) { void Scoreboard::renderScoreMode(size_t panel_index) {
// SCORE // SCORE
text_scoreboard_->writeDX(TEXT_COLOR | TEXT_CENTER, slot4_1_.x, slot4_1_.y, name_[panelIndex], 1, text_color1_); text_scoreboard_->writeDX(TEXT_COLOR | TEXT_CENTER, slot4_1_.x, slot4_1_.y, name_[panel_index], 1, text_color1_);
text_scoreboard_->writeDX(TEXT_COLOR | TEXT_CENTER, slot4_2_.x, slot4_2_.y, updateScoreText(score_[panelIndex]), 1, text_color2_); text_scoreboard_->writeDX(TEXT_COLOR | TEXT_CENTER, slot4_2_.x, slot4_2_.y, updateScoreText(score_[panel_index]), 1, text_color2_);
// MULT // MULT
text_scoreboard_->writeDX(TEXT_COLOR | TEXT_CENTER, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 3"), 1, text_color1_); text_scoreboard_->writeDX(TEXT_COLOR | TEXT_CENTER, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 3"), 1, text_color1_);
text_scoreboard_->writeDX(TEXT_COLOR | TEXT_CENTER, slot4_4_.x, slot4_4_.y, "x" + std::to_string(mult_[panelIndex]).substr(0, 3), 1, text_color2_); text_scoreboard_->writeDX(TEXT_COLOR | TEXT_CENTER, slot4_4_.x, slot4_4_.y, "x" + std::to_string(mult_[panel_index]).substr(0, 3), 1, text_color2_);
} }
void Scoreboard::renderDemoMode() { void Scoreboard::renderDemoMode() {
@@ -253,74 +253,74 @@ void Scoreboard::renderStageInfoMode() {
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_4_.x, slot4_4_.y, NAME + updateScoreText(hi_score_), 1, text_color2_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_4_.x, slot4_4_.y, NAME + updateScoreText(hi_score_), 1, text_color2_);
} }
void Scoreboard::renderContinueMode(size_t panelIndex) { void Scoreboard::renderContinueMode(size_t panel_index) {
// SCORE // SCORE
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_1_.x, slot4_1_.y, name_[panelIndex], 1, text_color1_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_1_.x, slot4_1_.y, name_[panel_index], 1, text_color1_);
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_2_.x, slot4_2_.y, updateScoreText(score_[panelIndex]), 1, text_color2_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_2_.x, slot4_2_.y, updateScoreText(score_[panel_index]), 1, text_color2_);
// CONTINUE // CONTINUE
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 10"), 1, text_color1_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 10"), 1, text_color1_);
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_4_.x, slot4_4_.y, std::to_string(continue_counter_[panelIndex]), 1, text_color2_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_4_.x, slot4_4_.y, std::to_string(continue_counter_[panel_index]), 1, text_color2_);
} }
void Scoreboard::renderEnterNameMode(size_t panelIndex) { void Scoreboard::renderEnterNameMode(size_t panel_index) {
// SCORE // SCORE
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_1_.x, slot4_1_.y, name_[panelIndex], 1, text_color1_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_1_.x, slot4_1_.y, name_[panel_index], 1, text_color1_);
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_2_.x, slot4_2_.y, updateScoreText(score_[panelIndex]), 1, text_color2_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_2_.x, slot4_2_.y, updateScoreText(score_[panel_index]), 1, text_color2_);
// ENTER NAME // ENTER NAME
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 11"), 1, text_color1_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 11"), 1, text_color1_);
renderNameInputField(panelIndex); renderNameInputField(panel_index);
} }
void Scoreboard::renderNameInputField(size_t panelIndex) { void Scoreboard::renderNameInputField(size_t panel_index) {
SDL_FRect rect = {enter_name_pos_.x, enter_name_pos_.y, 5.0F, 7.0F}; SDL_FRect rect = {enter_name_pos_.x, enter_name_pos_.y, 5.0F, 7.0F};
// Recorre todos los slots de letras del nombre // Recorre todos los slots de letras del nombre
for (size_t j = 0; j < NAME_SIZE; ++j) { for (size_t j = 0; j < NAME_SIZE; ++j) {
// Selecciona el color // Selecciona el color
const Color COLOR = j < selector_pos_[panelIndex] ? text_color2_ : text_color1_; const Color COLOR = j < selector_pos_[panel_index] ? text_color2_ : text_color1_;
if (j != selector_pos_[panelIndex] || time_counter_ % 3 == 0) { if (j != selector_pos_[panel_index] || time_counter_ % 3 == 0) {
// Dibuja la linea // Dibuja la linea
if (j >= selector_pos_[panelIndex]) { if (j >= selector_pos_[panel_index]) {
SDL_SetRenderDrawColor(renderer_, COLOR.r, COLOR.g, COLOR.b, 255); SDL_SetRenderDrawColor(renderer_, COLOR.r, COLOR.g, COLOR.b, 255);
SDL_RenderLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h); SDL_RenderLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
} }
// Dibuja la letra // Dibuja la letra
if (j < record_name_[panelIndex].size()) { if (j < record_name_[panel_index].size()) {
text_scoreboard_->writeColored(rect.x, rect.y, record_name_[panelIndex].substr(j, 1), COLOR); text_scoreboard_->writeColored(rect.x, rect.y, record_name_[panel_index].substr(j, 1), COLOR);
} }
} }
rect.x += 7; rect.x += 7;
} }
} }
void Scoreboard::renderShowNameMode(size_t panelIndex) { void Scoreboard::renderShowNameMode(size_t panel_index) {
// SCORE // SCORE
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_1_.x, slot4_1_.y, name_[panelIndex], 1, text_color1_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_1_.x, slot4_1_.y, name_[panel_index], 1, text_color1_);
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_2_.x, slot4_2_.y, updateScoreText(score_[panelIndex]), 1, text_color2_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_2_.x, slot4_2_.y, updateScoreText(score_[panel_index]), 1, text_color2_);
// NAME // NAME
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 11"), 1, text_color1_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 11"), 1, text_color1_);
/* TEXTO CENTRADO */ /* TEXTO CENTRADO */
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_4_.x, slot4_4_.y, record_name_[panelIndex], 1, getColorLikeKnightRider(name_colors_, loop_counter_ / 5)); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_4_.x, slot4_4_.y, record_name_[panel_index], 1, getColorLikeKnightRider(name_colors_, loop_counter_ / 5));
/* TEXTO A LA IZQUIERDA */ /* TEXTO A LA IZQUIERDA */
// text_scoreboard_->writeColored(enter_name_pos_.x, enter_name_pos_.y, record_name_[panelIndex], getColorLikeKnightRider(name_colors_, loop_counter_ / 5)); // text_scoreboard_->writeColored(enter_name_pos_.x, enter_name_pos_.y, record_name_[panelIndex], getColorLikeKnightRider(name_colors_, loop_counter_ / 5));
} }
void Scoreboard::renderGameCompletedMode(size_t panelIndex) { void Scoreboard::renderGameCompletedMode(size_t panel_index) {
// GAME OVER // GAME OVER
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_1_.x, slot4_1_.y + 4, Lang::getText("[SCOREBOARD] 7"), 1, text_color1_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_1_.x, slot4_1_.y + 4, Lang::getText("[SCOREBOARD] 7"), 1, text_color1_);
// SCORE // SCORE
if (time_counter_ % 10 < 8) { if (time_counter_ % 10 < 8) {
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_3_.x, slot4_3_.y - 2, Lang::getText("[SCOREBOARD] 14"), 1, text_color1_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_3_.x, slot4_3_.y - 2, Lang::getText("[SCOREBOARD] 14"), 1, text_color1_);
text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_4_.x, slot4_4_.y - 2, updateScoreText(score_[panelIndex]), 1, text_color2_); text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_4_.x, slot4_4_.y - 2, updateScoreText(score_[panel_index]), 1, text_color2_);
} }
} }

58
source/scoreboard.h
View File

@@ -85,16 +85,16 @@ class Scoreboard {
std::array<int, SCOREBOARD_MAX_PANELS> continue_counter_ = {}; // Tiempo para continuar de los jugadores std::array<int, SCOREBOARD_MAX_PANELS> continue_counter_ = {}; // Tiempo para continuar de los jugadores
std::array<Panel, SCOREBOARD_MAX_PANELS> panel_ = {}; // Lista con todos los paneles del marcador std::array<Panel, SCOREBOARD_MAX_PANELS> panel_ = {}; // Lista con todos los paneles del marcador
int stage_ = 1; // Número de fase actual int stage_ = 1; // Número de fase actual
int hi_score_ = 0; // Máxima puntuación int hi_score_ = 0; // Máxima puntuación
float power_ = 0; // Poder actual de la fase float power_ = 0; // Poder actual de la fase
std::string hi_score_name_; // Nombre del jugador con la máxima puntuación std::string hi_score_name_; // Nombre del jugador con la máxima puntuación
Color color_; // Color del marcador Color color_; // Color del marcador
SDL_FRect rect_ = {0, 0, 320, 40}; // Posición y dimensiones del marcador SDL_FRect rect_ = {0, 0, 320, 40}; // Posición y dimensiones del marcador
Uint64 ticks_ = SDL_GetTicks(); // Variable donde almacenar el valor de SDL_GetTicks() Uint64 ticks_ = SDL_GetTicks(); // Variable donde almacenar el valor de SDL_GetTicks()
int time_counter_ = 0; // Contador de segundos int time_counter_ = 0; // Contador de segundos
int loop_counter_ = 0; // Contador de bucle int loop_counter_ = 0; // Contador de bucle
std::vector<Color> name_colors_; // Colores para destacar el nombre una vez introducido std::vector<Color> name_colors_; // Colores para destacar el nombre una vez introducido
// --- Variables de aspecto --- // --- Variables de aspecto ---
Color text_color1_, text_color2_; // Colores para los marcadores del texto; Color text_color1_, text_color2_; // Colores para los marcadores del texto;
@@ -104,26 +104,26 @@ class Scoreboard {
SDL_FPoint enter_name_pos_; SDL_FPoint enter_name_pos_;
// --- Métodos internos --- // --- Métodos internos ---
void recalculateAnchors(); // Recalcula las anclas de los elementos void recalculateAnchors(); // Recalcula las anclas de los elementos
static auto updateScoreText(int num) -> std::string; // Transforma un valor numérico en una cadena de 7 cifras static auto updateScoreText(int num) -> std::string; // Transforma un valor numérico en una cadena de 7 cifras
void createBackgroundTexture(); // Crea la textura de fondo void createBackgroundTexture(); // Crea la textura de fondo
void createPanelTextures(); // Crea las texturas de los paneles void createPanelTextures(); // Crea las texturas de los paneles
void fillPanelTextures(); // Rellena los diferentes paneles del marcador void fillPanelTextures(); // Rellena los diferentes paneles del marcador
void fillBackgroundTexture(); // Rellena la textura de fondo void fillBackgroundTexture(); // Rellena la textura de fondo
void updateTimeCounter(); // Actualiza el contador void updateTimeCounter(); // Actualiza el contador
void renderSeparator(); // Dibuja la línea que separa la zona de juego del marcador void renderSeparator(); // Dibuja la línea que separa la zona de juego del marcador
void iniNameColors(); // Inicializa el vector de colores para el nombre void iniNameColors(); // Inicializa el vector de colores para el nombre
void renderPanelContent(size_t panelIndex); void renderPanelContent(size_t panel_index);
void renderScoreMode(size_t panelIndex); void renderScoreMode(size_t panel_index);
void renderDemoMode(); void renderDemoMode();
void renderWaitingMode(); void renderWaitingMode();
void renderGameOverMode(); void renderGameOverMode();
void renderStageInfoMode(); void renderStageInfoMode();
void renderContinueMode(size_t panelIndex); void renderContinueMode(size_t panel_index);
void renderEnterNameMode(size_t panelIndex); void renderEnterNameMode(size_t panel_index);
void renderNameInputField(size_t panelIndex); void renderNameInputField(size_t panel_index);
void renderShowNameMode(size_t panelIndex); void renderShowNameMode(size_t panel_index);
void renderGameCompletedMode(size_t panelIndex); void renderGameCompletedMode(size_t panel_index);
// --- Constructor y destructor privados (singleton) --- // --- Constructor y destructor privados (singleton) ---
Scoreboard(); Scoreboard();

336
source/screen.h
View File

@@ -14,201 +14,201 @@ class Text;
// Clase Screen: gestiona la ventana, el renderizador y los efectos visuales globales // Clase Screen: gestiona la ventana, el renderizador y los efectos visuales globales
class Screen { class Screen {
public: public:
// --- Métodos de singleton --- // --- Métodos de singleton ---
static void init(); // Inicializa el objeto Screen static void init(); // Inicializa el objeto Screen
static void destroy(); // Libera el objeto Screen static void destroy(); // Libera el objeto Screen
static auto get() -> Screen *; // Obtiene el puntero al objeto Screen static auto get() -> Screen *; // Obtiene el puntero al objeto Screen
// --- Métodos principales --- // --- Métodos principales ---
void update(); // Actualiza la lógica de la clase void update(); // Actualiza la lógica de la clase
void coreUpdate(); // Actualiza los elementos mínimos void coreUpdate(); // Actualiza los elementos mínimos
void clean(Color color = Color(0x00, 0x00, 0x00)); // Limpia la pantalla void clean(Color color = Color(0x00, 0x00, 0x00)); // Limpia la pantalla
void start(); // Prepara para empezar a dibujar en la textura de juego void start(); // Prepara para empezar a dibujar en la textura de juego
void render(); // Vuelca el contenido del renderizador en pantalla void render(); // Vuelca el contenido del renderizador en pantalla
void coreRender(); // Vuelca el contenido del renderizador en pantalla exceptuando ciertas partes void coreRender(); // Vuelca el contenido del renderizador en pantalla exceptuando ciertas partes
// --- Configuración de ventana y render --- // --- Configuración de ventana y render ---
void setFullscreenMode(); // Establece el modo de pantalla completa void setFullscreenMode(); // Establece el modo de pantalla completa
void toggleFullscreen(); // Cambia entre pantalla completa y ventana void toggleFullscreen(); // Cambia entre pantalla completa y ventana
void setWindowZoom(int size); // Cambia el tamaño de la ventana void setWindowZoom(int size); // Cambia el tamaño de la ventana
auto decWindowSize() -> bool; // Reduce el tamaño de la ventana auto decWindowSize() -> bool; // Reduce el tamaño de la ventana
auto incWindowSize() -> bool; // Aumenta el tamaño de la ventana auto incWindowSize() -> bool; // Aumenta el tamaño de la ventana
void applySettings(); // Aplica los valores de las opciones void applySettings(); // Aplica los valores de las opciones
void initShaders(); // Inicializa los shaders void initShaders(); // Inicializa los shaders
// --- Efectos visuales --- // --- Efectos visuales ---
void shake(int desp = 2, int delay = 3, int lenght = 8) { shake_effect_.enable(src_rect_, dst_rect_, desp, delay, lenght); } // Agita la pantalla void shake(int desp = 2, int delay = 3, int lenght = 8) { shake_effect_.enable(src_rect_, dst_rect_, desp, delay, lenght); } // Agita la pantalla
void flash(Color color, int lenght = 10, int delay = 0) { flash_effect_ = FlashEffect(true, lenght, delay, color); } // Pone la pantalla de color void flash(Color color, int lenght = 10, int delay = 0) { flash_effect_ = FlashEffect(true, lenght, delay, color); } // Pone la pantalla de color
void toggleShaders(); // Alterna entre activar y desactivar los shaders void toggleShaders(); // Alterna entre activar y desactivar los shaders
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
void setVSync(bool enabled); // Establece el estado del V-Sync void setVSync(bool enabled); // Establece el estado del V-Sync
void attenuate(bool value) { attenuate_effect_ = value; } // Atenúa la pantalla void attenuate(bool value) { attenuate_effect_ = value; } // Atenúa la pantalla
// --- Getters --- // --- Getters ---
auto getRenderer() -> SDL_Renderer * { return renderer_; } // Obtiene el renderizador auto getRenderer() -> SDL_Renderer * { return renderer_; } // Obtiene el renderizador
void show() { SDL_ShowWindow(window_); } // Muestra la ventana void show() { SDL_ShowWindow(window_); } // Muestra la ventana
void hide() { SDL_HideWindow(window_); } // Oculta la ventana void hide() { SDL_HideWindow(window_); } // Oculta la ventana
void getSingletons(); // Obtiene los punteros a los singletones void getSingletons(); // Obtiene los punteros a los singletones
[[nodiscard]] static auto getVSync() -> bool { return Options::video.v_sync; } // Obtiene el valor de V-Sync [[nodiscard]] static auto getVSync() -> bool { return Options::video.v_sync; } // Obtiene el valor de V-Sync
[[nodiscard]] auto getText() const -> std::shared_ptr<Text> { return text_; } // Obtiene el puntero al texto de Screen [[nodiscard]] auto getText() const -> std::shared_ptr<Text> { return text_; } // Obtiene el puntero al texto de Screen
#ifdef DEBUG #ifdef DEBUG
// --- Debug --- // --- Debug ---
void toggleDebugInfo() { debug_info_.show = !debug_info_.show; } void toggleDebugInfo() { debug_info_.show = !debug_info_.show; }
void setDebugInfoEnabled(bool value) { debug_info_.show = value; } void setDebugInfoEnabled(bool value) { debug_info_.show = value; }
#endif #endif
private: private:
// --- Constantes --- // --- Constantes ---
static constexpr int WINDOWS_DECORATIONS = 35; static constexpr int WINDOWS_DECORATIONS = 35;
// --- Estructuras internas --- // --- Estructuras internas ---
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.
FPS() = default; FPS() = default;
void increment() { frame_count++; } void increment() { 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;
}
};
// Efecto de flash en pantalla: pinta la pantalla de un color durante unos frames
struct FlashEffect {
bool enabled; // Indica si el efecto está activo
int lenght; // Duración total del efecto en frames
int delay; // Retraso antes de mostrar el flash
int counter; // Contador de frames restantes
Color color; // Color del flash
explicit FlashEffect(bool enabled = false, int lenght = 0, int delay = 0, Color color = Color(0xFF, 0xFF, 0xFF))
: enabled(enabled), lenght(lenght), delay(delay), counter(lenght), color(color) {}
void update() { (enabled && counter > 0) ? counter-- : static_cast<int>(enabled = false); }
[[nodiscard]] auto isRendarable() const -> bool { return enabled && counter < lenght - delay; }
};
// Efecto de sacudida/agitación de pantalla: mueve la imagen para simular un temblor
struct ShakeEffect {
int desp; // Desplazamiento máximo de la sacudida (en píxeles)
int delay; // Frames entre cada movimiento de sacudida
int counter; // Contador de frames para el siguiente movimiento
int lenght; // Duración total del efecto en frames
int remaining; // Frames restantes de sacudida
int original_pos; // Posición original de la imagen (x)
int original_width; // Ancho original de la imagen
bool enabled; // Indica si el efecto está activo
explicit ShakeEffect(bool en = false, int dp = 2, int dl = 3, int cnt = 0, int len = 8, int rem = 0, int orig_pos = 0, int orig_width = 800)
: desp(dp), delay(dl), counter(cnt), lenght(len), remaining(rem), original_pos(orig_pos), original_width(orig_width), enabled(en) {}
// Activa el efecto de sacudida y guarda la posición y tamaño originales
void enable(SDL_FRect &src_rect, SDL_FRect &dst_rect, int new_desp = -1, int new_delay = -1, int new_lenght = -1) {
if (!enabled) {
enabled = true;
original_pos = src_rect.x;
original_width = src_rect.w;
// Usar nuevos valores si se proporcionan, sino mantener los actuales
if (new_desp != -1) {
desp = new_desp;
}
if (new_delay != -1) {
delay = new_delay;
}
if (new_lenght != -1) {
lenght = new_lenght;
} }
};
src_rect.w -= desp; // Efecto de flash en pantalla: pinta la pantalla de un color durante unos frames
dst_rect.w = src_rect.w; struct FlashEffect {
} bool enabled; // Indica si el efecto está activo
remaining = lenght; int lenght; // Duración total del efecto en frames
counter = delay; int delay; // Retraso antes de mostrar el flash
} int counter; // Contador de frames restantes
Color color; // Color del flash
// Actualiza el estado del efecto de sacudida explicit FlashEffect(bool enabled = false, int lenght = 0, int delay = 0, Color color = Color(0xFF, 0xFF, 0xFF))
void update(SDL_FRect &src_rect, SDL_FRect &dst_rect) { : enabled(enabled), lenght(lenght), delay(delay), counter(lenght), color(color) {}
if (enabled) {
if (counter > 0) { void update() { (enabled && counter > 0) ? counter-- : static_cast<int>(enabled = false); }
counter--; [[nodiscard]] auto isRendarable() const -> bool { return enabled && counter < lenght - delay; }
} else { };
// Efecto de sacudida/agitación de pantalla: mueve la imagen para simular un temblor
struct ShakeEffect {
int desp; // Desplazamiento máximo de la sacudida (en píxeles)
int delay; // Frames entre cada movimiento de sacudida
int counter; // Contador de frames para el siguiente movimiento
int lenght; // Duración total del efecto en frames
int remaining; // Frames restantes de sacudida
int original_pos; // Posición original de la imagen (x)
int original_width; // Ancho original de la imagen
bool enabled; // Indica si el efecto está activo
explicit ShakeEffect(bool en = false, int dp = 2, int dl = 3, int cnt = 0, int len = 8, int rem = 0, int orig_pos = 0, int orig_width = 800)
: desp(dp), delay(dl), counter(cnt), lenght(len), remaining(rem), original_pos(orig_pos), original_width(orig_width), enabled(en) {}
// Activa el efecto de sacudida y guarda la posición y tamaño originales
void enable(SDL_FRect &src_rect, SDL_FRect &dst_rect, int new_desp = -1, int new_delay = -1, int new_lenght = -1) {
if (!enabled) {
enabled = true;
original_pos = src_rect.x;
original_width = src_rect.w;
// Usar nuevos valores si se proporcionan, sino mantener los actuales
if (new_desp != -1) {
desp = new_desp;
}
if (new_delay != -1) {
delay = new_delay;
}
if (new_lenght != -1) {
lenght = new_lenght;
}
src_rect.w -= desp;
dst_rect.w = src_rect.w;
}
remaining = lenght;
counter = delay; counter = delay;
const auto SRC_DESP = (remaining % 2 == 0) ? 0 : desp; }
const auto DST_DESP = (remaining % 2 == 1) ? 0 : desp;
src_rect.x = original_pos + SRC_DESP; // Actualiza el estado del efecto de sacudida
dst_rect.x = original_pos + DST_DESP; void update(SDL_FRect &src_rect, SDL_FRect &dst_rect) {
remaining--; if (enabled) {
if (remaining == -1) { if (counter > 0) {
enabled = false; counter--;
src_rect.x = original_pos; } else {
src_rect.w = original_width; counter = delay;
dst_rect.x = original_pos; const auto SRC_DESP = (remaining % 2 == 0) ? 0 : desp;
dst_rect.w = original_width; const auto DST_DESP = (remaining % 2 == 1) ? 0 : desp;
src_rect.x = original_pos + SRC_DESP;
dst_rect.x = original_pos + DST_DESP;
remaining--;
if (remaining == -1) {
enabled = false;
src_rect.x = original_pos;
src_rect.w = original_width;
dst_rect.x = original_pos;
dst_rect.w = original_width;
}
}
} }
} }
}
}
[[nodiscard]] auto isEnabled() const -> bool { return enabled; } [[nodiscard]] auto isEnabled() const -> bool { return enabled; }
}; };
#ifdef DEBUG #ifdef DEBUG
struct Debug { struct Debug {
std::shared_ptr<Text> text; std::shared_ptr<Text> text;
bool show = false; bool show = false;
}; };
#endif #endif
// --- Singleton --- // --- Singleton ---
static Screen *instance; static Screen *instance;
// --- Objetos y punteros --- // --- Objetos y punteros ---
SDL_Window *window_; // Ventana de la aplicación SDL_Window *window_; // Ventana de la aplicación
SDL_Renderer *renderer_; // El renderizador de la ventana SDL_Renderer *renderer_; // El renderizador de la ventana
SDL_Texture *game_canvas_; // Textura donde se dibuja todo antes de volcarse al renderizador SDL_Texture *game_canvas_; // Textura donde se dibuja todo antes de volcarse al renderizador
ServiceMenu *service_menu_; // Objeto para mostrar el menú de servicio ServiceMenu *service_menu_; // Objeto para mostrar el menú de servicio
Notifier *notifier_; // Objeto para mostrar las notificaciones por pantalla Notifier *notifier_; // Objeto para mostrar las notificaciones por pantalla
// --- Variables de estado --- // --- Variables de estado ---
SDL_FRect src_rect_; // Coordenadas de origen para dibujar la textura del juego SDL_FRect src_rect_; // Coordenadas de origen para dibujar la textura del juego
SDL_FRect dst_rect_; // Coordenadas destino para dibujar la textura del juego SDL_FRect dst_rect_; // Coordenadas destino para dibujar la textura del juego
FPS fps_; // Gestión de frames por segundo FPS fps_; // Gestión de frames por segundo
std::string shader_source_; // Almacena el contenido del archivo GLSL std::string shader_source_; // Almacena el contenido del archivo GLSL
FlashEffect flash_effect_; // Efecto de flash en pantalla FlashEffect flash_effect_; // Efecto de flash en pantalla
ShakeEffect shake_effect_; // Efecto de agitar la pantalla ShakeEffect shake_effect_; // Efecto de agitar la pantalla
bool attenuate_effect_ = false; // Indica si la pantalla ha de estar atenuada bool attenuate_effect_ = false; // Indica si la pantalla ha de estar atenuada
#ifdef DEBUG #ifdef DEBUG
Debug debug_info_; // Información de debug Debug debug_info_; // Información de debug
#endif #endif
// --- Texto --- // --- Texto ---
std::shared_ptr<Text> text_; // Objeto para escribir texto en pantalla std::shared_ptr<Text> text_; // Objeto para escribir texto en pantalla
// --- Métodos internos --- // --- Métodos internos ---
auto initSDLVideo() -> bool; // Arranca SDL VIDEO y crea la ventana auto initSDLVideo() -> bool; // Arranca SDL VIDEO y crea la ventana
void renderFlash(); // Dibuja el efecto de flash en la pantalla void renderFlash(); // Dibuja el efecto de flash en la pantalla
void renderShake(); // Aplica el efecto de agitar la pantalla void renderShake(); // Aplica el efecto de agitar la pantalla
void renderInfo(); // Muestra información por pantalla void renderInfo(); // Muestra información por pantalla
void renderScreen(); // Selecciona y ejecuta el método de renderizado adecuado void renderScreen(); // Selecciona y ejecuta el método de renderizado adecuado
void loadShaders(); // Carga el contenido del archivo GLSL void loadShaders(); // Carga el contenido del archivo GLSL
void adjustWindowSize(); // Calcula el tamaño de la ventana void adjustWindowSize(); // Calcula el tamaño de la ventana
static void getDisplayInfo(); // Obtiene información sobre la pantalla static void getDisplayInfo(); // Obtiene información sobre la pantalla
void renderOverlays(); // Renderiza todos los overlays y efectos void renderOverlays(); // Renderiza todos los overlays y efectos
void renderAttenuate(); // Atenúa la pantalla void renderAttenuate(); // Atenúa la pantalla
void createText(); // Crea el objeto de texto void createText(); // Crea el objeto de texto
// --- Constructores y destructor --- // --- Constructores y destructor ---
Screen(); Screen();
~Screen(); ~Screen();
}; };

3
source/sections/credits.cpp
View File

@@ -9,7 +9,7 @@
#include <stdexcept> // Para runtime_error #include <stdexcept> // Para runtime_error
#include <string> // Para basic_string, string #include <string> // Para basic_string, string
#include <string_view> #include <string_view>
#include <vector> // Para vector #include <vector> // Para vector
#include "audio.h" // Para Audio #include "audio.h" // Para Audio
#include "balloon_manager.h" // Para BalloonManager #include "balloon_manager.h" // Para BalloonManager
@@ -33,7 +33,6 @@
// Textos // Textos
constexpr std::string_view TEXT_COPYRIGHT = "@2020,2025 JailDesigner"; constexpr std::string_view TEXT_COPYRIGHT = "@2020,2025 JailDesigner";
// Constructor // Constructor
Credits::Credits() Credits::Credits()
: balloon_manager_(std::make_unique<BalloonManager>()), : balloon_manager_(std::make_unique<BalloonManager>()),

6
source/sections/credits.h
View File

@@ -101,10 +101,10 @@ class Credits {
SDL_FRect border_rect_ = play_area_; // Delimitador de ventana SDL_FRect border_rect_ = play_area_; // Delimitador de ventana
// --- Métodos del bucle principal --- // --- Métodos del bucle principal ---
void update(); // Actualización principal de la lógica void update(); // Actualización principal de la lógica
void render(); // Renderizado de la escena void render(); // Renderizado de la escena
static void checkEvents(); // Manejo de eventos static void checkEvents(); // Manejo de eventos
void checkInput(); // Procesamiento de entrada void checkInput(); // Procesamiento de entrada
// --- Métodos de renderizado --- // --- Métodos de renderizado ---
void fillTextTexture(); // Crear textura de texto de créditos void fillTextTexture(); // Crear textura de texto de créditos

2
source/sections/game.cpp
View File

@@ -2,8 +2,8 @@
#include <SDL3/SDL.h> // Para SDL_GetTicks, SDL_SetRenderTarget #include <SDL3/SDL.h> // Para SDL_GetTicks, SDL_SetRenderTarget
#include <algorithm> // Para find_if, clamp, find, min
#include <array> #include <array>
#include <algorithm> // Para find_if, clamp, find, min
#include <cstdlib> // Para rand, size_t #include <cstdlib> // Para rand, size_t
#include <functional> // Para function #include <functional> // Para function
#include <iterator> // Para distance, size #include <iterator> // Para distance, size

364
source/sections/game.h
View File

@@ -37,209 +37,209 @@ constexpr int TOTAL_SCORE_DATA = 3;
// Clase Game // Clase Game
class Game { class Game {
public: public:
// Constructor // Constructor
Game(int player_id, int current_stage, bool demo); Game(int player_id, int current_stage, bool demo);
// Destructor // Destructor
~Game(); ~Game();
// Bucle principal del juego // Bucle principal del juego
void run(); void run();
private: private:
// --- Tipos internos --- // --- Tipos internos ---
enum class GameState { enum class GameState {
FADE_IN, FADE_IN,
ENTERING_PLAYER, ENTERING_PLAYER,
SHOWING_GET_READY_MESSAGE, SHOWING_GET_READY_MESSAGE,
PLAYING, PLAYING,
COMPLETED, COMPLETED,
GAME_OVER, GAME_OVER,
}; };
// --- Constantes internas --- // --- Constantes internas ---
static constexpr int HELP_COUNTER = 1000; static constexpr int HELP_COUNTER = 1000;
static constexpr int GAME_COMPLETED_START_FADE = 500; static constexpr int GAME_COMPLETED_START_FADE = 500;
static constexpr int GAME_COMPLETED_END = 700; static constexpr int GAME_COMPLETED_END = 700;
static constexpr int GAME_OVER_COUNTER = 350; static constexpr int GAME_OVER_COUNTER = 350;
static constexpr int TIME_STOPPED_COUNTER = 360; static constexpr int TIME_STOPPED_COUNTER = 360;
static constexpr int ITEM_POINTS_1_DISK_ODDS = 10; static constexpr int ITEM_POINTS_1_DISK_ODDS = 10;
static constexpr int ITEM_POINTS_2_GAVINA_ODDS = 6; static constexpr int ITEM_POINTS_2_GAVINA_ODDS = 6;
static constexpr int ITEM_POINTS_3_PACMAR_ODDS = 3; static constexpr int ITEM_POINTS_3_PACMAR_ODDS = 3;
static constexpr int ITEM_CLOCK_ODDS = 5; static constexpr int ITEM_CLOCK_ODDS = 5;
static constexpr int ITEM_COFFEE_ODDS = 5; static constexpr int ITEM_COFFEE_ODDS = 5;
static constexpr int ITEM_POWER_BALL_ODDS = 0; static constexpr int ITEM_POWER_BALL_ODDS = 0;
static constexpr int ITEM_COFFEE_MACHINE_ODDS = 4; static constexpr int ITEM_COFFEE_MACHINE_ODDS = 4;
// --- Estructuras --- // --- Estructuras ---
struct Helper { struct Helper {
bool need_coffee{false}; // Indica si se necesitan cafes bool need_coffee{false}; // Indica si se necesitan cafes
bool need_coffee_machine{false}; // Indica si se necesita PowerUp bool need_coffee_machine{false}; // Indica si se necesita PowerUp
bool need_power_ball{false}; // Indica si se necesita una PowerBall bool need_power_ball{false}; // Indica si se necesita una PowerBall
int counter; // Contador para no dar ayudas consecutivas int counter; // Contador para no dar ayudas consecutivas
int item_disk_odds; // Probabilidad de aparición del objeto int item_disk_odds; // Probabilidad de aparición del objeto
int item_gavina_odds; // Probabilidad de aparición del objeto int item_gavina_odds; // Probabilidad de aparición del objeto
int item_pacmar_odds; // Probabilidad de aparición del objeto int item_pacmar_odds; // Probabilidad de aparición del objeto
int item_clock_odds; // Probabilidad de aparición del objeto int item_clock_odds; // Probabilidad de aparición del objeto
int item_coffee_odds; // Probabilidad de aparición del objeto int item_coffee_odds; // Probabilidad de aparición del objeto
int item_coffee_machine_odds; // Probabilidad de aparición del objeto int item_coffee_machine_odds; // Probabilidad de aparición del objeto
Helper() Helper()
: counter(HELP_COUNTER), : counter(HELP_COUNTER),
item_disk_odds(ITEM_POINTS_1_DISK_ODDS), item_disk_odds(ITEM_POINTS_1_DISK_ODDS),
item_gavina_odds(ITEM_POINTS_2_GAVINA_ODDS), item_gavina_odds(ITEM_POINTS_2_GAVINA_ODDS),
item_pacmar_odds(ITEM_POINTS_3_PACMAR_ODDS), item_pacmar_odds(ITEM_POINTS_3_PACMAR_ODDS),
item_clock_odds(ITEM_CLOCK_ODDS), item_clock_odds(ITEM_CLOCK_ODDS),
item_coffee_odds(ITEM_COFFEE_ODDS), item_coffee_odds(ITEM_COFFEE_ODDS),
item_coffee_machine_odds(ITEM_COFFEE_MACHINE_ODDS) {} item_coffee_machine_odds(ITEM_COFFEE_MACHINE_ODDS) {}
}; };
// --- Objetos y punteros --- // --- Objetos y punteros ---
SDL_Renderer *renderer_; // El renderizador de la ventana SDL_Renderer *renderer_; // El renderizador de la ventana
Screen *screen_; // Objeto encargado de dibujar en pantalla Screen *screen_; // Objeto encargado de dibujar en pantalla
Input *input_; // Manejador de entrada Input *input_; // Manejador de entrada
Scoreboard *scoreboard_; // Objeto para dibujar el marcador Scoreboard *scoreboard_; // Objeto para dibujar el marcador
std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego
SDL_Texture *canvas_; // Textura para dibujar la zona de juego SDL_Texture *canvas_; // Textura para dibujar la zona de juego
std::vector<std::shared_ptr<Player>> players_; // Vector con los jugadores std::vector<std::shared_ptr<Player>> players_; // Vector con los jugadores
std::vector<std::unique_ptr<Bullet>> bullets_; // Vector con las balas std::vector<std::unique_ptr<Bullet>> bullets_; // Vector con las balas
std::vector<std::unique_ptr<Item>> items_; // Vector con los items std::vector<std::unique_ptr<Item>> items_; // Vector con los items
std::vector<std::unique_ptr<SmartSprite>> smart_sprites_; // Vector con los smartsprites std::vector<std::unique_ptr<SmartSprite>> smart_sprites_; // Vector con los smartsprites
std::vector<std::unique_ptr<PathSprite>> path_sprites_; // Vector con los pathsprites std::vector<std::unique_ptr<PathSprite>> path_sprites_; // Vector con los pathsprites
std::vector<std::shared_ptr<Texture>> item_textures_; // Vector con las texturas de los items std::vector<std::shared_ptr<Texture>> item_textures_; // Vector con las texturas de los items
std::vector<std::vector<std::shared_ptr<Texture>>> player_textures_; // Vector con todas las texturas de los jugadores std::vector<std::vector<std::shared_ptr<Texture>>> player_textures_; // Vector con todas las texturas de los jugadores
std::vector<std::shared_ptr<Texture>> game_text_textures_; // Vector con las texturas para los sprites con textos std::vector<std::shared_ptr<Texture>> game_text_textures_; // Vector con las texturas para los sprites con textos
std::vector<std::vector<std::string>> item_animations_; // Vector con las animaciones de los items std::vector<std::vector<std::string>> item_animations_; // Vector con las animaciones de los items
std::vector<std::vector<std::string>> player_animations_; // Vector con las animaciones del jugador std::vector<std::vector<std::string>> player_animations_; // Vector con las animaciones del jugador
std::unique_ptr<Fade> fade_in_; // Objeto para renderizar fades std::unique_ptr<Fade> fade_in_; // Objeto para renderizar fades
std::unique_ptr<Fade> fade_out_; // Objeto para renderizar fades std::unique_ptr<Fade> fade_out_; // Objeto para renderizar fades
std::unique_ptr<BalloonManager> balloon_manager_; // Objeto para gestionar los globos std::unique_ptr<BalloonManager> balloon_manager_; // Objeto para gestionar los globos
std::unique_ptr<Tabe> tabe_; // Objeto para gestionar el Tabe Volaor std::unique_ptr<Tabe> tabe_; // Objeto para gestionar el Tabe Volaor
std::vector<Path> paths_; // Vector con los recorridos precalculados almacenados std::vector<Path> paths_; // Vector con los recorridos precalculados almacenados
// --- Variables de estado --- // --- Variables de estado ---
HiScoreEntry hi_score_ = HiScoreEntry( HiScoreEntry hi_score_ = HiScoreEntry(
Options::settings.hi_score_table[0].name, Options::settings.hi_score_table[0].name,
Options::settings.hi_score_table[0].score); // Máxima puntuación y nombre de quien la ostenta Options::settings.hi_score_table[0].score); // Máxima puntuación y nombre de quien la ostenta
Demo demo_; // Variable con todas las variables relacionadas con el modo demo Demo demo_; // Variable con todas las variables relacionadas con el modo demo
Options::DifficultyCode difficulty_ = Options::settings.difficulty; // Dificultad del juego Options::DifficultyCode difficulty_ = Options::settings.difficulty; // Dificultad del juego
Helper helper_; // Variable para gestionar las ayudas Helper helper_; // Variable para gestionar las ayudas
Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
bool coffee_machine_enabled_ = false; // Indica si hay una máquina de café en el terreno de juego bool coffee_machine_enabled_ = false; // Indica si hay una máquina de café en el terreno de juego
bool hi_score_achieved_ = false; // Indica si se ha superado la puntuación máxima bool hi_score_achieved_ = false; // Indica si se ha superado la puntuación máxima
bool paused_ = false; // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade) bool paused_ = false; // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
// bool paused_by_service_menu_ = false; // bool paused_by_service_menu_ = false;
float difficulty_score_multiplier_; // Multiplicador de puntos en función de la dificultad float difficulty_score_multiplier_; // Multiplicador de puntos en función de la dificultad
int counter_ = 0; // Contador para el juego int counter_ = 0; // Contador para el juego
int game_completed_counter_ = 0; // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos int game_completed_counter_ = 0; // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
int game_over_counter_ = GAME_OVER_COUNTER; // Contador para el estado de fin de partida int game_over_counter_ = GAME_OVER_COUNTER; // Contador para el estado de fin de partida
int time_stopped_counter_ = 0; // Temporizador para llevar la cuenta del tiempo detenido int time_stopped_counter_ = 0; // Temporizador para llevar la cuenta del tiempo detenido
int total_power_to_complete_game_; // La suma del poder necesario para completar todas las fases int total_power_to_complete_game_; // La suma del poder necesario para completar todas las fases
int menace_current_ = 0; // Nivel de amenaza actual int menace_current_ = 0; // Nivel de amenaza actual
int menace_threshold_ = 0; // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos int menace_threshold_ = 0; // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
GameState state_ = GameState::FADE_IN; // Estado GameState state_ = GameState::FADE_IN; // Estado
std::vector<std::shared_ptr<Player>> players_to_reorder_; std::vector<std::shared_ptr<Player>> players_to_reorder_;
#ifdef DEBUG #ifdef DEBUG
bool auto_pop_balloons_ = false; // Si es true, incrementa automaticamente los globos explotados bool auto_pop_balloons_ = false; // Si es true, incrementa automaticamente los globos explotados
// Comprueba los eventos en el modo DEBUG // Comprueba los eventos en el modo DEBUG
void checkDebugEvents(const SDL_Event &event); void checkDebugEvents(const SDL_Event &event);
#endif #endif
// --- Métodos internos --- // --- Métodos internos ---
void update(); // Actualiza el juego void update(); // Actualiza el juego
void render(); // Dibuja el juego void render(); // Dibuja el juego
void checkEvents(); // Comprueba los eventos que hay en cola void checkEvents(); // Comprueba los eventos que hay en cola
void setResources(); // Asigna texturas y animaciones void setResources(); // Asigna texturas y animaciones
void updateHiScore(); // Actualiza el valor de HiScore en caso necesario void updateHiScore(); // Actualiza el valor de HiScore en caso necesario
void updatePlayers(); // Actualiza las variables del jugador void updatePlayers(); // Actualiza las variables del jugador
void renderPlayers(); // Dibuja a los jugadores void renderPlayers(); // Dibuja a los jugadores
void updateStage(); // Comprueba si hay cambio de fase y actualiza las variables void updateStage(); // Comprueba si hay cambio de fase y actualiza las variables
void updateGameStateGameOver(); // Actualiza el estado de fin de la partida void updateGameStateGameOver(); // Actualiza el estado de fin de la partida
void destroyAllItems(); // Destruye todos los items void destroyAllItems(); // Destruye todos los items
auto checkPlayerBalloonCollision(std::shared_ptr<Player> &player) -> std::shared_ptr<Balloon>; // Comprueba la colisión entre el jugador y los globos activos auto checkPlayerBalloonCollision(std::shared_ptr<Player> &player) -> std::shared_ptr<Balloon>; // Comprueba la colisión entre el jugador y los globos activos
void checkPlayerItemCollision(std::shared_ptr<Player> &player); // Comprueba la colisión entre el jugador y los items void checkPlayerItemCollision(std::shared_ptr<Player> &player); // Comprueba la colisión entre el jugador y los items
void checkBulletCollision(); // Comprueba y procesa la colisión de las balas void checkBulletCollision(); // Comprueba y procesa la colisión de las balas
void updateBullets(); // Mueve las balas activas void updateBullets(); // Mueve las balas activas
void renderBullets(); // Pinta las balas activas void renderBullets(); // Pinta las balas activas
void createBullet(int x, int y, BulletType kind, bool powered_up, int owner); // Crea un objeto bala void createBullet(int x, int y, BulletType kind, bool powered_up, int owner); // Crea un objeto bala
void freeBullets(); // Vacia el vector de balas void freeBullets(); // Vacia el vector de balas
void updateItems(); // Actualiza los items void updateItems(); // Actualiza los items
void renderItems(); // Pinta los items activos void renderItems(); // Pinta los items activos
auto dropItem() -> ItemType; // Devuelve un item en función del azar auto dropItem() -> ItemType; // Devuelve un item en función del azar
void createItem(ItemType type, float x, float y); // Crea un objeto item void createItem(ItemType type, float x, float y); // Crea un objeto item
void freeItems(); // Vacia el vector de items void freeItems(); // Vacia el vector de items
void createItemText(int x, std::shared_ptr<Texture> texture); // Crea un objeto PathSprite void createItemText(int x, std::shared_ptr<Texture> texture); // Crea un objeto PathSprite
void createMessage(const std::vector<Path> &paths, std::shared_ptr<Texture> texture); // Crea un objeto PathSprite void createMessage(const std::vector<Path> &paths, std::shared_ptr<Texture> texture); // Crea un objeto PathSprite
void freeSmartSprites(); // Vacia el vector de smartsprites void freeSmartSprites(); // Vacia el vector de smartsprites
void freePathSprites(); // Vacia el vector de pathsprites void freePathSprites(); // Vacia el vector de pathsprites
void throwCoffee(int x, int y); // Crea un SpriteSmart para arrojar el item café al recibir un impacto void throwCoffee(int x, int y); // Crea un SpriteSmart para arrojar el item café al recibir un impacto
void updateSmartSprites(); // Actualiza los SpriteSmarts void updateSmartSprites(); // Actualiza los SpriteSmarts
void renderSmartSprites(); // Pinta los SpriteSmarts activos void renderSmartSprites(); // Pinta los SpriteSmarts activos
void updatePathSprites(); // Actualiza los PathSprites void updatePathSprites(); // Actualiza los PathSprites
void renderPathSprites(); // Pinta los PathSprites activos void renderPathSprites(); // Pinta los PathSprites activos
void handlePlayerCollision(std::shared_ptr<Player> &player); // Acciones a realizar cuando el jugador colisiona con un globo void handlePlayerCollision(std::shared_ptr<Player> &player); // Acciones a realizar cuando el jugador colisiona con un globo
void updateTimeStopped(); // Actualiza y comprueba el valor de la variable void updateTimeStopped(); // Actualiza y comprueba el valor de la variable
void updateBackground(); // Actualiza el fondo void updateBackground(); // Actualiza el fondo
void initPaths(); // Inicializa las variables que contienen puntos de ruta para mover objetos void initPaths(); // Inicializa las variables que contienen puntos de ruta para mover objetos
void enableTimeStopItem(); // Habilita el efecto del item de detener el tiempo void enableTimeStopItem(); // Habilita el efecto del item de detener el tiempo
void disableTimeStopItem(); // Deshabilita el efecto del item de detener el tiempo void disableTimeStopItem(); // Deshabilita el efecto del item de detener el tiempo
void updateHelper(); // Actualiza las variables de ayuda void updateHelper(); // Actualiza las variables de ayuda
auto allPlayersAreWaitingOrGameOver() -> bool; // Comprueba si todos los jugadores han terminado de jugar auto allPlayersAreWaitingOrGameOver() -> bool; // Comprueba si todos los jugadores han terminado de jugar
auto allPlayersAreGameOver() -> bool; // Comprueba si todos los jugadores han terminado de jugar auto allPlayersAreGameOver() -> bool; // Comprueba si todos los jugadores han terminado de jugar
auto allPlayersAreNotPlaying() -> bool; // Comprueba si todos los jugadores han terminado de jugar auto allPlayersAreNotPlaying() -> bool; // Comprueba si todos los jugadores han terminado de jugar
void updateScoreboard(); // Actualiza el marcador void updateScoreboard(); // Actualiza el marcador
void fillCanvas(); // Dibuja los elementos de la zona de juego en su textura void fillCanvas(); // Dibuja los elementos de la zona de juego en su textura
void pause(bool value); // Pausa el juego void pause(bool value); // Pausa el juego
void addScoreToScoreBoard(const std::shared_ptr<Player> &player); // Añade una puntuación a la tabla de records void addScoreToScoreBoard(const std::shared_ptr<Player> &player); // Añade una puntuación a la tabla de records
void checkAndUpdatePlayerStatus(int active_player_index, int inactive_player_index); // Saca del estado de GAME OVER al jugador si el otro está activo void checkAndUpdatePlayerStatus(int active_player_index, int inactive_player_index); // Saca del estado de GAME OVER al jugador si el otro está activo
void checkPlayersStatusPlaying(); // Comprueba el estado de juego de los jugadores void checkPlayersStatusPlaying(); // Comprueba el estado de juego de los jugadores
auto getPlayer(int id) -> std::shared_ptr<Player>; // Obtiene un jugador a partir de su "id" auto getPlayer(int id) -> std::shared_ptr<Player>; // Obtiene un jugador a partir de su "id"
static auto getController(int player_id) -> int; // Obtiene un controlador a partir del "id" del jugador static auto getController(int player_id) -> int; // Obtiene un controlador a partir del "id" del jugador
void checkInput(); // Gestiona la entrada durante el juego void checkInput(); // Gestiona la entrada durante el juego
void checkPauseInput(); // Verifica si alguno de los controladores ha solicitado una pausa y actualiza el estado de pausa del juego. void checkPauseInput(); // Verifica si alguno de los controladores ha solicitado una pausa y actualiza el estado de pausa del juego.
void demoHandleInput(); // Gestiona las entradas de los jugadores en el modo demo, incluyendo movimientos y disparos automáticos. void demoHandleInput(); // Gestiona las entradas de los jugadores en el modo demo, incluyendo movimientos y disparos automáticos.
void demoHandlePassInput(); // Gestiona las entradas de los jugadores en el modo demo para saltarse la demo. void demoHandlePassInput(); // Gestiona las entradas de los jugadores en el modo demo para saltarse la demo.
void demoHandlePlayerInput(const std::shared_ptr<Player> &player, int index); // Procesa las entradas para un jugador específico durante el modo demo. void demoHandlePlayerInput(const std::shared_ptr<Player> &player, int index); // Procesa las entradas para un jugador específico durante el modo demo.
void handleFireInput(const std::shared_ptr<Player> &player, BulletType bullet_type); // Maneja el disparo de un jugador, incluyendo la creación de balas y la gestión del tiempo de espera entre disparos. void handleFireInput(const std::shared_ptr<Player> &player, BulletType bullet_type); // Maneja el disparo de un jugador, incluyendo la creación de balas y la gestión del tiempo de espera entre disparos.
void handlePlayersInput(); // Gestiona las entradas de todos los jugadores en el modo normal (fuera del modo demo). void handlePlayersInput(); // Gestiona las entradas de todos los jugadores en el modo normal (fuera del modo demo).
void handleNormalPlayerInput(const std::shared_ptr<Player> &player); // Maneja las entradas de movimiento y disparo para un jugador en modo normal. void handleNormalPlayerInput(const std::shared_ptr<Player> &player); // Maneja las entradas de movimiento y disparo para un jugador en modo normal.
void handleFireInputs(const std::shared_ptr<Player> &player, bool autofire, int controller_index); // Procesa las entradas de disparo del jugador, permitiendo disparos automáticos si está habilitado. void handleFireInputs(const std::shared_ptr<Player> &player, bool autofire, int controller_index); // Procesa las entradas de disparo del jugador, permitiendo disparos automáticos si está habilitado.
void handlePlayerContinue(const std::shared_ptr<Player> &player); // Maneja la continuación del jugador cuando no está jugando, permitiendo que continúe si se pulsa el botón de inicio. void handlePlayerContinue(const std::shared_ptr<Player> &player); // Maneja la continuación del jugador cuando no está jugando, permitiendo que continúe si se pulsa el botón de inicio.
void handleNameInput(const std::shared_ptr<Player> &player); // Procesa las entradas para la introducción del nombre del jugador. void handleNameInput(const std::shared_ptr<Player> &player); // Procesa las entradas para la introducción del nombre del jugador.
void initDemo(int player_id); // Inicializa las variables para el modo DEMO void initDemo(int player_id); // Inicializa las variables para el modo DEMO
void setTotalPower(); // Calcula el poder total necesario para completar el juego void setTotalPower(); // Calcula el poder total necesario para completar el juego
void initScoreboard(); // Inicializa el marcador void initScoreboard(); // Inicializa el marcador
void initDifficultyVars(); // Inicializa las opciones relacionadas con la dificultad void initDifficultyVars(); // Inicializa las opciones relacionadas con la dificultad
void initPlayers(int player_id); // Inicializa los jugadores void initPlayers(int player_id); // Inicializa los jugadores
static void playMusic(); // Hace sonar la música static void playMusic(); // Hace sonar la música
void stopMusic() const; // Detiene la música void stopMusic() const; // Detiene la música
void playSound(const std::string &name) const; // Hace sonar un sonido void playSound(const std::string &name) const; // Hace sonar un sonido
void updateDemo(); // Actualiza las variables durante el modo demo void updateDemo(); // Actualiza las variables durante el modo demo
void updateGameStateFadeIn(); // Actualiza las variables durante dicho estado void updateGameStateFadeIn(); // Actualiza las variables durante dicho estado
void updateGameStateEnteringPlayer(); // Actualiza las variables durante dicho estado void updateGameStateEnteringPlayer(); // Actualiza las variables durante dicho estado
void updateGameStateShowingGetReadyMessage(); // Actualiza las variables durante dicho estado void updateGameStateShowingGetReadyMessage(); // Actualiza las variables durante dicho estado
void updateGameStatePlaying(); // Actualiza las variables durante el transcurso normal del juego void updateGameStatePlaying(); // Actualiza las variables durante el transcurso normal del juego
void updateGameStateCompleted(); // Gestiona eventos para el estado del final del juego void updateGameStateCompleted(); // Gestiona eventos para el estado del final del juego
void checkState(); // Comprueba el estado del juego void checkState(); // Comprueba el estado del juego
void cleanVectors(); // Vacía los vectores de elementos deshabilitados void cleanVectors(); // Vacía los vectores de elementos deshabilitados
void updateMenace(); // Gestiona el nivel de amenaza void updateMenace(); // Gestiona el nivel de amenaza
void evaluateAndSetMenace(); // Calcula y establece el valor de amenaza en funcion de los globos activos void evaluateAndSetMenace(); // Calcula y establece el valor de amenaza en funcion de los globos activos
void checkAndUpdateBalloonSpeed(); // Actualiza la velocidad de los globos en funcion del poder acumulado de la fase void checkAndUpdateBalloonSpeed(); // Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
void setState(GameState state); // Cambia el estado del juego void setState(GameState state); // Cambia el estado del juego
void movePlayersToFront(); // Organiza los jugadores para que los vivos se pinten sobre los muertos void movePlayersToFront(); // Organiza los jugadores para que los vivos se pinten sobre los muertos
void checkServiceMenu(); // Comprueba si está activo el menu de servicio para poner el juego en pausa void checkServiceMenu(); // Comprueba si está activo el menu de servicio para poner el juego en pausa
#ifdef RECORDING #ifdef RECORDING
void updateRecording(); // Actualiza las variables durante el modo de grabación void updateRecording(); // Actualiza las variables durante el modo de grabación
#endif #endif
}; };

82
source/sections/hiscore_table.h
View File

@@ -27,52 +27,52 @@ struct Path;
// Clase HiScoreTable // Clase HiScoreTable
class HiScoreTable { class HiScoreTable {
public: public:
// Constructor // Constructor
HiScoreTable(); HiScoreTable();
// Destructor // Destructor
~HiScoreTable(); ~HiScoreTable();
// Bucle principal // Bucle principal
void run(); void run();
private: private:
// --- Constantes --- // --- Constantes ---
static constexpr Uint16 COUNTER_END = 800; // Valor final para el contador static constexpr Uint16 COUNTER_END = 800; // Valor final para el contador
// --- Objetos y punteros --- // --- Objetos y punteros ---
SDL_Renderer *renderer_; // El renderizador de la ventana SDL_Renderer *renderer_; // El renderizador de la ventana
SDL_Texture *backbuffer_; // Textura para usar como backbuffer SDL_Texture *backbuffer_; // Textura para usar como backbuffer
std::unique_ptr<Fade> fade_; // Objeto para renderizar fades std::unique_ptr<Fade> fade_; // Objeto para renderizar fades
std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego
std::unique_ptr<Sprite> header_; // Sprite con la cabecera del texto std::unique_ptr<Sprite> header_; // Sprite con la cabecera del texto
std::vector<std::shared_ptr<PathSprite>> entry_names_; // Lista con los sprites de cada uno de los nombres de la tabla de records std::vector<std::shared_ptr<PathSprite>> entry_names_; // Lista con los sprites de cada uno de los nombres de la tabla de records
std::vector<Path> paths_; // Vector con los recorridos precalculados std::vector<Path> paths_; // Vector con los recorridos precalculados
// --- Variables --- // --- Variables ---
Uint16 counter_ = 0; // Contador Uint16 counter_ = 0; // Contador
Uint64 ticks_; // Contador de ticks para ajustar la velocidad del programa Uint64 ticks_; // Contador de ticks para ajustar la velocidad del programa
SDL_FRect view_area_; // Parte de la textura que se muestra en pantalla SDL_FRect view_area_; // Parte de la textura que se muestra en pantalla
FadeMode fade_mode_; // Modo de fade a utilizar FadeMode fade_mode_; // Modo de fade a utilizar
Color background_fade_color_; // Color de atenuación del fondo Color background_fade_color_; // Color de atenuación del fondo
std::vector<Color> entry_colors_; // Colores para destacar las entradas en la tabla std::vector<Color> entry_colors_; // Colores para destacar las entradas en la tabla
// --- Métodos internos --- // --- Métodos internos ---
void update(); // Actualiza las variables void update(); // Actualiza las variables
void render(); // Pinta en pantalla void render(); // Pinta en pantalla
static void checkEvents(); // Comprueba los eventos static void checkEvents(); // Comprueba los eventos
static void checkInput(); // Comprueba las entradas static void checkInput(); // Comprueba las entradas
static auto format(int number) -> std::string; // Convierte un entero a un string con separadores de miles static auto format(int number) -> std::string; // Convierte un entero a un string con separadores de miles
void fillTexture(); // Dibuja los sprites en la textura void fillTexture(); // Dibuja los sprites en la textura
void updateFade(); // Gestiona el fade void updateFade(); // Gestiona el fade
void createSprites(); // Crea los sprites con los textos void createSprites(); // Crea los sprites con los textos
void updateSprites(); // Actualiza las posiciones de los sprites de texto void updateSprites(); // Actualiza las posiciones de los sprites de texto
void initFade(); // Inicializa el fade void initFade(); // Inicializa el fade
void initBackground(); // Inicializa el fondo void initBackground(); // Inicializa el fondo
auto getEntryColor(int counter) -> Color; // Obtiene un color del vector de colores de entradas auto getEntryColor(int counter) -> Color; // Obtiene un color del vector de colores de entradas
void iniEntryColors(); // Inicializa los colores de las entradas void iniEntryColors(); // Inicializa los colores de las entradas
void glowEntryNames(); // Hace brillar los nombres de la tabla de records void glowEntryNames(); // Hace brillar los nombres de la tabla de records
void updateCounter(); // Gestiona el contador void updateCounter(); // Gestiona el contador
}; };

94
source/sections/instructions.h
View File

@@ -26,62 +26,62 @@ class TiledBG;
// Estructura para almacenar información de línea animada // Estructura para almacenar información de línea animada
struct Line { struct Line {
int y; // Coordenada Y de la línea int y; // Coordenada Y de la línea
float x; // Coordenada X inicial (usamos float para mayor precisión en el suavizado) float x; // Coordenada X inicial (usamos float para mayor precisión en el suavizado)
int direction; // Dirección de movimiento: -1 para izquierda, 1 para derecha int direction; // Dirección de movimiento: -1 para izquierda, 1 para derecha
Uint32 start_time{0}; // Tiempo de inicio del movimiento Uint32 start_time{0}; // Tiempo de inicio del movimiento
// Constructor de Line // Constructor de Line
Line(int y, float x, int direction) Line(int y, float x, int direction)
: y(y), x(x), direction(direction) {} : y(y), x(x), direction(direction) {}
}; };
// Clase Instructions // Clase Instructions
class Instructions { class Instructions {
public: public:
// Constructor // Constructor
Instructions(); Instructions();
// Destructor // Destructor
~Instructions(); ~Instructions();
// Bucle principal // Bucle principal
void run(); void run();
private: private:
// --- Objetos y punteros --- // --- Objetos y punteros ---
SDL_Renderer *renderer_; // El renderizador de la ventana SDL_Renderer *renderer_; // El renderizador de la ventana
SDL_Texture *texture_; // Textura fija con el texto SDL_Texture *texture_; // Textura fija con el texto
SDL_Texture *backbuffer_; // Textura para usar como backbuffer SDL_Texture *backbuffer_; // Textura para usar como backbuffer
std::vector<std::shared_ptr<Texture>> item_textures_; // Vector con las texturas de los items std::vector<std::shared_ptr<Texture>> item_textures_; // Vector con las texturas de los items
std::vector<std::unique_ptr<Sprite>> sprites_; // Vector con los sprites de los items std::vector<std::unique_ptr<Sprite>> sprites_; // Vector con los sprites de los items
std::shared_ptr<Text> text_; // Objeto para escribir texto std::shared_ptr<Text> text_; // Objeto para escribir texto
std::unique_ptr<TiledBG> tiled_bg_; // Objeto para dibujar el mosaico animado de fondo std::unique_ptr<TiledBG> tiled_bg_; // Objeto para dibujar el mosaico animado de fondo
std::unique_ptr<Fade> fade_; // Objeto para renderizar fades std::unique_ptr<Fade> fade_; // Objeto para renderizar fades
// --- Variables --- // --- Variables ---
int counter_ = 0; // Contador para manejar el progreso en la pantalla de instrucciones int counter_ = 0; // Contador para manejar el progreso en la pantalla de instrucciones
Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
SDL_FRect view_; // Vista del backbuffer que se va a mostrar por pantalla SDL_FRect view_; // Vista del backbuffer que se va a mostrar por pantalla
SDL_FPoint sprite_pos_ = {0, 0}; // Posición del primer sprite en la lista SDL_FPoint sprite_pos_ = {0, 0}; // Posición del primer sprite en la lista
float item_space_ = 2.0; // Espacio entre los items en pantalla float item_space_ = 2.0; // Espacio entre los items en pantalla
std::vector<Line> lines_; // Vector que contiene las líneas animadas en la pantalla std::vector<Line> lines_; // Vector que contiene las líneas animadas en la pantalla
bool all_lines_off_screen_ = false; // Indica si todas las líneas han salido de la pantalla bool all_lines_off_screen_ = false; // Indica si todas las líneas han salido de la pantalla
Uint32 start_delay_time_ = 0; // Tiempo de inicio del retraso para mover las líneas Uint32 start_delay_time_ = 0; // Tiempo de inicio del retraso para mover las líneas
bool start_delay_triggered_ = false; // Bandera para determinar si el retraso ha comenzado bool start_delay_triggered_ = false; // Bandera para determinar si el retraso ha comenzado
// --- Métodos internos --- // --- Métodos internos ---
void update(); // Actualiza las variables void update(); // Actualiza las variables
void render(); // Pinta en pantalla void render(); // Pinta en pantalla
static void checkEvents(); // Comprueba los eventos static void checkEvents(); // Comprueba los eventos
static void checkInput(); // Comprueba las entradas static void checkInput(); // Comprueba las entradas
void fillTexture(); // Rellena la textura de texto void fillTexture(); // Rellena la textura de texto
void fillBackbuffer(); // Rellena el backbuffer void fillBackbuffer(); // Rellena el backbuffer
void iniSprites(); // Inicializa los sprites de los items void iniSprites(); // Inicializa los sprites de los items
void updateSprites(); // Actualiza los sprites void updateSprites(); // Actualiza los sprites
static auto initializeLines(int height) -> std::vector<Line>; // Inicializa las líneas animadas static auto initializeLines(int height) -> std::vector<Line>; // Inicializa las líneas animadas
static auto moveLines(std::vector<Line> &lines, int width, float duration, Uint32 start_delay) -> bool; // Mueve las líneas static auto moveLines(std::vector<Line> &lines, int width, float duration, Uint32 start_delay) -> bool; // Mueve las líneas
static void renderLines(SDL_Renderer *renderer, SDL_Texture *texture, const std::vector<Line> &lines); // Renderiza las líneas static void renderLines(SDL_Renderer *renderer, SDL_Texture *texture, const std::vector<Line> &lines); // Renderiza las líneas
void updateBackbuffer(); // Gestiona la textura con los gráficos void updateBackbuffer(); // Gestiona la textura con los gráficos
}; };

88
source/sections/intro.h
View File

@@ -18,55 +18,55 @@
// Clase Intro // Clase Intro
class Intro { class Intro {
public: public:
// Constructor // Constructor
Intro(); Intro();
// Destructor // Destructor
~Intro() = default; ~Intro() = default;
// Bucle principal // Bucle principal
void run(); void run();
private: private:
// --- Estados internos --- // --- Estados internos ---
enum class IntroState { enum class IntroState {
SCENES, SCENES,
POST, POST,
}; };
enum class IntroPostState { enum class IntroPostState {
STOP_BG, STOP_BG,
END, END,
}; };
// --- Objetos --- // --- Objetos ---
std::vector<std::unique_ptr<PathSprite>> card_sprites_; // Vector con los sprites inteligentes para los dibujos de la intro std::vector<std::unique_ptr<PathSprite>> card_sprites_; // Vector con los sprites inteligentes para los dibujos de la intro
std::vector<std::unique_ptr<PathSprite>> shadow_sprites_; // Vector con los sprites inteligentes para las sombras std::vector<std::unique_ptr<PathSprite>> shadow_sprites_; // Vector con los sprites inteligentes para las sombras
std::vector<std::unique_ptr<Writer>> texts_; // Textos de la intro std::vector<std::unique_ptr<Writer>> texts_; // Textos de la intro
std::unique_ptr<TiledBG> tiled_bg_; // Fondo en mosaico std::unique_ptr<TiledBG> tiled_bg_; // Fondo en mosaico
// std::unique_ptr<Sprite> shadow_square_for_text_; // Sprite // std::unique_ptr<Sprite> shadow_square_for_text_; // Sprite
// --- Variables --- // --- Variables ---
Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
int scene_ = 0; // Indica qué escena está activa int scene_ = 0; // Indica qué escena está activa
IntroState state_ = IntroState::SCENES; // Estado principal de la intro IntroState state_ = IntroState::SCENES; // Estado principal de la intro
IntroPostState post_state_ = IntroPostState::STOP_BG; // Estado POST IntroPostState post_state_ = IntroPostState::STOP_BG; // Estado POST
Uint32 state_start_time_; // Tiempo de inicio del estado actual Uint32 state_start_time_; // Tiempo de inicio del estado actual
Color bg_color_ = param.intro.bg_color; // Color de fondo Color bg_color_ = param.intro.bg_color; // Color de fondo
// --- Métodos internos --- // --- Métodos internos ---
void update(); // Actualiza las variables del objeto void update(); // Actualiza las variables del objeto
void render(); // Dibuja el objeto en pantalla void render(); // Dibuja el objeto en pantalla
void checkEvents(); // Comprueba los eventos void checkEvents(); // Comprueba los eventos
static void checkInput(); // Comprueba las entradas static void checkInput(); // Comprueba las entradas
void updateScenes(); // Actualiza las escenas de la intro void updateScenes(); // Actualiza las escenas de la intro
void initSprites(); // Inicializa las imágenes void initSprites(); // Inicializa las imágenes
void initTexts(); // Inicializa los textos void initTexts(); // Inicializa los textos
void updateSprites(); // Actualiza los sprites void updateSprites(); // Actualiza los sprites
void updateTexts(); // Actualiza los textos void updateTexts(); // Actualiza los textos
void renderSprites(); // Dibuja los sprites void renderSprites(); // Dibuja los sprites
void renderTexts(); // Dibuja los textos void renderTexts(); // Dibuja los textos
static void renderTextRect(); // Dibuja el rectangulo de fondo del texto; static void renderTextRect(); // Dibuja el rectangulo de fondo del texto;
void updatePostState(); // Actualiza el estado POST void updatePostState(); // Actualiza el estado POST
}; };

64
source/sections/logo.h
View File

@@ -19,42 +19,42 @@ struct Color;
// --- Clase Logo --- // --- Clase Logo ---
class Logo { class Logo {
public: public:
// Constructor // Constructor
Logo(); Logo();
// Destructor // Destructor
~Logo(); ~Logo();
// Bucle principal // Bucle principal
void run(); void run();
private: private:
// --- Constantes --- // --- Constantes ---
static constexpr int SHOW_SINCE_SPRITE_COUNTER_MARK = 70; // Tiempo del contador en el que empieza a verse el sprite de "SINCE 1998" static constexpr int SHOW_SINCE_SPRITE_COUNTER_MARK = 70; // Tiempo del contador en el que empieza a verse el sprite de "SINCE 1998"
static constexpr int INIT_FADE_COUNTER_MARK = 300; // Tiempo del contador cuando inicia el fade a negro static constexpr int INIT_FADE_COUNTER_MARK = 300; // Tiempo del contador cuando inicia el fade a negro
static constexpr int END_LOGO_COUNTER_MARK = 400; // Tiempo del contador para terminar el logo static constexpr int END_LOGO_COUNTER_MARK = 400; // Tiempo del contador para terminar el logo
static constexpr int POST_LOGO_DURATION = 20; // Tiempo que dura el logo con el fade al máximo static constexpr int POST_LOGO_DURATION = 20; // Tiempo que dura el logo con el fade al máximo
static constexpr int SPEED = 8; // Velocidad de desplazamiento de cada línea static constexpr int SPEED = 8; // Velocidad de desplazamiento de cada línea
// --- Objetos y punteros --- // --- Objetos y punteros ---
std::shared_ptr<Texture> since_texture_; // Textura con los gráficos "Since 1998" std::shared_ptr<Texture> since_texture_; // Textura con los gráficos "Since 1998"
std::unique_ptr<Sprite> since_sprite_; // Sprite para manejar la since_texture std::unique_ptr<Sprite> since_sprite_; // Sprite para manejar la since_texture
std::shared_ptr<Texture> jail_texture_; // Textura con los gráficos "JAILGAMES" std::shared_ptr<Texture> jail_texture_; // Textura con los gráficos "JAILGAMES"
std::vector<std::unique_ptr<Sprite>> jail_sprite_; // Vector con los sprites de cada línea que forman el bitmap JAILGAMES std::vector<std::unique_ptr<Sprite>> jail_sprite_; // Vector con los sprites de cada línea que forman el bitmap JAILGAMES
// --- Variables --- // --- Variables ---
std::vector<Color> color_; // Vector con los colores para el fade std::vector<Color> color_; // Vector con los colores para el fade
int counter_ = 0; // Contador int counter_ = 0; // Contador
Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
SDL_FPoint dest_; // Posición donde dibujar el logo SDL_FPoint dest_; // Posición donde dibujar el logo
// --- Métodos internos --- // --- Métodos internos ---
void update(); // Actualiza las variables void update(); // Actualiza las variables
void render(); // Dibuja en pantalla void render(); // Dibuja en pantalla
static void checkEvents(); // Comprueba el manejador de eventos static void checkEvents(); // Comprueba el manejador de eventos
static void checkInput(); // Comprueba las entradas static void checkInput(); // Comprueba las entradas
void updateJAILGAMES(); // Gestiona el logo de JAILGAMES void updateJAILGAMES(); // Gestiona el logo de JAILGAMES
void renderJAILGAMES(); // Renderiza el logo de JAILGAMES void renderJAILGAMES(); // Renderiza el logo de JAILGAMES
void updateTextureColors(); // Gestiona el color de las texturas void updateTextureColors(); // Gestiona el color de las texturas
}; };

117
source/sections/title.h
View File

@@ -3,8 +3,8 @@
#include <SDL3/SDL.h> // Para Uint32 #include <SDL3/SDL.h> // Para Uint32
#include <memory> // Para unique_ptr, shared_ptr #include <memory> // Para unique_ptr, shared_ptr
#include <vector>
#include <string_view> #include <string_view>
#include <vector>
#include "section.h" // Para Options #include "section.h" // Para Options
@@ -19,7 +19,6 @@ class TiledBG;
// Textos // Textos
constexpr std::string_view TEXT_COPYRIGHT = "@2020,2025 JailDesigner"; constexpr std::string_view TEXT_COPYRIGHT = "@2020,2025 JailDesigner";
// Parámetros // Parámetros
constexpr bool ALLOW_TITLE_ANIMATION_SKIP = false; constexpr bool ALLOW_TITLE_ANIMATION_SKIP = false;
@@ -31,68 +30,68 @@ constexpr bool ALLOW_TITLE_ANIMATION_SKIP = false;
// Clase Title // Clase Title
class Title { class Title {
public: public:
// --- Constructores y destructor --- // --- Constructores y destructor ---
Title(); Title();
~Title(); ~Title();
// --- Método principal --- // --- Método principal ---
void run(); // Bucle para el título del juego void run(); // Bucle para el título del juego
private: private:
// --- Enumeraciones --- // --- Enumeraciones ---
enum class TitleState { enum class TitleState {
LOGO_ANIMATING, // El logo está animándose LOGO_ANIMATING, // El logo está animándose
LOGO_FINISHED, // El logo ha terminado de animarse LOGO_FINISHED, // El logo ha terminado de animarse
START_HAS_BEEN_PRESSED, // Se ha pulsado el botón de start START_HAS_BEEN_PRESSED, // Se ha pulsado el botón de start
}; };
// --- Estructura para definir anclas --- // --- Estructura para definir anclas ---
struct Anchor { struct Anchor {
int mini_logo; int mini_logo;
int copyright_text; int copyright_text;
}; };
// --- Objetos y punteros --- // --- Objetos y punteros ---
std::shared_ptr<Text> text_; // Objeto de texto para escribir en pantalla std::shared_ptr<Text> text_; // Objeto de texto para escribir en pantalla
std::unique_ptr<Fade> fade_; // Fundido en pantalla std::unique_ptr<Fade> fade_; // Fundido en pantalla
std::unique_ptr<TiledBG> tiled_bg_; // Fondo animado de tiles std::unique_ptr<TiledBG> tiled_bg_; // Fondo animado de tiles
std::unique_ptr<GameLogo> game_logo_; // Logo del juego std::unique_ptr<GameLogo> game_logo_; // Logo del juego
std::unique_ptr<Sprite> mini_logo_sprite_; // Logo JailGames mini std::unique_ptr<Sprite> mini_logo_sprite_; // Logo JailGames mini
std::unique_ptr<DefineButtons> define_buttons_; // Definición de botones del joystick std::unique_ptr<DefineButtons> define_buttons_; // Definición de botones del joystick
std::vector<std::shared_ptr<Player>> players_; // Vector de jugadores std::vector<std::shared_ptr<Player>> players_; // Vector de jugadores
// --- Variables de estado --- // --- Variables de estado ---
int counter_ = 0; // Temporizador para la pantalla de título int counter_ = 0; // Temporizador para la pantalla de título
Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad
Section::Name next_section_; // Siguiente sección a cargar Section::Name next_section_; // Siguiente sección a cargar
Section::Options selection_ = Section::Options::TITLE_TIME_OUT; // Opción elegida en el título Section::Options selection_ = Section::Options::TITLE_TIME_OUT; // Opción elegida en el título
int num_controllers_; // Número de mandos conectados int num_controllers_; // Número de mandos conectados
TitleState state_; // Estado actual de la sección TitleState state_; // Estado actual de la sección
bool should_render_start_prompt_ = false; // Indica si se muestra o no el texto de PRESS START BUTTON TO PLAY bool should_render_start_prompt_ = false; // Indica si se muestra o no el texto de PRESS START BUTTON TO PLAY
bool player1_start_pressed_ = false; // Indica si se ha pulsdo el boton de empezar a jugar para el jugador 1 bool player1_start_pressed_ = false; // Indica si se ha pulsdo el boton de empezar a jugar para el jugador 1
bool player2_start_pressed_ = false; // Indica si se ha pulsdo el boton de empezar a jugar para el jugador 2 bool player2_start_pressed_ = false; // Indica si se ha pulsdo el boton de empezar a jugar para el jugador 2
// -- Variables de diseño --- // -- Variables de diseño ---
Anchor anchor_; // Anclas para definir la posición de los elementos del titulo Anchor anchor_; // Anclas para definir la posición de los elementos del titulo
// --- Métodos internos --- // --- Métodos internos ---
void update(); // Actualiza las variables del objeto void update(); // Actualiza las variables del objeto
void render(); // Dibuja el objeto en pantalla void render(); // Dibuja el objeto en pantalla
void checkEvents(); // Comprueba los eventos void checkEvents(); // Comprueba los eventos
void checkInput(); // Comprueba las entradas void checkInput(); // Comprueba las entradas
void resetCounter(); // Reinicia el contador interno void resetCounter(); // Reinicia el contador interno
void swapControllers(); // Intercambia la asignación de mandos a los jugadores static void swapControllers(); // Intercambia la asignación de mandos a los jugadores
static void swapKeyboard(); // Intercambia el teclado de jugador static void swapKeyboard(); // Intercambia el teclado de jugador
static void showControllers(); // Muestra información sobre los controles y los jugadores static void showControllers(); // Muestra información sobre los controles y los jugadores
void updateFade(); // Actualiza el efecto de fundido (fade in/out) void updateFade(); // Actualiza el efecto de fundido (fade in/out)
void updateState(); // Actualiza el estado actual del título void updateState(); // Actualiza el estado actual del título
void updateStartPrompt(); // Actualiza el mensaje de "Pulsa Start" void updateStartPrompt(); // Actualiza el mensaje de "Pulsa Start"
void renderStartPrompt(); // Dibuja el mensaje de "Pulsa Start" en pantalla void renderStartPrompt(); // Dibuja el mensaje de "Pulsa Start" en pantalla
void renderCopyright(); // Dibuja el aviso de copyright void renderCopyright(); // Dibuja el aviso de copyright
void setState(TitleState state); // Cambia el estado del título void setState(TitleState state); // Cambia el estado del título
void initPlayers(); // Inicializa los jugadores void initPlayers(); // Inicializa los jugadores
void renderPlayers(); // Renderiza los jugadores void renderPlayers(); // Renderiza los jugadores
void updatePlayers(); // Actualza los jugadores void updatePlayers(); // Actualza los jugadores
auto getPlayer(int id) -> std::shared_ptr<Player>; // Obtiene un jugador a partir de su "id" auto getPlayer(int id) -> std::shared_ptr<Player>; // Obtiene un jugador a partir de su "id"
}; };

58
source/smart_sprite.h
View File

@@ -8,38 +8,38 @@ class Texture;
// Clase SmartSprite: Sprite animado que se mueve hacia un destino y puede deshabilitarse automáticamente // Clase SmartSprite: Sprite animado que se mueve hacia un destino y puede deshabilitarse automáticamente
class SmartSprite : public AnimatedSprite { class SmartSprite : public AnimatedSprite {
public: public:
// --- Constructor y destructor --- // --- Constructor y destructor ---
explicit SmartSprite(std::shared_ptr<Texture> texture) explicit SmartSprite(std::shared_ptr<Texture> texture)
: AnimatedSprite(texture) {} : AnimatedSprite(texture) {}
~SmartSprite() override = default; ~SmartSprite() override = default;
// --- Métodos principales --- // --- Métodos principales ---
void update() override; // Actualiza la posición y comprueba si ha llegado a su destino void update() override; // Actualiza la posición y comprueba si ha llegado a su destino
void render() override; // Dibuja el sprite void render() override; // Dibuja el sprite
// --- Getters --- // --- Getters ---
auto getDestX() const -> int { return dest_x_; } // Obtiene la posición de destino en X auto getDestX() const -> int { return dest_x_; } // Obtiene la posición de destino en X
auto getDestY() const -> int { return dest_y_; } // Obtiene la posición de destino en Y auto getDestY() const -> int { return dest_y_; } // Obtiene la posición de destino en Y
auto isOnDestination() const -> bool { return on_destination_; } // Indica si está en el destino auto isOnDestination() const -> bool { return on_destination_; } // Indica si está en el destino
auto hasFinished() const -> bool { return finished_; } // Indica si ya ha terminado auto hasFinished() const -> bool { return finished_; } // Indica si ya ha terminado
// --- Setters --- // --- Setters ---
void setFinishedCounter(int value) { finished_counter_ = value; } // Establece el contador para deshabilitarlo void setFinishedCounter(int value) { finished_counter_ = value; } // Establece el contador para deshabilitarlo
void setDestX(int x) { dest_x_ = x; } // Establece la posición de destino en X void setDestX(int x) { dest_x_ = x; } // Establece la posición de destino en X
void setDestY(int y) { dest_y_ = y; } // Establece la posición de destino en Y void setDestY(int y) { dest_y_ = y; } // Establece la posición de destino en Y
void setEnabled(bool value) { enabled_ = value; } // Habilita o deshabilita el objeto void setEnabled(bool value) { enabled_ = value; } // Habilita o deshabilita el objeto
private: private:
// --- Variables internas --- // --- Variables internas ---
bool on_destination_ = false; // Indica si está en el destino bool on_destination_ = false; // Indica si está en el destino
int dest_x_ = 0; // Posición de destino en el eje X int dest_x_ = 0; // Posición de destino en el eje X
int dest_y_ = 0; // Posición de destino en el eje Y int dest_y_ = 0; // Posición de destino en el eje Y
int finished_counter_ = 0; // Contador para deshabilitarlo int finished_counter_ = 0; // Contador para deshabilitarlo
bool finished_ = false; // Indica si ya ha terminado bool finished_ = false; // Indica si ya ha terminado
bool enabled_ = false; // Indica si el objeto está habilitado bool enabled_ = false; // Indica si el objeto está habilitado
// --- Métodos internos --- // --- Métodos internos ---
void checkFinished(); // Comprueba si ha terminado void checkFinished(); // Comprueba si ha terminado
void checkMove(); // Comprueba el movimiento void checkMove(); // Comprueba el movimiento
}; };

84
source/sprite.h
View File

@@ -8,54 +8,54 @@ class Texture;
// Clase Sprite: representa un objeto gráfico básico con posición, tamaño y textura // Clase Sprite: representa un objeto gráfico básico con posición, tamaño y textura
class Sprite { class Sprite {
public: public:
// --- Constructores y destructor --- // --- Constructores y destructor ---
Sprite(std::shared_ptr<Texture> texture, float pos_x, float pos_y, float width, float height); Sprite(std::shared_ptr<Texture> texture, float pos_x, float pos_y, float width, float height);
Sprite(std::shared_ptr<Texture> texture, SDL_FRect rect); Sprite(std::shared_ptr<Texture> texture, SDL_FRect rect);
explicit Sprite(std::shared_ptr<Texture> texture); explicit Sprite(std::shared_ptr<Texture> texture);
virtual ~Sprite() = default; virtual ~Sprite() = default;
// --- Renderizado y control --- // --- Renderizado y control ---
virtual void render(); // Muestra el sprite por pantalla virtual void render(); // Muestra el sprite por pantalla
virtual void clear(); // Reinicia las variables a cero virtual void clear(); // Reinicia las variables a cero
// --- Getters de posición y tamaño --- // --- Getters de posición y tamaño ---
[[nodiscard]] auto getX() const -> float { return pos_.x; } [[nodiscard]] auto getX() const -> float { return pos_.x; }
[[nodiscard]] auto getY() const -> float { return pos_.y; } [[nodiscard]] auto getY() const -> float { return pos_.y; }
[[nodiscard]] auto getWidth() const -> float { return pos_.w; } [[nodiscard]] auto getWidth() const -> float { return pos_.w; }
[[nodiscard]] auto getHeight() const -> float { return pos_.h; } [[nodiscard]] auto getHeight() const -> float { return pos_.h; }
[[nodiscard]] auto getPosition() const -> SDL_FRect { return pos_; } [[nodiscard]] auto getPosition() const -> SDL_FRect { return pos_; }
auto getRect() -> SDL_FRect& { return pos_; } auto getRect() -> SDL_FRect& { return pos_; }
// --- Setters de posición y tamaño --- // --- Setters de posición y tamaño ---
void setX(float pos_x) { pos_.x = pos_x; } void setX(float pos_x) { pos_.x = pos_x; }
void setY(float pos_y) { pos_.y = pos_y; } void setY(float pos_y) { pos_.y = pos_y; }
void setWidth(float width) { pos_.w = width; } void setWidth(float width) { pos_.w = width; }
void setHeight(float height) { pos_.h = height; } void setHeight(float height) { pos_.h = height; }
void setPosition(float pos_x, float pos_y); void setPosition(float pos_x, float pos_y);
void setPosition(SDL_FPoint point); void setPosition(SDL_FPoint point);
void setPosition(SDL_FRect rect) { pos_ = rect; } void setPosition(SDL_FRect rect) { pos_ = rect; }
// --- Zoom --- // --- Zoom ---
void setZoom(float zoom) { zoom_ = zoom; } void setZoom(float zoom) { zoom_ = zoom; }
// --- Modificación de posición --- // --- Modificación de posición ---
void incX(float value) { pos_.x += value; } void incX(float value) { pos_.x += value; }
void incY(float value) { pos_.y += value; } void incY(float value) { pos_.y += value; }
// --- Sprite clip --- // --- Sprite clip ---
[[nodiscard]] auto getSpriteClip() const -> SDL_FRect { return sprite_clip_; } [[nodiscard]] auto getSpriteClip() const -> SDL_FRect { return sprite_clip_; }
void setSpriteClip(SDL_FRect rect) { sprite_clip_ = rect; } void setSpriteClip(SDL_FRect rect) { sprite_clip_ = rect; }
void setSpriteClip(float pos_x, float pos_y, float width, float height) { sprite_clip_ = SDL_FRect{pos_x, pos_y, width, height}; } void setSpriteClip(float pos_x, float pos_y, float width, float height) { sprite_clip_ = SDL_FRect{pos_x, pos_y, width, height}; }
// --- Textura --- // --- Textura ---
[[nodiscard]] auto getTexture() const -> std::shared_ptr<Texture> { return texture_; } [[nodiscard]] auto getTexture() const -> std::shared_ptr<Texture> { return texture_; }
void setTexture(std::shared_ptr<Texture> texture) { texture_ = texture; } void setTexture(std::shared_ptr<Texture> texture) { texture_ = texture; }
protected: protected:
// --- Variables internas --- // --- Variables internas ---
std::shared_ptr<Texture> texture_; // Textura donde están todos los dibujos del sprite std::shared_ptr<Texture> texture_; // Textura donde están todos los dibujos del sprite
SDL_FRect pos_; // Posición y tamaño donde dibujar el sprite SDL_FRect pos_; // Posición y tamaño donde dibujar el sprite
SDL_FRect sprite_clip_; // Rectángulo de origen de la textura que se dibujará en pantalla SDL_FRect sprite_clip_; // Rectángulo de origen de la textura que se dibujará en pantalla
double zoom_ = 1.0F; // Zoom aplicado a la textura double zoom_ = 1.0F; // Zoom aplicado a la textura
}; };

16
source/stage.h
View File

@@ -10,13 +10,13 @@
namespace Stage { namespace Stage {
// --- Estructura con los datos de una fase --- // --- Estructura con los datos de una fase ---
struct Stage { struct Stage {
int power_to_complete; // Cantidad de poder que se necesita para completar la fase int power_to_complete; // Cantidad de poder que se necesita para completar la fase
int min_menace; // Umbral mínimo de amenaza de la fase int min_menace; // Umbral mínimo de amenaza de la fase
int max_menace; // Umbral máximo de amenaza de la fase int max_menace; // Umbral máximo de amenaza de la fase
// Constructor // Constructor
Stage(int power_to_complete, int min_menace, int max_menace) Stage(int power_to_complete, int min_menace, int max_menace)
: power_to_complete(power_to_complete), min_menace(min_menace), max_menace(max_menace) {} : power_to_complete(power_to_complete), min_menace(min_menace), max_menace(max_menace) {}
}; };
// --- Variables globales del estado de las fases --- // --- Variables globales del estado de las fases ---
@@ -28,6 +28,6 @@ extern bool power_can_be_added; // Indica si se puede añadir poder a la fase
// --- Funciones principales --- // --- Funciones principales ---
auto get(int index) -> Stage; // Devuelve una fase por índice auto get(int index) -> Stage; // Devuelve una fase por índice
void init(); // Inicializa las variables del namespace Stage void init(); // Inicializa las variables del namespace Stage
void addPower(int amount); // Añade poder a la fase actual void addPower(int amount); // Añade poder a la fase actual
} // namespace Stage } // namespace Stage

8
source/tabe.cpp
View File

@@ -4,10 +4,10 @@
#include <SDL3/SDL.h> // Para SDL_FlipMode, SDL_GetTicks #include <SDL3/SDL.h> // Para SDL_FlipMode, SDL_GetTicks
#include <algorithm> // Para max #include <algorithm> // Para max
#include <array> #include <array>
#include <cmath> // Para abs #include <cmath> // Para abs
#include <cstdlib> // Para rand, abs #include <cstdlib> // Para rand, abs
#include <string> // Para basic_string #include <string> // Para basic_string
#include "audio.h" // Para Audio #include "audio.h" // Para Audio
#include "param.h" // Para Param, ParamGame, param #include "param.h" // Para Param, ParamGame, param

202
source/tabe.h
View File

@@ -9,128 +9,128 @@
// --- Enumeraciones para dirección y estado --- // --- Enumeraciones para dirección y estado ---
enum class TabeDirection : int { enum class TabeDirection : int {
TO_THE_LEFT = 0, TO_THE_LEFT = 0,
TO_THE_RIGHT = 1, TO_THE_RIGHT = 1,
}; };
enum class TabeState : int { enum class TabeState : int {
FLY = 0, FLY = 0,
HIT = 1, HIT = 1,
}; };
// --- Estructura para el temporizador del Tabe --- // --- Estructura para el temporizador del Tabe ---
struct TabeTimer { struct TabeTimer {
private: private:
static constexpr Uint32 MINUTES_TO_MILLISECONDS = 60000; // Factor de conversión de minutos a milisegundos static constexpr Uint32 MINUTES_TO_MILLISECONDS = 60000; // Factor de conversión de minutos a milisegundos
public: public:
Uint32 time_until_next_spawn; // Tiempo restante para la próxima aparición Uint32 time_until_next_spawn; // Tiempo restante para la próxima aparición
Uint32 min_spawn_time; // Tiempo mínimo entre apariciones (en milisegundos) Uint32 min_spawn_time; // Tiempo mínimo entre apariciones (en milisegundos)
Uint32 max_spawn_time; // Tiempo máximo entre apariciones (en milisegundos) Uint32 max_spawn_time; // Tiempo máximo entre apariciones (en milisegundos)
Uint32 current_time; // Tiempo actual Uint32 current_time; // Tiempo actual
Uint32 delta_time; // Diferencia de tiempo desde la última actualización Uint32 delta_time; // Diferencia de tiempo desde la última actualización
Uint32 last_time; // Tiempo de la última actualización Uint32 last_time; // Tiempo de la última actualización
bool is_paused{false}; // Indica si el temporizador está pausado bool is_paused{false}; // Indica si el temporizador está pausado
// Constructor - los parámetros min_time y max_time están en mintos // Constructor - los parámetros min_time y max_time están en mintos
TabeTimer(float min_time, float max_time) TabeTimer(float min_time, float max_time)
: min_spawn_time(static_cast<Uint32>(min_time * MINUTES_TO_MILLISECONDS)), : min_spawn_time(static_cast<Uint32>(min_time * MINUTES_TO_MILLISECONDS)),
max_spawn_time(static_cast<Uint32>(max_time * MINUTES_TO_MILLISECONDS)), max_spawn_time(static_cast<Uint32>(max_time * MINUTES_TO_MILLISECONDS)),
current_time(SDL_GetTicks()) { current_time(SDL_GetTicks()) {
reset(); reset();
}
// Restablece el temporizador con un nuevo tiempo hasta la próxima aparición
void reset() {
Uint32 range = max_spawn_time - min_spawn_time;
time_until_next_spawn = min_spawn_time + rand() % (range + 1);
last_time = SDL_GetTicks();
}
// Actualiza el temporizador, decrementando el tiempo hasta la próxima aparición
void update() {
current_time = SDL_GetTicks();
// Solo actualizar si no está pausado
if (!is_paused) {
delta_time = current_time - last_time;
if (time_until_next_spawn > delta_time) {
time_until_next_spawn -= delta_time;
} else {
time_until_next_spawn = 0;
} }
}
// Siempre actualizar last_time para evitar saltos de tiempo al despausar // Restablece el temporizador con un nuevo tiempo hasta la próxima aparición
last_time = current_time; void reset() {
} Uint32 range = max_spawn_time - min_spawn_time;
time_until_next_spawn = min_spawn_time + rand() % (range + 1);
// Pausa o reanuda el temporizador last_time = SDL_GetTicks();
void setPaused(bool paused) {
if (is_paused != paused) {
is_paused = paused;
// Al despausar, actualizar last_time para evitar saltos
if (!paused) {
last_time = SDL_GetTicks();
} }
}
}
// Indica si el temporizador ha finalizado // Actualiza el temporizador, decrementando el tiempo hasta la próxima aparición
[[nodiscard]] auto shouldSpawn() const -> bool { void update() {
return time_until_next_spawn == 0 && !is_paused; current_time = SDL_GetTicks();
}
// Solo actualizar si no está pausado
if (!is_paused) {
delta_time = current_time - last_time;
if (time_until_next_spawn > delta_time) {
time_until_next_spawn -= delta_time;
} else {
time_until_next_spawn = 0;
}
}
// Siempre actualizar last_time para evitar saltos de tiempo al despausar
last_time = current_time;
}
// Pausa o reanuda el temporizador
void setPaused(bool paused) {
if (is_paused != paused) {
is_paused = paused;
// Al despausar, actualizar last_time para evitar saltos
if (!paused) {
last_time = SDL_GetTicks();
}
}
}
// Indica si el temporizador ha finalizado
[[nodiscard]] auto shouldSpawn() const -> bool {
return time_until_next_spawn == 0 && !is_paused;
}
}; };
// --- Clase Tabe --- // --- Clase Tabe ---
class Tabe { class Tabe {
public: public:
// --- Constructores y destructor --- // --- Constructores y destructor ---
Tabe(); Tabe();
~Tabe() = default; ~Tabe() = default;
// --- Métodos principales --- // --- Métodos principales ---
void update(); // Actualiza la lógica void update(); // Actualiza la lógica
void render(); // Dibuja el objeto void render(); // Dibuja el objeto
void enable(); // Habilita el objeto void enable(); // Habilita el objeto
void setState(TabeState state); // Establece el estado void setState(TabeState state); // Establece el estado
auto tryToGetBonus() -> bool; // Intenta obtener el bonus auto tryToGetBonus() -> bool; // Intenta obtener el bonus
void pauseTimer(bool value); // Detiene/activa el timer void pauseTimer(bool value); // Detiene/activa el timer
// --- Getters --- // --- Getters ---
auto getCollider() -> SDL_FRect& { return sprite_->getRect(); } // Obtiene el área de colisión auto getCollider() -> SDL_FRect& { return sprite_->getRect(); } // Obtiene el área de colisión
[[nodiscard]] auto isEnabled() const -> bool { return enabled_; } // Indica si el objeto está activo [[nodiscard]] auto isEnabled() const -> bool { return enabled_; } // Indica si el objeto está activo
private: private:
// --- Constantes --- // --- Constantes ---
static constexpr int WIDTH = 32; static constexpr int WIDTH = 32;
static constexpr int HEIGHT = 32; static constexpr int HEIGHT = 32;
// --- Objetos y punteros --- // --- Objetos y punteros ---
std::unique_ptr<AnimatedSprite> sprite_; // Sprite con los gráficos y animaciones std::unique_ptr<AnimatedSprite> sprite_; // Sprite con los gráficos y animaciones
// --- Variables de estado --- // --- Variables de estado ---
float x_ = 0; // Posición X float x_ = 0; // Posición X
float y_ = 0; // Posición Y float y_ = 0; // Posición Y
float speed_ = 0.0F; // Velocidad de movimiento float speed_ = 0.0F; // Velocidad de movimiento
float accel_ = 0.0F; // Aceleración float accel_ = 0.0F; // Aceleración
int fly_distance_ = 0; // Distancia de vuelo int fly_distance_ = 0; // Distancia de vuelo
int waiting_counter_ = 0; // Tiempo que pasa quieto int waiting_counter_ = 0; // Tiempo que pasa quieto
bool enabled_ = false; // Indica si el objeto está activo bool enabled_ = false; // Indica si el objeto está activo
TabeDirection direction_ = TabeDirection::TO_THE_LEFT; // Dirección actual TabeDirection direction_ = TabeDirection::TO_THE_LEFT; // Dirección actual
TabeDirection destiny_ = TabeDirection::TO_THE_LEFT; // Destino TabeDirection destiny_ = TabeDirection::TO_THE_LEFT; // Destino
TabeState state_ = TabeState::FLY; // Estado actual TabeState state_ = TabeState::FLY; // Estado actual
int hit_counter_ = 0; // Contador para el estado HIT int hit_counter_ = 0; // Contador para el estado HIT
int number_of_hits_ = 0; // Cantidad de disparos recibidos int number_of_hits_ = 0; // Cantidad de disparos recibidos
bool has_bonus_ = true; // Indica si aún tiene el bonus para soltar bool has_bonus_ = true; // Indica si aún tiene el bonus para soltar
TabeTimer timer_; // Temporizador para gestionar la aparición TabeTimer timer_; // Temporizador para gestionar la aparición
// --- Métodos internos --- // --- Métodos internos ---
void move(); // Mueve el objeto void move(); // Mueve el objeto
void shiftSprite() { sprite_->setPos(x_, y_); } // Actualiza la posición del sprite void shiftSprite() { sprite_->setPos(x_, y_); } // Actualiza la posición del sprite
void setRandomFlyPath(TabeDirection direction, int lenght); // Establece un vuelo aleatorio void setRandomFlyPath(TabeDirection direction, int lenght); // Establece un vuelo aleatorio
void updateState(); // Actualiza el estado void updateState(); // Actualiza el estado
void updateTimer(); // Actualiza el temporizador void updateTimer(); // Actualiza el temporizador
void disable(); // Deshabilita el objeto void disable(); // Deshabilita el objeto
}; };

2
source/texture.cpp
View File

@@ -243,7 +243,7 @@ auto Texture::loadSurface(const std::string &file_path) -> std::shared_ptr<Surfa
// Si el constructor de Surface espera un std::shared_ptr<Uint8[]>: // Si el constructor de Surface espera un std::shared_ptr<Uint8[]>:
size_t pixel_count = raw_pixels.size(); size_t pixel_count = raw_pixels.size();
auto pixels = std::shared_ptr<Uint8[]>(new Uint8[pixel_count], std::default_delete<Uint8[]>()); // NOLINT(modernize-avoid-c-arrays) auto pixels = std::shared_ptr<Uint8[]>(new Uint8[pixel_count], std::default_delete<Uint8[]>()); // NOLINT(modernize-avoid-c-arrays)
std::memcpy(pixels.get(), raw_pixels.data(), pixel_count); std::memcpy(pixels.get(), raw_pixels.data(), pixel_count);
auto surface = std::make_shared<Surface>(w, h, pixels); auto surface = std::make_shared<Surface>(w, h, pixels);

98
source/texture.h
View File

@@ -16,66 +16,66 @@ using Palette = std::array<Uint32, 256>;
// Definición de Surface para imágenes con paleta // Definición de Surface para imágenes con paleta
struct Surface { struct Surface {
std::shared_ptr<Uint8[]> data; // NOLINT(modernize-avoid-c-arrays) std::shared_ptr<Uint8[]> data; // NOLINT(modernize-avoid-c-arrays)
Uint16 w, h; Uint16 w, h;
// Constructor // Constructor
Surface(Uint16 width, Uint16 height, std::shared_ptr<Uint8[]> pixels) // NOLINT(modernize-avoid-c-arrays) Surface(Uint16 width, Uint16 height, std::shared_ptr<Uint8[]> pixels) // NOLINT(modernize-avoid-c-arrays)
: data(std::move(pixels)), w(width), h(height) {} : data(std::move(pixels)), w(width), h(height) {}
}; };
// Clase Texture: gestiona texturas, paletas y renderizado // Clase Texture: gestiona texturas, paletas y renderizado
class Texture { class Texture {
public: public:
// --- Constructores y destructor --- // --- Constructores y destructor ---
explicit Texture(SDL_Renderer *renderer, std::string path = std::string()); explicit Texture(SDL_Renderer *renderer, std::string path = std::string());
~Texture(); ~Texture();
// --- Carga y creación --- // --- Carga y creación ---
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
// --- Renderizado --- // --- Renderizado ---
void render(int x, int 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(int x, int 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 setAsRenderTarget(SDL_Renderer *renderer); // Establece la textura como objetivo de renderizado void setAsRenderTarget(SDL_Renderer *renderer); // Establece la textura como objetivo de renderizado
// --- Modificadores de color y blending --- // --- Modificadores de color y blending ---
void setColor(Uint8 red, Uint8 green, Uint8 blue); // Establece el color para la modulación void setColor(Uint8 red, Uint8 green, Uint8 blue); // Establece el color para la modulación
void setColor(Color color); // Establece el color para la modulación void setColor(Color color); // Establece el color para la modulación
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
// --- Paletas --- // --- Paletas ---
void addPaletteFromGifFile(const std::string &path); // Añade una paleta a la lista void addPaletteFromGifFile(const std::string &path); // Añade una paleta a la lista
void addPaletteFromPalFile(const std::string &path); // Añade una paleta a la lista void addPaletteFromPalFile(const std::string &path); // Añade una paleta a la lista
void setPaletteColor(int palette, int index, Uint32 color); // Establece un color de la paleta void setPaletteColor(int palette, int index, Uint32 color); // Establece un color de la paleta
void setPalette(size_t palette); // Cambia la paleta de la textura void setPalette(size_t palette); // Cambia la paleta de la textura
// --- Getters --- // --- Getters ---
[[nodiscard]] auto getWidth() const -> int; // Obtiene el ancho de la imagen [[nodiscard]] auto getWidth() const -> int; // Obtiene el ancho de la imagen
[[nodiscard]] auto getHeight() const -> int; // Obtiene el alto de la imagen [[nodiscard]] auto getHeight() const -> int; // Obtiene el alto de la imagen
auto getSDLTexture() -> SDL_Texture *; // Obtiene la textura SDL auto getSDLTexture() -> SDL_Texture *; // Obtiene la textura SDL
auto getRenderer() -> SDL_Renderer *; // Obtiene el renderizador auto getRenderer() -> SDL_Renderer *; // Obtiene el renderizador
private: private:
// --- Objetos y punteros --- // --- Objetos y punteros ---
SDL_Renderer *renderer_; // Renderizador donde dibujar la textura SDL_Renderer *renderer_; // Renderizador donde dibujar la textura
SDL_Texture *texture_ = nullptr; // La textura SDL_Texture *texture_ = nullptr; // La textura
std::shared_ptr<Surface> surface_ = nullptr; // Surface para usar imágenes en formato gif con paleta std::shared_ptr<Surface> surface_ = nullptr; // Surface para usar imágenes en formato gif con paleta
// --- Variables --- // --- Variables ---
std::string path_; // Ruta de la imagen de la textura std::string path_; // Ruta de la imagen de la textura
int width_ = 0; // Ancho de la imagen int width_ = 0; // Ancho de la imagen
int height_ = 0; // Alto de la imagen int height_ = 0; // Alto de la imagen
std::vector<Palette> palettes_; // Vector con las diferentes paletas std::vector<Palette> palettes_; // Vector con las diferentes paletas
int current_palette_ = 0; // Índice de la paleta en uso int current_palette_ = 0; // Índice de la paleta en uso
// --- Métodos internos --- // --- Métodos internos ---
auto loadSurface(const std::string &file_name) -> std::shared_ptr<Surface>; // Crea una surface desde un fichero .gif auto loadSurface(const std::string &file_name) -> std::shared_ptr<Surface>; // Crea una surface desde un fichero .gif
void flipSurface(); // Vuelca la surface en la textura void flipSurface(); // Vuelca la surface en la textura
static auto loadPaletteFromFile(const std::string &file_name) -> Palette; // Carga una paleta desde un fichero static auto loadPaletteFromFile(const std::string &file_name) -> Palette; // Carga una paleta desde un fichero
void unloadTexture(); // Libera la memoria de la textura void unloadTexture(); // Libera la memoria de la textura
void unloadSurface(); // Libera la surface actual void unloadSurface(); // Libera la surface actual
static auto readPalFile(const std::string &file_path) -> Palette; // Carga una paleta desde un archivo .pal static auto readPalFile(const std::string &file_path) -> Palette; // Carga una paleta desde un archivo .pal
}; };

65
source/tiled_bg.h
View File

@@ -1,6 +1,7 @@
#pragma once #pragma once
#include <SDL3/SDL.h> // Para SDL_FRect, SDL_SetTextureColorMod, SDL_Renderer, SDL_Texture #include <SDL3/SDL.h> // Para SDL_FRect, SDL_SetTextureColorMod, SDL_Renderer, SDL_Texture
#include <array> #include <array>
#include "utils.h" // Para Color #include "utils.h" // Para Color
@@ -21,43 +22,43 @@ enum class TiledBGMode : int {
// Clase TiledBG // Clase TiledBG
class TiledBG { class TiledBG {
public: public:
// --- Constructores y destructor --- // --- Constructores y destructor ---
TiledBG(SDL_FRect pos, TiledBGMode mode); TiledBG(SDL_FRect pos, TiledBGMode mode);
~TiledBG(); ~TiledBG();
// --- Métodos principales --- // --- Métodos principales ---
void render(); // Pinta la clase en pantalla void render(); // Pinta la clase en pantalla
void update(); // Actualiza la lógica de la clase void update(); // Actualiza la lógica de la clase
// --- Configuración --- // --- Configuración ---
void setSpeed(float speed) { speed_ = speed; } // Establece la velocidad void setSpeed(float speed) { speed_ = speed; } // Establece la velocidad
void stopGracefully() { stopping_ = true; } // Detiene el desplazamiento de forma ordenada void stopGracefully() { stopping_ = true; } // Detiene el desplazamiento de forma ordenada
void setColor(Color color) { SDL_SetTextureColorMod(canvas_, color.r, color.g, color.b); } // Cambia el color de la textura void setColor(Color color) { SDL_SetTextureColorMod(canvas_, color.r, color.g, color.b); } // Cambia el color de la textura
// --- Getters --- // --- Getters ---
[[nodiscard]] auto isStopped() const -> bool { return speed_ == 0.0F; } // Indica si está parado [[nodiscard]] auto isStopped() const -> bool { return speed_ == 0.0F; } // Indica si está parado
private: private:
// --- Constantes --- // --- Constantes ---
static constexpr int TILE_WIDTH = 64; // Ancho del tile static constexpr int TILE_WIDTH = 64; // Ancho del tile
static constexpr int TILE_HEIGHT = 64; // Alto del tile static constexpr int TILE_HEIGHT = 64; // Alto del tile
// --- Objetos y punteros --- // --- Objetos y punteros ---
SDL_Renderer *renderer_; // El renderizador de la ventana SDL_Renderer *renderer_; // El renderizador de la ventana
SDL_Texture *canvas_; // Textura donde dibujar el fondo formado por tiles SDL_Texture *canvas_; // Textura donde dibujar el fondo formado por tiles
// --- Variables de estado --- // --- Variables de estado ---
SDL_FRect pos_; // Posición y tamaño del mosaico SDL_FRect pos_; // Posición y tamaño del mosaico
SDL_FRect window_; // Ventana visible para la textura de fondo del título SDL_FRect window_; // Ventana visible para la textura de fondo del título
TiledBGMode mode_; // Tipo de movimiento del mosaico TiledBGMode mode_; // Tipo de movimiento del mosaico
std::array<double, 360> sin_; // Vector con los valores del seno precalculados std::array<double, 360> sin_; // Vector con los valores del seno precalculados
float desp_ = 0.0F; // Desplazamiento aplicado float desp_ = 0.0F; // Desplazamiento aplicado
float speed_ = 1.0F; // Incremento que se añade al desplazamiento a cada bucle float speed_ = 1.0F; // Incremento que se añade al desplazamiento a cada bucle
bool stopping_ = false; // Indica si se está deteniendo bool stopping_ = false; // Indica si se está deteniendo
// --- Métodos internos --- // --- Métodos internos ---
void fillTexture(); // Rellena la textura con el contenido void fillTexture(); // Rellena la textura con el contenido
void updateDesp() { desp_ += speed_; } // Actualiza el desplazamiento void updateDesp() { desp_ += speed_; } // Actualiza el desplazamiento
void updateStop(); // Detiene el desplazamiento de forma ordenada void updateStop(); // Detiene el desplazamiento de forma ordenada
}; };

232
source/ui/menu_option.h
View File

@@ -15,161 +15,161 @@
// --- Interfaz Base para todas las Opciones del Menú --- // --- Interfaz Base para todas las Opciones del Menú ---
class MenuOption { class MenuOption {
public: public:
enum class Behavior { enum class Behavior {
ADJUST, ADJUST,
SELECT SELECT
}; };
MenuOption(std::string caption, ServiceMenu::SettingsGroup group, bool hidden = false) MenuOption(std::string caption, ServiceMenu::SettingsGroup group, bool hidden = false)
: caption_(std::move(caption)), group_(group), hidden_(hidden) {} : caption_(std::move(caption)), group_(group), hidden_(hidden) {}
virtual ~MenuOption() = default; virtual ~MenuOption() = default;
[[nodiscard]] auto getCaption() const -> const std::string & { return caption_; } [[nodiscard]] auto getCaption() const -> const std::string & { return caption_; }
[[nodiscard]] auto getGroup() const -> ServiceMenu::SettingsGroup { return group_; } [[nodiscard]] auto getGroup() const -> ServiceMenu::SettingsGroup { return group_; }
[[nodiscard]] auto isHidden() const -> bool { return hidden_; } [[nodiscard]] auto isHidden() const -> bool { return hidden_; }
void setHidden(bool hidden) { hidden_ = hidden; } void setHidden(bool hidden) { hidden_ = hidden; }
[[nodiscard]] virtual auto getBehavior() const -> Behavior = 0; [[nodiscard]] virtual auto getBehavior() const -> Behavior = 0;
[[nodiscard]] virtual auto getValueAsString() const -> std::string { return ""; } [[nodiscard]] virtual auto getValueAsString() const -> std::string { return ""; }
virtual void adjustValue(bool adjust_up) {} virtual void adjustValue(bool adjust_up) {}
[[nodiscard]] virtual auto getTargetGroup() const -> ServiceMenu::SettingsGroup { return ServiceMenu::SettingsGroup::MAIN; } [[nodiscard]] virtual auto getTargetGroup() const -> ServiceMenu::SettingsGroup { return ServiceMenu::SettingsGroup::MAIN; }
virtual void executeAction() {} virtual void executeAction() {}
// Método virtual para que cada opción calcule el ancho de su valor más largo. // Método virtual para que cada opción calcule el ancho de su valor más largo.
virtual auto getMaxValueWidth(Text *text_renderer) const -> int { return 0; } virtual auto getMaxValueWidth(Text *text_renderer) const -> int { return 0; }
protected: protected:
std::string caption_; std::string caption_;
ServiceMenu::SettingsGroup group_; ServiceMenu::SettingsGroup group_;
bool hidden_; bool hidden_;
}; };
// --- Clases Derivadas --- // --- Clases Derivadas ---
class BoolOption : public MenuOption { class BoolOption : public MenuOption {
public: public:
BoolOption(const std::string &cap, ServiceMenu::SettingsGroup grp, bool *var) BoolOption(const std::string &cap, ServiceMenu::SettingsGroup grp, bool *var)
: MenuOption(cap, grp), linked_variable_(var) {} : MenuOption(cap, grp), linked_variable_(var) {}
[[nodiscard]] auto getBehavior() const -> Behavior override { return Behavior::ADJUST; } [[nodiscard]] auto getBehavior() const -> Behavior override { return Behavior::ADJUST; }
[[nodiscard]] auto getValueAsString() const -> std::string override { [[nodiscard]] auto getValueAsString() const -> std::string override {
return *linked_variable_ ? Lang::getText("[SERVICE_MENU] ON") : Lang::getText("[SERVICE_MENU] OFF"); return *linked_variable_ ? Lang::getText("[SERVICE_MENU] ON") : Lang::getText("[SERVICE_MENU] OFF");
} }
void adjustValue(bool /*adjust_up*/) override { void adjustValue(bool /*adjust_up*/) override {
*linked_variable_ = !*linked_variable_; *linked_variable_ = !*linked_variable_;
} }
auto getMaxValueWidth(Text *text_renderer) const -> int override { auto getMaxValueWidth(Text *text_renderer) const -> int override {
return std::max( return std::max(
text_renderer->lenght(Lang::getText("[SERVICE_MENU] ON"), -2), text_renderer->lenght(Lang::getText("[SERVICE_MENU] ON"), -2),
text_renderer->lenght(Lang::getText("[SERVICE_MENU] OFF"), -2)); text_renderer->lenght(Lang::getText("[SERVICE_MENU] OFF"), -2));
} }
private: private:
bool *linked_variable_; bool *linked_variable_;
}; };
class IntOption : public MenuOption { class IntOption : public MenuOption {
public: public:
IntOption(const std::string &cap, ServiceMenu::SettingsGroup grp, int *var, int min, int max, int step) IntOption(const std::string &cap, ServiceMenu::SettingsGroup grp, int *var, int min, int max, int step)
: MenuOption(cap, grp), linked_variable_(var), min_value_(min), max_value_(max), step_value_(step) {} : MenuOption(cap, grp), linked_variable_(var), min_value_(min), max_value_(max), step_value_(step) {}
[[nodiscard]] auto getBehavior() const -> Behavior override { return Behavior::ADJUST; } [[nodiscard]] auto getBehavior() const -> Behavior override { return Behavior::ADJUST; }
[[nodiscard]] auto getValueAsString() const -> std::string override { return std::to_string(*linked_variable_); } [[nodiscard]] auto getValueAsString() const -> std::string override { return std::to_string(*linked_variable_); }
void adjustValue(bool adjust_up) override { void adjustValue(bool adjust_up) override {
int new_value = *linked_variable_ + (adjust_up ? step_value_ : -step_value_); int new_value = *linked_variable_ + (adjust_up ? step_value_ : -step_value_);
*linked_variable_ = std::clamp(new_value, min_value_, max_value_); *linked_variable_ = std::clamp(new_value, min_value_, max_value_);
} }
auto getMaxValueWidth(Text *text_renderer) const -> int override { auto getMaxValueWidth(Text *text_renderer) const -> int override {
int max_width = 0; int max_width = 0;
// Iterar por todos los valores posibles en el rango // Iterar por todos los valores posibles en el rango
for (int value = min_value_; value <= max_value_; value += step_value_) { for (int value = min_value_; value <= max_value_; value += step_value_) {
int width = text_renderer->lenght(std::to_string(value), -2); int width = text_renderer->lenght(std::to_string(value), -2);
max_width = std::max(max_width, width); max_width = std::max(max_width, width);
}
return max_width;
} }
return max_width; private:
} int *linked_variable_;
int min_value_, max_value_, step_value_;
private:
int *linked_variable_;
int min_value_, max_value_, step_value_;
}; };
class ListOption : public MenuOption { class ListOption : public MenuOption {
public: public:
ListOption(const std::string &cap, ServiceMenu::SettingsGroup grp, std::vector<std::string> values, std::function<std::string()> current_value_getter, std::function<void(const std::string &)> new_value_setter) ListOption(const std::string &cap, ServiceMenu::SettingsGroup grp, std::vector<std::string> values, std::function<std::string()> current_value_getter, std::function<void(const std::string &)> new_value_setter)
: MenuOption(cap, grp), : MenuOption(cap, grp),
value_list_(std::move(values)), value_list_(std::move(values)),
getter_(std::move(current_value_getter)), getter_(std::move(current_value_getter)),
setter_(std::move(new_value_setter)) { setter_(std::move(new_value_setter)) {
sync(); sync();
} }
void sync() { void sync() {
std::string current_value = getter_(); std::string current_value = getter_();
for (size_t i = 0; i < value_list_.size(); ++i) { for (size_t i = 0; i < value_list_.size(); ++i) {
if (value_list_[i] == current_value) { if (value_list_[i] == current_value) {
list_index_ = i; list_index_ = i;
return; return;
}
} }
} }
}
[[nodiscard]] auto getBehavior() const -> Behavior override { return Behavior::ADJUST; } [[nodiscard]] auto getBehavior() const -> Behavior override { return Behavior::ADJUST; }
[[nodiscard]] auto getValueAsString() const -> std::string override { [[nodiscard]] auto getValueAsString() const -> std::string override {
return value_list_.empty() ? "" : value_list_[list_index_]; return value_list_.empty() ? "" : value_list_[list_index_];
}
void adjustValue(bool adjust_up) override {
if (value_list_.empty()) {
return;
} }
size_t size = value_list_.size(); void adjustValue(bool adjust_up) override {
list_index_ = (adjust_up) ? (list_index_ + 1) % size if (value_list_.empty()) {
: (list_index_ + size - 1) % size; return;
setter_(value_list_[list_index_]); }
} size_t size = value_list_.size();
auto getMaxValueWidth(Text *text_renderer) const -> int override { list_index_ = (adjust_up) ? (list_index_ + 1) % size
int max_w = 0; : (list_index_ + size - 1) % size;
for (const auto &val : value_list_) { setter_(value_list_[list_index_]);
max_w = std::max(max_w, text_renderer->lenght(val, -2)); }
auto getMaxValueWidth(Text *text_renderer) const -> int override {
int max_w = 0;
for (const auto &val : value_list_) {
max_w = std::max(max_w, text_renderer->lenght(val, -2));
}
return max_w;
} }
return max_w;
}
private: private:
std::vector<std::string> value_list_; std::vector<std::string> value_list_;
std::function<std::string()> getter_; std::function<std::string()> getter_;
std::function<void(const std::string &)> setter_; std::function<void(const std::string &)> setter_;
size_t list_index_{0}; size_t list_index_{0};
}; };
class FolderOption : public MenuOption { class FolderOption : public MenuOption {
public: public:
FolderOption(const std::string &cap, ServiceMenu::SettingsGroup grp, ServiceMenu::SettingsGroup target) FolderOption(const std::string &cap, ServiceMenu::SettingsGroup grp, ServiceMenu::SettingsGroup target)
: MenuOption(cap, grp), target_group_(target) {} : MenuOption(cap, grp), target_group_(target) {}
[[nodiscard]] auto getBehavior() const -> Behavior override { return Behavior::SELECT; } [[nodiscard]] auto getBehavior() const -> Behavior override { return Behavior::SELECT; }
[[nodiscard]] auto getTargetGroup() const -> ServiceMenu::SettingsGroup override { return target_group_; } [[nodiscard]] auto getTargetGroup() const -> ServiceMenu::SettingsGroup override { return target_group_; }
private: private:
ServiceMenu::SettingsGroup target_group_; ServiceMenu::SettingsGroup target_group_;
}; };
class ActionOption : public MenuOption { class ActionOption : public MenuOption {
public: public:
ActionOption(const std::string &cap, ServiceMenu::SettingsGroup grp, std::function<void()> action, bool hidden = false) ActionOption(const std::string &cap, ServiceMenu::SettingsGroup grp, std::function<void()> action, bool hidden = false)
: MenuOption(cap, grp, hidden), action_(std::move(action)) {} : MenuOption(cap, grp, hidden), action_(std::move(action)) {}
[[nodiscard]] auto getBehavior() const -> Behavior override { return Behavior::SELECT; } [[nodiscard]] auto getBehavior() const -> Behavior override { return Behavior::SELECT; }
void executeAction() override { void executeAction() override {
if (action_) { if (action_) {
action_(); action_();
}
} }
}
private: private:
std::function<void()> action_; std::function<void()> action_;
}; };

164
source/ui/service_menu.h
View File

@@ -12,98 +12,98 @@ class MenuOption;
class MenuRenderer; // <-- Nuevo class MenuRenderer; // <-- Nuevo
class ServiceMenu { class ServiceMenu {
public: public:
enum class SettingsGroup { enum class SettingsGroup {
VIDEO, VIDEO,
AUDIO, AUDIO,
SETTINGS, SETTINGS,
SYSTEM, SYSTEM,
MAIN MAIN
}; };
enum class GroupAlignment { enum class GroupAlignment {
CENTERED, CENTERED,
LEFT LEFT
}; };
// --- Constantes públicas que el Renderer podría necesitar --- // --- Constantes públicas que el Renderer podría necesitar ---
static constexpr size_t OPTIONS_HORIZONTAL_PADDING = 20; static constexpr size_t OPTIONS_HORIZONTAL_PADDING = 20;
static constexpr size_t MIN_WIDTH = 240; static constexpr size_t MIN_WIDTH = 240;
static constexpr size_t MIN_GAP_OPTION_VALUE = 30; static constexpr size_t MIN_GAP_OPTION_VALUE = 30;
// --- Métodos de singleton --- // --- Métodos de singleton ---
static void init(); static void init();
static void destroy(); static void destroy();
static auto get() -> ServiceMenu *; static auto get() -> ServiceMenu *;
ServiceMenu(const ServiceMenu &) = delete; ServiceMenu(const ServiceMenu &) = delete;
auto operator=(const ServiceMenu &) -> ServiceMenu & = delete; auto operator=(const ServiceMenu &) -> ServiceMenu & = delete;
// --- Métodos principales --- // --- Métodos principales ---
void toggle(); void toggle();
void render(); void render();
void update(); void update();
void reset(); void reset();
// --- Lógica de navegación --- // --- Lógica de navegación ---
void setSelectorUp(); void setSelectorUp();
void setSelectorDown(); void setSelectorDown();
void adjustOption(bool adjust_up); void adjustOption(bool adjust_up);
void selectOption(); void selectOption();
void moveBack(); void moveBack();
// --- Getters para que el Renderer pueda leer el estado --- // --- Getters para que el Renderer pueda leer el estado ---
[[nodiscard]] auto isEnabled() const -> bool { return enabled_; } [[nodiscard]] auto isEnabled() const -> bool { return enabled_; }
[[nodiscard]] auto getTitle() const -> const std::string & { return title_; } [[nodiscard]] auto getTitle() const -> const std::string & { return title_; }
[[nodiscard]] auto getCurrentGroup() const -> SettingsGroup { return current_settings_group_; } [[nodiscard]] auto getCurrentGroup() const -> SettingsGroup { return current_settings_group_; }
[[nodiscard]] auto getCurrentGroupAlignment() const -> GroupAlignment; [[nodiscard]] auto getCurrentGroupAlignment() const -> GroupAlignment;
[[nodiscard]] auto getDisplayOptions() const -> const std::vector<MenuOption *> & { return display_options_; } [[nodiscard]] auto getDisplayOptions() const -> const std::vector<MenuOption *> & { return display_options_; }
[[nodiscard]] auto getAllOptions() const -> const std::vector<std::unique_ptr<MenuOption>> & { return options_; } [[nodiscard]] auto getAllOptions() const -> const std::vector<std::unique_ptr<MenuOption>> & { return options_; }
[[nodiscard]] auto getSelectedIndex() const -> size_t { return selected_; } [[nodiscard]] auto getSelectedIndex() const -> size_t { return selected_; }
[[nodiscard]] auto getOptionPairs() const -> const std::vector<std::pair<std::string, std::string>> & { return option_pairs_; } [[nodiscard]] auto getOptionPairs() const -> const std::vector<std::pair<std::string, std::string>> & { return option_pairs_; }
[[nodiscard]] auto countOptionsInGroup(SettingsGroup group) const -> size_t; [[nodiscard]] auto countOptionsInGroup(SettingsGroup group) const -> size_t;
private: private:
// --- Lógica de estado del menú (Modelo) --- // --- Lógica de estado del menú (Modelo) ---
bool enabled_ = false; bool enabled_ = false;
std::vector<std::unique_ptr<MenuOption>> options_; std::vector<std::unique_ptr<MenuOption>> options_;
std::vector<MenuOption *> display_options_; std::vector<MenuOption *> display_options_;
std::vector<std::pair<std::string, std::string>> option_pairs_; std::vector<std::pair<std::string, std::string>> option_pairs_;
SettingsGroup current_settings_group_; SettingsGroup current_settings_group_;
SettingsGroup previous_settings_group_; SettingsGroup previous_settings_group_;
std::string title_; std::string title_;
size_t selected_ = 0; size_t selected_ = 0;
size_t main_menu_selected_ = 0; size_t main_menu_selected_ = 0;
// --- Mensaje de reinicio --- // --- Mensaje de reinicio ---
std::unique_ptr<UIMessage> restart_message_ui_; std::unique_ptr<UIMessage> restart_message_ui_;
bool last_pending_changes_ = false; bool last_pending_changes_ = false;
// --- La Vista --- // --- La Vista ---
std::unique_ptr<MenuRenderer> renderer_; std::unique_ptr<MenuRenderer> renderer_;
// --- Métodos de lógica interna --- // --- Métodos de lógica interna ---
void updateDisplayOptions(); void updateDisplayOptions();
void updateOptionPairs(); void updateOptionPairs();
void initializeOptions(); void initializeOptions();
void updateMenu(); void updateMenu();
void applySettings(); void applySettings();
void applyVideoSettings(); void applyVideoSettings();
static void applyAudioSettings(); static void applyAudioSettings();
void applySettingsSettings(); void applySettingsSettings();
[[nodiscard]] auto getOptionByCaption(const std::string &caption) const -> MenuOption *; [[nodiscard]] auto getOptionByCaption(const std::string &caption) const -> MenuOption *;
void adjustListValues(); void adjustListValues();
static void playMoveSound(); static void playMoveSound();
static void playAdjustSound(); static void playAdjustSound();
static void playSelectSound(); static void playSelectSound();
static void playBackSound(); static void playBackSound();
[[nodiscard]] static auto settingsGroupToString(SettingsGroup group) -> std::string; [[nodiscard]] static auto settingsGroupToString(SettingsGroup group) -> std::string;
void setHiddenOptions(); void setHiddenOptions();
// --- Constructores y destructor privados (singleton) --- // --- Constructores y destructor privados (singleton) ---
ServiceMenu(); ServiceMenu();
~ServiceMenu() = default; ~ServiceMenu() = default;
// --- Instancia singleton --- // --- Instancia singleton ---
static ServiceMenu *instance; static ServiceMenu *instance;
}; };

4
source/ui/ui_message.cpp
View File

@@ -15,7 +15,7 @@ void UIMessage::show() {
return; // Ya está visible y quieto return; // Ya está visible y quieto
} }
start_y_ = DESP; // Empieza 8 píxeles arriba de la posición base start_y_ = DESP; // Empieza 8 píxeles arriba de la posición base
target_y_ = 0.0F; // La posición final es la base target_y_ = 0.0F; // La posición final es la base
y_offset_ = start_y_; y_offset_ = start_y_;
anim_step_ = 0; anim_step_ = 0;
@@ -30,7 +30,7 @@ void UIMessage::hide() {
} }
start_y_ = y_offset_; // Comienza desde la posición actual start_y_ = y_offset_; // Comienza desde la posición actual
target_y_ = DESP; // Termina 8 píxeles arriba de la base target_y_ = DESP; // Termina 8 píxeles arriba de la base
anim_step_ = 0; anim_step_ = 0;
animating_ = true; animating_ = true;
} }

68
source/ui/ui_message.h
View File

@@ -9,48 +9,48 @@ class Text;
// Clase para mostrar mensajes animados en la interfaz de usuario // Clase para mostrar mensajes animados en la interfaz de usuario
class UIMessage { class UIMessage {
public: public:
// Constructor: recibe el renderizador de texto, el mensaje y el color // Constructor: recibe el renderizador de texto, el mensaje y el color
UIMessage(std::shared_ptr<Text> text_renderer, std::string message_text, const Color &color); UIMessage(std::shared_ptr<Text> text_renderer, std::string message_text, const Color &color);
// Muestra el mensaje con animación de entrada // Muestra el mensaje con animación de entrada
void show(); void show();
// Oculta el mensaje con animación de salida // Oculta el mensaje con animación de salida
void hide(); void hide();
// Actualiza el estado de la animación (debe llamarse cada frame) // Actualiza el estado de la animación (debe llamarse cada frame)
void update(); void update();
// Dibuja el mensaje en pantalla si está visible // Dibuja el mensaje en pantalla si está visible
void render(); void render();
// Indica si el mensaje está visible actualmente // Indica si el mensaje está visible actualmente
[[nodiscard]] auto isVisible() const -> bool; [[nodiscard]] auto isVisible() const -> bool;
// Permite actualizar la posición del mensaje (por ejemplo, si el menú se mueve) // Permite actualizar la posición del mensaje (por ejemplo, si el menú se mueve)
void setPosition(float new_base_x, float new_base_y); void setPosition(float new_base_x, float new_base_y);
private: private:
// --- Configuración --- // --- Configuración ---
std::shared_ptr<Text> text_renderer_; // Renderizador de texto std::shared_ptr<Text> text_renderer_; // Renderizador de texto
std::string text_; // Texto del mensaje a mostrar std::string text_; // Texto del mensaje a mostrar
Color color_; // Color del texto Color color_; // Color del texto
// --- Estado --- // --- Estado ---
bool visible_ = false; // Indica si el mensaje está visible bool visible_ = false; // Indica si el mensaje está visible
bool animating_ = false; // Indica si el mensaje está en proceso de animación bool animating_ = false; // Indica si el mensaje está en proceso de animación
float base_x_ = 0.0F; // Posición X base donde se muestra el mensaje float base_x_ = 0.0F; // Posición X base donde se muestra el mensaje
float base_y_ = 0.0F; // Posición Y base donde se muestra el mensaje float base_y_ = 0.0F; // Posición Y base donde se muestra el mensaje
float y_offset_ = 0.0F; // Desplazamiento vertical actual del mensaje (para animación) float y_offset_ = 0.0F; // Desplazamiento vertical actual del mensaje (para animación)
// --- Animación --- // --- Animación ---
float start_y_ = 0.0F; // Posición Y inicial de la animación float start_y_ = 0.0F; // Posición Y inicial de la animación
float target_y_ = 0.0F; // Posición Y objetivo de la animación float target_y_ = 0.0F; // Posición Y objetivo de la animación
int anim_step_ = 0; // Paso actual de la animación int anim_step_ = 0; // Paso actual de la animación
static constexpr int ANIMATION_STEPS = 8; // Número total de pasos de la animación static constexpr int ANIMATION_STEPS = 8; // Número total de pasos de la animación
static constexpr float DESP = -8.0F; // Distancia a desplazarse static constexpr float DESP = -8.0F; // Distancia a desplazarse
// Actualiza la interpolación de la animación (ease out/in cubic) // Actualiza la interpolación de la animación (ease out/in cubic)
void updateAnimation(); void updateAnimation();
}; };

6
source/utils.cpp
View File

@@ -235,7 +235,7 @@ auto easeInElastic(double time) -> double {
if (time == 0) { if (time == 0) {
return 0; return 0;
} }
if (time == 1) { if (time == 1) {
return 1; return 1;
} }
@@ -266,11 +266,11 @@ auto easeOutElastic(double time) -> double {
if (time == 0) { if (time == 0) {
return 0; return 0;
} }
if (time == 1) { if (time == 1) {
return 1; return 1;
} }
const double C4 = (2 * M_PI) / 3; // Constante para controlar la elasticidad const double C4 = (2 * M_PI) / 3; // Constante para controlar la elasticidad
return pow(2, -10 * time) * sin((time * 10 - 0.75) * C4) + 1; return pow(2, -10 * time) * sin((time * 10 - 0.75) * C4) + 1;
} }

78
source/writer.h
View File

@@ -8,51 +8,51 @@ class Text;
// Clase Writer. Pinta texto en pantalla letra a letra a partir de una cadena y un objeto Text // Clase Writer. Pinta texto en pantalla letra a letra a partir de una cadena y un objeto Text
class Writer { class Writer {
public: public:
// Constructor // Constructor
explicit Writer(std::shared_ptr<Text> text) explicit Writer(std::shared_ptr<Text> text)
: text_(std::move(text)) {} : text_(std::move(text)) {}
// Destructor // Destructor
~Writer() = default; ~Writer() = default;
// Actualiza el objeto // Actualiza el objeto
void update(); void update();
// Dibuja el objeto en pantalla // Dibuja el objeto en pantalla
void render() const; void render() const;
// Setters // Setters
void setPosX(int value); // Establece la posición X void setPosX(int value); // Establece la posición X
void setPosY(int value); // Establece la posición Y void setPosY(int value); // Establece la posición Y
void setKerning(int value); // Establece el kerning (espaciado entre caracteres) void setKerning(int value); // Establece el kerning (espaciado entre caracteres)
void setCaption(const std::string &text); // Establece el texto a escribir void setCaption(const std::string &text); // Establece el texto a escribir
void setSpeed(int value); // Establece la velocidad de escritura void setSpeed(int value); // Establece la velocidad de escritura
void setEnabled(bool value); // Habilita o deshabilita el objeto void setEnabled(bool value); // Habilita o deshabilita el objeto
void setFinishedCounter(int time); // Establece el temporizador para deshabilitar el objeto void setFinishedCounter(int time); // Establece el temporizador para deshabilitar el objeto
// Centra la cadena de texto a un punto X // Centra la cadena de texto a un punto X
void center(int x); void center(int x);
// Getters // Getters
[[nodiscard]] auto isEnabled() const -> bool; // Indica si el objeto está habilitado [[nodiscard]] auto isEnabled() const -> bool; // Indica si el objeto está habilitado
[[nodiscard]] auto hasFinished() const -> bool; // Indica si ya ha terminado [[nodiscard]] auto hasFinished() const -> bool; // Indica si ya ha terminado
private: private:
// --- Objetos y punteros --- // --- Objetos y punteros ---
std::shared_ptr<Text> text_; // Objeto encargado de escribir el texto std::shared_ptr<Text> text_; // Objeto encargado de escribir el texto
// --- Variables de estado --- // --- Variables de estado ---
int pos_x_ = 0; // Posición en el eje X donde empezar a escribir el texto int pos_x_ = 0; // Posición en el eje X donde empezar a escribir el texto
int pos_y_ = 0; // Posición en el eje Y donde empezar a escribir el texto int pos_y_ = 0; // Posición en el eje Y donde empezar a escribir el texto
int kerning_ = 0; // Kerning del texto, es decir, espaciado entre caracteres int kerning_ = 0; // Kerning del texto, es decir, espaciado entre caracteres
std::string caption_; // El texto para escribir std::string caption_; // El texto para escribir
int speed_ = 0; // Velocidad de escritura int speed_ = 0; // Velocidad de escritura
int writing_counter_ = 0; // Temporizador de escritura para cada caracter int writing_counter_ = 0; // Temporizador de escritura para cada caracter
int index_ = 0; // Posición del texto que se está escribiendo int index_ = 0; // Posición del texto que se está escribiendo
int lenght_ = 0; // Longitud de la cadena a escribir int lenght_ = 0; // Longitud de la cadena a escribir
bool completed_ = false; // Indica si se ha escrito todo el texto bool completed_ = false; // Indica si se ha escrito todo el texto
bool enabled_ = false; // Indica si el objeto está habilitado bool enabled_ = false; // Indica si el objeto está habilitado
int enabled_counter_ = 0; // Temporizador para deshabilitar el objeto int enabled_counter_ = 0; // Temporizador para deshabilitar el objeto
bool finished_ = false; // Indica si ya ha terminado bool finished_ = false; // Indica si ya ha terminado
}; };