Afegida la opció de crear els globos sense temps de creació en el balloon_manager

Modificat el mode demo per a que la primera oleada estiga ja creada

.gitignore

@@ -15,4 +15,5 @@ thumbs.db
 *score.bin
 coffee_crisis*
 debug.txt
-cppcheck-result*
+cppcheck-result*
+desktop.ini

Makefile

@@ -1,59 +1,63 @@
 # Directorios
-DIR_ROOT   := $(dir $(abspath $(MAKEFILE_LIST)))
+DIR_ROOT       := $(dir $(abspath $(MAKEFILE_LIST)))
-DIR_SOURCES:= $(addsuffix /, $(DIR_ROOT)source)
+DIR_SOURCES    := $(addsuffix /, $(DIR_ROOT)source)
-DIR_BIN    := $(addsuffix /, $(DIR_ROOT))
+DIR_BIN        := $(addsuffix /, $(DIR_ROOT))
-DIR_BUILD  := $(addsuffix /, $(DIR_ROOT)build)
+DIR_BUILD      := $(addsuffix /, $(DIR_ROOT)build)
 
 # Variables
-TARGET_NAME   := coffee_crisis_arcade_edition
+TARGET_NAME    := coffee_crisis_arcade_edition
-TARGET_FILE   := $(DIR_BIN)$(TARGET_NAME)
+TARGET_FILE    := $(DIR_BIN)$(TARGET_NAME)
-APP_NAME      := Coffee Crisis Arcade Edition
+APP_NAME       := Coffee Crisis Arcade Edition
-RELEASE_FOLDER:= ccae_release
+RELEASE_FOLDER := ccae_release
-RELEASE_FILE  := $(RELEASE_FOLDER)/$(TARGET_NAME)
+RELEASE_FILE   := $(RELEASE_FOLDER)/$(TARGET_NAME)
-VERSION       := v0.01
+RESOURCE_FILE  := release/coffee.res
+VERSION        := 2024-12-31
 
 # Nombres para los ficheros de lanzamiento
-WINDOWS_RELEASE            := $(TARGET_FILE)-$(VERSION)-win32-x64.zip
+WINDOWS_RELEASE             := $(TARGET_NAME)-$(VERSION)-win32-x64.zip
-MACOS_INTEL_RELEASE        := $(TARGET_FILE)-$(VERSION)-macos-intel.dmg
+MACOS_INTEL_RELEASE         := $(TARGET_FILE)-$(VERSION)-macos-intel.dmg
-MACOS_APPLE_SILICON_RELEASE:= $(TARGET_FILE)-$(VERSION)-macos-apple-silicon.dmg
+MACOS_APPLE_SILICON_RELEASE := $(TARGET_FILE)-$(VERSION)-macos-apple-silicon.dmg
-LINUX_RELEASE              := $(TARGET_FILE)-$(VERSION)-linux.tar.gz
+LINUX_RELEASE               := $(TARGET_FILE)-$(VERSION)-linux.tar.gz
+RASPI_RELEASE               := $(TARGET_FILE)-$(VERSION)-raspberry.tar.gz
 
 # Includes
-INCLUDES:= -I$(DIR_SOURCES)
+INCLUDES := -I$(DIR_SOURCES)
 
 # Variables según el sistema operativo
 ifeq ($(OS),Windows_NT)
