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
119 changed files with 8357 additions and 8254 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,8 +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
 game.game_text.dest_y
 ## 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/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/player2.gif
+++ b/data/gfx/player/player2.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,30 +32,25 @@ 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) {}
+{
 	if (!animations.empty())
 	{
 		loadFromAnimationsFileBuffer(animations);
 	}
 }
 // Obtiene el indice de la animación a partir del nombre
 int AnimatedSprite::getIndex(const std::string &name)
@@ -110,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)
 {
@@ -226,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()
 {
@@ -249,255 +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 frame_width = 1;
+	int frames_per_row = 1;
-	auto frame_height = 1;
+	int max_tiles = 1;
-	std::ifstream file(file_path);
+	size_t index = 0;
-	std::string line;
+	while (index < source.size())
 	// El fichero se puede abrir
 	if (file.good())
 	{
-		// Procesa el fichero linea a linea
+		std::string line = source.at(index);
-		std::cout << "Animation loaded: " << getFileName(file_path) << std::endl;
+
-		while (std::getline(file, line))
+		// Parsea el fichero para buscar variables y valores
 		if (line != "[animation]")
 		{
-			auto max_tiles = 1;
+			// Encuentra la posición del caracter '='
-			auto frames_per_row = 1;
+			size_t pos = line.find("=");
-			// Si la linea contiene el texto [animation] se realiza el proceso de carga de una animación
+
-			if (line == "[animation]")
+			// 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 " << getFileName(file_path).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
 			if (line != "[animation]")
 			{
 				// Encuentra la posición del caracter '='
 				size_t pos = line.find("=");
 				// Procesa las dos subcadenas
 				if (pos != line.npos)
 				{
 					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 " << getFileName(file_path) << "\n, unknown parameter \"" << line.substr(0, pos) << "\"" << std::endl;
 					}
 					frames_per_row = texture_->getWidth() / frame_width;
 					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 " << getFileName(file_path).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
@@ -507,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,32 +20,30 @@ 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() = default;
@@ -54,34 +51,9 @@ public:
    // 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,11 +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
 #include <fstream>
 #include <string>
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Asset *Asset::asset_ = nullptr;
@@ -38,16 +36,21 @@ void Asset::add(const std::string &file, AssetType type, bool required, bool abs
 // 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)
-        if (getFileName(f.file) == text)
+                           {
-        {
+                               return getFileName(f.file) == text;
-            return f.file;
+                           });
        }
    }
-    std::cout << "Warning: file " << text.c_str() << " not found" << std::endl;
+    if (it != file_list_.end())
-    return "";
+    {
        return it->file;
    }
    else
    {
        std::cout << "Warning: file " << text << " not found" << std::endl;
        return "";
    }
 }
 // Comprueba que existen todos los elementos
--- a/source/asset.h
+++ b/source/asset.h
@@ -1,7 +1,7 @@
 #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
--- a/source/background.cpp
+++ b/source/background.cpp
@@ -1,14 +1,13 @@
 #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 "screen.h"
+#include "sprite.h"             // Para Sprite
-#include "sprite.h"  // for Sprite
+#include "texture.h"            // Para Texture
 #include "texture.h" // for Texture
 // Constructor
 Background::Background()
@@ -248,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
@@ -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
@@ -1,289 +1,131 @@
 #include "balloon.h"
-#include <cmath>			 // for abs
+#include <algorithm>		 // Para clamp
-#include "animated_sprite.h" // for SpriteAnimated
+#include <cmath>			 // Para fabs
-#include "moving_sprite.h"	 // for MovingSprite
+#include "animated_sprite.h" // Para AnimatedSprite
-#include "param.h"			 // for param
+#include "param.h"			 // Para Param, param, ParamBalloon, ParamGame
-#include "sprite.h"			 // for Sprite
+#include "sprite.h"			 // Para Sprite
-#include "texture.h"		 // for Texture
+#include "texture.h"		 // Para Texture
 // Constructor
-Balloon::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::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)
 	: sprite_(std::make_unique<AnimatedSprite>(texture, animation)),
-	  pos_x_(x),
+	  x_(x),
-	  pos_y_(y),
+	  y_(y),
-	  vel_x_(vel_x),
+	  vx_(vel_x),
 	  being_created_(creation_timer > 0),
 	  invulnerable_(creation_timer > 0),
 	  stopped_(creation_timer > 0),
 	  creation_counter_(creation_timer),
 	  creation_counter_ini_(creation_timer),
-	  kind_(kind),
+	  type_(type),
 	  size_(size),
 	  speed_(speed)
 {
-
+	switch (type_)
 	switch (kind_)
 	{
-	case BALLOON_1:
+	case BalloonType::BALLOON:
-		// Alto y ancho del objeto
+	{
-		width_ = BALLOON_WIDTH_1;
+		vy_ = 0;
-		height_ = BALLOON_WIDTH_1;
+		max_vy_ = 3.0f;
 		size_ = BALLOON_SIZE_1;
 		power_ = 1;
-		// Inicializa los valores de velocidad y gravedad
+		const int index = static_cast<int>(size_);
-		vel_y_ = 0;
+		gravity_ = param.balloon.at(index).grav;
-		max_vel_y_ = 3.0f;
+		default_vy_ = param.balloon.at(index).vel;
-		gravity_ = param.balloon_1.grav;
+		h_ = w_ = BALLOON_SIZE[index];
-		default_vel_y_ = param.balloon_1.vel;
+		power_ = BALLOON_POWER[index];
-
+		menace_ = BALLOON_MENACE[index];
-		// Puntos que da el globo al ser destruido
+		score_ = BALLOON_SCORE[index];
 		score_ = BALLOON_SCORE_1;
 		// Amenaza que genera el globo
 		menace_ = 1;
 		break;
 	}
-	case BALLOON_2:
+	case BalloonType::FLOATER:
-		// Alto y ancho del objeto
+	{
-		width_ = BALLOON_WIDTH_2;
+		default_vy_ = max_vy_ = vy_ = fabs(vx_ * 2.0f);
 		height_ = BALLOON_WIDTH_2;
 		size_ = BALLOON_SIZE_2;
 		power_ = 3;
 		// Inicializa los valores de velocidad y gravedad
 		vel_y_ = 0;
 		max_vel_y_ = 3.0f;
 		gravity_ = param.balloon_2.grav;
 		default_vel_y_ = param.balloon_2.vel;
 		// Puntos que da el globo al ser destruido
 		score_ = BALLOON_SCORE_2;
 		// Amenaza que genera el globo
 		menace_ = 2;
 		break;
 	case BALLOON_3:
 		// Alto y ancho del objeto
 		width_ = BALLOON_WIDTH_3;
 		height_ = BALLOON_WIDTH_3;
 		size_ = BALLOON_SIZE_3;
 		power_ = 7;
 		// Inicializa los valores de velocidad y gravedad
 		vel_y_ = 0;
 		max_vel_y_ = 3.0f;
 		gravity_ = param.balloon_3.grav;
 		default_vel_y_ = param.balloon_3.vel;
 		// Puntos que da el globo al ser destruido
 		score_ = BALLOON_SCORE_3;
 		// Amenaza que genera el globo
 		menace_ = 4;
 		break;
 	case BALLOON_4:
 		// Alto y ancho del objeto
 		width_ = BALLOON_WIDTH_4;
 		height_ = BALLOON_WIDTH_4;
 		size_ = BALLOON_SIZE_4;
 		power_ = 15;
 		// Inicializa los valores de velocidad y gravedad
 		vel_y_ = 0;
 		max_vel_y_ = 3.0f;
 		gravity_ = param.balloon_4.grav;
 		default_vel_y_ = param.balloon_4.vel;
 		// Puntos que da el globo al ser destruido
 		score_ = BALLOON_SCORE_4;
 		// Amenaza que genera el globo
 		menace_ = 8;
 		break;
 	case HEXAGON_1:
 		// Alto y ancho del objeto
 		width_ = BALLOON_WIDTH_1;
 		height_ = BALLOON_WIDTH_1;
 		size_ = BALLOON_SIZE_1;
 		power_ = 1;
 		// Inicializa los valores de velocidad y gravedad
 		vel_y_ = fabs(vel_x_ * 2.0f);
 		max_vel_y_ = vel_y_;
 		gravity_ = 0.00f;
 		default_vel_y_ = vel_y_;
-		// Puntos que da el globo al ser destruido
+		const int index = static_cast<int>(size_);
-		score_ = BALLOON_SCORE_1;
+		h_ = w_ = BALLOON_SIZE[index];
-
+		power_ = BALLOON_POWER[index];
-		// Amenaza que genera el globo
+		menace_ = BALLOON_MENACE[index];
-		menace_ = 1;
+		score_ = BALLOON_SCORE[index];
 		break;
 	}
-	case HEXAGON_2:
+	case BalloonType::POWERBALL:
-		// Alto y ancho del objeto
+	{
-		width_ = BALLOON_WIDTH_2;
+		const int index = 3;
-		height_ = BALLOON_WIDTH_2;
+		h_ = w_ = BALLOON_SIZE[index];
-		size_ = BALLOON_SIZE_2;
+		power_ = score_ = menace_ = 0;
 		power_ = 3;
-		// Inicializa los valores de velocidad y gravedad
+		vy_ = 0;
-		vel_y_ = fabs(vel_x_ * 2.0f);
+		max_vy_ = 3.0f;
-		max_vel_y_ = vel_y_;
+		gravity_ = param.balloon.at(index).grav;
-		gravity_ = 0.00f;
+		default_vy_ = param.balloon.at(index).vel;
 		default_vel_y_ = vel_y_;
 		// Puntos que da el globo al ser destruido
 		score_ = BALLOON_SCORE_2;
 		// Amenaza que genera el globo
 		menace_ = 2;
 		break;
 	case HEXAGON_3:
 		// Alto y ancho del objeto
 		width_ = BALLOON_WIDTH_3;
 		height_ = BALLOON_WIDTH_3;
 		size_ = BALLOON_SIZE_3;
 		power_ = 7;
 		// Inicializa los valores de velocidad y gravedad
 		vel_y_ = fabs(vel_x_ * 2.0f);
 		max_vel_y_ = vel_y_;
 		gravity_ = 0.00f;
 		default_vel_y_ = vel_y_;
 		// Puntos que da el globo al ser destruido
 		score_ = BALLOON_SCORE_3;
 		// Amenaza que genera el globo
 		menace_ = 4;
 		break;
 	case HEXAGON_4:
 		// Alto y ancho del objeto
 		width_ = BALLOON_WIDTH_4;
 		height_ = BALLOON_WIDTH_4;
 		size_ = BALLOON_SIZE_4;
 		power_ = 15;
 		// Inicializa los valores de velocidad y gravedad
 		vel_y_ = fabs(vel_x_ * 2.0f);
 		max_vel_y_ = vel_y_;
 		gravity_ = 0.00f;
 		default_vel_y_ = vel_y_;
 		// Puntos que da el globo al ser destruido
 		score_ = BALLOON_SCORE_4;
 		// Amenaza que genera el globo
 		menace_ = 8;
 		break;
 	case POWER_BALL:
 		// Alto y ancho del objeto
 		width_ = BALLOON_WIDTH_4;
 		height_ = BALLOON_WIDTH_4;
 		size_ = 4;
 		power_ = 0;
 		// Inicializa los valores de velocidad y gravedad
 		vel_y_ = 0;
 		max_vel_y_ = 3.0f;
 		gravity_ = param.balloon_4.grav;
 		default_vel_y_ = param.balloon_4.vel;
 		// Puntos que da el globo al ser destruido
 		score_ = 0;
 		// Amenaza que genera el globo
 		menace_ = 0;
 		// Añade rotación al sprite_
 		sprite_->disableRotate();
 		sprite_->setRotateSpeed(0);
-		vel_x_ > 0.0f ? sprite_->setRotateAmount(2.0) : sprite_->setRotateAmount(-2.0);
+		sprite_->setRotateAmount(vx_ > 0.0f ? 2.0 : -2.0);
 		break;
 	}
 	default:
 		break;
 	}
 	// Configura el sprite
-	sprite_->setPos({static_cast<int>(pos_x_), static_cast<int>(pos_y_), width_, height_});
+	sprite_->setWidth(w_);
 	sprite_->setHeight(h_);
 	shiftSprite();
 	// Alinea el circulo de colisión con el objeto
-	updateColliders();
+	collider_.r = w_ / 2;
 	shiftColliders();
 	// Establece la animación a usar
 	setAnimation();
 }
 // Centra el globo en la posición X
-void Balloon::allignTo(int x)
+void Balloon::alignTo(int x)
 {
-	pos_x_ = float(x - (width_ / 2));
+	x_ = static_cast<float>(x - (w_ / 2));
-
+	const int min_x = param.game.play_area.rect.x;
-	if (pos_x_ < param.game.play_area.rect.x)
+	const int max_x = param.game.play_area.rect.w - w_;
-	{
+	x_ = std::clamp(x_, static_cast<float>(min_x), static_cast<float>(max_x));
 		pos_x_ = param.game.play_area.rect.x + 1;
 	}
 	else if ((pos_x_ + width_) > param.game.play_area.rect.w)
 	{
 		pos_x_ = float(param.game.play_area.rect.w - width_ - 1);
 	}
 	// Posición X,Y del sprite_
 	sprite_->setPosX(getPosX());
 	sprite_->setPosY(getPosY());
 	// Alinea el circulo de colisión con el objeto
 	updateColliders();
 }
 // Pinta el globo en la pantalla
 void Balloon::render()
 {
-	if (visible_ && enabled_)
+	if (isBeingCreated())
 	{
 		// Aplica alpha blending
 		sprite_->getTexture()->setAlpha(255 - (int)((float)creation_counter_ * (255.0f / (float)creation_counter_ini_)));
 		sprite_->render();
 		sprite_->getTexture()->setAlpha(255);
 	}
 	else
 	{
 		if (bouncing_.enabled)
 		{
-			if (kind_ != POWER_BALL)
+			// Aplica efecto de bouncing
-			{
+			sprite_->setPos(x_ + bouncing_.despX, y_ + bouncing_.despY);
 				// Aplica desplazamiento para el zoom
 				sprite_->setPosX(getPosX() + bouncing_.despX);
 				sprite_->setPosY(getPosY() + bouncing_.despY);
 				sprite_->render();
 				sprite_->setPosX(getPosX() - bouncing_.despX);
 				sprite_->setPosY(getPosY() - bouncing_.despY);
 			}
 		}
 		else if (isBeingCreated())
 		{
 			// Aplica alpha blending
 			sprite_->getTexture()->setAlpha(255 - (int)((float)creation_counter_ * (255.0f / (float)creation_counter_ini_)));
 			sprite_->render();
-			sprite_->getTexture()->setAlpha(255);
+			sprite_->setPos(x_ - bouncing_.despX, y_ - bouncing_.despY);
 		}
 		else
 		{
 			sprite_->render();
-		}
+	}
-		if (kind_ == POWER_BALL && !isBeingCreated())
+	// Añade la máscara del borde a la PowerBall
-		{
+	if (type_ == BalloonType::POWERBALL && !isBeingCreated())
-			auto sp = std::make_unique<Sprite>(sprite_->getTexture(), sprite_->getPosition());
+	{
-			sp->setSpriteClip(BALLOON_WIDTH_4, 0, BALLOON_WIDTH_4, BALLOON_WIDTH_4);
+		auto sp = std::make_unique<Sprite>(sprite_->getTexture(), sprite_->getPosition());
-			sp->render();
+		sp->setSpriteClip(BALLOON_SIZE[3], 0, BALLOON_SIZE[3], BALLOON_SIZE[3]);
-		}
+		sp->render();
 	}
 }
@@ -293,61 +135,45 @@ void Balloon::move()
 	// Comprueba si se puede mover
 	if (!isStopped())
 	{
-		// Lo mueve a izquierda o derecha
+		// Mueve el globo en horizontal
-		pos_x_ += (vel_x_ * speed_);
+		x_ += vx_ * speed_;
-		// Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido
+		// Colisión en las partes laterales de la zona de juego
-		if ((pos_x_ < param.game.play_area.rect.x) || (pos_x_ + width_ > param.game.play_area.rect.w))
+		const int clip = 2;
 		const float min_x = param.game.play_area.rect.x - clip;
 		const float max_x = param.game.play_area.rect.w - w_ + clip;
 		if (x_ < min_x || x_ > max_x)
 		{
-			// Corrige posición
+			x_ = std::clamp(x_, min_x, max_x);
-			pos_x_ -= (vel_x_ * speed_);
+			vx_ = -vx_;
-
+			// Activa el efecto de rebote o invierte la rotación
-			// Invierte sentido
+			if (type_ == BalloonType::POWERBALL)
-			vel_x_ = -vel_x_;
+				sprite_->switchRotate();
-
+			else
-			// Invierte la rotación
+				enableBounce();
 			sprite_->switchRotate();
 			// Activa el efecto de rebote
 			if (kind_ != POWER_BALL)
 			{
 				bounceStart();
 			}
 		}
-		// Mueve el globo hacia arriba o hacia abajo
+		// Mueve el globo en vertical
-		pos_y_ += (vel_y_ * speed_);
+		y_ += vy_ * speed_;
-		// Si se sale por arriba
+		// Colisión en la parte superior de la zona de juego
-		if (pos_y_ < param.game.play_area.rect.y)
+		const int min_y = param.game.play_area.rect.y;
 		if (y_ < min_y)
 		{
-			// Corrige
+			y_ = min_y;
-			pos_y_ = param.game.play_area.rect.y;
+			vy_ = -vy_;
-
+			if (type_ != BalloonType::POWERBALL)
-			// Invierte sentido
+				enableBounce();
 			vel_y_ = -vel_y_;
 			// Activa el efecto de rebote
 			if (kind_ != POWER_BALL)
 			{
 				bounceStart();
 			}
 		}
-		// Si el globo se sale por la parte inferior
+		// Colisión en la parte inferior de la zona de juego
-		if (pos_y_ + height_ > param.game.play_area.rect.h)
+		const int max_y = param.game.play_area.rect.h - h_;
 		if (y_ > max_y)
 		{
-			// Corrige
+			y_ = max_y;
-			pos_y_ = param.game.play_area.rect.h - height_;
+			vy_ = -default_vy_;
-
+			if (type_ != BalloonType::POWERBALL)
-			// Invierte colocando una velocidad por defecto
+				enableBounce();
 			vel_y_ = -default_vel_y_;
 			// Activa el efecto de rebote
 			if (kind_ != POWER_BALL)
 			{
 				bounceStart();
 			}
 		}
 		/*
@@ -369,69 +195,27 @@ void Balloon::move()
 			travel_y_ -= 1.0f;
 			// Aplica la gravedad al objeto sin pasarse de una velocidad máxima
-			vel_y_ += gravity_;
+			vy_ += gravity_;
 		}
 		// Actualiza la posición del sprite_
 		sprite_->setPosX(getPosX());
 		sprite_->setPosY(getPosY());
 	}
 }
-// Deshabilita el globo y pone a cero todos los valores
+// Deshabilita el globo
-void Balloon::disable()
+void Balloon::disable() { enabled_ = false; }
 {
 	being_created_ = false;
 	blinking_ = false;
 	collider_.r = 0;
 	collider_.x = 0;
 	collider_.y = 0;
 	counter_ = 0;
 	creation_counter_ = 0;
 	creation_counter_ini_ = 0;
 	default_vel_y_ = 0.0f;
 	enabled_ = false;
 	gravity_ = 0.0f;
 	height_ = 0;
 	invulnerable_ = false;
 	kind_ = 0;
 	max_vel_y_ = 0.0f;
 	menace_ = 0;
 	pos_x_ = 0.0f;
 	pos_y_ = 0.0f;
 	power_ = 0;
 	score_ = 0;
 	size_ = 0;
 	speed_ = 0;
 	stopped_ = false;
 	stopped_counter_ = 0;
 	travel_y_ = 0;
 	vel_x_ = 0.0f;
 	vel_y_ = 0.0f;
 	visible_ = false;
 	width_ = 0;
 	sprite_->clear();
 }
 // Explosiona el globo
-void Balloon::pop()
+void Balloon::pop() { disable(); }
 {
 	disable();
 }
 // Actualiza al globo a su posicion, animación y controla los contadores
 void Balloon::update()
 {
-	if (enabled_)
+	move();
-	{
+	updateState();
-		sprite_->update();
+	updateBounce();
-		move();
+	shiftSprite();
-		updateAnimation();
+	shiftColliders();
-		updateColliders();
+	sprite_->update();
-		updateState();
+	++counter_;
 		updateBounce();
 		++counter_;
 	}
 }
 // Actualiza los estados del globo
@@ -441,335 +225,180 @@ void Balloon::updateState()
 	if (isBeingCreated())
 	{
 		// Actualiza el valor de las variables
-		setStop(true);
+		stop();
 		setInvulnerable(true);
 		// Todavia tiene tiempo en el contador
 		if (creation_counter_ > 0)
 		{
 			// Desplaza lentamente el globo hacia abajo y hacia un lado
 			if (creation_counter_ % 10 == 0)
 			{
-				pos_y_++;
+				y_++;
-				pos_x_ += vel_x_;
+				x_ += vx_;
 				// Comprueba no se salga por los laterales
-				if ((pos_x_ < param.game.play_area.rect.x) || (pos_x_ > (param.game.play_area.rect.w - width_)))
+				const int min_x = param.game.play_area.rect.x;
 				const int max_x = param.game.play_area.rect.w - w_;
 				if (x_ < min_x || x_ > max_x)
 				{
 					// Corrige y cambia el sentido de la velocidad
-					pos_x_ -= vel_x_;
+					x_ -= vx_;
-					vel_x_ = -vel_x_;
+					vx_ = -vx_;
 				}
 				// Actualiza la posición del sprite_
 				sprite_->setPosX(getPosX());
 				sprite_->setPosY(getPosY());
 				// Actualiza la posición del circulo de colisión
 				updateColliders();
 			}
-
+			--creation_counter_;
 			creation_counter_--;
 		}
-		// El contador ha llegado a cero
+
 		else
 		{
-			setBeingCreated(false);
+			// El contador ha llegado a cero
-			setStop(false);
+			being_created_ = false;
-			setVisible(true);
+			start();
 			setInvulnerable(false);
-			if (kind_ == POWER_BALL)
+			setAnimation();
 			{
 				sprite_->enableRotate();
 			}
 		}
 	}
 	// Solo comprueba el estado detenido cuando no se está creando
 	else if (isStopped())
 	{
 		// Si es una powerball deja de rodar
 		if (kind_ == POWER_BALL)
 		{
 			sprite_->disableRotate();
 		}
 		// Reduce el contador
 		if (stopped_counter_ > 0)
 		{
 			stopped_counter_--;
 		}
 		// Si el contador ha llegado a cero
 		else
 		{ // Quitarles el estado "detenido"
 			setStop(false);
 			// Si es una powerball vuelve a rodar
 			if (kind_ == POWER_BALL)
 			{
 				sprite_->enableRotate();
 			}
 		}
 	}
 }
 // Establece la animación correspondiente al estado
-void Balloon::updateAnimation()
+void Balloon::setAnimation()
 {
-	std::string creating_animation = "blue";
+	std::string creating_animation;
-	std::string normal_animation = "orange";
+	std::string normal_animation;
-	if (kind_ == POWER_BALL)
+	switch (type_)
 	{
 	case BalloonType::POWERBALL:
 		creating_animation = "powerball";
 		normal_animation = "powerball";
-	}
+		break;
-	else if (getClass() == HEXAGON_CLASS)
+	case BalloonType::FLOATER:
 	{
 		creating_animation = "red";
 		normal_animation = "green";
 		break;
 	default:
 		creating_animation = "blue";
 		normal_animation = "orange";
 		break;
 	}
 	// Establece el frame de animación
-	if (isBeingCreated())
+	if (use_reversed_colors_)
 	{
 		sprite_->setCurrentAnimation(creating_animation);
 	}
 	else
-	{
+		sprite_->setCurrentAnimation(isBeingCreated() ? creating_animation : normal_animation);
 		sprite_->setCurrentAnimation(normal_animation);
 	}
 	sprite_->update();
 }
-// Comprueba si el globo está habilitado
+// Detiene el globo
-bool Balloon::isEnabled() const
+void Balloon::stop()
 {
-	return enabled_;
+	stopped_ = true;
 	if (type_ == BalloonType::POWERBALL)
 		sprite_->disableRotate();
 }
-// Obtiene del valor de la variable
+// Pone el globo en movimiento
-float Balloon::getPosX() const
+void Balloon::start()
 {
-	return pos_x_;
+	stopped_ = false;
-}
+	if (type_ == BalloonType::POWERBALL)
-
+		sprite_->enableRotate();
 // Obtiene del valor de la variable
 float Balloon::getPosY() const
 {
 	return pos_y_;
 }
 // Obtiene del valor de la variable
 float Balloon::getVelY() const
 {
 	return vel_y_;
 }
 // Obtiene del valor de la variable
 int Balloon::getWidth() const
 {
 	return width_;
 }
 // Obtiene del valor de la variable
 int Balloon::getHeight() const
 {
 	return height_;
 }
 // Establece el valor de la variable
 void Balloon::setVelY(float vel_y)
 {
 	vel_y_ = vel_y;
 }
 // Establece el valor de la variable
 void Balloon::setSpeed(float speed)
 {
 	speed_ = speed;
 }
 // Obtiene del valor de la variable
 int Balloon::getKind() const
 {
 	return kind_;
 }
 // Obtiene del valor de la variable
 Uint8 Balloon::getSize() const
 {
 	return size_;
 }
 // Obtiene la clase a la que pertenece el globo
 Uint8 Balloon::getClass() const
 {
 	if ((kind_ >= BALLOON_1) && (kind_ <= BALLOON_4))
 	{
 		return BALLOON_CLASS;
 	}
 	else if ((kind_ >= HEXAGON_1) && (kind_ <= HEXAGON_4))
 	{
 		return HEXAGON_CLASS;
 	}
 	return BALLOON_CLASS;
 }
 // Establece el valor de la variable
 void Balloon::setStop(bool state)
 {
 	stopped_ = state;
 }
 // Obtiene del valor de la variable
 bool Balloon::isStopped() const
 {
 	return stopped_;
 }
 // Establece el valor de la variable
 void Balloon::setBlink(bool value)
 {
 	blinking_ = value;
 }
 // Obtiene del valor de la variable
 bool Balloon::isBlinking() const
 {
 	return blinking_;
 }
 // Establece el valor de la variable
 void Balloon::setVisible(bool value)
 {
 	visible_ = value;
 }
 // Obtiene del valor de la variable
 bool Balloon::isVisible() const
 {
 	return visible_;
 }
 // Establece el valor de la variable
 void Balloon::setInvulnerable(bool value)
 {
 	invulnerable_ = value;
 }
 // Obtiene del valor de la variable
 bool Balloon::isInvulnerable() const
 {
 	return invulnerable_;
 }
 // Establece el valor de la variable
 void Balloon::setBeingCreated(bool value)
 {
 	being_created_ = value;
 }
 // Obtiene del valor de la variable
 bool Balloon::isBeingCreated() const
 {
 	return being_created_;
 }
 // Establece el valor de la variable
 void Balloon::setStoppedTimer(Uint16 time)
 {
 	stopped_counter_ = time;
 }
 // Obtiene del valor de la variable
 Uint16 Balloon::getStoppedTimer() const
 {
 	return stopped_counter_;
 }
 // Obtiene del valor de la variable
 Uint16 Balloon::getScore() const
 {
 	return score_;
 }
 // Obtiene el circulo de colisión
 Circle &Balloon::getCollider()
 {
 	return collider_;
 }
 // Alinea el circulo de colisión con la posición del objeto globo
-void Balloon::updateColliders()
+void Balloon::shiftColliders()
 {
-	collider_.x = static_cast<int>(pos_x_ + collider_.r);
+	collider_.x = static_cast<int>(x_) + collider_.r;
-	collider_.y = static_cast<int>(pos_y_ + collider_.r);
+	collider_.y = static_cast<int>(y_) + collider_.r;
 }
-// Obtiene le valor de la variable
+// Alinea el sprite con la posición del objeto globo
-Uint8 Balloon::getMenace() const
+void Balloon::shiftSprite()
 {
-	return isEnabled() ? menace_ : 0;
+	sprite_->setPosX(x_);
 	sprite_->setPosY(y_);
 }
-// Obtiene le valor de la variable
+// Establece el nivel de zoom del sprite
-Uint8 Balloon::getPower() const
+void Balloon::zoomSprite()
 {
-	return power_;
+	sprite_->setZoomW(bouncing_.zoomW);
 	sprite_->setZoomH(bouncing_.zoomH);
 }
-void Balloon::bounceStart()
+// Activa el efecto
 void Balloon::enableBounce()
 {
 	bouncing_.enabled = true;
-	bouncing_.zoomW = 1;
+	bouncing_.reset();
-	bouncing_.zoomH = 1;
+	zoomSprite();
 	sprite_->setZoomW(bouncing_.zoomW);
 	sprite_->setZoomH(bouncing_.zoomH);
 	bouncing_.despX = 0;
 	bouncing_.despY = 0;
 }
-void Balloon::bounceStop()
+// Detiene el efecto
 void Balloon::disableBounce()
 {
 	bouncing_.enabled = false;
-	bouncing_.counter = 0;
+	bouncing_.reset();
-	bouncing_.zoomW = 1.0f;
+	zoomSprite();
 	bouncing_.zoomH = 1.0f;
 	sprite_->setZoomW(bouncing_.zoomW);
 	sprite_->setZoomH(bouncing_.zoomH);
 	bouncing_.despX = 0.0f;
 	bouncing_.despY = 0.0f;
 }
 // Aplica el efecto
 void Balloon::updateBounce()
 {
 	if (bouncing_.enabled)
 	{
-		bouncing_.zoomW = bouncing_.w[bouncing_.counter / bouncing_.speed];
+		const int index = bouncing_.counter / bouncing_.speed;
-		bouncing_.zoomH = bouncing_.h[bouncing_.counter / bouncing_.speed];
+		bouncing_.zoomW = bouncing_.w[index];
-		sprite_->setZoomW(bouncing_.zoomW);
+		bouncing_.zoomH = bouncing_.h[index];
-		sprite_->setZoomH(bouncing_.zoomH);
+
-		bouncing_.despX = (sprite_->getSpriteClip().w - (sprite_->getSpriteClip().w * bouncing_.zoomW));
+		zoomSprite();
-		bouncing_.despY = (sprite_->getSpriteClip().h - (sprite_->getSpriteClip().h * bouncing_.zoomH));
+
-		++bouncing_.counter;
+		const auto spriteClip = sprite_->getSpriteClip();
-		if ((bouncing_.counter / bouncing_.speed) > (MAX_BOUNCE - 1))
+		bouncing_.despX = spriteClip.w * (1.0f - bouncing_.zoomW);
-		{
+		bouncing_.despY = spriteClip.h * (1.0f - bouncing_.zoomH);
-			bounceStop();
+
-		}
+		if (++bouncing_.counter / bouncing_.speed >= MAX_BOUNCE)
 			disableBounce();
 	}
 }
-// Indica si el globo se puede explotar
+// Pone el color alternativo en el globo
-bool Balloon::canBePopped() const
+void Balloon::useReverseColor()
 {
-	return isEnabled() && !isBeingCreated();
+	if (!isBeingCreated())
 	{
 		use_reversed_colors_ = true;
 		setAnimation();
 	}
 }
-// Indica si el globo se puede destruir
+// Pone el color normal en el globo
-bool Balloon::canBeDestroyed() const
+void Balloon::useNormalColor()
 {
-	return isEnabled();
+	use_reversed_colors_ = false;
-}
+	setAnimation();
 }
 // Getters
 float Balloon::getPosX() const { return x_; }
 float Balloon::getPosY() const { return y_; }
 int Balloon::getWidth() const { return w_; }
 int Balloon::getHeight() const { return h_; }
 BalloonSize Balloon::getSize() const { return size_; }
 BalloonType Balloon::getType() const { return type_; }
 Uint16 Balloon::getScore() const { return score_; }
 Circle &Balloon::getCollider() { return collider_; }
 Uint8 Balloon::getMenace() const { return isEnabled() ? menace_ : 0; }
 Uint8 Balloon::getPower() const { return power_; }
 bool Balloon::isStopped() const { return stopped_; }
 bool Balloon::isInvulnerable() const { return invulnerable_; }
 bool Balloon::isBeingCreated() const { return being_created_; }
 bool Balloon::isEnabled() const { return enabled_; }
 bool Balloon::isUsingReversedColor() { return use_reversed_colors_; }
 bool Balloon::canBePopped() const { return !isBeingCreated(); }
 // Setters
 void Balloon::setVelY(float vel_y) { vy_ = vel_y; }
 void Balloon::setSpeed(float speed) { speed_ = speed; }
 void Balloon::setInvulnerable(bool value) { invulnerable_ = value; }
--- 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,65 +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 = false; // Si el efecto está activo
-		Uint8 counter = 0;	  // Countador para el efecto
+		Uint8 counter = 0;	  // Contador para el efecto
 		Uint8 speed = 2;	  // Velocidad a la que transcurre el efecto
 		float zoomW = 1.0f;	  // Zoom aplicado a la anchura
 		float zoomH = 1.0f;	  // Zoom aplicado a la altura
 		float despX = 0.0f;	  // Desplazamiento de pixeles en el eje X antes de pintar el objeto con zoom
 		float despY = 0.0f;	  // Desplazamiento de pixeles en el eje Y antes de pintar el objeto con zoom
-		std::vector<float> w = {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 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
-		std::vector<float> h = {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
+		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() {}
+		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_ = false;						 // Indica si el globo está intermitente
+	bool enabled_ = true;			   // Indica si el globo esta activo
-	bool enabled_ = true;						 // 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_ = true;						 // 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_ = true;						 // Indica si el globo es visible
+	Circle collider_;				   // Circulo de colisión del objeto
-	Circle collider_ = Circle(0, 0, width_ / 2); // 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_ = 0;				 // 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_ = 0;						 // Contador interno
+	float travel_y_ = 1.0f;			   // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
-	float travel_y_ = 1.0f;						 // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
+	float speed_;					   // Velocidad a la que se mueven los globos
-	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_ = 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();
@@ -138,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();
@@ -168,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,28 +16,28 @@ 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] = BalloonFormationParams();
+			balloon_formation_[j].init[i] = BalloonFormationParams();
 		}
 	}
@@ -56,7 +56,7 @@ 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);
 	}
@@ -67,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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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);
 	}
 	// #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++)
 	{
@@ -345,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);
 	}
 	// #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++)
 	{
@@ -370,13 +370,13 @@ void BalloonFormations::initBalloonFormations()
 			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++)
 	{
@@ -394,13 +394,13 @@ void BalloonFormations::initBalloonFormations()
 			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++)
 	{
@@ -418,7 +418,7 @@ void BalloonFormations::initBalloonFormations()
 			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
@@ -441,7 +441,7 @@ void BalloonFormations::initBalloonFormations()
 			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
@@ -464,7 +464,7 @@ void BalloonFormations::initBalloonFormations()
 			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
@@ -477,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;
 		}
 	}
@@ -487,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;
 }
@@ -513,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
@@ -641,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,40 +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 = 0;                // 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 = 0;                // 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 = 0.0f;       // Velocidad inicial en el eje X
+    float vel_x = 0.0f;                      // Velocidad inicial en el eje X
-    int kind = 0;             // Tipo de enemigo
+    BalloonType type = BalloonType::BALLOON; // Tipo de globo
-    int creation_counter = 0; // 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 que inicializa todos los campos con valores proporcionados o predeterminados
+    // Constructor por defecto
-    explicit BalloonFormationParams(int x_val = 0, int y_val = 0, float vel_x_val = 0.0f, int kind_val = 0, int creation_counter_val = 0)
+    BalloonFormationParams() = default;
-        : x(x_val), y(y_val), vel_x(vel_x_val), kind(kind_val), creation_counter(creation_counter_val) {}
+
    // 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
@@ -42,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,12 +1,11 @@
 #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_)
@@ -17,11 +16,7 @@ DefineButtons::DefineButtons(std::unique_ptr<Text> text_)
    x_ = param.game.width / 2;
    y_ = param.title.press_start_position;
-    buttons_.emplace_back(lang::getText(95), InputType::FIRE_LEFT, SDL_CONTROLLER_BUTTON_X);
+    clearButtons();
    buttons_.emplace_back(lang::getText(96), InputType::FIRE_CENTER, SDL_CONTROLLER_BUTTON_Y);
    buttons_.emplace_back(lang::getText(97), InputType::FIRE_RIGHT, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER);
    buttons_.emplace_back(lang::getText(98), InputType::START, SDL_CONTROLLER_BUTTON_START);
    buttons_.emplace_back(lang::getText(99), InputType::EXIT, SDL_CONTROLLER_BUTTON_BACK);
    for (int i = 0; i < input_->getNumControllers(); ++i)
    {
@@ -34,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_)
    {
@@ -82,13 +79,11 @@ void DefineButtons::checkInput()
                section::options = section::Options::QUIT_WITH_KEYBOARD;
                break;
            }
            case SDL_CONTROLLERBUTTONDOWN:
            {
-                doControllerButtonDown(&event.cbutton);
+                doControllerButtonDown(event.cbutton);
                break;
            }
            default:
                break;
            }
@@ -104,6 +99,7 @@ bool DefineButtons::enable(int index)
        enabled_ = true;
        index_controller_ = index;
        index_button_ = 0;
        clearButtons();
        return true;
    }
@@ -111,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();
@@ -130,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;
    }
 }
@@ -143,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,13 +1,14 @@
 #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
 {
@@ -33,15 +34,15 @@ private:
    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_ = 0;                  // Indice del controlador a reasignar
+    size_t index_controller_ = 0;               // Indice del controlador a reasignar
-    int index_button_ = 0;                      // 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();
@@ -49,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);
@@ -59,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);
@@ -86,45 +98,29 @@ Director::Director(int argc, const char *argv[])
 #else
 	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);
 		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();
 }
@@ -192,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)
@@ -227,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
@@ -262,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_)
 		{
@@ -305,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_)
@@ -318,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);
 			}
 		}
@@ -425,14 +431,6 @@ void Director::setFileList()
 		Asset::get()->add(prefix + "/data/gfx/game/game_sky_colors.png", AssetType::BITMAP);
 	}
 	{ // Game Text
 		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_1000_points.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_2500_points.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_5000_points.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_powerup.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_one_hit.png", AssetType::BITMAP);
 	}
 	{ // Intro
 		Asset::get()->add(prefix + "/data/gfx/intro/intro.png", AssetType::BITMAP);
 	}
@@ -492,16 +490,12 @@ void Director::setFileList()
 	Asset::get()->add(prefix + "/data/font/8bithud.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/8bithud.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/nokia.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/nokia_big2.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/nokia.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/nokia2.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/nokia2.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/nokia_big2.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/smb2_big.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/smb2_big.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/smb2.gif", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/smb2_palette1.pal", AssetType::PALETTE);
 	Asset::get()->add(prefix + "/data/font/smb2.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/04b_25.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/04b_25.txt", AssetType::FONT);
 	// Textos
 	Asset::get()->add(prefix + "/data/lang/es_ES.txt", AssetType::LANG);
@@ -513,40 +507,22 @@ 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[])
 {
 	const std::vector<std::string> argument_list = {"--h", "--320x240", "--clear_score"};
 	// Establece la ruta del programa
 	executable_path_ = argv[0];
 	// Comprueba el resto de parámetros
 	for (int i = 1; i < argc; ++i)
 	{
-		if (strcmp(argv[i], "--h") == 0)
+		std::string arg = argv[i];
 		{
 			for (const auto &argument : argument_list)
 			{
 				std::cout << argument << std::endl;
 			}
 			// std::exit(EXIT_SUCCESS);
 			section::name = section::Name::QUIT;
 			section::options = section::Options::QUIT_FROM_EVENT;
 		}
-		if (strcmp(argv[i], "--320x240") == 0)
+		if (arg == "--320x240")
 		{
-			overrides.param_file = argv[i];
+			overrides.param_file = arg;
 		}
-
+		else if (arg == "--clear_score")
 		if (strcmp(argv[i], "--clear_score") == 0)
 		{
 			overrides.clear_hi_score_table = true;
 		}
@@ -638,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();
 }
@@ -676,54 +656,57 @@ 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_WITH_CONTROLLER)
+	{
-		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_WITH_KEYBOARD) ? "with keyboard" : (section::options == section::Options::QUIT_WITH_CONTROLLER) ? "with controller"
 																																										 : "from event";
 	std::cout << "\nGame end " << return_code << std::endl;
 #ifndef VERBOSE
 	// Habilita de nuevo los std::cout
 	std::cout.rdbuf(orig_buf);
 #endif
 #ifdef ARCADE
 	// Comprueba si ha de apagar el sistema
 	if (section::options == section::Options::QUIT_WITH_CONTROLLER)
 		shutdownSystem();
 #endif
 	return (section::options == section::Options::QUIT_WITH_CONTROLLER) ? 1 : 0;
 }
@@ -736,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;
 	}
@@ -770,4 +750,4 @@ void Director::shutdownSystem()
 #error "Sistema operativo no soportado"
 #endif
 }
-#endif //ARCADE
+#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,13 +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
 	// Inicializa jail_audio
 	void initJailAudio();
@@ -35,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();
--- 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()
--- 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
 {
@@ -33,10 +33,10 @@ private:
 public:
    // Constructor
-    Explosions();
+    Explosions() = default;
    // Destructor
-    ~Explosions();
+    ~Explosions() = default;
    // Actualiza la lógica de la clase
    void update();
--- 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;
@@ -63,6 +64,30 @@ constexpr int TOTAL_SCORE_DATA = 3;
 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
 	{
@@ -78,31 +103,19 @@ private:
 		int item_coffee_machine_odds; // Probabilidad de aparición del objeto
 		// Constructor con valores predeterminados
-		explicit Helper(bool nc = false, bool ncm = false, bool npb = false, int c = 0, int ido = 0, int igo = 0, int ipo = 0, int ico = 0, int icoffo = 0, int icmo = 0)
+		Helper()
-			: need_coffee(nc), need_coffee_machine(ncm), need_power_ball(npb), counter(c),
+			: need_coffee(false),
-			  item_disk_odds(ido), item_gavina_odds(igo), item_pacmar_odds(ipo), item_clock_odds(ico),
+			  need_coffee_machine(false),
-			  item_coffee_odds(icoffo), item_coffee_machine_odds(icmo) {}
+			  need_power_ball(false),
 			  counter(HELP_COUNTER_),
 			  item_disk_odds(ITEM_POINTS_1_DISK_ODDS_),
 			  item_gavina_odds(ITEM_POINTS_2_GAVINA_ODDS_),
 			  item_pacmar_odds(ITEM_POINTS_3_PACMAR_ODDS_),
 			  item_clock_odds(ITEM_CLOCK_ODDS_),
 			  item_coffee_odds(ITEM_COFFEE_ODDS_),
 			  item_coffee_machine_odds(ITEM_COFFEE_MACHINE_ODDS_) {}
 	};
 	// Constantes
 	// Contadores
 	static constexpr int STAGE_COUNTER_ = 200;
 	static constexpr int HELP_COUNTER_ = 1000;
 	static constexpr int GAME_COMPLETED_START_FADE_ = 500;
 	static constexpr int GAME_COMPLETED_END_ = 700;
 	static constexpr int GAME_OVER_COUNTER_ = 350;
 	static constexpr int TIME_STOPPED_COUNTER_ = 300;
 	// Porcentaje de aparición de los objetos
 	static constexpr int ITEM_POINTS_1_DISK_ODDS_ = 10;
 	static constexpr int ITEM_POINTS_2_GAVINA_ODDS_ = 6;
 	static constexpr int ITEM_POINTS_3_PACMAR_ODDS_ = 3;
 	static constexpr int ITEM_CLOCK_ODDS_ = 5;
 	static constexpr int ITEM_COFFEE_ODDS_ = 5;
 	static constexpr int ITEM_POWER_BALL_ODDS_ = 0;
 	static constexpr int ITEM_COFFEE_MACHINE_ODDS_ = 4;
 	// Objetos y punteros
 	SDL_Renderer *renderer_; // El renderizador de la ventana
 	Screen *screen_;		 // Objeto encargado de dibujar en pantalla
@@ -121,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
@@ -135,47 +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(
-	bool hi_score_achieved_;					  // Indica si se ha superado la puntuación máxima
+		options.game.hi_score_table[0].name,
-	HiScoreEntry hi_score_;						  // Máxima puntuación y nombre de quien la ostenta
+		options.game.hi_score_table[0].score); // Máxima puntuación y nombre de quien la ostenta
-	int current_stage_;							  // Indica la fase actual
+
-	int stage_bitmap_counter_;					  // Contador para el tiempo visible del texto de Stage
+	int current_stage_;									  // Indica la fase actual
-	float stage_bitmap_path_[STAGE_COUNTER_];	  // Vector con los puntos Y por donde se desplaza el texto
+	Demo demo_;											  // Variable con todas las variables relacionadas con el modo demo
-	float get_ready_bitmap_path_[STAGE_COUNTER_]; // Vector con los puntos X por donde se desplaza el texto
+	GameDifficulty difficulty_ = options.game.difficulty; // Dificultad del juego
-	int game_over_counter_;						  // Contador para el estado de fin de partida
+	Helper helper_;										  // Variable para gestionar las ayudas
-	int menace_current_;						  // Nivel de amenaza actual
+	Uint32 ticks_ = 0;									  // Contador de ticks para ajustar la velocidad del programa
-	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 coffee_machine_enabled_ = false;				  // Indica si hay una máquina de café en el terreno de juego
-	bool time_stopped_;							  // Indica si el tiempo está detenido
+	bool hi_score_achieved_ = false;					  // Indica si se ha superado la puntuación máxima
-	int time_stopped_counter_;					  // Temporizador para llevar la cuenta del tiempo detenido
+	bool paused_ = false;								  // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
-	int counter_;								  // Contador para el juego
+	bool power_ball_enabled_ = false;					  // Indica si hay una powerball ya activa
-	int balloons_popped_;						  // Lleva la cuenta de los globos explotados
+	float balloon_speed_;								  // Velocidad a la que se mueven los enemigos
-	int last_ballon_deploy_;					  // Guarda cual ha sido la última formación desplegada para no repetir;
+	float default_balloon_speed_;						  // Velocidad base de los enemigos, sin incrementar
-	int balloon_deploy_counter_;				  // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
+	float difficulty_score_multiplier_;					  // Multiplicador de puntos en función de la dificultad
-	float balloon_speed_;						  // Velocidad a la que se mueven los enemigos
+	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 default_balloon_speed_;				  // Velocidad base de los enemigos, sin incrementar
+	int balloons_popped_ = 0;							  // Lleva la cuenta de los globos explotados
-	Helper helper_;								  // Variable para gestionar las ayudas
+	int counter_ = 0;									  // Contador para el juego
-	bool power_ball_enabled_;					  // Indica si hay una powerball ya activa
+	int current_power_ = 0;								  // Poder actual almacenado para completar la fase
-	int power_ball_counter_;					  // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
+	int game_completed_counter_ = 0;					  // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
-	bool coffee_machine_enabled_;				  // Indica si hay una máquina de café en el terreno de juego
+	int game_over_counter_ = GAME_OVER_COUNTER_;		  // Contador para el estado de fin de partida
-	bool game_completed_;						  // Indica si se ha completado la partida, llegando al final de la ultima pantalla
+	int last_balloon_deploy_ = 0;						  // Guarda cual ha sido la última formación desplegada para no repetir;
-	int game_completed_counter_;				  // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
+	int menace_current_ = 0;							  // Nivel de amenaza actual
-	GameDifficulty difficulty_;					  // Dificultad del juego
+	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
-	float difficulty_score_multiplier_;			  // Multiplicador de puntos en función de la dificultad
+	int power_ball_counter_ = 0;						  // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
-	int last_stage_reached_;					  // Contiene el número de la última pantalla que se ha alcanzado
+	int time_stopped_counter_ = 0;						  // Temporizador para llevar la cuenta del tiempo detenido
-	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
-	int total_power_to_complete_game_;			  // La suma del poder necesario para completar todas las fases
+	GameState state_ = GameState::PLAYING;				  // Estado
 	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
@@ -187,7 +195,7 @@ private:
 	// Comprueba los eventos que hay en cola
 	void checkEvents();
-	// Asigna los recursos a variables privadas del objeto
+	// Asigna texturas y animaciones
 	void setResources();
 	// Crea una formación de enemigos
@@ -209,7 +217,7 @@ private:
 	void updateStage();
 	// Actualiza el estado de fin de la partida
-	void updateGameOver();
+	void updateGameOverState();
 	// Actualiza los globos
 	void updateBalloons();
@@ -218,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();
@@ -227,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);
@@ -238,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();
@@ -283,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);
@@ -304,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();
@@ -331,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();
@@ -346,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();
@@ -404,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.
@@ -425,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)
 {
@@ -104,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
 {
@@ -40,9 +40,9 @@ namespace globalInputs
        {
 #ifdef ARCADE
            const int index = code == section::Options::QUIT_WITH_CONTROLLER ? 116 : 94;
-            Notifier::get()->showText(lang::getText(index), std::string(), -1, exit_code);
+            Notifier::get()->showText({lang::getText(index), std::string()}, -1, exit_code);
 #else
-            Notifier::get()->showText(lang::getText(94), std::string(), -1, exit_code);
+            Notifier::get()->showText({lang::getText(94), std::string()}, -1, exit_code);
 #endif
        }
    }
@@ -51,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_WITH_KEYBOARD);
+#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_WITH_CONTROLLER);
                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,25 +1,25 @@
 #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()
@@ -208,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
--- 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))
 		{
@@ -417,7 +245,6 @@ bool Input::discoverGameControllers()
 	}
 	std::cout << "\n** LOOKING FOR GAME CONTROLLERS" << std::endl;
 	// std::cout << "  " << num_joysticks_ << " joysticks found" << std::endl;
 	std::cout << "Gamepads found: " << num_gamepads_ << std::endl;
 	if (num_gamepads_ > 0)
@@ -432,16 +259,12 @@ bool Input::discoverGameControllers()
 			{
 				connected_controllers_.push_back(pad);
 				const std::string name = SDL_GameControllerNameForIndex(i);
-				{
+				std::cout << "#" << i << ": " << name << std::endl;
 					std::cout << "#" << i << ": " << 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;
 				}
 			}
 		}
@@ -449,27 +272,17 @@ bool Input::discoverGameControllers()
 	}
 	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
@@ -485,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_)
 		{
@@ -500,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;
 		}
 	}
 }
@@ -520,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,27 +1,25 @@
 #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()
@@ -315,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
@@ -33,7 +32,7 @@ private:
 	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
--- a/source/intro.cpp
+++ b/source/intro.cpp
@@ -1,23 +1,21 @@
 #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()
@@ -141,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
@@ -173,9 +169,7 @@ void Intro::checkEvents()
 		case SDL_WINDOWEVENT:
 		{
 			if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
 			{
 				reloadTextures();
 			}
 			break;
 		}
@@ -197,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();
 }
@@ -369,7 +360,7 @@ void Intro::updateScenes()
 void Intro::update()
 {
 	constexpr int TICKS_SPEED = 15;
-	
+
 	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		// Actualiza el contador de ticks
--- 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
--- a/source/item.cpp
+++ b/source/item.cpp
@@ -1,7 +1,7 @@
 #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
@@ -44,7 +44,7 @@ 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_ = static_cast<float>(x - (width_ / 2));
--- 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
@@ -64,7 +64,7 @@ public:
    ~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,19 +1,18 @@
 #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()
@@ -55,6 +54,13 @@ Logo::Logo()
 	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
 void Logo::reloadTextures()
 {
@@ -100,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();
 }
--- 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
@@ -26,7 +26,7 @@ private:
 	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
@@ -65,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,10 +1,9 @@
 #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
 // Resetea la tabla a los valores por defecto
 void ManageHiScoreTable::clear()
--- 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,6 +11,17 @@ 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
 {
--- 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,14 +1,15 @@
 #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;
@@ -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, const 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, const st
    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, const st
    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, const st
    }
    // 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, const st
    }
    // 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, const st
    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
@@ -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, const 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/source/on_screen_help.h
+++ b/source/on_screen_help.h
@@ -1,8 +1,8 @@
 #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_Texture
+#include <SDL2/SDL_render.h> // para SDL_Texture
-#include <vector>             // for vector
+#include <vector>            // para vector
 class Sprite;
 class Text;
--- a/source/options.cpp
+++ b/source/options.cpp
@@ -1,13 +1,14 @@
 #include "options.h"
-#include <SDL2/SDL_gamecontroller.h> // for SDL_GameControllerButton, SDL_C...
+#include <SDL2/SDL_gamecontroller.h> // Para SDL_GameControllerButton
-#include <algorithm>				 // for max, min
+#include <algorithm>				 // Para clamp
-#include <fstream>					 // for basic_ostream, operator<<, basi...
+#include <fstream>					 // Para basic_ostream, operator<<, basi...
-#include <iostream>					 // for cout
+#include <iostream>					 // Para cout
-#include <vector>					 // for vector
+#include <utility>					 // Para swap
-#include "input.h"					 // for inputs_e, INPUT_USE_ANY, INPUT_...
+#include <vector>					 // Para vector
-#include "lang.h"					 // for lang_e
+#include "input.h"					 // Para InputDeviceToUse
-#include "screen.h"					 // for ScreenVideoMode, ScreenFilter
+#include "lang.h"					 // Para Code
-#include "utils.h"					 // for OptionsController, Options, op_...
+#include "screen.h"					 // Para ScreenVideoMode, ScreenFilter
 #include "utils.h"					 // Para boolToString, stringToBool, get...
 // Variables
 Options options;
@@ -32,10 +33,12 @@ void initOptions()
 	options.video.shaders = true;
 	// Opciones de audio
 	options.audio.enabled = true;
 	options.audio.volume = 100;
 	options.audio.music.enabled = true;
-	options.audio.music.volume = 128;
+	options.audio.music.volume = 100;
 	options.audio.sound.enabled = true;
-	options.audio.sound.volume = 64;
+	options.audio.sound.volume = 50;
 	// Opciones de juego
 	options.game.difficulty = GameDifficulty::NORMAL;
@@ -43,37 +46,11 @@ void initOptions()
 	options.game.autofire = true;
 	// Opciones de control
-	options.controller.clear();
+	options.controllers.clear();
-	OptionsController c;
+	options.controllers.resize(2);
-
+	options.controllers.at(0).player_id = 1;
-	constexpr int num_players = 2;
+	options.controllers.at(1).player_id = 2;
-	for (int index = 0; index < num_players; ++index)
+	setKeyboardToPlayer(1);
 	{
 		c.index = index;
 		c.player_id = index + 1;
 		c.device_type = INPUT_USE_GAMECONTROLLER;
 		c.name = "NO NAME";
 		c.plugged = false;
 		// Inputs que se guardan en las opciones y, por tanto, a disco
 		c.inputs.clear();
 		c.inputs.push_back(InputType::FIRE_LEFT);
 		c.inputs.push_back(InputType::FIRE_CENTER);
 		c.inputs.push_back(InputType::FIRE_RIGHT);
 		c.inputs.push_back(InputType::START);
 		c.inputs.push_back(InputType::SERVICE);
 		// Botones asociados a los inputs anteriores
 		c.buttons.clear();
 		c.buttons.push_back(SDL_CONTROLLER_BUTTON_X);
 		c.buttons.push_back(SDL_CONTROLLER_BUTTON_Y);
 		c.buttons.push_back(SDL_CONTROLLER_BUTTON_B);
 		c.buttons.push_back(SDL_CONTROLLER_BUTTON_START);
 		c.buttons.push_back(SDL_CONTROLLER_BUTTON_BACK);
 		options.controller.push_back(c);
 	}
 	options.controller[0].device_type = INPUT_USE_ANY; // El primer jugador puede usar tanto el teclado como el primer mando
 }
 // Carga el fichero de configuración
@@ -127,12 +104,11 @@ bool loadOptionsFile(std::string file_path)
 		options.video.mode = ScreenVideoMode::WINDOW;
 	}
-	if (options.video.window.size < 1 || options.video.window.size > 4)
+	options.video.window.size = std::clamp(options.video.window.size, 1, 4);
 	{
 		options.video.window.size = 3;
 	}
-	if (options.game.language != lang::Code::en_UK && options.game.language != lang::Code::ba_BA && options.game.language != lang::Code::es_ES)
+	if (options.game.language != lang::Code::en_UK &&
 		options.game.language != lang::Code::ba_BA &&
 		options.game.language != lang::Code::es_ES)
 	{
 		options.game.language = lang::Code::en_UK;
 	}
@@ -154,71 +130,58 @@ bool saveOptionsFile(std::string file_path)
 	std::cout << "Writing file: " << getFileName(file_path) << std::endl;
 	// Opciones de video
 	const auto value_video_mode_winow = std::to_string(static_cast<int>(ScreenVideoMode::WINDOW));
 	const auto value_video_mode_fullscreen = std::to_string(static_cast<int>(ScreenVideoMode::FULLSCREEN));
 	const auto value_filter_nearest = std::to_string(static_cast<int>(ScreenFilter::NEAREST));
 	const auto value_filter_lineal = std::to_string(static_cast<int>(ScreenFilter::LINEAL));
 	file << "## VIDEO\n";
-	file << "## video.mode [" << value_video_mode_winow << ": window, " << value_video_mode_fullscreen << ": fullscreen]\n";
+	file << "## video.mode [" << static_cast<int>(ScreenVideoMode::WINDOW) << ": window, " << static_cast<int>(ScreenVideoMode::FULLSCREEN) << ": fullscreen]\n";
-	file << "## video.filter [" << value_filter_nearest << ": nearest, " << value_filter_lineal << ": lineal]\n";
+	file << "## video.filter [" << static_cast<int>(ScreenFilter::NEAREST) << ": nearest, " << static_cast<int>(ScreenFilter::LINEAL) << ": lineal]\n";
 	file << "\n";
-	const auto valueVideoMode = std::to_string(static_cast<int>(options.video.mode));
+	file << "video.mode=" << static_cast<int>(options.video.mode) << "\n";
-	file << "video.mode=" << valueVideoMode << "\n";
+	file << "video.window.size=" << options.video.window.size << "\n";
-
+	file << "video.filter=" << static_cast<int>(options.video.filter) << "\n";
-	file << "video.window.size=" + std::to_string(options.video.window.size) + "\n";
+	file << "video.v_sync=" << boolToString(options.video.v_sync) << "\n";
-
+	file << "video.integer_scale=" << boolToString(options.video.integer_scale) << "\n";
-	const auto valueFilter = std::to_string(static_cast<int>(options.video.filter));
+	file << "video.shaders=" << boolToString(options.video.shaders) << "\n";
 	file << "video.filter=" << valueFilter << "\n";
 	file << "video.v_sync=" + boolToString(options.video.v_sync) + "\n";
 	file << "video.integer_scale=" + boolToString(options.video.integer_scale) + "\n";
 	file << "video.shaders=" + boolToString(options.video.shaders) + "\n";
 	// Opciones de audio
 	file << "\n\n## AUDIO\n";
-	file << "## volume [0 .. 128]\n";
+	file << "## volume [0 .. 100]\n";
 	file << "\n";
-	file << "audio.music.enabled=" + boolToString(options.audio.music.enabled) + "\n";
+	file << "audio.enabled=" << boolToString(options.audio.enabled) << "\n";
-	file << "audio.music.volume=" + std::to_string(options.audio.music.volume) + "\n";
+	file << "audio.volume=" << options.audio.volume << "\n";
-	file << "audio.sound.enabled=" + boolToString(options.audio.sound.enabled) + "\n";
+	file << "audio.music.enabled=" << boolToString(options.audio.music.enabled) << "\n";
-	file << "audio.sound.volume=" + std::to_string(options.audio.sound.volume) + "\n";
+	file << "audio.music.volume=" << options.audio.music.volume << "\n";
 	file << "audio.sound.enabled=" << boolToString(options.audio.sound.enabled) << "\n";
 	file << "audio.sound.volume=" << options.audio.sound.volume << "\n";
 	// Opciones del juego
 	const auto value_difficulty_easy = std::to_string(static_cast<int>(GameDifficulty::EASY));
 	const auto value_difficulty_normal = std::to_string(static_cast<int>(GameDifficulty::NORMAL));
 	const auto value_difficulty_hard = std::to_string(static_cast<int>(GameDifficulty::HARD));
 	file << "\n\n## GAME\n";
 	file << "## game.language [0: spanish, 1: valencian, 2: english]\n";
-	file << "## game.difficulty [" << value_difficulty_easy << ": easy, " << value_difficulty_normal << ": normal, " << value_difficulty_hard << ": hard]\n";
+	file << "## game.difficulty [" << static_cast<int>(GameDifficulty::EASY) << ": easy, " << static_cast<int>(GameDifficulty::NORMAL) << ": normal, " << static_cast<int>(GameDifficulty::HARD) << ": hard]\n";
 	file << "\n";
-	file << "game.language=" + std::to_string(static_cast<int>(options.game.language)) + "\n";
+	file << "game.language=" << static_cast<int>(options.game.language) << "\n";
-	file << "game.difficulty=" + std::to_string(static_cast<int>(options.game.difficulty)) + "\n";
+	file << "game.difficulty=" << static_cast<int>(options.game.difficulty) << "\n";
-	file << "game.autofire=" + boolToString(options.game.autofire) + "\n";
+	file << "game.autofire=" << boolToString(options.game.autofire) << "\n";
 	// Opciones de mandos
 	file << "\n\n## CONTROLLERS\n";
 	file << "\n";
-	const int num_players = 2;
+	int controller_index = 0;
-	for (int index = 0; index < num_players; ++index)
+	for (const auto &controller : options.controllers)
 	{
-		const std::string joyIndex = std::to_string(index + 1);
+		file << "\n";
-		file << "controller" + joyIndex + ".name=" + options.controller[index].name + "\n";
+		file << "controller." << controller_index << ".name=" << controller.name << "\n";
-		file << "controller" + joyIndex + ".player=" + std::to_string(options.controller[index].player_id) + "\n";
+		file << "controller." << controller_index << ".player=" << controller.player_id << "\n";
-		file << "controller" + joyIndex + ".button.fire_left=" + std::to_string((int)options.controller[index].buttons[0]) + "\n";
+		file << "controller." << controller_index << ".type=" << static_cast<int>(controller.type) << "\n";
-		file << "controller" + joyIndex + ".button.fire_center=" + std::to_string((int)options.controller[index].buttons[1]) + "\n";
+		file << "controller." << controller_index << ".button.fire_left=" << controller.buttons.at(0) << "\n";
-		file << "controller" + joyIndex + ".button.fire_right=" + std::to_string((int)options.controller[index].buttons[2]) + "\n";
+		file << "controller." << controller_index << ".button.fire_center=" << controller.buttons.at(1) << "\n";
-		file << "controller" + joyIndex + ".button.start=" + std::to_string((int)options.controller[index].buttons[3]) + "\n";
+		file << "controller." << controller_index << ".button.fire_right=" << controller.buttons.at(2) << "\n";
-		file << "controller" + joyIndex + ".button.service=" + std::to_string((int)options.controller[index].buttons[4]) + "\n";
+		file << "controller." << controller_index << ".button.start=" << controller.buttons.at(3) << "\n";
 		file << "controller." << controller_index << ".button.service=" << controller.buttons.at(4) << "\n";
-		if (index < num_players - 1)
+		// Incrementa el índice
-		{
+		++controller_index;
 			file << "\n";
 		}
 	}
 	// Cierra el fichero
@@ -238,7 +201,6 @@ bool setOptions(const std::string &var, const std::string &value)
 	{
 		options.video.mode = static_cast<ScreenVideoMode>(std::stoi(value));
 	}
 	else if (var == "video.window.size")
 	{
 		options.video.window.size = std::stoi(value);
@@ -247,43 +209,44 @@ bool setOptions(const std::string &var, const std::string &value)
 			options.video.window.size = 3;
 		}
 	}
 	else if (var == "video.filter")
 	{
 		options.video.filter = static_cast<ScreenFilter>(std::stoi(value));
 	}
 	else if (var == "video.shaders")
 	{
 		options.video.shaders = stringToBool(value);
 	}
 	else if (var == "video.integer_scale")
 	{
 		options.video.integer_scale = stringToBool(value);
 	}
 	else if (var == "video.v_sync")
 	{
 		options.video.v_sync = stringToBool(value);
 	}
 	// Opciones de audio
 	else if (var == "audio.enabled")
 	{
 		options.audio.enabled = stringToBool(value);
 	}
 	else if (var == "audio.volume")
 	{
 		options.audio.volume = std::stoi(value);
 	}
 	else if (var == "audio.music.enabled")
 	{
 		options.audio.music.enabled = stringToBool(value);
 	}
 	else if (var == "audio.music.volume")
 	{
 		options.audio.music.volume = std::stoi(value);
 	}
 	else if (var == "audio.sound.enabled")
 	{
 		options.audio.sound.enabled = stringToBool(value);
 	}
 	else if (var == "audio.sound.volume")
 	{
 		options.audio.sound.volume = std::stoi(value);
@@ -294,97 +257,138 @@ bool setOptions(const std::string &var, const std::string &value)
 	{
 		options.game.language = static_cast<lang::Code>(std::stoi(value));
 	}
 	else if (var == "game.difficulty")
 	{
 		options.game.difficulty = static_cast<GameDifficulty>(std::stoi(value));
 	}
 	else if (var == "game.autofire")
 	{
 		options.game.autofire = stringToBool(value);
 	}
 	// Opciones de mandos
-	else if (var == "controller1.name")
+	else if (var == "controller.0.name")
 	{
-		options.controller[0].name = value;
+		options.controllers.at(0).name = value;
 	}
-
+	else if (var == "controller.0.player")
 	else if (var == "controller1.player")
 	{
-		options.controller[0].player_id = std::max(1, std::min(2, std::stoi(value)));
+		options.controllers.at(0).player_id = std::clamp(std::stoi(value), 1, 2);
 	}
-
+	else if (var == "controller.0.type")
 	else if (var == "controller1.button.fire_left")
 	{
-		options.controller[0].buttons[0] = (SDL_GameControllerButton)std::stoi(value);
+		options.controllers.at(0).type = static_cast<InputDeviceToUse>(std::stoi(value));
 	}
-
+	else if (var == "controller.0.button.fire_left")
 	else if (var == "controller1.button.fire_center")
 	{
-		options.controller[0].buttons[1] = (SDL_GameControllerButton)std::stoi(value);
+		options.controllers.at(0).buttons.at(0) = static_cast<SDL_GameControllerButton>(std::stoi(value));
 	}
-
+	else if (var == "controller.0.button.fire_center")
 	else if (var == "controller1.button.fire_right")
 	{
-		options.controller[0].buttons[2] = (SDL_GameControllerButton)std::stoi(value);
+		options.controllers.at(0).buttons.at(1) = static_cast<SDL_GameControllerButton>(std::stoi(value));
 	}
-
+	else if (var == "controller.0.button.fire_right")
 	else if (var == "controller1.button.start")
 	{
-		options.controller[0].buttons[3] = (SDL_GameControllerButton)std::stoi(value);
+		options.controllers.at(0).buttons.at(2) = static_cast<SDL_GameControllerButton>(std::stoi(value));
 	}
-
+	else if (var == "controller.0.button.start")
 	else if (var == "controller1.button.service")
 	{
-		options.controller[0].buttons[4] = (SDL_GameControllerButton)std::stoi(value);
+		options.controllers.at(0).buttons.at(3) = static_cast<SDL_GameControllerButton>(std::stoi(value));
 	}
-
+	else if (var == "controller.0.button.service")
 	else if (var == "controller2.name")
 	{
-		options.controller[1].name = value;
+		options.controllers.at(0).buttons.at(4) = static_cast<SDL_GameControllerButton>(std::stoi(value));
 	}
-
+	else if (var == "controller.1.name")
 	else if (var == "controller2.player")
 	{
-		options.controller[1].player_id = std::max(1, std::min(2, std::stoi(value)));
+		options.controllers.at(1).name = value;
 	}
-
+	else if (var == "controller.1.player")
 	else if (var == "controller2.button.fire_left")
 	{
-		options.controller[1].buttons[0] = (SDL_GameControllerButton)std::stoi(value);
+		options.controllers.at(1).player_id = std::clamp(std::stoi(value), 1, 2);
 	}
-
+	else if (var == "controller.1.type")
 	else if (var == "controller2.button.fire_center")
 	{
-		options.controller[1].buttons[1] = (SDL_GameControllerButton)std::stoi(value);
+		options.controllers.at(1).type = static_cast<InputDeviceToUse>(std::stoi(value));
 	}
-
+	else if (var == "controller.1.button.fire_left")
 	else if (var == "controller2.button.fire_right")
 	{
-		options.controller[1].buttons[2] = (SDL_GameControllerButton)std::stoi(value);
+		options.controllers.at(1).buttons.at(0) = static_cast<SDL_GameControllerButton>(std::stoi(value));
 	}
-
+	else if (var == "controller.1.button.fire_center")
 	else if (var == "controller2.button.start")
 	{
-		options.controller[1].buttons[3] = (SDL_GameControllerButton)std::stoi(value);
+		options.controllers.at(1).buttons.at(1) = static_cast<SDL_GameControllerButton>(std::stoi(value));
 	}
-
+	else if (var == "controller.1.button.fire_right")
 	else if (var == "controller2.button.service")
 	{
-		options.controller[1].buttons[4] = (SDL_GameControllerButton)std::stoi(value);
+		options.controllers.at(1).buttons.at(2) = static_cast<SDL_GameControllerButton>(std::stoi(value));
 	}
 	else if (var == "controller.1.button.start")
 	{
 		options.controllers.at(1).buttons.at(3) = static_cast<SDL_GameControllerButton>(std::stoi(value));
 	}
 	else if (var == "controller.1.button.service")
 	{
 		options.controllers.at(1).buttons.at(4) = static_cast<SDL_GameControllerButton>(std::stoi(value));
 	}
 	// Lineas vacias o que empiezan por comentario
 	else if (var.empty() || var.starts_with("#"))
 	{
 	}
 	else
 	{
 		success = false;
 	}
 	return success;
 }
 // Convierte valores de 0 a 100 en valores de 0 a 128
 int to_JA_volume(int vol)
 {
 	vol = vol * 1.28f;
 	return std::clamp(vol, 0, 128);
 }
 // Asigna el teclado al jugador
 void setKeyboardToPlayer(int player_id)
 {
 	for (auto &controller : options.controllers)
 	{
 		if (controller.player_id == player_id)
 		{
 			controller.type = InputDeviceToUse::ANY;
 		}
 		else
 		{
 			controller.type = InputDeviceToUse::CONTROLLER;
 		}
 	}
 }
 // Intercambia el teclado de jugador
 void swapOptionsKeyboard()
 {
 	std::swap(options.controllers.at(0).type, options.controllers.at(1).type);
 }
 // Intercambia los jugadores asignados a los dos primeros mandos
 void swapOptionsControllers()
 {
 	std::swap(options.controllers.at(0).player_id, options.controllers.at(1).player_id);
 	std::swap(options.controllers.at(0).type, options.controllers.at(1).type);
 }
 // Averigua quien está usando el teclado
 int getPlayerWhoUsesKeyboard()
 {
 	for (const auto &controller : options.controllers)
 	{
 		if (controller.type == InputDeviceToUse::ANY)
 		{
 			return controller.player_id;
 		}
 	}
 	return 0;
 }
--- a/source/options.h
+++ b/source/options.h
@@ -1,13 +1,123 @@
 #pragma once
-#include <string> // for string
+#include <SDL2/SDL_gamecontroller.h> // Para SDL_CONTROLLER_BUTTON_B, SDL_CO...
-struct Options;
+#include <string>					 // Para string
 #include <vector>					 // Para vector
 #include "input.h"					 // Para InputType, InputDeviceToUse
 #include "manage_hiscore_table.h"	 // Para HiScoreEntry
 enum class ScreenFilter : int;		 // lines 10-10
 enum class ScreenVideoMode : int;	 // lines 11-11
 namespace lang
 {
 	enum class Code : int;
 } // lines 14-14
 // Dificultad del juego
 enum class GameDifficulty
 {
 	EASY = 0,
 	NORMAL = 1,
 	HARD = 2,
 };
 // Estructura para las opciones de la ventana
 struct OptionsWindow
 {
 	int size; // Contiene el valor por el que se multiplica el tamaño de la ventana
 };
 // Estructura con opciones para el video
 struct OptionsVideo
 {
 	OptionsWindow window; // Opciones para la ventana del programa
 	ScreenVideoMode mode; // Contiene el valor del modo de pantalla completa
 	ScreenFilter filter;  // Filtro usado para el escalado de la imagen
 	bool v_sync;		  // Indica si se quiere usar vsync o no
 	bool integer_scale;	  // Indica si se va a usar el escalado entero
 	bool shaders;		  // Indica si se van a usar shaders para los filtros de video
 };
 // Estructura para las opciones de musica
 struct OptionsMusic
 {
 	bool enabled; // Indica si la musica suena o no
 	int volume;	  // Volumen al que suena la música
 };
 // Estructura para las opciones de sonido
 struct OptionsSound
 {
 	bool enabled; // Indica si los sonidos suenan o no
 	int volume;	  // Volumen al que suenan los sonidos
 };
 // Estructura para las opciones de audio
 struct OptionsAudio
 {
 	OptionsMusic music; // Opciones para la música
 	OptionsSound sound; // Opciones para los efectos de sonido
 	bool enabled;		// Indica si el audio está activo o no
 	int volume;			// Volumen al que suenan el audio
 };
 // Estructura para las opciones del juego
 struct OptionsGame
 {
 	GameDifficulty difficulty;				  // Dificultad del juego
 	lang::Code language;					  // Idioma usado en el juego
 	bool autofire;							  // Indica si el jugador ha de pulsar repetidamente para disparar o basta con mantener pulsado
 	std::vector<HiScoreEntry> hi_score_table; // Tabla con las mejores puntuaciones
 };
 // Estructura para los controles del juego
 struct OptionsController
 {
 	int index;									   // Indice en el vector de mandos
 	int player_id;								   // Jugador asociado al mando
 	InputDeviceToUse type;						   // Indica si se utilizará teclado o mando o ambos
 	std::string name;							   // Nombre del dispositivo
 	bool plugged;								   // Indica si el mando se encuentra conectado
 	std::vector<InputType> inputs;				   // Listado de inputs
 	std::vector<SDL_GameControllerButton> buttons; // Listado de botones asignados a cada input
 	// Constructor por defecto
 	OptionsController()
 		: index(-1), player_id(-1), type(InputDeviceToUse::CONTROLLER), name(""), plugged(false),
 		  inputs{InputType::FIRE_LEFT, InputType::FIRE_CENTER, InputType::FIRE_RIGHT, InputType::START, InputType::SERVICE},
 		  buttons{SDL_CONTROLLER_BUTTON_X, SDL_CONTROLLER_BUTTON_Y, SDL_CONTROLLER_BUTTON_B, SDL_CONTROLLER_BUTTON_START, SDL_CONTROLLER_BUTTON_BACK} {}
 };
 // Estructura con todas las opciones de configuración del programa
 struct Options
 {
 	OptionsGame game;							// Opciones para el propio juego
 	OptionsVideo video;							// Opciones relativas a la clase screen
 	OptionsAudio audio;							// Opciones para el audio
 	std::vector<OptionsController> controllers; // Opciones con las asignaciones del mando para cada jugador
 };
 // Variables
 extern Options options;
 void initOptions();
 // Carga el fichero de configuración
 bool loadOptionsFile(std::string file_path);
 // Guarda el fichero de configuración
-bool saveOptionsFile(std::string file_path);
+bool saveOptionsFile(std::string file_path);
 // Convierte valores de 0 a 100 en valores de 0 a 128
 int to_JA_volume(int vol);
 // Asigna el teclado al jugador
 void setKeyboardToPlayer(int player_id);
 // Intercambia el teclado de jugador
 void swapOptionsKeyboard();
 // Intercambia los jugadores asignados a los dos primeros mandos
 void swapOptionsControllers();
 // Averigua quien está usando el teclado
 int getPlayerWhoUsesKeyboard();
--- a/source/param.cpp
+++ b/source/param.cpp
@@ -1,10 +1,10 @@
 #include "param.h"
-#include <fstream>	// for char_traits, basic_ostream, basic_ifstream, basi...
+#include <fstream>	// para char_traits, basic_ostream, basic_ifstream, basi...
-#include <iostream> // for cout
+#include <iostream> // para cout
 #include <sstream>
 #include <string>
 #include <stdexcept>
-#include "utils.h" // for Param, ParamGame, Zone, ParamBalloon
+#include "utils.h" // para Param, ParamGame, Zone, ParamBalloon
 Param param;
@@ -23,6 +23,7 @@ void initParam()
 	param.game.item_size = 20;
 	param.game.game_area.rect = {0, 0, param.game.width, param.game.height};
 	param.game.play_area.rect = {0, 0, param.game.width, 216};
 	param.game.enter_name_seconds = 30;
 	precalculateZones();
 	// SCOREBOARD
@@ -43,18 +44,14 @@ void initParam()
 	param.title.title_c_c_position = 11;
 	// BACKGROUND
-	param.background.attenuate_color = (Color){255, 255, 255};
+	param.background.attenuate_color = Color(255, 255, 255);
 	param.background.attenuate_alpha = 32;
 	// BALLOONS
-	param.balloon_1.vel = 2.60f;
+	param.balloon.emplace_back(0.09f, 2.60f);
-	param.balloon_1.grav = 0.09f;
+	param.balloon.emplace_back(0.10f, 3.50f);
-	param.balloon_2.vel = 3.50f;
+	param.balloon.emplace_back(0.10f, 4.50f);
-	param.balloon_2.grav = 0.10f;
+	param.balloon.emplace_back(0.10f, 4.95f);
 	param.balloon_3.vel = 4.50f;
 	param.balloon_3.grav = 0.10f;
 	param.balloon_4.vel = 4.95f;
 	param.balloon_4.grav = 0.10f;
 	// NOTIFICATION
 	param.notification.pos_v = NotifyPosition::TOP;
@@ -249,42 +246,42 @@ bool setParams(const std::string &var, const std::string &value)
 	// BALLOON
 	else if (var == "balloon_1.vel")
 	{
-		param.balloon_1.vel = std::stof(value);
+		param.balloon.at(0).vel = std::stof(value);
 	}
 	else if (var == "balloon_1.grav")
 	{
-		param.balloon_1.grav = std::stof(value);
+		param.balloon.at(0).grav = std::stof(value);
 	}
 	else if (var == "balloon_2.vel")
 	{
-		param.balloon_2.vel = std::stof(value);
+		param.balloon.at(1).vel = std::stof(value);
 	}
 	else if (var == "balloon_2.grav")
 	{
-		param.balloon_2.grav = std::stof(value);
+		param.balloon.at(1).grav = std::stof(value);
 	}
 	else if (var == "balloon_3.vel")
 	{
-		param.balloon_3.vel = std::stof(value);
+		param.balloon.at(2).vel = std::stof(value);
 	}
 	else if (var == "balloon_3.grav")
 	{
-		param.balloon_3.grav = std::stof(value);
+		param.balloon.at(2).grav = std::stof(value);
 	}
 	else if (var == "balloon_4.vel")
 	{
-		param.balloon_4.vel = std::stof(value);
+		param.balloon.at(3).vel = std::stof(value);
 	}
 	else if (var == "balloon_4.grav")
 	{
-		param.balloon_4.grav = std::stof(value);
+		param.balloon.at(3).grav = std::stof(value);
 	}
 	// NOTIFICACIONES
--- a/source/param.h
+++ b/source/param.h
@@ -1,7 +1,84 @@
 #pragma once
-#include <string> // for string
+#include <SDL2/SDL_rect.h> // Para SDL_Rect
-struct Param;
+#include <string>          // Para string
 #include <vector>          // Para vector
 #include "utils.h"         // Para Color, Zone
 // param.game
 struct ParamGame
 {
    int width;              // Ancho de la resolucion nativa del juego
    int height;             // Alto de la resolucion nativa del juego
    int item_size;          // Tamaño de los items del juego
    Zone play_area;         // Rectangulo con la posición de la zona de juego
    Zone game_area;         // Rectangulo con las dimensiones del juego
    int enter_name_seconds; // Duración en segundos para introducir el nombre al finalizar la partida
 };
 // param.fade
 struct ParamFade
 {
    int num_squares_width;    // Cantidad total de cuadraditos en horizontal para el FadeType::RANDOM_SQUARE
    int num_squares_height;   // Cantidad total de cuadraditos en vertical para el FadeType::RANDOM_SQUARE
    int random_squares_delay; // Duración entre cada pintado de cuadrados
    int random_squares_mult;  // Cantidad de cuadrados que se pintaran cada vez
    int post_duration;        // Duración final del fade
    int venetian_size;        // Altura de los rectangulos para FadeType::VENETIAN
 };
 // param.title
 struct ParamTitle
 {
    int press_start_position;    // Posición del texto para empezar a jugar
    int title_duration;          // Tiempo de inactividad del titulo
    int arcade_edition_position; // Posición del bitmap
    int title_c_c_position;      // Posición del bitmap
 };
 // param.background
 struct ParamBackground
 {
    Color attenuate_color;
    int attenuate_alpha;
 };
 struct ParamBalloon
 {
    float grav; // Aceleración en el eje Y. Modifica la velocidad
    float vel;  // Velocidad inicial que tienen al rebotar contra el suelo
    // Constructor
    explicit ParamBalloon(float grav_val = 0.0f, float vel_val = 0.0f)
        : grav(grav_val), vel(vel_val) {}
 };
 // Estructura para las opciones de las notificaciones
 struct ParamNotification
 {
    NotifyPosition pos_h; // Ubicación de las notificaciones en pantalla
    NotifyPosition pos_v; // Ubicación de las notificaciones en pantalla
    bool sound;           // Indica si las notificaciones suenan
    Color color;          // Color de las notificaciones
 };
 // Estructura para almacenar todos los parámetros del juego
 struct Param {
    ParamGame game;
    ParamFade fade;
    SDL_Rect scoreboard;
    ParamTitle title;
    ParamBackground background;
    std::vector<ParamBalloon> balloon;
    ParamNotification notification;
    Param() : game(), fade(), scoreboard(), title(), background(), notification() {
        balloon.reserve(4);
    }
 };
 extern Param param;
 extern Param param;
--- a/source/path_sprite.cpp
+++ b/source/path_sprite.cpp
@@ -0,0 +1,148 @@
 #include "path_sprite.h"
 #include <cmath>	  // Para abs
 #include <stdlib.h>	  // Para abs
 #include <functional> // Para function
 #include <utility>	  // Para move
 // Devuelve un vector con los puntos que conforman la ruta
 std::vector<SDL_Point> createPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction)
 {
 	std::vector<SDL_Point> v;
 	v.reserve(steps);
 	for (int i = 0; i < steps; ++i)
 	{
 		double t = static_cast<double>(i) / (steps - 1);
 		double value = start + (end - start) * easingFunction(t);
 		if (start > 0 && end < 0)
 		{
 			value = start - std::abs(end - start) * easingFunction(t);
 		}
 		else if (start < 0 && end > 0)
 		{
 			value = start + std::abs(end - start) * easingFunction(t);
 		}
 		switch (type)
 		{
 		case PathType::HORIZONTAL:
 			v.emplace_back(SDL_Point{static_cast<int>(value), fixed_pos});
 			break;
 		case PathType::VERTICAL:
 			v.emplace_back(SDL_Point{fixed_pos, static_cast<int>(value)});
 			break;
 		default:
 			break;
 		}
 	}
 	return v;
 }
 // Actualiza la posición y comprueba si ha llegado a su destino
 void PathSprite::update()
 {
 	if (enabled_)
 	{
 		moveThroughCurrentPath();
 		goToNextPathOrDie();
 	}
 }
 // Añade un recorrido
 void PathSprite::addPath(Path path, bool centered)
 {
 	PathCentered path_centered = PathCentered::NONE;
 	if (centered)
 		path_centered = (path.spots.back().x == path.spots.front().x) ? PathCentered::ON_X : PathCentered::ON_Y;
 	switch (path_centered)
 	{
 	case PathCentered::ON_X:
 	{
 		const int x = path.spots.back().x - pos_.w / 2;
 		for (auto &spot : path.spots)
 			spot.x = x;
 		paths_.emplace_back(path);
 		break;
 	}
 	case PathCentered::ON_Y:
 	{
 		const int y = path.spots.back().y - pos_.h / 2;
 		for (auto &spot : path.spots)
 			spot.y = y;
 		paths_.emplace_back(path);
 		break;
 	}
 	default:
 		paths_.emplace_back(path);
 		break;
 	}
 }
 // Añade un recorrido
 void PathSprite::addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction, int waiting_counter)
 {
 	paths_.emplace_back(createPath(start, end, type, fixed_pos, steps, easingFunction), waiting_counter);
 }
 // Añade un recorrido
 void PathSprite::addPath(std::vector<SDL_Point> spots, int waiting_counter)
 {
 	paths_.emplace_back(std::move(spots), waiting_counter);
 }
 // Habilita el objeto
 void PathSprite::enable()
 {
 	enabled_ = true;
 }
 // Coloca el sprite en los diferentes puntos del recorrido
 void PathSprite::moveThroughCurrentPath()
 {
 	auto &path = paths_.at(current_path_);
 	// Establece la posición
 	const auto &p = path.spots.at(path.counter);
 	setPosition(p);
 	// Comprobar si ha terminado el recorrido
 	if (!path.on_destination)
 	{
 		++path.counter;
 		if (path.counter >= static_cast<int>(path.spots.size()))
 		{
 			path.on_destination = true;
 			path.counter = static_cast<int>(path.spots.size()) - 1;
 		}
 	}
 	// Comprobar si ha terminado la espera
 	if (path.on_destination)
 	{
 		if (path.waiting_counter == 0)
 			path.finished = true;
 		else
 			--path.waiting_counter;
 	}
 }
 // Cambia de recorrido o finaliza
 void PathSprite::goToNextPathOrDie()
 {
 	// Comprueba si ha terminado el recorrdo actual
 	if (paths_.at(current_path_).finished)
 		++current_path_;
 	// Comprueba si quedan mas recorridos
 	if (current_path_ >= static_cast<int>(paths_.size()))
 		enabled_ = false;
 }
 // Indica si ha terminado todos los recorridos
 bool PathSprite::hasFinished()
 {
 	return !enabled_;
 }
--- a/source/path_sprite.h
+++ b/source/path_sprite.h
@@ -0,0 +1,76 @@
 #pragma once
 #include <SDL2/SDL_rect.h> // Para SDL_Point
 #include <functional>	   // Para function
 #include <memory>		   // Para shared_ptr
 #include <vector>		   // Para vector
 #include "sprite.h"		   // Para Sprite
 class Texture;			   // lines 8-8
 enum class PathType
 {
 	VERTICAL,
 	HORIZONTAL,
 };
 enum class PathCentered
 {
 	ON_X,
 	ON_Y,
 	NONE,
 };
 // Estructuras
 struct Path
 {
 	std::vector<SDL_Point> spots; // Puntos por los que se desplazará el sprite
 	int waiting_counter;		  // Tiempo de espera una vez en el destino
 	bool on_destination = false;  // Indica si ha llegado al destino
 	bool finished = false;		  // Indica si ha terminado de esperarse
 	int counter = 0;			  // Contador interno
 	// Constructor
 	Path(const std::vector<SDL_Point> &spots_init, int waiting_counter_init)
 		: spots(spots_init), waiting_counter(waiting_counter_init) {}
 };
 // Devuelve un vector con los puntos que conforman la ruta
 std::vector<SDL_Point> createPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction);
 // Clase PathSprite
 class PathSprite : public Sprite
 {
 private:
 	// Variables
 	bool enabled_ = false;	  // Indica si el objeto está habilitado
 	int current_path_ = 0;	  // Path que se está recorriendo actualmente
 	std::vector<Path> paths_; // Caminos a recorrer por el sprite
 	// Coloca el sprite en los diferentes puntos del recorrido
 	void moveThroughCurrentPath();
 	// Cambia de recorrido o finaliza
 	void goToNextPathOrDie();
 public:
 	// Constructor
 	explicit PathSprite(std::shared_ptr<Texture> texture)
 		: Sprite(texture) {}
 	// Destructor
 	~PathSprite() = default;
 	// Actualiza la posición del sprite
 	void update();
 	// Añade un recorrido
 	void addPath(Path path, bool centered = false);
 	void addPath(std::vector<SDL_Point> spots, int waiting_counter);
 	void addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction, int waiting_counter);
 	// Habilita el objeto
 	void enable();
 	// Indica si ha terminado todos los recorridos
 	bool hasFinished();
 };
--- a/source/player.cpp
+++ b/source/player.cpp
@@ -1,14 +1,15 @@
 #include "player.h"
-#include <SDL2/SDL_render.h> // for SDL_FLIP_HORIZONTAL, SDL_FLIP_NONE, SDL...
+#include <SDL2/SDL_render.h>	  // Para SDL_FLIP_HORIZONTAL, SDL_FLIP_NONE
-#include <SDL2/SDL_timer.h>	 // for SDL_GetTicks
+#include <SDL2/SDL_timer.h>		  // Para SDL_GetTicks
-#include <stdlib.h>			 // for rand
+#include <stdlib.h>				  // Para rand
-#include <algorithm>		 // for max, min
+#include <algorithm>			  // Para max, min
-#include "animated_sprite.h" // for SpriteAnimated
+#include "animated_sprite.h"	  // Para AnimatedSprite
-#include "input.h"			 // for inputs_e
+#include "input.h"				  // Para InputType
-#include "param.h"			 // for param
+#include "manage_hiscore_table.h" // Para HiScoreEntry
-#include "texture.h"		 // for Texture
+#include "options.h"			  // Para Options, OptionsGame, options
-#include "scoreboard.h"		 // for Texture
+#include "param.h"				  // Para Param, ParamGame, param
-#include "options.h"
+#include "scoreboard.h"			  // Para Scoreboard, ScoreboardMode
 #include "texture.h"			  // Para Texture
 // Constructor
 Player::Player(int id, float x, int y, bool demo, SDL_Rect &play_area, std::vector<std::shared_ptr<Texture>> texture, const std::vector<std::vector<std::string>> &animations)
@@ -22,6 +23,7 @@ Player::Player(int id, float x, int y, bool demo, SDL_Rect &play_area, std::vect
 	  demo_(demo)
 {
 	// Configura objetos
 	player_sprite_->getTexture()->setPalette(coffees_);
 	power_sprite_->getTexture()->setAlpha(224);
 	power_up_desp_x_ = (power_sprite_->getWidth() - player_sprite_->getWidth()) / 2;
 	power_sprite_->setPosY(y - (power_sprite_->getHeight() - player_sprite_->getHeight()));
@@ -37,9 +39,9 @@ void Player::init()
 	// Inicializa variables de estado
 	pos_x_ = default_pos_x_;
 	pos_y_ = default_pos_y_;
-	status_walking_ = PlayerStatus::WALKING_STOP;
+	walking_state_ = PlayerState::WALKING_STOP;
-	status_firing_ = PlayerStatus::FIRING_NONE;
+	firing_state_ = PlayerState::FIRING_NONE;
-	status_playing_ = PlayerStatus::WAITING;
+	playing_state_ = PlayerState::WAITING;
 	invulnerable_ = true;
 	invulnerable_counter_ = INVULNERABLE_COUNTER_;
 	power_up_ = false;
@@ -59,8 +61,7 @@ void Player::init()
 	// Establece la posición del sprite
 	player_sprite_->clear();
-	player_sprite_->setPosX(pos_x_);
+	shiftSprite();
 	player_sprite_->setPosY(pos_y_);
 	// Selecciona un frame para pintar
 	player_sprite_->setCurrentAnimation("stand");
@@ -69,20 +70,19 @@ void Player::init()
 // Actua en consecuencia de la entrada recibida
 void Player::setInput(InputType input)
 {
-	switch (status_playing_)
+	switch (playing_state_)
 	{
-	case PlayerStatus::PLAYING:
+	case PlayerState::PLAYING:
 	{
 		setInputPlaying(input);
 		break;
 	}
-
+	case PlayerState::ENTERING_NAME:
-	case PlayerStatus::ENTERING_NAME:
+	case PlayerState::ENTERING_NAME_GAME_COMPLETED:
 	{
 		setInputEnteringName(input);
 		break;
 	}
 	default:
 		break;
 	}
@@ -96,39 +96,34 @@ void Player::setInputPlaying(InputType input)
 	case InputType::LEFT:
 	{
 		vel_x_ = -BASE_SPEED_;
-		setWalkingStatus(PlayerStatus::WALKING_LEFT);
+		setWalkingState(PlayerState::WALKING_LEFT);
 		break;
 	}
 	case InputType::RIGHT:
 	{
 		vel_x_ = BASE_SPEED_;
-		setWalkingStatus(PlayerStatus::WALKING_RIGHT);
+		setWalkingState(PlayerState::WALKING_RIGHT);
 		break;
 	}
 	case InputType::FIRE_CENTER:
 	{
-		setFiringStatus(PlayerStatus::FIRING_UP);
+		setFiringState(PlayerState::FIRING_UP);
 		break;
 	}
 	case InputType::FIRE_LEFT:
 	{
-		setFiringStatus(PlayerStatus::FIRING_LEFT);
+		setFiringState(PlayerState::FIRING_LEFT);
 		break;
 	}
 	case InputType::FIRE_RIGHT:
 	{
-		setFiringStatus(PlayerStatus::FIRING_RIGHT);
+		setFiringState(PlayerState::FIRING_RIGHT);
 		break;
 	}
 	default:
 	{
 		vel_x_ = 0;
-		setWalkingStatus(PlayerStatus::WALKING_STOP);
+		setWalkingState(PlayerState::WALKING_STOP);
 		break;
 	}
 	}
@@ -142,23 +137,18 @@ void Player::setInputEnteringName(InputType input)
 	case InputType::LEFT:
 		enter_name_->decPosition();
 		break;
 	case InputType::RIGHT:
 		enter_name_->incPosition();
 		break;
 	case InputType::UP:
 		enter_name_->incIndex();
 		break;
 	case InputType::DOWN:
 		enter_name_->decIndex();
 		break;
 	case InputType::START:
 		setRecordName(enter_name_->getName());
 		break;
 	default:
 		break;
 	}
@@ -168,44 +158,57 @@ void Player::setInputEnteringName(InputType input)
 // Mueve el jugador a la posición y animación que le corresponde
 void Player::move()
 {
-	if (isPlaying())
+	switch (playing_state_)
 	{
 	case PlayerState::PLAYING:
 	{
 		// Mueve el jugador a derecha o izquierda
 		pos_x_ += vel_x_;
-		// Si el jugador abandona el area de juego por los laterales
+		// Si el jugador abandona el area de juego por los laterales, restaura su posición
-		if ((pos_x_ < param.game.play_area.rect.x - 5) || (pos_x_ + WIDTH_ > play_area_.w + 5))
+		const float min_x = param.game.play_area.rect.x - 5;
-		{
+		const float max_x = play_area_.w + 5 - WIDTH_;
-			// Restaura su posición
+		pos_x_ = std::clamp(pos_x_, min_x, max_x);
 			pos_x_ -= vel_x_;
 		}
-		// Actualiza la posición del sprite
+		shiftSprite();
-		player_sprite_->setPosX(getPosX());
+		break;
 		player_sprite_->setPosY(pos_y_);
 		power_sprite_->setPosX(getPosX() - power_up_desp_x_);
 	}
-	else if (isDying())
+	case PlayerState::DYING:
 	{
-		player_sprite_->update();
+		// Si el cadaver abandona el area de juego por los laterales lo hace rebotar
 		// Si el cadaver abandona el area de juego por los laterales
 		if ((player_sprite_->getPosX() < param.game.play_area.rect.x) || (player_sprite_->getPosX() + WIDTH_ > play_area_.w))
-		{
+			player_sprite_->setVelX(-player_sprite_->getVelX());
 			// Restaura su posición
 			const float vx = player_sprite_->getVelX();
 			player_sprite_->setPosX(player_sprite_->getPosX() - vx);
 			// Rebota
 			player_sprite_->setVelX(-vx);
 		}
 		// Si el cadaver abandona el area de juego por abajo
 		if (player_sprite_->getPosY() > param.game.play_area.rect.h)
 			setPlayingState(PlayerState::DIED);
 		break;
 	}
 	case PlayerState::GAME_COMPLETED:
 	{
 		switch (id_)
 		{
-			setStatusPlaying(PlayerStatus::DIED);
+		case 1:
 			setInputPlaying(InputType::LEFT);
 			break;
 		case 2:
 			setInputPlaying(InputType::RIGHT);
 			break;
 		default:
 			break;
 		}
 		pos_x_ += vel_x_;
 		const float min_x = -WIDTH_;
 		const float max_x = play_area_.w;
 		pos_x_ = std::clamp(pos_x_, min_x, max_x);
 		shiftSprite();
 		if (pos_x_ == min_x || pos_x_ == max_x)
 			setPlayingState(PlayerState::GAME_OVER);
 		break;
 	}
 	default:
 		break;
 	}
 }
@@ -213,118 +216,95 @@ void Player::move()
 void Player::render()
 {
 	if (power_up_ && isPlaying())
 	{
 		if (power_up_counter_ > (POWERUP_COUNTER_ / 4) || power_up_counter_ % 20 > 4)
 		{
 			power_sprite_->render();
 		}
 	}
 	if (isRenderable())
 		player_sprite_->render();
 }
 // Establece el estado del jugador cuando camina
 void Player::setWalkingStatus(PlayerStatus status)
 {
 	status_walking_ = status;
 }
 // Establece el estado del jugador cuando dispara
 void Player::setFiringStatus(PlayerStatus status)
 {
 	status_firing_ = status;
 }
 // Establece la animación correspondiente al estado
 void Player::setAnimation()
 {
 	// Crea cadenas de texto para componer el nombre de la animación
-	const std::string a_walking = status_walking_ == PlayerStatus::WALKING_STOP ? "stand" : "walk";
+	const std::string a_walking = walking_state_ == PlayerState::WALKING_STOP ? "stand" : "walk";
-	const std::string a_firing = status_firing_ == PlayerStatus::FIRING_UP ? "centershoot" : "sideshoot";
+	const std::string a_firing = firing_state_ == PlayerState::FIRING_UP ? "centershoot" : "sideshoot";
 	const std::string a_cooling = firing_state_ == PlayerState::COOLING_UP ? "centershoot" : "sideshoot";
-	const SDL_RendererFlip flip_walk = status_walking_ == PlayerStatus::WALKING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
+	const SDL_RendererFlip flip_walk = walking_state_ == PlayerState::WALKING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
-	const SDL_RendererFlip flip_fire = status_firing_ == PlayerStatus::FIRING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
+	const SDL_RendererFlip flip_fire = firing_state_ == PlayerState::FIRING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
 	const SDL_RendererFlip flip_cooling = firing_state_ == PlayerState::COOLING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
 	// Establece la animación a partir de las cadenas
-	if (isPlaying())
+	if (isPlaying() || isEnteringNameGameCompleted() || isGameCompleted())
 	{
-		if (status_firing_ == PlayerStatus::FIRING_NONE)
+		if (firing_state_ == PlayerState::FIRING_NONE)
 		{ // No esta disparando
 			player_sprite_->setCurrentAnimation(a_walking);
 			player_sprite_->setFlip(flip_walk);
 		}
 		else if (isCooling())
 		{ // Acaba de disparar
 			player_sprite_->setCurrentAnimation(a_walking + "-" + a_cooling + "-cooldown");
 			player_sprite_->setFlip(flip_cooling);
 		}
 		else
 		{ // Está disparando
 			player_sprite_->setCurrentAnimation(a_walking + "-" + a_firing);
 			// Si dispara de lado, invierte el sprite segun hacia donde dispara
 			// Si dispara recto, invierte el sprite segun hacia donde camina
-			a_firing == "centershoot" ? player_sprite_->setFlip(flip_walk) : player_sprite_->setFlip(flip_fire);
+			player_sprite_->setFlip(a_firing == "centershoot" ? flip_walk : flip_fire);
 		}
 	}
-	else
+	else if (isDying() || hasDied())
 	{
 		player_sprite_->setCurrentAnimation("death");
 	}
 	else if (isCelebrating())
 	{
 		player_sprite_->setCurrentAnimation("celebration");
 	}
 	// Actualiza las animaciones de los sprites
-	player_sprite_->update();
+	player_sprite_->update(); // Hace avanzar las animaciones y mueve el cadaver del jugador
 	// powerSprite->setFlip(flip_walk);
 	power_sprite_->update();
 }
 // Obtiene el valor de la variable
 int Player::getPosX() const
 {
 	return int(pos_x_);
 }
 // Obtiene el valor de la variable
 int Player::getPosY() const
 {
 	return pos_y_;
 }
 // Obtiene el valor de la variable
 int Player::getWidth() const
 {
 	return WIDTH_;
 }
 // Obtiene el valor de la variable
 int Player::getHeight() const
 {
 	return HEIGHT_;
 }
 // Indica si el jugador puede disparar
 bool Player::canFire() const
 {
 	// Si el contador a llegado a cero, podemos disparar. En caso contrario decrementamos el contador
 	return cooldown_ > 0 ? false : true;
 }
 // Establece el valor de la variable
 void Player::setFireCooldown(int time)
 {
 	cooldown_ = time;
 }
 // Actualiza el valor de la variable
 void Player::updateCooldown()
 {
 	if (cooldown_ > 0)
 	{
-		cooldown_--;
+		cooldown_ -= power_up_ ? 2 : 1;
 		if (power_up_)
 		{
 			cooldown_--;
 		}
 	}
 	else
 	{
-		setFiringStatus(PlayerStatus::FIRING_NONE);
+		if (!isCooling())
 		{
 			cooling_status_counter_ = 40;
 			switch (firing_state_)
 			{
 			case PlayerState::FIRING_LEFT:
 				firing_state_ = PlayerState::COOLING_LEFT;
 				break;
 			case PlayerState::FIRING_RIGHT:
 				firing_state_ = PlayerState::COOLING_RIGHT;
 				break;
 			case PlayerState::FIRING_UP:
 				firing_state_ = PlayerState::COOLING_UP;
 				break;
 			default:
 				break;
 			}
 		}
 		else if (cooling_status_counter_ > 0)
 		{
 			--cooling_status_counter_;
 		}
 		else
 		{
 			setFiringState(PlayerState::FIRING_NONE);
 		}
 	}
 }
@@ -342,18 +322,6 @@ void Player::update()
 	updateScoreboard();
 }
 // Obtiene la puntuación del jugador
 int Player::getScore() const
 {
 	return score_;
 }
 // Asigna un valor a la puntuación del jugador
 void Player::setScore(int score)
 {
 	score_ = score;
 }
 // Incrementa la puntuación del jugador
 void Player::addScore(int score)
 {
@@ -363,67 +331,23 @@ void Player::addScore(int score)
 	}
 }
 // Indica si el jugador está jugando
 bool Player::isPlaying() const
 {
 	return status_playing_ == PlayerStatus::PLAYING;
 }
 // Indica si el jugador está continuando
 bool Player::isContinue() const
 {
 	return status_playing_ == PlayerStatus::CONTINUE;
 }
 // Indica si el jugador está esperando
 bool Player::isWaiting() const
 {
 	return status_playing_ == PlayerStatus::WAITING;
 }
 // Indica si el jugador está introduciendo su nombre
 bool Player::isEnteringName() const
 {
 	return status_playing_ == PlayerStatus::ENTERING_NAME;
 }
 // Indica si el jugador está muriendose
 bool Player::isDying() const
 {
 	return status_playing_ == PlayerStatus::DYING;
 }
 // Indica si el jugador ha terminado de morir
 bool Player::hasDied() const
 {
 	return status_playing_ == PlayerStatus::DIED;
 }
 // Indica si el jugador ya ha terminado de jugar
 bool Player::isGameOver() const
 {
 	return status_playing_ == PlayerStatus::GAME_OVER;
 }
 // Actualiza el panel del marcador
 void Player::updateScoreboard()
 {
-	switch (status_playing_)
+	switch (playing_state_)
 	{
-
+	case PlayerState::CONTINUE:
 	case PlayerStatus::CONTINUE:
 	{
 		Scoreboard::get()->setContinue(getScoreBoardPanel(), getContinueCounter());
 		break;
 	}
-
+	case PlayerState::ENTERING_NAME:
-	case PlayerStatus::ENTERING_NAME:
+	case PlayerState::ENTERING_NAME_GAME_COMPLETED:
 	{
 		Scoreboard::get()->setRecordName(getScoreBoardPanel(), getRecordName());
 		Scoreboard::get()->setSelectorPos(getScoreBoardPanel(), getRecordNamePos());
 		break;
 	}
 	default:
 		break;
 	}
@@ -439,21 +363,20 @@ void Player::setScoreboardMode(ScoreboardMode mode)
 }
 // Establece el estado del jugador en el juego
-void Player::setStatusPlaying(PlayerStatus value)
+void Player::setPlayingState(PlayerState state)
 {
-	status_playing_ = value;
+	playing_state_ = state;
-	switch (status_playing_)
+	switch (playing_state_)
 	{
-	case PlayerStatus::PLAYING:
+	case PlayerState::PLAYING:
 	{
 		init();
-		status_playing_ = PlayerStatus::PLAYING;
+		playing_state_ = PlayerState::PLAYING;
 		setScoreboardMode(ScoreboardMode::SCORE);
 		break;
 	}
-
+	case PlayerState::CONTINUE:
 	case PlayerStatus::CONTINUE:
 	{
 		// Inicializa el contador de continuar
 		continue_ticks_ = SDL_GetTicks();
@@ -462,20 +385,17 @@ void Player::setStatusPlaying(PlayerStatus value)
 		setScoreboardMode(ScoreboardMode::CONTINUE);
 		break;
 	}
-
+	case PlayerState::WAITING:
 	case PlayerStatus::WAITING:
 	{
 		setScoreboardMode(ScoreboardMode::WAITING);
 		break;
 	}
-
+	case PlayerState::ENTERING_NAME:
 	case PlayerStatus::ENTERING_NAME:
 	{
 		setScoreboardMode(ScoreboardMode::ENTER_NAME);
 		break;
 	}
-
+	case PlayerState::DYING:
 	case PlayerStatus::DYING:
 	{
 		// Activa la animación de morir
 		player_sprite_->setAccelY(0.2f);
@@ -483,43 +403,39 @@ void Player::setStatusPlaying(PlayerStatus value)
 		rand() % 2 == 0 ? player_sprite_->setVelX(3.3f) : player_sprite_->setVelX(-3.3f);
 		break;
 	}
-
+	case PlayerState::DIED:
 	case PlayerStatus::DIED:
 	{
-		const auto nextPlayerStatus = IsEligibleForHighScore() ? PlayerStatus::ENTERING_NAME : PlayerStatus::CONTINUE;
+		const auto nextPlayerStatus = IsEligibleForHighScore() ? PlayerState::ENTERING_NAME : PlayerState::CONTINUE;
-		demo_ ? setStatusPlaying(PlayerStatus::WAITING) : setStatusPlaying(nextPlayerStatus);
+		demo_ ? setPlayingState(PlayerState::WAITING) : setPlayingState(nextPlayerStatus);
 		break;
 	}
-
+	case PlayerState::GAME_OVER:
 	case PlayerStatus::GAME_OVER:
 	{
 		setScoreboardMode(ScoreboardMode::GAME_OVER);
 		break;
 	}
-
+	case PlayerState::CELEBRATING:
 	{
 		setScoreboardMode(ScoreboardMode::SCORE);
 		break;
 	}
 	case PlayerState::ENTERING_NAME_GAME_COMPLETED:
 	{
 		setWalkingState(PlayerState::WALKING_STOP);
 		setFiringState(PlayerState::FIRING_NONE);
 		setScoreboardMode(ScoreboardMode::ENTER_NAME);
 		break;
 	}
 	case PlayerState::GAME_COMPLETED:
 	{
 		setScoreboardMode(ScoreboardMode::GAME_COMPLETED);
 		break;
 	}
 	default:
 		break;
 	}
 }
 // Obtiene el estado del jugador en el juego
 PlayerStatus Player::getStatusPlaying() const
 {
 	return status_playing_;
 }
 // Obtiene el valor de la variable
 float Player::getScoreMultiplier() const
 {
 	return score_multiplier_;
 }
 // Establece el valor de la variable
 void Player::setScoreMultiplier(float value)
 {
 	score_multiplier_ = value;
 }
 // Aumenta el valor de la variable hasta un máximo
 void Player::incScoreMultiplier()
 {
@@ -534,12 +450,6 @@ void Player::decScoreMultiplier()
 	score_multiplier_ = std::max(score_multiplier_, 1.0f);
 }
 // Obtiene el valor de la variable
 bool Player::isInvulnerable() const
 {
 	return invulnerable_;
 }
 // Establece el valor del estado
 void Player::setInvulnerable(bool value)
 {
@@ -547,18 +457,6 @@ void Player::setInvulnerable(bool value)
 	invulnerable_counter_ = invulnerable_ ? INVULNERABLE_COUNTER_ : 0;
 }
 // Obtiene el valor de la variable
 int Player::getInvulnerableCounter() const
 {
 	return invulnerable_counter_;
 }
 // Establece el valor de la variable
 void Player::setInvulnerableCounter(int value)
 {
 	invulnerable_counter_ = value;
 }
 // Monitoriza el estado
 void Player::updateInvulnerable()
 {
@@ -577,12 +475,6 @@ void Player::updateInvulnerable()
 	}
 }
 // Obtiene el valor de la variable
 bool Player::isPowerUp() const
 {
 	return power_up_;
 }
 // Establece el valor de la variable
 void Player::setPowerUp()
 {
@@ -590,18 +482,6 @@ void Player::setPowerUp()
 	power_up_counter_ = POWERUP_COUNTER_;
 }
 // Obtiene el valor de la variable
 int Player::getPowerUpCounter() const
 {
 	return power_up_counter_;
 }
 // Establece el valor de la variable
 void Player::setPowerUpCounter(int value)
 {
 	power_up_counter_ = value;
 }
 // Actualiza el valor de la variable
 void Player::updatePowerUp()
 {
@@ -612,12 +492,6 @@ void Player::updatePowerUp()
 	}
 }
 // Obtiene el valor de la variable
 bool Player::hasExtraHit() const
 {
 	return extra_hit_;
 }
 // Concede un toque extra al jugador
 void Player::giveExtraHit()
 {
@@ -642,18 +516,6 @@ void Player::removeExtraHit()
 	extra_hit_ = coffees_ == 0 ? false : true;
 }
 // Devuelve el número de cafes actuales
 int Player::getCoffees() const
 {
 	return coffees_;
 }
 // Obtiene el circulo de colisión
 Circle &Player::getCollider()
 {
 	return collider_;
 }
 // Actualiza el circulo de colisión a la posición del jugador
 void Player::shiftColliders()
 {
@@ -668,16 +530,10 @@ void Player::setPlayerTextures(const std::vector<std::shared_ptr<Texture>> &text
 	power_sprite_->setTexture(texture[1]);
 }
 // Obtiene el valor de la variable
 int Player::getContinueCounter() const
 {
 	return continue_counter_;
 }
 // Actualiza el contador de continue
 void Player::updateContinueCounter()
 {
-	if (status_playing_ == PlayerStatus::CONTINUE)
+	if (playing_state_ == PlayerState::CONTINUE)
 	{
 		constexpr int TICKS_SPEED = 1000;
 		if (SDL_GetTicks() - continue_ticks_ > TICKS_SPEED)
@@ -690,7 +546,7 @@ void Player::updateContinueCounter()
 // Actualiza el contador de entrar nombre
 void Player::updateEnterNameCounter()
 {
-	if (status_playing_ == PlayerStatus::ENTERING_NAME)
+	if (playing_state_ == PlayerState::ENTERING_NAME || playing_state_ == PlayerState::ENTERING_NAME_GAME_COMPLETED)
 	{
 		constexpr int TICKS_SPEED = 1000;
 		if (SDL_GetTicks() - enter_name_ticks_ > TICKS_SPEED)
@@ -700,18 +556,6 @@ void Player::updateEnterNameCounter()
 	}
 }
 // Le asigna un panel en el marcador al jugador
 void Player::setScoreBoardPanel(int panel)
 {
 	scoreboard_panel_ = panel;
 }
 // Obtiene el valor de la variable
 int Player::getScoreBoardPanel() const
 {
 	return scoreboard_panel_;
 }
 // Decrementa el contador de continuar
 void Player::decContinueCounter()
 {
@@ -719,7 +563,7 @@ void Player::decContinueCounter()
 	--continue_counter_;
 	if (continue_counter_ < 0)
 	{
-		setStatusPlaying(PlayerStatus::GAME_OVER);
+		setPlayingState(PlayerState::GAME_OVER);
 	}
 }
@@ -731,71 +575,72 @@ void Player::decEnterNameCounter()
 	if (enter_name_counter_ < 0)
 	{
 		enter_name_counter_ = param.game.enter_name_seconds;
-		setStatusPlaying(PlayerStatus::CONTINUE);
+		if (playing_state_ == PlayerState::ENTERING_NAME)
 			setPlayingState(PlayerState::CONTINUE);
 		else
 			setPlayingState(PlayerState::GAME_COMPLETED);
 	}
 }
-// Establece el nombre del jugador
+// Obtiene la posición que se está editando del nombre del jugador para la tabla de mejores puntuaciones
 void Player::setName(const std::string &name)
 {
 	name_ = name;
 }
 // Establece el nombre del jugador para la tabla de mejores puntuaciones
 void Player::setRecordName(const std::string &record_name)
 {
 	record_name_ = record_name.substr(0, 8);
 }
 // Obtiene el nombre del jugador
 std::string Player::getName() const
 {
 	return name_;
 }
 // Obtiene el nombre del jugador para la tabla de mejores puntuaciones
 std::string Player::getRecordName() const
 {
 	return record_name_;
 }
 // Obtiene la posici´´on que se está editando del nombre del jugador para la tabla de mejores puntuaciones
 int Player::getRecordNamePos() const
 {
 	if (enter_name_)
 	{
 		return enter_name_->getPosition();
 	}
 	return 0;
 }
-// Establece el mando que usará para ser controlado
+// Recoloca los sprites
-void Player::setController(int index)
+void Player::shiftSprite()
 {
-	controller_index_ = index;
+	player_sprite_->setPosX(pos_x_);
 	player_sprite_->setPosY(pos_y_);
 	power_sprite_->setPosX(getPosX() - power_up_desp_x_);
 }
-// Obtiene el mando que usa para ser controlado
+int Player::getScore() const { return score_; }
-int Player::getController() const
+void Player::setScore(int score) { score_ = score; }
-{
+PlayerState Player::getPlayingState() const { return playing_state_; }
-	return controller_index_;
+float Player::getScoreMultiplier() const { return score_multiplier_; }
-}
+void Player::setScoreMultiplier(float value) { score_multiplier_ = value; }
-
+bool Player::isInvulnerable() const { return invulnerable_; }
-// Obtiene el "id" del jugador
+int Player::getInvulnerableCounter() const { return invulnerable_counter_; }
-int Player::getId() const
+void Player::setInvulnerableCounter(int value) { invulnerable_counter_ = value; }
-{
+bool Player::isPowerUp() const { return power_up_; }
-	return id_;
+int Player::getPowerUpCounter() const { return power_up_counter_; }
-}
+void Player::setPowerUpCounter(int value) { power_up_counter_ = value; }
-
+bool Player::hasExtraHit() const { return extra_hit_; }
-// Indica si el jugador se puede dibujar
+void Player::setScoreBoardPanel(int panel) { scoreboard_panel_ = panel; }
-bool Player::isRenderable() const
+int Player::getScoreBoardPanel() const { return scoreboard_panel_; }
-{
+int Player::getCoffees() const { return coffees_; }
-	return isPlaying() || isDying();
+Circle &Player::getCollider() { return collider_; }
-}
+int Player::getContinueCounter() const { return continue_counter_; }
-
+void Player::setName(const std::string &name) { name_ = name; }
-// Comprueba si la puntuación entra en la tabla de mejores puntuaciones
+void Player::setRecordName(const std::string &record_name) { record_name_ = record_name.substr(0, 8); }
-bool Player::IsEligibleForHighScore()
+std::string Player::getName() const { return name_; }
-{
+std::string Player::getRecordName() const { return record_name_; }
-	return score_ > options.game.hi_score_table.back().score;
+void Player::setController(int index) { controller_index_ = index; }
-}
+int Player::getController() const { return controller_index_; }
 int Player::getId() const { return id_; }
 bool Player::isRenderable() const { return isPlaying() || isDying() || isCelebrating() || isEnteringNameGameCompleted() || isGameCompleted(); }
 bool Player::IsEligibleForHighScore() { return score_ > options.game.hi_score_table.back().score; }
 bool Player::isCooling() { return firing_state_ == PlayerState::COOLING_LEFT || firing_state_ == PlayerState::COOLING_UP || firing_state_ == PlayerState::COOLING_RIGHT; }
 int Player::getPosX() const { return static_cast<int>(pos_x_); }
 int Player::getPosY() const { return pos_y_; }
 int Player::getWidth() const { return WIDTH_; }
 int Player::getHeight() const { return HEIGHT_; }
 bool Player::canFire() const { return cooldown_ > 0 ? false : true; }
 void Player::setFireCooldown(int time) { cooldown_ = time; }
 void Player::setWalkingState(PlayerState state) { walking_state_ = state; }
 void Player::setFiringState(PlayerState state) { firing_state_ = state; }
 bool Player::isPlaying() const { return playing_state_ == PlayerState::PLAYING; }
 bool Player::isContinue() const { return playing_state_ == PlayerState::CONTINUE; }
 bool Player::isWaiting() const { return playing_state_ == PlayerState::WAITING; }
 bool Player::isEnteringName() const { return playing_state_ == PlayerState::ENTERING_NAME; }
 bool Player::isDying() const { return playing_state_ == PlayerState::DYING; }
 bool Player::hasDied() const { return playing_state_ == PlayerState::DIED; }
 bool Player::isGameOver() const { return playing_state_ == PlayerState::GAME_OVER; }
 bool Player::isEnteringNameGameCompleted() const { return playing_state_ == PlayerState::ENTERING_NAME_GAME_COMPLETED; }
 bool Player::isGameCompleted() const { return playing_state_ == PlayerState::GAME_COMPLETED; }
 bool Player::isCelebrating() const { return playing_state_ == PlayerState::CELEBRATING; }
--- a/source/player.h
+++ b/source/player.h
@@ -1,20 +1,20 @@
 #pragma once
-#include <SDL2/SDL_rect.h>	 // for SDL_Rect
+#include "animated_sprite.h" // Para AnimatedSprite
-#include <SDL2/SDL_stdinc.h> // for Uint32
+#include "enter_name.h"		 // Para EnterName
-#include <memory>			 // for unique_ptr, shared_ptr
+#include "utils.h"			 // Para Circle
-#include <string>			 // for string
+#include <SDL2/SDL_rect.h>	 // Para SDL_Rect
-#include <vector>			 // for vector
+#include <SDL2/SDL_stdinc.h> // Para Uint32
-#include "animated_sprite.h" // for SpriteAnimated
+#include <memory>			 // Para unique_ptr, shared_ptr
-#include "smart_sprite.h"	 // for SpriteAnimated
+#include <string>			 // Para string
-#include "enter_name.h"		 // for EnterName
+#include <vector>			 // Para vector
-#include "utils.h"			 // for Circle
+
-class Texture;
+class Texture;				// lines 12-12
-enum class InputType : int;
+enum class InputType : int; // lines 13-13
-enum class ScoreboardMode; // lines 12-12
+enum class ScoreboardMode;	// lines 14-14
 // Estados del jugador
-enum class PlayerStatus
+enum class PlayerState
 {
 	WALKING_LEFT,
 	WALKING_RIGHT,
@@ -25,27 +25,32 @@ enum class PlayerStatus
 	FIRING_RIGHT,
 	FIRING_NONE,
-	PLAYING,
+	COOLING_UP,
-	CONTINUE,
+	COOLING_LEFT,
-	WAITING,
+	COOLING_RIGHT,
 	ENTERING_NAME,
 	DYING,
 	DIED,
 	GAME_OVER,
 };
-// Variables del jugador
+	PLAYING,					  // Está jugando
 	CONTINUE,					  // Está con la cuenta atras para continuar
 	WAITING,					  // No está jugando pero puede entrar a jugar
 	ENTERING_NAME,				  // Introduciendo nombre
 	DYING,						  // El cadaver está volando por ahi
 	DIED,						  // El cadaver ha desaparecido por el fondo
 	GAME_OVER,					  // No está jugando y no puede entrar a jugar
 	CELEBRATING,				  // Poniendo pose de victoria
 	ENTERING_NAME_GAME_COMPLETED, // Poniendo nombre en el tramo final del juego
 	GAME_COMPLETED,				  // Moviendose fuera de la pantalla
 };
 // Clase Player
 class Player
 {
 private:
 	// Constantes
-	static constexpr int POWERUP_COUNTER_ = 1500;		  // Duración del estado PowerUp
+	static constexpr int POWERUP_COUNTER_ = 1500;	  // Duración del estado PowerUp
-	static constexpr int INVULNERABLE_COUNTER_ = 200;	  // Duración del estado invulnerable
+	static constexpr int INVULNERABLE_COUNTER_ = 200; // Duración del estado invulnerable
-	static constexpr int WIDTH_ = 30;					  // Anchura
+	static constexpr int WIDTH_ = 30;				  // Anchura
-	static constexpr int HEIGHT_ = 30;					  // Altura
+	static constexpr int HEIGHT_ = 30;				  // Altura
-	static constexpr float BASE_SPEED_ = 1.5f;			  // Velocidad base del jugador
+	static constexpr float BASE_SPEED_ = 1.5f;		  // Velocidad base del jugador
 	// Objetos y punteros
 	std::unique_ptr<AnimatedSprite> player_sprite_; // Sprite para dibujar el jugador
@@ -53,41 +58,45 @@ private:
 	std::unique_ptr<EnterName> enter_name_;			// Clase utilizada para introducir el nombre
 	// Variables
-	int id_;												   // Numero de identificación para el jugador. Player1 = 1, Player2 = 2
+	int id_;												// Numero de identificación para el jugador. Player1 = 1, Player2 = 2
-	SDL_Rect play_area_;									   // Rectangulo con la zona de juego
+	SDL_Rect play_area_;									// Rectangulo con la zona de juego
-	float pos_x_ = 0.0f;									   // Posicion en el eje X
+	float pos_x_ = 0.0f;									// Posicion en el eje X
-	int pos_y_ = 0;											   // Posicion en el eje Y
+	int pos_y_ = 0;											// Posicion en el eje Y
-	float default_pos_x_;									   // Posición inicial para el jugador
+	float default_pos_x_;									// Posición inicial para el jugador
-	int default_pos_y_;										   // Posición inicial para el jugador
+	int default_pos_y_;										// Posición inicial para el jugador
-	float vel_x_ = 0.0f;									   // Cantidad de pixeles a desplazarse en el eje X
+	float vel_x_ = 0.0f;									// Cantidad de pixeles a desplazarse en el eje X
-	int vel_y_ = 0.0f;										   // Cantidad de pixeles a desplazarse en el eje Y
+	int vel_y_ = 0.0f;										// Cantidad de pixeles a desplazarse en el eje Y
-	int cooldown_ = 10;										   // Contador durante el cual no puede disparar
+	int cooldown_ = 0;										// Contador durante el cual no puede disparar
-	int score_ = 0;											   // Puntos del jugador
+	int cooling_status_counter_ = 0;						// Contador para la animación del estado cooling
-	float score_multiplier_ = 1.0f;							   // Multiplicador de puntos
+	int score_ = 0;											// Puntos del jugador
-	PlayerStatus status_walking_ = PlayerStatus::WALKING_STOP; // Estado del jugador al moverse
+	float score_multiplier_ = 1.0f;							// Multiplicador de puntos
-	PlayerStatus status_firing_ = PlayerStatus::FIRING_NONE;   // Estado del jugador al disparar
+	PlayerState walking_state_ = PlayerState::WALKING_STOP; // Estado del jugador al moverse
-	PlayerStatus status_playing_ = PlayerStatus::WAITING;	   // Estado del jugador en el juego
+	PlayerState firing_state_ = PlayerState::FIRING_NONE;	// Estado del jugador al disparar
-	bool invulnerable_ = true;								   // Indica si el jugador es invulnerable
+	PlayerState playing_state_ = PlayerState::WAITING;		// Estado del jugador en el juego
-	int invulnerable_counter_ = INVULNERABLE_COUNTER_;		   // Contador para la invulnerabilidad
+	bool invulnerable_ = true;								// Indica si el jugador es invulnerable
-	bool extra_hit_ = false;								   // Indica si el jugador tiene un toque extra
+	int invulnerable_counter_ = INVULNERABLE_COUNTER_;		// Contador para la invulnerabilidad
-	int coffees_ = 0;										   // Indica cuantos cafes lleva acumulados
+	bool extra_hit_ = false;								// Indica si el jugador tiene un toque extra
-	bool power_up_ = false;									   // Indica si el jugador tiene activo el modo PowerUp
+	int coffees_ = 0;										// Indica cuantos cafes lleva acumulados
-	int power_up_counter_ = POWERUP_COUNTER_;				   // Temporizador para el modo PowerUp
+	bool power_up_ = false;									// Indica si el jugador tiene activo el modo PowerUp
-	int power_up_desp_x_ = 0;								   // Desplazamiento del sprite de PowerUp respecto al sprite del jugador
+	int power_up_counter_ = POWERUP_COUNTER_;				// Temporizador para el modo PowerUp
-	Circle collider_ = Circle(0, 0, 9);						   // Circulo de colisión del jugador
+	int power_up_desp_x_ = 0;								// Desplazamiento del sprite de PowerUp respecto al sprite del jugador
-	int continue_counter_ = 10;								   // Contador para poder continuar
+	Circle collider_ = Circle(0, 0, 9);						// Circulo de colisión del jugador
-	Uint32 continue_ticks_ = 0;								   // Variable para poder cambiar el contador de continue en función del tiempo
+	int continue_counter_ = 10;								// Contador para poder continuar
-	int scoreboard_panel_ = 0;								   // Panel del marcador asociado al jugador
+	Uint32 continue_ticks_ = 0;								// Variable para poder cambiar el contador de continue en función del tiempo
-	std::string name_;										   // Nombre del jugador
+	int scoreboard_panel_ = 0;								// Panel del marcador asociado al jugador
-	std::string record_name_;								   // Nombre del jugador para la tabla de mejores puntuaciones
+	std::string name_;										// Nombre del jugador
-	int controller_index_ = 0;								   // Indice del array de mandos que utilizará para moverse
+	std::string record_name_;								// Nombre del jugador para la tabla de mejores puntuaciones
-	bool demo_;												   // Para que el jugador sepa si está en el modo demostración
+	int controller_index_ = 0;								// Indice del array de mandos que utilizará para moverse
-	int enter_name_counter_;								   // Contador para poner nombre
+	bool demo_;												// Para que el jugador sepa si está en el modo demostración
-	Uint32 enter_name_ticks_ = 0;							   // Variable para poder cambiar el contador de poner nombre en función del tiempo
+	int enter_name_counter_;								// Contador para poner nombre
 	Uint32 enter_name_ticks_ = 0;							// Variable para poder cambiar el contador de poner nombre en función del tiempo
 	// Actualiza el circulo de colisión a la posición del jugador
 	void shiftColliders();
 	// Recoloca el sprite
 	void shiftSprite();
 	// Monitoriza el estado
 	void updateInvulnerable();
@@ -106,12 +115,12 @@ private:
 	// Actualiza el panel del marcador
 	void updateScoreboard();
 	// Comprueba si la puntuación entra en la tabla de mejores puntuaciones
 	bool IsEligibleForHighScore();
 	// Cambia el modo del marcador
 	void setScoreboardMode(ScoreboardMode mode);
 	// Se encuentra en alguno de los estados "COOLING"
 	bool isCooling();
 public:
 	// Constructor
 	Player(int id, float x, int y, bool demo, SDL_Rect &play_area, std::vector<std::shared_ptr<Texture>> texture, const std::vector<std::vector<std::string>> &animations);
@@ -144,10 +153,10 @@ public:
 	void move();
 	// Establece el estado del jugador
-	void setWalkingStatus(PlayerStatus status);
+	void setWalkingState(PlayerState state);
 	// Establece el estado del jugador
-	void setFiringStatus(PlayerStatus status);
+	void setFiringState(PlayerState state);
 	// Establece la animación correspondiente al estado
 	void setAnimation();
@@ -182,32 +191,23 @@ public:
 	// Incrementa la puntuación del jugador
 	void addScore(int score);
-	// Indica si el jugador está jugando
+	// Indica si el jugador se encuentra en ese estado
 	bool isPlaying() const;
 	// Indica si el jugador está continuando
 	bool isContinue() const;
 	// Indica si el jugador está esperando
 	bool isWaiting() const;
 	// Indica si el jugador está introduciendo su nombre
 	bool isEnteringName() const;
 	// Indica si el jugador está muriendose
 	bool isDying() const;
 	// Indica si el jugador ha terminado de morir
 	bool hasDied() const;
 	// Indica si el jugador ya ha terminado de jugar
 	bool isGameOver() const;
 	bool isEnteringNameGameCompleted() const;
 	bool isGameCompleted() const;
 	bool isCelebrating() const;
 	// Establece el estado del jugador en el juego
-	void setStatusPlaying(PlayerStatus value);
+	void setPlayingState(PlayerState state);
 	// Obtiene el estado del jugador en el juego
-	PlayerStatus getStatusPlaying() const;
+	PlayerState getPlayingState() const;
 	// Obtiene el valor de la variable
 	float getScoreMultiplier() const;
@@ -287,7 +287,7 @@ public:
 	// Obtiene el nombre del jugador para la tabla de mejores puntuaciones
 	std::string getRecordName() const;
-	// Obtiene la posici´´on que se está editando del nombre del jugador para la tabla de mejores puntuaciones
+	// Obtiene la posición que se está editando del nombre del jugador para la tabla de mejores puntuaciones
 	int getRecordNamePos() const;
 	// Establece el mando que usará para ser controlado
@@ -298,4 +298,7 @@ public:
 	// Obtiene el "id" del jugador
 	int getId() const;
 	// Comprueba si la puntuación entra en la tabla de mejores puntuaciones
 	bool IsEligibleForHighScore();
 };
--- a/source/resource.cpp
+++ b/source/resource.cpp
@@ -1,9 +1,14 @@
 #include <algorithm>
 #include <stdexcept>
 #include <iostream>
 #include "resource.h"
-#include "asset.h"
+#include <algorithm>    // Para find_if
-#include "screen.h"
+#include <iostream>     // Para basic_ostream, operator<<, endl, cout, cerr
 #include <stdexcept>    // Para runtime_error
 #include "asset.h"      // Para Asset, AssetType
 #include "lang.h"       // Para lang
 #include "jail_audio.h" // Para JA_LoadMusic, JA_LoadSound
 #include "screen.h"     // Para Screen
 #include "text.h"       // Para Text
 struct JA_Music_t;
 struct JA_Sound_t;
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Resource *Resource::resource_ = nullptr;
@@ -37,19 +42,10 @@ Resource::Resource()
    loadAnimations();
    loadDemoData();
    addPalettes();
    createTextures();
    std::cout << "\n** RESOURCES LOADED" << std::endl;
 }
 // Destructor
 Resource::~Resource()
 {
    sounds_.clear();
    musics_.clear();
    textures_.clear();
    text_files_.clear();
    animations_.clear();
 }
 // Obtiene el sonido a partir de un nombre
 JA_Sound_t *Resource::getSound(const std::string &name)
 {
@@ -111,9 +107,9 @@ std::shared_ptr<TextFile> Resource::getTextFile(const std::string &name)
 }
 // Obtiene la animación a partir de un nombre
-Animations &Resource::getAnimation(const std::string &name)
+AnimationsFileBuffer &Resource::getAnimation(const std::string &name)
 {
-    auto it = std::find_if(animations_.begin(), animations_.end(), [&name](auto &a)
+    auto it = std::find_if(animations_.begin(), animations_.end(), [&name](const auto &a)
                           { return a.name == name; });
    if (it != animations_.end())
@@ -227,4 +223,50 @@ void Resource::addPalettes()
    // Fuentes
    getTexture("smb2.gif")->addPaletteFromFile(Asset::get()->get("smb2_palette1.pal"));
-}
+}
 // Crea texturas
 void Resource::createTextures()
 {
    struct NameAndText
    {
        std::string name;
        std::string text;
        // Constructor
        NameAndText(const std::string &name_init, const std::string &text_init)
            : name(name_init), text(text_init) {}
    };
    std::cout << "\n>> CREATING TEXTURES" << std::endl;
    auto text = std::make_unique<Text>(getTexture("04b_25.png"), getTextFile("04b_25.txt"));
    // Tamaño normal
    std::vector<NameAndText> strings = {
        NameAndText("game_text_1000_points", "1.000"),
        NameAndText("game_text_2500_points", "2.500"),
        NameAndText("game_text_5000_points", "5.000"),
        NameAndText("game_text_powerup", lang::getText(117)),
        NameAndText("game_text_one_hit", lang::getText(118)),
        NameAndText("game_text_stop", lang::getText(119)),
        NameAndText("1000000_points", lang::getText(76))};
    for (const auto &s : strings)
    {
        textures_.emplace_back(ResourceTexture(s.name, text->writeToTexture(s.text, 1, -2)));
        printWithDots("Texture : ", s.name, "[  DONE  ]");
    }
    // Tamaño doble
    std::vector<NameAndText> strings2X = {
        NameAndText("get_ready", lang::getText(75)),
        NameAndText("last_stage", lang::getText(79)),
        NameAndText("congratulations", lang::getText(50)),
        NameAndText("game_over", "Game Over")};
    for (const auto &s : strings2X)
    {
        textures_.emplace_back(ResourceTexture(s.name, text->writeToTexture(s.text, 2, -2)));
        printWithDots("Texture : ", s.name, "[  DONE  ]");
    }
 }
--- a/source/resource.h
+++ b/source/resource.h
@@ -1,14 +1,14 @@
 #pragma once
-#include <SDL2/SDL.h>
+#include <memory>            // Para shared_ptr
-#include <vector>
+#include <string>            // Para string
-#include <memory>
+#include <vector>            // Para vector
-#include <string>
+#include "animated_sprite.h" // Para AnimationsFileBuffer
-#include "jail_audio.h"
+#include "text.h"            // Para TextFile
-#include "texture.h"
+#include "texture.h"         // Para Texture
-#include "text.h"
+#include "utils.h"           // Para DemoData
-#include "utils.h"
+struct JA_Music_t;
-#include "animated_sprite.h"
+struct JA_Sound_t;
 // Estructura para almacenar ficheros de sonido y su nombre
 struct ResourceSound
@@ -57,11 +57,11 @@ struct ResourceTextFile
 // Estructura para almacenar ficheros animaciones y su nombre
 struct ResourceAnimation
 {
-    std::string name;     // Nombre del fichero
+    std::string name;               // Nombre del fichero
-    Animations animation; // Objeto con las animaciones
+    AnimationsFileBuffer animation; // Objeto con las animaciones
    // Constructor
-    ResourceAnimation(const std::string &name, const Animations &animation)
+    ResourceAnimation(const std::string &name, const AnimationsFileBuffer &animation)
        : name(name), animation(animation) {}
 };
@@ -99,13 +99,16 @@ private:
    // Añade paletas a las texturas
    void addPalettes();
    // Crea texturas
    void createTextures();
    // [SINGLETON] Ahora el constructor y el destructor son privados, para no poder crear objetos resource desde fuera
    // Constructor
    Resource();
    // Destructor
-    ~Resource();
+    ~Resource() = default;
 public:
    // [SINGLETON] Crearemos el objeto resource con esta función estática
@@ -130,7 +133,7 @@ public:
    std::shared_ptr<TextFile> getTextFile(const std::string &name);
    // Obtiene la animación a partir de un nombre
-    Animations &getAnimation(const std::string &name);
+    AnimationsFileBuffer &getAnimation(const std::string &name);
    // Obtiene el fichero con los datos para el modo demostración a partir de un çindice
    DemoData &getDemoData(int index);
--- a/source/scoreboard.cpp
+++ b/source/scoreboard.cpp
@@ -1,17 +1,15 @@
 #include "scoreboard.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 <SDL2/SDL_timer.h>		// for SDL_GetTicks
+#include <SDL2/SDL_timer.h>		// Para SDL_GetTicks
-#include <math.h>				// for roundf
+#include <math.h>				// Para roundf
-#include <iomanip>
+#include <iomanip>				// Para operator<<, setfill, setw
-#include <sstream>
+#include <sstream>				// Para basic_ostream, basic_ostringstream
-#include "asset.h"	  // for Asset
+#include "lang.h"				// Para getText
-#include "lang.h"	  // for getText
+#include "resource.h"			// Para Resource
-#include "resource.h" // for Resource
+#include "screen.h"				// Para Screen
-#include "screen.h"
+#include "sprite.h"				// Para Sprite
-#include "sprite.h"	 // for Sprite
+#include "text.h"				// Para Text
 #include "text.h"	 // for Text
 #include "texture.h" // for Texture
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Scoreboard *Scoreboard::scoreboard_ = nullptr;
@@ -120,77 +118,28 @@ void Scoreboard::render()
 	SDL_RenderCopy(renderer_, background_, nullptr, &rect_);
 }
-// Establece el valor de la variable
+void Scoreboard::setName(int panel, const std::string &name) { name_[panel] = name; }
-void Scoreboard::setName(int panel_, const std::string &name_)
+void Scoreboard::setRecordName(int panel, const std::string &record_name) { record_name_[panel] = record_name; }
-{
+void Scoreboard::setSelectorPos(int panel, int pos) { selector_pos_[panel] = pos; }
-	this->name_[panel_] = name_;
+void Scoreboard::setScore(int panel, int score) { score_[panel] = score; }
-}
+void Scoreboard::setMult(int panel, float mult) { mult_[panel] = mult; }
 void Scoreboard::setContinue(int panel, int continue_counter) { continue_counter_[panel] = continue_counter; }
 void Scoreboard::setStage(int stage) { stage_ = stage; }
 void Scoreboard::setHiScore(int hi_score) { hi_score_ = hi_score; }
 void Scoreboard::setPower(float power) { power_ = power; }
 void Scoreboard::setHiScoreName(const std::string &name) { hi_score_name_ = name; }
 // Establece el valor de la variable
-void Scoreboard::setRecordName(int panel_, const std::string &record_name_)
+void Scoreboard::setColor(Color color)
 {
-	this->record_name_[panel_] = record_name_;
+	color_ = color;
 }
 // Establece el valor de la variable
 void Scoreboard::setSelectorPos(int panel_, int pos)
 {
 	selector_pos_[panel_] = pos;
 }
 // Establece el valor de la variable
 void Scoreboard::setScore(int panel_, int score_)
 {
 	this->score_[panel_] = score_;
 }
 // Establece el valor de la variable
 void Scoreboard::setMult(int panel_, float mult_)
 {
 	this->mult_[panel_] = mult_;
 }
 // Establece el valor de la variable
 void Scoreboard::setContinue(int panel_, int value)
 {
 	continue_counter_[panel_] = value;
 }
 // Establece el valor de la variable
 void Scoreboard::setStage(int stage_)
 {
 	this->stage_ = stage_;
 }
 // Establece el valor de la variable
 void Scoreboard::setHiScore(int hi_score_)
 {
 	this->hi_score_ = hi_score_;
 }
 // Establece el valor de la variable
 void Scoreboard::setPower(float power_)
 {
 	this->power_ = power_;
 }
 // Establece el valor de la variable
 void Scoreboard::setHiScoreName(const std::string &name_)
 {
 	hi_score_name_ = name_;
 }
 // Establece el valor de la variable
 void Scoreboard::setColor(Color color_)
 {
 	this->color_ = color_;
 	fillBackgroundTexture();
 }
 // Establece el valor de la variable
-void Scoreboard::setPos(SDL_Rect rect_)
+void Scoreboard::setPos(SDL_Rect rect)
 {
-	this->rect_ = rect_;
+	rect_ = rect;
 	// Recalcula las anclas de los elementos
 	recalculateAnchors();
@@ -209,10 +158,10 @@ void Scoreboard::setPos(SDL_Rect rect_)
 void Scoreboard::fillPanelTextures()
 {
 	// Guarda a donde apunta actualmente el renderizador
-	SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
+	auto temp = SDL_GetRenderTarget(renderer_);
 	// Genera el contenidoi de cada panel_
-	for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
+	for (size_t i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
 	{
 		// Cambia el destino del renderizador
 		SDL_SetRenderTarget(renderer_, panel_texture_[i]);
@@ -316,8 +265,9 @@ void Scoreboard::fillPanelTextures()
 			text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(106));
 			SDL_Rect rect = {enter_name_pos_.x, enter_name_pos_.y, 5, 7};
 			SDL_SetRenderDrawColor(renderer_, 0xFF, 0xFF, 0xEB, 255);
-			for (int j = 0; j < (int)record_name_[i].size(); ++j)
+			for (size_t j = 0; j < record_name_[i].size(); ++j)
 			{
 				/*
 				if (j == selector_pos_[i])
 				{ // La letra seleccionada se pinta de forma intermitente
 					if (counter_ % 3 > 0)
@@ -331,11 +281,28 @@ void Scoreboard::fillPanelTextures()
 					SDL_RenderDrawLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
 					text_scoreboard_->write(rect.x, rect.y, record_name_[i].substr(j, 1));
 				}
 				*/
 				if (j != selector_pos_[i] || counter_ % 3 == 0)
 				{
 					SDL_RenderDrawLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
 					text_scoreboard_->write(rect.x, rect.y, record_name_[i].substr(j, 1));
 				}
 				rect.x += 7;
 			}
 			break;
 		}
 		case ScoreboardMode::GAME_COMPLETED:
 		{
 			// GAME OVER
 			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(102));
 			// SCORE
 			if (counter_ % 10 < 8)
 			{
 				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(120));
 				text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, updateScoreText(score_[i]));
 			}
 		}
 		default:
 			break;
 		}
