Retocs en Texture::loadPaletteFromFile

Varios arreglos
Les notificacions ara accepten un vector de cadenes en lloc de una o dos cadenes
2024-11-03 20:43:52 +01:00 · 2024-11-03 20:28:01 +01:00 · 2024-11-03 18:12:46 +01:00 · 2024-11-03 17:25:31 +01:00 · 2024-11-03 11:07:58 +01:00 · 2024-11-01 20:01:17 +01:00
133 changed files with 9210 additions and 9329 deletions
--- a/README.md
+++ b/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
+## Controls
-El juego se maneja con teclado, aunque tambien se puede conectar un mando de control.
+El joc està optimitzat per a ser jugat amb un mando de jocs, encara que un dels jugadors pot utilitzar el teclat.
-Las teclas son las siguientes:
+Les tecles son les següents:
-* **Cursores**: Mover al personaje, moverse por los menus
+* **Fletxes**: Mou al personatge
-* **Q, W, E**: Disparar a la izquierda, al centro y a la derecha respectivamente
+* **Q, W, E**: Disparar a la esquerra, al centre i a la dreta respectivament
 * **ESCAPE**: Pone en pausa el juego durante la partida. Sale de los menus. Cierra el juego
 * **ENTER**: Acepta las opciones en los menus
-![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:
+- **Tecla F2**: Fa la finestra mes gran
 ```bash
 sudo apt install libsdl2-dev g++
 ```
-En macOS se pueden instalar fácilmente con [brew](https://brew.sh):
+- **Tecla F3**: Alterna entre el mode de pantalla completa i el de finestra
 ```bash
 brew install sdl2 g++
 ```
-Una vez instaladas las librerías SDL, se puede compilar utilizando el fichero Makefile suministrado.
+- **Tecla F4**: Activa o desactiva els shaders
-En Linux:
+- **Tecla F10**: Reset
 ```bash
 make linux
 ```
-En macOS:
+<p align="center">
-```bash
+    <img src="https://php.sustancia.synology.me/images/ccae2.png" alt="Joc" 
-make macos
+</p>
 ```
 ![alt text](https://php.sustancia.synology.me/images/cc3.png)
 ## Como ejecutar
-Para ejecutar el juego hay que escribir en la terminal la orden que se muestra a continuación.
+## Agraiments
-
+A chatGPT i sobretot a Copilot. Gracies per estar sempre quan vos he necesitat.
 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.
--- a/data/config/param_320x240.txt
+++ b/data/config/param_320x240.txt
@@ -6,7 +6,7 @@ game.play_area.rect.x     0 # Rectangulo con la posición de la zona de juego
 game.play_area.rect.y     0 # Rectangulo con la posición de la zona de juego
 game.play_area.rect.w   320 # Rectangulo con la posición de la zona de juego
 game.play_area.rect.h   200 # Rectangulo con la posición de la zona de juego
-game.enter_name_seconds  30 # Duración en segundos para introducir el nombre al finalizar la partida
+game.enter_name_seconds  60 # Duración en segundos para introducir el nombre al finalizar la partida
 ## FADE
 fade.num_squares_width    160
--- a/data/config/param_320x256.txt
+++ b/data/config/param_320x256.txt
@@ -6,7 +6,7 @@ game.play_area.rect.x    0 # Rectangulo con la posición de la zona de juego
 game.play_area.rect.y    0 # Rectangulo con la posición de la zona de juego
 game.play_area.rect.w  320 # Rectangulo con la posición de la zona de juego
 game.play_area.rect.h  216 # Rectangulo con la posición de la zona de juego
-game.enter_name_seconds 30 # Duración en segundos para introducir el nombre al finalizar la partida
+game.enter_name_seconds 60 # Duración en segundos para introducir el nombre al finalizar la partida
 ## FADE
 fade.num_squares_width    160
--- a/data/font/04b_25.png
+++ b/data/font/04b_25.png
--- a/data/font/04b_25.txt
+++ b/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
+8
-# 35 #
+# 35 
-7
+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
+# 49 1
 7
 # 66 B
 7
 # 67 C
 7
 # 68 D
 7
 # 69 E
 7
 # 70 F
 7
 # 71 G
 7
 # 72 H
 7
 # 73 I
 4
 # 74 J
 6
 # 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
+8
-# 123 { -> ñ
+# 123 {
-7
+1
-# 124 | -> ç
+# 124 |
-7
+1
 # 125 }
-0
+1
 # 126 ~
-0
+1
--- a/data/font/nokia.png
+++ b/data/font/nokia.png
--- a/data/font/nokia2.png
+++ b/data/font/nokia2.png
--- a/data/font/nokia_big2.png
+++ b/data/font/nokia_big2.png
--- a/data/font/nokia_big2.txt
+++ b/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
--- a/data/font/smb2_big.png
+++ b/data/font/smb2_big.png
--- a/data/font/smb2_big.txt
+++ b/data/font/smb2_big.txt
@@ -1,194 +0,0 @@
 # box width
 16
 # box height
 16
 # 32 espacio ( )
 16
 # 33 !
 16
 # 34 "
 16
 # 35 #
 16
 # 36 $
 16
 # 37 %
 16
 # 38 &
 16
 # 39 '
 16
 # 40 (
 16
 # 41 )
 16
 # 42 *
 16
 # 43 +
 16
 # 44 ,
 16
 # 45 -
 16
 # 46 .
 16
 # 47 /
 16
 # 48 0
 16
 # 49 1
 16
 # 50 2
 16
 # 51 3
 16
 # 52 4
 16
 # 53 5
 16
 # 54 6
 16
 # 55 7
 16
 # 56 8
 16
 # 57 9
 16
 # 58 :
 16
 # 59 ;
 16
 # 60 <
 16
 # 61 =
 16
 # 62 >
 16
 # 63 ?
 16
 # 64 @
 16
 # 65 A
 16
 # 66 B
 16
 # 67 C
 16
 # 68 D
 16
 # 69 E
 16
 # 70 F
 16
 # 71 G
 16
 # 72 H
 16
 # 73 I
 16
 # 74 J
 16
 # 75 K
 16
 # 76 L
 16
 # 77 M
 16
 # 78 N
 16
 # 79 O
 16
 # 80 P
 16
 # 81 Q
 16
 # 82 R
 16
 # 83 S
 16
 # 84 T
 16
 # 85 U
 16
 # 86 V
 16
 # 87 W
 16
 # 88 X
 16
 # 89 Y
 16
 # 90 Z
 16
 # 91 [
 16
 # 92 \
 16
 # 93 ]
 16
 # 94 ^
 16
 # 95 _
 16
 # 96 `
 16
 # 97 a
 16
 # 98 b
 16
 # 99 c
 16
 # 100 d
 16
 # 101 e
 16
 # 102 f
 16
 # 103 g
 16
 # 104 h
 16
 # 105 i
 16
 # 106 j
 16
 # 107 k
 16
 # 108 l
 16
 # 109 m
 16
 # 110 n
 16
 # 111 o
 16
 # 112 p
 16
 # 113 q
 16
 # 114 r
 16
 # 115 s
 16
 # 116 t
 16
 # 117 u
 16
 # 118 v
 16
 # 119 w
 16
 # 120 x
 16
 # 121 y
 16
 # 122 z
 16
 # 123 {
 16
 # 124 |
 16
 # 125 }
 16
 # 126 ~
 16
--- a/data/font/smb2_palette1.pal
+++ b/data/font/smb2_palette1.pal
--- a/data/gfx/game_text/game_text_1000_points.png
+++ b/data/gfx/game_text/game_text_1000_points.png
--- a/data/gfx/game_text/game_text_2500_points.png
+++ b/data/gfx/game_text/game_text_2500_points.png
--- a/data/gfx/game_text/game_text_5000_points.png
+++ b/data/gfx/game_text/game_text_5000_points.png
--- a/data/gfx/game_text/game_text_one_hit.png
+++ b/data/gfx/game_text/game_text_one_hit.png
--- a/data/gfx/game_text/game_text_powerup.png
+++ b/data/gfx/game_text/game_text_powerup.png
--- a/data/gfx/player/player.ani
+++ b/data/gfx/player/player.ani
@@ -23,29 +23,64 @@ 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
+name=walk-centershoot-cooldown
-speed=15
+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=death
 speed=10
 loop=0
 frames=32,33,34,35
 [/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]
--- a/data/gfx/player/player1.gif
+++ b/data/gfx/player/player1.gif
--- a/data/gfx/player/player1_all_white_palette.pal
+++ b/data/gfx/player/player1_all_white_palette.pal
--- a/data/gfx/player/player1_one_coffee_palette.pal
+++ b/data/gfx/player/player1_one_coffee_palette.pal
--- a/data/gfx/player/player1_pal1.gif
+++ b/data/gfx/player/player1_pal1.gif
--- a/data/gfx/player/player1_power.gif
+++ b/data/gfx/player/player1_power.gif
--- a/data/gfx/player/player1_power.png
+++ b/data/gfx/player/player1_power.png
--- a/data/gfx/player/player1_two_coffee_palette.pal
+++ b/data/gfx/player/player1_two_coffee_palette.pal
--- a/data/gfx/player/player2.gif
+++ b/data/gfx/player/player2.gif
--- a/data/gfx/player/player2_all_white_palette.pal
+++ b/data/gfx/player/player2_all_white_palette.pal
--- a/data/gfx/player/player2_one_coffee_palette.pal
+++ b/data/gfx/player/player2_one_coffee_palette.pal
--- a/data/gfx/player/player2_power.gif
+++ b/data/gfx/player/player2_power.gif
--- a/data/gfx/player/player2_power.png
+++ b/data/gfx/player/player2_power.png
--- a/data/gfx/player/player2_two_coffee_palette.pal
+++ b/data/gfx/player/player2_two_coffee_palette.pal
--- a/data/gfx/player/player_power.gif
+++ b/data/gfx/player/player_power.gif
--- a/data/gfx/player/player_power_pal.gif
+++ b/data/gfx/player/player_power_pal.gif
--- a/data/lang/ba_BA.txt
+++ b/data/lang/ba_BA.txt
@@ -206,7 +206,7 @@ NORMAL
 DIFICIL
 ## 69 - MENU DE OPCIONES
-TECLAT
+Teclat
 ## 70 - MENU DE OPCIONES
 MANDO
@@ -347,4 +347,16 @@ Per favor
 espere
 ## 116 - NOTIFICACIONES
-Torna a polsar per apagar el sistema
+Torna a polsar per apagar el sistema
 ## 117 - GAME TEXT
 SuperPoder!
 ## 118 - GAME TEXT
 +1 Colp
 ## 119 - GAME TEXT
 Temps!
 ## 120 - SCOREBOARD
 Puntuacio
--- a/data/lang/en_UK.txt
+++ b/data/lang/en_UK.txt
@@ -206,7 +206,7 @@ NORMAL
 HARD
 ## 69 - MENU DE OPCIONES
-KEYBOARD
+Keyboard
 ## 70 - MENU DE OPCIONES
 GAME CONTROLLER
@@ -347,4 +347,16 @@ Please
 wait
 ## 116 - NOTIFICACIONES
-Press again to shutdown system
+Press again to shutdown system
 ## 117 - GAME TEXT
 PowerUp
 ## 118 - GAME TEXT
 +1 Hit
 ## 119 - GAME TEXT
 Stop!
 ## 120 - SCOREBOARD
 Score
--- a/data/lang/es_ES.txt
+++ b/data/lang/es_ES.txt
@@ -206,7 +206,7 @@ NORMAL
 DIFICIL
 ## 69 - MENU DE OPCIONES
-TECLADO
+Teclado
 ## 70 - MENU DE OPCIONES
 MANDO
@@ -347,4 +347,16 @@ Por favor
 espere
 ## 94 - NOTIFICACIONES
-Pulsa otra vez para apagar el sistema
+Pulsa otra vez para apagar el sistema
 ## 117 - GAME TEXT
 Potenciador
 ## 118 - GAME TEXT
 +1 Golpe
 ## 119 - GAME TEXT
 Tiempo!
 ## 120 - SCOREBOARD
 Puntuacion
--- a/linux-utils/run_valgrind.sh
+++ b/linux-utils/run_valgrind.sh
@@ -1,3 +0,0 @@
 #!/bin/bash
 valgrind --suppressions=valgrind_exceptions --leak-check=full ~/coffee_crisis_arcade_edition/coffee_crisis_arcade_edition_debug > ~/coffee_crisis_arcade_edition/debug.txt 2>&1
--- a/linux_utils/build_time_tracker.sh
+++ b/linux_utils/build_time_tracker.sh
--- a/linux_utils/check_all_includes.sh
+++ b/linux_utils/check_all_includes.sh
@@ -0,0 +1,8 @@
 #!/bin/bash
 SOURCEPATH=../source/
 for i in "$SOURCEPATH"/*.cpp
 do
    include-what-you-use -D DEBUG -D VERBOSE -std=c++20 -Wall "$i"
 done
--- a/linux_utils/check_includes.sh
+++ b/linux_utils/check_includes.sh
@@ -5,6 +5,6 @@ SOURCEPATH=../source/
 for i in "$SOURCEPATH"/*.cpp
 do
    include-what-you-use -D DEBUG -D VERBOSE -std=c++20 -Wall "$i"
-    read -p "Presiona cualquier tecla para continuar..."
+    read -r -p "Presiona cualquier tecla para continuar..."
    clear
 done
--- a/linux_utils/cppcheck_suppressions
+++ b/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/*
--- a/linux_utils/include-what-you-use
+++ b/linux_utils/include-what-you-use
--- a/linux_utils/run_cppcheck.sh
+++ b/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
--- a/linux_utils/run_valgrind.sh
+++ b/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
--- a/linux_utils/valgrind_exceptions
+++ b/linux_utils/valgrind_exceptions
--- a/source/animated_sprite.cpp
+++ b/source/animated_sprite.cpp
@@ -1,16 +1,15 @@
 #include "animated_sprite.h"
-#include <algorithm> // for copy
+#include <stddef.h>	 // Para size_t
-#include <fstream>	 // for basic_ostream, operator<<, basic_istream, basic...
+#include <fstream>	 // Para basic_ostream, basic_istream, operator<<, basic...
-#include <iostream>	 // for cout
+#include <iostream>	 // Para cout, cerr
-#include <iterator>	 // for back_insert_iterator, back_inserter
+#include <sstream>	 // Para basic_stringstream
-#include <sstream>	 // for basic_stringstream
+#include <stdexcept> // Para runtime_error
-#include "texture.h" // for Texture
+#include "texture.h" // Para Texture
-#include "utils.h"
+#include "utils.h"	 // Para printWithDots
 // Carga las animaciones en un vector(Animations) desde un fichero
-Animations loadAnimationsFromFile(const std::string &file_path)
+AnimationsFileBuffer loadAnimationsFromFile(const std::string &file_path)
 {
 	std::vector<std::string> buffer;
 	std::ifstream file(file_path);
 	if (!file)
 	{
@@ -18,12 +17,14 @@ Animations loadAnimationsFromFile(const std::string &file_path)
 		throw std::runtime_error("Fichero no encontrado: " + file_path);
 	}
 	std::string line;
 	printWithDots("Animation : ", file_path.substr(file_path.find_last_of("\\/") + 1), "[ LOADED ]");
 	std::vector<std::string> buffer;
 	std::string line;
 	while (std::getline(file, line))
 	{
-		buffer.push_back(line);
+		if (!line.empty())
 			buffer.push_back(line);
 	}
 	return buffer;
@@ -31,35 +32,24 @@ Animations loadAnimationsFromFile(const std::string &file_path)
 // Constructor
 AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const std::string &file_path)
-	: MovingSprite(texture),
+	: MovingSprite(texture)
 	  current_animation_(0)
 {
 	// Carga las animaciones
 	if (!file_path.empty())
 	{
-		animations_ = loadFromFile(file_path);
+		AnimationsFileBuffer v = loadAnimationsFromFile(file_path);
-	}
+		loadFromAnimationsFileBuffer(v);
 }
 AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const Animations &animations)
 	: MovingSprite(texture),
 	  current_animation_(0)
 {
 	if (!animations.empty())
 	{
 		loadFromVector(animations);
 	}
 }
 // Constructor
-AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture)
+AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const AnimationsFileBuffer &animations)
-	: MovingSprite(texture),
+	: MovingSprite(texture)
 	  current_animation_(0) {}
 // Destructor
 AnimatedSprite::~AnimatedSprite()
 {
-	animations_.clear();
+	if (!animations.empty())
 	{
 		loadFromAnimationsFileBuffer(animations);
 	}
 }
 // Obtiene el indice de la animación a partir del nombre
@@ -116,89 +106,12 @@ void AnimatedSprite::animate()
 	}
 }
 // Obtiene el número de frames de la animación actual
 int AnimatedSprite::getNumFrames()
 {
 	return (int)animations_[current_animation_].frames.size();
 }
 // Establece el frame actual de la animación
 void AnimatedSprite::setCurrentFrame(int num)
 {
 	// Descarta valores fuera de rango
 	if (num >= (int)animations_[current_animation_].frames.size())
 	{
 		num = 0;
 	}
 	// Cambia el valor de la variable
 	animations_[current_animation_].current_frame = num;
 	animations_[current_animation_].counter = 0;
 	// Escoge el frame correspondiente de la animación
 	setSpriteClip(animations_[current_animation_].frames[animations_[current_animation_].current_frame]);
 }
 // Establece el valor del contador
 void AnimatedSprite::setAnimationCounter(const std::string &name, int num)
 {
 	animations_[getIndex(name)].counter = num;
 }
 // Establece la velocidad de una animación
 void AnimatedSprite::setAnimationSpeed(const std::string &name, int speed)
 {
 	animations_[getIndex(name)].counter = speed;
 }
 // Establece la velocidad de una animación
 void AnimatedSprite::setAnimationSpeed(int index, int speed)
 {
 	animations_[index].counter = speed;
 }
 // Establece si la animación se reproduce en bucle
 void AnimatedSprite::setAnimationLoop(const std::string &name, int loop)
 {
 	animations_[getIndex(name)].loop = loop;
 }
 // Establece si la animación se reproduce en bucle
 void AnimatedSprite::setAnimationLoop(int index, int loop)
 {
 	animations_[index].loop = loop;
 }
 // Establece el valor de la variable
 void AnimatedSprite::setAnimationCompleted(const std::string &name, bool value)
 {
 	animations_[getIndex(name)].completed = value;
 }
 // OLD - Establece el valor de la variable
 void AnimatedSprite::setAnimationCompleted(int index, bool value)
 {
 	animations_[index].completed = value;
 }
 // Comprueba si ha terminado la animación
 bool AnimatedSprite::animationIsCompleted()
 {
 	return animations_[current_animation_].completed;
 }
 // Devuelve el rectangulo de una animación y frame concreto
 SDL_Rect AnimatedSprite::getAnimationClip(const std::string &name, Uint8 index)
 {
 	return animations_[getIndex(name)].frames[index];
 }
 // Devuelve el rectangulo de una animación y frame concreto
 SDL_Rect AnimatedSprite::getAnimationClip(int indexA, Uint8 indexF)
 {
 	return animations_[indexA].frames[indexF];
 }
 // Establece la animacion actual
 void AnimatedSprite::setCurrentAnimation(const std::string &name)
 {
@@ -232,21 +145,6 @@ void AnimatedSprite::update()
 	MovingSprite::update();
 }
 // Establece el rectangulo para un frame de una animación
 void AnimatedSprite::setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h)
 {
 	animations_[index_animation].frames.push_back({x, y, w, h});
 }
 // OLD - Establece el contador para todas las animaciones
 void AnimatedSprite::setAnimationCounter(int value)
 {
 	for (auto &a : animations_)
 	{
 		a.counter = value;
 	}
 }
 // Reinicia la animación
 void AnimatedSprite::resetAnimation()
 {
@@ -255,268 +153,91 @@ void AnimatedSprite::resetAnimation()
 	animations_[current_animation_].completed = false;
 }
-// Carga la animación desde un fichero
+// Carga la animación desde un vector de cadenas
-std::vector<Animation> AnimatedSprite::loadFromFile(const std::string &file_path)
+void AnimatedSprite::loadFromAnimationsFileBuffer(const AnimationsFileBuffer &source)
 {
-	// Inicializa variables
+	int frame_width = 1;
-	std::vector<Animation> animations;
+	int frame_height = 1;
-	auto frames_per_row = 0;
+	int frames_per_row = 1;
-	auto frame_width = 0;
+	int max_tiles = 1;
 	auto frame_height = 0;
 	auto max_tiles = 0;
-	const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
+	size_t index = 0;
-	std::ifstream file(file_path);
+	while (index < source.size())
 	std::string line;
 	// El fichero se puede abrir
 	if (file.good())
 	{
-		// Procesa el fichero linea a linea
+		std::string line = source.at(index);
-		std::cout << "Animation loaded: " << file_name << std::endl;
+
-		while (std::getline(file, line))
+		// Parsea el fichero para buscar variables y valores
 		if (line != "[animation]")
 		{
-			// Si la linea contiene el texto [animation] se realiza el proceso de carga de una animación
+			// Encuentra la posición del caracter '='
-			if (line == "[animation]")
+			size_t pos = line.find("=");
 			// Procesa las dos subcadenas
 			if (pos != std::string::npos)
 			{
-				Animation animation = Animation();
+				std::string key = line.substr(0, pos);
 				int value = std::stoi(line.substr(pos + 1));
 				if (key == "frame_width")
 					frame_width = value;
 				else if (key == "frame_height")
 					frame_height = value;
 				else
 					std::cout << "Warning: unknown parameter " << key << std::endl;
-				do
+				frames_per_row = texture_->getWidth() / frame_width;
-				{
+				const int w = texture_->getWidth() / frame_width;
-					std::getline(file, line);
+				const int h = texture_->getHeight() / frame_height;
-
+				max_tiles = w * h;
 					// Encuentra la posición del caracter '='
 					int pos = line.find("=");
 					// Procesa las dos subcadenas
 					if (pos != static_cast<int>(line.npos))
 					{
 						if (line.substr(0, pos) == "name")
 						{
 							animation.name = line.substr(pos + 1, line.length());
 						}
 						else if (line.substr(0, pos) == "speed")
 						{
 							animation.speed = std::stoi(line.substr(pos + 1, line.length()));
 						}
 						else if (line.substr(0, pos) == "loop")
 						{
 							animation.loop = std::stoi(line.substr(pos + 1, line.length()));
 						}
 						else if (line.substr(0, pos) == "frames")
 						{
 							// Se introducen los valores separados por comas en un vector
 							std::stringstream ss(line.substr(pos + 1, line.length()));
 							std::string tmp;
 							SDL_Rect rect = {0, 0, frame_width, frame_height};
 							while (getline(ss, tmp, ','))
 							{
 								// Comprueba que el tile no sea mayor que el maximo indice permitido
 								const auto num_tile = std::stoi(tmp) > max_tiles ? 0 : std::stoi(tmp);
 								rect.x = (num_tile % frames_per_row) * frame_width;
 								rect.y = (num_tile / frames_per_row) * frame_height;
 								animation.frames.push_back(rect);
 							}
 						}
 						else
 						{
 							std::cout << "Warning: file " << file_name.c_str() << "\n, unknown parameter \"" << line.substr(0, pos).c_str() << "\"" << std::endl;
 						}
 					}
 				} while (line != "[/animation]");
 				// Añade la animación al vector de animaciones
 				animations.push_back(animation);
 			}
 			// En caso contrario se parsea el fichero para buscar las variables y los valores
 			else
 			{
 				// Encuentra la posición del caracter '='
 				int pos = line.find("=");
 				// Procesa las dos subcadenas
 				if (pos != (int)line.npos)
 				{
 					if (line.substr(0, pos) == "frames_per_row")
 					{
 						frames_per_row = std::stoi(line.substr(pos + 1, line.length()));
 					}
 					else if (line.substr(0, pos) == "frame_width")
 					{
 						frame_width = std::stoi(line.substr(pos + 1, line.length()));
 					}
 					else if (line.substr(0, pos) == "frame_height")
 					{
 						frame_height = std::stoi(line.substr(pos + 1, line.length()));
 					}
 					else
 					{
 						std::cout << "Warning: file " << file_name.c_str() << "\n, unknown parameter \"" << line.substr(0, pos).c_str() << "\"" << std::endl;
 					}
 					// Normaliza valores
 					if (frames_per_row == 0 && frame_width > 0)
 					{
 						frames_per_row = texture_->getWidth() / frame_width;
 					}
 					if (max_tiles == 0 && frame_width > 0 && frame_height > 0)
 					{
 						const auto w = texture_->getWidth() / frame_width;
 						const auto h = texture_->getHeight() / frame_height;
 						max_tiles = w * h;
 					}
 				}
 			}
 		}
 		// Cierra el fichero
 		file.close();
 	}
 	// El fichero no se puede abrir
 	else
 	{
 		std::cout << "Warning: Unable to open " << file_name.c_str() << " file" << std::endl;
 	}
 	// Pone un valor por defecto
 	setWidth(frame_width);
 	setHeight(frame_height);
 	return animations;
 }
 // Carga la animación desde un vector
 bool AnimatedSprite::loadFromVector(const Animations &source)
 {
 	// Inicializa variables
 	auto frames_per_row = 0;
 	auto frame_width = 0;
 	auto frame_height = 0;
 	auto max_tiles = 0;
 	// Indicador de éxito en el proceso
 	auto success = true;
 	std::string line;
 	// Recorre todo el vector
 	auto index = 0;
 	while (index < (int)source.size())
 	{
 		// Lee desde el vector
 		line = source.at(index);
 		// Si la linea contiene el texto [animation] se realiza el proceso de carga de una animación
 		if (line == "[animation]")
 		{
-			Animation animation = Animation();
+			Animation animation;
 			do
 			{
 				// Aumenta el indice para leer la siguiente linea
 				index++;
 				line = source.at(index);
 				size_t pos = line.find("=");
-				// Encuentra la posición del caracter '='
+				if (pos != std::string::npos)
 				int pos = line.find("=");
 				// Procesa las dos subcadenas
 				if (pos != static_cast<int>(line.npos))
 				{
-					if (line.substr(0, pos) == "name")
+					std::string key = line.substr(0, pos);
-					{
+					std::string value = line.substr(pos + 1);
 						animation.name = line.substr(pos + 1, line.length());
 					}
-					else if (line.substr(0, pos) == "speed")
+					if (key == "name")
-					{
+						animation.name = value;
-						animation.speed = std::stoi(line.substr(pos + 1, line.length()));
+					else if (key == "speed")
-					}
+						animation.speed = std::stoi(value);
-
+					else if (key == "loop")
-					else if (line.substr(0, pos) == "loop")
+						animation.loop = std::stoi(value);
-					{
+					else if (key == "frames")
 						animation.loop = std::stoi(line.substr(pos + 1, line.length()));
 					}
 					else if (line.substr(0, pos) == "frames")
 					{
 						// Se introducen los valores separados por comas en un vector
-						std::stringstream ss(line.substr(pos + 1, line.length()));
+						std::stringstream ss(value);
 						std::string tmp;
 						SDL_Rect rect = {0, 0, frame_width, frame_height};
 						while (getline(ss, tmp, ','))
 						{
 							// Comprueba que el tile no sea mayor que el maximo indice permitido
-							const int num_tile = std::stoi(tmp) > max_tiles ? 0 : std::stoi(tmp);
+							const int num_tile = std::stoi(tmp);
-							rect.x = (num_tile % frames_per_row) * frame_width;
+							if (num_tile <= max_tiles)
-							rect.y = (num_tile / frames_per_row) * frame_height;
+							{
-							animation.frames.push_back(rect);
+								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;
 						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
-			animations_.push_back(animation);
+			animations_.emplace_back(animation);
 		}
 		// En caso contrario se parsea el fichero para buscar las variables y los valores
 		else
 		{
 			// Encuentra la posición del caracter '='
 			int pos = line.find("=");
 			// Procesa las dos subcadenas
 			if (pos != (int)line.npos)
 			{
 				if (line.substr(0, pos) == "frames_per_row")
 				{
 					frames_per_row = std::stoi(line.substr(pos + 1, line.length()));
 				}
 				else if (line.substr(0, pos) == "frame_width")
 				{
 					frame_width = std::stoi(line.substr(pos + 1, line.length()));
 				}
 				else if (line.substr(0, pos) == "frame_height")
 				{
 					frame_height = std::stoi(line.substr(pos + 1, line.length()));
 				}
 				else
 				{
 					std::cout << "Warning: unknown parameter " << line.substr(0, pos).c_str() << std::endl;
 					success = false;
 				}
 				// Normaliza valores
 				if (frames_per_row == 0 && frame_width > 0)
 				{
 					frames_per_row = texture_->getWidth() / frame_width;
 				}
 				if (max_tiles == 0 && frame_width > 0 && frame_height > 0)
 				{
 					const int w = texture_->getWidth() / frame_width;
 					const int h = texture_->getHeight() / frame_height;
 					max_tiles = w * h;
 				}
 			}
 		}
 		// Una vez procesada la linea, aumenta el indice para pasar a la siguiente
@@ -526,6 +247,4 @@ bool AnimatedSprite::loadFromVector(const Animations &source)
 	// Pone un valor por defecto
 	setWidth(frame_width);
 	setHeight(frame_height);
 	return success;
 }
--- a/source/animated_sprite.h
+++ b/source/animated_sprite.h
@@ -1,12 +1,11 @@
 #pragma once
-#include <SDL2/SDL_rect.h>   // for SDL_Rect
+#include <SDL2/SDL_rect.h> // Para SDL_Rect
-#include <SDL2/SDL_stdinc.h> // for Uint8
+#include <memory>          // Para shared_ptr
-#include <memory>            // for shared_ptr
+#include <string>          // Para string
-#include <string>            // for string
+#include <vector>          // Para vector
-#include <vector>            // for vector
+#include "moving_sprite.h" // Para MovingSprite
-#include "moving_sprite.h"   // for MovingSprite
+class Texture;             // lines 9-9
 class Texture;
 struct Animation
 {
@@ -21,67 +20,40 @@ struct Animation
    Animation() : name(std::string()), speed(5), loop(0), completed(false), current_frame(0), counter(0) {}
 };
-using Animations = std::vector<std::string>;
+using AnimationsFileBuffer = std::vector<std::string>;
 // Carga las animaciones en un vector(Animations) desde un fichero
-Animations loadAnimationsFromFile(const std::string &file_path);
+AnimationsFileBuffer loadAnimationsFromFile(const std::string &file_path);
 class AnimatedSprite : public MovingSprite
 {
 protected:
    // Variables
    std::vector<Animation> animations_; // Vector con las diferentes animaciones
-    int current_animation_;             // Animacion activa
+    int current_animation_ = 0;         // Animacion activa
    // Calcula el frame correspondiente a la animación actual
    void animate();
-    // Carga la animación desde un fichero
+    // Carga la animación desde un vector de cadenas
-    std::vector<Animation> loadFromFile(const std::string &file_path);
+    void loadFromAnimationsFileBuffer(const AnimationsFileBuffer &source);
    // Carga la animación desde un vector
    bool loadFromVector(const Animations &source);
 public:
    // Constructor
    AnimatedSprite(std::shared_ptr<Texture> texture, const std::string &file_path);
-    AnimatedSprite(std::shared_ptr<Texture> texture, const Animations &animations);
+    AnimatedSprite(std::shared_ptr<Texture> texture, const AnimationsFileBuffer &animations);
-    explicit AnimatedSprite(std::shared_ptr<Texture> texture);
+    explicit AnimatedSprite(std::shared_ptr<Texture> texture)
        : MovingSprite(texture) {}
    // Destructor
-    virtual ~AnimatedSprite();
+    virtual ~AnimatedSprite() = default;
    // Actualiza las variables del objeto
    void update() override;
    // Obtiene el número de frames de la animación actual
    int getNumFrames();
    // Establece el frame actual de la animación
    void setCurrentFrame(int num);
    // Establece el valor del contador
    void setAnimationCounter(const std::string &name, int num);
    // Establece la velocidad de una animación
    void setAnimationSpeed(const std::string &name, int speed);
    void setAnimationSpeed(int index, int speed);
    // Establece el frame al que vuelve la animación al finalizar
    void setAnimationLoop(const std::string &name, int loop);
    void setAnimationLoop(int index, int loop);
    // Establece el valor de la variable
    void setAnimationCompleted(const std::string &name, bool value);
    void setAnimationCompleted(int index, bool value);
    // Comprueba si ha terminado la animación
    bool animationIsCompleted();
    // Devuelve el rectangulo de una animación y frame concreto
    SDL_Rect getAnimationClip(const std::string &name = "default", Uint8 index = 0);
    SDL_Rect getAnimationClip(int indexA = 0, Uint8 indexF = 0);
    // Obtiene el indice de la animación a partir del nombre
    int getIndex(const std::string &name);
@@ -89,12 +61,6 @@ public:
    void setCurrentAnimation(const std::string &name = "default");
    void setCurrentAnimation(int index = 0);
    // OLD - Establece el rectangulo para un frame de una animación
    void setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h);
    // OLD - Establece el contador para todas las animaciones
    void setAnimationCounter(int value);
    // Reinicia la animación
    void resetAnimation();
 };
--- a/source/asset.cpp
+++ b/source/asset.cpp
@@ -1,9 +1,9 @@
 #include "asset.h"
-#include "utils.h"
+#include <algorithm> // Para find_if, max
-#include <SDL2/SDL_rwops.h>  // for SDL_RWFromFile, SDL_RWclose, SDL_RWops
+#include <fstream>   // Para basic_ostream, operator<<, basic_ifstream, endl
-#include <SDL2/SDL_stdinc.h> // for SDL_max
+#include <iostream>  // Para cout
-#include <stddef.h>          // for size_t
+#include <string>    // Para allocator, char_traits, string, operator+, oper...
-#include <iostream>          // for basic_ostream, operator<<, cout, endl
+#include "utils.h"   // Para getFileName, printWithDots
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Asset *Asset::asset_ = nullptr;
@@ -26,42 +26,31 @@ Asset *Asset::get()
    return Asset::asset_;
 }
 // Constructor
 Asset::Asset(const std::string &executable_path)
    : executable_path_(executable_path.substr(0, executable_path.find_last_of("\\/")))
 {
    longest_name_ = 0;
 }
 // Añade un elemento a la lista
 void Asset::add(const std::string &file, AssetType type, bool required, bool absolute)
 {
-    AssetItem ai;
+    file_list_.emplace_back(absolute ? file : executable_path_ + file, type, required);
-    ai.file = absolute ? file : executable_path_ + file;
+    longest_name_ = std::max(longest_name_, static_cast<int>(file_list_.back().file.size()));
    ai.type = type;
    ai.required = required;
    file_list_.push_back(ai);
    const std::string file_name = file.substr(file.find_last_of("\\/") + 1);
    longest_name_ = SDL_max(longest_name_, file_name.size());
 }
-// Devuelve el fichero de un elemento de la lista a partir de una cadena
+// Devuelve la ruta completa a un fichero a partir de una cadena
 std::string Asset::get(const std::string &text) const
 {
-    for (const auto &f : file_list_)
+    auto it = std::find_if(file_list_.begin(), file_list_.end(),
                           [&text](const auto &f)
                           {
                               return getFileName(f.file) == text;
                           });
    if (it != file_list_.end())
    {
-        const size_t last_index = f.file.find_last_of("/") + 1;
+        return it->file;
-        const std::string file = f.file.substr(last_index, std::string::npos);
+    }
-
+    else
-        if (file == text)
+    {
-        {
+        std::cout << "Warning: file " << text << " not found" << std::endl;
-            return f.file;
+        return "";
        }
    }
    std::cout << "Warning: file " << text.c_str() << " not found" << std::endl;
    return "";
 }
 // Comprueba que existen todos los elementos
@@ -114,20 +103,12 @@ bool Asset::check() const
 // Comprueba que existe un fichero
 bool Asset::checkFile(const std::string &path) const
 {
-    auto success = false;
+    std::ifstream file(path);
    bool success = file.good();
    file.close();
    // Comprueba si existe el fichero
    auto file = SDL_RWFromFile(path.c_str(), "rb");
    if (file)
    {
        success = true;
        SDL_RWclose(file);
    }
    const std::string file_name = path.substr(path.find_last_of("\\/") + 1);
    if (!success)
-        printWithDots("Checking file : ", file_name, (success ? " [ OK ]" : " [ ERROR ]"));
+        printWithDots("Checking file : ", getFileName(path), "[ ERROR ]");
    return success;
 }
--- a/source/asset.h
+++ b/source/asset.h
@@ -1,7 +1,8 @@
 #pragma once
-#include <string> // for string, basic_string
+#include <string> // para string, basic_string
-#include <vector> // for vector
+#include <vector> // para vector
 #include "utils.h"
 enum class AssetType : int
 {
@@ -27,14 +28,17 @@ private:
 	// Estructura para definir un item
 	struct AssetItem
 	{
-		std::string file;	 // Ruta del fichero desde la raiz del directorio
+		std::string file; // Ruta del fichero desde la raíz del directorio
-		enum AssetType type; // Indica el tipo de recurso
+		AssetType type;	  // Indica el tipo de recurso
-		bool required;		 // Indica si es un fichero que debe de existir
+		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
+
 		// Constructor
 		AssetItem(const std::string &filePath, AssetType assetType, bool isRequired)
 			: file(filePath), type(assetType), required(isRequired) {}
 	};
 	// Variables
-	int longest_name_;				   // Contiene la longitud del nombre de fichero mas largo
+	int longest_name_ = 0;			   // Contiene la longitud del nombre de fichero mas largo
 	std::vector<AssetItem> file_list_; // Listado con todas las rutas a los ficheros
 	std::string executable_path_;	   // Ruta al ejecutable
@@ -45,7 +49,8 @@ private:
 	std::string getTypeName(AssetType type) const;
 	// Constructor
-	explicit Asset(const std::string &executable_path);
+	explicit Asset(const std::string &executable_path)
 		: executable_path_(getPath(executable_path)) {}
 	// Destructor
 	~Asset() = default;
@@ -63,7 +68,7 @@ public:
 	// Añade un elemento a la lista
 	void add(const std::string &file, AssetType type, bool required = true, bool absolute = false);
-	// Devuelve un elemento de la lista a partir de una cadena
+	// Devuelve la ruta completa a un fichero a partir de una cadena
 	std::string get(const std::string &text) const;
 	// Comprueba que existen todos los elementos
--- a/source/background.cpp
+++ b/source/background.cpp
@@ -1,40 +1,35 @@
 #include "background.h"
-#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_pixels.h>    // for SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888
-#include <algorithm>            // for clamp, max
+#include <algorithm>            // Para clamp, max
-#include "asset.h"              // for Asset
+#include "moving_sprite.h"      // Para MovingSprite
-#include "moving_sprite.h"      // for MovingSprite
+#include "param.h"              // Para Param, ParamBackground, param
-#include "param.h"              // for param
+#include "resource.h"           // Para Resource
-#include "resource.h"           // for Resource
+#include "screen.h"             // Para Screen
-#include "sprite.h"             // for Sprite
+#include "sprite.h"             // Para Sprite
-#include "texture.h"            // for Texture
+#include "texture.h"            // Para Texture
 // Constructor
-Background::Background(SDL_Renderer *renderer)
+Background::Background()
-    : renderer_(renderer),
+    : 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"))
+      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)
 {
    // Inicializa variables
    {
        gradient_number_ = 0;
        alpha_ = 0;
        clouds_speed_ = 0;
        transition_ = 0;
        counter_ = 0;
        rect_ = {0, 0, gradients_texture_->getWidth() / 2, gradients_texture_->getHeight() / 2};
        src_rect_ = {0, 0, 320, 240};
        dst_rect_ = {0, 0, 320, 240};
        base_ = rect_.h;
        color_ = {param.background.attenuate_color.r, param.background.attenuate_color.g, param.background.attenuate_color.b};
        alpha_color_text_ = alpha_color_text_temp_ = param.background.attenuate_alpha;
        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};
@@ -87,11 +82,11 @@ Background::Background(SDL_Renderer *renderer)
    }
    // Crea la textura para componer el fondo
-    canvas_ = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
+    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
-    color_texture_ = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
+    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_);
@@ -120,7 +115,7 @@ void Background::update()
    alpha_ = std::max((255 - (int)(255 * transition_)), 0);
    // Incrementa el contador
-    counter_++;
+    ++counter_;
    // Compone todos los elementos del fondo en la textura
    fillCanvas();
@@ -252,18 +247,6 @@ void Background::setPos(SDL_Rect pos)
    src_rect_.h = pos.h;
 }
 // Ajusta el valor de la variable
 void Background::setSrcRect(SDL_Rect value)
 {
    src_rect_ = value;
 }
 // Ajusta el valor de la variable
 void Background::setDstRect(SDL_Rect value)
 {
    dst_rect_ = value;
 }
 // Establece el color_ de atenuación
 void Background::setColor(Color color)
 {
--- a/source/background.h
+++ b/source/background.h
@@ -1,9 +1,9 @@
 #pragma once
-#include <SDL2/SDL_rect.h>   // for SDL_Rect
+#include <SDL2/SDL_rect.h>   // para SDL_Rect
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
-#include <memory>            // for unique_ptr, shared_ptr
+#include <memory>            // para unique_ptr, shared_ptr
-#include "utils.h"           // for Color
+#include "utils.h"           // para Color
 class MovingSprite;
 class Sprite;
 class Texture;
@@ -32,12 +32,6 @@ class Texture;
        - setTransition(float value)
          Porcentaje (entre 0.0f (textura actual) y 1.0f (textura siguiente)) para mostrar entre la textura de fondo actual y la siguiente
        - setSrcRect(SDL_Rect value)
          Rectangulo de la textura de fondo que se desea mostrar
        - setDstRecr(SDL_Rect value)
          Rectangulo de destino donde se mostrará el rectángulo antrior. Automaticamente modifica srcRect para coincidor en tamaño con el destino.
        - setColor(Color color)
          Establece el color de la textura de superposición
@@ -74,11 +68,11 @@ private:
  SDL_Rect gradient_rect_[4];      // Vector con las coordenadas de los 4 degradados para el cielo
  SDL_Rect top_clouds_rect_[4];    // Vector con las coordenadas de los 4 nubes de arriba
  SDL_Rect bottom_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de abajo
-  int gradient_number_;            // Indica el número de degradado de fondo que se va a dibujar
+  int gradient_number_ = 0;        // Indica el número de degradado de fondo que se va a dibujar
-  int alpha_;                      // Transparencia entre los dos degradados
+  int alpha_ = 0;                  // Transparencia entre los dos degradados
-  float clouds_speed_;             // Velocidad a la que se desplazan las nubes
+  float clouds_speed_ = 0;         // Velocidad a la que se desplazan las nubes
-  float transition_;               // Nivel de transición del fondo 0..1
+  float transition_ = 0;           // Nivel de transición del fondo 0..1
-  int counter_;                    // Contador interno
+  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
@@ -107,7 +101,7 @@ private:
 public:
  // Constructor
-  explicit Background(SDL_Renderer *renderer);
+  Background();
  // Destructor
  ~Background();
@@ -133,12 +127,6 @@ public:
  // Ajusta el valor de la variable
  void setTransition(float value);
  // Ajusta el valor de la variable
  void setSrcRect(SDL_Rect value);
  // Ajusta el valor de la variable
  void setDstRect(SDL_Rect value);
  // Establece el color de atenuación
  void setColor(Color color);
--- a/source/balloon.cpp
+++ b/source/balloon.cpp
--- a/source/balloon.h
+++ b/source/balloon.h
@@ -1,42 +1,38 @@
 #pragma once
-#include <SDL2/SDL_stdinc.h> // for Uint8, Uint16, Uint32
+#include <SDL2/SDL_stdinc.h> // Para Uint8, Uint16, Uint32
-#include <memory>			 // for shared_ptr, unique_ptr
+#include <memory>			 // Para shared_ptr, unique_ptr
-#include <string>			 // for string
+#include <string>			 // Para string
-#include <vector>			 // for vector
+#include <vector>			 // Para vector
-#include "animated_sprite.h" // for SpriteAnimated
+#include "animated_sprite.h" // Para AnimatedSprite
-#include "utils.h"			 // for Circle
+#include "utils.h"			 // Para Circle
-class Texture;
+class Texture;				 // lines 10-10
 // Cantidad de elementos del vector con los valores de la deformación del globo al rebotar
 constexpr int MAX_BOUNCE = 10;
 // Tipos de globo
 constexpr int BALLOON_1 = 1;
 constexpr int BALLOON_2 = 2;
 constexpr int BALLOON_3 = 3;
 constexpr int BALLOON_4 = 4;
 constexpr int HEXAGON_1 = 5;
 constexpr int HEXAGON_2 = 6;
 constexpr int HEXAGON_3 = 7;
 constexpr int HEXAGON_4 = 8;
 constexpr int POWER_BALL = 9;
 // Puntos de globo
-constexpr int BALLOON_SCORE_1 = 50;
+constexpr int BALLOON_SCORE[] = {50, 100, 200, 400};
-constexpr int BALLOON_SCORE_2 = 100;
+constexpr int BALLOON_POWER[] = {1, 3, 7, 15};
-constexpr int BALLOON_SCORE_3 = 200;
+constexpr int BALLOON_MENACE[] = {1, 2, 4, 8};
-constexpr int BALLOON_SCORE_4 = 400;
+constexpr int BALLOON_SIZE[] = {10, 16, 26, 46};
 // Tamaños de globo
-constexpr int BALLOON_SIZE_1 = 1;
+enum class BalloonSize : Uint8
-constexpr int BALLOON_SIZE_2 = 2;
+{
-constexpr int BALLOON_SIZE_3 = 3;
+	SIZE1 = 0,
-constexpr int BALLOON_SIZE_4 = 4;
+	SIZE2 = 1,
 	SIZE3 = 2,
 	SIZE4 = 3,
 };
 // Clases de globo
-constexpr int BALLOON_CLASS = 0;
+enum class BalloonType : Uint8
-constexpr int HEXAGON_CLASS = 1;
+{
 	BALLOON = 0,
 	FLOATER = 1,
 	POWERBALL = 2,
 };
 // Velocidad del globo
 constexpr float BALLOON_VELX_POSITIVE = 0.7f;
@@ -47,21 +43,8 @@ constexpr int BALLOON_MOVING_ANIMATION = 0;
 constexpr int BALLOON_POP_ANIMATION = 1;
 constexpr int BALLOON_BORN_ANIMATION = 2;
 // Cantidad posible de globos
 constexpr int MAX_BALLOONS = 100;
 // Velocidades a las que se mueven los globos
-constexpr float BALLOON_SPEED_1 = 0.60f;
+constexpr float BALLOON_SPEED[] = {0.60f, 0.70f, 0.80f, 0.90f, 1.00f};
 constexpr float BALLOON_SPEED_2 = 0.70f;
 constexpr float BALLOON_SPEED_3 = 0.80f;
 constexpr float BALLOON_SPEED_4 = 0.90f;
 constexpr float BALLOON_SPEED_5 = 1.00f;
 // Tamaño de los globos
 constexpr int BALLOON_WIDTH_1 = 10;
 constexpr int BALLOON_WIDTH_2 = 16;
 constexpr int BALLOON_WIDTH_3 = 26;
 constexpr int BALLOON_WIDTH_4 = 46;
 // PowerBall
 constexpr int POWERBALL_SCREENPOWER_MINIMUM = 10;
@@ -71,61 +54,78 @@ constexpr int POWERBALL_COUNTER = 8;
 class Balloon
 {
 private:
-	// Estructura para las variables para el efecto de los rebotes
+	// Estructura para el efecto de los rebotes en los globos
 	struct Bouncing
 	{
-		bool enabled;		  // Si el efecto está activo
+		bool enabled = false; // Si el efecto está activo
-		Uint8 counter;		  // Countador para el efecto
+		Uint8 counter = 0;	  // Contador para el efecto
-		Uint8 speed;		  // Velocidad a la que transcurre el efecto
+		Uint8 speed = 2;	  // Velocidad a la que transcurre el efecto
-		float zoomW;		  // Zoom aplicado a la anchura
+		float zoomW = 1.0f;	  // Zoom aplicado a la anchura
-		float zoomH;		  // Zoom aplicado a la altura
+		float zoomH = 1.0f;	  // Zoom aplicado a la altura
-		float despX;		  // Desplazamiento de pixeles en el eje X antes de pintar el objeto con zoom
+		float despX = 0.0f;	  // 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
+		float despY = 0.0f;	  // 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
+		float w[MAX_BOUNCE] = {1.10f, 1.05f, 1.00f, 0.95f, 0.90f, 0.95f, 1.00f, 1.02f, 1.05f, 1.02f}; // Vector con los valores de zoom para el ancho del globo
-	};
+		float h[MAX_BOUNCE] = {0.90f, 0.95f, 1.00f, 1.05f, 1.10f, 1.05f, 1.00f, 0.98f, 0.95f, 0.98f}; // Vector con los valores de zoom para el alto del globo
 		// Constructor por defecto
 		Bouncing() = default;
 		// Método reset
 		void reset()
 		{
 			counter = 0;
 			zoomW = 1.0f;
 			zoomH = 1.0f;
 			despX = 0.0f;
 			despY = 0.0f;
 		}
 	} bouncing_;
 	// Objetos y punteros
 	std::unique_ptr<AnimatedSprite> sprite_; // Sprite del objeto globo
 	// Variables
-	float pos_x_;				  // Posición en el eje X
+	float x_;						   // Posición en el eje X
-	float pos_y_;				  // Posición en el eje Y
+	float y_;						   // Posición en el eje Y
-	Uint8 width_;				  // Ancho
+	Uint8 w_;						   // Ancho
-	Uint8 height_;				  // Alto
+	Uint8 h_;						   // Alto
-	float vel_x_;				  // Velocidad en el eje X. Cantidad de pixeles a desplazarse
+	float vx_;						   // Velocidad en el eje X. Cantidad de pixeles a desplazarse
-	float vel_y_;				  // Velocidad en el eje Y. 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 gravity_;					   // Aceleración en el eje Y. Modifica la velocidad
-	float default_vel_y_;		  // Velocidad inicial que tienen al rebotar contra el suelo
+	float default_vy_;				   // Velocidad inicial que tienen al rebotar contra el suelo
-	float max_vel_y_;			  // Máxima velocidad que puede alcanzar el objeto en el eje Y
+	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 being_created_;			   // Indica si el globo se está creando
-	bool blinking_;				  // Indica si el globo está intermitente
+	bool enabled_ = true;			   // Indica si el globo esta activo
-	bool enabled_;				  // Indica si el globo esta activo
+	bool invulnerable_;				   // Indica si el globo es invulnerable
-	bool invulnerable_;			  // Indica si el globo es invulnerable
+	bool stopped_;					   // Indica si el globo está parado
-	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
-	bool visible_;				  // Indica si el globo es visible
+	Circle collider_;				   // Circulo de colisión del objeto
-	Circle collider_;			  // Circulo de colisión del objeto
+	Uint16 creation_counter_;		   // Temporizador para controlar el estado "creandose"
-	Uint16 creation_counter_;	  // Temporizador para controlar el estado "creandose"
+	Uint16 creation_counter_ini_;	   // Valor inicial para el temporizador para controlar el estado "creandose"
-	Uint16 creation_counter_ini_; // Valor inicial para el temporizador para controlar el estado "creandose"
+	Uint16 score_;					   // Puntos que da el globo al ser destruido
-	Uint16 score_;				  // Puntos que da el globo al ser destruido
+	BalloonType type_;				   // Clase de globo
-	Uint16 stopped_counter_;	  // Contador para controlar el estado "parado"
+	BalloonSize size_;				   // Tamaño del globo
-	Uint8 kind_;				  // Tipo de globo
+	Uint8 menace_;					   // Cantidad de amenaza que genera el globo
-	Uint8 menace_;				  // Cantidad de amenaza que genera el globo
+	Uint32 counter_ = 0;			   // Contador interno
-	Uint32 counter_;			  // 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 travel_y_;			  // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
+	float speed_;					   // Velocidad a la que se mueven los globos
-	float speed_;				  // Velocidad a la que se mueven los globos
+	Uint8 power_;					   // Cantidad de poder que alberga el globo
 	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
 	// Alinea el circulo de colisión con la posición del objeto globo
-	void updateColliders();
+	void shiftColliders();
 	// Alinea el sprite con la posición del objeto globo
 	void shiftSprite();
 	// Establece el nivel de zoom del sprite
 	void zoomSprite();
 	// Activa el efecto
-	void bounceStart();
+	void enableBounce();
 	// Detiene el efecto
-	void bounceStop();
+	void disableBounce();
 	// Aplica el efecto
 	void updateBounce();
@@ -134,20 +134,17 @@ private:
 	void updateState();
 	// Establece la animación correspondiente
-	void updateAnimation();
+	void setAnimation();
 	// Establece el valor de la variable
 	void setBeingCreated(bool value);
 public:
 	// Constructor
-	Balloon(float x, float y, Uint8 kind, float vel_x, float speed, Uint16 creation_timer, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
+	Balloon(float x, float y, BalloonType type, BalloonSize size, float vel_x, float speed, Uint16 creation_timer, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
 	// Destructor
 	~Balloon() = default;
 	// Centra el globo en la posición X
-	void allignTo(int x);
+	void alignTo(int x);
 	// Pinta el globo en la pantalla
 	void render();
@@ -164,87 +161,38 @@ public:
 	// Actualiza al globo a su posicion, animación y controla los contadores
 	void update();
-	// Comprueba si el globo está habilitado
+	// Detiene el globo
-	bool isEnabled() const;
+	void stop();
-	// Obtiene del valor de la variable
+	// Pone el globo en movimiento
 	void start();
 	// Pone el color alternativo en el globo
 	void useReverseColor();
 	// Pone el color normal en el globo
 	void useNormalColor();
 	// Getters
 	float getPosX() const;
 	// Obtiene del valor de la variable
 	float getPosY() const;
 	// Obtiene del valor de la variable
 	float getVelY() const;
 	// Obtiene del valor de la variable
 	int getWidth() const;
 	// Obtiene del valor de la variable
 	int getHeight() const;
-
+	BalloonSize getSize() const;
-	// Establece el valor de la variable
+	BalloonType getType() const;
 	void setVelY(float vel_y);
 	// Establece el valor de la variable
 	void setSpeed(float speed);
 	// Obtiene del valor de la variable
 	int getKind() const;
 	// Obtiene del valor de la variable
 	Uint8 getSize() const;
 	// Obtiene la clase a la que pertenece el globo
 	Uint8 getClass() const;
 	// Establece el valor de la variable
 	void setStop(bool value);
 	// Obtiene del valor de la variable
 	bool isStopped() const;
 	// Establece el valor de la variable
 	void setBlink(bool value);
 	// Obtiene del valor de la variable
 	bool isBlinking() const;
 	// Establece el valor de la variable
 	void setVisible(bool value);
 	// Obtiene del valor de la variable
 	bool isVisible() const;
 	// Establece el valor de la variable
 	void setInvulnerable(bool value);
 	// Obtiene del valor de la variable
 	bool isInvulnerable() const;
 	// Obtiene del valor de la variable
 	bool isBeingCreated() const;
 	// Establece el valor de la variable
 	void setStoppedTimer(Uint16 time);
 	// Obtiene del valor de la variable
 	Uint16 getStoppedTimer() const;
 	// Obtiene del valor de la variable
 	Uint16 getScore() const;
 	// Obtiene el circulo de colisión
 	Circle &getCollider();
 	// Obtiene le valor de la variable
 	Uint8 getMenace() const;
 	// Obtiene le valor de la variable
 	Uint8 getPower() const;
-
+	bool isStopped() const;
-	// Indica si el globo se puede explotar
+	bool isInvulnerable() const;
 	bool isBeingCreated() const;
 	bool isEnabled() const;
 	bool isUsingReversedColor();
 	bool canBePopped() const;
-	// Indica si el globo se puede destruir
+	// Setters
-	bool canBeDestroyed() const;
+	void setVelY(float vel_y);
 	void setSpeed(float speed);
 	void setInvulnerable(bool value);
 };
--- a/source/balloon_formations.cpp
+++ b/source/balloon_formations.cpp
@@ -1,7 +1,7 @@
 #include "balloon_formations.h"
-#include "balloon.h" // for BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
+#include "balloon.h" // para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
-#include "param.h"	 // for param
+#include "param.h"	 // para param
-#include "utils.h"	 // for ParamGame, Param, Zone, BLOCK
+#include "utils.h"	 // para ParamGame, Param, Zone, BLOCK
 // Constructor
 BalloonFormations::BalloonFormations()
@@ -16,36 +16,32 @@ 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_WIDTH_4;
+	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_WIDTH_3;
+	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_WIDTH_2;
+	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_WIDTH_1 / 2);
+	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_WIDTH_1;
+	const int x1_100 = param.game.play_area.rect.w - BALLOON_SIZE[0];
 	// Inicializa a cero las variables
-	for (int i = 0; i < NUMBER_OF_BALLOON_FORMATIONS; i++)
+	for (int j = 0; j < NUMBER_OF_BALLOON_FORMATIONS; ++j)
 	{
-		balloon_formation_[i].number_of_balloons = 0;
+		balloon_formation_[j].number_of_balloons = 0;
-		for (int j = 0; j < MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION; j++)
+		for (int i = 0; i < MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION; ++i)
 		{
-			balloon_formation_[i].init[j].x = 0;
+			balloon_formation_[j].init[i] = BalloonFormationParams();
 			balloon_formation_[i].init[j].y = 0;
 			balloon_formation_[i].init[j].vel_x = 0;
 			balloon_formation_[i].init[j].kind = 0;
 			balloon_formation_[i].init[j].creation_counter = 0;
 		}
 	}
-	const int creation_time = 300;
+	constexpr int CREATION_TIME = 300;
 	int inc_x = 0;
 	int inc_time = 0;
 	int j = 0;
@@ -60,8 +56,8 @@ void BalloonFormations::initBalloonFormations()
 		balloon_formation_[j].init[i].x = x4_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y4;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
-		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE4;
-		balloon_formation_[j].init[i].creation_counter = creation_time + (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME + (inc_time * i);
 	}
 	// #01 - Dos enemigos BALLOON4 uno a cada cuarto. Ambos van hacia el centro
@@ -71,269 +67,269 @@ void BalloonFormations::initBalloonFormations()
 	inc_time = 0;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
-		balloon_formation_[j].init[i].x = param.game.play_area.first_quarter_x - (BALLOON_WIDTH_4 / 2) + (i * inc_x);
+		balloon_formation_[j].init[i].x = param.game.play_area.first_quarter_x - (BALLOON_SIZE[3] / 2) + (i * inc_x);
 		balloon_formation_[j].init[i].y = y4;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
-		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE4;
-		balloon_formation_[j].init[i].creation_counter = creation_time + (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME + (inc_time * i);
 	}
 	// #02 - Cuatro enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
 	j = 2;
 	balloon_formation_[j].number_of_balloons = 4;
-	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_x = BALLOON_SIZE[1] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x2_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y2;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_2;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE2;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #03 - Cuatro enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
 	j = 3;
 	balloon_formation_[j].number_of_balloons = 4;
-	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_x = BALLOON_SIZE[1] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x2_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y2;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_2;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE2;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #04 - Tres enemigos BALLOON3. 0, 25, 50. Hacia la derecha
 	j = 4;
 	balloon_formation_[j].number_of_balloons = 3;
-	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_x = BALLOON_SIZE[2] * 2;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #05 - Tres enemigos BALLOON3. 50, 75, 100. Hacia la izquierda
 	j = 5;
 	balloon_formation_[j].number_of_balloons = 3;
-	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_x = BALLOON_SIZE[2] * 2;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #06 - Tres enemigos BALLOON3. 0, 0, 0. Hacia la derecha
 	j = 6;
 	balloon_formation_[j].number_of_balloons = 3;
-	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_x = BALLOON_SIZE[2] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #07 - Tres enemigos BALLOON3. 100, 100, 100. Hacia la izquierda
 	j = 7;
 	balloon_formation_[j].number_of_balloons = 3;
-	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_x = BALLOON_SIZE[2] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #08 - Seis enemigos BALLOON1. 0, 0, 0, 0, 0, 0. Hacia la derecha
 	j = 8;
 	balloon_formation_[j].number_of_balloons = 6;
-	inc_x = BALLOON_WIDTH_1 + 1;
+	inc_x = BALLOON_SIZE[0] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x1_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y1;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE1;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #09 - Seis enemigos BALLOON1. 100, 100, 100, 100, 100, 100. Hacia la izquierda
 	j = 9;
 	balloon_formation_[j].number_of_balloons = 6;
-	inc_x = BALLOON_WIDTH_1 + 1;
+	inc_x = BALLOON_SIZE[0] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x1_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y1;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE1;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #10 - Tres enemigos BALLOON4 seguidos desde la izquierda
 	j = 10;
 	balloon_formation_[j].number_of_balloons = 3;
-	inc_x = BALLOON_WIDTH_4 + 1;
+	inc_x = BALLOON_SIZE[3] + 1;
 	inc_time = 15;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x4_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y4;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE4;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #11 - Tres enemigos BALLOON4 seguidos desde la derecha
 	j = 11;
 	balloon_formation_[j].number_of_balloons = 3;
-	inc_x = BALLOON_WIDTH_4 + 1;
+	inc_x = BALLOON_SIZE[3] + 1;
 	inc_time = 15;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x4_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y4;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE4;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #12 - Seis enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
 	j = 12;
 	balloon_formation_[j].number_of_balloons = 6;
-	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_x = BALLOON_SIZE[1] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x2_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y2;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_2;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE2;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #13 - Seis enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
 	j = 13;
 	balloon_formation_[j].number_of_balloons = 6;
-	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_x = BALLOON_SIZE[1] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x2_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y2;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_2;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE2;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #14 - Cinco enemigos BALLOON3. Hacia la derecha. Separados
 	j = 14;
 	balloon_formation_[j].number_of_balloons = 5;
-	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_x = BALLOON_SIZE[2] * 2;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #15 - Cinco enemigos BALLOON3. Hacia la izquierda. Separados
 	j = 15;
 	balloon_formation_[j].number_of_balloons = 5;
-	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_x = BALLOON_SIZE[2] * 2;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #16 - Cinco enemigos BALLOON3. Hacia la derecha. Juntos
 	j = 16;
 	balloon_formation_[j].number_of_balloons = 5;
-	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_x = BALLOON_SIZE[2] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #17 - Cinco enemigos BALLOON3. Hacia la izquierda. Juntos
 	j = 17;
 	balloon_formation_[j].number_of_balloons = 5;
-	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_x = BALLOON_SIZE[2] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #18 - Doce enemigos BALLOON1. Hacia la derecha. Juntos
 	j = 18;
 	balloon_formation_[j].number_of_balloons = 12;
-	inc_x = BALLOON_WIDTH_1 + 1;
+	inc_x = BALLOON_SIZE[0] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x1_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y1;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE1;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #19 - Doce enemigos BALLOON1. Hacia la izquierda. Juntos
 	j = 19;
 	balloon_formation_[j].number_of_balloons = 12;
-	inc_x = BALLOON_WIDTH_1 + 1;
+	inc_x = BALLOON_SIZE[0] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x1_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y1;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE1;
-		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
 	}
 	// #20 - Dos enemigos BALLOON4 seguidos desde la izquierda/derecha. Simetricos
 	j = 20;
 	balloon_formation_[j].number_of_balloons = 4;
-	inc_x = BALLOON_WIDTH_4 + 1;
+	inc_x = BALLOON_SIZE[3] + 1;
 	inc_time = 0;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
@@ -349,14 +345,14 @@ void BalloonFormations::initBalloonFormations()
 			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
 		}
 		balloon_formation_[j].init[i].y = y4;
-		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE4;
-		balloon_formation_[j].init[i].creation_counter = creation_time + (inc_time * i);
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME + (inc_time * i);
 	}
 	// #21 - Diez enemigos BALLOON2 uno detras del otro. Izquierda/derecha. Simetricos
 	j = 21;
 	balloon_formation_[j].number_of_balloons = 10;
-	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_x = BALLOON_SIZE[1] + 1;
 	inc_time = 3;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
@@ -365,22 +361,22 @@ void BalloonFormations::initBalloonFormations()
 		{
 			balloon_formation_[j].init[i].x = x2_0 + (i * inc_x);
 			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * i);
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) - (inc_time * i);
 		}
 		else
 		{
 			balloon_formation_[j].init[i].x = x2_100 - ((i - half) * inc_x);
 			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * (i - half));
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) - (inc_time * (i - half));
 		}
 		balloon_formation_[j].init[i].y = y2;
-		balloon_formation_[j].init[i].kind = BALLOON_2;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE2;
 	}
 	// #22 - Diez enemigos BALLOON3. Hacia la derecha/izquierda. Separados. Simetricos
 	j = 22;
 	balloon_formation_[j].number_of_balloons = 10;
-	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_x = BALLOON_SIZE[2] * 2;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
@@ -389,22 +385,22 @@ void BalloonFormations::initBalloonFormations()
 		{
 			balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
 			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * i);
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) - (inc_time * i);
 		}
 		else
 		{
 			balloon_formation_[j].init[i].x = x3_100 - ((i - half) * inc_x);
 			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * (i - half));
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) - (inc_time * (i - half));
 		}
 		balloon_formation_[j].init[i].y = y3;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
 	}
 	// #23 - Diez enemigos BALLOON3. Hacia la derecha. Juntos. Simetricos
 	j = 23;
 	balloon_formation_[j].number_of_balloons = 10;
-	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_x = BALLOON_SIZE[2] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
@@ -413,16 +409,16 @@ void BalloonFormations::initBalloonFormations()
 		{
 			balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
 			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * i);
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) - (inc_time * i);
 		}
 		else
 		{
 			balloon_formation_[j].init[i].x = x3_100 - ((i - half) * inc_x);
 			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * (i - half));
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) - (inc_time * (i - half));
 		}
 		balloon_formation_[j].init[i].y = y3;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
 	}
 	// #24 - Treinta enemigos BALLOON1. Del centro hacia los extremos. Juntos. Simetricos
@@ -436,16 +432,16 @@ void BalloonFormations::initBalloonFormations()
 		{
 			balloon_formation_[j].init[i].x = x1_50;
 			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-			balloon_formation_[j].init[i].creation_counter = (creation_time) + (inc_time * i);
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) + (inc_time * i);
 		}
 		else
 		{
 			balloon_formation_[j].init[i].x = x1_50;
 			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-			balloon_formation_[j].init[i].creation_counter = (creation_time) + (inc_time * (i - half));
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) + (inc_time * (i - half));
 		}
 		balloon_formation_[j].init[i].y = y1;
-		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE1;
 	}
 	// #25 - Treinta enemigos BALLOON1. Del centro hacia adentro. Juntos. Simetricos
@@ -459,16 +455,16 @@ void BalloonFormations::initBalloonFormations()
 		{
 			balloon_formation_[j].init[i].x = x1_50 + 20;
 			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * i);
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) - (inc_time * i);
 		}
 		else
 		{
 			balloon_formation_[j].init[i].x = x1_50 - 20;
 			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * (i - half));
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) - (inc_time * (i - half));
 		}
 		balloon_formation_[j].init[i].y = y1;
-		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE1;
 	}
 	// Crea las mismas formaciones pero con hexagonos a partir de la posición 50 del vector
@@ -481,7 +477,8 @@ void BalloonFormations::initBalloonFormations()
 			balloon_formation_[k + 50].init[i].y = balloon_formation_[k].init[i].y;
 			balloon_formation_[k + 50].init[i].vel_x = balloon_formation_[k].init[i].vel_x;
 			balloon_formation_[k + 50].init[i].creation_counter = balloon_formation_[k].init[i].creation_counter;
-			balloon_formation_[k + 50].init[i].kind = balloon_formation_[k].init[i].kind + 4;
+			balloon_formation_[k + 50].init[i].size = balloon_formation_[k].init[i].size;
 			balloon_formation_[k + 50].init[i].type = BalloonType::FLOATER;
 		}
 	}
@@ -491,25 +488,25 @@ void BalloonFormations::initBalloonFormations()
 	balloon_formation_[99].init[0].x = 10;
 	balloon_formation_[99].init[0].y = y1;
 	balloon_formation_[99].init[0].vel_x = 0;
-	balloon_formation_[99].init[0].kind = BALLOON_1;
+	balloon_formation_[99].init[0].size = BalloonSize::SIZE1;
 	balloon_formation_[99].init[0].creation_counter = 200;
 	balloon_formation_[99].init[1].x = 50;
 	balloon_formation_[99].init[1].y = y1;
 	balloon_formation_[99].init[1].vel_x = 0;
-	balloon_formation_[99].init[1].kind = BALLOON_2;
+	balloon_formation_[99].init[1].size = BalloonSize::SIZE2;
 	balloon_formation_[99].init[1].creation_counter = 200;
 	balloon_formation_[99].init[2].x = 90;
 	balloon_formation_[99].init[2].y = y1;
 	balloon_formation_[99].init[2].vel_x = 0;
-	balloon_formation_[99].init[2].kind = BALLOON_3;
+	balloon_formation_[99].init[2].size = BalloonSize::SIZE3;
 	balloon_formation_[99].init[2].creation_counter = 200;
 	balloon_formation_[99].init[3].x = 140;
 	balloon_formation_[99].init[3].y = y1;
 	balloon_formation_[99].init[3].vel_x = 0;
-	balloon_formation_[99].init[3].kind = BALLOON_4;
+	balloon_formation_[99].init[3].size = BalloonSize::SIZE4;
 	balloon_formation_[99].init[3].creation_counter = 200;
 }
@@ -517,124 +514,124 @@ void BalloonFormations::initBalloonFormations()
 void BalloonFormations::initBalloonFormationPools()
 {
 	// EnemyPool #0
-	balloon_formation_pool_[0].set[0] = &balloon_formation_[0];
+	balloon_formation_pool_[0].set[0] = balloon_formation_[0];
-	balloon_formation_pool_[0].set[1] = &balloon_formation_[1];
+	balloon_formation_pool_[0].set[1] = balloon_formation_[1];
-	balloon_formation_pool_[0].set[2] = &balloon_formation_[2];
+	balloon_formation_pool_[0].set[2] = balloon_formation_[2];
-	balloon_formation_pool_[0].set[3] = &balloon_formation_[3];
+	balloon_formation_pool_[0].set[3] = balloon_formation_[3];
-	balloon_formation_pool_[0].set[4] = &balloon_formation_[4];
+	balloon_formation_pool_[0].set[4] = balloon_formation_[4];
-	balloon_formation_pool_[0].set[5] = &balloon_formation_[5];
+	balloon_formation_pool_[0].set[5] = balloon_formation_[5];
-	balloon_formation_pool_[0].set[6] = &balloon_formation_[6];
+	balloon_formation_pool_[0].set[6] = balloon_formation_[6];
-	balloon_formation_pool_[0].set[7] = &balloon_formation_[7];
+	balloon_formation_pool_[0].set[7] = balloon_formation_[7];
-	balloon_formation_pool_[0].set[8] = &balloon_formation_[8];
+	balloon_formation_pool_[0].set[8] = balloon_formation_[8];
-	balloon_formation_pool_[0].set[9] = &balloon_formation_[9];
+	balloon_formation_pool_[0].set[9] = balloon_formation_[9];
 	// EnemyPool #1
-	balloon_formation_pool_[1].set[0] = &balloon_formation_[10];
+	balloon_formation_pool_[1].set[0] = balloon_formation_[10];
-	balloon_formation_pool_[1].set[1] = &balloon_formation_[11];
+	balloon_formation_pool_[1].set[1] = balloon_formation_[11];
-	balloon_formation_pool_[1].set[2] = &balloon_formation_[12];
+	balloon_formation_pool_[1].set[2] = balloon_formation_[12];
-	balloon_formation_pool_[1].set[3] = &balloon_formation_[13];
+	balloon_formation_pool_[1].set[3] = balloon_formation_[13];
-	balloon_formation_pool_[1].set[4] = &balloon_formation_[14];
+	balloon_formation_pool_[1].set[4] = balloon_formation_[14];
-	balloon_formation_pool_[1].set[5] = &balloon_formation_[15];
+	balloon_formation_pool_[1].set[5] = balloon_formation_[15];
-	balloon_formation_pool_[1].set[6] = &balloon_formation_[16];
+	balloon_formation_pool_[1].set[6] = balloon_formation_[16];
-	balloon_formation_pool_[1].set[7] = &balloon_formation_[17];
+	balloon_formation_pool_[1].set[7] = balloon_formation_[17];
-	balloon_formation_pool_[1].set[8] = &balloon_formation_[18];
+	balloon_formation_pool_[1].set[8] = balloon_formation_[18];
-	balloon_formation_pool_[1].set[9] = &balloon_formation_[19];
+	balloon_formation_pool_[1].set[9] = balloon_formation_[19];
 	// EnemyPool #2
-	balloon_formation_pool_[2].set[0] = &balloon_formation_[0];
+	balloon_formation_pool_[2].set[0] = balloon_formation_[0];
-	balloon_formation_pool_[2].set[1] = &balloon_formation_[1];
+	balloon_formation_pool_[2].set[1] = balloon_formation_[1];
-	balloon_formation_pool_[2].set[2] = &balloon_formation_[2];
+	balloon_formation_pool_[2].set[2] = balloon_formation_[2];
-	balloon_formation_pool_[2].set[3] = &balloon_formation_[3];
+	balloon_formation_pool_[2].set[3] = balloon_formation_[3];
-	balloon_formation_pool_[2].set[4] = &balloon_formation_[4];
+	balloon_formation_pool_[2].set[4] = balloon_formation_[4];
-	balloon_formation_pool_[2].set[5] = &balloon_formation_[55];
+	balloon_formation_pool_[2].set[5] = balloon_formation_[55];
-	balloon_formation_pool_[2].set[6] = &balloon_formation_[56];
+	balloon_formation_pool_[2].set[6] = balloon_formation_[56];
-	balloon_formation_pool_[2].set[7] = &balloon_formation_[57];
+	balloon_formation_pool_[2].set[7] = balloon_formation_[57];
-	balloon_formation_pool_[2].set[8] = &balloon_formation_[58];
+	balloon_formation_pool_[2].set[8] = balloon_formation_[58];
-	balloon_formation_pool_[2].set[9] = &balloon_formation_[59];
+	balloon_formation_pool_[2].set[9] = balloon_formation_[59];
 	// EnemyPool #3
-	balloon_formation_pool_[3].set[0] = &balloon_formation_[50];
+	balloon_formation_pool_[3].set[0] = balloon_formation_[50];
-	balloon_formation_pool_[3].set[1] = &balloon_formation_[51];
+	balloon_formation_pool_[3].set[1] = balloon_formation_[51];
-	balloon_formation_pool_[3].set[2] = &balloon_formation_[52];
+	balloon_formation_pool_[3].set[2] = balloon_formation_[52];
-	balloon_formation_pool_[3].set[3] = &balloon_formation_[53];
+	balloon_formation_pool_[3].set[3] = balloon_formation_[53];
-	balloon_formation_pool_[3].set[4] = &balloon_formation_[54];
+	balloon_formation_pool_[3].set[4] = balloon_formation_[54];
-	balloon_formation_pool_[3].set[5] = &balloon_formation_[5];
+	balloon_formation_pool_[3].set[5] = balloon_formation_[5];
-	balloon_formation_pool_[3].set[6] = &balloon_formation_[6];
+	balloon_formation_pool_[3].set[6] = balloon_formation_[6];
-	balloon_formation_pool_[3].set[7] = &balloon_formation_[7];
+	balloon_formation_pool_[3].set[7] = balloon_formation_[7];
-	balloon_formation_pool_[3].set[8] = &balloon_formation_[8];
+	balloon_formation_pool_[3].set[8] = balloon_formation_[8];
-	balloon_formation_pool_[3].set[9] = &balloon_formation_[9];
+	balloon_formation_pool_[3].set[9] = balloon_formation_[9];
 	// EnemyPool #4
-	balloon_formation_pool_[4].set[0] = &balloon_formation_[60];
+	balloon_formation_pool_[4].set[0] = balloon_formation_[60];
-	balloon_formation_pool_[4].set[1] = &balloon_formation_[61];
+	balloon_formation_pool_[4].set[1] = balloon_formation_[61];
-	balloon_formation_pool_[4].set[2] = &balloon_formation_[62];
+	balloon_formation_pool_[4].set[2] = balloon_formation_[62];
-	balloon_formation_pool_[4].set[3] = &balloon_formation_[63];
+	balloon_formation_pool_[4].set[3] = balloon_formation_[63];
-	balloon_formation_pool_[4].set[4] = &balloon_formation_[64];
+	balloon_formation_pool_[4].set[4] = balloon_formation_[64];
-	balloon_formation_pool_[4].set[5] = &balloon_formation_[65];
+	balloon_formation_pool_[4].set[5] = balloon_formation_[65];
-	balloon_formation_pool_[4].set[6] = &balloon_formation_[66];
+	balloon_formation_pool_[4].set[6] = balloon_formation_[66];
-	balloon_formation_pool_[4].set[7] = &balloon_formation_[67];
+	balloon_formation_pool_[4].set[7] = balloon_formation_[67];
-	balloon_formation_pool_[4].set[8] = &balloon_formation_[68];
+	balloon_formation_pool_[4].set[8] = balloon_formation_[68];
-	balloon_formation_pool_[4].set[9] = &balloon_formation_[69];
+	balloon_formation_pool_[4].set[9] = balloon_formation_[69];
 	// EnemyPool #5
-	balloon_formation_pool_[5].set[0] = &balloon_formation_[10];
+	balloon_formation_pool_[5].set[0] = balloon_formation_[10];
-	balloon_formation_pool_[5].set[1] = &balloon_formation_[61];
+	balloon_formation_pool_[5].set[1] = balloon_formation_[61];
-	balloon_formation_pool_[5].set[2] = &balloon_formation_[12];
+	balloon_formation_pool_[5].set[2] = balloon_formation_[12];
-	balloon_formation_pool_[5].set[3] = &balloon_formation_[63];
+	balloon_formation_pool_[5].set[3] = balloon_formation_[63];
-	balloon_formation_pool_[5].set[4] = &balloon_formation_[14];
+	balloon_formation_pool_[5].set[4] = balloon_formation_[14];
-	balloon_formation_pool_[5].set[5] = &balloon_formation_[65];
+	balloon_formation_pool_[5].set[5] = balloon_formation_[65];
-	balloon_formation_pool_[5].set[6] = &balloon_formation_[16];
+	balloon_formation_pool_[5].set[6] = balloon_formation_[16];
-	balloon_formation_pool_[5].set[7] = &balloon_formation_[67];
+	balloon_formation_pool_[5].set[7] = balloon_formation_[67];
-	balloon_formation_pool_[5].set[8] = &balloon_formation_[18];
+	balloon_formation_pool_[5].set[8] = balloon_formation_[18];
-	balloon_formation_pool_[5].set[9] = &balloon_formation_[69];
+	balloon_formation_pool_[5].set[9] = balloon_formation_[69];
 	// EnemyPool #6
-	balloon_formation_pool_[6].set[0] = &balloon_formation_[60];
+	balloon_formation_pool_[6].set[0] = balloon_formation_[60];
-	balloon_formation_pool_[6].set[1] = &balloon_formation_[11];
+	balloon_formation_pool_[6].set[1] = balloon_formation_[11];
-	balloon_formation_pool_[6].set[2] = &balloon_formation_[62];
+	balloon_formation_pool_[6].set[2] = balloon_formation_[62];
-	balloon_formation_pool_[6].set[3] = &balloon_formation_[13];
+	balloon_formation_pool_[6].set[3] = balloon_formation_[13];
-	balloon_formation_pool_[6].set[4] = &balloon_formation_[64];
+	balloon_formation_pool_[6].set[4] = balloon_formation_[64];
-	balloon_formation_pool_[6].set[5] = &balloon_formation_[15];
+	balloon_formation_pool_[6].set[5] = balloon_formation_[15];
-	balloon_formation_pool_[6].set[6] = &balloon_formation_[66];
+	balloon_formation_pool_[6].set[6] = balloon_formation_[66];
-	balloon_formation_pool_[6].set[7] = &balloon_formation_[17];
+	balloon_formation_pool_[6].set[7] = balloon_formation_[17];
-	balloon_formation_pool_[6].set[8] = &balloon_formation_[68];
+	balloon_formation_pool_[6].set[8] = balloon_formation_[68];
-	balloon_formation_pool_[6].set[9] = &balloon_formation_[19];
+	balloon_formation_pool_[6].set[9] = balloon_formation_[19];
 	// EnemyPool #7
-	balloon_formation_pool_[7].set[0] = &balloon_formation_[20];
+	balloon_formation_pool_[7].set[0] = balloon_formation_[20];
-	balloon_formation_pool_[7].set[1] = &balloon_formation_[21];
+	balloon_formation_pool_[7].set[1] = balloon_formation_[21];
-	balloon_formation_pool_[7].set[2] = &balloon_formation_[22];
+	balloon_formation_pool_[7].set[2] = balloon_formation_[22];
-	balloon_formation_pool_[7].set[3] = &balloon_formation_[23];
+	balloon_formation_pool_[7].set[3] = balloon_formation_[23];
-	balloon_formation_pool_[7].set[4] = &balloon_formation_[24];
+	balloon_formation_pool_[7].set[4] = balloon_formation_[24];
-	balloon_formation_pool_[7].set[5] = &balloon_formation_[65];
+	balloon_formation_pool_[7].set[5] = balloon_formation_[65];
-	balloon_formation_pool_[7].set[6] = &balloon_formation_[66];
+	balloon_formation_pool_[7].set[6] = balloon_formation_[66];
-	balloon_formation_pool_[7].set[7] = &balloon_formation_[67];
+	balloon_formation_pool_[7].set[7] = balloon_formation_[67];
-	balloon_formation_pool_[7].set[8] = &balloon_formation_[68];
+	balloon_formation_pool_[7].set[8] = balloon_formation_[68];
-	balloon_formation_pool_[7].set[9] = &balloon_formation_[69];
+	balloon_formation_pool_[7].set[9] = balloon_formation_[69];
 	// EnemyPool #8
-	balloon_formation_pool_[8].set[0] = &balloon_formation_[70];
+	balloon_formation_pool_[8].set[0] = balloon_formation_[70];
-	balloon_formation_pool_[8].set[1] = &balloon_formation_[71];
+	balloon_formation_pool_[8].set[1] = balloon_formation_[71];
-	balloon_formation_pool_[8].set[2] = &balloon_formation_[72];
+	balloon_formation_pool_[8].set[2] = balloon_formation_[72];
-	balloon_formation_pool_[8].set[3] = &balloon_formation_[73];
+	balloon_formation_pool_[8].set[3] = balloon_formation_[73];
-	balloon_formation_pool_[8].set[4] = &balloon_formation_[74];
+	balloon_formation_pool_[8].set[4] = balloon_formation_[74];
-	balloon_formation_pool_[8].set[5] = &balloon_formation_[15];
+	balloon_formation_pool_[8].set[5] = balloon_formation_[15];
-	balloon_formation_pool_[8].set[6] = &balloon_formation_[16];
+	balloon_formation_pool_[8].set[6] = balloon_formation_[16];
-	balloon_formation_pool_[8].set[7] = &balloon_formation_[17];
+	balloon_formation_pool_[8].set[7] = balloon_formation_[17];
-	balloon_formation_pool_[8].set[8] = &balloon_formation_[18];
+	balloon_formation_pool_[8].set[8] = balloon_formation_[18];
-	balloon_formation_pool_[8].set[9] = &balloon_formation_[19];
+	balloon_formation_pool_[8].set[9] = balloon_formation_[19];
 	// EnemyPool #9
-	balloon_formation_pool_[9].set[0] = &balloon_formation_[20];
+	balloon_formation_pool_[9].set[0] = balloon_formation_[20];
-	balloon_formation_pool_[9].set[1] = &balloon_formation_[21];
+	balloon_formation_pool_[9].set[1] = balloon_formation_[21];
-	balloon_formation_pool_[9].set[2] = &balloon_formation_[22];
+	balloon_formation_pool_[9].set[2] = balloon_formation_[22];
-	balloon_formation_pool_[9].set[3] = &balloon_formation_[23];
+	balloon_formation_pool_[9].set[3] = balloon_formation_[23];
-	balloon_formation_pool_[9].set[4] = &balloon_formation_[24];
+	balloon_formation_pool_[9].set[4] = balloon_formation_[24];
-	balloon_formation_pool_[9].set[5] = &balloon_formation_[70];
+	balloon_formation_pool_[9].set[5] = balloon_formation_[70];
-	balloon_formation_pool_[9].set[6] = &balloon_formation_[71];
+	balloon_formation_pool_[9].set[6] = balloon_formation_[71];
-	balloon_formation_pool_[9].set[7] = &balloon_formation_[72];
+	balloon_formation_pool_[9].set[7] = balloon_formation_[72];
-	balloon_formation_pool_[9].set[8] = &balloon_formation_[73];
+	balloon_formation_pool_[9].set[8] = balloon_formation_[73];
-	balloon_formation_pool_[9].set[9] = &balloon_formation_[74];
+	balloon_formation_pool_[9].set[9] = balloon_formation_[74];
 }
 // Inicializa las fases del juego
@@ -645,70 +642,70 @@ void BalloonFormations::initGameStages()
 	stage_[0].power_to_complete = 200;
 	stage_[0].min_menace = 7 + (4 * 1);
 	stage_[0].max_menace = 7 + (4 * 3);
-	stage_[0].balloon_pool = &balloon_formation_pool_[0];
+	stage_[0].balloon_pool = balloon_formation_pool_[0];
 	// STAGE 2
 	stage_[1].number = 2;
 	stage_[1].power_to_complete = 300;
 	stage_[1].min_menace = 7 + (4 * 2);
 	stage_[1].max_menace = 7 + (4 * 4);
-	stage_[1].balloon_pool = &balloon_formation_pool_[1];
+	stage_[1].balloon_pool = balloon_formation_pool_[1];
 	// STAGE 3
 	stage_[2].number = 3;
 	stage_[2].power_to_complete = 600;
 	stage_[2].min_menace = 7 + (4 * 3);
 	stage_[2].max_menace = 7 + (4 * 5);
-	stage_[2].balloon_pool = &balloon_formation_pool_[2];
+	stage_[2].balloon_pool = balloon_formation_pool_[2];
 	// STAGE 4
 	stage_[3].number = 4;
 	stage_[3].power_to_complete = 600;
 	stage_[3].min_menace = 7 + (4 * 3);
 	stage_[3].max_menace = 7 + (4 * 5);
-	stage_[3].balloon_pool = &balloon_formation_pool_[3];
+	stage_[3].balloon_pool = balloon_formation_pool_[3];
 	// STAGE 5
 	stage_[4].number = 5;
 	stage_[4].power_to_complete = 600;
 	stage_[4].min_menace = 7 + (4 * 4);
 	stage_[4].max_menace = 7 + (4 * 6);
-	stage_[4].balloon_pool = &balloon_formation_pool_[4];
+	stage_[4].balloon_pool = balloon_formation_pool_[4];
 	// STAGE 6
 	stage_[5].number = 6;
 	stage_[5].power_to_complete = 600;
 	stage_[5].min_menace = 7 + (4 * 4);
 	stage_[5].max_menace = 7 + (4 * 6);
-	stage_[5].balloon_pool = &balloon_formation_pool_[5];
+	stage_[5].balloon_pool = balloon_formation_pool_[5];
 	// STAGE 7
 	stage_[6].number = 7;
 	stage_[6].power_to_complete = 650;
 	stage_[6].min_menace = 7 + (4 * 5);
 	stage_[6].max_menace = 7 + (4 * 7);
-	stage_[6].balloon_pool = &balloon_formation_pool_[6];
+	stage_[6].balloon_pool = balloon_formation_pool_[6];
 	// STAGE 8
 	stage_[7].number = 8;
 	stage_[7].power_to_complete = 750;
 	stage_[7].min_menace = 7 + (4 * 5);
 	stage_[7].max_menace = 7 + (4 * 7);
-	stage_[7].balloon_pool = &balloon_formation_pool_[7];
+	stage_[7].balloon_pool = balloon_formation_pool_[7];
 	// STAGE 9
 	stage_[8].number = 9;
 	stage_[8].power_to_complete = 850;
 	stage_[8].min_menace = 7 + (4 * 6);
 	stage_[8].max_menace = 7 + (4 * 8);
-	stage_[8].balloon_pool = &balloon_formation_pool_[8];
+	stage_[8].balloon_pool = balloon_formation_pool_[8];
 	// STAGE 10
 	stage_[9].number = 10;
 	stage_[9].power_to_complete = 950;
 	stage_[9].min_menace = 7 + (4 * 7);
 	stage_[9].max_menace = 7 + (4 * 10);
-	stage_[9].balloon_pool = &balloon_formation_pool_[9];
+	stage_[9].balloon_pool = balloon_formation_pool_[9];
 }
 // Devuelve una fase
--- a/source/balloon_formations.h
+++ b/source/balloon_formations.h
@@ -1,36 +1,48 @@
 #pragma once
 #include "balloon.h"
 constexpr int NUMBER_OF_BALLOON_FORMATIONS = 100;
 constexpr int MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION = 50;
 constexpr int NUMBER_OF_SETS_PER_POOL = 10;
 constexpr int NUMBER_OF_STAGES = 10;
 // Estructuras
 struct BalloonFormationParams
 {
-    int x;                // Posición en el eje X donde crear al enemigo
+    int x = 0;                               // Posición en el eje X donde crear el globo
-    int y;                // Posición en el eje Y donde crear al enemigo
+    int y = 0;                               // Posición en el eje Y donde crear el globo
-    float vel_x;          // Velocidad inicial en el eje X
+    float vel_x = 0.0f;                      // Velocidad inicial en el eje X
-    int kind;             // Tipo de enemigo
+    BalloonType type = BalloonType::BALLOON; // Tipo de globo
-    int creation_counter; // Temporizador para la creación del enemigo
+    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 // Contiene la información de una formación enemiga
 {
-    int number_of_balloons;                                             // Cantidad de enemigos que forman la formación
+    int number_of_balloons;                                             // Cantidad de globos que forman la formación
-    BalloonFormationParams init[MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION]; // Vector con todas las inicializaciones de los enemigos de la formación
+    BalloonFormationParams init[MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION]; // Vector con todas las inicializaciones de los globos de la formación
 };
 struct BalloonFormationPool
 {
-    BalloonFormationUnit *set[10]; // Conjunto de formaciones de globos
+    BalloonFormationUnit set[NUMBER_OF_SETS_PER_POOL]; // Conjunto de formaciones de globos
 };
 struct Stage // Contiene todas las variables relacionadas con una fase
 {
-    BalloonFormationPool *balloon_pool; // El conjunto de formaciones de globos de la fase
+    BalloonFormationPool balloon_pool; // El conjunto de formaciones de globos de la fase
-    int power_to_complete;              // Cantidad de poder que se necesita para completar la fase
+    int power_to_complete;             // Cantidad de poder que se necesita para completar la fase
-    int max_menace;                     // Umbral máximo de amenaza de la fase
+    int max_menace;                    // Umbral máximo de amenaza de la fase
-    int min_menace;                     // Umbral mínimo de amenaza de la fase
+    int min_menace;                    // Umbral mínimo de amenaza de la fase
-    int number;                         // Número de fase
+    int number;                        // Número de fase
 };
 // Clase BalloonFormations, para gestionar las formaciones de globos
@@ -38,9 +50,9 @@ class BalloonFormations
 {
 private:
    // Variables
-    Stage stage_[10];                                                      // Variable con los datos de cada pantalla
+    Stage stage_[NUMBER_OF_STAGES];                                        // Variable con los datos de cada pantalla
    BalloonFormationUnit balloon_formation_[NUMBER_OF_BALLOON_FORMATIONS]; // Vector con todas las formaciones enemigas
-    BalloonFormationPool balloon_formation_pool_[10];                      // Variable con los diferentes conjuntos de formaciones enemigas
+    BalloonFormationPool balloon_formation_pool_[NUMBER_OF_STAGES];        // Variable con los diferentes conjuntos de formaciones enemigas
    // Inicializa las formaciones enemigas
    void initBalloonFormations();
--- a/source/bullet.cpp
+++ b/source/bullet.cpp
@@ -1,36 +1,27 @@
 #include "bullet.h"
-#include <memory>    // for unique_ptr, make_unique, shared_ptr
+#include <SDL2/SDL_rect.h> // Para SDL_Rect
-#include "param.h"   // for param
+#include <memory>          // Para unique_ptr, make_unique, shared_ptr
-#include "sprite.h"  // for Sprite
+#include "param.h"         // Para Param, ParamGame, param
-class Texture;
+#include "sprite.h"        // Para Sprite
-
+class Texture;             // lines 5-5
 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;
 // Constructor
-Bullet::Bullet(int x, int y, BulletType kind, bool powered_up, int owner, SDL_Rect *play_area, std::shared_ptr<Texture> texture)
+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})),
+    : sprite_(std::make_unique<Sprite>(texture, SDL_Rect{x, y, BULLET_WIDTH_, BULLET_HEIGHT_})),
      pos_x_(x),
      pos_y_(y),
-      width_(BULLET_WIDTH),
+      bullet_type_(bullet_type),
-      height_(BULLET_HEIGHT),
+      owner_(owner)
      vel_x_(0),
      vel_y_(BULLET_VELY),
      kind_(kind),
      owner_(owner),
      play_area_(play_area)
 {
-    vel_x_ = (kind_ == BulletType::LEFT) ? BULLET_VELX_LEFT : (kind_ == BulletType::RIGHT) ? BULLET_VELX_RIGHT
+    vel_x_ = (bullet_type_ == BulletType::LEFT)    ? BULLET_VEL_X_LEFT_
-                                                                                           : 0;
+             : (bullet_type_ == BulletType::RIGHT) ? BULLET_VEL_X_RIGHT_
                                                   : 0;
-    auto sprite_offset = powered_up ? 3 : 0;
+    int sprite_offset = powered_up ? 3 : 0;
-    auto kind_index = static_cast<int>(kind);
+    int offset = (static_cast<int>(bullet_type) + sprite_offset) * BULLET_WIDTH_;
-    sprite_->setSpriteClip((kind_index + sprite_offset) * width_, 0, sprite_->getWidth(), sprite_->getHeight());
+    sprite_->setSpriteClip(offset, 0, BULLET_WIDTH_, BULLET_HEIGHT_);
-    collider_.r = width_ / 2;
+    collider_.r = BULLET_WIDTH_ / 2;
    shiftColliders();
 }
@@ -44,21 +35,20 @@ void Bullet::render()
 BulletMoveStatus Bullet::move()
 {
    pos_x_ += vel_x_;
-    if (pos_x_ < param.game.play_area.rect.x - width_ || pos_x_ > play_area_->w)
+    if (pos_x_ < param.game.play_area.rect.x - BULLET_WIDTH_ || pos_x_ > param.game.play_area.rect.w)
    {
        disable();
        return BulletMoveStatus::OUT;
    }
-    pos_y_ += vel_y_;
+    pos_y_ += BULLET_VEL_Y_;
-    if (pos_y_ < param.game.play_area.rect.y - height_)
+    if (pos_y_ < param.game.play_area.rect.y - BULLET_HEIGHT_)
    {
        disable();
        return BulletMoveStatus::OUT;
    }
-    sprite_->setX(pos_x_);
+    shiftSprite();
    sprite_->setY(pos_y_);
    shiftColliders();
    return BulletMoveStatus::OK;
@@ -66,42 +56,12 @@ BulletMoveStatus Bullet::move()
 bool Bullet::isEnabled() const
 {
-    return kind_ != BulletType::NONE;
+    return bullet_type_ != BulletType::NONE;
 }
 void Bullet::disable()
 {
-    kind_ = BulletType::NONE;
+    bullet_type_ = BulletType::NONE;
 }
 int Bullet::getPosX() const
 {
    return pos_x_;
 }
 int Bullet::getPosY() const
 {
    return pos_y_;
 }
 void Bullet::setPosX(int x)
 {
    pos_x_ = x;
 }
 void Bullet::setPosY(int y)
 {
    pos_y_ = y;
 }
 int Bullet::getVelY() const
 {
    return vel_y_;
 }
 BulletType Bullet::getKind() const
 {
    return kind_;
 }
 int Bullet::getOwner() const
@@ -119,3 +79,9 @@ void Bullet::shiftColliders()
    collider_.x = pos_x_ + collider_.r;
    collider_.y = pos_y_ + collider_.r;
 }
 void Bullet::shiftSprite()
 {
    sprite_->setX(pos_x_);
    sprite_->setY(pos_y_);
 }
--- a/source/bullet.h
+++ b/source/bullet.h
@@ -1,14 +1,13 @@
 #pragma once
-#include <SDL2/SDL_rect.h>    // for SDL_Rect
+#include <SDL2/SDL_stdinc.h> // Para Uint8
-#include <SDL2/SDL_stdinc.h>  // for Uint8
+#include <memory>			 // Para shared_ptr, unique_ptr
-#include <memory>             // for shared_ptr, unique_ptr
+#include "sprite.h"			 // Para Sprite
-#include "sprite.h"           // for Sprite
+#include "utils.h"			 // Para Circle
-#include "utils.h"            // for Circle
+class Texture;				 // lines 8-8
 class Texture;
-// Enumeración para los diferentes tipos de balas
+// Tipos de balas
-enum class BulletType
+enum class BulletType : Uint8
 {
 	UP,
 	LEFT,
@@ -16,7 +15,7 @@ enum class BulletType
 	NONE
 };
-// Enumeración para los resultados del movimiento de la bala
+// Resultado del movimiento de la bala
 enum class BulletMoveStatus : Uint8
 {
 	OK = 0,
@@ -27,26 +26,29 @@ enum class BulletMoveStatus : Uint8
 class Bullet
 {
 private:
 	// Constantes
 	static constexpr int BULLET_WIDTH_ = 12;
 	static constexpr int BULLET_HEIGHT_ = 12;
 	static constexpr int BULLET_VEL_Y_ = -3;
 	static constexpr int BULLET_VEL_X_LEFT_ = -2;
 	static constexpr int BULLET_VEL_X_RIGHT_ = 2;
 	std::unique_ptr<Sprite> sprite_; // Sprite con los gráficos y métodos de pintado
-	int pos_x_;	   // Posición en el eje X
+	int pos_x_; // Posición en el eje X
-	int pos_y_;	   // Posición en el eje Y
+	int pos_y_; // Posición en el eje Y
 	Uint8 width_;  // Ancho del objeto
 	Uint8 height_; // Alto del objeto
 	int vel_x_; // Velocidad en el eje X
 	int vel_y_; // Velocidad en el eje Y
-	BulletType kind_;	  // Tipo de objeto
+	BulletType bullet_type_; // Tipo de objeto
-	int owner_;			  // Identificador del dueño del objeto
+	int owner_;				 // Identificador del dueño del objeto
-	Circle collider_;	  // Círculo de colisión del objeto
+	Circle collider_;		 // Círculo de colisión del objeto
 	SDL_Rect *play_area_; // Rectángulo con la zona de juego
 	void shiftColliders(); // Alinea el círculo de colisión con el objeto
 	void shiftSprite();	   // Alinea el sprite con el objeto
 public:
 	// Constructor
-	Bullet(int x, int y, BulletType kind, bool powered_up, int owner, SDL_Rect *play_area, std::shared_ptr<Texture> texture);
+	Bullet(int x, int y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture);
 	// Destructor
 	~Bullet() = default;
@@ -63,17 +65,7 @@ public:
 	// Deshabilita el objeto
 	void disable();
 	// Obtiene la posición
 	int getPosX() const;
 	int getPosY() const;
 	// Establece la posición
 	void setPosX(int x);
 	void setPosY(int y);
 	// Obtiene parámetros
 	int getVelY() const;
 	BulletType getKind() const;
 	int getOwner() const;
 	Circle &getCollider();
 };
--- a/source/dbgtxt.cpp
+++ b/source/dbgtxt.cpp
@@ -1,7 +1,7 @@
 #include "dbgtxt.h"
-#include <SDL2/SDL_rect.h>     // for SDL_Rect
+#include <SDL2/SDL_rect.h>    // para SDL_Rect
-#include <SDL2/SDL_rwops.h>    // for SDL_RWFromMem
+#include <SDL2/SDL_rwops.h>   // para SDL_RWFromMem
-#include <SDL2/SDL_surface.h>  // for SDL_LoadBMP_RW
+#include <SDL2/SDL_surface.h> // para SDL_LoadBMP_RW
 namespace
 {
--- a/source/dbgtxt.h
+++ b/source/dbgtxt.h
@@ -1,7 +1,7 @@
 #pragma once
-#include <SDL2/SDL_render.h>  // for SDL_Renderer
+#include <SDL2/SDL_render.h> // para SDL_Renderer
-#include <SDL2/SDL_stdinc.h>  // for Uint8
+#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);
--- a/source/define_buttons.cpp
+++ b/source/define_buttons.cpp
@@ -1,58 +1,26 @@
 #include "define_buttons.h"
-#include <utility>    // for move
+#include <utility>   // Para move
-#include "input.h"    // for Input, InputType
+#include "input.h"   // Para Input, InputType
-#include "lang.h"     // for getText
+#include "lang.h"    // Para getText
-#include "options.h"  // for options
+#include "options.h" // Para OptionsController, Options, options
-#include "param.h"    // for param
+#include "param.h"   // Para Param, param, ParamGame, ParamTitle
-#include "section.h"  // for Name, Options, name, options
+#include "section.h" // Para Name, Options, name, options
-#include "text.h"     // for Text
+#include "text.h"    // Para Text
 #include "utils.h"    // for OptionsController, Options, Param, ParamGame
 // Constructor
 DefineButtons::DefineButtons(std::unique_ptr<Text> text_)
-    : text_(std::move(text_))
+    : input_(Input::get()),
      text_(std::move(text_))
 {
    // Copia punteros a los objetos
    input_ = Input::get();
    // Inicializa variables
    enabled_ = false;
    x_ = param.game.width / 2;
    y_ = param.title.press_start_position;
    index_controller_ = 0;
    index_button_ = 0;
-    buttons_.clear();
+    clearButtons();
    DefineButtonsButton button;
    button.label = lang::getText(95);
    button.input = InputType::FIRE_LEFT;
    button.button = SDL_CONTROLLER_BUTTON_X;
    buttons_.push_back(button);
    button.label = lang::getText(96);
    button.input = InputType::FIRE_CENTER;
    button.button = SDL_CONTROLLER_BUTTON_Y;
    buttons_.push_back(button);
    button.label = lang::getText(97);
    button.input = InputType::FIRE_RIGHT;
    button.button = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
    buttons_.push_back(button);
    button.label = lang::getText(98);
    button.input = InputType::START;
    button.button = SDL_CONTROLLER_BUTTON_START;
    buttons_.push_back(button);
    button.label = lang::getText(99);
    button.input = InputType::EXIT;
    button.button = SDL_CONTROLLER_BUTTON_BACK;
    buttons_.push_back(button);
    for (int i = 0; i < input_->getNumControllers(); ++i)
    {
-        controller_names_.push_back(input_->getControllerName(i));
+        controller_names_.emplace_back(input_->getControllerName(i));
    }
 }
@@ -61,38 +29,40 @@ void DefineButtons::render()
 {
    if (enabled_)
    {
-        text_->writeCentered(x_, y_ - 10, lang::getText(100) + std::to_string(options.controller[index_controller_].player_id));
+        text_->writeCentered(x_, y_ - 10, lang::getText(100) + std::to_string(options.controllers.at(index_controller_).player_id));
-        text_->writeCentered(x_, y_, controller_names_[index_controller_]);
+        text_->writeCentered(x_, y_, controller_names_.at(index_controller_));
-        text_->writeCentered(x_, y_ + 10, buttons_[index_button_].label);
+        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 pilla botones del mando que toca
-
+    if (input_->getJoyIndex(event.which) != static_cast<int>(index_controller_))
    // Solo pillamos botones del mando que toca
    if (i != index_controller_)
    {
        return;
    }
-    buttons_[index_button_].button = (SDL_GameControllerButton)event->button;
+    const auto button = static_cast<SDL_GameControllerButton>(event.button);
-    incIndexButton();
+    if (checkButtonNotInUse(button))
    {
        buttons_.at(index_button_).button = button;
        incIndexButton();
    }
 }
 // Asigna los botones definidos al input_
 void DefineButtons::bindButtons()
 {
-    for (int i = 0; i < (int)buttons_.size(); ++i)
+    for (const auto &button : buttons_)
    {
-        input_->bindGameControllerButton(index_controller_, buttons_[i].input, buttons_[i].button);
+        input_->bindGameControllerButton(index_controller_, button.input, button.button);
    }
 }
-// Comprueba las entradas
+// Comprueba los eventos
-void DefineButtons::checkInput()
+void DefineButtons::checkEvents()
 {
    if (enabled_)
    {
@@ -106,16 +76,14 @@ void DefineButtons::checkInput()
            case SDL_QUIT:
            {
                section::name = section::Name::QUIT;
-                section::options = section::Options::QUIT_NORMAL;
+                section::options = section::Options::QUIT_WITH_KEYBOARD;
                break;
            }
            case SDL_CONTROLLERBUTTONDOWN:
            {
-                doControllerButtonDown(&event.cbutton);
+                doControllerButtonDown(event.cbutton);
                break;
            }
            default:
                break;
            }
@@ -131,6 +99,7 @@ bool DefineButtons::enable(int index)
        enabled_ = true;
        index_controller_ = index;
        index_button_ = 0;
        clearButtons();
        return true;
    }
@@ -138,18 +107,15 @@ bool DefineButtons::enable(int index)
 }
 // Comprueba si está habilitado
-bool DefineButtons::isEnabled()
+bool DefineButtons::isEnabled() { return enabled_; }
 {
    return enabled_;
 }
 // Incrementa el indice de los botones
 void DefineButtons::incIndexButton()
 {
-    index_button_++;
+    ++index_button_;
    // Comprueba si ha finalizado
-    if (index_button_ == (int)buttons_.size())
+    if (index_button_ == buttons_.size())
    {
        // Asigna los botones definidos al input_
        bindButtons();
@@ -157,11 +123,7 @@ void DefineButtons::incIndexButton()
        // Guarda los cambios en las opciones
        saveBindingsToOptions();
-        //input_->allActive(index_controller_);
+        // Deshabilita
        // Reinicia variables
        index_button_ = 0;
        index_controller_ = 0;
        enabled_ = false;
    }
 }
@@ -170,17 +132,34 @@ void DefineButtons::incIndexButton()
 void DefineButtons::saveBindingsToOptions()
 {
    // Modifica las opciones para colocar los valores asignados
-    options.controller[index_controller_].name = input_->getControllerName(index_controller_);
+    auto &controller = options.controllers.at(index_controller_);
-    for (int j = 0; j < (int)options.controller[index_controller_].inputs.size(); ++j)
+    controller.name = input_->getControllerName(index_controller_);
    for (size_t j = 0; j < controller.inputs.size(); ++j)
    {
-        options.controller[index_controller_].buttons[j] = input_->getControllerBinding(index_controller_, options.controller[index_controller_].inputs[j]);
+        controller.buttons.at(j) = input_->getControllerBinding(index_controller_, controller.inputs.at(j));
    }
 }
-// Intercambia los jugadores asignados a los dos primeros mandos
+// Comprueba que un botón no esté ya asignado
-void DefineButtons::swapControllers()
+bool DefineButtons::checkButtonNotInUse(SDL_GameControllerButton button)
 {
-    const int temp = options.controller[0].player_id;
+    for (const auto &b : buttons_)
-    options.controller[0].player_id = options.controller[1].player_id;
+    {
-    options.controller[1].player_id = temp;
+        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);
 }
--- a/source/define_buttons.h
+++ b/source/define_buttons.h
@@ -1,19 +1,24 @@
 #pragma once
-#include <SDL2/SDL_events.h>          // for SDL_ControllerButtonEvent
+#include <SDL2/SDL_events.h>         // Para SDL_ControllerButtonEvent
-#include <SDL2/SDL_gamecontroller.h>  // for SDL_GameControllerButton
+#include <SDL2/SDL_gamecontroller.h> // Para SDL_GameControllerButton
-#include <memory>                     // for shared_ptr, unique_ptr
+#include <stddef.h>                  // Para size_t
-#include <string>                     // for string
+#include <memory>                    // Para shared_ptr, unique_ptr
-#include <vector>                     // for vector
+#include <string>                    // Para string
-class Input;
+#include <vector>                    // Para vector
-class Text;
+class Input;                         // lines 8-8
-enum class InputType : int;
+class Text;                          // lines 9-9
 enum class InputType : int;          // lines 10-10
 struct DefineButtonsButton
 {
    std::string label;               // Texto en pantalla para el botón
    InputType input;                 // Input asociado
    SDL_GameControllerButton button; // Botón del mando correspondiente
    // Constructor
    DefineButtonsButton(const std::string &lbl, InputType inp, SDL_GameControllerButton btn)
        : label(lbl), input(inp), button(btn) {}
 };
 // Clase Bullet
@@ -25,19 +30,19 @@ private:
    std::shared_ptr<Text> text_; // Objeto para escribir texto
    // Variables
-    bool enabled_;                              // Indica si el objeto está habilitado
+    bool enabled_ = false;                      // Indica si el objeto está habilitado
    int x_;                                     // Posición donde dibujar el texto
    int y_;                                     // Posición donde dibujar el texto
    std::vector<DefineButtonsButton> buttons_;  // Vector con las nuevas definiciones de botones/acciones
-    int index_controller_;                      // Indice del controlador a reasignar
+    size_t index_controller_ = 0;               // Indice del controlador a reasignar
-    int index_button_;                          // Indice para saber qué bot´çon se está definiendo
+    size_t index_button_ = 0;                   // Indice para saber qué botón se está definiendo
    std::vector<std::string> controller_names_; // Nombres de los mandos
    // Incrementa el indice de los botones
    void incIndexButton();
    // Comprueba el botón que se ha pulsado
-    void doControllerButtonDown(SDL_ControllerButtonEvent *event);
+    void doControllerButtonDown(const SDL_ControllerButtonEvent &event);
    // Asigna los botones definidos al input
    void bindButtons();
@@ -45,6 +50,12 @@ private:
    // Guarda los cambios en las opciones
    void saveBindingsToOptions();
    // Comprueba que un botón no esté ya asignado
    bool checkButtonNotInUse(SDL_GameControllerButton button);
    // Limpia la asignación de botones
    void clearButtons();
 public:
    // Constructor
    explicit DefineButtons(std::unique_ptr<Text> text);
@@ -55,15 +66,12 @@ public:
    // Dibuja el objeto en pantalla
    void render();
-    // Comprueba las entradas
+    // Comprueba los eventos
-    void checkInput();
+    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();
 };
--- a/source/director.cpp
+++ b/source/director.cpp
@@ -1,49 +1,58 @@
 #include "director.h"
-#include <SDL2/SDL.h>				 // for SDL_Init, SDL_Quit, SDL_INIT_EV...
+#include <SDL2/SDL.h>				 // Para SDL_Init, SDL_Quit, SDL_INIT_EV...
-#include <SDL2/SDL_audio.h>			 // for AUDIO_S16
+#include <SDL2/SDL_audio.h>			 // Para AUDIO_S16
-#include <SDL2/SDL_blendmode.h>		 // for SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_blendmode.h>		 // Para SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_error.h>			 // for SDL_GetError
+#include <SDL2/SDL_error.h>			 // Para SDL_GetError
-#include <SDL2/SDL_gamecontroller.h> // for SDL_CONTROLLER_BUTTON_B, SDL_CO...
+#include <SDL2/SDL_gamecontroller.h> // Para SDL_CONTROLLER_BUTTON_B, SDL_CO...
-#include <SDL2/SDL_hints.h>			 // for SDL_SetHint, SDL_HINT_RENDER_DR...
+#include <SDL2/SDL_hints.h>			 // Para SDL_SetHint, SDL_HINT_RENDER_DR...
-#include <SDL2/SDL_scancode.h>		 // for SDL_SCANCODE_0, SDL_SCANCODE_DOWN
+#include <SDL2/SDL_scancode.h>		 // Para SDL_SCANCODE_0, SDL_SCANCODE_DOWN
-#include <SDL2/SDL_stdinc.h>		 // for SDL_bool, Uint32
+#include <SDL2/SDL_stdinc.h>		 // Para SDL_bool, Uint32
-#include <SDL2/SDL_timer.h>			 // for SDL_GetTicks
+#include <bits/chrono.h>			 // Para duration, system_clock
-#include <cstdlib>					 // for system
+#include <errno.h>					 // Para errno, EEXIST, EACCES, ENAMETOO...
-#include <errno.h>					 // for errno, EEXIST, EACCES, ENAMETOO...
+#include <stdio.h>					 // Para printf, perror
-#include <stdio.h>					 // for printf, perror
+#include <sys/stat.h>				 // Para mkdir, stat, S_IRWXU
-#include <string.h>					 // for strcmp
+#include <unistd.h>					 // Para getuid
-#include <sys/stat.h>				 // for mkdir, stat, S_IRWXU
+#include <algorithm>				 // Para min
-#include <unistd.h>					 // for getuid
+#include <cstdlib>					 // Para exit, EXIT_FAILURE, size_t, rand
-#include <cstdlib>					 // for exit, EXIT_FAILURE, rand, srand
+#include <iostream>					 // Para basic_ostream, operator<<, basi...
-#include <iostream>					 // for basic_ostream, operator<<, cout
+#include <memory>					 // Para make_unique, unique_ptr, make_s...
-#include <memory>					 // for make_unique, unique_ptr
+#include <stdexcept>				 // Para runtime_error
-#include <string>					 // for operator+, allocator, char_traits
+#include <string>					 // Para operator+, char_traits, allocator
-#include "asset.h"					 // for Asset, AssetType
+#include <vector>					 // Para vector
-#include "dbgtxt.h"					 // for dbg_init
+#include "asset.h"					 // Para Asset, AssetType
-#include "game.h"					 // for Game, GAME_MODE_DEMO_OFF, GAME_...
+#include "dbgtxt.h"					 // Para dbg_init
-#include "global_inputs.h"			 // for init
+#include "game.h"					 // Para Game, GAME_MODE_DEMO_OFF, GAME_...
-#include "hiscore_table.h"			 // for HiScoreTable
+#include "global_inputs.h"			 // Para init
-#include "input.h"					 // for Input, InputType
+#include "hiscore_table.h"			 // Para HiScoreTable
-#include "instructions.h"			 // for Instructions
+#include "input.h"					 // Para Input, InputType
-#include "intro.h"					 // for Intro
+#include "instructions.h"			 // Para Instructions
-#include "jail_audio.h"				 // for JA_LoadMusic, JA_LoadSound, JA_...
+#include "intro.h"					 // Para Intro
-#include "lang.h"					 // for Code, loadFromFile
+#include "jail_audio.h"				 // Para JA_SetMusicVolume, JA_SetSoundV...
-#include "logo.h"					 // for Logo
+#include "lang.h"					 // Para Code, loadFromFile
-#include "manage_hiscore_table.h"	 // for ManageHiScoreTable
+#include "logo.h"					 // Para Logo
-#include "notifier.h"				 // for Notifier
+#include "manage_hiscore_table.h"	 // Para ManageHiScoreTable
-#include "on_screen_help.h"			 // for OnScreenHelp
+#include "notifier.h"				 // Para Notifier
-#include "options.h"				 // for options, loadOptionsFile, saveO...
+#include "on_screen_help.h"			 // Para OnScreenHelp
-#include "param.h"					 // for param, loadParamsFromFile
+#include "options.h"				 // Para Options, OptionsController, opt...
-#include "resource.h"				 //for Resource
+#include "param.h"					 // Para Param, ParamGame, param, loadPa...
-#include "screen.h"					 // for Screen
+#include "resource.h"				 // Para Resource
-#include "section.h"				 // for Name, name, Options, options
+#include "screen.h"					 // Para Screen
-#include "title.h"					 // for Title
+#include "section.h"				 // Para Name, Options, name, options
-#include "utils.h"					 // for MusicFile, SoundFile, Options
+#include "text.h"					 // Para Text
 #include "title.h"					 // Para Title
 #include "utils.h"					 // Para Overrides, overrides
 #ifndef _WIN32
-#include <pwd.h> // for getpwuid, passwd
+#include <pwd.h> // para getpwuid, passwd
 #endif
 // Inicia la semilla aleatoria
 void initRand()
 {
 	unsigned int seed = static_cast<unsigned int>(std::chrono::system_clock::now().time_since_epoch().count());
 	std::srand(seed);
 }
 // Constructor
 Director::Director(int argc, const char *argv[])
 {
@@ -54,6 +63,7 @@ Director::Director(int argc, const char *argv[])
 	section::name = section::Name::LOGO;
 #else
 	section::name = section::Name::LOGO;
 	section::attract_mode = section::AttractMode::TITLE_TO_DEMO;
 #endif
 #ifndef VERBOSE
@@ -64,6 +74,8 @@ Director::Director(int argc, const char *argv[])
 	std::cout << "Game start" << std::endl;
 	initRand();
 	// Comprueba los parametros del programa
 	checkProgramArguments(argc, argv);
@@ -84,38 +96,31 @@ Director::Director(int argc, const char *argv[])
 #ifdef ANBERNIC
 	const std::string paramFilePath = asset->get("param_320x240.txt");
 #else
-	const std::string paramFilePath = param_file_argument_ == "--320x240" ? Asset::get()->get("param_320x240.txt") : Asset::get()->get("param_320x256.txt");
+	const std::string paramFilePath = overrides.param_file == "--320x240" ? Asset::get()->get("param_320x240.txt") : Asset::get()->get("param_320x256.txt");
 #endif
-	loadParams(paramFilePath);
+	loadParamsFromFile(paramFilePath);
 	// Carga el fichero de puntuaciones
-	auto manager = std::make_unique<ManageHiScoreTable>(&options.game.hi_score_table);
+	{
-	manager->loadFromFile(Asset::get()->get("score.bin"));
+		auto manager = std::make_unique<ManageHiScoreTable>(options.game.hi_score_table);
 		if (overrides.clear_hi_score_table)
 			manager->clear();
 		else
 			manager->loadFromFile(Asset::get()->get("score.bin"));
 	}
-	// Inicializa SDL
+	// Inicializa todo
 	initSDL();
 	// Inicializa JailAudio
 	initJailAudio();
 	// Inicializa el texto de debug
 	dbg_init(renderer_);
-
+	lang::loadFromFile(getLangFile(static_cast<lang::Code>(options.game.language)));
 	// Crea los objetos
 	lang::loadFromFile(getLangFile((lang::Code)options.game.language));
 	Screen::init(window_, renderer_);
 	Resource::init();
 	Input::init(Asset::get()->get("gamecontrollerdb.txt"));
 	bindInputs();
 	auto notifier_text = std::make_shared<Text>(Resource::get()->getTexture("8bithud.png"), Resource::get()->getTextFile("8bithud.txt"));
 	Notifier::init(std::string(), notifier_text, Asset::get()->get("notify.wav"));
 	OnScreenHelp::init();
 	globalInputs::init();
 }
@@ -134,6 +139,8 @@ Director::~Director()
 	SDL_DestroyWindow(window_);
 	SDL_Quit();
 	std::cout << "\nBye!" << std::endl;
 }
 // Asigna los botones y teclas al objeto Input
@@ -181,27 +188,23 @@ void Director::bindInputs()
 		// Mando - Control del programa
 		Input::get()->bindGameControllerButton(i, InputType::SERVICE, SDL_CONTROLLER_BUTTON_BACK);
 		Input::get()->bindGameControllerButton(i, InputType::EXIT, InputType::START);
 		Input::get()->bindGameControllerButton(i, InputType::PAUSE, InputType::FIRE_RIGHT);
 		Input::get()->bindGameControllerButton(i, InputType::VIDEO_SHADERS, InputType::FIRE_LEFT);
 		Input::get()->bindGameControllerButton(i, InputType::MUTE, InputType::LEFT);
 		Input::get()->bindGameControllerButton(i, InputType::SHOWINFO, InputType::RIGHT);
 		Input::get()->bindGameControllerButton(i, InputType::RESET, InputType::FIRE_CENTER);
 		Input::get()->bindGameControllerButton(i, InputType::CONFIG, InputType::DOWN);
 		Input::get()->bindGameControllerButton(i, InputType::SWAP_CONTROLLERS, InputType::UP);
 	}
 	// Mapea las asignaciones a los botones desde el archivo de configuración, si se da el caso
-	for (int i = 0; i < num_gamepads; ++i)
+	const size_t max_controllers = std::min(2, num_gamepads);
-		for (int index = 0; index < (int)options.controller.size(); ++index)
+	for (size_t i = 0; i < max_controllers; ++i)
-			if (Input::get()->getControllerName(i) == options.controller[index].name)
+	{
 		for (auto &controller : options.controllers)
 		{
 			if (Input::get()->getControllerName(i) == controller.name)
 			{
-				options.controller[index].plugged = true;
+				for (size_t j = 0; j < controller.inputs.size(); ++j)
 				for (int j = 0; j < (int)options.controller[index].inputs.size(); ++j)
 				{
-					Input::get()->bindGameControllerButton(i, options.controller[index].inputs[j], options.controller[index].buttons[j]);
+					Input::get()->bindGameControllerButton(i, controller.inputs.at(j), controller.buttons.at(j));
 				}
 			}
 		}
 	}
 	// Asigna botones a inputs desde otros inputs
 	for (int i = 0; i < num_gamepads; ++i)
@@ -216,25 +219,41 @@ void Director::bindInputs()
 		Input::get()->bindGameControllerButton(i, InputType::SWAP_CONTROLLERS, InputType::UP);
 	}
-	// Guarda las asignaciones de botones en las opciones
+	// Guarda las asignaciones de botones en las opciones de los dos primeros mandos
-	for (int i = 0; i < num_gamepads; ++i)
+	for (size_t i = 0; i < max_controllers; ++i)
 	{
-		options.controller[i].name = Input::get()->getControllerName(i);
+		// Variables asociadas al mando
-		for (int j = 0; j < (int)options.controller[i].inputs.size(); ++j)
+		options.controllers.at(i).index = i;
 		options.controllers.at(i).name = Input::get()->getControllerName(i);
 		options.controllers.at(i).plugged = true;
 		// Asignaciones de botones
 		for (size_t j = 0; j < options.controllers.at(i).inputs.size(); ++j)
 		{
-			options.controller[i].buttons[j] = Input::get()->getControllerBinding(i, options.controller[i].inputs[j]);
+			options.controllers.at(i).buttons.at(j) = Input::get()->getControllerBinding(i, options.controllers.at(i).inputs.at(j));
 		}
 	}
 	// Asegura que algún jugador tenga el teclado asignado
 	if (getPlayerWhoUsesKeyboard() == 0)
 	{
 		setKeyboardToPlayer(1);
 	}
 }
 // Inicializa JailAudio
 void Director::initJailAudio()
 {
 	JA_Init(48000, AUDIO_S16, 2);
-	JA_EnableMusic(options.audio.music.enabled);
+	if (options.audio.enabled)
-	JA_EnableSound(options.audio.sound.enabled);
+	{
-	JA_SetMusicVolume(options.audio.music.volume);
+		JA_SetMusicVolume(to_JA_volume(options.audio.music.volume));
-	JA_SetSoundVolume(options.audio.sound.volume);
+		JA_SetSoundVolume(to_JA_volume(options.audio.sound.volume));
 	}
 	else
 	{
 		JA_SetMusicVolume(0);
 		JA_SetSoundVolume(0);
 	}
 }
 // Arranca SDL y crea la ventana
@@ -251,35 +270,36 @@ bool Director::initSDL()
 	}
 	else
 	{
-		// Inicia el generador de numeros aleatorios
+		/*
 		std::srand(static_cast<unsigned int>(SDL_GetTicks()));
 		// Muestra información de la pantalla
-		/*std::cout << "\nDisplay modes list:" << std::endl;
+		std::cout << "\nDisplay modes list:" << std::endl;
 		for (int i = 0; i < SDL_GetNumDisplayModes(0); ++i)
 		{
 			SDL_DisplayMode DM;
 			SDL_GetDisplayMode(0,i,&DM);
-			std::cout << "  - " + std::to_string(DM.w) + "x" + std::to_string(DM.h) + " @ " + std::to_string(DM.refresh_rate) + "Hz" << std::endl;
+			std::cout << "  - " << DM.w << "x" << DM.h << " @ " << DM.refresh_rate << "Hz" << std::endl;
-		}*/
+		}
 		*/
 		SDL_DisplayMode DM;
 		SDL_GetCurrentDisplayMode(0, &DM);
-		std::cout << "\nCurrent display mode: " + std::to_string(DM.w) + "x" + std::to_string(DM.h) + " @ " + std::to_string(DM.refresh_rate) + "Hz" << std::endl;
+		std::cout << "\nCurrent display mode: " << DM.w << "x" << DM.h << " @ " << DM.refresh_rate << "Hz" << std::endl;
-		std::cout << "Window resolution   : " + std::to_string(param.game.width) + "x" + std::to_string(param.game.height) + " x" + std::to_string(options.video.window.size) << std::endl;
+		std::cout << "Window resolution   : " << param.game.width << "x" << param.game.height << " x" << options.video.window.size << std::endl;
 		// Establece el filtro de la textura
 		if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, std::to_string(static_cast<int>(options.video.filter)).c_str()))
 		{
 			std::cout << "Warning: texture filtering not enabled!\n";
 		}
 #ifndef NO_SHADERS
 		if (!SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl"))
 		{
 			std::cout << "Warning: opengl not enabled!\n";
 		}
-#endif // NO_SHADERS
+#endif
-	   // Crea la ventana
+
 		// Crea la ventana
 		window_ = SDL_CreateWindow(WINDOW_CAPTION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, param.game.width * options.video.window.size, param.game.height * options.video.window.size, SDL_WINDOW_HIDDEN);
 		if (!window_)
 		{
@@ -294,10 +314,12 @@ bool Director::initSDL()
 			{
 				flags = SDL_RENDERER_PRESENTVSYNC;
 			}
 #ifndef NO_SHADERS
 			// La aceleración se activa según el define
 			flags = flags | SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
 #endif
 			renderer_ = SDL_CreateRenderer(window_, -1, flags);
 			if (!renderer_)
@@ -307,14 +329,9 @@ bool Director::initSDL()
 			}
 			else
 			{
 				// Inicializa el color de renderizado
 				SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
 				// Establece el tamaño del buffer de renderizado
 				SDL_RenderSetLogicalSize(renderer_, param.game.width, param.game.height);
 				SDL_RenderSetIntegerScale(renderer_, static_cast<SDL_bool>(options.video.integer_scale));
 				// Establece el modo de mezcla
 				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
 			}
 		}
