fix: un vuelo rasante havia trencat els credits

Es necesita almenys un jugador viu per a poder incrementar el poder de la fase

data/config/param_320x240.txt

@@ -1,5 +1,7 @@
 ## GAME
 game.item_size           20 # Tamaño de los items del juego
+game.coffee_machine_w    28 # Ancho de la máquina de café
+game.coffee_machine_h    37 # Alto de la máquina de café
 game.width              320 # Ancho de la resolucion nativa del juego
 game.height             240 # Alto de la resolucion nativa del juego
 game.play_area.rect.x     0 # Rectangulo con la posición de la zona de juego

data/config/param_320x256.txt

@@ -1,12 +1,14 @@
 ## GAME
-game.item_size          20 # Tamaño de los items del juego
-game.width             320 # Ancho de la resolucion nativa del juego
-game.height            256 # Alto de la resolucion nativa del juego
-game.play_area.rect.x    0 # Rectangulo con la posición de la zona de juego
-game.play_area.rect.y    0 # Rectangulo con la posición de la zona de juego
-game.play_area.rect.w  320 # Rectangulo con la posición de la zona de juego
-game.play_area.rect.h  216 # Rectangulo con la posición de la zona de juego
-game.enter_name_seconds 60 # Duración en segundos para introducir el nombre al finalizar la partida
+game.item_size           20 # Tamaño de los items del juego
+game.coffee_machine_w    28 # Ancho de la máquina de café
+game.coffee_machine_h    37 # Alto de la máquina de café
+game.width              320 # Ancho de la resolucion nativa del juego
+game.height             256 # Alto de la resolucion nativa del juego
+game.play_area.rect.x     0 # Rectangulo con la posición de la zona de juego
+game.play_area.rect.y     0 # Rectangulo con la posición de la zona de juego
+game.play_area.rect.w   320 # Rectangulo con la posición de la zona de juego
+game.play_area.rect.h   216 # Rectangulo con la posición de la zona de juego
+game.enter_name_seconds  60 # Duración en segundos para introducir el nombre al finalizar la partida
 
 ## FADE
 fade.num_squares_width    160

source/balloon.cpp

@@ -229,12 +229,6 @@ void Balloon::move()
 	}
 }
 
-// Deshabilita el globo
-void Balloon::disable() { enabled_ = false; }
-
-// Explosiona el globo
-void Balloon::pop() { disable(); }
-
 // Actualiza al globo a su posicion, animación y controla los contadores
 void Balloon::update()
 {

source/balloon.h

@@ -170,12 +170,6 @@ public:
 	// Actualiza la posición y estados del globo
 	void move();
 
-	// Deshabilita el globo y pone a cero todos los valores
-	void disable();
-
-	// Explosiona el globo
-	void pop();
-
 	// Actualiza al globo a su posicion, animación y controla los contadores
 	void update();
 
@@ -215,4 +209,5 @@ public:
 	void setSpeed(float speed) { speed_ = speed; }
 	void setInvulnerable(bool value) { invulnerable_ = value; }
 	void setSound(bool value) { sound_enabled_ = value; }
+	void disable() { enabled_ = false; }
 };

source/balloon_manager.cpp

@@ -107,11 +107,18 @@ void BalloonManager::deployBalloonFormation(int stage)
             last_balloon_deploy_ = formation;
 
             const auto set = balloon_formations_->getSet(stage, formation);
-            const auto numEnemies = set.number_of_balloons;
-            for (int i = 0; i < numEnemies; ++i)
+            const auto num_enemies = set.number_of_balloons;
+            for (int i = 0; i < num_enemies; ++i)
             {
                 auto p = set.init[i];
-                createBalloon(p.x, p.y, p.type, p.size, p.vel_x, balloon_speed_, p.creation_counter);
+                createBalloon(
+                    p.x,
+                    p.y,
+                    p.type,
+                    p.size,
+                    p.vel_x,
+                    balloon_speed_,
+                    (creation_time_enabled_) ? p.creation_counter : 0);
             }
 
             balloon_deploy_counter_ = 300;
@@ -123,8 +130,8 @@ void BalloonManager::deployBalloonFormation(int stage)
 void BalloonManager::deploySet(int set_number)
 {
     const auto set = balloon_formations_->getSet(set_number);
-    const auto numEnemies = set.number_of_balloons;
-    for (int i = 0; i < numEnemies; ++i)
+    const auto num_enemies = set.number_of_balloons;
+    for (int i = 0; i < num_enemies; ++i)
     {
         auto p = set.init[i];
         createBalloon(p.x, p.y, p.type, p.size, p.vel_x, balloon_speed_, p.creation_counter);
@@ -135,8 +142,8 @@ void BalloonManager::deploySet(int set_number)
 void BalloonManager::deploySet(int set_number, int y)
 {
     const auto set = balloon_formations_->getSet(set_number);
-    const auto numEnemies = set.number_of_balloons;
-    for (int i = 0; i < numEnemies; ++i)
+    const auto num_enemies = set.number_of_balloons;
+    for (int i = 0; i < num_enemies; ++i)
     {
         auto p = set.init[i];
         createBalloon(p.x, y, p.type, p.size, p.vel_x, balloon_speed_, p.creation_counter);
@@ -251,7 +258,7 @@ int BalloonManager::popBalloon(std::shared_ptr<Balloon> balloon)
 
         // Agrega la explosión y elimina el globo
         explosions_->add(balloon->getPosX(), balloon->getPosY(), static_cast<int>(balloon->getSize()));
-        balloon->pop();
+        balloon->disable();
     }
 
     return score;
@@ -287,7 +294,7 @@ int BalloonManager::destroyBalloon(std::shared_ptr<Balloon> &balloon)
 
     // Destruye el globo
     explosions_->add(balloon->getPosX(), balloon->getPosY(), static_cast<int>(balloon->getSize()));
-    balloon->pop();
+    balloon->disable();
 
     return score;
 }
@@ -366,6 +373,21 @@ void BalloonManager::createTwoBigBalloons()
     deploySet(1);
 }
 
+// Crea una disposición de globos aleatoria
+void BalloonManager::createRandomBalloons()
+{
+    const int num_balloons = 2 + rand() % 4;
+    for (int i = 0; i < num_balloons; ++i)
+    {
+        const float x = param.game.game_area.rect.x + (rand() % param.game.game_area.rect.w) - BALLOON_SIZE[3];
+        const int y = param.game.game_area.rect.y + (rand() % 50);
+        const BalloonSize size = static_cast<BalloonSize>(rand() % 4);
+        const float vel_x = (rand() % 2 == 0) ? BALLOON_VELX_POSITIVE : BALLOON_VELX_NEGATIVE;
+        const int creation_counter = 0;
+        createBalloon(x, y, BalloonType::BALLOON, size, vel_x, balloon_speed_, creation_counter);
+    }
+}
+
 // Obtiene el nivel de ameza actual generado por los globos
 int BalloonManager::getMenace()
 {

source/balloon_manager.h

@@ -33,6 +33,7 @@ private:
     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
 
     // Inicializa
     void init();
@@ -108,6 +109,9 @@ public:
     // 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();
 
@@ -117,9 +121,11 @@ public:
     // 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; }
 };

source/credits.cpp

@@ -22,9 +22,10 @@
 #include "player.h"
 #include "fade.h"
 #include "lang.h"
+#include "mouse.h"
 
 // Textos
-constexpr const char TEXT_COPYRIGHT[] = "@2020,2024 JailDesigner";
+constexpr const char TEXT_COPYRIGHT[] = "@2020,2025 JailDesigner";
 
 // Constructor
 Credits::Credits()
@@ -39,20 +40,18 @@ Credits::Credits()
         throw std::runtime_error("Failed to create SDL texture for text.");
     }
     section::name = section::Name::CREDITS;
-    //top_black_rect_ = {play_area_.x, 0, play_area_.w, black_bars_size_};
-    //bottom_black_rect_ = {play_area_.x, param.game.game_area.rect.h - black_bars_size_, play_area_.w, black_bars_size_};
     balloon_manager_->setPlayArea(play_area_);
-    
+
     fade_in_->setColor(fade_color.r, fade_color.g, fade_color.b);
     fade_in_->setType(FadeType::FULLSCREEN);
-    fade_in_->setPost(50);
+    fade_in_->setPostDuration(50);
     fade_in_->setMode(FadeMode::IN);
     fade_in_->activate();
-    
+
     fade_out_->setColor(0, 0, 0);
     fade_out_->setType(FadeType::FULLSCREEN);
-    fade_out_->setPost(400);
-    
+    fade_out_->setPostDuration(400);
+
     initPlayers();
     SDL_SetTextureBlendMode(text_texture_, SDL_BLENDMODE_BLEND);
     fillTextTexture();
@@ -158,6 +157,9 @@ void Credits::checkEvents()
             section::options = section::Options::QUIT_FROM_EVENT;
             break;
         }
+
+        // Comprueba el cursor
+        Mouse::handleEvent(event);
     }
 }
 

source/director.cpp

@@ -54,7 +54,7 @@ Director::Director(int argc, const char *argv[])
 	section::name = section::Name::GAME;
 	section::options = section::Options::GAME_PLAY_1P;
 #elif DEBUG
-	section::name = section::Name::LOGO;
+	section::name = section::Name::CREDITS;
 #else // NORMAL GAME
 	section::name = section::Name::LOGO;
 	section::attract_mode = section::AttractMode::TITLE_TO_DEMO;
@@ -388,29 +388,31 @@ void Director::setFileList()
 	Asset::get()->add(prefix + "/data/music/credits.ogg", AssetType::MUSIC);
 
 	// Sonidos
-	Asset::get()->add(prefix + "/data/sound/game_start.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/balloon.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/bubble1.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/bubble2.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/bubble3.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/bubble4.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/bullet.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/clock.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/coffeeout.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/continue_clock.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/game_start.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/hiscore.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/itemdrop.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/itempickup.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/player_collision.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/stage_change.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/title.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/clock.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/powerball.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/notify.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/logo.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/voice_coffee.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/voice_power_up.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/voice_no.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/voice_get_ready.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/notify.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/player_collision.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/powerball.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/stage_change.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/tabe.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/title.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/voice_coffee.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/voice_get_ready.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/voice_no.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/voice_power_up.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/walk.wav", AssetType::SOUND);
 
 	// Shaders
 	Asset::get()->add(prefix + "/data/shaders/crtpi_256.glsl", AssetType::DATA);