@@ -418,10 +385,7 @@ void Scoreboard::recalculateAnchors()
 }
 // Establece el modo del marcador
-void Scoreboard::setMode(int index, ScoreboardMode mode)
+void Scoreboard::setMode(int index, ScoreboardMode mode) { panel_[index].mode = mode; }
 {
 	panel_[index].mode = mode;
 }
 // Crea la textura de fondo
 void Scoreboard::createBackgroundTexture()
--- a/source/scoreboard.h
+++ b/source/scoreboard.h
@@ -1,16 +1,17 @@
 #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_Renderer, SDL_Texture
+#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 <SDL2/SDL_timer.h>		// for SDL_GetTicks
+#include <SDL2/SDL_timer.h>	 // Para SDL_GetTicks
-#include <memory>			 // for unique_ptr, shared_ptr
+#include <stddef.h>			 // Para size_t
-#include <string>			 // for string
+#include <memory>			 // Para unique_ptr, shared_ptr
-#include <vector>			 // for vector
+#include <string>			 // Para string
-#include "utils.h"			 // for Color
+#include <vector>			 // Para vector
-class Sprite;
+#include "utils.h"			 // Para Color
-class Text;
+class Sprite;				 // lines 11-11
-class Texture;
+class Text;					 // lines 12-12
 class Texture;				 // lines 13-13
 // Defines
 constexpr int SCOREBOARD_LEFT_PANEL = 0;