@@ -369,100 +386,116 @@ void Director::setFileList()
 	Asset::get()->add(prefix + "/data/shaders/crtpi.glsl", AssetType::DATA);
 	// Texturas
 	Asset::get()->add(prefix + "/data/gfx/controllers/controllers.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/balloon/balloon1.png", AssetType::BITMAP);
+	{ // Controllers
-	Asset::get()->add(prefix + "/data/gfx/balloon/balloon1.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/controllers/controllers.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/balloon/balloon2.png", AssetType::BITMAP);
+	}
 	Asset::get()->add(prefix + "/data/gfx/balloon/balloon2.ani", AssetType::ANIMATION);
 	Asset::get()->add(prefix + "/data/gfx/balloon/balloon3.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/gfx/balloon/balloon3.ani", AssetType::ANIMATION);
 	Asset::get()->add(prefix + "/data/gfx/balloon/balloon4.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/gfx/balloon/balloon4.ani", AssetType::ANIMATION);
-	Asset::get()->add(prefix + "/data/gfx/balloon/explosion1.png", AssetType::BITMAP);
+	{ // Balloons
-	Asset::get()->add(prefix + "/data/gfx/balloon/explosion1.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/balloon/balloon1.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/balloon/explosion2.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/balloon/balloon1.ani", AssetType::ANIMATION);
-	Asset::get()->add(prefix + "/data/gfx/balloon/explosion2.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/balloon/balloon2.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/balloon/explosion3.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/balloon/balloon2.ani", AssetType::ANIMATION);
-	Asset::get()->add(prefix + "/data/gfx/balloon/explosion3.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/balloon/balloon3.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/balloon/explosion4.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/balloon/balloon3.ani", AssetType::ANIMATION);
-	Asset::get()->add(prefix + "/data/gfx/balloon/explosion4.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/balloon/balloon4.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/balloon/balloon4.ani", AssetType::ANIMATION);
 	}
