Actualitzada la data de la versió

debug: opció de no crear mes globos

.gitignore

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

CMakeLists.txt

@@ -0,0 +1,85 @@
+# CMakeLists.txt
+
+cmake_minimum_required(VERSION 3.10)
+project(coffee_crisis_arcade_edition VERSION 0.01)
+
+# Configuración de compilador para MinGW en Windows, si es necesario
+if(WIN32 AND NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+    set(CMAKE_CXX_COMPILER "g++")
+    set(CMAKE_C_COMPILER "gcc")
+endif()
+
+# Establecer estándar de C++
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+# Configuración global de flags de compilación
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Os -ffunction-sections -fdata-sections")
+
+# Define el directorio de los archivos fuente
+set(DIR_SOURCES "${CMAKE_SOURCE_DIR}/source")
+
+# Cargar todos los archivos fuente en DIR_SOURCES
+file(GLOB SOURCES "${DIR_SOURCES}/*.cpp")
+
+# Verificar si se encontraron archivos fuente
+if(NOT SOURCES)
+    message(FATAL_ERROR "No se encontraron archivos fuente en ${DIR_SOURCES}. Verifica que el directorio existe y contiene archivos .cpp.")
+endif()
+
+# Configuración de SDL2
+find_package(SDL2 REQUIRED)
+if(SDL2_FOUND)
+    message(STATUS "SDL2 encontrado: ${SDL2_INCLUDE_DIRS}")
+    include_directories(${SDL2_INCLUDE_DIRS})
+    link_directories(${SDL2_LIBDIR})
+else()
+    message(FATAL_ERROR "SDL2 no encontrado")
+endif()
+
+# Incluye rutas de SDL2 obtenidas con pkg-config
+include_directories(/usr/local/include /usr/local/include/SDL2)
+link_directories(/usr/local/lib)
+
+# Definir las bibliotecas comunes
+set(LIBS SDL2)
+
+# Configuración común de salida de ejecutables en el directorio raíz
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR})
+
+# Añadir ejecutable principal
+add_executable(${PROJECT_NAME} ${SOURCES})
+
+# Añadir definiciones de compilación dependiendo del tipo de build
+target_compile_definitions(${PROJECT_NAME} PRIVATE $<$<CONFIG:DEBUG>:DEBUG VERBOSE>)
+
+# Enlazar bibliotecas
+target_link_libraries(${PROJECT_NAME} ${LIBS})
+
+# Configuración específica para cada plataforma
+if(WIN32)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE WINDOWS_BUILD)
+    target_link_libraries(${PROJECT_NAME} mingw32 opengl32 gdi32 winmm imm32 ole32 version)
+elseif(APPLE)
+    set(LIBS ${LIBS} "-framework OpenGL")
+    target_compile_definitions(${PROJECT_NAME} PRIVATE MACOS_BUILD)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated")
+    # Configurar compilación para Apple Silicon
+    set(CMAKE_OSX_ARCHITECTURES "arm64")
+elseif(UNIX AND NOT APPLE)
+    set(LIBS ${LIBS} GL)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE LINUX_BUILD)
+    target_link_libraries(${PROJECT_NAME} ${LIBS})
+endif()
+
+# Añadir OpenGL a las bibliotecas enlazadas
+if(NOT WIN32)
+    find_package(OpenGL REQUIRED)
+    if(OPENGL_FOUND)
+        message(STATUS "OpenGL encontrado: ${OPENGL_LIBRARIES}")
+        target_link_libraries(${PROJECT_NAME} ${OPENGL_LIBRARIES})
+    else()
+        message(FATAL_ERROR "OpenGL no encontrado")
+    endif()
+endif()

Makefile

@@ -1,136 +1,63 @@
 # Directorios
-DIR_ROOT   := $(dir $(abspath $(MAKEFILE_LIST)))
-DIR_SOURCES:= $(addsuffix /, $(DIR_ROOT)source)
-DIR_BIN    := $(addsuffix /, $(DIR_ROOT))
-DIR_BUILD  := $(addsuffix /, $(DIR_ROOT)build)
+DIR_ROOT       := $(dir $(abspath $(MAKEFILE_LIST)))
+DIR_SOURCES    := $(addsuffix /, $(DIR_ROOT)source)
+DIR_BIN        := $(addsuffix /, $(DIR_ROOT))
+DIR_BUILD      := $(addsuffix /, $(DIR_ROOT)build)
 
 # Variables
-TARGET_NAME   := coffee_crisis_arcade_edition
-TARGET_FILE   := $(DIR_BIN)$(TARGET_NAME)
-APP_NAME      := Coffee Crisis Arcade Edition
-RELEASE_FOLDER:= ccae_release
-RELEASE_FILE  := $(RELEASE_FOLDER)/$(TARGET_NAME)
-VERSION       := v0.01
+TARGET_NAME    := coffee_crisis_arcade_edition
+TARGET_FILE    := $(DIR_BIN)$(TARGET_NAME)
+APP_NAME       := Coffee Crisis Arcade Edition
+RELEASE_FOLDER := ccae_release
+RELEASE_FILE   := $(RELEASE_FOLDER)/$(TARGET_NAME)
+RESOURCE_FILE  := release/coffee.res
+VERSION        := 2025-01-05
 
 # Nombres para los ficheros de lanzamiento
