coffee_crisis_arcade_edition/source/balloon_manager.h

#pragma once

#include <SDL2/SDL_rect.h>      // Para SDL_Rect
#include <memory>               // Para shared_ptr, unique_ptr
#include <string>               // Para string
#include <vector>               // Para vector
#include "balloon.h"            // Para BALLOON_SPEED, Balloon
#include "balloon_formations.h" // Para BalloonFormations
#include "explosions.h"         // Para Explosions
#include "param.h"              // Para Param, ParamGame, param
#include "utils.h"              // Para Zone
class Texture;                  // lines 10-10

using Balloons = std::vector<std::shared_ptr<Balloon>>;

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_Rect 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
    BalloonManager();

    // Destructor
    ~BalloonManager() = default;

    // Actualiza
    void update();

    // Renderiza los globos
    void render();

    // Vacia del vector de globos los globos que ya no sirven
    void freeBalloons();

    // Crea una formación de enemigos al azar
    void deployBalloonFormation(int stage);

    // Crea una formación de enemigos específica
    void deploySet(int set);
    void deploySet(int set, int y);

    // Actualiza la variable enemyDeployCounter
    void updateBalloonDeployCounter();

    // Indica si se puede crear una powerball
    bool canPowerBallBeCreated();

    // Calcula el poder actual de los globos en pantalla
    int calculateScreenPower();

    // 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);

    // 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();

    // Recarga las texturas
    void reLoad();

    // 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_; }
    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_Rect play_area) { play_area_ = play_area; }
    void setCreationTimeEnabled(bool value) { creation_time_enabled_ = value; }
    void setDeployBalloons(bool value) { can_deploy_balloons_ = value; }
};