@@ -28,6 +29,7 @@ enum class ScoreboardMode : int
 	GAME_OVER,
 	DEMO,
 	ENTER_NAME,
 	GAME_COMPLETED,
 	NUM_MODES,
 };
@@ -58,7 +60,7 @@ private:
 	// Variables
 	std::string name_[SCOREBOARD_MAX_PANELS] = {};		  // Nom de cada jugador
 	std::string record_name_[SCOREBOARD_MAX_PANELS] = {}; // Nombre introducido para la tabla de records
-	int selector_pos_[SCOREBOARD_MAX_PANELS] = {};		  // Posición del selector de letra para introducir el nombre
+	size_t selector_pos_[SCOREBOARD_MAX_PANELS] = {};	  // Posición del selector de letra para introducir el nombre
 	int score_[SCOREBOARD_MAX_PANELS] = {};				  // Puntuación de los jugadores
 	float mult_[SCOREBOARD_MAX_PANELS] = {};			  // Multiplicador de los jugadores
 	int continue_counter_[SCOREBOARD_MAX_PANELS] = {};	  // Tiempo para continuar de los jugadores
--- a/source/screen.cpp
+++ b/source/screen.cpp
@@ -1,24 +1,23 @@
 #include "screen.h"
-#include <SDL2/SDL_events.h> // for SDL_DISABLE, SDL_ENABLE
+#include <SDL2/SDL_events.h> // Para SDL_DISABLE, SDL_ENABLE
-#include <SDL2/SDL_mouse.h>  // for SDL_ShowCursor
+#include <SDL2/SDL_mouse.h>  // Para SDL_ShowCursor
-#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 <algorithm>         // for max, min
+#include <algorithm>         // Para clamp, max, min
-#include <fstream>           // for basic_ifstream, ifstream
+#include <fstream>           // Para basic_ifstream, ifstream
-#include <iterator>          // for istreambuf_iterator, operator!=
+#include <iterator>          // Para istreambuf_iterator, operator==
-#include <string>            // for basic_string, operator+, to_string, cha...
+#include <string>            // Para allocator, operator+, char_traits, to_s...
-#include <vector>            // for vector
+#include <vector>            // Para vector
-#include "asset.h"           // for Asset
+#include "asset.h"           // Para Asset
-#include "dbgtxt.h"          // for dbg_print
+#include "dbgtxt.h"          // Para dbg_print
-#include "global_inputs.h"   // for servicePressedCounter
+#include "global_inputs.h"   // Para service_pressed_counter
-#include "input.h"           // for Input, inputs_e, INPUT_DO_NOT_ALLOW_REPEAT
+#include "jail_shader.h"     // Para init, render
-#include "notifier.h"        // for Notify
+#include "notifier.h"        // Para Notifier
-#include "on_screen_help.h"  // for OnScreenHelp
+#include "on_screen_help.h"  // Para OnScreenHelp
-#include "options.h"         // for options
+#include "options.h"         // Para Options, OptionsVideo, options, Options...
 #include "param.h"           // for param
 #ifndef NO_SHADERS
