reestructurat background, balloon_formations i balloon_manager
This commit is contained in:
@@ -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
|
||||
};
|
||||
|
||||
@@ -3,11 +3,13 @@
|
||||
#include "balloon.h" // Para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
|
||||
#include <vector>
|
||||
|
||||
// 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<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)
|
||||
: number_of_balloons(num_balloons), init(init_params) {}
|
||||
|
||||
// Default constructor
|
||||
// Constructor por defecto
|
||||
BalloonFormationUnit() : number_of_balloons(0), init() {}
|
||||
};
|
||||
|
||||
using BalloonFormationPool = std::vector<const BalloonFormationUnit *>;
|
||||
|
||||
// Clase 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:
|
||||
// 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<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();
|
||||
};
|
||||
|
||||
@@ -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<std::shared_ptr<Balloon>>;
|
||||
|
||||
// Clase 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:
|
||||
// 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<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
|
||||
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> 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
|
||||
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<Balloon> 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> &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> 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
|
||||
// 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; }
|
||||
};
|
||||
private:
|
||||
Balloons balloons_; // Vector con los globos activos
|
||||
std::unique_ptr<Explosions> explosions_; // Objeto para gestionar explosiones
|
||||
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>> 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();
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user