@@ -503,17 +505,17 @@ void Director::setFileList()
 
 	{ // Jugador 1
 		Asset::get()->add(prefix + "/data/gfx/player/player1.gif", AssetType::BITMAP);
-		Asset::get()->add(prefix + "/data/gfx/player/player1_one_coffee_palette.pal", AssetType::PALETTE);
-		Asset::get()->add(prefix + "/data/gfx/player/player1_two_coffee_palette.pal", AssetType::PALETTE);
-		Asset::get()->add(prefix + "/data/gfx/player/player1_all_white_palette.pal", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player1_1_coffee_palette.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player1_2_coffee_palette.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player1_invencible_palette.gif", AssetType::PALETTE);
 		Asset::get()->add(prefix + "/data/gfx/player/player1_power.png", AssetType::BITMAP);
 	}
 
 	{ // Jugador 2
 		Asset::get()->add(prefix + "/data/gfx/player/player2.gif", AssetType::BITMAP);
-		Asset::get()->add(prefix + "/data/gfx/player/player2_one_coffee_palette.pal", AssetType::PALETTE);
-		Asset::get()->add(prefix + "/data/gfx/player/player2_two_coffee_palette.pal", AssetType::PALETTE);
-		Asset::get()->add(prefix + "/data/gfx/player/player2_all_white_palette.pal", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player2_1_coffee_palette.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player2_2_coffee_palette.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player2_invencible_palette.gif", AssetType::PALETTE);
 		Asset::get()->add(prefix + "/data/gfx/player/player2_power.png", AssetType::BITMAP);
 	}
 

source/fade.cpp

@@ -30,15 +30,15 @@ void Fade::init()
 {
 	type_ = FadeType::CENTER;
 	mode_ = FadeMode::OUT;
-	enabled_ = false;
-	finished_ = false;
 	counter_ = 0;
 	r_ = 0;
 	g_ = 0;
 	b_ = 0;
 	a_ = 0;
-	post_duration_ = 20;
+	post_duration_ = 0;
 	post_counter_ = 0;
+	pre_duration_ = 0;
+	pre_counter_ = 0;
 	num_squares_width_ = param.fade.num_squares_width;
 	num_squares_height_ = param.fade.num_squares_height;
 	fade_random_squares_delay_ = param.fade.random_squares_delay;
@@ -48,15 +48,14 @@ void Fade::init()
 // Resetea algunas variables para volver a hacer el fade sin perder ciertos parametros
 void Fade::reset()
 {
-	enabled_ = false;
-	finished_ = false;
+	state_ = FadeState::NOT_ENABLED;
 	counter_ = 0;
 }
 
 // Pinta una transición en pantalla
 void Fade::render()
 {
-	if (enabled_ || finished_)
+	//if (state_ != FadeState::NOT_ENABLED)
 	{
 		SDL_RenderCopy(renderer_, backbuffer_, nullptr, nullptr);
 	}
@@ -65,7 +64,20 @@ void Fade::render()
 // Actualiza las variables internas
 void Fade::update()
 {
-	if (enabled_)
+	if (state_ == FadeState::PRE)
+	{
+		// Actualiza el contador
+		if (pre_counter_ == pre_duration_)
+		{
+			state_ = FadeState::FADING;
+		}
+		else
+		{
+			pre_counter_++;
+		}
+	}
+
+	if (state_ == FadeState::FADING)
 	{
 		switch (type_)
 		{
@@ -79,7 +91,7 @@ void Fade::update()
 			// Comprueba si ha terminado
 			if (counter_ >= 255 / 4)
 			{
-				finished_ = true;
+				state_ = FadeState::POST;
 			}
 
 			break;
@@ -110,7 +122,7 @@ void Fade::update()
 			// Comprueba si ha terminado
 			if ((counter_ * 4) > param.game.height)
 			{
-				finished_ = true;
+				state_ = FadeState::POST;
 				a_ = 255;
 			}
 			break;
@@ -143,7 +155,7 @@ void Fade::update()
 			// Comprueba si ha terminado
 			if (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_ >= num_squares_width_ * num_squares_height_)
 			{
-				finished_ = true;
+				state_ = FadeState::POST;
 			}
 
 			break;
@@ -151,7 +163,7 @@ void Fade::update()
 
 		case FadeType::VENETIAN:
 		{
-			// Counter debe ir de 0 a 150
+			// Counter debe ir de 0 a 150 <-- comprobar si esto es aún cierto
 			if (square_.back().h < param.fade.venetian_size)
 			{
 				// Dibuja sobre el backbuffer_
@@ -176,42 +188,60 @@ void Fade::update()
 					// A partir del segundo rectangulo se pinta en función del anterior
 					square_.at(i).h = i == 0 ? h : std::max(square_.at(i - 1).h - 2, 0);
 				}
+
+				int completed = 0;
+				for (const auto &square : square_)
+				{
+					if (square.h >= param.fade.venetian_size)
+					{
+						++completed;
+					}
+				}
+				value_ = calculateValue(0, square_.size() - 1, completed);
 			}
 			else
 			{
-				finished_ = true;
+				state_ = FadeState::POST;
 			}
 
 			break;
 		}
+		default:
+			break;
 		}
-
-		if (finished_)
-		{
-			// Actualiza el contador
-			post_counter_ == post_duration_ ? enabled_ = false : post_counter_++;
-
-			// Deja el backbuffer_ todo del mismo color
-			cleanBackbuffer(r_, g_, b_, a_);
-		}
-
 		counter_++;
 	}
+
+	if (state_ == FadeState::POST)
+	{
+		// Actualiza el contador
+		if (post_counter_ == post_duration_)
+		{
+			state_ = FadeState::FINISHED;
+		}
+		else
+		{
+			post_counter_++;
+		}
+
+		// Deja el backbuffer_ todo del mismo color
+		cleanBackbuffer(r_, g_, b_, a_);
+	}
 }
 
 // Activa el fade
 void Fade::activate()
 {
 	// Si ya está habilitado, no hay que volverlo a activar
-	if (enabled_)
+	if (state_ != FadeState::NOT_ENABLED)
 	{
 		return;
 	}
 
-	enabled_ = true;
-	finished_ = false;
+	state_ = FadeState::PRE;
 	counter_ = 0;
 	post_counter_ = 0;
+	pre_counter_ = 0;
 
 	switch (type_)
 	{
@@ -315,9 +345,15 @@ void Fade::cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a)
 // Calcula el valor del estado del fade
 int Fade::calculateValue(int min, int max, int current)
 {
-	if (max == 0)
+	if (current < min)
 	{
 		return 0;
 	}
-	return std::clamp(current * 100 / max, 0, 100);
+
+	if (current > max)
+	{
+		return 100;
+	}
+
+	return static_cast<int>(100.0 * (current - min) / (max - min));
 }

source/fade.h

@@ -21,6 +21,16 @@ enum class FadeMode : Uint8
 	OUT = 1,
 };
 
+// Estados del objeto
+enum class FadeState : Uint8
+{
+	NOT_ENABLED = 0,
+	PRE = 1,
+	FADING = 2,
+	POST = 3,
+	FINISHED = 4,
+};
+
 // Clase Fade
 class Fade
 {
@@ -30,22 +40,23 @@ private:
 	SDL_Texture *backbuffer_; // Textura para usar como backbuffer con SDL_TEXTUREACCESS_TARGET
 
 	// Variables
-	FadeType type_;					// Tipo de fade a realizar
-	FadeMode mode_;					// Modo de fade a realizar
-	Uint16 counter_;				// Contador interno
-	bool enabled_;					// Indica si el fade está activo
-	bool finished_;					// Indica si ha terminado la transición
-	Uint8 r_, g_, b_, a_;			// Colores para el fade
-	SDL_Rect rect1_;				// Rectangulo usado para crear los efectos de transición
-	SDL_Rect rect2_;				// Rectangulo usado para crear los efectos de transición
-	int num_squares_width_;			// Cantidad total de cuadraditos en horizontal para el FadeType::RANDOM_SQUARE
-	int num_squares_height_;		// Cantidad total de cuadraditos en vertical para el FadeType::RANDOM_SQUARE
-	std::vector<SDL_Rect> square_;	// Vector con los indices de los cuadrados para el FadeType::RANDOM_SQUARE
-	int fade_random_squares_delay_; // Duración entre cada pintado de cuadrados
-	int fade_random_squares_mult_;	// Cantidad de cuadrados que se pintaran cada vez
-	int post_duration_;				// Duración posterior del fade tras finalizar
-	int post_counter_;				// Contador para la duración posterior
-	int value_ = 0;					// Estado actual del fade entre 0 y 100
+	FadeType type_;							   // Tipo de fade a realizar
+	FadeMode mode_;							   // Modo de fade a realizar
+	FadeState state_ = FadeState::NOT_ENABLED; // Estado actual del objeto
+	Uint16 counter_;						   // Contador interno
+	Uint8 r_, g_, b_, a_;					   // Colores para el fade
+	SDL_Rect rect1_;						   // Rectangulo usado para crear los efectos de transición
+	SDL_Rect rect2_;						   // Rectangulo usado para crear los efectos de transición
+	int num_squares_width_;					   // Cantidad total de cuadraditos en horizontal para el FadeType::RANDOM_SQUARE
+	int num_squares_height_;				   // Cantidad total de cuadraditos en vertical para el FadeType::RANDOM_SQUARE
+	std::vector<SDL_Rect> square_;			   // Vector con los indices de los cuadrados para el FadeType::RANDOM_SQUARE
+	int fade_random_squares_delay_;			   // Duración entre cada pintado de cuadrados
+	int fade_random_squares_mult_;			   // Cantidad de cuadrados que se pintaran cada vez
+	int post_duration_ = 0;					   // Duración posterior del fade tras finalizar
+	int post_counter_ = 0;					   // Contador para la duración posterior
+	int pre_duration_ = 0;					   // Duración previa del fade antes de iniciar
+	int pre_counter_ = 0;					   // Contador para la duración previa
+	int value_ = 0;							   // Estado actual del fade entre 0 y 100
 
 	// Inicializa las variables
 	void init();
@@ -80,11 +91,12 @@ public:
 
 	// Getters
 	int getValue() const { return value_; }
-	bool isEnabled() const { return enabled_; }
-	bool hasEnded() const { return !enabled_ && finished_; }
+	bool isEnabled() const { return state_ != FadeState::NOT_ENABLED; }
+	bool hasEnded() const { return state_ == FadeState::FINISHED; }
 
 	// Setters
 	void setType(FadeType type) { type_ = type; }
 	void setMode(FadeMode mode) { mode_ = mode; }
-	void setPost(int value) { post_duration_ = value; }
+	void setPostDuration(int value) { post_duration_ = value; }
+	void setPreDuration(int value) { pre_duration_ = value; }
 };

source/game.cpp

@@ -35,7 +35,8 @@
 #include "tabe.h"				  // Para Tabe
 #include "text.h"				  // Para Text
 #include "texture.h"			  // Para Texture
-struct JA_Sound_t;				  // lines 37-37
+#include "mouse.h"
+struct JA_Sound_t; // lines 37-37
 
 // Constructor
 Game::Game(int player_id, int current_stage, bool demo)
@@ -67,13 +68,14 @@ Game::Game(int player_id, int current_stage, bool demo)
 	scoreboard_ = Scoreboard::get();
 
 	fade_in_->setColor(fade_color.r, fade_color.g, fade_color.b);
-	fade_in_->setPost(0);
+	fade_in_->setPreDuration(demo_.enabled ? 80 : 0);
+	fade_in_->setPostDuration(0);
 	fade_in_->setType(FadeType::RANDOM_SQUARE);
 	fade_in_->setMode(FadeMode::IN);
 	fade_in_->activate();
 
 	fade_out_->setColor(fade_color.r, fade_color.g, fade_color.b);
-	fade_out_->setPost(param.fade.post_duration);
+	fade_out_->setPostDuration(param.fade.post_duration);
 	fade_out_->setType(FadeType::VENETIAN);
 
 	background_->setPos(param.game.play_area.rect);
@@ -254,145 +256,156 @@ void Game::renderPlayers()
 // Comprueba si hay cambio de fase y actualiza las variables
 void Game::updateStage()
 {
-	if (state_ == GameState::PLAYING)
+	if (Stage::power >= Stage::get(Stage::number).power_to_complete)
 	{
-		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;
-			JA_PlaySound(Resource::get()->getSound("stage_change.wav"));
-			balloon_manager_->resetBalloonSpeed();
-			screen_->flash(flash_color, 3);
-			screen_->shake();
+		// Cambio de fase
+		Stage::power = Stage::get(Stage::number).power_to_complete - Stage::power;
+		++Stage::number;
+		JA_PlaySound(Resource::get()->getSound("stage_change.wav"));
+		balloon_manager_->resetBalloonSpeed();
+		screen_->flash(flash_color, 3);
+		screen_->shake();
 
-			// Escribe el texto por pantalla
-			if (Stage::number < 10)
+		// Escribe el texto por pantalla
+		if (Stage::number < 10)
+		{
+			std::vector<Path> paths = {paths_.at(2), paths_.at(3)};
+			if (Stage::number == 9)
 			{
-				std::vector<Path> paths = {paths_.at(2), paths_.at(3)};
-				if (Stage::number == 9)
-				{
-					createMessage(paths, Resource::get()->getTexture("game_text_last_stage"));
-				}
-				else
-				{
-					auto text = Resource::get()->getText("04b_25_2x");
-					const std::string caption = std::to_string(10 - Stage::number) + lang::getText(38);
-					createMessage(paths, text->writeToTexture(caption, 1, -4));
-				}
+				createMessage(paths, Resource::get()->getTexture("game_text_last_stage"));
 			}
-		}
-	}
-}
-
-// Actualiza el estado de fade in
-void Game::updateFadeInState()
-{
-	if (state_ == GameState::FADE_IN)
-	{
-		if (fade_in_->hasEnded())
-		{
-			state_ = GameState::PLAYING;
-
-			// Crea los primeros globos y el mensaje de inicio
-			if (!demo_.enabled)
+			else
 			{
-				balloon_manager_->createTwoBigBalloons();
-				evaluateAndSetMenace();
-				createMessage({paths_.at(0), paths_.at(1)}, Resource::get()->getTexture("game_text_get_ready"));
-				JA_PlaySound(Resource::get()->getSound("voice_get_ready.wav"));
+				auto text = Resource::get()->getText("04b_25_2x");
+				const std::string caption = std::to_string(10 - Stage::number) + lang::getText(38);
+				createMessage(paths, text->writeToTexture(caption, 1, -4));
 			}
 		}
 	}
 }
 
 // Actualiza el estado de fin de la partida
-void Game::updateGameOverState()
+void Game::updateGameStateGameOver()
 {
-	if (state_ == GameState::GAME_OVER)
+	fade_out_->update();
+	updatePlayers();
+	updateScoreboard();
+	updateBackground();
+	balloon_manager_->update();
+	tabe_->update();
+	updateBullets();
+	updateItems();
+	updateSmartSprites();
+	updatePathSprites();
+	updateTimeStopped();
+	checkBulletBalloonCollision();
+	cleanVectors();
+
+	if (game_over_counter_ > 0)
 	{
-		if (game_over_counter_ > 0)
+		if (game_over_counter_ == GAME_OVER_COUNTER_)
 		{
-			if (game_over_counter_ == GAME_OVER_COUNTER_)
-			{
-				createMessage({paths_.at(2), paths_.at(3)}, Resource::get()->getTexture("game_text_game_over"));
-				JA_FadeOutMusic(1000);
-				balloon_manager_->setSounds(true);
-			}
-
-			game_over_counter_--;
-
-			if (game_over_counter_ == 150)
-			{
-				fade_out_->activate();
-			}
+			createMessage({paths_.at(2), paths_.at(3)}, Resource::get()->getTexture("game_text_game_over"));
+			JA_FadeOutMusic(1000);
+			balloon_manager_->setSounds(true);
 		}
 
-		if (fade_out_->hasEnded())
+		game_over_counter_--;
+
+		if (game_over_counter_ == 150)
 		{
-			if (game_completed_counter_ > 0)
-			{
-				// Los jugadores han completado el juego
-				section::name = section::Name::CREDITS;
-			}
-			else
-			{
-				// La partida ha terminado con la derrota de los jugadores
-				section::name = section::Name::HI_SCORE_TABLE;
-			}
+			fade_out_->activate();
 		}
 	}
+
+	if (fade_out_->isEnabled())
+	{
+		const float vol = static_cast<float>(64 * (100 - fade_out_->getValue())) / 100.0f;
+		JA_SetSoundVolume(to_JA_volume(static_cast<int>(vol)));
+	}
+
+	if (fade_out_->hasEnded())
+	{
+		if (game_completed_counter_ > 0)
+		{
+			// Los jugadores han completado el juego
+			section::name = section::Name::CREDITS;
+		}
+		else
+		{
+			// La partida ha terminado con la derrota de los jugadores
+			section::name = section::Name::HI_SCORE_TABLE;
+		}
+		JA_StopChannel(-1);
+		JA_SetSoundVolume(to_JA_volume(options.audio.sound.volume));
+	}
 }
 
 // Gestiona eventos para el estado del final del juego
-void Game::updateCompletedState()
+void Game::updateGameStateCompleted()
 {
-	if (state_ == GameState::COMPLETED)
+	updatePlayers();
+	updateScoreboard();
+	updateBackground();
+	balloon_manager_->update();
+	tabe_->update();
+	updateBullets();
+	updateItems();
+	updateSmartSprites();
+	updatePathSprites();
+	cleanVectors();
+
+	// Para la música y elimina todos los globos e items
+	if (game_completed_counter_ == 0)
 	{
-		// Para la música y elimina todos los globos e items
-		if (game_completed_counter_ == 0)
-		{
-			stopMusic();
-			Stage::number = 9;						// Deja el valor dentro de los limites
-			balloon_manager_->destroyAllBalloons(); // Destruye a todos los globos
-			destroyAllItems();						// Destruye todos los items
-			Stage::power = 0;						// Vuelve a dejar el poder a cero, por lo que hubiera podido subir al destruir todos los globos
-		}
-
-		// Comienza las celebraciones
-		// Muestra el mensaje de felicitación y da los puntos a los jugadores
-		if (game_completed_counter_ == 200)
-		{
-			createMessage({paths_.at(4), paths_.at(5)}, Resource::get()->getTexture("game_text_congratulations"));
-			createMessage({paths_.at(6), paths_.at(7)}, Resource::get()->getTexture("game_text_1000000_points"));
-
-			for (auto &player : players_)
-				if (player->isPlaying())
-				{
-					player->addScore(1000000);
-					player->setPlayingState(PlayerState::CELEBRATING);
-				}
-				else
-				{
-					player->setPlayingState(PlayerState::GAME_OVER);
-				}
-
-			updateHiScore();
-		}
-
-		// Termina las celebraciones
-		if (game_completed_counter_ == 500)
-		{
-			for (auto &player : players_)
-				if (player->isCelebrating())
-				{
-					player->setPlayingState(player->IsEligibleForHighScore() ? PlayerState::ENTERING_NAME_GAME_COMPLETED : PlayerState::LEAVING_SCREEN);
-				}
-		}
-
-		// Incrementa el contador al final
-		++game_completed_counter_;
+		stopMusic();
+		Stage::number = 9;						// Deja el valor dentro de los limites
+		balloon_manager_->destroyAllBalloons(); // Destruye a todos los globos
+		destroyAllItems();						// Destruye todos los items
+		Stage::power = 0;						// Vuelve a dejar el poder a cero, por lo que hubiera podido subir al destruir todos los globos
 	}
+
+	// Comienza las celebraciones
+	// Muestra el mensaje de felicitación y da los puntos a los jugadores
+	if (game_completed_counter_ == 200)
+	{
+		createMessage({paths_.at(4), paths_.at(5)}, Resource::get()->getTexture("game_text_congratulations"));
+		createMessage({paths_.at(6), paths_.at(7)}, Resource::get()->getTexture("game_text_1000000_points"));
+
+		for (auto &player : players_)
+			if (player->isPlaying())
+			{
+				player->addScore(1000000);
+				player->setPlayingState(PlayerState::CELEBRATING);
+			}
+			else
+			{
+				player->setPlayingState(PlayerState::GAME_OVER);
+			}
+
+		updateHiScore();
+	}
+
+	// Termina las celebraciones
+	if (game_completed_counter_ == 500)
+	{
+		for (auto &player : players_)
+		{
+			if (player->isCelebrating())
+			{
+				player->setPlayingState(player->IsEligibleForHighScore() ? PlayerState::ENTERING_NAME_GAME_COMPLETED : PlayerState::LEAVING_SCREEN);
+			}
+		}
+	}
+
+	// Si los jugadores ya no estan y no quedan mensajes en pantalla
+	if (allPlayersAreGameOver() && path_sprites_.size() == 0)
+	{
+		state_ = GameState::GAME_OVER;
+	}
+
+	// Incrementa el contador al final
+	++game_completed_counter_;
 }
 
 // Comprueba el estado del juego
@@ -542,17 +555,17 @@ void Game::checkBulletBalloonCollision()
 					auto player = getPlayer(bullet->getOwner());
 
 					// Suelta el item si se da el caso
-					const auto droppeditem = dropItem();
-					if (droppeditem != ItemType::NONE && !demo_.recording)
+					const auto dropped_item = dropItem();
+					if (dropped_item != ItemType::NONE && !demo_.recording)
 					{
-						if (droppeditem != ItemType::COFFEE_MACHINE)
+						if (dropped_item != ItemType::COFFEE_MACHINE)
 						{
-							createItem(droppeditem, balloon->getPosX(), balloon->getPosY());
+							createItem(dropped_item, balloon->getPosX(), balloon->getPosY());
 							JA_PlaySound(Resource::get()->getSound("itemdrop.wav"));
 						}
 						else
 						{
-							createItem(droppeditem, player->getPosX(), 0);
+							createItem(dropped_item, player->getPosX(), param.game.game_area.rect.y - param.game.coffee_machine_h);
 							coffee_machine_enabled_ = true;
 						}
 					}
@@ -583,11 +596,15 @@ void Game::checkBulletBalloonCollision()
 }
 
 // Mueve las balas activas
-void Game::moveBullets()
+void Game::updateBullets()
 {
 	for (auto &bullet : bullets_)
+	{
 		if (bullet->move() == BulletMoveStatus::OUT)
+		{
 			getPlayer(bullet->getOwner())->decScoreMultiplier();
+		}
+	}
 }
 
 // Pinta las balas activas
@@ -802,35 +819,44 @@ void Game::throwCoffee(int x, int y)
 void Game::updateSmartSprites()
 {
 	for (auto &sprite : smart_sprites_)
+	{
 		sprite->update();
+	}
 }
 
 // Pinta los SmartSprites activos
 void Game::renderSmartSprites()
 {
 	for (auto &sprite : smart_sprites_)
+	{
 		sprite->render();
+	}
 }
 
 // Actualiza los PathSprites
 void Game::updatePathSprites()
 {
 	for (auto &sprite : path_sprites_)
+	{
 		sprite->update();
+	}
 }
 
 // Pinta los PathSprites activos
 void Game::renderPathSprites()
 {
 	for (auto &sprite : path_sprites_)
+	{
 		sprite->render();
+	}
 }
 
 // Acciones a realizar cuando el jugador muere
 void Game::killPlayer(std::shared_ptr<Player> &player)
 {
 	if (!player->isPlaying() || player->isInvulnerable())
-	{ // Si no está jugando o tiene inmunidad, no hace nada
+	{ 
+		 // Si no está jugando o tiene inmunidad, no hace nada
 		return;
 	}
 
@@ -846,12 +872,16 @@ void Game::killPlayer(std::shared_ptr<Player> &player)
 	else
 	{
 		// Si no tiene cafes, muere
-		// pauseMusic();
 		balloon_manager_->stopAllBalloons();
 		JA_PlaySound(Resource::get()->getSound("player_collision.wav"));
 		screen_->shake();
 		JA_PlaySound(Resource::get()->getSound("voice_no.wav"));
 		player->setPlayingState(PlayerState::DYING);
+		if (allPlayersAreNotPlaying())
+		{
+			// No se puede subir poder de fase si no hay nadie jugando
+			Stage::power_can_be_added = false;
+		}
 	}
 }
 
@@ -891,11 +921,36 @@ void Game::update()
 		counter_++;
 
 		updateDemo();
-
 #ifdef RECORDING
 		updateRecording();
 #endif
-		updateGame();
+		if (!paused_)
+		{
+			switch (state_)
+			{
+			case GameState::COMPLETED:
+				updateGameStateCompleted();
+				break;
+			case GameState::GAME_OVER:
+				updateGameStateGameOver();
+				break;
+			case GameState::PLAYING:
+				updateGameStatePlaying();
+				break;
+			case GameState::FADE_IN:
+				updateGameStateFadeIn();
+				break;
+			case GameState::ENTERING_PLAYER:
+				updateGameStateEnteringPlayer();
+				break;
+			case GameState::SHOWING_GET_READY_MESSAGE:
+				updateGameStateShowingGetReadyMessage();
+				break;
+
+			default:
+				break;
+			}
+		}
 
 		checkMusicStatus();
 		screen_->update();
@@ -991,7 +1046,7 @@ void Game::disableTimeStopItem()
 void Game::checkMusicStatus()
 {
 	// Si se ha completado el juego o los jugadores han terminado, detiene la música
-	if (state_ != GameState::COMPLETED && !allPlayersAreGameOver())
+	if (state_ == GameState::PLAYING || state_ == GameState::SHOWING_GET_READY_MESSAGE)
 	{
 		playMusic();
 	}
@@ -1194,7 +1249,7 @@ void Game::checkEvents()
 			}
 			case SDLK_6: // Crea un mensaje
 			{
-				createMessage({paths_.at(2), paths_.at(3)}, Resource::get()->getTexture("game_text_congratulations"));
+				createMessage({paths_.at(0), paths_.at(1)}, Resource::get()->getTexture("game_text_get_ready"));
 				break;
 			}
 			case SDLK_7: // Flash
@@ -1204,7 +1259,14 @@ void Game::checkEvents()
 			}
 			case SDLK_8:
 			{
-				players_.at(0)->setPlayingState(PlayerState::LEAVING_SCREEN);
+				for (auto player : players_)
+				{
+					if (player->isPlaying())
+					{
+						createItem(ItemType::COFFEE_MACHINE, player->getPosX(), param.game.game_area.rect.y - param.game.coffee_machine_h);
+						break;
+					}
+				}
 				break;
 			}
 			case SDLK_9:
@@ -1217,6 +1279,8 @@ void Game::checkEvents()
 			}
 		}
 #endif