-    FixPath = $(subst /,\,$1)
+    FixPath         = $(subst /,\\,$1)
-	SOURCES := source/*.cpp
+    SOURCES         := source/*.cpp
-	CXXFLAGS:= -std=c++20 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows
+    CXXFLAGS        := -std=c++20 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows
-	CXXFLAGS_DEBUG:= -std=c++20 -Wall -g
+    CXXFLAGS_DEBUG  := -std=c++20 -Wall -g
-	LDFLAGS := -lmingw32 -lws2_32 -lSDL2main -lSDL2 -lopengl32
+    LDFLAGS         := -lmingw32 -lws2_32 -lSDL2main -lSDL2 -lopengl32
-	RM = del /Q
+    RM              := del /Q
-	MKD:= mkdir
+    MKDIR           := mkdir
 else
-    FixPath = $1
+    FixPath         = $1
-	SOURCES := $(shell find $(DIR_SOURCES) -name '*.cpp')
+    SOURCES         := $(shell find $(DIR_SOURCES) -name '*.cpp')
-	SOURCES := source/*.cpp
+    SOURCES         := source/*.cpp
-	CXXFLAGS:= -std=c++20 -Wall -Os -ffunction-sections -fdata-sections
+    CXXFLAGS        := -std=c++20 -Wall -Os -ffunction-sections -fdata-sections
-	CXXFLAGS_DEBUG:= -std=c++20 -Wall -g
+    CXXFLAGS_DEBUG  := -std=c++20 -Wall -g
-	LDFLAGS := -lSDL2
+    LDFLAGS         := -lSDL2
-	RM = rm -f
+    RMFILE          := rm -f
-	MKD:= mkdir -p
+	RMDIR			:= rm -rdf
-	UNAME_S := $(shell uname -s)
+    MKDIR           := mkdir -p
+    UNAME_S         := $(shell uname -s)
     ifeq ($(UNAME_S),Linux)
-        LDFLAGS += -lGL
+        LDFLAGS     += -lGL
     endif
     ifeq ($(UNAME_S),Darwin)
-		CXXFLAGS += -Wno-deprecated
+        CXXFLAGS       += -Wno-deprecated
-		CXXFLAGS_DEBUG += -Wno-deprecated
+        CXXFLAGS_DEBUG += -Wno-deprecated
-        LDFLAGS += -framework OpenGL
+        LDFLAGS        += -framework OpenGL
     endif
 endif
 
-# Rules
+# Reglas para compilación
 windows:
 	@echo off
-	$(CXX) $(SOURCES) $(CXXFLAGS) $(LDFLAGS) -o "$(TARGET_FILE).exe"
+	windres release/coffee.rc -O coff -o $(RESOURCE_FILE)
+	$(CXX) $(SOURCES) $(RESOURCE_FILE) $(CXXFLAGS) $(LDFLAGS) -o "$(TARGET_FILE).exe"
 	strip -s -R .comment -R .gnu.version "$(TARGET_FILE).exe" --strip-unneeded
 
 windows_rec:
@@ -80,12 +84,13 @@ windows_release:
 	powershell Copy-Item "release\*.dll" -Destination "$(RELEASE_FOLDER)"
 
 # Compila
-	$(CXX) $(SOURCES) $(CXXFLAGS) $(LDFLAGS) -o "$(RELEASE_FILE).exe"
+	windres release/coffee.rc -O coff -o $(RESOURCE_FILE)
-	strip -s -R .comment -R .gnu.version "$(RELEASE_FOLDER)/$(TARGET_FILE).exe" --strip-unneeded
+	$(CXX) $(SOURCES) $(RESOURCE_FILE) $(CXXFLAGS) $(LDFLAGS) -o "$(RELEASE_FILE).exe"
+	strip -s -R .comment -R .gnu.version "$(RELEASE_FILE).exe" --strip-unneeded
 
 # Crea el fichero .zip
-	powershell if (Test-Path $(WINDOWS_RELEASE)) {Remove-Item $(WINDOWS_RELEASE)}
+	powershell if (Test-Path "$(WINDOWS_RELEASE)") {Remove-Item "$(WINDOWS_RELEASE)"}
-	powershell Compress-Archive -Path "$(RELEASE_FOLDER)"/* -DestinationPath $(WINDOWS_RELEASE)
+	powershell Compress-Archive -Path "$(RELEASE_FOLDER)"/* -DestinationPath "$(WINDOWS_RELEASE)"
 
 # Elimina la carpeta temporal 'RELEASE_FOLDER'
 	powershell if (Test-Path "$(RELEASE_FOLDER)") {Remove-Item "$(RELEASE_FOLDER)" -Recurse -Force}
@@ -98,17 +103,17 @@ macos_debug:
 
 macos_release:
 # Elimina datos de compilaciones anteriores
-	rm -rdf "$(RELEASE_FOLDER)"
+	$(RMDIR) "$(RELEASE_FOLDER)"
-	rm -rdf Frameworks
+	$(RMDIR) Frameworks
-	rm -f tmp.dmg
+	$(RMFILE) tmp.dmg
-	rm -f "$(MACOS_INTEL_RELEASE)"
+	$(RMFILE) "$(MACOS_INTEL_RELEASE)"
-	rm -f "$(MACOS_APPLE_SILICON_RELEASE)"
+	$(RMFILE) "$(MACOS_APPLE_SILICON_RELEASE)"
 
 # Crea la carpeta temporal para hacer el trabajo y las carpetas obligatorias para crear una app de macos
-	mkdir -p "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks"
+	$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks"
-	mkdir -p "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS"
+	$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS"
-	mkdir -p "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
+	$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
-	mkdir -p Frameworks
+	$(MKDIR) Frameworks
 
 # Copia carpetas y ficheros
 	cp -R data "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
@@ -123,24 +128,24 @@ macos_release:
 	ln -s /Applications "$(RELEASE_FOLDER)"/Applications
 
 # Compila la versión para procesadores Intel
-	$(CXX) $(SOURCES) -D MACOS_BUNDLE $(CXXFLAGS) $(LDFLAGS) -o "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS/$(TARGET_FILE)" -rpath @executable_path/../Frameworks/ -target x86_64-apple-macos10.12
+	$(CXX) $(SOURCES) -D MACOS_BUNDLE $(CXXFLAGS) $(LDFLAGS) -o "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS/$(TARGET_NAME)" -rpath @executable_path/../Frameworks/ -target x86_64-apple-macos10.12
 
 # Empaqueta el .dmg de la versión Intel
 	hdiutil create tmp.dmg -ov -volname "$(APP_NAME)" -fs HFS+ -srcfolder "$(RELEASE_FOLDER)" 
 	hdiutil convert tmp.dmg -format UDZO -o "$(MACOS_INTEL_RELEASE)"
-	rm -f tmp.dmg
+	$(RMFILE) tmp.dmg
 
 # Compila la versión para procesadores Apple Silicon
-	$(CXX) $(SOURCES) -D MACOS_BUNDLE $(CXXFLAGS) $(LDFLAGS) -o "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS/$(TARGET_FILE)" -rpath @executable_path/../Frameworks/ -target arm64-apple-macos11
+	$(CXX) $(SOURCES) -D MACOS_BUNDLE -D SDL_DISABLE_IMMINTRIN_H $(CXXFLAGS) $(LDFLAGS) -o "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS/$(TARGET_NAME)" -rpath @executable_path/../Frameworks/ -target arm64-apple-macos11
 
 # Empaqueta el .dmg de la versión Apple Silicon
 	hdiutil create tmp.dmg -ov -volname "$(APP_NAME)" -fs HFS+ -srcfolder "$(RELEASE_FOLDER)" 
 	hdiutil convert tmp.dmg -format UDZO -o "$(MACOS_APPLE_SILICON_RELEASE)"
-	rm -f tmp.dmg
+	$(RMFILE) tmp.dmg
 
 # Elimina las carpetas temporales
-	$(RM) Frameworks
+	$(RMDIR) Frameworks
-	$(RM) "$(RELEASE_FOLDER)"
+	$(RMDIR) "$(RELEASE_FOLDER)"
 
 linux:
 	$(CXX) $(SOURCES) $(CXXFLAGS) $(LDFLAGS) -o "$(TARGET_FILE)"
@@ -151,10 +156,10 @@ linux_debug:
 
 linux_release:
 # Elimina carpetas previas
-	$(RM) "$(RELEASE_FOLDER)"
+	$(RMDIR) "$(RELEASE_FOLDER)"
 
 # Crea la carpeta temporal para realizar el lanzamiento
-	mkdir -p "$(RELEASE_FOLDER)"
+	$(MKDIR) "$(RELEASE_FOLDER)"
 
 # Copia ficheros
 	cp -R data "$(RELEASE_FOLDER)"
@@ -166,11 +171,11 @@ linux_release:
 	strip -s -R .comment -R .gnu.version "$(RELEASE_FILE)" --strip-unneeded
 
 # Empaqueta ficheros
-	$(RM) "$(LINUX_RELEASE)"
+	$(RMFILE) "$(LINUX_RELEASE)"
-	cd "$(RELEASE_FOLDER)" && tar -czvf "../$(LINUX_RELEASE)" *
+	cd "$(RELEASE_FOLDER)" && tar -czvf "$(LINUX_RELEASE)" *
 
 # Elimina la carpeta temporal
-	$(RM) "$(RELEASE_FOLDER)"
+	$(RMDIR) "$(RELEASE_FOLDER)"
 
 raspi:
 	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(TARGET_FILE)
@@ -179,12 +184,35 @@ raspi:
 raspi_debug:
 	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE -D DEBUG $(CXXFLAGS_DEBUG) $(LDFLAGS) -o "$(TARGET_FILE)_debug"
 
-anbernic:
+raspi_release:
 # Elimina carpetas previas
-	$(RM) "$(RELEASE_FOLDER)"_anbernic
+	$(RMDIR) "$(RELEASE_FOLDER)"
 
 # Crea la carpeta temporal para realizar el lanzamiento
-	mkdir -p "$(RELEASE_FOLDER)"_anbernic
+	$(MKDIR) "$(RELEASE_FOLDER)"
+
+# Copia ficheros
+	cp -R data "$(RELEASE_FOLDER)"
+	cp LICENSE "$(RELEASE_FOLDER)"
+	cp README.md "$(RELEASE_FOLDER)"
+
+# Complia
+	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o "$(RELEASE_FILE)"
+	strip -s -R .comment -R .gnu.version "$(RELEASE_FILE)" --strip-unneeded
+
+# Empaqueta ficheros
+	$(RMFILE) "$(LINUX_RELEASE)"
+	cd "$(RELEASE_FOLDER)" && tar -czvf "$(RASPI_RELEASE)" *
+
+# Elimina la carpeta temporal
+	$(RMDIR) "$(RELEASE_FOLDER)"
+
+anbernic:
+# Elimina carpetas previas
+	$(RMDIR) "$(RELEASE_FOLDER)"_anbernic
+
+# Crea la carpeta temporal para realizar el lanzamiento
+	$(MKDIR) "$(RELEASE_FOLDER)"_anbernic
 
 # Copia ficheros
 	cp -R data "$(RELEASE_FOLDER)"_anbernic

README.md

@@ -30,7 +30,9 @@ Les tecles son les següents:
 
 - **Tecla F5**: Activa o desactiva l'audio
 
-- **Tecla F6**: Canvia el idioma del joc i reinicia
+- **Tecla F6**: Activa o desactiva el dispar automàtic
+
+- **Tecla F7**: Canvia el idioma del joc i reinicia
 
 - **Tecla F10**: Reset
 

data/config/param_320x240.txt

@@ -14,7 +14,7 @@ fade.num_squares_height   120
 fade.random_squares_delay   1
 fade.random_squares_mult  500
 fade.post_duration         80
-fade.venetian_size         16
+fade.venetian_size         12
 
 ## SCOREBOARD
 scoreboard.x   0

data/config/param_320x256.txt

@@ -14,7 +14,7 @@ fade.num_squares_height   128
 fade.random_squares_delay   1
 fade.random_squares_mult  500
 fade.post_duration         80
-fade.venetian_size         16
+fade.venetian_size         12
 
 ## SCOREBOARD
 scoreboard.x   0

data/gfx/tabe/tabe.ani

@@ -0,0 +1,9 @@
+frame_width=32
+frame_height=32
+
+[animation]
+name=default
+speed=2
+loop=0
+frames=0,1
+[/animation]

release/coffee.rc

@@ -0,0 +1,2 @@
+// coffee.rc
+IDI_ICON1 ICON "icon.ico"

source/balloon.cpp

@@ -5,6 +5,8 @@
 #include "param.h"			 // Para Param, param, ParamBalloon, ParamGame
 #include "sprite.h"			 // Para Sprite
 #include "texture.h"		 // Para Texture
+#include "resource.h"
+#include "jail_audio.h"
 
 // Constructor
 Balloon::Balloon(float x, float y, BalloonType type, BalloonSize size, float vel_x, float speed, Uint16 creation_timer, SDL_Rect play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
@@ -36,6 +38,7 @@ Balloon::Balloon(float x, float y, BalloonType type, BalloonSize size, float vel
 		power_ = BALLOON_POWER[index];
 		menace_ = BALLOON_MENACE[index];
 		score_ = BALLOON_SCORE[index];
+		sound_ = BALLOON_SOUND[index];
 
 		break;
 	}
@@ -50,14 +53,16 @@ Balloon::Balloon(float x, float y, BalloonType type, BalloonSize size, float vel
 		power_ = BALLOON_POWER[index];
 		menace_ = BALLOON_MENACE[index];
 		score_ = BALLOON_SCORE[index];
+		sound_ = BALLOON_SOUND[index];
 
 		break;
 	}
 
 	case BalloonType::POWERBALL:
 	{
-		const int index = 3;
+		constexpr int index = 3;
 		h_ = w_ = BALLOON_SIZE[4];
+		sound_ = BALLOON_SOUND[3];
 		power_ = score_ = menace_ = 0;
 
 		vy_ = 0;
@@ -145,6 +150,7 @@ void Balloon::move()
 		const float max_x = play_area_.x + play_area_.w - w_ + clip;
 		if (x_ < min_x || x_ > max_x)
 		{
+			playSound();
 			x_ = std::clamp(x_, min_x, max_x);
 			vx_ = -vx_;
 			// Activa el efecto de rebote o invierte la rotación
@@ -179,6 +185,7 @@ void Balloon::move()
 			const int min_y = play_area_.y;
 			if (y_ < min_y)
 			{
+				playSound();
 				y_ = min_y;
 				vy_ = -vy_;
 				enableBounce();
@@ -189,6 +196,7 @@ void Balloon::move()
 		const int max_y = play_area_.y + play_area_.h - h_;
 		if (y_ > max_y)
 		{
+			playSound();
 			y_ = max_y;
 			vy_ = -default_vy_;
 			if (type_ != BalloonType::POWERBALL)
@@ -401,4 +409,13 @@ void Balloon::useNormalColor()
 {
 	use_reversed_colors_ = false;
 	setAnimation();
+}
+
+// Reproduce el sonido al rebotar
+void Balloon::playSound()
+{
+	if (sound_enabled_)
+	{
+		JA_PlaySound(Resource::get()->getSound(sound_));
+	}
 }

source/balloon.h

@@ -17,6 +17,7 @@ constexpr int BALLOON_SCORE[] = {50, 100, 200, 400};
 constexpr int BALLOON_POWER[] = {1, 3, 7, 15};
 constexpr int BALLOON_MENACE[] = {1, 2, 4, 8};
 constexpr int BALLOON_SIZE[] = {10, 16, 26, 48, 49};
+const std::string BALLOON_SOUND[] = {"bubble1.wav", "bubble2.wav", "bubble3.wav", "bubble4.wav"};
 
 // Tamaños de globo
 enum class BalloonSize : Uint8
@@ -113,6 +114,8 @@ private:
 	float speed_;					   // Velocidad a la que se mueven los globos
 	Uint8 power_;					   // Cantidad de poder que alberga el globo
 	SDL_Rect play_area_;			   // Zona por donde se puede mover el globo
+	std::string sound_;				   // Archivo de sonido que hace el globo al rebotar
+	bool sound_enabled_ = false;	   // Indica si ha de sonar el sonido del globo al rebotar
 
 	// Alinea el circulo de colisión con la posición del objeto globo
 	void shiftColliders();
@@ -138,6 +141,9 @@ private:
 	// Establece la animación correspondiente
 	void setAnimation();
 
+	// Reproduce el sonido al rebotar
+	void playSound();
+
 public:
 	// Constructor
 	Balloon(
@@ -208,4 +214,5 @@ public:
 	void setVelY(float vel_y) { vy_ = vel_y; }
 	void setSpeed(float speed) { speed_ = speed; }
 	void setInvulnerable(bool value) { invulnerable_ = value; }
+	void setSound(bool value) { sound_enabled_ = value; }
 };

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;
+            const auto num_enemies = set.number_of_balloons;
-            for (int i = 0; i < numEnemies; ++i)
+            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;
+    const auto num_enemies = set.number_of_balloons;
-    for (int i = 0; i < numEnemies; ++i)
+    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;
+    const auto num_enemies = set.number_of_balloons;
-    for (int i = 0; i < numEnemies; ++i)
+    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);
@@ -366,9 +373,33 @@ 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()
 {
     return std::accumulate(balloons_.begin(), balloons_.end(), 0, [](int sum, const auto &balloon)
                            { return sum + (balloon->isEnabled() ? balloon->getMenace() : 0); });
+}
+
+// Establece el sonido de los globos
+void BalloonManager::setSounds(bool value)
+{
+    for (auto &balloon : balloons_)
+    {
+        balloon->setSound(value);
+    }
 }

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,15 +109,23 @@ 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();
 
+    // Establece el sonido de los globos
+    void setSounds(bool value);
+
     // Getters
     float getBalloonSpeed() const { return balloon_speed_; }
     Balloons &getBalloons() { return balloons_; }
+    int getNumBalloons() const { return balloons_.size(); }
 
     // Setters
     void setDefaultBalloonSpeed(float speed) { default_balloon_speed_ = speed; }
     void resetBalloonSpeed() { setBalloonSpeed(default_balloon_speed_); }
     void setPlayArea(SDL_Rect play_area) { play_area_ = play_area; }
+    void setCreationTimeEnabled(bool value) { creation_time_enabled_ = value; }
 };

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,20 @@ 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_};
+    // 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_};
+    // 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_->setMode(FadeMode::IN);
     fade_in_->activate();
-    
+
     fade_out_->setColor(0, 0, 0);
     fade_out_->setType(FadeType::FULLSCREEN);
     fade_out_->setPost(400);
-    
+
     initPlayers();
     SDL_SetTextureBlendMode(text_texture_, SDL_BLENDMODE_BLEND);
     fillTextTexture();
@@ -158,6 +159,9 @@ void Credits::checkEvents()
             section::options = section::Options::QUIT_FROM_EVENT;
             break;
         }
+
+        // Comprueba el cursor
+        Mouse::handleEvent(event);
     }
 }
 

source/director.cpp

@@ -180,8 +180,9 @@ void Director::bindInputs()
 	Input::get()->bindKey(InputType::WINDOW_FULLSCREEN, SDL_SCANCODE_F3);
 	Input::get()->bindKey(InputType::VIDEO_SHADERS, SDL_SCANCODE_F4);
 	Input::get()->bindKey(InputType::MUTE, SDL_SCANCODE_F5);
-	Input::get()->bindKey(InputType::CHANGE_LANG, SDL_SCANCODE_F6);
+	Input::get()->bindKey(InputType::AUTO_FIRE, SDL_SCANCODE_F6);
-	Input::get()->bindKey(InputType::SHOWINFO, SDL_SCANCODE_F7);
+	Input::get()->bindKey(InputType::CHANGE_LANG, SDL_SCANCODE_F7);
+	Input::get()->bindKey(InputType::SHOWINFO, SDL_SCANCODE_F8);
 	Input::get()->bindKey(InputType::RESET, SDL_SCANCODE_F10);
 
 	// Asigna botones a inputs
@@ -295,8 +296,15 @@ bool Director::initSDL()
 		}
 		*/
 
+		// Obtiene información sobre la pantalla
 		SDL_DisplayMode DM;
 		SDL_GetCurrentDisplayMode(0, &DM);
+
+		// Calcula el máximo factor de zoom que se puede aplicar a la pantalla
+		options.video.window.max_size = std::min(DM.w / param.game.width, DM.h / param.game.height);
+		options.video.window.size = std::min(options.video.window.size, options.video.window.max_size);
+
+		// Muestra información sobre el tamaño de la pantalla y de la ventana de juego
 		std::cout << "\nCurrent display mode: " << DM.w << "x" << DM.h << " @ " << DM.refresh_rate << "Hz" << std::endl;
 		std::cout << "Window resolution   : " << param.game.width << "x" << param.game.height << " x" << options.video.window.size << std::endl;
 
@@ -386,17 +394,25 @@ void Director::setFileList()
 	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/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);
@@ -439,6 +455,11 @@ void Director::setFileList()
 		Asset::get()->add(prefix + "/data/gfx/bullet/bullet.png", AssetType::BITMAP);
 	}
 
+	{ // Tabe
+		Asset::get()->add(prefix + "/data/gfx/tabe/tabe.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/tabe/tabe.ani", AssetType::ANIMATION);
+	}
+
 	{ // Juego
 		Asset::get()->add(prefix + "/data/gfx/game/game_buildings.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/game/game_clouds1.png", AssetType::BITMAP);

source/fade.cpp

@@ -100,6 +100,8 @@ void Fade::update()
 
 				SDL_RenderFillRect(renderer_, &rect1_);
 				SDL_RenderFillRect(renderer_, &rect2_);
+
+				value_ = calculateValue(0, counter_, i);
 			}
 
 			// Deja el renderizador como estaba
@@ -121,7 +123,6 @@ void Fade::update()
 				// Dibuja sobre el backbuffer_
 				auto temp = SDL_GetRenderTarget(renderer_);
 				SDL_SetRenderTarget(renderer_, backbuffer_);
-
 				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
 				SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
 
@@ -133,12 +134,12 @@ void Fade::update()
 					SDL_RenderFillRect(renderer_, &square_[index2]);
 				}
 
-				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
-
 				// Deja el renderizador como estaba
 				SDL_SetRenderTarget(renderer_, temp);
 			}
 
