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

canvi de pc

Browse Source
This commit is contained in:
Sergio
2024-11-06 17:22:16 +01:00
parent caf04e3a7e
commit d902bb9088
5 changed files with 107 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
source/balloon_formations.cpp
View File

@@ -709,7 +709,4 @@ void BalloonFormations::initGameStages()
} }
// Devuelve una fase // Devuelve una fase
Stage BalloonFormations::getStage(int index) const Stage BalloonFormations::getStage(int index) const { return stage_[index]; }
{
return stage_[index];
}

100
source/balloon_manager.cpp
View File

@@ -4,49 +4,46 @@
#include "balloon.h" // Para Balloon, BALLOON_SCORE, BALLOON_VE... #include "balloon.h" // Para Balloon, BALLOON_SCORE, BALLOON_VE...
#include "balloon_formations.h" // Para BalloonFormations, BalloonFormatio... #include "balloon_formations.h" // Para BalloonFormations, BalloonFormatio...
#include "resource.h" #include "resource.h"
#include "game.h"
#include "screen.h" #include "screen.h"
#include "explosions.h" // Para Explosions #include "explosions.h" // Para Explosions
#include "jail_audio.h" #include "jail_audio.h"
// Constructor // Constructor
BalloonManager::BalloonManager() BalloonManager::BalloonManager()
: explosions_(std::make_unique<Explosions>()), : explosions_(std::make_unique<Explosions>()),
balloon_formations_(std::make_unique<BalloonFormations>()) balloon_formations_(std::make_unique<BalloonFormations>()) {init();}
// Inicializa
void BalloonManager::init()
{ {
// Texturas - Globos // Texturas - Globos
{ balloon_textures_.emplace_back(Resource::get()->getTexture("balloon1.png"));
balloon_textures_.emplace_back(Resource::get()->getTexture("balloon1.png")); balloon_textures_.emplace_back(Resource::get()->getTexture("balloon2.png"));
balloon_textures_.emplace_back(Resource::get()->getTexture("balloon2.png")); balloon_textures_.emplace_back(Resource::get()->getTexture("balloon3.png"));
balloon_textures_.emplace_back(Resource::get()->getTexture("balloon3.png")); balloon_textures_.emplace_back(Resource::get()->getTexture("balloon4.png"));
balloon_textures_.emplace_back(Resource::get()->getTexture("balloon4.png")); balloon_textures_.emplace_back(Resource::get()->getTexture("powerball.png"));
balloon_textures_.emplace_back(Resource::get()->getTexture("powerball.png"));
}
// Texturas - Explosiones // Animaciones -- Globos
{ balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon1.ani"));
explosions_textures_.emplace_back(Resource::get()->getTexture("explosion1.png")); balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon2.ani"));
explosions_textures_.emplace_back(Resource::get()->getTexture("explosion2.png")); balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon3.ani"));
explosions_textures_.emplace_back(Resource::get()->getTexture("explosion3.png")); balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon4.ani"));
explosions_textures_.emplace_back(Resource::get()->getTexture("explosion4.png")); balloon_animations_.emplace_back(Resource::get()->getAnimation("powerball.ani"));
}
// Animaciones -- Globos // Texturas - Explosiones
{ explosions_textures_.emplace_back(Resource::get()->getTexture("explosion1.png"));
balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon1.ani")); explosions_textures_.emplace_back(Resource::get()->getTexture("explosion2.png"));
balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon2.ani")); explosions_textures_.emplace_back(Resource::get()->getTexture("explosion3.png"));
balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon3.ani")); explosions_textures_.emplace_back(Resource::get()->getTexture("explosion4.png"));
balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon4.ani"));
balloon_animations_.emplace_back(Resource::get()->getAnimation("powerball.ani"));
}
// Animaciones -- Explosiones // Animaciones -- Explosiones
{ explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion1.ani"));
explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion1.ani")); explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion2.ani"));
explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion2.ani")); explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion3.ani"));
explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion3.ani")); explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion4.ani"));
explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion4.ani"));
}
// Añade texturas
explosions_->addTexture(1, explosions_textures_[0], explosions_animations_[0]); explosions_->addTexture(1, explosions_textures_[0], explosions_animations_[0]);
explosions_->addTexture(2, explosions_textures_[1], explosions_animations_[1]); explosions_->addTexture(2, explosions_textures_[1], explosions_animations_[1]);
explosions_->addTexture(3, explosions_textures_[2], explosions_animations_[2]); explosions_->addTexture(3, explosions_textures_[2], explosions_animations_[2]);
@@ -102,7 +99,7 @@ void BalloonManager::deployBalloonFormation()
last_balloon_deploy_ = formation; last_balloon_deploy_ = formation;
const auto set = balloon_formations_->getStage(current_stage_).balloon_pool.set[formation]; const auto set = balloon_formations_->getStage(game_.getCurrentStage()).balloon_pool.set[formation];
const auto numEnemies = set.number_of_balloons; const auto numEnemies = set.number_of_balloons;
for (int i = 0; i < numEnemies; ++i) for (int i = 0; i < numEnemies; ++i)
{ {
@@ -115,27 +112,6 @@ void BalloonManager::deployBalloonFormation()
} }
} }
// Gestiona el nivel de amenaza
void BalloonManager::updateMenace()
{
const auto stage = balloon_formations_->getStage(current_stage_);
const float percent = current_power_ / stage.power_to_complete;
const int difference = stage.max_menace - stage.min_menace;
// Aumenta el nivel de amenaza en función de la puntuación
menace_threshold_ = stage.min_menace + (difference * percent);
// Si el nivel de amenza es inferior al umbral
if (menace_current_ < menace_threshold_)
{
// Crea una formación de enemigos
deployBalloonFormation();
// Recalcula el nivel de amenaza con el nuevo globo
evaluateAndSetMenace();
}
}
// Vacia del vector de globos los globos que ya no sirven // Vacia del vector de globos los globos que ya no sirven
void BalloonManager::freeBalloons() void BalloonManager::freeBalloons()
{ {
@@ -144,14 +120,6 @@ void BalloonManager::freeBalloons()
balloons_.erase(it, balloons_.end()); balloons_.erase(it, balloons_.end());
} }
// Calcula y establece el valor de amenaza en funcion de los globos activos
void BalloonManager::evaluateAndSetMenace()
{
menace_current_ = std::accumulate(
balloons_.begin(), balloons_.end(), 0, [](int sum, const auto &balloon)
{ return sum + (balloon->isEnabled() ? balloon->getMenace() : 0); });
}
// Actualiza la variable enemyDeployCounter // Actualiza la variable enemyDeployCounter
void BalloonManager::updateBalloonDeployCounter() void BalloonManager::updateBalloonDeployCounter()
{ {
@@ -225,7 +193,7 @@ void BalloonManager::checkAndUpdateBalloonSpeed()
if (difficulty_ != GameDifficulty::NORMAL) if (difficulty_ != GameDifficulty::NORMAL)
return; return;
const float percent = static_cast<float>(current_power_) / balloon_formations_->getStage(current_stage_).power_to_complete; const float percent = static_cast<float>(game_.getCurrentPower()) / balloon_formations_->getStage(game_.getCurrentStage()).power_to_complete;
const float thresholds[] = {0.2f, 0.4f, 0.6f, 0.8f}; const float thresholds[] = {0.2f, 0.4f, 0.6f, 0.8f};
for (size_t i = 0; i < std::size(thresholds); ++i) for (size_t i = 0; i < std::size(thresholds); ++i)
@@ -240,7 +208,7 @@ void BalloonManager::checkAndUpdateBalloonSpeed()
// Explosiona un globo. Lo destruye y crea otros dos si es el caso // Explosiona un globo. Lo destruye y crea otros dos si es el caso
void BalloonManager::popBalloon(std::shared_ptr<Balloon> balloon) void BalloonManager::popBalloon(std::shared_ptr<Balloon> balloon)
{ {
increaseStageCurrentPower(1); game_.increaseStageCurrentPower(1);
balloons_popped_++; balloons_popped_++;
if (balloon->getType() == BalloonType::POWERBALL) if (balloon->getType() == BalloonType::POWERBALL)
@@ -298,7 +266,7 @@ void BalloonManager::destroyBalloon(std::shared_ptr<Balloon> &balloon)
// Aumenta el poder de la fase // Aumenta el poder de la fase
const auto power = balloon->getPower(); const auto power = balloon->getPower();
increaseStageCurrentPower(power); game_.increaseStageCurrentPower(power);
balloons_popped_ += power; balloons_popped_ += power;
// Destruye el globo // Destruye el globo
@@ -310,7 +278,9 @@ void BalloonManager::destroyBalloon(std::shared_ptr<Balloon> &balloon)
void BalloonManager::destroyAllBalloons() void BalloonManager::destroyAllBalloons()
{ {
for (auto &balloon : balloons_) for (auto &balloon : balloons_)
{
destroyBalloon(balloon); destroyBalloon(balloon);
}
balloon_deploy_counter_ = 300; balloon_deploy_counter_ = 300;
JA_PlaySound(Resource::get()->getSound("powerball.wav")); JA_PlaySound(Resource::get()->getSound("powerball.wav"));

43
source/balloon_manager.h
View File

@@ -24,18 +24,29 @@ private:
bool power_ball_enabled_ = false; // Indica si hay una powerball ya activa 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 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; int last_balloon_deploy_ = 0; // Guarda cual ha sido la última formación desplegada para no repetir;
int menace_current_ = 0; // Nivel de amenaza actual
int menace_threshold_ = 0; // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos // Inicializa
void init();
public:
// Constructor
BalloonManager();
// Destructor
~BalloonManager() = default;
// Actualiza
void update();
// Renderiza los globos
void renderBalloons();
// Vacia del vector de globos los globos que ya no sirven
void freeBalloons();
// Crea una formación de enemigos // Crea una formación de enemigos
void deployBalloonFormation(); void deployBalloonFormation();
// Gestiona el nivel de amenaza
void updateMenace();
// Calcula y establece el valor de amenaza en funcion de los globos activos
void evaluateAndSetMenace();
// Actualiza la variable enemyDeployCounter // Actualiza la variable enemyDeployCounter
void updateBalloonDeployCounter(); void updateBalloonDeployCounter();
@@ -80,20 +91,4 @@ private:
// Cambia el color de todos los globos // Cambia el color de todos los globos
void normalColorsToAllBalloons(); void normalColorsToAllBalloons();
public:
// Constructor
BalloonManager();
// Destructor
~BalloonManager() = default;
// Actualiza
void update();
// Renderiza los globos
void renderBalloons();
// Vacia del vector de globos los globos que ya no sirven
void freeBalloons();
}; };

33
source/game.cpp
View File

@@ -44,6 +44,7 @@ Game::Game(int player_id, int current_stage, bool demo)
background_(std::make_unique<Background>()), background_(std::make_unique<Background>()),
canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.play_area.rect.w, param.game.play_area.rect.h)), canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.play_area.rect.w, param.game.play_area.rect.h)),
fade_(std::make_unique<Fade>()), fade_(std::make_unique<Fade>()),
balloon_manager_(std::make_unique<BalloonManager>(*this)),
current_stage_(current_stage) current_stage_(current_stage)
{ {
// Pasa variables // Pasa variables
@@ -171,9 +172,6 @@ void Game::setResources()
} }
} }
// Aumenta el poder de la fase
void Game::increaseStageCurrentPower(int power) { current_power_ += power; }
// Actualiza el valor de hiScore en caso necesario // Actualiza el valor de hiScore en caso necesario
void Game::updateHiScore() void Game::updateHiScore()
{ {
@@ -1781,4 +1779,33 @@ void Game::cleanVectors()
freeItems(); freeItems();
freeSmartSprites(); freeSmartSprites();
freePathSprites(); freePathSprites();
}
// Gestiona el nivel de amenaza
void Game::updateMenace()
{
const auto stage = balloon_formations_->getStage(current_stage_);
const float percent = current_power_ / stage.power_to_complete;
const int difference = stage.max_menace - stage.min_menace;
// Aumenta el nivel de amenaza en función de la puntuación
menace_threshold_ = stage.min_menace + (difference * percent);
// Si el nivel de amenza es inferior al umbral
if (menace_current_ < menace_threshold_)
{
// Crea una formación de enemigos
balloon_manager_->deployBalloonFormation();
// Recalcula el nivel de amenaza con el nuevo globo
evaluateAndSetMenace();
}
}
// Calcula y establece el valor de amenaza en funcion de los globos activos
void Game::evaluateAndSetMenace()
{
menace_current_ = std::accumulate(
balloons_.begin(), balloons_.end(), 0, [](int sum, const auto &balloon)
{ return sum + (balloon->isEnabled() ? balloon->getMenace() : 0); });
} }