+		// Comprueba el cursor
+		Mouse::handleEvent(event);
 	}
 }
 
@@ -1426,8 +1490,11 @@ void Game::handleFireInput(const std::shared_ptr<Player> &player, BulletType bul
 																												: InputType::FIRE_RIGHT);
 		createBullet(player->getPosX() + (player->getWidth() / 2) - 6, player->getPosY() + (player->getHeight() / 2), bulletType, player->isPowerUp(), player->getId());
 		JA_PlaySound(Resource::get()->getSound("bullet.wav"));
+
 		// Establece un tiempo de espera para el próximo disparo.
-		player->setFireCooldown(10);
+		const int cooldown = player->isPowerUp() ? 5 : options.game.autofire ? 10
+																			 : 7;
+		player->setFireCooldown(cooldown);
 	}
 }
 
@@ -1437,15 +1504,18 @@ void Game::handlePlayersInput()
 	for (const auto &player : players_)
 	{
 		if (player->isPlaying())
-		{ // Maneja el input de los jugadores en modo normal.
+		{
+			// Maneja el input de los jugadores en modo normal.
 			handleNormalPlayerInput(player);
 		}
 		else if (player->isContinue() || player->isWaiting())
-		{ // Gestiona la continuación del jugador.
+		{
+			// Gestiona la continuación del jugador.
 			handlePlayerContinue(player);
 		}
 		else if (player->isEnteringName() || player->isEnteringNameGameCompleted())
-		{ // Gestiona la introducción del nombre del jugador.
+		{
+			// Gestiona la introducción del nombre del jugador.
 			handleNameInput(player);
 		}
 	}
@@ -1538,8 +1608,8 @@ void Game::handleNameInput(const std::shared_ptr<Player> &player)
 		{
 			player->setInput(InputType::START);
 			addScoreToScoreBoard(player->getRecordName(), player->getScore());
-			const auto status = player->getPlayingState();
-			player->setPlayingState(status == PlayerState::ENTERING_NAME ? PlayerState::CONTINUE : PlayerState::LEAVING_SCREEN);
+			const auto state = player->getPlayingState();
+			player->setPlayingState(state == PlayerState::ENTERING_NAME ? PlayerState::CONTINUE : PlayerState::LEAVING_SCREEN);
 		}
 		else
 		{
@@ -1562,8 +1632,8 @@ void Game::handleNameInput(const std::shared_ptr<Player> &player)
 	{
 		player->setInput(InputType::START);
 		addScoreToScoreBoard(player->getRecordName(), player->getScore());
-		const auto status = player->getPlayingState();
-		player->setPlayingState(status == PlayerState::ENTERING_NAME ? PlayerState::CONTINUE : PlayerState::LEAVING_SCREEN);
+		const auto state = player->getPlayingState();
+		player->setPlayingState(state == PlayerState::ENTERING_NAME ? PlayerState::CONTINUE : PlayerState::LEAVING_SCREEN);
 	}
 }
 
@@ -1572,11 +1642,16 @@ void Game::initDemo(int player_id)
 {
 	if (demo_.enabled)
 	{
+		// Cambia el estado del juego
+		state_ = GameState::PLAYING;
+
 		// Aleatoriza la asignación del fichero con los datos del modo demostracion
-		const auto demo1 = rand() % 2;
-		const auto demo2 = (demo1 == 0) ? 1 : 0;
-		demo_.data.emplace_back(Resource::get()->getDemoData(demo1));
-		demo_.data.emplace_back(Resource::get()->getDemoData(demo2));
+		{
+			const auto demo1 = rand() % 2;
+			const auto demo2 = (demo1 == 0) ? 1 : 0;
+			demo_.data.emplace_back(Resource::get()->getDemoData(demo1));
+			demo_.data.emplace_back(Resource::get()->getDemoData(demo2));
+		}
 
 		// Selecciona una pantalla al azar
 		{
@@ -1593,7 +1668,7 @@ void Game::initDemo(int player_id)
 		}
 
 		// Activa o no al otro jugador
-		if (rand() % 2 == 0)
+		if (rand() % 3 != 0)
 		{
 			const auto other_player_id = player_id == 1 ? 2 : 1;
 			auto other_player = getPlayer(other_player_id);
@@ -1606,7 +1681,7 @@ void Game::initDemo(int player_id)
 			for (int i = 0; i < rand() % 3; ++i)
 				player->giveExtraHit();
 
-			player->setInvulnerable(false);
+			player->setInvulnerable(true);
 		}
 
 		// Deshabilita los sonidos
@@ -1615,6 +1690,9 @@ void Game::initDemo(int player_id)
 		// Configura los marcadores
 		scoreboard_->setMode(SCOREBOARD_LEFT_PANEL, ScoreboardMode::DEMO);
 		scoreboard_->setMode(SCOREBOARD_RIGHT_PANEL, ScoreboardMode::DEMO);
+
+		// Añade unos cuantos globos
+		// balloon_manager_->createRandomBalloons();
 	}
 
 	// Modo grabar demo
@@ -1705,7 +1783,7 @@ void Game::initPlayers(int player_id)
 
 	// Activa el jugador que coincide con el "player_id"
 	auto player = getPlayer(player_id);
-	player->setPlayingState(PlayerState::PLAYING);
+	player->setPlayingState((demo_.enabled) ? PlayerState::PLAYING : PlayerState::ENTERING_SCREEN);
 	player->setInvulnerable(false);
 }
 
@@ -1751,9 +1829,17 @@ void Game::updateDemo()
 {
 	if (demo_.enabled)
 	{
+		balloon_manager_->setCreationTimeEnabled((balloon_manager_->getNumBalloons() == 0) ? false : true);
+
+		// Actualiza ambos fades
+		fade_in_->update();
+		fade_out_->update();
+
 		// Incrementa el contador de la demo
 		if (demo_.counter < TOTAL_DEMO_DATA)
+		{
 			demo_.counter++;
+		}
 
 		// Activa el fundido antes de acabar con los datos de la demo
 		if (demo_.counter == TOTAL_DEMO_DATA - 200)
@@ -1791,43 +1877,83 @@ void Game::updateRecording()
 }
 #endif
 
-// Actualiza las variables durante el transcurso normal del juego
-void Game::updateGame()
+// Actualiza las variables durante dicho estado
+void Game::updateGameStateFadeIn()
 {
-	if (!paused_)
+	fade_in_->update();
+	updateScoreboard();
+	updateBackground();
+	if (fade_in_->hasEnded())
 	{
-#ifdef DEBUG
-		if (auto_pop_balloons_ && state_ == GameState::PLAYING)
-		{
-			Stage::addPower(5);
-		}
-#endif
-		fade_in_->update();
-		fade_out_->update();
-		updatePlayers();
-		checkPlayersStatusPlaying();
-		updateScoreboard();
-		updateBackground();
-		balloon_manager_->update();
-		tabe_->update();
-		moveBullets();
-		updateItems();
-		updateStage();
-		updateFadeInState();
-		updateGameOverState();
-		updateCompletedState();
-		updateSmartSprites();
-		updatePathSprites();
-		updateTimeStopped();
-		updateHelper();
-		checkBulletBalloonCollision();
-		updateMenace();
-		checkAndUpdateBalloonSpeed();
-		checkState();
-		cleanVectors();
+		state_ = GameState::ENTERING_PLAYER;
+		balloon_manager_->createTwoBigBalloons();
+		evaluateAndSetMenace();
 	}
 }
 
+// Actualiza las variables durante dicho estado
+void Game::updateGameStateEnteringPlayer()
+{
+	balloon_manager_->update();
+	updatePlayers();
+	updateScoreboard();
+	updateBackground();
+	for (auto player : players_)
+	{
+		if (player->isPlaying())
+		{
+			state_ = GameState::SHOWING_GET_READY_MESSAGE;
+			createMessage({paths_.at(0), paths_.at(1)}, Resource::get()->getTexture("game_text_get_ready"));
+			JA_PlaySound(Resource::get()->getSound("voice_get_ready.wav"));
+		}
+	}
+}
+
+// Actualiza las variables durante dicho estado
+void Game::updateGameStateShowingGetReadyMessage()
+{
+	balloon_manager_->update();
+	updatePathSprites();
+	updatePlayers();
+	updateBullets();
+	updateScoreboard();
+	updateBackground();
+	freePathSprites();
+	if (path_sprites_.size() == 0)
+	{
+		state_ = GameState::PLAYING;
+	}
+}
+
+// Actualiza las variables durante el transcurso normal del juego
+void Game::updateGameStatePlaying()
+{
+#ifdef DEBUG
+	if (auto_pop_balloons_)
+	{
+		Stage::addPower(20);
+	}
+#endif
+	updatePlayers();
+	checkPlayersStatusPlaying();
+	updateScoreboard();
+	updateBackground();
+	balloon_manager_->update();
+	tabe_->update();
+	updateBullets();
+	updateItems();
+	updateStage();
+	updateSmartSprites();
+	updatePathSprites();
+	updateTimeStopped();
+	updateHelper();
+	checkBulletBalloonCollision();
+	updateMenace();
+	checkAndUpdateBalloonSpeed();
+	checkState();
+	cleanVectors();
+}
+
 // Vacía los vectores de elementos deshabilitados
 void Game::cleanVectors()
 {

source/game.h

@@ -67,6 +67,8 @@ private:
 	enum class GameState
 	{
 		FADE_IN,
+		ENTERING_PLAYER,
+		SHOWING_GET_READY_MESSAGE,
 		PLAYING,
 		COMPLETED,
 		GAME_OVER,
@@ -197,11 +199,8 @@ private:
 	// Comprueba si hay cambio de fase y actualiza las variables
 	void updateStage();
 
-	// Actualiza el estado de fade in
-	void updateFadeInState();
-
 	// Actualiza el estado de fin de la partida
-	void updateGameOverState();
+	void updateGameStateGameOver();
 
 	// Destruye todos los items
 	void destroyAllItems();
@@ -216,7 +215,7 @@ private:
 	void checkBulletBalloonCollision();
 
 	// Mueve las balas activas
-	void moveBullets();
+	void updateBullets();
 
 	// Pinta las balas activas
 	void renderBullets();
@@ -392,11 +391,20 @@ private:
 	// Actualiza las variables durante el modo de grabación
 	void updateRecording();
 #endif
+	// Actualiza las variables durante dicho estado
+	void updateGameStateFadeIn();
+
+	// Actualiza las variables durante dicho estado
+	void updateGameStateEnteringPlayer();
+
+	// Actualiza las variables durante dicho estado
+	void updateGameStateShowingGetReadyMessage();
+
 	// Actualiza las variables durante el transcurso normal del juego
-	void updateGame();
+	void updateGameStatePlaying();
 
 	// Gestiona eventos para el estado del final del juego
-	void updateCompletedState();
+	void updateGameStateCompleted();
 
 	// Comprueba el estado del juego
 	void checkState();

source/hiscore_table.cpp

@@ -20,6 +20,7 @@
 #include "section.h"			  // Para Name, name, Options, options
 #include "text.h"				  // Para Text, TEXT_CENTER, TEXT_SHADOW
 #include "utils.h"				  // Para Color, Zone, fade_color, orange_color
+#include "mouse.h"
 
 // Constructor
 HiScoreTable::HiScoreTable()
@@ -44,7 +45,7 @@ HiScoreTable::HiScoreTable()
 	background_->setTransition(0.8f);
 	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
 	fade_->setType(FadeType::RANDOM_SQUARE);
-	fade_->setPost(param.fade.post_duration);
+	fade_->setPostDuration(param.fade.post_duration);
 	fade_->setMode(fade_mode_);
 	fade_->activate();
 
@@ -78,7 +79,7 @@ void HiScoreTable::update()
 		Screen::get()->update();
 
 		// Actualiza las variables de globalInputs
-        globalInputs::update();
+		globalInputs::update();
 
 		// Actualiza el fondo
 		background_->update();
@@ -196,6 +197,9 @@ void HiScoreTable::checkEvents()
 				reloadTextures();
 			}
 		}
+
+		// Comprueba el cursor
+		Mouse::handleEvent(event);
 	}
 }
 
@@ -205,7 +209,7 @@ void HiScoreTable::checkInput()
 	// Comprueba si se ha pulsado cualquier botón (de los usados para jugar)
 	if (Input::get()->checkAnyButtonPressed())
 	{
-		//JA_StopMusic();
+		// JA_StopMusic();
 		section::name = section::Name::TITLE;
 		section::options = section::Options::TITLE_1;
 		section::attract_mode = section::AttractMode::TITLE_TO_DEMO;

source/input.cpp

@@ -245,7 +245,15 @@ bool Input::discoverGameControllers()
 	}
 
 	std::cout << "\n** LOOKING FOR GAME CONTROLLERS" << std::endl;
-	std::cout << "Gamepads found: " << num_gamepads_ << std::endl;
+	if (num_joysticks_ != num_gamepads_)
+	{
+		std::cout << "Joysticks found: " << num_joysticks_ << std::endl;
+		std::cout << "Gamepads found : " << num_gamepads_ << std::endl;
+	}
+	else
+	{
+		std::cout << "Gamepads found: " << num_gamepads_ << std::endl;
+	}
 
 	if (num_gamepads_ > 0)
 	{

source/instructions.cpp

@@ -20,6 +20,7 @@
 #include "texture.h"			// Para Texture
 #include "tiled_bg.h"			// Para TiledBG, TiledBGMode
 #include "utils.h"				// Para Color, shdw_txt_color, Zone, no_color
+#include "mouse.h"
 
 // Constructor
 Instructions::Instructions()
@@ -41,7 +42,7 @@ Instructions::Instructions()
 	// Inicializa objetos
 	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
 	fade_->setType(FadeType::FULLSCREEN);
-	fade_->setPost(param.fade.post_duration);
+	fade_->setPostDuration(param.fade.post_duration);
 	fade_->setMode(FadeMode::IN);
 	fade_->activate();
 
@@ -217,7 +218,7 @@ void Instructions::update()
 		Screen::get()->update();
 
 		// Actualiza las variables de globalInputs
-        globalInputs::update();
+		globalInputs::update();
 
 		// Incrementa el contador
 		counter_++;
@@ -301,6 +302,9 @@ void Instructions::checkEvents()
 				reloadTextures();
 			}
 		}
+
+		// Comprueba el cursor
+		Mouse::handleEvent(event);
 	}
 }
 
