Els items reboten al tocar el piso

Nova lògica al morir

.gitignore

@@ -14,3 +14,5 @@ thumbs.db
 *config.bin
 *score.bin
 coffee_crisis*
+debug.txt
+cppcheck-result*

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

@@ -25,8 +25,8 @@ INCLUDES:= -I$(DIR_SOURCES)
 ifeq ($(OS),Windows_NT)
     FixPath = $(subst /,\,$1)
 	SOURCES := source/*.cpp
-	CXXFLAGS:= -std=c++11 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows
-	CXXFLAGS_DEBUG:= -std=c++11 -Wall
+	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
@@ -34,8 +34,8 @@ else
     FixPath = $1
 	SOURCES := $(shell find $(DIR_SOURCES) -name '*.cpp')
 	SOURCES := source/*.cpp
-	CXXFLAGS:= -std=c++11 -Wall -Os -ffunction-sections -fdata-sections
-	CXXFLAGS_DEBUG:= -std=c++11 -Wall
+	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
@@ -50,84 +50,7 @@ else
     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"
-
+# Rules
 windows:
 	@echo off
 	$(CXX) $(SOURCES) $(CXXFLAGS) $(LDFLAGS) -o "$(TARGET_FILE).exe"
@@ -249,6 +172,13 @@ linux_release:
 # Elimina la carpeta temporal
 	$(RM) "$(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"
+
 anbernic:
 # Elimina carpetas previas
 	$(RM) "$(RELEASE_FOLDER)"_anbernic
@@ -259,6 +189,5 @@ 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,39 @@
-# 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.
+Coffee Crisis Arcade Edition es la versió ampliada i millorada del aclamat Coffee Crisis. Preparat per a jugar sense parar amn dos jugadors, nous gràfics i moltes sorpreses mes.
 
-![alt text](https://php.sustancia.synology.me/images/cc1.png)
+<p align="center">
+    <img src="https://php.sustancia.synology.me/images/ccae_title.png" alt="Titol" 
+</p>
 
-## Teclado
-El juego se maneja con teclado, aunque tambien se puede conectar un mando de control.
-Las teclas son las siguientes:
+## Controls
+El joc està optimitzat per a ser jugat amb un mando de jocs, encara que un dels jugadors pot utilitzar el teclat.
+Les tecles son les següents:
 
-* **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
+* **Fletxes**: Mou al personatge
+* **Q, W, E**: Disparar a la esquerra, al centre i a la dreta respectivament
 
-![alt text](https://php.sustancia.synology.me/images/cc2.png)
+<p align="center">
+    <img src="https://php.sustancia.synology.me/images/ccae1.png" alt="Joc" 
+</p>
 
-## Compilar
+## Altres tecles
+- **Tecla ESC**: Tancar el joc
 
-Para compilar el código se necesitan tener las librerías SDL instaladas en el sistema y el compilador g++.
+- **Tecla F1**: Fa la finestra mes xicoteta
 
-En Linux:
-```bash
-sudo apt install libsdl2-dev g++
-```
+- **Tecla F2**: Fa la finestra mes gran
 
-En macOS se pueden instalar fácilmente con [brew](https://brew.sh):
-```bash
-brew install sdl2 g++
-```
+- **Tecla F3**: Alterna entre el mode de pantalla completa i el de finestra
 
-Una vez instaladas las librerías SDL, se puede compilar utilizando el fichero Makefile suministrado.
+- **Tecla F4**: Activa o desactiva els shaders
 
-En Linux:
-```bash
-make linux
-```
+- **Tecla F10**: Reset
 
-En macOS:
-```bash
-make macos
-```
-![alt text](https://php.sustancia.synology.me/images/cc3.png)
+<p align="center">
+    <img src="https://php.sustancia.synology.me/images/ccae2.png" alt="Joc" 
+</p>
 
-## Como ejecutar
 
-Para ejecutar el juego hay que escribir en la terminal la orden que se muestra a continuación.
-
-En Linux:
-```bash
-./coffee_crisis_linux
-```
-
-En macOS:
-```bash
-./coffee_crisis_macos
-```
-
-En macOS tambien puedes hacer doble click sobre el archivo coffee_crisis_macos
-
-## 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.
-
-Y por supuesto a ti por estar aquí.
-
-## 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.
+## Agraiments
+A chatGPT i sobretot a Copilot. Gracies per estar sempre quan vos he necesitat.

data/config/param_320x240.txt

@@ -1,19 +1,20 @@
 ## GAME
-game.itemSize           20
-game.width             320
-game.height            240
-game.playArea.rect.x     0
-game.playArea.rect.y     0
-game.playArea.rect.w   320
-game.playArea.rect.h   200
+game.item_size           20 # Tamaño de los items del juego
+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  60 # Duración en segundos para introducir el nombre al finalizar la partida
 
 ## FADE
-fade.numSquaresWidth    160
-fade.numSquaresHeight   120
-fade.randomSquaresDelay   1
-fade.randomSquaresMult  500
-fade.postDuration        80
-fade.venetianSize        16
+fade.num_squares_width    160
+fade.num_squares_height   120
+fade.random_squares_delay   1
+fade.random_squares_mult  500
+fade.post_duration         80
+fade.venetian_size         16
 
 ## SCOREBOARD
 scoreboard.x   0
@@ -22,23 +23,31 @@ scoreboard.w 320
 scoreboard.h  40
 
 ## TITLE
-title.pressStartPosition    170
-title.titleDuration         800
-title.arcadeEditionPosition 123
-title.titleCCPosition        80
+title.press_start_position     170
+title.title_duration           800
+title.arcade_edition_position  123
+title.title_c_c_position        80
 
 ## BACKGROUND
-background.attenuateColor.r 255
-background.attenuateColor.g 255
-background.attenuateColor.b 255
-background.attenuateAlpha     0
+background.attenuate_color.r 255
+background.attenuate_color.g 255
+background.attenuate_color.b 255
+background.attenuate_alpha     0
 
 ## BALLOONS
-balloon1.vel  2.75f
-balloon1.grav 0.09f
-balloon2.vel  3.70f
-balloon2.grav 0.10f
-balloon3.vel  4.70f
-balloon3.grav 0.10f
-balloon4.vel  5.45f
-balloon4.grav 0.10f
+balloon_1.vel  2.75f
+balloon_1.grav 0.09f
+balloon_2.vel  3.70f
+balloon_2.grav 0.10f
+balloon_3.vel  4.70f
+balloon_3.grav 0.10f
+balloon_4.vel  5.45f
+balloon_4.grav 0.10f
+
+## NOTIFICATION
+notification.pos_v     TOP
+notification.pos_h    LEFT
+notification.sound   false
+notification.color.r    48
+notification.color.g    48
+notification.color.b    48

data/config/param_320x256.txt

@@ -1,19 +1,20 @@
 ## GAME
-game.itemSize           20
-game.width             320
-game.height            256
-game.playArea.rect.x     0
-game.playArea.rect.y     0
-game.playArea.rect.w   320
-game.playArea.rect.h   216
+game.item_size          20 # Tamaño de los items del juego
+game.width             320 # Ancho de la resolucion nativa del juego
+game.height            256 # Alto de la resolucion nativa del juego
+game.play_area.rect.x    0 # Rectangulo con la posición de la zona de juego
+game.play_area.rect.y    0 # Rectangulo con la posición de la zona de juego
+game.play_area.rect.w  320 # Rectangulo con la posición de la zona de juego
+game.play_area.rect.h  216 # Rectangulo con la posición de la zona de juego
+game.enter_name_seconds 60 # Duración en segundos para introducir el nombre al finalizar la partida
 
 ## FADE
-fade.numSquaresWidth    160
-fade.numSquaresHeight   128
-fade.randomSquaresDelay   1
-fade.randomSquaresMult  500
-fade.postDuration        80
-fade.venetianSize        16
+fade.num_squares_width    160
+fade.num_squares_height   128
+fade.random_squares_delay   1
+fade.random_squares_mult  500
+fade.post_duration         80
+fade.venetian_size         16
 
 ## SCOREBOARD
 scoreboard.x   0
@@ -22,23 +23,31 @@ scoreboard.w 320
 scoreboard.h  40
 
 ## TITLE
-title.pressStartPosition    180
-title.titleDuration         800
-title.arcadeEditionPosition 123
-title.titleCCPosition        80
+title.press_start_position     180
+title.title_duration           800
+title.arcade_edition_position  123
+title.title_c_c_position        80
 
 ## BACKGROUND
-background.attenuateColor.r 255
-background.attenuateColor.g 255
-background.attenuateColor.b 255
-background.attenuateAlpha     0
+background.attenuate_color.r 255
+background.attenuate_color.g 255
+background.attenuate_color.b 255
+background.attenuate_alpha     0
 
 ## BALLOONS
-balloon1.vel  2.75f
-balloon1.grav 0.09f
-balloon2.vel  3.70f
-balloon2.grav 0.10f
-balloon3.vel  4.70f
-balloon3.grav 0.10f
-balloon4.vel  5.45f
-balloon4.grav 0.10f
+balloon_1.vel  2.75f
+balloon_1.grav 0.09f
+balloon_2.vel  3.70f
+balloon_2.grav 0.10f
+balloon_3.vel  4.70f
+balloon_3.grav 0.10f
+balloon_4.vel  5.45f
+balloon_4.grav 0.10f
+
+## NOTIFICATION
+notification.pos_v     TOP
+notification.pos_h    LEFT
+notification.sound   false
+notification.color.r    48
+notification.color.g    48
+notification.color.b    48

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/balloon1.ani

@@ -1,5 +1,5 @@
-frameWidth=10
-frameHeight=10
+frame_width=10
+frame_height=10
 
 [animation]
 name=orange

data/gfx/balloon/balloon2.ani

@@ -1,5 +1,5 @@
-frameWidth=16
-frameHeight=16
+frame_width=16
+frame_height=16
 
 [animation]
 name=orange

data/gfx/balloon/balloon3.ani

@@ -1,5 +1,5 @@
-frameWidth=26
-frameHeight=26
+frame_width=26
+frame_height=26
 
 [animation]
 name=orange

data/gfx/balloon/balloon4.ani

@@ -1,5 +1,5 @@
-frameWidth=48
-frameHeight=48
+frame_width=48
+frame_height=48
 
 [animation]
 name=orange

data/gfx/balloon/explosion1.ani

@@ -1,5 +1,5 @@
-frameWidth=10
-frameHeight=10
+frame_width=10
+frame_height=10
 
 [animation]
 name=default

data/gfx/balloon/explosion2.ani

@@ -1,5 +1,5 @@
-frameWidth=16
-frameHeight=16
+frame_width=16
+frame_height=16
 
 [animation]
 name=default

data/gfx/balloon/explosion3.ani

@@ -1,5 +1,5 @@
-frameWidth=26
-frameHeight=26
+frame_width=26
+frame_height=26
 
 [animation]
 name=default

data/gfx/balloon/explosion4.ani

@@ -1,5 +1,5 @@
-frameWidth=46
-frameHeight=46
+frame_width=46
+frame_height=46
 
 [animation]
 name=default

data/gfx/balloon/powerball.ani

@@ -1,5 +1,5 @@
-frameWidth=46
-frameHeight=46
+frame_width=46
+frame_height=46
 
 [animation]
 name=powerball

data/gfx/item/item_clock.ani

@@ -1,5 +1,5 @@
-frameWidth=20
-frameHeight=20
+frame_width=20
+frame_height=20
 
 [animation]
 name=default

data/gfx/item/item_coffee.ani

@@ -1,5 +1,5 @@
-frameWidth=20
-frameHeight=20
+frame_width=20
+frame_height=20
 
 [animation]
 name=default

data/gfx/item/item_coffee_machine.ani

@@ -1,5 +1,5 @@
-frameWidth=28
-frameHeight=37
+frame_width=28
+frame_height=37
 
 [animation]
 name=default

data/gfx/item/item_points1_disk.ani

@@ -1,5 +1,5 @@
-frameWidth=20
-frameHeight=20
+frame_width=20
+frame_height=20
 
 [animation]
 name=default

data/gfx/item/item_points2_gavina.ani

@@ -1,5 +1,5 @@
-frameWidth=20
-frameHeight=20
+frame_width=20
+frame_height=20
 
 [animation]
 name=default

data/gfx/item/item_points3_pacmar.ani

@@ -1,5 +1,5 @@
-frameWidth=20
-frameHeight=20
+frame_width=20
+frame_height=20
 
 [animation]
 name=default

data/gfx/player/player.ani

@@ -1,5 +1,5 @@
-frameWidth=30
-frameHeight=30
+frame_width=30
+frame_height=30
 
 [animation]
 name=walk
@@ -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/player/player_power.ani

@@ -1,5 +1,5 @@
-frameWidth=39
-frameHeight=44
+frame_width=39
+frame_height=44
 
 [animation]
 name=default

data/gfx/title/title_dust.ani

@@ -1,5 +1,5 @@
-frameWidth=16
-frameHeight=16
+frame_width=16
+frame_height=16
 
 [animation]
 name=default

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
@@ -281,7 +281,7 @@ MODE FORA DE LINEA
 TAULER DE PUNTS
 
 ## 94 - NOTIFICACIONES
-Torna a polsar per eixir ...
+Torna a polsar per eixir
 
 ## 95 - DEFINE BUTTONS
 Disparar cap a l'esquerra
@@ -320,22 +320,43 @@ Continuar?
 Posa el nom
 
 ## 107 - AJUDA
-Canvia mandos
+Intercanviar mandos
 
 ## 108 - AJUDA
 Configuracio
 
 ## 109 - AJUDA
-Des-activa el so
+Alternar el audio
 
 ## 110 - AJUDA
-Filtros
+Filtres
 
 ## 111 - AJUDA
-Reset
+Reiniciar
 
 ## 112 - AJUDA
-Pausa
+Pausar
 
 ## 113 - AJUDA
-Eixir
+Eixir
+
+## 114 - MARCADOR
+Per favor
+
+## 115 - MARCADOR
+espere
+
+## 116 - NOTIFICACIONES
+Torna a polsar per apagar el sistema
+
+## 117 - GAME TEXT
+SuperPoder!
+
+## 118 - GAME TEXT
++1 Colp
+
+## 119 - GAME TEXT
+Temps!
+
+## 120 - SCOREBOARD
+Puntuacio

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
@@ -323,10 +323,10 @@ Enter name
 Swap Controllers
 
 ## 108 - AJUDA
-Config
+Configuration
 
 ## 109 - AJUDA
-Un-mute audio
+Toggle audio
 
 ## 110 - AJUDA
 Shaders
@@ -338,4 +338,25 @@ Reset
 Pause
 
 ## 113 - AJUDA
-Exit
+Exit
+
+## 114 - MARCADOR
+Please
+
+## 115 - MARCADOR
+wait
+
+## 116 - NOTIFICACIONES
+Press again to shutdown system
+
+## 117 - GAME TEXT
+PowerUp
+
+## 118 - GAME TEXT
++1 Hit
+
+## 119 - GAME TEXT
+Stop!
+
+## 120 - SCOREBOARD
+Score

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
@@ -320,22 +320,43 @@ Continuar?
 Pon tu nombre
 
 ## 107 - AJUDA
-Intercambia mandos
+Intercambiar mandos
 
 ## 108 - AJUDA
 Configuracion
 
 ## 109 - AJUDA
-Des-activa el sonido
+Alternar el audio
 
 ## 110 - AJUDA
 Filtros
 
 ## 111 - AJUDA
-Reset
+Reiniciar
 
 ## 112 - AJUDA
-Pausa
+Pausar
 
 ## 113 - AJUDA
-Salir
+Salir
+
+## 114 - MARCADOR
+Por favor
+
+## 115 - MARCADOR
+espere
+
+## 94 - NOTIFICACIONES
+Pulsa otra vez para apagar el sistema
+
+## 117 - GAME TEXT
+Potenciador
+
+## 118 - GAME TEXT
++1 Golpe
+
+## 119 - GAME TEXT
+Tiempo!
+
+## 120 - SCOREBOARD
+Puntuacion

linux_utils/check_all_includes.sh

@@ -4,5 +4,5 @@ SOURCEPATH=../source/
 
 for i in "$SOURCEPATH"/*.cpp
 do
-    include-what-you-use -D DEBUG -D VERBOSE -std=c++11 -Wall "$i"
+    include-what-you-use -D DEBUG -D VERBOSE -std=c++20 -Wall "$i"
 done

linux_utils/check_includes.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+SOURCEPATH=../source/
+
+for i in "$SOURCEPATH"/*.cpp
+do
+    include-what-you-use -D DEBUG -D VERBOSE -std=c++20 -Wall "$i"
+    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

linux_utils/valgrind_exceptions

@@ -0,0 +1,12 @@
+{  
+   ignore_unversioned_libs
+   Memcheck:Leak
+   ...
+   obj:*/lib*/lib*.so
+}
+{
+   ignore_versioned_libs
+   Memcheck:Leak
+   ...
+   obj:*/lib*/lib*.so.*
+}

source/animated_sprite.cpp

@@ -1,213 +1,63 @@
 #include "animated_sprite.h"
-#include <fstream>    // for basic_ostream, operator<<, basic_istream, basic...
-#include <iostream>   // for cout
-#include <sstream>    // for basic_stringstream
-#include "texture.h"  // for Texture
+#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 la animación desde un fichero
-animatedSprite_t loadAnimationFromFile(Texture *texture, std::string filePath, bool verbose)
+// Carga las animaciones en un vector(Animations) desde un fichero
+AnimationsFileBuffer loadAnimationsFromFile(const std::string &file_path)
 {
-	// Inicializa variables
-	animatedSprite_t as;
-	as.texture = texture;
-	int framesPerRow = 0;
-	int frameWidth = 0;
-	int frameHeight = 0;
-	int maxTiles = 0;
+	std::ifstream file(file_path);
+	if (!file)
+	{
+		std::cerr << "Error: Fichero no encontrado " << file_path << std::endl;
+		throw std::runtime_error("Fichero no encontrado: " + file_path);
+	}
 
-	const std::string filename = filePath.substr(filePath.find_last_of("\\/") + 1);
-	std::ifstream file(filePath);
+	printWithDots("Animation : ", file_path.substr(file_path.find_last_of("\\/") + 1), "[ LOADED ]");
+
+	std::vector<std::string> buffer;
 	std::string line;
-
-	// El fichero se puede abrir
-	if (file.good())
+	while (std::getline(file, line))
 	{
-		// Procesa el fichero linea a linea
-		if (verbose)
-		{
-			std::cout << "Animation loaded: " << filename << std::endl;
-		}
-		while (std::getline(file, line))
-		{
-			// Si la linea contiene el texto [animation] se realiza el proceso de carga de una animación
-			if (line == "[animation]")
-			{
-				animation_t buffer;
-				buffer.counter = 0;
-				buffer.currentFrame = 0;
-				buffer.completed = false;
-
-				do
-				{
-					std::getline(file, line);
-
-					// Encuentra la posición del caracter '='
-					int pos = line.find("=");
-
-					// Procesa las dos subcadenas
-					if (pos != (int)line.npos)
-					{
-						if (line.substr(0, pos) == "name")
-						{
-							buffer.name = line.substr(pos + 1, line.length());
-						}
-
-						else if (line.substr(0, pos) == "speed")
-						{
-							buffer.speed = std::stoi(line.substr(pos + 1, line.length()));
-						}
-
-						else if (line.substr(0, pos) == "loop")
-						{
-							buffer.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, frameWidth, frameHeight};
-							while (getline(ss, tmp, ','))
-							{
-								// Comprueba que el tile no sea mayor que el maximo indice permitido
-								const int numTile = std::stoi(tmp) > maxTiles ? 0 : std::stoi(tmp);
-								rect.x = (numTile % framesPerRow) * frameWidth;
-								rect.y = (numTile / framesPerRow) * frameHeight;
-								buffer.frames.push_back(rect);
-							}
-						}
-
-						else
-						{
-							std::cout << "Warning: file " << filename.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
-				as.animations.push_back(buffer);
-			}
-
-			// 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) == "framesPerRow")
-					{
-						framesPerRow = std::stoi(line.substr(pos + 1, line.length()));
-					}
-
-					else if (line.substr(0, pos) == "frameWidth")
-					{
-						frameWidth = std::stoi(line.substr(pos + 1, line.length()));
-					}
-
-					else if (line.substr(0, pos) == "frameHeight")
-					{
-						frameHeight = std::stoi(line.substr(pos + 1, line.length()));
-					}
-
-					else
-					{
-						std::cout << "Warning: file " << filename.c_str() << "\n, unknown parameter \"" << line.substr(0, pos).c_str() << "\"" << std::endl;
-					}
-
-					// Normaliza valores
-					if (framesPerRow == 0 && frameWidth > 0)
-					{
-						framesPerRow = texture->getWidth() / frameWidth;
-					}
-
-					if (maxTiles == 0 && frameWidth > 0 && frameHeight > 0)
-					{
-						const int w = texture->getWidth() / frameWidth;
-						const int h = texture->getHeight() / frameHeight;
-						maxTiles = w * h;
-					}
-				}
-			}
-		}
-
-		// Cierra el fichero
-		file.close();
-	}
-	// El fichero no se puede abrir
-	else
-	{
-		if (verbose)
-		{
-			std::cout << "Warning: Unable to open " << filename.c_str() << " file" << std::endl;
-		}
+		if (!line.empty())
+			buffer.push_back(line);
 	}
 
-	return as;
+	return buffer;
 }
 
 // Constructor
-AnimatedSprite::AnimatedSprite(Texture *texture, std::string file, std::vector<std::string> *buffer)
+AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const std::string &file_path)
+	: MovingSprite(texture)
 {
-	// Copia los punteros
-	setTexture(texture);
-
 	// Carga las animaciones
-	if (file != "")
+	if (!file_path.empty())
 	{
-		animatedSprite_t as = loadAnimationFromFile(texture, file);
-
-		// Copia los datos de las animaciones
-		for (auto animation : as.animations)
-		{
-			this->animation.push_back(animation);
-		}
+		AnimationsFileBuffer v = loadAnimationsFromFile(file_path);
+		loadFromAnimationsFileBuffer(v);
 	}
-
-	else if (buffer)
-	{
-		loadFromVector(buffer);
-	}
-
-	// Inicializa variables
-	currentAnimation = 0;
 }
 
 // Constructor
-AnimatedSprite::AnimatedSprite(animatedSprite_t *animation)
+AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const AnimationsFileBuffer &animations)
+	: MovingSprite(texture)
 {
-	// Copia los punteros
-	setTexture(animation->texture);
-
-	// Inicializa variables
-	currentAnimation = 0;
-
-	// Copia los datos de las animaciones
-	for (auto a : animation->animations)
+	if (!animations.empty())
 	{
-		this->animation.push_back(a);
+		loadFromAnimationsFileBuffer(animations);
 	}
 }
 
-// Destructor
-AnimatedSprite::~AnimatedSprite()
-{
-	for (auto &a : animation)
-	{
-		a.frames.clear();
-	}
-	animation.clear();
-}
-
 // Obtiene el indice de la animación a partir del nombre
-int AnimatedSprite::getIndex(std::string name)
+int AnimatedSprite::getIndex(const std::string &name)
 {
-	int index = -1;
+	auto index = -1;
 
-	for (auto a : animation)
+	for (const auto &a : animations_)
 	{
 		index++;
 		if (a.name == name)
@@ -215,293 +65,76 @@ int AnimatedSprite::getIndex(std::string name)
 			return index;
 		}
 	}
-
 	std::cout << "** Warning: could not find \"" << name.c_str() << "\" animation" << std::endl;
-
 	return -1;
 }
 
 // Calcula el frame correspondiente a la animación
 void AnimatedSprite::animate()
 {
-	if (!enabled || animation[currentAnimation].speed == 0)
+	if (animations_[current_animation_].speed == 0)
 	{
 		return;
 	}
 
 	// Calcula el frame actual a partir del contador
-	animation[currentAnimation].currentFrame = animation[currentAnimation].counter / animation[currentAnimation].speed;
+	animations_[current_animation_].current_frame = animations_[current_animation_].counter / animations_[current_animation_].speed;
 
 	// Si alcanza el final de la animación, reinicia el contador de la animación
 	// en función de la variable loop y coloca el nuevo frame
-	if (animation[currentAnimation].currentFrame >= (int)animation[currentAnimation].frames.size())
+	if (animations_[current_animation_].current_frame >= (int)animations_[current_animation_].frames.size())
 	{
-		if (animation[currentAnimation].loop == -1)
+		if (animations_[current_animation_].loop == -1)
 		{ // Si no hay loop, deja el último frame
-			animation[currentAnimation].currentFrame = animation[currentAnimation].frames.size();
-			animation[currentAnimation].completed = true;
+			animations_[current_animation_].current_frame = animations_[current_animation_].frames.size();
+			animations_[current_animation_].completed = true;
 		}
 		else
 		{ // Si hay loop, vuelve al frame indicado
-			animation[currentAnimation].counter = 0;
-			animation[currentAnimation].currentFrame = animation[currentAnimation].loop;
+			animations_[current_animation_].counter = 0;
+			animations_[current_animation_].current_frame = animations_[current_animation_].loop;
 		}
 	}
 	// En caso contrario
 	else
 	{
 		// Escoge el frame correspondiente de la animación
-		setSpriteClip(animation[currentAnimation].frames[animation[currentAnimation].currentFrame]);
+		setSpriteClip(animations_[current_animation_].frames[animations_[current_animation_].current_frame]);
 
 		// Incrementa el contador de la animacion
-		animation[currentAnimation].counter++;
+		animations_[current_animation_].counter++;
 	}
 }
 
-// Obtiene el número de frames de la animación actual
-int AnimatedSprite::getNumFrames()
-{
-	return (int)animation[currentAnimation].frames.size();
-}
-
-// Establece el frame actual de la animación
-void AnimatedSprite::setCurrentFrame(int num)
-{
-	// Descarta valores fuera de rango
-	if (num >= (int)animation[currentAnimation].frames.size())
-	{
-		num = 0;
-	}
-
-	// Cambia el valor de la variable
-	animation[currentAnimation].currentFrame = num;
-	animation[currentAnimation].counter = 0;
-
-	// Escoge el frame correspondiente de la animación
-	setSpriteClip(animation[currentAnimation].frames[animation[currentAnimation].currentFrame]);
-}
-
-// Establece el valor del contador
-void AnimatedSprite::setAnimationCounter(std::string name, int num)
-{
-	animation[getIndex(name)].counter = num;
-}
-
-// Establece la velocidad de una animación
-void AnimatedSprite::setAnimationSpeed(std::string name, int speed)
-{
-	animation[getIndex(name)].counter = speed;
-}
-
-// Establece la velocidad de una animación
-void AnimatedSprite::setAnimationSpeed(int index, int speed)
-{
-	animation[index].counter = speed;
-}
-
-// Establece si la animación se reproduce en bucle
-void AnimatedSprite::setAnimationLoop(std::string name, int loop)
-{
-	animation[getIndex(name)].loop = loop;
-}
-
-// Establece si la animación se reproduce en bucle
-void AnimatedSprite::setAnimationLoop(int index, int loop)
-{
-	animation[index].loop = loop;
-}
-
-// Establece el valor de la variable
-void AnimatedSprite::setAnimationCompleted(std::string name, bool value)
-{
-	animation[getIndex(name)].completed = value;
-}
-
-// OLD - Establece el valor de la variable
-void AnimatedSprite::setAnimationCompleted(int index, bool value)
-{
-	animation[index].completed = value;
-}
-
 // Comprueba si ha terminado la animación
 bool AnimatedSprite::animationIsCompleted()
 {
-	return animation[currentAnimation].completed;
-}
-
-// Devuelve el rectangulo de una animación y frame concreto
-SDL_Rect AnimatedSprite::getAnimationClip(std::string name, Uint8 index)
-{
-	return animation[getIndex(name)].frames[index];
-}
-
-// Devuelve el rectangulo de una animación y frame concreto
-SDL_Rect AnimatedSprite::getAnimationClip(int indexA, Uint8 indexF)
-{
-	return animation[indexA].frames[indexF];
-}
-
-// Carga la animación desde un vector
-bool AnimatedSprite::loadFromVector(std::vector<std::string> *source)
-{
-	// Inicializa variables
-	int framesPerRow = 0;
-	int frameWidth = 0;
-	int frameHeight = 0;
-	int maxTiles = 0;
-
-	// Indicador de éxito en el proceso
-	bool success = true;
-	std::string line;
-
-	// Recorre todo el vector
-	int 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_t buffer;
-			buffer.counter = 0;
-			buffer.currentFrame = 0;
-			buffer.completed = false;
-
-			do
-			{
-				// Aumenta el indice para leer la siguiente linea
-				index++;
-				line = source->at(index);
-
-				// Encuentra la posición del caracter '='
-				int pos = line.find("=");
-
-				// Procesa las dos subcadenas
-				if (pos != (int)line.npos)
-				{
-					if (line.substr(0, pos) == "name")
-					{
-						buffer.name = line.substr(pos + 1, line.length());
-					}
-
-					else if (line.substr(0, pos) == "speed")
-					{
-						buffer.speed = std::stoi(line.substr(pos + 1, line.length()));
-					}
-
-					else if (line.substr(0, pos) == "loop")
-					{
-						buffer.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, frameWidth, frameHeight};
-						while (getline(ss, tmp, ','))
-						{
-							// Comprueba que el tile no sea mayor que el maximo indice permitido
-							const int numTile = std::stoi(tmp) > maxTiles ? 0 : std::stoi(tmp);
-							rect.x = (numTile % framesPerRow) * frameWidth;
-							rect.y = (numTile / framesPerRow) * frameHeight;
-							buffer.frames.push_back(rect);
-						}
-					}
-
-					else
-					{
-						std::cout << "Warning: unknown parameter " << line.substr(0, pos).c_str() << std::endl;
-						success = false;
-					}
-				}
-			} while (line != "[/animation]");
-
-			// Añade la animación al vector de animaciones
-			animation.push_back(buffer);
-		}
-
-		// 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) == "framesPerRow")
-				{
-					framesPerRow = std::stoi(line.substr(pos + 1, line.length()));
-				}
-
-				else if (line.substr(0, pos) == "frameWidth")
-				{
-					frameWidth = std::stoi(line.substr(pos + 1, line.length()));
-				}
-
-				else if (line.substr(0, pos) == "frameHeight")
-				{
-					frameHeight = 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 (framesPerRow == 0 && frameWidth > 0)
-				{
-					framesPerRow = texture->getWidth() / frameWidth;
-				}
-
-				if (maxTiles == 0 && frameWidth > 0 && frameHeight > 0)
-				{
-					const int w = texture->getWidth() / frameWidth;
-					const int h = texture->getHeight() / frameHeight;
-					maxTiles = w * h;
-				}
-			}
-		}
-
-		// Una vez procesada la linea, aumenta el indice para pasar a la siguiente
-		index++;
-	}
-
-	// Pone un valor por defecto
-	setRect({0, 0, frameWidth, frameHeight});
-
-	return success;
+	return animations_[current_animation_].completed;
 }
 
 // Establece la animacion actual
-void AnimatedSprite::setCurrentAnimation(std::string name)
+void AnimatedSprite::setCurrentAnimation(const std::string &name)
 {
-	const int newAnimation = getIndex(name);
-	if (currentAnimation != newAnimation)
+	const auto new_animation = getIndex(name);
+	if (current_animation_ != new_animation)
 	{
-		currentAnimation = newAnimation;
-		animation[currentAnimation].currentFrame = 0;
-		animation[currentAnimation].counter = 0;
-		animation[currentAnimation].completed = false;
+		current_animation_ = new_animation;
+		animations_[current_animation_].current_frame = 0;
+		animations_[current_animation_].counter = 0;
+		animations_[current_animation_].completed = false;
 	}
 }
 
 // Establece la animacion actual
 void AnimatedSprite::setCurrentAnimation(int index)
 {
-	const int newAnimation = index;
-	if (currentAnimation != newAnimation)
+	const auto new_animation = index;
+	if (current_animation_ != new_animation)
 	{
-		currentAnimation = newAnimation;
-		animation[currentAnimation].currentFrame = 0;
-		animation[currentAnimation].counter = 0;
-		animation[currentAnimation].completed = false;
+		current_animation_ = new_animation;
+		animations_[current_animation_].current_frame = 0;
+		animations_[current_animation_].counter = 0;
+		animations_[current_animation_].completed = false;
 	}
 }
 