-WINDOWS_RELEASE            := $(TARGET_FILE)-$(VERSION)-win32-x64.zip
-MACOS_INTEL_RELEASE        := $(TARGET_FILE)-$(VERSION)-macos-intel.dmg
-MACOS_APPLE_SILICON_RELEASE:= $(TARGET_FILE)-$(VERSION)-macos-apple-silicon.dmg
-LINUX_RELEASE              := $(TARGET_FILE)-$(VERSION)-linux.tar.gz
+WINDOWS_RELEASE             := $(TARGET_NAME)-$(VERSION)-win32-x64.zip
+MACOS_INTEL_RELEASE         := $(TARGET_FILE)-$(VERSION)-macos-intel.dmg
+MACOS_APPLE_SILICON_RELEASE := $(TARGET_FILE)-$(VERSION)-macos-apple-silicon.dmg
+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)
-	SOURCES := source/*.cpp
-	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
-	LDFLAGS := -lmingw32 -lws2_32 -lSDL2main -lSDL2 -lopengl32
-	RM = del /Q
-	MKD:= mkdir
+    FixPath         = $(subst /,\\,$1)
+    SOURCES         := source/*.cpp
+    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
+    LDFLAGS         := -lmingw32 -lws2_32 -lSDL2main -lSDL2 -lopengl32
+    RM              := del /Q
+    MKDIR           := mkdir
 else
-    FixPath = $1
-	SOURCES := $(shell find $(DIR_SOURCES) -name '*.cpp')
-	SOURCES := source/*.cpp
-	CXXFLAGS:= -std=c++20 -Wall -Os -ffunction-sections -fdata-sections
-	CXXFLAGS_DEBUG:= -std=c++20 -Wall -g
-	LDFLAGS := -lSDL2
-	RM = rm -f
-	MKD:= mkdir -p
-	UNAME_S := $(shell uname -s)
+    FixPath         = $1
+    SOURCES         := $(shell find $(DIR_SOURCES) -name '*.cpp')
+    SOURCES         := source/*.cpp
+    CXXFLAGS        := -std=c++20 -Wall -Os -ffunction-sections -fdata-sections
+    CXXFLAGS_DEBUG  := -std=c++20 -Wall -g
+    LDFLAGS         := -lSDL2
+    RMFILE          := rm -f
+	RMDIR			:= rm -rdf
+    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_DEBUG += -Wno-deprecated
-        LDFLAGS += -framework OpenGL
+        CXXFLAGS       += -Wno-deprecated
+        CXXFLAGS_DEBUG += -Wno-deprecated
+        LDFLAGS        += -framework OpenGL
     endif
 endif
 
-OBJECTS     := $(subst $(DIR_SOURCES), $(DIR_BUILD), $(SOURCES))
-OBJECTS     := $(OBJECTS:.cpp=.o)
-DEPENDENCIES:= $(OBJECTS:.o=.d)
-
-
-###############################################################################
-#                                                                             #
-#     RULES                                                                   #
-#                                                                             #
-###############################################################################
-
-.PHONY: all a1
-
-all: a1
-
-a1: $(TARGET_FILE)
-
-$(TARGET_FILE): $(OBJECTS)
-	$(MKD) $(@D)
-	$(CXX) $(OBJECTS) $(LDFLAGS) -o $(TARGET_FILE)
-
-$(DIR_BUILD)%.o: $(DIR_SOURCES)%.cpp
-	$(MKD) $(@D)
-	$(CXX) -c $< $(CXXFLAGS) $(INCLUDES) -o $@
-
--include $(DEPENDENCIES)
-
-###############################################################################
-#                                                                             #
-#     CLEAN                                                                   #
-#                                                                             #
-###############################################################################
-
-.PHONY: clean
-
-clean:
-	$(RM) $(call FixPath,$(DIR_BUILD))
-
-###############################################################################
-#                                                                             #
-#     PRINT-VARIABLES                                                         #
-#                                                                             #
-###############################################################################
-
-.PHONY: print-variables
-
-print-variables:
-	@echo MAKEFILE_LIST: $(MAKEFILE_LIST)
-	
-	@echo "DIR_ROOT  :" $(DIR_ROOT)
-	@echo "DIR_SOURCES:" $(DIR_SOURCES)
-	@echo "DIR_BIN   :" $(DIR_BIN)
-	@echo "DIR_BUILD :" $(DIR_BUILD)
-
-	@echo "DIR_IMGUI     :" $(DIR_IMGUI)
-	@echo "DIR_IMGUI_SFML:" $(DIR_IMGUI_SFML)
-	@echo "INCLUDES      :" $(INCLUDES)
-
-	@echo CXX: $(CXX)
-	@echo CXXFLAGS: $(CXXFLAGS)
-	@echo LDFLAGS: $(LDFLAGS)
-
-	@echo SOURCES: $(SOURCES)
-	@echo OBJECTS: $(OBJECTS)
-	@echo DEPENDENCIES: $(DEPENDENCIES)
-
-	@echo TARGET_NAME: $(TARGET_NAME)
-	@echo TARGET_FILE: $(TARGET_FILE)
-
-	@echo RM: $(RM)
-
-raspi:
-	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(TARGET_FILE)
-	strip -s -R .comment -R .gnu.version $(TARGET_FILE) --strip-unneeded
-
-raspi_debug:
-	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE -D DEBUG $(CXXFLAGS_DEBUG) $(LDFLAGS) -o "$(TARGET_FILE)_debug"
-
+# 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:
@@ -157,12 +84,13 @@ windows_release:
 	powershell Copy-Item "release\*.dll" -Destination "$(RELEASE_FOLDER)"
 
 # Compila
-	$(CXX) $(SOURCES) $(CXXFLAGS) $(LDFLAGS) -o "$(RELEASE_FILE).exe"
-	strip -s -R .comment -R .gnu.version "$(RELEASE_FOLDER)/$(TARGET_FILE).exe" --strip-unneeded
+	windres release/coffee.rc -O coff -o $(RESOURCE_FILE)
+	$(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 Compress-Archive -Path "$(RELEASE_FOLDER)"/* -DestinationPath $(WINDOWS_RELEASE)
+	powershell if (Test-Path "$(WINDOWS_RELEASE)") {Remove-Item "$(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}
@@ -175,17 +103,17 @@ macos_debug:
 
 macos_release:
 # Elimina datos de compilaciones anteriores
-	rm -rdf "$(RELEASE_FOLDER)"
-	rm -rdf Frameworks
-	rm -f tmp.dmg
-	rm -f "$(MACOS_INTEL_RELEASE)"
-	rm -f "$(MACOS_APPLE_SILICON_RELEASE)"
+	$(RMDIR) "$(RELEASE_FOLDER)"
+	$(RMDIR) Frameworks
+	$(RMFILE) tmp.dmg
+	$(RMFILE) "$(MACOS_INTEL_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 -p "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS"
-	mkdir -p "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
-	mkdir -p Frameworks
+	$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks"
+	$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS"
+	$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
+	$(MKDIR) Frameworks
 
 # Copia carpetas y ficheros
 	cp -R data "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
@@ -200,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
-	$(RM) "$(RELEASE_FOLDER)"
+	$(RMDIR) Frameworks
+	$(RMDIR) "$(RELEASE_FOLDER)"
 
 linux:
 	$(CXX) $(SOURCES) $(CXXFLAGS) $(LDFLAGS) -o "$(TARGET_FILE)"
@@ -228,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)"
@@ -243,22 +171,51 @@ linux_release:
 	strip -s -R .comment -R .gnu.version "$(RELEASE_FILE)" --strip-unneeded
 
 # Empaqueta ficheros
-	$(RM) "$(LINUX_RELEASE)"
-	cd "$(RELEASE_FOLDER)" && tar -czvf "../$(LINUX_RELEASE)" *
+	$(RMFILE) "$(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)
+	strip -s -R .comment -R .gnu.version $(TARGET_FILE) --strip-unneeded
+
+raspi_debug:
+	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE -D DEBUG $(CXXFLAGS_DEBUG) $(LDFLAGS) -o "$(TARGET_FILE)_debug"
+
+raspi_release:
+# Elimina carpetas previas
+	$(RMDIR) "$(RELEASE_FOLDER)"
+
+# Crea la carpeta temporal para realizar el lanzamiento
+	$(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
-	$(RM) "$(RELEASE_FOLDER)"_anbernic
+	$(RMDIR) "$(RELEASE_FOLDER)"_anbernic
 
 # Crea la carpeta temporal para realizar el lanzamiento
-	mkdir -p "$(RELEASE_FOLDER)"_anbernic
+	$(MKDIR) "$(RELEASE_FOLDER)"_anbernic
 
 # Copia ficheros
 	cp -R data "$(RELEASE_FOLDER)"_anbernic
 
-# Complia
-	$(CXX) $(SOURCES) -D ANBERNIC -D NO_SHADERS -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(RELEASE_FOLDER)_anbernic/$(TARGET_NAME)
-	$(CXX) $(SOURCES) -D ANBERNIC -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(RELEASE_FOLDER)_anbernic/$(TARGET_NAME).shaders
+# Compila
+	$(CXX) $(SOURCES) -D ANBERNIC -D NO_SHADERS -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(RELEASE_FOLDER)_anbernic/$(TARGET_NAME)

README.md

@@ -1,67 +1,72 @@
-# Coffee Crisis
+# Coffee Crisis Arcade Edition
 
-Coffee Crisis es un juego arcade que pondrá a prueba tus reflejos. Empezado durante el verano de 2020 y terminado un año despues, en el verano de 2021. Intenta conseguir todos los puntos que puedas con una sola vida a traves de los 10 niveles de juego y ayuda a Bal1 a defender la UPV de la invasión de la cafeína esférica y saltarina.
+**¡La batalla definitiva pel cafè està ací!**
 
-![alt text](https://php.sustancia.synology.me/images/cc1.png)
+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:
 
-## Teclado
-El juego se maneja con teclado, aunque tambien se puede conectar un mando de control.
-Las teclas son las siguientes:
+- **Mode multijugador** per a dues persones.
+- **Nous gràfics** que revitalitzen l'experiència arcade clàssica.
+- **Moltes sorpreses** per descobrir en cada partida.
 
-* **Cursores**: Mover al personaje, moverse por los menus
-* **Q, W, E**: Disparar a la izquierda, al centro y a la derecha respectivamente
-* **ESCAPE**: Pone en pausa el juego durante la partida. Sale de los menus. Cierra el juego
-* **ENTER**: Acepta las opciones en los menus
+Defensa el teu cafè contra les bambolles gegants en aquest trepidant joc d'arcade! 🍵
 
-![alt text](https://php.sustancia.synology.me/images/cc2.png)
+<p align="center">
+    <img src="https://php.sustancia.synology.me/images/ccae_title.png" alt="Títol" />
+</p>
 
-## Compilar
+## Controls
 
-Para compilar el código se necesitan tener las librerías SDL instaladas en el sistema y el compilador g++.
+El joc està optimitzat per a ser jugat amb un mando de jocs, encara que un dels jugadors pot utilitzar el teclat.
 
-En Linux:
-```bash
-sudo apt install libsdl2-dev g++
-```
+### Controls del teclat:
+- **Fletxes**: Mou al personatge.
+- **Q, W, E**: Disparar a l'esquerra, al centre i a la dreta, respectivament.
 
-En macOS se pueden instalar fácilmente con [brew](https://brew.sh):
-```bash
-brew install sdl2 g++
-```
+> Nota: El joc suporta nomes un jugador amb teclat.
 
-Una vez instaladas las librerías SDL, se puede compilar utilizando el fichero Makefile suministrado.
+<p align="center">
+    <img src="https://php.sustancia.synology.me/images/ccae1.png" alt="Joc" />
+</p>
 
-En Linux:
-```bash
-make linux
-```
+## Altres tecles
 
-En macOS:
-```bash
-make macos
-```
-![alt text](https://php.sustancia.synology.me/images/cc3.png)
+| Tecla       | Funció                                       |
+|-------------|----------------------------------------------|
+| **ESC**     | Tancar el joc                                |
+| **F1**      | Fa la finestra més xicoteta                 |
+| **F2**      | Fa la finestra més gran                     |
+| **F3**      | Alterna entre mode de pantalla completa i finestra |
+| **F4**      | Activa o desactiva els shaders              |
+| **F5**      | Activa o desactiva l'àudio                 |
+| **F6**      | Activa o desactiva el dispar automàtic      |
+| **F7**      | Canvia l'idioma del joc i reinicia         |
+| **F10**     | Reset del joc                               |
 
-## Como ejecutar
+<p align="center">
+    <img src="https://php.sustancia.synology.me/images/ccae2.png" alt="Joc" />
+</p>
 
-Para ejecutar el juego hay que escribir en la terminal la orden que se muestra a continuación.
+## Com instal·lar i jugar
 
-En Linux:
-```bash
-./coffee_crisis_linux
-```
+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!
 
-En macOS:
-```bash
-./coffee_crisis_macos
-```
+## Agraïments
 
-En macOS tambien puedes hacer doble click sobre el archivo coffee_crisis_macos
+Vull expressar la meua gratitud a **ChatGPT** i **GitHub Copilot**. Gràcies per ser un suport constant en el desenvolupament d'aquest joc!
 
-## Agradecimientos
-A los jailers y a la jail. Y entre ellos, a JailDoctor por estar siempre ahí apoyándonos/obligándonos a sacar un Jailgame más.
+També vull agrair a tots els jugadors que fan que aquest projecte valgui la pena. 🕹️❤️
 
-Y por supuesto a ti por estar aquí.
+## 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.
 
-## Licencia
-Usa el código para lo que quieras: aprender, reirte, curiosear... excepto para sacar beneficio económico. Si lo consigues, por favor avísame y vamos a medias.

data/config/param_320x240.txt

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

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

data/font/04b_25_2x.txt

@@ -1,43 +1,43 @@
 # box width
-16
+28
 # box height
-16
+28
 # 32 espacio ( )
 16
 # 33 !
-16
+10
 # 34 "
 16
-# 35 #
-16
+# 35 
+20
 # 36 $
-16
+20
 # 37 %
-16
+18
 # 38 &
-16
+22
 # 39 '
-16
+10
 # 40 (
-16
+14
 # 41 )
-16
+14
 # 42 *
-16
+14
 # 43 +
-16
+18
 # 44 ,
-16
+10
 # 45 -
-16
+18
 # 46 .
-16
+10
 # 47 /
-16
+24
 # 48 0
 16
 # 49 1
-16
+12
 # 50 2
 16
 # 51 3
@@ -55,9 +55,9 @@
 # 57 9
 16
 # 58 :
-16
+10
 # 59 ;
-16
+10
 # 60 <
 16
 # 61 =
@@ -67,7 +67,7 @@
 # 63 ?
 16
 # 64 @
-16
+22
 # 65 A
 16
 # 66 B
@@ -85,7 +85,7 @@
 # 72 H
 16
 # 73 I
-16
+10
 # 74 J
 16
 # 75 K
@@ -93,7 +93,7 @@
 # 76 L
 16
 # 77 M
-16
+22
 # 78 N
 16
 # 79 O
@@ -107,13 +107,13 @@
 # 83 S
 16
 # 84 T
-16
+18
 # 85 U
 16
 # 86 V
 16
 # 87 W
-16
+22
 # 88 X
 16
 # 89 Y
@@ -121,17 +121,17 @@
 # 90 Z
 16
 # 91 [
-16
+14
 # 92 \
-16
+22
 # 93 ]
-16
+14
 # 94 ^
-16
+12
 # 95 _
-16
+14
 # 96 `
-16
+12
 # 97 a
 16
 # 98 b
@@ -149,7 +149,7 @@
 # 104 h
 16
 # 105 i
-16
+10
 # 106 j
 16
 # 107 k
@@ -157,7 +157,7 @@
 # 108 l
 16
 # 109 m
-16
+22
 # 110 n
 16
 # 111 o
@@ -171,13 +171,13 @@
 # 115 s
 16
 # 116 t
-16
+18
 # 117 u
 16
 # 118 v
 16
 # 119 w
-16
+22
 # 120 x
 16
 # 121 y
@@ -185,10 +185,10 @@
 # 122 z
 16
 # 123 {
-16
+2
 # 124 |
-16
+2
 # 125 }
-16
+2
 # 126 ~
-16
+2

data/font/nokia_big2.txt

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

data/gfx/balloon/powerball.ani

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

data/gfx/player/player.ani

@@ -23,29 +23,71 @@ frames=8,9,10,11
 [/animation]
 
 [animation]
-name=stand-sideshoot
+name=walk-sideshoot-cooldown
 speed=5
 loop=0
 frames=12,13,14,15
 [/animation]
 
 [animation]
-name=walk-centershoot
+name=stand-sideshoot
 speed=5
 loop=0
 frames=16,17,18,19
 [/animation]
 
 [animation]
-name=stand-centershoot
+name=stand-sideshoot-cooldown
+speed=5
+loop=0
+frames=15
+[/animation]
+
+[animation]
+name=walk-centershoot
 speed=5
 loop=0
 frames=20,21,22,23
 [/animation]
 
 [animation]
-name=death
-speed=15
+name=walk-centershoot-cooldown
+speed=5
 loop=0
 frames=24,25,26,27
+[/animation]
+
+[animation]
+name=stand-centershoot
+speed=5
+loop=0
+frames=28,29,30,31
+[/animation]
+
+[animation]
+name=stand-centershoot-cooldown
+speed=5
+loop=0
+frames=27
+[/animation]
+
+[animation]
+name=dying
+speed=10
+loop=0
+frames=32,33,34,35
+[/animation]
+
+[animation]
+name=dead
+speed=3
+loop=0
+frames=44,45,46,47,48,49,50
+[/animation]
+
+[animation]
+name=celebration
+speed=10
+loop=-1
+frames=36,36,36,36,36,36,37,38,39,40,40,40,40,40,40,39,39,39,40,40,40,39,39,39,38,37,36,36,36
 [/animation]

data/gfx/tabe/tabe.ani

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

data/lang/ba_BA.txt

@@ -158,19 +158,19 @@ Felicitats!!
 2 JUGADORS
 
 ## 53 MARCADOR
-jugador 1
+Jugador 1
 
 ## 54 MARCADOR
-jugador 2
+Jugador 2
 
 ## 55 MARCADOR
-mult
+Multiplicador
 
 ## 56 MARCADOR
-max. puntuacio
+Max. puntuacio
 
 ## 57 MARCADOR
-fase 
+Fase 
 
 ## 58 - MENU DE OPCIONES
 MODE DE VISUALITZACIO
@@ -206,7 +206,7 @@ NORMAL
 DIFICIL
 
 ## 69 - MENU DE OPCIONES
-TECLAT
+Teclat
 
 ## 70 - MENU DE OPCIONES
 MANDO
@@ -347,4 +347,28 @@ Per favor
 espere
 
 ## 116 - NOTIFICACIONES
-Torna a polsar per apagar el sistema
+Torna a polsar per apagar el sistema
+
+## 117 - GAME TEXT
+SuperPoder!
+
+## 118 - GAME TEXT
++1 Colp
+
+## 119 - GAME TEXT
+Temps!
+
+## 120 - SCOREBOARD
+Puntuacio
+
+## 121 - CREDITS
+PROGRAMAT I DISSENYAT PER
+
+## 122 - CREDITS
+GRAFICS DIBUIXATS PER
+
+## 123 - CREDITS
+MUSICA COMPOSADA PER
+
+## 124 - CREDITS
+EFECTES DE SO

data/lang/en_UK.txt

@@ -158,19 +158,19 @@ Congratulations!!
 2 PLAYERS
 
 ## 53 - MARCADOR
-player 1
+Player 1
 
 ## 54 - MARCADOR
-player 2
+Player 2
 
 ## 55 - MARCADOR
-mult
+Multiplier
 
 ## 56 - MARCADOR
-high score
+High Score
 
 ## 57 - MARCADOR
-stage 
+Stage 
 
 ## 58 - MENU DE OPCIONES
 DISPLAY MODE
@@ -206,7 +206,7 @@ NORMAL
 HARD
 
 ## 69 - MENU DE OPCIONES
-KEYBOARD
+Keyboard
 
 ## 70 - MENU DE OPCIONES
 GAME CONTROLLER
@@ -347,4 +347,28 @@ Please
 wait
 
 ## 116 - NOTIFICACIONES
-Press again to shutdown system
+Press again to shutdown system
+
+## 117 - GAME TEXT
+PowerUp
+
+## 118 - GAME TEXT
++1 Hit
+
+## 119 - GAME TEXT
+Stop!
+
+## 120 - SCOREBOARD
+Score
+
+## 121 - CREDITS
+PROGRAMMED AND DESIGNED BY
+
+## 122 - CREDITS
+PIXELART DRAWN BY
+
+## 123 - CREDITS
+MUSIC COMPOSED BY
+
+## 124 - CREDITS
+SOUND EFFECTS

data/lang/es_ES.txt

@@ -158,19 +158,19 @@ Felicidades!!
 2 JUGADORES
 
 ## 53 - MARCADOR
-jugador 1
+Jugador 1
 
 ## 54 - MARCADOR
-jugador 2
+Jugador 2
 
 ## 55 - MARCADOR
-mult
+Multiplicador
 
 ## 56 - MARCADOR
-max. puntuacion
+Max. puntuacion
 
 ## 57 - MARCADOR
-FASE 
+Fase 
 
 ## 58 - MENU DE OPCIONES
 MODO DE VISUALIZACION
@@ -206,7 +206,7 @@ NORMAL
 DIFICIL
 
 ## 69 - MENU DE OPCIONES
-TECLADO
+Teclado
 
 ## 70 - MENU DE OPCIONES
 MANDO
@@ -347,4 +347,28 @@ Por favor
 espere
 
 ## 94 - NOTIFICACIONES
-Pulsa otra vez para apagar el sistema
+Pulsa otra vez para apagar el sistema
+
+## 117 - GAME TEXT
+Potenciador
+
+## 118 - GAME TEXT
++1 Golpe
+
+## 119 - GAME TEXT
+Tiempo!
+
+## 120 - SCOREBOARD
+Puntuacion
+
+## 121 - CREDITS
+PROGRAMADO Y DISE{ADO POR
+
+## 122 - CREDITS
+GRAFICOS DIBUJADOS POR
+
+## 123 - CREDITS
+MUSICA COMPUESTA POR
+
+## 124 - CREDITS
+EFECTOS DE SONIDO

data/shaders/crtpi_240.glsl

@@ -0,0 +1,234 @@
+/*
+    crt-pi - A Raspberry Pi friendly CRT shader.
+
+    Copyright (C) 2015-2016 davej
+
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the Free
+    Software Foundation; either version 2 of the License, or (at your option)
+    any later version.
+
+
+Notes:
+
+This shader is designed to work well on Raspberry Pi GPUs (i.e. 1080P @ 60Hz on a game with a 4:3 aspect ratio). It pushes the Pi's GPU hard and enabling some features will slow it down so that it is no longer able to match 1080P @ 60Hz. You will need to overclock your Pi to the fastest setting in raspi-config to get the best results from this shader: 'Pi2' for Pi2 and 'Turbo' for original Pi and Pi Zero. Note: Pi2s are slower at running the shader than other Pis, this seems to be down to Pi2s lower maximum memory speed. Pi2s don't quite manage 1080P @ 60Hz - they drop about 1 in 1000 frames. You probably won't notice this, but if you do, try enabling FAKE_GAMMA.
+
+SCANLINES enables scanlines. You'll almost certainly want to use it with MULTISAMPLE to reduce moire effects. SCANLINE_WEIGHT defines how wide scanlines are (it is an inverse value so a higher number = thinner lines). SCANLINE_GAP_BRIGHTNESS defines how dark the gaps between the scan lines are. Darker gaps between scan lines make moire effects more likely.
+
+GAMMA enables gamma correction using the values in INPUT_GAMMA and OUTPUT_GAMMA. FAKE_GAMMA causes it to ignore the values in INPUT_GAMMA and OUTPUT_GAMMA and approximate gamma correction in a way which is faster than true gamma whilst still looking better than having none. You must have GAMMA defined to enable FAKE_GAMMA.
+
+CURVATURE distorts the screen by CURVATURE_X and CURVATURE_Y. Curvature slows things down a lot.
+
+By default the shader uses linear blending horizontally. If you find this too blury, enable SHARPER.
+
+BLOOM_FACTOR controls the increase in width for bright scanlines.
+
+MASK_TYPE defines what, if any, shadow mask to use. MASK_BRIGHTNESS defines how much the mask type darkens the screen.
+
+*/
+
+#pragma parameter CURVATURE_X "Screen curvature - horizontal" 0.10 0.0 1.0 0.01
+#pragma parameter CURVATURE_Y "Screen curvature - vertical" 0.15 0.0 1.0 0.01
+#pragma parameter MASK_BRIGHTNESS "Mask brightness" 0.70 0.0 1.0 0.01
+#pragma parameter SCANLINE_WEIGHT "Scanline weight" 6.0 0.0 15.0 0.1
+#pragma parameter SCANLINE_GAP_BRIGHTNESS "Scanline gap brightness" 0.12 0.0 1.0 0.01
+#pragma parameter BLOOM_FACTOR "Bloom factor" 1.5 0.0 5.0 0.01
+#pragma parameter INPUT_GAMMA "Input gamma" 2.4 0.0 5.0 0.01
+#pragma parameter OUTPUT_GAMMA "Output gamma" 2.2 0.0 5.0 0.01
+
+// Haven't put these as parameters as it would slow the code down.
+#define SCANLINES
+#define MULTISAMPLE
+#define GAMMA
+//#define FAKE_GAMMA
+//#define CURVATURE
+//#define SHARPER
+// MASK_TYPE: 0 = none, 1 = green/magenta, 2 = trinitron(ish)
+#define MASK_TYPE 2
+
+
+#ifdef GL_ES
+#define COMPAT_PRECISION mediump
+precision mediump float;
+#else
+#define COMPAT_PRECISION
+#endif
+
+#ifdef PARAMETER_UNIFORM
+uniform COMPAT_PRECISION float CURVATURE_X;
+uniform COMPAT_PRECISION float CURVATURE_Y;
+uniform COMPAT_PRECISION float MASK_BRIGHTNESS;
+uniform COMPAT_PRECISION float SCANLINE_WEIGHT;
+uniform COMPAT_PRECISION float SCANLINE_GAP_BRIGHTNESS;
+uniform COMPAT_PRECISION float BLOOM_FACTOR;
+uniform COMPAT_PRECISION float INPUT_GAMMA;
+uniform COMPAT_PRECISION float OUTPUT_GAMMA;
+#else
+#define CURVATURE_X 0.05
+#define CURVATURE_Y 0.1
+#define MASK_BRIGHTNESS 0.80
+#define SCANLINE_WEIGHT 6.0
+#define SCANLINE_GAP_BRIGHTNESS 0.12
+#define BLOOM_FACTOR 3.5
+#define INPUT_GAMMA 2.4
+#define OUTPUT_GAMMA 2.2
+#endif
+
+/* COMPATIBILITY
+   - GLSL compilers
+*/
+
+//uniform vec2 TextureSize;
+#if defined(CURVATURE)
+varying vec2 screenScale;
+#endif
+varying vec2 TEX0;
+varying float filterWidth;
+
+#if defined(VERTEX)
+//uniform mat4 MVPMatrix;
+//attribute vec4 VertexCoord;
+//attribute vec2 TexCoord;
+//uniform vec2 InputSize;
+//uniform vec2 OutputSize;
+
+void main()
+{
+#if defined(CURVATURE)
+	screenScale = vec2(1.0, 1.0); //TextureSize / InputSize;
+#endif
+	filterWidth = (768.0 / 240.0) / 3.0;
+	TEX0 = vec2(gl_MultiTexCoord0.x, 1.0-gl_MultiTexCoord0.y)*1.0001;
+	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+#elif defined(FRAGMENT)
+
+uniform sampler2D Texture;
+
+#if defined(CURVATURE)
+vec2 Distort(vec2 coord)
+{
+	vec2 CURVATURE_DISTORTION = vec2(CURVATURE_X, CURVATURE_Y);
+	// Barrel distortion shrinks the display area a bit, this will allow us to counteract that.
+	vec2 barrelScale = 1.0 - (0.23 * CURVATURE_DISTORTION);
+	coord *= screenScale;
+	coord -= vec2(0.5);
+	float rsq = coord.x * coord.x + coord.y * coord.y;
+	coord += coord * (CURVATURE_DISTORTION * rsq);
+	coord *= barrelScale;
+	if (abs(coord.x) >= 0.5 || abs(coord.y) >= 0.5)
+		coord = vec2(-1.0);		// If out of bounds, return an invalid value.
+	else
+	{
+		coord += vec2(0.5);
+		coord /= screenScale;
+	}
+
+	return coord;
+}
+#endif
+
+float CalcScanLineWeight(float dist)
+{
+	return max(1.0-dist*dist*SCANLINE_WEIGHT, SCANLINE_GAP_BRIGHTNESS);
+}
+
+float CalcScanLine(float dy)
+{
+	float scanLineWeight = CalcScanLineWeight(dy);
+#if defined(MULTISAMPLE)
+	scanLineWeight += CalcScanLineWeight(dy-filterWidth);
+	scanLineWeight += CalcScanLineWeight(dy+filterWidth);
+	scanLineWeight *= 0.3333333;
+#endif
+	return scanLineWeight;
+}
+
+void main()
+{
+	vec2 TextureSize = vec2(320.0, 240.0);
+#if defined(CURVATURE)
+	vec2 texcoord = Distort(TEX0);
+	if (texcoord.x < 0.0)
+		gl_FragColor = vec4(0.0);
+	else
+#else
+	vec2 texcoord = TEX0;
+#endif
+	{
+		vec2 texcoordInPixels = texcoord * TextureSize;
+#if defined(SHARPER)
+		vec2 tempCoord = floor(texcoordInPixels) + 0.5;
+		vec2 coord = tempCoord / TextureSize;
+		vec2 deltas = texcoordInPixels - tempCoord;
+		float scanLineWeight = CalcScanLine(deltas.y);
+		vec2 signs = sign(deltas);
+		deltas.x *= 2.0;
+		deltas = deltas * deltas;
+		deltas.y = deltas.y * deltas.y;
+		deltas.x *= 0.5;
+		deltas.y *= 8.0;
+		deltas /= TextureSize;
+		deltas *= signs;
+		vec2 tc = coord + deltas;
+#else
+		float tempY = floor(texcoordInPixels.y) + 0.5;
+		float yCoord = tempY / TextureSize.y;
+		float dy = texcoordInPixels.y - tempY;
+		float scanLineWeight = CalcScanLine(dy);
+		float signY = sign(dy);
+		dy = dy * dy;
+		dy = dy * dy;
+		dy *= 8.0;
+		dy /= TextureSize.y;
+		dy *= signY;
+		vec2 tc = vec2(texcoord.x, yCoord + dy);
+#endif
+
+		vec3 colour = texture2D(Texture, tc).rgb;
+
+#if defined(SCANLINES)
+#if defined(GAMMA)
+#if defined(FAKE_GAMMA)
+		colour = colour * colour;
+#else
+		colour = pow(colour, vec3(INPUT_GAMMA));
+#endif
+#endif
+		scanLineWeight *= BLOOM_FACTOR;
+		colour *= scanLineWeight;
+
+#if defined(GAMMA)
+#if defined(FAKE_GAMMA)
+		colour = sqrt(colour);
+#else
+		colour = pow(colour, vec3(1.0/OUTPUT_GAMMA));
+#endif
+#endif
+#endif
+#if MASK_TYPE == 0
+		gl_FragColor = vec4(colour, 1.0);
+#else
+#if MASK_TYPE == 1
+		float whichMask = fract((gl_FragCoord.x*1.0001) * 0.5);
+		vec3 mask;
+		if (whichMask < 0.5)
+			mask = vec3(MASK_BRIGHTNESS, 1.0, MASK_BRIGHTNESS);
+		else
+			mask = vec3(1.0, MASK_BRIGHTNESS, 1.0);
+#elif MASK_TYPE == 2
+		float whichMask = fract((gl_FragCoord.x*1.0001) * 0.3333333);
+		vec3 mask = vec3(MASK_BRIGHTNESS, MASK_BRIGHTNESS, MASK_BRIGHTNESS);
+		if (whichMask < 0.3333333)
+			mask.x = 1.0;
+		else if (whichMask < 0.6666666)
+			mask.y = 1.0;
+		else
+			mask.z = 1.0;
+#endif
+
+		gl_FragColor = vec4(colour * mask, 1.0);
+#endif
+	}
+}
+#endif

data/shaders/crtpi_256.glsl

@@ -97,7 +97,6 @@ void main()
 #if defined(CURVATURE)
 	screenScale = vec2(1.0, 1.0); //TextureSize / InputSize;
 #endif
-	//filterWidth = (768.0 / 240.0) / 3.0;
 	filterWidth = (768.0 / 256.0) / 3.0;
 	TEX0 = vec2(gl_MultiTexCoord0.x, 1.0-gl_MultiTexCoord0.y)*1.0001;
 	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;

linux-utils/run_valgrind.sh

@@ -1,3 +0,0 @@
-#!/bin/bash
-
-valgrind --suppressions=valgrind_exceptions --leak-check=full ~/coffee_crisis_arcade_edition/coffee_crisis_arcade_edition_debug > ~/coffee_crisis_arcade_edition/debug.txt 2>&1

linux_utils/check_all_includes.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+SOURCEPATH=../source/
+
+for i in "$SOURCEPATH"/*.cpp
+do
+    include-what-you-use -D DEBUG -D VERBOSE -std=c++20 -Wall "$i"
+done

linux_utils/check_includes.sh

@@ -5,6 +5,6 @@ SOURCEPATH=../source/
 for i in "$SOURCEPATH"/*.cpp
 do
     include-what-you-use -D DEBUG -D VERBOSE -std=c++20 -Wall "$i"
-    read -p "Presiona cualquier tecla para continuar..."
+    read -r -p "Presiona cualquier tecla para continuar..."
     clear
 done

linux_utils/cppcheck_suppressions

@@ -0,0 +1,8 @@
+*:/home/sergio/gitea/coffee_crisis_arcade_edition/source/stb*
+*:/home/sergio/gitea/coffee_crisis_arcade_edition/source/gif.c
+*:/home/sergio/gitea/coffee_crisis_arcade_edition/source/jail*
+*:/usr/include/*
+*:../source/stb*
+*:../source/gif.c
+*:../source/jail*
+*:/usr/include/*

linux_utils/run_cppcheck.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+# Función para mostrar el uso del script
+mostrar_uso() {
+    echo "Uso: $0 [-o opción]"
+    echo "Opciones:"
+    echo "  w    Ejecutar cppcheck con warning, style, performance"
+    echo "  a    Ejecutar cppcheck con todas las opciones habilitadas"
+    echo "  u    Ejecutar cppcheck para unusedFunction"
+}
+
+# Inicializar las variables
+opcion=""
+
+# Procesar las opciones
+while getopts "o:" opt; do
+    case $opt in
+        o)
+            opcion=$OPTARG
+            ;;
+        *)
+            mostrar_uso
+            exit 1
+            ;;
+    esac
+done
+
+# Ejecutar según la opción seleccionada
+case $opcion in
+    w)
+        cppcheck --force --enable=warning,style,performance --std=c++20 \
+        --suppressions-list=./cppcheck_suppressions \
+        ../source/ \
+        2>./cppcheck-result-warning-style-performance.txt
+        ;;
+    a)
+        cppcheck --force --enable=all -I /usr/include --std=c++20 \
+        --suppress=missingIncludeSystem \
+        --suppressions-list=./cppcheck_suppressions \
+        ../source/ \
+        2>./cppcheck-result-all.txt
+        ;;
+    u)
+        cppcheck --enable=style --std=c++20 \
+        --suppressions-list=./cppcheck_suppressions \
+        ../source/ \
+        2>./cppcheck-result-unusedFunction.txt
+        ;;
+    *)
+        mostrar_uso
+        exit 1
+        ;;
+esac

linux_utils/run_valgrind.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+valgrind --suppressions=valgrind_exceptions \
+--leak-check=full \
+~/coffee_crisis_arcade_edition/coffee_crisis_arcade_edition_debug \
+> ~/coffee_crisis_arcade_edition/debug.txt 2>&1

release/coffee.rc

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

source/animated_sprite.cpp

@@ -1,16 +1,15 @@
 #include "animated_sprite.h"
-#include <algorithm> // for copy
-#include <fstream>	 // for basic_ostream, operator<<, basic_istream, basic...
-#include <iostream>	 // for cout
-#include <iterator>	 // for back_insert_iterator, back_inserter
-#include <sstream>	 // for basic_stringstream
-#include "texture.h" // for Texture
-#include "utils.h"
+#include <stddef.h>	 // Para size_t
+#include <fstream>	 // Para basic_ostream, basic_istream, operator<<, basic...
+#include <iostream>	 // Para cout, cerr
+#include <sstream>	 // Para basic_stringstream
+#include <stdexcept> // Para runtime_error
+#include "texture.h" // Para Texture
+#include "utils.h"	 // Para printWithDots
 
 // Carga las animaciones en un vector(Animations) desde un fichero
-Animations loadAnimationsFromFile(const std::string &file_path)
+AnimationsFileBuffer loadAnimationsFromFile(const std::string &file_path)
 {
-	std::vector<std::string> buffer;
 	std::ifstream file(file_path);
 	if (!file)
 	{
@@ -18,12 +17,14 @@ Animations loadAnimationsFromFile(const std::string &file_path)
 		throw std::runtime_error("Fichero no encontrado: " + file_path);
 	}
 
-	std::string line;
 	printWithDots("Animation : ", file_path.substr(file_path.find_last_of("\\/") + 1), "[ LOADED ]");
 
+	std::vector<std::string> buffer;
+	std::string line;
 	while (std::getline(file, line))
 	{
-		buffer.push_back(line);
+		if (!line.empty())
+			buffer.push_back(line);
 	}
 
 	return buffer;
@@ -31,35 +32,24 @@ Animations loadAnimationsFromFile(const std::string &file_path)
 
 // Constructor
 AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const std::string &file_path)
-	: MovingSprite(texture),
-	  current_animation_(0)
+	: MovingSprite(texture)
 {
 	// Carga las animaciones
 	if (!file_path.empty())
 	{
-		animations_ = loadFromFile(file_path);
-	}
-}
-
-AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const Animations &animations)
-	: MovingSprite(texture),
-	  current_animation_(0)
-{
-	if (!animations.empty())
-	{
-		loadFromVector(animations);
+		AnimationsFileBuffer v = loadAnimationsFromFile(file_path);
+		loadFromAnimationsFileBuffer(v);
 	}
 }
 
 // Constructor
-AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture)
-	: MovingSprite(texture),
-	  current_animation_(0) {}
-
-// Destructor
-AnimatedSprite::~AnimatedSprite()
+AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const AnimationsFileBuffer &animations)
+	: MovingSprite(texture)
 {
-	animations_.clear();
+	if (!animations.empty())
+	{
+		loadFromAnimationsFileBuffer(animations);
+	}
 }
 
 // Obtiene el indice de la animación a partir del nombre
@@ -116,89 +106,12 @@ void AnimatedSprite::animate()
 	}
 }
 
-// Obtiene el número de frames de la animación actual
-int AnimatedSprite::getNumFrames()
-{
-	return (int)animations_[current_animation_].frames.size();
-}
-
-// Establece el frame actual de la animación
-void AnimatedSprite::setCurrentFrame(int num)
-{
-	// Descarta valores fuera de rango
-	if (num >= (int)animations_[current_animation_].frames.size())
-	{
-		num = 0;
-	}
-
-	// Cambia el valor de la variable
-	animations_[current_animation_].current_frame = num;
-	animations_[current_animation_].counter = 0;
-
-	// Escoge el frame correspondiente de la animación
-	setSpriteClip(animations_[current_animation_].frames[animations_[current_animation_].current_frame]);
-}
-
-// Establece el valor del contador
-void AnimatedSprite::setAnimationCounter(const std::string &name, int num)
-{
-	animations_[getIndex(name)].counter = num;
-}
-
-// Establece la velocidad de una animación
-void AnimatedSprite::setAnimationSpeed(const std::string &name, int speed)
-{
-	animations_[getIndex(name)].counter = speed;
-}
-
-// Establece la velocidad de una animación
-void AnimatedSprite::setAnimationSpeed(int index, int speed)
-{
-	animations_[index].counter = speed;
-}
-
-// Establece si la animación se reproduce en bucle
-void AnimatedSprite::setAnimationLoop(const std::string &name, int loop)
-{
-	animations_[getIndex(name)].loop = loop;
-}
-
-// Establece si la animación se reproduce en bucle
-void AnimatedSprite::setAnimationLoop(int index, int loop)
-{
-	animations_[index].loop = loop;
-}
-
-// Establece el valor de la variable
-void AnimatedSprite::setAnimationCompleted(const std::string &name, bool value)
-{
-	animations_[getIndex(name)].completed = value;
-}
-
-// OLD - Establece el valor de la variable
-void AnimatedSprite::setAnimationCompleted(int index, bool value)
-{
-	animations_[index].completed = value;
-}
-
 // Comprueba si ha terminado la animación
 bool AnimatedSprite::animationIsCompleted()
 {
 	return animations_[current_animation_].completed;
 }
 
-// Devuelve el rectangulo de una animación y frame concreto
-SDL_Rect AnimatedSprite::getAnimationClip(const std::string &name, Uint8 index)
-{
-	return animations_[getIndex(name)].frames[index];
-}
-
-// Devuelve el rectangulo de una animación y frame concreto
-SDL_Rect AnimatedSprite::getAnimationClip(int indexA, Uint8 indexF)
-{
-	return animations_[indexA].frames[indexF];
-}
-
 // Establece la animacion actual
 void AnimatedSprite::setCurrentAnimation(const std::string &name)
 {
@@ -232,21 +145,6 @@ void AnimatedSprite::update()
 	MovingSprite::update();
 }
 
-// Establece el rectangulo para un frame de una animación
-void AnimatedSprite::setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h)
-{
-	animations_[index_animation].frames.push_back({x, y, w, h});
-}
-
-// OLD - Establece el contador para todas las animaciones
-void AnimatedSprite::setAnimationCounter(int value)
-{
-	for (auto &a : animations_)
-	{
-		a.counter = value;
-	}
-}
-
 // Reinicia la animación
 void AnimatedSprite::resetAnimation()
 {
@@ -255,268 +153,91 @@ void AnimatedSprite::resetAnimation()
 	animations_[current_animation_].completed = false;
 }
 
-// Carga la animación desde un fichero
-std::vector<Animation> AnimatedSprite::loadFromFile(const std::string &file_path)
+// Carga la animación desde un vector de cadenas
+void AnimatedSprite::loadFromAnimationsFileBuffer(const AnimationsFileBuffer &source)
 {
-	// Inicializa variables
-	std::vector<Animation> animations;
-	auto frames_per_row = 0;
-	auto frame_width = 0;
-	auto frame_height = 0;
-	auto max_tiles = 0;
+	int frame_width = 1;
+	int frame_height = 1;
+	int frames_per_row = 1;
+	int max_tiles = 1;
 
-	const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
-	std::ifstream file(file_path);
-	std::string line;
-
-	// El fichero se puede abrir
-	if (file.good())
+	size_t index = 0;
+	while (index < source.size())
 	{
-		// Procesa el fichero linea a linea
-		std::cout << "Animation loaded: " << file_name << std::endl;
-		while (std::getline(file, line))
+		std::string line = source.at(index);
+
+		// Parsea el fichero para buscar variables y valores
+		if (line != "[animation]")
 		{
-			// Si la linea contiene el texto [animation] se realiza el proceso de carga de una animación
-			if (line == "[animation]")
+			// Encuentra la posición del caracter '='
+			size_t pos = line.find("=");
+
+			// Procesa las dos subcadenas
+			if (pos != std::string::npos)
 			{
-				Animation animation = Animation();
+				std::string key = line.substr(0, pos);
+				int value = std::stoi(line.substr(pos + 1));
+				if (key == "frame_width")
+					frame_width = value;
+				else if (key == "frame_height")
+					frame_height = value;
+				else
+					std::cout << "Warning: unknown parameter " << key << std::endl;
 
-				do
-				{
-					std::getline(file, line);
-
-					// Encuentra la posición del caracter '='
-					int pos = line.find("=");
-
-					// Procesa las dos subcadenas
-					if (pos != static_cast<int>(line.npos))
-					{
-						if (line.substr(0, pos) == "name")
-						{
-							animation.name = line.substr(pos + 1, line.length());
-						}
-
-						else if (line.substr(0, pos) == "speed")
-						{
-							animation.speed = std::stoi(line.substr(pos + 1, line.length()));
-						}
-
-						else if (line.substr(0, pos) == "loop")
-						{
-							animation.loop = std::stoi(line.substr(pos + 1, line.length()));
-						}
-
-						else if (line.substr(0, pos) == "frames")
-						{
-							// Se introducen los valores separados por comas en un vector
-							std::stringstream ss(line.substr(pos + 1, line.length()));
-							std::string tmp;
-							SDL_Rect rect = {0, 0, frame_width, frame_height};
-							while (getline(ss, tmp, ','))
-							{
-								// Comprueba que el tile no sea mayor que el maximo indice permitido
-								const auto num_tile = std::stoi(tmp) > max_tiles ? 0 : std::stoi(tmp);
-								rect.x = (num_tile % frames_per_row) * frame_width;
-								rect.y = (num_tile / frames_per_row) * frame_height;
-								animation.frames.push_back(rect);
-							}
-						}
-
-						else
-						{
-							std::cout << "Warning: file " << file_name.c_str() << "\n, unknown parameter \"" << line.substr(0, pos).c_str() << "\"" << std::endl;
-						}
-					}
-				} while (line != "[/animation]");
-
-				// Añade la animación al vector de animaciones
-				animations.push_back(animation);
-			}
-
-			// En caso contrario se parsea el fichero para buscar las variables y los valores
-			else
-			{
-				// Encuentra la posición del caracter '='
-				int pos = line.find("=");
-
-				// Procesa las dos subcadenas
-				if (pos != (int)line.npos)
-				{
-					if (line.substr(0, pos) == "frames_per_row")
-					{
-						frames_per_row = std::stoi(line.substr(pos + 1, line.length()));
-					}
-
-					else if (line.substr(0, pos) == "frame_width")
-					{
-						frame_width = std::stoi(line.substr(pos + 1, line.length()));
-					}
-
-					else if (line.substr(0, pos) == "frame_height")
-					{
-						frame_height = std::stoi(line.substr(pos + 1, line.length()));
-					}
-
-					else
-					{
-						std::cout << "Warning: file " << file_name.c_str() << "\n, unknown parameter \"" << line.substr(0, pos).c_str() << "\"" << std::endl;
-					}
-
-					// Normaliza valores
-					if (frames_per_row == 0 && frame_width > 0)
-					{
-						frames_per_row = texture_->getWidth() / frame_width;
-					}
-
-					if (max_tiles == 0 && frame_width > 0 && frame_height > 0)
-					{
-						const auto w = texture_->getWidth() / frame_width;
-						const auto h = texture_->getHeight() / frame_height;
-						max_tiles = w * h;
-					}
-				}
+				frames_per_row = texture_->getWidth() / frame_width;
+				const int w = texture_->getWidth() / frame_width;
+				const int h = texture_->getHeight() / frame_height;
+				max_tiles = w * h;
 			}
 		}
 
-		// Cierra el fichero
-		file.close();
-	}
-	// El fichero no se puede abrir
-	else
-	{
-		std::cout << "Warning: Unable to open " << file_name.c_str() << " file" << std::endl;
-	}
-
-	// Pone un valor por defecto
-	setWidth(frame_width);
-	setHeight(frame_height);
-
-	return animations;
-}
-
-// Carga la animación desde un vector
-bool AnimatedSprite::loadFromVector(const Animations &source)
-{
-	// Inicializa variables
-	auto frames_per_row = 0;
-	auto frame_width = 0;
-	auto frame_height = 0;
-	auto max_tiles = 0;
-
-	// Indicador de éxito en el proceso
-	auto success = true;
-	std::string line;
-
-	// Recorre todo el vector
-	auto index = 0;
-	while (index < (int)source.size())
-	{
-		// Lee desde el vector
-		line = source.at(index);
-
 		// Si la linea contiene el texto [animation] se realiza el proceso de carga de una animación
 		if (line == "[animation]")
 		{
-			Animation animation = Animation();
-
+			Animation animation;
 			do
 			{
-				// Aumenta el indice para leer la siguiente linea
 				index++;
 				line = source.at(index);
+				size_t pos = line.find("=");
 
-				// Encuentra la posición del caracter '='
-				int pos = line.find("=");
-
-				// Procesa las dos subcadenas
-				if (pos != static_cast<int>(line.npos))
+				if (pos != std::string::npos)
 				{
-					if (line.substr(0, pos) == "name")
-					{
-						animation.name = line.substr(pos + 1, line.length());
-					}
+					std::string key = line.substr(0, pos);
+					std::string value = line.substr(pos + 1);
 
-					else if (line.substr(0, pos) == "speed")
-					{
-						animation.speed = std::stoi(line.substr(pos + 1, line.length()));
-					}
-
-					else if (line.substr(0, pos) == "loop")
-					{
-						animation.loop = std::stoi(line.substr(pos + 1, line.length()));
-					}
-
-					else if (line.substr(0, pos) == "frames")
+					if (key == "name")
+						animation.name = value;
+					else if (key == "speed")
+						animation.speed = std::stoi(value);
+					else if (key == "loop")
+						animation.loop = std::stoi(value);
+					else if (key == "frames")
 					{
 						// Se introducen los valores separados por comas en un vector
-						std::stringstream ss(line.substr(pos + 1, line.length()));
+						std::stringstream ss(value);
 						std::string tmp;
 						SDL_Rect rect = {0, 0, frame_width, frame_height};
 						while (getline(ss, tmp, ','))
 						{
 							// Comprueba que el tile no sea mayor que el maximo indice permitido
-							const int num_tile = std::stoi(tmp) > max_tiles ? 0 : std::stoi(tmp);
-							rect.x = (num_tile % frames_per_row) * frame_width;
-							rect.y = (num_tile / frames_per_row) * frame_height;
-							animation.frames.push_back(rect);
+							const int num_tile = std::stoi(tmp);
+							if (num_tile <= max_tiles)
+							{
+								rect.x = (num_tile % frames_per_row) * frame_width;
+								rect.y = (num_tile / frames_per_row) * frame_height;
+								animation.frames.emplace_back(rect);
+							}
 						}
 					}
 
 					else
-					{
-						std::cout << "Warning: unknown parameter " << line.substr(0, pos).c_str() << std::endl;
-						success = false;
-					}
+						std::cout << "Warning: unknown parameter " << key << std::endl;
 				}
 			} while (line != "[/animation]");
 
 			// Añade la animación al vector de animaciones
-			animations_.push_back(animation);
-		}
-
-		// En caso contrario se parsea el fichero para buscar las variables y los valores
-		else
-		{
-			// Encuentra la posición del caracter '='
-			int pos = line.find("=");
-
-			// Procesa las dos subcadenas
-			if (pos != (int)line.npos)
-			{
-				if (line.substr(0, pos) == "frames_per_row")
-				{
-					frames_per_row = std::stoi(line.substr(pos + 1, line.length()));
-				}
-
-				else if (line.substr(0, pos) == "frame_width")
-				{
-					frame_width = std::stoi(line.substr(pos + 1, line.length()));
-				}
-
-				else if (line.substr(0, pos) == "frame_height")
-				{
-					frame_height = std::stoi(line.substr(pos + 1, line.length()));
-				}
-
-				else
-				{
-					std::cout << "Warning: unknown parameter " << line.substr(0, pos).c_str() << std::endl;
-					success = false;
-				}
-
-				// Normaliza valores
-				if (frames_per_row == 0 && frame_width > 0)
-				{
-					frames_per_row = texture_->getWidth() / frame_width;
-				}
-
-				if (max_tiles == 0 && frame_width > 0 && frame_height > 0)
-				{
-					const int w = texture_->getWidth() / frame_width;
-					const int h = texture_->getHeight() / frame_height;
-					max_tiles = w * h;
-				}
-			}
+			animations_.emplace_back(animation);
 		}
 
 		// Una vez procesada la linea, aumenta el indice para pasar a la siguiente
@@ -526,6 +247,4 @@ bool AnimatedSprite::loadFromVector(const Animations &source)
 	// Pone un valor por defecto
 	setWidth(frame_width);
 	setHeight(frame_height);
-
-	return success;
 }

source/animated_sprite.h

@@ -1,12 +1,11 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>   // for SDL_Rect
-#include <SDL2/SDL_stdinc.h> // for Uint8
-#include <memory>            // for shared_ptr
-#include <string>            // for string
-#include <vector>            // for vector
-#include "moving_sprite.h"   // for MovingSprite
-class Texture;
+#include <SDL2/SDL_rect.h> // Para SDL_Rect
+#include <memory>          // Para shared_ptr
+#include <string>          // Para string
+#include <vector>          // Para vector
+#include "moving_sprite.h" // Para MovingSprite
+class Texture;             // lines 9-9
 
 struct Animation
 {
@@ -21,67 +20,40 @@ struct Animation
     Animation() : name(std::string()), speed(5), loop(0), completed(false), current_frame(0), counter(0) {}
 };
 
-using Animations = std::vector<std::string>;
+using AnimationsFileBuffer = std::vector<std::string>;
 
 // Carga las animaciones en un vector(Animations) desde un fichero
-Animations loadAnimationsFromFile(const std::string &file_path);
+AnimationsFileBuffer loadAnimationsFromFile(const std::string &file_path);
 
 class AnimatedSprite : public MovingSprite
 {
 protected:
     // Variables
     std::vector<Animation> animations_; // Vector con las diferentes animaciones
-    int current_animation_;             // Animacion activa
+    int current_animation_ = 0;         // Animacion activa
 
     // Calcula el frame correspondiente a la animación actual
     void animate();
 
-    // Carga la animación desde un fichero
-    std::vector<Animation> loadFromFile(const std::string &file_path);
-
-    // Carga la animación desde un vector
-    bool loadFromVector(const Animations &source);
+    // Carga la animación desde un vector de cadenas
+    void loadFromAnimationsFileBuffer(const AnimationsFileBuffer &source);
 
 public:
     // Constructor
     AnimatedSprite(std::shared_ptr<Texture> texture, const std::string &file_path);
-    AnimatedSprite(std::shared_ptr<Texture> texture, const Animations &animations);
-    explicit AnimatedSprite(std::shared_ptr<Texture> texture);
+    AnimatedSprite(std::shared_ptr<Texture> texture, const AnimationsFileBuffer &animations);
+    explicit AnimatedSprite(std::shared_ptr<Texture> texture)
+        : MovingSprite(texture) {}
 
     // Destructor
-    virtual ~AnimatedSprite();
+    virtual ~AnimatedSprite() = default;
 
     // Actualiza las variables del objeto
     void update() override;
 
-    // Obtiene el número de frames de la animación actual
-    int getNumFrames();
-
-    // Establece el frame actual de la animación
-    void setCurrentFrame(int num);
-
-    // Establece el valor del contador
-    void setAnimationCounter(const std::string &name, int num);
-
-    // Establece la velocidad de una animación
-    void setAnimationSpeed(const std::string &name, int speed);
-    void setAnimationSpeed(int index, int speed);
-
-    // Establece el frame al que vuelve la animación al finalizar
-    void setAnimationLoop(const std::string &name, int loop);
-    void setAnimationLoop(int index, int loop);
-
-    // Establece el valor de la variable
-    void setAnimationCompleted(const std::string &name, bool value);
-    void setAnimationCompleted(int index, bool value);
-
     // Comprueba si ha terminado la animación
     bool animationIsCompleted();
 
-    // Devuelve el rectangulo de una animación y frame concreto
-    SDL_Rect getAnimationClip(const std::string &name = "default", Uint8 index = 0);
-    SDL_Rect getAnimationClip(int indexA = 0, Uint8 indexF = 0);
-
     // Obtiene el indice de la animación a partir del nombre
     int getIndex(const std::string &name);
 
@@ -89,12 +61,6 @@ public:
     void setCurrentAnimation(const std::string &name = "default");
     void setCurrentAnimation(int index = 0);
 
-    // OLD - Establece el rectangulo para un frame de una animación
-    void setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h);
-
-    // OLD - Establece el contador para todas las animaciones
-    void setAnimationCounter(int value);
-
     // Reinicia la animación
     void resetAnimation();
 };

source/asset.cpp

@@ -1,9 +1,9 @@
 #include "asset.h"
-#include "utils.h"
-#include <SDL2/SDL_rwops.h>  // for SDL_RWFromFile, SDL_RWclose, SDL_RWops
-#include <SDL2/SDL_stdinc.h> // for SDL_max
-#include <stddef.h>          // for size_t
-#include <iostream>          // for basic_ostream, operator<<, cout, endl
+#include <algorithm> // Para find_if, max
+#include <fstream>   // Para basic_ostream, operator<<, basic_ifstream, endl
+#include <iostream>  // Para cout
+#include <string>    // Para allocator, char_traits, string, operator+, oper...
+#include "utils.h"   // Para getFileName, printWithDots
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Asset *Asset::asset_ = nullptr;
@@ -26,42 +26,31 @@ Asset *Asset::get()
     return Asset::asset_;
 }
 
-// Constructor
-Asset::Asset(const std::string &executable_path)
-    : executable_path_(executable_path.substr(0, executable_path.find_last_of("\\/")))
-{
-    longest_name_ = 0;
-}
-
 // Añade un elemento a la lista
 void Asset::add(const std::string &file, AssetType type, bool required, bool absolute)
 {
-    AssetItem ai;
-    ai.file = absolute ? file : executable_path_ + file;
-    ai.type = type;
-    ai.required = required;
-    file_list_.push_back(ai);
-
-    const std::string file_name = file.substr(file.find_last_of("\\/") + 1);
-    longest_name_ = SDL_max(longest_name_, file_name.size());
+    file_list_.emplace_back(absolute ? file : executable_path_ + file, type, required);
+    longest_name_ = std::max(longest_name_, static_cast<int>(file_list_.back().file.size()));
 }
 
-// Devuelve el fichero de un elemento de la lista a partir de una cadena
+// Devuelve la ruta completa a un fichero a partir de una cadena
 std::string Asset::get(const std::string &text) const
 {
-    for (const auto &f : file_list_)
+    auto it = std::find_if(file_list_.begin(), file_list_.end(),
+                           [&text](const auto &f)
+                           {
+                               return getFileName(f.file) == text;
+                           });
+
+    if (it != file_list_.end())
     {
-        const size_t last_index = f.file.find_last_of("/") + 1;
-        const std::string file = f.file.substr(last_index, std::string::npos);
-
-        if (file == text)
-        {
-            return f.file;
-        }
+        return it->file;
+    }
+    else
+    {
+        std::cout << "Warning: file " << text << " not found" << std::endl;
+        return "";
     }
-
-    std::cout << "Warning: file " << text.c_str() << " not found" << std::endl;
-    return "";
 }
 
 // Comprueba que existen todos los elementos
@@ -114,20 +103,12 @@ bool Asset::check() const
 // Comprueba que existe un fichero
 bool Asset::checkFile(const std::string &path) const
 {
-    auto success = false;
+    std::ifstream file(path);
+    bool success = file.good();
+    file.close();
 
-    // Comprueba si existe el fichero
-    auto file = SDL_RWFromFile(path.c_str(), "rb");
-
-    if (file)
-    {
-        success = true;
-        SDL_RWclose(file);
-    }
-
-    const std::string file_name = path.substr(path.find_last_of("\\/") + 1);
     if (!success)
-        printWithDots("Checking file : ", file_name, (success ? " [ OK ]" : " [ ERROR ]"));
+        printWithDots("Checking file : ", getFileName(path), "[ ERROR ]");
 
     return success;
 }

source/asset.h

@@ -1,7 +1,8 @@
 #pragma once
 
-#include <string> // for string, basic_string
-#include <vector> // for vector
+#include <string> // para string, basic_string
+#include <vector> // para vector
+#include "utils.h"
 
 enum class AssetType : int
 {
@@ -27,14 +28,17 @@ private:
 	// Estructura para definir un item
 	struct AssetItem
 	{
-		std::string file;	 // Ruta del fichero desde la raiz del directorio
-		enum AssetType type; // Indica el tipo de recurso
-		bool required;		 // Indica si es un fichero que debe de existir
-							 // bool absolute;		 // Indica si la ruta que se ha proporcionado es una ruta absoluta
+		std::string file; // Ruta del fichero desde la raíz del directorio
+		AssetType type;	  // Indica el tipo de recurso
+		bool required;	  // Indica si es un fichero que debe de existir
+
+		// Constructor
+		AssetItem(const std::string &filePath, AssetType assetType, bool isRequired)
+			: file(filePath), type(assetType), required(isRequired) {}
 	};
 
 	// Variables
-	int longest_name_;				   // Contiene la longitud del nombre de fichero mas largo
+	int longest_name_ = 0;			   // Contiene la longitud del nombre de fichero mas largo
 	std::vector<AssetItem> file_list_; // Listado con todas las rutas a los ficheros
 	std::string executable_path_;	   // Ruta al ejecutable
 
@@ -45,7 +49,8 @@ private:
 	std::string getTypeName(AssetType type) const;
 
 	// Constructor
-	explicit Asset(const std::string &executable_path);
+	explicit Asset(const std::string &executable_path)
+		: executable_path_(getPath(executable_path)) {}
 
 	// Destructor
 	~Asset() = default;
@@ -63,7 +68,7 @@ public:
 	// Añade un elemento a la lista
 	void add(const std::string &file, AssetType type, bool required = true, bool absolute = false);
 
-	// Devuelve un elemento de la lista a partir de una cadena
+	// Devuelve la ruta completa a un fichero a partir de una cadena
 	std::string get(const std::string &text) const;
 
 	// Comprueba que existen todos los elementos

source/background.cpp

@@ -1,14 +1,14 @@
 #include "background.h"
-#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_pixels.h>    // for SDL_PIXELFORMAT_RGBA8888
-#include <algorithm>            // for clamp, max
-#include "asset.h"              // for Asset
-#include "moving_sprite.h"      // for MovingSprite
-#include "param.h"              // for param
-#include "resource.h"           // for Resource
-#include "screen.h"
-#include "sprite.h"  // for Sprite
-#include "texture.h" // for Texture
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888
+#include <algorithm>            // Para clamp, max
+#include <cmath>
+#include "moving_sprite.h" // Para MovingSprite
+#include "param.h"         // Para Param, ParamBackground, param
+#include "resource.h"      // Para Resource
+#include "screen.h"        // Para Screen
+#include "sprite.h"        // Para Sprite
+#include "texture.h"       // Para Texture
 
 // Constructor
 Background::Background()
@@ -19,21 +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")),
 
-      gradient_number_(0),
-      alpha_(0),
-      clouds_speed_(0),
-      transition_(0),
-      counter_(0),
       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_({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};
@@ -61,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
@@ -85,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
@@ -94,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_);
 }
 
@@ -109,7 +114,7 @@ Background::~Background()
 void Background::update()
 {
     // Actualiza el valor de alpha_
-    updateAlphaColorText();
+    updateAlphaColorTexture();
 
     // Actualiza las nubes
     updateClouds();
@@ -120,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_;
 
@@ -187,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();
 
@@ -253,28 +266,16 @@ void Background::setPos(SDL_Rect pos)
     src_rect_.h = pos.h;
 }
 
-// Ajusta el valor de la variable
-void Background::setSrcRect(SDL_Rect value)
-{
-    src_rect_ = value;
-}
-
-// Ajusta el valor de la variable
-void Background::setDstRect(SDL_Rect value)
-{
-    dst_rect_ = value;
-}
-
 // 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);
@@ -292,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_)
     {
@@ -340,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>   // for SDL_Rect
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
-#include <memory>            // for unique_ptr, shared_ptr
-#include "utils.h"           // for Color
-class MovingSprite;
-class Sprite;
-class Texture;
+#include <SDL2/SDL_rect.h>   // Para SDL_Rect, SDL_Point
+#include <SDL2/SDL_render.h> // Para SDL_Texture, SDL_Renderer
+#include <stddef.h>          // Para size_t
+#include <memory>            // Para unique_ptr, shared_ptr
+#include <vector>            // Para vector
+#include "utils.h"           // Para Color
+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
@@ -32,12 +34,6 @@ class Texture;
         - setTransition(float value)
           Porcentaje (entre 0.0f (textura actual) y 1.0f (textura siguiente)) para mostrar entre la textura de fondo actual y la siguiente
 
-        - setSrcRect(SDL_Rect value)
-          Rectangulo de la textura de fondo que se desea mostrar
-
-        - setDstRecr(SDL_Rect value)
-          Rectangulo de destino donde se mostrará el rectángulo antrior. Automaticamente modifica srcRect para coincidor en tamaño con el destino.
-
         - setColor(Color color)
           Establece el color de la textura de superposición
 
@@ -57,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
@@ -66,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 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
-  int gradient_number_;            // Indica el número de degradado de fondo que se va a dibujar
-  int alpha_;                      // Transparencia entre los dos degradados
-  float clouds_speed_;             // Velocidad a la que se desplazan las nubes
-  float transition_;               // Nivel de transición del fondo 0..1
-  int counter_;                    // Contador interno
-  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 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
-  Color color_;                    // Color 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
+  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 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 alpha_ = 0;                    // Transparencia entre los dos degradados
+  float clouds_speed_ = 0;           // Velocidad a la que se desplazan las nubes
+  float transition_ = 0;             // Nivel de transición del fondo 0..1
+  int counter_ = 0;                  // Contador interno
+  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 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
+  Color attenuate_color_;            // Color 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
+  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();
@@ -100,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();
@@ -133,15 +143,15 @@ public:
   // Ajusta el valor de la variable
   void setTransition(float value);
 
-  // Ajusta el valor de la variable
-  void setSrcRect(SDL_Rect value);
-
-  // Ajusta el valor de la variable
-  void setDstRect(SDL_Rect value);
-
   // Establece el color de atenuación
   void setColor(Color color);
 
   // 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.h

@@ -1,42 +1,40 @@
 #pragma once
 
-#include <SDL2/SDL_stdinc.h> // for Uint8, Uint16, Uint32
-#include <memory>			 // for shared_ptr, unique_ptr
-#include <string>			 // for string
-#include <vector>			 // for vector
-#include "animated_sprite.h" // for SpriteAnimated
-#include "utils.h"			 // for Circle
-class Texture;
+#include <SDL2/SDL_rect.h>	 // Para SDL_Rect
+#include <SDL2/SDL_stdinc.h> // Para Uint8, Uint16, Uint32
+#include <memory>			 // Para shared_ptr, unique_ptr
+#include <string>			 // Para string
+#include <vector>			 // Para vector
+#include "animated_sprite.h" // Para AnimatedSprite
+#include "utils.h"			 // Para Circle
+class Texture;				 // lines 9-9
 
 // Cantidad de elementos del vector con los valores de la deformación del globo al rebotar
 constexpr int MAX_BOUNCE = 10;
 
-// Tipos de globo
-constexpr int BALLOON_1 = 1;
-constexpr int BALLOON_2 = 2;
-constexpr int BALLOON_3 = 3;
-constexpr int BALLOON_4 = 4;
-constexpr int HEXAGON_1 = 5;
-constexpr int HEXAGON_2 = 6;
-constexpr int HEXAGON_3 = 7;
-constexpr int HEXAGON_4 = 8;
-constexpr int POWER_BALL = 9;
-
 // Puntos de globo
-constexpr int BALLOON_SCORE_1 = 50;
-constexpr int BALLOON_SCORE_2 = 100;
-constexpr int BALLOON_SCORE_3 = 200;
-constexpr int BALLOON_SCORE_4 = 400;
+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
-constexpr int BALLOON_SIZE_1 = 1;
-constexpr int BALLOON_SIZE_2 = 2;
-constexpr int BALLOON_SIZE_3 = 3;
-constexpr int BALLOON_SIZE_4 = 4;
+enum class BalloonSize : Uint8
+{
+	SIZE1 = 0,
+	SIZE2 = 1,
+	SIZE3 = 2,
+	SIZE4 = 3,
+};
 
 // Clases de globo
-constexpr int BALLOON_CLASS = 0;
-constexpr int HEXAGON_CLASS = 1;
+enum class BalloonType : Uint8
+{
+	BALLOON = 0,
+	FLOATER = 1,
+	POWERBALL = 2,
+};
 
 // Velocidad del globo
 constexpr float BALLOON_VELX_POSITIVE = 0.7f;
@@ -47,21 +45,8 @@ constexpr int BALLOON_MOVING_ANIMATION = 0;
 constexpr int BALLOON_POP_ANIMATION = 1;
 constexpr int BALLOON_BORN_ANIMATION = 2;
 
-// Cantidad posible de globos
-constexpr int MAX_BALLOONS = 100;
-
 // Velocidades a las que se mueven los globos
-constexpr float BALLOON_SPEED_1 = 0.60f;
-constexpr float BALLOON_SPEED_2 = 0.70f;
-constexpr float BALLOON_SPEED_3 = 0.80f;
-constexpr float BALLOON_SPEED_4 = 0.90f;
-constexpr float BALLOON_SPEED_5 = 1.00f;
-
-// Tamaño de los globos
-constexpr int BALLOON_WIDTH_1 = 10;
-constexpr int BALLOON_WIDTH_2 = 16;
-constexpr int BALLOON_WIDTH_3 = 26;
-constexpr int BALLOON_WIDTH_4 = 46;
+constexpr float BALLOON_SPEED[] = {0.60f, 0.70f, 0.80f, 0.90f, 1.00f};
 
 // PowerBall
 constexpr int POWERBALL_SCREENPOWER_MINIMUM = 10;
@@ -71,61 +56,81 @@ constexpr int POWERBALL_COUNTER = 8;
 class Balloon
 {
 private:
-	// Estructura para las variables para el efecto de los rebotes
+	// Estructura para el efecto de los rebotes en los globos
 	struct Bouncing
 	{
-		bool enabled;		  // Si el efecto está activo
-		Uint8 counter;		  // Countador para el efecto
-		Uint8 speed;		  // Velocidad a la que transcurre el efecto
-		float zoomW;		  // Zoom aplicado a la anchura
-		float zoomH;		  // Zoom aplicado a la altura
-		float despX;		  // Desplazamiento de pixeles en el eje X antes de pintar el objeto con zoom
-		float despY;		  // Desplazamiento de pixeles en el eje Y antes de pintar el objeto con zoom
-		std::vector<float> w; // Vector con los valores de zoom para el ancho del globo
-		std::vector<float> h; // Vector con los valores de zoom para el alto del globo
-	};
+		bool enabled = false; // Si el efecto está activo
+		Uint8 counter = 0;	  // Contador para el efecto
+		Uint8 speed = 2;	  // Velocidad a la que transcurre el efecto
+		float zoomW = 1.0f;	  // Zoom aplicado a la anchura
+		float zoomH = 1.0f;	  // Zoom aplicado a la altura
+		float despX = 0.0f;	  // Desplazamiento de pixeles en el eje X antes de pintar el objeto con zoom
+		float despY = 0.0f;	  // Desplazamiento de pixeles en el eje Y antes de pintar el objeto con zoom
+
+		float w[MAX_BOUNCE] = {1.10f, 1.05f, 1.00f, 0.95f, 0.90f, 0.95f, 1.00f, 1.02f, 1.05f, 1.02f}; // Vector con los valores de zoom para el ancho del globo
+		float h[MAX_BOUNCE] = {0.90f, 0.95f, 1.00f, 1.05f, 1.10f, 1.05f, 1.00f, 0.98f, 0.95f, 0.98f}; // Vector con los valores de zoom para el alto del globo
+
+		// Constructor por defecto
+		Bouncing() = default;
+
+		// Método reset
+		void reset()
+		{
+			counter = 0;
+			zoomW = 1.0f;
+			zoomH = 1.0f;
+			despX = 0.0f;
+			despY = 0.0f;
+		}
+	} bouncing_;
 
 	// Objetos y punteros
 	std::unique_ptr<AnimatedSprite> sprite_; // Sprite del objeto globo
 
 	// Variables
-	float pos_x_;				  // Posición en el eje X
-	float pos_y_;				  // Posición en el eje Y
-	Uint8 width_;				  // Ancho
-	Uint8 height_;				  // Alto
-	float vel_x_;				  // Velocidad en el eje X. Cantidad de pixeles a desplazarse
-	float vel_y_;				  // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
-	float gravity_;				  // Aceleración en el eje Y. Modifica la velocidad
-	float default_vel_y_;		  // Velocidad inicial que tienen al rebotar contra el suelo
-	float max_vel_y_;			  // Máxima velocidad que puede alcanzar el objeto en el eje Y
-	bool being_created_;		  // Indica si el globo se está creando
-	bool blinking_;				  // Indica si el globo está intermitente
-	bool enabled_;				  // Indica si el globo esta activo
-	bool invulnerable_;			  // Indica si el globo es invulnerable
-	bool stopped_;				  // Indica si el globo está parado
-	bool visible_;				  // Indica si el globo es visible
-	Circle collider_;			  // Circulo de colisión del objeto
-	Uint16 creation_counter_;	  // Temporizador para controlar el estado "creandose"
-	Uint16 creation_counter_ini_; // Valor inicial para el temporizador para controlar el estado "creandose"
-	Uint16 score_;				  // Puntos que da el globo al ser destruido
-	Uint16 stopped_counter_;	  // Contador para controlar el estado "parado"
-	Uint8 kind_;				  // Tipo de globo
-	Uint8 menace_;				  // Cantidad de amenaza que genera el globo
-	Uint32 counter_;			  // Contador interno
-	float travel_y_;			  // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
-	float speed_;				  // Velocidad a la que se mueven los globos
-	Uint8 size_;				  // Tamaño del globo
-	Uint8 power_;				  // Cantidad de poder que alberga el globo
-	Bouncing bouncing_;			  // Contiene las variables para el efecto de rebote
+	float x_;						   // Posición en el eje X
+	float y_;						   // Posición en el eje Y
+	Uint8 w_;						   // Ancho
+	Uint8 h_;						   // Alto
+	float vx_;						   // Velocidad en el eje X. Cantidad de pixeles a desplazarse
+	float vy_;						   // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
+	float gravity_;					   // Aceleración en el eje Y. Modifica la velocidad
+	float default_vy_;				   // Velocidad inicial que tienen al rebotar contra el suelo
+	float max_vy_;					   // Máxima velocidad que puede alcanzar el objeto en el eje Y
+	bool being_created_;			   // Indica si el globo se está creando
+	bool enabled_ = true;			   // Indica si el globo esta activo
+	bool invulnerable_;				   // Indica si el globo es invulnerable
+	bool stopped_;					   // Indica si el globo está parado
+	bool use_reversed_colors_ = false; // Indica si se ha de usar el color secundario del globo como color principal
+	Circle collider_;				   // Circulo de colisión del objeto
+	Uint16 creation_counter_;		   // Temporizador para controlar el estado "creandose"
+	Uint16 creation_counter_ini_;	   // Valor inicial para el temporizador para controlar el estado "creandose"
+	Uint16 score_;					   // Puntos que da el globo al ser destruido
+	BalloonType type_;				   // Clase de globo
+	BalloonSize size_;				   // Tamaño del globo
+	Uint8 menace_;					   // Cantidad de amenaza que genera el globo
+	Uint32 counter_ = 0;			   // Contador interno
+	float travel_y_ = 1.0f;			   // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
+	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 updateColliders();
+	void shiftColliders();
+
+	// Alinea el sprite con la posición del objeto globo
+	void shiftSprite();
+
+	// Establece el nivel de zoom del sprite
+	void zoomSprite();
 
 	// Activa el efecto
-	void bounceStart();
+	void enableBounce();
 
 	// Detiene el efecto
-	void bounceStop();
+	void disableBounce();
 
 	// Aplica el efecto
 	void updateBounce();
@@ -134,20 +139,30 @@ private:
 	void updateState();
 
 	// Establece la animación correspondiente
-	void updateAnimation();
+	void setAnimation();
 
-	// Establece el valor de la variable
-	void setBeingCreated(bool value);
+	// Reproduce el sonido al rebotar
+	void playSound();
 
 public:
 	// Constructor
-	Balloon(float x, float y, Uint8 kind, float vel_x, float speed, Uint16 creation_timer, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
+	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);
 
 	// Destructor
 	~Balloon() = default;
 
 	// Centra el globo en la posición X
-	void allignTo(int x);
+	void alignTo(int x);
 
 	// Pinta el globo en la pantalla
 	void render();
@@ -155,96 +170,44 @@ 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();
 
-	// Comprueba si el globo está habilitado
-	bool isEnabled() const;
+	// Detiene el globo
+	void stop();
 
-	// Obtiene del valor de la variable
-	float getPosX() const;
+	// Pone el globo en movimiento
+	void start();
 
-	// Obtiene del valor de la variable
-	float getPosY() const;
+	// Pone el color alternativo en el globo
+	void useReverseColor();
 
-	// Obtiene del valor de la variable
-	float getVelY() const;
+	// Pone el color normal en el globo
+	void useNormalColor();
 
-	// Obtiene del valor de la variable
-	int getWidth() const;
+	// Getters
+	float getPosX() const { return x_; }
+	float getPosY() const { return y_; }
+	int getWidth() const { return w_; }
+	int getHeight() const { return h_; }
+	BalloonSize getSize() const { return size_; }
+	BalloonType getType() const { return type_; }
+	Uint16 getScore() const { return score_; }
+	Circle &getCollider() { return collider_; }
+	Uint8 getMenace() const { return isEnabled() ? menace_ : 0; }
+	Uint8 getPower() const { return power_; }
+	bool isStopped() const { return stopped_; }
+	bool isPowerBall() const { return type_ == BalloonType::POWERBALL; }
+	bool isInvulnerable() const { return invulnerable_; }
+	bool isBeingCreated() const { return being_created_; }
+	bool isEnabled() const { return enabled_; }
+	bool isUsingReversedColor() { return use_reversed_colors_; }
+	bool canBePopped() const { return !isBeingCreated(); }
 
-	// Obtiene del valor de la variable
-	int getHeight() const;
-
-	// Establece el valor de la variable
-	void setVelY(float vel_y);
-
-	// Establece el valor de la variable
-	void setSpeed(float speed);
-
-	// Obtiene del valor de la variable
-	int getKind() const;
-
-	// Obtiene del valor de la variable
-	Uint8 getSize() const;
-
-	// Obtiene la clase a la que pertenece el globo
-	Uint8 getClass() const;
-
-	// Establece el valor de la variable
-	void setStop(bool value);
-
-	// Obtiene del valor de la variable
-	bool isStopped() const;
-
-	// Establece el valor de la variable
-	void setBlink(bool value);
-
-	// Obtiene del valor de la variable
-	bool isBlinking() const;
-
-	// Establece el valor de la variable
-	void setVisible(bool value);
-
-	// Obtiene del valor de la variable
-	bool isVisible() const;
-
-	// Establece el valor de la variable
-	void setInvulnerable(bool value);
-
-	// Obtiene del valor de la variable
-	bool isInvulnerable() const;
-
-	// Obtiene del valor de la variable
-	bool isBeingCreated() const;
-
-	// Establece el valor de la variable
-	void setStoppedTimer(Uint16 time);
-
-	// Obtiene del valor de la variable
-	Uint16 getStoppedTimer() const;
-
-	// Obtiene del valor de la variable
-	Uint16 getScore() const;
-
-	// Obtiene el circulo de colisión
-	Circle &getCollider();
-
-	// Obtiene le valor de la variable
-	Uint8 getMenace() const;
-
-	// Obtiene le valor de la variable
-	Uint8 getPower() const;
-
-	// Indica si el globo se puede explotar
-	bool canBePopped() const;
-
-	// Indica si el globo se puede destruir
-	bool canBeDestroyed() const;
+	// Setters
+	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_formations.h

@@ -1,50 +1,50 @@
 #pragma once
 
+#include "balloon.h" // para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
+#include <vector>
+
 constexpr int NUMBER_OF_BALLOON_FORMATIONS = 100;
 constexpr int MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION = 50;
+constexpr int NUMBER_OF_SETS_PER_POOL = 10;
+constexpr int NUMBER_OF_STAGES = 10;
 
-// Estructuras
 struct BalloonFormationParams
 {
-    int x = 0;                // Posición en el eje X donde crear al enemigo
-    int y = 0;                // Posición en el eje Y donde crear al enemigo
-    float vel_x = 0.0f;       // Velocidad inicial en el eje X
-    int kind = 0;             // Tipo de enemigo
-    int creation_counter = 0; // Temporizador para la creación del enemigo
+    int x = 0;                               // Posición en el eje X donde crear el globo
+    int y = 0;                               // Posición en el eje Y donde crear el globo
+    float vel_x = 0.0f;                      // Velocidad inicial en el eje X
+    BalloonType type = BalloonType::BALLOON; // Tipo de globo
+    BalloonSize size = BalloonSize::SIZE1;   // Tamaño de globo
+    int creation_counter = 0;                // Temporizador para la creación del globo
 
-    // Constructor que inicializa todos los campos con valores proporcionados o predeterminados
-    BalloonFormationParams(int x_val = 0, int y_val = 0, float vel_x_val = 0.0f, int kind_val = 0, int creation_counter_val = 0)
-        : x(x_val), y(y_val), vel_x(vel_x_val), kind(kind_val), creation_counter(creation_counter_val) {}
+    // Constructor por defecto
+    BalloonFormationParams() = default;
+
+    // Constructor con parámetros
+    BalloonFormationParams(int x_val, int y_val, float vel_x_val, BalloonType type_val, BalloonSize size_val, int creation_counter_val)
+        : x(x_val), y(y_val), vel_x(vel_x_val), type(type_val), size(size_val), creation_counter(creation_counter_val) {}
 };
 
-struct BalloonFormationUnit // Contiene la información de una formación enemiga
+struct BalloonFormationUnit
 {
-    int number_of_balloons;                                             // Cantidad de enemigos que forman la formación
-    BalloonFormationParams init[MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION]; // Vector con todas las inicializaciones de los enemigos de la formación
+    int number_of_balloons;                   // Cantidad de globos que forman la formación
+    std::vector<BalloonFormationParams> init; // Vector con todas las inicializaciones de los globos de la formación
+
+    // Constructor
+    BalloonFormationUnit(int num_balloons, const std::vector<BalloonFormationParams> &init_params)
+        : number_of_balloons(num_balloons), init(init_params) {}
+
+    // Default constructor
+    BalloonFormationUnit() : number_of_balloons(0), init() {}
 };
 
-struct BalloonFormationPool
-{
-    BalloonFormationUnit *set[10]; // Conjunto de formaciones de globos
-};
+using BalloonFormationPool = std::vector<const BalloonFormationUnit *>;
 
-struct Stage // Contiene todas las variables relacionadas con una fase
-{
-    BalloonFormationPool *balloon_pool; // El conjunto de formaciones de globos de la fase
-    int power_to_complete;              // Cantidad de poder que se necesita para completar la fase
-    int max_menace;                     // Umbral máximo de amenaza de la fase
-    int min_menace;                     // Umbral mínimo de amenaza de la fase
-    int number;                         // Número de fase
-};
-
-// Clase BalloonFormations, para gestionar las formaciones de globos
 class BalloonFormations
 {
 private:
-    // Variables
-    Stage stage_[10];                                                      // Variable con los datos de cada pantalla
-    BalloonFormationUnit balloon_formation_[NUMBER_OF_BALLOON_FORMATIONS]; // Vector con todas las formaciones enemigas
-    BalloonFormationPool balloon_formation_pool_[10];                      // Variable con los diferentes conjuntos de formaciones enemigas
+    std::vector<BalloonFormationUnit> balloon_formation_;      // Vector con todas las formaciones enemigas
+    std::vector<BalloonFormationPool> balloon_formation_pool_; // Variable con los diferentes conjuntos de formaciones enemigas
 
     // Inicializa las formaciones enemigas
     void initBalloonFormations();
@@ -52,16 +52,19 @@ private:
     // Inicializa los conjuntos de formaciones
     void initBalloonFormationPools();
 
-    // Inicializa las fases del juego
-    void initGameStages();
-
 public:
     // Constructor
-    BalloonFormations();
+    BalloonFormations()
+    {
+        initBalloonFormations();
+        initBalloonFormationPools();
+    }
 
     // Destructor
     ~BalloonFormations() = default;
 
-    // Devuelve una fase
-    Stage getStage(int index) const;
-};
+    // Getters
+    const BalloonFormationPool &getPool(int pool) { return balloon_formation_pool_.at(pool); }
+    const BalloonFormationUnit &getSet(int pool, int set) { return *balloon_formation_pool_.at(pool).at(set); }
+    const BalloonFormationUnit &getSet(int set) const { return balloon_formation_.at(set); }
+};

source/balloon_manager.cpp

@@ -0,0 +1,417 @@
+#include "balloon_manager.h"
+#include <stdlib.h>             // Para rand
+#include <algorithm>            // Para remove_if
+#include <numeric>              // Para accumulate
+#include "balloon.h"            // Para Balloon, BALLOON_SCORE, BALLOON_VELX...
+#include "balloon_formations.h" // Para BalloonFormationParams, BalloonForma...
+#include "explosions.h"         // Para Explosions
+#include "jail_audio.h"         // Para JA_PlaySound
+#include "param.h"              // Para Param, ParamGame, param
+#include "resource.h"           // Para Resource
+#include "screen.h"             // Para Screen
+#include "stage.h"              // Para power
+#include "texture.h"            // Para Texture
+#include "utils.h"              // Para Zone, BLOCK, Color, flash_color
+
+// Constructor
+BalloonManager::BalloonManager()
+    : explosions_(std::make_unique<Explosions>()),
+      balloon_formations_(std::make_unique<BalloonFormations>()) { init(); }
+
+// Inicializa
+void BalloonManager::init()
+{
+    // Texturas - Globos
+    balloon_textures_.emplace_back(Resource::get()->getTexture("balloon1.png"));
+    balloon_textures_.emplace_back(Resource::get()->getTexture("balloon2.png"));
+    balloon_textures_.emplace_back(Resource::get()->getTexture("balloon3.png"));
+    balloon_textures_.emplace_back(Resource::get()->getTexture("balloon4.png"));
+    balloon_textures_.emplace_back(Resource::get()->getTexture("powerball.png"));
+
+    // Animaciones -- Globos
+    balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon1.ani"));
+    balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon2.ani"));
+    balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon3.ani"));
+    balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon4.ani"));
+    balloon_animations_.emplace_back(Resource::get()->getAnimation("powerball.ani"));
+
+    // Texturas - Explosiones
+    explosions_textures_.emplace_back(Resource::get()->getTexture("explosion1.png"));
+    explosions_textures_.emplace_back(Resource::get()->getTexture("explosion2.png"));
+    explosions_textures_.emplace_back(Resource::get()->getTexture("explosion3.png"));
+    explosions_textures_.emplace_back(Resource::get()->getTexture("explosion4.png"));
+
+    // Animaciones -- Explosiones
+    explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion1.ani"));
+    explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion2.ani"));
+    explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion3.ani"));
+    explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion4.ani"));
+
+    // Añade texturas
+    explosions_->addTexture(1, explosions_textures_[0], explosions_animations_[0]);
+    explosions_->addTexture(2, explosions_textures_[1], explosions_animations_[1]);
+    explosions_->addTexture(3, explosions_textures_[2], explosions_animations_[2]);
+    explosions_->addTexture(4, explosions_textures_[3], explosions_animations_[3]);
+}
+
+// Actualiza
+void BalloonManager::update()
+{
+    for (auto balloon : balloons_)
+    {
+        balloon->update();
+    }
+    updateBalloonDeployCounter();
+    explosions_->update();
+}
+
+// Renderiza los objetos
+void BalloonManager::render()
+{
+    for (auto &balloon : balloons_)
+    {
+        balloon->render();
+    }
+    explosions_->render();
+}
+
+// Crea una formación de enemigos
+void BalloonManager::deployBalloonFormation(int stage)
+{
+    // Solo despliega una formación enemiga si ha pasado cierto tiempo desde la última
+    if (balloon_deploy_counter_ == 0)
+    {
+        // En este punto se decide entre crear una powerball o una formación enemiga
+        if ((rand() % 100 < 15) && (canPowerBallBeCreated()))
+        {
+            // Crea una powerball
+            createPowerBall();
+
+            // Da un poco de margen para que se creen mas enemigos
+            balloon_deploy_counter_ = 10;
+        }
+        else
+        {
+            // Decrementa el contador de despliegues enemigos de la PowerBall
+            power_ball_counter_ = (power_ball_counter_ > 0) ? (power_ball_counter_ - 1) : 0;
+
+            // Elige una formación enemiga la azar
+            auto formation = rand() % 10;
+
+            // Evita repetir la ultima formación enemiga desplegada
+            if (formation == last_balloon_deploy_)
+            {
+                ++formation %= 10;
+            }
+
+            last_balloon_deploy_ = formation;
+
+            const auto set = balloon_formations_->getSet(stage, formation);
+            const auto num_enemies = set.number_of_balloons;
+            for (int i = 0; i < num_enemies; ++i)
+            {
+                auto p = set.init[i];
+                createBalloon(
+                    p.x,
+                    p.y,
+                    p.type,
+                    p.size,
+                    p.vel_x,
+                    balloon_speed_,
+                    (creation_time_enabled_) ? p.creation_counter : 0);
+            }
+
+            balloon_deploy_counter_ = 300;
+        }
+    }
+}
+
+// Crea una formación de enemigos específica
+void BalloonManager::deploySet(int set_number)
+{
+    const auto set = balloon_formations_->getSet(set_number);
+    const auto num_enemies = set.number_of_balloons;
+    for (int i = 0; i < num_enemies; ++i)
+    {
+        auto p = set.init[i];
+        createBalloon(p.x, p.y, p.type, p.size, p.vel_x, balloon_speed_, p.creation_counter);
+    }
+}
+
+// Crea una formación de enemigos específica
+void BalloonManager::deploySet(int set_number, int y)
+{
+    const auto set = balloon_formations_->getSet(set_number);
+    const auto num_enemies = set.number_of_balloons;
+    for (int i = 0; i < num_enemies; ++i)
+    {
+        auto p = set.init[i];
+        createBalloon(p.x, y, p.type, p.size, p.vel_x, balloon_speed_, p.creation_counter);
+    }
+}
+
+// Vacia del vector de globos los globos que ya no sirven
+void BalloonManager::freeBalloons()
+{
+    auto it = std::remove_if(balloons_.begin(), balloons_.end(), [](const auto &balloon)
+                             { return !balloon->isEnabled(); });
+    balloons_.erase(it, balloons_.end());
+}
+
+// Actualiza la variable enemyDeployCounter
+void BalloonManager::updateBalloonDeployCounter()
+{
+    if (balloon_deploy_counter_ > 0)
+    {
+        --balloon_deploy_counter_;
+    }
+}
+
+// Indica si se puede crear una powerball
+bool BalloonManager::canPowerBallBeCreated() { return (!power_ball_enabled_) && (calculateScreenPower() > POWERBALL_SCREENPOWER_MINIMUM) && (power_ball_counter_ == 0); }
+
+// Calcula el poder actual de los globos en pantalla
+int BalloonManager::calculateScreenPower()
+{
+    return std::accumulate(balloons_.begin(), balloons_.end(), 0, [](int sum, const auto &balloon)
+                           { return sum + (balloon->isEnabled() ? balloon->getPower() : 0); });
+}
+
+// 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)
+{
+    if (can_deploy_balloons_)
+    {
+        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)
+{
+    if (can_deploy_balloons_)
+    {
+        const float vx = direction == "LEFT" ? BALLOON_VELX_NEGATIVE : BALLOON_VELX_POSITIVE;
+        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();
+        }
+        if (balloon->isUsingReversedColor())
+        {
+            b->useReverseColor();
+        }
+    }
+}
+
+// Crea una PowerBall
+void BalloonManager::createPowerBall()
+{
+    if (can_deploy_balloons_)
+    {
+        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 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 luck = rand() % values;
+        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};
+
+        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_counter_ = POWERBALL_COUNTER;
+    }
+}
+
+// Establece la velocidad de los globos
+void BalloonManager::setBalloonSpeed(float speed)
+{
+    balloon_speed_ = speed;
+    for (auto &balloon : balloons_)
+    {
+        balloon->setSpeed(speed);
+    }
+}
+
+// Explosiona un globo. Lo destruye y crea otros dos si es el caso
+int BalloonManager::popBalloon(std::shared_ptr<Balloon> balloon)
+{
+    Stage::addPower(1);
+    int score = 0;
+
+    if (balloon->getType() == BalloonType::POWERBALL)
+    {
+        score = destroyAllBalloons();
+        power_ball_enabled_ = false;
+        balloon_deploy_counter_ = 20;
+    }
+    else
+    {
+        score = balloon->getScore();
+        if (balloon->getSize() != BalloonSize::SIZE1)
+        {
+            createChildBalloon(balloon, "LEFT");
+            createChildBalloon(balloon, "RIGHT");
+        }
+
+        // Agrega la explosión y elimina el globo
+        explosions_->add(balloon->getPosX(), balloon->getPosY(), static_cast<int>(balloon->getSize()));
+        balloon->disable();
+    }
+
+    return score;
+}
+
+// Explosiona un globo. Lo destruye = no crea otros globos
+int BalloonManager::destroyBalloon(std::shared_ptr<Balloon> &balloon)
+{
+    int score = 0;
+
+    // Calcula la puntuación y el poder que generaria el globo en caso de romperlo a él y a sus hijos
+    switch (balloon->getSize())
+    {
+    case BalloonSize::SIZE4:
+        score = BALLOON_SCORE[3] + (2 * BALLOON_SCORE[2]) + (4 * BALLOON_SCORE[1]) + (8 * BALLOON_SCORE[0]);
+        break;
+    case BalloonSize::SIZE3:
+        score = BALLOON_SCORE[2] + (2 * BALLOON_SCORE[1]) + (4 * BALLOON_SCORE[0]);
+        break;
+    case BalloonSize::SIZE2:
+        score = BALLOON_SCORE[1] + (2 * BALLOON_SCORE[0]);
+        break;
+    case BalloonSize::SIZE1:
+        score = BALLOON_SCORE[0];
+        break;
+    default:
+        score = 0;
+        break;
+    }
+
+    // Aumenta el poder de la fase
+    Stage::addPower(balloon->getPower());
+
+    // Destruye el globo
+    explosions_->add(balloon->getPosX(), balloon->getPosY(), static_cast<int>(balloon->getSize()));
+    balloon->disable();
+
+    return score;
+}
+
+// Destruye todos los globos
+int BalloonManager::destroyAllBalloons()
+{
+    int score = 0;
+    for (auto &balloon : balloons_)
+    {
+        score += destroyBalloon(balloon);
+    }
+
+    balloon_deploy_counter_ = 300;
+    JA_PlaySound(Resource::get()->getSound("powerball.wav"));
+    Screen::get()->flash(flash_color, 3);
+    Screen::get()->shake();
+
+    return score;
+}
+
+// Detiene todos los globos
+void BalloonManager::stopAllBalloons()
+{
+    for (auto &balloon : balloons_)
+    {
+        balloon->stop();
+    }
+}
+
+// Pone en marcha todos los globos
+void BalloonManager::startAllBalloons()
+{
+    for (auto &balloon : balloons_)
+    {
+        if (!balloon->isBeingCreated())
+        {
+            balloon->start();
+        }
+    }
+}
+
+// Cambia el color de todos los globos
+void BalloonManager::reverseColorsToAllBalloons()
+{
+    for (auto &balloon : balloons_)
+    {
+        if (balloon->isStopped())
+        {
+            balloon->useReverseColor();
+        }
+    }
+}
+
+// Cambia el color de todos los globos
+void BalloonManager::normalColorsToAllBalloons()
+{
+    for (auto &balloon : balloons_)
+    {
+        balloon->useNormalColor();
+    }
+}
+
+// Recarga las texturas
+void BalloonManager::reLoad()
+{
+    for (auto &texture : balloon_textures_)
+    {
+        texture->reLoad();
+    }
+}
+
+// Crea dos globos gordos
+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

@@ -0,0 +1,133 @@
+#pragma once
+
+#include <SDL2/SDL_rect.h>      // Para SDL_Rect
+#include <memory>               // Para shared_ptr, unique_ptr
+#include <string>               // Para string
+#include <vector>               // Para vector
+#include "balloon.h"            // Para BALLOON_SPEED, Balloon
+#include "balloon_formations.h" // Para BalloonFormations
+#include "explosions.h"         // Para Explosions
+#include "param.h"              // Para Param, ParamGame, param
+#include "utils.h"              // Para Zone
+class Texture;                  // lines 10-10
+
+using Balloons = std::vector<std::shared_ptr<Balloon>>;
+
+class BalloonManager
+{
+private:
+    Balloons balloons_;                                     // Vector con los globos
+    std::unique_ptr<Explosions> explosions_;                // Objeto para dibujar explosiones
+    std::unique_ptr<BalloonFormations> balloon_formations_; // Objeto para gestionar las oleadas enemigas
+
+    std::vector<std::shared_ptr<Texture>> balloon_textures_;    // Vector con las texturas de los globos
+    std::vector<std::shared_ptr<Texture>> explosions_textures_; // Vector con las texturas de las explosiones
+
+    std::vector<std::vector<std::string>> balloon_animations_;    // Vector con las animaciones de los globos
+    std::vector<std::vector<std::string>> explosions_animations_; // Vector con las animaciones de las explosiones
+
+    float balloon_speed_ = BALLOON_SPEED[0];         // Velocidad a la que se mueven los enemigos
+    float default_balloon_speed_ = BALLOON_SPEED[0]; // Velocidad base de los enemigos, sin incrementar
+    int balloon_deploy_counter_ = 0;                 // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
+    bool power_ball_enabled_ = false;                // Indica si hay una powerball ya activa
+    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();
+
+public:
+    // Constructor
+    BalloonManager();
+
+    // Destructor
+    ~BalloonManager() = default;
+
+    // Actualiza
+    void update();
+
+    // Renderiza los globos
+    void render();
+
+    // Vacia del vector de globos los globos que ya no sirven
+    void freeBalloons();
+
+    // Crea una formación de enemigos al azar
+    void deployBalloonFormation(int stage);
+
+    // Crea una formación de enemigos específica
+    void deploySet(int set);
+    void deploySet(int set, int y);
+
+    // Actualiza la variable enemyDeployCounter
+    void updateBalloonDeployCounter();
+
+    // Indica si se puede crear una powerball
+    bool canPowerBallBeCreated();
+
+    // Calcula el poder actual de los globos en pantalla
+    int calculateScreenPower();
+
+    // Crea un globo nuevo en el vector de globos
+    std::shared_ptr<Balloon> createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int creation_timer);
+
+    // Crea un globo a partir de otro globo
+    void createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction);
+
+    // Crea una PowerBall
+    void createPowerBall();
+
+    // Establece la velocidad de los globos
+    void setBalloonSpeed(float speed);
+
+    // Explosiona un globo. Lo destruye y crea otros dos si es el caso
+    int popBalloon(std::shared_ptr<Balloon> balloon);
+
+    // Explosiona un globo. Lo destruye = no crea otros globos
+    int destroyBalloon(std::shared_ptr<Balloon> &balloon);
+
+    // Destruye todos los globos
+    int destroyAllBalloons();
+
+    // Detiene todos los globos
+    void stopAllBalloons();
+
+    // Pone en marcha todos los globos
+    void startAllBalloons();
+
+    // Cambia el color de todos los globos
+    void reverseColorsToAllBalloons();
+
+    // Cambia el color de todos los globos
+    void normalColorsToAllBalloons();
+
+    // Recarga las texturas
+    void reLoad();
+
+    // 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/bullet.cpp

@@ -1,36 +1,27 @@
 #include "bullet.h"
-#include <memory>    // for unique_ptr, make_unique, shared_ptr
-#include "param.h"   // for param
-#include "sprite.h"  // for Sprite
-class Texture;
-
-constexpr int BULLET_WIDTH = 12;
-constexpr int BULLET_HEIGHT = 12;
-constexpr int BULLET_VELY = -3;
-constexpr int BULLET_VELX_LEFT = -2;
-constexpr int BULLET_VELX_RIGHT = 2;
+#include <SDL2/SDL_rect.h> // Para SDL_Rect
+#include <memory>          // Para unique_ptr, make_unique, shared_ptr
+#include "param.h"         // Para Param, ParamGame, param
+#include "sprite.h"        // Para Sprite
+class Texture;             // lines 5-5
 
 // Constructor
-Bullet::Bullet(int x, int y, BulletType kind, bool powered_up, int owner, SDL_Rect *play_area, std::shared_ptr<Texture> texture)
-    : sprite_(std::make_unique<Sprite>(texture, SDL_Rect{x, y, BULLET_WIDTH, BULLET_HEIGHT})),
+Bullet::Bullet(int x, int y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture)
+    : sprite_(std::make_unique<Sprite>(texture, SDL_Rect{x, y, BULLET_WIDTH_, BULLET_HEIGHT_})),
       pos_x_(x),
       pos_y_(y),
-      width_(BULLET_WIDTH),
-      height_(BULLET_HEIGHT),
-      vel_x_(0),
-      vel_y_(BULLET_VELY),
-      kind_(kind),
-      owner_(owner),
-      play_area_(play_area)
+      bullet_type_(bullet_type),
+      owner_(owner)
 {
-    vel_x_ = (kind_ == BulletType::LEFT) ? BULLET_VELX_LEFT : (kind_ == BulletType::RIGHT) ? BULLET_VELX_RIGHT
-                                                                                           : 0;
+    vel_x_ = (bullet_type_ == BulletType::LEFT)    ? BULLET_VEL_X_LEFT_
+             : (bullet_type_ == BulletType::RIGHT) ? BULLET_VEL_X_RIGHT_
+                                                   : 0;
 
-    auto sprite_offset = powered_up ? 3 : 0;
-    auto kind_index = static_cast<int>(kind);
-    sprite_->setSpriteClip((kind_index + sprite_offset) * width_, 0, sprite_->getWidth(), sprite_->getHeight());
+    int sprite_offset = powered_up ? 3 : 0;
+    int offset = (static_cast<int>(bullet_type) + sprite_offset) * BULLET_WIDTH_;
+    sprite_->setSpriteClip(offset, 0, BULLET_WIDTH_, BULLET_HEIGHT_);
 
-    collider_.r = width_ / 2;
+    collider_.r = BULLET_WIDTH_ / 2;
     shiftColliders();
 }
 
@@ -44,21 +35,20 @@ void Bullet::render()
 BulletMoveStatus Bullet::move()
 {
     pos_x_ += vel_x_;
-    if (pos_x_ < param.game.play_area.rect.x - width_ || pos_x_ > play_area_->w)
+    if (pos_x_ < param.game.play_area.rect.x - BULLET_WIDTH_ || pos_x_ > param.game.play_area.rect.w)
     {
         disable();
         return BulletMoveStatus::OUT;
     }
 
-    pos_y_ += vel_y_;
-    if (pos_y_ < param.game.play_area.rect.y - height_)
+    pos_y_ += BULLET_VEL_Y_;
+    if (pos_y_ < param.game.play_area.rect.y - BULLET_HEIGHT_)
     {
         disable();
         return BulletMoveStatus::OUT;
     }
 
-    sprite_->setX(pos_x_);
-    sprite_->setY(pos_y_);
+    shiftSprite();
     shiftColliders();
 
     return BulletMoveStatus::OK;
@@ -66,42 +56,12 @@ BulletMoveStatus Bullet::move()
 
 bool Bullet::isEnabled() const
 {
-    return kind_ != BulletType::NONE;
+    return bullet_type_ != BulletType::NONE;
 }
 
 void Bullet::disable()
 {
-    kind_ = BulletType::NONE;
-}
-
-int Bullet::getPosX() const
-{
-    return pos_x_;
-}
-
-int Bullet::getPosY() const
-{
-    return pos_y_;
-}
-
-void Bullet::setPosX(int x)
-{
-    pos_x_ = x;
-}
-
-void Bullet::setPosY(int y)
-{
-    pos_y_ = y;
-}
-
-int Bullet::getVelY() const
-{
-    return vel_y_;
-}
-
-BulletType Bullet::getKind() const
-{
-    return kind_;
+    bullet_type_ = BulletType::NONE;
 }
 
 int Bullet::getOwner() const
@@ -119,3 +79,9 @@ void Bullet::shiftColliders()
     collider_.x = pos_x_ + collider_.r;
     collider_.y = pos_y_ + collider_.r;
 }
+
+void Bullet::shiftSprite()
+{
+    sprite_->setX(pos_x_);
+    sprite_->setY(pos_y_);
+}

source/bullet.h

@@ -1,14 +1,13 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>    // for SDL_Rect
-#include <SDL2/SDL_stdinc.h>  // for Uint8
-#include <memory>             // for shared_ptr, unique_ptr
-#include "sprite.h"           // for Sprite
-#include "utils.h"            // for Circle
-class Texture;
+#include <SDL2/SDL_stdinc.h> // Para Uint8
+#include <memory>			 // Para shared_ptr, unique_ptr
+#include "sprite.h"			 // Para Sprite
+#include "utils.h"			 // Para Circle
+class Texture;				 // lines 8-8
 
-// Enumeración para los diferentes tipos de balas
-enum class BulletType
+// Tipos de balas
+enum class BulletType : Uint8
 {
 	UP,
 	LEFT,
@@ -16,7 +15,7 @@ enum class BulletType
 	NONE
 };
 
-// Enumeración para los resultados del movimiento de la bala
+// Resultado del movimiento de la bala
 enum class BulletMoveStatus : Uint8
 {
 	OK = 0,
@@ -27,26 +26,29 @@ enum class BulletMoveStatus : Uint8
 class Bullet
 {
 private:
+	// Constantes
+	static constexpr int BULLET_WIDTH_ = 12;
+	static constexpr int BULLET_HEIGHT_ = 12;
+	static constexpr int BULLET_VEL_Y_ = -3;
+	static constexpr int BULLET_VEL_X_LEFT_ = -2;
+	static constexpr int BULLET_VEL_X_RIGHT_ = 2;
+
 	std::unique_ptr<Sprite> sprite_; // Sprite con los gráficos y métodos de pintado
 
-	int pos_x_;	   // Posición en el eje X
-	int pos_y_;	   // Posición en el eje Y
-	Uint8 width_;  // Ancho del objeto
-	Uint8 height_; // Alto del objeto
-
+	int pos_x_; // Posición en el eje X
+	int pos_y_; // Posición en el eje Y
 	int vel_x_; // Velocidad en el eje X
-	int vel_y_; // Velocidad en el eje Y
 
-	BulletType kind_;	  // Tipo de objeto
-	int owner_;			  // Identificador del dueño del objeto
-	Circle collider_;	  // Círculo de colisión del objeto
-	SDL_Rect *play_area_; // Rectángulo con la zona de juego
+	BulletType bullet_type_; // Tipo de objeto
+	int owner_;				 // Identificador del dueño del objeto
+	Circle collider_;		 // Círculo de colisión del objeto
 
 	void shiftColliders(); // Alinea el círculo de colisión con el objeto
+	void shiftSprite();	   // Alinea el sprite con el objeto
 
 public:
 	// Constructor
-	Bullet(int x, int y, BulletType kind, bool powered_up, int owner, SDL_Rect *play_area, std::shared_ptr<Texture> texture);
+	Bullet(int x, int y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture);
 
 	// Destructor
 	~Bullet() = default;
@@ -63,17 +65,7 @@ public:
 	// Deshabilita el objeto
 	void disable();
 
-	// Obtiene la posición
-	int getPosX() const;
-	int getPosY() const;
-
-	// Establece la posición
-	void setPosX(int x);
-	void setPosY(int y);
-
 	// Obtiene parámetros
-	int getVelY() const;
-	BulletType getKind() const;
 	int getOwner() const;
 	Circle &getCollider();
 };

source/credits.cpp

@@ -0,0 +1,496 @@
+// 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_timer.h>     // Para SDL_GetTicks
+#include <algorithm>            // Para max, min, clamp
+#include <cstdlib>              // Para abs
+#include <stdexcept>            // Para runtime_error
+#include <string>               // Para basic_string, string
+#include <vector>               // Para vector
+#include "balloon_manager.h"    // Para BalloonManager
+#include "fade.h"               // Para Fade, FadeType, FadeMode
+#include "global_inputs.h"      // Para check, update
+#include "input.h"              // Para Input
+#include "jail_audio.h"         // Para JA_GetMusicState, JA_SetMusicVolume
+#include "lang.h"               // Para getText
+#include "mouse.h"              // Para handleEvent
+#include "param.h"              // Para Param, ParamGame, param
+#include "player.h"             // Para Player, PlayerState
+#include "resource.h"           // Para Resource
+#include "screen.h"             // Para Screen
+#include "section.h"            // Para Name, name, Options, options
+#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,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>())
+{
+    if (!text_texture_)
+    {
+        throw std::runtime_error("Failed to create SDL texture for text.");
+    }
+    section::name = section::Name::CREDITS;
+    balloon_manager_->setPlayArea(play_area_);
+
+    fade_in_->setColor(fade_color.r, fade_color.g, fade_color.b);
+    fade_in_->setType(FadeType::FULLSCREEN);
+    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_->setPostDuration(400);
+
+    initPlayers();
+    SDL_SetTextureBlendMode(text_texture_, SDL_BLENDMODE_BLEND);
+    fillTextTexture();
+    steps_ = std::abs((top_black_rect_.h - param.game.game_area.center_y - 1) + ((left_black_rect_.w - param.game.game_area.center_x) / 4));
+}
+
+// Destructor
+Credits::~Credits()
+{
+    SDL_DestroyTexture(text_texture_);
+    SDL_DestroyTexture(canvas_);
+    resetVolume();
+}
+
+// Bucle principal
+void Credits::run()
+{
+    while (section::name == section::Name::CREDITS)
+    {
+        checkInput();
+        update();
+        checkEvents(); // Tiene que ir antes del render
+        render();
+    }
+}
+
+// Actualiza las variables
+void Credits::update()
+{
+    constexpr Uint32 TICKS_SPEED_ = 15;
+
+    if (SDL_GetTicks() - ticks_ > TICKS_SPEED_)
+    {
+        ticks_ = SDL_GetTicks();
+        const int repeat = want_to_pass_ ? 4 : 1;
+        for (int i = 0; i < repeat; ++i)
+        {
+            tiled_bg_->update();
+            balloon_manager_->update();
+            updateTextureDstRects();
+            throwBalloons();
+            for (auto &player : players_)
+            {
+                player->update();
+            }
+            updateAllFades();
+            ++counter_;
+        }
+        Screen::get()->update();
+        globalInputs::update();
+
+        fillCanvas();
+    }
+}
+
+// Dibuja Credits::en patalla
+void Credits::render()
+{
+    // Prepara para empezar a dibujar en la textura de juego
+    Screen::get()->start();
+
+    // Copia la textura con la zona de juego a la pantalla
+    SDL_RenderCopy(Screen::get()->getRenderer(), canvas_, nullptr, nullptr);
+
+    // Vuelca el contenido del renderizador en pantalla
+    Screen::get()->render();
+}
+
+// Comprueba el manejador de eventos
+void Credits::checkEvents()
+{
+    SDL_Event event;
+
+    // Comprueba los eventos que hay en la cola
+    while (SDL_PollEvent(&event))
+    {
+        // Evento de salida de la aplicación
+        if (event.type == SDL_QUIT)
+        {
+            section::name = section::Name::QUIT;
+            section::options = section::Options::QUIT_FROM_EVENT;
+            break;
+        }
+
+        // Comprueba el cursor
+        Mouse::handleEvent(event);
+    }
+}
+
+// Comprueba las entradas
+void Credits::checkInput()
+{
+    // Comprueba si se ha pulsado cualquier botón (de los usados para jugar)
+    if (Input::get()->checkAnyButtonPressed())
+    {
+        if (mini_logo_on_position_)
+        {
+            // Si el mini_logo ha llegado a su posición final, al pulsar cualquier tecla se activa el fundido
+            fading_ = true;
+        }
+        else
+        {
+            // Si todavía estan los creditos en marcha, se pasan solos a toda pastilla
+            want_to_pass_ = true;
+        }
+    }
+
+    // Comprueba los inputs que se pueden introducir en cualquier sección del juego
+    globalInputs::check();
+}
+
+// Crea la textura con el texto
+void Credits::fillTextTexture()
+{
+    auto text = Resource::get()->getText("smb2");
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), text_texture_);
+
+    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 0, 0, 0);
+    SDL_RenderClear(Screen::get()->getRenderer());
+
+    std::vector<std::string> texts = {
+        lang::getText(121),
+        lang::getText(122),
+        lang::getText(123),
+        lang::getText(124),
+        "JAILDESIGNER",
+        "JAILDOCTOR (INTRO)",
+        "ERIC MATYAS (SOUNDIMAGE.ORG)",
+        "WWW.THEMOTIONMONKEY.CO.UK",
+        "WWW.KENNEY.NL",
+        "JAILDOCTOR"};
+
+    const int space_post_title = 3 + text->getCharacterSize();
+    const int space_pre_title = text->getCharacterSize() * 4;
+    const int texts_height = 1 * text->getCharacterSize() + 7 * space_post_title + 3 * space_pre_title;
+    credits_rect_dst_.h = credits_rect_src_.h = texts_height;
+
+    int y = (param.game.height - texts_height) / 2;
+    y = 0;
+    text->setPalette(1);
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(0), 1, no_color, 1, shdw_txt_color);
+
+    text->setPalette(0);
+    y += space_post_title;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(4), 1, no_color, 1, shdw_txt_color);
+
+    y += space_pre_title;
+    text->setPalette(1);
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(1), 1, no_color, 1, shdw_txt_color);
+    text->setPalette(0);
+    y += space_post_title;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(4), 1, no_color, 1, shdw_txt_color);
+
+    y += space_pre_title;
+    text->setPalette(1);
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(2), 1, no_color, 1, shdw_txt_color);
+    text->setPalette(0);
+
+    y += space_post_title;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(5), 1, no_color, 1, shdw_txt_color);
+    y += space_post_title;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(6), 1, no_color, 1, shdw_txt_color);
+
+    y += space_pre_title;
+    text->setPalette(1);
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(3), 1, no_color, 1, shdw_txt_color);
+    text->setPalette(0);
+    y += space_post_title;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(7), 1, no_color, 1, shdw_txt_color);
+    y += space_post_title;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(8), 1, no_color, 1, shdw_txt_color);
+    y += space_post_title;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(9), 1, no_color, 1, shdw_txt_color);
+
+    // Mini logo
+    y += space_pre_title;
+    mini_logo_rect_src_.y = y;
+    auto mini_logo_sprite = std::make_unique<Sprite>(Resource::get()->getTexture("logo_jailgames_mini.png"));
+    mini_logo_sprite->setPosition(1 + param.game.game_area.center_x - mini_logo_sprite->getWidth() / 2, 1 + y);
+    Resource::get()->getTexture("logo_jailgames_mini.png")->setColor(shdw_txt_color.r, shdw_txt_color.g, shdw_txt_color.b);
+    mini_logo_sprite->render();
+
+    mini_logo_sprite->setPosition(param.game.game_area.center_x - mini_logo_sprite->getWidth() / 2, y);
+    Resource::get()->getTexture("logo_jailgames_mini.png")->setColor(255, 255, 255);
+    mini_logo_sprite->render();
+
+    // Texto con el copyright
+    y += mini_logo_sprite->getHeight() + 3;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, TEXT_COPYRIGHT, 1, no_color, 1, shdw_txt_color);
+
+    // Resetea el renderizador
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), nullptr);
+
+    // Actualiza las variables
+    mini_logo_rect_dst_.h = mini_logo_rect_src_.h = mini_logo_sprite->getHeight() + 3 + text->getCharacterSize();
+    credits_rect_dst_.y = param.game.game_area.rect.h;
+    mini_logo_rect_dst_.y = credits_rect_dst_.y + credits_rect_dst_.h + 30;
+    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()
+{
+    if (counter_ % 10 == 0)
+    {
+        // Comprueba la posición de la textura con los titulos de credito
+        if (credits_rect_dst_.y + credits_rect_dst_.h > play_area_.y)
+        {
+            --credits_rect_dst_.y;
+        }
+
+        // Comprueba la posición de la textura con el mini_logo
+        if (mini_logo_rect_dst_.y == mini_logo_final_pos_)
+        {
+            mini_logo_on_position_ = true;
+
+            // Si el jugador quiere pasar los titulos de credito, el fade se inicia solo
+            if (want_to_pass_)
+            {
+                fading_ = true;
+            }
+
+            // Se activa el contador para evitar que la sección sea infinita
+            if (counter_prevent_endless_ == 1000)
+            {
+                fading_ = true;
+            }
+            else
+            {
+                ++counter_prevent_endless_;
+            }
+        }
+        else
+        {
+            --mini_logo_rect_dst_.y;
+        }
+    }
+}
+
+// Tira globos al escenario
+void Credits::throwBalloons()
+{
+    constexpr int speed = 200;
+    const std::vector<int> sets = {0, 63, 25, 67, 17, 75, 13, 50};
+
+    if (counter_ > ((sets.size() - 1) * speed) * 3)
+    {
+        return;
+    }
+
+    if (counter_ % speed == 0)
+    {
+        const int index = (counter_ / speed) % sets.size();
+        balloon_manager_->deploySet(sets.at(index), -60);
+    }
+
+    if (counter_ % (speed * 4) == 0 && counter_ > 0)
+    {
+        balloon_manager_->createPowerBall();
+    }
+}
+
+// Inicializa los jugadores
+void Credits::initPlayers()
+{
+    std::vector<std::vector<std::shared_ptr<Texture>>> player_textures; // Vector con todas las texturas de los jugadores;
+    std::vector<std::vector<std::string>> player_animations;            // Vector con las animaciones del jugador
+
+    // Texturas - Player1
+    {
+        std::vector<std::shared_ptr<Texture>> player_texture;
+        player_texture.emplace_back(Resource::get()->getTexture("player1.gif"));
+        player_texture.emplace_back(Resource::get()->getTexture("player1_power.png"));
+        player_textures.push_back(player_texture);
+    }
+
+    // Texturas - Player2
+    {
+        std::vector<std::shared_ptr<Texture>> player_texture;
+        player_texture.emplace_back(Resource::get()->getTexture("player2.gif"));
+        player_texture.emplace_back(Resource::get()->getTexture("player2_power.png"));
+        player_textures.push_back(player_texture);
+    }
+
+    // Animaciones -- Jugador
+    {
+        player_animations.emplace_back(Resource::get()->getAnimation("player.ani"));
+        player_animations.emplace_back(Resource::get()->getAnimation("player_power.ani"));
+    }
+
+    // Crea los dos jugadores
+    constexpr int player_width = 30;
+    const int y = play_area_.y + play_area_.h - player_width;
+    constexpr bool demo = false;
+    constexpr int away_distance = 700;
+    players_.emplace_back(std::make_unique<Player>(1, play_area_.x - away_distance - player_width, y, demo, play_area_, player_textures.at(0), player_animations));
+    players_.back()->setWalkingState(PlayerState::WALKING_RIGHT);
+    players_.back()->setPlayingState(PlayerState::CREDITS);
+    players_.back()->setInvulnerable(false);
+
+    players_.emplace_back(std::make_unique<Player>(2, play_area_.x + play_area_.w + away_distance, y, demo, play_area_, player_textures.at(1), player_animations));
+    players_.back()->setWalkingState(PlayerState::WALKING_LEFT);
+    players_.back()->setPlayingState(PlayerState::CREDITS);
+    players_.back()->setInvulnerable(false);
+}
+
+// Actualiza los rectangulos negros
+void Credits::updateBlackRects()
+{
+    static int current_step = steps_;
+    if (top_black_rect_.h != param.game.game_area.center_y - 1 && bottom_black_rect_.y != param.game.game_area.center_y + 1)
+    {
+        // Si los rectangulos superior e inferior no han llegado al centro
+        if (counter_ % 4 == 0)
+        {
+            // Incrementa la altura del rectangulo superior
+            top_black_rect_.h = std::min(top_black_rect_.h + 1, param.game.game_area.center_y - 1);
+
+            // Incrementa la altura y modifica la posición del rectangulo inferior
+            ++bottom_black_rect_.h;
+            bottom_black_rect_.y = std::max(bottom_black_rect_.y - 1, param.game.game_area.center_y + 1);
+
+            --current_step;
+            setVolume(static_cast<int>(initial_volume_ * current_step / steps_));
+        }
+    }
+    else
+    {
+        // Si los rectangulos superior e inferior han llegado al centro
+        if (left_black_rect_.w != param.game.game_area.center_x && right_black_rect_.x != param.game.game_area.center_x)
+        {
+            // Si los rectangulos izquierdo y derecho no han llegado al centro
+            // Incrementa la anchura del rectangulo situado a la izquierda
+            left_black_rect_.w = std::min(left_black_rect_.w + 4, param.game.game_area.center_x);
+
+            // Incrementa la anchura y modifica la posición del rectangulo situado a la derecha
+            right_black_rect_.w += 4;
+            right_black_rect_.x = std::max(right_black_rect_.x - 4, param.game.game_area.center_x);
+
+            --current_step;
+            setVolume(static_cast<int>(initial_volume_ * current_step / steps_));
+        }
+        else
+        {
+            // Si los rectangulos izquierdo y derecho han llegado al centro
+            setVolume(0);
+            JA_StopMusic();
+            if (counter_pre_fade_ == 400)
+            {
+                fade_out_->activate();
+            }
+            else
+            {
+                ++counter_pre_fade_;
+            }
+        }
+    }
+}
+
+// Actualiza el estado de fade
+void Credits::updateAllFades()
+{
+    if (fading_)
+    {
+        updateBlackRects();
+    }
+
+    fade_in_->update();
+    if (fade_in_->hasEnded())
+    {
+        if (JA_GetMusicState() == JA_MUSIC_INVALID || JA_GetMusicState() == JA_MUSIC_STOPPED)
+        {
+            JA_PlayMusic(Resource::get()->getMusic("credits.ogg"));
+        }
+    }
+
+    fade_out_->update();
+    if (fade_out_->hasEnded())
+    {
+        section::name = section::Name::LOGO;
+    }
+}
+
+// Establece el nivel de volumen
+void Credits::setVolume(int amount)
+{
+    options.audio.music.volume = std::clamp(amount, 0, 100);
+    JA_SetMusicVolume(to_JA_volume(options.audio.music.volume));
+}
+
+// Reestablece el nivel de volumen
+void Credits::resetVolume()
+{
+    options.audio.music.volume = initial_volume_;
+    JA_SetMusicVolume(to_JA_volume(options.audio.music.volume));
+}

source/credits.h

@@ -0,0 +1,106 @@
+#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, shared_ptr
+#include <vector>            // Para vector
+#include "options.h"         // Para Options, OptionsAudio, OptionsMusic
+#include "param.h"           // Para Param, ParamGame, param
+#include "utils.h"           // Para Zone
+class BalloonManager;        // lines 8-8
+class Fade;                  // lines 11-11
+class Player;                // lines 10-10
+class TiledBG;               // lines 9-9
+
+constexpr int PLAY_AREA_HEIGHT = 200;
+
+class Credits
+{
+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
+    std::vector<std::shared_ptr<Player>> players_;    // Vector con los jugadores
+
+    // Variables
+    Uint32 ticks_ = 0;                                                           // Contador de ticks para ajustar la velocidad del programa
+    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
+    int black_bars_size_ = (param.game.game_area.rect.h - PLAY_AREA_HEIGHT) / 2; // Tamaño de las barras negras
+    int mini_logo_final_pos_ = 0;                                                // Ubicación donde se detiene el minilogo
+    bool fading_ = false;                                                        // Indica si se está realizando el fade final
+    bool want_to_pass_ = false;                                                  // Indica si el jugador quiere saltarse los titulos de crédito
+    bool mini_logo_on_position_ = false;                                         // Indica si el minilogo ya se ha quedado en su posición
+    int initial_volume_ = options.audio.music.volume;                            // Volumen actual al crear el objeto
+    int steps_ = 0;                                                              // Cantidad de pasos a dar para ir reduciendo el audio
+
+    // Rectangulos
+    SDL_Rect credits_rect_src_ = param.game.game_area.rect;   // Rectangulo con el texto de los créditos (origen)
+    SDL_Rect credits_rect_dst_ = param.game.game_area.rect;   // Rectangulo con el texto de los créditos (destino)
+    SDL_Rect mini_logo_rect_src_ = param.game.game_area.rect; // Rectangulo con el mini logo de JailGames y el texto de copyright (origen)
+    SDL_Rect mini_logo_rect_dst_ = param.game.game_area.rect; // Rectangulo con el mini logo de JailGames y el texto de copyright (destino)
+    SDL_Rect play_area_ = {
+        param.game.game_area.rect.x,
+        param.game.game_area.rect.y + black_bars_size_,
+        param.game.game_area.rect.w,
+        PLAY_AREA_HEIGHT};                                                                                                        // Area visible para los creditos
+    SDL_Rect top_black_rect_ = {play_area_.x, param.game.game_area.rect.y, play_area_.w, black_bars_size_};                       // Rectangulo negro superior
+    SDL_Rect bottom_black_rect_ = {play_area_.x, param.game.game_area.rect.h - black_bars_size_, play_area_.w, black_bars_size_}; // Rectangulo negro inferior
+    SDL_Rect left_black_rect_ = {play_area_.x, param.game.game_area.center_y - 1, 0, 2};                                          // Rectangulo negro situado a la izquierda
+    SDL_Rect right_black_rect_ = {play_area_.x + play_area_.w, param.game.game_area.center_y - 1, 0, 2};                          // Rectangulo negro situado a la derecha
+
+    // Actualiza las variables
+    void update();
+
+    // Dibuja en pantalla
+    void render();
+
+    // Comprueba el manejador de eventos
+    void checkEvents();
+
+    // Comprueba las entradas
+    void checkInput();
+
+    // 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();
+
+    // Tira globos al escenario
+    void throwBalloons();
+
+    // Inicializa los jugadores
+    void initPlayers();
+
+    // Actualiza los rectangulos negros
+    void updateBlackRects();
+
+    // Actualiza el estado de fade
+    void updateAllFades();
+
+    // Establece el nivel de volumen
+    void setVolume(int amount);
+
+    // Reestablece el nivel de volumen
+    void resetVolume();
+
+public:
+    // Constructor
+    Credits();
+
+    // Destructor
+    ~Credits();
+
+    // Bucle principal
+    void run();
+};

source/dbgtxt.cpp

@@ -1,7 +1,7 @@
 #include "dbgtxt.h"
-#include <SDL2/SDL_rect.h>     // for SDL_Rect
-#include <SDL2/SDL_rwops.h>    // for SDL_RWFromMem
-#include <SDL2/SDL_surface.h>  // for SDL_LoadBMP_RW
+#include <SDL2/SDL_rect.h>    // para SDL_Rect
+#include <SDL2/SDL_rwops.h>   // para SDL_RWFromMem
+#include <SDL2/SDL_surface.h> // para SDL_LoadBMP_RW
 
 namespace
 {

source/dbgtxt.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <SDL2/SDL_render.h>  // for SDL_Renderer
-#include <SDL2/SDL_stdinc.h>  // for Uint8
+#include <SDL2/SDL_render.h> // para SDL_Renderer
+#include <SDL2/SDL_stdinc.h> // para Uint8
 
 void dbg_init(SDL_Renderer *renderer);
 void dbg_print(int x, int y, const char *text, Uint8 r, Uint8 g, Uint8 b);

source/define_buttons.cpp

@@ -1,58 +1,26 @@
 #include "define_buttons.h"
-#include <utility>   // for move
-#include "input.h"   // for Input, InputType
-#include "lang.h"    // for getText
-#include "options.h" // for options
-#include "param.h"   // for param
-#include "section.h" // for Name, Options, name, options
-#include "text.h"    // for Text
-#include "utils.h"   // for OptionsController, Options, Param, ParamGame
+#include "input.h"    // Para Input, InputType
+#include "lang.h"     // Para getText
+#include "options.h"  // Para OptionsController, Options, options
+#include "param.h"    // Para Param, param, ParamGame, ParamTitle
+#include "resource.h" // Para Resource
+#include "section.h"  // Para Name, Options, name, options
+#include "text.h"     // Para Text
 
 // Constructor
-DefineButtons::DefineButtons(std::unique_ptr<Text> text_)
-    : text_(std::move(text_))
+DefineButtons::DefineButtons()
+    : input_(Input::get()),
+      text_(Resource::get()->getText("8bithud"))
 {
-    // Copia punteros a los objetos
-    input_ = Input::get();
-
     // Inicializa variables
-    enabled_ = false;
     x_ = param.game.width / 2;
     y_ = param.title.press_start_position;
-    index_controller_ = 0;
-    index_button_ = 0;
 
-    buttons_.clear();
-    DefineButtonsButton button;
-
-    button.label = lang::getText(95);
-    button.input = InputType::FIRE_LEFT;
-    button.button = SDL_CONTROLLER_BUTTON_X;
-    buttons_.push_back(button);
-
-    button.label = lang::getText(96);
-    button.input = InputType::FIRE_CENTER;
-    button.button = SDL_CONTROLLER_BUTTON_Y;
-    buttons_.push_back(button);
-
-    button.label = lang::getText(97);
-    button.input = InputType::FIRE_RIGHT;
-    button.button = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
-    buttons_.push_back(button);
-
-    button.label = lang::getText(98);
-    button.input = InputType::START;
-    button.button = SDL_CONTROLLER_BUTTON_START;
-    buttons_.push_back(button);
-
-    button.label = lang::getText(99);
-    button.input = InputType::EXIT;
-    button.button = SDL_CONTROLLER_BUTTON_BACK;
-    buttons_.push_back(button);
+    clearButtons();
 
     for (int i = 0; i < input_->getNumControllers(); ++i)
     {
-        controller_names_.push_back(input_->getControllerName(i));
+        controller_names_.emplace_back(input_->getControllerName(i));
     }
 }
 
@@ -61,38 +29,40 @@ void DefineButtons::render()
 {
     if (enabled_)
     {
-        text_->writeCentered(x_, y_ - 10, lang::getText(100) + std::to_string(options.controller[index_controller_].player_id));
-        text_->writeCentered(x_, y_, controller_names_[index_controller_]);
-        text_->writeCentered(x_, y_ + 10, buttons_[index_button_].label);
+        text_->writeCentered(x_, y_ - 10, lang::getText(100) + std::to_string(options.controllers.at(index_controller_).player_id));
+        text_->writeCentered(x_, y_, controller_names_.at(index_controller_));
+        text_->writeCentered(x_, y_ + 10, buttons_.at(index_button_).label);
     }
 }
 
 // Comprueba el botón que se ha pulsado
-void DefineButtons::doControllerButtonDown(SDL_ControllerButtonEvent *event)
+void DefineButtons::doControllerButtonDown(const SDL_ControllerButtonEvent &event)
 {
-    int i = input_->getJoyIndex(event->which);
-
-    // Solo pillamos botones del mando que toca
-    if (i != index_controller_)
+    // Solo pilla botones del mando que toca
+    if (input_->getJoyIndex(event.which) != static_cast<int>(index_controller_))
     {
         return;
     }
 
-    buttons_[index_button_].button = (SDL_GameControllerButton)event->button;
-    incIndexButton();
+    const auto button = static_cast<SDL_GameControllerButton>(event.button);
+    if (checkButtonNotInUse(button))
+    {
+        buttons_.at(index_button_).button = button;
+        incIndexButton();
+    }
 }
 
 // Asigna los botones definidos al input_
 void DefineButtons::bindButtons()
 {
-    for (int i = 0; i < (int)buttons_.size(); ++i)
+    for (const auto &button : buttons_)
     {
-        input_->bindGameControllerButton(index_controller_, buttons_[i].input, buttons_[i].button);
+        input_->bindGameControllerButton(index_controller_, button.input, button.button);
     }
 }
 
-// Comprueba las entradas
-void DefineButtons::checkInput()
+// Comprueba los eventos
+void DefineButtons::checkEvents()
 {
     if (enabled_)
     {
@@ -109,13 +79,11 @@ void DefineButtons::checkInput()
                 section::options = section::Options::QUIT_WITH_KEYBOARD;
                 break;
             }
-
             case SDL_CONTROLLERBUTTONDOWN:
             {
-                doControllerButtonDown(&event.cbutton);
+                doControllerButtonDown(event.cbutton);
                 break;
             }
-
             default:
                 break;
             }
@@ -131,6 +99,7 @@ bool DefineButtons::enable(int index)
         enabled_ = true;
         index_controller_ = index;
         index_button_ = 0;
+        clearButtons();
         return true;
     }
 
@@ -138,18 +107,15 @@ bool DefineButtons::enable(int index)
 }
 
 // Comprueba si está habilitado
-bool DefineButtons::isEnabled()
-{
-    return enabled_;
-}
+bool DefineButtons::isEnabled() { return enabled_; }
 
 // Incrementa el indice de los botones
 void DefineButtons::incIndexButton()
 {
-    index_button_++;
+    ++index_button_;
 
     // Comprueba si ha finalizado
-    if (index_button_ == (int)buttons_.size())
+    if (index_button_ == buttons_.size())
     {
         // Asigna los botones definidos al input_
         bindButtons();
@@ -157,11 +123,7 @@ void DefineButtons::incIndexButton()
         // Guarda los cambios en las opciones
         saveBindingsToOptions();
 
-        // input_->allActive(index_controller_);
-
-        // Reinicia variables
-        index_button_ = 0;
-        index_controller_ = 0;
+        // Deshabilita
         enabled_ = false;
     }
 }
@@ -170,17 +132,34 @@ void DefineButtons::incIndexButton()
 void DefineButtons::saveBindingsToOptions()
 {
     // Modifica las opciones para colocar los valores asignados
-    options.controller[index_controller_].name = input_->getControllerName(index_controller_);
-    for (int j = 0; j < (int)options.controller[index_controller_].inputs.size(); ++j)
+    auto &controller = options.controllers.at(index_controller_);
+    controller.name = input_->getControllerName(index_controller_);
+    for (size_t j = 0; j < controller.inputs.size(); ++j)
     {
-        options.controller[index_controller_].buttons[j] = input_->getControllerBinding(index_controller_, options.controller[index_controller_].inputs[j]);
+        controller.buttons.at(j) = input_->getControllerBinding(index_controller_, controller.inputs.at(j));
     }
 }
 
-// Intercambia los jugadores asignados a los dos primeros mandos
-void DefineButtons::swapControllers()
+// Comprueba que un botón no esté ya asignado
+bool DefineButtons::checkButtonNotInUse(SDL_GameControllerButton button)
 {
-    const int temp = options.controller[0].player_id;
-    options.controller[0].player_id = options.controller[1].player_id;
-    options.controller[1].player_id = temp;
+    for (const auto &b : buttons_)
+    {
+        if (b.button == button)
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+// Limpia la asignación de botones
+void DefineButtons::clearButtons()
+{
+    buttons_.clear();
+    buttons_.emplace_back(lang::getText(95), InputType::FIRE_LEFT, SDL_CONTROLLER_BUTTON_INVALID);
+    buttons_.emplace_back(lang::getText(96), InputType::FIRE_CENTER, SDL_CONTROLLER_BUTTON_INVALID);
+    buttons_.emplace_back(lang::getText(97), InputType::FIRE_RIGHT, SDL_CONTROLLER_BUTTON_INVALID);
+    buttons_.emplace_back(lang::getText(98), InputType::START, SDL_CONTROLLER_BUTTON_INVALID);
+    buttons_.emplace_back(lang::getText(99), InputType::SERVICE, SDL_CONTROLLER_BUTTON_INVALID);
 }

source/define_buttons.h

@@ -1,19 +1,24 @@
 #pragma once
 
-#include <SDL2/SDL_events.h>          // for SDL_ControllerButtonEvent
-#include <SDL2/SDL_gamecontroller.h>  // for SDL_GameControllerButton
-#include <memory>                     // for shared_ptr, unique_ptr
-#include <string>                     // for string
-#include <vector>                     // for vector
-class Input;
-class Text;
-enum class InputType : int;
+#include <SDL2/SDL_events.h>         // Para SDL_ControllerButtonEvent
+#include <SDL2/SDL_gamecontroller.h> // Para SDL_GameControllerButton
+#include <stddef.h>                  // Para size_t
+#include <memory>                    // Para shared_ptr, unique_ptr
+#include <string>                    // Para string
+#include <vector>                    // Para vector
+class Input;                         // lines 8-8
+class Text;                          // lines 9-9
+enum class InputType : int;          // lines 10-10
 
 struct DefineButtonsButton
 {
     std::string label;               // Texto en pantalla para el botón
     InputType input;                 // Input asociado
     SDL_GameControllerButton button; // Botón del mando correspondiente
+
+    // Constructor
+    DefineButtonsButton(const std::string &lbl, InputType inp, SDL_GameControllerButton btn)
+        : label(lbl), input(inp), button(btn) {}
 };
 
 // Clase Bullet
@@ -25,19 +30,19 @@ private:
     std::shared_ptr<Text> text_; // Objeto para escribir texto
 
     // Variables
-    bool enabled_;                              // Indica si el objeto está habilitado
+    bool enabled_ = false;                      // Indica si el objeto está habilitado
     int x_;                                     // Posición donde dibujar el texto
     int y_;                                     // Posición donde dibujar el texto
     std::vector<DefineButtonsButton> buttons_;  // Vector con las nuevas definiciones de botones/acciones
-    int index_controller_;                      // Indice del controlador a reasignar
-    int index_button_;                          // Indice para saber qué bot´çon se está definiendo
+    size_t index_controller_ = 0;               // Indice del controlador a reasignar
+    size_t index_button_ = 0;                   // Indice para saber qué botón se está definiendo
     std::vector<std::string> controller_names_; // Nombres de los mandos
 
     // Incrementa el indice de los botones
     void incIndexButton();
 
     // Comprueba el botón que se ha pulsado
-    void doControllerButtonDown(SDL_ControllerButtonEvent *event);
+    void doControllerButtonDown(const SDL_ControllerButtonEvent &event);
 
     // Asigna los botones definidos al input
     void bindButtons();
@@ -45,9 +50,15 @@ private:
     // Guarda los cambios en las opciones
     void saveBindingsToOptions();
 
+    // Comprueba que un botón no esté ya asignado
+    bool checkButtonNotInUse(SDL_GameControllerButton button);
+
+    // Limpia la asignación de botones
+    void clearButtons();
+
 public:
     // Constructor
-    explicit DefineButtons(std::unique_ptr<Text> text);
+    DefineButtons();
 
     // Destructor
     ~DefineButtons() = default;
@@ -55,15 +66,12 @@ public:
     // Dibuja el objeto en pantalla
     void render();
 
-    // Comprueba las entradas
-    void checkInput();
+    // Comprueba los eventos
+    void checkEvents();
 
     // Habilita el objeto
     bool enable(int index);
 
     // Comprueba si está habilitado
     bool isEnabled();
-
-    // Intercambia los jugadores asignados a los dos primeros mandos
-    void swapControllers();
 };

source/director.cpp

@@ -1,48 +1,49 @@
+// IWYU pragma: no_include <bits/chrono.h>
 #include "director.h"
-#include <SDL2/SDL.h>				 // for SDL_Init, SDL_Quit, SDL_INIT_EV...
-#include <SDL2/SDL_audio.h>			 // for AUDIO_S16
-#include <SDL2/SDL_blendmode.h>		 // for SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_error.h>			 // for SDL_GetError
-#include <SDL2/SDL_gamecontroller.h> // for SDL_CONTROLLER_BUTTON_B, SDL_CO...
-#include <SDL2/SDL_hints.h>			 // for SDL_SetHint, SDL_HINT_RENDER_DR...
-#include <SDL2/SDL_scancode.h>		 // for SDL_SCANCODE_0, SDL_SCANCODE_DOWN
-#include <SDL2/SDL_stdinc.h>		 // for SDL_bool, Uint32
-#include <SDL2/SDL_timer.h>			 // for SDL_GetTicks
-#include <cstdlib>					 // for system
-#include <errno.h>					 // for errno, EEXIST, EACCES, ENAMETOO...
-#include <stdio.h>					 // for printf, perror
-#include <string.h>					 // for strcmp
-#include <sys/stat.h>				 // for mkdir, stat, S_IRWXU
-#include <unistd.h>					 // for getuid
-#include <cstdlib>					 // for exit, EXIT_FAILURE, rand, srand
-#include <iostream>					 // for basic_ostream, operator<<, cout
-#include <memory>					 // for make_unique, unique_ptr
-#include <string>					 // for operator+, allocator, char_traits
-#include "asset.h"					 // for Asset, AssetType
-#include "dbgtxt.h"					 // for dbg_init
-#include "game.h"					 // for Game, GAME_MODE_DEMO_OFF, GAME_...
-#include "global_inputs.h"			 // for init
-#include "hiscore_table.h"			 // for HiScoreTable
-#include "input.h"					 // for Input, InputType
-#include "instructions.h"			 // for Instructions
-#include "intro.h"					 // for Intro
-#include "jail_audio.h"				 // for JA_LoadMusic, JA_LoadSound, JA_...
-#include "lang.h"					 // for Code, loadFromFile
-#include "logo.h"					 // for Logo
-#include "manage_hiscore_table.h"	 // for ManageHiScoreTable
-#include "notifier.h"				 // for Notifier
-#include "on_screen_help.h"			 // for OnScreenHelp
-#include "options.h"				 // for options, loadOptionsFile, saveO...
-#include "param.h"					 // for param, loadParamsFromFile
-#include "resource.h"				 //for Resource
-#include "screen.h"					 // for Screen
-#include "section.h"				 // for Name, name, Options, options
-#include "title.h"					 // for Title
-#include "utils.h"					 // for MusicFile, SoundFile, Options
-
+#include <SDL2/SDL.h>				 // Para SDL_Init, SDL_Quit, SDL_INIT_EV...
+#include <SDL2/SDL_audio.h>			 // Para AUDIO_S16
+#include <SDL2/SDL_blendmode.h>		 // Para SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_error.h>			 // Para SDL_GetError
+#include <SDL2/SDL_gamecontroller.h> // Para SDL_CONTROLLER_BUTTON_B, SDL_CO...
+#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 <errno.h>					 // Para errno, EEXIST, EACCES, ENAMETOO...
 #ifndef _WIN32
-#include <pwd.h> // for 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[])
@@ -52,8 +53,9 @@ Director::Director(int argc, const char *argv[])
 	section::options = section::Options::GAME_PLAY_1P;
 #elif DEBUG
 	section::name = section::Name::LOGO;
-#else
+#else // NORMAL GAME
 	section::name = section::Name::LOGO;
+	section::attract_mode = section::AttractMode::TITLE_TO_DEMO;
 #endif
 
 #ifndef VERBOSE
@@ -64,62 +66,50 @@ Director::Director(int argc, const char *argv[])
 
 	std::cout << "Game start" << std::endl;
 
+	// Inicia la semilla aleatoria
+	unsigned int seed = static_cast<unsigned int>(std::chrono::system_clock::now().time_since_epoch().count());
+	std::srand(seed);
+
 	// Comprueba los parametros del programa
 	checkProgramArguments(argc, argv);
 
-	// Crea la carpeta del sistema donde guardar datos
+	// Crea la carpeta del sistema donde guardar los datos persistentes
 	createSystemFolder("jailgames");
 	createSystemFolder("jailgames/coffee_crisis_arcade_edition");
 
-	// Crea el objeto que controla los ficheros de recursos
-	Asset::init(executable_path_);
-
-	// Crea el indice de ficheros
-	setFileList();
-
-	// Carga el fichero de configuración
-	loadOptionsFile(Asset::get()->get("config.txt"));
-
-	// Carga los parametros para configurar el juego
-#ifdef ANBERNIC
-	const std::string paramFilePath = asset->get("param_320x240.txt");
-#else
-	const std::string paramFilePath = param_file_argument_ == "--320x240" ? Asset::get()->get("param_320x240.txt") : Asset::get()->get("param_320x256.txt");
-#endif
-	loadParams(paramFilePath);
-
-	// Carga el fichero de puntuaciones
-	auto manager = std::make_unique<ManageHiScoreTable>(&options.game.hi_score_table);
-	manager->loadFromFile(Asset::get()->get("score.bin"));
-
-	// Inicializa SDL
-	initSDL();
-
-	// Inicializa JailAudio
-	initJailAudio();
-
-	// Inicializa el texto de debug
-	dbg_init(renderer_);
-
-	// Crea los objetos
-	lang::loadFromFile(getLangFile((lang::Code)options.game.language));
-
-	Screen::init(window_, renderer_);
-
-	Resource::init();
-
-	Input::init(Asset::get()->get("gamecontrollerdb.txt"));
-	bindInputs();
-
-	auto notifier_text = std::make_shared<Text>(Resource::get()->getTexture("8bithud.png"), Resource::get()->getTextFile("8bithud.txt"));
-	Notifier::init(std::string(), notifier_text, Asset::get()->get("notify.wav"));
-
-	OnScreenHelp::init();
-
-	globalInputs::init();
+	init();
 }
 
 Director::~Director()
+{
+	close();
+	std::cout << "\nBye!" << std::endl;
+}
+
+// Inicializa todo
+void Director::init()
+{
+	Asset::init(executable_path_);					  // Crea el objeto que controla los ficheros de recursos
+	setFileList();									  // Crea el indice de ficheros
+	loadOptionsFile(Asset::get()->get("config.txt")); // Carga el fichero de configuración
+	loadParams();									  // Carga los parametros
+	loadScoreFile();								  // Carga el fichero de puntuaciones
+
+	// Inicializa y crea el resto de objetos
+	initSDL();
+	initJailAudio();
+	dbg_init(renderer_);
+	lang::loadFromFile(getLangFile(static_cast<lang::Code>(options.game.language)));
+	Screen::init(window_, renderer_);
+	Resource::init();
+	Input::init(Asset::get()->get("gamecontrollerdb.txt"));
+	bindInputs();
+	Notifier::init(std::string(), Resource::get()->getText("8bithud"));
+	OnScreenHelp::init();
+}
+
+// Cierra todo
+void Director::close()
 {
 	saveOptionsFile(Asset::get()->get("config.txt"));
 
@@ -130,12 +120,38 @@ Director::~Director()
 	Notifier::destroy();
 	OnScreenHelp::destroy();
 
+	JA_Quit();
+
 	SDL_DestroyRenderer(renderer_);
 	SDL_DestroyWindow(window_);
 
 	SDL_Quit();
+}
 
-	std::cout << "\nBye!" << std::endl;
+// Carga los parametros
+void Director::loadParams()
+{
+	// Carga los parametros para configurar el juego
+#ifdef ANBERNIC
+	const std::string paramFilePath = asset->get("param_320x240.txt");
+#else
+	const std::string paramFilePath = overrides.param_file == "--320x240" ? Asset::get()->get("param_320x240.txt") : Asset::get()->get("param_320x256.txt");
+#endif
+	loadParamsFromFile(paramFilePath);
+}
+
+// Carga el fichero de puntuaciones
+void Director::loadScoreFile()
+{
+	auto manager = std::make_unique<ManageHiScoreTable>(options.game.hi_score_table);
+	if (overrides.clear_hi_score_table)
+	{
+		manager->clear();
+	}
+	else
+	{
+		manager->loadFromFile(Asset::get()->get("score.bin"));
+	}
 }
 
 // Asigna los botones y teclas al objeto Input
@@ -162,7 +178,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::SHOWINFO, SDL_SCANCODE_F6);
+	Input::get()->bindKey(InputType::AUTO_FIRE, SDL_SCANCODE_F6);
+	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
@@ -183,27 +201,23 @@ void Director::bindInputs()
 
 		// Mando - Control del programa
 		Input::get()->bindGameControllerButton(i, InputType::SERVICE, SDL_CONTROLLER_BUTTON_BACK);
-		Input::get()->bindGameControllerButton(i, InputType::EXIT, InputType::START);
-		Input::get()->bindGameControllerButton(i, InputType::PAUSE, InputType::FIRE_RIGHT);
-		Input::get()->bindGameControllerButton(i, InputType::VIDEO_SHADERS, InputType::FIRE_LEFT);
-		Input::get()->bindGameControllerButton(i, InputType::MUTE, InputType::LEFT);
-		Input::get()->bindGameControllerButton(i, InputType::SHOWINFO, InputType::RIGHT);
-		Input::get()->bindGameControllerButton(i, InputType::RESET, InputType::FIRE_CENTER);
-		Input::get()->bindGameControllerButton(i, InputType::CONFIG, InputType::DOWN);
-		Input::get()->bindGameControllerButton(i, InputType::SWAP_CONTROLLERS, InputType::UP);
 	}
 
 	// Mapea las asignaciones a los botones desde el archivo de configuración, si se da el caso
-	for (int i = 0; i < num_gamepads; ++i)
-		for (int index = 0; index < (int)options.controller.size(); ++index)
-			if (Input::get()->getControllerName(i) == options.controller[index].name)
+	const size_t max_controllers = std::min(2, num_gamepads);
+	for (size_t i = 0; i < max_controllers; ++i)
+	{
+		for (auto &controller : options.controllers)
+		{
+			if (Input::get()->getControllerName(i) == controller.name)
 			{
-				options.controller[index].plugged = true;
-				for (int j = 0; j < (int)options.controller[index].inputs.size(); ++j)
+				for (size_t j = 0; j < controller.inputs.size(); ++j)
 				{
-					Input::get()->bindGameControllerButton(i, options.controller[index].inputs[j], options.controller[index].buttons[j]);
+					Input::get()->bindGameControllerButton(i, controller.inputs.at(j), controller.buttons.at(j));
 				}
 			}
+		}
+	}
 
 	// Asigna botones a inputs desde otros inputs
 	for (int i = 0; i < num_gamepads; ++i)
@@ -218,25 +232,41 @@ void Director::bindInputs()
 		Input::get()->bindGameControllerButton(i, InputType::SWAP_CONTROLLERS, InputType::UP);
 	}
 
-	// Guarda las asignaciones de botones en las opciones
-	for (int i = 0; i < num_gamepads; ++i)
+	// Guarda las asignaciones de botones en las opciones de los dos primeros mandos
+	for (size_t i = 0; i < max_controllers; ++i)
 	{
-		options.controller[i].name = Input::get()->getControllerName(i);
-		for (int j = 0; j < (int)options.controller[i].inputs.size(); ++j)
+		// Variables asociadas al mando
+		options.controllers.at(i).index = i;
+		options.controllers.at(i).name = Input::get()->getControllerName(i);
+		options.controllers.at(i).plugged = true;
+		// Asignaciones de botones
+		for (size_t j = 0; j < options.controllers.at(i).inputs.size(); ++j)
 		{
-			options.controller[i].buttons[j] = Input::get()->getControllerBinding(i, options.controller[i].inputs[j]);
+			options.controllers.at(i).buttons.at(j) = Input::get()->getControllerBinding(i, options.controllers.at(i).inputs.at(j));
 		}
 	}
+
+	// Asegura que algún jugador tenga el teclado asignado
+	if (getPlayerWhoUsesKeyboard() == 0)
+	{
+		setKeyboardToPlayer(1);
+	}
 }
 
 // Inicializa JailAudio
 void Director::initJailAudio()
 {
 	JA_Init(48000, AUDIO_S16, 2);
-	JA_EnableMusic(options.audio.music.enabled);
-	JA_EnableSound(options.audio.sound.enabled);
-	JA_SetMusicVolume(options.audio.music.volume);
-	JA_SetSoundVolume(options.audio.sound.volume);
+	if (options.audio.enabled)
+	{
+		JA_SetMusicVolume(to_JA_volume(options.audio.music.volume));
+		JA_SetSoundVolume(to_JA_volume(options.audio.sound.volume));
+	}
+	else
+	{
+		JA_SetMusicVolume(0);
+		JA_SetSoundVolume(0);
+	}
 }
 
 // Arranca SDL y crea la ventana
@@ -253,35 +283,43 @@ bool Director::initSDL()
 	}
 	else
 	{
-		// Inicia el generador de numeros aleatorios
-		std::srand(static_cast<unsigned int>(SDL_GetTicks()));
-
+		/*
 		// Muestra información de la pantalla
-		/*std::cout << "\nDisplay modes list:" << std::endl;
+		std::cout << "\nDisplay modes list:" << std::endl;
 		for (int i = 0; i < SDL_GetNumDisplayModes(0); ++i)
 		{
 			SDL_DisplayMode DM;
 			SDL_GetDisplayMode(0,i,&DM);
-			std::cout << "  - " + std::to_string(DM.w) + "x" + std::to_string(DM.h) + " @ " + std::to_string(DM.refresh_rate) + "Hz" << std::endl;
-		}*/
+			std::cout << "  - " << DM.w << "x" << DM.h << " @ " << DM.refresh_rate << "Hz" << std::endl;
+		}
+		*/
 