@@ -310,7 +314,7 @@ void Instructions::checkInput()
 	// Comprueba si se ha pulsado cualquier botón (de los usados para jugar)
 	if (Input::get()->checkAnyButtonPressed())
 	{
-		//JA_StopMusic();
+		// JA_StopMusic();
 		section::name = section::Name::TITLE;
 		section::options = section::Options::TITLE_1;
 		section::attract_mode = section::AttractMode::TITLE_TO_DEMO;

source/intro.cpp

@@ -16,6 +16,7 @@
 #include "texture.h"		 // Para Texture
 #include "utils.h"			 // Para Zone, BLOCK, Color, bg_color
 #include "writer.h"			 // Para Writer
+#include "mouse.h"
 
 // Constructor
 Intro::Intro()
@@ -169,13 +170,18 @@ void Intro::checkEvents()
 		case SDL_WINDOWEVENT:
 		{
 			if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
+			{
 				reloadTextures();
+			}
 			break;
 		}
 
 		default:
 			break;
 		}
+
+		// Comprueba el cursor
+		Mouse::handleEvent(event);
 	}
 }
 
@@ -384,7 +390,7 @@ void Intro::update()
 		updateScenes();
 
 		// Actualiza las variables de globalInputs
-        globalInputs::update();
+		globalInputs::update();
 	}
 }
 