@@ -512,25 +145,106 @@ 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)
-{
-	animation[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 : animation)
-	{
-		a.counter = value;
-	}
-}
-
 // Reinicia la animación
 void AnimatedSprite::resetAnimation()
 {
-	animation[currentAnimation].currentFrame = 0;
-	animation[currentAnimation].counter = 0;
-	animation[currentAnimation].completed = false;
+	animations_[current_animation_].current_frame = 0;
+	animations_[current_animation_].counter = 0;
+	animations_[current_animation_].completed = false;
+}
+
+// Carga la animación desde un vector de cadenas
+void AnimatedSprite::loadFromAnimationsFileBuffer(const AnimationsFileBuffer &source)
+{
+	int frame_width = 1;
+	int frame_height = 1;
+	int frames_per_row = 1;
+	int max_tiles = 1;
+
+	size_t index = 0;
+	while (index < source.size())
+	{
+		std::string line = source.at(index);
+
+		// Parsea el fichero para buscar variables y valores
+		if (line != "[animation]")
+		{
+			// Encuentra la posición del caracter '='
+			size_t pos = line.find("=");
+
+			// Procesa las dos subcadenas
+			if (pos != std::string::npos)
+			{
+				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;
+
+				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;
+			}
+		}
+
+		// Si la linea contiene el texto [animation] se realiza el proceso de carga de una animación
+		if (line == "[animation]")
+		{
+			Animation animation;
+			do
+			{
+				index++;
+				line = source.at(index);
+				size_t pos = line.find("=");
+
+				if (pos != std::string::npos)
+				{
+					std::string key = line.substr(0, pos);
+					std::string value = line.substr(pos + 1);
+
+					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(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);
+							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 " << key << std::endl;
+				}
+			} while (line != "[/animation]");
+
+			// Añade la animación al vector de animaciones
+			animations_.emplace_back(animation);
+		}
+
+		// Una vez procesada la linea, aumenta el indice para pasar a la siguiente
+		index++;
+	}
+
+	// Pone un valor por defecto
+	setWidth(frame_width);
+	setHeight(frame_height);
 }

source/animated_sprite.h

@@ -1,97 +1,66 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>    // for SDL_Rect
-#include <SDL2/SDL_stdinc.h>  // for Uint8
-#include <string>             // for string, basic_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_t
+struct Animation
 {
     std::string name;             // Nombre de la animacion
     std::vector<SDL_Rect> frames; // Cada uno de los frames que componen la animación
     int speed;                    // Velocidad de la animación
     int loop;                     // Indica a que frame vuelve la animación al terminar. -1 para que no vuelva
     bool completed;               // Indica si ha finalizado la animación
-    int currentFrame;             // Frame actual
+    int current_frame;            // Frame actual
     int counter;                  // Contador para las animaciones
+
+    Animation() : name(std::string()), speed(5), loop(0), completed(false), current_frame(0), counter(0) {}
 };
 
-struct animatedSprite_t
-{
-    std::vector<animation_t> animations; // Vector con las diferentes animaciones
-    Texture *texture;                    // Textura con los graficos para el sprite
-};
+using AnimationsFileBuffer = std::vector<std::string>;
 