+		// Obtiene información sobre la pantalla
 		SDL_DisplayMode DM;
 		SDL_GetCurrentDisplayMode(0, &DM);
-		std::cout << "\nCurrent display mode: " + std::to_string(DM.w) + "x" + std::to_string(DM.h) + " @ " + std::to_string(DM.refresh_rate) + "Hz" << std::endl;
-		std::cout << "Window resolution   : " + std::to_string(param.game.width) + "x" + std::to_string(param.game.height) + " x" + std::to_string(options.video.window.size) << std::endl;
+
+		// 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;
 
 		// Establece el filtro de la textura
 		if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, std::to_string(static_cast<int>(options.video.filter)).c_str()))
 		{
 			std::cout << "Warning: texture filtering not enabled!\n";
 		}
+
 #ifndef NO_SHADERS
 		if (!SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl"))
 		{
 			std::cout << "Warning: opengl not enabled!\n";
 		}
-#endif // NO_SHADERS
-	   // Crea la ventana
+#endif
+
+		// Crea la ventana
 		window_ = SDL_CreateWindow(WINDOW_CAPTION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, param.game.width * options.video.window.size, param.game.height * options.video.window.size, SDL_WINDOW_HIDDEN);
 		if (!window_)
 		{
@@ -296,10 +334,12 @@ bool Director::initSDL()
 			{
 				flags = SDL_RENDERER_PRESENTVSYNC;
 			}
+
 #ifndef NO_SHADERS
 			// La aceleración se activa según el define
 			flags = flags | SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
 #endif
+
 			renderer_ = SDL_CreateRenderer(window_, -1, flags);
 
 			if (!renderer_)
@@ -309,14 +349,9 @@ bool Director::initSDL()
 			}
 			else
 			{
-				// Inicializa el color de renderizado
 				SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
-
-				// Establece el tamaño del buffer de renderizado
 				SDL_RenderSetLogicalSize(renderer_, param.game.width, param.game.height);
 				SDL_RenderSetIntegerScale(renderer_, static_cast<SDL_bool>(options.video.integer_scale));
-
-				// Establece el modo de mezcla
 				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
 			}
 		}
