Acabat BalloonManager

source/balloon_manager.cpp

@@ -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::addPower(balloon->getPower());
-    Stage::power += power;
-    // balloons_popped_ += power;
 
     // Destruye el globo
     explosions_->add(balloon->getPosX(), balloon->getPosY(), static_cast<int>(balloon->getSize()));

source/balloon_manager.h

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

source/game.cpp

@@ -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);
+					const auto score = balloon_manager_->popBalloon(balloon);
-					balloons_popped_++;
 					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, 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, 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;
+	paused_ = value;
-	//screen_->attenuate(paused_);
+	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::addPower(5);
-			Stage::power += 5;
 		}
 #endif
 		fade_->update();

source/game.h

@@ -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

source/stage.cpp

@@ -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(200, 7 + (4 * 1), 7 + (4 * 3)));
-        stages.emplace_back(Stage(2, 300, 7 + (4 * 2), 7 + (4 * 4)));
+        stages.emplace_back(Stage(300, 7 + (4 * 2), 7 + (4 * 4)));
-        stages.emplace_back(Stage(3, 600, 7 + (4 * 3), 7 + (4 * 5)));
+        stages.emplace_back(Stage(600, 7 + (4 * 3), 7 + (4 * 5)));
-        stages.emplace_back(Stage(4, 600, 7 + (4 * 3), 7 + (4 * 5)));
+        stages.emplace_back(Stage(600, 7 + (4 * 3), 7 + (4 * 5)));
-        stages.emplace_back(Stage(5, 600, 7 + (4 * 4), 7 + (4 * 6)));
+        stages.emplace_back(Stage(600, 7 + (4 * 4), 7 + (4 * 6)));
-        stages.emplace_back(Stage(6, 600, 7 + (4 * 4), 7 + (4 * 6)));
+        stages.emplace_back(Stage(600, 7 + (4 * 4), 7 + (4 * 6)));
-        stages.emplace_back(Stage(7, 650, 7 + (4 * 5), 7 + (4 * 7)));
+        stages.emplace_back(Stage(650, 7 + (4 * 5), 7 + (4 * 7)));
-        stages.emplace_back(Stage(8, 750, 7 + (4 * 5), 7 + (4 * 7)));
+        stages.emplace_back(Stage(750, 7 + (4 * 5), 7 + (4 * 7)));
-        stages.emplace_back(Stage(9, 850, 7 + (4 * 6), 7 + (4 * 8)));
+        stages.emplace_back(Stage(850, 7 + (4 * 6), 7 + (4 * 8)));
-        stages.emplace_back(Stage(10, 950, 7 + (4 * 7), 7 + (4 * 10)));
+        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;
     }
 }

source/stage.h

@@ -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)
+        Stage(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) {}
+            : 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 power;                 // Poder acumulado en la fase
-    extern int number;            // Fase actual
+    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);
 }