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

Acabat BalloonManager

Browse Source
This commit is contained in:
Sergio
2024-11-08 18:29:08 +01:00
parent 2fb7e88e4b
commit f9520185a2
6 changed files with 75 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
source/balloon_manager.cpp
View File

@@ -200,18 +200,20 @@ void BalloonManager::setBalloonSpeed(float speed)
}
// Explosiona un globo. Lo destruye y crea otros dos si es el caso
void BalloonManager::popBalloon(std::shared_ptr<Balloon> balloon)
int BalloonManager::popBalloon(std::shared_ptr<Balloon> balloon)
{
++Stage::power;
Stage::addPower(1);
int score = 0;
if (balloon->getType() == BalloonType::POWERBALL)
{
destroyAllBalloons();
score = destroyAllBalloons();
power_ball_enabled_ = false;
balloon_deploy_counter_ = 20;
}
else
{
score = balloon->getScore();
if (balloon->getSize() != BalloonSize::SIZE1)
{
createChildBalloon(balloon, "LEFT");
@@ -222,6 +224,8 @@ void BalloonManager::popBalloon(std::shared_ptr<Balloon> balloon)
explosions_->add(balloon->getPosX(), balloon->getPosY(), static_cast<int>(balloon->getSize()));
balloon->pop();
}
return score;
}
// Explosiona un globo. Lo destruye = no crea otros globos
@@ -249,19 +253,8 @@ int BalloonManager::destroyBalloon(std::shared_ptr<Balloon> &balloon)
break;
}
// Otorga los puntos correspondientes al globo
/*
for (auto &player : players_)
{
player->addScore(score * player->getScoreMultiplier() * difficulty_score_multiplier_);
}
updateHiScore();
*/
// Aumenta el poder de la fase
const auto power = balloon->getPower();
Stage::power += power;
// balloons_popped_ += power;
Stage::addPower(balloon->getPower());
// Destruye el globo
explosions_->add(balloon->getPosX(), balloon->getPosY(), static_cast<int>(balloon->getSize()));

2
source/balloon_manager.h
View File

@@ -74,7 +74,7 @@ public:
void setBalloonSpeed(float speed);
// Explosiona un globo. Lo destruye y crea otros dos si es el caso
void popBalloon(std::shared_ptr<Balloon> balloon);
int popBalloon(std::shared_ptr<Balloon> balloon);
// Explosiona un globo. Lo destruye = no crea otros globos
int destroyBalloon(std::shared_ptr<Balloon> &balloon);

61
source/game.cpp
View File

