EnterName: si has plenat tots els slots de lletres, apretar una volta mes el de fixar lletra fixa el nom

treballant en enter name

.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        := 2025-02-07
 
 # 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

@@ -1,43 +1,73 @@
 # Coffee Crisis Arcade Edition
 
-Coffee Crisis Arcade Edition es la versió ampliada i millorada del aclamat Coffee Crisis. Preparat per a jugar sense parar amn dos jugadors, nous gràfics i moltes sorpreses mes.
+**¡La batalla definitiva pel cafè està ací!**
+
+Coffee Crisis Arcade Edition és una versió ampliada i millorada del aclamat Coffee Crisis. Aquesta versió porta l'acció cooperativa al següent nivell, amb:
+
+- **Mode multijugador** per a dues persones.
+- **Nous gràfics** que revitalitzen l'experiència arcade clàssica.
+- **Moltes sorpreses** per descobrir en cada partida.
+
+Defensa el teu cafè contra les bambolles gegants en aquest trepidant joc d'arcade! 🍵
 
 <p align="center">
-    <img src="https://php.sustancia.synology.me/images/ccae_title.png" alt="Titol" 
+    <img src="https://php.sustancia.synology.me/images/ccae_title.png" alt="Títol" width="60%" />
 </p>
 
 ## Controls
-El joc està optimitzat per a ser jugat amb un mando de jocs, encara que un dels jugadors pot utilitzar el teclat.
-Les tecles son les següents:
 
-* **Fletxes**: Mou al personatge
+El joc està optimitzat per a ser jugat amb un mando de jocs, encara que un dels jugadors pot utilitzar el teclat.
-* **Q, W, E**: Disparar a la esquerra, al centre i a la dreta respectivament
+
+### Controls del teclat:
+- **Fletxes**: Mou al personatge.
+- **Q, W, E**: Disparar a l'esquerra, al centre i a la dreta, respectivament.
+
+> Nota: El joc suporta nomes un jugador amb teclat.
 
 <p align="center">
-    <img src="https://php.sustancia.synology.me/images/ccae1.png" alt="Joc" 
+    <img src="https://php.sustancia.synology.me/images/ccae1.png" alt="Joc" width="45%" />
+    <img src="https://php.sustancia.synology.me/images/ccae3.png" alt="Joc" width="45%" />
 </p>
 
 ## Altres tecles
-- **Tecla ESC**: Tancar el joc
 
-- **Tecla F1**: Fa la finestra mes xicoteta
+| Tecla       | Funció                                       |
-
+|-------------|----------------------------------------------|
-- **Tecla F2**: Fa la finestra mes gran
+| **ESC**     | Tancar el joc                                |
-
+| **F1**      | Fa la finestra més xicoteta                 |
-- **Tecla F3**: Alterna entre el mode de pantalla completa i el de finestra
+| **F2**      | Fa la finestra més gran                     |
-
+| **F3**      | Alterna entre mode de pantalla completa i finestra |
-- **Tecla F4**: Activa o desactiva els shaders
+| **F4**      | Activa o desactiva els shaders              |
-
+| **F5**      | Activa o desactiva l'àudio                 |
-- **Tecla F5**: Activa o desactiva l'audio
+| **F6**      | Activa o desactiva el dispar automàtic      |
-
+| **F7**      | Canvia l'idioma del joc i reinicia         |
-- **Tecla F6**: Canvia el idioma del joc i reinicia
+| **F10**     | Reset del joc                               |
-
-- **Tecla F10**: Reset
 
 <p align="center">
-    <img src="https://php.sustancia.synology.me/images/ccae2.png" alt="Joc" 
+    <img src="https://php.sustancia.synology.me/images/ccae2.png" alt="Joc" width="50%" />
 </p>
 