-	Asset::get()->add(prefix + "/data/gfx/balloon/powerball.png", AssetType::BITMAP);
+	{ // Explosions
-	Asset::get()->add(prefix + "/data/gfx/balloon/powerball.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/balloon/explosion1.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/balloon/explosion1.ani", AssetType::ANIMATION);
 		Asset::get()->add(prefix + "/data/gfx/balloon/explosion2.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/balloon/explosion2.ani", AssetType::ANIMATION);
 		Asset::get()->add(prefix + "/data/gfx/balloon/explosion3.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/balloon/explosion3.ani", AssetType::ANIMATION);
 		Asset::get()->add(prefix + "/data/gfx/balloon/explosion4.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/balloon/explosion4.ani", AssetType::ANIMATION);
 	}
-	Asset::get()->add(prefix + "/data/gfx/bullet/bullet.png", AssetType::BITMAP);
+	{ // Power Ball
 		Asset::get()->add(prefix + "/data/gfx/balloon/powerball.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/balloon/powerball.ani", AssetType::ANIMATION);
 	}
-	Asset::get()->add(prefix + "/data/gfx/game/game_buildings.png", AssetType::BITMAP);
+	{ // Bala
-	Asset::get()->add(prefix + "/data/gfx/game/game_clouds1.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/bullet/bullet.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/game/game_clouds2.png", AssetType::BITMAP);
+	}
 	Asset::get()->add(prefix + "/data/gfx/game/game_grass.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/gfx/game/game_power_meter.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/gfx/game/game_sky_colors.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/game_text/game_text_1000_points.png", AssetType::BITMAP);