-#include "jail_shader.h" // for init, render
+#include "jail_shader.h" // para init, render
 #endif
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
@@ -46,26 +45,12 @@ Screen *Screen::get()
 Screen::Screen(SDL_Window *window, SDL_Renderer *renderer)
    : window_(window),
      renderer_(renderer),
      game_canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
      shader_canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
      src_rect_({0, 0, param.game.width, param.game.height}),
      dst_rect_({0, 0, param.game.width, param.game.height})
 {
    // Inicializa variables
    flash_effect_.enabled = false;
    flash_effect_.counter = 0;
    flash_effect_.lenght = 0;
    flash_effect_.color = Color(0xFF, 0xFF, 0xFF);
    shake_effect_.enabled = false;
    shake_effect_.desp = 2;
    shake_effect_.delay = 3;
    shake_effect_.counter = 0;
    shake_effect_.lenght = 8;
    shake_effect_.remaining = 0;
    shake_effect_.originalPos = 0;
    shake_effect_.originalWidth = param.game.width;
    SDL_DisplayMode DM;
    SDL_GetCurrentDisplayMode(0, &DM);
    info_resolution_ = std::to_string(DM.w) + " X " + std::to_string(DM.h) + " AT " + std::to_string(DM.refresh_rate) + " HZ";
@@ -113,7 +98,7 @@ void Screen::blit()
    OnScreenHelp::get()->render();
    // Muestra información por pantalla
-    displayInfo();
+    renderInfo();
    // Muestra las notificaciones
    Notifier::get()->render();
@@ -156,7 +141,7 @@ void Screen::blit()
        // Copia la textura de juego en el renderizador en la posición adecuada
        if (shake_effect_.enabled)
-            SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
+            SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr); // Esta copia es para evitar que se vea negro por los laterales
        SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
        // Muestra por pantalla el renderizador