+			value_ = calculateValue(0, static_cast<int>(num_squares_width_ * num_squares_height_), static_cast<int>(counter_ * fade_random_squares_mult_ / fade_random_squares_delay_));
+
 			// Comprueba si ha terminado
 			if (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_ >= num_squares_width_ * num_squares_height_)
 			{
@@ -150,15 +151,17 @@ 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_
 				auto temp = SDL_GetRenderTarget(renderer_);
 				SDL_SetRenderTarget(renderer_, backbuffer_);
-
+				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
 				SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
-				for (auto rect : square_)
+
+				// Dibuja el cuadrado correspondiente
+				for (const auto rect : square_)
 				{
 					SDL_RenderFillRect(renderer_, &rect);
 				}
@@ -166,12 +169,23 @@ void Fade::update()
 				// Deja el renderizador como estaba
 				SDL_SetRenderTarget(renderer_, temp);
 
-				const auto h = counter_ / 3;
+				// Modifica el tamaño de los rectangulos
-				for (int i = 0; i < (int)square_.size(); ++i)
+				const auto h = counter_ / 2;
+				for (size_t i = 0; i < square_.size(); ++i)
 				{
 					// A partir del segundo rectangulo se pinta en función del anterior
-					square_[i].h = i == 0 ? h : std::max(square_[i - 1].h - 3, 0);
+					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
 			{
@@ -251,12 +265,8 @@ void Fade::activate()
 		}
 
 		// Limpia la textura
-		auto temp = SDL_GetRenderTarget(renderer_);
-		SDL_SetRenderTarget(renderer_, backbuffer_);
 		a_ = mode_ == FadeMode::OUT ? 0 : 255;
-		SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
+		cleanBackbuffer(r_, g_, b_, a_);
-		SDL_RenderClear(renderer_);
-		SDL_SetRenderTarget(renderer_, temp);
 
 		// Deja el color listo para usar
 		a_ = mode_ == FadeMode::OUT ? 255 : 0;
@@ -266,12 +276,16 @@ void Fade::activate()
 
 	case FadeType::VENETIAN:
 	{
-		cleanBackbuffer(0, 0, 0, 0);
+		// Limpia la textura
-		rect1_ = {0, 0, param.game.width, 0};
+		a_ = mode_ == FadeMode::OUT ? 0 : 255;
-		square_.clear();
+		cleanBackbuffer(r_, g_, b_, a_);
-		a_ = 255;
+
+		// Deja el color listo para usar
+		a_ = mode_ == FadeMode::OUT ? 255 : 0;
 
 		// Añade los cuadrados al vector
+		square_.clear();
+		rect1_ = {0, 0, param.game.width, 0};
 		const int max = param.game.height / param.fade.venetian_size;
 
 		for (int i = 0; i < max; ++i)
@@ -285,31 +299,6 @@ void Fade::activate()
 	}
 }
 
-// Comprueba si está activo
-bool Fade::isEnabled() const
-{
-	return enabled_;
-}
-
-// Comprueba si ha terminado la transicion
-bool Fade::hasEnded() const
-{
-	// Ha terminado cuando ha finalizado la transición y se ha deshabilitado
-	return !enabled_ && finished_;
-}
-
-// Establece el tipo de fade
-void Fade::setType(FadeType type)
-{
-	type_ = type;
-}
-
-// Establece el modo de fade
-void Fade::setMode(FadeMode mode)
-{
-	mode_ = mode;
-}
-
 // Establece el color del fade
 void Fade::setColor(Uint8 r, Uint8 g, Uint8 b)
 {
@@ -318,12 +307,6 @@ void Fade::setColor(Uint8 r, Uint8 g, Uint8 b)
 	b_ = b;
 }
 
-// Establece la duración posterior
-void Fade::setPost(int value)
-{
-	post_duration_ = value;
-}
-
 // Limpia el backbuffer
 void Fade::cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a)
 {
@@ -337,4 +320,14 @@ void Fade::cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a)
 
 	// Vuelve a dejar el renderizador como estaba
 	SDL_SetRenderTarget(renderer_, temp);
+}
+
+// Calcula el valor del estado del fade
+int Fade::calculateValue(int min, int max, int current)
+{
+	if (current < min)
+		return 0;
+	if (current > max)
+		return 100;
+	return static_cast<int>(100.0 * (current - min) / (max - min));
 }

source/fade.h

@@ -45,6 +45,7 @@ private:
 	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
 
 	// Inicializa las variables
 	void init();
@@ -52,6 +53,9 @@ private:
 	// Limpia el backbuffer
 	void cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a);
 
+	// Calcula el valor del estado del fade
+	int calculateValue(int min, int max, int current);
+
 public:
 	// Constructor
 	Fade();
@@ -71,21 +75,16 @@ public:
 	// Activa el fade
 	void activate();
 
-	// Comprueba si ha terminado la transicion
-	bool hasEnded() const;
-
-	// Comprueba si está activo
-	bool isEnabled() const;
-
-	// Establece el tipo de fade
-	void setType(FadeType type);
-
-	// Establece el modo de fade
-	void setMode(FadeMode mode);
-
 	// Establece el color del fade
 	void setColor(Uint8 r, Uint8 g, Uint8 b);
 
-	// Establece la duración posterior
+	// Getters
-	void setPost(int value);
+	int getValue() const { return value_; }
+	bool isEnabled() const { return enabled_; }
+	bool hasEnded() const { return !enabled_ && finished_; }
+
+	// Setters
+	void setType(FadeType type) { type_ = type; }
+	void setMode(FadeMode mode) { mode_ = mode; }
+	void setPost(int value) { post_duration_ = value; }
 };

source/game.cpp

@@ -32,9 +32,11 @@
 #include "section.h"			  // Para Name, name, Options, options
 #include "smart_sprite.h"		  // Para SmartSprite
 #include "stage.h"				  // Para number, get, Stage, power, total_p...
+#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)
@@ -44,8 +46,10 @@ Game::Game(int player_id, int current_stage, bool demo)
 	  input_(Input::get()),
 	  background_(std::make_unique<Background>()),
 	  canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.play_area.rect.w, param.game.play_area.rect.h)),
-	  fade_(std::make_unique<Fade>()),
+	  fade_in_(std::make_unique<Fade>()),
-	  balloon_manager_(std::make_unique<BalloonManager>())
+	  fade_out_(std::make_unique<Fade>()),
+	  balloon_manager_(std::make_unique<BalloonManager>()),
+	  tabe_(std::make_unique<Tabe>())
 {
 	// Pasa variables
 	demo_.enabled = demo;
@@ -63,9 +67,15 @@ Game::Game(int player_id, int current_stage, bool demo)
 	Scoreboard::init();
 	scoreboard_ = Scoreboard::get();
 
-	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
+	fade_in_->setColor(fade_color.r, fade_color.g, fade_color.b);
-	fade_->setPost(param.fade.post_duration);
+	fade_in_->setPost(0);
-	fade_->setType(FadeType::VENETIAN);
+	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_->setType(FadeType::VENETIAN);
 
 	background_->setPos(param.game.play_area.rect);
 
@@ -87,24 +97,25 @@ Game::Game(int player_id, int current_stage, bool demo)
 			Stage::total_power += Stage::get(i).power_to_complete;
 		}
 #endif
-
-	// Crea los primeros globos y el mensaje de inicio
-	if (!demo_.enabled)
-	{
-		balloon_manager_->createTwoBigBalloons();
-		evaluateAndSetMenace();
-		createMessage({paths_.at(0), paths_.at(1)}, Resource::get()->getTexture("get_ready"));
-	}
 }
 
 Game::~Game()
 {
-	// Guarda las puntuaciones en un fichero
+	// MODO DEMO
-	if (!demo_.enabled)
+	if (demo_.enabled)
 	{
+		// Habilita los sonidos
+		JA_EnableSound(true);
+	}
+	// MODO JUEGO
+	else
+	{
+		// Guarda las puntuaciones en un fichero
 		auto manager = std::make_unique<ManageHiScoreTable>(options.game.hi_score_table);
 		manager->saveToFile(asset_->get("score.bin"));
+		section::attract_mode = section::AttractMode::TITLE_TO_DEMO;
 	}
+
 #ifdef RECORDING
 	saveDemoFile(Asset::get()->get("demo1.bin"), demo_.data.at(0));
 #endif
@@ -213,8 +224,8 @@ void Game::updatePlayers()
 
 				if (demo_.enabled && allPlayersAreNotPlaying())
 				{
-					fade_->setType(FadeType::RANDOM_SQUARE);
+					fade_out_->setType(FadeType::RANDOM_SQUARE);
-					fade_->activate();
+					fade_out_->activate();
 				}
 			}
 
@@ -262,7 +273,7 @@ void Game::updateStage()
 				std::vector<Path> paths = {paths_.at(2), paths_.at(3)};
 				if (Stage::number == 9)
 				{
-					createMessage(paths, Resource::get()->getTexture("last_stage"));
+					createMessage(paths, Resource::get()->getTexture("game_text_last_stage"));
 				}
 				else
 				{
@@ -276,96 +287,127 @@ void Game::updateStage()
 }
 
 // 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"));
-				createMessage({paths_.at(2), paths_.at(3)}, Resource::get()->getTexture("game_over"));
+			JA_FadeOutMusic(1000);
-
+			balloon_manager_->setSounds(true);
-			game_over_counter_--;
-
-			if ((game_over_counter_ == 250) || (game_over_counter_ == 200) || (game_over_counter_ == 180) || (game_over_counter_ == 120) || (game_over_counter_ == 60))
-			{
-				// Hace sonar aleatoriamente uno de los 4 sonidos de burbujas
-				const auto index = rand() % 4;
-				JA_Sound_t *sound[4] = {Resource::get()->getSound("bubble1.wav"), Resource::get()->getSound("bubble2.wav"), Resource::get()->getSound("bubble3.wav"), Resource::get()->getSound("bubble4.wav")};
-				JA_PlaySound(sound[index], 0);
-			}
-
-			if (game_over_counter_ == 150)
-			{
-				fade_->activate();
-			}
 		}
 
-		if (fade_->hasEnded())
+		game_over_counter_--;
+
+		if (game_over_counter_ == 150)
 		{
-			if (game_completed_counter_ > 0)
+			fade_out_->activate();
-			{
-				// 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;
-			}
 		}
 	}
+
+	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
+		stopMusic();
-		if (game_completed_counter_ == 0)
+		Stage::number = 9;						// Deja el valor dentro de los limites
-		{
+		balloon_manager_->destroyAllBalloons(); // Destruye a todos los globos
-			stopMusic();
+		destroyAllItems();						// Destruye todos los items
-			Stage::number = 9;						// Deja el valor dentro de los limites
+		Stage::power = 0;						// Vuelve a dejar el poder a cero, por lo que hubiera podido subir al destruir todos los globos
-			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("congratulations"));
-			createMessage({paths_.at(6), paths_.at(7)}, Resource::get()->getTexture("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_;
 	}
+
+	// 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
@@ -474,6 +516,7 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
 							(item->getWidth() - game_text_textures_[4]->getWidth()) / 2;
 						createItemText(x, game_text_textures_[4]);
 					}
+					JA_PlaySound(Resource::get()->getSound("voice_coffee.wav"));
 					break;
 				}
 				case ItemType::COFFEE_MACHINE:
@@ -484,6 +527,7 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
 						item->getPosX() +
 						(item->getWidth() - game_text_textures_[3]->getWidth()) / 2;
 					createItemText(x, game_text_textures_[3]);
+					JA_PlaySound(Resource::get()->getSound("voice_power_up.wav"));
 					break;
 				}
 				default:
@@ -554,11 +598,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
@@ -722,7 +770,9 @@ void Game::createMessage(const std::vector<Path> &paths, std::shared_ptr<Texture
 
 	// Inicializa
 	for (const auto &path : paths)
+	{
 		path_sprites_.back()->addPath(path, true);
+	}
 	path_sprites_.back()->enable();
 }
 
@@ -771,28 +821,36 @@ 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
@@ -815,13 +873,12 @@ void Game::killPlayer(std::shared_ptr<Player> &player)
 	else
 	{
 		// Si no tiene cafes, muere
-		pauseMusic();
+		// pauseMusic();
 		balloon_manager_->stopAllBalloons();
 		JA_PlaySound(Resource::get()->getSound("player_collision.wav"));
 		screen_->shake();
-		JA_PlaySound(Resource::get()->getSound("coffeeout.wav"));
+		JA_PlaySound(Resource::get()->getSound("voice_no.wav"));
 		player->setPlayingState(PlayerState::DYING);
-		allPlayersAreNotPlaying() ? stopMusic() : resumeMusic();
 	}
 }
 
@@ -865,11 +922,37 @@ void Game::update()
 #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();
-        globalInputs::update();
+		globalInputs::update();
 		fillCanvas();
 	}
 }
@@ -912,11 +995,10 @@ void Game::fillCanvas()
 	renderItems();
 	renderSmartSprites();
 	balloon_manager_->render();
+	tabe_->render();
 	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);
 
 	// Deja el renderizador apuntando donde estaba
 	SDL_SetRenderTarget(renderer_, temp);
@@ -935,7 +1017,8 @@ void Game::render()
 	scoreboard_->render();
 
 	// Dibuja el fade
-	fade_->render();
+	fade_in_->render();
+	fade_out_->render();
 
 	// Vuelca el contenido del renderizador en pantalla
 	screen_->blit();