source/item.cpp

@@ -14,10 +14,10 @@ Item::Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr
 	{
 	case ItemType::COFFEE_MACHINE:
 	{
-		width_ = 28;
-		height_ = 37;
+		width_ = param.game.coffee_machine_w;
+		height_ = param.game.coffee_machine_h;
 		pos_x_ = ((static_cast<int>(x) + (play_area.w / 2)) % (play_area.w - width_ - 5)) + 2;
-		pos_y_ = -height_;
+		pos_y_ = y;
 		vel_x_ = 0.0f;
 		vel_y_ = -0.1f;
 		accel_y_ = 0.1f;
@@ -26,8 +26,8 @@ Item::Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr
 	}
 	default:
 	{
-		width_ = 20;
-		height_ = 20;
+		width_ = param.game.item_size;
+		height_ = param.game.item_size;
 		pos_x_ = x;
 		pos_y_ = y;
 		vel_x_ = -1.0f + ((rand() % 5) * 0.5f);

source/jail_audio.cpp

@@ -96,24 +96,12 @@ void audioCallback(void * userdata, uint8_t * stream, int len) {
 
 void JA_Init(const int freq, const SDL_AudioFormat format, const int channels)
 {
-    #ifdef DEBUG
-    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_DEBUG);
-    #endif
-    
-    SDL_Log("Iniciant JailAudio...");
     JA_freq = freq;
     JA_format = format;
     JA_channels = channels;
     SDL_AudioSpec audioSpec{JA_freq, JA_format, JA_channels, 0, 1024, 0, 0, audioCallback, NULL};
     if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
     sdlAudioDevice = SDL_OpenAudioDevice(NULL, 0, &audioSpec, NULL, 0);
-    if (sdlAudioDevice==0)
-    {
-        SDL_Log("FAILED!\n");
-        SDL_Log("Failed to initialize SDL audio!\n");
-    } else {
-        SDL_Log("OK!\n");
-    }
     SDL_PauseAudioDevice(sdlAudioDevice, 0);
 }
 
@@ -134,7 +122,6 @@ JA_Music_t *JA_LoadMusic(Uint8* buffer, Uint32 length)
 
     SDL_AudioCVT cvt;
     SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq);
-    SDL_Log("Music length: %f\n", float(music->samples)/float(JA_freq));
     if (cvt.needed) {
         cvt.len = music->samples * chan * 2;
         music->length = cvt.len;

source/logo.cpp

@@ -13,6 +13,7 @@
 #include "sprite.h"			 // Para Sprite
 #include "texture.h"		 // Para Texture
 #include "utils.h"			 // Para Color, Zone
+#include "mouse.h"
 
 // Constructor
 Logo::Logo()
@@ -92,6 +93,9 @@ void Logo::checkEvents()
 				reloadTextures();
 			}
 		}