@@ -225,7 +210,7 @@ void Screen::setVideoMode(ScreenVideoMode videoMode)
 }
 // Camibia entre pantalla completa y ventana
-void Screen::switchVideoMode()
+void Screen::toggleVideoMode()
 {
    options.video.mode = options.video.mode == ScreenVideoMode::WINDOW ? ScreenVideoMode::FULLSCREEN : ScreenVideoMode::WINDOW;
    setVideoMode(options.video.mode);
@@ -275,72 +260,6 @@ void Screen::update()
    OnScreenHelp::get()->update();
 }
 // Comprueba las entradas
 void Screen::checkInput()
 {
 #ifndef ARCADE
    // Comprueba el teclado para cambiar entre pantalla completa y ventana
    if (Input::get()->checkInput(InputType::WINDOW_FULLSCREEN, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
    {
        switchVideoMode();
        const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? "Window" : "Fullscreen";
        Notifier::get()->showText(mode + " mode");
        return;
    }
    // Comprueba el teclado para decrementar el tamaño de la ventana
    if (Input::get()->checkInput(InputType::WINDOW_DEC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
    {
        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, INPUT_USE_KEYBOARD))
    {
        incWindowSize();
        const std::string size = std::to_string(options.video.window.size);
        Notifier::get()->showText("Window size x" + size);
        return;
    }
 #endif
    // Comprueba el teclado para activar o desactivar los shaders
    if (Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
    {
        switchShaders();
        return;
    }
 #ifdef DEBUG
    // Comprueba el teclado para mostrar la información de debug
    if (Input::get()->checkInput(InputType::SHOWINFO, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
    {
        show_info_ = !show_info_;
        return;
    }
 #endif
    for (int i = 0; i < Input::get()->getNumControllers(); ++i)
    {
        // Comprueba los mandos para activar o desactivar los shaders
        if (Input::get()->checkModInput(InputType::SERVICE, InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
        {
            switchShaders();
            return;
        }
        // Comprueba los mandos para mostrar la información de debug
        if (Input::get()->checkModInput(InputType::SERVICE, InputType::SHOWINFO, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
        {
            show_info_ = !show_info_;
            return;
        }
    }
 }
 // Agita la pantalla
 void Screen::shake()
 {
@@ -390,10 +309,7 @@ void Screen::updateShakeEffect()
 // Pone la pantalla de color
 void Screen::flash(Color color, int lenght)
 {
-    flash_effect_.enabled = true;
+    flash_effect_ = FlashEffect(true, lenght, color);
    flash_effect_.counter = 0;
    flash_effect_.lenght = lenght;
    flash_effect_.color = color;
 }
 // Actualiza y dibuja el efecto de flash en la pantalla
@@ -402,14 +318,11 @@ void Screen::doFlash()
    if (flash_effect_.enabled)
    {
        // Dibuja el color del flash en la textura
        SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
        SDL_SetRenderTarget(renderer_, game_canvas_);
        SDL_SetRenderDrawColor(renderer_, flash_effect_.color.r, flash_effect_.color.g, flash_effect_.color.b, 0xFF);
        SDL_RenderClear(renderer_);
        SDL_SetRenderTarget(renderer_, temp);
        // Actualiza la lógica del efecto
-        flash_effect_.counter < flash_effect_.lenght ? flash_effect_.counter++ : flash_effect_.enabled = false;
+        flash_effect_.counter > 0 ? flash_effect_.counter-- : flash_effect_.enabled = false;
    }
 }
@@ -418,21 +331,24 @@ void Screen::doAttenuate()
 {
    if (attenuate_effect_)
    {
        SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
        SDL_SetRenderTarget(renderer_, game_canvas_);
        SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 64);
        SDL_RenderFillRect(renderer_, nullptr);
        SDL_SetRenderTarget(renderer_, temp);
    }
 }
-// Activa/desactiva los shaders
+// Activa / desactiva los shaders
-void Screen::switchShaders()
+void Screen::toggleShaders()
 {
    options.video.shaders = !options.video.shaders;
    setVideoMode(options.video.mode);
    const std::string value = options.video.shaders ? "on" : "off";
-    Notifier::get()->showText("Shaders " + value);
+    Notifier::get()->showText({"Shaders " + value});
 }
 // Activa / desactiva la información de debug
 void Screen::toggleDebugInfo()
 {
    show_info_ = !show_info_;
 }
 // Atenua la pantalla
@@ -459,7 +375,7 @@ void Screen::updateFPS()
 }
 // Muestra información por pantalla
-void Screen::displayInfo()
+void Screen::renderInfo()
 {
    if (show_info_)
    {
--- 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
		`@@ -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`