@@ -960,10 +1043,11 @@ void Game::disableTimeStopItem()
 // Comprueba si la música ha de estar sonando
 void Game::checkMusicStatus()
 {
-	// Si la música no está sonando
+	// Si se ha completado el juego o los jugadores han terminado, detiene la música
-	if (JA_GetMusicState() == JA_MUSIC_INVALID || JA_GetMusicState() == JA_MUSIC_STOPPED)
+	if (state_ == GameState::PLAYING || state_ == GameState::SHOWING_GET_READY_MESSAGE)
-		// Si se ha completado el juego o los jugadores han terminado, detiene la música
+	{
-		state_ == GameState::COMPLETED || allPlayersAreGameOver() ? JA_StopMusic() : JA_PlayMusic(Resource::get()->getMusic("playing.ogg"));
+		playMusic();
+	}
 }
 
 // Bucle para el juego
@@ -988,7 +1072,7 @@ void Game::initPaths()
 {
 	// Recorrido para el texto de "Get Ready!" (0,1)
 	{
-		const auto &texture = Resource::get()->getTexture("get_ready");
+		const auto &texture = Resource::get()->getTexture("game_text_get_ready");
 		const auto w = texture->getWidth();
 		const int x0 = -w;
 		const int x1 = param.game.play_area.center_x - w / 2;
@@ -998,10 +1082,9 @@ void Game::initPaths()
 		paths_.emplace_back(Path(createPath(x1, x2, PathType::HORIZONTAL, y, 80, easeInQuint), 0));
 	}
 
-	// Recorrido para el texto de "Last Stage!" o de "X stages left" o "Game Over"
+	// Recorrido para el texto de "Last Stage!" o de "X stages left" o "Game Over" (2,3)
-	// (2,3)
 	{
-		const auto &texture = Resource::get()->getTexture("last_stage");
+		const auto &texture = Resource::get()->getTexture("game_text_last_stage");
 		const auto h = texture->getHeight();
 		const int y0 = param.game.play_area.rect.h - h;
 		const int y1 = param.game.play_area.center_y - h / 2;
@@ -1013,7 +1096,7 @@ void Game::initPaths()
 
 	// Recorrido para el texto de "Congratulations!!" (3,4)
 	{
-		const auto &texture = Resource::get()->getTexture("congratulations");
+		const auto &texture = Resource::get()->getTexture("game_text_congratulations");
 		const auto w = texture->getWidth();
 		const auto h = texture->getHeight();
 		const int x0 = -w;
@@ -1026,7 +1109,7 @@ void Game::initPaths()
 
 	// Recorrido para el texto de "1.000.000 points!" (5,6)
 	{
-		const auto &texture = Resource::get()->getTexture("1000000_points");
+		const auto &texture = Resource::get()->getTexture("game_text_1000000_points");
 		const auto w = texture->getWidth();
 		const auto h = texture->getHeight();
 		const int x0 = param.game.play_area.rect.w;
@@ -1164,8 +1247,7 @@ void Game::checkEvents()
 			}
 			case SDLK_6: // Crea un mensaje
 			{
-				createMessage({paths_.at(4), paths_.at(5)}, Resource::get()->getTexture("congratulations"));
+				createMessage({paths_.at(0), paths_.at(1)}, Resource::get()->getTexture("game_text_get_ready"));
-				createMessage({paths_.at(6), paths_.at(7)}, Resource::get()->getTexture("1000000_points"));
 				break;
 			}
 			case SDLK_7: // Flash
@@ -1176,12 +1258,20 @@ void Game::checkEvents()
 			case SDLK_8:
 			{
 				players_.at(0)->setPlayingState(PlayerState::LEAVING_SCREEN);
+				break;
+			}
+			case SDLK_9:
+			{
+				tabe_->enable();
+				break;
 			}
 			default:
 				break;
 			}
 		}
 #endif
+		// Comprueba el cursor
+		Mouse::handleEvent(event);
 	}
 }
 
@@ -1342,7 +1432,8 @@ void Game::handleDemoMode()
 
 		if (input_->checkAnyButtonPressed())
 		{
-			section::name = section::Name::TITLE; // Salir del modo demo y regresar al menú principal.
+			section::name = section::Name::TITLE;						 // Salir del modo demo y regresar al menú principal.
+			section::attract_mode = section::AttractMode::TITLE_TO_DEMO; // El juego volverá a mostrar la demo
 			return;
 		}
 		++index;
@@ -1536,11 +1627,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;
+			const auto demo1 = rand() % 2;
-		demo_.data.emplace_back(Resource::get()->getDemoData(demo1));
+			const auto demo2 = (demo1 == 0) ? 1 : 0;
-		demo_.data.emplace_back(Resource::get()->getDemoData(demo2));
+			demo_.data.emplace_back(Resource::get()->getDemoData(demo1));
+			demo_.data.emplace_back(Resource::get()->getDemoData(demo2));
+		}
 
 		// Selecciona una pantalla al azar
 		{
@@ -1557,7 +1653,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);
@@ -1579,6 +1675,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
@@ -1669,7 +1768,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);
 }
 
@@ -1691,6 +1790,16 @@ void Game::resumeMusic()
 	}
 }
 
+// Hace sonar la música
+void Game::playMusic()
+{
+	// Si la música no está sonando
+	if (JA_GetMusicState() == JA_MUSIC_INVALID || JA_GetMusicState() == JA_MUSIC_STOPPED)
+	{
+		JA_PlayMusic(Resource::get()->getMusic("playing.ogg"));
+	}
+}
+
 // Detiene la música
 void Game::stopMusic()
 {
@@ -1705,19 +1814,27 @@ 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)
 		{
-			fade_->setType(FadeType::RANDOM_SQUARE);
+			fade_out_->setType(FadeType::RANDOM_SQUARE);
-			fade_->activate();
+			fade_out_->activate();
 		}
 
 		// Si ha terminado el fundido, cambia de sección
-		if (fade_->hasEnded())
+		if (fade_out_->hasEnded())
 		{
 			section::name = section::Name::HI_SCORE_TABLE;
 			return;
@@ -1745,40 +1862,83 @@ void Game::updateRecording()
 }
 #endif
 
-// Actualiza las variables durante el transcurso normal del juego
+// Actualiza las variables durante dicho estado
-void Game::updateGame()
+void Game::updateGameStateFadeIn()
 {
-	if (!paused_)
+	fade_in_->update();
+	updateScoreboard();
+	updateBackground();
+	if (fade_in_->hasEnded())
 	{
-#ifdef DEBUG
+		state_ = GameState::ENTERING_PLAYER;
-		if (auto_pop_balloons_ && state_ == GameState::PLAYING)
+		balloon_manager_->createTwoBigBalloons();
-		{
+		evaluateAndSetMenace();
-			Stage::addPower(5);
-		}
-#endif
-		fade_->update();
-		updatePlayers();
-		checkPlayersStatusPlaying();
-		updateScoreboard();
-		updateBackground();
-		balloon_manager_->update();
-		moveBullets();
-		updateItems();
-		updateStage();
-		updateGameOverState();
-		updateCompletedState();
-		updateSmartSprites();
-		updatePathSprites();
-		updateTimeStopped();
-		updateHelper();
-		checkBulletBalloonCollision();
-		updateMenace();
-		checkAndUpdateBalloonSpeed();
-		checkState();
-		cleanVectors();
 	}
 }
 