-// Carga la animación desde un fichero
-animatedSprite_t loadAnimationFromFile(Texture *texture, std::string filePath, bool verbose = false);
+// Carga las animaciones en un vector(Animations) desde un fichero
+AnimationsFileBuffer loadAnimationsFromFile(const std::string &file_path);
 
 class AnimatedSprite : public MovingSprite
 {
-private:
+protected:
     // Variables
-    std::vector<animation_t> animation; // Vector con las diferentes animaciones
-    int currentAnimation;               // Animacion activa
-
-public:
-    // Constructor
-    AnimatedSprite(Texture *texture = nullptr, std::string file = "", std::vector<std::string> *buffer = nullptr);
-    AnimatedSprite(animatedSprite_t *animation);
-
-    // Destructor
-    ~AnimatedSprite();
+    std::vector<Animation> animations_; // Vector con las diferentes animaciones
+    int current_animation_ = 0;         // Animacion activa
 
     // Calcula el frame correspondiente a la animación actual
     void animate();
 
-    // Obtiene el número de frames de la animación actual
-    int getNumFrames();
+    // Carga la animación desde un vector de cadenas
+    void loadFromAnimationsFileBuffer(const AnimationsFileBuffer &source);
 
-    // Establece el frame actual de la animación
-    void setCurrentFrame(int num);
+public:
+    // Constructor
+    AnimatedSprite(std::shared_ptr<Texture> texture, const std::string &file_path);
+    AnimatedSprite(std::shared_ptr<Texture> texture, const AnimationsFileBuffer &animations);
+    explicit AnimatedSprite(std::shared_ptr<Texture> texture)
+        : MovingSprite(texture) {}
 
-    // Establece el valor del contador
-    void setAnimationCounter(std::string name, int num);
+    // Destructor
+    virtual ~AnimatedSprite() = default;
 
-    // Establece la velocidad de una animación
-    void setAnimationSpeed(std::string name, int speed);
-    void setAnimationSpeed(int index, int speed);
-
-    // Establece el frame al que vuelve la animación al finalizar
-    void setAnimationLoop(std::string name, int loop);
-    void setAnimationLoop(int index, int loop);
-
-    // Establece el valor de la variable
-    void setAnimationCompleted(std::string name, bool value);
-    void setAnimationCompleted(int index, bool value);
+    // Actualiza las variables del objeto
+    void update() override;
 
     // Comprueba si ha terminado la animación
     bool animationIsCompleted();
 
-    // Devuelve el rectangulo de una animación y frame concreto
-    SDL_Rect getAnimationClip(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(std::string name);
-
-    // Carga la animación desde un vector
-    bool loadFromVector(std::vector<std::string> *source);
+    int getIndex(const std::string &name);
 
     // Establece la animacion actual
-    void setCurrentAnimation(std::string name = "default");
+    void setCurrentAnimation(const std::string &name = "default");
     void setCurrentAnimation(int index = 0);
 
-    // Actualiza las variables del objeto
-    void update();
-
-    // 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,104 +1,77 @@
 #include "asset.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;
+Asset *Asset::asset_ = nullptr;
 
 // [SINGLETON] Crearemos el objeto asset con esta función estática
-void Asset::init(std::string executablePath)
+void Asset::init(const std::string &executable_path)
 {
-    Asset::asset = new Asset(executablePath);
+    Asset::asset_ = new Asset(executable_path);
 }
 
 // [SINGLETON] Destruiremos el objeto asset con esta función estática
 void Asset::destroy()
 {
-    delete Asset::asset;
+    delete Asset::asset_;
 }
 
 // [SINGLETON] Con este método obtenemos el objeto asset y podemos trabajar con él
 Asset *Asset::get()
 {
-    return Asset::asset;
-}
-
-// Constructor
-Asset::Asset(std::string executablePath)
-{
-    this->executablePath = executablePath.substr(0, executablePath.find_last_of("\\/"));
-    longestName = 0;
-#ifdef VERBOSE
-    verbose = true;
-#else
-    verbose = false;
-#endif
-}
-
-// Destructor
-Asset::~Asset()
-{
-
+    return Asset::asset_;
 }
 
 // Añade un elemento a la lista
-void Asset::add(std::string file, enum assetType type, bool required, bool absolute)
+void Asset::add(const std::string &file, AssetType type, bool required, bool absolute)
 {
-    item_t temp;
-    temp.file = absolute ? file : executablePath + file;
-    temp.type = type;
-    temp.required = required;
-    fileList.push_back(temp);
-
-    const std::string filename = file.substr(file.find_last_of("\\/") + 1);
-    longestName = SDL_max(longestName, filename.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
-std::string Asset::get(std::string text)
+// Devuelve la ruta completa a un fichero a partir de una cadena
+std::string Asset::get(const std::string &text) const
 {
-    for (auto f : fileList)
-    {
-        const size_t lastIndex = f.file.find_last_of("/") + 1;
-        const std::string file = f.file.substr(lastIndex, std::string::npos);
+    auto it = std::find_if(file_list_.begin(), file_list_.end(),
+                           [&text](const auto &f)
+                           {
+                               return getFileName(f.file) == text;
+                           });
 
-        if (file == text)
-        {
-            return f.file;
-        }
-    }
-
-    if (verbose)
+    if (it != file_list_.end())
     {
-        std::cout << "Warning: file " << text.c_str() << " not found" << std::endl;
+        return it->file;
+    }
+    else
+    {
+        std::cout << "Warning: file " << text << " not found" << std::endl;
+        return "";
     }
-    return "";
 }
 
 // Comprueba que existen todos los elementos
-bool Asset::check()
+bool Asset::check() const
 {
     bool success = true;
 
-    if (verbose)
-    {
-        std::cout << "\n** Checking files" << std::endl;
+    std::cout << "\n** CHECKING FILES" << std::endl;
 
-        std::cout << "Executable path is:  " << executablePath << std::endl;
-        std::cout << "Sample filepath:  " << fileList.back().file << std::endl;
-    }
+    // std::cout << "Executable path is:  " << executable_path_ << std::endl;
+    // std::cout << "Sample filepath:  " << file_list_.back().file << std::endl;
 
     // Comprueba la lista de ficheros clasificandolos por tipo
-    for (int type = 0; type < t_maxAssetType; ++type)
+    for (int type = 0; type < static_cast<int>(AssetType::MAX_ASSET_TYPE); ++type)
     {
         // Comprueba si hay ficheros de ese tipo
         bool any = false;
 
-        for (auto f : fileList)
+        for (const auto &f : file_list_)
         {
-            if ((f.required) && (f.type == type))
+            if (f.required && f.type == static_cast<AssetType>(type))
             {
                 any = true;
             }
@@ -107,107 +80,77 @@ bool Asset::check()
         // Si hay ficheros de ese tipo, comprueba si existen
         if (any)
         {
-            if (verbose)
-            {
-                std::cout << "\n>> " << getTypeName(type).c_str() << " FILES" << std::endl;
-            }
+            std::cout << "\n>> " << getTypeName(static_cast<AssetType>(type)).c_str() << " FILES" << std::endl;
 
-            for (auto f : fileList)
+            for (const auto &f : file_list_)
             {
-                if ((f.required) && (f.type == type))
+                if (f.required && f.type == static_cast<AssetType>(type))
                 {
                     success &= checkFile(f.file);
                 }
             }
+            if (success)
+                std::cout << "   All files are OK." << std::endl;
         }
     }
 
     // Resultado
-    if (verbose)
-    {
-        if (success)
-        {
-            std::cout << "\n** All files OK.\n"
-                      << std::endl;
-        }
-        else
-        {
-            std::cout << "\n** A file is missing. Exiting.\n"
-                      << std::endl;
-        }
-    }
+    std::cout << (success ? "\n** CHECKING FILES COMPLETED.\n" : "\n** CHECKING FILES FAILED.\n") << std::endl;
 
     return success;
 }
 
 // Comprueba que existe un fichero
-bool Asset::checkFile(std::string path)
+bool Asset::checkFile(const std::string &path) const
 {
-    bool success = false;
-    std::string result = "ERROR";
+    std::ifstream file(path);
+    bool success = file.good();
+    file.close();
 
-    // Comprueba si existe el fichero
-    const std::string filename = path.substr(path.find_last_of("\\/") + 1);
-    SDL_RWops *file = SDL_RWFromFile(path.c_str(), "rb");
-
-    if (file != nullptr)
-    {
-        result = "OK";
-        success = true;
-        SDL_RWclose(file);
-    }
-
-    if (verbose)
-    {
-        std::cout.setf(std::ios::left, std::ios::adjustfield);
-        std::cout << "Checking file: ";
-        std::cout.width(longestName + 2);
-        std::cout.fill('.');
-        std::cout << filename + " ";
-        std::cout << " [" + result + "]" << std::endl;
-    }
+    if (!success)
+        printWithDots("Checking file : ", getFileName(path), "[ ERROR ]");
 
     return success;
 }
 
 // Devuelve el nombre del tipo de recurso
-std::string Asset::getTypeName(int type)
+std::string Asset::getTypeName(AssetType type) const
 {
     switch (type)
     {
-    case t_bitmap:
+    case AssetType::BITMAP:
         return "BITMAP";
         break;
 
-    case t_music:
+    case AssetType::MUSIC:
         return "MUSIC";
         break;
 
-    case t_sound:
+    case AssetType::SOUND:
         return "SOUND";
         break;
 
-    case t_font:
+    case AssetType::FONT:
         return "FONT";
         break;
 
-    case t_lang:
+    case AssetType::LANG:
         return "LANG";
         break;
 
-    case t_data:
+    case AssetType::DATA:
         return "DATA";
         break;
 
-    case t_animation:
+    case AssetType::ANIMATION:
         return "ANIMATION";
         break;
 
-    case t_palette:
+    case AssetType::PALETTE:
         return "PALETTE";
         break;
 
-    case t_item:
+    case AssetType::ITEM:
         return "ITEM";
         break;
 
@@ -217,18 +160,12 @@ std::string Asset::getTypeName(int type)
     }
 }
 
-// Establece si ha de mostrar texto por pantalla
-void Asset::setVerbose(bool value)
-{
-    verbose = value;
-}
-
 // Devuelve la lista de recursos de un tipo
-std::vector<std::string> Asset::getListByType(assetType type)
+std::vector<std::string> Asset::getListByType(AssetType type) const
 {
     std::vector<std::string> list;
 
-    for (auto f : fileList)
+    for (auto f : file_list_)
     {
         if (f.type == type)
         {

source/asset.h

@@ -1,20 +1,21 @@
 #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 assetType
+enum class AssetType : int
 {
-	t_bitmap,
-	t_music,
-	t_sound,
-	t_font,
-	t_lang,
-	t_data,
-	t_animation,
-	t_palette,
-	t_item,
-	t_maxAssetType
+	BITMAP,
+	MUSIC,
+	SOUND,
+	FONT,
+	LANG,
+	DATA,
+	ANIMATION,
+	PALETTE,
+	ITEM,
+	MAX_ASSET_TYPE,
 };
 
 // Clase Asset
@@ -22,38 +23,41 @@ class Asset
 {
 private:
 	// [SINGLETON] Objeto asset privado para Don Melitón
-	static Asset *asset;
+	static Asset *asset_;
 
 	// Estructura para definir un item
-	struct item_t
+	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 longestName;			  // Contiene la longitud del nombre de fichero mas largo
-	std::vector<item_t> fileList; // Listado con todas las rutas a los ficheros
-	std::string executablePath;	  // Ruta al ejecutable
-	bool verbose;				  // Indica si ha de mostrar información por pantalla
+	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
 
 	// Comprueba que existe un fichero
-	bool checkFile(std::string executablePath);
+	bool checkFile(const std::string &path) const;
 
 	// Devuelve el nombre del tipo de recurso
-	std::string getTypeName(int type);
+	std::string getTypeName(AssetType type) const;
 
 	// Constructor
-	Asset(std::string path);
+	explicit Asset(const std::string &executable_path)
+		: executable_path_(getPath(executable_path)) {}
 
 	// Destructor
-	~Asset();
+	~Asset() = default;
 
 public:
 	// [SINGLETON] Crearemos el objeto screen con esta función estática
-	static void init(std::string path);
+	static void init(const std::string &executable_path);
 
 	// [SINGLETON] Destruiremos el objeto screen con esta función estática
 	static void destroy();
@@ -62,17 +66,14 @@ public:
 	static Asset *get();
 
 	// Añade un elemento a la lista
-	void add(std::string file, enum assetType type, bool required = true, bool absolute = false);
+	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
-	std::string get(std::string text);
+	// 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
-	bool check();
-
-	// Establece si ha de mostrar texto por pantalla
-	void setVerbose(bool value);
+	bool check() const;
 
 	// Devuelve la lista de recursos de un tipo
-	std::vector<std::string> getListByType(assetType type);
+	std::vector<std::string> getListByType(AssetType type) const;
 };

source/background.cpp

@@ -1,187 +1,182 @@
 #include "background.h"
-#include <SDL2/SDL_blendmode.h>  // for SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_pixels.h>     // for SDL_PIXELFORMAT_RGBA8888
-#include <algorithm>             // for max, min
-#include <string>                // for basic_string
-#include "asset.h"               // for Asset
-#include "moving_sprite.h"        // for MovingSprite
-#include "param.h"               // for param
-#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 "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(SDL_Renderer *renderer)
+Background::Background()
+    : renderer_(Screen::get()->getRenderer()),
+
+      buildings_texture_(Resource::get()->getTexture("game_buildings.png")),
+      top_clouds_texture_(Resource::get()->getTexture("game_clouds1.png")),
+      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")),
+
+      rect_({0, 0, gradients_texture_->getWidth() / 2, gradients_texture_->getHeight() / 2}),
+      src_rect_({0, 0, 320, 240}),
+      dst_rect_({0, 0, 320, 240}),
+      base_(rect_.h),
+      color_(Color(param.background.attenuate_color.r, param.background.attenuate_color.g, param.background.attenuate_color.b)),
+      alpha_color_text_(param.background.attenuate_alpha),
+      alpha_color_text_temp_(param.background.attenuate_alpha)
+
 {
-    // Copia los punteros
-    this->renderer = renderer;
-    asset = Asset::get();
-
-    // Carga las texturas
-    buildingsTexture = new Texture(renderer, asset->get("game_buildings.png"));
-    topCloudsTexture = new Texture(renderer, asset->get("game_clouds1.png"));
-    bottomCloudsTexture = new Texture(renderer, asset->get("game_clouds2.png"));
-    grassTexture = new Texture(renderer, asset->get("game_grass.png"));
-    gradientsTexture = new Texture(renderer, asset->get("game_sky_colors.png"));
-
     // Inicializa variables
-    gradientNumber = 0;
-    alpha = 0;
-    cloudsSpeed = 0;
-    transition = 0;
-    counter = 0;
-
-    rect = {0, 0, gradientsTexture->getWidth() / 2, gradientsTexture->getHeight() / 2};
-    srcRect = {0, 0, 320, 240};
-    dstRect = {0, 0, 320, 240};
-
-    base = rect.h;
-    color = {param.background.attenuateColor.r, param.background.attenuateColor.g, param.background.attenuateColor.b};
-    alphaColorText = alphaColorTextTemp = param.background.attenuateAlpha;
-
-    gradientRect[0] = {0, 0, rect.w, rect.h};
-    gradientRect[1] = {rect.w, 0, rect.w, rect.h};
-    gradientRect[2] = {0, rect.h, rect.w, rect.h};
-    gradientRect[3] = {rect.w, rect.h, rect.w, rect.h};
-
-    const int topCloudsTextureHeight = topCloudsTexture->getHeight() / 4;
-    const int bottomCloudsTextureHeight = bottomCloudsTexture->getHeight() / 4;
-    for (int i = 0; i < 4; ++i)
     {
-        topCloudsRect[i] = {0, i * topCloudsTextureHeight, topCloudsTexture->getWidth(), topCloudsTextureHeight};
-        bottomCloudsRect[i] = {0, i * bottomCloudsTextureHeight, bottomCloudsTexture->getWidth(), bottomCloudsTextureHeight};
+        gradient_rect_[0] = {0, 0, rect_.w, rect_.h};
+        gradient_rect_[1] = {rect_.w, 0, rect_.w, rect_.h};
+        gradient_rect_[2] = {0, rect_.h, rect_.w, rect_.h};
+        gradient_rect_[3] = {rect_.w, rect_.h, rect_.w, rect_.h};
+
+        const int top_clouds_texture_height = top_clouds_texture_->getHeight() / 4;
+        const int bottom_clouds_texture_height = bottom_clouds_texture_->getHeight() / 4;
+        for (int i = 0; i < 4; ++i)
+        {
+            top_clouds_rect_[i] = {0, i * top_clouds_texture_height, top_clouds_texture_->getWidth(), top_clouds_texture_height};
+            bottom_clouds_rect_[i] = {0, i * bottom_clouds_texture_height, bottom_clouds_texture_->getWidth(), bottom_clouds_texture_height};
+        }
     }
 
     // Crea los sprites
-    const int topClouds_y = base - 165;
-    const int bottomClouds_y = base - 101;
-    const float topCloudsSpeed = 0.1f;
-    const float bottomCloudsSpeed = 0.05f;
-    topCloudsSprite_A = new MovingSprite(0, topClouds_y, rect.w, topCloudsTexture->getHeight(), -topCloudsSpeed, 0.0f, 0.0f, 0.0f, topCloudsTexture);
-    topCloudsSprite_B = new MovingSprite(rect.w, topClouds_y, rect.w, topCloudsTexture->getHeight(), -topCloudsSpeed, 0.0f, 0.0f, 0.0f, topCloudsTexture);
+    {
+        const int top_clouds_y = base_ - 165;
+        const int bottom_clouds_y = base_ - 101;
 
-    bottomCloudsSprite_A = new MovingSprite(0, bottomClouds_y, rect.w, bottomCloudsTexture->getHeight(), -bottomCloudsSpeed, 0.0f, 0.0f, 0.0f, bottomCloudsTexture);
-    bottomCloudsSprite_B = new MovingSprite(rect.w, bottomClouds_y, rect.w, bottomCloudsTexture->getHeight(), -bottomCloudsSpeed, 0.0f, 0.0f, 0.0f, bottomCloudsTexture);
+        top_clouds_sprite_a_ = std::make_unique<MovingSprite>(top_clouds_texture_, (SDL_Rect){0, top_clouds_y, rect_.w, top_clouds_texture_->getHeight()});
+        top_clouds_sprite_b_ = std::make_unique<MovingSprite>(top_clouds_texture_, (SDL_Rect){rect_.w, top_clouds_y, rect_.w, top_clouds_texture_->getHeight()});
 
-    buildingsSprite = new Sprite(0, 0, buildingsTexture->getWidth(), buildingsTexture->getHeight(), buildingsTexture);
-    gradientSprite = new Sprite(0, 0, rect.w, rect.h, gradientsTexture);
-    grassSprite = new Sprite(0, 0, grassTexture->getWidth(), grassTexture->getHeight() / 2, grassTexture);
+        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());
+        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);
+    }
 
     // Inicializa objetos
-    topCloudsSprite_A->setSpriteClip(0, 0, topCloudsTexture->getWidth(), topCloudsTexture->getHeight());
-    topCloudsSprite_B->setSpriteClip(0, 0, topCloudsTexture->getWidth(), topCloudsTexture->getHeight());
-    bottomCloudsSprite_A->setSpriteClip(0, 0, bottomCloudsTexture->getWidth(), bottomCloudsTexture->getHeight());
-    bottomCloudsSprite_B->setSpriteClip(0, 0, bottomCloudsTexture->getWidth(), bottomCloudsTexture->getHeight());
-    buildingsSprite->setPosY(base - buildingsSprite->getHeight());
-    grassSprite->setPosY(base - grassSprite->getHeight());
+    {
+        constexpr float top_clouds_speed = 0.1f;
+        constexpr float bottom_clouds_speed = 0.05f;
+
+        top_clouds_sprite_a_->setSpriteClip(0, 0, top_clouds_texture_->getWidth(), top_clouds_texture_->getHeight());
+        top_clouds_sprite_a_->setVelX(-top_clouds_speed);
+
+        top_clouds_sprite_b_->setSpriteClip(0, 0, top_clouds_texture_->getWidth(), top_clouds_texture_->getHeight());
+        top_clouds_sprite_b_->setVelX(-top_clouds_speed);
+
+        bottom_clouds_sprite_a_->setSpriteClip(0, 0, bottom_clouds_texture_->getWidth(), bottom_clouds_texture_->getHeight());
+        bottom_clouds_sprite_a_->setVelX(-bottom_clouds_speed);
+
+        bottom_clouds_sprite_b_->setSpriteClip(0, 0, bottom_clouds_texture_->getWidth(), bottom_clouds_texture_->getHeight());
+        bottom_clouds_sprite_b_->setVelX(-bottom_clouds_speed);
+
+        buildings_sprite_->setY(base_ - buildings_sprite_->getHeight());
+        grass_sprite_->setY(base_ - grass_sprite_->getHeight());
+    }
 
     // Crea la textura para componer el fondo
-    canvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
-    SDL_SetTextureBlendMode(canvas, SDL_BLENDMODE_BLEND);
+    canvas_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
+    SDL_SetTextureBlendMode(canvas_, SDL_BLENDMODE_BLEND);
 
     // Crea la textura para atenuar el fondo
-    colorTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
-    SDL_SetTextureBlendMode(colorTexture, SDL_BLENDMODE_BLEND);
-    setColor(color);
-    SDL_SetTextureAlphaMod(colorTexture, alphaColorText);
+    color_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
+    SDL_SetTextureBlendMode(color_texture_, SDL_BLENDMODE_BLEND);
+    setColor(color_);
+    SDL_SetTextureAlphaMod(color_texture_, alpha_color_text_);
 }
 
 // Destructor
 Background::~Background()
 {
-    delete buildingsTexture;
-    delete topCloudsTexture;
-    delete bottomCloudsTexture;
-    delete grassTexture;
-    delete gradientsTexture;
-
-    delete topCloudsSprite_A;
-    delete topCloudsSprite_B;
-    delete bottomCloudsSprite_A;
-    delete bottomCloudsSprite_B;
-    delete buildingsSprite;
-    delete gradientSprite;
-    delete grassSprite;
-    SDL_DestroyTexture(canvas);
-    SDL_DestroyTexture(colorTexture);
+    SDL_DestroyTexture(canvas_);
+    SDL_DestroyTexture(color_texture_);
 }
 
 // Actualiza la lógica del objeto
 void Background::update()
 {
-    // Actualiza el valor de alpha
+    // Actualiza el valor de alpha_
     updateAlphaColorText();
 
     // Actualiza las nubes
     updateClouds();
 
     // Calcula el frame de la hierba
-    grassSprite->setSpriteClip(0, (10 * (counter / 20 % 2)), 320, 10);
+    grass_sprite_->setSpriteClip(0, (10 * (counter_ / 20 % 2)), 320, 10);
 
-    // Calcula el valor de alpha
-    alpha = std::max((255 - (int)(255 * transition)), 0);
+    // Calcula el valor de alpha_
+    alpha_ = std::max((255 - (int)(255 * transition_)), 0);
 
     // Incrementa el contador
-    counter++;
+    ++counter_;
 
+    // Compone todos los elementos del fondo en la textura
     fillCanvas();
 }
 
 // Dibuja el gradiente de fondo
 void Background::renderGradient()
 {
-    // Dibuja el gradiente 2
-    gradientsTexture->setAlpha(255);
-    gradientSprite->setSpriteClip(gradientRect[(gradientNumber + 1) % 4]);
-    gradientSprite->render();
+    // Dibuja el gradiente de detras
+    gradients_texture_->setAlpha(255);
+    gradient_sprite_->setSpriteClip(gradient_rect_[(gradient_number_ + 1) % 4]);
+    gradient_sprite_->render();
 
-    // Dibuja el gradiente 1 con una opacidad cada vez menor
-    gradientsTexture->setAlpha(alpha);
-    gradientSprite->setSpriteClip(gradientRect[gradientNumber]);
-    gradientSprite->render();
+    // Dibuja el gradiente de delante con una opacidad cada vez menor
+    gradients_texture_->setAlpha(alpha_);
+    gradient_sprite_->setSpriteClip(gradient_rect_[gradient_number_]);
+    gradient_sprite_->render();
 }
 
 // Dibuja las nubes de arriba
 void Background::renderTopClouds()
 {
-    // Dibuja el primer conjunto de nubes
-    topCloudsTexture->setAlpha(255);
-    topCloudsSprite_A->setSpriteClip(topCloudsRect[(gradientNumber + 1) % 4]);
-    topCloudsSprite_A->render();
-    topCloudsSprite_B->setSpriteClip(topCloudsRect[(gradientNumber + 1) % 4]);
-    topCloudsSprite_B->render();
+    // Dibuja el primer conjunto de nubes, las de detras
+    top_clouds_texture_->setAlpha(255);
+    top_clouds_sprite_a_->setSpriteClip(top_clouds_rect_[(gradient_number_ + 1) % 4]);
+    top_clouds_sprite_b_->setSpriteClip(top_clouds_rect_[(gradient_number_ + 1) % 4]);
+    top_clouds_sprite_a_->render();
+    top_clouds_sprite_b_->render();
 
-    // Dibuja el segundo conjunto de nubes
-    topCloudsTexture->setAlpha(alpha);
-    topCloudsSprite_A->setSpriteClip(topCloudsRect[gradientNumber]);
-    topCloudsSprite_A->render();
-    topCloudsSprite_B->setSpriteClip(topCloudsRect[gradientNumber]);
-    topCloudsSprite_B->render();
+    // Dibuja el segundo conjunto de nubes, las de delante
+    top_clouds_texture_->setAlpha(alpha_);
+    top_clouds_sprite_a_->setSpriteClip(top_clouds_rect_[gradient_number_]);
+    top_clouds_sprite_b_->setSpriteClip(top_clouds_rect_[gradient_number_]);
+    top_clouds_sprite_a_->render();
+    top_clouds_sprite_b_->render();
 }
 
 // Dibuja las nubes de abajo
 void Background::renderBottomClouds()
 {
-    // Dibuja el primer conjunto de nubes
-    bottomCloudsTexture->setAlpha(255);
-    bottomCloudsSprite_A->setSpriteClip(bottomCloudsRect[(gradientNumber + 1) % 4]);
-    bottomCloudsSprite_A->render();
-    bottomCloudsSprite_B->setSpriteClip(bottomCloudsRect[(gradientNumber + 1) % 4]);
-    bottomCloudsSprite_B->render();
+    // Dibuja el primer conjunto de nubes, las de detras
+    bottom_clouds_texture_->setAlpha(255);
+    bottom_clouds_sprite_a_->setSpriteClip(bottom_clouds_rect_[(gradient_number_ + 1) % 4]);
+    bottom_clouds_sprite_b_->setSpriteClip(bottom_clouds_rect_[(gradient_number_ + 1) % 4]);
+    bottom_clouds_sprite_a_->render();
+    bottom_clouds_sprite_b_->render();
 
-    // Dibuja el segundo conjunto de nubes
-    bottomCloudsTexture->setAlpha(alpha);
-    bottomCloudsSprite_A->setSpriteClip(bottomCloudsRect[gradientNumber]);
-    bottomCloudsSprite_A->render();
-    bottomCloudsSprite_B->setSpriteClip(bottomCloudsRect[gradientNumber]);
-    bottomCloudsSprite_B->render();
+    // Dibuja el segundo conjunto de nubes, las de delante
+    bottom_clouds_texture_->setAlpha(alpha_);
+    bottom_clouds_sprite_a_->setSpriteClip(bottom_clouds_rect_[gradient_number_]);
+    bottom_clouds_sprite_b_->setSpriteClip(bottom_clouds_rect_[gradient_number_]);
+    bottom_clouds_sprite_a_->render();
+    bottom_clouds_sprite_b_->render();
 }
 
 // Compone todos los elementos del fondo en la textura
 void Background::fillCanvas()
 {
     // Cambia el destino del renderizador
-    SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-    SDL_SetRenderTarget(renderer, canvas);
+    auto temp = SDL_GetRenderTarget(renderer_);
+    SDL_SetRenderTarget(renderer_, canvas_);
 
     // Dibuja el gradiente de fondo
     renderGradient();
@@ -193,119 +188,102 @@ void Background::fillCanvas()
     renderBottomClouds();
 
     // Dibuja los edificios
-    buildingsSprite->render();
+    buildings_sprite_->render();
 
     // Dibuja la hierba
-    grassSprite->render();
+    grass_sprite_->render();
 
     // Deja el renderizador apuntando donde estaba
-    SDL_SetRenderTarget(renderer, temp);
+    SDL_SetRenderTarget(renderer_, temp);
 }
 
 // Dibuja el objeto
 void Background::render()
 {
     // Fondo
-    SDL_RenderCopy(renderer, canvas, &srcRect, &dstRect);
+    SDL_RenderCopy(renderer_, canvas_, &src_rect_, &dst_rect_);
 
     // Atenuación
-    SDL_RenderCopy(renderer, colorTexture, &srcRect, &dstRect);
+    SDL_RenderCopy(renderer_, color_texture_, &src_rect_, &dst_rect_);
 }
 
 // Vuelve a cargar las texturas
 void Background::reloadTextures()
 {
-    buildingsTexture->reLoad();
-    topCloudsTexture->reLoad();
-    bottomCloudsTexture->reLoad();
-    grassTexture->reLoad();
-    gradientsTexture->reLoad();
+    buildings_texture_->reLoad();
+    top_clouds_texture_->reLoad();
+    bottom_clouds_texture_->reLoad();
+    grass_texture_->reLoad();
+    gradients_texture_->reLoad();
 }
 
 // Ajusta el valor de la variable
 void Background::setCloudsSpeed(float value)
 {
-    cloudsSpeed = value;
+    clouds_speed_ = value;
 }
 
 // Ajusta el valor de la variable
 void Background::setGradientNumber(int value)
 {
-    gradientNumber = value % 4;
+    gradient_number_ = value % 4;
 }
 
 // Ajusta el valor de la variable
 void Background::setTransition(float value)
 {
-    value = std::min(value, 1.0f);
-    value = std::max(value, 0.0f);
-    transition = value;
+    transition_ = std::clamp(value, 0.0f, 1.0f);
 }
 
 // Establece la posición del objeto
 void Background::setPos(SDL_Rect pos)
 {
-    this->dstRect = pos;
+    dst_rect_ = pos;
 
     // Si cambian las medidas del destino, hay que cambiar las del origen para evitar deformar la imagen
-    this->srcRect.x = 0;
-    this->srcRect.y = rect.h - pos.h;
-    this->srcRect.w = pos.w;
-    this->srcRect.h = pos.h;
+    src_rect_.x = 0;
+    src_rect_.y = rect_.h - pos.h;
+    src_rect_.w = pos.w;
+    src_rect_.h = pos.h;
 }
 
-// Ajusta el valor de la variable
-void Background::setSrcRect(SDL_Rect value)
+// Establece el color_ de atenuación
+void Background::setColor(Color color)
 {
-    srcRect = value;
-}
-
-// Ajusta el valor de la variable
-void Background::setDstRect(SDL_Rect value)
-{
-    dstRect = value;
-}
-
-// Establece el color de atenuación
-void Background::setColor(color_t color)
-{
-    this->color = color;
+    color_ = color;
 
     // Colorea la textura
-    SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-    SDL_SetRenderTarget(renderer, colorTexture);
+    auto temp = SDL_GetRenderTarget(renderer_);
+    SDL_SetRenderTarget(renderer_, color_texture_);
 
-    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 255);
-    SDL_RenderClear(renderer);
+    SDL_SetRenderDrawColor(renderer_, color_.r, color_.g, color_.b, 255);
+    SDL_RenderClear(renderer_);
 
-    SDL_SetRenderTarget(renderer, temp);
+    SDL_SetRenderTarget(renderer_, temp);
 }
 
 // Establece la transparencia de la atenuación
 void Background::setAlpha(int alpha)
 {
     // Evita que se asignen valores fuera de rango
-    alpha = std::min(alpha, 255);
-    alpha = std::max(alpha, 0);
+    alpha_ = std::clamp(alpha, 0, 255);
 
-    // Guarda el valor actual
-    alphaColorTextTemp = alphaColorText;
-
-    // Establece el nuevo valor
-    alphaColorText = alpha;
+    // Guarda el valor actual y establece el nuevo valor
+    alpha_color_text_temp_ = alpha_color_text_;
+    alpha_color_text_ = alpha_;
 }
 
-// Actualiza el valor de alpha
+// Actualiza el valor de alpha_
 void Background::updateAlphaColorText()
 {
-    if (alphaColorText == alphaColorTextTemp)
+    if (alpha_color_text_ == alpha_color_text_temp_)
     {
         return;
     }
     else
     {
-        alphaColorText > alphaColorTextTemp ? alphaColorTextTemp++ : alphaColorTextTemp--;
-        SDL_SetTextureAlphaMod(colorTexture, alphaColorTextTemp);
+        alpha_color_text_ > alpha_color_text_temp_ ? ++alpha_color_text_temp_ : --alpha_color_text_temp_;
+        SDL_SetTextureAlphaMod(color_texture_, alpha_color_text_temp_);
     }
 }
 
@@ -313,35 +291,35 @@ void Background::updateAlphaColorText()
 void Background::updateClouds()
 {
     // Aplica la velocidad calculada a las nubes
-    topCloudsSprite_A->setVelX(cloudsSpeed);
-    topCloudsSprite_B->setVelX(cloudsSpeed);
-    bottomCloudsSprite_A->setVelX(cloudsSpeed / 2);
-    bottomCloudsSprite_B->setVelX(cloudsSpeed / 2);
+    top_clouds_sprite_a_->setVelX(clouds_speed_);
+    top_clouds_sprite_b_->setVelX(clouds_speed_);
+    bottom_clouds_sprite_a_->setVelX(clouds_speed_ / 2);
+    bottom_clouds_sprite_b_->setVelX(clouds_speed_ / 2);
 
     // Mueve las nubes
-    topCloudsSprite_A->move();
-    topCloudsSprite_B->move();
-    bottomCloudsSprite_A->move();
-    bottomCloudsSprite_B->move();
+    top_clouds_sprite_a_->update();
+    top_clouds_sprite_b_->update();
+    bottom_clouds_sprite_a_->update();
+    bottom_clouds_sprite_b_->update();
 
     // Calcula el offset de las nubes
-    if (topCloudsSprite_A->getPosX() < -topCloudsSprite_A->getWidth())
+    if (top_clouds_sprite_a_->getPosX() < -top_clouds_sprite_a_->getWidth())
     {
-        topCloudsSprite_A->setPosX(topCloudsSprite_A->getWidth());
+        top_clouds_sprite_a_->setPosX(top_clouds_sprite_a_->getWidth());
     }
 
-    if (topCloudsSprite_B->getPosX() < -topCloudsSprite_B->getWidth())
+    if (top_clouds_sprite_b_->getPosX() < -top_clouds_sprite_b_->getWidth())
     {
-        topCloudsSprite_B->setPosX(topCloudsSprite_B->getWidth());
+        top_clouds_sprite_b_->setPosX(top_clouds_sprite_b_->getWidth());
     }
 
-    if (bottomCloudsSprite_A->getPosX() < -bottomCloudsSprite_A->getWidth())
+    if (bottom_clouds_sprite_a_->getPosX() < -bottom_clouds_sprite_a_->getWidth())
     {
-        bottomCloudsSprite_A->setPosX(bottomCloudsSprite_A->getWidth());
+        bottom_clouds_sprite_a_->setPosX(bottom_clouds_sprite_a_->getWidth());
     }
 
-    if (bottomCloudsSprite_B->getPosX() < -bottomCloudsSprite_B->getWidth())
+    if (bottom_clouds_sprite_b_->getPosX() < -bottom_clouds_sprite_b_->getWidth())
     {
-        bottomCloudsSprite_B->setPosX(bottomCloudsSprite_B->getWidth());
+        bottom_clouds_sprite_b_->setPosX(bottom_clouds_sprite_b_->getWidth());
     }
 }

source/background.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 "utils.h"            // for color_t
-class Asset;
+#include <SDL2/SDL_rect.h>   // para SDL_Rect
+#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
+#include <memory>            // para unique_ptr, shared_ptr
+#include "utils.h"           // para Color
 class MovingSprite;
 class Sprite;
 class Texture;
@@ -32,13 +32,7 @@ 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_t color)
+        - setColor(Color color)
           Establece el color de la textura de superposición
 
         - setAlpha(int alpha)
@@ -50,43 +44,42 @@ class Background
 {
 private:
   // Objetos y punteros
-  SDL_Renderer *renderer; // El renderizador de la ventana
-  Asset *asset;           // Objeto que gestiona todos los ficheros de recursos
+  SDL_Renderer *renderer_; // El renderizador de la ventana
 
-  Texture *buildingsTexture;    // Textura con los edificios de fondo
-  Texture *topCloudsTexture;    // Textura con las nubes de fondo
-  Texture *bottomCloudsTexture; // Textura con las nubes de fondo
-  Texture *grassTexture;        // Textura con la hierba del suelo
-  Texture *gradientsTexture;    // Textura con los diferentes colores de fondo del juego
+  std::shared_ptr<Texture> buildings_texture_;     // Textura con los edificios de fondo
+  std::shared_ptr<Texture> top_clouds_texture_;    // Textura con las nubes de fondo
+  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
 
-  MovingSprite *topCloudsSprite_A;    // Sprite para las nubes superiores
-  MovingSprite *topCloudsSprite_B;    // Sprite para las nubes superiores
-  MovingSprite *bottomCloudsSprite_A; // Sprite para las nubes inferiores
-  MovingSprite *bottomCloudsSprite_B; // Sprite para las nubes inferiores
+  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
+  std::unique_ptr<MovingSprite> bottom_clouds_sprite_a_; // Sprite para las nubes inferiores
+  std::unique_ptr<MovingSprite> bottom_clouds_sprite_b_; // Sprite para las nubes inferiores
 
-  Sprite *buildingsSprite; // Sprite con los edificios de fondo
-  Sprite *gradientSprite;  // Sprite con los graficos del degradado de color de fondo
-  Sprite *grassSprite;     // Sprite para la hierba
+  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
 
-  SDL_Texture *canvas;       // Textura para componer el fondo
-  SDL_Texture *colorTexture; // Textura para atenuar el fondo
+  SDL_Texture *canvas_;        // Textura para componer el fondo
+  SDL_Texture *color_texture_; // Textura para atenuar el fondo
 
   // Variables
-  SDL_Rect gradientRect[4];     // Vector con las coordenadas de los 4 degradados para el cielo
-  SDL_Rect topCloudsRect[4];    // Vector con las coordenadas de los 4 nubes de arriba
-  SDL_Rect bottomCloudsRect[4]; // Vector con las coordenadas de los 4 nubes de abajo
-  int gradientNumber;           // Indica el número de degradado de fondo que se va a dibujar
-  int alpha;                    // Transparencia entre los dos degradados
-  float cloudsSpeed;            // 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 srcRect;             // Parte del objeto fondo que se va a dibujará en pantalla
-  SDL_Rect dstRect;             // 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_t color;                // Color para atenuar el fondo
-  int alphaColorText;           // Alpha para atenuar el fondo
-  int alphaColorTextTemp;       // 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 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
 
   // Dibuja el gradiente de fondo
   void renderGradient();
@@ -108,7 +101,7 @@ private:
 
 public:
   // Constructor
-  Background(SDL_Renderer *renderer);
+  Background();
 
   // Destructor
   ~Background();
@@ -134,14 +127,8 @@ 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_t color);
+  void setColor(Color color);
 
   // Establece la transparencia de la atenuación
   void setAlpha(int alpha);

source/balloon.h

@@ -1,130 +1,131 @@
 #pragma once
 
-#include <SDL2/SDL_stdinc.h>  // for Uint8, Uint16, Uint32
-#include <string>             // for string
-#include <vector>             // for vector
-#include "utils.h"            // for circle_t
-class AnimatedSprite;
-class Texture;
+#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 10-10
 
 // Cantidad de elementos del vector con los valores de la deformación del globo al rebotar
-#define MAX_BOUNCE 10
-
-// Tipos de globo
-#define BALLOON_1 1
-#define BALLOON_2 2
-#define BALLOON_3 3
-#define BALLOON_4 4
-#define HEXAGON_1 5
-#define HEXAGON_2 6
-#define HEXAGON_3 7
-#define HEXAGON_4 8
-#define POWER_BALL 9
+constexpr int MAX_BOUNCE = 10;
 
 // Puntos de globo
-#define BALLOON_SCORE_1 50
-#define BALLOON_SCORE_2 100
-#define BALLOON_SCORE_3 200
-#define 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};
 
 // Tamaños de globo
-#define BALLOON_SIZE_1 1
-#define BALLOON_SIZE_2 2
-#define BALLOON_SIZE_3 3
-#define BALLOON_SIZE_4 4
+enum class BalloonSize : Uint8
+{
+	SIZE1 = 0,
+	SIZE2 = 1,
+	SIZE3 = 2,
+	SIZE4 = 3,
+};
 
 // Clases de globo
-#define BALLOON_CLASS 0
-#define HEXAGON_CLASS 1
+enum class BalloonType : Uint8
+{
+	BALLOON = 0,
+	FLOATER = 1,
+	POWERBALL = 2,
+};
 
 // Velocidad del globo
-#define BALLOON_VELX_POSITIVE 0.7f
-#define BALLOON_VELX_NEGATIVE -0.7f
+constexpr float BALLOON_VELX_POSITIVE = 0.7f;
+constexpr float BALLOON_VELX_NEGATIVE = -0.7f;
 
 // Indice para las animaciones de los globos
-#define BALLOON_MOVING_ANIMATION 0
-#define BALLOON_POP_ANIMATION 1
-#define BALLOON_BORN_ANIMATION 2
-
-// Cantidad posible de globos
-#define MAX_BALLOONS 100
+constexpr int BALLOON_MOVING_ANIMATION = 0;
+constexpr int BALLOON_POP_ANIMATION = 1;
+constexpr int BALLOON_BORN_ANIMATION = 2;
 
 // Velocidades a las que se mueven los globos
-#define BALLOON_SPEED_1 0.60f
-#define BALLOON_SPEED_2 0.70f
-#define BALLOON_SPEED_3 0.80f
-#define BALLOON_SPEED_4 0.90f
-#define BALLOON_SPEED_5 1.00f
-
-// Tamaño de los globos
-#define BALLOON_WIDTH_1 10
-#define BALLOON_WIDTH_2 16
-#define BALLOON_WIDTH_3 26
-#define BALLOON_WIDTH_4 46
+constexpr float BALLOON_SPEED[] = {0.60f, 0.70f, 0.80f, 0.90f, 1.00f};
 
 // PowerBall
-#define POWERBALL_SCREENPOWER_MINIMUM 10
-#define POWERBALL_COUNTER 8
+constexpr int POWERBALL_SCREENPOWER_MINIMUM = 10;
+constexpr int POWERBALL_COUNTER = 8;
 
 // Clase Balloon
 class Balloon
 {
 private:
-	// Estructura para las variables para el efecto de los rebotes
-	struct bouncing
+	// 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
-	AnimatedSprite *sprite; // Sprite del objeto globo
+	std::unique_ptr<AnimatedSprite> sprite_; // Sprite del objeto globo
 
 	// Variables
-	float posX;				   // Posición en el eje X
-	float posY;				   // Posición en el eje Y
-	Uint8 width;			   // Ancho
-	Uint8 height;			   // Alto
-	float velX;				   // Velocidad en el eje X. Cantidad de pixeles a desplazarse
-	float velY;				   // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
-	float gravity;			   // Aceleración en el eje Y. Modifica la velocidad
-	float defaultVelY;		   // Velocidad inicial que tienen al rebotar contra el suelo
-	float maxVelY;			   // Máxima velocidad que puede alcanzar el objeto en el eje Y
-	bool beingCreated;		   // 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_t collider;		   // Circulo de colisión del objeto
-	Uint16 creationCounter;	   // Temporizador para controlar el estado "creandose"
-	Uint16 creationCounterIni; // Valor inicial para el temporizador para controlar el estado "creandose"
-	Uint16 score;			   // Puntos que da el globo al ser destruido
-	Uint16 stoppedCounter;	   // 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 travelY;			   // 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
 
 	// 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();
@@ -133,20 +134,17 @@ private:
 	void updateState();
 
 	// Establece la animación correspondiente
-	void updateAnimation();
-
-	// Establece el valor de la variable
-	void setBeingCreated(bool value);
+	void setAnimation();
 
 public:
 	// Constructor
-	Balloon(float x, float y, Uint8 kind, float velx, float speed, Uint16 creationtimer, Texture *texture, std::vector<std::string> *animation);
+	Balloon(float x, float y, BalloonType type, BalloonSize size, float vel_x, float speed, Uint16 creation_timer, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
 
 	// Destructor
-	~Balloon();
+	~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();
@@ -163,87 +161,39 @@ public:
 	// Actualiza al globo a su posicion, animación y controla los contadores
 	void update();
 
-	// Comprueba si el globo está habilitado
-	bool isEnabled();
+	// Detiene el globo
+	void stop();
 
-	// Obtiene del valor de la variable
-	float getPosX();
+	// Pone el globo en movimiento
+	void start();
 
-	// Obtiene del valor de la variable
-	float getPosY();
+	// Pone el color alternativo en el globo
+	void useReverseColor();
 
-	// Obtiene del valor de la variable
-	float getVelY();
+	// Pone el color normal en el globo
+	void useNormalColor();
 
-	// Obtiene del valor de la variable
-	int getWidth();
+	// 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();
-
-	// Establece el valor de la variable
-	void setVelY(float velY);
-
-	// Establece el valor de la variable
-	void setSpeed(float speed);
-
-	// Obtiene del valor de la variable
-	int getKind();
-
-	// Obtiene del valor de la variable
-	Uint8 getSize();
-
-	// Obtiene la clase a la que pertenece el globo
-	Uint8 getClass();
-
-	// Establece el valor de la variable
-	void setStop(bool value);
-
-	// Obtiene del valor de la variable
-	bool isStopped();
-
-	// Establece el valor de la variable
-	void setBlink(bool value);
-
-	// Obtiene del valor de la variable
-	bool isBlinking();
-
-	// Establece el valor de la variable
-	void setVisible(bool value);
-
-	// Obtiene del valor de la variable
-	bool isVisible();
-
-	// Establece el valor de la variable
-	void setInvulnerable(bool value);
-
-	// Obtiene del valor de la variable
-	bool isInvulnerable();
-
-	// Obtiene del valor de la variable
-	bool isBeingCreated();
-
-	// Establece el valor de la variable
-	void setStoppedTimer(Uint16 time);
-
-	// Obtiene del valor de la variable
-	Uint16 getStoppedTimer();
-
-	// Obtiene del valor de la variable
-	Uint16 getScore();
-
-	// Obtiene el circulo de colisión
-	circle_t &getCollider();
-
-	// Obtiene le valor de la variable
-	Uint8 getMenace();
-
-	// Obtiene le valor de la variable
-	Uint8 getPower();
-
-	// Indica si el globo se puede explotar
-	bool canBePopped();
-
-	// Indica si el globo se puede destruir
-	bool canBeDestroyed();
+	// Setters
+	void setVelY(float vel_y) { vy_ = vel_y; }
+	void setSpeed(float speed) { speed_ = speed; }
+	void setInvulnerable(bool value) { invulnerable_ = value; }
 };

source/balloon_formations.cpp

@@ -0,0 +1,456 @@
+#include "balloon_formations.h"
+#include "balloon.h" // para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
+#include "param.h"	 // para param
+#include "utils.h"	 // para ParamGame, Param, Zone, BLOCK
+
+void BalloonFormations::initBalloonFormations()
+{
+	constexpr int y4 = -BLOCK;
+	const int x4_0 = param.game.play_area.rect.x;
+	const int x4_100 = param.game.play_area.rect.w - BALLOON_SIZE[3];
+
+	constexpr int y3 = -BLOCK;
+	const int x3_0 = param.game.play_area.rect.x;
+	const int x3_100 = param.game.play_area.rect.w - BALLOON_SIZE[2];
+
+	constexpr int y2 = -BLOCK;
+	const int x2_0 = param.game.play_area.rect.x;
+	const int x2_100 = param.game.play_area.rect.w - BALLOON_SIZE[1];
+
+	constexpr int y1 = -BLOCK;
+	const int x1_0 = param.game.play_area.rect.x;
+	const int x1_50 = param.game.play_area.center_x - (BALLOON_SIZE[0] / 2);
+	const int x1_100 = param.game.play_area.rect.w - BALLOON_SIZE[0];
+
+	balloon_formation_.reserve(NUMBER_OF_BALLOON_FORMATIONS);
+
+	constexpr int CREATION_TIME = 300;
+
+	// #00 - Dos enemigos BALLOON4 uno a cada extremo
+	{
+		std::vector<BalloonFormationParams> init_params = {
+			BalloonFormationParams(x4_0, y4, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME),
+			BalloonFormationParams(x4_100, y4, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME)};
+		balloon_formation_.emplace_back(2, init_params);
+	}
+
+	// #01 - Dos enemigos BALLOON4 uno a cada cuarto. Ambos van hacia el centro
+	{
+		std::vector<BalloonFormationParams> init_params = {
+			BalloonFormationParams(param.game.play_area.first_quarter_x - (BALLOON_SIZE[3] / 2), y4, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME),
+			BalloonFormationParams(param.game.play_area.third_quarter_x - (BALLOON_SIZE[3] / 2), y4, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME)};
+		balloon_formation_.emplace_back(2, init_params);
+	}
+
+	// #02 - Cuatro enemigos BALLOON2 uno detrás del otro. A la izquierda y hacia el centro
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 4; ++i)
+		{
+			init_params.emplace_back(x2_0 + (i * (BALLOON_SIZE[1] + 1)), y2, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE2, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(4, init_params);
+	}
+
+	// #03 - Cuatro enemigos BALLOON2 uno detrás del otro. A la derecha y hacia el centro
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 4; ++i)
+		{
+			init_params.emplace_back(x2_100 - (i * (BALLOON_SIZE[1] + 1)), y2, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE2, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(4, init_params);
+	}
+
+	// #04 - Tres enemigos BALLOON3. 0, 25, 50. Hacia la derecha
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 3; ++i)
+		{
+			init_params.emplace_back(x3_0 + (i * (BALLOON_SIZE[2] * 2)), y3, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(3, init_params);
+	}
+
+	// #05 - Tres enemigos BALLOON3. 50, 75, 100. Hacia la izquierda
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 3; ++i)
+		{
+			init_params.emplace_back(x3_100 - (i * (BALLOON_SIZE[2] * 2)), y3, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(3, init_params);
+	}
+
+	// #06 - Tres enemigos BALLOON3. 0, 0, 0. Hacia la derecha
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 3; ++i)
+		{
+			init_params.emplace_back(x3_0 + (i * (BALLOON_SIZE[2] + 1)), y3, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(3, init_params);
+	}
+
+	// #07 - Tres enemigos BALLOON3. 100, 100, 100. Hacia la izquierda
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 3; ++i)
+		{
+			init_params.emplace_back(x3_100 - (i * (BALLOON_SIZE[2] + 1)), y3, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(3, init_params);
+	}
+
+	// #08 - Seis enemigos BALLOON1. 0, 0, 0, 0, 0, 0. Hacia la derecha
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 6; ++i)
+		{
+			init_params.emplace_back(x1_0 + (i * (BALLOON_SIZE[0] + 1)), y1, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(6, init_params);
+	}
+
+	// #09 - Seis enemigos BALLOON1. 100, 100, 100, 100, 100, 100. Hacia la izquierda
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 6; ++i)
+		{
+			init_params.emplace_back(x1_100 - (i * (BALLOON_SIZE[0] + 1)), y1, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(6, init_params);
+	}
+
+	// #10 - Tres enemigos BALLOON4 seguidos desde la izquierda. Hacia la derecha
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 3; ++i)
+		{
+			init_params.emplace_back(x4_0 + (i * (BALLOON_SIZE[3] + 1)), y4, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME - (15 * i));
+		}
+		balloon_formation_.emplace_back(3, init_params);
+	}
+
+	// #11 - Tres enemigos BALLOON4 seguidos desde la derecha. Hacia la izquierda
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 3; ++i)
+		{
+			init_params.emplace_back(x4_100 - (i * (BALLOON_SIZE[3] + 1)), y4, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME - (15 * i));
+		}
+		balloon_formation_.emplace_back(3, init_params);
+	}
+
+	// #12 - Seis enemigos BALLOON2 uno detrás del otro. A la izquierda y hacia el centro
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 6; ++i)
+		{
+			init_params.emplace_back(x2_0 + (i * (BALLOON_SIZE[1] + 1)), y2, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE2, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(6, init_params);
+	}
+
+	// #13 - Seis enemigos BALLOON2 uno detrás del otro. A la derecha y hacia el centro
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 6; ++i)
+		{
+			init_params.emplace_back(x2_100 - (i * (BALLOON_SIZE[1] + 1)), y2, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE2, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(6, init_params);
+	}
+
+	// #14 - Cinco enemigos BALLOON3. Hacia la derecha. Separados
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 5; ++i)
+		{
+			init_params.emplace_back(x3_0 + (i * (BALLOON_SIZE[2] * 2)), y3, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(5, init_params);
+	}
+
+	// #15 - Cinco enemigos BALLOON3. Hacia la izquierda. Separados
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 5; ++i)
+		{
+			init_params.emplace_back(x3_100 - (i * (BALLOON_SIZE[2] * 2)), y3, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(5, init_params);
+	}
+
+	// #16 - Cinco enemigos BALLOON3. Hacia la derecha. Juntos
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 5; ++i)
+		{
+			init_params.emplace_back(x3_0 + (i * (BALLOON_SIZE[2] + 1)), y3, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(5, init_params);
+	}
+
+	// #17 - Cinco enemigos BALLOON3. Hacia la izquierda. Juntos
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 5; ++i)
+		{
+			init_params.emplace_back(x3_100 - (i * (BALLOON_SIZE[2] + 1)), y3, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(5, init_params);
+	}
+
+	// #18 - Doce enemigos BALLOON1. Hacia la derecha. Juntos
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 12; ++i)
+		{
+			init_params.emplace_back(x1_0 + (i * (BALLOON_SIZE[0] + 1)), y1, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(12, init_params);
+	}
+
+	// #19 - Doce enemigos BALLOON1. Hacia la izquierda. Juntos
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < 12; ++i)
+		{
+			init_params.emplace_back(x1_100 - (i * (BALLOON_SIZE[0] + 1)), y1, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME - (10 * i));
+		}
+		balloon_formation_.emplace_back(12, init_params);
+	}
+
+	// #20 - Dos enemigos BALLOON4 seguidos desde la izquierda/derecha. Simétricos
+	{
+		std::vector<BalloonFormationParams> init_params;
+		const int half = 4 / 2;
+		for (int i = 0; i < 4; ++i)
+		{
+			if (i < half)
+			{
+				init_params.emplace_back(x4_0 + (i * (BALLOON_SIZE[3] + 1)), y4, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME + (0 * i));
+			}
+			else
+			{
+				init_params.emplace_back(x4_100 - ((i - half) * (BALLOON_SIZE[3] + 1)), y4, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME + (0 * i));
+			}
+		}
+		balloon_formation_.emplace_back(4, init_params);
+	}
+
+	// #20 - Dos enemigos BALLOON4 seguidos desde la izquierda/derecha. Simétricos
+	{
+		std::vector<BalloonFormationParams> init_params;
+		const int half = 4 / 2;
+		for (int i = 0; i < 4; ++i)
+		{
+			if (i < half)
+			{
+				init_params.emplace_back(x4_0 + (i * (BALLOON_SIZE[3] + 1)), y4, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME + (0 * i));
+			}
+			else
+			{
+				init_params.emplace_back(x4_100 - ((i - half) * (BALLOON_SIZE[3] + 1)), y4, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME + (0 * i));
+			}
+		}
+		balloon_formation_.emplace_back(4, init_params);
+	}
+
+	// #21 - Diez enemigos BALLOON2 uno detrás del otro. Izquierda/derecha. Simétricos
+	{
+		std::vector<BalloonFormationParams> init_params;
+		const int half = 10 / 2;
+		for (int i = 0; i < 10; ++i)
+		{
+			if (i < half)
+			{
+				init_params.emplace_back(x2_0 + (i * (BALLOON_SIZE[1] + 1)), y2, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE2, CREATION_TIME - (3 * i));
+			}
+			else
+			{
+				init_params.emplace_back(x2_100 - ((i - half) * (BALLOON_SIZE[1] + 1)), y2, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE2, CREATION_TIME - (3 * (i - half)));
+			}
+		}
+		balloon_formation_.emplace_back(10, init_params);
+	}
+
+	// #22 - Diez enemigos BALLOON3. Hacia la derecha/izquierda. Separados. Simétricos
+	{
+		std::vector<BalloonFormationParams> init_params;
+		const int half = 10 / 2;
+		for (int i = 0; i < 10; ++i)
+		{
+			if (i < half)
+			{
+				init_params.emplace_back(x3_0 + (i * (BALLOON_SIZE[2] * 2)), y3, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
+			}
+			else
+			{
+				init_params.emplace_back(x3_100 - ((i - half) * (BALLOON_SIZE[2] * 2)), y3, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * (i - half)));
+			}
+		}
+		balloon_formation_.emplace_back(10, init_params);
+	}
+
+	// #23 - Diez enemigos BALLOON3. Hacia la derecha. Juntos. Simétricos
+	{
+		std::vector<BalloonFormationParams> init_params;
+		const int half = 10 / 2;
+		for (int i = 0; i < 10; ++i)
+		{
+			if (i < half)
+			{
+				init_params.emplace_back(x3_0 + (i * (BALLOON_SIZE[2] + 1)), y3, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
+			}
+			else
+			{
+				init_params.emplace_back(x3_100 - ((i - half) * (BALLOON_SIZE[2] + 1)), y3, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * (i - half)));
+			}
+		}
+		balloon_formation_.emplace_back(10, init_params);
+	}
+
+	// #24 - Treinta enemigos BALLOON1. Del centro hacia los extremos. Juntos. Simétricos
+	{
+		std::vector<BalloonFormationParams> init_params;
+		const int half = 30 / 2;
+		for (int i = 0; i < 30; ++i)
+		{
+			if (i < half)
+			{
+				init_params.emplace_back(x1_50, y1, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME + (5 * i));
+			}
+			else
+			{
+				init_params.emplace_back(x1_50, y1, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME + (5 * (i - half)));
+			}
+		}
+		balloon_formation_.emplace_back(30, init_params);
+	}
+
+	// #25 - Treinta enemigos BALLOON1. Del centro hacia adentro. Juntos. Simétricos
+	{
+		std::vector<BalloonFormationParams> init_params;
+		const int half = 30 / 2;
+		for (int i = 0; i < 30; ++i)
+		{
+			if (i < half)
+			{
+				init_params.emplace_back(x1_50 + 20, y1, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME - (5 * i));
+			}
+			else
+			{
+				init_params.emplace_back(x1_50 - 20, y1, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME - (5 * (i - half)));
+			}
+		}
+		balloon_formation_.emplace_back(30, init_params);
+	}
+
+	// Reservar espacio para el vector
+	balloon_formation_.resize(100);
+
+	// Crea las mismas formaciones pero con hexágonos a partir de la posición 50 del vector
+	for (int k = 0; k < 50; k++)
+	{
+		std::vector<BalloonFormationParams> init_params;
+		for (int i = 0; i < balloon_formation_.at(k).number_of_balloons; i++)
+		{
+			init_params.emplace_back(
+				balloon_formation_.at(k).init.at(i).x,
+				balloon_formation_.at(k).init.at(i).y,
+				balloon_formation_.at(k).init.at(i).vel_x,
+				BalloonType::FLOATER,
+				balloon_formation_.at(k).init.at(i).size,
+				balloon_formation_.at(k).init.at(i).creation_counter);
+		}
+		balloon_formation_.at(k + 50) = BalloonFormationUnit(balloon_formation_.at(k).number_of_balloons, init_params);
+	}
+
+	// TEST
+	std::vector<BalloonFormationParams> test_params = {
+		{10, y1, 0, BalloonType::FLOATER, BalloonSize::SIZE1, 200},
+		{50, y1, 0, BalloonType::FLOATER, BalloonSize::SIZE2, 200},
+		{90, y1, 0, BalloonType::FLOATER, BalloonSize::SIZE3, 200},
+		{140, y1, 0, BalloonType::FLOATER, BalloonSize::SIZE4, 200}};
+
+	balloon_formation_.at(99) = BalloonFormationUnit(4, test_params);
+}
+
+// Inicializa los conjuntos de formaciones
+void BalloonFormations::initBalloonFormationPools()
+{
+	// Reserva espacio para cada pool de formaciones
+	balloon_formation_pool_.resize(NUMBER_OF_SETS_PER_POOL);
+
+	// Set #0
+	balloon_formation_pool_.at(0) = {
+		&balloon_formation_.at(0), &balloon_formation_.at(1), &balloon_formation_.at(2),
+		&balloon_formation_.at(3), &balloon_formation_.at(4), &balloon_formation_.at(5),
+		&balloon_formation_.at(6), &balloon_formation_.at(7), &balloon_formation_.at(8),
+		&balloon_formation_.at(9)};
+
+	// Set #1
+	balloon_formation_pool_.at(1) = {
+		&balloon_formation_.at(10), &balloon_formation_.at(11), &balloon_formation_.at(12),
+		&balloon_formation_.at(13), &balloon_formation_.at(14), &balloon_formation_.at(15),
+		&balloon_formation_.at(16), &balloon_formation_.at(17), &balloon_formation_.at(18),
+		&balloon_formation_.at(19)};
+
+	// Set #2
+	balloon_formation_pool_.at(2) = {
+		&balloon_formation_.at(0), &balloon_formation_.at(1), &balloon_formation_.at(2),
+		&balloon_formation_.at(3), &balloon_formation_.at(4), &balloon_formation_.at(55),
+		&balloon_formation_.at(56), &balloon_formation_.at(57), &balloon_formation_.at(58),
+		&balloon_formation_.at(59)};
+
+	// Set #3
+	balloon_formation_pool_.at(3) = {
+		&balloon_formation_.at(50), &balloon_formation_.at(51), &balloon_formation_.at(52),
+		&balloon_formation_.at(53), &balloon_formation_.at(54), &balloon_formation_.at(5),
+		&balloon_formation_.at(6), &balloon_formation_.at(7), &balloon_formation_.at(8),
+		&balloon_formation_.at(9)};
+
+	// Set #4
+	balloon_formation_pool_.at(4) = {
+		&balloon_formation_.at(60), &balloon_formation_.at(61), &balloon_formation_.at(62),
+		&balloon_formation_.at(63), &balloon_formation_.at(64), &balloon_formation_.at(65),
+		&balloon_formation_.at(66), &balloon_formation_.at(67), &balloon_formation_.at(68),
+		&balloon_formation_.at(69)};
+
+	// Set #5
+	balloon_formation_pool_.at(5) = {
+		&balloon_formation_.at(10), &balloon_formation_.at(61), &balloon_formation_.at(12),
+		&balloon_formation_.at(63), &balloon_formation_.at(14), &balloon_formation_.at(65),
+		&balloon_formation_.at(16), &balloon_formation_.at(67), &balloon_formation_.at(18),
+		&balloon_formation_.at(69)};
+
+	// Set #6
+	balloon_formation_pool_.at(6) = {
+		&balloon_formation_.at(60), &balloon_formation_.at(11), &balloon_formation_.at(62),
+		&balloon_formation_.at(13), &balloon_formation_.at(64), &balloon_formation_.at(15),
+		&balloon_formation_.at(66), &balloon_formation_.at(17), &balloon_formation_.at(68),
+		&balloon_formation_.at(19)};
+
+	// Set #7
+	balloon_formation_pool_.at(7) = {
+		&balloon_formation_.at(20), &balloon_formation_.at(21), &balloon_formation_.at(22),
+		&balloon_formation_.at(23), &balloon_formation_.at(24), &balloon_formation_.at(65),
+		&balloon_formation_.at(66), &balloon_formation_.at(67), &balloon_formation_.at(68),
+		&balloon_formation_.at(69)};
+
+	// Set #8
+	balloon_formation_pool_.at(8) = {
+		&balloon_formation_.at(70), &balloon_formation_.at(71), &balloon_formation_.at(72),
+		&balloon_formation_.at(73), &balloon_formation_.at(74), &balloon_formation_.at(15),
+		&balloon_formation_.at(16), &balloon_formation_.at(17), &balloon_formation_.at(18),
+		&balloon_formation_.at(19)};
+
+	// Set #9
+	balloon_formation_pool_.at(9) = {
+		&balloon_formation_.at(20), &balloon_formation_.at(21), &balloon_formation_.at(22),
+		&balloon_formation_.at(23), &balloon_formation_.at(24), &balloon_formation_.at(70),
+		&balloon_formation_.at(71), &balloon_formation_.at(72), &balloon_formation_.at(73),
+		&balloon_formation_.at(74)};
+}

