reestructurat background, balloon_formations i balloon_manager

This commit is contained in:
2025-05-27 13:58:51 +02:00
parent ada141cb09
commit 677e4d465d
3 changed files with 167 additions and 239 deletions

View File

@@ -6,149 +6,106 @@
#include <memory> // Para unique_ptr, shared_ptr
#include <vector> // 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<Texture> buildings_texture_; // Textura con los edificios de fondo
std::shared_ptr<Texture> top_clouds_texture_; // Textura con las nubes de fondo
std::shared_ptr<Texture> bottom_clouds_texture_; // Textura con las nubes de fondo
std::shared_ptr<Texture> grass_texture_; // Textura con la hierba del suelo
std::shared_ptr<Texture> gradients_texture_; // Textura con los diferentes colores de fondo del juego
std::shared_ptr<Texture> sun_texture_; // Textura con el sol
std::shared_ptr<Texture> moon_texture_; // Textura con la luna
// Texturas
std::shared_ptr<Texture> buildings_texture_;
std::shared_ptr<Texture> top_clouds_texture_;
std::shared_ptr<Texture> bottom_clouds_texture_;
std::shared_ptr<Texture> grass_texture_;
std::shared_ptr<Texture> gradients_texture_;
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
std::unique_ptr<MovingSprite> top_clouds_sprite_b_; // Sprite para las nubes superiores
std::unique_ptr<MovingSprite> bottom_clouds_sprite_a_; // Sprite para las nubes inferiores
std::unique_ptr<MovingSprite> bottom_clouds_sprite_b_; // Sprite para las nubes inferiores
std::unique_ptr<Sprite> buildings_sprite_; // Sprite con los edificios de fondo
std::unique_ptr<Sprite> gradient_sprite_; // Sprite con los graficos del degradado de color de fondo
std::unique_ptr<Sprite> grass_sprite_; // Sprite para la hierba
std::unique_ptr<Sprite> sun_sprite_; // Sprite para el sol
std::unique_ptr<Sprite> moon_sprite_; // Sprite para la luna
// Sprites
std::unique_ptr<MovingSprite> top_clouds_sprite_a_;
std::unique_ptr<MovingSprite> top_clouds_sprite_b_;
std::unique_ptr<MovingSprite> bottom_clouds_sprite_a_;
std::unique_ptr<MovingSprite> bottom_clouds_sprite_b_;
std::unique_ptr<Sprite> buildings_sprite_;
std::unique_ptr<Sprite> gradient_sprite_;
std::unique_ptr<Sprite> grass_sprite_;
std::unique_ptr<Sprite> sun_sprite_;
std::unique_ptr<Sprite> 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<SDL_FPoint> sun_path_; // Vector con el recorrido del sol
std::vector<SDL_FPoint> 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<SDL_FPoint> sun_path_;
std::vector<SDL_FPoint> 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);
};
// 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
};