+// 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()
 {
@@ -1792,21 +1952,24 @@ void Game::cleanVectors()
 // Gestiona el nivel de amenaza
 void Game::updateMenace()
 {
-	const auto stage = Stage::get(Stage::number);
+	if (state_ == GameState::PLAYING)
-	const float percent = Stage::power / stage.power_to_complete;
-	const int difference = stage.max_menace - stage.min_menace;
-
-	// Aumenta el nivel de amenaza en función de la puntuación
-	menace_threshold_ = stage.min_menace + (difference * percent);
-
-	// Si el nivel de amenza es inferior al umbral
-	if (menace_current_ < menace_threshold_)
 	{
-		// Crea una formación de enemigos
+		const auto stage = Stage::get(Stage::number);
-		balloon_manager_->deployBalloonFormation(Stage::number);
+		const float percent = Stage::power / stage.power_to_complete;
+		const int difference = stage.max_menace - stage.min_menace;
 
-		// Recalcula el nivel de amenaza con el nuevo globo
+		// Aumenta el nivel de amenaza en función de la puntuación
-		evaluateAndSetMenace();
+		menace_threshold_ = stage.min_menace + (difference * percent);
+
+		// Si el nivel de amenza es inferior al umbral
+		if (menace_current_ < menace_threshold_)
+		{
+			// Crea una formación de enemigos
+			balloon_manager_->deployBalloonFormation(Stage::number);
+
+			// Recalcula el nivel de amenaza con el nuevo globo
+			evaluateAndSetMenace();
+		}
 	}
 }
 

source/game.h

@@ -12,6 +12,7 @@
 class Asset;					  // lines 13-13
 class Background;				  // lines 14-14
 class BalloonManager;
+class Tabe;
 class Bullet;				   // lines 15-15
 class Fade;					   // lines 16-16
 class Input;				   // lines 17-17
@@ -65,6 +66,9 @@ private:
 	// Enum
 	enum class GameState
 	{
+		FADE_IN,
+		ENTERING_PLAYER,
+		SHOWING_GET_READY_MESSAGE,
 		PLAYING,
 		COMPLETED,
 		GAME_OVER,
@@ -140,8 +144,10 @@ private:
 	std::vector<std::vector<std::string>> item_animations_;	  // Vector con las animaciones de los items
 	std::vector<std::vector<std::string>> player_animations_; // Vector con las animaciones del jugador
 
-	std::unique_ptr<Fade> fade_;					  // Objeto para renderizar fades
+	std::unique_ptr<Fade> fade_in_;					  // Objeto para renderizar fades
+	std::unique_ptr<Fade> fade_out_;				  // Objeto para renderizar fades
 	std::unique_ptr<BalloonManager> balloon_manager_; // Objeto para gestionar los globos
+	std::unique_ptr<Tabe> tabe_;					  // Objeto para gestionar el Tabe Volaor
 	std::vector<Path> paths_;						  // Vector con los recorridos precalculados almacenados
 
 	// Variables
@@ -164,7 +170,7 @@ private:
 	int total_power_to_complete_game_;					  // La suma del poder necesario para completar todas las fases
 	int menace_current_ = 0;							  // Nivel de amenaza actual
 	int menace_threshold_ = 0;							  // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
-	GameState state_ = GameState::PLAYING;				  // Estado
+	GameState state_ = GameState::FADE_IN;				  // Estado
 #ifdef DEBUG
 	bool auto_pop_balloons_ = false; // Si es true, incrementa automaticamente los globos explotados
 #endif
@@ -194,7 +200,7 @@ private:
 	void updateStage();
 
 	// Actualiza el estado de fin de la partida
-	void updateGameOverState();
+	void updateGameStateGameOver();
 
 	// Destruye todos los items
 	void destroyAllItems();
@@ -209,7 +215,7 @@ private:
 	void checkBulletBalloonCollision();
 
 	// Mueve las balas activas
-	void moveBullets();
+	void updateBullets();
 
 	// Pinta las balas activas
 	void renderBullets();
@@ -373,6 +379,9 @@ private:
 	// Reanuda la música
 	void resumeMusic();
 
+	// Hace sonar la música
+	void playMusic();
+
 	// Detiene la música
 	void stopMusic();
 
@@ -382,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/game_logo.cpp

@@ -1,4 +1,5 @@
 #include "game_logo.h"
+#include <SDL2/SDL.h>
 #include <SDL2/SDL_render.h> // Para SDL_FLIP_HORIZONTAL
 #include <algorithm>         // Para max
 #include "animated_sprite.h" // Para AnimatedSprite
@@ -8,6 +9,11 @@
 #include "smart_sprite.h"    // Para SmartSprite
 #include "sprite.h"          // Para Sprite
 #include "texture.h"         // Para Texture
+#include "screen.h"
+
+constexpr int ZOOM_FACTOR = 5;
+constexpr int FLASH_DELAY = 3;
+constexpr int FLASH_LENGHT = FLASH_DELAY + 3;
 
 // Constructor
 GameLogo::GameLogo(int x, int y)
@@ -21,7 +27,7 @@ GameLogo::GameLogo(int x, int y)
       crisis_sprite_(std::make_unique<SmartSprite>(crisis_texture_)),
       arcade_edition_sprite_(std::make_unique<Sprite>(arcade_edition_texture_, (param.game.width - arcade_edition_texture_->getWidth()) / 2, param.title.arcade_edition_position, arcade_edition_texture_->getWidth(), arcade_edition_texture_->getHeight())),
       x_(x),
-      y_(y) { }
+      y_(y) {}
 
 // Inicializa las variables
 void GameLogo::init()
@@ -32,15 +38,8 @@ void GameLogo::init()
     // Variables
     coffee_crisis_status_ = Status::DISABLED;
     arcade_edition_status_ = Status::DISABLED;
-
+    shake_.init(1, 2, 8, xp);
-    shake_.desp = 1;
+    zoom_ = 3.0f * ZOOM_FACTOR;
-    shake_.delay = 2;
-    shake_.lenght = 8;
-    shake_.remaining = shake_.lenght;
-    shake_.counter = shake_.delay;
-    shake_.origin = xp;
-
-    zoom_ = 3.0f;
 
     // Inicializa el bitmap de 'Coffee'
     coffee_sprite_->setPosX(xp);
@@ -122,10 +121,11 @@ void GameLogo::update()
         if (coffee_sprite_->hasFinished() && crisis_sprite_->hasFinished())
         {
             coffee_crisis_status_ = Status::SHAKING;
-            arcade_edition_status_ = Status::MOVING;
 
             // Reproduce el efecto sonoro
             JA_PlaySound(Resource::get()->getSound("title.wav"));
+            Screen::get()->flash(Color(0xFF, 0xFF, 0xFF), FLASH_LENGHT, FLASH_DELAY);
+            Screen::get()->shake();
         }
 
         break;
@@ -133,7 +133,7 @@ void GameLogo::update()
 
     case Status::SHAKING:
     {
-        // Agita el logo
+        // Agita "COFFEE CRISIS"
         if (shake_.remaining > 0)
         {
             if (shake_.counter > 0)
@@ -154,6 +154,7 @@ void GameLogo::update()
             coffee_sprite_->setPosX(shake_.origin);
             crisis_sprite_->setPosX(shake_.origin + 15);
             coffee_crisis_status_ = Status::FINISHED;
+            arcade_edition_status_ = Status::MOVING;
         }
 
         dust_right_sprite_->update();
@@ -178,12 +179,42 @@ void GameLogo::update()
     {
     case Status::MOVING:
     {
-        zoom_ -= 0.1f;
+        zoom_ -= 0.1f * ZOOM_FACTOR;
         arcade_edition_sprite_->setZoom(zoom_);
         if (zoom_ <= 1.0f)
         {
-            arcade_edition_status_ = Status::FINISHED;
+            arcade_edition_status_ = Status::SHAKING;
             zoom_ = 1.0f;
+            arcade_edition_sprite_->setZoom(zoom_);
+            shake_.init(1, 2, 8, arcade_edition_sprite_->getX());
+            JA_PlaySound(Resource::get()->getSound("title.wav"));
+            Screen::get()->flash(Color(0xFF, 0xFF, 0xFF), FLASH_LENGHT, FLASH_DELAY);
+            Screen::get()->shake();
+        }
+        break;
+    }
+
+    case Status::SHAKING:
+    {
+        // Agita "ARCADE EDITION"
+        if (shake_.remaining > 0)
+        {
+            if (shake_.counter > 0)
+            {
+                shake_.counter--;
+            }
+            else
+            {
+                shake_.counter = shake_.delay;
+                const auto desp = shake_.remaining % 2 == 0 ? shake_.desp * (-1) : shake_.desp;
+                arcade_edition_sprite_->setX(shake_.origin + desp);
+                shake_.remaining--;
+            }
+        }
+        else
+        {
+            arcade_edition_sprite_->setX(shake_.origin);
+            arcade_edition_status_ = Status::FINISHED;
         }
         break;
     }
@@ -191,6 +222,13 @@ void GameLogo::update()
     default:
         break;
     }
+
+    if (coffee_crisis_status_ == Status::FINISHED &&
+        arcade_edition_status_ == Status::FINISHED &&
+        post_finished_counter_ > 0)
+    {
+        --post_finished_counter_;
+    }
 }
 
 // Activa la clase
@@ -203,7 +241,7 @@ void GameLogo::enable()
 // Indica si ha terminado la animación
 bool GameLogo::hasFinished() const
 {
-    return coffee_crisis_status_ == Status::FINISHED && arcade_edition_status_ == Status::FINISHED;
+    return post_finished_counter_ == 0;
 }
 
 // Recarga las texturas

source/game_logo.h

@@ -20,12 +20,30 @@ private:
 
     struct Shake
     {
-        int desp;      // Pixels de desplazamiento para agitar la pantalla en el eje x
+        int desp = 1;           // Pixels de desplazamiento para agitar la pantalla en el eje x
-        int delay;     // Retraso entre cada desplazamiento de la pantalla al agitarse
+        int delay = 2;          // Retraso entre cada desplazamiento de la pantalla al agitarse
-        int counter;   // Contador para el retraso
+        int lenght = 8;         // Cantidad de desplazamientos a realizar
-        int lenght;    // Cantidad de desplazamientos a realizar
+        int remaining = lenght; // Cantidad de desplazamientos pendientes a realizar
-        int remaining; // Cantidad de desplazamientos pendientes a realizar
+        int counter = delay;    // Contador para el retraso
-        int origin;    // Valor inicial de la pantalla para dejarla igual tras el desplazamiento
+        int origin;             // Valor inicial de la pantalla para dejarla igual tras el desplazamiento
+
+        // Constructor por defect
+        Shake() = default;
+
+        // Constructor
+        Shake(int d, int de, int l, int o)
+            : desp(d), delay(de), lenght(l), remaining(l), counter(de), origin(o) {}
+
+        // Inicializa los miembros
+        void init(int d, int de, int l, int o)
+        {
+            desp = d;
+            delay = de;
+            lenght = l;
+            remaining = l;
+            counter = de;
+            origin = o;
+        }
     };
 
     // Objetos y punteros
@@ -43,9 +61,10 @@ private:
     std::unique_ptr<Sprite> arcade_edition_sprite_; // Sprite con los graficos de "Arcade Edition"
 
     // Variables
-    int x_;      // Posición donde dibujar el logo
+    int x_;                           // Posición donde dibujar el logo
-    int y_;      // Posición donde dibujar el logo
+    int y_;                           // Posición donde dibujar el logo
-    float zoom_; // Zoom aplicado al texto "ARCADE EDITION"
+    float zoom_;                      // Zoom aplicado al texto "ARCADE EDITION"
+    int post_finished_counter_ = 1; // Contador final una vez terminada las animaciones de los logos
 
     Status coffee_crisis_status_ = Status::DISABLED;  // Estado en el que se encuentra el texto "COFFEE CRISIS"
     Status arcade_edition_status_ = Status::DISABLED; // Estado en el que se encuentra el texto "ARCADE_EDITION"

source/global_inputs.cpp

@@ -108,6 +108,13 @@ namespace globalInputs
         Notifier::get()->showText({getLangName(options.game.language)});
     }
 
+    // Cambia el modo de disparo
+    void toggleFireMode()
+    {
+        options.game.autofire = !options.game.autofire;
+        Notifier::get()->showText({"Autofire " + boolToOnOff(options.game.autofire)});
+    }
+
     // Comprueba los inputs que se pueden introducir en cualquier sección del juego
     void check()
     {
@@ -162,6 +169,13 @@ namespace globalInputs
                 return;
             }
 
+            // Autofire
+            if (Input::get()->checkInput(InputType::AUTO_FIRE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
+            {
+                toggleFireMode();
+                return;
+            }
+
             // Idioma
             if (Input::get()->checkInput(InputType::CHANGE_LANG, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {

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()
@@ -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,9 +209,10 @@ 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;
 		return;
 	}
 

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/input.h

@@ -44,6 +44,7 @@ enum class InputType : int
 	SHOWINFO,
 	CONFIG,
 	SWAP_CONTROLLERS,
+	AUTO_FIRE,
 
 	// Input obligatorio
 	NONE,

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()
@@ -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,9 +314,10 @@ 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;
 		return;
 	}
 

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();
 	}
 }
 
@@ -416,7 +422,6 @@ void Intro::render()
 void Intro::run()
 {
 	JA_PlayMusic(Resource::get()->getMusic("intro.ogg"), 0);
-
 	while (section::name == section::Name::INTRO)
 	{
 		checkInput();

source/jail_audio.cpp

@@ -1,91 +1,92 @@
 #ifndef JA_USESDLMIXER
-
 #include "jail_audio.h"
-#include <stdint.h>     // para uint8_t
+#include "stb_vorbis.c"
-#include <stdio.h>      // para NULL, fseek, fclose, fopen, fread, ftell, FILE
+#include <SDL2/SDL.h>
-#include <stdlib.h>     // para free, malloc
+#include <stdio.h>
-#include "stb_vorbis.c" // para stb_vorbis_decode_memory
 
-#define JA_MAX_SIMULTANEOUS_CHANNELS 5
+#define JA_MAX_SIMULTANEOUS_CHANNELS 20
 
-struct JA_Sound_t
+struct JA_Sound_t {
-{
+    Uint32  length {0};
-    Uint32 length{0};
+    Uint8*  buffer {NULL};
-    Uint8 *buffer{NULL};
 };
 
-struct JA_Channel_t
+struct JA_Channel_t {
-{
+    JA_Sound_t          *sound;
-    JA_Sound_t *sound;
+    int                 pos {0};
-    int pos{0};
+    int                 times {0};
-    int times{0};
+    JA_Channel_state    state { JA_CHANNEL_FREE };
-    JA_Channel_state state{JA_CHANNEL_FREE};
 };
 
-struct JA_Music_t
+struct JA_Music_t {
-{
+    int             samples {0};
-    int samples{0};
+    Uint32          length {0};
-    int pos{0};
+    int             pos {0};
-    int times{0};
+    int             times {0};
-    short *output{NULL};
+    short*          output {NULL};
-    JA_Music_state state{JA_MUSIC_INVALID};
+    JA_Music_state  state {JA_MUSIC_INVALID};
 };
 
-JA_Music_t *current_music{NULL};
+JA_Music_t      *current_music{NULL};
-JA_Channel_t channels[JA_MAX_SIMULTANEOUS_CHANNELS];
+JA_Channel_t    channels[JA_MAX_SIMULTANEOUS_CHANNELS];
 
-int JA_freq{48000};
+int             JA_freq {48000};
-SDL_AudioFormat JA_format{AUDIO_S16};
+SDL_AudioFormat JA_format {AUDIO_S16};
-Uint8 JA_channels{2};
+Uint8           JA_channels {2};
-int JA_musicVolume = 128;
+int             JA_musicVolume = 128;
-int JA_soundVolume = 64;
+int             JA_soundVolume = 64;
-bool JA_musicEnabled = true;
+bool            JA_musicEnabled = true;
-bool JA_soundEnabled = true;
+bool            JA_soundEnabled = true;
 SDL_AudioDeviceID sdlAudioDevice = 0;
 
-void audioCallback(void *userdata, uint8_t *stream, int len)
+bool fading = false;
-{
+int fade_start_time;
+int fade_duration;
+int fade_initial_volume;
+
+void audioCallback(void * userdata, uint8_t * stream, int len) {
     SDL_memset(stream, 0, len);
-    if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING)
+    if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING) {
-    {
+        int volume = JA_musicVolume;
-        const int size = SDL_min(len, current_music->samples * 2 - current_music->pos);
+        if (fading) {
-        SDL_MixAudioFormat(stream, (Uint8 *)(current_music->output + current_music->pos), AUDIO_S16, size, JA_musicVolume);
+            int time = SDL_GetTicks();
-        current_music->pos += size / 2;
+            if (time > (fade_start_time+fade_duration)) {
-        if (size < len)
+                fading = false;
-        {
+                current_music->pos = 0;
-            if (current_music->times != 0)
+                current_music->state = JA_MUSIC_STOPPED;
-            {
+                volume = 0;
-                SDL_MixAudioFormat(stream + size, (Uint8 *)current_music->output, AUDIO_S16, len - size, JA_musicVolume);
+            } else {
-                current_music->pos = (len - size) / 2;
+                const int time_passed = time - fade_start_time;
-                if (current_music->times > 0)
+                const float percent = (float)time_passed / (float)fade_duration;
-                    current_music->times--;
+                volume = JA_musicVolume * (1.0 - percent);
             }
-            else
+        }
-            {
+        const int size = SDL_min(len, current_music->length - current_music->pos);
+        SDL_MixAudioFormat(stream, (Uint8*)(current_music->output)+current_music->pos, AUDIO_S16, size, volume);
+        current_music->pos += size;
+        if (size < len) {
+            if (current_music->times != 0) {
+                SDL_MixAudioFormat(stream+size, (Uint8*)current_music->output, AUDIO_S16, len-size, volume);
+                current_music->pos = len-size;
+                if (current_music->times > 0) current_music->times--;
+            } else {
                 current_music->pos = 0;
                 current_music->state = JA_MUSIC_STOPPED;
             }
         }
     }
     // Mixar els channels mi amol
-    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-    {
+        if (channels[i].state == JA_CHANNEL_PLAYING) {
-        if (channels[i].state == JA_CHANNEL_PLAYING)
-        {
             const int size = SDL_min(len, channels[i].sound->length - channels[i].pos);
             SDL_MixAudioFormat(stream, channels[i].sound->buffer + channels[i].pos, AUDIO_S16, size, JA_soundVolume);
             channels[i].pos += size;
-            if (size < len)
+            if (size < len) {
-            {
+                if (channels[i].times != 0) {
-                if (channels[i].times != 0)
+                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len-size, JA_soundVolume);
-                {
+                    channels[i].pos = len-size;
-                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len - size, JA_soundVolume);
+                    if (channels[i].times > 0) channels[i].times--;
-                    channels[i].pos = len - size;
+                } else {
-                    if (channels[i].times > 0)
-                        channels[i].times--;
-                }
-                else
-                {
                     JA_StopChannel(i);
                 }
             }
@@ -99,65 +100,67 @@ void JA_Init(const int freq, const SDL_AudioFormat format, const int channels)
     JA_format = format;
     JA_channels = channels;
     SDL_AudioSpec audioSpec{JA_freq, JA_format, JA_channels, 0, 1024, 0, 0, audioCallback, NULL};
-    if (sdlAudioDevice != 0)
+    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
-        SDL_CloseAudioDevice(sdlAudioDevice);
     sdlAudioDevice = SDL_OpenAudioDevice(NULL, 0, &audioSpec, NULL, 0);
     SDL_PauseAudioDevice(sdlAudioDevice, 0);
 }
 
-void JA_Quit()
+void JA_Quit() {
-{
     SDL_PauseAudioDevice(sdlAudioDevice, 1);
-    if (sdlAudioDevice != 0)
+    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
-        SDL_CloseAudioDevice(sdlAudioDevice);
     sdlAudioDevice = 0;
 }
 
-JA_Music_t *JA_LoadMusic(const char *filename)
+JA_Music_t *JA_LoadMusic(Uint8* buffer, Uint32 length)
 {
     int chan, samplerate;
-
-    // [RZC 28/08/22] Carreguem primer el arxiu en memòria i després el descomprimim. Es algo més rapid.
-    FILE *f = fopen(filename, "rb");
-    fseek(f, 0, SEEK_END);
-    long fsize = ftell(f);
-    fseek(f, 0, SEEK_SET);
-    Uint8 *buffer = (Uint8 *)malloc(fsize + 1);
-    if (fread(buffer, fsize, 1, f) != 1)
-        return NULL;
-    fclose(f);
-
     JA_Music_t *music = new JA_Music_t();
 
-    music->samples = stb_vorbis_decode_memory(buffer, fsize, &chan, &samplerate, &music->output);
+    music->samples = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &music->output);
-    free(buffer);
     // [RZC 28/08/22] Abans el descomprimiem mentre el teniem obert
-    //    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
+//    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
 
     SDL_AudioCVT cvt;
     SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq);
-    if (cvt.needed)
+    if (cvt.needed) {
-    {
         cvt.len = music->samples * chan * 2;
-        cvt.buf = (Uint8 *)SDL_malloc(cvt.len * cvt.len_mult);
+        music->length = cvt.len;
+        cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
         SDL_memcpy(cvt.buf, music->output, cvt.len);
         SDL_ConvertAudio(&cvt);
         free(music->output);
-        music->output = (short *)cvt.buf;
+        music->output = (short*)cvt.buf;
     }
+    music->length = music->samples * chan * 2;
     music->pos = 0;
     music->state = JA_MUSIC_STOPPED;
 
     return music;
 }
 
+JA_Music_t *JA_LoadMusic(const char* filename)
+{
+    // [RZC 28/08/22] Carreguem primer el arxiu en memòria i després el descomprimim. Es algo més rapid.
+    FILE *f = fopen(filename, "rb");
+    fseek(f, 0, SEEK_END);
+    long fsize = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    Uint8 *buffer = (Uint8*)malloc(fsize + 1);
+    if (fread(buffer, fsize, 1, f)!=1) return NULL;
+    fclose(f);
+
+    JA_Music_t *music = JA_LoadMusic(buffer, fsize);
+
+    free(buffer);
+
+    return music;
+}
+
 void JA_PlayMusic(JA_Music_t *music, const int loop)
 {
-    if (!JA_musicEnabled || !music)
+    if (!JA_musicEnabled) return;
-        return;
 
-    if (current_music != NULL)
+    if (current_music != NULL) {
-    {
         current_music->pos = 0;
         current_music->state = JA_MUSIC_STOPPED;
     }
@@ -169,78 +172,108 @@ void JA_PlayMusic(JA_Music_t *music, const int loop)
 
 void JA_PauseMusic()
 {
-    if (!JA_musicEnabled)
+    if (!JA_musicEnabled) return;
-        return;
 
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
-        return;
     current_music->state = JA_MUSIC_PAUSED;
 }
 
 void JA_ResumeMusic()
 {
-    if (!JA_musicEnabled)
+    if (!JA_musicEnabled) return;
-        return;
 
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
-        return;
     current_music->state = JA_MUSIC_PLAYING;
 }
 
 void JA_StopMusic()
 {
-    if (!JA_musicEnabled)
+    if (!JA_musicEnabled) return;
-        return;
 
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
-        return;
     current_music->pos = 0;
     current_music->state = JA_MUSIC_STOPPED;
 }
 
-JA_Music_state JA_GetMusicState()
+void JA_FadeOutMusic(const int milliseconds)
 {
-    if (!JA_musicEnabled)
+    if (!JA_musicEnabled) return;
-        return JA_MUSIC_DISABLED;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
 
-    if (current_music == NULL)
+    fading = true;
-        return JA_MUSIC_INVALID;
+    fade_start_time = SDL_GetTicks();
+    fade_duration = milliseconds;
+    fade_initial_volume = JA_musicVolume;
+}
+
+JA_Music_state JA_GetMusicState() {
+    if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
+
+    if (current_music == NULL) return JA_MUSIC_INVALID;
     return current_music->state;
 }
 
-void JA_DeleteMusic(JA_Music_t *music)
+void JA_DeleteMusic(JA_Music_t *music) {
-{
+    if (current_music == music) current_music = NULL;
-    if (current_music == music)
-        current_music = NULL;
     free(music->output);
     delete music;
 }
 
 int JA_SetMusicVolume(int volume)
 {
-    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0
+    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
-                                                     : volume;
     return JA_musicVolume;
 }
 
+void JA_SetMusicPosition(float value)
+{
+    if (!current_music) return;
+    current_music->pos = value * JA_freq;
+}
+
+float JA_GetMusicPosition()
+{
+    if (!current_music) return 0;
+    return float(current_music->pos)/float(JA_freq);
+}
+
 void JA_EnableMusic(const bool value)
 {
-    if (!value && current_music != NULL && current_music->state == JA_MUSIC_PLAYING)
+    if (!value && current_music != NULL && current_music->state==JA_MUSIC_PLAYING) JA_StopMusic();
-        JA_StopMusic();
 
     JA_musicEnabled = value;
 }
 
-JA_Sound_t *JA_NewSound(Uint8 *buffer, Uint32 length)
+
-{
+
+
+
+JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length) {
     JA_Sound_t *sound = new JA_Sound_t();
     sound->buffer = buffer;
     sound->length = length;
     return sound;
 }
 
-JA_Sound_t *JA_LoadSound(const char *filename)
+JA_Sound_t *JA_LoadSound(uint8_t* buffer, uint32_t size) {
-{
+    JA_Sound_t *sound = new JA_Sound_t();
+    SDL_AudioSpec wavSpec;
+    SDL_LoadWAV_RW(SDL_RWFromMem(buffer, size),1, &wavSpec, &sound->buffer, &sound->length);
+    
+    SDL_AudioCVT cvt;
+    SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq);
+    cvt.len = sound->length;
+    cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
+    SDL_memcpy(cvt.buf, sound->buffer, sound->length);
+    SDL_ConvertAudio(&cvt);
+    SDL_FreeWAV(sound->buffer);
+    sound->buffer = cvt.buf;
+    sound->length = cvt.len_cvt;
+
+    return sound;
+}
+
+JA_Sound_t *JA_LoadSound(const char* filename) {
     JA_Sound_t *sound = new JA_Sound_t();
     SDL_AudioSpec wavSpec;
     SDL_LoadWAV(filename, &wavSpec, &sound->buffer, &sound->length);
@@ -248,7 +281,7 @@ JA_Sound_t *JA_LoadSound(const char *filename)
     SDL_AudioCVT cvt;
     SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq);
     cvt.len = sound->length;
-    cvt.buf = (Uint8 *)SDL_malloc(cvt.len * cvt.len_mult);
+    cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
     SDL_memcpy(cvt.buf, sound->buffer, sound->length);
     SDL_ConvertAudio(&cvt);
     SDL_FreeWAV(sound->buffer);
@@ -260,16 +293,24 @@ JA_Sound_t *JA_LoadSound(const char *filename)
 
 int JA_PlaySound(JA_Sound_t *sound, const int loop)
 {
-    if (!JA_soundEnabled || !sound)
+    if (!JA_soundEnabled) return -1;
-        return 0;
 
     int channel = 0;
-    while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE)
+    while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE) { channel++; }
-    {
+    if (channel == JA_MAX_SIMULTANEOUS_CHANNELS) channel = 0;
-        channel++;
+
-    }
+    channels[channel].sound = sound;
-    if (channel == JA_MAX_SIMULTANEOUS_CHANNELS)
+    channels[channel].times = loop;
-        channel = 0;
+    channels[channel].pos = 0;
+    channels[channel].state = JA_CHANNEL_PLAYING;
+    return channel;
+}
+
+int JA_PlaySoundOnChannel(JA_Sound_t *sound, const int channel, const int loop)
+{
+    if (!JA_soundEnabled) return -1;
+
+    if (channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return -1;
 
     channels[channel].sound = sound;
     channels[channel].times = loop;
@@ -280,10 +321,8 @@ int JA_PlaySound(JA_Sound_t *sound, const int loop)
 
 void JA_DeleteSound(JA_Sound_t *sound)
 {
-    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-    {
+        if (channels[i].sound == sound) JA_StopChannel(i);
-        if (channels[i].sound == sound)
-            JA_StopChannel(i);
     }
     SDL_free(sound->buffer);
     delete sound;
@@ -291,60 +330,41 @@ void JA_DeleteSound(JA_Sound_t *sound)
 
 void JA_PauseChannel(const int channel)
 {
-    if (!JA_soundEnabled)
+    if (!JA_soundEnabled) return;
-        return;
 
-    if (channel == -1)
+    if (channel == -1) {
-    {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+            if (channels[i].state == JA_CHANNEL_PLAYING) channels[i].state = JA_CHANNEL_PAUSED;
-        {
-            if (channels[i].state == JA_CHANNEL_PLAYING)
-                channels[i].state = JA_CHANNEL_PAUSED;
         }
-    }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
+        if (channels[channel].state == JA_CHANNEL_PLAYING) channels[channel].state = JA_CHANNEL_PAUSED;
-    {
-        if (channels[channel].state == JA_CHANNEL_PLAYING)
-            channels[channel].state = JA_CHANNEL_PAUSED;
     }
 }
 
 void JA_ResumeChannel(const int channel)
 {
-    if (!JA_soundEnabled)
+    if (!JA_soundEnabled) return;
-        return;
 
-    if (channel == -1)
+    if (channel == -1) {
-    {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+            if (channels[i].state == JA_CHANNEL_PAUSED) channels[i].state = JA_CHANNEL_PLAYING;
-        {
-            if (channels[i].state == JA_CHANNEL_PAUSED)
-                channels[i].state = JA_CHANNEL_PLAYING;
         }
-    }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
+        if (channels[channel].state == JA_CHANNEL_PAUSED) channels[channel].state = JA_CHANNEL_PLAYING;
-    {
-        if (channels[channel].state == JA_CHANNEL_PAUSED)
-            channels[channel].state = JA_CHANNEL_PLAYING;
     }
 }
 
 void JA_StopChannel(const int channel)
 {
-    if (!JA_soundEnabled)
+    if (!JA_soundEnabled) return;
-        return;
 
-    if (channel == -1)
+    if (channel == -1) {
-    {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
-        {
             channels[i].state = JA_CHANNEL_FREE;
             channels[i].pos = 0;
             channels[i].sound = NULL;
         }
-    }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
-    {
         channels[channel].state = JA_CHANNEL_FREE;
         channels[channel].pos = 0;
         channels[channel].sound = NULL;
@@ -353,18 +373,15 @@ void JA_StopChannel(const int channel)
 
 JA_Channel_state JA_GetChannelState(const int channel)
 {
-    if (!JA_soundEnabled)
+    if (!JA_soundEnabled) return JA_SOUND_DISABLED;
-        return JA_SOUND_DISABLED;
 
-    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS)
+    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return JA_CHANNEL_INVALID;
-        return JA_CHANNEL_INVALID;
     return channels[channel].state;
 }
 
 int JA_SetSoundVolume(int volume)
 {
-    JA_soundVolume = volume > 128 ? 128 : volume < 0 ? 0
+    JA_soundVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
-                                                     : volume;
     return JA_soundVolume;
 }
 
@@ -372,17 +389,15 @@ void JA_EnableSound(const bool value)
 {
     for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
     {
-        if (channels[i].state == JA_CHANNEL_PLAYING)
+        if (channels[i].state == JA_CHANNEL_PLAYING) JA_StopChannel(i);
-            JA_StopChannel(i);
     }
     JA_soundEnabled = value;
 }
 
 int JA_SetVolume(int volume)
 {
-    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0
+    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
-                                                     : volume;
+    JA_soundVolume = JA_musicVolume/2;
-    JA_soundVolume = JA_musicVolume / 2;
     return JA_musicVolume;
 }
 

source/jail_audio.h

@@ -1,43 +1,34 @@
 #pragma once
+#include <SDL2/SDL.h>
 
-#include <SDL2/SDL_audio.h>  // para SDL_AudioFormat
+enum JA_Channel_state { JA_CHANNEL_INVALID, JA_CHANNEL_FREE, JA_CHANNEL_PLAYING, JA_CHANNEL_PAUSED, JA_SOUND_DISABLED };
-#include <SDL2/SDL_stdinc.h> // para Uint32, Uint8
+enum JA_Music_state { JA_MUSIC_INVALID, JA_MUSIC_PLAYING, JA_MUSIC_PAUSED, JA_MUSIC_STOPPED, JA_MUSIC_DISABLED };
-struct JA_Music_t;           // lines 5-5
-struct JA_Sound_t;           // lines 6-6
 
-enum JA_Channel_state
+struct JA_Sound_t;
-{
+struct JA_Music_t;
-    JA_CHANNEL_INVALID,
-    JA_CHANNEL_FREE,
-    JA_CHANNEL_PLAYING,
-    JA_CHANNEL_PAUSED,
-    JA_SOUND_DISABLED
-};
-enum JA_Music_state
-{
-    JA_MUSIC_INVALID,
-    JA_MUSIC_PLAYING,
-    JA_MUSIC_PAUSED,
-    JA_MUSIC_STOPPED,
-    JA_MUSIC_DISABLED
-};
 
 void JA_Init(const int freq, const SDL_AudioFormat format, const int channels);
 void JA_Quit();
 
-JA_Music_t *JA_LoadMusic(const char *filename);
+JA_Music_t *JA_LoadMusic(const char* filename);
+JA_Music_t *JA_LoadMusic(Uint8* buffer, Uint32 length);
 void JA_PlayMusic(JA_Music_t *music, const int loop = -1);
 void JA_PauseMusic();
 void JA_ResumeMusic();
 void JA_StopMusic();
+void JA_FadeOutMusic(const int milliseconds);
 JA_Music_state JA_GetMusicState();
 void JA_DeleteMusic(JA_Music_t *music);
 int JA_SetMusicVolume(int volume);
+void JA_SetMusicPosition(float value);
+float JA_GetMusicPosition();
 void JA_EnableMusic(const bool value);
 
-JA_Sound_t *JA_NewSound(Uint8 *buffer, Uint32 length);
+JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length);
-JA_Sound_t *JA_LoadSound(const char *filename);
+JA_Sound_t *JA_LoadSound(Uint8* buffer, Uint32 length);
+JA_Sound_t *JA_LoadSound(const char* filename);
 int JA_PlaySound(JA_Sound_t *sound, const int loop = 0);
+int JA_PlaySoundOnChannel(JA_Sound_t *sound, const int channel, const int loop = 0);
 void JA_PauseChannel(const int channel);
 void JA_ResumeChannel(const int channel);
 void JA_StopChannel(const int channel);

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()
@@ -59,7 +60,7 @@ Logo::~Logo()
 {
 	jail_texture_->setColor(255, 255, 255);
 	since_texture_->setColor(255, 255, 255);
-	JA_PauseChannel(-1);
+	JA_StopChannel(-1);
 }
 
 // Recarga todas las texturas
@@ -92,6 +93,9 @@ void Logo::checkEvents()
 				reloadTextures();
 			}
 		}
+
+		// Comprueba el cursor
+		Mouse::handleEvent(event);
 	}
 }
 
@@ -101,7 +105,6 @@ void Logo::checkInput()
 	// Comprueba si se ha pulsado cualquier botón (de los usados para jugar)
 	if (Input::get()->checkAnyButtonPressed())
 	{
-		JA_StopMusic();
 		section::name = section::Name::TITLE;
 		section::options = section::Options::TITLE_1;
 		return;
@@ -203,7 +206,7 @@ void Logo::update()
 		}
 
 		// Actualiza las variables de globalInputs
-        globalInputs::update();
+		globalInputs::update();
 	}
 }
 
@@ -235,7 +238,7 @@ void Logo::render()
 void Logo::run()
 {
 	// Detiene la música
-	JA_StopMusic();
+	JA_FadeOutMusic(300);
 
 	while (section::name == section::Name::LOGO)
 	{

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/options.h

@@ -23,7 +23,8 @@ enum class GameDifficulty
 // Estructura para las opciones de la ventana
 struct OptionsWindow
 {
-	int size; // Contiene el valor por el que se multiplica el tamaño de la ventana
+	int size = 1;	  // Contiene el valor por el que se multiplica el tamaño de la ventana
+	int max_size = 1; // Tamaño máximo para que el tamaño de la ventana no sea mayor que el tamaño de la pantalla
 };
 
 // Estructura con opciones para el video

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

@@ -8,6 +8,8 @@
 #include "param.h"			 // Para Param, ParamGame, param
 #include "scoreboard.h"		 // Para Scoreboard, ScoreboardMode
 #include "texture.h"		 // Para Texture
+#include "resource.h"
+#include "jail_audio.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)
@@ -38,7 +40,7 @@ void Player::init()
 	pos_y_ = default_pos_y_;
 	walking_state_ = PlayerState::WALKING_STOP;
 	firing_state_ = PlayerState::FIRING_NONE;
-	playing_state_ = PlayerState::WAITING;
+	setPlayingState(PlayerState::WAITING);
 	invulnerable_ = true;
 	invulnerable_counter_ = INVULNERABLE_COUNTER_;
 	power_up_ = false;
@@ -172,9 +174,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());
+			playRandomBubbleSound();
 		}
 
 		// Si el cadaver toca el suelo cambia el estado
@@ -188,6 +195,7 @@ void Player::move()
 				pos_y_ = default_pos_y_;
 				player_sprite_->clear();
 				shiftSprite();
+				playRandomBubbleSound();
 			}
 			else
 			{
@@ -195,12 +203,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);
+				playRandomBubbleSound();
 			}
 		}
 		break;
 	}
 	case PlayerState::LEAVING_SCREEN:
 	{
+		++step_counter_;
+		if (step_counter_ % 10 == 0)
+		{
+			JA_PlaySound(Resource::get()->getSound("walk.wav"));
+		}
+
 		switch (id_)
 		{
 		case 1:
@@ -219,7 +234,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:
@@ -286,6 +339,7 @@ void Player::setAnimation()
 	{
 	case PlayerState::PLAYING:
 	case PlayerState::ENTERING_NAME_GAME_COMPLETED:
+	case PlayerState::ENTERING_SCREEN:
 	case PlayerState::LEAVING_SCREEN:
 	case PlayerState::CREDITS:
 	{
@@ -501,9 +555,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_;
@@ -643,6 +717,10 @@ void Player::decContinueCounter()
 	{
 		setPlayingState(PlayerState::GAME_OVER);
 	}
+	else
+	{
+		JA_PlaySound(Resource::get()->getSound("continue_clock.wav"));
+	}
 }
 
 // Decrementa el contador de entrar nombre
@@ -681,4 +759,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
 };
 
@@ -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:

source/resource.cpp

@@ -290,7 +290,7 @@ void Resource::createTextures()
         NameAndText("game_text_powerup", lang::getText(117)),
         NameAndText("game_text_one_hit", lang::getText(118)),
         NameAndText("game_text_stop", lang::getText(119)),
-        NameAndText("1000000_points", lang::getText(76))};
+        NameAndText("game_text_1000000_points", lang::getText(76))};
 
     auto text = getText("04b_25");
     for (const auto &s : strings)
@@ -301,10 +301,10 @@ void Resource::createTextures()
 
     // Tamaño doble
     std::vector<NameAndText> strings2X = {
-        NameAndText("get_ready", lang::getText(75)),
+        NameAndText("game_text_get_ready", lang::getText(75)),
-        NameAndText("last_stage", lang::getText(79)),
+        NameAndText("game_text_last_stage", lang::getText(79)),
-        NameAndText("congratulations", lang::getText(50)),
+        NameAndText("game_text_congratulations", lang::getText(50)),
-        NameAndText("game_over", "Game Over")};
+        NameAndText("game_text_game_over", "Game Over")};
 
     auto text2 = getText("04b_25_2x");
     for (const auto &s : strings2X)

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
@@ -235,7 +236,7 @@ void Screen::decWindowSize()
 void Screen::incWindowSize()
 {
     ++options.video.window.size;
-    options.video.window.size = std::min(options.video.window.size, 4);
+    options.video.window.size = std::min(options.video.window.size, options.video.window.max_size);
     setVideoMode(ScreenVideoMode::WINDOW);
 }
 
@@ -259,6 +260,7 @@ void Screen::update()
     Notifier::get()->update();
     updateFPS();
     OnScreenHelp::get()->update();
+    Mouse::updateCursorVisibility();
 }
 
 // Agita la pantalla
@@ -308,15 +310,15 @@ void Screen::updateShakeEffect()
 }
 
 // Pone la pantalla de color
-void Screen::flash(Color color, int lenght)
+void Screen::flash(Color color, int lenght, int delay)
 {
-    flash_effect_ = FlashEffect(true, lenght, color);
+    flash_effect_ = FlashEffect(true, lenght, delay, color);
 }
 
 // Actualiza y dibuja el efecto de flash en la pantalla
 void Screen::renderFlash()
 {
-    if (flash_effect_.enabled)
+    if (flash_effect_.isRendarable())
     {
         SDL_SetRenderDrawColor(renderer_, flash_effect_.color.r, flash_effect_.color.g, flash_effect_.color.b, 0xFF);
         SDL_RenderClear(renderer_);
@@ -326,10 +328,7 @@ void Screen::renderFlash()
 // Actualiza el efecto de flash
 void Screen::updateFlash()
 {
-    if (flash_effect_.enabled)
+    flash_effect_.update();
-    {
-        flash_effect_.counter > 0 ? flash_effect_.counter-- : flash_effect_.enabled = false;
-    }
 }
 
 // Atenua la pantalla

source/screen.h

@@ -51,12 +51,20 @@ private:
 	struct FlashEffect
 	{
 		bool enabled; // Indica si el efecto está activo
+		int lenght;	  // Duración del efecto
+		int delay;	  // Frames iniciales en los que no se aplica
 		int counter;  // Contador para el efecto
 		Color color;  // Color del efecto
 
 		// Constructor
-		explicit FlashEffect(bool en = false, int cnt = 0, Color col = Color(0xFF, 0xFF, 0xFF))
+		explicit FlashEffect(bool enabled = false, int lenght = 0, int delay = 0, Color color = Color(0xFF, 0xFF, 0xFF))
-			: enabled(en), counter(cnt), color(col) {}
+			: enabled(enabled), lenght(lenght), delay(delay), counter(lenght), color(color) {}
+
+		// Actualiza
+		void update() { (enabled && counter > 0) ? counter-- : enabled = false; }
+
+		// Indica si se pude dibujar
+		bool isRendarable() { return enabled && counter < lenght - delay; }
 	};
 
 	struct ShakeEffect
@@ -155,7 +163,7 @@ public:
 	void shake();
 
 	// Pone la pantalla de color
-	void flash(Color color, int lenght);
+	void flash(Color color, int lenght, int delay = 0);
 
 	// Activa / desactiva los shaders
 	void toggleShaders();

source/tabe.cpp

@@ -0,0 +1,145 @@
+#include "tabe.h"
+#include "resource.h"
+#include "param.h"
+#include "jail_audio.h"
+#include <algorithm>
+
+// Constructor
+Tabe::Tabe()
+    : sprite_(std::make_unique<AnimatedSprite>(Resource::get()->getTexture("tabe.png"), Resource::get()->getAnimation("tabe.ani"))) {}
+
+// Actualiza la lógica
+void Tabe::update()
+{
+    if (enabled_)
+    {
+        sprite_->update();
+        move();
+    }
+}
+
+// Dibuja el objeto
+void Tabe::render()
+{
+    if (enabled_)
+    {
+        sprite_->render();
+    }
+}
+
+// Mueve el objeto
+void Tabe::move()
+{
+    const int x = static_cast<int>(x_);
+    speed_ += accel_;
+    x_ += speed_;
+    fly_distance_ -= std::abs(x - static_cast<int>(x_));
+
+    // Comprueba si sale por los bordes
+    const float min_x = param.game.game_area.rect.x - WIDTH_;
+    const float max_x = param.game.game_area.rect.x + param.game.game_area.rect.w;
+    switch (destiny_)
+    {
+    case TabeDirection::TO_THE_LEFT:
+    {
+        if (x_ < min_x)
+        {
+            enabled_ = false;
+        }
+        if (x_ > param.game.game_area.rect.x + param.game.game_area.rect.w - WIDTH_ && direction_ == TabeDirection::TO_THE_RIGHT)
+        {
+            setRandomFlyPath(TabeDirection::TO_THE_LEFT, 80);
+            x_ = param.game.game_area.rect.x + param.game.game_area.rect.w - WIDTH_;
+        }
+        break;
+    }
+
+    case TabeDirection::TO_THE_RIGHT:
+    {
+        if (x_ > max_x)
+        {
+            enabled_ = false;
+        }
+        if (x_ < param.game.game_area.rect.x && direction_ == TabeDirection::TO_THE_LEFT)
+        {
+            setRandomFlyPath(TabeDirection::TO_THE_RIGHT, 80);
+            x_ = param.game.game_area.rect.x;
+        }
+        break;
+    }
+    default:
+        break;
+    }
+
+    if (fly_distance_ <= 0)
+    {
+        if (waiting_counter_ > 0)
+        {
+            accel_ = speed_ = 0.0f;
+            --waiting_counter_;
+        }
+        else
+        {
+            constexpr int CHOICES = 4;
+            const TabeDirection left[CHOICES] = {TabeDirection::TO_THE_LEFT, TabeDirection::TO_THE_LEFT, TabeDirection::TO_THE_LEFT, TabeDirection::TO_THE_RIGHT};
+            const TabeDirection right[CHOICES] = {TabeDirection::TO_THE_LEFT, TabeDirection::TO_THE_RIGHT, TabeDirection::TO_THE_RIGHT, TabeDirection::TO_THE_RIGHT};
+            const TabeDirection direction = destiny_ == TabeDirection::TO_THE_LEFT ? left[rand() % CHOICES] : right[rand() % CHOICES];
+            setRandomFlyPath(direction, 20 + rand() % 40);
+        }
+    }
+
+    shiftSprite();
+}
+
+// Habilita el objeto
+void Tabe::enable()
+{
+    if (!enabled_)
+    {
+        enabled_ = true;
+        y_ = 20.0f;
+
+        // Establece una dirección aleatoria
+        destiny_ = direction_ = rand() % 2 == 0 ? TabeDirection::TO_THE_LEFT : TabeDirection::TO_THE_RIGHT;
+
+        // Establece la posición inicial
+        x_ = (direction_ == TabeDirection::TO_THE_LEFT) ? param.game.game_area.rect.x + param.game.game_area.rect.w : param.game.game_area.rect.x - WIDTH_;
+
+        // Crea una ruta de vuelo
+        setRandomFlyPath(direction_, 60);
+        shiftSprite();
+    }
+}
+
+// Establece un vuelo aleatorio
+void Tabe::setRandomFlyPath(TabeDirection direction, int lenght)
+{
+    direction_ = direction;
+    fly_distance_ = lenght;
+    waiting_counter_ = 5 + rand() % 15;
+    JA_PlaySound(Resource::get()->getSound("tabe.wav"));
+
+    constexpr float SPEED = 2.0f;
+
+    switch (direction)
+    {
+    case TabeDirection::TO_THE_LEFT:
+    {
+        speed_ = -1.0f * SPEED;
+        accel_ = -1.0f * (1 + rand() % 10) / 30.0f;
+        sprite_->setFlip(SDL_FLIP_NONE);
+        break;
+    }
+
+    case TabeDirection::TO_THE_RIGHT:
+    {
+        speed_ = SPEED;
+        accel_ = (1 + rand() % 10) / 30.0f;
+        sprite_->setFlip(SDL_FLIP_HORIZONTAL);
+        break;
+    }
+
+    default:
+        break;
+    }
+}

source/tabe.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "animated_sprite.h"
+#include <memory>
+
+enum class TabeDirection : int
+{
+    TO_THE_LEFT = 0,
+    TO_THE_RIGHT = 1,
+};
+
+// Clase Tabe
+class Tabe
+{
+private:
+    // Constantes
+    static constexpr int WIDTH_ = 32;
+    static constexpr int HEIGHT_ = 32;
+
+    // Punteros
+    std::unique_ptr<AnimatedSprite> sprite_; // Sprite con los graficos y animaciones
+
+    // Variables
+    float x_ = 0;             // Posición del objeto
+    float y_ = 0;             // Posición del objeto
+    float speed_ = 0.0f;      // Velocidad de movimiento del objeto
+    float accel_ = 0.0f;      // Aceleración del objeto
+    int fly_distance_ = 0;    // Distancia de vuelo
+    int waiting_counter_ = 0; // Tiempo que pasa quieto el objeto
+    bool enabled_ = false;    // Indica si el objeto está activo
+    TabeDirection direction_; // Dirección del objeto
+    TabeDirection destiny_;   // Destino del objeto
+
+    // Mueve el objeto
+    void move();
+
+    // Actualiza la posición del sprite
+    void shiftSprite() { sprite_->setPos(x_, y_); }
+
+    // Establece un vuelo aleatorio
+    void setRandomFlyPath(TabeDirection direction, int lenght);
+
+public:
+    // Constructor
+    Tabe();
+
+    // Destructor
+    ~Tabe() = default;
+
+    // Actualiza la lógica
+    void update();
+
+    // Dibuja el objeto
+    void render();
+
+    // Habilita el objeto
+    void enable();
+};

source/text.cpp

@@ -161,12 +161,14 @@ std::shared_ptr<Texture> Text::writeToTexture(const std::string &text, int zoom,
 	auto texture = std::make_shared<Texture>(renderer);
 	auto width = lenght(text, kerning) * zoom;
 	auto height = box_height_ * zoom;
+	auto temp = SDL_GetRenderTarget(renderer);
 	texture->createBlank(width, height, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
 	texture->setBlendMode(SDL_BLENDMODE_BLEND);
 	texture->setAsRenderTarget(renderer);
 	SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
 	SDL_RenderClear(renderer);
 	zoom == 1 ? write(0, 0, text, kerning) : write2X(0, 0, text, kerning);
+	SDL_SetRenderTarget(renderer, temp);
 
 	return texture;
 }

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()
@@ -31,9 +32,10 @@ Title::Title()
 	  fade_(std::make_unique<Fade>()),
 	  tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::RANDOM)),
 	  game_logo_(std::make_unique<GameLogo>(param.game.game_area.center_x, param.title.title_c_c_position)),
-	  mini_logo_sprite_(std::make_unique<Sprite>(Resource::get()->getTexture("logo_jailgames_mini.png"))), 
+	  mini_logo_sprite_(std::make_unique<Sprite>(Resource::get()->getTexture("logo_jailgames_mini.png"))),
 	  define_buttons_(std::make_unique<DefineButtons>()),
-	  num_controllers_(Input::get()->getNumControllers())
+	  num_controllers_(Input::get()->getNumControllers()),
+	  state_(TitleState::LOGO_ANIMATING)
 {
 	// Configura objetos
 	game_logo_->enable();
@@ -54,6 +56,7 @@ Title::Title()
 Title::~Title()
 {
 	Resource::get()->getTexture("smb2.gif")->setPalette(0);
+	JA_StopChannel(-1);
 }
 
 // Actualiza las variables del objeto
@@ -70,9 +73,9 @@ void Title::update()
 		Screen::get()->update();
 
 		// Actualiza las variables de globalInputs
-        globalInputs::update();
+		globalInputs::update();
 
-		// Comprueba el fundido y si se ha acabado
+		// Comprueba el fundido
 		fade_->update();
 		if (fade_->hasEnded())
 		{
@@ -88,18 +91,19 @@ void Title::update()
 			}
 		}
 
-		// Sección 1 - Titulo animandose
+		// Establece la lógica según el estado
-		if (section::options == section::Options::TITLE_1)
+		switch (state_)
+		{
+		case TitleState::LOGO_ANIMATING:
 		{
 			game_logo_->update();
 			if (game_logo_->hasFinished())
 			{
-				section::options = section::Options::TITLE_2;
+				state_ = TitleState::LOGO_FINISHED;
 			}
+			break;
 		}
-
+		case TitleState::LOGO_FINISHED:
-		// Sección 2 - La pantalla con el titulo, el fondo animado y la música
-		else if (section::options == section::Options::TITLE_2)
 		{
 			// El contador solo sube si no estamos definiendo botones
 			counter_ = define_buttons_->isEnabled() ? 0 : counter_ + 1;
@@ -121,6 +125,27 @@ void Title::update()
 				fade_->activate();
 				post_fade_ = -1;
 			}
+
+			break;
+		}
+		case TitleState::START_HAS_BEEN_PRESSED:
+		{
+			// Actualiza el logo con el título del juego
+			game_logo_->update();
+
+			// Actualiza el mosaico de fondo
+			tiled_bg_->update();
+
+			if (counter_ == 100)
+			{
+				fade_->activate();
+			}
+			++counter_;
+			break;
+		}
+
+		default:
+			break;
 		}
 	}
 }
@@ -140,16 +165,10 @@ void Title::render()
 	// Dibuja el logo con el título del juego
 	game_logo_->render();
 
-	if (section::options == section::Options::TITLE_2)
+	constexpr Color shadow = Color(0x14, 0x87, 0xc4);
+
+	if (state_ != TitleState::LOGO_ANIMATING)
 	{
-		constexpr Color shadow = Color(0x14, 0x87, 0xc4);
-
-		// 'PRESS TO PLAY'
-		if (counter_ % 50 > 14 && !define_buttons_->isEnabled())
-		{
-			text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, param.title.press_start_position, lang::getText(23), 1, no_color, 1, shadow);
-		}
-
 		// Mini logo
 		const int pos1 = (param.game.height / 5 * 4) + BLOCK;
 		const int pos2 = pos1 + mini_logo_sprite_->getHeight() + 3;
@@ -160,6 +179,24 @@ void Title::render()
 		text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, pos2, TEXT_COPYRIGHT, 1, no_color, 1, shadow);
 	}
 
+	if (state_ == TitleState::LOGO_FINISHED)
+	{
+		// 'PRESS TO PLAY'
+		if (counter_ % 50 > 14 && !define_buttons_->isEnabled())
+		{
+			text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, param.title.press_start_position, lang::getText(23), 1, no_color, 1, shadow);
+		}
+	}
+
+	if (state_ == TitleState::START_HAS_BEEN_PRESSED)
+	{
+		// 'PRESS TO PLAY'
+		if (counter_ % 10 > 4 && !define_buttons_->isEnabled())
+		{
+			text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, param.title.press_start_position, lang::getText(23), 1, no_color, 1, shadow);
+		}
+	}
+
 	// Define Buttons
 	define_buttons_->render();
 
@@ -234,6 +271,9 @@ void Title::checkEvents()
 					break;
 				}
 			}