source/balloon_formations.h

@@ -0,0 +1,70 @@
+#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;
+
+struct BalloonFormationParams
+{
+    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 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
+{
+    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() {}
+};
+
+
+using BalloonFormationPool = std::vector<const BalloonFormationUnit *>;
+
+class BalloonFormations
+{
+private:
+    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();
+
+    // Inicializa los conjuntos de formaciones
+    void initBalloonFormationPools();
+
+public:
+    // Constructor
+    BalloonFormations()
+    {
+        initBalloonFormations();
+        initBalloonFormationPools();
+    }
+
+    // Destructor
+    ~BalloonFormations() = default;
+
+    // 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); }
+};

source/balloon_manager.cpp

@@ -0,0 +1,356 @@
+#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 numEnemies = set.number_of_balloons;
+            for (int i = 0; i < numEnemies; ++i)
+            {
+                auto p = set.init[i];
+                createBalloon(p.x, p.y, p.type, p.size, p.vel_x, balloon_speed_, p.creation_counter);
+            }
+
+            balloon_deploy_counter_ = 300;
+        }
+    }
+}
+
+// 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)
+{
+    const int index = static_cast<int>(size);
+    balloons_.emplace_back(std::make_shared<Balloon>(x, y, type, size, velx, speed, creation_timer, balloon_textures_.at(index), balloon_animations_.at(index)));
+    return balloons_.back();
+}
+
+// Crea un globo a partir de otro globo
+void BalloonManager::createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction)
+{
+    const float vx = direction == "LEFT" ? BALLOON_VELX_NEGATIVE : BALLOON_VELX_POSITIVE;
+    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()
+{
+    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, balloon_textures_[4], balloon_animations_[4]));
+
+    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->pop();
+    }
+
+    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->pop();
+
+    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, 100);
+    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()
+{
+    const auto set = balloon_formations_->getSet(0, 1);
+    const auto numEnemies = set.number_of_balloons;
+    for (int i = 0; i < numEnemies; ++i)
+    {
+        auto p = set.init[i];
+        createBalloon(p.x, p.y, p.type, p.size, p.vel_x, balloon_speed_, p.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); });
+}

source/balloon_manager.h

@@ -0,0 +1,113 @@
+#pragma once
+
+#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
+class Texture;
+
+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;
+
+    // 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
+    void deployBalloonFormation(int stage);
+
+    // 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();
+
+    // Obtiene el nivel de ameza actual generado por los globos
+    int getMenace();
+
+    // Getters
+    float getBalloonSpeed() const { return balloon_speed_; }
+    Balloons &getBalloons() { return balloons_; }
+
+    // Setters
+    void setDefaultBalloonSpeed(float speed) { default_balloon_speed_ = speed; }
+    void resetBalloonSpeed() { setBalloonSpeed(default_balloon_speed_); }
+};

source/bullet.cpp

@@ -1,57 +1,54 @@
 #include "bullet.h"