+	{ // Juego
-	Asset::get()->add(prefix + "/data/gfx/game_text/game_text_2500_points.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/game/game_buildings.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/game_text/game_text_5000_points.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/game/game_clouds1.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/game_text/game_text_powerup.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/game/game_clouds2.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/game_text/game_text_one_hit.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/game/game_grass.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/game/game_power_meter.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/game/game_sky_colors.png", AssetType::BITMAP);
 	}
-	Asset::get()->add(prefix + "/data/gfx/intro/intro.png", AssetType::BITMAP);
+	{ // Intro
 		Asset::get()->add(prefix + "/data/gfx/intro/intro.png", AssetType::BITMAP);
 	}
-	Asset::get()->add(prefix + "/data/gfx/logo/logo_jailgames.png", AssetType::BITMAP);
+	{ // Logo
-	Asset::get()->add(prefix + "/data/gfx/logo/logo_jailgames_mini.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/logo/logo_jailgames.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/logo/logo_since_1998.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/logo/logo_jailgames_mini.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/logo/logo_since_1998.png", AssetType::BITMAP);
 	}
-	Asset::get()->add(prefix + "/data/gfx/item/item_points1_disk.png", AssetType::BITMAP);
+	{ // Items
-	Asset::get()->add(prefix + "/data/gfx/item/item_points1_disk.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/item/item_points1_disk.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/item/item_points2_gavina.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/item/item_points1_disk.ani", AssetType::ANIMATION);
-	Asset::get()->add(prefix + "/data/gfx/item/item_points2_gavina.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/item/item_points2_gavina.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/item/item_points3_pacmar.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/item/item_points2_gavina.ani", AssetType::ANIMATION);
-	Asset::get()->add(prefix + "/data/gfx/item/item_points3_pacmar.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/item/item_points3_pacmar.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/item/item_clock.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/item/item_points3_pacmar.ani", AssetType::ANIMATION);
-	Asset::get()->add(prefix + "/data/gfx/item/item_clock.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/item/item_clock.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/item/item_coffee.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/item/item_clock.ani", AssetType::ANIMATION);
-	Asset::get()->add(prefix + "/data/gfx/item/item_coffee.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/item/item_coffee.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/item/item_coffee_machine.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/item/item_coffee.ani", AssetType::ANIMATION);
-	Asset::get()->add(prefix + "/data/gfx/item/item_coffee_machine.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/item/item_coffee_machine.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/item/item_coffee_machine.ani", AssetType::ANIMATION);
 	}
-	Asset::get()->add(prefix + "/data/gfx/title/title_bg_tile.png", AssetType::BITMAP);
+	{ // Titulo
-	Asset::get()->add(prefix + "/data/gfx/title/title_coffee.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/title/title_bg_tile.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/title/title_crisis.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/title/title_coffee.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/title/title_arcade_edition.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/title/title_crisis.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/title/title_dust.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/title/title_arcade_edition.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/title/title_dust.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/title/title_dust.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/title/title_dust.ani", AssetType::ANIMATION);
 	}
-	Asset::get()->add(prefix + "/data/gfx/player/player1.gif", AssetType::BITMAP);
+	{ // Jugador 1
-	Asset::get()->add(prefix + "/data/gfx/player/player1_pal1.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player1.gif", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/player/player1_pal2.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player1_one_coffee_palette.pal", AssetType::PALETTE);
-	Asset::get()->add(prefix + "/data/gfx/player/player1_pal3.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player1_two_coffee_palette.pal", AssetType::PALETTE);
 		Asset::get()->add(prefix + "/data/gfx/player/player1_all_white_palette.pal", AssetType::PALETTE);
 		Asset::get()->add(prefix + "/data/gfx/player/player1_power.png", AssetType::BITMAP);
 	}
-	Asset::get()->add(prefix + "/data/gfx/player/player2.gif", AssetType::BITMAP);
+	{ // Jugador 2
-	Asset::get()->add(prefix + "/data/gfx/player/player2_pal1.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player2.gif", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/gfx/player/player2_pal2.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player2_one_coffee_palette.pal", AssetType::PALETTE);
-	Asset::get()->add(prefix + "/data/gfx/player/player2_pal3.gif", AssetType::PALETTE);
+		Asset::get()->add(prefix + "/data/gfx/player/player2_two_coffee_palette.pal", AssetType::PALETTE);
 		Asset::get()->add(prefix + "/data/gfx/player/player2_all_white_palette.pal", AssetType::PALETTE);
 		Asset::get()->add(prefix + "/data/gfx/player/player2_power.png", AssetType::BITMAP);
 	}
-	Asset::get()->add(prefix + "/data/gfx/player/player.ani", AssetType::ANIMATION);
+	{ // Animaciones del jugador
-
+		Asset::get()->add(prefix + "/data/gfx/player/player.ani", AssetType::ANIMATION);
-	Asset::get()->add(prefix + "/data/gfx/player/player_power.gif", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/player/player_power.ani", AssetType::ANIMATION);
-	Asset::get()->add(prefix + "/data/gfx/player/player_power_pal.gif", AssetType::PALETTE);
+	}
 	Asset::get()->add(prefix + "/data/gfx/player/player_power.ani", AssetType::ANIMATION);
 	// Fuentes de texto
 	Asset::get()->add(prefix + "/data/font/8bithud.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/8bithud.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/nokia.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/nokia_big2.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/nokia.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/nokia2.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/nokia2.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/nokia_big2.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/smb2_big.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/smb2_big.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/smb2.gif", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/font/smb2_pal1.gif", AssetType::PALETTE);
+	Asset::get()->add(prefix + "/data/font/smb2_palette1.pal", AssetType::PALETTE);
 	Asset::get()->add(prefix + "/data/font/smb2.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/04b_25.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/04b_25.txt", AssetType::FONT);
 	// Textos
 	Asset::get()->add(prefix + "/data/lang/es_ES.txt", AssetType::LANG);
@@ -474,27 +507,24 @@ void Director::setFileList()
 		throw std::runtime_error("Falta algun fichero");
 }
 // Carga los parametros para configurar el juego
 void Director::loadParams(const std::string &file_path)
 {
 	loadParamsFromFile(file_path);
 }
 // Comprueba los parametros del programa
 void Director::checkProgramArguments(int argc, const char *argv[])
 {
 	// Establece la ruta del programa
 	executable_path_ = argv[0];
 	// Valores por defecto
 	param_file_argument_.clear();
 	// Comprueba el resto de parámetros
 	for (int i = 1; i < argc; ++i)
 	{
-		if (strcmp(argv[i], "--320x240") == 0)
+		std::string arg = argv[i];
 		if (arg == "--320x240")
 		{
-			param_file_argument_ = argv[i];
+			overrides.param_file = arg;
 		}
 		else if (arg == "--clear_score")
 		{
 			overrides.clear_hi_score_table = true;
 		}
 	}
 }
@@ -584,7 +614,11 @@ void Director::runTitle()
 void Director::runGame()
 {
 	const auto player_id = section::options == section::Options::GAME_PLAY_1P ? 1 : 2;
 #ifdef DEBUG
 	constexpr auto current_stage = 9;
 #else
 	constexpr auto current_stage = 0;
 #endif
 	auto game = std::make_unique<Game>(player_id, current_stage, GAME_MODE_DEMO_OFF);
 	game->run();
 }
@@ -622,55 +656,59 @@ int Director::run()
 		case section::Name::INIT:
 			section::name = section::Name::LOGO;
 			break;
 		case section::Name::LOGO:
 			runLogo();
 			break;
 		case section::Name::INTRO:
 			runIntro();
 			break;
 		case section::Name::TITLE:
 			runTitle();
 			break;
 		case section::Name::GAME:
 			runGame();
 			break;
 		case section::Name::HI_SCORE_TABLE:
 			runHiScoreTable();
 			break;
 		case section::Name::GAME_DEMO:
 			runDemoGame();
 			break;
 		case section::Name::INSTRUCTIONS:
 			runInstructions();
 			break;
 		default:
 			break;
 		}
 	}
-#ifdef ARCADE
+	std::string return_code;
-	// Comprueba si ha de apagar el sistema
+	switch (section::options)
-	if (section::options == section::Options::QUIT_SHUTDOWN)
+	{
-		shutdownSystem();
+	case section::Options::QUIT_WITH_KEYBOARD:
-#endif
+		return_code = "with keyboard";
 		break;
 	case section::Options::QUIT_WITH_CONTROLLER:
 		return_code = "with controller";
 		break;
 	default:
 		return_code = "from event";
 		break;
 	}
-	const auto return_code = (section::options == section::Options::QUIT_NORMAL) ? "keyboard" : "controller";
+	std::cout << "\nGame end " << return_code << std::endl;
 	std::cout << "\nGame end with " << return_code << std::endl;
 #ifndef VERBOSE
 	// Habilita de nuevo los std::cout
 	std::cout.rdbuf(orig_buf);
 #endif
 #ifdef ARCADE
 	// Comprueba si ha de apagar el sistema
 	if (section::options == section::Options::QUIT_WITH_CONTROLLER)
 		shutdownSystem();
 #endif
-	return (return_code == std::string("keyboard")) ? 0 : 1;
+	return (section::options == section::Options::QUIT_WITH_CONTROLLER) ? 1 : 0;
 }
 // Obtiene una fichero a partir de un lang::Code
@@ -681,15 +719,12 @@ std::string Director::getLangFile(lang::Code code)
 	case lang::Code::ba_BA:
 		return Asset::get()->get("ba_BA.txt");
 		break;
 	case lang::Code::es_ES:
 		return Asset::get()->get("es_ES.txt");
 		break;
 	case lang::Code::en_UK:
 		return Asset::get()->get("en_UK.txt");
 		break;
 	default:
 		break;
 	}
@@ -697,6 +732,7 @@ std::string Director::getLangFile(lang::Code code)
 	return Asset::get()->get("en_UK.txt");
 }
 #ifdef ARCADE
 // Apaga el sistema
 void Director::shutdownSystem()
 {
@@ -713,4 +749,5 @@ void Director::shutdownSystem()
 // Sistema operativo no compatible
 #error "Sistema operativo no soportado"
 #endif
-}
+}
 #endif // ARCADE
--- a/source/director.h
+++ b/source/director.h
@@ -1,15 +1,12 @@
 #pragma once
-#include <SDL2/SDL_render.h> // for SDL_Renderer
+#include <SDL2/SDL_render.h> // Para SDL_Renderer
-#include <SDL2/SDL_video.h>	 // for SDL_Window
+#include <SDL2/SDL_video.h>	 // Para SDL_Window
-#include <string>			 // for string
+#include <string>			 // Para string
 #include <vector>			 // for vector
 namespace lang
 {
 	enum class Code : int;
-}
+} // lines 9-9
 struct ResourceMusic;
 struct ResourceSound;
 // Textos
 constexpr char WINDOW_CAPTION[] = "Coffee Crisis Arcade Edition";