+
+		// Comprueba el cursor
+		Mouse::handleEvent(event);
 	}
 }
 
@@ -202,7 +206,7 @@ void Logo::update()
 		}
 
 		// Actualiza las variables de globalInputs
-        globalInputs::update();
+		globalInputs::update();
 	}
 }
 

source/mouse.cpp

@@ -0,0 +1,32 @@
+#include "mouse.h"
+#include <SDL.h>
+
+namespace Mouse
+{
+    Uint32 cursor_hide_time = 3000;  // Tiempo en milisegundos para ocultar el cursor
+    Uint32 last_mouse_move_time = 0; // Última vez que el ratón se movió
+    bool cursor_visible = true;      // Estado del cursor
+
+    void handleEvent(const SDL_Event &event)
+    {
+        if (event.type == SDL_MOUSEMOTION)
+        {
+            last_mouse_move_time = SDL_GetTicks();
+            if (!cursor_visible)
+            {
+                SDL_ShowCursor(SDL_ENABLE);
+                cursor_visible = true;
+            }
+        }
+    }
+
+    void updateCursorVisibility()
+    {
+        Uint32 current_time = SDL_GetTicks();
+        if (cursor_visible && (current_time - last_mouse_move_time > cursor_hide_time))
+        {
+            SDL_ShowCursor(SDL_DISABLE);
+            cursor_visible = false;
+        }
+    }
+}

source/mouse.h

@@ -0,0 +1,12 @@
+#pragma once
+#include <SDL.h>
+
+namespace Mouse
+{
+    extern Uint32 cursor_hide_time;     // Tiempo en milisegundos para ocultar el cursor
+    extern Uint32 last_mouse_move_time; // Última vez que el ratón se movió
+    extern bool cursor_visible;         // Estado del cursor
+
+    void handleEvent(const SDL_Event &event);
+    void updateCursorVisibility();
+}

source/notifier.cpp