-#include "param.h"  // for param
-#include "sprite.h" // for Sprite
-#include <memory>   // for std::unique_ptr
-
-// Constantes evaluables en tiempo de compilación
-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 poweredUp, int owner, SDL_Rect *playArea, Texture *texture)
-    : posX(x), posY(y), width(BULLET_WIDTH), height(BULLET_HEIGHT), velX(0), velY(BULLET_VELY),
-      kind(kind), owner(owner), playArea(playArea),
-      sprite(std::unique_ptr<Sprite>(new Sprite(SDL_Rect{x, y, BULLET_WIDTH, BULLET_HEIGHT}, texture))) // Crear manualmente el std::unique_ptr
+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),
+      bullet_type_(bullet_type),
+      owner_(owner)
 {
-    velX = (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 spriteOffset = poweredUp ? 3 : 0;
-    auto kindIndex = static_cast<int>(kind);
-    sprite->setSpriteClip((kindIndex + spriteOffset) * 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();
 }
 
-// Implementación de render (llama al render del sprite)
+// Implementación de render (llama al render del sprite_)
 void Bullet::render()
 {
-    sprite->render();
+    sprite_->render();
 }
 
 // Implementación del movimiento usando BulletMoveStatus
 BulletMoveStatus Bullet::move()
 {
-    posX += velX;
-    if (posX < param.game.playArea.rect.x - width || posX > playArea->w)
+    pos_x_ += vel_x_;
+    if (pos_x_ < param.game.play_area.rect.x - BULLET_WIDTH_ || pos_x_ > param.game.play_area.rect.w)
     {
         disable();
         return BulletMoveStatus::OUT;
     }
 
-    posY += velY;
-    if (posY < param.game.playArea.rect.y - height)
+    pos_y_ += BULLET_VEL_Y_;
+    if (pos_y_ < param.game.play_area.rect.y - BULLET_HEIGHT_)
     {
         disable();
         return BulletMoveStatus::OUT;
     }
 
-    sprite->setPosX(posX);
-    sprite->setPosY(posY);
+    shiftSprite();
     shiftColliders();
 
     return BulletMoveStatus::OK;
@@ -59,56 +56,32 @@ BulletMoveStatus Bullet::move()
 
 bool Bullet::isEnabled() const
 {
-    return kind != BulletType::NULL_TYPE;
+    return bullet_type_ != BulletType::NONE;
 }
 
 void Bullet::disable()
 {
-    kind = BulletType::NULL_TYPE;
-}
-
-int Bullet::getPosX() const
-{
-    return posX;
-}
-
-int Bullet::getPosY() const
-{
-    return posY;
-}
-
-void Bullet::setPosX(int x)
-{
-    posX = x;
-}
-
-void Bullet::setPosY(int y)
-{
-    posY = y;
-}
-
-int Bullet::getVelY() const
-{
-    return velY;
-}
-
-BulletType Bullet::getKind() const
-{
-    return kind;
+    bullet_type_ = BulletType::NONE;
 }
 
 int Bullet::getOwner() const
 {
-    return owner;
+    return owner_;
 }
 
-circle_t &Bullet::getCollider()
+Circle &Bullet::getCollider()
 {
-    return collider;
+    return collider_;
 }
 
 void Bullet::shiftColliders()
 {
-    collider.x = posX + collider.r;
-    collider.y = posY + collider.r;
+    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,22 +1,21 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>	 // for SDL_Rect
-#include <SDL2/SDL_stdinc.h> // for Uint8
-#include <memory>			 // for unique_ptr
-#include "sprite.h"			 // for Sprite
-#include "utils.h"			 // for circle_t
-class Texture;				 // lines 9-9
+#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,
 	RIGHT,
-	NULL_TYPE
+	NONE
 };
 
-// Enumeración para los resultados del movimiento de la bala
+// Resultado del movimiento de la bala
 enum class BulletMoveStatus : Uint8
 {
 	OK = 0,
@@ -27,36 +26,46 @@ enum class BulletMoveStatus : Uint8
 class Bullet
 {
 private:
-	int posX;						// Posición en el eje X
-	int posY;						// Posición en el eje Y
-	Uint8 width;					// Ancho del objeto
-	Uint8 height;					// Alto del objeto
-	int velX;						// Velocidad en el eje X
-	int velY;						// Velocidad en el eje Y
-	BulletType kind;				// Tipo de objeto
-	int owner;						// Identificador del dueño del objeto
-	circle_t collider;				// Círculo de colisión del objeto
-	SDL_Rect *playArea;				// Rectángulo con la zona de juego
-	std::unique_ptr<Sprite> sprite; // Sprite con los gráficos y métodos de pintado
+	// 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
+	int vel_x_; // Velocidad en el eje X
+
+	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:
-	Bullet(int x, int y, BulletType kind, bool poweredUp, int owner, SDL_Rect *playArea, Texture *texture);
+	// Constructor
+	Bullet(int x, int y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture);
+
+	// Destructor
 	~Bullet() = default;
 
-	void render();			 // Pinta el objeto en pantalla
-	BulletMoveStatus move(); // Actualiza la posición y estado del objeto
+	// Pinta el objeto en pantalla
+	void render();
 
-	bool isEnabled() const; // Comprueba si el objeto está habilitado
-	void disable();			// Deshabilita el objeto
+	// Actualiza la posición y estado del objeto
+	BulletMoveStatus move();
 
-	int getPosX() const;
-	int getPosY() const;
-	void setPosX(int x);
-	void setPosY(int y);
-	int getVelY() const;
-	BulletType getKind() const;
+	// Comprueba si el objeto está habilitado
+	bool isEnabled() const;
+
+	// Deshabilita el objeto
+	void disable();
+
+	// Obtiene parámetros
 	int getOwner() const;
-	circle_t &getCollider();
+	Circle &getCollider();
 };

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,128 +1,91 @@
 #include "define_buttons.h"
-#include "lang.h"     // for getText
-#include "options.h"  // for options
-#include "param.h"    // for param
-#include "section.h"  // for name, name_e, options, options_e
-#include "text.h"     // for Text
-#include "utils.h"    // for op_controller_t, options_t, param_t, paramGame_t
+#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(Text *text)
+DefineButtons::DefineButtons()
+    : input_(Input::get()),
+      text_(Resource::get()->getText("8bithud"))
 {
-    // Copia punteros a los objetos
-    input = Input::get();
-    this->text = text;
-
     // Inicializa variables
-    enabled = false;
-    x = param.game.width / 2;
-    y = param.title.pressStartPosition;
-    indexController = 0;
-    indexButton = 0;
+    x_ = param.game.width / 2;
+    y_ = param.title.press_start_position;
 
-    buttons.clear();
-    db_button_t button;
+    clearButtons();
 
-    button.label = lang::getText(95);
-    button.input = input_fire_left;
-    button.button = SDL_CONTROLLER_BUTTON_X;
-    buttons.push_back(button);
-
-    button.label = lang::getText(96);
-    button.input = input_fire_center;
-    button.button = SDL_CONTROLLER_BUTTON_Y;
-    buttons.push_back(button);
-
-    button.label = lang::getText(97);
-    button.input = input_fire_right;
-    button.button = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
-    buttons.push_back(button);
-
-    button.label = lang::getText(98);
-    button.input = input_start;
-    button.button = SDL_CONTROLLER_BUTTON_START;
-    buttons.push_back(button);
-
-    button.label = lang::getText(99);
-    button.input = input_exit;
-    button.button = SDL_CONTROLLER_BUTTON_BACK;
-    buttons.push_back(button);
-
-    for (int i = 0; i < input->getNumControllers(); ++i)
-    {
-        controllerNames.push_back(input->getControllerName(i));
-    }
-}
-
-// Destructor
-DefineButtons::~DefineButtons()
-{
-}
-
-// Actualiza las variables del objeto
-void DefineButtons::update()
-{
-    if (enabled)
+    for (int i = 0; i < input_->getNumControllers(); ++i)
     {
+        controller_names_.emplace_back(input_->getControllerName(i));
     }
 }
 
 // Dibuja el objeto en pantalla
 void DefineButtons::render()
 {
-    if (enabled)
+    if (enabled_)
     {
-        text->writeCentered(x, y - 10, lang::getText(100) + std::to_string(options.controller[indexController].playerId));
-        text->writeCentered(x, y, controllerNames[indexController]);
-        text->writeCentered(x, y + 10, buttons[indexButton].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 != indexController)
+    // Solo pilla botones del mando que toca
+    if (input_->getJoyIndex(event.which) != static_cast<int>(index_controller_))
     {
         return;
     }
 
-    buttons[indexButton].button = (SDL_GameControllerButton)event->button;
-    incIndexButton();
-}
-
-// Asigna los botones definidos al input
-void DefineButtons::bindButtons()
-{
-    for (int i = 0; i < (int)buttons.size(); ++i)
+    const auto button = static_cast<SDL_GameControllerButton>(event.button);
+    if (checkButtonNotInUse(button))
     {
-        input->bindGameControllerButton(indexController, buttons[i].input, buttons[i].button);
+        buttons_.at(index_button_).button = button;
+        incIndexButton();
     }
 }
 
-// Comprueba las entradas
-void DefineButtons::checkInput()
+// Asigna los botones definidos al input_
+void DefineButtons::bindButtons()
 {
-    if (enabled)
+    for (const auto &button : buttons_)
+    {
+        input_->bindGameControllerButton(index_controller_, button.input, button.button);
+    }
+}
+
+// Comprueba los eventos
+void DefineButtons::checkEvents()
+{
+    if (enabled_)
     {
         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)
+            switch (event.type)
             {
-                section::name = section::NAME_QUIT;
-                section::options = section::OPTIONS_QUIT_NORMAL;
+            case SDL_QUIT:
+            {
+                section::name = section::Name::QUIT;
+                section::options = section::Options::QUIT_WITH_KEYBOARD;
                 break;
             }
-
-            if (event.type == SDL_CONTROLLERBUTTONDOWN)
+            case SDL_CONTROLLERBUTTONDOWN:
             {
-                doControllerButtonDown(&event.cbutton);
+                doControllerButtonDown(event.cbutton);
+                break;
+            }
+            default:
+                break;
             }
         }
     }
@@ -131,11 +94,12 @@ void DefineButtons::checkInput()
 // Habilita el objeto
 bool DefineButtons::enable(int index)
 {
-    if (index < input->getNumControllers())
+    if (index < input_->getNumControllers())
     {
-        enabled = true;
-        indexController = index;
-        indexButton = 0;
+        enabled_ = true;
+        index_controller_ = index;
+        index_button_ = 0;
+        clearButtons();
         return true;
     }
 
@@ -143,31 +107,24 @@ 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()
 {
-    indexButton++;
+    ++index_button_;
 
     // Comprueba si ha finalizado
-    if (indexButton == (int)buttons.size())
+    if (index_button_ == buttons_.size())
     {
-        // Asigna los botones definidos al input
+        // Asigna los botones definidos al input_
         bindButtons();
 
         // Guarda los cambios en las opciones
         saveBindingsToOptions();
 
-        input->allActive(indexController);
-
-        // Reinicia variables
-        indexButton = 0;
-        indexController = 0;
-        enabled = false;
+        // Deshabilita
+        enabled_ = false;
     }
 }
 
@@ -175,17 +132,34 @@ void DefineButtons::incIndexButton()
 void DefineButtons::saveBindingsToOptions()
 {
     // Modifica las opciones para colocar los valores asignados
-    options.controller[indexController].name = input->getControllerName(indexController);
-    for (int j = 0; j < (int)options.controller[indexController].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[indexController].buttons[j] = input->getControllerBinding(indexController, options.controller[indexController].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].playerId;
-    options.controller[0].playerId = options.controller[1].playerId;
-    options.controller[1].playerId = 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,17 +1,24 @@
 #pragma once
 
-#include <SDL2/SDL_events.h>          // for SDL_ControllerButtonEvent
-#include <SDL2/SDL_gamecontroller.h>  // for SDL_GameControllerButton
-#include <string>                     // for string, basic_string
-#include <vector>                     // for vector
-#include "input.h"                    // for inputs_e
-class Text;
+#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 db_button_t
+struct DefineButtonsButton
 {
     std::string label;               // Texto en pantalla para el botón
-    inputs_e input;                  // Input asociado
+    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
@@ -19,23 +26,23 @@ class DefineButtons
 {
 private:
     // Objetos
-    Input *input; // Objeto pata gestionar la entrada
-    Text *text;   // Objeto para escribir texto
+    Input *input_;               // Objeto pata gestionar la entrada
+    std::shared_ptr<Text> text_; // Objeto para escribir texto
 
     // Variables
-    bool enabled;                             // Indica si el objeto está habilitado
-    int x;                                    // Posición donde dibujar el texto
-    int y;                                    // Posición donde dibujar el texto
-    std::vector<db_button_t> buttons;         // Vector con las nuevas definiciones de botones/acciones
-    int indexController;                      // Indice del controlador a reasignar
-    int indexButton;                          // Indice para saber qué bot´çon se está definiendo
-    std::vector<std::string> controllerNames; // Nombres de los mandos
+    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
+    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();
@@ -43,28 +50,28 @@ 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
-    DefineButtons(Text *text);
+    DefineButtons();
 
     // Destructor
-    ~DefineButtons();
-
-    // Actualiza las variables del objeto
-    void update();
+    ~DefineButtons() = default;
 
     // 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.h

@@ -1,47 +1,29 @@
 #pragma once
 
-#include <SDL2/SDL_render.h>  // for SDL_Renderer
-#include <SDL2/SDL_video.h>   // for SDL_Window
-#include <string>             // for string, basic_string
-#include <vector>             // for vector
-#include "lang.h"             // for lang_e
-#include "utils.h"            // for music_file_t, sound_file_t
-class Asset;
-class Game;
-class HiScoreTable;
-class Input;
-class Instructions;
-class Intro;
-class Logo;
-class Screen;
-class Title;
+#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;
+} // lines 9-9
 
 // Textos
-#define WINDOW_CAPTION "Coffee Crisis Arcade Edition"
+constexpr char WINDOW_CAPTION[] = "Coffee Crisis Arcade Edition";
 
 class Director
 {
 private:
 	// Objetos y punteros
-	SDL_Window *window;			// La ventana donde dibujamos
-	SDL_Renderer *renderer;		// El renderizador de la ventana
-	Screen *screen;				// Objeto encargado de dibujar en pantalla
-	Logo *logo;					// Objeto para la sección del logo
-	Intro *intro;				// Objeto para la sección de la intro
-	Title *title;				// Objeto para la sección del titulo y el menu de opciones
-	Game *game;					// Objeto para la sección del juego
-	Instructions *instructions; // Objeto para la sección de las instrucciones
-	HiScoreTable *hiScoreTable; // Objeto para mostrar las mejores puntuaciones online
-	Game *demoGame;				// Objeto para lanzar la demo del juego
-	Input *input;				// Objeto Input para gestionar las entradas
-	Asset *asset;				// Objeto que gestiona todos los ficheros de recursos
+	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 executablePath;		  // Path del ejecutable
-	std::string systemFolder;		  // Carpeta del sistema donde guardar datos
-	std::string paramFileArgument;	  // Argumento para gestionar el fichero con los parametros del programa
-	std::vector<sound_file_t> sounds; // Vector con los sonidos
-	std::vector<music_file_t> musics; // Vector con las musicas
+	std::string executable_path_; // Path del ejecutable
+	std::string system_folder_;	  // Carpeta del sistema donde guardar datos
 
 	// Inicializa jail_audio
 	void initJailAudio();
@@ -49,32 +31,17 @@ private:
 	// Arranca SDL y crea la ventana
 	bool initSDL();
 
-	// Inicializa el objeto input
-	void initInput();
-
-	// Carga los parametros para configurar el juego
-	void loadParams(std::string filepath);
+	// Asigna los botones y teclas al objeto Input
+	void bindInputs();
 
 	// Crea el indice de ficheros
-	bool setFileList();
-
-	// Carga los sonidos del juego
-	void loadSounds();
-
-	// Carga las musicas del juego
-	void loadMusics();
-
-	// Libera la memoria usada por los sonidos del juego
-	void deleteSounds();
-
-	// Libera la memoria usada por las músicas del juego
-	void deleteMusics();
+	void setFileList();
 
 	// Comprueba los parametros del programa
-	void checkProgramArguments(int argc, char *argv[]);
+	void checkProgramArguments(int argc, const char *argv[]);
 
 	// Crea la carpeta del sistema donde guardar datos
-	void createSystemFolder(std::string folder);
+	void createSystemFolder(const std::string &folder);
 
 	// Ejecuta la sección con el logo
 	void runLogo();
@@ -97,12 +64,16 @@ private:
 	// Ejecuta el juego en modo demo
 	void runDemoGame();
 
-	// Obtiene una fichero a partir de un lang_e
-	std::string getLangFile(lang::lang_e lang);
+	// Obtiene una fichero a partir de un lang::Code
+	std::string getLangFile(lang::Code code);
+#ifdef ARCADE
+	// Apaga el sistema
+	void shutdownSystem();
+#endif
 
 public:
 	// Constructor
-	Director(int argc, char *argv[]);
+	Director(int argc, const char *argv[]);
 
 	// Destructor
 	~Director();

source/enemy_formations.cpp

@@ -1,725 +0,0 @@
-#include "enemy_formations.h"
-#include "balloon.h"  // for BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
-#include "param.h"    // for param
-#include "utils.h"    // for paramGame_t, param_t, zone_t, BLOCK
-
-// Constructor
-EnemyFormations::EnemyFormations()
-{
-	initEnemyFormations();
-	initEnemyPools();
-	initGameStages();
-}
-
-// Destructor
-EnemyFormations::~EnemyFormations()
-{
-}
-
-// Inicializa las formaciones enemigas
-void EnemyFormations::initEnemyFormations()
-{
-	const int y4 =  - BLOCK;
-	const int x4_0 = param.game.playArea.rect.x;
-	const int x4_100 = param.game.playArea.rect.w - BALLOON_WIDTH_4;
-
-	const int y3 =  - BLOCK;
-	const int x3_0 = param.game.playArea.rect.x;
-	const int x3_100 = param.game.playArea.rect.w - BALLOON_WIDTH_3;
-
-	const int y2 =  - BLOCK;
-	const int x2_0 = param.game.playArea.rect.x;
-	const int x2_100 = param.game.playArea.rect.w - BALLOON_WIDTH_2;
-
-	const int y1 =  - BLOCK;
-	const int x1_0 = param.game.playArea.rect.x;
-	const int x1_50 = param.game.playArea.centerX - (BALLOON_WIDTH_1 / 2);
-	const int x1_100 = param.game.playArea.rect.w - BALLOON_WIDTH_1;
-
-	// Inicializa a cero las variables
-	for (int i = 0; i < NUMBER_OF_ENEMY_FORMATIONS; i++)
-	{
-		enemyFormation[i].numberOfEnemies = 0;
-		for (int j = 0; j < MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION; j++)
-		{
-			enemyFormation[i].init[j].x = 0;
-			enemyFormation[i].init[j].y = 0;
-			enemyFormation[i].init[j].velX = 0;
-			enemyFormation[i].init[j].kind = 0;
-			enemyFormation[i].init[j].creationCounter = 0;
-		}
-	}
-
-	const int creationTime = 300;
-	int incX = 0;
-	int incTime = 0;
-	int j = 0;
-
-	// #00 - Dos enemigos BALLOON4 uno a cada extremo
-	j = 0;
-	enemyFormation[j].numberOfEnemies = 2;
-	incX = x4_100;
-	incTime = 0;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x4_0 + (i * incX);
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime + (incTime * i);
-	}
-
-	// #01 - Dos enemigos BALLOON4 uno a cada cuarto. Ambos van hacia el centro
-	j = 1;
-	enemyFormation[j].numberOfEnemies = 2;
-	incX = param.game.playArea.centerX;
-	incTime = 0;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = param.game.playArea.firstQuarterX - (BALLOON_WIDTH_4 / 2) + (i * incX);
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime + (incTime * i);
-	}
-
-	// #02 - Cuatro enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
-	j = 2;
-	enemyFormation[j].numberOfEnemies = 4;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x2_0 + (i * incX);
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #03 - Cuatro enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
-	j = 3;
-	enemyFormation[j].numberOfEnemies = 4;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x2_100 - (i * incX);
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #04 - Tres enemigos BALLOON3. 0, 25, 50. Hacia la derecha
-	j = 4;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_0 + (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #05 - Tres enemigos BALLOON3. 50, 75, 100. Hacia la izquierda
-	j = 5;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_100 - (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #06 - Tres enemigos BALLOON3. 0, 0, 0. Hacia la derecha
-	j = 6;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_0 + (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #07 - Tres enemigos BALLOON3. 100, 100, 100. Hacia la izquierda
-	j = 7;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_100 - (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #08 - Seis enemigos BALLOON1. 0, 0, 0, 0, 0, 0. Hacia la derecha
-	j = 8;
-	enemyFormation[j].numberOfEnemies = 6;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x1_0 + (i * incX);
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #09 - Seis enemigos BALLOON1. 100, 100, 100, 100, 100, 100. Hacia la izquierda
-	j = 9;
-	enemyFormation[j].numberOfEnemies = 6;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x1_100 - (i * incX);
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #10 - Tres enemigos BALLOON4 seguidos desde la izquierda
-	j = 10;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_4 + 1;
-	incTime = 15;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x4_0 + (i * incX);
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #11 - Tres enemigos BALLOON4 seguidos desde la derecha
-	j = 11;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_4 + 1;
-	incTime = 15;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x4_100 - (i * incX);
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #12 - Seis enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
-	j = 12;
-	enemyFormation[j].numberOfEnemies = 6;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x2_0 + (i * incX);
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #13 - Seis enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
-	j = 13;
-	enemyFormation[j].numberOfEnemies = 6;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x2_100 - (i * incX);
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #14 - Cinco enemigos BALLOON3. Hacia la derecha. Separados
-	j = 14;
-	enemyFormation[j].numberOfEnemies = 5;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_0 + (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #15 - Cinco enemigos BALLOON3. Hacia la izquierda. Separados
-	j = 15;
-	enemyFormation[j].numberOfEnemies = 5;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_100 - (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #16 - Cinco enemigos BALLOON3. Hacia la derecha. Juntos
-	j = 16;
-	enemyFormation[j].numberOfEnemies = 5;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_0 + (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #17 - Cinco enemigos BALLOON3. Hacia la izquierda. Juntos
-	j = 17;
-	enemyFormation[j].numberOfEnemies = 5;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_100 - (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #18 - Doce enemigos BALLOON1. Hacia la derecha. Juntos
-	j = 18;
-	enemyFormation[j].numberOfEnemies = 12;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x1_0 + (i * incX);
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #19 - Doce enemigos BALLOON1. Hacia la izquierda. Juntos
-	j = 19;
-	enemyFormation[j].numberOfEnemies = 12;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x1_100 - (i * incX);
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #20 - Dos enemigos BALLOON4 seguidos desde la izquierda/derecha. Simetricos
-	j = 20;
-	enemyFormation[j].numberOfEnemies = 4;
-	incX = BALLOON_WIDTH_4 + 1;
-	incTime = 0;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x4_0 + (i * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x4_100 - ((i - half) * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		}
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime + (incTime * i);
-	}
-
-	// #21 - Diez enemigos BALLOON2 uno detras del otro. Izquierda/derecha. Simetricos
-	j = 21;
-	enemyFormation[j].numberOfEnemies = 10;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 3;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x2_0 + (i * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x2_100 - ((i - half) * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-	}
-
-	// #22 - Diez enemigos BALLOON3. Hacia la derecha/izquierda. Separados. Simetricos
-	j = 22;
-	enemyFormation[j].numberOfEnemies = 10;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x3_0 + (i * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x3_100 - ((i - half) * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-	}
-
-	// #23 - Diez enemigos BALLOON3. Hacia la derecha. Juntos. Simetricos
-	j = 23;
-	enemyFormation[j].numberOfEnemies = 10;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x3_0 + (i * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x3_100 - ((i - half) * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-	}
-
-	// #24 - Treinta enemigos BALLOON1. Del centro hacia los extremos. Juntos. Simetricos
-	j = 24;
-	enemyFormation[j].numberOfEnemies = 30;
-	incX = 0;
-	incTime = 5;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x1_50;
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) + (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x1_50;
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) + (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-	}
-
-	// #25 - Treinta enemigos BALLOON1. Del centro hacia adentro. Juntos. Simetricos
-	j = 25;
-	enemyFormation[j].numberOfEnemies = 30;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 5;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x1_50 + 20;
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x1_50 - 20;
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-	}
-
-	// Crea las mismas formaciones pero con hexagonos a partir de la posición 50 del vector
-	for (int k = 0; k < j + 1; k++)
-	{
-		enemyFormation[k + 50].numberOfEnemies = enemyFormation[k].numberOfEnemies;
-		for (int i = 0; i < enemyFormation[k + 50].numberOfEnemies; i++)
-		{
-			enemyFormation[k + 50].init[i].x = enemyFormation[k].init[i].x;
-			enemyFormation[k + 50].init[i].y = enemyFormation[k].init[i].y;
-			enemyFormation[k + 50].init[i].velX = enemyFormation[k].init[i].velX;
-			enemyFormation[k + 50].init[i].creationCounter = enemyFormation[k].init[i].creationCounter;
-			enemyFormation[k + 50].init[i].kind = enemyFormation[k].init[i].kind + 4;
-		}
-	}
-
-	// TEST
-	enemyFormation[99].numberOfEnemies = 4;
-
-	enemyFormation[99].init[0].x = 10;
-	enemyFormation[99].init[0].y = y1;
-	enemyFormation[99].init[0].velX = 0;
-	enemyFormation[99].init[0].kind = BALLOON_1;
-	enemyFormation[99].init[0].creationCounter = 200;
-
-	enemyFormation[99].init[1].x = 50;
-	enemyFormation[99].init[1].y = y1;
-	enemyFormation[99].init[1].velX = 0;
-	enemyFormation[99].init[1].kind = BALLOON_2;
-	enemyFormation[99].init[1].creationCounter = 200;
-
-	enemyFormation[99].init[2].x = 90;
-	enemyFormation[99].init[2].y = y1;
-	enemyFormation[99].init[2].velX = 0;
-	enemyFormation[99].init[2].kind = BALLOON_3;
-	enemyFormation[99].init[2].creationCounter = 200;
-
-	enemyFormation[99].init[3].x = 140;
-	enemyFormation[99].init[3].y = y1;
-	enemyFormation[99].init[3].velX = 0;
-	enemyFormation[99].init[3].kind = BALLOON_4;
-	enemyFormation[99].init[3].creationCounter = 200;
-}
-
-// Inicializa los conjuntos de formaciones
-void EnemyFormations::initEnemyPools()
-{
-	// EnemyPool #0
-	enemyPool[0].set[0] = &enemyFormation[0];
-	enemyPool[0].set[1] = &enemyFormation[1];
-	enemyPool[0].set[2] = &enemyFormation[2];
-	enemyPool[0].set[3] = &enemyFormation[3];
-	enemyPool[0].set[4] = &enemyFormation[4];
-	enemyPool[0].set[5] = &enemyFormation[5];
-	enemyPool[0].set[6] = &enemyFormation[6];
-	enemyPool[0].set[7] = &enemyFormation[7];
-	enemyPool[0].set[8] = &enemyFormation[8];
-	enemyPool[0].set[9] = &enemyFormation[9];
-
-	// EnemyPool #1
-	enemyPool[1].set[0] = &enemyFormation[10];
-	enemyPool[1].set[1] = &enemyFormation[11];
-	enemyPool[1].set[2] = &enemyFormation[12];
-	enemyPool[1].set[3] = &enemyFormation[13];
-	enemyPool[1].set[4] = &enemyFormation[14];
-	enemyPool[1].set[5] = &enemyFormation[15];
-	enemyPool[1].set[6] = &enemyFormation[16];
-	enemyPool[1].set[7] = &enemyFormation[17];
-	enemyPool[1].set[8] = &enemyFormation[18];
-	enemyPool[1].set[9] = &enemyFormation[19];
-
-	// EnemyPool #2
-	enemyPool[2].set[0] = &enemyFormation[0];
-	enemyPool[2].set[1] = &enemyFormation[1];
-	enemyPool[2].set[2] = &enemyFormation[2];
-	enemyPool[2].set[3] = &enemyFormation[3];
-	enemyPool[2].set[4] = &enemyFormation[4];
-	enemyPool[2].set[5] = &enemyFormation[55];
-	enemyPool[2].set[6] = &enemyFormation[56];
-	enemyPool[2].set[7] = &enemyFormation[57];
-	enemyPool[2].set[8] = &enemyFormation[58];
-	enemyPool[2].set[9] = &enemyFormation[59];
-
-	// EnemyPool #3
-	enemyPool[3].set[0] = &enemyFormation[50];
-	enemyPool[3].set[1] = &enemyFormation[51];
-	enemyPool[3].set[2] = &enemyFormation[52];
-	enemyPool[3].set[3] = &enemyFormation[53];
-	enemyPool[3].set[4] = &enemyFormation[54];
-	enemyPool[3].set[5] = &enemyFormation[5];
-	enemyPool[3].set[6] = &enemyFormation[6];
-	enemyPool[3].set[7] = &enemyFormation[7];
-	enemyPool[3].set[8] = &enemyFormation[8];
-	enemyPool[3].set[9] = &enemyFormation[9];
-
-	// EnemyPool #4
-	enemyPool[4].set[0] = &enemyFormation[60];
-	enemyPool[4].set[1] = &enemyFormation[61];
-	enemyPool[4].set[2] = &enemyFormation[62];
-	enemyPool[4].set[3] = &enemyFormation[63];
-	enemyPool[4].set[4] = &enemyFormation[64];
-	enemyPool[4].set[5] = &enemyFormation[65];
-	enemyPool[4].set[6] = &enemyFormation[66];
-	enemyPool[4].set[7] = &enemyFormation[67];
-	enemyPool[4].set[8] = &enemyFormation[68];
-	enemyPool[4].set[9] = &enemyFormation[69];
-
-	// EnemyPool #5
-	enemyPool[5].set[0] = &enemyFormation[10];
-	enemyPool[5].set[1] = &enemyFormation[61];
-	enemyPool[5].set[2] = &enemyFormation[12];
-	enemyPool[5].set[3] = &enemyFormation[63];
-	enemyPool[5].set[4] = &enemyFormation[14];
-	enemyPool[5].set[5] = &enemyFormation[65];
-	enemyPool[5].set[6] = &enemyFormation[16];
-	enemyPool[5].set[7] = &enemyFormation[67];
-	enemyPool[5].set[8] = &enemyFormation[18];
-	enemyPool[5].set[9] = &enemyFormation[69];
-
-	// EnemyPool #6
-	enemyPool[6].set[0] = &enemyFormation[60];
-	enemyPool[6].set[1] = &enemyFormation[11];
-	enemyPool[6].set[2] = &enemyFormation[62];
-	enemyPool[6].set[3] = &enemyFormation[13];
-	enemyPool[6].set[4] = &enemyFormation[64];
-	enemyPool[6].set[5] = &enemyFormation[15];
-	enemyPool[6].set[6] = &enemyFormation[66];
-	enemyPool[6].set[7] = &enemyFormation[17];
-	enemyPool[6].set[8] = &enemyFormation[68];
-	enemyPool[6].set[9] = &enemyFormation[19];
-
-	// EnemyPool #7
-	enemyPool[7].set[0] = &enemyFormation[20];
-	enemyPool[7].set[1] = &enemyFormation[21];
-	enemyPool[7].set[2] = &enemyFormation[22];
-	enemyPool[7].set[3] = &enemyFormation[23];
-	enemyPool[7].set[4] = &enemyFormation[24];
-	enemyPool[7].set[5] = &enemyFormation[65];
-	enemyPool[7].set[6] = &enemyFormation[66];
-	enemyPool[7].set[7] = &enemyFormation[67];
-	enemyPool[7].set[8] = &enemyFormation[68];
-	enemyPool[7].set[9] = &enemyFormation[69];
-
-	// EnemyPool #8
-	enemyPool[8].set[0] = &enemyFormation[70];
-	enemyPool[8].set[1] = &enemyFormation[71];
-	enemyPool[8].set[2] = &enemyFormation[72];
-	enemyPool[8].set[3] = &enemyFormation[73];
-	enemyPool[8].set[4] = &enemyFormation[74];
-	enemyPool[8].set[5] = &enemyFormation[15];
-	enemyPool[8].set[6] = &enemyFormation[16];
-	enemyPool[8].set[7] = &enemyFormation[17];
-	enemyPool[8].set[8] = &enemyFormation[18];
-	enemyPool[8].set[9] = &enemyFormation[19];
-
-	// EnemyPool #9
-	enemyPool[9].set[0] = &enemyFormation[20];
-	enemyPool[9].set[1] = &enemyFormation[21];
-	enemyPool[9].set[2] = &enemyFormation[22];
-	enemyPool[9].set[3] = &enemyFormation[23];
-	enemyPool[9].set[4] = &enemyFormation[24];
-	enemyPool[9].set[5] = &enemyFormation[70];
-	enemyPool[9].set[6] = &enemyFormation[71];
-	enemyPool[9].set[7] = &enemyFormation[72];
-	enemyPool[9].set[8] = &enemyFormation[73];
-	enemyPool[9].set[9] = &enemyFormation[74];
-}
-
-// Inicializa las fases del juego
-void EnemyFormations::initGameStages()
-{
-	// STAGE 1
-	stage[0].number = 1;
-	stage[0].powerToComplete = 200;
-	stage[0].minMenace = 7 + (4 * 1);
-	stage[0].maxMenace = 7 + (4 * 3);
-	stage[0].enemyPool = &enemyPool[0];
-
-	// STAGE 2
-	stage[1].number = 2;
-	stage[1].powerToComplete = 300;
-	stage[1].minMenace = 7 + (4 * 2);
-	stage[1].maxMenace = 7 + (4 * 4);
-	stage[1].enemyPool = &enemyPool[1];
-
-	// STAGE 3
-	stage[2].number = 3;
-	stage[2].powerToComplete = 600;
-	stage[2].minMenace = 7 + (4 * 3);
-	stage[2].maxMenace = 7 + (4 * 5);
-	stage[2].enemyPool = &enemyPool[2];
-
-	// STAGE 4
-	stage[3].number = 4;
-	stage[3].powerToComplete = 600;
-	stage[3].minMenace = 7 + (4 * 3);
-	stage[3].maxMenace = 7 + (4 * 5);
-	stage[3].enemyPool = &enemyPool[3];
-
-	// STAGE 5
-	stage[4].number = 5;
-	stage[4].powerToComplete = 600;
-	stage[4].minMenace = 7 + (4 * 4);
-	stage[4].maxMenace = 7 + (4 * 6);
-	stage[4].enemyPool = &enemyPool[4];
-
-	// STAGE 6
-	stage[5].number = 6;
-	stage[5].powerToComplete = 600;
-	stage[5].minMenace = 7 + (4 * 4);
-	stage[5].maxMenace = 7 + (4 * 6);
-	stage[5].enemyPool = &enemyPool[5];
-
-	// STAGE 7
-	stage[6].number = 7;
-	stage[6].powerToComplete = 650;
-	stage[6].minMenace = 7 + (4 * 5);
-	stage[6].maxMenace = 7 + (4 * 7);
-	stage[6].enemyPool = &enemyPool[6];
-
-	// STAGE 8
-	stage[7].number = 8;
-	stage[7].powerToComplete = 750;
-	stage[7].minMenace = 7 + (4 * 5);
-	stage[7].maxMenace = 7 + (4 * 7);
-	stage[7].enemyPool = &enemyPool[7];
-
-	// STAGE 9
-	stage[8].number = 9;
-	stage[8].powerToComplete = 850;
-	stage[8].minMenace = 7 + (4 * 6);
-	stage[8].maxMenace = 7 + (4 * 8);
-	stage[8].enemyPool = &enemyPool[8];
-
-	// STAGE 10
-	stage[9].number = 10;
-	stage[9].powerToComplete = 950;
-	stage[9].minMenace = 7 + (4 * 7);
-	stage[9].maxMenace = 7 + (4 * 10);
-	stage[9].enemyPool = &enemyPool[9];
-}
-
-// Devuelve una fase
-stage_t EnemyFormations::getStage(int index)
-{
-	return stage[index];
-}

source/enemy_formations.h

@@ -1,63 +0,0 @@
-#pragma once
-
-#define NUMBER_OF_ENEMY_FORMATIONS 100
-#define MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION 50
-
-// Estructuras
-struct enemyInits_t
-{
-    int x;               // Posición en el eje X donde crear al enemigo
-    int y;               // Posición en el eje Y donde crear al enemigo
-    float velX;          // Velocidad inicial en el eje X
-    int kind;            // Tipo de enemigo
-    int creationCounter; // Temporizador para la creación del enemigo
-};
-
-struct enemyFormation_t // Contiene la información de una formación enemiga
-{
-    int numberOfEnemies;                                     // Cantidad de enemigos que forman la formación
-    enemyInits_t init[MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION]; // Vector con todas las inicializaciones de los enemigos de la formación
-};
-
-struct enemyPool_t
-{
-    enemyFormation_t *set[10]; // Conjunto de formaciones enemigas
-};
-
-struct stage_t // Contiene todas las variables relacionadas con una fase
-{
-    enemyPool_t *enemyPool; // El conjunto de formaciones enemigas de la fase
-    int powerToComplete;    // Cantidad de poder que se necesita para completar la fase
-    int maxMenace;          // Umbral máximo de amenaza de la fase
-    int minMenace;          // Umbral mínimo de amenaza de la fase
-    int number;             // Número de fase
-};
-
-// Clase EnemyFormations, para gestionar las formaciones enemigas
-class EnemyFormations
-{
-private:
-    // Variables
-    stage_t stage[10];                                           // Variable con los datos de cada pantalla
-    enemyFormation_t enemyFormation[NUMBER_OF_ENEMY_FORMATIONS]; // Vector con todas las formaciones enemigas
-    enemyPool_t enemyPool[10];                                   // Variable con los diferentes conjuntos de formaciones enemigas
-
-    // Inicializa las formaciones enemigas
-    void initEnemyFormations();
-
-    // Inicializa los conjuntos de formaciones
-    void initEnemyPools();
-
-    // Inicializa las fases del juego
-    void initGameStages();
-
-public:
-    // Constructor
-    EnemyFormations();
-
-    // Destructor
-    ~EnemyFormations();
-
-    // Devuelve una fase
-    stage_t getStage(int index);
-};

source/enter_name.cpp

@@ -1,17 +1,23 @@
 #include "enter_name.h"
-#include <algorithm> // for max, min
+#include <stddef.h>  // Para size_t
+#include <algorithm> // Para max, min
 
 // Constructor
 EnterName::EnterName()
+{
+    init();
+}
+
+// Inicializa el objeto
+void EnterName::init()
 {
     // Obtiene el puntero al nombre
-    name = "A";
+    name_ = "A";
 
     // Inicia la lista de caracteres permitidos
-    // characterList = " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-    characterList = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()";
-    pos = 0;
-    numCharacters = (int)characterList.size();
+    character_list_ = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()";
+    position_ = 0;
+    num_characters_ = static_cast<int>(character_list_.size());
 
     // Pone la lista de indices para que refleje el nombre
     updateCharacterIndex();
@@ -20,32 +26,28 @@ EnterName::EnterName()
     updateName();
 }
 
-// Destructor
-EnterName::~EnterName()
-{
-}
-
 // Incrementa la posición
-void EnterName::incPos()
+void EnterName::incPosition()
 {
-    pos++;
-    pos = std::min(pos, NAME_LENGHT - 1);
+    position_++;
+    position_ = std::min(position_, NAME_LENGHT - 1);
+    checkIfPositionHasBeenUsed();
 }
 
 // Decrementa la posición
-void EnterName::decPos()
+void EnterName::decPosition()
 {
-    pos--;
-    pos = std::max(pos, 0);
+    --position_;
+    position_ = std::max(position_, 0);
 }
 
 // Incrementa el índice
 void EnterName::incIndex()
 {
-    ++characterIndex[pos];
-    if (characterIndex[pos] >= numCharacters)
+    ++character_index_[position_];
+    if (character_index_[position_] >= num_characters_)
     {
-        characterIndex[pos] = 0;
+        character_index_[position_] = 0;
     }
     updateName();
 }
@@ -53,61 +55,71 @@ void EnterName::incIndex()
 // Decrementa el índice
 void EnterName::decIndex()
 {
-    --characterIndex[pos];
-    if (characterIndex[pos] < 0)
+    --character_index_[position_];
+    if (character_index_[position_] < 0)
     {
-        characterIndex[pos] = numCharacters - 1;
+        character_index_[position_] = num_characters_ - 1;
     }
     updateName();
 }
 
-// Actualiza la variable
+// Actualiza el nombre a partir de la lista de índices
 void EnterName::updateName()
 {
-    name.clear();
+    name_.clear();
     for (int i = 0; i < NAME_LENGHT; ++i)
     {
-        name.push_back(characterList[characterIndex[i]]);
+        name_.push_back(character_list_[character_index_[i]]);
     }
 }
 
 // Actualiza la variable
 void EnterName::updateCharacterIndex()
 {
-    // Rellena de espacios
-    for (int i = 0; i < NAME_LENGHT; ++i)
+    // Rellena de espacios y marca como no usados
+    for (size_t i = 0; i < NAME_LENGHT; ++i)
     {
-        characterIndex[i] = 0;
+        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)
     {
-        characterIndex[i] = findIndex(name.at(i));
+        character_index_[i] = findIndex(name_.at(i));
+        position_has_been_used_[i] = true;
     }
 }
 
-// Encuentra el indice de un caracter en "characterList"
-int EnterName::findIndex(char character)
+// Encuentra el indice de un caracter en "character_list_"
+int EnterName::findIndex(char character) const
 {
-    for (int i = 0; i < (int)characterList.size(); ++i)
-    {
-        if (character == characterList[i])
-        {
+    for (size_t i = 0; i < character_list_.size(); ++i)
+        if (character == character_list_.at(i))
             return i;
-        }
-    }
     return 0;
 }
 
 // Obtiene el nombre
-std::string EnterName::getName()
+std::string EnterName::getName() const
 {
-    return name;
+    return name_;
 }
 
 // Obtiene la posición que se está editando
-int EnterName::getPos()
+int EnterName::getPosition() const
 {
-    return pos;
+    return position_;
+}
+
+// Comprueba la posición y copia el caracter si es necesario
+void EnterName::checkIfPositionHasBeenUsed()
+{
+    auto used = position_has_been_used_[position_];
+
+    if (!used && position_ > 0)
+        character_index_[position_] = character_index_[position_ - 1];
+
+    position_has_been_used_[position_] = true;
+    updateName();
 }

source/enter_name.h

@@ -2,7 +2,7 @@
 
 #include <string>
 
-#define NAME_LENGHT 8
+constexpr int NAME_LENGHT = 6;
 
 /*
     Un array, "characterList", contiene la lista de caracteres
@@ -16,33 +16,40 @@
 class EnterName
 {
 private:
-    std::string characterList;       // Lista de todos los caracteres permitidos
-    std::string name;                // Nombre introducido
-    int pos;                         // Posición a editar del nombre
-    int numCharacters;               // Cantidad de caracteres de la lista de caracteres
-    int characterIndex[NAME_LENGHT]; // Indice de la lista para cada uno de los caracteres que forman el nombre
+    std::string character_list_;               // Lista de todos los caracteres permitidos
+    std::string name_;                         // Nombre introducido
+    int position_;                             // Posición a editar del nombre
+    int num_characters_;                       // Cantidad de caracteres de la lista de caracteres
+    int character_index_[NAME_LENGHT];         // Indice de la lista para cada uno de los caracteres que forman el nombre
+    bool position_has_been_used_[NAME_LENGHT]; // Indica si en esa posición se ha puesto ya alguna letra. Se utiliza para replicar la letra anterior la primera vez
 
-    // Actualiza la variable
+    // Actualiza el nombre a partir de la lista de índices
     void updateName();
 
     // Actualiza la variable
     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();
 
 public:
     // Constructor
     EnterName();
 
     // Destructor
-    ~EnterName();
+    ~EnterName() = default;
+
+    // Inicializa el objeto
+    void init();
 
     // Incrementa la posición
-    void incPos();
+    void incPosition();
 
     // Decrementa la posición
-    void decPos();
+    void decPosition();
 
     // Incrementa el índice
     void incIndex();
@@ -51,8 +58,8 @@ public:
     void decIndex();
 
     // Obtiene el nombre
-    std::string getName();
+    std::string getName() const;
 
     // Obtiene la posición que se está editando
-    int getPos();
+    int getPosition() const;
 };

source/explosions.cpp

@@ -1,30 +1,11 @@
 #include "explosions.h"
-#include "animated_sprite.h"  // for AnimatedSprite
-class Texture;
-
-// Constructor
-Explosions::Explosions()
-{
-    textures.clear();
-    explosions.clear();
-}
-
-// Destructor
-Explosions::~Explosions()
-{
-    for (auto explosion : explosions)
-    {
-        if (explosion)
-        {
-            delete explosion;
-        }
-    }
-}
+#include "animated_sprite.h" // Para AnimatedSprite
+class Texture;               // lines 4-4
 
 // Actualiza la lógica de la clase
 void Explosions::update()
 {
-    for (auto explosion : explosions)
+    for (auto &explosion : explosions_)
     {
         explosion->update();
     }
@@ -36,42 +17,36 @@ void Explosions::update()
 // Dibuja el objeto en pantalla
 void Explosions::render()
 {
-    for (auto explosion : explosions)
+    for (auto &explosion : explosions_)
     {
         explosion->render();
     }
 }
 
-// Añade texturas al objetp
-void Explosions::addTexture(int size, Texture *texture, std::vector<std::string> *animation)
+// Añade texturas al objeto
+void Explosions::addTexture(int size, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
 {
-    explosion_texture_t temp;
-    temp.size = size;
-    temp.texture = texture;
-    temp.animation = animation;
-    textures.push_back(temp);
+    textures_.emplace_back(ExplosionTexture(size, texture, animation));
 }
 
 // Añade una explosión
 void Explosions::add(int x, int y, int size)
 {
-    const int index = getIndexBySize(size);
-    AnimatedSprite *sprite = new AnimatedSprite(textures[index].texture, "", textures[index].animation);
-    sprite->setPos(x, y);
-    explosions.push_back(sprite);
+    const auto index = getIndexBySize(size);
+    explosions_.emplace_back(std::make_unique<AnimatedSprite>(textures_[index].texture, textures_[index].animation));
+    explosions_.back()->setPos(x, y);
 }
 
 // Vacia el vector de elementos finalizados
 void Explosions::freeExplosions()
 {
-    if (explosions.empty() == false)
+    if (explosions_.empty() == false)
     {
-        for (int i = explosions.size() - 1; i >= 0; --i)
+        for (int i = explosions_.size() - 1; i >= 0; --i)
         {
-            if (explosions[i]->animationIsCompleted())
+            if (explosions_[i]->animationIsCompleted())
             {
-                delete explosions[i];
-                explosions.erase(explosions.begin() + i);
+                explosions_.erase(explosions_.begin() + i);
             }
         }
     }
@@ -80,9 +55,9 @@ void Explosions::freeExplosions()
 // Busca una textura a partir del tamaño
 int Explosions::getIndexBySize(int size)
 {
-    for (int i = 0; i < (int)textures.size();++i)
+    for (int i = 0; i < (int)textures_.size(); ++i)
     {
-        if (size == textures[i].size)
+        if (size == textures_[i].size)
         {
             return i;
         }

source/explosions.h

@@ -1,15 +1,20 @@
 #pragma once
 
-#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 explosion_texture_t
+struct ExplosionTexture
 {
-    Texture *texture;                    // Textura para la explosión
-    std::vector<std::string> *animation; // Animación para la textura
-    int size;                            // Tamaño de la explosión
+    int size;                           // Tamaño de la explosión
+    std::shared_ptr<Texture> texture;   // Textura para la explosión
+    std::vector<std::string> animation; // Animación para la textura
+
+    // Constructor
+    ExplosionTexture(int sz, std::shared_ptr<Texture> tex, const std::vector<std::string> &anim)
+        : size(sz), texture(tex), animation(anim) {}
 };
 
 // Clase explosions
@@ -17,8 +22,8 @@ class Explosions
 {
 private:
     // Variables
-    std::vector<explosion_texture_t> textures; // Vector con las texturas a utilizar
-    std::vector<AnimatedSprite *> explosions;  // Lista con todas las explosiones
+    std::vector<ExplosionTexture> textures_;                  // Vector con las texturas a utilizar
+    std::vector<std::unique_ptr<AnimatedSprite>> explosions_; // Lista con todas las explosiones
 
     // Vacia el vector de elementos finalizados
     void freeExplosions();
@@ -28,10 +33,10 @@ private:
 
 public:
     // Constructor
-    Explosions();
+    Explosions() = default;
 
     // Destructor
-    ~Explosions();
+    ~Explosions() = default;
 
     // Actualiza la lógica de la clase
     void update();
@@ -39,8 +44,8 @@ public:
     // Dibuja el objeto en pantalla
     void render();
 
-    // Añade texturas al objetp
-    void addTexture(int size, Texture *texture, std::vector<std::string> *animation);
+    // Añade texturas al objeto
+    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,20 +1,18 @@
 #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 "utils.h"               // for param_t, paramGame_t, paramFade_t
+#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(SDL_Renderer *renderer)
+Fade::Fade()
+	: renderer_(Screen::get()->getRenderer())
 {
-	// Copia punteros y objetos
-	this->renderer = renderer;
-
 	// Crea la textura donde dibujar el fade
-	backbuffer = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
-	SDL_SetTextureBlendMode(backbuffer, SDL_BLENDMODE_BLEND);
+	backbuffer_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
+	SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
 
 	// Inicializa las variables
 	init();
@@ -23,179 +21,177 @@ Fade::Fade(SDL_Renderer *renderer)
 // Destructor
 Fade::~Fade()
 {
-	SDL_DestroyTexture(backbuffer);
-	backbuffer = nullptr;
+	SDL_DestroyTexture(backbuffer_);
+	backbuffer_ = nullptr;
 }
 
 // Inicializa las variables
 void Fade::init()
 {
-	type = FADE_CENTER;
-	mode = FADE_OUT;
-	enabled = false;
-	finished = false;
-	counter = 0;
-	r = 0;
-	g = 0;
-	b = 0;
-	postDuration = 20;
-	postCounter = 0;
-	numSquaresWidth = param.fade.numSquaresWidth;
-	numSquaresHeight = param.fade.numSquaresHeight;
-	fadeRandomSquaresDelay = param.fade.randomSquaresDelay;
-	fadeRandomSquaresMult = param.fade.randomSquaresMult;
+	type_ = FadeType::CENTER;
+	mode_ = FadeMode::OUT;
+	enabled_ = false;
+	finished_ = false;
+	counter_ = 0;
+	r_ = 0;
+	g_ = 0;
+	b_ = 0;
+	a_ = 0;
+	post_duration_ = 20;
+	post_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;
+	fade_random_squares_mult_ = param.fade.random_squares_mult;
 }
 
 // Resetea algunas variables para volver a hacer el fade sin perder ciertos parametros
 void Fade::reset()
 {
-	enabled = false;
-	finished = false;
-	counter = 0;
+	enabled_ = false;
+	finished_ = false;
+	counter_ = 0;
 }
 
 // Pinta una transición en pantalla
 void Fade::render()
 {
-	if (enabled || finished)
+	if (enabled_ || finished_)
 	{
-		SDL_RenderCopy(renderer, backbuffer, nullptr, nullptr);
+		SDL_RenderCopy(renderer_, backbuffer_, nullptr, nullptr);
 	}
 }
 
 // Actualiza las variables internas
 void Fade::update()
 {
-	if (enabled)
+	if (enabled_)
 	{
-		switch (type)
+		switch (type_)
 		{
-		case FADE_FULLSCREEN:
+		case FadeType::FULLSCREEN:
 		{
-			// Modifica la transparencia de la 
-			if (mode == FADE_OUT)
-				a = std::min(counter * 4, 255);
-			else
-				a = 255 - std::min(counter * 4, 255);
+			// Modifica la transparencia
+			a_ = mode_ == FadeMode::OUT ? std::min(counter_ * 4, 255) : 255 - std::min(counter_ * 4, 255);
 
-			SDL_SetTextureAlphaMod(backbuffer, a);
+			SDL_SetTextureAlphaMod(backbuffer_, a_);
 
 			// Comprueba si ha terminado
-			if (counter >= 255 / 4)
+			if (counter_ >= 255 / 4)
 			{
-				finished = true;
+				finished_ = true;
 			}
 
 			break;
 		}
 
-		case FADE_CENTER:
+		case FadeType::CENTER:
 		{
-			// Dibuja sobre el backbuffer
-			SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-			SDL_SetRenderTarget(renderer, backbuffer);
+			// Dibuja sobre el backbuffer_
+			auto temp = SDL_GetRenderTarget(renderer_);
+			SDL_SetRenderTarget(renderer_, backbuffer_);
 
-			SDL_SetRenderDrawColor(renderer, r, g, b, a);
+			SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
 
-			for (int i = 0; i < counter; i++)
+			for (int i = 0; i < counter_; i++)
 			{
-				rect1.h = rect2.h = i * 4;
-				rect2.y = param.game.height - (i * 4);
+				rect1_.h = rect2_.h = i * 4;
+				rect2_.y = param.game.height - (i * 4);
 
-				SDL_RenderFillRect(renderer, &rect1);
-				SDL_RenderFillRect(renderer, &rect2);
+				SDL_RenderFillRect(renderer_, &rect1_);
+				SDL_RenderFillRect(renderer_, &rect2_);
 			}
 
 			// Deja el renderizador como estaba
-			SDL_SetRenderTarget(renderer, temp);
+			SDL_SetRenderTarget(renderer_, temp);
 
 			// Comprueba si ha terminado
-			if ((counter * 4) > param.game.height)
+			if ((counter_ * 4) > param.game.height)
 			{
-				finished = true;
-				a = 255;
+				finished_ = true;
+				a_ = 255;
 			}
 			break;
 		}
 
-		case FADE_RANDOM_SQUARE:
+		case FadeType::RANDOM_SQUARE:
 		{
-			if (counter % fadeRandomSquaresDelay == 0)
+			if (counter_ % fade_random_squares_delay_ == 0)
 			{
-				// Dibuja sobre el backbuffer
-				SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-				SDL_SetRenderTarget(renderer, backbuffer);
+				// Dibuja sobre el backbuffer_
+				auto temp = SDL_GetRenderTarget(renderer_);
+				SDL_SetRenderTarget(renderer_, backbuffer_);
 
-				SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
-				SDL_SetRenderDrawColor(renderer, r, g, b, a);
+				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
+				SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
 
 				// Dibuja el cuadrado correspondiente
-				const int index = std::min(counter / fadeRandomSquaresDelay, (numSquaresWidth * numSquaresHeight) - 1);
-				for (int i = 0; i < fadeRandomSquaresMult; ++i)
+				const int index = std::min(counter_ / fade_random_squares_delay_, (num_squares_width_ * num_squares_height_) - 1);
+				for (int i = 0; i < fade_random_squares_mult_; ++i)
 				{
-					const int index2 = std::min(index * fadeRandomSquaresMult + i, (int)square.size() - 1);
-					SDL_RenderFillRect(renderer, &square[index2]);
+					const int index2 = std::min(index * fade_random_squares_mult_ + i, (int)square_.size() - 1);
+					SDL_RenderFillRect(renderer_, &square_[index2]);
 				}
 
-				SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
+				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
 
 				// Deja el renderizador como estaba
-				SDL_SetRenderTarget(renderer, temp);
+				SDL_SetRenderTarget(renderer_, temp);
 			}
 
 			// Comprueba si ha terminado
-			if (counter * fadeRandomSquaresMult / fadeRandomSquaresDelay >= numSquaresWidth * numSquaresHeight)
+			if (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_ >= num_squares_width_ * num_squares_height_)
 			{
-				finished = true;
+				finished_ = true;
 			}
 
 			break;
 		}
 
-		case FADE_VENETIAN:
+		case FadeType::VENETIAN:
 		{
 			// Counter debe ir de 0 a 150
-			if (square.back().h < param.fade.venetianSize)
+			if (square_.back().h < param.fade.venetian_size)
 			{
-				// Dibuja sobre el backbuffer
-				SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-				SDL_SetRenderTarget(renderer, backbuffer);
+				// Dibuja sobre el backbuffer_
+				auto temp = SDL_GetRenderTarget(renderer_);
+				SDL_SetRenderTarget(renderer_, backbuffer_);
 
-				SDL_SetRenderDrawColor(renderer, r, g, b, a);
-				for (auto rect : square)
+				SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
+				for (auto rect : square_)
 				{
-					SDL_RenderFillRect(renderer, &rect);
+					SDL_RenderFillRect(renderer_, &rect);
 				}
 
 				// Deja el renderizador como estaba
-				SDL_SetRenderTarget(renderer, temp);
+				SDL_SetRenderTarget(renderer_, temp);
 
-				const Uint8 h = counter / 3;
-				for (int i = 0; i < (int)square.size(); ++i)
+				const auto h = counter_ / 3;
+				for (int i = 0; i < (int)square_.size(); ++i)
 				{
 					// A partir del segundo rectangulo se pinta en función del anterior
-					i == 0 ? square[i].h = h : square[i].h = std::max(square[i - 1].h - 3, 0);
+					square_[i].h = i == 0 ? h : std::max(square_[i - 1].h - 3, 0);
 				}
 			}
 			else
 			{
-				finished = true;
+				finished_ = true;
 			}
 
 			break;
 		}
 		}
 
-		if (finished)
+		if (finished_)
 		{
 			// Actualiza el contador
-			postCounter == postDuration ? enabled = false : postCounter++;
+			post_counter_ == post_duration_ ? enabled_ = false : post_counter_++;
 
-			// Deja el backbuffer todo del mismo color
-			cleanBackbuffer(r, g, b, a);
+			// Deja el backbuffer_ todo del mismo color
+			cleanBackbuffer(r_, g_, b_, a_);
 		}
 
-		counter++;
+		counter_++;
 	}
 }
 
@@ -203,84 +199,85 @@ void Fade::update()
 void Fade::activate()
 {
 	// Si ya está habilitado, no hay que volverlo a activar
-	if (enabled)
+	if (enabled_)
 	{
 		return;
 	}
 
-	enabled = true;
-	finished = false;
-	counter = 0;
-	postCounter = 0;
+	enabled_ = true;
+	finished_ = false;
+	counter_ = 0;
+	post_counter_ = 0;
 
-	switch (type)
+	switch (type_)
 	{
-	case FADE_FULLSCREEN:
+	case FadeType::FULLSCREEN:
 	{
-		// Pinta el backbuffer de color sólido
-		cleanBackbuffer(r, g, b, 255);
+		// Pinta el backbuffer_ de color sólido
+		cleanBackbuffer(r_, g_, b_, 255);
 		break;
 	}
 
-	case FADE_CENTER:
+	case FadeType::CENTER:
 	{
-		rect1 = {0, 0, param.game.width, 0};
-		rect2 = {0, 0, param.game.width, 0};
-		a = 64;
+		rect1_ = {0, 0, param.game.width, 0};
+		rect2_ = {0, 0, param.game.width, 0};
+		a_ = 64;
 		break;
 	}
 
-	case FADE_RANDOM_SQUARE:
+	case FadeType::RANDOM_SQUARE:
 	{
-		rect1 = {0, 0, param.game.width / numSquaresWidth, param.game.height / numSquaresHeight};
-		square.clear();
+		rect1_ = {0, 0, param.game.width / num_squares_width_, param.game.height / num_squares_height_};
+		square_.clear();
 
 		// Añade los cuadrados al vector
-		for (int i = 0; i < numSquaresWidth * numSquaresHeight; ++i)
+		for (int i = 0; i < num_squares_width_ * num_squares_height_; ++i)
 		{
-			rect1.x = (i % numSquaresWidth) * rect1.w;
-			rect1.y = (i / numSquaresWidth) * rect1.h;
-			square.push_back(rect1);
+			rect1_.x = (i % num_squares_width_) * rect1_.w;
+			rect1_.y = (i / num_squares_width_) * rect1_.h;
+			square_.push_back(rect1_);
 		}
 
 		// Desordena el vector de cuadrados
-		int num = numSquaresWidth * numSquaresHeight;
+		auto num = num_squares_width_ * num_squares_height_;
 		while (num > 1)
 		{
-			int num_arreu = rand() % num;
-			SDL_Rect temp = square[num_arreu];
-			square[num_arreu] = square[num - 1];
-			square[num - 1] = temp;
+			auto num_arreu = rand() % num;
+			SDL_Rect temp = square_[num_arreu];
+			square_[num_arreu] = square_[num - 1];
+			square_[num - 1] = temp;
 			num--;
 		}
 
 		// Limpia la textura
-		SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-		SDL_SetRenderTarget(renderer, backbuffer);
-		a = mode == FADE_OUT ? 0 : 255;
-		SDL_SetRenderDrawColor(renderer, r, g, b, a);
-		SDL_RenderClear(renderer);
-		SDL_SetRenderTarget(renderer, temp);
+		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);
 
 		// Deja el color listo para usar
-		a = mode == FADE_OUT ? 255 : 0;
+		a_ = mode_ == FadeMode::OUT ? 255 : 0;
 
 		break;
 	}
 
-	case FADE_VENETIAN:
+	case FadeType::VENETIAN:
 	{
-		rect1 = {0, 0, param.game.width, 0};
-		square.clear();
-		a = 255;
+		cleanBackbuffer(0, 0, 0, 0);
+		rect1_ = {0, 0, param.game.width, 0};
+		square_.clear();
+		a_ = 255;
 
 		// Añade los cuadrados al vector
-		const int max = param.game.height / param.fade.venetianSize;
+		const int max = param.game.height / param.fade.venetian_size;
 
 		for (int i = 0; i < max; ++i)
 		{
-			rect1.y = i * param.fade.venetianSize;
-			square.push_back(rect1);
+			rect1_.y = i * param.fade.venetian_size;
+			square_.push_back(rect1_);
 		}
 
 		break;
@@ -289,55 +286,55 @@ void Fade::activate()
 }
 
 // Comprueba si está activo
-bool Fade::isEnabled()
+bool Fade::isEnabled() const
 {
-	return enabled;
+	return enabled_;
 }
 
 // Comprueba si ha terminado la transicion
-bool Fade::hasEnded()
+bool Fade::hasEnded() const
 {
 	// Ha terminado cuando ha finalizado la transición y se ha deshabilitado
-	return !enabled && finished;
+	return !enabled_ && finished_;
 }
 
 // Establece el tipo de fade
-void Fade::setType(Uint8 type)
+void Fade::setType(FadeType type)
 {
-	this->type = type;
+	type_ = type;
 }
 
 // Establece el modo de fade
-void Fade::setMode(Uint8 mode)
+void Fade::setMode(FadeMode mode)
 {
-	this->mode = mode;
+	mode_ = mode;
 }
 
 // Establece el color del fade
 void Fade::setColor(Uint8 r, Uint8 g, Uint8 b)
 {
-	this->r = r;
-	this->g = g;
-	this->b = b;
+	r_ = r;
+	g_ = g;
+	b_ = b;
 }
 
 // Establece la duración posterior
 void Fade::setPost(int value)
 {
-	postDuration = value;
+	post_duration_ = value;
 }
 
 // Limpia el backbuffer
-void Fade::cleanBackbuffer(int r, int g, int b, int a)
+void Fade::cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a)
 {
-	// Dibujamos sobre el backbuffer
-	SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-	SDL_SetRenderTarget(renderer, backbuffer);
+	// Dibujamos sobre el backbuffer_
+	auto temp = SDL_GetRenderTarget(renderer_);
+	SDL_SetRenderTarget(renderer_, backbuffer_);
 
 	// Pintamos la textura con el color del fade
-	SDL_SetRenderDrawColor(renderer, r, g, b, a);
-	SDL_RenderClear(renderer);
+	SDL_SetRenderDrawColor(renderer_, r, g, b, a);
+	SDL_RenderClear(renderer_);
 
 	// Vuelve a dejar el renderizador como estaba
-	SDL_SetRenderTarget(renderer, temp);
+	SDL_SetRenderTarget(renderer_, temp);
 }

source/fade.h

@@ -1,54 +1,60 @@
 #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
-#define FADE_FULLSCREEN 0
-#define FADE_CENTER 1
-#define FADE_RANDOM_SQUARE 2
-#define FADE_VENETIAN 3
+enum class FadeType : Uint8
+{
+	FULLSCREEN = 0,
+	CENTER = 1,
+	RANDOM_SQUARE = 2,
+	VENETIAN = 3,
+};
 
 // Modos de fundido
-#define FADE_IN 0
-#define FADE_OUT 1
+enum class FadeMode : Uint8
+{
+	IN = 0,
+	OUT = 1,
+};
 
 // Clase Fade
 class Fade
 {
 private:
 	// Objetos y punteros
-	SDL_Renderer *renderer;	 // El renderizador de la ventana
-	SDL_Texture *backbuffer; // Textura para usar como backbuffer con SDL_TEXTUREACCESS_TARGET
+	SDL_Renderer *renderer_;  // El renderizador de la ventana
+	SDL_Texture *backbuffer_; // Textura para usar como backbuffer con SDL_TEXTUREACCESS_TARGET
 
 	// Variables
-	Uint8 type;					  // Tipo de fade a realizar
-	Uint8 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 numSquaresWidth;		  // Cantidad total de cuadraditos en horizontal para el FADE_RANDOM_SQUARE
-	int numSquaresHeight;		  // Cantidad total de cuadraditos en vertical para el FADE_RANDOM_SQUARE
-	std::vector<SDL_Rect> square; // Vector con los indices de los cuadrados para el FADE_RANDOM_SQUARE
-	int fadeRandomSquaresDelay;	  // Duración entre cada pintado de cuadrados
-	int fadeRandomSquaresMult;	  // Cantidad de cuadrados que se pintaran cada vez
-	int postDuration;			  // Duración posterior del fade tras finalizar
-	int postCounter;			  // Contador para la duración posterior
+	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
 
 	// Inicializa las variables
 	void init();
 
 	// Limpia el backbuffer
-	void cleanBackbuffer(int r, int g, int b, int a);
+	void cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a);
 
 public:
 	// Constructor
-	Fade(SDL_Renderer *renderer);
+	Fade();
 
 	// Destructor
 	~Fade();
@@ -66,16 +72,16 @@ public:
 	void activate();
 
 	// Comprueba si ha terminado la transicion
-	bool hasEnded();
+	bool hasEnded() const;
 
 	// Comprueba si está activo
-	bool isEnabled();
+	bool isEnabled() const;
 
 	// Establece el tipo de fade
-	void setType(Uint8 type);
+	void setType(FadeType type);
 
 	// Establece el modo de fade
-	void setMode(Uint8 mode);
+	void setMode(FadeMode mode);
 
 	// Establece el color del fade
 	void setColor(Uint8 r, Uint8 g, Uint8 b);

source/game.h

@@ -1,55 +1,36 @@
 #pragma once
 
-#include <SDL2/SDL_events.h> // for SDL_Event
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h> // for Uint32
-#include <string>			 // for string
-#include <vector>			 // for vector
-#include "section.h"		 // for options_e
-#include "utils.h"			 // for demoKeys_t, color_t, hiScoreEntry_t
-class Asset;				 // lines 11-11
-class Background;			 // lines 12-12
-class Balloon;				 // lines 13-13
-class Bullet;				 // lines 14-14
-class EnemyFormations;		 // lines 15-15
-class Explosions;			 // lines 16-16
-class Fade;					 // lines 17-17
-class Input;				 // lines 18-18
-class Item;					 // lines 19-19
-class Player;				 // lines 20-20
-class Scoreboard;			 // lines 21-21
-class Screen;				 // lines 22-22
-class SmartSprite;			 // lines 23-23
-class Text;					 // lines 24-24
-class Texture;				 // lines 25-25
-enum class BulletType;
-struct JA_Music_t; // lines 26-26
-struct JA_Sound_t; // lines 27-27
+#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 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
 
-#define GAME_MODE_DEMO_OFF false
-#define GAME_MODE_DEMO_ON true
+// Modo demo
+constexpr bool GAME_MODE_DEMO_OFF = false;
+constexpr bool GAME_MODE_DEMO_ON = true;
 
 // Cantidad de elementos a escribir en los ficheros de datos
-#define TOTAL_SCORE_DATA 3
-#define TOTAL_DEMO_DATA 2000
-
-// Contadores
-#define STAGE_COUNTER 200
-#define HELP_COUNTER 1000
-#define GAME_COMPLETED_START_FADE 500
-#define GAME_COMPLETED_END 700
-
-// Porcentaje de aparición de los objetos
-#define ITEM_POINTS_1_DISK_ODDS 10
-#define ITEM_POINTS_2_GAVINA_ODDS 6
-#define ITEM_POINTS_3_PACMAR_ODDS 3
-#define ITEM_CLOCK_ODDS 5
-#define ITEM_COFFEE_ODDS 5
-#define ITEM_POWER_BALL_ODDS 0
-#define ITEM_COFFEE_MACHINE_ODDS 4
-
-// Valores para las variables asociadas a los objetos
-#define TIME_STOPPED_COUNTER 300
+constexpr int TOTAL_SCORE_DATA = 3;
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de toda la parte en la
@@ -81,127 +62,111 @@ struct JA_Sound_t; // lines 27-27
 class Game
 {
 private:
-	struct helper_t
+	// Enum
+	enum class GameState
 	{
-		bool needCoffee;		   // Indica si se necesitan cafes
-		bool needCoffeeMachine;	   // Indica si se necesita PowerUp
-		bool needPowerBall;		   // Indica si se necesita una PowerBall
-		int counter;			   // Contador para no dar ayudas consecutivas
-		int itemPoints1Odds;	   // Probabilidad de aparición del objeto
-		int itemPoints2Odds;	   // Probabilidad de aparición del objeto
-		int itemPoints3Odds;	   // Probabilidad de aparición del objeto
-		int itemClockOdds;		   // Probabilidad de aparición del objeto
-		int itemCoffeeOdds;		   // Probabilidad de aparición del objeto
-		int itemCoffeeMachineOdds; // Probabilidad de aparición del objeto
+		PLAYING,
+		COMPLETED,
+		GAME_OVER,
 	};
 
-	struct demo_t
+	// 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
 	{
-		bool enabled;							 // Indica si está activo el modo demo
-		bool recording;							 // Indica si está activado el modo para grabar la demo
-		int counter;							 // Contador para el modo demo
-		demoKeys_t keys;						 // Variable con las pulsaciones de teclas del modo demo
-		demoKeys_t dataFile[2][TOTAL_DEMO_DATA]; // Vector con diferentes sets de datos con los movimientos para la demo
+		bool need_coffee;			  // Indica si se necesitan cafes
+		bool need_coffee_machine;	  // Indica si se necesita PowerUp
+		bool need_power_ball;		  // Indica si se necesita una PowerBall
+		int counter;				  // Contador para no dar ayudas consecutivas
+		int item_disk_odds;			  // Probabilidad de aparición del objeto
+		int item_gavina_odds;		  // Probabilidad de aparición del objeto
+		int item_pacmar_odds;		  // Probabilidad de aparición del objeto
+		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_) {}
 	};
 
 	// Objetos y punteros
-	SDL_Renderer *renderer;			  // El renderizador de la ventana
-	Screen *screen;					  // Objeto encargado de dibujar en pantalla
-	Asset *asset;					  // Objeto que gestiona todos los ficheros de recursos
-	Input *input;					  // Manejador de entrada
-	Scoreboard *scoreboard;			  // Objeto para dibujar el marcador
-	Background *background;			  // Objeto para dibujar el fondo del juego
-	Explosions *explosions;			  // Objeto para dibujar explosiones
-	EnemyFormations *enemyFormations; // Objeto para gestionar las oleadas enemigas
-	SDL_Texture *canvas;			  // Textura para dibujar la zona de juego
+	SDL_Renderer *renderer_; // El renderizador de la ventana
+	Screen *screen_;		 // Objeto encargado de dibujar en pantalla
+	Asset *asset_;			 // Objeto que gestiona todos los ficheros de recursos
+	Input *input_;			 // Manejador de entrada
+	Scoreboard *scoreboard_; // Objeto para dibujar el marcador
 
-	std::vector<Player *> players;			 // Vector con los jugadores
-	std::vector<Balloon *> balloons;		 // Vector con los globos
-	std::vector<Bullet *> bullets;			 // Vector con las balas
-	std::vector<Item *> items;				 // Vector con los items
-	std::vector<SmartSprite *> smartSprites; // Vector con los smartsprites
+	std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego
 
-	Texture *bulletTexture;								// Textura para las balas
-	std::vector<Texture *> itemTextures;				// Vector con las texturas de los items
-	std::vector<Texture *> balloonTextures;				// Vector con las texturas de los globos
-	std::vector<Texture *> explosionsTextures;			// Vector con las texturas de las explosiones
-	std::vector<Texture *> player1Textures;				// Vector con las texturas del jugador
-	std::vector<Texture *> player2Textures;				// Vector con las texturas del jugador
-	std::vector<std::vector<Texture *>> playerTextures; // Vector con todas las texturas de los jugadores;
+	SDL_Texture *canvas_; // Textura para dibujar la zona de juego
 
-	Texture *gameTextTexture; // Textura para los sprites con textos
+	std::vector<std::shared_ptr<Player>> players_;			  // Vector con los jugadores
+	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::vector<std::vector<std::string> *> itemAnimations;		  // Vector con las animaciones de los items
-	std::vector<std::vector<std::string> *> playerAnimations;	  // Vector con las animaciones del jugador
-	std::vector<std::vector<std::string> *> balloonAnimations;	  // Vector con las animaciones de los globos
-	std::vector<std::vector<std::string> *> explosionsAnimations; // Vector con las animaciones de las explosiones
+	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::vector<std::shared_ptr<Texture>>> player_textures_; // Vector con todas las texturas de los jugadores;
 
-	Text *text;			 // Fuente para los textos del juego
-	Text *textBig;		 // Fuente de texto grande
-	Text *textNokia2;	 // Otra fuente de texto para mensajes
-	Text *textNokiaBig2; // Y la versión en grande
+	std::vector<std::shared_ptr<Texture>> game_text_textures_; // Vector con las texturas para los sprites con textos
 
-	Fade *fade;				 // Objeto para renderizar fades
-	SDL_Event *eventHandler; // Manejador de eventos
+	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
 
-	SmartSprite *n1000Sprite; // Sprite con el texto 1.000
-	SmartSprite *n2500Sprite; // Sprite con el texto 2.500
-	SmartSprite *n5000Sprite; // Sprite con el texto 5.000
-
-	JA_Sound_t *balloonSound;		  // Sonido para la explosión del globo
-	JA_Sound_t *bulletSound;		  // Sonido para los disparos
-	JA_Sound_t *playerCollisionSound; // Sonido para la colisión del jugador con un enemigo
-	JA_Sound_t *hiScoreSound;		  // Sonido para cuando se alcanza la máxima puntuación
-	JA_Sound_t *itemDropSound;		  // Sonido para cuando se genera un item
-	JA_Sound_t *itemPickUpSound;	  // Sonido para cuando se recoge un item
-	JA_Sound_t *coffeeOutSound;		  // Sonido para cuando el jugador pierde el café al recibir un impacto
-	JA_Sound_t *stageChangeSound;	  // Sonido para cuando se cambia de fase
-	JA_Sound_t *bubble1Sound;		  // Sonido para cuando el jugador muere
-	JA_Sound_t *bubble2Sound;		  // Sonido para cuando el jugador muere
-	JA_Sound_t *bubble3Sound;		  // Sonido para cuando el jugador muere
-	JA_Sound_t *bubble4Sound;		  // Sonido para cuando el jugador muere
-	JA_Sound_t *clockSound;			  // Sonido para cuando se detiene el tiempo con el item reloj
-	JA_Sound_t *powerBallSound;		  // Sonido para cuando se explota una Power Ball
-	JA_Sound_t *coffeeMachineSound;	  // Sonido para cuando la máquina de café toca el suelo
-
-	JA_Music_t *music; // Musica de fondo
+	std::unique_ptr<Fade> fade_;					  // Objeto para renderizar fades
+	std::unique_ptr<BalloonManager> balloon_manager_; // Objeto para gestionar los globos
+	std::vector<Path> paths_;						  // Vector con los recorridos precalculados almacenados
 
 	// Variables
-	Uint32 ticks;							 // Contador de ticks para ajustar la velocidad del programa
-	Uint32 ticksSpeed;						 // Velocidad a la que se repiten los bucles del programa
-	bool hiScoreAchieved;					 // Indica si se ha superado la puntuación máxima
-	hiScoreEntry_t hiScore;					 // Máxima puntuación y nombre de quien la ostenta
-	int currentStage;						 // Indica la fase actual
-	int stageBitmapCounter;					 // Contador para el tiempo visible del texto de Stage
-	float stageBitmapPath[STAGE_COUNTER];	 // Vector con los puntos Y por donde se desplaza el texto
-	float getReadyBitmapPath[STAGE_COUNTER]; // Vector con los puntos X por donde se desplaza el texto
-	int gameOverCounter;					 // Contador para el estado de fin de partida
-	int menaceCurrent;						 // Nivel de amenaza actual
-	int menaceThreshold;					 // 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 timeStopped;						 // Indica si el tiempo está detenido
-	int timeStoppedCounter;					 // Temporizador para llevar la cuenta del tiempo detenido
-	int counter;							 // Contador para el juego
-	int balloonsPopped;						 // Lleva la cuenta de los globos explotados
-	int lastEnemyDeploy;					 // Guarda cual ha sido la última formación desplegada para no repetir;
-	int enemyDeployCounter;					 // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
-	float enemySpeed;						 // Velocidad a la que se mueven los enemigos
-	float defaultEnemySpeed;				 // Velocidad base de los enemigos, sin incrementar
-	helper_t helper;						 // Variable para gestionar las ayudas
-	bool powerBallEnabled;					 // Indica si hay una powerball ya activa
-	int powerBallCounter;					 // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
-	bool coffeeMachineEnabled;				 // Indica si hay una máquina de café en el terreno de juego
-	bool gameCompleted;						 // Indica si se ha completado la partida, llegando al final de la ultima pantalla
-	int gameCompletedCounter;				 // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
-	int difficulty;							 // Dificultad del juego
-	float difficultyScoreMultiplier;		 // Multiplicador de puntos en función de la dificultad
-	color_t difficultyColor;				 // Color asociado a la dificultad
-	int lastStageReached;					 // Contiene el número de la última pantalla que se ha alcanzado
-	demo_t demo;							 // Variable con todas las variables relacionadas con el modo demo
-	int totalPowerToCompleteGame;			 // 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 currentPower;						 // 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::PLAYING;				  // Estado
 #ifdef DEBUG
-	bool autoPopBalloons; // 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
@@ -213,26 +178,8 @@ private:
 	// Comprueba los eventos que hay en cola
 	void checkEvents();
 
-	// Inicializa las variables necesarias para la sección 'Game'
-	void init(int playerID);
-
-	// Carga los recursos necesarios para la sección 'Game'
-	void loadMedia();
-
-	// Libera los recursos previamente cargados
-	void unloadMedia();
-
-	// Carga el fichero de datos para la demo
-	bool loadDemoFile(std::string filePath, demoKeys_t (*dataFile)[TOTAL_DEMO_DATA]);
-#ifdef RECORDING
-	// Guarda el fichero de datos para la demo
-	bool saveDemoFile(std::string filePath);
-#endif
-	// Crea una formación de enemigos
-	void deployEnemyFormation();
-
-	// 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();
@@ -247,61 +194,16 @@ private:
 	void updateStage();
 
 	// Actualiza el estado de fin de la partida
-	void updateGameOver();
+	void updateGameOverState();
 
-	// Actualiza los globos
-	void updateBalloons();
-
-	// Pinta en pantalla todos los globos activos
-	void renderBalloons();
-
-	// Crea un globo nuevo en el vector de globos
-	int createBalloon(float x, int y, int kind, float velx, float speed, int stoppedcounter);
-
-	// Crea una PowerBall
-	void createPowerBall();
-
-	// Establece la velocidad de los globos
-	void setBalloonSpeed(float speed);
-
-	// Incrementa la velocidad de los globos
-	void incBalloonSpeed();
-
-	// Decrementa la velocidad de los globos
-	void decBalloonSpeed();
-
-	// 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(Balloon *balloon);
-
-	// Explosiona un globo. Lo destruye
-	void destroyBalloon(Balloon *balloon);
-
-	// Explosiona todos los globos
-	void popAllBalloons();
-
-	// Destruye todos los globos
-	void destroyAllBalloons();
-
-	// Detiene todos los globos
-	void stopAllBalloons(int time);
-
-	// Pone en marcha todos los globos
-	void startAllBalloons();
-
-	// Obtiene el número de globos activos
-	int countBalloons();
-
-	// 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(Player *player);
+	bool checkPlayerBalloonCollision(std::shared_ptr<Player> &player);
 
 	// Comprueba la colisión entre el jugador y los items
-	void checkPlayerItemCollision(Player *player);
+	void checkPlayerItemCollision(std::shared_ptr<Player> &player);
 
 	// Comprueba la colisión entre las balas y los globos
 	void checkBulletBalloonCollision();
@@ -313,7 +215,7 @@ private:
 	void renderBullets();
 
 	// Crea un objeto bala
-	void createBullet(int x, int y, BulletType kind, bool poweredUp, int owner);
+	void createBullet(int x, int y, BulletType kind, bool powered_up, int owner);
 
 	// Vacia el vector de balas
 	void freeBullets();
@@ -325,67 +227,52 @@ private:
 	void renderItems();
 
 	// Devuelve un item en función del azar
-	int dropItem();
+	ItemType dropItem();
 
 	// Crea un objeto item
-	void createItem(int kind, float x, float y);
+	void createItem(ItemType type, float x, float y);
 
 	// Vacia el vector de items
 	void freeItems();
 
-	// Crea un objeto SmartSprite
-	void createItemScoreSprite(int x, int y, SmartSprite *sprite);
+	// 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 freeSmartSprites();
 
-	// Crea un SmartSprite para arrojar el item café al recibir un impacto
+	// 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 SmartSprites
+	// Actualiza los SpriteSmarts
 	void updateSmartSprites();
 
-	// Pinta los SmartSprites activos
+	// Pinta los SpriteSmarts activos
 	void renderSmartSprites();
 
+	// Actualiza los PathSprites
+	void updatePathSprites();
+
+	// Pinta los PathSprites activos
+	void renderPathSprites();
+
 	// Acciones a realizar cuando el jugador muere
-	void killPlayer(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();
-
-	// Establece el valor de la variable
-	void setTimeStopped(bool value);
-
-	// Obtiene el valor de la variable
-	bool isTimeStopped();
-
-	// 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 updateEnemyDeployCounter();
+	void killPlayer(std::shared_ptr<Player> &player);
 
 	// Actualiza y comprueba el valor de la variable
-	void updateTimeStoppedCounter();
-
-	// Gestiona el nivel de amenaza
-	void updateMenace();
+	void updateTimeStopped();
 
 	// Actualiza el fondo
 	void updateBackground();
 
-	// Gestiona la entrada durante el juego
-	void checkInput();
-
-	// 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();
@@ -393,33 +280,18 @@ 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();
 
 	// Comprueba si todos los jugadores han terminado de jugar
-	bool allPlayersAreWaiting();
+	bool allPlayersAreWaitingOrGameOver();
+
+	// Comprueba si todos los jugadores han terminado de jugar
+	bool allPlayersAreGameOver();
 
 	// Comprueba si todos los jugadores han terminado de jugar
 	bool allPlayersAreNotPlaying();
 
-	// Carga las animaciones
-	void loadAnimations(std::string filePath, std::vector<std::string> *buffer);
-
-	// Elimina todos los objetos contenidos en vectores
-	void deleteAllVectorObjects();
-
 	// Recarga las texturas
 	void reloadTextures();
 
@@ -436,26 +308,104 @@ private:
 	void checkMusicStatus();
 
 	// Añade una puntuación a la tabla de records
-	void addScoreToScoreBoard(std::string name, int score);
+	void addScoreToScoreBoard(const std::string &name, int score);
 
-	// Comprueba si la puntuación entra en la tabla de mejores puntuaciones
-	bool IsEligibleForHighScore(int score);
+	// Saca del estado de GAME OVER al jugador si el otro está activo
+	void checkAndUpdatePlayerStatus(int active_player_index, int inactive_player_index);
 
 	// Comprueba el estado de juego de los jugadores
 	void checkPlayersStatusPlaying();
 
 	// Obtiene un jugador a partir de su "id"
-	Player *getPlayer(int id);
+	std::shared_ptr<Player> getPlayer(int id);
 
 	// Obtiene un controlador a partir del "id" del jugador
 	int getController(int playerId);
 
-	// Termina
-	void quit(section::options_e code);
+	// Gestiona la entrada durante el juego
+	void checkInput();
+
+	// Verifica si alguno de los controladores ha solicitado una pausa y actualiza el estado de pausa del juego.
+	void checkPauseInput();
+
+	// Gestiona las entradas de los jugadores en el modo demo, incluyendo movimientos y disparos automáticos.
+	void handleDemoMode();
+
+	// Procesa las entradas para un jugador específico durante el modo demo.
+	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.
+	void handleFireInput(const std::shared_ptr<Player> &player, BulletType bulletType);
+
+	// Gestiona las entradas de todos los jugadores en el modo normal (fuera del modo demo).
+	void handlePlayersInput();
+
+	// Maneja las entradas de movimiento y disparo para un jugador en modo normal.
+	void handleNormalPlayerInput(const std::shared_ptr<Player> &player);
+
+	// Procesa las entradas de disparo del jugador, permitiendo disparos automáticos si está habilitado.
+	void handleFireInputs(const std::shared_ptr<Player> &player, bool autofire, int controllerIndex);
+
+	// Maneja la continuación del jugador cuando no está jugando, permitiendo que continúe si se pulsa el botón de inicio.
+	void handlePlayerContinue(const std::shared_ptr<Player> &player);
+
+	// 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();
+
+	// 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 el transcurso normal del juego
+	void updateGame();
+
+	// Gestiona eventos para el estado del final del juego
+	void updateCompletedState();
+
+	// 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();
 
 public:
 	// Constructor
-	Game(int playerID, int currentStage, bool demo, JA_Music_t *music);
+	Game(int playerID, int current_stage, bool demo);
 
 	// Destructor
 	~Game();

source/game_logo.cpp

@@ -1,194 +1,175 @@
 #include "game_logo.h"
-#include <algorithm>         // for max
-#include <string>            // for basic_string
-#include "animated_sprite.h"  // for AnimatedSprite
-#include "asset.h"           // for Asset
-#include "jail_audio.h"      // for JA_DeleteSound, JA_LoadSound, JA_PlaySound
-#include "param.h"           // for param
-#include "screen.h"          // for Screen
-#include "smart_sprite.h"     // for SmartSprite
-#include "sprite.h"          // for Sprite
-#include "texture.h"         // for Texture
-#include "utils.h"           // for param_t, paramGame_t, paramTitle_t
+#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 "smart_sprite.h"    // Para SmartSprite
+#include "sprite.h"          // Para Sprite
+#include "texture.h"         // Para Texture
 
 // Constructor
 GameLogo::GameLogo(int x, int y)
+    : dust_texture_(Resource::get()->getTexture("title_dust.png")),
+      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)
 {
-    // Copia los punteros
-    screen = Screen::get();
-    renderer = screen->getRenderer();
-    asset = Asset::get();
-    this->x = x;
-    this->y = y;
-
-    // Crea los objetos
-    dustTexture = new Texture(renderer, asset->get("title_dust.png"));
-    coffeeTexture = new Texture(renderer, asset->get("title_coffee.png"));
-    crisisTexture = new Texture(renderer, asset->get("title_crisis.png"));
-    arcadeEditionTexture = new Texture(renderer, asset->get("title_arcade_edition.png"));
-
-    coffeeBitmap = new SmartSprite(coffeeTexture);
-    crisisBitmap = new SmartSprite(crisisTexture);
-    arcadeEditionBitmap = new Sprite((param.game.width - arcadeEditionTexture->getWidth()) / 2, param.title.arcadeEditionPosition, arcadeEditionTexture->getWidth(), arcadeEditionTexture->getHeight(), arcadeEditionTexture);
-    dustBitmapL = new AnimatedSprite(dustTexture, asset->get("title_dust.ani"));
-    dustBitmapR = new AnimatedSprite(dustTexture, asset->get("title_dust.ani"));
-
-    // Sonidos
-    crashSound = JA_LoadSound(asset->get("title.wav").c_str());
-
     // Inicializa las variables
     init();
 }
 
-// Destructor
-GameLogo::~GameLogo()
-{
-    delete dustTexture;
-    delete coffeeTexture;
-    delete crisisTexture;
-    delete arcadeEditionTexture;
-
-    delete coffeeBitmap;
-    delete crisisBitmap;
-    delete arcadeEditionBitmap;
-    delete dustBitmapL;
-    delete dustBitmapR;
-
-    JA_DeleteSound(crashSound);
-}
-
 // Inicializa las variables
 void GameLogo::init()
 {
-    const int xp = x - coffeeBitmap->getWidth() / 2;
-    const int desp = getInitialVerticalDesp();
-    
+    const auto xp = x_ - coffee_sprite_->getWidth() / 2;
+    const auto desp = getInitialVerticalDesp();
+
     // Variables
-    status = disabled;
-    shake.desp = 1;
-    shake.delay = 2;
-    shake.lenght = 8;
-    shake.remaining = shake.lenght;
-    shake.counter = shake.delay;
-    shake.origin = xp;
+    status_ = Status::DISABLED;
+    shake_.desp = 1;
+    shake_.delay = 2;
+    shake_.lenght = 8;
+    shake_.remaining = shake_.lenght;
+    shake_.counter = shake_.delay;
+    shake_.origin = xp;
 
     // Inicializa el bitmap de 'Coffee'
-    coffeeBitmap->init();
-    coffeeBitmap->setPosX(xp);
-    coffeeBitmap->setPosY(y - coffeeTexture->getHeight() - desp);
-    coffeeBitmap->setWidth(coffeeTexture->getWidth());
-    coffeeBitmap->setHeight(coffeeTexture->getHeight());
-    coffeeBitmap->setVelX(0.0f);
-    coffeeBitmap->setVelY(2.5f);
-    coffeeBitmap->setAccelX(0.0f);
-    coffeeBitmap->setAccelY(0.1f);
-    coffeeBitmap->setSpriteClip(0, 0, coffeeTexture->getWidth(), coffeeTexture->getHeight());
-    coffeeBitmap->setEnabled(true);
-    coffeeBitmap->setEnabledCounter(0);
-    coffeeBitmap->setDestX(xp);
-    coffeeBitmap->setDestY(y - coffeeTexture->getHeight());
+    coffee_sprite_->setPosX(xp);
+    coffee_sprite_->setPosY(y_ - coffee_texture_->getHeight() - desp);
+    coffee_sprite_->setWidth(coffee_texture_->getWidth());
+    coffee_sprite_->setHeight(coffee_texture_->getHeight());
+    coffee_sprite_->setVelX(0.0f);
+    coffee_sprite_->setVelY(2.5f);
+    coffee_sprite_->setAccelX(0.0f);
+    coffee_sprite_->setAccelY(0.1f);
+    coffee_sprite_->setSpriteClip(0, 0, coffee_texture_->getWidth(), coffee_texture_->getHeight());
+    coffee_sprite_->setEnabled(true);
+    coffee_sprite_->setFinishedCounter(0);
+    coffee_sprite_->setDestX(xp);
+    coffee_sprite_->setDestY(y_ - coffee_texture_->getHeight());
 
     // Inicializa el bitmap de 'Crisis'
-    crisisBitmap->init();
-    crisisBitmap->setPosX(xp + 15);
-    crisisBitmap->setPosY(y + desp);
-    crisisBitmap->setWidth(crisisTexture->getWidth());
-    crisisBitmap->setHeight(crisisTexture->getHeight());
-    crisisBitmap->setVelX(0.0f);
-    crisisBitmap->setVelY(-2.5f);
-    crisisBitmap->setAccelX(0.0f);
-    crisisBitmap->setAccelY(-0.1f);
-    crisisBitmap->setSpriteClip(0, 0, crisisTexture->getWidth(), crisisTexture->getHeight());
-    crisisBitmap->setEnabled(true);
-    crisisBitmap->setEnabledCounter(0);
-    crisisBitmap->setDestX(xp + 15);
-    crisisBitmap->setDestY(y);
+    crisis_sprite_->setPosX(xp + 15);
+    crisis_sprite_->setPosY(y_ + desp);
+    crisis_sprite_->setWidth(crisis_texture_->getWidth());
+    crisis_sprite_->setHeight(crisis_texture_->getHeight());
+    crisis_sprite_->setVelX(0.0f);
+    crisis_sprite_->setVelY(-2.5f);
+    crisis_sprite_->setAccelX(0.0f);
+    crisis_sprite_->setAccelY(-0.1f);
+    crisis_sprite_->setSpriteClip(0, 0, crisis_texture_->getWidth(), crisis_texture_->getHeight());
+    crisis_sprite_->setEnabled(true);
+    crisis_sprite_->setFinishedCounter(0);
+    crisis_sprite_->setDestX(xp + 15);
+    crisis_sprite_->setDestY(y_);
 
     // Inicializa el bitmap de 'DustRight'
-    dustBitmapR->resetAnimation();
-    dustBitmapR->setPosX(coffeeBitmap->getPosX() + coffeeBitmap->getWidth());
-    dustBitmapR->setPosY(y);
-    dustBitmapR->setWidth(16);
-    dustBitmapR->setHeight(16);
-    dustBitmapR->setFlip(SDL_FLIP_HORIZONTAL);
+    dust_right_sprite_->resetAnimation();
+    dust_right_sprite_->setPosX(coffee_sprite_->getPosX() + coffee_sprite_->getWidth());
+    dust_right_sprite_->setPosY(y_);
+    dust_right_sprite_->setWidth(16);
+    dust_right_sprite_->setHeight(16);
+    dust_right_sprite_->setFlip(SDL_FLIP_HORIZONTAL);
 
     // Inicializa el bitmap de 'DustLeft'
-    dustBitmapL->resetAnimation();
-    dustBitmapL->setPosX(coffeeBitmap->getPosX() - 16);
-    dustBitmapL->setPosY(y);
-    dustBitmapL->setWidth(16);
-    dustBitmapL->setHeight(16);
+    dust_left_sprite_->resetAnimation();
+    dust_left_sprite_->setPosX(coffee_sprite_->getPosX() - 16);
+    dust_left_sprite_->setPosY(y_);
+    dust_left_sprite_->setWidth(16);
+    dust_left_sprite_->setHeight(16);
 }
 
 // Pinta la clase en pantalla
 void GameLogo::render()
 {
     // Dibuja el logo
-    coffeeBitmap->render();
-    crisisBitmap->render();
+    coffee_sprite_->render();
+    crisis_sprite_->render();
 
-    if (status == finished)
-        arcadeEditionBitmap->render();
+    if (status_ == Status::FINISHED)
+        arcade_edition_sprite_->render();
 
     // Dibuja el polvillo del logo
-    dustBitmapR->render();
-    dustBitmapL->render();
+    dust_right_sprite_->render();
+    dust_left_sprite_->render();
 }
 
 // Actualiza la lógica de la clase
 void GameLogo::update()
 {
-    if (status == moving)
+    switch (status_)
     {
-        coffeeBitmap->update();
-        crisisBitmap->update();
+    case Status::MOVING:
+    {
+        coffee_sprite_->update();
+        crisis_sprite_->update();
 
         // Si los objetos han llegado a su destino, cambiamos de Sección
-        if (coffeeBitmap->hasFinished() && crisisBitmap->hasFinished())
+        if (coffee_sprite_->hasFinished() && crisis_sprite_->hasFinished())
         {
-            status = shaking;
-
-            // Pantallazo blanco
-            //screen->flash(flashColor, 10);
+            status_ = Status::SHAKING;
 
             // Reproduce el efecto sonoro
-            JA_PlaySound(crashSound);
+            JA_PlaySound(Resource::get()->getSound("title.wav"));
         }
+
+        break;
     }
 
-    else if (status == shaking)
+    case Status::SHAKING:
     {
         // Agita el logo
-        if (shake.remaining > 0)
+        if (shake_.remaining > 0)
         {
-            if (shake.counter > 0)
+            if (shake_.counter > 0)
             {
-                shake.counter--;
+                shake_.counter--;
             }
             else
             {
-                shake.counter = shake.delay;
-                const int desp = shake.remaining % 2 == 0 ? shake.desp * (-1) : shake.desp;
-                coffeeBitmap->setPosX(shake.origin + desp);
-                crisisBitmap->setPosX(shake.origin + desp + 15);
-                shake.remaining--;
+                shake_.counter = shake_.delay;
+                const auto desp = shake_.remaining % 2 == 0 ? shake_.desp * (-1) : shake_.desp;
+                coffee_sprite_->setPosX(shake_.origin + desp);
+                crisis_sprite_->setPosX(shake_.origin + desp + 15);
+                shake_.remaining--;
             }
         }
         else
         {
-            coffeeBitmap->setPosX(shake.origin);
-            crisisBitmap->setPosX(shake.origin + 15);
-            status = finished;
+            coffee_sprite_->setPosX(shake_.origin);
+            crisis_sprite_->setPosX(shake_.origin + 15);
+            status_ = Status::FINISHED;
         }
 
-        dustBitmapR->update();
-        dustBitmapL->update();
+        dust_right_sprite_->update();
+        dust_left_sprite_->update();
+
+        break;
     }
 
-    else if (status == finished)
+    case Status::FINISHED:
     {
-        dustBitmapR->update();
-        dustBitmapL->update();
+        dust_right_sprite_->update();
+        dust_left_sprite_->update();
+
+        break;
+    }
+
+    default:
+        break;
     }
 }
 
@@ -196,28 +177,28 @@ void GameLogo::update()
 void GameLogo::enable()
 {
     init();
-    status = moving;
+    status_ = Status::MOVING;
 }
 
 // Indica si ha terminado la animación
-bool GameLogo::hasFinished()
+bool GameLogo::hasFinished() const
 {
-    return (status == finished);
+    return status_ == Status::FINISHED;
 }
 
 // Recarga las texturas
 void GameLogo::reLoad()
 {
-    dustTexture->reLoad();
-    coffeeTexture->reLoad();
-    crisisTexture->reLoad();
+    dust_texture_->reLoad();
+    coffee_texture_->reLoad();
+    crisis_texture_->reLoad();
 }
 
 // Calcula el desplazamiento vertical inicial
 int GameLogo::getInitialVerticalDesp()
 {
-    int despUp = y;
-    int despDown = param.game.height - y;
+    auto desp_up = y_;
+    auto desp_down = param.game.height - y_;
 
-    return std::max(despUp, despDown);
+    return std::max(desp_up, desp_down);
 }

source/game_logo.h

@@ -1,51 +1,24 @@
 #pragma once
 
-#include <SDL2/SDL_render.h>  // for SDL_Renderer
-class AnimatedSprite;
-class Asset;
-class Screen;
-class SmartSprite;
-class Sprite;
-class Texture;
-struct JA_Sound_t;
+#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
 {
 private:
-    // Objetos y punteros
-    SDL_Renderer *renderer; // El renderizador de la ventana
-    Screen *screen;         // Objeto encargado de dibujar en pantalla
-    Asset *asset;           // Objeto que gestiona todos los ficheros de recursos
-
-    Texture *dustTexture;          // Textura con los graficos del polvo
-    Texture *coffeeTexture;        // Textura con los graficos de la palabra "COFFEE"
-    Texture *crisisTexture;        // Textura con los graficos de la plabra "CRISIS"
-    Texture *arcadeEditionTexture; // Textura con los graficos de "Arcade Edition"
-
-    AnimatedSprite *dustBitmapL; // Sprite con la el polvo que aparece al colisionar el texto de la pantalla de titulo
-    AnimatedSprite *dustBitmapR; // Sprite con la el polvo que aparece al colisionar el texto de la pantalla de titulo
-
-    SmartSprite *coffeeBitmap; // Sprite con la palabra "COFFEE" para la pantalla de titulo
-    SmartSprite *crisisBitmap; // Sprite con la palabra "CRISIS" para la pantalla de titulo
-
-    Sprite *arcadeEditionBitmap; // Sprite con los graficos de "Arcade Edition"
-
-    JA_Sound_t *crashSound; // Sonido con el impacto del título
-
-    // Variables
-    int x; // Posición donde dibujar el logo
-    int y; // Posición donde dibujar el logo
-
-    enum status_e
+    enum class Status
     {
-        disabled,
-        moving,
-        shaking,
-        finished
-    } status; // Estado en el que se encuentra la clase
+        DISABLED,
+        MOVING,
+        SHAKING,
+        FINISHED,
+    };
 
-    struct shake_t
+    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
@@ -53,7 +26,28 @@ private:
         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
-    } shake;           // Estructura para generar el efecto de agitación
+    };
+
+    // Objetos y punteros
+    std::shared_ptr<Texture> dust_texture_;           // Textura con los graficos del polvo
+    std::shared_ptr<Texture> coffee_texture_;         // Textura con los graficos de la palabra "COFFEE"
+    std::shared_ptr<Texture> crisis_texture_;         // Textura con los graficos de la plabra "CRISIS"
+    std::shared_ptr<Texture> arcade_edition_texture_; // Textura con los graficos de "Arcade Edition"
+
+    std::unique_ptr<AnimatedSprite> dust_left_sprite_;  // Sprite con la el polvo que aparece al colisionar el texto de la pantalla de titulo
+    std::unique_ptr<AnimatedSprite> dust_right_sprite_; // Sprite con la el polvo que aparece al colisionar el texto de la pantalla de titulo
+
+    std::unique_ptr<SmartSprite> coffee_sprite_; // Sprite con la palabra "COFFEE" para la pantalla de titulo
+    std::unique_ptr<SmartSprite> crisis_sprite_; // Sprite con la palabra "CRISIS" para la pantalla de titulo
+
+    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
+
+    Status status_; // Estado en el que se encuentra la clase
+    Shake shake_;   // Estructura para generar el efecto de agitación
 
     // Inicializa las variables
     void init();
@@ -66,7 +60,7 @@ public:
     GameLogo(int x, int y);
 
     // Destructor
-    ~GameLogo();
+    ~GameLogo() = default;
 
     // Pinta la clase en pantalla
     void render();
@@ -78,7 +72,7 @@ public:
     void enable();
 
     // Indica si ha terminado la animación
-    bool hasFinished();
+    bool hasFinished() const;
 
     // Recarga las texturas
     void reLoad();

source/global_inputs.cpp

@@ -1,94 +1,220 @@
 #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 "options.h"    // for options
-#include "on_screen_help.h"
-#include "screen.h"  // for Screen
-#include "section.h" // for options_e, name, name_e, options
-#include "utils.h"   // for op_audio_t, options_t, op_music_t, boolToOnOff
+#include <string>           // Para operator+, string
+#include "input.h"          // Para Input, InputType, INPUT_DO_NOT_ALLOW_REPEAT
+#include "jail_audio.h"     // Para JA_EnableMusic, JA_EnableSound
+#include "lang.h"           // Para getText
+#include "notifier.h"       // Para Notifier
+#include "on_screen_help.h" // Para OnScreenHelp
+#include "options.h"        // Para Options, OptionsAudio, options, OptionsM...
+#include "section.h"        // Para Name, Options, name, options
+#include "utils.h"          // Para boolToOnOff, stringInVector
+#include "screen.h"
 
-// Termina
-void quit(section::options_e code)
+namespace globalInputs
 {
-    if (Screen::get()->notificationsAreActive())
-    {
-        section::name = section::NAME_QUIT;
-        section::options = code;
-    }
-    else
-    {
-        Screen::get()->showNotification(lang::getText(94));
-    }
-}
+    // Variables
+    std::vector<int> service_pressed_counter;
 
-// Reinicia
-void reset()
-{
-    section::name = section::NAME_INIT;
-    Screen::get()->showNotification("Reset");
-}
-
-// Activa o desactiva el audio
-void switchAudio()
-{
-    options.audio.sound.enabled = options.audio.music.enabled = !options.audio.music.enabled;
-    JA_EnableMusic(options.audio.music.enabled);
-    JA_EnableSound(options.audio.sound.enabled);
-    Screen::get()->showNotification("Audio " + boolToOnOff(options.audio.music.enabled));
-}
-
-// Comprueba los inputs que se pueden introducir en cualquier sección del juego
-void checkGlobalInputs()
-{
-    // Comprueba si se sale con el teclado
-    if (Input::get()->checkInput(input_exit, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
+    // Inicializa variables
+    void init()
     {
-        quit(section::OPTIONS_QUIT_NORMAL);
-        return;
-    }
-
-    // Comprueba si se va a resetear el juego
-    else if (Input::get()->checkInput(input_reset, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
-    {
-        reset();
-        return;
-    }
-
-    else if (Input::get()->checkInput(input_mute, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
-    {
-        switchAudio();
-        return;
-    }
-
-    else if (Input::get()->checkInput(input_service, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
-    {
-        OnScreenHelp::get()->toggleState();
-        return;
-    }
-
-    for (int i = 0; i < Input::get()->getNumControllers(); ++i)
-    {
-        // Comprueba si se sale con el mando
-        if (Input::get()->checkModInput(input_service, input_exit, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+        const auto num_inputs = Input::get()->getNumControllers() + 1;
+        service_pressed_counter.reserve(num_inputs);
+        for (int i = 0; i < num_inputs; ++i)
         {
-            quit(section::OPTIONS_QUIT_SHUTDOWN);
-            return;
+            service_pressed_counter.push_back(0);
+        }
+    }
+
+    // Termina
+    void quit(section::Options code)
+    {
+        const std::string exit_code = "QUIT";
+        auto code_found = stringInVector(Notifier::get()->getCodes(), exit_code);
+        if (code_found)
+        {
+            section::name = section::Name::QUIT;
+            section::options = code;
+        }
+        else
+        {
+#ifdef ARCADE
+            const int index = code == section::Options::QUIT_WITH_CONTROLLER ? 116 : 94;
+            Notifier::get()->showText({lang::getText(index), std::string()}, -1, exit_code);
+#else
+            Notifier::get()->showText({lang::getText(94), std::string()}, -1, exit_code);
+#endif
+        }
+    }
+
+    // Reinicia
+    void reset()
+    {
+        section::name = section::Name::INIT;
+        Notifier::get()->showText({"Reset"});
+    }
+
+    // Activa o desactiva el audio
+    void toggleAudio()
+    {
+        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)});
+    }
+
+    // Comprueba los inputs que se pueden introducir en cualquier sección del juego
+    void check()
+    {
+        // Teclado
+        {
+#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))
+            {
+                Screen::get()->toggleVideoMode();
+                const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? "Window" : "Fullscreen";
+                Notifier::get()->showText({mode + " mode"});
+                return;
+            }
+
+            // 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;
+            }
+
+            // Audio
+            if (Input::get()->checkInput(InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
+            {
+                toggleAudio();
+                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_counter[0]++;
+
+                if (service_pressed_counter[0] >= 3000)
+                {
+                    OnScreenHelp::get()->toggleState();
+                    service_pressed_counter[0] = 0;
+                }
+                return;
+            }
+
+            service_pressed_counter[0] = 0;
         }
 
-        // Comprueba si se va a resetear el juego
-        else if (Input::get()->checkModInput(input_service, input_reset, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+        // Mandos
         {
-            reset();
-            return;
-        }
+            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))
+                {
+                    quit(section::Options::QUIT_WITH_CONTROLLER);
+                    return;
+                }
 
-        // Comprueba si se va a activar o desactivar el audio
-        else if (Input::get()->checkModInput(input_service, input_mute, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
-        {
-            switchAudio();
-            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_counter[i + 1]++;
+
+                    if (service_pressed_counter[i + 1] >= 3000)
+                    {
+                        OnScreenHelp::get()->toggleState();
+                        service_pressed_counter[i + 1] = 0;
+                    }
+                    return;
+                }
+
+                service_pressed_counter[i + 1] = 0;
+            }
         }
     }
 }

source/global_inputs.h

@@ -1,2 +1,11 @@
-// Comprueba los inputs que se pueden introducir en cualquier sección del juego
-void checkGlobalInputs();
+#include <vector>
+namespace globalInputs
+{
+    extern std::vector<int> service_pressed_counter;
+
+    // Inicializa variables
+    void init();
+
+    // Comprueba los inputs que se pueden introducir en cualquier sección del juego
+    void check();
+}

source/hiscore_table.cpp

@@ -1,62 +1,52 @@
 #include "hiscore_table.h"
-#include <SDL2/SDL_blendmode.h>  // for SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_pixels.h>     // for SDL_PIXELFORMAT_RGBA8888
-#include <SDL2/SDL_timer.h>      // for SDL_GetTicks
-#include <SDL2/SDL_video.h>      // for SDL_WINDOWEVENT_SIZE_CHANGED
-#include <algorithm>             // for max
-#include <vector>                // for vector
-#include "asset.h"               // for Asset
-#include "background.h"          // for Background
-#include "fade.h"                // for Fade, FADE_IN, FADE_OUT, FADE_RANDOM...
-#include "global_inputs.h"       // for checkGlobalInputs
-#include "input.h"               // for Input
-#include "jail_audio.h"          // for JA_GetMusicState, JA_Music_state
-#include "lang.h"                // for getText
-#include "options.h"             // for options
-#include "param.h"               // for param
-#include "screen.h"              // for Screen
-#include "text.h"                // for Text, TXT_CENTER, TXT_SHADOW, TXT_COLOR
-#include "utils.h"               // for param_t, paramGame_t, hiScoreEntry_t
+#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 <SDL2/SDL_video.h>		  // Para SDL_WINDOWEVENT_SIZE_CHANGED
+#include <algorithm>			  // Para max
+#include <vector>				  // Para vector
+#include "background.h"			  // Para Background
+#include "fade.h"				  // Para Fade, FadeMode, FadeType
+#include "global_inputs.h"		  // Para check
+#include "input.h"				  // Para Input
+#include "jail_audio.h"			  // Para JA_GetMusicState, JA_Music_state
+#include "lang.h"				  // Para getText
+#include "manage_hiscore_table.h" // Para HiScoreEntry
+#include "options.h"			  // Para Options, OptionsGame, options
+#include "param.h"				  // Para Param, param, ParamGame, ParamFade
+#include "resource.h"			  // Para Resource
+#include "screen.h"				  // Para Screen
+#include "section.h"			  // Para Name, name, Options, options
+#include "text.h"				  // Para Text, TEXT_CENTER, TEXT_SHADOW
+#include "utils.h"				  // Para Color, Zone, fade_color, orange_color
 
 // Constructor
-HiScoreTable::HiScoreTable(JA_Music_t *music)
+HiScoreTable::HiScoreTable()
+	: renderer_(Screen::get()->getRenderer()),
+	  backbuffer_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
+	  fade_(std::make_unique<Fade>()),
+	  background_(std::make_unique<Background>()),
+	  text_(Resource::get()->getText("smb2")),
+	  counter_(0),
+	  ticks_(0),
+	  view_area_({0, 0, param.game.width, param.game.height}),
+	  fade_mode_(FadeMode::IN)
 {
-	// Copia punteros
-	this->music = music;
-	asset = Asset::get();
-	input = Input::get();
-	screen = Screen::get();
-	renderer = screen->getRenderer();
-
-	// Objetos
-	eventHandler = new SDL_Event();
-	fade = new Fade(renderer);
-	background = new Background(renderer);
-	text = new Text(asset->get("smb2.gif"), asset->get("smb2.txt"), renderer);
-
-	// Crea un backbuffer para el renderizador
-	backbuffer = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
-	SDL_SetTextureBlendMode(backbuffer, SDL_BLENDMODE_BLEND);
-
-	// Inicializa variables
-	section::name = section::NAME_HI_SCORE_TABLE;
-	ticks = 0;
-	ticksSpeed = 15;
-	counter = 0;
-	counterEnd = 800;
-	viewArea = {0, 0, param.game.width, param.game.height};
-	fadeMode = FADE_IN;
+	// Inicializa el resto de variables
+	section::name = section::Name::HI_SCORE_TABLE;
 
 	// Inicializa objetos
-	background->setPos(param.game.gameArea.rect);
-	background->setCloudsSpeed(-0.1f);
-	background->setGradientNumber(1);
-	background->setTransition(0.8f);
-	fade->setColor(fadeColor.r, fadeColor.g, fadeColor.b);
-	fade->setType(FADE_RANDOM_SQUARE);
-	fade->setPost(param.fade.postDuration);
-	fade->setMode(fadeMode);
-	fade->activate();
+	SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
+	background_->setPos(param.game.game_area.rect);
+	background_->setCloudsSpeed(-0.1f);
+	background_->setGradientNumber(1);
+	background_->setTransition(0.8f);
+	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
+	fade_->setType(FadeType::RANDOM_SQUARE);
+	fade_->setPost(param.fade.post_duration);
+	fade_->setMode(fade_mode_);
+	fade_->activate();
 
 	// Crea el contenido de la textura con la lista de puntuaciones
 	fillTexture();
@@ -65,47 +55,46 @@ HiScoreTable::HiScoreTable(JA_Music_t *music)
 // Destructor
 HiScoreTable::~HiScoreTable()
 {
-	delete text;
-	delete eventHandler;
-	delete background;
-
-	SDL_DestroyTexture(backbuffer);
+	SDL_DestroyTexture(backbuffer_);
 }
 
 // Actualiza las variables
 void HiScoreTable::update()
 {
-	// Actualiza las variables
-	if (SDL_GetTicks() - ticks > ticksSpeed)
+	constexpr int TICKS_SPEED = 15;
+
+	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		// Actualiza el contador de ticks
-		ticks = SDL_GetTicks();
+		ticks_ = SDL_GetTicks();
 
 		// Mantiene la música sonando
 		if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
-			JA_PlayMusic(music);
+		{
+			JA_PlayMusic(Resource::get()->getMusic("title.ogg"));
+		}
 
 		// Actualiza el objeto screen
-		screen->update();
+		Screen::get()->update();
 
 		// Actualiza el fondo
-		background->update();
+		background_->update();
 
 		// Gestiona el fade
 		updateFade();
 
 		// Gestiona el contador y sus eventos
-		counter++;
+		counter_++;
 
-		if (counter == 150)
+		if (counter_ == 150)
 		{
-			background->setColor({0, 0, 0});
-			background->setAlpha(96);
+			background_->setColor(Color(0, 0, 0));
+			background_->setAlpha(96);
 		}
 
-		if (counter == counterEnd)
+		if (counter_ == COUNTER_END_)
 		{
-			fade->activate();
+			fade_->activate();
 		}
 	}
 }
@@ -113,70 +102,71 @@ void HiScoreTable::update()
 // Crea el contenido de la textura con la lista de puntuaciones
 void HiScoreTable::fillTexture()
 {
-	// hay 27 letras - 7 de puntos quedan 20 caracteres 20 - nameLenght 0 numDots
-	const int maxNames = 10;
-	const int spaceBetweenHeader = 32;
-	const int spaceBetweenLines = text->getCharacterSize() * 2.0f;
-	const int size = spaceBetweenHeader + spaceBetweenLines * (maxNames - 1) + text->getCharacterSize();
-	const int firstLine = (param.game.height - size) / 2;
+	// hay 27 letras - 7 de puntos quedan 20 caracteres 20 - name_lenght 0 num_dots
+	constexpr auto max_names = 10;
+	constexpr auto space_between_header = 32;
+	const auto space_between_lines = text_->getCharacterSize() * 2.0f;
+	const auto size = space_between_header + space_between_lines * (max_names - 1) + text_->getCharacterSize();
+	const auto first_line = (param.game.height - size) / 2;
 
 	// Pinta en el backbuffer el texto y los sprites
-	SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-	SDL_SetRenderTarget(renderer, backbuffer);
-	SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
-	SDL_RenderClear(renderer);
+	auto temp = SDL_GetRenderTarget(renderer_);
+	SDL_SetRenderTarget(renderer_, backbuffer_);
+	SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
+	SDL_RenderClear(renderer_);
 
 	// Escribe el texto: Mejores puntuaciones
-	text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, param.game.gameArea.centerX, firstLine, lang::getText(42), 1, orangeColor, 1, shdwTxtColor);
+	text_->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, first_line, lang::getText(42), 1, orange_color, 1, shdw_txt_color);
 
 	// Escribe los nombres de la tabla de puntuaciones
-	for (int i = 0; i < maxNames; ++i)
+	for (int i = 0; i < max_names; ++i)
 	{
-		const int nameLenght = options.game.hiScoreTable[i].name.length();
-		const std::string score = format(options.game.hiScoreTable[i].score);
-		const int scoreLenght = score.size();
-		const int numDots = 25 - nameLenght - scoreLenght;
-		std::string dots = "";
-		for (int j = 0; j < numDots; ++j)
+		const auto name_lenght = options.game.hi_score_table[i].name.length();
+		const auto score = format(options.game.hi_score_table[i].score);
+		const auto score_lenght = score.size();
+		const auto num_dots = 25 - name_lenght - score_lenght;
+		std::string dots;
+		for (int j = 0; j < (int)num_dots; ++j)
 		{
 			dots = dots + ".";
 		}
-		const std::string line = options.game.hiScoreTable[i].name + dots + score;
-		text->writeDX(TXT_CENTER | TXT_SHADOW, param.game.gameArea.centerX, (i * spaceBetweenLines) + firstLine + spaceBetweenHeader, line, 1, orangeColor, 1, shdwTxtColor);
+		const auto line = options.game.hi_score_table[i].name + dots + score;
+		text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, (i * space_between_lines) + first_line + space_between_header, line, 1, orange_color, 1, shdw_txt_color);
 	}
 
 	// Cambia el destino de renderizado
-	SDL_SetRenderTarget(renderer, temp);
+	SDL_SetRenderTarget(renderer_, temp);
 }
 
 // Pinta en pantalla
 void HiScoreTable::render()
 {
 	// Prepara para empezar a dibujar en la textura de juego
-	screen->start();
+	Screen::get()->start();
 
 	// Limpia la pantalla
-	screen->clean(bgColor);
+	Screen::get()->clean(bg_color);
 
 	// Pinta el fondo
-	background->render();
+	background_->render();
 
 	// Establece la ventana del backbuffer
-	viewArea.y = std::max(0, param.game.height - counter + 100);
+	view_area_.y = std::max(0, param.game.height - counter_ + 100);
 
 	// Copia el backbuffer al renderizador
-	SDL_RenderCopy(renderer, backbuffer, nullptr, &viewArea);
+	SDL_RenderCopy(renderer_, backbuffer_, nullptr, &view_area_);
 
-	fade->render();
+	// Renderiza el fade
+	fade_->render();
 
 	// Vuelca el contenido del renderizador en pantalla
-	screen->blit();
+	Screen::get()->blit();
 }
 
 // Recarga todas las texturas
 void HiScoreTable::reloadTextures()
 {
-	text->reLoadTexture();
+	text_->reLoadTexture();
 	fillTexture();
 }
 
@@ -184,19 +174,21 @@ void HiScoreTable::reloadTextures()
 void HiScoreTable::checkEvents()
 {
 	// Comprueba los eventos que hay en la cola
-	while (SDL_PollEvent(eventHandler) != 0)
+	SDL_Event event;
+	while (SDL_PollEvent(&event))
 	{
 		// Evento de salida de la aplicación
-		if (eventHandler->type == SDL_QUIT)
+		if (event.type == SDL_QUIT)
 		{
-			section::name = section::NAME_QUIT;
+			section::name = section::Name::QUIT;
+			section::options = section::Options::QUIT_FROM_EVENT;
 			break;
 		}
 
 		// Comprueba si se ha cambiado el tamaño de la ventana
-		else if (eventHandler->type == SDL_WINDOWEVENT)
+		else if (event.type == SDL_WINDOWEVENT)
 		{
-			if (eventHandler->window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
+			if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
 			{
 				reloadTextures();
 			}
@@ -208,25 +200,22 @@ void HiScoreTable::checkEvents()
 void HiScoreTable::checkInput()
 {
 	// Comprueba si se ha pulsado cualquier botón (de los usados para jugar)
-	if (input->checkAnyButtonPressed())
+	if (Input::get()->checkAnyButtonPressed())
 	{
 		JA_StopMusic();
-		section::name = section::NAME_TITLE;
-		section::options = section::OPTIONS_TITLE_1;
+		section::name = section::Name::TITLE;
+		section::options = section::Options::TITLE_1;
 		return;
 	}
 
-	// Comprueba el input para el resto de objetos
-	screen->checkInput();
-
 	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
-	checkGlobalInputs();
+	globalInputs::check();
 }
 
 // Bucle para la pantalla de instrucciones
 void HiScoreTable::run()
 {
-	while (section::name == section::NAME_HI_SCORE_TABLE)
+	while (section::name == section::Name::HI_SCORE_TABLE)
 	{
 		checkInput();
 		update();
@@ -235,62 +224,21 @@ void HiScoreTable::run()
 	}
 }
 
-// Transforma un valor numérico en una cadena de 6 cifras
-std::string HiScoreTable::scoreToString(int num)
-{
-	if ((num >= 0) && (num <= 9))
-	{
-		return ("000000" + std::to_string(num));
-	}
-
-	if ((num >= 10) && (num <= 99))
-	{
-		return ("00000" + std::to_string(num));
-	}
-
-	if ((num >= 100) && (num <= 999))
-	{
-		return ("0000" + std::to_string(num));
-	}
-
-	if ((num >= 1000) && (num <= 9999))
-	{
-		return ("000" + std::to_string(num));
-	}
-
-	if ((num >= 010000) && (num <= 99999))
-	{
-		return ("00" + std::to_string(num));
-	}
-
-	if ((num >= 100000) && (num <= 999999))
-	{
-		return ("0" + std::to_string(num));
-	}
-
-	if ((num >= 1000000) && (num <= 9999999))
-	{
-		return (std::to_string(num));
-	}
-
-	return (std::to_string(num));
-}
-
 // Gestiona el fade
 void HiScoreTable::updateFade()
 {
-	fade->update();
+	fade_->update();
 
-	if (fade->hasEnded() && fadeMode == FADE_IN)
+	if (fade_->hasEnded() && fade_mode_ == FadeMode::IN)
 	{
-		fade->reset();
-		fadeMode = FADE_OUT;
-		fade->setMode(fadeMode);
+		fade_->reset();
+		fade_mode_ = FadeMode::OUT;
+		fade_->setMode(fade_mode_);
 	}
 
-	if (fade->hasEnded() && fadeMode == FADE_OUT)
+	if (fade_->hasEnded() && fade_mode_ == FadeMode::OUT)
 	{
-		section::name = section::NAME_INSTRUCTIONS;
+		section::name = section::Name::INSTRUCTIONS;
 	}
 }
 
@@ -300,9 +248,9 @@ std::string HiScoreTable::format(int number)
 	const std::string separator = ".";
 	const std::string score = std::to_string(number);
 
-	int index = (int)score.size() - 1;
-	std::string result = "";
-	int i = 0;
+	auto index = (int)score.size() - 1;
+	std::string result;
+	auto i = 0;
 	while (index >= 0)
 	{
 		result = score.at(index) + result;

source/hiscore_table.h

@@ -1,18 +1,14 @@
 #pragma once
 
-#include <SDL2/SDL_events.h>  // for SDL_Event
-#include <SDL2/SDL_rect.h>    // for SDL_Rect
-#include <SDL2/SDL_render.h>  // for SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h>  // for Uint16, Uint32
-#include <string>             // for string
-#include "section.h"          // for options_e
-class Asset;
-class Background;
-class Fade;
-class Input;
-class Screen;
-class Text;
-struct JA_Music_t;
+#include <SDL2/SDL_rect.h>	 // para SDL_Rect
+#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_stdinc.h> // para Uint16, Uint32, Uint8
+#include <memory>			 // para unique_ptr
+#include <string>			 // para string
+class Background;			 // lines 8-8
+class Fade;					 // lines 9-9
+class Text;					 // lines 10-10
+enum class FadeMode : Uint8; // lines 11-11
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de mostrar la tabla con las puntuaciones
@@ -28,25 +24,22 @@ struct JA_Music_t;
 class HiScoreTable
 {
 private:
+	// Constantes
+	static constexpr Uint16 COUNTER_END_ = 800; // Valor final para el contador
+
 	// Objetos y punteros
-	SDL_Renderer *renderer;	 // El renderizador de la ventana
-	Screen *screen;			 // Objeto encargado de dibujar en pantalla
-	SDL_Event *eventHandler; // Manejador de eventos
-	SDL_Texture *backbuffer; // Textura para usar como backbuffer
-	Asset *asset;			 // Objeto que gestiona todos los ficheros de recursos
-	Input *input;			 // Objeto pata gestionar la entrada
-	Background *background;	 // Objeto para dibujar el fondo del juego
-	Fade *fade;				 // Objeto para renderizar fades
-	Text *text;				 // Objeto para escribir texto
-	JA_Music_t *music;		 // Musica de fondo
+	SDL_Renderer *renderer_;  // El renderizador de la ventana
+	SDL_Texture *backbuffer_; // Textura para usar como backbuffer
+
+	std::unique_ptr<Fade> fade_;			 // Objeto para renderizar fades
+	std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego
+	std::shared_ptr<Text> text_;			 // Objeto para escribir texto
 
 	// Variables
-	Uint16 counter;	   // Contador
-	Uint16 counterEnd; // Valor final para el contador
-	Uint32 ticks;	   // Contador de ticks para ajustar la velocidad del programa
-	Uint32 ticksSpeed; // Velocidad a la que se repiten los bucles del programa
-	SDL_Rect viewArea; // Parte de la textura que se muestra en pantalla
-	int fadeMode;	   // Modo de fade a utilizar
+	Uint16 counter_;	 // Contador
+	Uint32 ticks_;		 // Contador de ticks para ajustar la velocidad del programa
+	SDL_Rect view_area_; // Parte de la textura que se muestra en pantalla
+	FadeMode fade_mode_; // Modo de fade a utilizar
 
 	// Actualiza las variables
 	void update();
@@ -63,9 +56,6 @@ private:
 	// Convierte un entero a un string con separadores de miles
 	std::string format(int number);
 
-	// Transforma un valor numérico en una cadena de 6 cifras
-	std::string scoreToString(int num);
-
 	// Crea el contenido de la textura con la lista de puntuaciones
 	void fillTexture();
 
@@ -75,12 +65,9 @@ private:
 	// Gestiona el fade
 	void updateFade();
 
-	// Termina
-	void quit(section::options_e code);
-
 public:
 	// Constructor
-	HiScoreTable(JA_Music_t *music);
+	HiScoreTable();
 
 	// Destructor
 	~HiScoreTable();

source/input.cpp

@@ -1,353 +1,165 @@
 #include "input.h"
-#include <SDL2/SDL.h>           // for SDL_INIT_GAMECONTROLLER, SDL_InitSubS...
-#include <SDL2/SDL_error.h>     // for SDL_GetError
-#include <SDL2/SDL_events.h>    // for SDL_ENABLE
-#include <SDL2/SDL_keyboard.h>  // for SDL_GetKeyboardState
-#include <iostream>             // for basic_ostream, operator<<, cout, basi...
+#include <SDL2/SDL.h>		   // Para SDL_INIT_GAMECONTROLLER, SDL_InitSubS...
+#include <SDL2/SDL_error.h>	   // Para SDL_GetError
+#include <SDL2/SDL_events.h>   // Para SDL_ENABLE
+#include <SDL2/SDL_keyboard.h> // Para SDL_GetKeyboardState
+#include <algorithm>		   // Para find
+#include <iostream>			   // Para basic_ostream, operator<<, cout, endl
+#include <iterator>			   // Para distance
+#include <unordered_map>	   // Para unordered_map, operator==, _Node_cons...
+#include <utility>			   // Para pair
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
-Input *Input::input = nullptr;
+Input *Input::input_ = nullptr;
 
 // [SINGLETON] Crearemos el objeto input con esta función estática
-void Input::init(std::string file)
+void Input::init(const std::string &game_controller_db_path)
 {
-    Input::input = new Input(file);
+	Input::input_ = new Input(game_controller_db_path);
 }
 
 // [SINGLETON] Destruiremos el objeto input con esta función estática
 void Input::destroy()
 {
-    delete Input::input;
+	delete Input::input_;
 }
 
 // [SINGLETON] Con este método obtenemos el objeto input y podemos trabajar con él
 Input *Input::get()
 {
-    return Input::input;
+	return Input::input_;
 }
 
 // Constructor
-Input::Input(std::string file)
+Input::Input(const std::string &game_controller_db_path)
+	: game_controller_db_path_(game_controller_db_path)
 {
-	// Inicializa variables
-	verbose = false;
-	enabled = true;
-
-	// Fichero gamecontrollerdb.txt
-	dbPath = file;
-
 	// Busca si hay mandos conectados
 	discoverGameControllers();
 
-	// Inicializa las vectores
-	keyBindings_t kb;
-	kb.scancode = 0;
-	kb.active = false;
-	keyBindings.resize(input_number_of_inputs, kb);
-
-	GameControllerBindings_t gcb;
-	gcb.button = SDL_CONTROLLER_BUTTON_INVALID;
-	gcb.active = false;
-	gameControllerBindings.resize(numGamepads);
-	for (int i = 0; i < numGamepads; ++i)
-	{
-		gameControllerBindings[i].resize(input_number_of_inputs, gcb);
-	}
-
-	// Listado de los inputs usados para jugar, excluyendo botones para la interfaz
-	gameInputs.clear();
-	gameInputs.push_back(input_fire_left);
-	gameInputs.push_back(input_fire_center);
-	gameInputs.push_back(input_fire_right);
-	gameInputs.push_back(input_up);
-	gameInputs.push_back(input_down);
-	gameInputs.push_back(input_left);
-	gameInputs.push_back(input_right);
+	// Inicializa los vectores
+	key_bindings_.resize(static_cast<int>(InputType::NUMBER_OF_INPUTS), KeyBindings());
+	controller_bindings_.resize(num_gamepads_, std::vector<ControllerBindings>(static_cast<int>(InputType::NUMBER_OF_INPUTS), ControllerBindings()));
 
 	// Listado de los inputs para jugar que utilizan botones, ni palancas ni crucetas
-	buttonInputs.clear();
-	buttonInputs.push_back(input_fire_left);
-	buttonInputs.push_back(input_fire_center);
-	buttonInputs.push_back(input_fire_right);
-	buttonInputs.push_back(input_start);
-}
-
-// Destructor
-Input::~Input()
-{
-	
-}
-
-// Actualiza el estado del objeto
-void Input::update()
-{
-	if (disabledUntil == d_keyPressed && !checkAnyInput())
-	{
-		enable();
-	}
+	button_inputs_ = {InputType::FIRE_LEFT, InputType::FIRE_CENTER, InputType::FIRE_RIGHT, InputType::START};
 }
 
 // Asigna inputs a teclas
-void Input::bindKey(inputs_e input, SDL_Scancode code)
+void Input::bindKey(InputType input, SDL_Scancode code)
 {
-	keyBindings[input].scancode = code;
+	key_bindings_.at(static_cast<int>(input)).scancode = code;
 }
 
 // Asigna inputs a botones del mando
-void Input::bindGameControllerButton(int index, inputs_e input, SDL_GameControllerButton button)
+void Input::bindGameControllerButton(int controller_index, InputType input, SDL_GameControllerButton button)
 {
-	if (index < numGamepads)
+	if (controller_index < num_gamepads_)
 	{
-		gameControllerBindings[index][input].button = button;
+		controller_bindings_.at(controller_index).at(static_cast<int>(input)).button = button;
 	}
 }
 
 // Asigna inputs a botones del mando
-void Input::bindGameControllerButton(int index, inputs_e inputTarget, inputs_e inputSource)
+void Input::bindGameControllerButton(int controller_index, InputType input_target, InputType input_source)
 {
-	if (index < numGamepads)
+	if (controller_index < num_gamepads_)
 	{
-		gameControllerBindings[index][inputTarget].button = gameControllerBindings[index][inputSource].button;
+		controller_bindings_.at(controller_index).at(static_cast<int>(input_target)).button = controller_bindings_.at(controller_index).at(static_cast<int>(input_source)).button;
 	}
 }
 
 // Comprueba si un input esta activo
-bool Input::checkInput(inputs_e input, bool repeat, int device, int index)
+bool Input::checkInput(InputType input, bool repeat, InputDeviceToUse device, int controller_index)
 {
-	if (!enabled)
-	{
-		return false;
-	}
+	bool success_keyboard = false;
+	bool success_controller = false;
+	const int input_index = static_cast<int>(input);
 
-	bool successKeyboard = false;
-	bool successGameController = false;
-
-	if (device == INPUT_USE_ANY)
-	{
-		index = 0;
-	}
-
-	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
+	if (device == InputDeviceToUse::KEYBOARD || device == InputDeviceToUse::ANY)
 	{
 		const Uint8 *keyStates = SDL_GetKeyboardState(nullptr);
 
 		if (repeat)
 		{
-			if (keyStates[keyBindings[input].scancode] != 0)
-			{
-				successKeyboard = true;
-			}
-			else
-			{
-				successKeyboard = false;
-			}
+			success_keyboard = keyStates[key_bindings_[input_index].scancode] != 0;
 		}
 		else
 		{
-			if (!keyBindings[input].active)
+			if (!key_bindings_[input_index].active)
 			{
-				if (keyStates[keyBindings[input].scancode] != 0)
+				if (keyStates[key_bindings_[input_index].scancode] != 0)
 				{
-					keyBindings[input].active = true;
-					successKeyboard = true;
+					key_bindings_[input_index].active = true;
+					success_keyboard = true;
 				}
 				else
 				{
-					successKeyboard = false;
+					success_keyboard = false;
 				}
 			}
 			else
 			{
-				if (keyStates[keyBindings[input].scancode] == 0)
+				if (keyStates[key_bindings_[input_index].scancode] == 0)
 				{
-					keyBindings[input].active = false;
-					successKeyboard = false;
-				}
-				else
-				{
-					successKeyboard = false;
+					key_bindings_[input_index].active = false;
 				}
+				success_keyboard = false;
 			}
 		}
 	}
 
-	if (gameControllerFound() &&  index < numGamepads)
-		if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY))
+	if (gameControllerFound() && controller_index >= 0 && controller_index < num_gamepads_)
+		if ((device == InputDeviceToUse::CONTROLLER) || (device == InputDeviceToUse::ANY))
 		{
-			successGameController = checkAxisInput(input, index);
-			if (!successGameController)
+			success_controller = checkAxisInput(input, controller_index);
+			if (!success_controller)
 			{
 				if (repeat)
 				{
-					if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0)
-					{
-						successGameController = true;
-					}
-					else
-					{
-						successGameController = false;
-					}
+					success_controller = SDL_GameControllerGetButton(connected_controllers_.at(controller_index), controller_bindings_.at(controller_index).at(input_index).button) != 0;
 				}
 				else
 				{
-					if (!gameControllerBindings[index][input].active)
+					if (!controller_bindings_.at(controller_index).at(input_index).active)
 					{
-						if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0)
+						if (SDL_GameControllerGetButton(connected_controllers_.at(controller_index), controller_bindings_.at(controller_index).at(input_index).button) != 0)
 						{
-							gameControllerBindings[index][input].active = true;
-							successGameController = true;
+							controller_bindings_.at(controller_index).at(input_index).active = true;
+							success_controller = true;
 						}
 						else
 						{
-							successGameController = false;
+							success_controller = false;
 						}
 					}
 					else
 					{
-						if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) == 0)
+						if (SDL_GameControllerGetButton(connected_controllers_.at(controller_index), controller_bindings_.at(controller_index).at(input_index).button) == 0)
 						{
-							gameControllerBindings[index][input].active = false;
-							successGameController = false;
-						}
-						else
-						{
-							successGameController = false;
+							controller_bindings_.at(controller_index).at(input_index).active = false;
 						}
+						success_controller = false;
 					}
 				}
 			}
 		}
 
-	return (successKeyboard || successGameController);
-}
-
-// Comprueba si un input con modificador esta activo
-bool Input::checkModInput(inputs_e inputMod, inputs_e input, bool repeat, int device, int index)
-{
-	if (!enabled || index >= numGamepads || !checkInput(inputMod, INPUT_ALLOW_REPEAT, device, index))
-	{
-		return false;
-	}
-
-	bool successKeyboard = false;
-	bool successGameController = false;
-
-	if (device == INPUT_USE_ANY)
-	{
-		index = 0;
-	}
-
-	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
-	{
-		const Uint8 *keyStates = SDL_GetKeyboardState(nullptr);
-
-		if (repeat)
-		{
-			if (keyStates[keyBindings[input].scancode] != 0)
-			{
-				successKeyboard = true;
-			}
-			else
-			{
-				successKeyboard = false;
-			}
-		}
-		else
-		{
-			if (!keyBindings[input].active)
-			{
-				if (keyStates[keyBindings[input].scancode] != 0)
-				{
-					keyBindings[input].active = true;
-					successKeyboard = true;
-				}
-				else
-				{
-					successKeyboard = false;
-				}
-			}
-			else
-			{
-				if (keyStates[keyBindings[input].scancode] == 0)
-				{
-					keyBindings[input].active = false;
-					successKeyboard = false;
-				}
-				else
-				{
-					successKeyboard = false;
-				}
-			}
-		}
-	}
-
-	if (gameControllerFound() && index < numGamepads)
-		if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY))
-		{
-			successGameController = checkAxisInput(input, index);
-			if (!successGameController)
-			{
-				if (repeat)
-				{
-					if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0)
-					{
-						successGameController = true;
-					}
-					else
-					{
-						successGameController = false;
-					}
-				}
-				else
-				{
-					if (!gameControllerBindings[index][input].active)
-					{
-						if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0)
-						{
-							gameControllerBindings[index][input].active = true;
-							successGameController = true;
-						}
-						else
-						{
-							successGameController = false;
-						}
-					}
-					else
-					{
-						if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) == 0)
-						{
-							gameControllerBindings[index][input].active = false;
-							successGameController = false;
-						}
-						else
-						{
-							successGameController = false;
-						}
-					}
-				}
-			}
-		}
-
-	return (successKeyboard || successGameController);
+	return (success_keyboard || success_controller);
 }
 
 // Comprueba si hay almenos un input activo
-bool Input::checkAnyInput(int device, int index)
+bool Input::checkAnyInput(InputDeviceToUse device, int controller_index)
 {
-	if (device == INPUT_USE_ANY)
-	{
-		index = 0;
-	}
-
-	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
+	if (device == InputDeviceToUse::KEYBOARD || device == InputDeviceToUse::ANY)
 	{
 		const Uint8 *mKeystates = SDL_GetKeyboardState(nullptr);
 
-		for (int i = 0; i < (int)keyBindings.size(); ++i)
+		for (int i = 0; i < (int)key_bindings_.size(); ++i)
 		{
-			if (mKeystates[keyBindings[i].scancode] != 0 && !keyBindings[i].active)
+			if (mKeystates[key_bindings_[i].scancode] != 0 && !key_bindings_[i].active)
 			{
-				keyBindings[i].active = true;
+				key_bindings_[i].active = true;
 				return true;
 			}
 		}
@@ -355,13 +167,13 @@ bool Input::checkAnyInput(int device, int index)
 
 	if (gameControllerFound())
 	{
-		if (device == INPUT_USE_GAMECONTROLLER || device == INPUT_USE_ANY)
+		if (device == InputDeviceToUse::CONTROLLER || device == InputDeviceToUse::ANY)
 		{
-			for (int i = 0; i < (int)gameControllerBindings.size(); ++i)
+			for (int i = 0; i < (int)controller_bindings_.size(); ++i)
 			{
-				if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][i].button) != 0 && !gameControllerBindings[index][i].active)
+				if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][i].button) != 0 && !controller_bindings_[controller_index][i].active)
 				{
-					gameControllerBindings[index][i].active = true;
+					controller_bindings_[controller_index][i].active = true;
 					return true;
 				}
 			}
@@ -375,24 +187,24 @@ bool Input::checkAnyInput(int device, int index)
 int Input::checkAnyButtonPressed(bool repeat)
 {
 	// Si está pulsado el botón de servicio, ningún botón se puede considerar pulsado
-	if (checkInput(input_service, INPUT_ALLOW_REPEAT, INPUT_USE_ANY))
+	if (checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::ANY))
 	{
 		return 0;
 	}
 
 	// Solo comprueba los botones definidos previamente
-	for (auto bi : buttonInputs)
+	for (auto bi : button_inputs_)
 	{
 		// Comprueba el teclado
-		if (checkInput(bi, repeat, INPUT_USE_KEYBOARD))
+		if (checkInput(bi, repeat, InputDeviceToUse::KEYBOARD))
 		{
 			return 1;
 		}
 
 		// Comprueba los mandos
-		for (int i = 0; i < numGamepads; ++i)
+		for (int i = 0; i < num_gamepads_; ++i)
 		{
-			if (checkInput(bi, repeat, INPUT_USE_GAMECONTROLLER, i))
+			if (checkInput(bi, repeat, InputDeviceToUse::CONTROLLER, i))
 			{
 				return i + 1;
 			}
@@ -412,115 +224,72 @@ bool Input::discoverGameControllers()
 		SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER);
 	}
 
-	if (SDL_GameControllerAddMappingsFromFile(dbPath.c_str()) < 0)
+	if (SDL_GameControllerAddMappingsFromFile(game_controller_db_path_.c_str()) < 0)
 	{
-		if (verbose)
-		{
-			std::cout << "Error, could not load " << dbPath.c_str() << " file: " << SDL_GetError() << std::endl;
-		}
+		std::cout << "Error, could not load " << game_controller_db_path_.c_str() << " file: " << SDL_GetError() << std::endl;
 	}
 
-	numJoysticks = SDL_NumJoysticks();
-	numGamepads = 0;
+	num_joysticks_ = SDL_NumJoysticks();
+	num_gamepads_ = 0;
 
 	// Cuenta el número de mandos
-	joysticks.clear();
-	for (int i = 0; i < numJoysticks; ++i)
+	joysticks_.clear();
+	for (int i = 0; i < num_joysticks_; ++i)
 	{
-		SDL_Joystick *joy = SDL_JoystickOpen(i);
-		joysticks.push_back(joy);
+		auto joy = SDL_JoystickOpen(i);
+		joysticks_.push_back(joy);
 		if (SDL_IsGameController(i))
 		{
-			numGamepads++;
+			num_gamepads_++;
 		}
 	}
 
-	if (verbose)
-	{
-		std::cout << "\nChecking for game controllers...\n";
-		std::cout << numJoysticks << " joysticks found, " << numGamepads << " are gamepads\n";
-	}
+	std::cout << "\n** LOOKING FOR GAME CONTROLLERS" << std::endl;
+	std::cout << "Gamepads found: " << num_gamepads_ << std::endl;
 
-	if (numGamepads > 0)
+	if (num_gamepads_ > 0)
 	{
 		found = true;
 
-		for (int i = 0; i < numGamepads; i++)
+		for (int i = 0; i < num_gamepads_; i++)
 		{
 			// Abre el mando y lo añade a la lista
-			SDL_GameController *pad = SDL_GameControllerOpen(i);
+			auto pad = SDL_GameControllerOpen(i);
 			if (SDL_GameControllerGetAttached(pad) == 1)
 			{
-				connectedControllers.push_back(pad);
-				const std::string separator(" #");
-				std::string name = SDL_GameControllerNameForIndex(i);
-				// name.resize(25);
-				// name = name + separator + std::to_string(i);
-				if (verbose)
-				{
-					std::cout << name << std::endl;
-				}
-				controllerNames.push_back(name);
+				connected_controllers_.push_back(pad);
+				const std::string name = SDL_GameControllerNameForIndex(i);
+				std::cout << "#" << i << ": " << name << std::endl;
+				controller_names_.push_back(name);
 			}
 			else
 			{
-				if (verbose)
-				{
-					std::cout << "SDL_GetError() = " << SDL_GetError() << std::endl;
-				}
+				std::cout << "SDL_GetError() = " << SDL_GetError() << std::endl;
 			}
 		}
 
 		SDL_GameControllerEventState(SDL_ENABLE);
 	}
 
+	std::cout << "\n** FINISHED LOOKING FOR GAME CONTROLLERS" << std::endl;
 	return found;
 }
 
 // Comprueba si hay algun mando conectado
-bool Input::gameControllerFound()
-{
-	return numGamepads > 0 ? true : false;
-}
+bool Input::gameControllerFound() { return num_gamepads_ > 0 ? true : false; }
 
 // Obten el nombre de un mando de juego
-std::string Input::getControllerName(int index)
-{
-	return numGamepads > 0 ? controllerNames[index] : "";
-}
+std::string Input::getControllerName(int controller_index) const { return num_gamepads_ > 0 ? controller_names_.at(controller_index) : std::string(); }
 
 // Obten el número de mandos conectados
-int Input::getNumControllers()
-{
-	return numGamepads;
-}
-
-// Establece si ha de mostrar mensajes
-void Input::setVerbose(bool value)
-{
-	verbose = value;
-}
-
-// Deshabilita las entradas durante un periodo de tiempo
-void Input::disableUntil(i_disable_e value)
-{
-	disabledUntil = value;
-	enabled = false;
-}
-
-// Hablita las entradas
-void Input::enable()
-{
-	enabled = true;
-	disabledUntil = d_notDisabled;
-}
+int Input::getNumControllers() const { return num_gamepads_; }
 
 // Obtiene el indice del controlador a partir de un event.id
-int Input::getJoyIndex(int id)
+int Input::getJoyIndex(int id) const
 {
-	for (int i = 0; i < numJoysticks; ++i)
+	for (int i = 0; i < num_joysticks_; ++i)
 	{
-		if (SDL_JoystickInstanceID(joysticks[i]) == id)
+		if (SDL_JoystickInstanceID(joysticks_[i]) == id)
 		{
 			return i;
 		}
@@ -529,160 +298,92 @@ int Input::getJoyIndex(int id)
 }
 
 // Muestra por consola los controles asignados
-void Input::printBindings(int device, int index)
+void Input::printBindings(InputDeviceToUse device, int controller_index) const
 {
-	if (device == INPUT_USE_ANY || device == INPUT_USE_KEYBOARD)
+	if (device == InputDeviceToUse::ANY || device == InputDeviceToUse::KEYBOARD)
 	{
 		return;
 	}
 
-	if (device == INPUT_USE_GAMECONTROLLER)
+	if (device == InputDeviceToUse::CONTROLLER)
 	{
-		if (index >= numGamepads)
+		if (controller_index >= num_gamepads_)
 		{
 			return;
 		}
 
 		// Muestra el nombre del mando
-		std::cout << "\n"
-				  << controllerNames[index] << std::endl;
+		std::cout << "\n" + controller_names_.at(controller_index) << std::endl;
 
 		// Muestra los botones asignados
-		for (auto bi : buttonInputs)
+		for (auto bi : button_inputs_)
 		{
-			std::cout << to_string(bi) << " : " << gameControllerBindings[index][bi].button << std::endl;
+			std::cout << to_string(bi) << " : " << controller_bindings_.at(controller_index).at(static_cast<int>(bi)).button << std::endl;
 		}
 	}
 }
 
 // Obtiene el SDL_GameControllerButton asignado a un input
-SDL_GameControllerButton Input::getControllerBinding(int index, inputs_e input)
+SDL_GameControllerButton Input::getControllerBinding(int controller_index, InputType input) const
 {
-	return gameControllerBindings[index][input].button;
+	return controller_bindings_[controller_index][static_cast<int>(input)].button;
 }
 
 // Obtiene el indice a partir del nombre del mando
-int Input::getIndexByName(std::string name)
+int Input::getIndexByName(const std::string &name) const
 {
-	for (int i = 0; i < numGamepads; ++i)
-	{
-		if (controllerNames[i] == name)
-		{
-			return i;
-		}
-	}
-	return -1;
+	auto it = std::find(controller_names_.begin(), controller_names_.end(), name);
+	return it != controller_names_.end() ? std::distance(controller_names_.begin(), it) : -1;
 }
 
-// Convierte un inputs_e a std::string
-std::string Input::to_string(inputs_e input)
+// Convierte un InputType a std::string
+std::string Input::to_string(InputType input) const
 {
-	if (input == input_fire_left)
+	switch (input)
 	{
+	case InputType::FIRE_LEFT:
 		return "input_fire_left";
-	}
-
-	if (input == input_fire_center)
-	{
+	case InputType::FIRE_CENTER:
 		return "input_fire_center";
-	}
-
-	if (input == input_fire_right)
-	{
+	case InputType::FIRE_RIGHT:
 		return "input_fire_right";
-	}
-
-	if (input == input_start)
-	{
+	case InputType::START:
 		return "input_start";
-	}
-
-	if (input == input_service)
-	{
+	case InputType::SERVICE:
 		return "input_service";
+	default:
+		return "";
 	}
-
-	return "";
 }
 
-// Convierte un std::string a inputs_e
-inputs_e Input::to_inputs_e(std::string name)
+// Convierte un std::string a InputType
+InputType Input::to_inputs_e(const std::string &name) const
 {
-	if (name == "input_fire_left")
-	{
-		return input_fire_left;
-	}
+	static const std::unordered_map<std::string, InputType> inputMap = {
+		{"input_fire_left", InputType::FIRE_LEFT},
+		{"input_fire_center", InputType::FIRE_CENTER},
+		{"input_fire_right", InputType::FIRE_RIGHT},
+		{"input_start", InputType::START},
+		{"input_service", InputType::SERVICE}};
 
-	if (name == "input_fire_center")
-	{
-		return input_fire_center;
-	}
-
-	if (name == "input_fire_right")
-	{
-		return input_fire_right;
-	}
-
-	if (name == "input_start")
-	{
-		return input_start;
-	}
-
-	if (name == "input_service")
-	{
-		return input_service;
-	}
-
-	return input_null;
-}
-
-// Activa todos los inputs. Sirve para evitar inputs sin repeticiones pero que ya vienen pulsados cuando checkInput no estaba monitorizando
-void Input::allActive(int index)
-{
-	for (int i = 0; i < (int)buttonInputs.size(); ++i)
-	{
-		gameControllerBindings[index][i].active = true;
-	}
+	auto it = inputMap.find(name);
+	return it != inputMap.end() ? it->second : InputType::NONE;
 }
 
 // Comprueba el eje del mando
-bool Input::checkAxisInput(inputs_e input, int index)
+bool Input::checkAxisInput(InputType input, int controller_index) const
 {
-	bool success = false;
-
 	switch (input)
 	{
-	case input_left:
-		if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTX) < -30000)
-		{
-			success = true;
-		}
-		break;
-
-	case input_right:
-		if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTX) > 30000)
-		{
-			success = true;
-		}
-		break;
-
-	case input_up:
-		if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTY) < -30000)
-		{
-			success = true;
-		}
-		break;
-
-	case input_down:
-		if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTY) > 30000)
-		{
-			success = true;
-		}
-		break;
-
+	case InputType::LEFT:
+		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) < -30000;
+	case InputType::RIGHT:
+		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) > 30000;
+	case InputType::UP:
+		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) < -30000;
+	case InputType::DOWN:
+		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) > 30000;
 	default:
-		break;
+		return false;
 	}
-
-	return success;
 }

source/input.h

@@ -1,113 +1,113 @@
 #pragma once
 
-#include <SDL2/SDL_gamecontroller.h>  // for SDL_GameControllerButton, SDL_G...
-#include <SDL2/SDL_joystick.h>        // for SDL_Joystick
-#include <SDL2/SDL_scancode.h>        // for SDL_Scancode
-#include <SDL2/SDL_stdinc.h>          // for Uint8
-#include <string>                     // for string, basic_string
-#include <vector>                     // for vector
+#include <SDL2/SDL_gamecontroller.h> // para SDL_GameControllerButton, SDL_G...
+#include <SDL2/SDL_joystick.h>		 // para SDL_Joystick
+#include <SDL2/SDL_scancode.h>		 // para SDL_Scancode
+#include <SDL2/SDL_stdinc.h>		 // para Uint8
+#include <string>					 // para string, basic_string
+#include <vector>					 // para vector
 
 /*
 connectedControllers es un vector donde estan todos los mandos encontrados [0 .. n]
 checkInput requiere de un indice para comprobar las pulsaciónes de un controlador en concreto [0 .. n]
 device contiene el tipo de dispositivo a comprobar:
-	INPUT_USE_KEYBOARD solo mirará el teclado
-	INPUT_USE_GAMECONTROLLER solo mirará el controlador especificado (Si no se especifica, el primero)
-	INPUT_USE_ANY mirará tanto el teclado como el PRIMER controlador
+	InputDeviceToUse::KEYBOARD solo mirará el teclado
+	InputDeviceToUse::CONTROLLER solo mirará el controlador especificado (Si no se especifica, el primero)
+	InputDeviceToUse::ANY mirará tanto el teclado como el PRIMER controlador
 */
 
-enum inputs_e
+enum class InputType : int
 {
 	// Inputs de movimiento
-	input_up,
-	input_down,
-	input_left,
-	input_right,
+	UP,
+	DOWN,
+	LEFT,
+	RIGHT,
 
 	// Inputs personalizados
-	input_fire_left,
-	input_fire_center,
-	input_fire_right,
-	input_start,
+	FIRE_LEFT,
+	FIRE_CENTER,
+	FIRE_RIGHT,
+	START,
 
 	// Inputs de control
-	input_exit,
-	input_pause,
-	input_service,
-	input_window_fullscreen,
-	input_window_inc_size,
-	input_window_dec_size,
-	input_video_shaders,
-	input_reset,
-	input_mute,
-	input_showinfo,
-	input_config,
-	input_swap_controllers,
+	EXIT,
+	PAUSE,
+	SERVICE,
+	WINDOW_FULLSCREEN,
+	WINDOW_INC_SIZE,
+	WINDOW_DEC_SIZE,
+	VIDEO_SHADERS,
+	RESET,
+	MUTE,
+	SHOWINFO,
+	CONFIG,
+	SWAP_CONTROLLERS,
 
 	// Input obligatorio
-	input_null,
-	input_number_of_inputs,
+	NONE,
+	NUMBER_OF_INPUTS,
 };
 
-#define INPUT_ALLOW_REPEAT true
-#define INPUT_DO_NOT_ALLOW_REPEAT false
+constexpr bool INPUT_ALLOW_REPEAT = true;
+constexpr bool INPUT_DO_NOT_ALLOW_REPEAT = false;
 
-#define INPUT_USE_KEYBOARD 0
-#define INPUT_USE_GAMECONTROLLER 1
-#define INPUT_USE_ANY 2
-
-enum i_disable_e
+enum class InputDeviceToUse : int
 {
-	d_notDisabled,
-	d_forever,
-	d_keyPressed
+	KEYBOARD = 0,
+	CONTROLLER = 1,
+	ANY = 2,
 };
 
 class Input
 {
 private:
 	// [SINGLETON] Objeto screen privado para Don Melitón
-	static Input *input;
+	static Input *input_;
 
-	struct keyBindings_t
+	struct KeyBindings
 	{
 		Uint8 scancode; // Scancode asociado
 		bool active;	// Indica si está activo
+
+		// Constructor
+		explicit KeyBindings(Uint8 sc = 0, bool act = false)
+			: scancode(sc), active(act) {}
 	};
 
-	struct GameControllerBindings_t
+	struct ControllerBindings
 	{
 		SDL_GameControllerButton button; // GameControllerButton asociado
 		bool active;					 // Indica si está activo
+
+		// Constructor
+		explicit ControllerBindings(SDL_GameControllerButton btn = SDL_CONTROLLER_BUTTON_INVALID, bool act = false)
+			: button(btn), active(act) {}
 	};
 
 	// Variables
-	std::vector<SDL_GameController *> connectedControllers;					   // Vector con todos los mandos conectados
-	std::vector<SDL_Joystick *> joysticks;									   // Vector con todos los joysticks conectados
-	std::vector<keyBindings_t> keyBindings;									   // Vector con las teclas asociadas a los inputs predefinidos
-	std::vector<std::vector<GameControllerBindings_t>> gameControllerBindings; // Vector con los botones asociadas a los inputs predefinidos para cada mando
-	std::vector<std::string> controllerNames;								   // Vector con los nombres de los mandos
-	std::vector<inputs_e> gameInputs;										   // Inputs usados para jugar, normalmente direcciones y botones
-	std::vector<inputs_e> buttonInputs;										   // Inputs asignados al jugador y a botones, excluyendo direcciones
-	int numJoysticks;														   // Número de joysticks conectados
-	int numGamepads;														   // Número de mandos conectados
-	std::string dbPath;														   // Ruta al archivo gamecontrollerdb.txt
-	bool verbose;															   // Indica si ha de mostrar mensajes
-	i_disable_e disabledUntil;												   // Tiempo que esta deshabilitado
-	bool enabled;															   // Indica si está habilitado
+	std::vector<SDL_GameController *> connected_controllers_;		   // Vector con todos los mandos conectados
+	std::vector<SDL_Joystick *> joysticks_;							   // Vector con todos los joysticks conectados
+	std::vector<KeyBindings> key_bindings_;							   // Vector con las teclas asociadas a los inputs predefinidos
+	std::vector<std::vector<ControllerBindings>> controller_bindings_; // Vector con los botones asociadas a los inputs predefinidos para cada mando
+	std::vector<std::string> controller_names_;						   // Vector con los nombres de los mandos
+	std::vector<InputType> button_inputs_;							   // Inputs asignados al jugador y a botones, excluyendo direcciones
+	int num_joysticks_ = 0;											   // Número de joysticks conectados
+	int num_gamepads_ = 0;											   // Número de mandos conectados
+	std::string game_controller_db_path_;							   // Ruta al archivo gamecontrollerdb.txt
 
 	// Comprueba el eje del mando
-	bool checkAxisInput(inputs_e input, int index = 0);
+	bool checkAxisInput(InputType input, int controller_index = 0) const;
 
 	// Constructor
-	Input(std::string file);
+	explicit Input(const std::string &game_controller_db_path);
 
 	// Destructor
-	~Input();
+	~Input() = default;
 
 public:
 	// [SINGLETON] Crearemos el objeto screen con esta función estática
-	static void init(std::string file);
+	static void init(const std::string &game_controller_db_path);
 
 	// [SINGLETON] Destruiremos el objeto screen con esta función estática
 	static void destroy();
@@ -115,24 +115,18 @@ public:
 	// [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
 	static Input *get();
 
-	// Actualiza el estado del objeto
-	void update();
-
 	// Asigna inputs a teclas
-	void bindKey(inputs_e input, SDL_Scancode code);
+	void bindKey(InputType input, SDL_Scancode code);
 
 	// Asigna inputs a botones del mando
-	void bindGameControllerButton(int index, inputs_e input, SDL_GameControllerButton button);
-	void bindGameControllerButton(int index, inputs_e inputTarget, inputs_e inputSource);
+	void bindGameControllerButton(int controller_index, InputType input, SDL_GameControllerButton button);
+	void bindGameControllerButton(int controller_index, InputType inputTarget, InputType inputSource);
 
 	// Comprueba si un input esta activo
-	bool checkInput(inputs_e input, bool repeat = true, int device = INPUT_USE_ANY, int index = 0);
-
-	// Comprueba si un input con modificador esta activo
-	bool checkModInput(inputs_e inputMod, inputs_e input, bool repeat = true, int device = INPUT_USE_ANY, int index = 0);
+	bool checkInput(InputType input, bool repeat = true, InputDeviceToUse device = InputDeviceToUse::ANY, int controller_index = 0);
 
 	// Comprueba si hay almenos un input activo
-	bool checkAnyInput(int device = INPUT_USE_ANY, int index = 0);
+	bool checkAnyInput(InputDeviceToUse device = InputDeviceToUse::ANY, int controller_index = 0);
 
 	// Comprueba si hay algún botón pulsado
 	int checkAnyButtonPressed(bool repeat = INPUT_DO_NOT_ALLOW_REPEAT);
@@ -144,38 +138,26 @@ public:
 	bool gameControllerFound();
 
 	// Obten el número de mandos conectados
-	int getNumControllers();
+	int getNumControllers() const;
 
 	// Obten el nombre de un mando de juego
-	std::string getControllerName(int index);
-
-	// Establece si ha de mostrar mensajes
-	void setVerbose(bool value);
-
-	// Deshabilita las entradas durante un periodo de tiempo
-	void disableUntil(i_disable_e value);
-
-	// Hablita las entradas
-	void enable();
+	std::string getControllerName(int controller_index) const;
 
 	// Obtiene el indice del controlador a partir de un event.id
-	int getJoyIndex(int id);
+	int getJoyIndex(int id) const;
 
 	// Muestra por consola los controles asignados
-	void printBindings(int device = INPUT_USE_KEYBOARD, int index = 0);
+	void printBindings(InputDeviceToUse device = InputDeviceToUse::KEYBOARD, int controller_index = 0) const;
 
 	// Obtiene el SDL_GameControllerButton asignado a un input
-	SDL_GameControllerButton getControllerBinding(int index, inputs_e input);
+	SDL_GameControllerButton getControllerBinding(int controller_index, InputType input) const;
 
-	// Convierte un inputs_e a std::string
-	std::string to_string(inputs_e input);
+	// Convierte un InputType a std::string
+	std::string to_string(InputType input) const;
 
-	// Convierte un std::string a inputs_e
-	inputs_e to_inputs_e(std::string name);
+	// Convierte un std::string a InputType
+	InputType to_inputs_e(const std::string &name) const;
 
 	// Obtiene el indice a partir del nombre del mando
-	int getIndexByName(std::string name);
-
-	// Activa todos los inputs. Sirve para evitar inputs sin repeticiones pero que ya vienen pulsados cuando checkInput no estaba monitorizando
-	void allActive(int index);
+	int getIndexByName(const std::string &name) const;
 };