@@ -32,7 +32,7 @@
#include "smart_sprite.h" // Para SmartSprite
#include "stage.h" // Para get, number, Stage, power
#include "text.h" // Para Text
#include "dbgtxt.h" // Para dbg_print
#include "dbgtxt.h" // Para dbg_print
#include "texture.h" // Para Texture
struct JA_Sound_t; // lines 37-37
@@ -84,7 +84,7 @@ Game::Game(int player_id, int current_stage, bool demo)
if (!demo_.enabled)
for (int i = 0; i < Stage::number; ++i)
{
balloons_popped_ += Stage::get(i).power_to_complete;
Stage::total_power += Stage::get(i).power_to_complete;
}
#endif
@@ -247,8 +247,8 @@ void Game::updateStage()
if (Stage::power >= Stage::get(Stage::number).power_to_complete)
{
// Cambio de fase
Stage::power = Stage::get(Stage::number).power_to_complete - Stage::power;
++Stage::number;
Stage::power = 0;
JA_PlaySound(Resource::get()->getSound("stage_change.wav"));
balloon_manager_->resetBalloonSpeed();
screen_->flash(flash_color, 100);
@@ -257,9 +257,8 @@ void Game::updateStage()
// Escribe el texto por pantalla
if (Stage::number < 10)
{
const auto stage_number = Stage::get(Stage::number).number;
std::vector<Path> paths = {paths_.at(2), paths_.at(3)};
if (stage_number == 10)
if (Stage::number == 9)
{
createMessage(paths, Resource::get()->getTexture("last_stage"));
}
@@ -499,15 +498,8 @@ void Game::checkBulletBalloonCollision()
{
if (checkCollision(balloon->getCollider(), bullet->getCollider()))
{
// Otorga los puntos al jugador que disparó la bala
// Obtiene al jugador que disparó la bala
auto player = getPlayer(bullet->getOwner());
if (!player)
{
return;
}
player->addScore(balloon->getScore() * player->getScoreMultiplier() * difficulty_score_multiplier_);
player->incScoreMultiplier();
updateHiScore();
// Suelta el item si se da el caso
const auto droppeditem = dropItem();
@@ -526,10 +518,17 @@ void Game::checkBulletBalloonCollision()
}
// Explota el globo
balloon_manager_->popBalloon(balloon);
balloons_popped_++;
const auto score = balloon_manager_->popBalloon(balloon);
evaluateAndSetMenace();
// Otorga los puntos al jugador que disparó la bala
if (player->isPlaying())
{
player->addScore(score * player->getScoreMultiplier() * difficulty_score_multiplier_);
player->incScoreMultiplier();
}
updateHiScore();
// Sonido de explosión
JA_PlaySound(Resource::get()->getSound("balloon.wav"));
@@ -869,17 +868,18 @@ void Game::updateBackground()
// Si el juego está completado, se reduce la velocidad de las nubes
if (state_ == GameState::COMPLETED)
{
balloons_popped_ = (balloons_popped_ > 400) ? (balloons_popped_ - 25) : 200;
Stage::total_power = (Stage::total_power > 400) ? (Stage::total_power - 25) : 200;
}
// Calcula la velocidad en función de los globos explotados y el total de globos a explotar para acabar el juego
constexpr float clouds_initial_speed = 0.05f;
constexpr float clouds_final_speed = 2.00f - clouds_initial_speed;
const float cloudsSpeed = (-clouds_initial_speed) + (-clouds_final_speed * (static_cast<float>(balloons_popped_) / total_power_to_complete_game_));
const float cloudsSpeed = (-clouds_initial_speed) + (-clouds_final_speed * (static_cast<float>(Stage::total_power) / total_power_to_complete_game_));
background_->setCloudsSpeed(cloudsSpeed);
// Calcula la transición de los diferentes fondos
const float gradient_number = std::min(balloons_popped_ / 1250.0f, 3.0f);
constexpr float num = 1525.0f; // total_power_to_complete div 4
const float gradient_number = std::min(Stage::total_power / num, 3.0f);
const float percent = gradient_number - static_cast<int>(gradient_number);
background_->setGradientNumber(static_cast<int>(gradient_number));
background_->setTransition(percent);
@@ -903,8 +903,8 @@ void Game::fillCanvas()
renderBullets();
renderPathSprites();
renderPlayers();
dbg_print(0, 40, std::to_string(menace_current_).c_str(), 255, 0 ,0);
dbg_print(0, 50, std::to_string(menace_threshold_).c_str(), 255, 0 ,0);
// dbg_print(0, 40, std::to_string(menace_current_).c_str(), 255, 0, 0);
// dbg_print(0, 50, std::to_string(menace_threshold_).c_str(), 255, 0, 0);
// Deja el renderizador apuntando donde estaba
SDL_SetRenderTarget(renderer_, temp);
@@ -1201,7 +1201,7 @@ void Game::updateScoreboard()
}
// Resto de marcador
scoreboard_->setStage(Stage::get(Stage::number).number);
scoreboard_->setStage(Stage::number + 1);
scoreboard_->setPower((float)Stage::power / (float)Stage::get(Stage::number).power_to_complete);
scoreboard_->setHiScore(hi_score_.score);
scoreboard_->setHiScoreName(hi_score_.name);
@@ -1213,8 +1213,8 @@ void Game::updateScoreboard()
// Pausa el juego
void Game::pause(bool value)
{
//paused_ = value;
//screen_->attenuate(paused_);
paused_ = value;
screen_->attenuate(paused_);
}
// Añade una puntuación a la tabla de records
@@ -1547,7 +1547,7 @@ void Game::initDemo(int player_id)
// Actualiza el numero de globos explotados según la fase del modo demostración
for (int i = 0; i < Stage::number; ++i)
{
balloons_popped_ += Stage::get(i).power_to_complete;
Stage::total_power += Stage::get(i).power_to_complete;
}
// Activa o no al otro jugador
@@ -1588,9 +1588,9 @@ void Game::initDemo(int player_id)
void Game::setTotalPower()
{
total_power_to_complete_game_ = 0;
for (int i = 0; i < 10; ++i)
for (const auto &stage : Stage::stages)
{
total_power_to_complete_game_ += Stage::get(i).power_to_complete;
total_power_to_complete_game_ += stage.power_to_complete;
}
}
@@ -1671,21 +1671,27 @@ void Game::initPlayers(int player_id)
void Game::pauseMusic()
{
if (JA_GetMusicState() == JA_MUSIC_PLAYING && !demo_.enabled)
{
JA_PauseMusic();
}
}
// Reanuda la música
void Game::resumeMusic()
{
if (JA_GetMusicState() == JA_MUSIC_PAUSED && !demo_.enabled)
{
JA_ResumeMusic();
}
}
// Detiene la música
void Game::stopMusic()
{
if (!demo_.enabled)
{
JA_StopMusic();
}
}
// Actualiza las variables durante el modo demo
@@ -1741,8 +1747,7 @@ void Game::updateGame()
#ifdef DEBUG
if (auto_pop_balloons_ && state_ == GameState::PLAYING)
{
balloons_popped_ += 5;
Stage::power += 5;
Stage::addPower(5);
}
#endif
fade_->update();

1
source/game.h
View File

@@ -162,7 +162,6 @@ private:
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 total_power_to_complete_game_; // La suma del poder necesario para completar todas las fases
int balloons_popped_ = 0; // Lleva la cuenta de los globos explotados
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

36
source/stage.cpp
View File

@@ -6,23 +6,35 @@ namespace Stage
std::vector<Stage> stages; // Variable con los datos de cada pantalla
int power = 0; // Poder acumulado en la fase
int total_power = 0; // Poder total necesario para completar el juego
int number = 0; // Fase actual
// Devuelve una fase
Stage get(int index) { return stages.at(index); }
Stage get(int index) { return stages.at(std::min(9, index)); }
// Inicializa las fases del juego
// Inicializa las variables del namespace Stage
void init()
{
stages.emplace_back(Stage(1, 200, 7 + (4 * 1), 7 + (4 * 3)));
stages.emplace_back(Stage(2, 300, 7 + (4 * 2), 7 + (4 * 4)));
stages.emplace_back(Stage(3, 600, 7 + (4 * 3), 7 + (4 * 5)));
stages.emplace_back(Stage(4, 600, 7 + (4 * 3), 7 + (4 * 5)));
stages.emplace_back(Stage(5, 600, 7 + (4 * 4), 7 + (4 * 6)));
stages.emplace_back(Stage(6, 600, 7 + (4 * 4), 7 + (4 * 6)));
stages.emplace_back(Stage(7, 650, 7 + (4 * 5), 7 + (4 * 7)));
stages.emplace_back(Stage(8, 750, 7 + (4 * 5), 7 + (4 * 7)));
stages.emplace_back(Stage(9, 850, 7 + (4 * 6), 7 + (4 * 8)));
stages.emplace_back(Stage(10, 950, 7 + (4 * 7), 7 + (4 * 10)));
stages.emplace_back(Stage(200, 7 + (4 * 1), 7 + (4 * 3)));
stages.emplace_back(Stage(300, 7 + (4 * 2), 7 + (4 * 4)));
stages.emplace_back(Stage(600, 7 + (4 * 3), 7 + (4 * 5)));
stages.emplace_back(Stage(600, 7 + (4 * 3), 7 + (4 * 5)));
stages.emplace_back(Stage(600, 7 + (4 * 4), 7 + (4 * 6)));
stages.emplace_back(Stage(600, 7 + (4 * 4), 7 + (4 * 6)));
stages.emplace_back(Stage(650, 7 + (4 * 5), 7 + (4 * 7)));
stages.emplace_back(Stage(750, 7 + (4 * 5), 7 + (4 * 7)));
stages.emplace_back(Stage(850, 7 + (4 * 6), 7 + (4 * 8)));
stages.emplace_back(Stage(950, 7 + (4 * 7), 7 + (4 * 10)));
power = 0;
total_power = 0;
number = 0;
}
// Añade poder
void addPower(int amount)
{
power += amount;
total_power += amount;
}
}

15
source/stage.h
View File

@@ -6,23 +6,26 @@ namespace Stage
{
struct Stage
{
int number; // Número de fase
int power_to_complete; // Cantidad de poder que se necesita para completar la fase
int min_menace; // Umbral mínimo de amenaza de la fase
int max_menace; // Umbral máximo de amenaza de la fase
// Constructor
Stage(int number, int power_to_complete, int min_menace, int max_menace)
: number(number), power_to_complete(power_to_complete), min_menace(min_menace), max_menace(max_menace) {}
Stage(int power_to_complete, int min_menace, int max_menace)
: power_to_complete(power_to_complete), min_menace(min_menace), max_menace(max_menace) {}
};
extern std::vector<Stage> stages; // Variable con los datos de cada pantalla
extern int power; // Poder acumulado en la fase
extern int number; // Fase actual
extern int power; // Poder acumulado en la fase
extern int total_power; // Poder total necesario para completar el juego
extern int number; // Fase actual
// Devuelve una fase
Stage get(int index);
// Inicializa las fases del juego
// Inicializa las variables del namespace Stage
void init();
// Añade poder
void addPower(int amount);
}