From 677e4d465d15ec337b530fcbf4ebd7b20dab3679 Mon Sep 17 00:00:00 2001 From: Sergio Valor Date: Tue, 27 May 2025 13:58:51 +0200 Subject: [PATCH] reestructurat background, balloon_formations i balloon_manager --- source/background.h | 217 +++++++++++++++--------------------- source/balloon_formations.h | 25 +++-- source/balloon_manager.h | 164 +++++++++++---------------- 3 files changed, 167 insertions(+), 239 deletions(-) diff --git a/source/background.h b/source/background.h index 09d7b72..9248763 100644 --- a/source/background.h +++ b/source/background.h @@ -6,149 +6,106 @@ #include // Para unique_ptr, shared_ptr #include // Para vector #include "utils.h" // Para Color -class MovingSprite; // lines 10-10 -class Sprite; // lines 11-11 -class Texture; // lines 12-12 +class MovingSprite; +class Sprite; +class Texture; /* - Esta clase es la encargada de dibujar el fondo que aparece durante la sección - jugable. + Esta clase gestiona el fondo que aparece en la sección jugable. - Utiliza una textura donde compone la imagen y luego tiene una textura superior - rellena de un color sólido cuya opacidad se puede modificar. + Usa una textura compuesta y una capa superior con un color sólido cuya opacidad es ajustable. + Su área total está definida por "rect", pero solo se pinta la región "srcRect" en la pantalla en "dstRect". - El objeto tiene un tamaño total definido en la variable "rect". En principio este - tamaño coincide con el tamaño de la ventana o resolución del juego, pero se pinta - solo el rectangulo definido en srcRect en la posición de la pantalla definida en - dstRect. - - Ambos rectangulos han de coincidir en tamaño y por definición, el punto comun es el inferior derecho el rectangulo. - - Utiliza varios métodos para definir su comportamiento: - - setCloudsSpeed(float value) - Velocidad a la que se desplazan las nubes cada frame - - - setGradientNumber(int value) - Escoge el índice de la textura de fondo a usar (el color del cielo) - - - setTransition(float value) - Porcentaje (entre 0.0f (textura actual) y 1.0f (textura siguiente)) para mostrar entre la textura de fondo actual y la siguiente - - - setColor(Color color) - Establece el color de la textura de superposición - - - setAlpha(int alpha) - Establece la transparencia de la textura de superposición + Métodos clave: + - setCloudsSpeed(float value) -> Define la velocidad de las nubes + - setGradientNumber(int value) -> Ajusta el índice del color de cielo + - setTransition(float value) -> Configura la transición entre texturas + - setColor(Color color) -> Aplica un color de atenuación + - setAlpha(int alpha) -> Ajusta la transparencia de la capa de atenuación */ - -// Clase Background class Background { +public: + // Constructor y Destructor + Background(); + ~Background(); + + // Actualización y renderizado + void update(); // Actualiza la lógica del objeto + void render(); // Dibuja el objeto + + // Configuración de posición + void setPos(SDL_FRect pos); // Establece la posición del objeto + + // Configuración de animaciones y efectos + void setCloudsSpeed(float value); // Ajusta la velocidad de desplazamiento de las nubes + void setGradientNumber(int value); // Establece el degradado de fondo a usar + void setTransition(float value); // Ajusta la transición entre texturas de fondo + + // Configuración de efectos visuales + void setColor(Color color); // Establece el color de atenuación + void setAlpha(int alpha); // Ajusta la transparencia del fondo + + // Configuración del sol y la luna + void setSunProgression(float progress); // Establece la posición del sol + void setMoonProgression(float progress); // Establece la posición de la luna + private: // Objetos y punteros - SDL_Renderer *renderer_; // El renderizador de la ventana + SDL_Renderer *renderer_; // Renderizador de la ventana - std::shared_ptr buildings_texture_; // Textura con los edificios de fondo - std::shared_ptr top_clouds_texture_; // Textura con las nubes de fondo - std::shared_ptr bottom_clouds_texture_; // Textura con las nubes de fondo - std::shared_ptr grass_texture_; // Textura con la hierba del suelo - std::shared_ptr gradients_texture_; // Textura con los diferentes colores de fondo del juego - std::shared_ptr sun_texture_; // Textura con el sol - std::shared_ptr moon_texture_; // Textura con la luna + // Texturas + std::shared_ptr buildings_texture_; + std::shared_ptr top_clouds_texture_; + std::shared_ptr bottom_clouds_texture_; + std::shared_ptr grass_texture_; + std::shared_ptr gradients_texture_; + std::shared_ptr sun_texture_; + std::shared_ptr moon_texture_; - std::unique_ptr top_clouds_sprite_a_; // Sprite para las nubes superiores - std::unique_ptr top_clouds_sprite_b_; // Sprite para las nubes superiores - std::unique_ptr bottom_clouds_sprite_a_; // Sprite para las nubes inferiores - std::unique_ptr bottom_clouds_sprite_b_; // Sprite para las nubes inferiores - - std::unique_ptr buildings_sprite_; // Sprite con los edificios de fondo - std::unique_ptr gradient_sprite_; // Sprite con los graficos del degradado de color de fondo - std::unique_ptr grass_sprite_; // Sprite para la hierba - std::unique_ptr sun_sprite_; // Sprite para el sol - std::unique_ptr moon_sprite_; // Sprite para la luna + // Sprites + std::unique_ptr top_clouds_sprite_a_; + std::unique_ptr top_clouds_sprite_b_; + std::unique_ptr bottom_clouds_sprite_a_; + std::unique_ptr bottom_clouds_sprite_b_; + std::unique_ptr buildings_sprite_; + std::unique_ptr gradient_sprite_; + std::unique_ptr grass_sprite_; + std::unique_ptr sun_sprite_; + std::unique_ptr moon_sprite_; + // Buffers de renderizado SDL_Texture *canvas_; // Textura para componer el fondo SDL_Texture *color_texture_; // Textura para atenuar el fondo - // Variables - SDL_FRect gradient_rect_[4]; // Vector con las coordenadas de los 4 degradados para el cielo - SDL_FRect top_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de arriba - SDL_FRect bottom_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de abajo - int gradient_number_ = 0; // Indica el número de degradado de fondo que se va a dibujar - int alpha_ = 0; // Transparencia entre los dos degradados - float clouds_speed_ = 0; // Velocidad a la que se desplazan las nubes - float transition_ = 0; // Nivel de transición del fondo 0..1 - int counter_ = 0; // Contador interno - SDL_FRect rect_; // Tamaño del objeto fondo - SDL_FRect src_rect_; // Parte del objeto fondo que se va a dibujará en pantalla - SDL_FRect dst_rect_; // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla - int base_; // Linea de fondo coincidente con el area inferior de la zona de juego - Color attenuate_color_; // Color para atenuar el fondo - int alpha_color_text_; // Alpha para atenuar el fondo - int alpha_color_text_temp_; // Valor temporal para hacer la transición de alpha - std::vector sun_path_; // Vector con el recorrido del sol - std::vector moon_path_; // Vector con el recorrido de la luna - size_t sun_index_ = 0; // Posición del vector del recorrido del sol - size_t moon_index_ = 0; // Posición del vector del recorrido de la luna + // Variables de control + SDL_FRect gradient_rect_[4]; + SDL_FRect top_clouds_rect_[4]; + SDL_FRect bottom_clouds_rect_[4]; + int gradient_number_ = 0; + int alpha_ = 0; + float clouds_speed_ = 0; + float transition_ = 0; + int counter_ = 0; + SDL_FRect rect_; + SDL_FRect src_rect_; + SDL_FRect dst_rect_; + int base_; + Color attenuate_color_; + int alpha_color_text_; + int alpha_color_text_temp_; + std::vector sun_path_; + std::vector moon_path_; + size_t sun_index_ = 0; + size_t moon_index_ = 0; - // Dibuja el gradiente de fondo - void renderGradient(); - - // Dibuja las nubes de arriba - void renderTopClouds(); - - // Dibuja las nubes de abajo - void renderBottomClouds(); - - // Compone todos los elementos del fondo en la textura - void fillCanvas(); - - // Actualiza el valor de alpha - void updateAlphaColorTexture(); - - // Actualiza las nubes - void updateClouds(); - - // Precalcula el vector con el recorrido del sol - void createSunPath(); - - // Precalcula el vector con el recorrido de la luna - void createMoonPath(); - -public: - // Constructor - Background(); - - // Destructor - ~Background(); - - // Actualiza la lógica del objeto - void update(); - - // Dibuja el objeto - void render(); - - // Establece la posición del objeto - void setPos(SDL_FRect pos); - - // Ajusta el valor de la variable - void setCloudsSpeed(float value); - - // Ajusta el valor de la variable - void setGradientNumber(int value); - - // Ajusta el valor de la variable - void setTransition(float value); - - // Establece el color de atenuación - void setColor(Color color); - - // Establece la transparencia de la atenuación - void setAlpha(int alpha); - - // Establece la posición del sol - void setSunProgression(float progress); - - // Establece la posición de la luna - void setMoonProgression(float progress); -}; \ No newline at end of file + // Métodos internos + void renderGradient(); // Dibuja el gradiente de fondo + void renderTopClouds(); // Dibuja las nubes superiores + void renderBottomClouds(); // Dibuja las nubes inferiores + void fillCanvas(); // Compone todos los elementos en la textura + void updateAlphaColorTexture(); // Actualiza el alpha de la textura de atenuación + void updateClouds(); // Actualiza el movimiento de las nubes + void createSunPath(); // Precalcula el recorrido del sol + void createMoonPath(); // Precalcula el recorrido de la luna +}; diff --git a/source/balloon_formations.h b/source/balloon_formations.h index 4bb082b..c28c635 100644 --- a/source/balloon_formations.h +++ b/source/balloon_formations.h @@ -3,11 +3,13 @@ #include "balloon.h" // Para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE #include +// Constantes de configuración constexpr int NUMBER_OF_BALLOON_FORMATIONS = 100; constexpr int MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION = 50; constexpr int NUMBER_OF_SETS_PER_POOL = 10; constexpr int NUMBER_OF_STAGES = 10; +// Estructuras de datos struct BalloonFormationParams { int x = 0; // Posición en el eje X donde crear el globo @@ -30,28 +32,19 @@ struct BalloonFormationUnit int number_of_balloons; // Cantidad de globos que forman la formación std::vector init; // Vector con todas las inicializaciones de los globos de la formación - // Constructor + // Constructor con parámetros BalloonFormationUnit(int num_balloons, const std::vector &init_params) : number_of_balloons(num_balloons), init(init_params) {} - // Default constructor + // Constructor por defecto BalloonFormationUnit() : number_of_balloons(0), init() {} }; using BalloonFormationPool = std::vector; +// Clase BalloonFormations class BalloonFormations { -private: - std::vector balloon_formation_; // Vector con todas las formaciones enemigas - std::vector balloon_formation_pool_; // Variable con los diferentes conjuntos de formaciones enemigas - - // Inicializa las formaciones enemigas - void initBalloonFormations(); - - // Inicializa los conjuntos de formaciones - void initBalloonFormationPools(); - public: // Constructor BalloonFormations() @@ -67,4 +60,12 @@ public: const BalloonFormationPool &getPool(int pool) { return balloon_formation_pool_.at(pool); } const BalloonFormationUnit &getSet(int pool, int set) { return *balloon_formation_pool_.at(pool).at(set); } const BalloonFormationUnit &getSet(int set) const { return balloon_formation_.at(set); } + +private: + std::vector balloon_formation_; // Vector con todas las formaciones enemigas + std::vector balloon_formation_pool_; // Conjuntos de formaciones enemigas + + // Métodos internos de inicialización + void initBalloonFormations(); + void initBalloonFormationPools(); }; diff --git a/source/balloon_manager.h b/source/balloon_manager.h index 9cc1b4e..f317933 100644 --- a/source/balloon_manager.h +++ b/source/balloon_manager.h @@ -9,122 +9,92 @@ #include "explosions.h" // Para Explosions #include "param.h" // Para Param, ParamGame, param #include "utils.h" // Para Zone -class Texture; // lines 10-10 +class Texture; using Balloons = std::vector>; +// Clase BalloonManager class BalloonManager { -private: - Balloons balloons_; // Vector con los globos - std::unique_ptr explosions_; // Objeto para dibujar explosiones - std::unique_ptr balloon_formations_; // Objeto para gestionar las oleadas enemigas - - std::vector> balloon_textures_; // Vector con las texturas de los globos - std::vector> explosions_textures_; // Vector con las texturas de las explosiones - - std::vector> balloon_animations_; // Vector con las animaciones de los globos - std::vector> explosions_animations_; // Vector con las animaciones de las explosiones - - float balloon_speed_ = BALLOON_SPEED[0]; // Velocidad a la que se mueven los enemigos - float default_balloon_speed_ = BALLOON_SPEED[0]; // Velocidad base de los enemigos, sin incrementar - int balloon_deploy_counter_ = 0; // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero - bool power_ball_enabled_ = false; // Indica si hay una powerball ya activa - int power_ball_counter_ = 0; // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra - int last_balloon_deploy_ = 0; // Guarda cual ha sido la última formación desplegada para no repetir; - SDL_FRect play_area_ = param.game.play_area.rect; // Zona por donde se moveran los globos - bool creation_time_enabled_ = true; // Indica si los globos se crean con tiempo - bool can_deploy_balloons_ = true; // Indica si creará globos - - // Inicializa - void init(); - public: - // Constructor + // Constructor y Destructor BalloonManager(); - - // Destructor ~BalloonManager() = default; - // Actualiza - void update(); + // Actualización y Renderizado + void update(); // Actualiza el estado de los globos + void render(); // Renderiza los globos en pantalla - // Renderiza los globos - void render(); + // Gestión de globos + void freeBalloons(); // Libera globos que ya no sirven - // Vacia del vector de globos los globos que ya no sirven - void freeBalloons(); + // Creación de formaciones enemigas + 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, int y); // Crea una formación específica con coordenadas - // Crea una formación de enemigos al azar - void deployBalloonFormation(int stage); + // Creación de globos + std::shared_ptr createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int creation_timer); // Crea un nuevo globo + void createChildBalloon(const std::shared_ptr &balloon, const std::string &direction); // Crea un globo a partir de otro + void createPowerBall(); // Crea una PowerBall + void createTwoBigBalloons(); // Crea dos globos grandes + void createRandomBalloons(); // Crea una disposición aleatoria de globos - // Crea una formación de enemigos específica - void deploySet(int set); - void deploySet(int set, int y); + // Control de velocidad y despliegue + void setBalloonSpeed(float speed); // Ajusta la velocidad de los globos + 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 updateBalloonDeployCounter(); // Actualiza el contador de despliegue + bool canPowerBallBeCreated(); // Indica si se puede crear una PowerBall + int calculateScreenPower(); // Calcula el poder de los globos en pantalla - // Actualiza la variable enemyDeployCounter - void updateBalloonDeployCounter(); + // Manipulación de globos existentes + int popBalloon(std::shared_ptr balloon); // Explosiona un globo, creando otros si aplica + int destroyBalloon(std::shared_ptr &balloon); // Explosiona un globo sin crear otros + int destroyAllBalloons(); // Destruye todos los globos + void stopAllBalloons(); // Detiene el movimiento de los globos + void startAllBalloons(); // Reactiva el movimiento de los globos - // Indica si se puede crear una powerball - bool canPowerBallBeCreated(); + // Cambios de apariencia + void reverseColorsToAllBalloons(); // Invierte los colores de los globos + void normalColorsToAllBalloons(); // Restaura los colores originales - // Calcula el poder actual de los globos en pantalla - int calculateScreenPower(); + // Configuración de sonido + void setSounds(bool value); // Activa o desactiva los sonidos de los globos - // Crea un globo nuevo en el vector de globos - std::shared_ptr createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int creation_timer); + // Configuración 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 setDeployBalloons(bool value) { can_deploy_balloons_ = value; }; // Activa o desactiva la generación de globos - // Crea un globo a partir de otro globo - void createChildBalloon(const std::shared_ptr &balloon, const std::string &direction); - - // Crea una PowerBall - void createPowerBall(); - - // Establece la velocidad de los globos - void setBalloonSpeed(float speed); - - // Explosiona un globo. Lo destruye y crea otros dos si es el caso - int popBalloon(std::shared_ptr balloon); - - // Explosiona un globo. Lo destruye = no crea otros globos - int destroyBalloon(std::shared_ptr &balloon); - - // Destruye todos los globos - int destroyAllBalloons(); - - // Detiene todos los globos - void stopAllBalloons(); - - // Pone en marcha todos los globos - void startAllBalloons(); - - // Cambia el color de todos los globos - void reverseColorsToAllBalloons(); - - // Cambia el color de todos los globos - void normalColorsToAllBalloons(); - - // Crea dos globos gordos - void createTwoBigBalloons(); - - // Crea una disposición de globos aleatoria - void createRandomBalloons(); - - // Obtiene el nivel de ameza actual generado por los globos - int getMenace(); - - // Establece el sonido de los globos - void setSounds(bool value); - - // Getters + // Obtención de información + int getMenace(); // Obtiene el nivel de amenaza generado por los globos float getBalloonSpeed() const { return balloon_speed_; } Balloons &getBalloons() { return balloons_; } int getNumBalloons() const { return balloons_.size(); } - // Setters - void setDefaultBalloonSpeed(float speed) { default_balloon_speed_ = speed; } - void resetBalloonSpeed() { setBalloonSpeed(default_balloon_speed_); } - void setPlayArea(SDL_FRect play_area) { play_area_ = play_area; } - void setCreationTimeEnabled(bool value) { creation_time_enabled_ = value; } - void setDeployBalloons(bool value) { can_deploy_balloons_ = value; } -}; \ No newline at end of file +private: + Balloons balloons_; // Vector con los globos activos + std::unique_ptr explosions_; // Objeto para gestionar explosiones + std::unique_ptr balloon_formations_; // Objeto para manejar formaciones enemigas + + std::vector> balloon_textures_; // Texturas de los globos + std::vector> explosions_textures_; // Texturas de explosiones + + std::vector> balloon_animations_; // Animaciones de los globos + std::vector> explosions_animations_; // Animaciones de las explosiones + + // Variables de control de globos + float balloon_speed_ = BALLOON_SPEED[0]; + float default_balloon_speed_ = BALLOON_SPEED[0]; + int balloon_deploy_counter_ = 0; + bool power_ball_enabled_ = false; + int power_ball_counter_ = 0; + int last_balloon_deploy_ = 0; + SDL_FRect play_area_ = param.game.play_area.rect; + bool creation_time_enabled_ = true; + bool can_deploy_balloons_ = true; + + // Inicialización interna + void init(); +};