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

reestructurat background, balloon_formations i balloon_manager

Browse Source
This commit is contained in:
Sergio
2025-05-27 13:58:51 +02:00
parent ada141cb09
commit 677e4d465d
3 changed files with 167 additions and 239 deletions
Download Patch File Download Diff File Expand all files Collapse all files

217
source/background.h
View File

@@ -6,149 +6,106 @@
#include <memory> // Para unique_ptr, shared_ptr #include <memory> // Para unique_ptr, shared_ptr
#include <vector> // Para vector #include <vector> // Para vector
#include "utils.h" // Para Color #include "utils.h" // Para Color
class MovingSprite; // lines 10-10 class MovingSprite;
class Sprite; // lines 11-11 class Sprite;
class Texture; // lines 12-12 class Texture;
/* /*
Esta clase es la encargada de dibujar el fondo que aparece durante la sección Esta clase gestiona el fondo que aparece en la sección jugable.
jugable.
Utiliza una textura donde compone la imagen y luego tiene una textura superior Usa una textura compuesta y una capa superior con un color sólido cuya opacidad es ajustable.
rellena de un color sólido cuya opacidad se puede modificar. 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 Métodos clave:
tamaño coincide con el tamaño de la ventana o resolución del juego, pero se pinta - setCloudsSpeed(float value) -> Define la velocidad de las nubes
solo el rectangulo definido en srcRect en la posición de la pantalla definida en - setGradientNumber(int value) -> Ajusta el índice del color de cielo
dstRect. - setTransition(float value) -> Configura la transición entre texturas
- setColor(Color color) -> Aplica un color de atenuación
Ambos rectangulos han de coincidir en tamaño y por definición, el punto comun es el inferior derecho el rectangulo. - setAlpha(int alpha) -> Ajusta la transparencia de la capa de atenuación
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
*/ */
// Clase Background
class 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: private:
// Objetos y punteros // Objetos y punteros
SDL_Renderer *renderer_; // El renderizador de la ventana SDL_Renderer *renderer_; // Renderizador de la ventana
std::shared_ptr<Texture> buildings_texture_; // Textura con los edificios de fondo // Texturas
std::shared_ptr<Texture> top_clouds_texture_; // Textura con las nubes de fondo std::shared_ptr<Texture> buildings_texture_;
std::shared_ptr<Texture> bottom_clouds_texture_; // Textura con las nubes de fondo std::shared_ptr<Texture> top_clouds_texture_;
std::shared_ptr<Texture> grass_texture_; // Textura con la hierba del suelo std::shared_ptr<Texture> bottom_clouds_texture_;
std::shared_ptr<Texture> gradients_texture_; // Textura con los diferentes colores de fondo del juego std::shared_ptr<Texture> grass_texture_;
std::shared_ptr<Texture> sun_texture_; // Textura con el sol std::shared_ptr<Texture> gradients_texture_;
std::shared_ptr<Texture> moon_texture_; // Textura con la luna std::shared_ptr<Texture> sun_texture_;
std::shared_ptr<Texture> moon_texture_;
std::unique_ptr<MovingSprite> top_clouds_sprite_a_; // Sprite para las nubes superiores // Sprites
std::unique_ptr<MovingSprite> top_clouds_sprite_b_; // Sprite para las nubes superiores std::unique_ptr<MovingSprite> top_clouds_sprite_a_;
std::unique_ptr<MovingSprite> bottom_clouds_sprite_a_; // Sprite para las nubes inferiores std::unique_ptr<MovingSprite> top_clouds_sprite_b_;
std::unique_ptr<MovingSprite> bottom_clouds_sprite_b_; // Sprite para las nubes inferiores std::unique_ptr<MovingSprite> bottom_clouds_sprite_a_;
std::unique_ptr<MovingSprite> bottom_clouds_sprite_b_;
std::unique_ptr<Sprite> buildings_sprite_; // Sprite con los edificios de fondo std::unique_ptr<Sprite> buildings_sprite_;
std::unique_ptr<Sprite> gradient_sprite_; // Sprite con los graficos del degradado de color de fondo std::unique_ptr<Sprite> gradient_sprite_;
std::unique_ptr<Sprite> grass_sprite_; // Sprite para la hierba std::unique_ptr<Sprite> grass_sprite_;
std::unique_ptr<Sprite> sun_sprite_; // Sprite para el sol std::unique_ptr<Sprite> sun_sprite_;
std::unique_ptr<Sprite> moon_sprite_; // Sprite para la luna std::unique_ptr<Sprite> moon_sprite_;
// Buffers de renderizado
SDL_Texture *canvas_; // Textura para componer el fondo SDL_Texture *canvas_; // Textura para componer el fondo
SDL_Texture *color_texture_; // Textura para atenuar el fondo SDL_Texture *color_texture_; // Textura para atenuar el fondo
// Variables // Variables de control
SDL_FRect gradient_rect_[4]; // Vector con las coordenadas de los 4 degradados para el cielo SDL_FRect gradient_rect_[4];
SDL_FRect top_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de arriba SDL_FRect top_clouds_rect_[4];
SDL_FRect bottom_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de abajo SDL_FRect bottom_clouds_rect_[4];
int gradient_number_ = 0; // Indica el número de degradado de fondo que se va a dibujar int gradient_number_ = 0;
int alpha_ = 0; // Transparencia entre los dos degradados int alpha_ = 0;
float clouds_speed_ = 0; // Velocidad a la que se desplazan las nubes float clouds_speed_ = 0;
float transition_ = 0; // Nivel de transición del fondo 0..1 float transition_ = 0;
int counter_ = 0; // Contador interno int counter_ = 0;
SDL_FRect rect_; // Tamaño del objeto fondo SDL_FRect rect_;
SDL_FRect src_rect_; // Parte del objeto fondo que se va a dibujará en pantalla SDL_FRect src_rect_;
SDL_FRect dst_rect_; // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla SDL_FRect dst_rect_;
int base_; // Linea de fondo coincidente con el area inferior de la zona de juego int base_;
Color attenuate_color_; // Color para atenuar el fondo Color attenuate_color_;
int alpha_color_text_; // Alpha para atenuar el fondo int alpha_color_text_;
int alpha_color_text_temp_; // Valor temporal para hacer la transición de alpha int alpha_color_text_temp_;
std::vector<SDL_FPoint> sun_path_; // Vector con el recorrido del sol std::vector<SDL_FPoint> sun_path_;
std::vector<SDL_FPoint> moon_path_; // Vector con el recorrido de la luna std::vector<SDL_FPoint> moon_path_;
size_t sun_index_ = 0; // Posición del vector del recorrido del sol size_t sun_index_ = 0;
size_t moon_index_ = 0; // Posición del vector del recorrido de la luna size_t moon_index_ = 0;
// Dibuja el gradiente de fondo // Métodos internos
void renderGradient(); void renderGradient(); // Dibuja el gradiente de fondo
void renderTopClouds(); // Dibuja las nubes superiores
// Dibuja las nubes de arriba void renderBottomClouds(); // Dibuja las nubes inferiores
void renderTopClouds(); void fillCanvas(); // Compone todos los elementos en la textura
void updateAlphaColorTexture(); // Actualiza el alpha de la textura de atenuación
// Dibuja las nubes de abajo void updateClouds(); // Actualiza el movimiento de las nubes
void renderBottomClouds(); void createSunPath(); // Precalcula el recorrido del sol
void createMoonPath(); // Precalcula el recorrido de la luna
// 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);
};