+
+			// Comprueba el cursor
+			Mouse::handleEvent(event);
 		}
 	}
 }
@@ -241,24 +281,28 @@ void Title::checkEvents()
 // Comprueba las entradas
 void Title::checkInput()
 {
-	// Comprueba los controladores solo si no se estan definiendo los botones
+	// Comprueba las entradas solo si no se estan definiendo los botones
 	if (!define_buttons_->isEnabled())
 	{
-		// Comprueba los métodos de control
+		// Comprueba todos los métodos de control
 		for (const auto &controller : options.controllers)
 		{
+			// START
 			if (Input::get()->checkInput(InputType::START, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index) &&
 				!Input::get()->checkInput(InputType::SERVICE, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index))
 			{
-				if (section::options == section::Options::TITLE_2 || ALLOW_TITLE_ANIMATION_SKIP)
+				if (state_ == TitleState::LOGO_FINISHED || ALLOW_TITLE_ANIMATION_SKIP)
 				{
-					fade_->activate();
+					JA_PlaySound(Resource::get()->getSound("game_start.wav"));
+					JA_FadeOutMusic(1500);
 					post_fade_ = controller.player_id;
+					state_ = TitleState::START_HAS_BEEN_PRESSED;
+					counter_ = 0;
 					return;
 				}
 			}
 
-			// Comprueba si se va a intercambiar la asignación de mandos a jugadores
+			// SWAP_CONTROLLERS
 			if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, controller.type, controller.index) &&
 				Input::get()->checkInput(InputType::SWAP_CONTROLLERS, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index))
 			{
@@ -266,7 +310,7 @@ void Title::checkInput()
 				return;
 			}
 
-			// Comprueba si algun mando quiere ser configurado
+			// CONFIG
 			if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, controller.type, controller.index) &&
 				Input::get()->checkInput(InputType::CONFIG, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index))
 			{
@@ -345,7 +389,6 @@ void Title::showControllers()
 		}
 	}
 