@@ -60,7 +60,7 @@ void Notifier::update()
         // Si la notificación anterior está "saliendo", no hagas nada
         if (i > 0)
         {
-            if (notifications_[i - 1].status == NotificationStatus::RISING)
+            if (notifications_[i - 1].state == NotificationStatus::RISING)
             {
                 break;
             }
@@ -73,8 +73,8 @@ void Notifier::update()
         {
             if (param.notification.sound)
             {
-                if (notifications_[i].status == NotificationStatus::RISING)
-                { 
+                if (notifications_[i].state == NotificationStatus::RISING)
+                {
                     // Reproduce el sonido de la notificación
                     JA_PlaySound(Resource::get()->getSound("notify.wav"));
                 }
@@ -82,7 +82,7 @@ void Notifier::update()
         }
 
         // Comprueba los estados
-        if (notifications_[i].status == NotificationStatus::RISING)
+        if (notifications_[i].state == NotificationStatus::RISING)
         {
             const float step = ((float)notifications_[i].counter / notifications_[i].travel_dist);
             const int alpha = 255 * step;
@@ -99,21 +99,21 @@ void Notifier::update()
 
             if (notifications_[i].rect.y == notifications_[i].y)
             {
-                notifications_[i].status = NotificationStatus::STAY;
+                notifications_[i].state = NotificationStatus::STAY;
                 notifications_[i].texture->setAlpha(255);
                 notifications_[i].counter = 0;
             }
         }
 
-        else if (notifications_[i].status == NotificationStatus::STAY)
+        else if (notifications_[i].state == NotificationStatus::STAY)
         {
             if (notifications_[i].counter == wait_time_)
             {
-                notifications_[i].status = NotificationStatus::VANISHING;
+                notifications_[i].state = NotificationStatus::VANISHING;
                 notifications_[i].counter = 0;
             }
         }
-        else if (notifications_[i].status == NotificationStatus::VANISHING)
+        else if (notifications_[i].state == NotificationStatus::VANISHING)
         {
 
             const float step = (notifications_[i].counter / (float)notifications_[i].travel_dist);
@@ -131,7 +131,7 @@ void Notifier::update()
 
             if (notifications_[i].rect.y == notifications_[i].y - notifications_[i].travel_dist)
             {
-                notifications_[i].status = NotificationStatus::FINISHED;
+                notifications_[i].state = NotificationStatus::FINISHED;
             }
         }
 
@@ -146,7 +146,7 @@ void Notifier::clearFinishedNotifications()
 {
     for (int i = (int)notifications_.size() - 1; i >= 0; --i)
     {
-        if (notifications_[i].status == NotificationStatus::FINISHED)
+        if (notifications_[i].state == NotificationStatus::FINISHED)
         {
             notifications_.erase(notifications_.begin() + i);
         }
@@ -302,7 +302,7 @@ void Notifier::clearNotifications()
 {
     for (auto &notification : notifications_)
     {
-        notification.status = NotificationStatus::FINISHED;
+        notification.state = NotificationStatus::FINISHED;
     }
 
     clearFinishedNotifications();

source/notifier.h

@@ -37,7 +37,7 @@ private:
 		std::shared_ptr<Sprite> sprite;
 		std::vector<std::string> texts;
 		int counter;
-		NotificationStatus status;
+		NotificationStatus state;
 		NotificationShape shape;
 		SDL_Rect rect;
 		int y;
@@ -46,7 +46,7 @@ private:
 
 		// Constructor
 		explicit Notification()
-			: texture(nullptr), sprite(nullptr), texts(), counter(0), status(NotificationStatus::RISING),
+			: texture(nullptr), sprite(nullptr), texts(), counter(0), state(NotificationStatus::RISING),
 			  shape(NotificationShape::SQUARED), rect{0, 0, 0, 0}, y(0), travel_dist(0), code("") {}
 	};
 

source/param.cpp

@@ -21,6 +21,8 @@ void initParam()
 	param.game.width = 320;
 	param.game.height = 256;
 	param.game.item_size = 20;
+	param.game.coffee_machine_w = 28;
+	param.game.coffee_machine_h = 37;
 	param.game.game_area.rect = {0, 0, param.game.width, param.game.height};
 	param.game.play_area.rect = {0, 0, param.game.width, 216};
 	param.game.enter_name_seconds = 30;
@@ -124,6 +126,16 @@ bool setParams(const std::string &var, const std::string &value)
 		param.game.item_size = std::stoi(value);
 	}
 
+	else if (var == "game.coffee_machine_w")
+	{
+		param.game.coffee_machine_w = std::stoi(value);
+	}
+
+	else if (var == "game.coffee_machine_h")
+	{
+		param.game.coffee_machine_h = std::stoi(value);
+	}
+
 	else if (var == "game.play_area.rect.x")
 	{
 		param.game.play_area.rect.x = std::stoi(value);

source/param.h

@@ -11,6 +11,8 @@ struct ParamGame
     int width;              // Ancho de la resolucion nativa del juego
     int height;             // Alto de la resolucion nativa del juego
     int item_size;          // Tamaño de los items del juego
+    int coffee_machine_w;   // Ancho de la máquina de café
+    int coffee_machine_h;   // Alto de la máquina de café
     Zone play_area;         // Rectangulo con la posición de la zona de juego
     Zone game_area;         // Rectangulo con las dimensiones del juego
     int enter_name_seconds; // Duración en segundos para introducir el nombre al finalizar la partida
@@ -63,7 +65,8 @@ struct ParamNotification
 };
 
 // Estructura para almacenar todos los parámetros del juego
-struct Param {
+struct Param
+{
     ParamGame game;
     ParamFade fade;
     SDL_Rect scoreboard;
@@ -72,14 +75,14 @@ struct Param {
     std::vector<ParamBalloon> balloon;
     ParamNotification notification;
 
-    Param() : game(), fade(), scoreboard(), title(), background(), notification() {
+    Param() : game(), fade(), scoreboard(), title(), background(), notification()
+    {
         balloon.reserve(4);
     }
 };
 
 extern Param param;
 
-
 extern Param param;
 
 // Establece valores para los parametros a partir de un fichero de texto

source/path_sprite.cpp

@@ -95,7 +95,17 @@ void PathSprite::addPath(std::vector<SDL_Point> spots, int waiting_counter)
 // Habilita el objeto
 void PathSprite::enable()
 {
+	if (paths_.size() == 0)
+	{
+		return;
+	}
+
 	enabled_ = true;
+	
+	// Establece la posición
+	auto &path = paths_.at(current_path_);
+	const auto &p = path.spots.at(path.counter);
+	setPosition(p);
 }
 
 // Coloca el sprite en los diferentes puntos del recorrido

source/path_sprite.h

@@ -73,4 +73,7 @@ public:
 
 	// Indica si ha terminado todos los recorridos
 	bool hasFinished();
+
+	// Getters
+	int getCurrentPath() const { return current_path_; }
 };

source/player.cpp

@@ -10,6 +10,7 @@
 #include "texture.h"		 // Para Texture
 #include "resource.h"
 #include "jail_audio.h"
+#include "stage.h"
 
 // Constructor
 Player::Player(int id, float x, int y, bool demo, SDL_Rect &play_area, std::vector<std::shared_ptr<Texture>> texture, const std::vector<std::vector<std::string>> &animations)
@@ -56,7 +57,7 @@ void Player::init()
 	vel_y_ = 0;
 	score_ = 0;
 	score_multiplier_ = 1.0f;
-	cooldown_ = 10;
+	cool_down_ = 10;
 	enter_name_->init();
 
 	// Establece la posición del sprite
@@ -174,10 +175,14 @@ void Player::move()
 	case PlayerState::DYING:
 	{
 		// Si el cadaver abandona el area de juego por los laterales lo hace rebotar
-		if ((player_sprite_->getPosX() < play_area_.x) || (player_sprite_->getPosX() + WIDTH_ > play_area_.w))
+		const int x = player_sprite_->getPosX();
+		const int min_x = play_area_.x;
+		const int max_x = play_area_.x + play_area_.w - WIDTH_;
+		if ((x < min_x) || (x > max_x))
 		{
+			player_sprite_->setPosX(std::clamp(x, min_x, max_x));
 			player_sprite_->setVelX(-player_sprite_->getVelX());
-			JA_PlaySound(Resource::get()->getSound("bubble4.wav"));
+			playRandomBubbleSound();
 		}
 
 		// Si el cadaver toca el suelo cambia el estado
@@ -191,7 +196,7 @@ void Player::move()
 				pos_y_ = default_pos_y_;
 				player_sprite_->clear();
 				shiftSprite();
-				JA_PlaySound(Resource::get()->getSound("bubble4.wav"));
+				playRandomBubbleSound();
 			}
 			else
 			{
@@ -199,13 +204,19 @@ void Player::move()
 				player_sprite_->setPosY(play_area_.h - HEIGHT_);
 				player_sprite_->setVelY(player_sprite_->getVelY() * -0.5f);
 				player_sprite_->setVelX(player_sprite_->getVelX() * 0.75f);
-				JA_PlaySound(Resource::get()->getSound("bubble4.wav"));
+				playRandomBubbleSound();
 			}
 		}
 		break;
 	}
 	case PlayerState::LEAVING_SCREEN:
 	{
+		++step_counter_;
+		if (step_counter_ % 10 == 0)
+		{
+			JA_PlaySound(Resource::get()->getSound("walk.wav"));
+		}
+
 		switch (id_)
 		{
 		case 1:
@@ -224,7 +235,45 @@ void Player::move()
 		shiftSprite();
 
 		if (pos_x_ == min_x || pos_x_ == max_x)
+		{
 			setPlayingState(PlayerState::GAME_OVER);
+		}
+		break;
+	}
+	case PlayerState::ENTERING_SCREEN:
+	{
+		++step_counter_;
+		if (step_counter_ % 10 == 0)
+		{
+			JA_PlaySound(Resource::get()->getSound("walk.wav"));
+		}
+
+		switch (id_)
+		{
+		case 1:
+			setInputPlaying(InputType::RIGHT);
+			pos_x_ += vel_x_;
+			if (pos_x_ > default_pos_x_)
+			{
+				pos_x_ = default_pos_x_;
+				setPlayingState(PlayerState::PLAYING);
+				setInvulnerable(false);
+			}
+			break;
+		case 2:
+			setInputPlaying(InputType::LEFT);
+			pos_x_ += vel_x_;
+			if (pos_x_ < default_pos_x_)
+			{
+				pos_x_ = default_pos_x_;
+				setPlayingState(PlayerState::PLAYING);
+				setInvulnerable(false);
+			}
+			break;
+		default:
+			break;
+		}
+		shiftSprite();
 		break;
 	}
 	case PlayerState::CREDITS:
@@ -291,6 +340,7 @@ void Player::setAnimation()
 	{
 	case PlayerState::PLAYING:
 	case PlayerState::ENTERING_NAME_GAME_COMPLETED:
+	case PlayerState::ENTERING_SCREEN:
 	case PlayerState::LEAVING_SCREEN:
 	case PlayerState::CREDITS:
 	{
@@ -352,37 +402,38 @@ void Player::setAnimation()
 // Actualiza el valor de la variable
 void Player::updateCooldown()
 {
-	if (cooldown_ > 0)
+	if (cool_down_ > 0)
 	{
-		cooldown_ -= power_up_ ? 2 : 1;
+		--cool_down_;
+		cooling_state_counter_ = 50;
 	}
 	else
 	{
-		if (!isCooling())
+		if (cooling_state_counter_ > 0)
 		{
-			cooling_status_counter_ = 40;
-			switch (firing_state_)
+			if (cooling_state_counter_ == 40)
 			{
-			case PlayerState::FIRING_LEFT:
-				firing_state_ = PlayerState::COOLING_LEFT;
-				break;
-			case PlayerState::FIRING_RIGHT:
-				firing_state_ = PlayerState::COOLING_RIGHT;
-				break;
-			case PlayerState::FIRING_UP:
-				firing_state_ = PlayerState::COOLING_UP;
-				break;
-			default:
-				break;
+				switch (firing_state_)
+				{
+				case PlayerState::FIRING_LEFT:
+					setFiringState(PlayerState::COOLING_LEFT);
+					break;
+				case PlayerState::FIRING_RIGHT:
+					setFiringState(PlayerState::COOLING_RIGHT);
+					break;
+				case PlayerState::FIRING_UP:
+					setFiringState(PlayerState::COOLING_UP);
+					break;
+				default:
+					break;
+				}
 			}
-		}
-		else if (cooling_status_counter_ > 0)
-		{
-			--cooling_status_counter_;
+			--cooling_state_counter_;
 		}
 		else
 		{
 			setFiringState(PlayerState::FIRING_NONE);
+			cooling_state_counter_ = 0;
 		}
 	}
 }
@@ -453,6 +504,7 @@ void Player::setPlayingState(PlayerState state)
 		init();
 		playing_state_ = PlayerState::PLAYING;
 		setScoreboardMode(ScoreboardMode::SCORE);
+		Stage::power_can_be_added = true;
 		break;
 	}
 	case PlayerState::CONTINUE:
@@ -506,9 +558,29 @@ void Player::setPlayingState(PlayerState state)
 	}
 	case PlayerState::LEAVING_SCREEN:
 	{
+		step_counter_ = 0;
 		setScoreboardMode(ScoreboardMode::GAME_COMPLETED);
 		break;
 	}
+	case PlayerState::ENTERING_SCREEN:
+	{
+		step_counter_ = 0;
+		setScoreboardMode(ScoreboardMode::SCORE);
+		switch (id_)
+		{
+		case 1:
+			pos_x_ = param.game.game_area.rect.x - WIDTH_;
+			break;
+
+		case 2:
+			pos_x_ = param.game.game_area.rect.x + param.game.game_area.rect.w;
+			break;
+
+		default:
+			break;
+		}
+		break;
+	}
 	case PlayerState::CREDITS:
 	{
 		vel_x_ = (walking_state_ == PlayerState::WALKING_RIGHT) ? BASE_SPEED_ : -BASE_SPEED_;
@@ -648,6 +720,10 @@ void Player::decContinueCounter()
 	{
 		setPlayingState(PlayerState::GAME_OVER);
 	}
+	else
+	{
+		JA_PlaySound(Resource::get()->getSound("continue_clock.wav"));
+	}
 }
 
 // Decrementa el contador de entrar nombre
@@ -686,4 +762,11 @@ void Player::shiftSprite()
 	player_sprite_->setPosX(pos_x_);
 	player_sprite_->setPosY(pos_y_);
 	power_sprite_->setPosX(getPosX() - power_up_desp_x_);
+}
+
+// Hace sonar un ruido al azar
+void Player::playRandomBubbleSound()
+{
+	const std::vector<std::string> sounds = {"bubble1.wav", "bubble2.wav", "bubble3.wav", "bubble4.wav"};
+	JA_PlaySound(Resource::get()->getSound(sounds.at(rand() % sounds.size())));
 }

source/player.h

@@ -40,6 +40,7 @@ enum class PlayerState
 	CELEBRATING,				  // Poniendo pose de victoria
 	ENTERING_NAME_GAME_COMPLETED, // Poniendo nombre en el tramo final del juego
 	LEAVING_SCREEN,				  // Moviendose fuera de la pantalla
+	ENTERING_SCREEN,			  // Entando a la pantalla
 	CREDITS,					  // Estado para los creditos del juego
 };
 
@@ -68,8 +69,8 @@ private:
 	int default_pos_y_;										// Posición inicial para el jugador
 	float vel_x_ = 0.0f;									// Cantidad de pixeles a desplazarse en el eje X
 	int vel_y_ = 0.0f;										// Cantidad de pixeles a desplazarse en el eje Y
-	int cooldown_ = 0;										// Contador durante el cual no puede disparar
-	int cooling_status_counter_ = 0;						// Contador para la animación del estado cooling
+	int cool_down_ = 0;										// Contador durante el cual no puede disparar
+	int cooling_state_counter_ = 0;							// Contador para la animación del estado cooling
 	int score_ = 0;											// Puntos del jugador
 	float score_multiplier_ = 1.0f;							// Multiplicador de puntos
 	PlayerState walking_state_ = PlayerState::WALKING_STOP; // Estado del jugador al moverse
@@ -91,6 +92,7 @@ private:
 	bool demo_;												// Para que el jugador sepa si está en el modo demostración
 	int enter_name_counter_;								// Contador para poner nombre
 	Uint32 enter_name_ticks_ = 0;							// Variable para poder cambiar el contador de poner nombre en función del tiempo
+	int step_counter_ = 0;									// Cuenta los pasos para los estados en los que camina automáticamente
 
 	// Actualiza el circulo de colisión a la posición del jugador
 	void shiftColliders();
@@ -116,6 +118,10 @@ private:
 	// Cambia el modo del marcador
 	void setScoreboardMode(ScoreboardMode mode);
 
+	// Hace sonar un ruido al azar
+	void playRandomBubbleSound();
+
+	// Getters
 	bool isRenderable() const { return !isWaiting() && !isGameOver(); }
 
 public:
@@ -201,10 +207,10 @@ public:
 	bool isWaiting() const { return playing_state_ == PlayerState::WAITING; }
 
 	// Getters
-	bool canFire() const { return cooldown_ > 0 ? false : true; }
+	bool canFire() const { return cool_down_ > 0 ? false : true; }
 	bool hasExtraHit() const { return extra_hit_; }
-	bool isCooling() { return firing_state_ == PlayerState::COOLING_LEFT || firing_state_ == PlayerState::COOLING_UP || firing_state_ == PlayerState::COOLING_RIGHT; }
-	bool IsEligibleForHighScore() { return score_ > options.game.hi_score_table.back().score; }
+	bool isCooling() const { return firing_state_ == PlayerState::COOLING_LEFT || firing_state_ == PlayerState::COOLING_UP || firing_state_ == PlayerState::COOLING_RIGHT; }
+	bool IsEligibleForHighScore() const { return score_ > options.game.hi_score_table.back().score; }
 	bool isInvulnerable() const { return invulnerable_; }
 	bool isPowerUp() const { return power_up_; }
 	Circle &getCollider() { return collider_; }
@@ -227,7 +233,7 @@ public:
 
 	// Setters
 	void setController(int index) { controller_index_ = index; }
-	void setFireCooldown(int time) { cooldown_ = time; }
+	void setFireCooldown(int time) { cool_down_ = time; }
 	void setFiringState(PlayerState state) { firing_state_ = state; }
 	void setInvulnerableCounter(int value) { invulnerable_counter_ = value; }
 	void setName(const std::string &name) { name_ = name; }

source/resource.cpp

@@ -254,14 +254,14 @@ void Resource::addPalettes()
 {
     // Jugador 1
     std::cout << "\n>> PALETTES" << std::endl;
-    getTexture("player1.gif")->addPaletteFromFile(Asset::get()->get("player1_one_coffee_palette.pal"));
-    getTexture("player1.gif")->addPaletteFromFile(Asset::get()->get("player1_two_coffee_palette.pal"));
-    getTexture("player1.gif")->addPaletteFromFile(Asset::get()->get("player1_all_white_palette.pal"));
+    getTexture("player1.gif")->addPaletteFromFile(Asset::get()->get("player1_1_coffee_palette.gif"));
+    getTexture("player1.gif")->addPaletteFromFile(Asset::get()->get("player1_2_coffee_palette.gif"));
+    getTexture("player1.gif")->addPaletteFromFile(Asset::get()->get("player1_invencible_palette.gif"));
 
     // Jugador 2
-    getTexture("player2.gif")->addPaletteFromFile(Asset::get()->get("player2_one_coffee_palette.pal"));
-    getTexture("player2.gif")->addPaletteFromFile(Asset::get()->get("player2_two_coffee_palette.pal"));
-    getTexture("player2.gif")->addPaletteFromFile(Asset::get()->get("player2_all_white_palette.pal"));
+    getTexture("player2.gif")->addPaletteFromFile(Asset::get()->get("player2_1_coffee_palette.gif"));
+    getTexture("player2.gif")->addPaletteFromFile(Asset::get()->get("player2_2_coffee_palette.gif"));
+    getTexture("player2.gif")->addPaletteFromFile(Asset::get()->get("player2_invencible_palette.gif"));
 
     // Fuentes
     getTexture("smb2.gif")->addPaletteFromFile(Asset::get()->get("smb2_palette1.pal"));

source/screen.cpp

@@ -14,6 +14,7 @@
 #include "notifier.h"        // Para Notifier
 #include "on_screen_help.h"  // Para OnScreenHelp
 #include "options.h"         // Para Options, OptionsVideo, options, Options...
+#include "mouse.h"
 
 #ifndef NO_SHADERS
 #include "jail_shader.h" // para init, render
@@ -259,6 +260,7 @@ void Screen::update()
     Notifier::get()->update();
     updateFPS();
     OnScreenHelp::get()->update();
+    Mouse::updateCursorVisibility();
 }
 
 // Agita la pantalla

source/section.h

@@ -5,30 +5,31 @@ namespace section
     // Secciones del programa
     enum class Name
     {
-        INIT = 0,
-        LOGO = 1,
-        INTRO = 2,
-        TITLE = 3,
-        GAME = 4,
-        HI_SCORE_TABLE = 5,
-        GAME_DEMO = 6,
-        INSTRUCTIONS = 7,
-        CREDITS = 8,
-        QUIT = 9,
+        INIT,
+        LOGO,
+        INTRO,
+        TITLE,
+        GAME,
+        HI_SCORE_TABLE,
+        GAME_DEMO,
+        INSTRUCTIONS,
+        CREDITS,
+        QUIT,
     };
 
     // Opciones para la sección
     enum class Options
     {
-        GAME_PLAY_1P = 0,
-        GAME_PLAY_2P = 1,
-        TITLE_1 = 2,
-        TITLE_2 = 3,
-        QUIT_WITH_KEYBOARD = 4,
-        QUIT_WITH_CONTROLLER = 5,
-        QUIT_FROM_EVENT = 6,
-        RELOAD = 7,
-        NONE = 8,
+        GAME_PLAY_1P,
+        GAME_PLAY_2P,
+        TITLE_TIME_OUT,
+        TITLE_1,
+        TITLE_2,
+        QUIT_WITH_KEYBOARD,
+        QUIT_WITH_CONTROLLER,
+        QUIT_FROM_EVENT,
+        RELOAD,
+        NONE,
     };
 
     // Variables para el Attract Mode

source/stage.cpp

@@ -5,10 +5,11 @@
 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
+    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
+    bool power_can_be_added = true; // Habilita la recolecta de poder
 
     // Devuelve una fase
     Stage get(int index) { return stages.at(std::min(9, index)); }
@@ -35,7 +36,10 @@ namespace Stage
     // Añade poder
     void addPower(int amount)
     {
-        power += amount;
-        total_power += amount;
+        if (power_can_be_added)
+        {
+            power += amount;
+            total_power += amount;
+        }
     }
 }

source/stage.h

@@ -19,6 +19,7 @@ namespace Stage
     extern int power;                 // Poder acumulado en la fase
     extern int total_power;           // Poder total necesario para completar el juego
     extern int number;                // Fase actual
+    extern bool power_can_be_added;   // Indica si se puede añadir poder a la fase
 
     // Devuelve una fase
     Stage get(int index);

source/title.cpp

@@ -24,6 +24,7 @@
 #include "texture.h"		  // Para Texture
 #include "tiled_bg.h"		  // Para TiledBG, TiledBGMode
 #include "utils.h"			  // Para Color, Zone, fade_color, no_color, BLOCK
+#include "mouse.h"
 
 // Constructor
 Title::Title()
@@ -41,7 +42,7 @@ Title::Title()
 	mini_logo_sprite_->setX(param.game.game_area.center_x - mini_logo_sprite_->getWidth() / 2);
 	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
 	fade_->setType(FadeType::RANDOM_SQUARE);
-	fade_->setPost(param.fade.post_duration);
+	fade_->setPostDuration(param.fade.post_duration);
 	Resource::get()->getTexture("smb2.gif")->setPalette(1);
 
 	// Asigna valores a otras variables
@@ -78,14 +79,16 @@ void Title::update()
 		fade_->update();
 		if (fade_->hasEnded())
 		{
-			if (post_fade_ == -1)
+			if (selection_ == section::Options::TITLE_TIME_OUT)
 			{
+				// El menu ha hecho time out
 				section::name = next_section_;
 			}
 			else
 			{
+				// Se ha pulsado para jugar
 				section::name = section::Name::GAME;
-				section::options = post_fade_ == 1 ? section::Options::GAME_PLAY_1P : section::Options::GAME_PLAY_2P;
+				section::options = selection_;
 				JA_StopMusic();
 			}
 		}
@@ -121,8 +124,10 @@ void Title::update()
 
 			if (counter_ == param.title.title_duration)
 			{
+				// El menu ha hecho time out
+				fade_->setPostDuration(0);
 				fade_->activate();
-				post_fade_ = -1;
+				selection_ = section::Options::TITLE_TIME_OUT;
 			}
 
 			break;
@@ -134,7 +139,7 @@ void Title::update()
 
 			// Actualiza el mosaico de fondo
 			tiled_bg_->update();
-			
+
 			if (counter_ == 100)
 			{
 				fade_->activate();
@@ -270,6 +275,9 @@ void Title::checkEvents()
 					break;
 				}
 			}
+
+			// Comprueba el cursor
+			Mouse::handleEvent(event);
 		}
 	}
 }