@@ -348,6 +383,7 @@ void Director::setFileList()
 	Asset::get()->add(prefix + "/data/music/intro.ogg", AssetType::MUSIC);
 	Asset::get()->add(prefix + "/data/music/playing.ogg", AssetType::MUSIC);
 	Asset::get()->add(prefix + "/data/music/title.ogg", AssetType::MUSIC);
+	Asset::get()->add(prefix + "/data/music/credits.ogg", AssetType::MUSIC);
 
 	// Sonidos
 	Asset::get()->add(prefix + "/data/sound/balloon.wav", AssetType::SOUND);
@@ -356,19 +392,29 @@ void Director::setFileList()
 	Asset::get()->add(prefix + "/data/sound/bubble3.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/bubble4.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/bullet.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/clock.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/coffeeout.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/continue_clock.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/game_start.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/hiscore.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/itemdrop.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/itempickup.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/player_collision.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/stage_change.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/title.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/clock.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/powerball.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/logo.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/notify.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/player_collision.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/powerball.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/stage_change.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/tabe.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/title.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/voice_coffee.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/voice_get_ready.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/voice_no.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/voice_power_up.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/walk.wav", AssetType::SOUND);
 
 	// Shaders
-	Asset::get()->add(prefix + "/data/shaders/crtpi.glsl", AssetType::DATA);
+	Asset::get()->add(prefix + "/data/shaders/crtpi_256.glsl", AssetType::DATA);
+	Asset::get()->add(prefix + "/data/shaders/crtpi_240.glsl", AssetType::DATA);
 
 	// Texturas
 