@@ -18,14 +15,15 @@ class Director
 {
 private:
 	// Objetos y punteros
-	SDL_Window *window_;	  // La ventana donde dibujamos
+	SDL_Window *window_;	 // La ventana donde dibujamos
-	SDL_Renderer *renderer_;  // El renderizador de la ventana
+	SDL_Renderer *renderer_; // El renderizador de la ventana
 #ifndef VERBOSE
 	std::streambuf *orig_buf; // Puntero al buffer de flujo original para restaurar std::cout
 #endif
 	// Variables
-	std::string executable_path_;	  // Path del ejecutable
+	std::string executable_path_; // Path del ejecutable
-	std::string system_folder_;		  // Carpeta del sistema donde guardar datos
+	std::string system_folder_;	  // Carpeta del sistema donde guardar datos
 	std::string param_file_argument_; // Argumento para gestionar el fichero con los parametros del programa
 	// Inicializa jail_audio
 	void initJailAudio();
@@ -36,9 +34,6 @@ private:
 	// Asigna los botones y teclas al objeto Input
 	void bindInputs();
 	// Carga los parametros para configurar el juego
 	void loadParams(const std::string &file_path);
 	// Crea el indice de ficheros
 	void setFileList();
@@ -71,9 +66,10 @@ private:
 	// 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
--- a/source/enter_name.cpp
+++ b/source/enter_name.cpp
@@ -1,5 +1,6 @@
 #include "enter_name.h"
-#include <algorithm> // for max, min
+#include <stddef.h>  // Para size_t
 #include <algorithm> // Para max, min
 // Constructor
 EnterName::EnterName()
@@ -16,7 +17,7 @@ void EnterName::init()
    // Inicia la lista de caracteres permitidos
    character_list_ = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()";
    position_ = 0;
-    num_characters_ = (int)character_list_.size();
+    num_characters_ = static_cast<int>(character_list_.size());
    // Pone la lista de indices para que refleje el nombre
    updateCharacterIndex();
@@ -36,7 +37,7 @@ void EnterName::incPosition()
 // Decrementa la posición
 void EnterName::decPosition()
 {
-    position_--;
+    --position_;
    position_ = std::max(position_, 0);
 }
@@ -76,14 +77,14 @@ void EnterName::updateName()
 void EnterName::updateCharacterIndex()
 {
    // Rellena de espacios y marca como no usados
-    for (int i = 0; i < NAME_LENGHT; ++i)
+    for (size_t i = 0; i < NAME_LENGHT; ++i)
    {
        character_index_[i] = 0;
        position_has_been_used_[i] = false;
    }
-    // Coloca los índices en funcion de los caracteres que forman el nombre
+    // Coloca los índices en función de los caracteres que forman el nombre
-    for (int i = 0; i < (int)name_.size(); ++i)
+    for (size_t i = 0; i < name_.size(); ++i)
    {
        character_index_[i] = findIndex(name_.at(i));
        position_has_been_used_[i] = true;
@@ -91,15 +92,11 @@ void EnterName::updateCharacterIndex()
 }
 // Encuentra el indice de un caracter en "character_list_"
-int EnterName::findIndex(char character)
+int EnterName::findIndex(char character) const
 {
-    for (int i = 0; i < (int)character_list_.size(); ++i)
+    for (size_t i = 0; i < character_list_.size(); ++i)
-    {
+        if (character == character_list_.at(i))
        if (character == character_list_[i])
        {
            return i;
        }
    }
    return 0;
 }
@@ -121,9 +118,7 @@ void EnterName::checkIfPositionHasBeenUsed()
    auto used = position_has_been_used_[position_];
    if (!used && position_ > 0)
    {
        character_index_[position_] = character_index_[position_ - 1];
    }
    position_has_been_used_[position_] = true;
    updateName();
--- a/source/enter_name.h
+++ b/source/enter_name.h
@@ -30,7 +30,7 @@ private:
    void updateCharacterIndex();
    // Encuentra el indice de un caracter en "characterList"
-    int findIndex(char character);
+    int findIndex(char character) const;
    // Comprueba la posición y copia el caracter si es necesario
    void checkIfPositionHasBeenUsed();
--- a/source/explosions.cpp
+++ b/source/explosions.cpp
@@ -1,20 +1,6 @@
 #include "explosions.h"
-#include <utility>           // for move
+#include "animated_sprite.h" // Para AnimatedSprite
-#include "animated_sprite.h" // for SpriteAnimated
+class Texture;               // lines 4-4
 class Texture;               // lines 3-3
 // Constructor
 Explosions::Explosions()
 {
    textures_.clear();
    explosions_.clear();
 }
 // Destructor
 Explosions::~Explosions()
 {
    explosions_.clear();
 }
 // Actualiza la lógica de la clase
 void Explosions::update()
@@ -38,7 +24,7 @@ void Explosions::render()
 }
 // Añade texturas al objeto
-void Explosions::addTexture(int size, std::shared_ptr<Texture> texture, std::vector<std::string> &animation)
+void Explosions::addTexture(int size, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
 {
    textures_.emplace_back(ExplosionTexture(size, texture, animation));
 }
--- a/source/explosions.h
+++ b/source/explosions.h
@@ -1,10 +1,10 @@
 #pragma once
-#include <memory> // for shared_ptr, unique_ptr
+#include <memory>            // Para unique_ptr, shared_ptr
-#include <string> // for string
+#include <string>            // Para string
-#include <vector> // for vector
+#include <vector>            // Para vector
-class AnimatedSprite;
+#include "animated_sprite.h" // Para AnimatedSprite
-class Texture;
+class Texture;               // lines 7-7
 struct ExplosionTexture
 {
@@ -13,7 +13,7 @@ struct ExplosionTexture
    std::vector<std::string> animation; // Animación para la textura
    // Constructor
-    ExplosionTexture(int sz, std::shared_ptr<Texture> tex, std::vector<std::string> anim)
+    ExplosionTexture(int sz, std::shared_ptr<Texture> tex, const std::vector<std::string> &anim)
        : size(sz), texture(tex), animation(anim) {}
 };
@@ -33,10 +33,10 @@ private:
 public:
    // Constructor
-    Explosions();
+    Explosions() = default;
    // Destructor
-    ~Explosions();
+    ~Explosions() = default;
    // Actualiza la lógica de la clase
    void update();
@@ -45,7 +45,7 @@ public:
    void render();
    // Añade texturas al objeto
-    void addTexture(int size, std::shared_ptr<Texture> texture, std::vector<std::string> &animation);
+    void addTexture(int size, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
    // Añade una explosión
    void add(int x, int y, int size);
--- a/source/fade.cpp
+++ b/source/fade.cpp
@@ -1,11 +1,10 @@
 #include "fade.h"
-#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND, SDL_BLENDMODE_NONE
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND, SDL_BLENDMODE_NONE
-#include <SDL2/SDL_pixels.h>	// for SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_pixels.h>	// Para SDL_PIXELFORMAT_RGBA8888
-#include <stdlib.h>				// for rand
+#include <stdlib.h>				// Para rand
-#include <algorithm>			// for min, max
+#include <algorithm>			// Para min, max
-#include "param.h"				// for param
+#include "param.h"				// Para Param, param, ParamGame, ParamFade
-#include "screen.h"
+#include "screen.h"				// Para Screen
 #include "utils.h"				// for Param, ParamGame, ParamFade
 // Constructor
 Fade::Fade()
--- a/source/fade.h
+++ b/source/fade.h
@@ -1,9 +1,9 @@
 #pragma once
-#include <SDL2/SDL_rect.h>	 // for SDL_Rect
+#include <SDL2/SDL_rect.h>	 // para SDL_Rect
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h> // for Uint8, Uint16
+#include <SDL2/SDL_stdinc.h> // para Uint8, Uint16
-#include <vector>			 // for vector
+#include <vector>			 // para vector
 // Tipos de fundido
 enum class FadeType : Uint8
--- a/source/game.cpp
+++ b/source/game.cpp
--- a/source/game.h
+++ b/source/game.h
@@ -1,30 +1,31 @@
 #pragma once
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_render.h>	  // Para SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h> // for Uint32
+#include <SDL2/SDL_stdinc.h>	  // Para Uint32, Uint8
-#include <memory>			 // for shared_ptr, unique_ptr
+#include <memory>				  // Para shared_ptr, unique_ptr
-#include <string>			 // for string
+#include <string>				  // Para string
-#include <vector>			 // for vector
+#include <vector>				  // Para vector
-#include "balloon.h"		 // for Balloon
+#include "balloon.h"			  // Para Balloon
-#include "player.h"			 // for Player
+#include "manage_hiscore_table.h" // Para HiScoreEntry
-#include "utils.h"			 // for DemoKeys, Color, HiScoreEntry
+#include "options.h"			  // Para Options, OptionsGame, options
-class Asset;
+#include "player.h"				  // Para Player
-class Background;
+#include "utils.h"				  // Para Demo
-class BalloonFormations;
+class Asset;					  // lines 14-14
-class Bullet;
+class Background;				  // lines 15-15
-class Explosions;
+class BalloonFormations;		  // lines 16-16
-class Fade;
+class Bullet;					  // lines 17-17
-class Input;
+class Explosions;				  // lines 18-18
-class Item;
+class Fade;						  // lines 19-19
-class Scoreboard;
+class Input;					  // lines 20-20
-class Screen;
+class Item;						  // lines 21-21
-class SmartSprite;
+class PathSprite;				  // lines 22-22
-class Text;
+class Scoreboard;				  // lines 23-23
-class Texture;
+class Screen;					  // lines 24-24
-enum class BulletType; // lines 26-26
+class SmartSprite;				  // lines 25-25
-struct JA_Music_t;	   // lines 27-27
+class Texture;					  // lines 27-27
-struct JA_Sound_t;	   // lines 28-28
+enum class BulletType : Uint8;	  // lines 28-28
-enum class ItemType;
+enum class ItemType;			  // lines 29-29
 struct Path;
 // Modo demo
 constexpr bool GAME_MODE_DEMO_OFF = false;
@@ -32,26 +33,6 @@ constexpr bool GAME_MODE_DEMO_ON = true;
 // Cantidad de elementos a escribir en los ficheros de datos
 constexpr int TOTAL_SCORE_DATA = 3;
 constexpr int TOTAL_DEMO_DATA = 2000;
 // Contadores
 constexpr int STAGE_COUNTER = 200;
 constexpr int HELP_COUNTER = 1000;
 constexpr int GAME_COMPLETED_START_FADE = 500;
 constexpr int GAME_COMPLETED_END = 700;
 constexpr int GAME_OVER_COUNTER = 350;
 // Porcentaje de aparición de los objetos
 constexpr int ITEM_POINTS_1_DISK_ODDS = 10;
 constexpr int ITEM_POINTS_2_GAVINA_ODDS = 6;
 constexpr int ITEM_POINTS_3_PACMAR_ODDS = 3;
 constexpr int ITEM_CLOCK_ODDS = 5;
 constexpr int ITEM_COFFEE_ODDS = 5;
 constexpr int ITEM_POWER_BALL_ODDS = 0;
 constexpr int ITEM_COFFEE_MACHINE_ODDS = 4;
 // Valores para las variables asociadas a los objetos
 constexpr int TIME_STOPPED_COUNTER = 300;
 /*
 	Esta clase gestiona un estado del programa. Se encarga de toda la parte en la
@@ -83,6 +64,31 @@ constexpr int TIME_STOPPED_COUNTER = 300;
 class Game
 {
 private:
 	// Enum
 	enum class GameState
 	{
 		PLAYING,
 		COMPLETED,
 		GAME_OVER,
 	};
 	// Contadores
 	static constexpr int HELP_COUNTER_ = 1000;
 	static constexpr int GAME_COMPLETED_START_FADE_ = 500;
 	static constexpr int GAME_COMPLETED_END_ = 700;
 	static constexpr int GAME_OVER_COUNTER_ = 350;
 	static constexpr int TIME_STOPPED_COUNTER_ = 360;
 	// Porcentaje de aparición de los objetos
 	static constexpr int ITEM_POINTS_1_DISK_ODDS_ = 10;
 	static constexpr int ITEM_POINTS_2_GAVINA_ODDS_ = 6;
 	static constexpr int ITEM_POINTS_3_PACMAR_ODDS_ = 3;
 	static constexpr int ITEM_CLOCK_ODDS_ = 5;
 	static constexpr int ITEM_COFFEE_ODDS_ = 5;
 	static constexpr int ITEM_POWER_BALL_ODDS_ = 0;
 	static constexpr int ITEM_COFFEE_MACHINE_ODDS_ = 4;
 	// Estructuras
 	struct Helper
 	{
 		bool need_coffee;			  // Indica si se necesitan cafes
@@ -95,15 +101,19 @@ private:
 		int item_clock_odds;		  // Probabilidad de aparición del objeto
 		int item_coffee_odds;		  // Probabilidad de aparición del objeto
 		int item_coffee_machine_odds; // Probabilidad de aparición del objeto
 	};
-	struct Demo
+		// Constructor con valores predeterminados
-	{
+		Helper()
-		bool enabled;							// Indica si está activo el modo demo
+			: need_coffee(false),
-		bool recording;							// Indica si está activado el modo para grabar la demo
+			  need_coffee_machine(false),
-		int counter;							// Contador para el modo demo
+			  need_power_ball(false),
-		DemoKeys keys;							// Variable con las pulsaciones de teclas del modo demo
+			  counter(HELP_COUNTER_),
-		DemoKeys data_file[2][TOTAL_DEMO_DATA]; // Vector con diferentes sets de datos con los movimientos para la demo
+			  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
@@ -124,6 +134,7 @@ private:
 	std::vector<std::unique_ptr<Bullet>> bullets_;			  // Vector con las balas
 	std::vector<std::unique_ptr<Item>> items_;				  // Vector con los items
 	std::vector<std::unique_ptr<SmartSprite>> smart_sprites_; // Vector con los smartsprites
 	std::vector<std::unique_ptr<PathSprite>> path_sprites_;	  // Vector con los smartsprites
 	std::shared_ptr<Texture> bullet_texture_;							 // Textura para las balas
 	std::vector<std::shared_ptr<Texture>> item_textures_;				 // Vector con las texturas de los items
@@ -138,49 +149,41 @@ private:
 	std::vector<std::vector<std::string>> balloon_animations_;	  // Vector con las animaciones de los globos
 	std::vector<std::vector<std::string>> explosions_animations_; // Vector con las animaciones de las explosiones
 	std::unique_ptr<Text> text_;			// Fuente para los textos del juego
 	std::unique_ptr<Text> text_big_;		// Fuente de texto grande
 	std::unique_ptr<Text> text_nokia2_;		// Otra fuente de texto para mensajes
 	std::unique_ptr<Text> text_nokia2_big_; // Y la versión en grande
 	std::unique_ptr<Fade> fade_; // Objeto para renderizar fades
 	std::vector<Path> paths_;	 // Vector con los recorridos precalculados almacenados
 	// Variables
-	Uint32 ticks_;								 // Contador de ticks para ajustar la velocidad del programa
+	HiScoreEntry hi_score_ = HiScoreEntry(
-	Uint32 ticks_speed_;						 // Velocidad a la que se repiten los bucles del programa
+		options.game.hi_score_table[0].name,
-	bool hi_score_achieved_;					 // Indica si se ha superado la puntuación máxima
+		options.game.hi_score_table[0].score); // Máxima puntuación y nombre de quien la ostenta
-	HiScoreEntry hi_score_;						 // Máxima puntuación y nombre de quien la ostenta
+
-	int current_stage_;							 // Indica la fase actual
+	int current_stage_;									  // Indica la fase actual
-	int stage_bitmap_counter_;					 // Contador para el tiempo visible del texto de Stage
+	Demo demo_;											  // Variable con todas las variables relacionadas con el modo demo
-	float stage_bitmap_path_[STAGE_COUNTER];	 // Vector con los puntos Y por donde se desplaza el texto
+	GameDifficulty difficulty_ = options.game.difficulty; // Dificultad del juego
-	float get_ready_bitmap_path_[STAGE_COUNTER]; // Vector con los puntos X por donde se desplaza el texto
+	Helper helper_;										  // Variable para gestionar las ayudas
-	int game_over_counter_;						 // Contador para el estado de fin de partida
+	Uint32 ticks_ = 0;									  // Contador de ticks para ajustar la velocidad del programa
-	int menace_current_;						 // Nivel de amenaza actual
+	bool coffee_machine_enabled_ = false;				  // Indica si hay una máquina de café en el terreno de juego
-	int menace_threshold_;						 // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
+	bool hi_score_achieved_ = false;					  // Indica si se ha superado la puntuación máxima
-	bool time_stopped_;							 // Indica si el tiempo está detenido
+	bool paused_ = false;								  // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
-	int time_stopped_counter_;					 // Temporizador para llevar la cuenta del tiempo detenido
+	bool power_ball_enabled_ = false;					  // Indica si hay una powerball ya activa
-	int counter_;								 // Contador para el juego
+	float balloon_speed_;								  // Velocidad a la que se mueven los enemigos
-	int balloons_popped_;						 // Lleva la cuenta de los globos explotados
+	float default_balloon_speed_;						  // Velocidad base de los enemigos, sin incrementar
-	int last_ballon_deploy_;					 // Guarda cual ha sido la última formación desplegada para no repetir;
+	float difficulty_score_multiplier_;					  // Multiplicador de puntos en función de la dificultad
-	int balloon_deploy_counter_;				 // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
+	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
-	float balloon_speed_;						 // Velocidad a la que se mueven los enemigos
+	int balloons_popped_ = 0;							  // Lleva la cuenta de los globos explotados
-	float default_balloon_speed_;				 // Velocidad base de los enemigos, sin incrementar
+	int counter_ = 0;									  // Contador para el juego
-	Helper helper_;								 // Variable para gestionar las ayudas
+	int current_power_ = 0;								  // Poder actual almacenado para completar la fase
-	bool power_ball_enabled_;					 // Indica si hay una powerball ya activa
+	int game_completed_counter_ = 0;					  // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
-	int power_ball_counter_;					 // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
+	int game_over_counter_ = GAME_OVER_COUNTER_;		  // Contador para el estado de fin de partida
-	bool coffee_machine_enabled_;				 // Indica si hay una máquina de café en el terreno de juego
+	int last_balloon_deploy_ = 0;						  // Guarda cual ha sido la última formación desplegada para no repetir;
-	bool game_completed_;						 // Indica si se ha completado la partida, llegando al final de la ultima pantalla
+	int menace_current_ = 0;							  // Nivel de amenaza actual
-	int game_completed_counter_;				 // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
+	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
-	GameDifficulty difficulty_;					 // Dificultad del juego
+	int power_ball_counter_ = 0;						  // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
-	float difficulty_score_multiplier_;			 // Multiplicador de puntos en función de la dificultad
+	int time_stopped_counter_ = 0;						  // Temporizador para llevar la cuenta del tiempo detenido
-	Color difficulty_color_;					 // Color asociado a la dificultad
+	int total_power_to_complete_game_;					  // La suma del poder necesario para completar todas las fases
-	int last_stage_reached_;					 // Contiene el número de la última pantalla que se ha alcanzado
+	GameState state_ = GameState::PLAYING;				  // Estado
 	Demo demo_;									 // Variable con todas las variables relacionadas con el modo demo
 	int total_power_to_complete_game_;			 // La suma del poder necesario para completar todas las fases
 	bool paused_;								 // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
 	int current_power_;							 // Poder actual almacenado para completar la fase
 #ifdef DEBUG
-	bool auto_pop_balloons_; // Si es true, incrementa automaticamente los globos explotados
+	bool auto_pop_balloons_ = false; // Si es true, incrementa automaticamente los globos explotados
 #endif
 	// Actualiza el juego
@@ -192,21 +195,9 @@ private:
 	// Comprueba los eventos que hay en cola
 	void checkEvents();
-	// Inicializa las variables necesarias para la sección 'Game'
+	// Asigna texturas y animaciones
-	void init(int player_id);
+	void setResources();
 	// 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(const std::string &file_path, DemoKeys (*data_file)[TOTAL_DEMO_DATA]);
 #ifdef RECORDING
 	// Guarda el fichero de datos para la demo
 	bool saveDemoFile(const std::string &file_path);
 #endif
 	// Crea una formación de enemigos
 	void deployBalloonFormation();
@@ -226,7 +217,7 @@ private:
 	void updateStage();
 	// Actualiza el estado de fin de la partida
-	void updateGameOver();
+	void updateGameOverState();
 	// Actualiza los globos
 	void updateBalloons();
@@ -235,7 +226,10 @@ private:
 	void renderBalloons();
 	// Crea un globo nuevo en el vector de globos
-	std::shared_ptr<Balloon> createBalloon(float x, int y, int kind, float velx, float speed, int stopped_counter);
+	std::shared_ptr<Balloon> createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int stopped_counter);
 	// 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();
@@ -244,7 +238,7 @@ private:
 	void setBalloonSpeed(float speed);
 	// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
-	void updateBalloonSpeed();
+	void checkAndUpdateBalloonSpeed();
 	// Explosiona un globo. Lo destruye y crea otros dos si es el caso
 	void popBalloon(std::shared_ptr<Balloon> balloon);
@@ -255,12 +249,21 @@ private:
 	// Destruye todos los globos
 	void destroyAllBalloons();
 	// Destruye todos los items
 	void destroyAllItems();
 	// Detiene todos los globos
-	void stopAllBalloons(int time);
+	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();
 	// Vacia el vector de globos
 	void freeBalloons();
@@ -300,20 +303,32 @@ private:
 	// Vacia el vector de items
 	void freeItems();
-	// Crea un objeto SpriteSmart
+	// Crea un objeto PathSprite
-	void createItemScoreSprite(int x, int y, std::shared_ptr<Texture> texture);
+	void createItemText(int x, std::shared_ptr<Texture> texture);
 	// Crea un objeto PathSprite
 	void createMessage(const std::vector<Path> &paths, std::shared_ptr<Texture> texture);
 	// Vacia el vector de smartsprites
-	void freeSpriteSmarts();
+	void freeSmartSprites();
 	// Vacia el vector de pathsprites
 	void freePathSprites();
 	// Crea un SpriteSmart para arrojar el item café al recibir un impacto
 	void throwCoffee(int x, int y);
 	// Actualiza los SpriteSmarts
-	void updateSpriteSmarts();
+	void updateSmartSprites();
 	// Pinta los SpriteSmarts activos
-	void renderSpriteSmarts();
+	void renderSmartSprites();
 	// Actualiza los PathSprites
 	void updatePathSprites();
 	// Pinta los PathSprites activos
 	void renderPathSprites();
 	// Acciones a realizar cuando el jugador muere
 	void killPlayer(std::shared_ptr<Player> &player);
@@ -321,26 +336,11 @@ private:
 	// Calcula y establece el valor de amenaza en funcion de los globos activos
 	void evaluateAndSetMenace();
 	// Obtiene el valor de la variable
 	int getMenace() const;
 	// Establece el valor de la variable
 	void setTimeStopped(bool value);
 	// Obtiene el valor de la variable
 	bool isTimeStopped() const;
 	// Establece el valor de la variable
 	void setTimeStoppedCounter(int value);
 	// Incrementa el valor de la variable
 	void incTimeStoppedCounter(int value);
 	// Actualiza la variable EnemyDeployCounter
 	void updateBalloonDeployCounter();
 	// Actualiza y comprueba el valor de la variable
-	void updateTimeStoppedCounter();
+	void updateTimeStopped();
 	// Gestiona el nivel de amenaza
 	void updateMenace();
@@ -348,8 +348,8 @@ private:
 	// Actualiza el fondo
 	void updateBackground();
-	// Pinta diferentes mensajes en la pantalla
+	// Inicializa las variables que contienen puntos de ruta para mover objetos
-	void renderMessages();
+	void initPaths();
 	// Habilita el efecto del item de detener el tiempo
 	void enableTimeStopItem();
@@ -363,12 +363,6 @@ private:
 	// 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();
@@ -381,9 +375,6 @@ private:
 	// Comprueba si todos los jugadores han terminado de jugar
 	bool allPlayersAreNotPlaying();
 	// Elimina todos los objetos contenidos en vectores
 	void deleteAllVectorObjects();
 	// Recarga las texturas
 	void reloadTextures();
@@ -424,7 +415,6 @@ private:
 	void handleDemoMode();
 	// Procesa las entradas para un jugador específico durante el modo demo.
 	// Incluye movimientos (izquierda, derecha, sin movimiento) y disparos automáticos.
 	void handleDemoPlayerInput(const std::shared_ptr<Player> &player, int index);
 	// Maneja el disparo de un jugador, incluyendo la creación de balas y la gestión del tiempo de espera entre disparos.
@@ -445,6 +435,54 @@ private:
 	// Procesa las entradas para la introducción del nombre del jugador.
 	void handleNameInput(const std::shared_ptr<Player> &player);
 	// Inicializa las variables para el modo DEMO
 	void initDemo(int player_id);
 	// Calcula el poder total necesario para completar el juego
 	void setTotalPower();
 	// Inicializa el marcador
 	void initScoreboard();
 	// Inicializa las opciones relacionadas con la dificultad
 	void initDifficultyVars();
 	// Inicializa los jugadores
 	void initPlayers(int player_id);
 	// Crea dos globos gordos
 	void createTwoBigBalloons();
 	// 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();
 	// Actualiza las variables durante el transcurso del final del juego
 	void updateCompletedGame();
 	// 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();
 public:
 	// Constructor
 	Game(int playerID, int current_stage, bool demo);
--- a/source/game_logo.cpp
+++ b/source/game_logo.cpp
@@ -1,16 +1,13 @@
 #include "game_logo.h"
-#include <SDL2/SDL_render.h> // for SDL_FLIP_HORIZONTAL
+#include <SDL2/SDL_render.h> // Para SDL_FLIP_HORIZONTAL
-#include <algorithm>         // for max
+#include <algorithm>         // Para max
-#include "animated_sprite.h" // for SpriteAnimated
+#include "animated_sprite.h" // Para AnimatedSprite
-#include "asset.h"           // for Asset
+#include "jail_audio.h"      // Para JA_PlaySound
-#include "jail_audio.h"      // JA_PlaySound
+#include "param.h"           // Para Param, param, ParamGame, ParamTitle
-#include "param.h"           // for param
+#include "resource.h"        // Para Resource
-#include "resource.h"        // for Resource
+#include "smart_sprite.h"    // Para SmartSprite
-#include "screen.h"          // for Screen
+#include "sprite.h"          // Para Sprite
-#include "smart_sprite.h"    // for SpriteSmart
+#include "texture.h"         // Para Texture
 #include "sprite.h"          // for Sprite
 #include "texture.h"         // for Texture
 #include "utils.h"           // for Param, ParamGame, ParamTitle
 // Constructor
 GameLogo::GameLogo(int x, int y)
@@ -27,7 +24,6 @@ GameLogo::GameLogo(int x, int y)
      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)
 {
@@ -51,7 +47,6 @@ void GameLogo::init()
    shake_.origin = xp;
    // Inicializa el bitmap de 'Coffee'
    coffee_sprite_->init();
    coffee_sprite_->setPosX(xp);
    coffee_sprite_->setPosY(y_ - coffee_texture_->getHeight() - desp);
    coffee_sprite_->setWidth(coffee_texture_->getWidth());
@@ -67,7 +62,6 @@ void GameLogo::init()
    coffee_sprite_->setDestY(y_ - coffee_texture_->getHeight());
    // Inicializa el bitmap de 'Crisis'
    crisis_sprite_->init();
    crisis_sprite_->setPosX(xp + 15);
    crisis_sprite_->setPosY(y_ + desp);
    crisis_sprite_->setWidth(crisis_texture_->getWidth());
@@ -106,9 +100,7 @@ void GameLogo::render()
    crisis_sprite_->render();
    if (status_ == Status::FINISHED)
    {
        arcade_edition_sprite_->render();
    }
    // Dibuja el polvillo del logo
    dust_right_sprite_->render();
--- a/source/game_logo.h
+++ b/source/game_logo.h
@@ -1,11 +1,10 @@
 #pragma once
-#include <memory> // for unique_ptr, shared_ptr
+#include <memory>            // Para unique_ptr, shared_ptr
-#include "animated_sprite.h"
+#include "animated_sprite.h" // Para AnimatedSprite
-#include "smart_sprite.h"
+#include "smart_sprite.h"    // Para SmartSprite
-class Sprite;
+#include "sprite.h"          // Para Sprite
-class Texture;
+class Texture;               // lines 7-7
 struct JA_Sound_t; // lines 10-10
 // Clase GameLogo
 class GameLogo
--- a/source/global_inputs.cpp
+++ b/source/global_inputs.cpp
@@ -1,14 +1,14 @@
 #include "global_inputs.h"
-#include <string>       // for basic_string, operator+
+#include <string>           // Para operator+, string
-#include "input.h"      // for Input, inputs_e, INPUT_DO_NOT_ALLOW_REPEAT
+#include "input.h"          // Para Input, InputType, INPUT_DO_NOT_ALLOW_REPEAT
-#include "jail_audio.h" // for JA_EnableMusic, JA_EnableSound
+#include "jail_audio.h"     // Para JA_EnableMusic, JA_EnableSound
-#include "lang.h"       // for getText
+#include "lang.h"           // Para getText
-#include "notifier.h"   // for Notifier
+#include "notifier.h"       // Para Notifier
-#include "options.h"    // for options
+#include "on_screen_help.h" // Para OnScreenHelp
-#include "on_screen_help.h"
+#include "options.h"        // Para Options, OptionsAudio, options, OptionsM...
-#include "screen.h"  // for Screen
+#include "section.h"        // Para Name, Options, name, options
-#include "section.h" // for SectionOptions, name, SectionName, options
+#include "utils.h"          // Para boolToOnOff, stringInVector
-#include "utils.h"   // for OptionsAudio, Options, OptionsMusic, boolToOnOff
+#include "screen.h"
 namespace globalInputs
 {
@@ -39,10 +39,10 @@ namespace globalInputs
        else
        {
 #ifdef ARCADE
-            const int index = code == section::Options::QUIT_NORMAL ? 94 : 116;
+            const int index = code == section::Options::QUIT_WITH_CONTROLLER ? 116 : 94;
-            Notifier::get()->showText(lang::getText(index), std::string(), -1, exit_code);
+            Notifier::get()->showText({lang::getText(index), std::string()}, -1, exit_code);
 #else
-            Notifier::get()->showText(lang::getText(94), std::string(), -1, exit_code);
+            Notifier::get()->showText({lang::getText(94), std::string()}, -1, exit_code);
 #endif
        }
    }
@@ -51,93 +51,168 @@ namespace globalInputs
    void reset()
    {
        section::name = section::Name::INIT;
-        Notifier::get()->showText("Reset");
+        Notifier::get()->showText({"Reset"});
    }
    // Activa o desactiva el audio
-    void switchAudio()
+    void toggleAudio()
    {
-        options.audio.sound.enabled = options.audio.music.enabled = !options.audio.music.enabled;
+        options.audio.enabled = !options.audio.enabled;
-        JA_EnableMusic(options.audio.music.enabled);
+        if (options.audio.enabled)
-        JA_EnableSound(options.audio.sound.enabled);
+        {
-        Notifier::get()->showText("Audio " + boolToOnOff(options.audio.music.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()
    {
-        // Comprueba si se sale con el teclado
+        // Teclado
        if (Input::get()->checkInput(InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
        {
-            quit(section::Options::QUIT_NORMAL);
+#ifndef ARCADE
-            return;
+            // Comprueba el teclado para cambiar entre pantalla completa y ventana
-        }
+            if (Input::get()->checkInput(InputType::WINDOW_FULLSCREEN, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
        // Comprueba si se va a resetear el juego
        else if (Input::get()->checkInput(InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
        {
            reset();
            return;
        }
        else if (Input::get()->checkInput(InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
        {
            switchAudio();
            return;
        }
        else if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
        {
            service_pressed_counter[0]++;
            if (service_pressed_counter[0] >= 3000)
            {
-                OnScreenHelp::get()->toggleState();
+                Screen::get()->toggleVideoMode();
-                service_pressed_counter[0] = 0;
+                const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? "Window" : "Fullscreen";
-            }
+                Notifier::get()->showText({mode + " mode"});
            return;
        }
        else
        {
            service_pressed_counter[0] = 0;
        }
        for (int i = 0; i < Input::get()->getNumControllers(); ++i)
        {
            // Comprueba si se sale con el mando
            if (Input::get()->checkModInput(InputType::SERVICE, InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
            {
                quit(section::Options::QUIT_SHUTDOWN);
                return;
            }
-            // Comprueba si se va a resetear el juego
+            // Comprueba el teclado para decrementar el tamaño de la ventana
-            else if (Input::get()->checkModInput(InputType::SERVICE, InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+            if (Input::get()->checkInput(InputType::WINDOW_DEC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
            {
                Screen::get()->decWindowSize();
                const std::string size = std::to_string(options.video.window.size);
                Notifier::get()->showText({"Window size x" + size});
                return;
            }
            // Comprueba el teclado para incrementar el tamaño de la ventana
            if (Input::get()->checkInput(InputType::WINDOW_INC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
            {
                Screen::get()->incWindowSize();
                const std::string size = std::to_string(options.video.window.size);
                Notifier::get()->showText({"Window size x" + size});
                return;
            }
 #endif
            // Salir
            if (Input::get()->checkInput(InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
            {
                quit(section::Options::QUIT_WITH_KEYBOARD);
                return;
            }
            // Reset
            if (Input::get()->checkInput(InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
            {
                reset();
                return;
            }
-            // Comprueba si se va a activar o desactivar el audio
+            // Audio
-            else if (Input::get()->checkModInput(InputType::SERVICE, InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+            if (Input::get()->checkInput(InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
            {
-                switchAudio();
+                toggleAudio();
                return;
            }
-            if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+            // Shaders
            if (Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
            {
-                service_pressed_counter[i + 1]++;
+                Screen::get()->toggleShaders();
                return;
            }
-                if (service_pressed_counter[i + 1] >= 3000)
+#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[i + 1] = 0;
+                    service_pressed_counter[0] = 0;
                }
                return;
            }
-            else
+
            service_pressed_counter[0] = 0;
        }
        // Mandos
        {
            for (int i = 0; i < Input::get()->getNumControllers(); ++i)
            {
                // Salir
                if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
                    Input::get()->checkInput(InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
                {
                    quit(section::Options::QUIT_WITH_CONTROLLER);
                    return;
                }
                // Reset
                if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
                    Input::get()->checkInput(InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
                {
                    reset();
                    return;
                }
                // Audio
                if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
                    Input::get()->checkInput(InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
                {
                    toggleAudio();
                    return;
                }
                // Shaders
                if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
                    Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
                {
                    Screen::get()->toggleShaders();
                    return;
                }
 #ifdef DEBUG
                // Debug Info
                if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
                    Input::get()->checkInput(InputType::SHOWINFO, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
                {
                    Screen::get()->toggleDebugInfo();
                    return;
                }
 #endif
                // OnScreenHelp
                if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
                {
                    service_pressed_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;
            }
        }
--- a/source/hiscore_table.cpp
+++ b/source/hiscore_table.cpp
@@ -1,51 +1,43 @@
 #include "hiscore_table.h"
-#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_blendmode.h>	  // Para SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_events.h>	// for SDL_PollEvent, SDL_Event, SDL_QUIT
+#include <SDL2/SDL_events.h>	  // Para SDL_PollEvent, SDL_Event, SDL_QUIT
-#include <SDL2/SDL_pixels.h>	// for SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_pixels.h>	  // Para SDL_PIXELFORMAT_RGBA8888
-#include <SDL2/SDL_timer.h>		// for SDL_GetTicks
+#include <SDL2/SDL_timer.h>		  // Para SDL_GetTicks
-#include <SDL2/SDL_video.h>		// for SDL_WINDOWEVENT_SIZE_CHANGED
+#include <SDL2/SDL_video.h>		  // Para SDL_WINDOWEVENT_SIZE_CHANGED
-#include <algorithm>			// for max
+#include <algorithm>			  // Para max
-#include <vector>				// for vector
+#include <vector>				  // Para vector
-#include "asset.h"				// for Asset
+#include "background.h"			  // Para Background
-#include "background.h"			// for Background
+#include "fade.h"				  // Para Fade, FadeMode, FadeType
-#include "fade.h"				// for Fade, FadeMode, FadeType
+#include "global_inputs.h"		  // Para check
-#include "global_inputs.h"		// for check
+#include "input.h"				  // Para Input
-#include "input.h"				// for Input
+#include "jail_audio.h"			  // Para JA_GetMusicState, JA_Music_state
-#include "jail_audio.h"			// for JA_GetMusicState, JA_Music_state
+#include "lang.h"				  // Para getText
-#include "lang.h"				// for getText
+#include "manage_hiscore_table.h" // Para HiScoreEntry
-#include "options.h"			// for options
+#include "options.h"			  // Para Options, OptionsGame, options
-#include "param.h"				// for param
+#include "param.h"				  // Para Param, param, ParamGame, ParamFade
-#include "resource.h"			// for Resource
+#include "resource.h"			  // Para Resource
-#include "screen.h"				// for Screen
+#include "screen.h"				  // Para Screen
-#include "section.h"			// for Name, name, Options, options
+#include "section.h"			  // Para Name, name, Options, options
-#include "text.h"				// for Text, TEXT_CENTER, TEXT_SHADOW, TEXT...
+#include "text.h"				  // Para Text, TEXT_CENTER, TEXT_SHADOW
-#include "utils.h"				// for Param, ParamGame, Color, HiScoreEntry
+#include "utils.h"				  // Para Color, Zone, fade_color, orange_color
 // Constructor
 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_(std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"))),
 	  counter_(0),
 	  ticks_(0),
 	  view_area_({0, 0, param.game.width, param.game.height}),
 	  fade_mode_(FadeMode::IN)
 {
-	// Copia punteros
+	// Inicializa el resto de variables
 	renderer_ = Screen::get()->getRenderer();
 	// Objetos
 	fade_ = std::make_unique<Fade>();
 	background_ = std::make_unique<Background>(renderer_);
 	text_ = std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"));
 	// 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;
 	ticks_speed_ = 15;
 	counter_ = 0;
 	counter_end_ = 800;
 	view_area_ = {0, 0, param.game.width, param.game.height};
 	fade_mode_ = FadeMode::IN;
 	// Inicializa objetos
 	SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
 	background_->setPos(param.game.game_area.rect);
 	background_->setCloudsSpeed(-0.1f);
 	background_->setGradientNumber(1);
@@ -69,8 +61,9 @@ HiScoreTable::~HiScoreTable()
 // Actualiza las variables
 void HiScoreTable::update()
 {
-	// Actualiza las variables
+	constexpr int TICKS_SPEED = 15;
-	if (SDL_GetTicks() - ticks_ > ticks_speed_)
+
 	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		// Actualiza el contador de ticks
 		ticks_ = SDL_GetTicks();
@@ -95,11 +88,11 @@ void HiScoreTable::update()
 		if (counter_ == 150)
 		{
-			background_->setColor({0, 0, 0});
+			background_->setColor(Color(0, 0, 0));
 			background_->setAlpha(96);
 		}
-		if (counter_ == counter_end_)
+		if (counter_ == COUNTER_END_)
 		{
 			fade_->activate();
 		}
@@ -188,6 +181,7 @@ void HiScoreTable::checkEvents()
 		if (event.type == SDL_QUIT)
 		{
 			section::name = section::Name::QUIT;
 			section::options = section::Options::QUIT_FROM_EVENT;
 			break;
 		}
@@ -214,9 +208,6 @@ void HiScoreTable::checkInput()
 		return;
 	}
 	// Comprueba el input para el resto de objetos
 	Screen::get()->checkInput();
 	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
 	globalInputs::check();
 }
--- a/source/hiscore_table.h
+++ b/source/hiscore_table.h
@@ -1,10 +1,10 @@
 #pragma once
-#include <SDL2/SDL_rect.h>	 // for SDL_Rect
+#include <SDL2/SDL_rect.h>	 // para SDL_Rect
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h> // for Uint16, Uint32, Uint8
+#include <SDL2/SDL_stdinc.h> // para Uint16, Uint32, Uint8
-#include <memory>			 // for unique_ptr
+#include <memory>			 // para unique_ptr
-#include <string>			 // for string
+#include <string>			 // para string
 class Background;			 // lines 8-8
 class Fade;					 // lines 9-9
 class Text;					 // lines 10-10
@@ -24,6 +24,9 @@ enum class FadeMode : Uint8; // lines 11-11
 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
 	SDL_Texture *backbuffer_; // Textura para usar como backbuffer
@@ -34,9 +37,7 @@ private:
 	// Variables
 	Uint16 counter_;	 // Contador
 	Uint16 counter_end_; // Valor final para el contador
 	Uint32 ticks_;		 // Contador de ticks para ajustar la velocidad del programa
 	Uint32 ticks_speed_; // Velocidad a la que se repiten los bucles del programa
 	SDL_Rect view_area_; // Parte de la textura que se muestra en pantalla
 	FadeMode fade_mode_; // Modo de fade a utilizar
--- a/source/input.cpp
+++ b/source/input.cpp
@@ -1,9 +1,13 @@
 #include "input.h"
-#include <SDL2/SDL.h>		   // for SDL_INIT_GAMECONTROLLER, SDL_InitSubS...
+#include <SDL2/SDL.h>		   // Para SDL_INIT_GAMECONTROLLER, SDL_InitSubS...
-#include <SDL2/SDL_error.h>	   // for SDL_GetError
+#include <SDL2/SDL_error.h>	   // Para SDL_GetError
-#include <SDL2/SDL_events.h>   // for SDL_ENABLE
+#include <SDL2/SDL_events.h>   // Para SDL_ENABLE
-#include <SDL2/SDL_keyboard.h> // for SDL_GetKeyboardState
+#include <SDL2/SDL_keyboard.h> // Para SDL_GetKeyboardState
-#include <iostream>			   // for basic_ostream, operator<<, cout, basi...
+#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;
@@ -28,49 +32,23 @@ Input *Input::get()
 // Constructor
 Input::Input(const std::string &game_controller_db_path)
-	: game_controller_db_path_(game_controller_db_path),
+	: game_controller_db_path_(game_controller_db_path)
 	  enabled_(true)
 {
 	// Busca si hay mandos conectados
 	discoverGameControllers();
-	// Inicializa las vectores
+	// Inicializa los vectores
-	KeyBindings kb;
+	key_bindings_.resize(static_cast<int>(InputType::NUMBER_OF_INPUTS), KeyBindings());
-	kb.scancode = 0;
+	controller_bindings_.resize(num_gamepads_, std::vector<ControllerBindings>(static_cast<int>(InputType::NUMBER_OF_INPUTS), ControllerBindings()));
 	kb.active = false;
 	key_bindings_.resize(static_cast<int>(InputType::NUMBER_OF_INPUTS), kb);
 	ControllerBindings gcb;
 	gcb.button = SDL_CONTROLLER_BUTTON_INVALID;
 	gcb.active = false;
 	controller_bindings_.resize(num_gamepads_);
 	for (int i = 0; i < num_gamepads_; ++i)
 	{
 		controller_bindings_[i].resize(static_cast<int>(InputType::NUMBER_OF_INPUTS), gcb);
 	}
 	// Listado de los inputs usados para jugar, excluyendo botones para la interfaz
 	game_inputs_.clear();
 	game_inputs_.push_back(InputType::FIRE_LEFT);
 	game_inputs_.push_back(InputType::FIRE_CENTER);
 	game_inputs_.push_back(InputType::FIRE_RIGHT);
 	game_inputs_.push_back(InputType::UP);
 	game_inputs_.push_back(InputType::DOWN);
 	game_inputs_.push_back(InputType::LEFT);
 	game_inputs_.push_back(InputType::RIGHT);
 	// Listado de los inputs para jugar que utilizan botones, ni palancas ni crucetas
-	button_inputs_.clear();
+	button_inputs_ = {InputType::FIRE_LEFT, InputType::FIRE_CENTER, InputType::FIRE_RIGHT, InputType::START};
 	button_inputs_.push_back(InputType::FIRE_LEFT);
 	button_inputs_.push_back(InputType::FIRE_CENTER);
 	button_inputs_.push_back(InputType::FIRE_RIGHT);
 	button_inputs_.push_back(InputType::START);
 }
 // Asigna inputs a teclas
 void Input::bindKey(InputType input, SDL_Scancode code)
 {
-	key_bindings_[static_cast<int>(input)].scancode = code;
+	key_bindings_.at(static_cast<int>(input)).scancode = code;
 }
 // Asigna inputs a botones del mando
@@ -78,7 +56,7 @@ void Input::bindGameControllerButton(int controller_index, InputType input, SDL_
 {
 	if (controller_index < num_gamepads_)
 	{
-		controller_bindings_[controller_index][static_cast<int>(input)].button = button;
+		controller_bindings_.at(controller_index).at(static_cast<int>(input)).button = button;
 	}
 }
@@ -87,41 +65,24 @@ void Input::bindGameControllerButton(int controller_index, InputType input_targe
 {
 	if (controller_index < num_gamepads_)
 	{
-		controller_bindings_[controller_index][static_cast<int>(input_target)].button = controller_bindings_[controller_index][static_cast<int>(input_source)].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(InputType input, bool repeat, int device, int controller_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);
-	if (device == INPUT_USE_ANY)
+	if (device == InputDeviceToUse::KEYBOARD || device == InputDeviceToUse::ANY)
 	{
 		controller_index = 0;
 	}
 	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
 	{
 		const Uint8 *keyStates = SDL_GetKeyboardState(nullptr);
 		if (repeat)
 		{
-			if (keyStates[key_bindings_[input_index].scancode] != 0)
+			success_keyboard = keyStates[key_bindings_[input_index].scancode] != 0;
 			{
 				success_keyboard = true;
 			}
 			else
 			{
 				success_keyboard = false;
 			}
 		}
 		else
 		{
@@ -142,151 +103,29 @@ bool Input::checkInput(InputType input, bool repeat, int device, int controller_
 				if (keyStates[key_bindings_[input_index].scancode] == 0)
 				{
 					key_bindings_[input_index].active = false;
 					success_keyboard = false;
 				}
 				else
 				{
 					success_keyboard = false;
 				}
 			}
 		}
 	}
 	if (gameControllerFound() && controller_index < num_gamepads_)
 		if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY))
 		{
 			success_controller = checkAxisInput(input, controller_index);
 			if (!success_controller)
 			{
 				if (repeat)
 				{
 					if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0)
 					{
 						success_controller = true;
 					}
 					else
 					{
 						success_controller = false;
 					}
 				}
 				else
 				{
 					if (!controller_bindings_[controller_index][input_index].active)
 					{
 						if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0)
 						{
 							controller_bindings_[controller_index][input_index].active = true;
 							success_controller = true;
 						}
 						else
 						{
 							success_controller = false;
 						}
 					}
 					else
 					{
 						if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) == 0)
 						{
 							controller_bindings_[controller_index][input_index].active = false;
 							success_controller = false;
 						}
 						else
 						{
 							success_controller = false;
 						}
 					}
 				}
 			}
 		}
 	return (success_keyboard || success_controller);
 }
 // Comprueba si un input con modificador esta activo
 bool Input::checkModInput(InputType input_mod, InputType input, bool repeat, int device, int controller_index)
 {
 	if (!enabled_ || controller_index >= num_gamepads_ || !checkInput(input_mod, INPUT_ALLOW_REPEAT, device, controller_index))
 	{
 		return false;
 	}
 	bool success_keyboard = false;
 	bool success_controller = false;
 	const int input_index = static_cast<int>(input);
 	if (device == INPUT_USE_ANY)
 	{
 		controller_index = 0;
 	}
 	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
 	{
 		const Uint8 *keyStates = SDL_GetKeyboardState(nullptr);
 		if (repeat)
 		{
 			if (keyStates[key_bindings_[input_index].scancode] != 0)
 			{
 				success_keyboard = true;
 			}
 			else
 			{
 				success_keyboard = false;
 			}
 		}
 		else
 		{
 			if (!key_bindings_[input_index].active)
 			{
 				if (keyStates[key_bindings_[input_index].scancode] != 0)
 				{
 					key_bindings_[input_index].active = true;
 					success_keyboard = true;
 				}
 				else
 				{
 					success_keyboard = false;
 				}
 			}
 			else
 			{
 				if (keyStates[key_bindings_[input_index].scancode] == 0)
 				{
 					key_bindings_[input_index].active = false;
 					success_keyboard = false;
 				}
 				else
 				{
 					success_keyboard = false;
 				}
 			}
 		}
 	}
-	if (gameControllerFound() && controller_index < num_gamepads_)
+	if (gameControllerFound() && controller_index >= 0 && controller_index < num_gamepads_)
-		if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY))
+		if ((device == InputDeviceToUse::CONTROLLER) || (device == InputDeviceToUse::ANY))
 		{
 			success_controller = checkAxisInput(input, controller_index);
 			if (!success_controller)
 			{
 				if (repeat)
 				{
-					if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0)
+					success_controller = SDL_GameControllerGetButton(connected_controllers_.at(controller_index), controller_bindings_.at(controller_index).at(input_index).button) != 0;
 					{
 						success_controller = true;
 					}
 					else
 					{
 						success_controller = false;
 					}
 				}
 				else
 				{
-					if (!controller_bindings_[controller_index][input_index].active)
+					if (!controller_bindings_.at(controller_index).at(input_index).active)
 					{
-						if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0)
+						if (SDL_GameControllerGetButton(connected_controllers_.at(controller_index), controller_bindings_.at(controller_index).at(input_index).button) != 0)
 						{
-							controller_bindings_[controller_index][input_index].active = true;
+							controller_bindings_.at(controller_index).at(input_index).active = true;
 							success_controller = true;
 						}
 						else
@@ -296,15 +135,11 @@ bool Input::checkModInput(InputType input_mod, InputType input, bool repeat, int
 					}
 					else
 					{
-						if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) == 0)
+						if (SDL_GameControllerGetButton(connected_controllers_.at(controller_index), controller_bindings_.at(controller_index).at(input_index).button) == 0)
 						{
-							controller_bindings_[controller_index][input_index].active = false;
+							controller_bindings_.at(controller_index).at(input_index).active = false;
 							success_controller = false;
 						}
 						else
 						{
 							success_controller = false;
 						}
 						success_controller = false;
 					}
 				}
 			}
@@ -314,14 +149,9 @@ bool Input::checkModInput(InputType input_mod, InputType input, bool repeat, int
 }
 // Comprueba si hay almenos un input activo
-bool Input::checkAnyInput(int device, int controller_index)
+bool Input::checkAnyInput(InputDeviceToUse device, int controller_index)
 {
-	if (device == INPUT_USE_ANY)
+	if (device == InputDeviceToUse::KEYBOARD || device == InputDeviceToUse::ANY)
 	{
 		controller_index = 0;
 	}
 	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
 	{
 		const Uint8 *mKeystates = SDL_GetKeyboardState(nullptr);
@@ -337,7 +167,7 @@ bool Input::checkAnyInput(int device, int controller_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)controller_bindings_.size(); ++i)
 			{
@@ -357,7 +187,7 @@ bool Input::checkAnyInput(int device, int controller_index)
 int Input::checkAnyButtonPressed(bool repeat)
 {
 	// Si está pulsado el botón de servicio, ningún botón se puede considerar pulsado
-	if (checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_ANY))
+	if (checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::ANY))
 	{
 		return 0;
 	}
@@ -366,7 +196,7 @@ int Input::checkAnyButtonPressed(bool repeat)
 	for (auto bi : button_inputs_)
 	{
 		// Comprueba el teclado
-		if (checkInput(bi, repeat, INPUT_USE_KEYBOARD))
+		if (checkInput(bi, repeat, InputDeviceToUse::KEYBOARD))
 		{
 			return 1;
 		}
@@ -374,7 +204,7 @@ int Input::checkAnyButtonPressed(bool repeat)
 		// Comprueba los mandos
 		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;
 			}
@@ -396,9 +226,7 @@ bool Input::discoverGameControllers()
 	if (SDL_GameControllerAddMappingsFromFile(game_controller_db_path_.c_str()) < 0)
 	{
-		{
+		std::cout << "Error, could not load " << game_controller_db_path_.c_str() << " file: " << SDL_GetError() << std::endl;
 			std::cout << "Error, could not load " << game_controller_db_path_.c_str() << " file: " << SDL_GetError() << std::endl;
 		}
 	}
 	num_joysticks_ = SDL_NumJoysticks();
@@ -408,7 +236,7 @@ bool Input::discoverGameControllers()
 	joysticks_.clear();
 	for (int i = 0; i < num_joysticks_; ++i)
 	{
-		SDL_Joystick *joy = SDL_JoystickOpen(i);
+		auto joy = SDL_JoystickOpen(i);
 		joysticks_.push_back(joy);
 		if (SDL_IsGameController(i))
 		{
@@ -416,10 +244,8 @@ bool Input::discoverGameControllers()
 		}
 	}
-	{
+	std::cout << "\n** LOOKING FOR GAME CONTROLLERS" << std::endl;
-		std::cout << "\nChecking for game controllers...\n";
+	std::cout << "Gamepads found: " << num_gamepads_ << std::endl;
 		std::cout << num_joysticks_ << " joysticks found, " << num_gamepads_ << " are gamepads\n";
 	}
 	if (num_gamepads_ > 0)
 	{
@@ -433,42 +259,30 @@ bool Input::discoverGameControllers()
 			{
 				connected_controllers_.push_back(pad);
 				const std::string name = SDL_GameControllerNameForIndex(i);
-				{
+				std::cout << "#" << i << ": " << name << std::endl;
 					std::cout << name << std::endl;
 				}
 				controller_names_.push_back(name);
 			}
 			else
 			{
-				{
+				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()
+bool Input::gameControllerFound() { return num_gamepads_ > 0 ? true : false; }
 {
 	return num_gamepads_ > 0 ? true : false;
 }
 // Obten el nombre de un mando de juego
-std::string Input::getControllerName(int controller_index) const
+std::string Input::getControllerName(int controller_index) const { return num_gamepads_ > 0 ? controller_names_.at(controller_index) : std::string(); }
 {
 	return num_gamepads_ > 0 ? controller_names_[controller_index] : "";
 }
 // Obten el número de mandos conectados
-int Input::getNumControllers() const
+int Input::getNumControllers() const { return num_gamepads_; }
 {
 	return num_gamepads_;
 }
 // Obtiene el indice del controlador a partir de un event.id
 int Input::getJoyIndex(int id) const
@@ -484,14 +298,14 @@ int Input::getJoyIndex(int id) const
 }
 // Muestra por consola los controles asignados
-void Input::printBindings(int device, int controller_index) const
+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 (controller_index >= num_gamepads_)
 		{
@@ -499,13 +313,12 @@ void Input::printBindings(int device, int controller_index) const
 		}
 		// Muestra el nombre del mando
-		std::cout << "\n"
+		std::cout << "\n" + controller_names_.at(controller_index) << std::endl;
 				  << controller_names_[controller_index] << std::endl;
 		// Muestra los botones asignados
 		for (auto bi : button_inputs_)
 		{
-			std::cout << to_string(bi) << " : " << controller_bindings_[controller_index][static_cast<int>(bi)].button << std::endl;
+			std::cout << to_string(bi) << " : " << controller_bindings_.at(controller_index).at(static_cast<int>(bi)).button << std::endl;
 		}
 	}
 }
@@ -519,116 +332,58 @@ SDL_GameControllerButton Input::getControllerBinding(int controller_index, Input
 // Obtiene el indice a partir del nombre del mando
 int Input::getIndexByName(const std::string &name) const
 {
-	for (int i = 0; i < num_gamepads_; ++i)
+	auto it = std::find(controller_names_.begin(), controller_names_.end(), name);
-	{
+	return it != controller_names_.end() ? std::distance(controller_names_.begin(), it) : -1;
 		if (controller_names_[i] == name)
 		{
 			return i;
 		}
 	}
 	return -1;
 }
 // Convierte un InputType a std::string
 std::string Input::to_string(InputType input) const
 {
-	if (input == InputType::FIRE_LEFT)
+	switch (input)
 	{
 	case InputType::FIRE_LEFT:
 		return "input_fire_left";
-	}
+	case InputType::FIRE_CENTER:
 	if (input == InputType::FIRE_CENTER)
 	{
 		return "input_fire_center";
-	}
+	case InputType::FIRE_RIGHT:
 	if (input == InputType::FIRE_RIGHT)
 	{
 		return "input_fire_right";
-	}
+	case InputType::START:
 	if (input == InputType::START)
 	{
 		return "input_start";
-	}
+	case InputType::SERVICE:
 	if (input == InputType::SERVICE)
 	{
 		return "input_service";
 	default:
 		return "";
 	}
 	return "";
 }
 // Convierte un std::string a InputType
 InputType Input::to_inputs_e(const std::string &name) const
 {
-	if (name == "input_fire_left")
+	static const std::unordered_map<std::string, InputType> inputMap = {
-	{
+		{"input_fire_left", InputType::FIRE_LEFT},
-		return 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")
+	auto it = inputMap.find(name);
-	{
+	return it != inputMap.end() ? it->second : InputType::NONE;
 		return InputType::FIRE_CENTER;
 	}
 	if (name == "input_fire_right")
 	{
 		return InputType::FIRE_RIGHT;
 	}
 	if (name == "input_start")
 	{
 		return InputType::START;
 	}
 	if (name == "input_service")
 	{
 		return InputType::SERVICE;
 	}
 	return InputType::NONE;
 }
 // Comprueba el eje del mando
 bool Input::checkAxisInput(InputType input, int controller_index) const
 {
 	bool success = false;
 	switch (input)
 	{
 	case InputType::LEFT:
-		if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) < -30000)
+		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) < -30000;
 		{
 			success = true;
 		}
 		break;
 	case InputType::RIGHT:
-		if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) > 30000)
+		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) > 30000;
 		{
 			success = true;
 		}
 		break;
 	case InputType::UP:
-		if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) < -30000)
+		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) < -30000;
 		{
 			success = true;
 		}
 		break;
 	case InputType::DOWN:
-		if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) > 30000)
+		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) > 30000;
 		{
 			success = true;
 		}
 		break;
 	default:
-		break;
+		return false;
 	}
 	return success;
 }
--- a/source/input.h
+++ b/source/input.h
@@ -1,19 +1,19 @@
 #pragma once
-#include <SDL2/SDL_gamecontroller.h> // for SDL_GameControllerButton, SDL_G...
+#include <SDL2/SDL_gamecontroller.h> // para SDL_GameControllerButton, SDL_G...
-#include <SDL2/SDL_joystick.h>		 // for SDL_Joystick
+#include <SDL2/SDL_joystick.h>		 // para SDL_Joystick
-#include <SDL2/SDL_scancode.h>		 // for SDL_Scancode
+#include <SDL2/SDL_scancode.h>		 // para SDL_Scancode
-#include <SDL2/SDL_stdinc.h>		 // for Uint8
+#include <SDL2/SDL_stdinc.h>		 // para Uint8
-#include <string>					 // for string, basic_string
+#include <string>					 // para string, basic_string
-#include <vector>					 // for vector
+#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
+	InputDeviceToUse::KEYBOARD solo mirará el teclado
-	INPUT_USE_GAMECONTROLLER solo mirará el controlador especificado (Si no se especifica, el primero)
+	InputDeviceToUse::CONTROLLER solo mirará el controlador especificado (Si no se especifica, el primero)
-	INPUT_USE_ANY mirará tanto el teclado como el PRIMER controlador
+	InputDeviceToUse::ANY mirará tanto el teclado como el PRIMER controlador
 */
 enum class InputType : int
@@ -52,9 +52,12 @@ enum class InputType : int
 constexpr bool INPUT_ALLOW_REPEAT = true;
 constexpr bool INPUT_DO_NOT_ALLOW_REPEAT = false;
-constexpr int INPUT_USE_KEYBOARD = 0;
+enum class InputDeviceToUse : int
-constexpr int INPUT_USE_GAMECONTROLLER = 1;
+{
-constexpr int INPUT_USE_ANY = 2;
+	KEYBOARD = 0,
 	CONTROLLER = 1,
 	ANY = 2,
 };
 class Input
 {
@@ -66,12 +69,20 @@ private:
 	{
 		Uint8 scancode; // Scancode asociado
 		bool active;	// Indica si está activo
 		// Constructor
 		explicit KeyBindings(Uint8 sc = 0, bool act = false)
 			: scancode(sc), active(act) {}
 	};
 	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
@@ -80,12 +91,10 @@ private:
 	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> game_inputs_;							   // Inputs usados para jugar, normalmente direcciones y botones
 	std::vector<InputType> button_inputs_;							   // Inputs asignados al jugador y a botones, excluyendo direcciones
-	int num_joysticks_;												   // Número de joysticks conectados
+	int num_joysticks_ = 0;											   // Número de joysticks conectados
-	int num_gamepads_;												   // Número de mandos conectados
+	int num_gamepads_ = 0;											   // Número de mandos conectados
 	std::string game_controller_db_path_;							   // Ruta al archivo gamecontrollerdb.txt
 	bool enabled_;													   // Indica si está habilitado
 	// Comprueba el eje del mando
 	bool checkAxisInput(InputType input, int controller_index = 0) const;
@@ -114,13 +123,10 @@ public:
 	void bindGameControllerButton(int controller_index, InputType inputTarget, InputType inputSource);
 	// Comprueba si un input esta activo
-	bool checkInput(InputType input, bool repeat = true, int device = INPUT_USE_ANY, int controller_index = 0);
+	bool checkInput(InputType input, bool repeat = true, InputDeviceToUse device = InputDeviceToUse::ANY, int controller_index = 0);
 	// Comprueba si un input con modificador esta activo
 	bool checkModInput(InputType input_mod, InputType input, bool repeat = true, int device = INPUT_USE_ANY, int controller_index = 0);
 	// Comprueba si hay almenos un input activo
-	bool checkAnyInput(int device = INPUT_USE_ANY, int controller_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);
@@ -141,7 +147,7 @@ public:
 	int getJoyIndex(int id) const;
 	// Muestra por consola los controles asignados
-	void printBindings(int device = INPUT_USE_KEYBOARD, int controller_index = 0) const;
+	void printBindings(InputDeviceToUse device = InputDeviceToUse::KEYBOARD, int controller_index = 0) const;
 	// Obtiene el SDL_GameControllerButton asignado a un input
 	SDL_GameControllerButton getControllerBinding(int controller_index, InputType input) const;
--- a/source/instructions.cpp
+++ b/source/instructions.cpp
@@ -1,56 +1,44 @@
 #include "instructions.h"
-#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_events.h>	// for SDL_PollEvent, SDL_Event, SDL_QUIT
+#include <SDL2/SDL_events.h>	// Para SDL_PollEvent, SDL_Event, SDL_QUIT
-#include <SDL2/SDL_pixels.h>	// for SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_pixels.h>	// Para SDL_PIXELFORMAT_RGBA8888
-#include <SDL2/SDL_timer.h>		// for SDL_GetTicks
+#include <SDL2/SDL_timer.h>		// Para SDL_GetTicks
-#include <SDL2/SDL_video.h>		// for SDL_WINDOWEVENT_SIZE_CHANGED
+#include <SDL2/SDL_video.h>		// Para SDL_WINDOWEVENT_SIZE_CHANGED
-#include <algorithm>			// for max
+#include <algorithm>			// Para max
-#include <utility>				// for move
+#include <utility>				// Para move
-#include "asset.h"				// for Asset
+#include "fade.h"				// Para Fade, FadeMode, FadeType
-#include "fade.h"				// for Fade, FadeMode, FadeType
+#include "global_inputs.h"		// Para check
-#include "global_inputs.h"		// for check
+#include "input.h"				// Para Input
-#include "input.h"				// for Input
+#include "jail_audio.h"			// Para JA_GetMusicState, JA_Music_state
-#include "jail_audio.h"			// for JA_GetMusicState, JA_Music_state
+#include "lang.h"				// Para getText
-#include "lang.h"				// for getText
+#include "param.h"				// Para Param, param, ParamGame, ParamFade
-#include "param.h"				// for param
+#include "resource.h"			// Para Resource
-#include "resource.h"			// for Resource
+#include "screen.h"				// Para Screen
-#include "screen.h"				// for Screen
+#include "section.h"			// Para Name, name, Options, options
-#include "section.h"			// for Name, name, Options, options
+#include "sprite.h"				// Para Sprite
-#include "sprite.h"				// for Sprite
+#include "text.h"				// Para Text, TEXT_CENTER, TEXT_COLOR, TEXT_...
-#include "text.h"				// for Text, TEXT_CENTER, TEXT_COLOR, TEXT_...
+#include "texture.h"			// Para Texture
-#include "texture.h"			// for Texture
+#include "tiled_bg.h"			// Para TiledBG, TiledBGMode
-#include "tiled_bg.h"			// for TiledBG, TILED_MODE_STATIC
+#include "utils.h"				// Para Color, shdw_txt_color, Zone, no_color
 #include "utils.h"				// for Param, ParamGame, Color, shdw_txt_color
 struct JA_Music_t;				// lines 22-22
 // Constructor
 Instructions::Instructions()
 	: renderer_(Screen::get()->getRenderer()),
 	  texture_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
 	  backbuffer_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
 	  text_(std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"))),
 	  tiled_bg_(std::make_unique<TiledBG>((SDL_Rect){0, 0, param.game.width, param.game.height}, TiledBGMode::STATIC)),
 	  fade_(std::make_unique<Fade>())
 {
 	// Copia los punteros
 	renderer_ = Screen::get()->getRenderer();
 	// Crea objetos
 	text_ = std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"));
 	tiled_bg_ = std::make_unique<TiledBG>((SDL_Rect){0, 0, param.game.width, param.game.height}, TILED_MODE_STATIC);
 	fade_ = std::make_unique<Fade>();
 	// 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);
 	// Crea una textura para el texto fijo
 	texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
 	SDL_SetTextureBlendMode(texture_, SDL_BLENDMODE_BLEND);
 	// Inicializa variables
 	section::name = section::Name::INSTRUCTIONS;
 	ticks_ = 0;
 	ticks_speed_ = 15;
 	counter_ = 0;
 	counter_end_ = 700;
 	view_ = {0, 0, param.game.width, param.game.height};
 	sprite_pos_ = {0, 0};
 	item_space_ = 2;
 	// Inicializa objetos
 	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
@@ -214,8 +202,9 @@ void Instructions::fillBackbuffer()
 // Actualiza las variables
 void Instructions::update()
 {
-	// Actualiza las variables
+	constexpr int TICKS_SPEED = 15;
-	if (SDL_GetTicks() - ticks_ > ticks_speed_)
+
 	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		// Actualiza el contador de ticks
 		ticks_ = SDL_GetTicks();
@@ -297,6 +286,7 @@ void Instructions::checkEvents()
 		if (event.type == SDL_QUIT)
 		{
 			section::name = section::Name::QUIT;
 			section::options = section::Options::QUIT_FROM_EVENT;
 			break;
 		}
@@ -323,9 +313,6 @@ void Instructions::checkInput()
 		return;
 	}
 	// Comprueba el input para el resto de objetos
 	Screen::get()->checkInput();
 	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
 	globalInputs::check();
 }
--- a/source/instructions.h
+++ b/source/instructions.h
@@ -1,16 +1,15 @@
 #pragma once
-#include <SDL2/SDL_rect.h>	 // for SDL_Point, SDL_Rect
+#include <SDL2/SDL_rect.h>	 // Para SDL_Point, SDL_Rect
-#include <SDL2/SDL_render.h> // for SDL_Texture, SDL_Renderer
+#include <SDL2/SDL_render.h> // Para SDL_Texture, SDL_Renderer
-#include <SDL2/SDL_stdinc.h> // for Uint32
+#include <SDL2/SDL_stdinc.h> // Para Uint32
-#include <memory>			 // for unique_ptr, shared_ptr
+#include <memory>			 // Para unique_ptr, shared_ptr
-#include <vector>			 // for vector
+#include <vector>			 // Para vector
-class Fade;
+class Fade;					 // lines 8-8
-class Sprite;
+class Sprite;				 // lines 9-9
-class Text;
+class Text;					 // lines 10-10
-class Texture;
+class Texture;				 // lines 11-11
-class TiledBG;
+class TiledBG;				 // lines 12-12
 struct JA_Music_t; // lines 14-14
 /*
 	Esta clase gestiona un estado del programa. Se encarga de poner en pantalla
@@ -30,24 +29,23 @@ class Instructions
 {
 private:
 	// Objetos y punteros
 	SDL_Renderer *renderer_;  // El renderizador de la ventana
 	SDL_Texture *texture_;	  // Textura fija con el texto
 	SDL_Texture *backbuffer_; // Textura para usar como backbuffer
 	std::vector<std::shared_ptr<Texture>> item_textures_; // Vector con las texturas de los items
 	std::vector<std::unique_ptr<Sprite>> sprites_;		  // Vector con los sprites de los items
 	std::unique_ptr<Text> text_;						  // Objeto para escribir texto
 	std::unique_ptr<TiledBG> tiled_bg_;					  // Objeto para dibujar el mosaico animado de fondo
 	std::unique_ptr<Fade> fade_;						  // Objeto para renderizar fades
 	SDL_Renderer *renderer_;  // El renderizador de la ventana
 	SDL_Texture *texture_;	  // Textura fija con el texto
 	SDL_Texture *backbuffer_; // Textura para usar como backbuffer
 	// Variables
-	int counter_;		   // Contador
+	int counter_ = 0;				// Contador
-	int counter_end_;	   // Valor final para el contador
+	int counter_end_ = 700;			// Valor final para el contador
-	Uint32 ticks_;		   // Contador de ticks para ajustar la velocidad del programa
+	Uint32 ticks_ = 0;				// Contador de ticks para ajustar la velocidad del programa
-	Uint32 ticks_speed_;   // Velocidad a la que se repiten los bucles del programa
+	SDL_Rect view_;					// Vista del backbuffer que se va amostrar por pantalla
-	SDL_Rect view_;		   // Vista del backbuffer que se va amostrar por pantalla
+	SDL_Point sprite_pos_ = {0, 0}; // Posición del primer sprite
-	SDL_Point sprite_pos_; // Posición del primer sprite
+	int item_space_ = 2;			// Espacio entre los items
 	int item_space_;	   // Espacio entre los items
 	// Actualiza las variables
 	void update();
--- a/source/intro.cpp
+++ b/source/intro.cpp
@@ -1,37 +1,31 @@
 #include "intro.h"
-#include <SDL2/SDL_events.h> // for SDL_PollEvent, SDL_Event, SDL_QUIT, SDL...
+#include <SDL2/SDL_events.h> // Para SDL_PollEvent, SDL_Event, SDL_QUIT, SDL...
-#include <SDL2/SDL_timer.h>	 // for SDL_GetTicks
+#include <SDL2/SDL_timer.h>	 // Para SDL_GetTicks
-#include <SDL2/SDL_video.h>	 // for SDL_WINDOWEVENT_SIZE_CHANGED
+#include <SDL2/SDL_video.h>	 // Para SDL_WINDOWEVENT_SIZE_CHANGED
-#include <utility>			 // for move
+#include <utility>			 // Para move
-#include "asset.h"			 // for Asset
+#include "global_inputs.h"	 // Para check
-#include "global_inputs.h"	 // for check
+#include "input.h"			 // Para Input
-#include "input.h"			 // for Input
+#include "jail_audio.h"		 // Para JA_StopMusic, JA_PlayMusic
-#include "jail_audio.h"		 // for JA_StopMusic, JA_PlayMusic
+#include "lang.h"			 // Para getText
-#include "lang.h"			 // for getText
+#include "param.h"			 // Para Param, ParamGame, param
-#include "param.h"			 // for param
+#include "resource.h"		 // Para Resource
-#include "resource.h"		 // for Resource
+#include "screen.h"			 // Para Screen
-#include "screen.h"			 // for Screen
+#include "section.h"		 // Para Name, name, Options, options
-#include "section.h"		 // for Name, name, Options, options
+#include "smart_sprite.h"	 // Para SmartSprite
-#include "smart_sprite.h"	 // for SpriteSmart
+#include "text.h"			 // Para Text
-#include "text.h"			 // for Text
+#include "texture.h"		 // Para Texture
-#include "texture.h"		 // for Texture
+#include "utils.h"			 // Para Zone, BLOCK, Color, bg_color
-#include "utils.h"			 // for Param, ParamGame, Zone, BLOCK, Color
+#include "writer.h"			 // Para Writer
 #include "writer.h"			 // for Writer
 struct JA_Music_t;			 // lines 19-19
 // Constructor
 Intro::Intro()
 	: texture_(Resource::get()->getTexture("intro.png")),
 	  text_(std::make_shared<Text>(Resource::get()->getTexture("nokia.png"), Resource::get()->getTextFile("nokia.txt")))
 {
 	// Reserva memoria para los objetos
 	texture_ = Resource::get()->getTexture("intro.png");
 	text_ = std::make_shared<Text>(Resource::get()->getTexture("nokia.png"), Resource::get()->getTextFile("nokia.txt"));
 	// Inicializa variables
 	section::name = section::Name::INTRO;
 	section::options = section::Options::NONE;
 	ticks_ = 0;
 	ticks_speed_ = 15;
 	scene_ = 1;
 	// Inicializa los bitmaps de la intro
 	constexpr int totalBitmaps = 6;
@@ -145,9 +139,7 @@ Intro::Intro()
 	texts_[8]->setSpeed(16);
 	for (auto &text : texts_)
 	{
 		text->center(param.game.game_area.center_x);
 	}
 }
 // Recarga todas las texturas
@@ -170,15 +162,14 @@ void Intro::checkEvents()
 		case SDL_QUIT:
 		{
 			section::name = section::Name::QUIT;
 			section::options = section::Options::QUIT_FROM_EVENT;
 			break;
 		}
 		case SDL_WINDOWEVENT:
 		{
 			if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
 			{
 				reloadTextures();
 			}
 			break;
 		}
@@ -200,9 +191,6 @@ void Intro::checkInput()
 		return;
 	}
 	// Comprueba el input para el resto de objetos
 	Screen::get()->checkInput();
 	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
 	globalInputs::check();
 }
@@ -371,7 +359,9 @@ void Intro::updateScenes()
 // Actualiza las variables del objeto
 void Intro::update()
 {
-	if (SDL_GetTicks() - ticks_ > ticks_speed_)
+	constexpr int TICKS_SPEED = 15;
 	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		// Actualiza el contador de ticks
 		ticks_ = SDL_GetTicks();
--- a/source/intro.h
+++ b/source/intro.h
@@ -1,13 +1,12 @@
 #pragma once
-#include <SDL2/SDL_stdinc.h> // for Uint32, Uint8
+#include <SDL2/SDL_stdinc.h> // Para Uint32
-#include <memory>			 // for unique_ptr, shared_ptr
+#include <memory>			 // Para unique_ptr, shared_ptr
-#include <vector>			 // for vector
+#include <vector>			 // Para vector
-#include "smart_sprite.h"	 // for SpriteSmart
+#include "smart_sprite.h"	 // Para SmartSprite
-#include "writer.h"			 // for Writer
+#include "writer.h"			 // Para Writer
-class Text;
+class Text;					 // lines 8-8
-class Texture;
+class Texture;				 // lines 9-9
 struct JA_Music_t; // lines 11-11
 /*
 	Esta clase gestiona un estado del programa. Se encarga de mostrar la secuencia
@@ -26,9 +25,8 @@ private:
 	std::vector<std::unique_ptr<Writer>> texts_;		// Textos de la intro
 	// Variables
-	Uint32 ticks_;		// Contador de ticks para ajustar la velocidad del programa
+	Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
-	Uint8 ticks_speed_; // Velocidad a la que se repiten los bucles del programa
+	int scene_ = 1;	   // Indica que escena está activa
 	int scene_;			// Indica que escena está activa
 	// Actualiza las variables del objeto
 	void update();
--- a/source/item.cpp
+++ b/source/item.cpp
@@ -1,31 +1,30 @@
 #include "item.h"
-#include <stdlib.h>			 // for rand
+#include <stdlib.h>			 // para rand
-#include "animated_sprite.h" // for SpriteAnimated
+#include "animated_sprite.h" // para SpriteAnimated
-#include "param.h"			 // for param
+#include "param.h"			 // para param
 class Texture;
 // Constructor
-Item::Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
+Item::Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
 	: sprite_(std::make_unique<AnimatedSprite>(texture, animation)),
 	  accel_x_(0.0f),
 	  floor_collision_(false),
 	  type_(type),
-	  enabled_(true),
+	  play_area_(play_area)
 	  play_area_(play_area),
 	  time_to_live_(600)
 {
-	if (type == ItemType::COFFEE_MACHINE)
+	switch (type)
 	{
 	case ItemType::COFFEE_MACHINE:
 	{
 		width_ = 28;
 		height_ = 37;
-		pos_x_ = (((int)x + (play_area->w / 2)) % (play_area->w - width_ - 5)) + 2;
+		pos_x_ = ((static_cast<int>(x) + (play_area.w / 2)) % (play_area.w - width_ - 5)) + 2;
 		pos_y_ = -height_;
 		vel_x_ = 0.0f;
 		vel_y_ = -0.1f;
 		accel_y_ = 0.1f;
 		collider_.r = 10;
 		break;
 	}
-	else
+	default:
 	{
 		width_ = 20;
 		height_ = 20;
@@ -35,6 +34,8 @@ Item::Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr
 		vel_y_ = -4.0f;
 		accel_y_ = 0.2f;
 		collider_.r = width_ / 2;
 		break;
 	}
 	}
 	sprite_->setPosX(pos_x_);
@@ -43,22 +44,22 @@ Item::Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr
 }
 // Centra el objeto en la posición X
-void Item::allignTo(int x)
+void Item::alignTo(int x)
 {
-	pos_x_ = float(x - (width_ / 2));
+	pos_x_ = static_cast<float>(x - (width_ / 2));
 	if (pos_x_ < param.game.play_area.rect.x)
 	{
 		pos_x_ = param.game.play_area.rect.x + 1;
 	}
-	else if ((pos_x_ + width_) > play_area_->w)
+	else if (pos_x_ + width_ > play_area_.w)
 	{
-		pos_x_ = float(play_area_->w - width_ - 1);
+		pos_x_ = static_cast<float>(play_area_.w - width_ - 1);
 	}
 	// Posición X,Y del sprite
-	sprite_->setPosX(int(pos_x_));
+	sprite_->setPosX(pos_x_);
-	sprite_->setPosY(int(pos_y_));
+	sprite_->setPosY(pos_y_);
 	// Alinea el circulo de colisión con el objeto
 	shiftColliders();
@@ -94,7 +95,7 @@ void Item::move()
 	vel_y_ += accel_y_;
 	// Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido
-	if ((pos_x_ < param.game.play_area.rect.x) || (pos_x_ + width_ > play_area_->w))
+	if ((pos_x_ < param.game.play_area.rect.x) || (pos_x_ + width_ > play_area_.w))
 	{
 		// Corregir posición
 		pos_x_ -= vel_x_;
@@ -114,14 +115,14 @@ void Item::move()
 	}
 	// Si el objeto se sale por la parte inferior
-	if (pos_y_ + height_ > play_area_->h)
+	if (pos_y_ + height_ > play_area_.h)
 	{
 		// Detiene el objeto
 		vel_y_ = 0;
 		vel_x_ = 0;
 		accel_x_ = 0;
 		accel_y_ = 0;
-		pos_y_ = play_area_->h - height_;
+		pos_y_ = play_area_.h - height_;
 		if (type_ == ItemType::COFFEE_MACHINE)
 		{
 			floor_collision_ = true;
--- a/source/item.h
+++ b/source/item.h
@@ -1,12 +1,12 @@
 #pragma once
-#include <SDL2/SDL_rect.h>   // for SDL_Rect
+#include <SDL2/SDL_rect.h>   // para SDL_Rect
-#include <SDL2/SDL_stdinc.h> // for Uint16
+#include <SDL2/SDL_stdinc.h> // para Uint16
-#include <memory>            // for shared_ptr, unique_ptr
+#include <memory>            // para shared_ptr, unique_ptr
-#include <string>            // for string
+#include <string>            // para string
-#include <vector>            // for vector
+#include <vector>            // para vector
-#include "animated_sprite.h" // for SpriteAnimated
+#include "animated_sprite.h" // para SpriteAnimated
-#include "utils.h"           // for Circle
+#include "utils.h"           // para Circle
 class Texture;
 // Tipos de objetos
@@ -29,20 +29,20 @@ private:
    std::unique_ptr<AnimatedSprite> sprite_; // Sprite con los graficos del objeto
    // Variables
-    float pos_x_;          // Posición X del objeto
+    float pos_x_;                  // Posición X del objeto
-    float pos_y_;          // Posición Y del objeto
+    float pos_y_;                  // Posición Y del objeto
-    int width_;            // Ancho del objeto
+    int width_;                    // Ancho del objeto
-    int height_;           // Alto del objeto
+    int height_;                   // Alto del objeto
-    float vel_x_;          // Velocidad en el eje X
+    float vel_x_;                  // Velocidad en el eje X
-    float vel_y_;          // Velocidad en el eje Y
+    float vel_y_;                  // Velocidad en el eje Y
-    float accel_x_;        // Aceleración en el eje X
+    float accel_x_ = 0.0f;         // Aceleración en el eje X
-    float accel_y_;        // Aceleración en el eje Y
+    float accel_y_;                // Aceleración en el eje Y
-    bool floor_collision_; // Indica si el objeto colisiona con el suelo
+    bool floor_collision_ = false; // Indica si el objeto colisiona con el suelo
-    ItemType type_;        // Especifica el tipo de objeto que es
+    ItemType type_;                // Especifica el tipo de objeto que es
-    bool enabled_;         // Especifica si el objeto está habilitado
+    bool enabled_ = true;          // Especifica si el objeto está habilitado
-    Circle collider_;      // Circulo de colisión del objeto
+    Circle collider_;              // Circulo de colisión del objeto
-    SDL_Rect *play_area_;  // Rectangulo con la zona de juego
+    SDL_Rect play_area_;           // Rectangulo con la zona de juego
-    Uint16 time_to_live_;  // Temporizador con el tiempo que el objeto está presente
+    Uint16 time_to_live_ = 600;    // Temporizador con el tiempo que el objeto está presente
    // Alinea el circulo de colisión con la posición del objeto
    void shiftColliders();
@@ -58,13 +58,13 @@ private:
 public:
    // Constructor
-    Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
+    Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
    // Destructor
    ~Item() = default;
    // Centra el objeto en la posición X
-    void allignTo(int x);
+    void alignTo(int x);
    // Pinta el objeto en la pantalla
    void render();
--- a/source/jail_audio.cpp
+++ b/source/jail_audio.cpp
@@ -1,74 +1,91 @@
 #ifndef JA_USESDLMIXER
 #include "jail_audio.h"
-#include <stdint.h>      // for uint8_t
+#include <stdint.h>     // para uint8_t
-#include <stdio.h>       // for NULL, fseek, fclose, fopen, fread, ftell, FILE
+#include <stdio.h>      // para NULL, fseek, fclose, fopen, fread, ftell, FILE
-#include <stdlib.h>      // for free, malloc
+#include <stdlib.h>     // para free, malloc
-#include "stb_vorbis.c"  // for stb_vorbis_decode_memory
+#include "stb_vorbis.c" // para stb_vorbis_decode_memory
 #define JA_MAX_SIMULTANEOUS_CHANNELS 5
-struct JA_Sound_t {
+struct JA_Sound_t
-    Uint32  length {0};
+{
-    Uint8*  buffer {NULL};
+    Uint32 length{0};
    Uint8 *buffer{NULL};
 };
-struct JA_Channel_t {
+struct JA_Channel_t
-    JA_Sound_t          *sound;
+{
-    int                 pos {0};
+    JA_Sound_t *sound;
-    int                 times {0};
+    int pos{0};
-    JA_Channel_state    state { JA_CHANNEL_FREE };
+    int times{0};
    JA_Channel_state state{JA_CHANNEL_FREE};
 };
-struct JA_Music_t {
+struct JA_Music_t
-    int             samples {0};
+{
-    int             pos {0};
+    int samples{0};
-    int             times {0};
+    int pos{0};
-    short*          output {NULL};
+    int times{0};
-    JA_Music_state  state {JA_MUSIC_INVALID};
+    short *output{NULL};
    JA_Music_state state{JA_MUSIC_INVALID};
 };
-JA_Music_t      *current_music{NULL};
+JA_Music_t *current_music{NULL};
-JA_Channel_t    channels[JA_MAX_SIMULTANEOUS_CHANNELS];
+JA_Channel_t channels[JA_MAX_SIMULTANEOUS_CHANNELS];
-int             JA_freq {48000};
+int JA_freq{48000};
-SDL_AudioFormat JA_format {AUDIO_S16};
+SDL_AudioFormat JA_format{AUDIO_S16};
-Uint8           JA_channels {2};
+Uint8 JA_channels{2};
-int             JA_musicVolume = 128;
+int JA_musicVolume = 128;
-int             JA_soundVolume = 64;
+int JA_soundVolume = 64;
-bool            JA_musicEnabled = true;
+bool JA_musicEnabled = true;
-bool            JA_soundEnabled = true;
+bool JA_soundEnabled = true;
 SDL_AudioDeviceID sdlAudioDevice = 0;
-void audioCallback(void * userdata, uint8_t * stream, int len) {
+void audioCallback(void *userdata, uint8_t *stream, int len)
 {
    SDL_memset(stream, 0, len);
-    if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING) {
+    if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING)
-        const int size = SDL_min(len, current_music->samples*2-current_music->pos);
+    {
-        SDL_MixAudioFormat(stream, (Uint8*)(current_music->output+current_music->pos), AUDIO_S16, size, JA_musicVolume);
+        const int size = SDL_min(len, current_music->samples * 2 - current_music->pos);
-        current_music->pos += size/2;
+        SDL_MixAudioFormat(stream, (Uint8 *)(current_music->output + current_music->pos), AUDIO_S16, size, JA_musicVolume);
-        if (size < len) {
+        current_music->pos += size / 2;
-            if (current_music->times != 0) {
+        if (size < len)
-                SDL_MixAudioFormat(stream+size, (Uint8*)current_music->output, AUDIO_S16, len-size, JA_musicVolume);
+        {
-                current_music->pos = (len-size)/2;
+            if (current_music->times != 0)
-                if (current_music->times > 0) current_music->times--;
+            {
-            } else {
+                SDL_MixAudioFormat(stream + size, (Uint8 *)current_music->output, AUDIO_S16, len - size, JA_musicVolume);
                current_music->pos = (len - size) / 2;
                if (current_music->times > 0)
                    current_music->times--;
            }
            else
            {
                current_music->pos = 0;
                current_music->state = JA_MUSIC_STOPPED;
            }
        }
    }
    // Mixar els channels mi amol
-    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
-        if (channels[i].state == JA_CHANNEL_PLAYING) {
+    {
        if (channels[i].state == JA_CHANNEL_PLAYING)
        {
            const int size = SDL_min(len, channels[i].sound->length - channels[i].pos);
            SDL_MixAudioFormat(stream, channels[i].sound->buffer + channels[i].pos, AUDIO_S16, size, JA_soundVolume);
            channels[i].pos += size;
-            if (size < len) {
+            if (size < len)
-                if (channels[i].times != 0) {
+            {
-                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len-size, JA_soundVolume);
+                if (channels[i].times != 0)
-                    channels[i].pos = len-size;
+                {
-                    if (channels[i].times > 0) channels[i].times--;
+                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len - size, JA_soundVolume);
-                } else {
+                    channels[i].pos = len - size;
                    if (channels[i].times > 0)
                        channels[i].times--;
                }
                else
                {
                    JA_StopChannel(i);
                }
            }
@@ -76,23 +93,28 @@ void audioCallback(void * userdata, uint8_t * stream, int len) {
    }
 }
-void JA_Init(const int freq, const SDL_AudioFormat format, const int channels) {
+void JA_Init(const int freq, const SDL_AudioFormat format, const int channels)
 {
    JA_freq = freq;
    JA_format = format;
    JA_channels = channels;
    SDL_AudioSpec audioSpec{JA_freq, JA_format, JA_channels, 0, 1024, 0, 0, audioCallback, NULL};
-    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
+    if (sdlAudioDevice != 0)
        SDL_CloseAudioDevice(sdlAudioDevice);
    sdlAudioDevice = SDL_OpenAudioDevice(NULL, 0, &audioSpec, NULL, 0);
    SDL_PauseAudioDevice(sdlAudioDevice, 0);
 }
-void JA_Quit() {
+void JA_Quit()
 {
    SDL_PauseAudioDevice(sdlAudioDevice, 1);
-    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
+    if (sdlAudioDevice != 0)
        SDL_CloseAudioDevice(sdlAudioDevice);
    sdlAudioDevice = 0;
 }
-JA_Music_t *JA_LoadMusic(const char* filename) {
+JA_Music_t *JA_LoadMusic(const char *filename)
 {
    int chan, samplerate;
    // [RZC 28/08/22] Carreguem primer el arxiu en memòria i després el descomprimim. Es algo més rapid.
@@ -100,8 +122,9 @@ JA_Music_t *JA_LoadMusic(const char* filename) {
    fseek(f, 0, SEEK_END);
    long fsize = ftell(f);
    fseek(f, 0, SEEK_SET);
-    Uint8 *buffer = (Uint8*)malloc(fsize + 1);
+    Uint8 *buffer = (Uint8 *)malloc(fsize + 1);
-    if (fread(buffer, fsize, 1, f)!=1) return NULL;
+    if (fread(buffer, fsize, 1, f) != 1)
        return NULL;
    fclose(f);
    JA_Music_t *music = new JA_Music_t();
@@ -109,17 +132,18 @@ JA_Music_t *JA_LoadMusic(const char* filename) {
    music->samples = stb_vorbis_decode_memory(buffer, fsize, &chan, &samplerate, &music->output);
    free(buffer);
    // [RZC 28/08/22] Abans el descomprimiem mentre el teniem obert
-//    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
+    //    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
    SDL_AudioCVT cvt;
    SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq);
-    if (cvt.needed) {
+    if (cvt.needed)
    {
        cvt.len = music->samples * chan * 2;
-        cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
+        cvt.buf = (Uint8 *)SDL_malloc(cvt.len * cvt.len_mult);
        SDL_memcpy(cvt.buf, music->output, cvt.len);
        SDL_ConvertAudio(&cvt);
        free(music->output);
-        music->output = (short*)cvt.buf;
+        music->output = (short *)cvt.buf;
    }
    music->pos = 0;
    music->state = JA_MUSIC_STOPPED;
@@ -129,9 +153,11 @@ JA_Music_t *JA_LoadMusic(const char* filename) {
 void JA_PlayMusic(JA_Music_t *music, const int loop)
 {
-    if (!JA_musicEnabled || !music) return;
+    if (!JA_musicEnabled || !music)
        return;
-    if (current_music != NULL) {
+    if (current_music != NULL)
    {
        current_music->pos = 0;
        current_music->state = JA_MUSIC_STOPPED;
    }
@@ -143,67 +169,78 @@ void JA_PlayMusic(JA_Music_t *music, const int loop)
 void JA_PauseMusic()
 {
-    if (!JA_musicEnabled) return;
+    if (!JA_musicEnabled)
        return;
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
        return;
    current_music->state = JA_MUSIC_PAUSED;
 }
 void JA_ResumeMusic()
 {
-    if (!JA_musicEnabled) return;
+    if (!JA_musicEnabled)
        return;
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
        return;
    current_music->state = JA_MUSIC_PLAYING;
 }
 void JA_StopMusic()
 {
-    if (!JA_musicEnabled) return;
+    if (!JA_musicEnabled)
        return;
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
        return;
    current_music->pos = 0;
    current_music->state = JA_MUSIC_STOPPED;
 }
-JA_Music_state JA_GetMusicState() {
+JA_Music_state JA_GetMusicState()
-    if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
+{
    if (!JA_musicEnabled)
        return JA_MUSIC_DISABLED;
-    if (current_music == NULL) return JA_MUSIC_INVALID;
+    if (current_music == NULL)
        return JA_MUSIC_INVALID;
    return current_music->state;
 }
-void JA_DeleteMusic(JA_Music_t *music) {
+void JA_DeleteMusic(JA_Music_t *music)
-    if (current_music == music) current_music = NULL;
+{
    if (current_music == music)
        current_music = NULL;
    free(music->output);
    delete music;
 }
 int JA_SetMusicVolume(int volume)
 {
-    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0
                                                     : volume;
    return JA_musicVolume;
 }
 void JA_EnableMusic(const bool value)
 {
-    if (!value && current_music != NULL && current_music->state==JA_MUSIC_PLAYING) JA_StopMusic();
+    if (!value && current_music != NULL && current_music->state == JA_MUSIC_PLAYING)
        JA_StopMusic();
    JA_musicEnabled = value;
 }
-
+JA_Sound_t *JA_NewSound(Uint8 *buffer, Uint32 length)
-
+{
 JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length) {
    JA_Sound_t *sound = new JA_Sound_t();
    sound->buffer = buffer;
    sound->length = length;
    return sound;
 }
-JA_Sound_t *JA_LoadSound(const char* filename) {
+JA_Sound_t *JA_LoadSound(const char *filename)
 {
    JA_Sound_t *sound = new JA_Sound_t();
    SDL_AudioSpec wavSpec;
    SDL_LoadWAV(filename, &wavSpec, &sound->buffer, &sound->length);
@@ -211,7 +248,7 @@ JA_Sound_t *JA_LoadSound(const char* filename) {
    SDL_AudioCVT cvt;
    SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq);
    cvt.len = sound->length;
-    cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
+    cvt.buf = (Uint8 *)SDL_malloc(cvt.len * cvt.len_mult);
    SDL_memcpy(cvt.buf, sound->buffer, sound->length);
    SDL_ConvertAudio(&cvt);
    SDL_FreeWAV(sound->buffer);
@@ -223,11 +260,16 @@ JA_Sound_t *JA_LoadSound(const char* filename) {
 int JA_PlaySound(JA_Sound_t *sound, const int loop)
 {
-    if (!JA_soundEnabled || !sound) return 0;
+    if (!JA_soundEnabled || !sound)
        return 0;
    int channel = 0;
-    while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE) { channel++; }
+    while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE)
-    if (channel == JA_MAX_SIMULTANEOUS_CHANNELS) channel = 0;
+    {
        channel++;
    }
    if (channel == JA_MAX_SIMULTANEOUS_CHANNELS)
        channel = 0;
    channels[channel].sound = sound;
    channels[channel].times = loop;
@@ -238,8 +280,10 @@ int JA_PlaySound(JA_Sound_t *sound, const int loop)
 void JA_DeleteSound(JA_Sound_t *sound)
 {
-    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
-        if (channels[i].sound == sound) JA_StopChannel(i);
+    {
        if (channels[i].sound == sound)
            JA_StopChannel(i);
    }
    SDL_free(sound->buffer);
    delete sound;
@@ -247,41 +291,60 @@ void JA_DeleteSound(JA_Sound_t *sound)
 void JA_PauseChannel(const int channel)
 {
-    if (!JA_soundEnabled) return;
+    if (!JA_soundEnabled)
        return;
-    if (channel == -1) {
+    if (channel == -1)
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+    {
-            if (channels[i].state == JA_CHANNEL_PLAYING) channels[i].state = JA_CHANNEL_PAUSED;
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
        {
            if (channels[i].state == JA_CHANNEL_PLAYING)
                channels[i].state = JA_CHANNEL_PAUSED;
        }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+    }
-        if (channels[channel].state == JA_CHANNEL_PLAYING) channels[channel].state = JA_CHANNEL_PAUSED;
+    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
    {
        if (channels[channel].state == JA_CHANNEL_PLAYING)
            channels[channel].state = JA_CHANNEL_PAUSED;
    }
 }
 void JA_ResumeChannel(const int channel)
 {
-    if (!JA_soundEnabled) return;
+    if (!JA_soundEnabled)
        return;
-    if (channel == -1) {
+    if (channel == -1)
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+    {
-            if (channels[i].state == JA_CHANNEL_PAUSED) channels[i].state = JA_CHANNEL_PLAYING;
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
        {
            if (channels[i].state == JA_CHANNEL_PAUSED)
                channels[i].state = JA_CHANNEL_PLAYING;
        }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+    }
-        if (channels[channel].state == JA_CHANNEL_PAUSED) channels[channel].state = JA_CHANNEL_PLAYING;
+    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
    {
        if (channels[channel].state == JA_CHANNEL_PAUSED)
            channels[channel].state = JA_CHANNEL_PLAYING;
    }
 }
 void JA_StopChannel(const int channel)
 {
-    if (!JA_soundEnabled) return;
+    if (!JA_soundEnabled)
        return;
-    if (channel == -1) {
+    if (channel == -1)
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+    {
        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
        {
            channels[i].state = JA_CHANNEL_FREE;
            channels[i].pos = 0;
            channels[i].sound = NULL;
        }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+    }
    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
    {
        channels[channel].state = JA_CHANNEL_FREE;
        channels[channel].pos = 0;
        channels[channel].sound = NULL;
@@ -290,15 +353,18 @@ void JA_StopChannel(const int channel)
 JA_Channel_state JA_GetChannelState(const int channel)
 {
-    if (!JA_soundEnabled) return JA_SOUND_DISABLED;
+    if (!JA_soundEnabled)
        return JA_SOUND_DISABLED;
-    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return JA_CHANNEL_INVALID;
+    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS)
        return JA_CHANNEL_INVALID;
    return channels[channel].state;
 }
 int JA_SetSoundVolume(int volume)
 {
-    JA_soundVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    JA_soundVolume = volume > 128 ? 128 : volume < 0 ? 0
                                                     : volume;
    return JA_soundVolume;
 }
@@ -306,15 +372,17 @@ void JA_EnableSound(const bool value)
 {
    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
    {
-        if (channels[i].state == JA_CHANNEL_PLAYING) JA_StopChannel(i);
+        if (channels[i].state == JA_CHANNEL_PLAYING)
            JA_StopChannel(i);
    }
    JA_soundEnabled = value;
 }
 int JA_SetVolume(int volume)
 {
-    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0
-    JA_soundVolume = JA_musicVolume/2;
+                                                     : volume;
    JA_soundVolume = JA_musicVolume / 2;
    return JA_musicVolume;
 }
--- a/source/jail_audio.h
+++ b/source/jail_audio.h
@@ -1,17 +1,31 @@
 #pragma once
-#include <SDL2/SDL_audio.h>   // for SDL_AudioFormat
+#include <SDL2/SDL_audio.h>  // para SDL_AudioFormat
-#include <SDL2/SDL_stdinc.h>  // for Uint32, Uint8
+#include <SDL2/SDL_stdinc.h> // para Uint32, Uint8
-struct JA_Music_t;  // lines 5-5
+struct JA_Music_t;           // lines 5-5
-struct JA_Sound_t;  // lines 6-6
+struct JA_Sound_t;           // lines 6-6
-enum JA_Channel_state { JA_CHANNEL_INVALID, JA_CHANNEL_FREE, JA_CHANNEL_PLAYING, JA_CHANNEL_PAUSED, JA_SOUND_DISABLED };
+enum JA_Channel_state
-enum JA_Music_state { JA_MUSIC_INVALID, JA_MUSIC_PLAYING, JA_MUSIC_PAUSED, JA_MUSIC_STOPPED, JA_MUSIC_DISABLED };
+{
    JA_CHANNEL_INVALID,
    JA_CHANNEL_FREE,
    JA_CHANNEL_PLAYING,
    JA_CHANNEL_PAUSED,
    JA_SOUND_DISABLED
 };
 enum JA_Music_state
 {
    JA_MUSIC_INVALID,
    JA_MUSIC_PLAYING,
    JA_MUSIC_PAUSED,
    JA_MUSIC_STOPPED,
    JA_MUSIC_DISABLED
 };
 void JA_Init(const int freq, const SDL_AudioFormat format, const int channels);
 void JA_Quit();
-JA_Music_t *JA_LoadMusic(const char* filename);
+JA_Music_t *JA_LoadMusic(const char *filename);
 void JA_PlayMusic(JA_Music_t *music, const int loop = -1);
 void JA_PauseMusic();
 void JA_ResumeMusic();
@@ -21,8 +35,8 @@ void JA_DeleteMusic(JA_Music_t *music);
 int JA_SetMusicVolume(int volume);
 void JA_EnableMusic(const bool value);
-JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length);
+JA_Sound_t *JA_NewSound(Uint8 *buffer, Uint32 length);
-JA_Sound_t *JA_LoadSound(const char* filename);
+JA_Sound_t *JA_LoadSound(const char *filename);
 int JA_PlaySound(JA_Sound_t *sound, const int loop = 0);
 void JA_PauseChannel(const int channel);
 void JA_ResumeChannel(const int channel);
--- a/source/jail_shader.cpp
+++ b/source/jail_shader.cpp
@@ -1,10 +1,10 @@
 #ifndef NO_SHADERS
 #include "jail_shader.h"
-#include <SDL2/SDL_rect.h>    // for SDL_Point
+#include <SDL2/SDL_rect.h> // para SDL_Point
-#include <stdlib.h>           // for NULL, free, malloc, exit
+#include <stdlib.h>        // para NULL, free, malloc, exit
-#include <string.h>           // for strncmp
+#include <string.h>        // para strncmp
-#include <iostream>           // for basic_ostream, char_traits, operator<<
+#include <iostream>        // para basic_ostream, char_traits, operator<<
 #ifdef __APPLE__
 #include "CoreFoundation/CoreFoundation.h"
@@ -14,7 +14,7 @@
 #include <OpenGL/gl3.h>
 #else
 #include <OpenGL/gl.h>
-#endif //!ESSENTIAL_GL_PRACTICES_SUPPORT_GL3
+#endif //! ESSENTIAL_GL_PRACTICES_SUPPORT_GL3
 #else
 #include <SDL2/SDL_opengl.h>
 #endif
@@ -24,14 +24,14 @@ namespace shader
    SDL_Window *win = nullptr;
    SDL_Renderer *renderer = nullptr;
    GLuint programId = 0;
-    SDL_Texture* backBuffer = nullptr;
+    SDL_Texture *backBuffer = nullptr;
-    SDL_Point win_size = {320*4, 256*4};
+    SDL_Point win_size = {320 * 4, 256 * 4};
    SDL_Point tex_size = {320, 256};
    bool usingOpenGL;
-    #ifndef __APPLE__
+#ifndef __APPLE__
-    // I'm avoiding the use of GLEW or some extensions handler, but that 
+    // I'm avoiding the use of GLEW or some extensions handler, but that
    // doesn't mean you should...
    PFNGLCREATESHADERPROC glCreateShader;
    PFNGLSHADERSOURCEPROC glShaderSource;
@@ -47,7 +47,8 @@ namespace shader
    PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
    PFNGLUSEPROGRAMPROC glUseProgram;
-    bool initGLExtensions() {
+    bool initGLExtensions()
    {
        glCreateShader = (PFNGLCREATESHADERPROC)SDL_GL_GetProcAddress("glCreateShader");
        glShaderSource = (PFNGLSHADERSOURCEPROC)SDL_GL_GetProcAddress("glShaderSource");
        glCompileShader = (PFNGLCOMPILESHADERPROC)SDL_GL_GetProcAddress("glCompileShader");
@@ -62,56 +63,60 @@ namespace shader
        glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)SDL_GL_GetProcAddress("glGetProgramInfoLog");
        glUseProgram = (PFNGLUSEPROGRAMPROC)SDL_GL_GetProcAddress("glUseProgram");
-        return glCreateShader && glShaderSource && glCompileShader && glGetShaderiv && 
+        return glCreateShader && glShaderSource && glCompileShader && glGetShaderiv &&
-            glGetShaderInfoLog && glDeleteShader && glAttachShader && glCreateProgram &&
+               glGetShaderInfoLog && glDeleteShader && glAttachShader && glCreateProgram &&
-            glLinkProgram && glValidateProgram && glGetProgramiv && glGetProgramInfoLog &&
+               glLinkProgram && glValidateProgram && glGetProgramiv && glGetProgramInfoLog &&
-            glUseProgram;
+               glUseProgram;
    }
-    #endif
+#endif
-    GLuint compileShader(const char* source, GLuint shaderType) {
+    GLuint compileShader(const char *source, GLuint shaderType)
    {
        // Create ID for shader
        GLuint result = glCreateShader(shaderType);
        // Add define depending on shader type
-        const char *sources[2] = { shaderType==GL_VERTEX_SHADER?"#define VERTEX\n":"#define FRAGMENT\n", source };
+        const char *sources[2] = {shaderType == GL_VERTEX_SHADER ? "#define VERTEX\n" : "#define FRAGMENT\n", source};
        // Define shader text
        glShaderSource(result, 2, sources, NULL);
        // Compile shader
        glCompileShader(result);
-        //Check vertex shader for errors
+        // Check vertex shader for errors
        GLint shaderCompiled = GL_FALSE;
-        glGetShaderiv( result, GL_COMPILE_STATUS, &shaderCompiled );
+        glGetShaderiv(result, GL_COMPILE_STATUS, &shaderCompiled);
-        if( shaderCompiled != GL_TRUE ) {
+        if (shaderCompiled != GL_TRUE)
        {
            std::cout << "Error en la compilación: " << result << "!" << std::endl;
            GLint logLength;
            glGetShaderiv(result, GL_INFO_LOG_LENGTH, &logLength);
            if (logLength > 0)
            {
-                GLchar *log = (GLchar*)malloc(logLength);
+                GLchar *log = (GLchar *)malloc(logLength);
                glGetShaderInfoLog(result, logLength, &logLength, log);
                std::cout << "Shader compile log:" << log << std::endl;
                free(log);
            }
            glDeleteShader(result);
            result = 0;
-//        } else {
+            //        } else {
-//            std::cout << "Shader compilado correctamente. Id = " << result << std::endl;
+            //            std::cout << "Shader compilado correctamente. Id = " << result << std::endl;
        }
        return result;
    }
-    GLuint compileProgram(const char* vertexShaderSource, const char* fragmentShaderSource) {
+    GLuint compileProgram(const char *vertexShaderSource, const char *fragmentShaderSource)
    {
        GLuint programId = 0;
        GLuint vtxShaderId, fragShaderId;
        programId = glCreateProgram();
        vtxShaderId = compileShader(vertexShaderSource, GL_VERTEX_SHADER);
-        fragShaderId = compileShader(fragmentShaderSource?fragmentShaderSource:vertexShaderSource, GL_FRAGMENT_SHADER);
+        fragShaderId = compileShader(fragmentShaderSource ? fragmentShaderSource : vertexShaderSource, GL_FRAGMENT_SHADER);
-        if(vtxShaderId && fragShaderId) {
+        if (vtxShaderId && fragShaderId)
        {
            // Associate shader with program
            glAttachShader(programId, vtxShaderId);
            glAttachShader(programId, fragShaderId);
@@ -121,24 +126,28 @@ namespace shader
            // Check the status of the compile/link
            GLint logLen;
            glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &logLen);
-            if(logLen > 0) {
+            if (logLen > 0)
-                char* log = (char*) malloc(logLen * sizeof(char));
+            {
                char *log = (char *)malloc(logLen * sizeof(char));
                // Show any errors as appropriate
                glGetProgramInfoLog(programId, logLen, &logLen, log);
-                std::cout << "Prog Info Log: " << std::endl << log << std::endl;
+                std::cout << "Prog Info Log: " << std::endl
                          << log << std::endl;
                free(log);
            }
        }
-        if(vtxShaderId) {
+        if (vtxShaderId)
        {
            glDeleteShader(vtxShaderId);
        }
-        if(fragShaderId) {
+        if (fragShaderId)
        {
            glDeleteShader(fragShaderId);
        }
        return programId;
    }
-    const bool init(SDL_Window* win, SDL_Texture* backBuffer, const char* vertexShader, const char* fragmentShader)
+    const bool init(SDL_Window *win, SDL_Texture *backBuffer, const char *vertexShader, const char *fragmentShader)
    {
        shader::win = win;
        shader::renderer = SDL_GetRenderer(win);
@@ -155,19 +164,23 @@ namespace shader
        SDL_RendererInfo rendererInfo;
        SDL_GetRendererInfo(renderer, &rendererInfo);
-        if(!strncmp(rendererInfo.name, "opengl", 6)) {
+        if (!strncmp(rendererInfo.name, "opengl", 6))
-            //std::cout << "Es OpenGL!" << std::endl;
+        {
-    #ifndef __APPLE__
+            // std::cout << "Es OpenGL!" << std::endl;
-            if (!initGLExtensions()) {
+#ifndef __APPLE__
            if (!initGLExtensions())
            {
                std::cout << "WARNING: No s'han pogut inicialitzar les extensions d'OpenGL!" << std::endl;
                usingOpenGL = false;
                return false;
            }
-    #endif
+#endif
            // Compilar el shader y dejarlo listo para usar.
            programId = compileProgram(vertexShader, fragmentShader);
-            //std::cout << "programId = " << programId << std::endl;
+            // std::cout << "programId = " << programId << std::endl;
-        } else {
+        }
        else
        {
            std::cout << "WARNING: El driver del renderer no es OpenGL." << std::endl;
            usingOpenGL = false;
            return false;
@@ -180,19 +193,21 @@ namespace shader
    {
        GLint oldProgramId;
        // Guarrada para obtener el textureid (en driverdata->texture)
-        //Detach the texture
+        // Detach the texture
        SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
        SDL_SetRenderTarget(renderer, NULL);
        SDL_RenderClear(renderer);
-        if (usingOpenGL) {
+        if (usingOpenGL)
        {
            SDL_GL_BindTexture(backBuffer, NULL, NULL);
-            if(programId != 0) {
+            if (programId != 0)
-                glGetIntegerv(GL_CURRENT_PROGRAM,&oldProgramId);
+            {
                glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgramId);
                glUseProgram(programId);
            }
-            
+
            GLfloat minx, miny, maxx, maxy;
            GLfloat minu, maxu, minv, maxv;
@@ -210,21 +225,24 @@ namespace shader
            glViewport(0, 0, win_size.x, win_size.y);
            glBegin(GL_TRIANGLE_STRIP);
-                glTexCoord2f(minu, minv);
+            glTexCoord2f(minu, minv);
-                glVertex2f(minx, miny);
+            glVertex2f(minx, miny);
-                glTexCoord2f(maxu, minv);
+            glTexCoord2f(maxu, minv);
-                glVertex2f(maxx, miny);
+            glVertex2f(maxx, miny);
-                glTexCoord2f(minu, maxv);
+            glTexCoord2f(minu, maxv);
-                glVertex2f(minx, maxy);
+            glVertex2f(minx, maxy);
-                glTexCoord2f(maxu, maxv);
+            glTexCoord2f(maxu, maxv);
-                glVertex2f(maxx, maxy);
+            glVertex2f(maxx, maxy);
            glEnd();
            SDL_GL_SwapWindow(win);
-            if(programId != 0) {
+            if (programId != 0)
            {
                glUseProgram(oldProgramId);
            }
-        } else {
+        }
        else
        {
            SDL_RenderCopy(renderer, backBuffer, NULL, NULL);
            SDL_RenderPresent(renderer);
        }
--- a/source/jail_shader.h
+++ b/source/jail_shader.h
@@ -2,8 +2,8 @@
 #pragma once
-#include <SDL2/SDL_render.h>  // for SDL_Texture
+#include <SDL2/SDL_render.h> // para SDL_Texture
-#include <SDL2/SDL_video.h>   // for SDL_Window
+#include <SDL2/SDL_video.h>  // para SDL_Window
 // TIPS:
 // =======================================================================
@@ -27,7 +27,7 @@
 // Els shaders li'ls passem com una cadena, som nosaltres els que s'encarreguem
 // de carregarlos de disc, amb fopen, ifstream, jfile o el que vullgues.
 // Si els tens en un std::string, passa-li-la com "cadena.c_str()".
-// 
+//
 // Poden ser els dos el mateix arxiu, com fa libRetro, jo desde dins ja fique
 // els defines necessaris. Si es el mateix arxiu, pots no ficar el quart paràmetre.
 //
@@ -40,8 +40,8 @@
 namespace shader
 {
-    const bool init(SDL_Window* win, SDL_Texture* backBuffer,
+    const bool init(SDL_Window *win, SDL_Texture *backBuffer,
-                    const char* vertexShader, const char* fragmentShader=nullptr);
+                    const char *vertexShader, const char *fragmentShader = nullptr);
    void render();
 }
--- a/source/lang.cpp
+++ b/source/lang.cpp
@@ -1,11 +1,11 @@
 #include "lang.h"
-#include <fstream>  // for basic_ifstream, basic_istream, ifstream
+#include <fstream> // para basic_ifstream, basic_istream, ifstream
-#include <vector>   // for vector
+#include <vector>  // para vector
 namespace lang
-{ 
+{
    std::vector<std::string> texts; // Vector con los textos
-    
+
    // Inicializa los textos del juego en el idioma seleccionado
    bool loadFromFile(std::string file_path)
    {
--- a/source/lang.h
+++ b/source/lang.h
@@ -1,6 +1,6 @@
 #pragma once
-#include <string>  // for string
+#include <string> // para string
 namespace lang
 {
--- a/source/logo.cpp
+++ b/source/logo.cpp
@@ -1,31 +1,30 @@
 #include "logo.h"
-#include <SDL2/SDL_events.h> // for SDL_PollEvent, SDL_Event, SDL_QUIT, SDL...
+#include <SDL2/SDL_events.h> // Para SDL_PollEvent, SDL_Event, SDL_QUIT, SDL...
-#include <SDL2/SDL_render.h> // for SDL_Renderer
+#include <SDL2/SDL_timer.h>	 // Para SDL_GetTicks
-#include <SDL2/SDL_timer.h>	 // for SDL_GetTicks
+#include <SDL2/SDL_video.h>	 // Para SDL_WINDOWEVENT_SIZE_CHANGED
-#include <SDL2/SDL_video.h>	 // for SDL_WINDOWEVENT_SIZE_CHANGED
+#include <utility>			 // Para move
-#include <utility>			 // for move
+#include "global_inputs.h"	 // Para check
-#include "asset.h"			 // for Asset
+#include "input.h"			 // Para Input
-#include "global_inputs.h"	 // for check
+#include "jail_audio.h"		 // Para JA_StopMusic
-#include "input.h"			 // for Input
+#include "param.h"			 // Para Param, ParamGame, param
-#include "jail_audio.h"		 // for JA_StopMusic
+#include "resource.h"		 // Para Resource
-#include "param.h"			 // for param
+#include "screen.h"			 // Para Screen
-#include "resource.h"		 // for Resource
+#include "section.h"		 // Para Name, name, Options, options
-#include "screen.h"			 // for Screen
+#include "sprite.h"			 // Para Sprite
-#include "section.h"		 // for Name, name, Options, options
+#include "texture.h"		 // Para Texture
-#include "sprite.h"			 // for Sprite
+#include "utils.h"			 // Para Color, Zone
 #include "texture.h"		 // for Texture
 // Constructor
 Logo::Logo()
 	: since_texture_(Resource::get()->getTexture("logo_since_1998.png")),
 	  since_sprite_(std::make_unique<Sprite>(since_texture_)),
-	  jail_texture_(Resource::get()->getTexture("logo_jailgames.png"))
+	  jail_texture_(Resource::get()->getTexture("logo_jailgames.png")),
 	  ticks_(0)
 {
 	// Inicializa variables
 	counter_ = 0;
 	section::name = section::Name::LOGO;
 	ticks_ = 0;
 	dest_.x = param.game.game_area.center_x - jail_texture_->getWidth() / 2;
 	dest_.y = param.game.game_area.center_y - jail_texture_->getHeight() / 2;
 	since_sprite_->setPosition({(param.game.width - since_texture_->getWidth()) / 2, 83 + jail_texture_->getHeight() + 5, since_texture_->getWidth(), since_texture_->getHeight()});
@@ -45,14 +44,21 @@ Logo::Logo()
 	}
 	// Inicializa el vector de colores
-	color_.push_back({0x00, 0x00, 0x00}); // Black
+	color_.push_back(Color(0x00, 0x00, 0x00)); // Black
-	color_.push_back({0x00, 0x00, 0xd8}); // Blue
+	color_.push_back(Color(0x00, 0x00, 0xd8)); // Blue
-	color_.push_back({0xd8, 0x00, 0x00}); // Red
+	color_.push_back(Color(0xd8, 0x00, 0x00)); // Red
-	color_.push_back({0xd8, 0x00, 0xd8}); // Magenta
+	color_.push_back(Color(0xd8, 0x00, 0xd8)); // Magenta
-	color_.push_back({0x00, 0xd8, 0x00}); // Green
+	color_.push_back(Color(0x00, 0xd8, 0x00)); // Green
-	color_.push_back({0x00, 0xd8, 0xd8}); // Cyan
+	color_.push_back(Color(0x00, 0xd8, 0xd8)); // Cyan
-	color_.push_back({0xd8, 0xd8, 0x00}); // Yellow
+	color_.push_back(Color(0xd8, 0xd8, 0x00)); // Yellow
-	color_.push_back({0xFF, 0xFF, 0xFF}); // Bright white
+	color_.push_back(Color(0xFF, 0xFF, 0xFF)); // Bright white
 }
 // Destructor
 Logo::~Logo()
 {
 	jail_texture_->setColor(255, 255, 255);
 	since_texture_->setColor(255, 255, 255);
 }
 // Recarga todas las texturas
@@ -73,6 +79,7 @@ void Logo::checkEvents()
 		if (event.type == SDL_QUIT)
 		{
 			section::name = section::Name::QUIT;
 			section::options = section::Options::QUIT_FROM_EVENT;
 			break;
 		}
@@ -99,9 +106,6 @@ void Logo::checkInput()
 		return;
 	}
 	// Comprueba el input para el resto de objetos
 	Screen::get()->checkInput();
 	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
 	globalInputs::check();
 }
@@ -164,7 +168,8 @@ void Logo::updateTextureColors()
 // Actualiza las variables
 void Logo::update()
 {
-	// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
+	constexpr int TICKS_SPEED = 15;
 	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		// Actualiza el contador de ticks
--- a/source/logo.h
+++ b/source/logo.h
@@ -1,12 +1,12 @@
 #pragma once
-#include <SDL2/SDL_rect.h>    // for SDL_Point
+#include <SDL2/SDL_rect.h>	 // Para SDL_Point
-#include <SDL2/SDL_stdinc.h>  // for Uint32
+#include <SDL2/SDL_stdinc.h> // Para Uint32
-#include <memory>             // for unique_ptr, shared_ptr
+#include <memory>			 // Para shared_ptr, unique_ptr
-#include <vector>             // for vector
+#include <vector>			 // Para vector
-#include "sprite.h"           // for Sprite
+class Sprite;
-#include "utils.h"            // for Color
+class Texture; // lines 9-9
-class Texture;
+struct Color;
 /*
 	Esta clase gestiona un estado del programa. Se encarga de dibujar por pantalla el
@@ -21,13 +21,12 @@ class Logo
 {
 private:
 	// Constantes
 	static constexpr Uint32 TICKS_SPEED = 15;				  // Velocidad a la que se repiten los bucles del programa
 	static constexpr int SHOW_SINCE_SPRITE_COUNTER_MARK = 70; // Tiempo del contador en el que empieza a verse el sprite de "SINCE 1998"
 	static constexpr int INIT_FADE_COUNTER_MARK = 300;		  // Tiempo del contador cuando inicia el fade a negro
 	static constexpr int END_LOGO_COUNTER_MARK = 400;		  // Tiempo del contador para terminar el logo
 	static constexpr int POST_LOGO_DURATION = 20;			  // Tiempo que dura el logo con el fade al maximo
 	static constexpr int SPEED = 8;							  // Velocidad de desplazamiento de cada linea
-	
+
 	// Objetos y punteros
 	std::shared_ptr<Texture> since_texture_;		   // Textura con los graficos "Since 1998"
 	std::unique_ptr<Sprite> since_sprite_;			   // Sprite para manejar la sinceTexture
@@ -66,7 +65,7 @@ public:
 	Logo();
 	// Destructor
-	~Logo() = default;
+	~Logo();
 	// Bucle principal
 	void run();
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -7,9 +7,8 @@ Actualizando a la versión "Arcade Edition" en 08/05/2024
 */
-#include <iostream>    // for char_traits, basic_ostream, operator<<, cout
+#include <memory>     // Para make_unique, unique_ptr
-#include <memory>      // for make_unique, unique_ptr
+#include "director.h" // Para Director
 #include "director.h"  // for Director
 int main(int argc, char *argv[])
 {
--- a/source/manage_hiscore_table.cpp
+++ b/source/manage_hiscore_table.cpp
@@ -1,48 +1,40 @@
 #include "manage_hiscore_table.h"
-#include <SDL2/SDL_error.h> // for SDL_GetError
+#include <SDL2/SDL_error.h> // Para SDL_GetError
-#include <SDL2/SDL_rwops.h> // for SDL_RWread, SDL_RWwrite, SDL_RWFromFile
+#include <SDL2/SDL_rwops.h> // Para SDL_RWread, SDL_RWwrite, SDL_RWFromFile
-#include <stdlib.h>         // for free, malloc
+#include <algorithm>        // Para sort
-#include <algorithm>        // for sort
+#include <iostream>         // Para basic_ostream, operator<<, cout, endl
-#include <iostream>         // for basic_ostream, char_traits, operator<<
+#include "utils.h"          // Para HiScoreEntry, getFileName
 #include "utils.h"          // for HiScoreEntry
 // Constructor
 ManageHiScoreTable::ManageHiScoreTable(std::vector<HiScoreEntry> *table)
    : table_(table) {}
 // Resetea la tabla a los valores por defecto
 void ManageHiScoreTable::clear()
 {
    // Limpia la tabla
-    table_->clear();
+    table_.clear();
    // Añade 10 entradas predefinidas
-    table_->push_back({"Bry", 1000000});
+    table_.push_back(HiScoreEntry("Bry", 1000000));
-    table_->push_back({"Usufondo", 500000});
+    table_.push_back(HiScoreEntry("Usufondo", 500000));
-    table_->push_back({"G.Lucas", 100000});
+    table_.push_back(HiScoreEntry("G.Lucas", 100000));
-    table_->push_back({"P.Delgat", 50000});
+    table_.push_back(HiScoreEntry("P.Delgat", 50000));
-    table_->push_back({"P.Arrabalera", 10000});
+    table_.push_back(HiScoreEntry("P.Arrabalera", 10000));
-    table_->push_back({"Pelechano", 5000});
+    table_.push_back(HiScoreEntry("Pelechano", 5000));
-    table_->push_back({"Sahuquillo", 1000});
+    table_.push_back(HiScoreEntry("Sahuquillo", 1000));
-    table_->push_back({"Bacteriol", 500});
+    table_.push_back(HiScoreEntry("Bacteriol", 500));
-    table_->push_back({"Pepe", 200});
+    table_.push_back(HiScoreEntry("Pepe", 200));
-    table_->push_back({"Rosita", 100});
+    table_.push_back(HiScoreEntry("Rosita", 100));
 }
 // Añade un elemento a la tabla
 void ManageHiScoreTable::add(HiScoreEntry entry)
 {
    // Añade la entrada a la tabla
-    table_->push_back(entry);
+    table_.push_back(entry);
    // Ordena la tabla
    sort();
    // Deja solo las 10 primeras entradas
-    if (static_cast<int>(table_->size()) > 10)
+    table_.resize(10);
    {
        table_->resize(10);
    }
 }
 // Ordena la tabla
@@ -51,28 +43,27 @@ void ManageHiScoreTable::sort()
    struct
    {
        bool operator()(const HiScoreEntry &a, const HiScoreEntry &b) const { return a.score > b.score; }
-    } custom_less;
+    } scoreDescendingComparator;
-    std::sort(table_->begin(), table_->end(), custom_less);
+    std::sort(table_.begin(), table_.end(), scoreDescendingComparator);
 }
 // Carga la tabla con los datos de un fichero
 bool ManageHiScoreTable::loadFromFile(const std::string &file_path)
 {
    clear();
    auto success = true;
    auto file = SDL_RWFromFile(file_path.c_str(), "r+b");
    if (file)
    {
-        const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
+        std::cout << "Reading file: " << getFileName(file_path) << std::endl;
-        std::cout << "Reading file: " << file_name.c_str() << std::endl;
+
-        for (int i = 0; i < (int)table_->size(); ++i)
+        for (auto &entry : table_)
        {
            int nameSize = 0;
-            if (SDL_RWread(file, &table_->at(i).score, sizeof(int), 1) == 0)
+            if (SDL_RWread(file, &entry.score, sizeof(int), 1) == 0)
            {
                success = false;
                break;
@@ -84,19 +75,15 @@ bool ManageHiScoreTable::loadFromFile(const std::string &file_path)
                break;
            }
-            char *name = static_cast<char *>(malloc(nameSize + 1));
+            std::vector<char> nameBuffer(nameSize + 1);
-            if (SDL_RWread(file, name, sizeof(char) * nameSize, 1) == 0)
+            if (SDL_RWread(file, nameBuffer.data(), sizeof(char) * nameSize, 1) == 0)
            {
                success = false;
                free(name);
                break;
            }
-            else
+
-            {
+            nameBuffer[nameSize] = '\0';
-                name[nameSize] = 0;
+            entry.name = std::string(nameBuffer.data());
                table_->at(i).name = name;
                free(name);
            }
        }
        SDL_RWclose(file);
@@ -113,28 +100,26 @@ bool ManageHiScoreTable::loadFromFile(const std::string &file_path)
 // Guarda la tabla en un fichero
 bool ManageHiScoreTable::saveToFile(const std::string &file_path)
 {
    const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
    auto success = true;
    auto file = SDL_RWFromFile(file_path.c_str(), "w+b");
    if (file)
    {
        // Guarda los datos
-        for (int i = 0; i < (int)table_->size(); ++i)
+        for (int i = 0; i < (int)table_.size(); ++i)
        {
-            SDL_RWwrite(file, &table_->at(i).score, sizeof(int), 1);
+            SDL_RWwrite(file, &table_.at(i).score, sizeof(int), 1);
-            const int nameSize = (int)table_->at(i).name.size();
+            const int nameSize = (int)table_.at(i).name.size();
            SDL_RWwrite(file, &nameSize, sizeof(int), 1);
-            SDL_RWwrite(file, table_->at(i).name.c_str(), nameSize, 1);
+            SDL_RWwrite(file, table_.at(i).name.c_str(), nameSize, 1);
        }
-        std::cout << "Writing file: " << file_name.c_str() << std::endl;
+        std::cout << "Writing file: " << getFileName(file_path).c_str() << std::endl;
        // Cierra el fichero
        SDL_RWclose(file);
    }
    else
    {
-        std::cout << "Error: Unable to save " << file_name.c_str() << " file! " << SDL_GetError() << std::endl;
+        std::cout << "Error: Unable to save " << getFileName(file_path).c_str() << " file! " << SDL_GetError() << std::endl;
    }
    return success;
 }
--- a/source/manage_hiscore_table.h
+++ b/source/manage_hiscore_table.h
@@ -1,8 +1,7 @@
 #pragma once
-#include <string> // for string
+#include <string> // para string
-#include <vector> // for vector
+#include <vector> // para vector
 struct HiScoreEntry;
 /*
    Esta clase sirve para añadir elementos hiScoreEntry_r a un vector (tabla), de manera
@@ -12,19 +11,31 @@ struct HiScoreEntry;
    leer y escribir la tabla a un fichero
 */
 // Estructura para las entradas de la tabla de recirds
 struct HiScoreEntry
 {
 	std::string name; // Nombre
 	int score;		  // Puntuación
 	// Constructor
 	explicit HiScoreEntry(const std::string &n = "", int s = 0)
 		: name(n), score(s) {}
 };
 // Clase ManageHiScoreTable
 class ManageHiScoreTable
 {
 private:
    // Variables
-    std::vector<HiScoreEntry> *table_; // Tabla con los records
+    std::vector<HiScoreEntry> &table_; // Tabla con los records
    // Ordena la tabla
    void sort();
 public:
    // Constructor
-    explicit ManageHiScoreTable(std::vector<HiScoreEntry> *table);
+    explicit ManageHiScoreTable(std::vector<HiScoreEntry> &table)
        : table_(table) {}
    // Destructor
    ~ManageHiScoreTable() = default;
--- a/source/moving_sprite.cpp
+++ b/source/moving_sprite.cpp
@@ -1,15 +1,12 @@
 #include "moving_sprite.h"
-#include "texture.h" // for Texture
+#include <algorithm> // Para max
 #include "texture.h" // Para Texture
 // Constructor
 MovingSprite::MovingSprite(std::shared_ptr<Texture> texture, SDL_Rect pos, Rotate rotate, float zoom_w, float zoom_h, SDL_RendererFlip flip)
 	: Sprite(texture, pos),
 	  x_(pos.x),
 	  y_(pos.y),
 	  vx_(0.0f),
 	  vy_(0.0f),
 	  ax_(0.0f),
 	  ay_(0.0f),
 	  rotate_(rotate),
 	  zoom_w_(zoom_w),
 	  zoom_h_(zoom_h),
@@ -19,10 +16,6 @@ MovingSprite::MovingSprite(std::shared_ptr<Texture> texture, SDL_Rect pos)
 	: Sprite(texture, pos),
 	  x_(pos.x),
 	  y_(pos.y),
 	  vx_(0.0f),
 	  vy_(0.0f),
 	  ax_(0.0f),
 	  ay_(0.0f),
 	  rotate_(Rotate()),
 	  zoom_w_(1.0f),
 	  zoom_h_(1.0f),
@@ -32,10 +25,6 @@ MovingSprite::MovingSprite(std::shared_ptr<Texture> texture)
 	: Sprite(texture),
 	  x_(0.0f),
 	  y_(0.0f),
 	  vx_(0.0f),
 	  vy_(0.0f),
 	  ax_(0.0f),
 	  ay_(0.0f),
 	  rotate_(Rotate()),
 	  zoom_w_(1.0f),
 	  zoom_h_(1.0f),
@@ -89,24 +78,6 @@ void MovingSprite::render()
 	texture_->render(pos_.x, pos_.y, &sprite_clip_, zoom_w_, zoom_h_, rotate_.angle, rotate_.center, flip_);
 }
 // Obtiene el valor de la variable
 float MovingSprite::getZoomW() const
 {
 	return zoom_w_;
 }
 // Obtiene el valor de la variable
 float MovingSprite::getZoomH() const
 {
 	return zoom_h_;
 }
 // Obtiene el valor de la variable
 double MovingSprite::getAngle() const
 {
 	return rotate_.angle;
 }
 // Establece el valor de la variable
 void MovingSprite::setZoomW(float value)
 {
@@ -137,12 +108,6 @@ bool MovingSprite::isRotating() const
 	return rotate_.enabled;
 }
 // Obtiene el valor de la variable
 int MovingSprite::getRotateSpeed() const
 {
 	return rotate_.speed;
 }
 // Establece la rotacion
 void MovingSprite::rotate()
 {
--- a/source/moving_sprite.h
+++ b/source/moving_sprite.h
@@ -1,11 +1,10 @@
 #pragma once
-#include <SDL2/SDL_rect.h>   // for SDL_Rect, SDL_Point
+#include <SDL2/SDL_rect.h>   // Para SDL_Rect, SDL_Point
-#include <SDL2/SDL_render.h> // for SDL_RendererFlip
+#include <SDL2/SDL_render.h> // Para SDL_RendererFlip
-#include <SDL2/SDL_stdinc.h> // for Uint16
+#include <memory>            // Para shared_ptr
-#include <memory>            // for shared_ptr
+#include "sprite.h"          // Para Sprite
-#include "sprite.h"          // for Sprite
+class Texture;               // lines 8-8
 class Texture;
 // Clase MovingSprite. Añade movimiento y efectos de rotación, zoom y flip al sprite
 class MovingSprite : public Sprite
@@ -27,11 +26,11 @@ protected:
    float x_; // Posición en el eje X
    float y_; // Posición en el eje Y
-    float vx_; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
+    float vx_ = 0.0f; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
-    float vy_; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
+    float vy_ = 0.0f; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
-    float ax_; // Aceleración en el eje X. Variación de la velocidad
+    float ax_ = 0.0f; // Aceleración en el eje X. Variación de la velocidad
-    float ay_; // Aceleración en el eje Y. Variación de la velocidad
+    float ay_ = 0.0f; // Aceleración en el eje Y. Variación de la velocidad
    Rotate rotate_;         // Variables usada para controlar la rotación del sprite
    float zoom_w_;          // Zoom aplicado a la anchura
@@ -54,7 +53,7 @@ public:
    explicit MovingSprite(std::shared_ptr<Texture> texture);
    // Destructor
-    ~MovingSprite() = default;
+    virtual ~MovingSprite() = default;
    // Actualiza las variables internas del objeto
    virtual void update();
@@ -79,14 +78,8 @@ public:
    void setAccelX(float value);
    void setAccelY(float value);
    // Obten el valor de la variable
    float getZoomW() const;
    float getZoomH() const;
    // Obten el valor de la variable
    bool isRotating() const;
    double getAngle() const;
    int getRotateSpeed() const;
    // Establece el valor de la variable
    void setZoomW(float value);
--- a/source/notifier.cpp
+++ b/source/notifier.cpp
@@ -1,20 +1,21 @@
 #include "notifier.h"
-#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_pixels.h>    // for SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888
-#include <string>               // for string
+#include <string>               // Para string
-#include "jail_audio.h"         // for JA_DeleteSound, JA_LoadSound, JA_Pla...
+#include <algorithm>
-#include "param.h"              // for param
+#include <vector>
-#include "resource.h"           // for Resource
+#include "jail_audio.h" // Para JA_DeleteSound, JA_LoadSound, JA_Pla...
-#include "screen.h"             // for Screen
+#include "param.h"      // Para Param, param, ParamNotification, Par...
-#include "sprite.h"             // for Sprite
+#include "screen.h"     // Para Screen
-#include "text.h"               // for Text
+#include "sprite.h"     // Para Sprite
-#include "texture.h"            // for Texture
+#include "text.h"       // Para Text
 #include "texture.h"    // Para Texture
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Notifier *Notifier::notifier_ = nullptr;
 // [SINGLETON] Crearemos el objeto screen con esta función estática
-void Notifier::init(std::string icon_file, std::shared_ptr<Text> text, const std::string &sound_file)
+void Notifier::init(const std::string &icon_file, std::shared_ptr<Text> text, const std::string &sound_file)
 {
    Notifier::notifier_ = new Notifier(icon_file, text, sound_file);
 }
@@ -34,26 +35,18 @@ Notifier *Notifier::get()
 // Constructor
 Notifier::Notifier(std::string icon_file, std::shared_ptr<Text> text, const std::string &sound_file)
    : renderer_(Screen::get()->getRenderer()),
      icon_texture_(!icon_file.empty() ? std::make_unique<Texture>(renderer_, icon_file) : nullptr),
      text_(text),
      bg_color_(param.notification.color),
      wait_time_(150),
      stack_(false),
-      sound_(JA_LoadSound(sound_file.c_str()))
+      has_icons_(!icon_file.empty()),
-{
+      sound_(JA_LoadSound(sound_file.c_str())) {}
    // Inicializa variables
    has_icons_ = !icon_file.empty();
    // Crea objetos
    icon_texture_ = has_icons_ ? std::make_unique<Texture>(renderer_, icon_file) : nullptr;
 }
 // Destructor
 Notifier::~Notifier()
 {
    // Libera la memoria de los objetos
    JA_DeleteSound(sound_);
    notifications_.clear();
 }
 // Dibuja las notificaciones por pantalla
@@ -165,39 +158,41 @@ void Notifier::clearFinishedNotifications()
    }
 }
-void Notifier::showText(std::string text1, std::string text2, int icon, std::string code)
+void Notifier::showText(std::vector<std::string> texts, int icon, const std::string &code)
 {
    // Cuenta el número de textos a mostrar
    const int num_texts = !text1.empty() + !text2.empty();
    // Si no hay texto, acaba
-    if (num_texts == 0)
+    if (texts.empty())
    {
        return;
    }
    // Si solo hay un texto, lo coloca en la primera variable
    if (num_texts == 1)
    {
        text1 += text2;
        text2.clear();
    }
    // Si las notificaciones no se apilan, elimina las anteriores
    if (!stack_)
    {
        clearNotifications();
    }
    // Elimina las cadenas vacías
    texts.erase(std::remove_if(texts.begin(), texts.end(), [](const std::string &s)
                               { return s.empty(); }),
                texts.end());
    // Encuentra la cadena más larga
    std::string longest;
    for (const auto &text : texts)
    {
        if (text.length() > longest.length())
            longest = text;
    }
    // Inicializa variables
-    constexpr auto icon_size = 16;
+    constexpr int icon_size = 16;
-    constexpr auto padding_out = 1;
+    constexpr int padding_out = 1;
    const auto padding_in_h = text_->getCharacterSize();
    const auto padding_in_v = text_->getCharacterSize() / 2;
-    const auto icon_space = icon >= 0 ? icon_size + padding_in_h : 0;
+    const int icon_space = icon >= 0 ? icon_size + padding_in_h : 0;
-    const std::string txt = text1.length() > text2.length() ? text1 : text2;
+    const int width = text_->lenght(longest) + (padding_in_h * 2) + icon_space;
-    const auto width = text_->lenght(txt) + (padding_in_h * 2) + icon_space;
+    const int height = (text_->getCharacterSize() * texts.size()) + (padding_in_v * 2);
    const auto height = (text_->getCharacterSize() * num_texts) + (padding_in_v * 2);
    const auto shape = NotificationShape::SQUARED;
    // Posición horizontal
@@ -223,11 +218,11 @@ void Notifier::showText(std::string text1, std::string text2, int icon, std::str
    auto offset = 0;
    if (param.notification.pos_v == NotifyPosition::TOP)
    {
-        offset = (int)notifications_.size() > 0 ? notifications_.back().y + travel_dist : desp_v;
+        offset = !notifications_.empty() ? notifications_.back().y + travel_dist : desp_v;
    }
    else
    {
-        offset = (int)notifications_.size() > 0 ? notifications_.back().y - travel_dist : desp_v;
+        offset = !notifications_.empty() ? notifications_.back().y - travel_dist : desp_v;
    }
    // Crea la notificacion
@@ -237,10 +232,7 @@ void Notifier::showText(std::string text1, std::string text2, int icon, std::str
    n.code = code;
    n.y = offset;
    n.travel_dist = travel_dist;
-    n.counter = 0;
+    n.texts = texts;
    n.status = NotificationStatus::RISING;
    n.text1 = text1;
    n.text2 = text2;
    n.shape = shape;
    auto y_pos = offset + (param.notification.pos_v == NotifyPosition::TOP ? -travel_dist : travel_dist);
    n.rect = {desp_h, y_pos, width, height};
@@ -277,7 +269,7 @@ void Notifier::showText(std::string text1, std::string text2, int icon, std::str
    }
    // Dibuja el icono de la notificación
-    if (has_icons_ && icon >= 0 && num_texts == 2)
+    if (has_icons_ && icon >= 0 && texts.size() >= 2)
    {
        auto sp = std::make_unique<Sprite>(icon_texture_, (SDL_Rect){0, 0, icon_size, icon_size});
        sp->setPosition({padding_in_h, padding_in_v, icon_size, icon_size});
@@ -286,15 +278,12 @@ void Notifier::showText(std::string text1, std::string text2, int icon, std::str
    }
    // Escribe el texto de la notificación
-    Color color = {255, 255, 255};
+    const Color color{255, 255, 255};
-    if (num_texts == 2)
+    int iterator = 0;
-    { // Dos lineas de texto
+    for (const auto &text : texts)
-        text_->writeColored(padding_in_h + icon_space, padding_in_v, text1, color);
+    {
-        text_->writeColored(padding_in_h + icon_space, padding_in_v + text_->getCharacterSize() + 1, text2, color);
+        text_->writeColored(padding_in_h + icon_space, padding_in_v + iterator * (text_->getCharacterSize() + 1), text, color);
-    }
+        ++iterator;
    else
    { // Una linea de texto
        text_->writeColored(padding_in_h + icon_space, padding_in_v, text1, color);
    }
    // Deja de dibujar en la textura
@@ -307,26 +296,18 @@ void Notifier::showText(std::string text1, std::string text2, int icon, std::str
    n.texture->setAlpha(0);
    // Añade la notificación a la lista
-    notifications_.push_back(n);
+    notifications_.emplace_back(n);
 }
 // Indica si hay notificaciones activas
-bool Notifier::isActive()
+bool Notifier::isActive() { return !notifications_.empty(); }
 {
    if ((int)notifications_.size() > 0)
    {
        return true;
    }
    return false;
 }
 // Finaliza y elimnina todas las notificaciones activas
 void Notifier::clearNotifications()
 {
-    for (int i = 0; i < (int)notifications_.size(); ++i)
+    for (auto &notification : notifications_)
    {
-        notifications_[i].status = NotificationStatus::FINISHED;
+        notification.status = NotificationStatus::FINISHED;
    }
    clearFinishedNotifications();
@@ -336,9 +317,9 @@ void Notifier::clearNotifications()
 std::vector<std::string> Notifier::getCodes()
 {
    std::vector<std::string> codes;
-    for (int i = 0; i < (int)notifications_.size(); ++i)
+    for (const auto &notification : notifications_)
    {
-        codes.push_back(notifications_[i].code);
+        codes.emplace_back(notification.code);
    }
    return codes;
 }
--- a/source/notifier.h
+++ b/source/notifier.h
@@ -1,11 +1,11 @@
 #pragma once
-#include <SDL2/SDL_rect.h>	 // for SDL_Rect
+#include <SDL2/SDL_rect.h>	 // para SDL_Rect
-#include <SDL2/SDL_render.h> // for SDL_Renderer
+#include <SDL2/SDL_render.h> // para SDL_Renderer
-#include <memory>			 // for shared_ptr, unique_ptr
+#include <memory>			 // para shared_ptr, unique_ptr
-#include <string>			 // for string, basic_string
+#include <string>			 // para string, basic_string
-#include <vector>			 // for vector
+#include <vector>			 // para vector
-#include "utils.h"			 // for Color
+#include "utils.h"			 // para Color
 class Sprite;
 class Text;
 class Texture;
@@ -25,18 +25,6 @@ private:
 		FINISHED,
 	};
 	enum class NotificationPosition
 	{
 		UPPER_LEFT,
 		UPPER_CENTER,
 		UPPER_RIGHT,
 		MIDDLE_LEFT,
 		MIDDLE_RIGHT,
 		BOTTOM_LEFT,
 		BOTTOM_CENTER,
 		BOTTOM_RIGHT,
 	};
 	enum class NotificationShape
 	{
 		ROUNDED,
@@ -47,16 +35,19 @@ private:
 	{
 		std::shared_ptr<Texture> texture;
 		std::shared_ptr<Sprite> sprite;
-		std::string text1;
+		std::vector<std::string> texts;
 		std::string text2;
 		int counter;
 		NotificationStatus status;
 		NotificationPosition position;
 		NotificationShape shape;
 		SDL_Rect rect;
 		int y;
 		int travel_dist;
 		std::string code; // Permite asignar un código a la notificación
 		// Constructor
 		explicit Notification()
 			: texture(nullptr), sprite(nullptr), texts(), counter(0), status(NotificationStatus::RISING),
 			  shape(NotificationShape::SQUARED), rect{0, 0, 0, 0}, y(0), travel_dist(0), code("") {}
 	};
 	// Objetos y punteros
@@ -89,7 +80,7 @@ private:
 public:
 	// [SINGLETON] Crearemos el objeto notifier con esta función estática
-	static void init(std::string icon_file, std::shared_ptr<Text> text, const std::string &sound_file);
+	static void init(const std::string &icon_file, std::shared_ptr<Text> text, const std::string &sound_file);
 	// [SINGLETON] Destruiremos el objeto notifier con esta función estática
 	static void destroy();
@@ -103,15 +94,8 @@ public:
 	// Actualiza el estado de las notificaiones
 	void update();
-	/**
+	// Muestra una notificación de texto por pantalla
-	 * @brief Muestra una notificación de texto por pantalla.
+	void showText(std::vector<std::string> texts, int icon = -1, const std::string &code = std::string());
 	 *
 	 * @param text1 Primer texto opcional para mostrar (valor predeterminado: cadena vacía).
 	 * @param text2 Segundo texto opcional para mostrar (valor predeterminado: cadena vacía).
 	 * @param icon Icono opcional para mostrar (valor predeterminado: -1).
 	 * @param code Permite asignar un código a la notificación (valor predeterminado: cadena vacía).
 	 */
 	void showText(std::string text1 = std::string(), std::string text2 = std::string(), int icon = -1, std::string code = std::string());
 	// Indica si hay notificaciones activas
 	bool isActive();
--- a/source/on_screen_help.cpp
+++ b/source/on_screen_help.cpp
@@ -1,16 +1,14 @@
 #include "on_screen_help.h"
-#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_pixels.h>    // for SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888
-#include <memory>               // for make_unique, make_shared, unique_ptr
+#include <memory>               // Para make_unique, unique_ptr
-#include "asset.h"              // for Asset
+#include "lang.h"               // Para getText
-#include "lang.h"               // for getText
+#include "param.h"              // Para Param, ParamGame, param
-#include "param.h"              // for param
+#include "resource.h"           // Para Resource
-#include "resource.h"           // for Resource
+#include "screen.h"             // Para Screen
-#include "screen.h"             // for Screen
+#include "sprite.h"             // Para Sprite
-#include "sprite.h"             // for Sprite
+#include "text.h"               // Para Text
-#include "text.h"               // for Text
+#include "utils.h"              // Para easeInOutSine
 #include "texture.h"            // for Texture
 #include "utils.h"              // for easeInOutSine, Param, ParamGame
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 OnScreenHelp *OnScreenHelp::onScreenHelp = nullptr;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Sergio Valor	e0e82ee273	Retocs en Texture::loadPaletteFromFile	2024-11-03 20:43:52 +01:00
Sergio Valor	371c477d0d	Varios arreglos	2024-11-03 20:28:01 +01:00
Sergio Valor	f29eb2f411	Les notificacions ara accepten un vector de cadenes en lloc de una o dos cadenes	2024-11-03 18:12:46 +01:00
Sergio Valor	69a92cba66	Apanyats alguns bugs que quedaven respecte a lo del teclat	2024-11-03 17:25:31 +01:00
Sergio Valor	86cd7b0f16	Ja es pot gastar el teclat com a control independent del primer mando Ja pot jugar un jugador amb teclat i altre amb mando Es pot asignar el teclat a qualsevol dels dos jugadors Continua podentse gastar mando i teclat a l'hora per al mateix jugador	2024-11-03 11:07:58 +01:00
Sergio Valor	a1ccb6102a	Abans de clavar-li ma a Input	2024-11-01 20:01:17 +01:00
Sergio Valor	2dd8bbbbf7	Moguts els checkInputs de Screen a GlobalInputs	2024-11-01 19:07:19 +01:00
Sergio Valor	c66cc965f1	define_buttons ja acaba be de definir els buttons	2024-11-01 18:39:10 +01:00
Sergio Valor	0757f63b73	Eliminat checkModInput	2024-11-01 18:20:18 +01:00
Sergio Valor	80a110e1d7	Abans de llevar checkInputMod	2024-11-01 16:48:03 +01:00
Sergio Valor	cd68c5ffea	Al redefinir botons, ja no pots repetir botó. Util per als qui tenim la ma tremolosa i apretem dos voltes sense voler	2024-11-01 14:32:27 +01:00
Sergio Valor	f786cb7776	Implementat el final del joc	2024-11-01 13:05:11 +01:00
Sergio Valor	2e0d27a95c	Modificats parámetres	2024-11-01 12:56:09 +01:00
Sergio Valor	861a9411d3	Nous textos	2024-11-01 12:55:37 +01:00
Sergio Valor	da27fde366	Millores en la gestió del "mute" en el joc	2024-11-01 07:55:37 +01:00
Sergio Valor	c6e2368e82	Noves animacions per a deixar de disparar	2024-10-31 23:32:11 +01:00
Sergio Valor	30dfa4c545	Treballant en el final del joc	2024-10-31 11:58:01 +01:00
Sergio Valor	7e2691e33e	Finalitzat el Attract Mode	2024-10-30 21:29:23 +01:00
Sergio Valor Martínez	7e918e99f7	Arreglat un include	2024-10-30 13:15:30 +01:00
Sergio Valor	2aa3f827cb	Arreglada la animació de morir, que s'updatava dos voltes per frame	2024-10-30 10:15:53 +01:00
Sergio Valor	06899d95a8	Arreglat el efecte de flash. Estava passant-li un valor massa xicotet	2024-10-30 09:45:57 +01:00
Sergio Valor	20c51d0796	Acabat el nou motor per a textos en pantalla	2024-10-30 09:25:28 +01:00
Sergio Valor	b43782786a	Modificades les linux_utils	2024-10-30 09:25:12 +01:00
Sergio Valor	15554c449f	Nuevos textos para el game_text	2024-10-30 08:19:32 +01:00
Sergio Valor	ba05eab79e	Reduida la dependencia de PathSprite a Sprite Treballant en els missatges de text que ixen durant la partida	2024-10-29 20:05:05 +01:00
Sergio Valor	d83c05bad4	El game_text dels items ja son textures generades i precarregades	2024-10-29 16:04:14 +01:00
Sergio Valor	e2abf835f9	Afegida nova tipografia 04b_25 Eliminades tipografies que no s'utilitzaven La classe Text ara pot tornar una textura amb el text	2024-10-29 15:22:19 +01:00
Sergio Valor	59e2865a4a	El game_text ara gasta PathSprites en lloc d'SmartSprites fix: la paleta dels jugadors no s'iniciava correctament	2024-10-28 22:09:28 +01:00
Sergio Valor	787cb6366f	Pasaeta de include-what-you-use Acabada de perfilar la classe PathSprite Menjeades declaracions de utils.h als fitxers que toca	2024-10-28 20:45:24 +01:00
Sergio Valor	0fe371653a	commit de me ane cap a casa	2024-10-28 13:51:26 +01:00
Sergio Valor	2cffe8dfc9	Merge branch 'main' of https://gitea.sustancia.synology.me/JailDesigner/coffee_crisis_arcade_edition	2024-10-27 22:28:47 +01:00
Sergio Valor	1dd96cfaff	Completada la classe PathSprite	2024-10-27 22:28:44 +01:00
Sergio Valor	d054e188b6	fix: alguns minibugs tontos	2024-10-27 19:04:05 +01:00
Sergio	ca6ff71a46	Actualitzat README.MD	2024-10-27 18:46:42 +01:00
Sergio Valor	b90ac65cfc	Eliminats warnings que nomes es veuen al compilar en macos/linux	2024-10-27 17:45:49 +01:00
Sergio Valor	759adbf6fd	Actualitzat README.MD	2024-10-27 17:09:40 +01:00
Sergio Valor	71f76fda05	Redissenyat el time stopper	2024-10-27 13:36:00 +01:00
Sergio Valor	ddfb3672ea	Afegida la funció createTwoBigBalloons() per a que la partida sempre comence igual	2024-10-26 18:16:23 +02:00
Sergio Valor	6235d0b684	Revisada la classe Balloon	2024-10-26 18:08:04 +02:00
Sergio Valor	f750997b34	Revisant la classe Balloon	2024-10-26 14:13:08 +02:00
Sergio Valor	de2a29b669	Ajustado el game_text para que se dibuje siempre en pantalla, sin clipping	2024-10-26 12:23:04 +02:00
Sergio Valor	f99f908c11	Revisant la classe Balloon	2024-10-26 11:38:08 +02:00
Sergio Valor	d44bfd51de	Balloon: inicialitzades variables en la declaració	2024-10-26 09:09:19 +02:00
Sergio Valor	4f095ab018	Repasada la classe Bullet	2024-10-26 09:01:32 +02:00
Sergio Valor	bffd2bdace	.	2024-10-26 08:11:30 +02:00
Sergio Valor	24d09a2e3c	Millorada la aparició dels game_text	2024-10-24 22:16:57 +02:00
Sergio Valor	caf191672e	Posat ordre en el constructor de Game	2024-10-24 22:08:53 +02:00
Sergio Valor	43e7b83403	Continue arreglant cosetes amb cppcheck	2024-10-24 20:36:30 +02:00
Sergio Valor	a5c72a0f65	Collons, que m'havien stagejat no se que.. ara si, arreglada la carrega d'animacions	2024-10-24 19:58:45 +02:00
Sergio Valor	ca464b2e81	Arreglada la cárrega d'animacions	2024-10-24 19:58:25 +02:00
Sergio Valor	f26ecbd969	Canviat el final de linea als scripts de linux	2024-10-24 18:14:33 +02:00
Sergio Valor	018bb68f9a	Canviat el nom de la carpeta a linux_utils	2024-10-24 17:59:50 +02:00
Sergio Valor	f36ff3d7fe	Actualitzats scripts de linux_utils	2024-10-24 17:53:24 +02:00
Sergio Valor	8f33308f8d	.	2024-10-24 14:03:12 +02:00
Sergio Valor	8c98430b68	.	2024-10-23 22:18:46 +02:00
Sergio Valor	6e2f80d8ce	.	2024-10-23 18:29:52 +02:00
Sergio Valor	95478134dd	Merdetes en la faena, básicament arreglar uns quants iniciadors de variables en les clases	2024-10-23 14:00:19 +02:00
Sergio Valor	528533fd9b	Au, a casa	2024-10-22 13:56:50 +02:00
Sergio Valor	5df85e1b1a	Pasaeta de cppcheck, ale	2024-10-22 09:24:19 +02:00
Sergio Valor	1d0c2e01a5	Varios arreglos d'estil en el codi i llevar metodes que ja no servien	2024-10-21 22:47:00 +02:00
Sergio Valor	236d6f58b6	Nous gràfics per al game_text	2024-10-21 19:29:54 +02:00
Sergio Valor	898b551e06	Paletes noves per al primer café dels jugadors	2024-10-21 18:09:34 +02:00
Sergio Valor	84238032e0	Afegits uns overrides pa agafar parametres per linea de comandos	2024-10-21 17:46:05 +02:00
Sergio Valor	2cb22ed013	fix: els globos tenien un parell de setters mal asignats per culpa de buscar y reemplazar fix: els globos verds s'inicialitzaven amb vy = 0 per gastar abs en lloc de fabs fix: corregit un bug milenari que de sempre havia creat els balloons verds al popar al pare amb la meitat de velocitat en y. Lo que jo no se es com anava res. Supose que ara el joc serà un poc mes xungo. Quan rebotaven en el piso ja se'ls posava la velocitat bona (crec)	2024-10-20 22:58:15 +02:00
Sergio Valor	a3a583deb7	Precàrrega dels fitxers amb dades per al mode demostració	2024-10-20 21:23:04 +02:00
Sergio Valor	b263e0c4be	Modificada la estructura on es guarden els datos de la demo	2024-10-20 20:43:03 +02:00
Sergio Valor	3bf61fc758	fix: no guardar el fitxer de puntuacions en el modo demo	2024-10-20 19:40:09 +02:00
Sergio Valor	2377815c02	Amb les textures en memoria i compartides ja no puc fer el trick de canvi de paleta per a la flama del segon jugador tal i com està plantejat el codi. Arreglat creant una segona textura	2024-10-20 19:38:28 +02:00
Sergio Valor	7434869894	Corregit un fallo amagat baix un ifdef ARCADE. Ja he posat que estiga definit per defecte pa que no torne a passar	2024-10-20 15:43:10 +02:00
Sergio Valor	848d61b5c0	He fet un "manolete" i he pasat a c++ i smartpointers la cárrega de surfaces desde gif. Sembla que no ha petat res Precárrega i asignació de paletes a les textures Ara si algú toca una paleta, que siga conscient que la textura es compartida durant tot el joc	2024-10-20 15:36:04 +02:00
Sergio Valor	cbc9b3f071	Eliminats els últimes defines i passats a enum class	2024-10-20 12:07:55 +02:00
Sergio Valor	8bca5095da	Modificats, estructurats i ben formatats alguns missatges de consola Canvis en els codis d'eixida del programa	2024-10-20 11:37:26 +02:00
		`@@ -1,3 +0,0 @@`
			`#!/bin/bash`

			`valgrind --suppressions=valgrind_exceptions --leak-check=full ~/coffee_crisis_arcade_edition/coffee_crisis_arcade_edition_debug > ~/coffee_crisis_arcade_edition/debug.txt 2>&1`