@@ -291,7 +299,18 @@ void Title::checkInput()
 				{
 					JA_PlaySound(Resource::get()->getSound("game_start.wav"));
 					JA_FadeOutMusic(1500);
-					post_fade_ = controller.player_id;
+					switch (controller.player_id)
+					{
+					case 1:
+						selection_ = section::Options::GAME_PLAY_1P;
+						break;
+					case 2:
+						selection_ = section::Options::GAME_PLAY_2P;
+						break;
+					default:
+						selection_ = section::Options::TITLE_TIME_OUT;
+						break;
+					}
 					state_ = TitleState::START_HAS_BEEN_PRESSED;
 					counter_ = 0;
 					return;

source/title.h

@@ -9,13 +9,10 @@ class Sprite;				 // lines 9-9
 class Text;					 // lines 10-10
 class Texture;				 // lines 11-11
 class TiledBG;				 // lines 12-12
-namespace section
-{
-	enum class Name;
-}
+#include "section.h"
 
 // Textos
-constexpr const char TEXT_COPYRIGHT[] = "@2020,2024 JailDesigner";
+constexpr const char TEXT_COPYRIGHT[] = "@2020,2025 JailDesigner";
 
 // Parámetros
 constexpr bool ALLOW_TITLE_ANIMATION_SKIP = false;
@@ -57,12 +54,12 @@ private:
 	std::unique_ptr<DefineButtons> define_buttons_; // Objeto para definir los botones del joystic
 
 	// Variable
-	int counter_ = 0;			 // Temporizador para la pantalla de titulo
-	Uint32 ticks_ = 0;			 // Contador de ticks para ajustar la velocidad del programa
-	section::Name next_section_; // Indica cual es la siguiente sección a cargar cuando termine el contador del titulo
-	int post_fade_ = 0;			 // Opción a realizar cuando termina el fundido
-	int num_controllers_;		 // Número de mandos conectados
-	TitleState state_;			 // Estado en el que se encuentra la sección
+	int counter_ = 0;												// Temporizador para la pantalla de titulo
+	Uint32 ticks_ = 0;												// Contador de ticks para ajustar la velocidad del programa
+	section::Name next_section_;									// Indica cual es la siguiente sección a cargar cuando termine el contador del titulo
+	section::Options selection_ = section::Options::TITLE_TIME_OUT; // Opción elegida en el titulo
+	int num_controllers_;											// Número de mandos conectados
+	TitleState state_;												// Estado en el que se encuentra la sección
 
 	// Actualiza las variables del objeto
 	void update();