89
source/game.h
View File

@@ -121,7 +121,7 @@ private:
Input *input_; // Manejador de entrada Input *input_; // Manejador de entrada
Scoreboard *scoreboard_; // Objeto para dibujar el marcador Scoreboard *scoreboard_; // Objeto para dibujar el marcador
std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego
SDL_Texture *canvas_; // Textura para dibujar la zona de juego SDL_Texture *canvas_; // Textura para dibujar la zona de juego
@@ -137,8 +137,8 @@ private:
std::vector<std::shared_ptr<Texture>> game_text_textures_; // Vector con las texturas para los sprites con textos std::vector<std::shared_ptr<Texture>> game_text_textures_; // Vector con las texturas para los sprites con textos
std::vector<std::vector<std::string>> item_animations_; // Vector con las animaciones de los items std::vector<std::vector<std::string>> item_animations_; // Vector con las animaciones de los items
std::vector<std::vector<std::string>> player_animations_; // Vector con las animaciones del jugador std::vector<std::vector<std::string>> player_animations_; // Vector con las animaciones del jugador
std::unique_ptr<Fade> fade_; // Objeto para renderizar fades std::unique_ptr<Fade> fade_; // Objeto para renderizar fades
std::unique_ptr<BalloonManager> balloon_manager_; // Objeto para gestionar los globos std::unique_ptr<BalloonManager> balloon_manager_; // Objeto para gestionar los globos
@@ -150,6 +150,7 @@ private:
options.game.hi_score_table[0].score); // Máxima puntuación y nombre de quien la ostenta options.game.hi_score_table[0].score); // Máxima puntuación y nombre de quien la ostenta
int current_stage_; // Indica la fase actual int current_stage_; // Indica la fase actual
int current_power_ = 0; // Poder actual almacenado para completar la fase
Demo demo_; // Variable con todas las variables relacionadas con el modo demo Demo demo_; // Variable con todas las variables relacionadas con el modo demo
GameDifficulty difficulty_ = options.game.difficulty; // Dificultad del juego GameDifficulty difficulty_ = options.game.difficulty; // Dificultad del juego
Helper helper_; // Variable para gestionar las ayudas Helper helper_; // Variable para gestionar las ayudas
@@ -159,11 +160,12 @@ private:
bool paused_ = false; // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade) bool paused_ = false; // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
float difficulty_score_multiplier_; // Multiplicador de puntos en función de la dificultad float difficulty_score_multiplier_; // Multiplicador de puntos en función de la dificultad
int counter_ = 0; // Contador para el juego int counter_ = 0; // Contador para el juego
int current_power_ = 0; // Poder actual almacenado para completar la fase
int game_completed_counter_ = 0; // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos int game_completed_counter_ = 0; // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
int game_over_counter_ = GAME_OVER_COUNTER_; // Contador para el estado de fin de partida int game_over_counter_ = GAME_OVER_COUNTER_; // Contador para el estado de fin de partida
int time_stopped_counter_ = 0; // Temporizador para llevar la cuenta del tiempo detenido int time_stopped_counter_ = 0; // Temporizador para llevar la cuenta del tiempo detenido
int total_power_to_complete_game_; // La suma del poder necesario para completar todas las fases int total_power_to_complete_game_; // La suma del poder necesario para completar todas las fases
int menace_current_ = 0; // Nivel de amenaza actual
int menace_threshold_ = 0; // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
GameState state_ = GameState::PLAYING; // Estado GameState state_ = GameState::PLAYING; // Estado
#ifdef DEBUG #ifdef DEBUG
bool auto_pop_balloons_ = false; // Si es true, incrementa automaticamente los globos explotados bool auto_pop_balloons_ = false; // Si es true, incrementa automaticamente los globos explotados
@@ -181,9 +183,6 @@ private:
// Asigna texturas y animaciones // Asigna texturas y animaciones
void setResources(); void setResources();
// Aumenta el poder de la fase
void increaseStageCurrentPower(int power);
// Actualiza el valor de HiScore en caso necesario // Actualiza el valor de HiScore en caso necesario
void updateHiScore(); void updateHiScore();
@@ -199,54 +198,9 @@ private:
// Actualiza el estado de fin de la partida // Actualiza el estado de fin de la partida
void updateGameOverState(); void updateGameOverState();
// Actualiza los globos
void updateBalloons();
// Pinta en pantalla todos los globos activos
void renderBalloons();
// 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 stopped_counter);
// 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);
// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
void checkAndUpdateBalloonSpeed();
// Explosiona un globo. Lo destruye y crea otros dos si es el caso
void popBalloon(std::shared_ptr<Balloon> balloon);
// Explosiona un globo. Lo destruye
void destroyBalloon(std::shared_ptr<Balloon> &balloon);
// Destruye todos los globos
void destroyAllBalloons();
// Destruye todos los items // Destruye todos los items
void destroyAllItems(); void destroyAllItems();
// 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();
// Vacia el vector de globos
void freeBalloons();
// Comprueba la colisión entre el jugador y los globos activos // Comprueba la colisión entre el jugador y los globos activos
bool checkPlayerBalloonCollision(std::shared_ptr<Player> &player); bool checkPlayerBalloonCollision(std::shared_ptr<Player> &player);
@@ -313,12 +267,6 @@ private:
// Acciones a realizar cuando el jugador muere // Acciones a realizar cuando el jugador muere
void killPlayer(std::shared_ptr<Player> &player); void killPlayer(std::shared_ptr<Player> &player);
// Calcula y establece el valor de amenaza en funcion de los globos activos
void evaluateAndSetMenace();
// Actualiza la variable EnemyDeployCounter
void updateBalloonDeployCounter();
// Actualiza y comprueba el valor de la variable // Actualiza y comprueba el valor de la variable
void updateTimeStopped(); void updateTimeStopped();
@@ -334,12 +282,6 @@ private:
// Deshabilita el efecto del item de detener el tiempo // Deshabilita el efecto del item de detener el tiempo
void disableTimeStopItem(); void disableTimeStopItem();
// Indica si se puede crear una powerball
bool canPowerBallBeCreated();
// Calcula el poder actual de los globos en pantalla
int calculateScreenPower();
// Actualiza las variables de ayuda // Actualiza las variables de ayuda
void updateHelper(); void updateHelper();
@@ -448,9 +390,6 @@ private:
// Actualiza las variables durante el transcurso normal del juego // Actualiza las variables durante el transcurso normal del juego
void updateGame(); void updateGame();
// Actualiza las variables durante el transcurso del final del juego
void updateCompletedGame();
// Gestiona eventos para el estado del final del juego // Gestiona eventos para el estado del final del juego
void updateCompletedState(); void updateCompletedState();
@@ -460,6 +399,12 @@ private:
// Vacía los vectores de elementos deshabilitados // Vacía los vectores de elementos deshabilitados
void cleanVectors(); void cleanVectors();
// Gestiona el nivel de amenaza
void updateMenace();
// Calcula y establece el valor de amenaza en funcion de los globos activos
void evaluateAndSetMenace();
public: public:
// Constructor // Constructor
Game(int playerID, int current_stage, bool demo); Game(int playerID, int current_stage, bool demo);
@@ -469,4 +414,14 @@ public:
// Bucle para el juego // Bucle para el juego
void run(); void run();
// Aumenta el poder de la fase
void increaseStageCurrentPower(int power) { current_power_ += power; }
// Getters y Setters
int getCurrentStage() const { return current_stage_; }
void setCurrentStage(int stage) { current_stage_ = stage; }
int getCurrentPower() const { return current_power_; }
void setCurrentPower(int power) { current_power_ = power; }
}; };