25
source/balloon_formations.h
View File

@@ -3,11 +3,13 @@
#include "balloon.h" // Para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE #include "balloon.h" // Para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
#include <vector> #include <vector>
// Constantes de configuración
constexpr int NUMBER_OF_BALLOON_FORMATIONS = 100; constexpr int NUMBER_OF_BALLOON_FORMATIONS = 100;
constexpr int MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION = 50; constexpr int MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION = 50;
constexpr int NUMBER_OF_SETS_PER_POOL = 10; constexpr int NUMBER_OF_SETS_PER_POOL = 10;
constexpr int NUMBER_OF_STAGES = 10; constexpr int NUMBER_OF_STAGES = 10;
// 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
@@ -30,28 +32,19 @@ 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 // 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) {}
// Default constructor // Constructor por defecto
BalloonFormationUnit() : number_of_balloons(0), init() {} BalloonFormationUnit() : number_of_balloons(0), init() {}
}; };
using BalloonFormationPool = std::vector<const BalloonFormationUnit *>; using BalloonFormationPool = std::vector<const BalloonFormationUnit *>;
// Clase BalloonFormations
class BalloonFormations class BalloonFormations
{ {
private:
std::vector<BalloonFormationUnit> balloon_formation_; // Vector con todas las formaciones enemigas
std::vector<BalloonFormationPool> 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: public:
// Constructor // Constructor
BalloonFormations() BalloonFormations()
@@ -67,4 +60,12 @@ public:
const BalloonFormationPool &getPool(int pool) { return balloon_formation_pool_.at(pool); } 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 pool, int set) { return *balloon_formation_pool_.at(pool).at(set); }
const BalloonFormationUnit &getSet(int set) const { return balloon_formation_.at(set); } const BalloonFormationUnit &getSet(int set) const { return balloon_formation_.at(set); }
private:
std::vector<BalloonFormationUnit> balloon_formation_; // Vector con todas las formaciones enemigas
std::vector<BalloonFormationPool> balloon_formation_pool_; // Conjuntos de formaciones enemigas
// Métodos internos de inicialización
void initBalloonFormations();
void initBalloonFormationPools();
}; };