@@ -407,6 +453,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);
@@ -414,14 +465,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);
-	}
-
-	{ // Game Text
-		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_1000_points.png", AssetType::BITMAP);
-		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_2500_points.png", AssetType::BITMAP);
-		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_5000_points.png", AssetType::BITMAP);
-		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_powerup.png", AssetType::BITMAP);
-		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_one_hit.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
@@ -460,17 +505,17 @@ void Director::setFileList()
 
 	{ // Jugador 1
 		Asset::get()->add(prefix + "/data/gfx/player/player1.gif", AssetType::BITMAP);
-		Asset::get()->add(prefix + "/data/gfx/player/player1_one_coffee_palette.pal", AssetType::PALETTE);
-		Asset::get()->add(prefix + "/data/gfx/player/player1_two_coffee_palette.pal", AssetType::PALETTE);
-		Asset::get()->add(prefix + "/data/gfx/player/player1_all_white_palette.pal", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player1_1_coffee_palette.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player1_2_coffee_palette.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player1_invencible_palette.gif", AssetType::PALETTE);
 		Asset::get()->add(prefix + "/data/gfx/player/player1_power.png", AssetType::BITMAP);
 	}
 
 	{ // Jugador 2
 		Asset::get()->add(prefix + "/data/gfx/player/player2.gif", AssetType::BITMAP);
-		Asset::get()->add(prefix + "/data/gfx/player/player2_one_coffee_palette.pal", AssetType::PALETTE);
-		Asset::get()->add(prefix + "/data/gfx/player/player2_two_coffee_palette.pal", AssetType::PALETTE);
-		Asset::get()->add(prefix + "/data/gfx/player/player2_all_white_palette.pal", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player2_1_coffee_palette.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player2_2_coffee_palette.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player2_invencible_palette.gif", AssetType::PALETTE);
 		Asset::get()->add(prefix + "/data/gfx/player/player2_power.png", AssetType::BITMAP);
 	}
 
@@ -483,16 +528,14 @@ void Director::setFileList()
 	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_big2.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/nokia.txt", AssetType::FONT);
-	Asset::get()->add(prefix + "/data/font/nokia2.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/font/nokia2.txt", AssetType::FONT);
-	Asset::get()->add(prefix + "/data/font/nokia_big2.txt", AssetType::FONT);
-	Asset::get()->add(prefix + "/data/font/smb2_big.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/font/smb2_big.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);
+	Asset::get()->add(prefix + "/data/font/04b_25.png", AssetType::BITMAP);
+	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);
 
 	// Textos
 	Asset::get()->add(prefix + "/data/lang/es_ES.txt", AssetType::LANG);
@@ -504,27 +547,24 @@ void Director::setFileList()
 		throw std::runtime_error("Falta algun fichero");
 }
 
-// Carga los parametros para configurar el juego
-void Director::loadParams(const std::string &file_path)
-{
-	loadParamsFromFile(file_path);
-}
-
 // Comprueba los parametros del programa
 void Director::checkProgramArguments(int argc, const char *argv[])
 {
 	// Establece la ruta del programa
 	executable_path_ = argv[0];
 
-	// Valores por defecto
-	param_file_argument_.clear();
-
 	// Comprueba el resto de parámetros
 	for (int i = 1; i < argc; ++i)
 	{
-		if (strcmp(argv[i], "--320x240") == 0)
+		std::string arg = argv[i];
+
+		if (arg == "--320x240")
 		{
-			param_file_argument_ = argv[i];
+			overrides.param_file = arg;
+		}
+		else if (arg == "--clear_score")
+		{
+			overrides.clear_hi_score_table = true;
 		}
 	}
 }
@@ -614,7 +654,11 @@ void Director::runTitle()
 void Director::runGame()
 {
 	const auto player_id = section::options == section::Options::GAME_PLAY_1P ? 1 : 2;
+#ifdef DEBUG
 	constexpr auto current_stage = 0;
+#else
+	constexpr auto current_stage = 0;
+#endif
 	auto game = std::make_unique<Game>(player_id, current_stage, GAME_MODE_DEMO_OFF);
 	game->run();
 }
@@ -626,6 +670,13 @@ void Director::runInstructions()
 	instructions->run();
 }
 
+// Ejecuta la sección donde se muestran los creditos del programa
+void Director::runCredits()
+{
+	auto credits = std::make_unique<Credits>();
+	credits->run();
+}
+
 // Ejecuta la sección donde se muestra la tabla de puntuaciones
 void Director::runHiScoreTable()
 {
@@ -642,6 +693,16 @@ void Director::runDemoGame()
 	game->run();
 }
 
+// Ejecuta la sección init
+void Director::runInit()
+{
+	if (section::options == section::Options::RELOAD)
+	{
+		Resource::get()->reload();
+	}
+	section::name = section::Name::LOGO;
+}
+
 int Director::run()
 {
 	// Bucle principal
@@ -650,56 +711,62 @@ int Director::run()
 		switch (section::name)
 		{
 		case section::Name::INIT:
-			section::name = section::Name::LOGO;
+			runInit();
 			break;
-
 		case section::Name::LOGO:
 			runLogo();
 			break;
-
 		case section::Name::INTRO:
 			runIntro();
 			break;
-
 		case section::Name::TITLE:
 			runTitle();
 			break;
-
 		case section::Name::GAME:
 			runGame();
 			break;
-
 		case section::Name::HI_SCORE_TABLE:
 			runHiScoreTable();
 			break;
-
 		case section::Name::GAME_DEMO:
 			runDemoGame();
 			break;
-
 		case section::Name::INSTRUCTIONS:
 			runInstructions();
 			break;
-
+		case section::Name::CREDITS:
+			runCredits();
+			break;
 		default:
 			break;
 		}
 	}
 
-#ifdef ARCADE
-	// Comprueba si ha de apagar el sistema
-	if (section::options == section::Options::QUIT_WITH_CONTROLLER)
-		shutdownSystem();
-#endif
+	std::string return_code;
+	switch (section::options)
+	{
+	case section::Options::QUIT_WITH_KEYBOARD:
+		return_code = "with keyboard";
+		break;
+	case section::Options::QUIT_WITH_CONTROLLER:
+		return_code = "with controller";
+		break;
+	default:
+		return_code = "from event";
+		break;
+	}
 
-	const auto return_code = (section::options == section::Options::QUIT_WITH_KEYBOARD) ? "with keyboard" : (section::options == section::Options::QUIT_WITH_CONTROLLER) ? "with controller"
-																																										 : "from event";
 	std::cout << "\nGame end " << return_code << std::endl;
 
 #ifndef VERBOSE
 	// 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;
 }