-	// std::string spaces(lang::getText(100).length() + 3, ' ');
+	// Muestra la notificación
-	// std::string kb_text = spaces + lang::getText(69);
 	Notifier::get()->showText({text.at(0), text.at(1)});
 }

source/title.h

@@ -15,10 +15,10 @@ namespace section
 }
 
 // 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 = true;
+constexpr bool ALLOW_TITLE_ANIMATION_SKIP = false;
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de la parte del titulo o menu
@@ -27,9 +27,10 @@ constexpr bool ALLOW_TITLE_ANIMATION_SKIP = true;
 		- Dibujar el tileado de fondo
 		- Redifinir los botones de los mandos de juego
 
-	Esta clase tiene dos estados:
+	Esta clase tiene tres estados:
 		- El titulo está animandose, con el fondo estático
 		- El titulo ya está en su sitio y el fondo se está animando
+		- Se ha pulsado el botón de start
 
 	Por razones de diseño, no se permite saltarse la animación del titulo, aunque es
 	configurable mediante un define
@@ -39,6 +40,14 @@ constexpr bool ALLOW_TITLE_ANIMATION_SKIP = true;
 class Title
 {
 private:
+	// Enumeraciones
+	enum class TitleState
+	{
+		LOGO_ANIMATING,
+		LOGO_FINISHED,
+		START_HAS_BEEN_PRESSED,
+	};
+
 	// Objetos y punteros
 	std::shared_ptr<Text> text_;					// Objeto de texto para poder escribir textos en pantalla
 	std::unique_ptr<Fade> fade_;					// Objeto para realizar fundidos en pantalla
@@ -53,6 +62,7 @@ private:
 	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
 
 	// Actualiza las variables del objeto
 	void update();