+## Com instal·lar i jugar
+
+1. Descarrega el joc des de [l'apartat de llançaments](https://gitea.sustancia.synology.me/JailDesigner/coffee_crisis_arcade_edition/releases).
+2. Descomprimix i executa l'arxiu `coffee_crisis_arcade_edition.exe`.
+3. Gaudeix del joc!
+
+## Agraïments
+
+Vull expressar la meua gratitud a **ChatGPT** i **GitHub Copilot**. Gràcies per ser un suport constant en el desenvolupament d'aquest joc!
+
+També vull agrair a tots els jugadors que fan que aquest projecte valgui la pena. 🕹️❤️
+
+## Com contribuir
+
+Accepte contribucions! Si tens una idea o vols ajudar:
+
+1. Fes un fork d'aquest repositori.
+2. Crea una branca nova amb els teus canvis.
+3. Fes un pull request.
+
+## Llicència
+
+Aquest joc està subjecte a una llicència [MIT](https://opensource.org/licenses/MIT). Consulta el fitxer LICENSE per a més detalls.
 
-## Agraiments
-A chatGPT i sobretot a Copilot. Gracies per estar sempre quan vos he necesitat.

data/config/param_320x240.txt

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

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

@@ -1,194 +0,0 @@
-# box width
-10
-# box height
-10
-# 32 espacio ( )
-5
-# 33 !
-4
-# 34 "
-5
-# 35 #
-7
-# 36 $
-7
-# 37 %
-8
-# 38 &
-8
-# 39 '
-3
-# 40 (
-5
-# 41 )
-5
-# 42 *
-7         
-# 43 +
-7
-# 44 ,
-4
-# 45 -
-6
-# 46 .
-4
-# 47 /
-5
-# 48 0
-7
-# 49 1
-5
-# 50 2
-7
-# 51 3
-7
-# 52 4
-7
-# 53 5
-7
-# 54 6
-7
-# 55 7
-7
-# 56 8
-7
-# 57 9
-7
-# 58 :
-4
-# 59 ;
-4
-# 60 <
-6
-# 61 =
-6
-# 62 >
-6
-# 63 ?
-7
-# 64 @
-8
-# 65 A
-7
-# 66 B
-7
-# 67 C
-7
-# 68 D
-7
-# 69 E
-7
-# 70 F
-7
-# 71 G
-7
-# 72 H
-7
-# 73 I
-4
-# 74 J
-6
-# 75 K
-8
-# 76 L
-6
-# 77 M
-9
-# 78 N
-8
-# 79 O
-8
-# 80 P
-7
-# 81 Q
-8
-# 82 R
-7
-# 83 S
-6
-# 84 T
-8
-# 85 U
-7
-# 86 V
-8
-# 87 W
-9
-# 88 X
-8
-# 89 Y
-8
-# 90 Z
-7
-# 91 [
-4
-# 92 \
-5
-# 93 ]
-4
-# 94 ^
-5
-# 95 _
-8
-# 96 `
-4
-# 97 a
-7
-# 98 b
-7
-# 99 c
-6
-# 100 d
-7
-# 101 e
-7
-# 102 f
-5
-# 103 g
-7
-# 104 h
-7
-# 105 i
-4
-# 106 j
-5
-# 107 k
-7
-# 108 l
-4
-# 109 m
-10
-# 110 n
-7
-# 111 o
-7
-# 112 p
-7
-# 113 q
-7
-# 114 r
-6
-# 115 s
-6
-# 116 t
-5
-# 117 u
-7
-# 118 v
-7
-# 119 w
-9
-# 120 x
-7
-# 121 y
-7
-# 122 z
-7
-# 123 { -> ñ
-7
-# 124 | -> ç
-7
-# 125 }
-0
-# 126 ~
-0

data/gfx/balloon/powerball.ani

@@ -1,9 +1,9 @@
-frame_width=46
+frame_width=49
-frame_height=46
+frame_height=49
 
 [animation]
 name=powerball
 speed=10
 loop=-1
-frames=0
+frames=1
 [/animation]

data/gfx/item/item_debian.ani

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

data/gfx/tabe/tabe.ani

@@ -0,0 +1,16 @@
+frame_width=32
+frame_height=32
+
+[animation]
+name=fly
+speed=2
+loop=0
+frames=0,1
+[/animation]
+
+[animation]
+name=hit
+speed=2
+loop=0
+frames=2,3
+[/animation]

data/lang/ba_BA.txt

@@ -32,7 +32,7 @@ IDIOMA
 [ CANCELAR ]
 
 ## 11 - INSTRUCCIONES
-OBJECTIU
+Objectiu
 
 ## 12 - INSTRUCCIONES
 HAS D'EXPLOTAR
@@ -47,7 +47,7 @@ LA DIFICULTAT AUGMENTA
 A MESURA QUE VAS PUNTUANT
 
 ## 16 - INSTRUCCIONES
-OBJECTES
+Objectes
 
 ## 17 - INSTRUCCIONES
 1.000 PUNTS

release/coffee.rc

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

source/background.cpp

@@ -2,12 +2,13 @@
 #include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
 #include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888
 #include <algorithm>            // Para clamp, max
-#include "moving_sprite.h"      // Para MovingSprite
+#include <cmath>
-#include "param.h"              // Para Param, ParamBackground, param
+#include "moving_sprite.h" // Para MovingSprite
-#include "resource.h"           // Para Resource
+#include "param.h"         // Para Param, ParamBackground, param
-#include "screen.h"             // Para Screen
+#include "resource.h"      // Para Resource
-#include "sprite.h"             // Para Sprite
+#include "screen.h"        // Para Screen
-#include "texture.h"            // Para Texture
+#include "sprite.h"        // Para Sprite
+#include "texture.h"       // Para Texture
 
 // Constructor
 Background::Background()
@@ -18,16 +19,22 @@ Background::Background()
       bottom_clouds_texture_(Resource::get()->getTexture("game_clouds2.png")),
       grass_texture_(Resource::get()->getTexture("game_grass.png")),
       gradients_texture_(Resource::get()->getTexture("game_sky_colors.png")),
+      sun_texture_(Resource::get()->getTexture("game_sun.png")),
+      moon_texture_(Resource::get()->getTexture("game_moon.png")),
 
       rect_({0, 0, gradients_texture_->getWidth() / 2, gradients_texture_->getHeight() / 2}),
       src_rect_({0, 0, 320, 240}),
       dst_rect_({0, 0, 320, 240}),
       base_(rect_.h),
-      color_(Color(param.background.attenuate_color.r, param.background.attenuate_color.g, param.background.attenuate_color.b)),
+      attenuate_color_(Color(param.background.attenuate_color.r, param.background.attenuate_color.g, param.background.attenuate_color.b)),
       alpha_color_text_(param.background.attenuate_alpha),
       alpha_color_text_temp_(param.background.attenuate_alpha)
 
 {
+    // Precalcula rutas
+    createSunPath();
+    createMoonPath();
+
     // Inicializa variables
     {
         gradient_rect_[0] = {0, 0, rect_.w, rect_.h};
@@ -55,9 +62,11 @@ Background::Background()
         bottom_clouds_sprite_a_ = std::make_unique<MovingSprite>(bottom_clouds_texture_, (SDL_Rect){0, bottom_clouds_y, rect_.w, bottom_clouds_texture_->getHeight()});
         bottom_clouds_sprite_b_ = std::make_unique<MovingSprite>(bottom_clouds_texture_, (SDL_Rect){rect_.w, bottom_clouds_y, rect_.w, bottom_clouds_texture_->getHeight()});
 
-        buildings_sprite_ = std::make_unique<Sprite>(buildings_texture_, 0, 0, buildings_texture_->getWidth(), buildings_texture_->getHeight());
+        buildings_sprite_ = std::make_unique<Sprite>(buildings_texture_);
         gradient_sprite_ = std::make_unique<Sprite>(gradients_texture_, 0, 0, rect_.w, rect_.h);
         grass_sprite_ = std::make_unique<Sprite>(grass_texture_, 0, 0, grass_texture_->getWidth(), grass_texture_->getHeight() / 2);
+        sun_sprite_ = std::make_unique<Sprite>(sun_texture_);
+        moon_sprite_ = std::make_unique<Sprite>(moon_texture_);
     }
 
     // Inicializa objetos
@@ -79,6 +88,8 @@ Background::Background()
 
         buildings_sprite_->setY(base_ - buildings_sprite_->getHeight());
         grass_sprite_->setY(base_ - grass_sprite_->getHeight());
+        sun_sprite_->setPosition(sun_path_.front());
+        moon_sprite_->setPosition(moon_path_.front());
     }
 
     // Crea la textura para componer el fondo
@@ -88,7 +99,7 @@ Background::Background()
     // Crea la textura para atenuar el fondo
     color_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
     SDL_SetTextureBlendMode(color_texture_, SDL_BLENDMODE_BLEND);
-    setColor(color_);
+    setColor(attenuate_color_);
     SDL_SetTextureAlphaMod(color_texture_, alpha_color_text_);
 }
 
@@ -103,7 +114,7 @@ Background::~Background()
 void Background::update()
 {
     // Actualiza el valor de alpha_
-    updateAlphaColorText();
+    updateAlphaColorTexture();
 
     // Actualiza las nubes
     updateClouds();
@@ -114,6 +125,10 @@ void Background::update()
     // Calcula el valor de alpha_
     alpha_ = std::max((255 - (int)(255 * transition_)), 0);
 
+    // Mueve el sol
+    sun_sprite_->setPosition(sun_path_.at(sun_index_));
+    moon_sprite_->setPosition(moon_path_.at(moon_index_));
+
     // Incrementa el contador
     ++counter_;
 
@@ -181,6 +196,10 @@ void Background::fillCanvas()
     // Dibuja el gradiente de fondo
     renderGradient();
 
+    // Dibuja los astros
+    sun_sprite_->render();
+    moon_sprite_->render();
+
     // Dibuja las nubes de arriba
     renderTopClouds();
 
@@ -250,13 +269,13 @@ void Background::setPos(SDL_Rect pos)
 // Establece el color_ de atenuación
 void Background::setColor(Color color)
 {
-    color_ = color;
+    attenuate_color_ = color;
 
     // Colorea la textura
     auto temp = SDL_GetRenderTarget(renderer_);
     SDL_SetRenderTarget(renderer_, color_texture_);
 
-    SDL_SetRenderDrawColor(renderer_, color_.r, color_.g, color_.b, 255);
+    SDL_SetRenderDrawColor(renderer_, attenuate_color_.r, attenuate_color_.g, attenuate_color_.b, 255);
     SDL_RenderClear(renderer_);
 
     SDL_SetRenderTarget(renderer_, temp);
@@ -274,7 +293,7 @@ void Background::setAlpha(int alpha)
 }
 
 // Actualiza el valor de alpha_
-void Background::updateAlphaColorText()
+void Background::updateAlphaColorTexture()
 {
     if (alpha_color_text_ == alpha_color_text_temp_)
     {
@@ -322,4 +341,58 @@ void Background::updateClouds()
     {
         bottom_clouds_sprite_b_->setPosX(bottom_clouds_sprite_b_->getWidth());
     }
+}
+
+// Precalcula el vector con el recorrido del sol
+void Background::createSunPath()
+{
+    constexpr int CENTER_X = 170;
+    const int center_y = base_ - 80;
+    constexpr int RADIUS = 120;
+
+    // Generar puntos de la curva desde 90 a 180 grados
+    for (double theta = M_PI / 2; theta <= M_PI; theta += 0.01)
+    {
+        int x = CENTER_X + static_cast<int>(RADIUS * cos(theta));
+        int y = center_y - static_cast<int>(RADIUS * sin(theta));
+        sun_path_.push_back({x, y});
+    }
+
+    // Agregar puntos en línea recta después de la curva
+    constexpr int EXTRA_PIXELS = 40;
+    SDL_Point last_point = sun_path_.back();
+    for (int i = 1; i <= EXTRA_PIXELS; ++i)
+    {
+        sun_path_.push_back({last_point.x, last_point.y + i});
+    }
+}
+
+// Precalcula el vector con el recorrido de la luna
+void Background::createMoonPath()
+{
+    constexpr int CENTER_X = 100;
+    const int center_y = base_ - 50;
+    constexpr int RADIUS = 140;
+
+    // Generar puntos de la curva desde 0 a 90 grados
+    for (double theta = 0; theta <= M_PI / 2; theta += 0.01)
+    {
+        int x = CENTER_X + static_cast<int>(RADIUS * cos(theta));
+        int y = center_y - static_cast<int>(RADIUS * sin(theta));
+        moon_path_.push_back({x, y});
+    }
+}
+
+// Establece la posición del sol
+void Background::setSunProgression(float progress)
+{
+    progress = std::clamp(progress, 0.0f, 1.0f);
+    sun_index_ = static_cast<size_t>(progress * (sun_path_.size() - 1));
+}
+
+// Establece la posición de la luna
+void Background::setMoonProgression(float progress)
+{
+    progress = std::clamp(progress, 0.0f, 1.0f);
+    moon_index_ = static_cast<size_t>(progress * (moon_path_.size() - 1));
 }

source/background.h

@@ -1,12 +1,14 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>   // para SDL_Rect
+#include <SDL2/SDL_rect.h>   // Para SDL_Rect, SDL_Point
-#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_render.h> // Para SDL_Texture, SDL_Renderer
-#include <memory>            // para unique_ptr, shared_ptr
+#include <stddef.h>          // Para size_t
-#include "utils.h"           // para Color
+#include <memory>            // Para unique_ptr, shared_ptr
-class MovingSprite;
+#include <vector>            // Para vector
-class Sprite;
+#include "utils.h"           // Para Color
-class Texture;
+class MovingSprite;          // lines 7-7
+class Sprite;                // lines 8-8
+class Texture;               // lines 9-9
 
 /*
     Esta clase es la encargada de dibujar el fondo que aparece durante la sección
@@ -51,6 +53,8 @@ private:
   std::shared_ptr<Texture> bottom_clouds_texture_; // Textura con las nubes de fondo
   std::shared_ptr<Texture> grass_texture_;         // Textura con la hierba del suelo
   std::shared_ptr<Texture> gradients_texture_;     // Textura con los diferentes colores de fondo del juego
+  std::shared_ptr<Texture> sun_texture_;           // Textura con el sol
+  std::shared_ptr<Texture> moon_texture_;          // Textura con la luna
 
   std::unique_ptr<MovingSprite> top_clouds_sprite_a_;    // Sprite para las nubes superiores
   std::unique_ptr<MovingSprite> top_clouds_sprite_b_;    // Sprite para las nubes superiores
@@ -60,26 +64,32 @@ private:
   std::unique_ptr<Sprite> buildings_sprite_; // Sprite con los edificios de fondo
   std::unique_ptr<Sprite> gradient_sprite_;  // Sprite con los graficos del degradado de color de fondo
   std::unique_ptr<Sprite> grass_sprite_;     // Sprite para la hierba
+  std::unique_ptr<Sprite> sun_sprite_;       // Sprite para el sol
+  std::unique_ptr<Sprite> moon_sprite_;      // Sprite para la luna
 
   SDL_Texture *canvas_;        // Textura para componer el fondo
   SDL_Texture *color_texture_; // Textura para atenuar el fondo
 
   // Variables
-  SDL_Rect gradient_rect_[4];      // Vector con las coordenadas de los 4 degradados para el cielo
+  SDL_Rect gradient_rect_[4];        // Vector con las coordenadas de los 4 degradados para el cielo
-  SDL_Rect top_clouds_rect_[4];    // Vector con las coordenadas de los 4 nubes de arriba
+  SDL_Rect top_clouds_rect_[4];      // Vector con las coordenadas de los 4 nubes de arriba
-  SDL_Rect bottom_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de abajo
+  SDL_Rect bottom_clouds_rect_[4];   // Vector con las coordenadas de los 4 nubes de abajo
-  int gradient_number_ = 0;        // Indica el número de degradado de fondo que se va a dibujar
+  int gradient_number_ = 0;          // Indica el número de degradado de fondo que se va a dibujar
-  int alpha_ = 0;                  // Transparencia entre los dos degradados
+  int alpha_ = 0;                    // Transparencia entre los dos degradados
-  float clouds_speed_ = 0;         // Velocidad a la que se desplazan las nubes
+  float clouds_speed_ = 0;           // Velocidad a la que se desplazan las nubes
-  float transition_ = 0;           // Nivel de transición del fondo 0..1
+  float transition_ = 0;             // Nivel de transición del fondo 0..1
-  int counter_ = 0;                // Contador interno
+  int counter_ = 0;                  // Contador interno
-  SDL_Rect rect_;                  // Tamaño del objeto fondo
+  SDL_Rect rect_;                    // Tamaño del objeto fondo
-  SDL_Rect src_rect_;              // Parte del objeto fondo que se va a dibujará en pantalla
+  SDL_Rect src_rect_;                // Parte del objeto fondo que se va a dibujará en pantalla
-  SDL_Rect dst_rect_;              // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
+  SDL_Rect dst_rect_;                // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
-  int base_;                       // Linea de fondo coincidente con el area inferior de la zona de juego
+  int base_;                         // Linea de fondo coincidente con el area inferior de la zona de juego
-  Color color_;                    // Color para atenuar el fondo
+  Color attenuate_color_;            // Color para atenuar el fondo
-  int alpha_color_text_;           // Alpha para atenuar el fondo
+  int alpha_color_text_;             // Alpha para atenuar el fondo
-  int alpha_color_text_temp_;      // Valor temporal para hacer la transición de alpha
+  int alpha_color_text_temp_;        // Valor temporal para hacer la transición de alpha
+  std::vector<SDL_Point> sun_path_;  // Vector con el recorrido del sol
+  std::vector<SDL_Point> moon_path_; // Vector con el recorrido de la luna
+  size_t sun_index_ = 0;             // Posición del vector del recorrido del sol
+  size_t moon_index_ = 0;            // Posición del vector del recorrido de la luna
 
   // Dibuja el gradiente de fondo
   void renderGradient();
@@ -94,11 +104,17 @@ private:
   void fillCanvas();
 
   // Actualiza el valor de alpha
-  void updateAlphaColorText();
+  void updateAlphaColorTexture();
 
   // Actualiza las nubes
   void updateClouds();
 
+  // Precalcula el vector con el recorrido del sol
+  void createSunPath();
+
+  // Precalcula el vector con el recorrido de la luna
+  void createMoonPath();
+
 public:
   // Constructor
   Background();
@@ -132,4 +148,10 @@ public:
 
   // Establece la transparencia de la atenuación
   void setAlpha(int alpha);
+
+  // Establece la posición del sol
+  void setSunProgression(float progress);
+
+  // Establece la posición de la luna
+  void setMoonProgression(float progress);
 };

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;
@@ -102,15 +107,27 @@ void Balloon::render()
 {
 	if (type_ == BalloonType::POWERBALL)
 	{
-		// Renderizado para la PowerBall
+		// Renderiza el fondo azul
-		SDL_Point p = {24, 24};
+		{
-		sprite_->setRotatingCenter(&p);
+			auto sp = std::make_unique<Sprite>(sprite_->getTexture(), sprite_->getPosition());
-		sprite_->render();
+			sp->setSpriteClip(0, 0, BALLOON_SIZE[4], BALLOON_SIZE[4]);
+			sp->render();
+		}
+
+		// Renderiza la estrella
+		if (!invulnerable_)
+		{
+			SDL_Point p = {24, 24};
+			sprite_->setRotatingCenter(&p);
+			sprite_->render();
+		}
 
 		// Añade la máscara del borde y los reflejos
-		auto sp = std::make_unique<Sprite>(sprite_->getTexture(), sprite_->getPosition());
+		{
-		sp->setSpriteClip(BALLOON_SIZE[4], 0, BALLOON_SIZE[4], BALLOON_SIZE[4]);
+			auto sp = std::make_unique<Sprite>(sprite_->getTexture(), sprite_->getPosition());
-		sp->render();
+			sp->setSpriteClip(BALLOON_SIZE[4] * 2, 0, BALLOON_SIZE[4], BALLOON_SIZE[4]);
+			sp->render();
+		}
 	}
 	else
 	{
@@ -145,6 +162,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
@@ -161,24 +179,13 @@ void Balloon::move()
 		// Mueve el globo en vertical
 		y_ += vy_ * speed_;
 
-		// Colisión en la parte superior de la zona de juego excepto para la PowerBall
-		/*if (type_ != BalloonType::POWERBALL)
-		{
-			const int min_y = play_area_.y;
-			if (y_ < min_y)
-			{
-				y_ = min_y;
-				vy_ = -vy_;
-				enableBounce();
-			}
-		}*/
-
 		// Colisión en la parte superior solo si el globo va de subida
 		if (vy_ < 0)
 		{
 			const int min_y = play_area_.y;
 			if (y_ < min_y)
 			{
+				playSound();
 				y_ = min_y;
 				vy_ = -vy_;
 				enableBounce();
@@ -189,12 +196,17 @@ 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)
 			{
 				enableBounce();
 			}
+			else
+			{
+				setInvulnerable(false);
+			}
 		}
 
 		/*
@@ -221,12 +233,6 @@ void Balloon::move()
 	}
 }
 
-// Deshabilita el globo
-void Balloon::disable() { enabled_ = false; }
-
-// Explosiona el globo
-void Balloon::pop() { disable(); }
-
 // Actualiza al globo a su posicion, animación y controla los contadores
 void Balloon::update()
 {
@@ -401,4 +407,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(
@@ -164,12 +170,6 @@ public:
 	// Actualiza la posición y estados del globo
 	void move();
 
-	// Deshabilita el globo y pone a cero todos los valores
-	void disable();
-
-	// Explosiona el globo
-	void pop();
-
 	// Actualiza al globo a su posicion, animación y controla los contadores
 	void update();
 
@@ -208,4 +208,6 @@ 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; }
+	void disable() { enabled_ = false; }
 };

source/balloon_manager.cpp

@@ -107,11 +107,18 @@ void BalloonManager::deployBalloonFormation(int stage)
             last_balloon_deploy_ = formation;
 
             const auto set = balloon_formations_->getSet(stage, formation);
-            const auto numEnemies = set.number_of_balloons;
+            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);
@@ -173,49 +180,61 @@ int BalloonManager::calculateScreenPower()
 // Crea un globo nuevo en el vector de globos
 std::shared_ptr<Balloon> BalloonManager::createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int creation_timer)
 {
-    const int index = static_cast<int>(size);
+    if (can_deploy_balloons_)
-    balloons_.emplace_back(std::make_shared<Balloon>(x, y, type, size, velx, speed, creation_timer, play_area_, balloon_textures_.at(index), balloon_animations_.at(index)));
+    {
-    return balloons_.back();
+        const int index = static_cast<int>(size);
+        balloons_.emplace_back(std::make_shared<Balloon>(x, y, type, size, velx, speed, creation_timer, play_area_, balloon_textures_.at(index), balloon_animations_.at(index)));
+        return balloons_.back();
+    }
+
+    return nullptr;
 }
 
 // Crea un globo a partir de otro globo
 void BalloonManager::createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction)
 {
-    const float vx = direction == "LEFT" ? BALLOON_VELX_NEGATIVE : BALLOON_VELX_POSITIVE;
+    if (can_deploy_balloons_)
-    const auto lower_size = static_cast<BalloonSize>(static_cast<int>(balloon->getSize()) - 1);
-    auto b = createBalloon(0, balloon->getPosY(), balloon->getType(), lower_size, vx, balloon_speed_, 0);
-    const int x = direction == "LEFT" ? balloon->getPosX() + (balloon->getWidth() / 3) : balloon->getPosX() + 2 * (balloon->getWidth() / 3);
-    b->alignTo(x);
-    b->setVelY(b->getType() == BalloonType::BALLOON ? -2.50f : BALLOON_VELX_NEGATIVE * 2.0f);
-    if (balloon->isStopped())
     {
-        b->stop();
+        const float vx = direction == "LEFT" ? BALLOON_VELX_NEGATIVE : BALLOON_VELX_POSITIVE;
-    }
+        const auto lower_size = static_cast<BalloonSize>(static_cast<int>(balloon->getSize()) - 1);
-    if (balloon->isUsingReversedColor())
+        auto b = createBalloon(0, balloon->getPosY(), balloon->getType(), lower_size, vx, balloon_speed_, 0);
-    {
+        const int x = direction == "LEFT" ? balloon->getPosX() + (balloon->getWidth() / 3) : balloon->getPosX() + 2 * (balloon->getWidth() / 3);
-        b->useReverseColor();
+        b->alignTo(x);
+        b->setVelY(b->getType() == BalloonType::BALLOON ? -2.50f : BALLOON_VELX_NEGATIVE * 2.0f);
+        if (balloon->isStopped())
+        {
+            b->stop();
+        }
+        if (balloon->isUsingReversedColor())
+        {
+            b->useReverseColor();
+        }
     }
 }
 
 // Crea una PowerBall
 void BalloonManager::createPowerBall()
 {
-    constexpr int values = 6;
+    if (can_deploy_balloons_)
-    constexpr int pos_y = -BALLOON_SIZE[4];
+    {
-    constexpr int creation_time = 0;
+        constexpr int values = 6;
+        constexpr int pos_y = -BALLOON_SIZE[4];
+        constexpr int creation_time = 0;
 
-    const auto left = param.game.play_area.rect.x;
+        const auto left = param.game.play_area.rect.x;
-    const auto center = param.game.play_area.center_x - (BALLOON_SIZE[4] / 2);
+        const auto center = param.game.play_area.center_x - (BALLOON_SIZE[4] / 2);
-    const auto right = param.game.play_area.rect.w - BALLOON_SIZE[4];
+        const auto right = param.game.play_area.rect.w - BALLOON_SIZE[4];
 
-    const auto luck = rand() % values;
+        const auto luck = rand() % values;
-    const int x[values] = {left, left, center, center, right, right};
+        const int x[values] = {left, left, center, center, right, right};
-    const float vx[values] = {BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE};
+        const float vx[values] = {BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE};
 
-    balloons_.emplace_back(std::make_unique<Balloon>(x[luck], pos_y, BalloonType::POWERBALL, BalloonSize::SIZE4, vx[luck], balloon_speed_, creation_time, play_area_, balloon_textures_[4], balloon_animations_[4]));
+        balloons_.emplace_back(std::make_unique<Balloon>(x[luck], pos_y, BalloonType::POWERBALL, BalloonSize::SIZE4, vx[luck], balloon_speed_, creation_time, play_area_, balloon_textures_[4], balloon_animations_[4]));
+        balloons_.back()->setInvulnerable(true);
 
-    power_ball_enabled_ = true;
+        power_ball_enabled_ = true;
-    power_ball_counter_ = POWERBALL_COUNTER;
+        power_ball_counter_ = POWERBALL_COUNTER;
+    }
 }
 
 // Establece la velocidad de los globos
@@ -251,7 +270,7 @@ int BalloonManager::popBalloon(std::shared_ptr<Balloon> balloon)
 
         // Agrega la explosión y elimina el globo
         explosions_->add(balloon->getPosX(), balloon->getPosY(), static_cast<int>(balloon->getSize()));
-        balloon->pop();
+        balloon->disable();
     }
 
     return score;
@@ -287,7 +306,7 @@ int BalloonManager::destroyBalloon(std::shared_ptr<Balloon> &balloon)
 
     // Destruye el globo
     explosions_->add(balloon->getPosX(), balloon->getPosY(), static_cast<int>(balloon->getSize()));
-    balloon->pop();
+    balloon->disable();
 
     return score;
 }
@@ -302,7 +321,7 @@ int BalloonManager::destroyAllBalloons()
     }
 
     balloon_deploy_counter_ = 300;
-    JA_PlaySound(Resource::get()->getSound("powerball.wav"));
+    JA_PlaySound(Resource::get()->getSound("power_ball_explosion.wav"));
     Screen::get()->flash(flash_color, 3);
     Screen::get()->shake();
 
@@ -366,9 +385,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,8 @@ 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
+    bool can_deploy_balloons_ = true;                // Indica si creará globos
 
     // Inicializa
     void init();
@@ -108,15 +110,24 @@ 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; }
+    void setDeployBalloons(bool value) { can_deploy_balloons_ = value; }
 };

source/credits.cpp

@@ -1,35 +1,40 @@
+// IWYU pragma: no_include <bits/std_abs.h>
 #include "credits.h"
 #include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
 #include <SDL2/SDL_events.h>    // Para SDL_PollEvent, SDL_Event, SDL_QUIT
 #include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888
-#include <SDL2/SDL_rect.h>      // Para SDL_Rect
 #include <SDL2/SDL_timer.h>     // Para SDL_GetTicks
-#include <algorithm>
+#include <algorithm>            // Para max, min, clamp
-#include <cstdlib>
+#include <cstdlib>              // Para abs
-#include <string>            // Para basic_string, string
+#include <stdexcept>            // Para runtime_error
-#include <vector>            // Para vector
+#include <string>               // Para basic_string, string
-#include "balloon_manager.h" // Para BalloonManager
+#include <vector>               // Para vector
-#include "global_inputs.h"   // Para check
+#include "balloon_manager.h"    // Para BalloonManager
-#include "input.h"           // Para Input
+#include "fade.h"               // Para Fade, FadeType, FadeMode
-#include "jail_audio.h"      // Para JA_PlayMusic, JA_StopMusic
+#include "global_inputs.h"      // Para check, update
-#include "param.h"           // Para Param, ParamGame, param
+#include "input.h"              // Para Input
-#include "resource.h"        // Para Resource
+#include "jail_audio.h"         // Para JA_GetMusicState, JA_SetMusicVolume
-#include "screen.h"          // Para Screen
+#include "lang.h"               // Para getText
-#include "section.h"         // Para Name, name, Options, options
+#include "mouse.h"              // Para handleEvent
-#include "text.h"            // Para Text, TEXT_CENTER, TEXT_SHADOW
+#include "param.h"              // Para Param, ParamGame, param
-#include "tiled_bg.h"        // Para TiledBG, TiledBGMode
+#include "player.h"             // Para Player, PlayerState
-#include "utils.h"           // Para Color, no_color, shdw_txt_color, Zone
+#include "resource.h"           // Para Resource
-#include "player.h"
+#include "screen.h"             // Para Screen
-#include "fade.h"
+#include "section.h"            // Para Name, name, Options, options
-#include "lang.h"
+#include "sprite.h"             // Para Sprite
+#include "text.h"               // Para Text, TEXT_CENTER, TEXT_SHADOW
+#include "texture.h"            // Para Texture
+#include "tiled_bg.h"           // Para TiledBG, TiledBGMode
+#include "utils.h"              // Para Color, Zone, shdw_txt_color, no_color
 
 // Textos
-constexpr const char TEXT_COPYRIGHT[] = "@2020,2024 JailDesigner";
+constexpr const char TEXT_COPYRIGHT[] = "@2020,2025 JailDesigner";
 
 // Constructor
 Credits::Credits()
     : balloon_manager_(std::make_unique<BalloonManager>()),
       text_texture_(SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
+      canvas_(SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
       tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::DIAGONAL)),
       fade_in_(std::make_unique<Fade>()),
       fade_out_(std::make_unique<Fade>())
@@ -39,20 +44,18 @@ Credits::Credits()
         throw std::runtime_error("Failed to create SDL texture for text.");
     }
     section::name = section::Name::CREDITS;
-    //top_black_rect_ = {play_area_.x, 0, play_area_.w, black_bars_size_};
-    //bottom_black_rect_ = {play_area_.x, param.game.game_area.rect.h - black_bars_size_, play_area_.w, black_bars_size_};
     balloon_manager_->setPlayArea(play_area_);
-    
+
     fade_in_->setColor(fade_color.r, fade_color.g, fade_color.b);
     fade_in_->setType(FadeType::FULLSCREEN);
-    fade_in_->setPost(50);
+    fade_in_->setPostDuration(50);
     fade_in_->setMode(FadeMode::IN);
     fade_in_->activate();
-    
+
     fade_out_->setColor(0, 0, 0);
     fade_out_->setType(FadeType::FULLSCREEN);
-    fade_out_->setPost(400);
+    fade_out_->setPostDuration(400);
-    
+
     initPlayers();
     SDL_SetTextureBlendMode(text_texture_, SDL_BLENDMODE_BLEND);
     fillTextTexture();
@@ -63,7 +66,9 @@ Credits::Credits()
 Credits::~Credits()
 {
     SDL_DestroyTexture(text_texture_);
+    SDL_DestroyTexture(canvas_);
     resetVolume();
+    JA_StopMusic();
 }
 
 // Bucle principal
@@ -81,21 +86,29 @@ void Credits::run()
 // Actualiza las variables
 void Credits::update()
 {
-    if (SDL_GetTicks() - ticks_ > ticks_speed_)
+    constexpr Uint32 TICKS_SPEED_ = 15;
+
+    if (SDL_GetTicks() - ticks_ > TICKS_SPEED_)
     {
         ticks_ = SDL_GetTicks();
-        tiled_bg_->update();
+        const int repeat = want_to_pass_ ? 4 : 1;
-        balloon_manager_->update();
+        for (int i = 0; i < repeat; ++i)
-        updateTextureDstRects();
-        throwBalloons();
-        for (auto &player : players_)
         {
-            player->update();
+            tiled_bg_->update();
+            balloon_manager_->update();
+            updateTextureDstRects();
+            throwBalloons();
+            for (auto &player : players_)
+            {
+                player->update();
+            }
+            updateAllFades();
+            ++counter_;
         }
-        updateAllFades();
         Screen::get()->update();
         globalInputs::update();
-        ++counter_;
+
+        fillCanvas();
     }
 }
 
@@ -105,42 +118,11 @@ void Credits::render()
     // Prepara para empezar a dibujar en la textura de juego
     Screen::get()->start();
 
-    // Limpia la pantalla
+    // Copia la textura con la zona de juego a la pantalla
-    Screen::get()->clean();
+    SDL_RenderCopy(Screen::get()->getRenderer(), canvas_, nullptr, nullptr);
-
-    // Dibuja el fondo, los globos y los jugadores
-    tiled_bg_->render();
-    balloon_manager_->render();
-    for (auto const &player : players_)
-    {
-        player->render();
-    }
-
-    // Dibuja los titulos de credito
-    SDL_RenderCopy(Screen::get()->getRenderer(), text_texture_, &credits_rect_src_, &credits_rect_dst_);
-
-    // Dibuja el mini_logo
-    SDL_RenderCopy(Screen::get()->getRenderer(), text_texture_, &mini_logo_rect_src_, &mini_logo_rect_dst_);
-
-    // Dibuja los rectangulos negros
-    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 0, 0, 255);
-    SDL_RenderFillRect(Screen::get()->getRenderer(), &top_black_rect_);
-    SDL_RenderFillRect(Screen::get()->getRenderer(), &bottom_black_rect_);
-    SDL_RenderFillRect(Screen::get()->getRenderer(), &left_black_rect_);
-    SDL_RenderFillRect(Screen::get()->getRenderer(), &right_black_rect_);
-
-    // Si el mini_logo está en su destino, lo dibuja encima de lo anterior
-    if (mini_logo_on_position_)
-    {
-        SDL_RenderCopy(Screen::get()->getRenderer(), text_texture_, &mini_logo_rect_src_, &mini_logo_rect_dst_);
-    }
-
-    // Dibuja el fade sobre el resto de elementos
-    fade_in_->render();
-    fade_out_->render();
 
     // Vuelca el contenido del renderizador en pantalla
-    Screen::get()->blit();
+    Screen::get()->render();
 }
 
 // Comprueba el manejador de eventos
@@ -158,6 +140,9 @@ void Credits::checkEvents()
             section::options = section::Options::QUIT_FROM_EVENT;
             break;
         }
+
+        // Comprueba el cursor
+        Mouse::handleEvent(event);
     }
 }
 
@@ -176,7 +161,6 @@ void Credits::checkInput()
         {
             // Si todavía estan los creditos en marcha, se pasan solos a toda pastilla
             want_to_pass_ = true;
-            ticks_speed_ = 1;
         }
     }
 
@@ -273,6 +257,48 @@ void Credits::fillTextTexture()
     mini_logo_final_pos_ = param.game.game_area.center_y - mini_logo_rect_src_.h / 2;
 }
 
+// Dibuja todos los sprites en la textura
+void Credits::fillCanvas()
+{
+    // Cambia el destino del renderizador
+    auto temp = SDL_GetRenderTarget(Screen::get()->getRenderer());
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), canvas_);
+
+    // Dibuja el fondo, los globos y los jugadores
+    tiled_bg_->render();
+    balloon_manager_->render();
+    for (auto const &player : players_)
+    {
+        player->render();
+    }
+
+    // Dibuja los titulos de credito
+    SDL_RenderCopy(Screen::get()->getRenderer(), text_texture_, &credits_rect_src_, &credits_rect_dst_);
+
+    // Dibuja el mini_logo
+    SDL_RenderCopy(Screen::get()->getRenderer(), text_texture_, &mini_logo_rect_src_, &mini_logo_rect_dst_);
+
+    // Dibuja los rectangulos negros
+    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 0, 0, 255);
+    SDL_RenderFillRect(Screen::get()->getRenderer(), &top_black_rect_);
+    SDL_RenderFillRect(Screen::get()->getRenderer(), &bottom_black_rect_);
+    SDL_RenderFillRect(Screen::get()->getRenderer(), &left_black_rect_);
+    SDL_RenderFillRect(Screen::get()->getRenderer(), &right_black_rect_);
+
+    // Si el mini_logo está en su destino, lo dibuja encima de lo anterior
+    if (mini_logo_on_position_)
+    {
+        SDL_RenderCopy(Screen::get()->getRenderer(), text_texture_, &mini_logo_rect_src_, &mini_logo_rect_dst_);
+    }
+
+    // Dibuja el fade sobre el resto de elementos
+    fade_in_->render();
+    fade_out_->render();
+
+    // Deja el renderizador apuntando donde estaba
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), temp);
+}
+
 // Actualiza el destino de los rectangulos de las texturas
 void Credits::updateTextureDstRects()
 {
@@ -452,7 +478,7 @@ void Credits::updateAllFades()
     fade_out_->update();
     if (fade_out_->hasEnded())
     {
-        section::name = section::Name::LOGO;
+        section::name = section::Name::HI_SCORE_TABLE;
     }
 }
 

source/credits.h

@@ -1,14 +1,17 @@
 #pragma once
 
+#include <SDL2/SDL_rect.h>   // Para SDL_Rect
 #include <SDL2/SDL_render.h> // Para SDL_Texture
 #include <SDL2/SDL_stdinc.h> // Para Uint32
-#include <memory>            // Para unique_ptr
+#include <memory>            // Para unique_ptr, shared_ptr
-#include "param.h"
+#include <vector>            // Para vector
-#include "options.h"
+#include "options.h"         // Para Options, OptionsAudio, OptionsMusic
-class BalloonManager;
+#include "param.h"           // Para Param, ParamGame, param
-class TiledBG;
+#include "utils.h"           // Para Zone
-class Player;
+class BalloonManager;        // lines 8-8
-class Fade;
+class Fade;                  // lines 11-11
+class Player;                // lines 10-10
+class TiledBG;               // lines 9-9
 
 constexpr int PLAY_AREA_HEIGHT = 200;
 
@@ -18,6 +21,7 @@ private:
     // Objetos
     std::unique_ptr<BalloonManager> balloon_manager_; // Objeto para gestionar los globos
     SDL_Texture *text_texture_;                       // Textura con el texto
+    SDL_Texture *canvas_;                             // Textura donde dibujarlo todo
     std::unique_ptr<TiledBG> tiled_bg_;               // Objeto para dibujar el mosaico animado de fondo
     std::unique_ptr<Fade> fade_in_;                   // Objeto para realizar el fundido de entrada
     std::unique_ptr<Fade> fade_out_;                  // Objeto para realizar el fundido de salida
@@ -25,7 +29,6 @@ private:
 
     // Variables
     Uint32 ticks_ = 0;                                                           // Contador de ticks para ajustar la velocidad del programa
-    Uint32 ticks_speed_ = 15;                                                    // Velocidad del bucle update
     Uint32 counter_ = 0;                                                         // Contador para la lógica de la clase
     Uint32 counter_pre_fade_ = 0;                                                // Contador para activar el fundido final
     Uint32 counter_prevent_endless_ = 0;                                         // Contador para evitar que el juego se quede para siempre en los creditos
@@ -67,6 +70,9 @@ private:
     // Crea la textura con el texto
     void fillTextTexture();
 
+    // Dibuja todos los sprites en la textura
+    void fillCanvas();
+
     // Actualiza el destino de los rectangulos de las texturas
     void updateTextureDstRects();
 

source/director.cpp

@@ -8,44 +8,42 @@
 #include <SDL2/SDL_hints.h>			 // Para SDL_SetHint, SDL_HINT_RENDER_DR...
 #include <SDL2/SDL_scancode.h>		 // Para SDL_SCANCODE_0, SDL_SCANCODE_DOWN
 #include <SDL2/SDL_stdinc.h>		 // Para SDL_bool, Uint32
-#include <chrono>					 // Para duration, system_clock
 #include <errno.h>					 // Para errno, EEXIST, EACCES, ENAMETOO...
-#include <stdio.h>					 // Para printf, perror
-#include <sys/stat.h>				 // Para mkdir, stat, S_IRWXU
-#include <unistd.h>					 // Para getuid
-#include <algorithm>				 // Para min
-#include <cstdlib>					 // Para exit, EXIT_FAILURE, size_t, rand
-#include <iostream>					 // Para basic_ostream, operator<<, basi...
-#include <memory>					 // Para make_unique, unique_ptr
-#include <stdexcept>				 // Para runtime_error
-#include <string>					 // Para operator+, char_traits, allocator
-#include <vector>					 // Para vector
-#include "asset.h"					 // Para Asset, AssetType
-#include "credits.h"				 // Para Credits
-#include "dbgtxt.h"					 // Para dbg_init
-#include "game.h"					 // Para Game, GAME_MODE_DEMO_OFF, GAME_...
-#include "global_inputs.h"			 // Para init
-#include "hiscore_table.h"			 // Para HiScoreTable
-#include "input.h"					 // Para Input, InputType
-#include "instructions.h"			 // Para Instructions
-#include "intro.h"					 // Para Intro
-#include "jail_audio.h"				 // Para JA_SetMusicVolume, JA_SetSoundV...
-#include "lang.h"					 // Para Code, loadFromFile
-#include "logo.h"					 // Para Logo
-#include "manage_hiscore_table.h"	 // Para ManageHiScoreTable
-#include "notifier.h"				 // Para Notifier
-#include "on_screen_help.h"			 // Para OnScreenHelp
-#include "options.h"				 // Para Options, OptionsController, opt...
-#include "param.h"					 // Para Param, ParamGame, param, loadPa...
-#include "resource.h"				 // Para Resource
-#include "screen.h"					 // Para Screen
-#include "section.h"				 // Para Name, Options, name, options
-#include "title.h"					 // Para Title
-#include "utils.h"					 // Para Overrides, overrides
-
 #ifndef _WIN32
-#include <pwd.h> // para getpwuid, passwd
+#include <pwd.h> // Para getpwuid, passwd
 #endif
+#include <stdio.h>				  // Para printf, perror
+#include <sys/stat.h>			  // Para mkdir, stat, S_IRWXU
+#include <unistd.h>				  // Para getuid
+#include <algorithm>			  // Para min
+#include <chrono>				  // Para chrono
+#include <cstdlib>				  // Para exit, EXIT_FAILURE, size_t, rand
+#include <iostream>				  // Para basic_ostream, operator<<, basi...
+#include <memory>				  // Para make_unique, unique_ptr
+#include <stdexcept>			  // Para runtime_error
+#include <string>				  // Para operator+, char_traits, allocator
+#include <vector>				  // Para vector
+#include "asset.h"				  // Para Asset, AssetType
+#include "credits.h"			  // Para Credits
+#include "dbgtxt.h"				  // Para dbg_init
+#include "game.h"				  // Para Game, GAME_MODE_DEMO_OFF, GAME_...
+#include "hiscore_table.h"		  // Para HiScoreTable
+#include "input.h"				  // Para Input, InputType
+#include "instructions.h"		  // Para Instructions
+#include "intro.h"				  // Para Intro
+#include "jail_audio.h"			  // Para JA_SetMusicVolume, JA_SetSoundV...
+#include "lang.h"				  // Para Code, loadFromFile
+#include "logo.h"				  // Para Logo
+#include "manage_hiscore_table.h" // Para ManageHiScoreTable
+#include "notifier.h"			  // Para Notifier
+#include "on_screen_help.h"		  // Para OnScreenHelp
+#include "options.h"			  // Para Options, options, OptionsContro...
+#include "param.h"				  // Para Param, ParamGame, param, loadPa...
+#include "resource.h"			  // Para Resource
+#include "screen.h"				  // Para Screen
+#include "section.h"			  // Para Name, Options, name, options
+#include "title.h"				  // Para Title
+#include "utils.h"				  // Para Overrides, overrides
 
 // Constructor
 Director::Director(int argc, const char *argv[])
@@ -128,6 +126,10 @@ void Director::close()
 	SDL_DestroyWindow(window_);
 
 	SDL_Quit();
+
+#ifdef ARCADE
+	shutdownSystem(section::options == section::Options::QUIT_WITH_CONTROLLER);
+#endif
 }
 
 // Carga los parametros
@@ -180,8 +182,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 +298,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 +396,28 @@ 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/coffeeout.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/coffee_out.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/notify.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/hi_score_achieved.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/item_drop.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/item_pickup.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/power_ball_explosion.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);
+	Asset::get()->add(prefix + "/data/sound/debian_drop.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/debian_pickup.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/tabe_hit.wav", AssetType::SOUND);
 
 	// Shaders
 	Asset::get()->add(prefix + "/data/shaders/crtpi_256.glsl", AssetType::DATA);
@@ -439,6 +460,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);
@@ -446,6 +472,8 @@ void Director::setFileList()
 		Asset::get()->add(prefix + "/data/gfx/game/game_grass.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/game/game_power_meter.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/game/game_sky_colors.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/game/game_sun.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/game/game_moon.png", AssetType::BITMAP);
 	}
 
 	{ // Intro
@@ -469,6 +497,8 @@ void Director::setFileList()
 		Asset::get()->add(prefix + "/data/gfx/item/item_clock.ani", AssetType::ANIMATION);
 		Asset::get()->add(prefix + "/data/gfx/item/item_coffee.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/item/item_coffee.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/item/item_debian.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/item/item_debian.ani", AssetType::ANIMATION);
 		Asset::get()->add(prefix + "/data/gfx/item/item_coffee_machine.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/item/item_coffee_machine.ani", AssetType::ANIMATION);
 	}
@@ -484,17 +514,17 @@ void Director::setFileList()
 
 	{ // Jugador 1
 		Asset::get()->add(prefix + "/data/gfx/player/player1.gif", AssetType::BITMAP);
-		Asset::get()->add(prefix + "/data/gfx/player/player1_one_coffee_palette.pal", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player1_1_coffee_palette.gif", AssetType::PALETTE);
-		Asset::get()->add(prefix + "/data/gfx/player/player1_two_coffee_palette.pal", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player1_2_coffee_palette.gif", AssetType::PALETTE);
-		Asset::get()->add(prefix + "/data/gfx/player/player1_all_white_palette.pal", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player1_invencible_palette.gif", AssetType::PALETTE);
 		Asset::get()->add(prefix + "/data/gfx/player/player1_power.png", AssetType::BITMAP);
 	}
 
 	{ // Jugador 2
 		Asset::get()->add(prefix + "/data/gfx/player/player2.gif", AssetType::BITMAP);
-		Asset::get()->add(prefix + "/data/gfx/player/player2_one_coffee_palette.pal", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player2_1_coffee_palette.gif", AssetType::PALETTE);
-		Asset::get()->add(prefix + "/data/gfx/player/player2_two_coffee_palette.pal", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player2_2_coffee_palette.gif", AssetType::PALETTE);
-		Asset::get()->add(prefix + "/data/gfx/player/player2_all_white_palette.pal", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player2_invencible_palette.gif", AssetType::PALETTE);
 		Asset::get()->add(prefix + "/data/gfx/player/player2_power.png", AssetType::BITMAP);
 	}
 
@@ -506,8 +536,6 @@ void Director::setFileList()
 	// Fuentes de texto
 	Asset::get()->add(prefix + "/data/font/8bithud.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/8bithud.txt", AssetType::FONT);
-	Asset::get()->add(prefix + "/data/font/nokia.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/font/nokia.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/smb2.gif", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/smb2_palette1.pal", AssetType::PALETTE);
 	Asset::get()->add(prefix + "/data/font/smb2.txt", AssetType::FONT);
@@ -515,6 +543,8 @@ void Director::setFileList()
 	Asset::get()->add(prefix + "/data/font/04b_25.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/04b_25_2x.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/04b_25_2x.txt", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/04b_25_metal.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/font/04b_25_grey.png", AssetType::BITMAP);
 
 	// Textos
 	Asset::get()->add(prefix + "/data/lang/es_ES.txt", AssetType::LANG);
@@ -741,11 +771,6 @@ int Director::run()
 	// Habilita de nuevo los std::cout
 	std::cout.rdbuf(orig_buf);
 #endif
-#ifdef ARCADE
-	// Comprueba si ha de apagar el sistema
-	if (section::options == section::Options::QUIT_WITH_CONTROLLER)
-		shutdownSystem();
-#endif
 
 	return (section::options == section::Options::QUIT_WITH_CONTROLLER) ? 1 : 0;
 }
@@ -773,20 +798,23 @@ std::string Director::getLangFile(lang::Code code)
 
 #ifdef ARCADE
 // Apaga el sistema
-void Director::shutdownSystem()
+void Director::shutdownSystem(bool shouldShutdown)
 {
+	if (shouldShutdown)
+	{
 #ifdef _WIN32
-	// Apaga el sistema en Windows
+		// Apaga el sistema en Windows
-	system("shutdown /s /t 0");
+		system("shutdown /s /t 5");
 #elif __APPLE__
-	// Apaga el sistema en macOS
+		// Apaga el sistema en macOS
-	system("sudo shutdown -h now");
+		system("sudo shutdown -h +0.1");
 #elif __linux__
-	// Apaga el sistema en Linux
+		// Apaga el sistema en Linux
-	system("shutdown -h now");
+		system("sleep 5; shutdown -h now");
 #else
 // Sistema operativo no compatible
 #error "Sistema operativo no soportado"
 #endif
+	}
 }
 #endif // ARCADE

source/director.h

@@ -74,7 +74,7 @@ private:
 	std::string getLangFile(lang::Code code);
 #ifdef ARCADE
 	// Apaga el sistema
-	void shutdownSystem();
+	void shutdownSystem(bool shouldShutdown);
 #endif
 
 	// Inicializa todo

source/enter_name.cpp

@@ -1,93 +1,164 @@
 #include "enter_name.h"
+#include "utils.h"
 #include <stddef.h>  // Para size_t
 #include <algorithm> // Para max, min
+#include <cassert>   // Para assert
+#include <iostream>
 
 // Constructor
 EnterName::EnterName()
-{
+    : character_list_(" ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()") {}
-    init();
-}
 
 // Inicializa el objeto
-void EnterName::init()
+void EnterName::init(const std::string &name)
 {
-    // Obtiene el puntero al nombre
+    // No se pasa ningún nombre
-    name_ = "A";
+    if (name == "")
+    {
+        name_ = "A";
+        position_ = 0;
+        position_overflow_ = false;
+    }
+    // Se pasa un nombre
+    else
+    {
+        name_ = name;
+        position_ = name_.length();
+        position_overflow_ = position_ >= NAME_LENGHT ? true : false;
+    }
 
-    // Inicia la lista de caracteres permitidos
+    // Inicializa el vector de indices con el nombre y espacios
-    character_list_ = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()";
+    initCharacterIndex(name_);
-    position_ = 0;
-    num_characters_ = static_cast<int>(character_list_.size());
-
-    // Pone la lista de indices para que refleje el nombre
-    updateCharacterIndex();
-
-    // Actualiza el nombre para que ocupe 8 espacios
-    updateName();
 }
 
 // Incrementa la posición
 void EnterName::incPosition()
 {
-    position_++;
+    if (position_overflow_)
-    position_ = std::min(position_, NAME_LENGHT - 1);
+    {
-    checkIfPositionHasBeenUsed();
+        // Si ya estamos en overflow, no incrementamos más.
+        return;
+    }
+
+    ++position_;
+
+    if (position_ >= NAME_LENGHT)
+    {
+        position_ = NAME_LENGHT; // Mantenemos en el índice máximo válido.
+        position_overflow_ = true;    // Activamos el flag de overflow.
+    }
+    else
+    {
+        // Copiamos el índice del carácter anterior si es posible.
+        if (position_ > 0 && position_ < NAME_LENGHT)
+        {
+            character_index_[position_] = character_index_[position_ - 1];
+        }
+        else
+        {
+            // Si position_ es 0, inicializamos el carácter actual.
+            character_index_[position_] = 0;
+        }
+    }
+
+    updateNameFromCharacterIndex();
 }
 
 // Decrementa la posición
 void EnterName::decPosition()
 {
-    --position_;
+    if (position_overflow_)
-    position_ = std::max(position_, 0);
+    {
+        // Si estaba en overflow, lo desactivamos y mantenemos position_ en el máximo.
+        position_overflow_ = false;
+        position_ = NAME_LENGHT - 1;
+    }
+    else
+    {
+        if (position_ > 0)
+        {
+            --position_;
+
+            // Limpiamos el carácter siguiente si el índice es válido.
+            if (position_ + 1 < NAME_LENGHT)
+            {
+                character_index_[position_ + 1] = 0;
+            }
+        }
+        else
+        {
+            // Si position_ es 0, aseguramos que no vaya a ser negativo y limpiamos el carácter actual.
+            position_ = 0;
+            character_index_[position_] = 0;
+        }
+
+        // Si position_ es menor que NAME_LENGHT, aseguramos que el overflow esté desactivado.
+        if (position_ < NAME_LENGHT)
+        {
+            position_overflow_ = false;
+        }
+    }
+
+    updateNameFromCharacterIndex();
 }
 
+
 // Incrementa el índice
 void EnterName::incIndex()
 {
+    if (position_overflow_)
+    {
+        return;
+    }
+
     ++character_index_[position_];
-    if (character_index_[position_] >= num_characters_)
+    if (character_index_[position_] >= static_cast<int>(character_list_.size()))
     {
         character_index_[position_] = 0;
     }
-    updateName();
+    updateNameFromCharacterIndex();
 }
 
 // Decrementa el índice
 void EnterName::decIndex()
 {
+    if (position_overflow_)
+    {
+        return;
+    }
+    
     --character_index_[position_];
     if (character_index_[position_] < 0)
     {
-        character_index_[position_] = num_characters_ - 1;
+        character_index_[position_] = character_list_.size() - 1;
     }
-    updateName();
+    updateNameFromCharacterIndex();
 }
 
 // Actualiza el nombre a partir de la lista de índices
-void EnterName::updateName()
+void EnterName::updateNameFromCharacterIndex()
 {
     name_.clear();
     for (int i = 0; i < NAME_LENGHT; ++i)
     {
         name_.push_back(character_list_[character_index_[i]]);
     }
+    name_ = trim(name_);
 }
 
 // Actualiza la variable
-void EnterName::updateCharacterIndex()
+void EnterName::initCharacterIndex(const std::string &name)
 {
-    // Rellena de espacios y marca como no usados
+    // Rellena de espacios
     for (size_t i = 0; i < NAME_LENGHT; ++i)
     {
         character_index_[i] = 0;
-        position_has_been_used_[i] = false;
     }
 
     // Coloca los índices en función de los caracteres que forman el nombre
-    for (size_t i = 0; i < name_.size(); ++i)
+    for (size_t i = 0; i < name.substr(0, NAME_LENGHT).size(); ++i)
     {
-        character_index_[i] = findIndex(name_.at(i));
+        character_index_[i] = findIndex(name.at(i));
-        position_has_been_used_[i] = true;
     }
 }
 
@@ -98,28 +169,4 @@ int EnterName::findIndex(char character) const
         if (character == character_list_.at(i))
             return i;
     return 0;
-}
-
-// Obtiene el nombre
-std::string EnterName::getName() const
-{
-    return name_;
-}
-
-// Obtiene la posición que se está editando
-int EnterName::getPosition() const
-{
-    return position_;
-}
-
-// Comprueba la posición y copia el caracter si es necesario
-void EnterName::checkIfPositionHasBeenUsed()
-{
-    auto used = position_has_been_used_[position_];
-
-    if (!used && position_ > 0)
-        character_index_[position_] = character_index_[position_ - 1];
-
-    position_has_been_used_[position_] = true;
-    updateName();
 }

source/enter_name.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include "utils.h"
 
 constexpr int NAME_LENGHT = 6;
 
@@ -16,25 +17,21 @@ constexpr int NAME_LENGHT = 6;
 class EnterName
 {
 private:
-    std::string character_list_;               // Lista de todos los caracteres permitidos
+    std::string character_list_;       // Lista de todos los caracteres permitidos
-    std::string name_;                         // Nombre introducido
+    std::string name_;                 // Nombre introducido
-    int position_;                             // Posición a editar del nombre
+    int position_ = 0;                 // Posición a editar del nombre
-    int num_characters_;                       // Cantidad de caracteres de la lista de caracteres
+    bool position_overflow_ = false;   // Indica si hemos incrementado la posición más allá del límite
-    int character_index_[NAME_LENGHT];         // Indice de la lista para cada uno de los caracteres que forman el nombre
+    int character_index_[NAME_LENGHT]; // Indice de la lista para cada uno de los caracteres que forman el nombre
-    bool position_has_been_used_[NAME_LENGHT]; // Indica si en esa posición se ha puesto ya alguna letra. Se utiliza para replicar la letra anterior la primera vez
 
     // Actualiza el nombre a partir de la lista de índices
-    void updateName();
+    void updateNameFromCharacterIndex();
 
     // Actualiza la variable
-    void updateCharacterIndex();
+    void initCharacterIndex(const std::string &name);
 
     // Encuentra el indice de un caracter en "characterList"
     int findIndex(char character) const;
 
-    // Comprueba la posición y copia el caracter si es necesario
-    void checkIfPositionHasBeenUsed();
-
 public:
     // Constructor
     EnterName();
@@ -43,7 +40,7 @@ public:
     ~EnterName() = default;
 
     // Inicializa el objeto
-    void init();
+    void init(const std::string &name = "");
 
     // Incrementa la posición
     void incPosition();
@@ -57,9 +54,9 @@ public:
     // Decrementa el índice
     void decIndex();
 
-    // Obtiene el nombre
+    // Getters
-    std::string getName() const;
+    std::string getFinalName() const { return trim(name_.substr(0, position_)); }
-
+    std::string getCurrentName() const { return trim(name_); }
-    // Obtiene la posición que se está editando
+    int getPosition() const { return position_; }
-    int getPosition() const;
+    bool getPositionOverflow() const { return position_overflow_; }
 };

source/fade.cpp

@@ -30,15 +30,15 @@ void Fade::init()
 {
 	type_ = FadeType::CENTER;
 	mode_ = FadeMode::OUT;
-	enabled_ = false;
-	finished_ = false;
 	counter_ = 0;
 	r_ = 0;
 	g_ = 0;
 	b_ = 0;
 	a_ = 0;
-	post_duration_ = 20;
+	post_duration_ = 0;
 	post_counter_ = 0;
+	pre_duration_ = 0;
+	pre_counter_ = 0;
 	num_squares_width_ = param.fade.num_squares_width;
 	num_squares_height_ = param.fade.num_squares_height;
 	fade_random_squares_delay_ = param.fade.random_squares_delay;
@@ -48,15 +48,14 @@ void Fade::init()
 // Resetea algunas variables para volver a hacer el fade sin perder ciertos parametros
 void Fade::reset()
 {
-	enabled_ = false;
+	state_ = FadeState::NOT_ENABLED;
-	finished_ = false;
 	counter_ = 0;
 }
 
 // Pinta una transición en pantalla
 void Fade::render()
 {
-	if (enabled_ || finished_)
+	if (state_ != FadeState::NOT_ENABLED)
 	{
 		SDL_RenderCopy(renderer_, backbuffer_, nullptr, nullptr);
 	}
@@ -65,7 +64,20 @@ void Fade::render()
 // Actualiza las variables internas
 void Fade::update()
 {
-	if (enabled_)
+	if (state_ == FadeState::PRE)
+	{
+		// Actualiza el contador
+		if (pre_counter_ == pre_duration_)
+		{
+			state_ = FadeState::FADING;
+		}
+		else
+		{
+			pre_counter_++;
+		}
+	}
+
+	if (state_ == FadeState::FADING)
 	{
 		switch (type_)
 		{
@@ -79,7 +91,7 @@ void Fade::update()
 			// Comprueba si ha terminado
 			if (counter_ >= 255 / 4)
 			{
-				finished_ = true;
+				state_ = FadeState::POST;
 			}
 
 			break;
@@ -100,6 +112,8 @@ void Fade::update()
 
 				SDL_RenderFillRect(renderer_, &rect1_);
 				SDL_RenderFillRect(renderer_, &rect2_);
+
+				value_ = calculateValue(0, counter_, i);
 			}
 
 			// Deja el renderizador como estaba
@@ -108,7 +122,7 @@ void Fade::update()
 			// Comprueba si ha terminado
 			if ((counter_ * 4) > param.game.height)
 			{
-				finished_ = true;
+				state_ = FadeState::POST;
 				a_ = 255;
 			}
 			break;
@@ -118,10 +132,11 @@ void Fade::update()
 		{
 			if (counter_ % fade_random_squares_delay_ == 0)
 			{
-				// Dibuja sobre el backbuffer_
+				// Cambia el renderizador al backbuffer_ y modifica sus opciones
 				auto temp = SDL_GetRenderTarget(renderer_);
 				SDL_SetRenderTarget(renderer_, backbuffer_);
-
+				SDL_BlendMode blend_mode;
+				SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
 				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
 				SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
 
@@ -133,16 +148,17 @@ void Fade::update()
 					SDL_RenderFillRect(renderer_, &square_[index2]);
 				}
 
-				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
-
 				// Deja el renderizador como estaba
+				SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
 				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_)
 			{
-				finished_ = true;
+				state_ = FadeState::POST;
 			}
 
 			break;
@@ -150,64 +166,88 @@ 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_BlendMode blend_mode;
+				SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
+				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);
 				}
 
 				// Deja el renderizador como estaba
+				SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
 				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
 			{
-				finished_ = true;
+				state_ = FadeState::POST;
 			}
 
 			break;
 		}
+		default:
+			break;
 		}
-
-		if (finished_)
-		{
-			// Actualiza el contador
-			post_counter_ == post_duration_ ? enabled_ = false : post_counter_++;
-
-			// Deja el backbuffer_ todo del mismo color
-			cleanBackbuffer(r_, g_, b_, a_);
-		}
-
 		counter_++;
 	}
+
+	if (state_ == FadeState::POST)
+	{
+		// Actualiza el contador
+		if (post_counter_ == post_duration_)
+		{
+			state_ = FadeState::FINISHED;
+		}
+		else
+		{
+			post_counter_++;
+		}
+
+		// Deja el backbuffer_ todo del mismo color
+		cleanBackbuffer(r_, g_, b_, a_);
+	}
 }
 
 // Activa el fade
 void Fade::activate()
 {
 	// Si ya está habilitado, no hay que volverlo a activar
-	if (enabled_)
+	if (state_ != FadeState::NOT_ENABLED)
 	{
 		return;
 	}
 
-	enabled_ = true;
+	state_ = FadeState::PRE;
-	finished_ = false;
 	counter_ = 0;
 	post_counter_ = 0;
+	pre_counter_ = 0;
 
 	switch (type_)
 	{
@@ -251,12 +291,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 +302,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 +325,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 +333,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 +346,20 @@ 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

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

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();
@@ -205,11 +211,11 @@ private:
 	// Comprueba la colisión entre el jugador y los items
 	void checkPlayerItemCollision(std::shared_ptr<Player> &player);
 
-	// Comprueba la colisión entre las balas y los globos
+	// Comprueba y procesa la colisión de las balas
-	void checkBulletBalloonCollision();
+	void checkBulletCollision();
 
 	// Mueve las balas activas
-	void moveBullets();
+	void updateBullets();
 
 	// Pinta las balas activas
 	void renderBullets();
@@ -304,11 +310,8 @@ private:
 	// Pausa el juego
 	void pause(bool value);
 
-	// Comprueba si la música ha de estar sonando
-	void checkMusicStatus();
-
 	// Añade una puntuación a la tabla de records
-	void addScoreToScoreBoard(const std::string &name, int score);
+	void addScoreToScoreBoard(const std::shared_ptr<Player> &player);
 
 	// Saca del estado de GAME OVER al jugador si el otro está activo
 	void checkAndUpdatePlayerStatus(int active_player_index, int inactive_player_index);
@@ -373,6 +376,9 @@ private:
 	// Reanuda la música
 	void resumeMusic();
 
+	// Hace sonar la música
+	void playMusic();
+
 	// Detiene la música
 	void stopMusic();
 
@@ -382,11 +388,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();
@@ -403,6 +418,9 @@ private:
 	// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
 	void checkAndUpdateBalloonSpeed();
 
+	// Cambia el estado del juego
+	void setState(GameState state);
+
 public:
 	// Constructor
 	Game(int playerID, int current_stage, bool demo);

source/game_logo.cpp

@@ -5,9 +5,15 @@
 #include "jail_audio.h"      // Para JA_PlaySound
 #include "param.h"           // Para Param, param, ParamGame, ParamTitle
 #include "resource.h"        // Para Resource
+#include "screen.h"          // Para Screen
 #include "smart_sprite.h"    // Para SmartSprite
 #include "sprite.h"          // Para Sprite
 #include "texture.h"         // Para Texture
+#include "utils.h"           // Para Color
+
+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

@@ -1,15 +1,16 @@
 #include "global_inputs.h"
-#include <string>  // Para operator+, string
+#include <string>           // Para operator+, string, to_string, basic_string
-#include "input.h" // Para Input, InputType, INPUT_DO_NOT_ALLOW_REPEAT
+#include <vector>           // Para vector
-#include "asset.h"
+#include "asset.h"          // Para Asset
-#include "jail_audio.h"     // Para JA_EnableMusic, JA_EnableSound
+#include "input.h"          // Para Input, InputDeviceToUse, InputType, INPU...
-#include "lang.h"           // Para getText
+#include "jail_audio.h"     // Para JA_SetMusicVolume, JA_SetSoundVolume
+#include "lang.h"           // Para Code, getText, change, loadFromFile
 #include "notifier.h"       // Para Notifier
 #include "on_screen_help.h" // Para OnScreenHelp
-#include "options.h"        // Para Options, OptionsAudio, options, OptionsM...
+#include "options.h"        // Para Options, options, OptionsGame, OptionsAudio
+#include "screen.h"         // Para Screen, ScreenVideoMode
 #include "section.h"        // Para Name, Options, name, options
 #include "utils.h"          // Para boolToOnOff, stringInVector
-#include "screen.h"
 
 namespace globalInputs
 {
@@ -108,6 +109,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 +170,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/global_inputs.h

@@ -1,4 +1,3 @@
-#include <vector>
 namespace globalInputs
 {
     extern int service_pressed_counter;

source/hiscore_table.cpp

@@ -4,22 +4,28 @@
 #include <SDL2/SDL_pixels.h>	  // Para SDL_PIXELFORMAT_RGBA8888
 #include <SDL2/SDL_timer.h>		  // Para SDL_GetTicks
 #include <SDL2/SDL_video.h>		  // Para SDL_WINDOWEVENT_SIZE_CHANGED
+#include <stdlib.h>				  // Para rand
 #include <algorithm>			  // Para max
+#include <functional>			  // Para function
 #include <vector>				  // Para vector
 #include "background.h"			  // Para Background
 #include "fade.h"				  // Para Fade, FadeMode, FadeType
-#include "global_inputs.h"		  // Para check
+#include "global_inputs.h"		  // Para check, update
 #include "input.h"				  // Para Input
 #include "jail_audio.h"			  // Para JA_GetMusicState, JA_Music_state
 #include "lang.h"				  // Para getText
 #include "manage_hiscore_table.h" // Para HiScoreEntry
+#include "mouse.h"				  // Para handleEvent
 #include "options.h"			  // Para Options, OptionsGame, options
 #include "param.h"				  // Para Param, param, ParamGame, ParamFade
+#include "path_sprite.h"		  // Para PathSprite, Path, PathType
 #include "resource.h"			  // Para Resource
 #include "screen.h"				  // Para Screen
-#include "section.h"			  // Para Name, name, Options, options
+#include "section.h"			  // Para Name, name, Options, options, Attr...
-#include "text.h"				  // Para Text, TEXT_CENTER, TEXT_SHADOW
+#include "sprite.h"				  // Para Sprite
-#include "utils.h"				  // Para Color, Zone, fade_color, orange_color
+#include "text.h"				  // Para Text, TEXT_COLOR, TEXT_SHADOW
+#include "texture.h"			  // Para Texture
+#include "utils.h"				  // Para Color, easeOutQuint, fade_color
 
 // Constructor
 HiScoreTable::HiScoreTable()
@@ -27,35 +33,26 @@ HiScoreTable::HiScoreTable()
 	  backbuffer_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
 	  fade_(std::make_unique<Fade>()),
 	  background_(std::make_unique<Background>()),
-	  text_(Resource::get()->getText("smb2")),
 	  counter_(0),
 	  ticks_(0),
 	  view_area_({0, 0, param.game.width, param.game.height}),
-	  fade_mode_(FadeMode::IN)
+	  fade_mode_(FadeMode::IN),
+	  background_fade_color_(Color(0, 0, 0))
 {
-	// Inicializa el resto de variables
+	// Inicializa el resto
 	section::name = section::Name::HI_SCORE_TABLE;
-
-	// Inicializa objetos
 	SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
-	background_->setPos(param.game.game_area.rect);
+	initFade();
-	background_->setCloudsSpeed(-0.1f);
+	initBackground();
-	background_->setGradientNumber(1);
+	iniEntryColors();
-	background_->setTransition(0.8f);
+	createSprites();
-	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
-	fade_->setType(FadeType::RANDOM_SQUARE);
-	fade_->setPost(param.fade.post_duration);
-	fade_->setMode(fade_mode_);
-	fade_->activate();
-
-	// Crea el contenido de la textura con la lista de puntuaciones
-	fillTexture();
 }
 
 // Destructor
 HiScoreTable::~HiScoreTable()
 {
 	SDL_DestroyTexture(backbuffer_);
+	options.game.clear_last_hi_score_entries();
 }
 
 // Actualiza las variables
@@ -74,11 +71,14 @@ void HiScoreTable::update()
 			JA_PlayMusic(Resource::get()->getMusic("title.ogg"));
 		}
 
+		// Actualiza las posiciones de los sprites de texto
+		updateSprites();
+
 		// Actualiza el objeto screen
 		Screen::get()->update();
 
 		// Actualiza las variables de globalInputs
-        globalInputs::update();
+		globalInputs::update();
 
 		// Actualiza el fondo
 		background_->update();
@@ -91,7 +91,7 @@ void HiScoreTable::update()
 
 		if (counter_ == 150)
 		{
-			background_->setColor(Color(0, 0, 0));
+			background_->setColor(background_fade_color_.darken());
 			background_->setAlpha(96);
 		}
 
@@ -99,19 +99,15 @@ void HiScoreTable::update()
 		{
 			fade_->activate();
 		}
+
+		// Dibuja los sprites en la textura
+		fillTexture();
 	}
 }
 
-// Crea el contenido de la textura con la lista de puntuaciones
+// Dibuja los sprites en la textura
 void HiScoreTable::fillTexture()
 {
-	// hay 27 letras - 7 de puntos quedan 20 caracteres 20 - name_lenght 0 num_dots
-	constexpr auto max_names = 10;
-	constexpr auto space_between_header = 32;
-	const auto space_between_lines = text_->getCharacterSize() * 2.0f;
-	const auto size = space_between_header + space_between_lines * (max_names - 1) + text_->getCharacterSize();
-	const auto first_line = (param.game.height - size) / 2;
-
 	// Pinta en el backbuffer el texto y los sprites
 	auto temp = SDL_GetRenderTarget(renderer_);
 	SDL_SetRenderTarget(renderer_, backbuffer_);
@@ -119,22 +115,12 @@ void HiScoreTable::fillTexture()
 	SDL_RenderClear(renderer_);
 
 	// Escribe el texto: Mejores puntuaciones
-	text_->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, first_line, lang::getText(42), 1, orange_color, 1, shdw_txt_color);
+	header_->render();
 
 	// Escribe los nombres de la tabla de puntuaciones
-	for (int i = 0; i < max_names; ++i)
+	for (auto const &entry : entry_names_)
 	{
-		const auto name_lenght = options.game.hi_score_table[i].name.length();
+		entry->render();
-		const auto score = format(options.game.hi_score_table[i].score);
-		const auto score_lenght = score.size();
-		const auto num_dots = 25 - name_lenght - score_lenght;
-		std::string dots;
-		for (int j = 0; j < (int)num_dots; ++j)
-		{
-			dots = dots + ".";
-		}
-		const auto line = options.game.hi_score_table[i].name + dots + score;
-		text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, (i * space_between_lines) + first_line + space_between_header, line, 1, orange_color, 1, shdw_txt_color);
 	}
 
 	// Cambia el destino de renderizado
@@ -163,14 +149,12 @@ void HiScoreTable::render()
 	fade_->render();
 
 	// Vuelca el contenido del renderizador en pantalla
-	Screen::get()->blit();
+	Screen::get()->render();
 }
 
 // Recarga todas las texturas
 void HiScoreTable::reloadTextures()
 {
-	text_->reLoadTexture();
-	fillTexture();
 }
 
 // Comprueba los eventos
@@ -196,6 +180,9 @@ void HiScoreTable::checkEvents()
 				reloadTextures();
 			}
 		}
+
+		// Comprueba el cursor
+		Mouse::handleEvent(event);
 	}
 }
 
@@ -205,9 +192,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;
 	}
 
@@ -267,4 +255,213 @@ std::string HiScoreTable::format(int number)
 	}
 
 	return result;
-}
+}
+
+// Crea los sprites con los textos
+void HiScoreTable::createSprites()
+{
+	auto header_text = Resource::get()->getText("04b_25_grey");
+	auto entry_text = Resource::get()->getText("smb2");
+
+	// Obtiene el tamaño de la textura
+	int backbuffer_width;
+	int backbuffer_height;
+	SDL_QueryTexture(backbuffer_, nullptr, nullptr, &backbuffer_width, &backbuffer_height);
+
+	constexpr int entry_lenght = 22;
+	constexpr int max_names = 10;
+	const int space_between_header = entry_text->getCharacterSize() * 4;
+	const int space_between_lines = entry_text->getCharacterSize() * 2;
+	const int size = space_between_header + space_between_lines * (max_names - 1) + entry_text->getCharacterSize();
+	const int first_line = (param.game.height - size) / 2;
+
+	// Crea el sprite para el texto de cabecera
+	header_ = std::make_unique<Sprite>(header_text->writeDXToTexture(TEXT_COLOR, lang::getText(42), -2, background_fade_color_.getInverse().lighten(25)));
+	header_->setPosition(param.game.game_area.center_x - (header_->getWidth() / 2), first_line);
+
+	// Crea los sprites para las entradas en la tabla de puntuaciones
+	const int animation = rand() % 4;
+	const std::string sample_line(entry_lenght + 3, ' ');
+	auto sample_entry = std::make_unique<Sprite>(entry_text->writeDXToTexture(TEXT_SHADOW, sample_line, 1, orange_color, 1, shdw_txt_color));
+	const auto entry_width = sample_entry->getWidth();
+	for (int i = 0; i < max_names; ++i)
+	{
+		const auto table_position = format(i + 1) + ". ";
+		const auto score = format(options.game.hi_score_table.at(i).score);
+		const auto num_dots = entry_lenght - options.game.hi_score_table.at(i).name.size() - score.size();
+		const auto one_cc = options.game.hi_score_table.at(i).one_credit_complete ? " }" : "";
+		std::string dots;
+		for (int j = 0; j < (int)num_dots; ++j)
+		{
+			dots = dots + ".";
+		}
+		const auto line = table_position + options.game.hi_score_table.at(i).name + dots + score + one_cc;
+
+		entry_names_.emplace_back(std::make_shared<PathSprite>(entry_text->writeDXToTexture(TEXT_SHADOW, line, 1, orange_color, 1, shdw_txt_color)));
+		const int default_pos_x = (backbuffer_width - entry_width) / 2;
+		const int pos_x = (i < 9) ? default_pos_x : default_pos_x - entry_text->getCharacterSize();
+		const int pos_y = (i * space_between_lines) + first_line + space_between_header;
+		constexpr int steps = 80;
+		switch (animation)
+		{
+		case 0: // Ambos lados alternativamente
+		{
+			if (i % 2 == 0)
+			{
+				entry_names_.back()->addPath(-entry_names_.back()->getWidth(), pos_x, PathType::HORIZONTAL, pos_y, steps, easeOutQuint);
+				entry_names_.back()->setPosition(-entry_names_.back()->getWidth(), 0);
+			}
+			else
+			{
+				entry_names_.back()->addPath(backbuffer_width, pos_x, PathType::HORIZONTAL, pos_y, steps, easeOutQuint);
+				entry_names_.back()->setPosition(backbuffer_width, 0);
+			}
+			break;
+		}
+
+		case 1: // Entran por la izquierda
+		{
+			entry_names_.back()->addPath(-entry_names_.back()->getWidth(), pos_x, PathType::HORIZONTAL, pos_y, steps, easeOutQuint);
+			entry_names_.back()->setPosition(-entry_names_.back()->getWidth(), 0);
+			break;
+		}
+
+		case 2: // Entran por la derecha
+		{
+			entry_names_.back()->addPath(backbuffer_width, pos_x, PathType::HORIZONTAL, pos_y, steps, easeOutQuint);
+			entry_names_.back()->setPosition(backbuffer_width, 0);
+			break;
+		}
+
+		case 3: // Entran desde la parte inferior
+		{
+			entry_names_.back()->addPath(backbuffer_height, pos_y, PathType::VERTICAL, pos_x, steps, easeOutQuint);
+			entry_names_.back()->setPosition(0, backbuffer_height);
+		}
+
+		default:
+			break;
+		}
+	}
+}
+
+// Actualiza las posiciones de los sprites de texto
+void HiScoreTable::updateSprites()
+{
+	constexpr int init_counter = 190;
+	const int counter_between_entries = 16;
+	if (counter_ >= init_counter)
+	{
+		const int counter2 = counter_ - init_counter;
+		if (counter2 % counter_between_entries == 0)
+		{
+			int index = counter2 / counter_between_entries;
+			if (index < static_cast<int>(entry_names_.size()))
+			{
+				entry_names_.at(index)->enable();
+			}
+		}
+	}
+	for (auto const &entry : entry_names_)
+	{
+		entry->update();
+	}
+
+	glowEntryNames();
+}
+
+// Inicializa el fade
+void HiScoreTable::initFade()
+{
+	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
+	fade_->setType(FadeType::RANDOM_SQUARE);
+	fade_->setPostDuration(param.fade.post_duration);
+	fade_->setMode(fade_mode_);
+	fade_->activate();
+}
+
+// Inicializa el fondo
+void HiScoreTable::initBackground()
+{
+	background_->setPos(param.game.game_area.rect);
+	background_->setCloudsSpeed(-0.1f);
+
+	const int lucky = rand() % 3;
+	switch (lucky)
+	{
+	case 0: // Fondo verde
+	{
+		background_->setGradientNumber(2);
+		background_->setTransition(0.0f);
+		background_->setSunProgression(1.0f);
+		background_->setMoonProgression(0.0f);
+		background_fade_color_ = green_sky_color;
+		break;
+	}
+
+	case 1: // Fondo naranja
+	{
+		background_->setGradientNumber(1);
+		background_->setTransition(0.0f);
+		background_->setSunProgression(0.65f);
+		background_->setMoonProgression(0.0f);
+		background_fade_color_ = pink_sky_color;
+		break;
+	}
+
+	case 2: // Fondo azul
+	{
+		background_->setGradientNumber(0);
+		background_->setTransition(0.0f);
+		background_->setSunProgression(0.0f);
+		background_->setMoonProgression(0.0f);
+		background_fade_color_ = blue_sky_color;
+		break;
+	}
+
+	default:
+		break;
+	}
+}
+
+// Obtiene un color del vector de colores de entradas
+Color HiScoreTable::getEntryColor(int counter_)
+{
+	int cycle_length = entry_colors_.size() * 2 - 2;
+	size_t n = counter_ % cycle_length;
+
+	size_t index;
+	if (n < entry_colors_.size())
+	{
+		index = n; // Avanza: 0,1,2,3
+	}
+	else
+	{
+		index = 2 * (entry_colors_.size() - 1) - n; // Retrocede: 2,1
+	}
+
+	return entry_colors_[index];
+}
+
+// Inicializa los colores de las entradas
+void HiScoreTable::iniEntryColors()
+{
+	entry_colors_.clear();
+	entry_colors_.emplace_back(background_fade_color_.getInverse().lighten(75));
+	entry_colors_.emplace_back(background_fade_color_.getInverse().lighten(50));
+	entry_colors_.emplace_back(background_fade_color_.getInverse().lighten(25));
+	entry_colors_.emplace_back(background_fade_color_.getInverse());
+}
+
+// Hace brillar los nombres de la tabla de records
+void HiScoreTable::glowEntryNames()
+{
+    const Color entry_color = getEntryColor(counter_ / 5);
+    for (const auto& entry_index : options.game.last_hi_score_entry)
+    {
+        if (entry_index != -1)
+        {
+            entry_names_.at(entry_index)->getTexture()->setColor(entry_color);
+        }
+    }
+}

source/hiscore_table.h

@@ -1,14 +1,18 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>	 // para SDL_Rect
+#include <SDL2/SDL_rect.h>	 // Para SDL_Rect
-#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_render.h> // Para SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h> // para Uint16, Uint32, Uint8
+#include <SDL2/SDL_stdinc.h> // Para Uint16, Uint32, Uint8
-#include <memory>			 // para unique_ptr
+#include <memory>			 // Para unique_ptr, shared_ptr
-#include <string>			 // para string
+#include <string>			 // Para string
-class Background;			 // lines 8-8
+#include <vector>			 // Para vector
-class Fade;					 // lines 9-9
+#include "utils.h"
-class Text;					 // lines 10-10
+class Background; // lines 10-10
-enum class FadeMode : Uint8; // lines 11-11
+class Fade;		  // lines 11-11
+class PathSprite;
+class Sprite;
+enum class FadeMode : Uint8; // lines 13-13
+struct Path;
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de mostrar la tabla con las puntuaciones
@@ -31,15 +35,19 @@ private:
 	SDL_Renderer *renderer_;  // El renderizador de la ventana
 	SDL_Texture *backbuffer_; // Textura para usar como backbuffer
 
-	std::unique_ptr<Fade> fade_;			 // Objeto para renderizar fades
+	std::unique_ptr<Fade> fade_;						   // Objeto para renderizar fades
-	std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego
+	std::unique_ptr<Background> background_;			   // Objeto para dibujar el fondo del juego
-	std::shared_ptr<Text> text_;			 // Objeto para escribir texto
+	std::unique_ptr<Sprite> header_;					   // Sprite con la cabecera del texto
+	std::vector<std::shared_ptr<PathSprite>> entry_names_; // Lista con los spritres de cada uno de los nombres de la tabla de records
+	std::vector<Path> paths_;							   // Vector con los recorridos precalculados
 
 	// Variables
-	Uint16 counter_;	 // Contador
+	Uint16 counter_ = 0;			  // Contador
-	Uint32 ticks_;		 // Contador de ticks para ajustar la velocidad del programa
+	Uint32 ticks_;					  // Contador de ticks para ajustar la velocidad del programa
-	SDL_Rect view_area_; // Parte de la textura que se muestra en pantalla
+	SDL_Rect view_area_;			  // Parte de la textura que se muestra en pantalla
-	FadeMode fade_mode_; // Modo de fade a utilizar
+	FadeMode fade_mode_;			  // Modo de fade a utilizar
+	Color background_fade_color_;	  // Color de atenuación del fondo
+	std::vector<Color> entry_colors_; // Colores para destacar las entradas en la tabla
 
 	// Actualiza las variables
 	void update();
@@ -56,7 +64,7 @@ private:
 	// Convierte un entero a un string con separadores de miles
 	std::string format(int number);
 
-	// Crea el contenido de la textura con la lista de puntuaciones
+	// Dibuja los sprites en la textura
 	void fillTexture();
 
 	// Recarga todas las texturas
@@ -65,6 +73,27 @@ private:
 	// Gestiona el fade
 	void updateFade();
 
+	// Crea los sprites con los textos
+	void createSprites();
+
+	// Actualiza las posiciones de los sprites de texto
+	void updateSprites();
+
+	// Inicializa el fade
+	void initFade();
+
+	// Inicializa el fondo
+	void initBackground();
+
+	// Obtiene un color del vector de colores de entradas
+	Color getEntryColor(int counter_);
+
+	// Inicializa los colores de las entradas
+	void iniEntryColors();
+
+	// Hace brillar los nombres de la tabla de records
+	void glowEntryNames();
+
 public:
 	// Constructor
 	HiScoreTable();

source/input.cpp

@@ -110,9 +110,11 @@ bool Input::checkInput(InputType input, bool repeat, InputDeviceToUse device, in
 	}
 
 	if (gameControllerFound() && controller_index >= 0 && controller_index < num_gamepads_)
+	{
 		if ((device == InputDeviceToUse::CONTROLLER) || (device == InputDeviceToUse::ANY))
 		{
-			success_controller = checkAxisInput(input, controller_index);
+			success_controller = checkAxisInput(input, controller_index, repeat);
+
 			if (!success_controller)
 			{
 				if (repeat)
@@ -144,6 +146,7 @@ bool Input::checkInput(InputType input, bool repeat, InputDeviceToUse device, in
 				}
 			}
 		}
+	}
 
 	return (success_keyboard || success_controller);
 }
@@ -245,7 +248,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)
 	{
@@ -371,19 +382,53 @@ InputType Input::to_inputs_e(const std::string &name) const
 }
 
 // Comprueba el eje del mando
-bool Input::checkAxisInput(InputType input, int controller_index) const
+bool Input::checkAxisInput(InputType input, int controller_index, bool repeat)
 {
+	// Umbral para considerar el eje como activo
+	const Sint16 threshold = 30000;
+	bool axis_active_now = false;
+
 	switch (input)
 	{
 	case InputType::LEFT:
-		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) < -30000;
+		axis_active_now = SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) < -threshold;
+		break;
 	case InputType::RIGHT:
-		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) > 30000;
+		axis_active_now = SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) > threshold;
+		break;
 	case InputType::UP:
-		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) < -30000;
+		axis_active_now = SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) < -threshold;
+		break;
 	case InputType::DOWN:
-		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) > 30000;
+		axis_active_now = SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) > threshold;
+		break;
 	default:
 		return false;
 	}
+
+	// Referencia al binding correspondiente
+	auto &binding = controller_bindings_.at(controller_index).at(static_cast<int>(input));
+
+	if (repeat)
+	{
+		// Si se permite repetir, simplemente devolvemos el estado actual
+		return axis_active_now;
+	}
+	else
+	{
+		// Si no se permite repetir, aplicamos la lógica de transición
+		if (axis_active_now && !binding.axis_active)
+		{
+			// Transición de inactivo a activo
+			binding.axis_active = true;
+			return true;
+		}
+		else if (!axis_active_now && binding.axis_active)
+		{
+			// Transición de activo a inactivo
+			binding.axis_active = false;
+		}
+		// Mantener el estado actual
+		return false;
+	}
 }

source/input.h

@@ -44,6 +44,7 @@ enum class InputType : int
 	SHOWINFO,
 	CONFIG,
 	SWAP_CONTROLLERS,
+	AUTO_FIRE,
 
 	// Input obligatorio
 	NONE,
@@ -80,10 +81,11 @@ private:
 	{
 		SDL_GameControllerButton button; // GameControllerButton asociado
 		bool active;					 // Indica si está activo
+		bool axis_active;				 // Estado del eje
 
 		// Constructor
-		explicit ControllerBindings(SDL_GameControllerButton btn = SDL_CONTROLLER_BUTTON_INVALID, bool act = false)
+		explicit ControllerBindings(SDL_GameControllerButton btn = SDL_CONTROLLER_BUTTON_INVALID, bool act = false, bool axis_act = false)
-			: button(btn), active(act) {}
+			: button(btn), active(act), axis_active(axis_act) {}
 	};
 
 	// Variables
@@ -98,7 +100,7 @@ private:
 	std::string game_controller_db_path_;							   // Ruta al archivo gamecontrollerdb.txt
 
 	// Comprueba el eje del mando
-	bool checkAxisInput(InputType input, int controller_index = 0) const;
+	bool checkAxisInput(InputType input, int controller_index, bool repeat);
 
 	// Constructor
 	explicit Input(const std::string &game_controller_db_path);

source/instructions.cpp

@@ -20,6 +20,11 @@
 #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"
+
+#include <SDL2/SDL.h>
+#include <vector>
+#include <cmath>
 
 // Constructor
 Instructions::Instructions()
@@ -41,10 +46,13 @@ Instructions::Instructions()
 	// Inicializa objetos
 	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
 	fade_->setType(FadeType::FULLSCREEN);
-	fade_->setPost(param.fade.post_duration);
+	fade_->setPostDuration(param.fade.post_duration);
 	fade_->setMode(FadeMode::IN);
 	fade_->activate();
 
+	// Inicializa las líneas con un retraso progresivo de 50 ms
+	lines_ = initializeLines(256);
+
 	// Rellena la textura de texto
 	fillTexture();
 
@@ -158,7 +166,6 @@ void Instructions::fillTexture()
 	text_->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, anchor2, lang::getText(16), 1, orange_color, 1, shdw_txt_color);
 
 	const int anchor3 = anchor2 + space_post_header;
-	// const int anchor4 = anchor3 + ((param.game.item_size + text->getCharacterSize()) / 2);
 	text_->writeShadowed(anchor_item + desp_x, anchor3 + space_between_item_lines * 0, lang::getText(17), shdw_txt_color);
 	text_->writeShadowed(anchor_item + desp_x, anchor3 + space_between_item_lines * 1, lang::getText(18), shdw_txt_color);
 	text_->writeShadowed(anchor_item + desp_x, anchor3 + space_between_item_lines * 2, lang::getText(19), shdw_txt_color);
@@ -217,7 +224,7 @@ void Instructions::update()
 		Screen::get()->update();
 
 		// Actualiza las variables de globalInputs
-        globalInputs::update();
+		globalInputs::update();
 
 		// Incrementa el contador
 		counter_++;
@@ -225,14 +232,36 @@ void Instructions::update()
 		// Actualiza los sprites
 		updateSprites();
 
+		// Establece la ventana del backbuffer
+		view_.y = std::max(0, param.game.height - counter_ + 100);
+
+		// Verifica si view_.y == 0 y gestiona el temporizador
+        if (view_.y == 0)
+        {
+            if (!start_delay_triggered_)
+            {
+                // Activa el temporizador si no ha sido activado
+                start_delay_triggered_ = true;
+                start_delay_time_ = SDL_GetTicks();
+            }
+            else if (SDL_GetTicks() - start_delay_time_ >= 4000)
+            {
+                // Han pasado tres segundos, mover líneas
+                all_lines_off_screen_ = moveLines(lines_, 320, 1.0f, 5);
+            }
+        }
+
 		// Actualiza el mosaico de fondo
 		tiled_bg_->update();
 
 		// Actualiza el objeto "fade"
 		fade_->update();
 
+		// Rellena el backbuffer
+		fillBackbuffer();
+
 		// Comprueba si el contador ha llegado al final
-		if (counter_ == counter_end_)
+		if (all_lines_off_screen_)
 		{
 			section::name = section::Name::TITLE;
 			section::options = section::Options::TITLE_1;
@@ -243,9 +272,6 @@ void Instructions::update()
 // Pinta en pantalla
 void Instructions::render()
 {
-	// Rellena el backbuffer
-	fillBackbuffer();
-
 	// Prepara para empezar a dibujar en la textura de juego
 	Screen::get()->start();
 
@@ -255,16 +281,16 @@ void Instructions::render()
 	// Dibuja el mosacico de fondo
 	tiled_bg_->render();
 
-	// Establece la ventana del backbuffer
-	view_.y = std::max(0, param.game.height - counter_ + 100);
-
 	// Copia la textura y el backbuffer al renderizador
-	SDL_RenderCopy(renderer_, backbuffer_, nullptr, &view_);
+	if (view_.y == 0)
+		renderLines(renderer_, backbuffer_, lines_);
+	else
+		SDL_RenderCopy(renderer_, backbuffer_, nullptr, &view_);
 
 	fade_->render();
 
 	// Vuelca el contenido del renderizador en pantalla
-	Screen::get()->blit();
+	Screen::get()->render();
 }
 
 // Recarga todas las texturas
@@ -301,6 +327,9 @@ void Instructions::checkEvents()
 				reloadTextures();
 			}
 		}
+
+		// Comprueba el cursor
+		Mouse::handleEvent(event);
 	}
 }
 
@@ -310,9 +339,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;
 	}
 
@@ -330,4 +360,61 @@ void Instructions::run()
 		checkEvents(); // Tiene que ir antes del render
 		render();
 	}
+}
+
+// Método para inicializar las líneas
+std::vector<Line> Instructions::initializeLines(int height)
+{
+	std::vector<Line> lines;
+	for (int y = 0; y < height; y++)
+	{
+		int direction = (y % 2 == 0) ? -1 : 1; // Pares a la izquierda, impares a la derecha
+		lines.emplace_back(y, 0.0f, direction);
+	}
+	return lines;
+}
+
+// Método para mover las líneas con suavizado
+bool Instructions::moveLines(std::vector<Line> &lines, int width, float duration, Uint32 startDelay)
+{
+	Uint32 currentTime = SDL_GetTicks();
+	bool allLinesOffScreen = true;
+
+	for (auto &line : lines)
+	{
+		// Establecer startTime en el primer cuadro de animación
+		if (line.startTime == 0)
+		{
+			line.startTime = currentTime + line.y * startDelay;
+		}
+
+		float elapsedTime = (currentTime - line.startTime) / 1000.0f; // Convertir a segundos
+		if (elapsedTime < 0)
+		{
+			allLinesOffScreen = false; // Si aún no se debe mover esta línea, no están todas fuera de pantalla
+			continue;
+		}
+		if (elapsedTime >= duration)
+		{
+			continue; // Si la línea ha salido de los límites, no la muevas más
+		}
+
+		float t = elapsedTime / duration;
+		float smoothFactor = easeInOutQuint(t);
+		line.x = line.direction * smoothFactor * width;
+		allLinesOffScreen = false; // Si alguna línea aún se está moviendo, no están todas fuera de pantalla
+	}
+
+	return allLinesOffScreen;
+}
+
+// Método para renderizar las líneas
+void Instructions::renderLines(SDL_Renderer *renderer, SDL_Texture *texture, const std::vector<Line> &lines)
+{
+	for (const auto &line : lines)
+	{
+		SDL_Rect srcRect = {0, line.y, 320, 1};
+		SDL_Rect dstRect = {static_cast<int>(line.x), line.y, 320, 1};
+		SDL_RenderCopy(renderer, texture, &srcRect, &dstRect);
+	}
 }

source/instructions.h

@@ -24,6 +24,19 @@ class TiledBG;				 // lines 12-12
 	por la pantalla sobre el mosaico de fondo (gestionado por el correspondiente objeto)
 */
 
+// Estructura para almacenar información de línea
+struct Line
+{
+	int y;			  // Coordenada Y de la línea
+	float x;		  // Coordenada X inicial (usamos float para mayor precisión en el suavizado)
+	int direction;	  // Dirección de movimiento: -1 para izquierda, 1 para derecha
+	Uint32 startTime; // Tiempo de inicio del movimiento
+
+	// Constructor de Line
+	Line(int y, float x, int direction)
+		: y(y), x(x), direction(direction), startTime(0) {}
+};
+
 // Clase Instructions
 class Instructions
 {
@@ -40,12 +53,15 @@ private:
 	std::unique_ptr<Fade> fade_;						  // Objeto para renderizar fades
 
 	// Variables
-	int counter_ = 0;				// Contador
+	int counter_ = 0;					 // Contador para manejar el progreso en la pantalla de instrucciones
-	int counter_end_ = 700;			// Valor final para el contador
+	Uint32 ticks_ = 0;					 // Contador de ticks para ajustar la velocidad del programa
-	Uint32 ticks_ = 0;				// Contador de ticks para ajustar la velocidad del programa
+	SDL_Rect view_;						 // Vista del backbuffer que se va a mostrar por pantalla
-	SDL_Rect view_;					// Vista del backbuffer que se va amostrar por pantalla
+	SDL_Point sprite_pos_ = {0, 0};		 // Posición del primer sprite en la lista
-	SDL_Point sprite_pos_ = {0, 0}; // Posición del primer sprite
+	int item_space_ = 2;				 // Espacio entre los items en pantalla
-	int item_space_ = 2;			// Espacio entre los items
+	std::vector<Line> lines_;			 // Vector que contiene las líneas animadas en la pantalla
+	bool all_lines_off_screen_ = false;	 // Indica si todas las líneas han salido de la pantalla
+	Uint32 start_delay_time_ = 0;		 // Tiempo de inicio del retraso para mover las líneas
+	bool start_delay_triggered_ = false; // Bandera para determinar si el retraso ha comenzado
 
 	// Actualiza las variables
 	void update();
@@ -74,6 +90,15 @@ private:
 	// Recarga todas las texturas
 	void reloadTextures();
 
+	// Método para inicializar las líneas
+	std::vector<Line> initializeLines(int height);
+
+	// Método para mover las líneas
+	bool moveLines(std::vector<Line> &lines, int width, float duration, Uint32 startDelay);
+
+	// Método para renderizar las líneas
+	void renderLines(SDL_Renderer *renderer, SDL_Texture *texture, const std::vector<Line> &lines);
+
 public:
 	// Constructor
 	Instructions();

source/intro.cpp

@@ -16,11 +16,12 @@
 #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()
 	: texture_(Resource::get()->getTexture("intro.png")),
-	  text_(Resource::get()->getText("nokia"))
+	  text_(Resource::get()->getText("04b_25_metal"))
 {
 
 	// Inicializa variables
@@ -96,7 +97,7 @@ Intro::Intro()
 		auto w = std::make_unique<Writer>(text_);
 		w->setPosX(BLOCK * 0);
 		w->setPosY(param.game.height - (BLOCK * 6));
-		w->setKerning(-1);
+		w->setKerning(-2);
 		w->setEnabled(false);
 		w->setFinishedCounter(180);
 		texts_.push_back(std::move(w));
@@ -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();
 	}
 }
 
@@ -409,14 +415,13 @@ void Intro::render()
 	}
 
 	// Vuelca el contenido del renderizador en pantalla
-	Screen::get()->blit();
+	Screen::get()->render();
 }
 
 // Bucle principal
 void Intro::run()
 {
 	JA_PlayMusic(Resource::get()->getMusic("intro.ogg"), 0);
-
 	while (section::name == section::Name::INTRO)
 	{
 		checkInput();

source/item.cpp

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

source/item.h

@@ -22,8 +22,9 @@ enum class ItemType : int
     PACMAR = 3,        /**< Pacman */
     CLOCK = 4,         /**< Reloj */
     COFFEE = 5,        /**< Café */
-    COFFEE_MACHINE = 6,/**< Máquina de café */
+    DEBIAN = 6,        /**< Debian */
-    NONE = 7,          /**< Ninguno */
+    COFFEE_MACHINE = 7,/**< Máquina de café */
+    NONE = 8,          /**< Ninguno */
 };
 
 /**

source/jail_audio.cpp

@@ -1,12 +1,13 @@
 #ifndef JA_USESDLMIXER
-
 #include "jail_audio.h"
-#include <stdint.h>     // para uint8_t
+#include <SDL2/SDL_rwops.h> // Para SDL_RWFromMem
-#include <stdio.h>      // para NULL, fseek, fclose, fopen, fread, ftell, FILE
+#include <SDL2/SDL_timer.h> // Para SDL_GetTicks
-#include <stdlib.h>     // para free, malloc
+#include <stdint.h>         // Para uint8_t, uint32_t
-#include "stb_vorbis.c" // para stb_vorbis_decode_memory
+#include <stdio.h>          // Para NULL, fseek, fclose, fopen, fread, ftell
+#include <stdlib.h>         // Para free, malloc
+#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
 {
@@ -25,6 +26,7 @@ struct JA_Channel_t
 struct JA_Music_t
 {
     int samples{0};
+    Uint32 length{0};
     int pos{0};
     int times{0};
     short *output{NULL};
@@ -43,20 +45,43 @@ bool JA_musicEnabled = true;
 bool JA_soundEnabled = true;
 SDL_AudioDeviceID sdlAudioDevice = 0;
 
+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)
     {
-        const int size = SDL_min(len, current_music->samples * 2 - current_music->pos);
+        int volume = JA_musicVolume;
-        SDL_MixAudioFormat(stream, (Uint8 *)(current_music->output + current_music->pos), AUDIO_S16, size, JA_musicVolume);
+        if (fading)
-        current_music->pos += size / 2;
+        {
+            int time = SDL_GetTicks();
+            if (time > (fade_start_time + fade_duration))
+            {
+                fading = false;
+                current_music->pos = 0;
+                current_music->state = JA_MUSIC_STOPPED;
+                volume = 0;
+            }
+            else
+            {
+                const int time_passed = time - fade_start_time;
+                const float percent = (float)time_passed / (float)fade_duration;
+                volume = JA_musicVolume * (1.0 - percent);
+            }
+        }
+        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, JA_musicVolume);
+                SDL_MixAudioFormat(stream + size, (Uint8 *)current_music->output, AUDIO_S16, len - size, volume);
-                current_music->pos = (len - size) / 2;
+                current_music->pos = len - size;
                 if (current_music->times > 0)
                     current_music->times--;
             }
@@ -113,10 +138,36 @@ void JA_Quit()
     sdlAudioDevice = 0;
 }
 
-JA_Music_t *JA_LoadMusic(const char *filename)
+JA_Music_t *JA_LoadMusic(Uint8 *buffer, Uint32 length)
 {
     int chan, samplerate;
+    JA_Music_t *music = new JA_Music_t();
 
+    music->samples = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &music->output);
+    // [RZC 28/08/22] Abans el descomprimiem mentre el teniem obert
+    //    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)
+    {
+        cvt.len = music->samples * chan * 2;
+        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->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);
@@ -127,33 +178,16 @@ JA_Music_t *JA_LoadMusic(const char *filename)
         return NULL;
     fclose(f);
 
-    JA_Music_t *music = new JA_Music_t();
+    JA_Music_t *music = JA_LoadMusic(buffer, fsize);
 
-    music->samples = stb_vorbis_decode_memory(buffer, fsize, &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);
-
-    SDL_AudioCVT cvt;
-    SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq);
-    if (cvt.needed)
-    {
-        cvt.len = music->samples * chan * 2;
-        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->pos = 0;
-    music->state = JA_MUSIC_STOPPED;
 
     return music;
 }
 
 void JA_PlayMusic(JA_Music_t *music, const int loop)
 {
-    if (!JA_musicEnabled || !music)
+    if (!JA_musicEnabled)
         return;
 
     if (current_music != NULL)
@@ -198,6 +232,19 @@ void JA_StopMusic()
     current_music->state = JA_MUSIC_STOPPED;
 }
 
+void JA_FadeOutMusic(const int milliseconds)
+{
+    if (!JA_musicEnabled)
+        return;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
+        return;
+
+    fading = true;
+    fade_start_time = SDL_GetTicks();
+    fade_duration = milliseconds;
+    fade_initial_volume = JA_musicVolume;
+}
+
 JA_Music_state JA_GetMusicState()
 {
     if (!JA_musicEnabled)
@@ -223,6 +270,20 @@ int JA_SetMusicVolume(int 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)
@@ -239,6 +300,25 @@ JA_Sound_t *JA_NewSound(Uint8 *buffer, Uint32 length)
     return sound;
 }
 
+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();
@@ -260,8 +340,8 @@ 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 0;
+        return -1;
 
     int channel = 0;
     while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE)
@@ -278,6 +358,21 @@ int JA_PlaySound(JA_Sound_t *sound, const int loop)
     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;
+    channels[channel].pos = 0;
+    channels[channel].state = JA_CHANNEL_PLAYING;
+    return channel;
+}
+
 void JA_DeleteSound(JA_Sound_t *sound)
 {
     for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)

source/jail_audio.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include <SDL2/SDL_audio.h>  // para SDL_AudioFormat
+#include <SDL2/SDL_audio.h>  // Para SDL_AudioFormat
-#include <SDL2/SDL_stdinc.h> // para Uint32, Uint8
+#include <SDL2/SDL_stdinc.h> // Para Uint32, Uint8
-struct JA_Music_t;           // lines 5-5
+struct JA_Music_t;           // lines 4-4
-struct JA_Sound_t;           // lines 6-6
+struct JA_Sound_t;           // lines 5-5
 
 enum JA_Channel_state
 {
@@ -26,18 +26,24 @@ 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(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_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();
 	}
 }
 
@@ -228,14 +231,14 @@ void Logo::render()
 	}
 
 	// Vuelca el contenido del renderizador en pantalla
-	Screen::get()->blit();
+	Screen::get()->render();
 }
 
 // Bucle para el logo del juego
 void Logo::run()
 {
 	// Detiene la música
-	JA_StopMusic();
+	JA_FadeOutMusic(300);
 
 	while (section::name == section::Name::LOGO)
 	{

source/manage_hiscore_table.cpp

@@ -27,7 +27,7 @@ void ManageHiScoreTable::clear()
 }
 
 // Añade un elemento a la tabla
-void ManageHiScoreTable::add(HiScoreEntry entry)
+int ManageHiScoreTable::add(const HiScoreEntry &entry)
 {
     // Añade la entrada a la tabla
     table_.push_back(entry);
@@ -35,8 +35,32 @@ void ManageHiScoreTable::add(HiScoreEntry entry)
     // Ordena la tabla
     sort();
 
+    // Encontrar la posición del nuevo elemento
+    auto it = std::find_if(table_.begin(), table_.end(), [&](const HiScoreEntry &e)
+                           { return e.name == entry.name &&
+                                    e.score == entry.score &&
+                                    e.one_credit_complete == entry.one_credit_complete; });
+
+    int position = -1;
+    if (it != table_.end())
+    {
+        position = std::distance(table_.begin(), it);
+    }
+
     // Deja solo las 10 primeras entradas
-    table_.resize(10);
+    if (table_.size() > 10)
+    {
+        table_.resize(10);
+
+        // Si el nuevo elemento quedó fuera del top 10
+        if (position >= 10)
+        {
+            position = -1; // No entró en el top 10
+        }
+    }
+
+    // Devuelve la posición
+    return position;
 }
 
 // Ordena la tabla
@@ -50,52 +74,55 @@ void ManageHiScoreTable::sort()
     std::sort(table_.begin(), table_.end(), scoreDescendingComparator);
 }
 
-// Carga la tabla con los datos de un fichero
+// Carga la tabla desde un fichero
 bool ManageHiScoreTable::loadFromFile(const std::string &file_path)
 {
     clear();
     auto success = true;
-    auto file = SDL_RWFromFile(file_path.c_str(), "r+b");
+    auto file = SDL_RWFromFile(file_path.c_str(), "rb");
 
     if (file)
     {
-        std::cout << "Reading file: " << getFileName(file_path) << std::endl;
+        table_.clear(); // Limpia la tabla actual
 
-        for (auto &entry : table_)
+        // Lee el número de entradas en la tabla
+        int tableSize = 0;
+        SDL_RWread(file, &tableSize, sizeof(int), 1);
+
+        // Lee los datos de cada entrada
+        for (int i = 0; i < tableSize; ++i)
         {
+            HiScoreEntry entry;
+
+            // Lee la puntuación
+            SDL_RWread(file, &entry.score, sizeof(int), 1);
+
+            // Lee el tamaño del nombre y luego el nombre
             int nameSize = 0;
-
+            SDL_RWread(file, &nameSize, sizeof(int), 1);
-            if (SDL_RWread(file, &entry.score, sizeof(int), 1) == 0)
-            {
-                success = false;
-                break;
-            }
-
-            if (SDL_RWread(file, &nameSize, sizeof(int), 1) == 0)
-            {
-                success = false;
-                break;
-            }
 
             std::vector<char> nameBuffer(nameSize + 1);
-            if (SDL_RWread(file, nameBuffer.data(), sizeof(char) * nameSize, 1) == 0)
+            SDL_RWread(file, nameBuffer.data(), nameSize, 1);
-            {
+            nameBuffer[nameSize] = '\0'; // Asegurar el fin de la cadena
-                success = false;
-                break;
-            }
-
-            nameBuffer[nameSize] = '\0';
             entry.name = std::string(nameBuffer.data());
+
+            // Lee el valor de one_credit_complete
+            int occValue = 0;
+            SDL_RWread(file, &occValue, sizeof(int), 1);
+            entry.one_credit_complete = (occValue != 0);
+
+            // Añade la entrada a la tabla
+            table_.push_back(entry);
         }
 
+        std::cout << "Reading file: " << getFileName(file_path) << std::endl;
         SDL_RWclose(file);
     }
-
+    else
-    if (!success)
     {
-        clear();
+        std::cout << "Error: Unable to load " << getFileName(file_path) << " file! " << SDL_GetError() << std::endl;
+        success = false;
     }
-
     return success;
 }
 
@@ -107,21 +134,35 @@ bool ManageHiScoreTable::saveToFile(const std::string &file_path)
 
     if (file)
     {
-        // Guarda los datos
+        // Guarda el número de entradas en la tabla
-        for (int i = 0; i < (int)table_.size(); ++i)
+        int tableSize = static_cast<int>(table_.size());
+        SDL_RWwrite(file, &tableSize, sizeof(int), 1);
+
+        // Guarda los datos de cada entrada
+        for (int i = 0; i < tableSize; ++i)
         {
-            SDL_RWwrite(file, &table_.at(i).score, sizeof(int), 1);
+            const HiScoreEntry &entry = table_.at(i);
-            const int nameSize = (int)table_.at(i).name.size();
+
+            // Guarda la puntuación
+            SDL_RWwrite(file, &entry.score, sizeof(int), 1);
+
+            // Guarda el tamaño del nombre y luego el nombre
+            int nameSize = static_cast<int>(entry.name.size());
             SDL_RWwrite(file, &nameSize, sizeof(int), 1);
-            SDL_RWwrite(file, table_.at(i).name.c_str(), nameSize, 1);
+            SDL_RWwrite(file, entry.name.c_str(), nameSize, 1);
+
+            // Guarda el valor de one_credit_complete como un entero (0 o 1)
+            int occValue = entry.one_credit_complete ? 1 : 0;
+            SDL_RWwrite(file, &occValue, sizeof(int), 1);
         }
 
-        std::cout << "Writing file: " << getFileName(file_path).c_str() << std::endl;
+        std::cout << "Writing file: " << getFileName(file_path) << std::endl;
         SDL_RWclose(file);
     }
     else
     {
-        std::cout << "Error: Unable to save " << getFileName(file_path).c_str() << " file! " << SDL_GetError() << std::endl;
+        std::cout << "Error: Unable to save " << getFileName(file_path) << " file! " << SDL_GetError() << std::endl;
+        success = false;
     }
     return success;
 }

source/manage_hiscore_table.h

@@ -14,12 +14,13 @@
 // Estructura para las entradas de la tabla de recirds
 struct HiScoreEntry
 {
-	std::string name; // Nombre
+    std::string name;         // Nombre
-	int score;		  // Puntuación
+    int score;                // Puntuación
+    bool one_credit_complete; // Indica si se ha conseguido 1CC
 
-	// Constructor
+    // Constructor
-	explicit HiScoreEntry(const std::string &n = "", int s = 0)
+    explicit HiScoreEntry(const std::string &n = "", int s = 0, bool occ = false)
-		: name(n), score(s) {}
+        : name(n.substr(0, 6)), score(s), one_credit_complete(occ) {}
 };
 
 // Clase ManageHiScoreTable
@@ -44,7 +45,7 @@ public:
     void clear();
 
     // Añade un elemento a la tabla
-    void add(HiScoreEntry entry);
+    int add(const HiScoreEntry& entry);
 
     // Carga la tabla con los datos de un fichero
     bool loadFromFile(const std::string &file_path);

source/mouse.cpp

@@ -0,0 +1,35 @@
+#include "mouse.h"
+#include <SDL2/SDL_mouse.h> // Para SDL_ShowCursor
+#include <SDL2/SDL_timer.h> // Para SDL_GetTicks
+
+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)
+            {
+#ifndef ARCADE
+                SDL_ShowCursor(SDL_ENABLE);
+#endif
+                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,14 @@
+#pragma once
+
+#include <SDL2/SDL_events.h> // Para SDL_Event
+#include <SDL2/SDL_stdinc.h> // Para Uint32
+
+namespace Mouse
+{
+    extern Uint32 cursor_hide_time;     // Tiempo en milisegundos para ocultar el cursor
+    extern Uint32 last_mouse_move_time; // Última vez que el ratón se movió
+    extern bool cursor_visible;         // Estado del cursor
+
+    void handleEvent(const SDL_Event &event);
+    void updateCursorVisibility();
+}

source/notifier.cpp

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

source/notifier.h

@@ -1,15 +1,14 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>	 // para SDL_Rect
+#include <SDL2/SDL_rect.h>	 // Para SDL_Rect
-#include <SDL2/SDL_render.h> // para SDL_Renderer
+#include <SDL2/SDL_render.h> // Para SDL_Renderer
-#include <memory>			 // para shared_ptr, unique_ptr
+#include <memory>			 // Para shared_ptr
-#include <string>			 // para string, basic_string
+#include <string>			 // Para string, basic_string
-#include <vector>			 // para vector
+#include <vector>			 // Para vector
-#include "utils.h"			 // para Color
+#include "utils.h"			 // Para Color
-class Sprite;
+class Sprite;				 // lines 9-9
-class Text;
+class Text;					 // lines 10-10
-class Texture;
+class Texture;				 // lines 11-11
-struct JA_Sound_t; // lines 12-12
 
 class Notifier
 {
@@ -37,7 +36,7 @@ private:
 		std::shared_ptr<Sprite> sprite;
 		std::vector<std::string> texts;
 		int counter;
-		NotificationStatus status;
+		NotificationStatus state;
 		NotificationShape shape;
 		SDL_Rect rect;
 		int y;
@@ -46,7 +45,7 @@ private:
 
 		// Constructor
 		explicit Notification()
-			: texture(nullptr), sprite(nullptr), texts(), counter(0), status(NotificationStatus::RISING),
+			: texture(nullptr), sprite(nullptr), texts(), counter(0), state(NotificationStatus::RISING),
 			  shape(NotificationShape::SQUARED), rect{0, 0, 0, 0}, y(0), travel_dist(0), code("") {}
 	};
 

source/options.cpp

@@ -44,6 +44,7 @@ void initOptions()
 	options.game.difficulty = GameDifficulty::NORMAL;
 	options.game.language = lang::Code::ba_BA;
 	options.game.autofire = true;
+	options.game.clear_last_hi_score_entries();
 
 	// Opciones de control
 	options.controllers.clear();

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
@@ -63,10 +64,18 @@ struct OptionsAudio
 // Estructura para las opciones del juego
 struct OptionsGame
 {
-	GameDifficulty difficulty;				  // Dificultad del juego
+    GameDifficulty difficulty;                  // Dificultad del juego
-	lang::Code language;					  // Idioma usado en el juego
+    lang::Code language;                        // Idioma usado en el juego
-	bool autofire;							  // Indica si el jugador ha de pulsar repetidamente para disparar o basta con mantener pulsado
+    bool autofire;                              // Indicador de autofire
-	std::vector<HiScoreEntry> hi_score_table; // Tabla con las mejores puntuaciones
+    std::vector<HiScoreEntry> hi_score_table;   // Tabla de mejores puntuaciones
+    std::vector<int> last_hi_score_entry = { -1, -1 }; // Inicialización directa con dos elementos en -1
+
+    // Método para reiniciar las últimas entradas de puntuación
+    void clear_last_hi_score_entries()
+    {
+        last_hi_score_entry[0] = -1;
+        last_hi_score_entry[1] = -1;
+    }
 };
 
 // Estructura para los controles del juego

source/param.cpp

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

source/param.h

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

source/path_sprite.cpp

@@ -1,3 +1,4 @@
+// IWYU pragma: no_include <bits/std_abs.h>
 #include "path_sprite.h"
 #include <cstdlib>	  // Para abs
 #include <functional> // Para function
@@ -95,7 +96,17 @@ void PathSprite::addPath(std::vector<SDL_Point> spots, int waiting_counter)
 // Habilita el objeto
 void PathSprite::enable()
 {
+	if (paths_.size() == 0 || enabled_)
+	{
+		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
@@ -122,9 +133,13 @@ void PathSprite::moveThroughCurrentPath()
 	if (path.on_destination)
 	{
 		if (path.waiting_counter == 0)
+		{
 			path.finished = true;
+		}
 		else
+		{
 			--path.waiting_counter;
+		}
 	}
 }
 
@@ -133,11 +148,15 @@ void PathSprite::goToNextPathOrDie()
 {
 	// Comprueba si ha terminado el recorrdo actual
 	if (paths_.at(current_path_).finished)
+	{
 		++current_path_;
+	}
 
 	// Comprueba si quedan mas recorridos
 	if (current_path_ >= static_cast<int>(paths_.size()))
+	{
 		enabled_ = false;
+	}
 }
 
 // Indica si ha terminado todos los recorridos

source/path_sprite.h

@@ -65,12 +65,15 @@ public:
 
 	// Añade un recorrido
 	void addPath(Path path, bool centered = false);
-	void addPath(std::vector<SDL_Point> spots, int waiting_counter);
+	void addPath(std::vector<SDL_Point> spots, int waiting_counter = 0);
-	void addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction, int waiting_counter);
+	void addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction, int waiting_counter = 0);
 
 	// Habilita el objeto
 	void enable();
 
 	// Indica si ha terminado todos los recorridos
 	bool hasFinished();
+
+	// Getters
+	int getCurrentPath() const { return current_path_; }
 };

source/player.cpp

@@ -8,6 +8,9 @@
 #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"
+#include "stage.h"
 
 // Constructor
 Player::Player(int id, float x, int y, bool demo, SDL_Rect &play_area, std::vector<std::shared_ptr<Texture>> texture, const std::vector<std::vector<std::string>> &animations)
@@ -54,8 +57,8 @@ void Player::init()
 	vel_y_ = 0;
 	score_ = 0;
 	score_multiplier_ = 1.0f;
-	cooldown_ = 10;
+	cool_down_ = 10;
-	enter_name_->init();
+	enter_name_->init(last_enter_name_);
 
 	// Establece la posición del sprite
 	player_sprite_->clear();
@@ -145,6 +148,7 @@ void Player::setInputEnteringName(InputType input)
 		enter_name_->decIndex();
 		break;
 	case InputType::START:
+		last_enter_name_ = getRecordName();
 		break;
 	default:
 		break;
@@ -172,9 +176,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 +197,7 @@ void Player::move()
 				pos_y_ = default_pos_y_;
 				player_sprite_->clear();
 				shiftSprite();
+				playRandomBubbleSound();
 			}
 			else
 			{
@@ -195,12 +205,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 +236,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 +341,7 @@ void Player::setAnimation()
 	{
 	case PlayerState::PLAYING:
 	case PlayerState::ENTERING_NAME_GAME_COMPLETED:
+	case PlayerState::ENTERING_SCREEN:
 	case PlayerState::LEAVING_SCREEN:
 	case PlayerState::CREDITS:
 	{
@@ -347,37 +403,38 @@ void Player::setAnimation()
 // Actualiza el valor de la variable
 void Player::updateCooldown()
 {
-	if (cooldown_ > 0)
+	if (cool_down_ > 0)
 	{
-		cooldown_ -= power_up_ ? 2 : 1;
+		--cool_down_;
+		cooling_state_counter_ = 50;
 	}
 	else
 	{
-		if (!isCooling())
+		if (cooling_state_counter_ > 0)
 		{
-			cooling_status_counter_ = 40;
+			if (cooling_state_counter_ == 40)
-			switch (firing_state_)
 			{
-			case PlayerState::FIRING_LEFT:
+				switch (firing_state_)
-				firing_state_ = PlayerState::COOLING_LEFT;
+				{
-				break;
+				case PlayerState::FIRING_LEFT:
-			case PlayerState::FIRING_RIGHT:
+					setFiringState(PlayerState::COOLING_LEFT);
-				firing_state_ = PlayerState::COOLING_RIGHT;
+					break;
-				break;
+				case PlayerState::FIRING_RIGHT:
-			case PlayerState::FIRING_UP:
+					setFiringState(PlayerState::COOLING_RIGHT);
-				firing_state_ = PlayerState::COOLING_UP;
+					break;
-				break;
+				case PlayerState::FIRING_UP:
-			default:
+					setFiringState(PlayerState::COOLING_UP);
-				break;
+					break;
+				default:
+					break;
+				}
 			}
-		}
+			--cooling_state_counter_;
-		else if (cooling_status_counter_ > 0)
-		{
-			--cooling_status_counter_;
 		}
 		else
 		{
 			setFiringState(PlayerState::FIRING_NONE);
+			cooling_state_counter_ = 0;
 		}
 	}
 }
@@ -393,6 +450,7 @@ void Player::update()
 	updateInvulnerable();
 	updateContinueCounter();
 	updateEnterNameCounter();
+	updateShowingName();
 	updateScoreboard();
 }
 
@@ -418,7 +476,7 @@ void Player::updateScoreboard()
 	case PlayerState::ENTERING_NAME:
 	case PlayerState::ENTERING_NAME_GAME_COMPLETED:
 	{
-		Scoreboard::get()->setRecordName(getScoreBoardPanel(), enter_name_->getName());
+		Scoreboard::get()->setRecordName(getScoreBoardPanel(), enter_name_->getCurrentName());
 		Scoreboard::get()->setSelectorPos(getScoreBoardPanel(), getRecordNamePos());
 		break;
 	}
@@ -448,6 +506,7 @@ void Player::setPlayingState(PlayerState state)
 		init();
 		playing_state_ = PlayerState::PLAYING;
 		setScoreboardMode(ScoreboardMode::SCORE);
+		Stage::power_can_be_added = true;
 		break;
 	}
 	case PlayerState::CONTINUE:
@@ -468,12 +527,19 @@ void Player::setPlayingState(PlayerState state)
 		setScoreboardMode(ScoreboardMode::ENTER_NAME);
 		break;
 	}
+	case PlayerState::SHOWING_NAME:
+	{
+		showing_name_ticks_ = SDL_GetTicks();
+		setScoreboardMode(ScoreboardMode::SHOW_NAME);
+		Scoreboard::get()->setRecordName(scoreboard_panel_, last_enter_name_);
+		break;
+	}
 	case PlayerState::DYING:
 	{
 		// Activa la animación de morir
 		player_sprite_->setAccelY(0.2f);
 		player_sprite_->setVelY(-6.6f);
-		rand() % 2 == 0 ? player_sprite_->setVelX(3.3f) : player_sprite_->setVelX(-3.3f);
+		(rand() % 2 == 0) ? player_sprite_->setVelX(3.3f) : player_sprite_->setVelX(-3.3f);
 		break;
 	}
 	case PlayerState::DIED:
@@ -489,6 +555,7 @@ void Player::setPlayingState(PlayerState state)
 	}
 	case PlayerState::CELEBRATING:
 	{
+		game_completed_ = true;
 		setScoreboardMode(ScoreboardMode::SCORE);
 		break;
 	}
@@ -501,9 +568,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_;
@@ -634,6 +721,19 @@ void Player::updateEnterNameCounter()
 	}
 }
 
+// Actualiza el estado de SHOWING_NAME
+void Player::updateShowingName()
+{
+	if (playing_state_ == PlayerState::SHOWING_NAME)
+	{
+		constexpr int TICKS_SPEED = 5000;
+		if (SDL_GetTicks() - enter_name_ticks_ > TICKS_SPEED)
+		{
+			game_completed_ ? setPlayingState(PlayerState::LEAVING_SCREEN) : setPlayingState(PlayerState::CONTINUE);
+		}
+	}
+}
+
 // Decrementa el contador de continuar
 void Player::decContinueCounter()
 {
@@ -643,6 +743,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 +785,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

@@ -34,12 +34,14 @@ enum class PlayerState
 	CONTINUE,					  // Está con la cuenta atras para continuar
 	WAITING,					  // No está jugando pero puede entrar a jugar
 	ENTERING_NAME,				  // Introduciendo nombre
+	SHOWING_NAME,				  // Mostrando el nombre introducido
 	DYING,						  // El cadaver está volando por ahi
 	DIED,						  // El cadaver ha desaparecido por el fondo
 	GAME_OVER,					  // No está jugando y no puede entrar a jugar
 	CELEBRATING,				  // Poniendo pose de victoria
 	ENTERING_NAME_GAME_COMPLETED, // Poniendo nombre en el tramo final del juego
 	LEAVING_SCREEN,				  // Moviendose fuera de la pantalla
+	ENTERING_SCREEN,			  // Entando a la pantalla
 	CREDITS,					  // Estado para los creditos del juego
 };
 
@@ -68,8 +70,8 @@ private:
 	int default_pos_y_;										// Posición inicial para el jugador
 	float vel_x_ = 0.0f;									// Cantidad de pixeles a desplazarse en el eje X
 	int vel_y_ = 0.0f;										// Cantidad de pixeles a desplazarse en el eje Y
-	int cooldown_ = 0;										// Contador durante el cual no puede disparar
+	int cool_down_ = 0;										// Contador durante el cual no puede disparar
-	int cooling_status_counter_ = 0;						// Contador para la animación del estado cooling
+	int cooling_state_counter_ = 0;							// Contador para la animación del estado cooling
 	int score_ = 0;											// Puntos del jugador
 	float score_multiplier_ = 1.0f;							// Multiplicador de puntos
 	PlayerState walking_state_ = PlayerState::WALKING_STOP; // Estado del jugador al moverse
@@ -91,6 +93,11 @@ 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
+	Uint32 showing_name_ticks_ = 0;							// Tiempo en el que se entra al estado SHOWING_NAME
+	int step_counter_ = 0;									// Cuenta los pasos para los estados en los que camina automáticamente
+	bool game_completed_ = false;							// Indica si ha completado el juego
+	int credits_used_ = 1;									// Indica el numero de veces que ha continuado
+	std::string last_enter_name_;							// Ultimo nombre introducido en la tabla de puntuaciones
 
 	// Actualiza el circulo de colisión a la posición del jugador
 	void shiftColliders();
@@ -107,6 +114,9 @@ private:
 	// Actualiza el contador de entrar nombre
 	void updateEnterNameCounter();
 
+	// Actualiza el estado de SHOWING_NAME
+	void updateShowingName();
+
 	// Decrementa el contador de entrar nombre
 	void decEnterNameCounter();
 
@@ -116,6 +126,10 @@ private:
 	// Cambia el modo del marcador
 	void setScoreboardMode(ScoreboardMode mode);
 
+	// Hace sonar un ruido al azar
+	void playRandomBubbleSound();
+
+	// Getters
 	bool isRenderable() const { return !isWaiting() && !isGameOver(); }
 
 public:
@@ -201,10 +215,10 @@ public:
 	bool isWaiting() const { return playing_state_ == PlayerState::WAITING; }
 
 	// Getters
-	bool canFire() const { return cooldown_ > 0 ? false : true; }
+	bool canFire() const { return cool_down_ > 0 ? false : true; }
 	bool hasExtraHit() const { return extra_hit_; }
-	bool isCooling() { return firing_state_ == PlayerState::COOLING_LEFT || firing_state_ == PlayerState::COOLING_UP || firing_state_ == PlayerState::COOLING_RIGHT; }
+	bool isCooling() const { return firing_state_ == PlayerState::COOLING_LEFT || firing_state_ == PlayerState::COOLING_UP || firing_state_ == PlayerState::COOLING_RIGHT; }
-	bool IsEligibleForHighScore() { return score_ > options.game.hi_score_table.back().score; }
+	bool IsEligibleForHighScore() const { return score_ > options.game.hi_score_table.back().score; }
 	bool isInvulnerable() const { return invulnerable_; }
 	bool isPowerUp() const { return power_up_; }
 	Circle &getCollider() { return collider_; }
@@ -218,16 +232,18 @@ public:
 	int getPosX() const { return static_cast<int>(pos_x_); }
 	int getPosY() const { return pos_y_; }
 	int getPowerUpCounter() const { return power_up_counter_; }
-	std::string getRecordName() const { return enter_name_->getName(); }
+	std::string getRecordName() const { return enter_name_->getFinalName(); }
 	int getScore() const { return score_; }
 	int getScoreBoardPanel() const { return scoreboard_panel_; }
 	int getWidth() const { return WIDTH_; }
 	PlayerState getPlayingState() const { return playing_state_; }
 	std::string getName() const { return name_; }
+	bool get1CC() const { return game_completed_ && credits_used_ == 1; }
+	bool getEnterNamePositionOverflow() const { return enter_name_->getPositionOverflow(); }
 
 	// Setters
 	void setController(int index) { controller_index_ = index; }
-	void setFireCooldown(int time) { cooldown_ = time; }
+	void setFireCooldown(int time) { cool_down_ = time; }
 	void setFiringState(PlayerState state) { firing_state_ = state; }
 	void setInvulnerableCounter(int value) { invulnerable_counter_ = value; }
 	void setName(const std::string &name) { name_ = name; }
@@ -236,4 +252,5 @@ public:
 	void setScoreBoardPanel(int panel) { scoreboard_panel_ = panel; }
 	void setScoreMultiplier(float value) { score_multiplier_ = value; }
 	void setWalkingState(PlayerState state) { walking_state_ = state; }
+	void addCredit() { ++credits_used_; }
 };

source/resource.cpp

@@ -254,14 +254,14 @@ void Resource::addPalettes()
 {
     // Jugador 1
     std::cout << "\n>> PALETTES" << std::endl;
-    getTexture("player1.gif")->addPaletteFromFile(Asset::get()->get("player1_one_coffee_palette.pal"));
+    getTexture("player1.gif")->addPaletteFromFile(Asset::get()->get("player1_1_coffee_palette.gif"));
-    getTexture("player1.gif")->addPaletteFromFile(Asset::get()->get("player1_two_coffee_palette.pal"));
+    getTexture("player1.gif")->addPaletteFromFile(Asset::get()->get("player1_2_coffee_palette.gif"));
-    getTexture("player1.gif")->addPaletteFromFile(Asset::get()->get("player1_all_white_palette.pal"));
+    getTexture("player1.gif")->addPaletteFromFile(Asset::get()->get("player1_invencible_palette.gif"));
 
     // Jugador 2
-    getTexture("player2.gif")->addPaletteFromFile(Asset::get()->get("player2_one_coffee_palette.pal"));
+    getTexture("player2.gif")->addPaletteFromFile(Asset::get()->get("player2_1_coffee_palette.gif"));
-    getTexture("player2.gif")->addPaletteFromFile(Asset::get()->get("player2_two_coffee_palette.pal"));
+    getTexture("player2.gif")->addPaletteFromFile(Asset::get()->get("player2_2_coffee_palette.gif"));
-    getTexture("player2.gif")->addPaletteFromFile(Asset::get()->get("player2_all_white_palette.pal"));
+    getTexture("player2.gif")->addPaletteFromFile(Asset::get()->get("player2_invencible_palette.gif"));
 
     // Fuentes
     getTexture("smb2.gif")->addPaletteFromFile(Asset::get()->get("smb2_palette1.pal"));
@@ -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,11 @@ void Resource::createTextures()
 
     // Tamaño doble
     std::vector<NameAndText> strings2X = {
-        NameAndText("get_ready", lang::getText(75)),
+        NameAndText("game_text_100000_points", "100.000"),
-        NameAndText("last_stage", lang::getText(79)),
+        NameAndText("game_text_get_ready", lang::getText(75)),
-        NameAndText("congratulations", lang::getText(50)),
+        NameAndText("game_text_last_stage", lang::getText(79)),
-        NameAndText("game_over", "Game Over")};
+        NameAndText("game_text_congratulations", lang::getText(50)),
+        NameAndText("game_text_game_over", "Game Over")};
 
     auto text2 = getText("04b_25_2x");
     for (const auto &s : strings2X)
@@ -314,22 +315,35 @@ void Resource::createTextures()
     }
 }
 
-// Crea los objetos de texto
 void Resource::createText()
 {
+    struct ResourceInfo
+    {
+        std::string key;         // Identificador del recurso
+        std::string textureFile; // Nombre del archivo de textura
+        std::string textFile;    // Nombre del archivo de texto
+
+        // Constructor para facilitar la creación de objetos ResourceInfo
+        ResourceInfo(const std::string &k, const std::string &tFile, const std::string &txtFile)
+            : key(k), textureFile(tFile), textFile(txtFile) {}
+    };
+
     std::cout << "\n>> CREATING TEXT_OBJECTS" << std::endl;
 
-    std::vector<std::pair<std::string, std::string>> resources = {
+    std::vector<ResourceInfo> resources = {
-        {"04b_25", "04b_25.png"},
+        {"04b_25", "04b_25.png", "04b_25.txt"},
-        {"04b_25_2x", "04b_25_2x.png"},
+        {"04b_25_2x", "04b_25_2x.png", "04b_25_2x.txt"},
-        {"8bithud", "8bithud.png"},
+        {"04b_25_metal", "04b_25_metal.png", "04b_25.txt"},
-        {"nokia", "nokia.png"},
+        {"04b_25_grey", "04b_25_grey.png", "04b_25.txt"},
-        {"smb2", "smb2.gif"}};
+        {"8bithud", "8bithud.png", "8bithud.txt"},
+        {"smb2", "smb2.gif", "smb2.txt"}};
 
     for (const auto &resource : resources)
     {
-        texts_.emplace_back(ResourceText(resource.first, std::make_shared<Text>(getTexture(resource.second), getTextFile(resource.first + ".txt"))));
+        texts_.emplace_back(ResourceText(resource.key, std::make_shared<Text>(
-        printWithDots("Text : ", resource.first, "[  DONE  ]");
+                                                           getTexture(resource.textureFile),
+                                                           getTextFile(resource.textFile))));
+        printWithDots("Text : ", resource.key, "[  DONE  ]");
     }
 }
 

source/scoreboard.cpp

@@ -10,7 +10,8 @@
 #include "screen.h"				// Para Screen
 #include "sprite.h"				// Para Sprite
 #include "text.h"				// Para Text
-#include "enter_name.h"
+#include "enter_name.h"			// Para NAME_LENGHT
+#include <iostream>
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Scoreboard *Scoreboard::scoreboard_ = nullptr;
@@ -68,6 +69,9 @@ Scoreboard::Scoreboard()
 
 	// Rellena la textura de fondo
 	fillBackgroundTexture();
+
+	// Inicializa el vector de colores para el nombre
+	iniNameColors();
 }
 
 Scoreboard::~Scoreboard()
@@ -86,23 +90,23 @@ Scoreboard::~Scoreboard()
 	}
 }
 
-// Transforma un valor numérico en una cadena de 6 cifras
+// Transforma un valor numérico en una cadena de 7 cifras
 std::string Scoreboard::updateScoreText(int num)
 {
 	std::ostringstream oss;
-	oss << std::setw(8) << std::setfill('0') << num;
+	oss << std::setw(7) << std::setfill('0') << num;
 	return oss.str();
 }
 
 // Actualiza el contador
-void Scoreboard::updateCounter()
+void Scoreboard::updateTimeCounter()
 {
 	constexpr int TICKS_SPEED = 100;
 
 	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		ticks_ = SDL_GetTicks();
-		counter_++;
+		++time_counter_;
 	}
 }
 
@@ -110,7 +114,8 @@ void Scoreboard::updateCounter()
 void Scoreboard::update()
 {
 	fillBackgroundTexture();
-	updateCounter();
+	updateTimeCounter();
+	++loop_counter_;
 }
 
 // Pinta el marcador
@@ -150,7 +155,7 @@ void Scoreboard::fillPanelTextures()
 	// Guarda a donde apunta actualmente el renderizador
 	auto temp = SDL_GetRenderTarget(renderer_);
 
-	// Genera el contenidoi de cada panel_
+	// Genera el contenido de cada panel_
 	for (size_t i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
 	{
 		// Cambia el destino del renderizador
@@ -180,7 +185,7 @@ void Scoreboard::fillPanelTextures()
 			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(101));
 
 			// PRESS START TO PLAY
-			if (counter_ % 10 < 8)
+			if (time_counter_ % 10 < 8)
 			{
 				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(103));
 				text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(104));
@@ -194,7 +199,7 @@ void Scoreboard::fillPanelTextures()
 			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(102));
 
 			// PRESS START TO PLAY
-			if (counter_ % 10 < 8)
+			if (time_counter_ % 10 < 8)
 			{
 				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(103));
 				text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(104));
@@ -208,7 +213,7 @@ void Scoreboard::fillPanelTextures()
 			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(102));
 
 			// PLEASE WAIT
-			if (counter_ % 10 < 8)
+			if (time_counter_ % 10 < 8)
 			{
 				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(114));
 				text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(115));
@@ -253,27 +258,54 @@ void Scoreboard::fillPanelTextures()
 			text_scoreboard_->writeCentered(slot4_2_.x, slot4_2_.y, updateScoreText(score_[i]));
 
 			// ENTER NAME
-			text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(106));
-			SDL_Rect rect = {enter_name_pos_.x, enter_name_pos_.y, 5, 7};
-			SDL_SetRenderDrawColor(renderer_, 0xFF, 0xFF, 0xEB, 255);
-			for (size_t j = 0; j < record_name_[i].size(); ++j)
 			{
-				if (j != selector_pos_[i] || counter_ % 3 == 0)
+				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(106));
+				SDL_Rect rect = {enter_name_pos_.x, enter_name_pos_.y, 5, 7};
+
+				// Recorre todos los slots de letras del nombre
+				for (size_t j = 0; j < NAME_LENGHT; ++j)
 				{
-					SDL_RenderDrawLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
+					// Selecciona el color
-					text_scoreboard_->write(rect.x, rect.y, record_name_[i].substr(j, 1));
+					const Color color = j < selector_pos_[i] ? orange_soft_color.lighten() : Color(0xFF, 0xFF, 0xEB);
+
+					if (j != selector_pos_[i] || time_counter_ % 3 == 0)
+					{
+						// Dibuja la linea
+						if (j >= selector_pos_[i])
+						{
+							SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 255);
+							SDL_RenderDrawLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
+						}
+
+						// Dibuja la letra
+						if (j < record_name_->size())
+						{
+							text_scoreboard_->writeColored(rect.x, rect.y, record_name_[i].substr(j, 1), color);
+						}
+					}
+					rect.x += 7;
 				}
-				rect.x += 7;
 			}
 			break;
 		}
+		case ScoreboardMode::SHOW_NAME:
+		{
+			// SCORE
+			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, name_[i]);
+			text_scoreboard_->writeCentered(slot4_2_.x, slot4_2_.y, updateScoreText(score_[i]));
+
+			// NAME
+			text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(106));
+			text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_4_.x, slot4_4_.y, record_name_[i], 1, getColorLikeKnightRider(name_colors_, loop_counter_ / 5));
+			break;
+		}
 		case ScoreboardMode::GAME_COMPLETED:
 		{
 			// GAME OVER
 			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(102));
 
 			// SCORE
-			if (counter_ % 10 < 8)
+			if (time_counter_ % 10 < 8)
 			{
 				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(120));
 				text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, updateScoreText(score_[i]));
@@ -319,27 +351,27 @@ void Scoreboard::fillBackgroundTexture()
 void Scoreboard::recalculateAnchors()
 {
 	// Recalcula la posición y el tamaño de los paneles
-	const float panelWidth = (float)rect_.w / (float)SCOREBOARD_MAX_PANELS;
+	const float panel_width = (float)rect_.w / (float)SCOREBOARD_MAX_PANELS;
 	for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
 	{
-		panel_[i].pos.x = roundf(panelWidth * i);
+		panel_[i].pos.x = roundf(panel_width * i);
 		panel_[i].pos.y = 0;
-		panel_[i].pos.w = roundf(panelWidth * (i + 1)) - panel_[i].pos.x;
+		panel_[i].pos.w = roundf(panel_width * (i + 1)) - panel_[i].pos.x;
 		panel_[i].pos.h = rect_.h;
 	}
 
 	// Constantes para definir las zonas del panel_: 4 filas y 1 columna
-	const int rowSize = rect_.h / 4;
+	const int row_size = rect_.h / 4;
-	const int textHeight = 7;
+	const int text_height = 7;
 
 	// Filas
-	const int row1 = (rowSize * 0) + (textHeight / 2);
+	const int row1 = (row_size * 0) + (text_height / 2);
-	const int row2 = (rowSize * 1) + (textHeight / 2) - 1;
+	const int row2 = (row_size * 1) + (text_height / 2) - 1;
-	const int row3 = (rowSize * 2) + (textHeight / 2) - 2;
+	const int row3 = (row_size * 2) + (text_height / 2) - 2;
-	const int row4 = (rowSize * 3) + (textHeight / 2) - 3;
+	const int row4 = (row_size * 3) + (text_height / 2) - 3;
 
 	// Columna
-	const int col = panelWidth / 2;
+	const int col = panel_width / 2;
 
 	// Slots de 4
 	slot4_1_ = {col, row1};
@@ -348,8 +380,8 @@ void Scoreboard::recalculateAnchors()
 	slot4_4_ = {col, row4};
 
 	// Primer cuadrado para poner el nombre de record
-	const int enterNameLenght = NAME_LENGHT * 7;
+	const int enter_name_lenght = text_scoreboard_->lenght(std::string(NAME_LENGHT, 'A'));
-	enter_name_pos_.x = (panelWidth - enterNameLenght) / 2;
+	enter_name_pos_.x = col - (enter_name_lenght / 2);
 	enter_name_pos_.y = row4;
 
 	// Recoloca los sprites
@@ -402,4 +434,14 @@ void Scoreboard::renderSeparator()
 	// Dibuja la linea que separa el marcador de la zona de juego
 	SDL_SetRenderDrawColor(renderer_, separator_color.r, separator_color.g, separator_color.b, 255);
 	SDL_RenderDrawLine(renderer_, 0, 0, rect_.w, 0);
+}
+
+// Inicializa el vector de colores para el nombre
+void Scoreboard::iniNameColors()
+{
+	name_colors_.clear();
+	name_colors_.emplace_back(green_color.lighten(50));
+	name_colors_.emplace_back(green_color.lighten(25));
+	name_colors_.emplace_back(green_color);
+	name_colors_.emplace_back(green_color.darken(25));
 }

source/scoreboard.h

@@ -29,6 +29,7 @@ enum class ScoreboardMode : int
 	GAME_OVER,
 	DEMO,
 	ENTER_NAME,
+	SHOW_NAME,
 	GAME_COMPLETED,
 	NUM_MODES,
 };
@@ -72,7 +73,9 @@ private:
 	Color color_ = Color();								  // Color del marcador
 	SDL_Rect rect_ = {0, 0, 320, 40};					  // Posición y dimensiones del marcador
 	Uint32 ticks_ = SDL_GetTicks();						  // Variable donde almacenar el valor de SDL_GetTiks()
-	int counter_ = 0;									  // Contador
+	int time_counter_ = 0;								  // Contador de segundos
+	int loop_counter_ = 0;								  // Contador de bucle
+	std::vector<Color> name_colors_;					  // Colores para destacar el nombre una vez introducido
 
 	// Puntos predefinidos para colocar elementos en los paneles
 	SDL_Point slot4_1_, slot4_2_, slot4_3_, slot4_4_;
@@ -81,7 +84,7 @@ private:
 	// Recalcula las anclas de los elementos
 	void recalculateAnchors();
 
-	// Transforma un valor numérico en una cadena de 6 cifras
+	// Transforma un valor numérico en una cadena de 7 cifras
 	std::string updateScoreText(int num);
 
 	// Crea la textura de fondo
@@ -97,11 +100,14 @@ private:
 	void fillBackgroundTexture();
 
 	// Actualiza el contador
-	void updateCounter();
+	void updateTimeCounter();
 
 	// Dibuja la linea que separa la zona de juego del marcador
 	void renderSeparator();
 
+	// Inicializa el vector de colores para el nombre
+	void iniNameColors();
+
 	// [SINGLETON] Ahora el constructor y el destructor son privados
 
 	// Constructor

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
@@ -45,7 +46,6 @@ Screen::Screen(SDL_Window *window, SDL_Renderer *renderer)
     : window_(window),
       renderer_(renderer),
       game_canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
-      shader_canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
       src_rect_({0, 0, param.game.width, param.game.height}),
       dst_rect_({0, 0, param.game.width, param.game.height})
 {
@@ -65,7 +65,6 @@ Screen::Screen(SDL_Window *window, SDL_Renderer *renderer)
 Screen::~Screen()
 {
     SDL_DestroyTexture(game_canvas_);
-    SDL_DestroyTexture(shader_canvas_);
 }
 
 // Limpia la pantalla
@@ -82,68 +81,44 @@ void Screen::start()
 }
 
 // Vuelca el contenido del renderizador en pantalla
-void Screen::blit()
+void Screen::render()
 {
     // Actualiza el contador de FPS
-    fps_counter_++;
+    ++fps_counter_;
 
-    // Actualiza y dibuja el efecto de flash en la pantalla
+    // Dibuja efectos y elementos sobre el game_canvas_
     renderFlash();
-
-    // Atenua la pantalla
     renderAttenuate();
-
+    renderShake();
-    // Muestra la ayuda por pantalla
     OnScreenHelp::get()->render();
-
-    // Muestra información por pantalla
     renderInfo();
-
-    // Muestra las notificaciones
     Notifier::get()->render();
 
-#ifdef NO_SHADERS
+    // Renderiza el contenido del game_canvas_
-    // Vuelve a dejar el renderizador en modo normal
+    renderScreen();
+}
+
+// Renderiza el contenido del game_canvas_
+void Screen::renderScreen()
+{
+    // Restablece el objetivo de renderizado al buffer de pantalla predeterminado
     SDL_SetRenderTarget(renderer_, nullptr);
+    clean();
 
-    // Borra el contenido previo
+#ifdef NO_SHADERS
-    SDL_SetRenderDrawColor(renderer_, border_color_.r, border_color_.g, border_color_.b, 0xFF);
+    // Actualiza la pantalla con el contenido del buffer de renderizado
-    SDL_RenderClear(renderer_);
+    SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
-
-    // Copia la textura de juego en el renderizador en la posición adecuada
-    if (shake_effect_.enabled)
-        SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
-    SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
-
-    // Muestra por pantalla el renderizador
     SDL_RenderPresent(renderer_);
 #else
     if (options.video.shaders)
     {
-        SDL_SetRenderTarget(renderer_, shader_canvas_);
+        // Aplica shaders y renderiza el contenido
-        SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
-        SDL_RenderClear(renderer_);
-        if (shake_effect_.enabled)
-            SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
-        SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
-        SDL_SetRenderTarget(renderer_, nullptr);
         shader::render();
     }
     else
     {
-        // Vuelve a dejar el renderizador en modo normal
+        // Actualiza la pantalla con el contenido del buffer de renderizado
-        SDL_SetRenderTarget(renderer_, nullptr);
+        SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
-
-        // Borra el render
-        SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
-        SDL_RenderClear(renderer_);
-
-        // Copia la textura de juego en el renderizador en la posición adecuada
-        if (shake_effect_.enabled)
-            SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr); // Esta copia es para evitar que se vea negro por los laterales
-        SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
-
-        // Muestra por pantalla el renderizador
         SDL_RenderPresent(renderer_);
     }
 #endif
@@ -204,7 +179,7 @@ void Screen::setVideoMode(ScreenVideoMode videoMode)
         std::ifstream f(Asset::get()->get(glsl_file).c_str());
         std::string source((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
 
-        shader::init(window_, shader_canvas_, source.c_str());
+        shader::init(window_, game_canvas_, source.c_str());
 #endif
     }
 }
@@ -235,7 +210,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 +234,7 @@ void Screen::update()
     Notifier::get()->update();
     updateFPS();
     OnScreenHelp::get()->update();
+    Mouse::updateCursorVisibility();
 }
 
 // Agita la pantalla
@@ -308,15 +284,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 +302,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
@@ -342,6 +315,33 @@ void Screen::renderAttenuate()
     }
 }
 
+// Aplica el efecto de agitar la pantalla
+void Screen::renderShake()
+{
+    if (shake_effect_.enabled)
+    {
+        // Guarda el renderizador actual para dejarlo despues como estaba
+        auto current_target = SDL_GetRenderTarget(renderer_);
+
+        // Crea una textura temporal
+        auto temp_texture = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
+
+        // Vuelca game_canvas_ a la textura temporal
+        SDL_SetRenderTarget(renderer_, temp_texture);
+        SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
+
+        // Vuelca textura temporal a game_canvas_
+        SDL_SetRenderTarget(renderer_, game_canvas_);
+        SDL_RenderCopy(renderer_, temp_texture, &src_rect_, &dst_rect_);
+
+        // Elimina la textura temporal
+        SDL_DestroyTexture(temp_texture);
+
+        // Restaura el renderizador de destino original
+        SDL_SetRenderTarget(renderer_, current_target);
+    }
+}
+
 // Activa / desactiva los shaders
 void Screen::toggleShaders()
 {
@@ -394,7 +394,9 @@ void Screen::renderInfo()
 
         // Contador de service_pressed_counter
         if (const int counter = globalInputs::service_pressed_counter; counter > 0)
+        {
             dbg_print(0, 8, std::to_string(counter).c_str(), 255, 0, 255);
+        }
     }
 }