@@ -712,15 +779,12 @@ std::string Director::getLangFile(lang::Code code)
 	case lang::Code::ba_BA:
 		return Asset::get()->get("ba_BA.txt");
 		break;
-
 	case lang::Code::es_ES:
 		return Asset::get()->get("es_ES.txt");
 		break;
-
 	case lang::Code::en_UK:
 		return Asset::get()->get("en_UK.txt");
 		break;
-
 	default:
 		break;
 	}
@@ -728,6 +792,7 @@ std::string Director::getLangFile(lang::Code code)
 	return Asset::get()->get("en_UK.txt");
 }
 
+#ifdef ARCADE
 // Apaga el sistema
 void Director::shutdownSystem()
 {
@@ -744,4 +809,5 @@ void Director::shutdownSystem()
 // Sistema operativo no compatible
 #error "Sistema operativo no soportado"
 #endif
-}
+}
+#endif // ARCADE

source/director.h

@@ -1,15 +1,12 @@
 #pragma once
 
-#include <SDL2/SDL_render.h> // for SDL_Renderer
-#include <SDL2/SDL_video.h>	 // for SDL_Window
-#include <string>			 // for string
-#include <vector>			 // for vector
+#include <SDL2/SDL_render.h> // Para SDL_Renderer
+#include <SDL2/SDL_video.h>	 // Para SDL_Window
+#include <string>			 // Para string
 namespace lang
 {
 	enum class Code : int;
-}
-struct ResourceMusic;
-struct ResourceSound;
+} // lines 9-9
 
 // Textos
 constexpr char WINDOW_CAPTION[] = "Coffee Crisis Arcade Edition";