164
source/balloon_manager.h
View File

@@ -9,122 +9,92 @@
#include "explosions.h" // Para Explosions #include "explosions.h" // Para Explosions
#include "param.h" // Para Param, ParamGame, param #include "param.h" // Para Param, ParamGame, param
#include "utils.h" // Para Zone #include "utils.h" // Para Zone
class Texture; // lines 10-10 class Texture;
using Balloons = std::vector<std::shared_ptr<Balloon>>; using Balloons = std::vector<std::shared_ptr<Balloon>>;
// Clase BalloonManager
class BalloonManager class BalloonManager
{ {
private:
Balloons balloons_; // Vector con los globos
std::unique_ptr<Explosions> explosions_; // Objeto para dibujar explosiones
std::unique_ptr<BalloonFormations> balloon_formations_; // Objeto para gestionar las oleadas enemigas
std::vector<std::shared_ptr<Texture>> balloon_textures_; // Vector con las texturas de los globos
std::vector<std::shared_ptr<Texture>> explosions_textures_; // Vector con las texturas de las explosiones
std::vector<std::vector<std::string>> balloon_animations_; // Vector con las animaciones de los globos
std::vector<std::vector<std::string>> 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: public:
// Constructor // Constructor y Destructor
BalloonManager(); BalloonManager();
// Destructor
~BalloonManager() = default; ~BalloonManager() = default;
// Actualiza // Actualización y Renderizado
void update(); void update(); // Actualiza el estado de los globos
void render(); // Renderiza los globos en pantalla
// Renderiza los globos // Gestión de globos
void render(); void freeBalloons(); // Libera globos que ya no sirven
// Vacia del vector de globos los globos que ya no sirven // Creación de formaciones enemigas
void freeBalloons(); 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 // Creación de globos
void deployBalloonFormation(int stage); std::shared_ptr<Balloon> 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> &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 // Control de velocidad y despliegue
void deploySet(int set); void setBalloonSpeed(float speed); // Ajusta la velocidad de los globos
void deploySet(int set, int y); 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 // Manipulación de globos existentes
void updateBalloonDeployCounter(); int popBalloon(std::shared_ptr<Balloon> balloon); // Explosiona un globo, creando otros si aplica
int destroyBalloon(std::shared_ptr<Balloon> &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 // Cambios de apariencia
bool canPowerBallBeCreated(); void reverseColorsToAllBalloons(); // Invierte los colores de los globos
void normalColorsToAllBalloons(); // Restaura los colores originales
// Calcula el poder actual de los globos en pantalla // Configuración de sonido
int calculateScreenPower(); void setSounds(bool value); // Activa o desactiva los sonidos de los globos
// Crea un globo nuevo en el vector de globos // Configuración de juego
std::shared_ptr<Balloon> createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int creation_timer); 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 // Obtención de información
void createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction); int getMenace(); // Obtiene el nivel de amenaza generado por los globos
// 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> balloon);
// Explosiona un globo. Lo destruye = no crea otros globos
int destroyBalloon(std::shared_ptr<Balloon> &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
float getBalloonSpeed() const { return balloon_speed_; } float getBalloonSpeed() const { return balloon_speed_; }
Balloons &getBalloons() { return balloons_; } Balloons &getBalloons() { return balloons_; }
int getNumBalloons() const { return balloons_.size(); } int getNumBalloons() const { return balloons_.size(); }
// Setters private:
void setDefaultBalloonSpeed(float speed) { default_balloon_speed_ = speed; } Balloons balloons_; // Vector con los globos activos
void resetBalloonSpeed() { setBalloonSpeed(default_balloon_speed_); } std::unique_ptr<Explosions> explosions_; // Objeto para gestionar explosiones
void setPlayArea(SDL_FRect play_area) { play_area_ = play_area; } std::unique_ptr<BalloonFormations> balloon_formations_; // Objeto para manejar formaciones enemigas
void setCreationTimeEnabled(bool value) { creation_time_enabled_ = value; }
void setDeployBalloons(bool value) { can_deploy_balloons_ = value; } 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::vector<std::string>> balloon_animations_; // Animaciones de los globos
std::vector<std::vector<std::string>> 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();
};