@@ -18,14 +15,15 @@ class Director
 {
 private:
 	// Objetos y punteros
-	SDL_Window *window_;	  // La ventana donde dibujamos
-	SDL_Renderer *renderer_;  // El renderizador de la ventana
+	SDL_Window *window_;	 // La ventana donde dibujamos
+	SDL_Renderer *renderer_; // El renderizador de la ventana
+#ifndef VERBOSE
 	std::streambuf *orig_buf; // Puntero al buffer de flujo original para restaurar std::cout
+#endif
 
 	// Variables
-	std::string executable_path_;	  // Path del ejecutable
-	std::string system_folder_;		  // Carpeta del sistema donde guardar datos
-	std::string param_file_argument_; // Argumento para gestionar el fichero con los parametros del programa
+	std::string executable_path_; // Path del ejecutable
+	std::string system_folder_;	  // Carpeta del sistema donde guardar datos
 
 	// Inicializa jail_audio
 	void initJailAudio();
@@ -36,9 +34,6 @@ private:
 	// Asigna los botones y teclas al objeto Input
 	void bindInputs();
 
-	// Carga los parametros para configurar el juego
-	void loadParams(const std::string &file_path);
-
 	// Crea el indice de ficheros
 	void setFileList();
 
@@ -63,17 +58,36 @@ private:
 	// Ejecuta la sección donde se muestran las instrucciones
 	void runInstructions();
 
+	// Ejecuta la sección donde se muestran los creditos del programa
+	void runCredits();
+
 	// Ejecuta la sección donde se muestra la tabla de puntuaciones
 	void runHiScoreTable();
 
 	// Ejecuta el juego en modo demo
 	void runDemoGame();
 
+	// Ejecuta la sección init
+	void runInit();
+
 	// Obtiene una fichero a partir de un lang::Code
 	std::string getLangFile(lang::Code code);
-
+#ifdef ARCADE
 	// Apaga el sistema
 	void shutdownSystem();
+#endif
+
+	// Inicializa todo
+	void init();
+
+	// Cierra todo
+	void close();
+
+	// Carga los parametros
+	void loadParams();
+
+	// Carga el fichero de puntuaciones
+	void loadScoreFile();
 
 public:
 	// Constructor

source/enter_name.cpp

@@ -1,5 +1,6 @@
 #include "enter_name.h"
-#include <algorithm> // for max, min
+#include <stddef.h>  // Para size_t
+#include <algorithm> // Para max, min
 
 // Constructor
 EnterName::EnterName()
@@ -16,7 +17,7 @@ void EnterName::init()
     // Inicia la lista de caracteres permitidos
     character_list_ = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()";
     position_ = 0;
-    num_characters_ = (int)character_list_.size();
+    num_characters_ = static_cast<int>(character_list_.size());
 
     // Pone la lista de indices para que refleje el nombre
     updateCharacterIndex();
@@ -36,7 +37,7 @@ void EnterName::incPosition()
 // Decrementa la posición
 void EnterName::decPosition()
 {
-    position_--;
+    --position_;
     position_ = std::max(position_, 0);
 }
 
@@ -76,14 +77,14 @@ void EnterName::updateName()
 void EnterName::updateCharacterIndex()
 {
     // Rellena de espacios y marca como no usados
-    for (int i = 0; i < NAME_LENGHT; ++i)
+    for (size_t i = 0; i < NAME_LENGHT; ++i)
     {
         character_index_[i] = 0;
         position_has_been_used_[i] = false;
     }
 
-    // Coloca los índices en funcion de los caracteres que forman el nombre
-    for (int i = 0; i < (int)name_.size(); ++i)
+    // Coloca los índices en función de los caracteres que forman el nombre
+    for (size_t i = 0; i < name_.size(); ++i)
     {
         character_index_[i] = findIndex(name_.at(i));
         position_has_been_used_[i] = true;
@@ -91,15 +92,11 @@ void EnterName::updateCharacterIndex()
 }
 
 // Encuentra el indice de un caracter en "character_list_"
-int EnterName::findIndex(char character)
+int EnterName::findIndex(char character) const
 {
-    for (int i = 0; i < (int)character_list_.size(); ++i)
-    {
-        if (character == character_list_[i])
-        {
+    for (size_t i = 0; i < character_list_.size(); ++i)
+        if (character == character_list_.at(i))
             return i;
-        }
-    }
     return 0;
 }
 
@@ -121,9 +118,7 @@ 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

@@ -2,7 +2,7 @@
 
 #include <string>
 
-constexpr int NAME_LENGHT = 8;
+constexpr int NAME_LENGHT = 6;
 
 /*
     Un array, "characterList", contiene la lista de caracteres
@@ -30,7 +30,7 @@ private:
     void updateCharacterIndex();
 
     // Encuentra el indice de un caracter en "characterList"
-    int findIndex(char character);
+    int findIndex(char character) const;
 
     // Comprueba la posición y copia el caracter si es necesario
     void checkIfPositionHasBeenUsed();

source/explosions.cpp

@@ -1,20 +1,6 @@
 #include "explosions.h"
-#include <utility>           // for move
-#include "animated_sprite.h" // for SpriteAnimated
-class Texture;               // lines 3-3
-
-// Constructor
-Explosions::Explosions()
-{
-    textures_.clear();
-    explosions_.clear();
-}
-
-// Destructor
-Explosions::~Explosions()
-{
-    explosions_.clear();
-}
+#include "animated_sprite.h" // Para AnimatedSprite
+class Texture;               // lines 4-4
 
 // Actualiza la lógica de la clase
 void Explosions::update()
@@ -38,7 +24,7 @@ void Explosions::render()
 }
 
 // Añade texturas al objeto
-void Explosions::addTexture(int size, std::shared_ptr<Texture> texture, std::vector<std::string> &animation)
+void Explosions::addTexture(int size, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
 {
     textures_.emplace_back(ExplosionTexture(size, texture, animation));
 }

source/explosions.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include <memory> // for shared_ptr, unique_ptr
-#include <string> // for string
-#include <vector> // for vector
-class AnimatedSprite;
-class Texture;
+#include <memory>            // Para unique_ptr, shared_ptr
+#include <string>            // Para string
+#include <vector>            // Para vector
+#include "animated_sprite.h" // Para AnimatedSprite
+class Texture;               // lines 7-7
 
 struct ExplosionTexture
 {
@@ -13,7 +13,7 @@ struct ExplosionTexture
     std::vector<std::string> animation; // Animación para la textura
 
     // Constructor
-    ExplosionTexture(int sz, std::shared_ptr<Texture> tex, std::vector<std::string> anim)
+    ExplosionTexture(int sz, std::shared_ptr<Texture> tex, const std::vector<std::string> &anim)
         : size(sz), texture(tex), animation(anim) {}
 };
 
@@ -33,10 +33,10 @@ private:
 
 public:
     // Constructor
-    Explosions();
+    Explosions() = default;
 
     // Destructor
-    ~Explosions();
+    ~Explosions() = default;
 
     // Actualiza la lógica de la clase
     void update();
@@ -45,7 +45,7 @@ public:
     void render();
 
     // Añade texturas al objeto
-    void addTexture(int size, std::shared_ptr<Texture> texture, std::vector<std::string> &animation);
+    void addTexture(int size, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
 
     // Añade una explosión
     void add(int x, int y, int size);

source/fade.cpp

@@ -1,11 +1,10 @@
 #include "fade.h"
-#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND, SDL_BLENDMODE_NONE
-#include <SDL2/SDL_pixels.h>	// for SDL_PIXELFORMAT_RGBA8888
-#include <stdlib.h>				// for rand
-#include <algorithm>			// for min, max
-#include "param.h"				// for param
-#include "screen.h"
-#include "utils.h"				// for Param, ParamGame, ParamFade
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND, SDL_BLENDMODE_NONE
+#include <SDL2/SDL_pixels.h>	// Para SDL_PIXELFORMAT_RGBA8888
+#include <stdlib.h>				// Para rand
+#include <algorithm>			// Para min, max
+#include "param.h"				// Para Param, param, ParamGame, ParamFade
+#include "screen.h"				// Para Screen
 
 // Constructor
 Fade::Fade()
@@ -31,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;
@@ -49,15 +48,14 @@ void Fade::init()
 // Resetea algunas variables para volver a hacer el fade sin perder ciertos parametros
 void Fade::reset()
 {
-	enabled_ = false;
-	finished_ = false;
+	state_ = FadeState::NOT_ENABLED;
 	counter_ = 0;
 }
 
 // Pinta una transición en pantalla
 void Fade::render()
 {
-	if (enabled_ || finished_)
+	if (state_ != FadeState::NOT_ENABLED)
 	{
 		SDL_RenderCopy(renderer_, backbuffer_, nullptr, nullptr);
 	}
@@ -66,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_)
 		{
@@ -80,7 +91,7 @@ void Fade::update()
 			// Comprueba si ha terminado
 			if (counter_ >= 255 / 4)
 			{
-				finished_ = true;
+				state_ = FadeState::POST;
 			}
 
 			break;
@@ -101,6 +112,8 @@ void Fade::update()
 
 				SDL_RenderFillRect(renderer_, &rect1_);
 				SDL_RenderFillRect(renderer_, &rect2_);
+
+				value_ = calculateValue(0, counter_, i);
 			}
 
 			// Deja el renderizador como estaba
@@ -109,7 +122,7 @@ void Fade::update()
 			// Comprueba si ha terminado
 			if ((counter_ * 4) > param.game.height)
 			{
-				finished_ = true;
+				state_ = FadeState::POST;
 				a_ = 255;
 			}
 			break;
@@ -119,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_);
 
@@ -134,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;
@@ -151,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;
-				for (int i = 0; i < (int)square_.size(); ++i)
+				// Modifica el tamaño de los rectangulos
+				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;
-	finished_ = false;
+	state_ = FadeState::PRE;
 	counter_ = 0;
 	post_counter_ = 0;
+	pre_counter_ = 0;
 
 	switch (type_)
 	{
@@ -252,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_);
-		SDL_RenderClear(renderer_);
-		SDL_SetRenderTarget(renderer_, temp);
+		cleanBackbuffer(r_, g_, b_, a_);
 
 		// Deja el color listo para usar
 		a_ = mode_ == FadeMode::OUT ? 255 : 0;
@@ -267,12 +302,16 @@ void Fade::activate()
 
 	case FadeType::VENETIAN:
 	{
-		cleanBackbuffer(0, 0, 0, 0);
-		rect1_ = {0, 0, param.game.width, 0};
-		square_.clear();
-		a_ = 255;
+		// Limpia la textura
+		a_ = mode_ == FadeMode::OUT ? 0 : 255;
+		cleanBackbuffer(r_, g_, b_, a_);
+
+		// 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)
@@ -286,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)
 {
@@ -319,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)
 {
@@ -338,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

@@ -1,9 +1,9 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>	 // for SDL_Rect
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h> // for Uint8, Uint16
-#include <vector>			 // for vector
+#include <SDL2/SDL_rect.h>	 // para SDL_Rect
+#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_stdinc.h> // para Uint8, Uint16
+#include <vector>			 // para vector
 
 // Tipos de fundido
 enum class FadeType : Uint8
@@ -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
-	FadeMode mode_;					// Modo de fade a realizar
-	Uint16 counter_;				// Contador interno
-	bool enabled_;					// Indica si el fade está activo
-	bool finished_;					// Indica si ha terminado la transición
-	Uint8 r_, g_, b_, a_;			// Colores para el fade
-	SDL_Rect rect1_;				// Rectangulo usado para crear los efectos de transición
-	SDL_Rect rect2_;				// Rectangulo usado para crear los efectos de transición
-	int num_squares_width_;			// Cantidad total de cuadraditos en horizontal para el FadeType::RANDOM_SQUARE
-	int num_squares_height_;		// Cantidad total de cuadraditos en vertical para el FadeType::RANDOM_SQUARE
-	std::vector<SDL_Rect> square_;	// Vector con los indices de los cuadrados para el FadeType::RANDOM_SQUARE
-	int fade_random_squares_delay_; // Duración entre cada pintado de cuadrados
-	int fade_random_squares_mult_;	// Cantidad de cuadrados que se pintaran cada vez
-	int post_duration_;				// Duración posterior del fade tras finalizar
-	int post_counter_;				// Contador para la duración posterior
+	FadeType type_;							   // Tipo de fade a realizar
+	FadeMode mode_;							   // Modo de fade a realizar
+	FadeState state_ = FadeState::NOT_ENABLED; // Estado actual del objeto
+	Uint16 counter_;						   // Contador interno
+	Uint8 r_, g_, b_, a_;					   // Colores para el fade
+	SDL_Rect rect1_;						   // Rectangulo usado para crear los efectos de transición
+	SDL_Rect rect2_;						   // Rectangulo usado para crear los efectos de transición
+	int num_squares_width_;					   // Cantidad total de cuadraditos en horizontal para el FadeType::RANDOM_SQUARE
+	int num_squares_height_;				   // Cantidad total de cuadraditos en vertical para el FadeType::RANDOM_SQUARE
+	std::vector<SDL_Rect> square_;			   // Vector con los indices de los cuadrados para el FadeType::RANDOM_SQUARE
+	int fade_random_squares_delay_;			   // Duración entre cada pintado de cuadrados
+	int fade_random_squares_mult_;			   // Cantidad de cuadrados que se pintaran cada vez
+	int post_duration_ = 0;					   // Duración posterior del fade tras finalizar
+	int post_counter_ = 0;					   // Contador para la duración posterior
+	int pre_duration_ = 0;					   // Duración previa del fade antes de iniciar
+	int pre_counter_ = 0;					   // Contador para la duración previa
+	int value_ = 0;							   // Estado actual del fade entre 0 y 100
 
 	// Inicializa las variables
 	void init();
@@ -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
-	void setPost(int value);
+	// Getters
+	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

@@ -1,30 +1,30 @@
 #pragma once
 
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h> // for Uint32
-#include <memory>			 // for shared_ptr, unique_ptr
-#include <string>			 // for string
-#include <vector>			 // for vector
-#include "balloon.h"		 // for Balloon
-#include "player.h"			 // for Player
-#include "utils.h"			 // for DemoKeys, Color, HiScoreEntry
-class Asset;
-class Background;
-class BalloonFormations;
-class Bullet;
-class Explosions;
-class Fade;
-class Input;
-class Item;
-class Scoreboard;
-class Screen;
-class SmartSprite;
-class Text;
-class Texture;
-enum class BulletType; // lines 26-26
-struct JA_Music_t;	   // lines 27-27
-struct JA_Sound_t;	   // lines 28-28
-enum class ItemType;
+#include <SDL2/SDL_render.h>	  // Para SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_stdinc.h>	  // Para Uint32, Uint8
+#include <memory>				  // Para shared_ptr, unique_ptr
+#include <string>				  // Para string
+#include <vector>				  // Para vector
+#include "manage_hiscore_table.h" // Para HiScoreEntry
+#include "options.h"			  // Para Options, OptionsGame, options
+#include "player.h"				  // Para Player
+#include "utils.h"				  // Para Demo
+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
+class Item;					   // lines 18-18
+class PathSprite;			   // lines 19-19
+class Scoreboard;			   // lines 20-20
+class Screen;				   // lines 21-21
+class SmartSprite;			   // lines 22-22
+class Texture;				   // lines 23-23
+enum class BulletType : Uint8; // lines 24-24
+enum class ItemType;		   // lines 25-25
+struct Path;				   // lines 26-26
 
 // Modo demo
 constexpr bool GAME_MODE_DEMO_OFF = false;
@@ -63,6 +63,33 @@ constexpr int TOTAL_SCORE_DATA = 3;
 class Game
 {
 private:
+	// Enum
+	enum class GameState
+	{
+		FADE_IN,
+		ENTERING_PLAYER,
+		SHOWING_GET_READY_MESSAGE,
+		PLAYING,
+		COMPLETED,
+		GAME_OVER,
+	};
+
+	// Contadores
+	static constexpr int HELP_COUNTER_ = 1000;
+	static constexpr int GAME_COMPLETED_START_FADE_ = 500;
+	static constexpr int GAME_COMPLETED_END_ = 700;
+	static constexpr int GAME_OVER_COUNTER_ = 350;
+	static constexpr int TIME_STOPPED_COUNTER_ = 360;
+
+	// Porcentaje de aparición de los objetos
+	static constexpr int ITEM_POINTS_1_DISK_ODDS_ = 10;
+	static constexpr int ITEM_POINTS_2_GAVINA_ODDS_ = 6;
+	static constexpr int ITEM_POINTS_3_PACMAR_ODDS_ = 3;
+	static constexpr int ITEM_CLOCK_ODDS_ = 5;
+	static constexpr int ITEM_COFFEE_ODDS_ = 5;
+	static constexpr int ITEM_POWER_BALL_ODDS_ = 0;
+	static constexpr int ITEM_COFFEE_MACHINE_ODDS_ = 4;
+
 	// Estructuras
 	struct Helper
 	{
@@ -76,28 +103,21 @@ private:
 		int item_clock_odds;		  // Probabilidad de aparición del objeto
 		int item_coffee_odds;		  // Probabilidad de aparición del objeto
 		int item_coffee_machine_odds; // Probabilidad de aparición del objeto
+
+		// Constructor con valores predeterminados
+		Helper()
+			: need_coffee(false),
+			  need_coffee_machine(false),
+			  need_power_ball(false),
+			  counter(HELP_COUNTER_),
+			  item_disk_odds(ITEM_POINTS_1_DISK_ODDS_),
+			  item_gavina_odds(ITEM_POINTS_2_GAVINA_ODDS_),
+			  item_pacmar_odds(ITEM_POINTS_3_PACMAR_ODDS_),
+			  item_clock_odds(ITEM_CLOCK_ODDS_),
+			  item_coffee_odds(ITEM_COFFEE_ODDS_),
+			  item_coffee_machine_odds(ITEM_COFFEE_MACHINE_ODDS_) {}
 	};
 
-	// Constantes
-
-	// Contadores
-	static constexpr int STAGE_COUNTER_ = 200;
-	static constexpr int HELP_COUNTER_ = 1000;
-	static constexpr int GAME_COMPLETED_START_FADE_ = 500;
-	static constexpr int GAME_COMPLETED_END_ = 700;
-	static constexpr int GAME_OVER_COUNTER_ = 350;
-	static constexpr int TIME_STOPPED_COUNTER_ = 300;
-	static constexpr int TICKS_SPEED_ = 15;
-
-	// Porcentaje de aparición de los objetos
-	static constexpr int ITEM_POINTS_1_DISK_ODDS_ = 10;
-	static constexpr int ITEM_POINTS_2_GAVINA_ODDS_ = 6;
-	static constexpr int ITEM_POINTS_3_PACMAR_ODDS_ = 3;
-	static constexpr int ITEM_CLOCK_ODDS_ = 5;
-	static constexpr int ITEM_COFFEE_ODDS_ = 5;
-	static constexpr int ITEM_POWER_BALL_ODDS_ = 0;
-	static constexpr int ITEM_COFFEE_MACHINE_ODDS_ = 4;
-
 	// Objetos y punteros
 	SDL_Renderer *renderer_; // El renderizador de la ventana
 	Screen *screen_;		 // Objeto encargado de dibujar en pantalla
@@ -105,73 +125,54 @@ private:
 	Input *input_;			 // Manejador de entrada
 	Scoreboard *scoreboard_; // Objeto para dibujar el marcador
 
-	std::unique_ptr<Background> background_;				// Objeto para dibujar el fondo del juego
-	std::unique_ptr<Explosions> explosions_;				// Objeto para dibujar explosiones
-	std::unique_ptr<BalloonFormations> balloon_formations_; // Objeto para gestionar las oleadas enemigas
+	std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego
 
 	SDL_Texture *canvas_; // Textura para dibujar la zona de juego
 
 	std::vector<std::shared_ptr<Player>> players_;			  // Vector con los jugadores
-	std::vector<std::shared_ptr<Balloon>> balloons_;		  // Vector con los globos
 	std::vector<std::unique_ptr<Bullet>> bullets_;			  // Vector con las balas
 	std::vector<std::unique_ptr<Item>> items_;				  // Vector con los items
 	std::vector<std::unique_ptr<SmartSprite>> smart_sprites_; // Vector con los smartsprites
+	std::vector<std::unique_ptr<PathSprite>> path_sprites_;	  // Vector con los smartsprites
 
 	std::shared_ptr<Texture> bullet_texture_;							 // Textura para las balas
 	std::vector<std::shared_ptr<Texture>> item_textures_;				 // Vector con las texturas de los items
-	std::vector<std::shared_ptr<Texture>> balloon_textures_;			 // Vector con las texturas de los globos
-	std::vector<std::shared_ptr<Texture>> explosions_textures_;			 // Vector con las texturas de las explosiones
 	std::vector<std::vector<std::shared_ptr<Texture>>> player_textures_; // Vector con todas las texturas de los jugadores;
 
 	std::vector<std::shared_ptr<Texture>> game_text_textures_; // Vector con las texturas para los sprites con textos
 
-	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::vector<std::vector<std::string>> balloon_animations_;	  // Vector con las animaciones de los globos
-	std::vector<std::vector<std::string>> explosions_animations_; // Vector con las animaciones de las explosiones
+	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<Text> text_;			// Fuente para los textos del juego
-	std::unique_ptr<Text> text_big_;		// Fuente de texto grande
-	std::unique_ptr<Text> text_nokia2_;		// Otra fuente de texto para mensajes
-	std::unique_ptr<Text> text_nokia2_big_; // Y la versión en grande
-
-	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
-	Uint32 ticks_;								  // Contador de ticks para ajustar la velocidad del programa
-	bool hi_score_achieved_;					  // Indica si se ha superado la puntuación máxima
-	HiScoreEntry hi_score_;						  // Máxima puntuación y nombre de quien la ostenta
-	int current_stage_;							  // Indica la fase actual
-	int stage_bitmap_counter_;					  // Contador para el tiempo visible del texto de Stage
-	float stage_bitmap_path_[STAGE_COUNTER_];	  // Vector con los puntos Y por donde se desplaza el texto
-	float get_ready_bitmap_path_[STAGE_COUNTER_]; // Vector con los puntos X por donde se desplaza el texto
-	int game_over_counter_;						  // Contador para el estado de fin de partida
-	int menace_current_;						  // Nivel de amenaza actual
-	int menace_threshold_;						  // 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
-	bool time_stopped_;							  // Indica si el tiempo está detenido
-	int time_stopped_counter_;					  // Temporizador para llevar la cuenta del tiempo detenido
-	int counter_;								  // Contador para el juego
-	int balloons_popped_;						  // Lleva la cuenta de los globos explotados
-	int last_ballon_deploy_;					  // Guarda cual ha sido la última formación desplegada para no repetir;
-	int balloon_deploy_counter_;				  // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
-	float balloon_speed_;						  // Velocidad a la que se mueven los enemigos
-	float default_balloon_speed_;				  // Velocidad base de los enemigos, sin incrementar
-	Helper helper_;								  // Variable para gestionar las ayudas
-	bool power_ball_enabled_;					  // Indica si hay una powerball ya activa
-	int power_ball_counter_;					  // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
-	bool coffee_machine_enabled_;				  // Indica si hay una máquina de café en el terreno de juego
-	bool game_completed_;						  // Indica si se ha completado la partida, llegando al final de la ultima pantalla
-	int game_completed_counter_;				  // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
-	GameDifficulty difficulty_;					  // Dificultad del juego
-	float difficulty_score_multiplier_;			  // Multiplicador de puntos en función de la dificultad
-	Color difficulty_color_;					  // Color asociado a la dificultad
-	int last_stage_reached_;					  // Contiene el número de la última pantalla que se ha alcanzado
-	Demo demo_;									  // Variable con todas las variables relacionadas con el modo demo
-	int total_power_to_complete_game_;			  // La suma del poder necesario para completar todas las fases
-	bool paused_;								  // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
-	int current_power_;							  // Poder actual almacenado para completar la fase
+	HiScoreEntry hi_score_ = HiScoreEntry(
+		options.game.hi_score_table[0].name,
+		options.game.hi_score_table[0].score); // Máxima puntuación y nombre de quien la ostenta
+
+	Demo demo_;											  // Variable con todas las variables relacionadas con el modo demo
+	GameDifficulty difficulty_ = options.game.difficulty; // Dificultad del juego
+	Helper helper_;										  // Variable para gestionar las ayudas
+	Uint32 ticks_ = 0;									  // Contador de ticks para ajustar la velocidad del programa
+	bool coffee_machine_enabled_ = false;				  // Indica si hay una máquina de café en el terreno de juego
+	bool hi_score_achieved_ = false;					  // Indica si se ha superado la puntuación máxima
+	bool paused_ = false;								  // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
+	float difficulty_score_multiplier_;					  // Multiplicador de puntos en función de la dificultad
+	int counter_ = 0;									  // Contador para el juego
+	int game_completed_counter_ = 0;					  // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
+	int game_over_counter_ = GAME_OVER_COUNTER_;		  // Contador para el estado de fin de partida
+	int time_stopped_counter_ = 0;						  // Temporizador para llevar la cuenta del tiempo detenido
+	int total_power_to_complete_game_;					  // La suma del poder necesario para completar todas las fases
+	int 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::FADE_IN;				  // Estado
 #ifdef DEBUG
-	bool auto_pop_balloons_; // Si es true, incrementa automaticamente los globos explotados
+	bool auto_pop_balloons_ = false; // Si es true, incrementa automaticamente los globos explotados
 #endif
 
 	// Actualiza el juego
@@ -183,20 +184,8 @@ private:
 	// Comprueba los eventos que hay en cola
 	void checkEvents();
 
-	// Inicializa las variables necesarias para la sección 'Game'
-	void init(int player_id);
-
-	// Carga los recursos necesarios para la sección 'Game'
-	void loadMedia();
-
-	// Libera los recursos previamente cargados
-	void unloadMedia();
-
-	// Crea una formación de enemigos
-	void deployBalloonFormation();
-
-	// Aumenta el poder de la fase
-	void increaseStageCurrentPower(int power);
+	// Asigna texturas y animaciones
+	void setResources();
 
 	// Actualiza el valor de HiScore en caso necesario
 	void updateHiScore();
@@ -211,43 +200,10 @@ private:
 	void updateStage();
 
 	// Actualiza el estado de fin de la partida
-	void updateGameOver();
+	void updateGameStateGameOver();
 
-	// Actualiza los globos
-	void updateBalloons();
-
-	// Pinta en pantalla todos los globos activos
-	void renderBalloons();
-
-	// Crea un globo nuevo en el vector de globos
-	std::shared_ptr<Balloon> createBalloon(float x, int y, int kind, float velx, float speed, int stopped_counter);
-
-	// Crea una PowerBall
-	void createPowerBall();
-
-	// Establece la velocidad de los globos
-	void setBalloonSpeed(float speed);
-
-	// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
-	void updateBalloonSpeed();
-
-	// Explosiona un globo. Lo destruye y crea otros dos si es el caso
-	void popBalloon(std::shared_ptr<Balloon> balloon);
-
-	// Explosiona un globo. Lo destruye
-	void destroyBalloon(std::shared_ptr<Balloon> &balloon);
-
-	// Destruye todos los globos
-	void destroyAllBalloons();
-
-	// Detiene todos los globos
-	void stopAllBalloons(int time);
-
-	// Pone en marcha todos los globos
-	void startAllBalloons();
-
-	// Vacia el vector de globos
-	void freeBalloons();
+	// Destruye todos los items
+	void destroyAllItems();
 
 	// Comprueba la colisión entre el jugador y los globos activos
 	bool checkPlayerBalloonCollision(std::shared_ptr<Player> &player);
@@ -259,7 +215,7 @@ private:
 	void checkBulletBalloonCollision();
 
 	// Mueve las balas activas
-	void moveBullets();
+	void updateBullets();
 
 	// Pinta las balas activas
 	void renderBullets();
@@ -285,56 +241,44 @@ private:
 	// Vacia el vector de items
 	void freeItems();
 
-	// Crea un objeto SpriteSmart
-	void createItemScoreSprite(int x, int y, std::shared_ptr<Texture> texture);
+	// Crea un objeto PathSprite
+	void createItemText(int x, std::shared_ptr<Texture> texture);
+
+	// Crea un objeto PathSprite
+	void createMessage(const std::vector<Path> &paths, std::shared_ptr<Texture> texture);
 
 	// Vacia el vector de smartsprites
-	void freeSpriteSmarts();
+	void freeSmartSprites();
+
+	// Vacia el vector de pathsprites
+	void freePathSprites();
 
 	// Crea un SpriteSmart para arrojar el item café al recibir un impacto
 	void throwCoffee(int x, int y);
 
 	// Actualiza los SpriteSmarts
-	void updateSpriteSmarts();
+	void updateSmartSprites();
 
 	// Pinta los SpriteSmarts activos
-	void renderSpriteSmarts();
+	void renderSmartSprites();
+
+	// Actualiza los PathSprites
+	void updatePathSprites();
+
+	// Pinta los PathSprites activos
+	void renderPathSprites();
 
 	// Acciones a realizar cuando el jugador muere
 	void killPlayer(std::shared_ptr<Player> &player);
 
-	// Calcula y establece el valor de amenaza en funcion de los globos activos
-	void evaluateAndSetMenace();
-
-	// Obtiene el valor de la variable
-	int getMenace() const;
-
-	// Establece el valor de la variable
-	void setTimeStopped(bool value);
-
-	// Obtiene el valor de la variable
-	bool isTimeStopped() const;
-
-	// Establece el valor de la variable
-	void setTimeStoppedCounter(int value);
-
-	// Incrementa el valor de la variable
-	void incTimeStoppedCounter(int value);
-
-	// Actualiza la variable EnemyDeployCounter
-	void updateBalloonDeployCounter();
-
 	// Actualiza y comprueba el valor de la variable
-	void updateTimeStoppedCounter();
-
-	// Gestiona el nivel de amenaza
-	void updateMenace();
+	void updateTimeStopped();
 
 	// Actualiza el fondo
 	void updateBackground();
 
-	// Pinta diferentes mensajes en la pantalla
-	void renderMessages();
+	// Inicializa las variables que contienen puntos de ruta para mover objetos
+	void initPaths();
 
 	// Habilita el efecto del item de detener el tiempo
 	void enableTimeStopItem();
@@ -342,18 +286,6 @@ private:
 	// Deshabilita el efecto del item de detener el tiempo
 	void disableTimeStopItem();
 
-	// Indica si se puede crear una powerball
-	bool canPowerBallBeCreated();
-
-	// Calcula el poder actual de los globos en pantalla
-	int calculateScreenPower();
-
-	// Inicializa las variables que contienen puntos de ruta para mover objetos
-	void initPaths();
-
-	// Actualiza el tramo final de juego, una vez completado
-	void updateGameCompleted();
-
 	// Actualiza las variables de ayuda
 	void updateHelper();
 
@@ -366,9 +298,6 @@ private:
 	// Comprueba si todos los jugadores han terminado de jugar
 	bool allPlayersAreNotPlaying();
 
-	// Elimina todos los objetos contenidos en vectores
-	void deleteAllVectorObjects();
-
 	// Recarga las texturas
 	void reloadTextures();
 
@@ -381,9 +310,6 @@ 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);
 
@@ -409,7 +335,6 @@ private:
 	void handleDemoMode();
 
 	// Procesa las entradas para un jugador específico durante el modo demo.
-	// Incluye movimientos (izquierda, derecha, sin movimiento) y disparos automáticos.
 	void handleDemoPlayerInput(const std::shared_ptr<Player> &player, int index);
 
 	// Maneja el disparo de un jugador, incluyendo la creación de balas y la gestión del tiempo de espera entre disparos.
@@ -430,6 +355,72 @@ private:
 	// Procesa las entradas para la introducción del nombre del jugador.
 	void handleNameInput(const std::shared_ptr<Player> &player);
 
+	// Inicializa las variables para el modo DEMO
+	void initDemo(int player_id);
+
+	// Calcula el poder total necesario para completar el juego
+	void setTotalPower();
+
+	// Inicializa el marcador
+	void initScoreboard();
+
+	// Inicializa las opciones relacionadas con la dificultad
+	void initDifficultyVars();
+
+	// Inicializa los jugadores
+	void initPlayers(int player_id);
+
+	// Pausa la música
+	void pauseMusic();
+
+	// Reanuda la música
+	void resumeMusic();
+
+	// Hace sonar la música
+	void playMusic();
+
+	// Detiene la música
+	void stopMusic();
+
+	// Actualiza las variables durante el modo demo
+	void updateDemo();
+#ifdef RECORDING
+	// 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 updateGameStatePlaying();
+
+	// Gestiona eventos para el estado del final del juego
+	void updateGameStateCompleted();
+
+	// Comprueba el estado del juego
+	void checkState();
+
+	// Vacía los vectores de elementos deshabilitados
+	void cleanVectors();
+
+	// Gestiona el nivel de amenaza
+	void updateMenace();
+
+	// Calcula y establece el valor de amenaza en funcion de los globos activos
+	void evaluateAndSetMenace();
+
+	// 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

@@ -1,16 +1,19 @@
 #include "game_logo.h"
-#include <SDL2/SDL_render.h> // for SDL_FLIP_HORIZONTAL
-#include <algorithm>         // for max
-#include "animated_sprite.h" // for SpriteAnimated
-#include "asset.h"           // for Asset
-#include "jail_audio.h"      // JA_PlaySound
-#include "param.h"           // for param
-#include "resource.h"        // for Resource
-#include "screen.h"          // for Screen
-#include "smart_sprite.h"    // for SpriteSmart
-#include "sprite.h"          // for Sprite
-#include "texture.h"         // for Texture
-#include "utils.h"           // for Param, ParamGame, ParamTitle
+#include <SDL2/SDL_render.h> // Para SDL_FLIP_HORIZONTAL
+#include <algorithm>         // Para max
+#include "animated_sprite.h" // Para AnimatedSprite
+#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)
@@ -18,40 +21,27 @@ GameLogo::GameLogo(int x, int y)
       coffee_texture_(Resource::get()->getTexture("title_coffee.png")),
       crisis_texture_(Resource::get()->getTexture("title_crisis.png")),
       arcade_edition_texture_(Resource::get()->getTexture("title_arcade_edition.png")),
-
       dust_left_sprite_(std::make_unique<AnimatedSprite>(dust_texture_, Resource::get()->getAnimation("title_dust.ani"))),
       dust_right_sprite_(std::make_unique<AnimatedSprite>(dust_texture_, Resource::get()->getAnimation("title_dust.ani"))),
-
       coffee_sprite_(std::make_unique<SmartSprite>(coffee_texture_)),
       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)
-{
-    // Inicializa las variables
-    init();
-}
+      y_(y) {}
 
 // Inicializa las variables
 void GameLogo::init()
 {
-    const auto xp = x_ - coffee_sprite_->getWidth() / 2;
+    const auto xp = x_ - coffee_texture_->getWidth() / 2;
     const auto desp = getInitialVerticalDesp();
 
     // Variables
-    status_ = Status::DISABLED;
-    shake_.desp = 1;
-    shake_.delay = 2;
-    shake_.lenght = 8;
-    shake_.remaining = shake_.lenght;
-    shake_.counter = shake_.delay;
-    shake_.origin = xp;
+    coffee_crisis_status_ = Status::DISABLED;
+    arcade_edition_status_ = Status::DISABLED;
+    shake_.init(1, 2, 8, xp);
+    zoom_ = 3.0f * ZOOM_FACTOR;
 
     // Inicializa el bitmap de 'Coffee'
-    coffee_sprite_->init();
     coffee_sprite_->setPosX(xp);
     coffee_sprite_->setPosY(y_ - coffee_texture_->getHeight() - desp);
     coffee_sprite_->setWidth(coffee_texture_->getWidth());
@@ -67,7 +57,6 @@ void GameLogo::init()
     coffee_sprite_->setDestY(y_ - coffee_texture_->getHeight());
 
     // Inicializa el bitmap de 'Crisis'
-    crisis_sprite_->init();
     crisis_sprite_->setPosX(xp + 15);
     crisis_sprite_->setPosY(y_ + desp);
     crisis_sprite_->setWidth(crisis_texture_->getWidth());
@@ -96,6 +85,9 @@ void GameLogo::init()
     dust_left_sprite_->setPosY(y_);
     dust_left_sprite_->setWidth(16);
     dust_left_sprite_->setHeight(16);
+
+    // Inicializa el bitmap de 'Arcade Edition'
+    arcade_edition_sprite_->setZoom(zoom_);
 }
 
 // Pinta la clase en pantalla
@@ -105,7 +97,7 @@ void GameLogo::render()
     coffee_sprite_->render();
     crisis_sprite_->render();
 
-    if (status_ == Status::FINISHED)
+    if (arcade_edition_status_ != Status::DISABLED)
     {
         arcade_edition_sprite_->render();
     }
@@ -118,20 +110,22 @@ void GameLogo::render()
 // Actualiza la lógica de la clase
 void GameLogo::update()
 {
-    switch (status_)
+    switch (coffee_crisis_status_)
     {
     case Status::MOVING:
     {
         coffee_sprite_->update();
         crisis_sprite_->update();
 
-        // Si los objetos han llegado a su destino, cambiamos de Sección
+        // Si los objetos han llegado a su destino, cambia el estado
         if (coffee_sprite_->hasFinished() && crisis_sprite_->hasFinished())
         {
-            status_ = Status::SHAKING;
+            coffee_crisis_status_ = Status::SHAKING;
 
             // 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;
@@ -139,7 +133,7 @@ void GameLogo::update()
 
     case Status::SHAKING:
     {
-        // Agita el logo
+        // Agita "COFFEE CRISIS"
         if (shake_.remaining > 0)
         {
             if (shake_.counter > 0)
@@ -159,7 +153,8 @@ void GameLogo::update()
         {
             coffee_sprite_->setPosX(shake_.origin);
             crisis_sprite_->setPosX(shake_.origin + 15);
-            status_ = Status::FINISHED;
+            coffee_crisis_status_ = Status::FINISHED;
+            arcade_edition_status_ = Status::MOVING;
         }
 
         dust_right_sprite_->update();
@@ -179,19 +174,74 @@ void GameLogo::update()
     default:
         break;
     }
+
+    switch (arcade_edition_status_)
+    {
+    case Status::MOVING:
+    {
+        zoom_ -= 0.1f * ZOOM_FACTOR;
+        arcade_edition_sprite_->setZoom(zoom_);
+        if (zoom_ <= 1.0f)
+        {
+            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;
+    }
+
+    default:
+        break;
+    }
+
+    if (coffee_crisis_status_ == Status::FINISHED &&
+        arcade_edition_status_ == Status::FINISHED &&
+        post_finished_counter_ > 0)
+    {
+        --post_finished_counter_;
+    }
 }
 
 // Activa la clase
 void GameLogo::enable()
 {
     init();
-    status_ = Status::MOVING;
+    coffee_crisis_status_ = Status::MOVING;
 }
 
 // Indica si ha terminado la animación
 bool GameLogo::hasFinished() const
 {
-    return status_ == Status::FINISHED;
+    return post_finished_counter_ == 0;
 }
 
 // Recarga las texturas
@@ -200,6 +250,7 @@ void GameLogo::reLoad()
     dust_texture_->reLoad();
     coffee_texture_->reLoad();
     crisis_texture_->reLoad();
+    arcade_edition_texture_->reLoad();
 }
 
 // Calcula el desplazamiento vertical inicial

source/game_logo.h

@@ -1,11 +1,10 @@
 #pragma once
 
-#include <memory> // for unique_ptr, shared_ptr
-#include "animated_sprite.h"
-#include "smart_sprite.h"
-class Sprite;
-class Texture;
-struct JA_Sound_t; // lines 10-10
+#include <memory>            // Para unique_ptr, shared_ptr
+#include "animated_sprite.h" // Para AnimatedSprite
+#include "smart_sprite.h"    // Para SmartSprite
+#include "sprite.h"          // Para Sprite
+class Texture;               // lines 7-7
 
 // Clase GameLogo
 class GameLogo
@@ -21,12 +20,30 @@ private:
 
     struct Shake
     {
-        int desp;      // Pixels de desplazamiento para agitar la pantalla en el eje x
-        int delay;     // Retraso entre cada desplazamiento de la pantalla al agitarse
-        int counter;   // Contador para el retraso
-        int lenght;    // Cantidad de desplazamientos a realizar
-        int remaining; // Cantidad de desplazamientos pendientes a realizar
-        int origin;    // Valor inicial de la pantalla para dejarla igual tras el desplazamiento
+        int desp = 1;           // Pixels de desplazamiento para agitar la pantalla en el eje x
+        int delay = 2;          // Retraso entre cada desplazamiento de la pantalla al agitarse
+        int lenght = 8;         // Cantidad de desplazamientos a realizar
+        int remaining = lenght; // 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
+
+        // 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
@@ -44,11 +61,14 @@ 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 y_; // Posición donde dibujar el logo
+    int x_;                           // Posición donde dibujar el logo
+    int y_;                           // Posición donde dibujar el logo
+    float zoom_;                      // Zoom aplicado al texto "ARCADE EDITION"
+    int post_finished_counter_ = 1; // Contador final una vez terminada las animaciones de los logos
 
-    Status status_; // Estado en el que se encuentra la clase
-    Shake shake_;   // Estructura para generar el efecto de agitación
+    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"
+    Shake shake_;                                     // Estructura para generar el efecto de agitación
 
     // Inicializa las variables
     void init();

source/global_inputs.cpp

@@ -1,30 +1,22 @@
 #include "global_inputs.h"
-#include <string>       // for basic_string, operator+
-#include "input.h"      // for Input, inputs_e, INPUT_DO_NOT_ALLOW_REPEAT
-#include "jail_audio.h" // for JA_EnableMusic, JA_EnableSound
-#include "lang.h"       // for getText
-#include "notifier.h"   // for Notifier
-#include "options.h"    // for options
-#include "on_screen_help.h"
-#include "screen.h"  // for Screen
-#include "section.h" // for SectionOptions, name, SectionName, options
-#include "utils.h"   // for OptionsAudio, Options, OptionsMusic, boolToOnOff
+#include <string>           // Para operator+, string, to_string, basic_string
+#include <vector>           // Para vector
+#include "asset.h"          // Para Asset
+#include "input.h"          // Para Input, InputDeviceToUse, InputType, INPU...
+#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, options, OptionsGame, OptionsAudio
+#include "screen.h"         // Para Screen, ScreenVideoMode
+#include "section.h"        // Para Name, Options, name, options
+#include "utils.h"          // Para boolToOnOff, stringInVector
 
 namespace globalInputs
 {
     // Variables
-    std::vector<int> service_pressed_counter;
-
-    // Inicializa variables
-    void init()
-    {
-        const auto num_inputs = Input::get()->getNumControllers() + 1;
-        service_pressed_counter.reserve(num_inputs);
-        for (int i = 0; i < num_inputs; ++i)
-        {
-            service_pressed_counter.push_back(0);
-        }
-    }
+    int service_pressed_counter = 0;
+    bool service_pressed = false;
 
     // Termina
     void quit(section::Options code)
@@ -33,16 +25,18 @@ namespace globalInputs
         auto code_found = stringInVector(Notifier::get()->getCodes(), exit_code);
         if (code_found)
         {
+            // Si la notificación de salir está activa, cambia de sección
             section::name = section::Name::QUIT;
             section::options = code;
         }
         else
         {
+            // Si la notificación de salir no está activa, muestra la notificación
 #ifdef ARCADE
             const int index = code == section::Options::QUIT_WITH_CONTROLLER ? 116 : 94;
-            Notifier::get()->showText(lang::getText(index), std::string(), -1, exit_code);
+            Notifier::get()->showText({lang::getText(index), std::string()}, -1, exit_code);
 #else
-            Notifier::get()->showText(lang::getText(94), std::string(), -1, exit_code);
+            Notifier::get()->showText({lang::getText(94), std::string()}, -1, exit_code);
 #endif
         }
     }
@@ -51,95 +45,239 @@ namespace globalInputs
     void reset()
     {
         section::name = section::Name::INIT;
-        Notifier::get()->showText("Reset");
+        Notifier::get()->showText({"Reset"});
     }
 
     // Activa o desactiva el audio
-    void switchAudio()
+    void toggleAudio()
     {
-        options.audio.sound.enabled = options.audio.music.enabled = !options.audio.music.enabled;
-        JA_EnableMusic(options.audio.music.enabled);
-        JA_EnableSound(options.audio.sound.enabled);
-        Notifier::get()->showText("Audio " + boolToOnOff(options.audio.music.enabled));
+        options.audio.enabled = !options.audio.enabled;
+        if (options.audio.enabled)
+        {
+            JA_SetMusicVolume(to_JA_volume(options.audio.music.volume));
+            JA_SetSoundVolume(to_JA_volume(options.audio.sound.volume));
+        }
+        else
+        {
+            JA_SetMusicVolume(0);
+            JA_SetSoundVolume(0);
+        }
+        Notifier::get()->showText({"Audio " + boolToOnOff(options.audio.enabled)});
+    }
+
+    // Obtiene una fichero a partir de un lang::Code
+    std::string getLangFile(lang::Code code)
+    {
+        switch (code)
+        {
+        case lang::Code::ba_BA:
+            return Asset::get()->get("ba_BA.txt");
+            break;
+        case lang::Code::es_ES:
+            return Asset::get()->get("es_ES.txt");
+            break;
+        default:
+            return Asset::get()->get("en_UK.txt");
+            break;
+        }
+    }
+
+    // Obtiene una cadena a partir de un lang::Code
+    std::string getLangName(lang::Code code)
+    {
+        switch (code)
+        {
+        case lang::Code::ba_BA:
+            return "ba_BA";
+            break;
+        case lang::Code::es_ES:
+            return "es_ES";
+            break;
+        default:
+            return "en_UK";
+            break;
+        }
+    }
+
+    // Cambia el idioma
+    void changeLang()
+    {
+        options.game.language = lang::change(options.game.language);
+        lang::loadFromFile(getLangFile(static_cast<lang::Code>(options.game.language)));
+        section::name = section::Name::INIT;
+        section::options = section::Options::RELOAD;
+        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()
     {
-        // Comprueba si se sale con el teclado
-        if (Input::get()->checkInput(InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
+        // Teclado
         {
-            quit(section::Options::QUIT_WITH_KEYBOARD);
-            return;
-        }
-
-        // Comprueba si se va a resetear el juego
-        else if (Input::get()->checkInput(InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
-        {
-            reset();
-            return;
-        }
-
-        else if (Input::get()->checkInput(InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
-        {
-            switchAudio();
-            return;
-        }
-
-        else if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
-        {
-            service_pressed_counter[0]++;
-
-            if (service_pressed_counter[0] >= 3000)
+#ifndef ARCADE
+            // Comprueba el teclado para cambiar entre pantalla completa y ventana
+            if (Input::get()->checkInput(InputType::WINDOW_FULLSCREEN, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {
-                OnScreenHelp::get()->toggleState();
-                service_pressed_counter[0] = 0;
-            }
-            return;
-        }
-        else
-        {
-            service_pressed_counter[0] = 0;
-        }
-
-        for (int i = 0; i < Input::get()->getNumControllers(); ++i)
-        {
-            // Comprueba si se sale con el mando
-            if (Input::get()->checkModInput(InputType::SERVICE, InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
-            {
-                quit(section::Options::QUIT_WITH_CONTROLLER);
+                Screen::get()->toggleVideoMode();
+                const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? "Window" : "Fullscreen";
+                Notifier::get()->showText({mode + " mode"});
                 return;
             }
 
-            // Comprueba si se va a resetear el juego
-            else if (Input::get()->checkModInput(InputType::SERVICE, InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+            // Comprueba el teclado para decrementar el tamaño de la ventana
+            if (Input::get()->checkInput(InputType::WINDOW_DEC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
+            {
+                Screen::get()->decWindowSize();
+                const std::string size = std::to_string(options.video.window.size);
+                Notifier::get()->showText({"Window size x" + size});
+                return;
+            }
+
+            // Comprueba el teclado para incrementar el tamaño de la ventana
+            if (Input::get()->checkInput(InputType::WINDOW_INC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
+            {
+                Screen::get()->incWindowSize();
+                const std::string size = std::to_string(options.video.window.size);
+                Notifier::get()->showText({"Window size x" + size});
+                return;
+            }
+#endif
+            // Salir
+            if (Input::get()->checkInput(InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
+            {
+                quit(section::Options::QUIT_WITH_KEYBOARD);
+                return;
+            }
+
+            // Reset
+            if (Input::get()->checkInput(InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {
                 reset();
                 return;
             }
 
-            // Comprueba si se va a activar o desactivar el audio
-            else if (Input::get()->checkModInput(InputType::SERVICE, InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+            // Audio
+            if (Input::get()->checkInput(InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {
-                switchAudio();
+                toggleAudio();
                 return;
             }
 
-            if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+            // Autofire
+            if (Input::get()->checkInput(InputType::AUTO_FIRE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {
-                service_pressed_counter[i + 1]++;
+                toggleFireMode();
+                return;
+            }
 
-                if (service_pressed_counter[i + 1] >= 3000)
+            // Idioma
+            if (Input::get()->checkInput(InputType::CHANGE_LANG, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
+            {
+                changeLang();
+                return;
+            }
+
+            // Shaders
+            if (Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
+            {
+                Screen::get()->toggleShaders();
+                return;
+            }
+
+#ifdef DEBUG
+            // Comprueba el teclado para mostrar la información de debug
+            if (Input::get()->checkInput(InputType::SHOWINFO, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
+            {
+                Screen::get()->toggleDebugInfo();
+                return;
+            }
+#endif
+            // OnScreenHelp
+            if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
+            {
+                service_pressed = true;
+                return;
+            }
+        }
+
+        // Mandos
+        {
+            for (int i = 0; i < Input::get()->getNumControllers(); ++i)
+            {
+                // Salir
+                if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
+                    Input::get()->checkInput(InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
                 {
-                    OnScreenHelp::get()->toggleState();
-                    service_pressed_counter[i + 1] = 0;
+                    quit(section::Options::QUIT_WITH_CONTROLLER);
+                    return;
+                }
+
+                // Reset
+                if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
+                    Input::get()->checkInput(InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
+                {
+                    reset();
+                    return;
+                }
+
+                // Audio
+                if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
+                    Input::get()->checkInput(InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
+                {
+                    toggleAudio();
+                    return;
+                }
+
+                // Shaders
+                if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
+                    Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
+                {
+                    Screen::get()->toggleShaders();
+                    return;
+                }
+#ifdef DEBUG
+                // Debug Info
+                if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
+                    Input::get()->checkInput(InputType::SHOWINFO, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
+                {
+                    Screen::get()->toggleDebugInfo();
+                    return;
+                }
+#endif
+                // OnScreenHelp
+                if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
+                {
+                    service_pressed = true;
+                    return;
                 }
-                return;
-            }
-            else
-            {
-                service_pressed_counter[i + 1] = 0;
             }
         }
     }
+
+    // Actualiza variables
+    void update()
+    {
+        if (service_pressed)
+        {
+            ++service_pressed_counter;
+            if (service_pressed_counter >= 200)
+            {
+                OnScreenHelp::get()->toggleState();
+                service_pressed_counter = 0;
+            }
+        }
+        else
+        {
+            service_pressed_counter = 0;
+        }
+
+        service_pressed = false;
+    }
 }