Opció de fer el reset amb o sense reload

FIX: Corregida la lògica del efecte de flash

CMakeLists.txt

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

Makefile

@@ -50,84 +50,7 @@ else
     endif
 endif
 
-OBJECTS     := $(subst $(DIR_SOURCES), $(DIR_BUILD), $(SOURCES))
-OBJECTS     := $(OBJECTS:.cpp=.o)
-DEPENDENCIES:= $(OBJECTS:.o=.d)
-
-
-###############################################################################
-#                                                                             #
-#     RULES                                                                   #
-#                                                                             #
-###############################################################################
-
-.PHONY: all a1
-
-all: a1
-
-a1: $(TARGET_FILE)
-
-$(TARGET_FILE): $(OBJECTS)
-	$(MKD) $(@D)
-	$(CXX) $(OBJECTS) $(LDFLAGS) -o $(TARGET_FILE)
-
-$(DIR_BUILD)%.o: $(DIR_SOURCES)%.cpp
-	$(MKD) $(@D)
-	$(CXX) -c $< $(CXXFLAGS) $(INCLUDES) -o $@
-
--include $(DEPENDENCIES)
-
-###############################################################################
-#                                                                             #
-#     CLEAN                                                                   #
-#                                                                             #
-###############################################################################
-
-.PHONY: clean
-
-clean:
-	$(RM) $(call FixPath,$(DIR_BUILD))
-
-###############################################################################
-#                                                                             #
-#     PRINT-VARIABLES                                                         #
-#                                                                             #
-###############################################################################
-
-.PHONY: print-variables
-
-print-variables:
-	@echo MAKEFILE_LIST: $(MAKEFILE_LIST)
-	
-	@echo "DIR_ROOT  :" $(DIR_ROOT)
-	@echo "DIR_SOURCES:" $(DIR_SOURCES)
-	@echo "DIR_BIN   :" $(DIR_BIN)
-	@echo "DIR_BUILD :" $(DIR_BUILD)
-
-	@echo "DIR_IMGUI     :" $(DIR_IMGUI)
-	@echo "DIR_IMGUI_SFML:" $(DIR_IMGUI_SFML)
-	@echo "INCLUDES      :" $(INCLUDES)
-
-	@echo CXX: $(CXX)
-	@echo CXXFLAGS: $(CXXFLAGS)
-	@echo LDFLAGS: $(LDFLAGS)
-
-	@echo SOURCES: $(SOURCES)
-	@echo OBJECTS: $(OBJECTS)
-	@echo DEPENDENCIES: $(DEPENDENCIES)
-
-	@echo TARGET_NAME: $(TARGET_NAME)
-	@echo TARGET_FILE: $(TARGET_FILE)
-
-	@echo RM: $(RM)
-
-raspi:
-	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(TARGET_FILE)
-	strip -s -R .comment -R .gnu.version $(TARGET_FILE) --strip-unneeded
-
-raspi_debug:
-	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE -D DEBUG $(CXXFLAGS_DEBUG) $(LDFLAGS) -o "$(TARGET_FILE)_debug"
-
+# Rules
 windows:
 	@echo off
 	$(CXX) $(SOURCES) $(CXXFLAGS) $(LDFLAGS) -o "$(TARGET_FILE).exe"
@@ -249,6 +172,13 @@ linux_release:
 # Elimina la carpeta temporal
 	$(RM) "$(RELEASE_FOLDER)"
 
+raspi:
+	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(TARGET_FILE)
+	strip -s -R .comment -R .gnu.version $(TARGET_FILE) --strip-unneeded
+
+raspi_debug:
+	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE -D DEBUG $(CXXFLAGS_DEBUG) $(LDFLAGS) -o "$(TARGET_FILE)_debug"
+
 anbernic:
 # Elimina carpetas previas
 	$(RM) "$(RELEASE_FOLDER)"_anbernic
@@ -259,6 +189,5 @@ anbernic:
 # Copia ficheros
 	cp -R data "$(RELEASE_FOLDER)"_anbernic
 
-# Complia
+# Compila
 	$(CXX) $(SOURCES) -D ANBERNIC -D NO_SHADERS -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(RELEASE_FOLDER)_anbernic/$(TARGET_NAME)
-	$(CXX) $(SOURCES) -D ANBERNIC -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(RELEASE_FOLDER)_anbernic/$(TARGET_NAME).shaders

README.md

@@ -28,6 +28,10 @@ Les tecles son les següents:
 
 - **Tecla F4**: Activa o desactiva els shaders
 
+- **Tecla F5**: Activa o desactiva l'audio
+
+- **Tecla F6**: Canvia el idioma del joc i reinicia
+
 - **Tecla F10**: Reset
 
 <p align="center">

data/font/04b_25_2x.txt

@@ -0,0 +1,194 @@
+# box width
+28
+# box height
+28
+# 32 espacio ( )
+16
+# 33 !
+10
+# 34 "
+16
+# 35 
+20
+# 36 $
+20
+# 37 %
+18
+# 38 &
+22
+# 39 '
+10
+# 40 (
+14
+# 41 )
+14
+# 42 *
+14
+# 43 +
+18
+# 44 ,
+10
+# 45 -
+18
+# 46 .
+10
+# 47 /
+24
+# 48 0
+16
+# 49 1
+12
+# 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 :
+10
+# 59 ;
+10
+# 60 <
+16
+# 61 =
+16
+# 62 >
+16
+# 63 ?
+16
+# 64 @
+22
+# 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
+10
+# 74 J
+16
+# 75 K
+16
+# 76 L
+16
+# 77 M
+22
+# 78 N
+16
+# 79 O
+16
+# 80 P
+16
+# 81 Q
+16
+# 82 R
+16
+# 83 S
+16
+# 84 T
+18
+# 85 U
+16
+# 86 V
+16
+# 87 W
+22
+# 88 X
+16
+# 89 Y
+16
+# 90 Z
+16
+# 91 [
+14
+# 92 \
+22
+# 93 ]
+14
+# 94 ^
+12
+# 95 _
+14
+# 96 `
+12
+# 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
+10
+# 106 j
+16
+# 107 k
+16
+# 108 l
+16
+# 109 m
+22
+# 110 n
+16
+# 111 o
+16
+# 112 p
+16
+# 113 q
+16
+# 114 r
+16
+# 115 s
+16
+# 116 t
+18
+# 117 u
+16
+# 118 v
+16
+# 119 w
+22
+# 120 x
+16
+# 121 y
+16
+# 122 z
+16
+# 123 {
+2
+# 124 |
+2
+# 125 }
+2
+# 126 ~
+2

data/gfx/player/player.ani

@@ -72,12 +72,19 @@ frames=27
 [/animation]
 
 [animation]
-name=death
+name=dying
 speed=10
 loop=0
 frames=32,33,34,35
 [/animation]
 
+[animation]
+name=dead
+speed=3
+loop=0
+frames=44,45,46,47,48,49,50
+[/animation]
+
 [animation]
 name=celebration
 speed=10

data/lang/ba_BA.txt

@@ -158,19 +158,19 @@ Felicitats!!
 2 JUGADORS
 
 ## 53 MARCADOR
-jugador 1
+Jugador 1
 
 ## 54 MARCADOR
-jugador 2
+Jugador 2
 
 ## 55 MARCADOR
-mult
+Multiplicador
 
 ## 56 MARCADOR
-max. puntuacio
+Max. puntuacio
 
 ## 57 MARCADOR
-fase 
+Fase 
 
 ## 58 - MENU DE OPCIONES
 MODE DE VISUALITZACIO
@@ -360,3 +360,15 @@ Temps!
 
 ## 120 - SCOREBOARD
 Puntuacio
+
+## 121 - CREDITS
+PROGRAMAT I DISSENYAT PER
+
+## 122 - CREDITS
+GRAFICS DIBUIXATS PER
+
+## 123 - CREDITS
+MUSICA COMPOSADA PER
+
+## 124 - CREDITS
+EFECTES DE SO

data/lang/en_UK.txt

@@ -158,19 +158,19 @@ Congratulations!!
 2 PLAYERS
 
 ## 53 - MARCADOR
-player 1
+Player 1
 
 ## 54 - MARCADOR
-player 2
+Player 2
 
 ## 55 - MARCADOR
-mult
+Multiplier
 
 ## 56 - MARCADOR
-high score
+High Score
 
 ## 57 - MARCADOR
-stage 
+Stage 
 
 ## 58 - MENU DE OPCIONES
 DISPLAY MODE
@@ -360,3 +360,15 @@ Stop!
 
 ## 120 - SCOREBOARD
 Score
+
+## 121 - CREDITS
+PROGRAMMED AND DESIGNED BY
+
+## 122 - CREDITS
+PIXELART DRAWN BY
+
+## 123 - CREDITS
+MUSIC COMPOSED BY
+
+## 124 - CREDITS
+SOUND EFFECTS

data/lang/es_ES.txt

@@ -158,19 +158,19 @@ Felicidades!!
 2 JUGADORES
 
 ## 53 - MARCADOR
-jugador 1
+Jugador 1
 
 ## 54 - MARCADOR
-jugador 2
+Jugador 2
 
 ## 55 - MARCADOR
-mult
+Multiplicador
 
 ## 56 - MARCADOR
-max. puntuacion
+Max. puntuacion
 
 ## 57 - MARCADOR
-FASE 
+Fase 
 
 ## 58 - MENU DE OPCIONES
 MODO DE VISUALIZACION
@@ -360,3 +360,15 @@ Tiempo!
 
 ## 120 - SCOREBOARD
 Puntuacion
+
+## 121 - CREDITS
+PROGRAMADO Y DISE{ADO POR
+
+## 122 - CREDITS
+GRAFICOS DIBUJADOS POR
+
+## 123 - CREDITS
+MUSICA COMPUESTA POR
+
+## 124 - CREDITS
+EFECTOS DE SONIDO

data/shaders/crtpi_240.glsl

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

data/shaders/crtpi_256.glsl

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

source/balloon.cpp

@@ -7,7 +7,7 @@
 #include "texture.h"		 // Para Texture
 
 // Constructor
-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)
+Balloon::Balloon(float x, float y, BalloonType type, BalloonSize size, float vel_x, float speed, Uint16 creation_timer, SDL_Rect play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
 	: sprite_(std::make_unique<AnimatedSprite>(texture, animation)),
 	  x_(x),
 	  y_(y),
@@ -19,7 +19,8 @@ Balloon::Balloon(float x, float y, BalloonType type, BalloonSize size, float vel
 	  creation_counter_ini_(creation_timer),
 	  type_(type),
 	  size_(size),
-	  speed_(speed)
+	  speed_(speed),
+	  play_area_(play_area)
 {
 	switch (type_)
 	{
@@ -56,7 +57,7 @@ Balloon::Balloon(float x, float y, BalloonType type, BalloonSize size, float vel
 	case BalloonType::POWERBALL:
 	{
 		const int index = 3;
-		h_ = w_ = BALLOON_SIZE[index];
+		h_ = w_ = BALLOON_SIZE[4];
 		power_ = score_ = menace_ = 0;
 
 		vy_ = 0;
@@ -64,8 +65,7 @@ Balloon::Balloon(float x, float y, BalloonType type, BalloonSize size, float vel
 		gravity_ = param.balloon.at(index).grav;
 		default_vy_ = param.balloon.at(index).vel;
 
-		sprite_->disableRotate();
-		sprite_->setRotateSpeed(0);
+		sprite_->setRotate(creation_timer <= 0);
 		sprite_->setRotateAmount(vx_ > 0.0f ? 2.0 : -2.0);
 
 		break;
@@ -92,40 +92,41 @@ Balloon::Balloon(float x, float y, BalloonType type, BalloonSize size, float vel
 void Balloon::alignTo(int x)
 {
 	x_ = static_cast<float>(x - (w_ / 2));
-	const int min_x = param.game.play_area.rect.x;
-	const int max_x = param.game.play_area.rect.w - w_;
+	const int min_x = play_area_.x;
+	const int max_x = play_area_.w - w_;
 	x_ = std::clamp(x_, static_cast<float>(min_x), static_cast<float>(max_x));
 }
 
 // Pinta el globo en la pantalla
 void Balloon::render()
 {
+	if (type_ == BalloonType::POWERBALL)
+	{
+		// Renderizado para la PowerBall
+		SDL_Point p = {24, 24};
+		sprite_->setRotatingCenter(&p);
+		sprite_->render();
+
+		// Añade la máscara del borde y los reflejos
+		auto sp = std::make_unique<Sprite>(sprite_->getTexture(), sprite_->getPosition());
+		sp->setSpriteClip(BALLOON_SIZE[4], 0, BALLOON_SIZE[4], BALLOON_SIZE[4]);
+		sp->render();
+	}
+	else
+	{
+		// Renderizado para el resto de globos
 		if (isBeingCreated())
 		{
-		// Aplica alpha blending
+			// Renderizado con transparencia
 			sprite_->getTexture()->setAlpha(255 - (int)((float)creation_counter_ * (255.0f / (float)creation_counter_ini_)));
 			sprite_->render();
 			sprite_->getTexture()->setAlpha(255);
 		}
 		else
 		{
-		if (bouncing_.enabled)
-		{
-			// Aplica efecto de bouncing
-			sprite_->setPos(x_ + bouncing_.despX, y_ + bouncing_.despY);
-			sprite_->render();
-			sprite_->setPos(x_ - bouncing_.despX, y_ - bouncing_.despY);
-		}
-		else
+			// Renderizado normal
 			sprite_->render();
 		}
-
-	// 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_SIZE[3], 0, BALLOON_SIZE[3], BALLOON_SIZE[3]);
-		sp->render();
 	}
 }
 
@@ -140,41 +141,61 @@ void Balloon::move()
 
 		// Colisión en las partes laterales de la zona de juego
 		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;
+		const float min_x = play_area_.x - clip;
+		const float max_x = play_area_.x + play_area_.w - w_ + clip;
 		if (x_ < min_x || x_ > max_x)
 		{
 			x_ = std::clamp(x_, min_x, max_x);
 			vx_ = -vx_;
 			// Activa el efecto de rebote o invierte la rotación
 			if (type_ == BalloonType::POWERBALL)
+			{
 				sprite_->switchRotate();
+			}
 			else
+			{
 				enableBounce();
 			}
+		}
 
 		// Mueve el globo en vertical
 		y_ += vy_ * speed_;
 
-		// Colisión en la parte superior de la zona de juego
-		const int min_y = param.game.play_area.rect.y;
+		// Colisión en la parte superior de la zona de juego excepto para la PowerBall
+		/*if (type_ != BalloonType::POWERBALL)
+		{
+			const int min_y = play_area_.y;
 			if (y_ < min_y)
 			{
 				y_ = min_y;
 				vy_ = -vy_;
-			if (type_ != BalloonType::POWERBALL)
 				enableBounce();
 			}
+		}*/
+
+		// Colisión en la parte superior solo si el globo va de subida
+		if (vy_ < 0)
+		{
+			const int min_y = play_area_.y;
+			if (y_ < min_y)
+			{
+				y_ = min_y;
+				vy_ = -vy_;
+				enableBounce();
+			}
+		}
 
 		// Colisión en la parte inferior de la zona de juego
-		const int max_y = param.game.play_area.rect.h - h_;
+		const int max_y = play_area_.y + play_area_.h - h_;
 		if (y_ > max_y)
 		{
 			y_ = max_y;
 			vy_ = -default_vy_;
 			if (type_ != BalloonType::POWERBALL)
+			{
 				enableBounce();
 			}
+		}
 
 		/*
 
@@ -237,8 +258,8 @@ void Balloon::updateState()
 				x_ += vx_;
 
 				// Comprueba no se salga por los laterales
-				const int min_x = param.game.play_area.rect.x;
-				const int max_x = param.game.play_area.rect.w - w_;
+				const int min_x = play_area_.x;
+				const int max_x = play_area_.w - w_;
 
 				if (x_ < min_x || x_ > max_x)
 				{
@@ -294,16 +315,20 @@ void Balloon::setAnimation()
 void Balloon::stop()
 {
 	stopped_ = true;
-	if (type_ == BalloonType::POWERBALL)
-		sprite_->disableRotate();
+	if (isPowerBall())
+	{
+		sprite_->setRotate(!stopped_);
+	}
 }
 
 // Pone el globo en movimiento
 void Balloon::start()
 {
 	stopped_ = false;
-	if (type_ == BalloonType::POWERBALL)
-		sprite_->enableRotate();
+	if (isPowerBall())
+	{
+		sprite_->setRotate(!stopped_);
+	}
 }
 
 // Alinea el circulo de colisión con la posición del objeto globo
@@ -354,13 +379,11 @@ void Balloon::updateBounce()
 
 		zoomSprite();
 
-		const auto spriteClip = sprite_->getSpriteClip();
-		bouncing_.despX = spriteClip.w * (1.0f - bouncing_.zoomW);
-		bouncing_.despY = spriteClip.h * (1.0f - bouncing_.zoomH);
-
 		if (++bouncing_.counter / bouncing_.speed >= MAX_BOUNCE)
+		{
 			disableBounce();
 		}
+	}
 }
 
 // Pone el color alternativo en el globo
@@ -379,26 +402,3 @@ void Balloon::useNormalColor()
 	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; }

source/balloon.h

@@ -1,12 +1,13 @@
 #pragma once
 
+#include <SDL2/SDL_rect.h>	 // Para SDL_Rect
 #include <SDL2/SDL_stdinc.h> // Para Uint8, Uint16, Uint32
 #include <memory>			 // Para shared_ptr, unique_ptr
 #include <string>			 // Para string
 #include <vector>			 // Para vector
 #include "animated_sprite.h" // Para AnimatedSprite
 #include "utils.h"			 // Para Circle
-class Texture;				 // lines 10-10
+class Texture;				 // lines 9-9
 
 // Cantidad de elementos del vector con los valores de la deformación del globo al rebotar
 constexpr int MAX_BOUNCE = 10;
@@ -15,7 +16,7 @@ constexpr int MAX_BOUNCE = 10;
 constexpr int BALLOON_SCORE[] = {50, 100, 200, 400};
 constexpr int BALLOON_POWER[] = {1, 3, 7, 15};
 constexpr int BALLOON_MENACE[] = {1, 2, 4, 8};
-constexpr int BALLOON_SIZE[] = {10, 16, 26, 46};
+constexpr int BALLOON_SIZE[] = {10, 16, 26, 48, 49};
 
 // Tamaños de globo
 enum class BalloonSize : Uint8
@@ -111,6 +112,7 @@ private:
 	float travel_y_ = 1.0f;			   // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
 	float speed_;					   // Velocidad a la que se mueven los globos
 	Uint8 power_;					   // Cantidad de poder que alberga el globo
+	SDL_Rect play_area_;			   // Zona por donde se puede mover el globo
 
 	// Alinea el circulo de colisión con la posición del objeto globo
 	void shiftColliders();
@@ -138,7 +140,17 @@ private:
 
 public:
 	// Constructor
-	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);
+	Balloon(
+		float x,
+		float y,
+		BalloonType type,
+		BalloonSize size,
+		float vel_x,
+		float speed,
+		Uint16 creation_timer,
+		SDL_Rect play_area,
+		std::shared_ptr<Texture> texture,
+		const std::vector<std::string> &animation);
 
 	// Destructor
 	~Balloon() = default;
@@ -174,25 +186,26 @@ public:
 	void useNormalColor();
 
 	// Getters
-	float getPosX() const;
-	float getPosY() const;
-	int getWidth() const;
-	int getHeight() const;
-	BalloonSize getSize() const;
-	BalloonType getType() const;
-	Uint16 getScore() const;
-	Circle &getCollider();
-	Uint8 getMenace() const;
-	Uint8 getPower() const;
-	bool isStopped() const;
-	bool isInvulnerable() const;
-	bool isBeingCreated() const;
-	bool isEnabled() const;
-	bool isUsingReversedColor();
-	bool canBePopped() const;
+	float getPosX() const { return x_; }
+	float getPosY() const { return y_; }
+	int getWidth() const { return w_; }
+	int getHeight() const { return h_; }
+	BalloonSize getSize() const { return size_; }
+	BalloonType getType() const { return type_; }
+	Uint16 getScore() const { return score_; }
+	Circle &getCollider() { return collider_; }
+	Uint8 getMenace() const { return isEnabled() ? menace_ : 0; }
+	Uint8 getPower() const { return power_; }
+	bool isStopped() const { return stopped_; }
+	bool isPowerBall() const { return type_ == BalloonType::POWERBALL; }
+	bool isInvulnerable() const { return invulnerable_; }
+	bool isBeingCreated() const { return being_created_; }
+	bool isEnabled() const { return enabled_; }
+	bool isUsingReversedColor() { return use_reversed_colors_; }
+	bool canBePopped() const { return !isBeingCreated(); }
 
 	// Setters
-	void setVelY(float vel_y);
-	void setSpeed(float speed);
-	void setInvulnerable(bool value);
+	void setVelY(float vel_y) { vy_ = vel_y; }
+	void setSpeed(float speed) { speed_ = speed; }
+	void setInvulnerable(bool value) { invulnerable_ = value; }
 };

source/balloon_formations.cpp

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

source/balloon_formations.h

@@ -1,13 +1,13 @@
 #pragma once
 
-#include "balloon.h"
+#include "balloon.h" // para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
+#include <vector>
 
 constexpr int NUMBER_OF_BALLOON_FORMATIONS = 100;
 constexpr int MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION = 50;
 constexpr int NUMBER_OF_SETS_PER_POOL = 10;
 constexpr int NUMBER_OF_STAGES = 10;
 
-// Estructuras
 struct BalloonFormationParams
 {
     int x = 0;                               // Posición en el eje X donde crear el globo
@@ -25,34 +25,26 @@ struct BalloonFormationParams
         : x(x_val), y(y_val), vel_x(vel_x_val), type(type_val), size(size_val), creation_counter(creation_counter_val) {}
 };
 
-struct BalloonFormationUnit // Contiene la información de una formación enemiga
+struct BalloonFormationUnit
 {
     int number_of_balloons;                   // Cantidad de globos que forman la formación
-    BalloonFormationParams init[MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION]; // Vector con todas las inicializaciones de los globos de la formación
+    std::vector<BalloonFormationParams> init; // Vector con todas las inicializaciones de los globos de la formación
+
+    // Constructor
+    BalloonFormationUnit(int num_balloons, const std::vector<BalloonFormationParams> &init_params)
+        : number_of_balloons(num_balloons), init(init_params) {}
+
+    // Default constructor
+    BalloonFormationUnit() : number_of_balloons(0), init() {}
 };
 
-struct BalloonFormationPool
-{
-    BalloonFormationUnit set[NUMBER_OF_SETS_PER_POOL]; // Conjunto de formaciones de globos
-};
+using BalloonFormationPool = std::vector<const BalloonFormationUnit *>;
 
-struct Stage // Contiene todas las variables relacionadas con una fase
-{
-    BalloonFormationPool balloon_pool; // El conjunto de formaciones de globos de la fase
-    int power_to_complete;             // Cantidad de poder que se necesita para completar la fase
-    int max_menace;                    // Umbral máximo de amenaza de la fase
-    int min_menace;                    // Umbral mínimo de amenaza de la fase
-    int number;                        // Número de fase
-};
-
-// Clase BalloonFormations, para gestionar las formaciones de globos
 class BalloonFormations
 {
 private:
-    // Variables
-    Stage stage_[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_[NUMBER_OF_STAGES];        // Variable con los diferentes conjuntos de formaciones enemigas
+    std::vector<BalloonFormationUnit> balloon_formation_;      // Vector con todas las formaciones enemigas
+    std::vector<BalloonFormationPool> balloon_formation_pool_; // Variable con los diferentes conjuntos de formaciones enemigas
 
     // Inicializa las formaciones enemigas
     void initBalloonFormations();
@@ -60,16 +52,19 @@ private:
     // Inicializa los conjuntos de formaciones
     void initBalloonFormationPools();
 
-    // Inicializa las fases del juego
-    void initGameStages();
-
 public:
     // Constructor
-    BalloonFormations();
+    BalloonFormations()
+    {
+        initBalloonFormations();
+        initBalloonFormationPools();
+    }
 
     // Destructor
     ~BalloonFormations() = default;
 
-    // Devuelve una fase
-    Stage getStage(int index) const;
+    // Getters
+    const BalloonFormationPool &getPool(int pool) { return balloon_formation_pool_.at(pool); }
+    const BalloonFormationUnit &getSet(int pool, int set) { return *balloon_formation_pool_.at(pool).at(set); }
+    const BalloonFormationUnit &getSet(int set) const { return balloon_formation_.at(set); }
 };

source/balloon_manager.cpp

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

source/balloon_manager.h

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

source/credits.cpp

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

source/credits.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <SDL2/SDL_render.h> // Para SDL_Texture
+#include <SDL2/SDL_stdinc.h> // Para Uint32
+#include <memory>            // Para unique_ptr
+#include "param.h"
+#include "options.h"
+class BalloonManager;
+class TiledBG;
+class Player;
+class Fade;
+
+constexpr int PLAY_AREA_HEIGHT = 200;
+
+class Credits
+{
+private:
+    // Objetos
+    std::unique_ptr<BalloonManager> balloon_manager_; // Objeto para gestionar los globos
+    SDL_Texture *text_texture_;                       // Textura con el texto
+    std::unique_ptr<TiledBG> tiled_bg_;               // Objeto para dibujar el mosaico animado de fondo
+    std::unique_ptr<Fade> fade_in_;                   // Objeto para realizar el fundido de entrada
+    std::unique_ptr<Fade> fade_out_;                  // Objeto para realizar el fundido de salida
+    std::vector<std::shared_ptr<Player>> players_;    // Vector con los jugadores
+
+    // Variables
+    Uint32 ticks_ = 0;                                                           // Contador de ticks para ajustar la velocidad del programa
+    Uint32 ticks_speed_ = 15;                                                    // Velocidad del bucle update
+    Uint32 counter_ = 0;                                                         // Contador para la lógica de la clase
+    Uint32 counter_pre_fade_ = 0;                                                // Contador para activar el fundido final
+    Uint32 counter_prevent_endless_ = 0;                                         // Contador para evitar que el juego se quede para siempre en los creditos
+    int black_bars_size_ = (param.game.game_area.rect.h - PLAY_AREA_HEIGHT) / 2; // Tamaño de las barras negras
+    int mini_logo_final_pos_ = 0;                                                // Ubicación donde se detiene el minilogo
+    bool fading_ = false;                                                        // Indica si se está realizando el fade final
+    bool want_to_pass_ = false;                                                  // Indica si el jugador quiere saltarse los titulos de crédito
+    bool mini_logo_on_position_ = false;                                         // Indica si el minilogo ya se ha quedado en su posición
+    int initial_volume_ = options.audio.music.volume;                            // Volumen actual al crear el objeto
+    int steps_ = 0;                                                              // Cantidad de pasos a dar para ir reduciendo el audio
+
+    // Rectangulos
+    SDL_Rect credits_rect_src_ = param.game.game_area.rect;   // Rectangulo con el texto de los créditos (origen)
+    SDL_Rect credits_rect_dst_ = param.game.game_area.rect;   // Rectangulo con el texto de los créditos (destino)
+    SDL_Rect mini_logo_rect_src_ = param.game.game_area.rect; // Rectangulo con el mini logo de JailGames y el texto de copyright (origen)
+    SDL_Rect mini_logo_rect_dst_ = param.game.game_area.rect; // Rectangulo con el mini logo de JailGames y el texto de copyright (destino)
+    SDL_Rect play_area_ = {
+        param.game.game_area.rect.x,
+        param.game.game_area.rect.y + black_bars_size_,
+        param.game.game_area.rect.w,
+        PLAY_AREA_HEIGHT};                                                                                                        // Area visible para los creditos
+    SDL_Rect top_black_rect_ = {play_area_.x, param.game.game_area.rect.y, play_area_.w, black_bars_size_};                       // Rectangulo negro superior
+    SDL_Rect bottom_black_rect_ = {play_area_.x, param.game.game_area.rect.h - black_bars_size_, play_area_.w, black_bars_size_}; // Rectangulo negro inferior
+    SDL_Rect left_black_rect_ = {play_area_.x, param.game.game_area.center_y - 1, 0, 2};                                          // Rectangulo negro situado a la izquierda
+    SDL_Rect right_black_rect_ = {play_area_.x + play_area_.w, param.game.game_area.center_y - 1, 0, 2};                          // Rectangulo negro situado a la derecha
+
+    // Actualiza las variables
+    void update();
+
+    // Dibuja en pantalla
+    void render();
+
+    // Comprueba el manejador de eventos
+    void checkEvents();
+
+    // Comprueba las entradas
+    void checkInput();
+
+    // Crea la textura con el texto
+    void fillTextTexture();
+
+    // Actualiza el destino de los rectangulos de las texturas
+    void updateTextureDstRects();
+
+    // Tira globos al escenario
+    void throwBalloons();
+
+    // Inicializa los jugadores
+    void initPlayers();
+
+    // Actualiza los rectangulos negros
+    void updateBlackRects();
+
+    // Actualiza el estado de fade
+    void updateAllFades();
+
+    // Establece el nivel de volumen
+    void setVolume(int amount);
+
+    // Reestablece el nivel de volumen
+    void resetVolume();
+
+public:
+    // Constructor
+    Credits();
+
+    // Destructor
+    ~Credits();
+
+    // Bucle principal
+    void run();
+};

source/define_buttons.cpp

@@ -1,16 +1,16 @@
 #include "define_buttons.h"
-#include <utility>   // Para move
 #include "input.h"    // Para Input, InputType
 #include "lang.h"     // Para getText
 #include "options.h"  // Para OptionsController, Options, options
 #include "param.h"    // Para Param, param, ParamGame, ParamTitle
+#include "resource.h" // Para Resource
 #include "section.h"  // Para Name, Options, name, options
 #include "text.h"     // Para Text
 
 // Constructor
-DefineButtons::DefineButtons(std::unique_ptr<Text> text_)
+DefineButtons::DefineButtons()
     : input_(Input::get()),
-      text_(std::move(text_))
+      text_(Resource::get()->getText("8bithud"))
 {
     // Inicializa variables
     x_ = param.game.width / 2;

source/define_buttons.h

@@ -58,7 +58,7 @@ private:
 
 public:
     // Constructor
-    explicit DefineButtons(std::unique_ptr<Text> text);
+    DefineButtons();
 
     // Destructor
     ~DefineButtons() = default;

source/director.cpp

@@ -1,3 +1,4 @@
+// IWYU pragma: no_include <bits/chrono.h>
 #include "director.h"
 #include <SDL2/SDL.h>				 // Para SDL_Init, SDL_Quit, SDL_INIT_EV...
 #include <SDL2/SDL_audio.h>			 // Para AUDIO_S16
@@ -7,7 +8,7 @@
 #include <SDL2/SDL_hints.h>			 // Para SDL_SetHint, SDL_HINT_RENDER_DR...
 #include <SDL2/SDL_scancode.h>		 // Para SDL_SCANCODE_0, SDL_SCANCODE_DOWN
 #include <SDL2/SDL_stdinc.h>		 // Para SDL_bool, Uint32
-#include <bits/chrono.h>			 // Para duration, system_clock
+#include <chrono>					 // Para duration, system_clock
 #include <errno.h>					 // Para errno, EEXIST, EACCES, ENAMETOO...
 #include <stdio.h>					 // Para printf, perror
 #include <sys/stat.h>				 // Para mkdir, stat, S_IRWXU
@@ -15,11 +16,12 @@
 #include <algorithm>				 // Para min
 #include <cstdlib>					 // Para exit, EXIT_FAILURE, size_t, rand
 #include <iostream>					 // Para basic_ostream, operator<<, basi...
-#include <memory>					 // Para make_unique, unique_ptr, make_s...
+#include <memory>					 // Para make_unique, unique_ptr
 #include <stdexcept>				 // Para runtime_error
 #include <string>					 // Para operator+, char_traits, allocator
 #include <vector>					 // Para vector
 #include "asset.h"					 // Para Asset, AssetType
+#include "credits.h"				 // Para Credits
 #include "dbgtxt.h"					 // Para dbg_init
 #include "game.h"					 // Para Game, GAME_MODE_DEMO_OFF, GAME_...
 #include "global_inputs.h"			 // Para init
@@ -38,7 +40,6 @@
 #include "resource.h"				 // Para Resource
 #include "screen.h"					 // Para Screen
 #include "section.h"				 // Para Name, Options, name, options
-#include "text.h"					 // Para Text
 #include "title.h"					 // Para Title
 #include "utils.h"					 // Para Overrides, overrides
 
@@ -46,13 +47,6 @@
 #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[])
 {
@@ -61,7 +55,7 @@ Director::Director(int argc, const char *argv[])
 	section::options = section::Options::GAME_PLAY_1P;
 #elif DEBUG
 	section::name = section::Name::LOGO;
-#else
+#else // NORMAL GAME
 	section::name = section::Name::LOGO;
 	section::attract_mode = section::AttractMode::TITLE_TO_DEMO;
 #endif
@@ -74,42 +68,36 @@ Director::Director(int argc, const char *argv[])
 
 	std::cout << "Game start" << std::endl;
 
-	initRand();
+	// Inicia la semilla aleatoria
+	unsigned int seed = static_cast<unsigned int>(std::chrono::system_clock::now().time_since_epoch().count());
+	std::srand(seed);
 
 	// Comprueba los parametros del programa
 	checkProgramArguments(argc, argv);
 
-	// Crea la carpeta del sistema donde guardar datos
+	// Crea la carpeta del sistema donde guardar los datos persistentes
 	createSystemFolder("jailgames");
 	createSystemFolder("jailgames/coffee_crisis_arcade_edition");
 
-	// Crea el objeto que controla los ficheros de recursos
-	Asset::init(executable_path_);
+	init();
+}
 
-	// Crea el indice de ficheros
-	setFileList();
+Director::~Director()
+{
+	close();
+	std::cout << "\nBye!" << std::endl;
+}
 
-	// Carga el fichero de configuración
-	loadOptionsFile(Asset::get()->get("config.txt"));
+// Inicializa todo
+void Director::init()
+{
+	Asset::init(executable_path_);					  // Crea el objeto que controla los ficheros de recursos
+	setFileList();									  // Crea el indice de ficheros
+	loadOptionsFile(Asset::get()->get("config.txt")); // Carga el fichero de configuración
+	loadParams();									  // Carga los parametros
+	loadScoreFile();								  // Carga el fichero de puntuaciones
 
-	// Carga los parametros para configurar el juego
-#ifdef ANBERNIC
-	const std::string paramFilePath = asset->get("param_320x240.txt");
-#else
-	const std::string paramFilePath = overrides.param_file == "--320x240" ? Asset::get()->get("param_320x240.txt") : Asset::get()->get("param_320x256.txt");
-#endif
-	loadParamsFromFile(paramFilePath);
-
-	// Carga el fichero de puntuaciones
-	{
-		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 todo
+	// Inicializa y crea el resto de objetos
 	initSDL();
 	initJailAudio();
 	dbg_init(renderer_);
@@ -118,13 +106,12 @@ Director::Director(int argc, const char *argv[])
 	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"));
+	Notifier::init(std::string(), Resource::get()->getText("8bithud"));
 	OnScreenHelp::init();
-	globalInputs::init();
 }
 
-Director::~Director()
+// Cierra todo
+void Director::close()
 {
 	saveOptionsFile(Asset::get()->get("config.txt"));
 
@@ -135,12 +122,38 @@ Director::~Director()
 	Notifier::destroy();
 	OnScreenHelp::destroy();
 
+	JA_Quit();
+
 	SDL_DestroyRenderer(renderer_);
 	SDL_DestroyWindow(window_);
 
 	SDL_Quit();
+}
 
-	std::cout << "\nBye!" << std::endl;
+// Carga los parametros
+void Director::loadParams()
+{
+	// Carga los parametros para configurar el juego
+#ifdef ANBERNIC
+	const std::string paramFilePath = asset->get("param_320x240.txt");
+#else
+	const std::string paramFilePath = overrides.param_file == "--320x240" ? Asset::get()->get("param_320x240.txt") : Asset::get()->get("param_320x256.txt");
+#endif
+	loadParamsFromFile(paramFilePath);
+}
+
+// Carga el fichero de puntuaciones
+void Director::loadScoreFile()
+{
+	auto manager = std::make_unique<ManageHiScoreTable>(options.game.hi_score_table);
+	if (overrides.clear_hi_score_table)
+	{
+		manager->clear();
+	}
+	else
+	{
+		manager->loadFromFile(Asset::get()->get("score.bin"));
+	}
 }
 
 // Asigna los botones y teclas al objeto Input
@@ -167,7 +180,8 @@ void Director::bindInputs()
 	Input::get()->bindKey(InputType::WINDOW_FULLSCREEN, SDL_SCANCODE_F3);
 	Input::get()->bindKey(InputType::VIDEO_SHADERS, SDL_SCANCODE_F4);
 	Input::get()->bindKey(InputType::MUTE, SDL_SCANCODE_F5);
-	Input::get()->bindKey(InputType::SHOWINFO, SDL_SCANCODE_F6);
+	Input::get()->bindKey(InputType::CHANGE_LANG, SDL_SCANCODE_F6);
+	Input::get()->bindKey(InputType::SHOWINFO, SDL_SCANCODE_F7);
 	Input::get()->bindKey(InputType::RESET, SDL_SCANCODE_F10);
 
 	// Asigna botones a inputs
@@ -363,6 +377,7 @@ void Director::setFileList()
 	Asset::get()->add(prefix + "/data/music/intro.ogg", AssetType::MUSIC);
 	Asset::get()->add(prefix + "/data/music/playing.ogg", AssetType::MUSIC);
 	Asset::get()->add(prefix + "/data/music/title.ogg", AssetType::MUSIC);
+	Asset::get()->add(prefix + "/data/music/credits.ogg", AssetType::MUSIC);
 
 	// Sonidos
 	Asset::get()->add(prefix + "/data/sound/balloon.wav", AssetType::SOUND);
@@ -381,9 +396,11 @@ void Director::setFileList()
 	Asset::get()->add(prefix + "/data/sound/clock.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/powerball.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/notify.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/logo.wav", AssetType::SOUND);
 
 	// Shaders
-	Asset::get()->add(prefix + "/data/shaders/crtpi.glsl", AssetType::DATA);
+	Asset::get()->add(prefix + "/data/shaders/crtpi_256.glsl", AssetType::DATA);
+	Asset::get()->add(prefix + "/data/shaders/crtpi_240.glsl", AssetType::DATA);
 
 	// Texturas
 
@@ -496,6 +513,8 @@ void Director::setFileList()
 	Asset::get()->add(prefix + "/data/font/smb2.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/04b_25.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/04b_25.txt", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/04b_25_2x.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/font/04b_25_2x.txt", AssetType::FONT);
 
 	// Textos
 	Asset::get()->add(prefix + "/data/lang/es_ES.txt", AssetType::LANG);
@@ -615,7 +634,7 @@ void Director::runGame()
 {
 	const auto player_id = section::options == section::Options::GAME_PLAY_1P ? 1 : 2;
 #ifdef DEBUG
-	constexpr auto current_stage = 9;
+	constexpr auto current_stage = 0;
 #else
 	constexpr auto current_stage = 0;
 #endif
@@ -630,6 +649,13 @@ void Director::runInstructions()
 	instructions->run();
 }
 
+// Ejecuta la sección donde se muestran los creditos del programa
+void Director::runCredits()
+{
+	auto credits = std::make_unique<Credits>();
+	credits->run();
+}
+
 // Ejecuta la sección donde se muestra la tabla de puntuaciones
 void Director::runHiScoreTable()
 {
@@ -646,6 +672,16 @@ void Director::runDemoGame()
 	game->run();
 }
 
+// Ejecuta la sección init
+void Director::runInit()
+{
+	if (section::options == section::Options::RELOAD)
+	{
+		Resource::get()->reload();
+	}
+	section::name = section::Name::LOGO;
+}
+
 int Director::run()
 {
 	// Bucle principal
@@ -654,7 +690,7 @@ int Director::run()
 		switch (section::name)
 		{
 		case section::Name::INIT:
-			section::name = section::Name::LOGO;
+			runInit();
 			break;
 		case section::Name::LOGO:
 			runLogo();
@@ -677,6 +713,9 @@ int Director::run()
 		case section::Name::INSTRUCTIONS:
 			runInstructions();
 			break;
+		case section::Name::CREDITS:
+			runCredits();
+			break;
 		default:
 			break;
 		}

source/director.h

@@ -58,12 +58,18 @@ private:
 	// Ejecuta la sección donde se muestran las instrucciones
 	void runInstructions();
 
+	// Ejecuta la sección donde se muestran los creditos del programa
+	void runCredits();
+
 	// Ejecuta la sección donde se muestra la tabla de puntuaciones
 	void runHiScoreTable();
 
 	// Ejecuta el juego en modo demo
 	void runDemoGame();
 
+	// Ejecuta la sección init
+	void runInit();
+
 	// Obtiene una fichero a partir de un lang::Code
 	std::string getLangFile(lang::Code code);
 #ifdef ARCADE
@@ -71,6 +77,18 @@ private:
 	void shutdownSystem();
 #endif
 
+	// Inicializa todo
+	void init();
+
+	// Cierra todo
+	void close();
+
+	// Carga los parametros
+	void loadParams();
+
+	// Carga el fichero de puntuaciones
+	void loadScoreFile();
+
 public:
 	// Constructor
 	Director(int argc, const char *argv[]);

source/enter_name.h

@@ -2,7 +2,7 @@
 
 #include <string>
 
-constexpr int NAME_LENGHT = 8;
+constexpr int NAME_LENGHT = 6;
 
 /*
     Un array, "characterList", contiene la lista de caracteres

source/game.h

@@ -5,27 +5,25 @@
 #include <memory>				  // Para shared_ptr, unique_ptr
 #include <string>				  // Para string
 #include <vector>				  // Para vector
-#include "balloon.h"			  // Para Balloon
 #include "manage_hiscore_table.h" // Para HiScoreEntry
 #include "options.h"			  // Para Options, OptionsGame, options
 #include "player.h"				  // Para Player
 #include "utils.h"				  // Para Demo
-class Asset;					  // lines 14-14
-class Background;				  // lines 15-15
-class BalloonFormations;		  // lines 16-16
-class Bullet;					  // lines 17-17
-class Explosions;				  // lines 18-18
-class Fade;						  // lines 19-19
-class Input;					  // lines 20-20
-class Item;						  // lines 21-21
-class PathSprite;				  // lines 22-22
-class Scoreboard;				  // lines 23-23
-class Screen;					  // lines 24-24
-class SmartSprite;				  // lines 25-25
-class Texture;					  // lines 27-27
-enum class BulletType : Uint8;	  // lines 28-28
-enum class ItemType;			  // lines 29-29
-struct Path;
+class Asset;					  // lines 13-13
+class Background;				  // lines 14-14
+class BalloonManager;
+class Bullet;				   // lines 15-15
+class Fade;					   // lines 16-16
+class Input;				   // lines 17-17
+class Item;					   // lines 18-18
+class PathSprite;			   // lines 19-19
+class Scoreboard;			   // lines 20-20
+class Screen;				   // lines 21-21
+class SmartSprite;			   // lines 22-22
+class Texture;				   // lines 23-23
+enum class BulletType : Uint8; // lines 24-24
+enum class ItemType;		   // lines 25-25
+struct Path;				   // lines 26-26
 
 // Modo demo
 constexpr bool GAME_MODE_DEMO_OFF = false;
@@ -124,13 +122,10 @@ private:
 	Scoreboard *scoreboard_; // Objeto para dibujar el marcador
 
 	std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego
-	std::unique_ptr<Explosions> explosions_;				// Objeto para dibujar explosiones
-	std::unique_ptr<BalloonFormations> balloon_formations_; // Objeto para gestionar las oleadas enemigas
 
 	SDL_Texture *canvas_; // Textura para dibujar la zona de juego
 
 	std::vector<std::shared_ptr<Player>> players_;			  // Vector con los jugadores
-	std::vector<std::shared_ptr<Balloon>> balloons_;		  // Vector con los globos
 	std::vector<std::unique_ptr<Bullet>> bullets_;			  // Vector con las balas
 	std::vector<std::unique_ptr<Item>> items_;				  // Vector con los items
 	std::vector<std::unique_ptr<SmartSprite>> smart_sprites_; // Vector con los smartsprites
@@ -138,18 +133,15 @@ private:
 
 	std::shared_ptr<Texture> bullet_texture_;							 // Textura para las balas
 	std::vector<std::shared_ptr<Texture>> item_textures_;				 // Vector con las texturas de los items
-	std::vector<std::shared_ptr<Texture>> balloon_textures_;			 // Vector con las texturas de los globos
-	std::vector<std::shared_ptr<Texture>> explosions_textures_;			 // Vector con las texturas de las explosiones
 	std::vector<std::vector<std::shared_ptr<Texture>>> player_textures_; // Vector con todas las texturas de los jugadores;
 
 	std::vector<std::shared_ptr<Texture>> game_text_textures_; // Vector con las texturas para los sprites con textos
 
 	std::vector<std::vector<std::string>> item_animations_;	  // Vector con las animaciones de los items
 	std::vector<std::vector<std::string>> player_animations_; // Vector con las animaciones del jugador
-	std::vector<std::vector<std::string>> balloon_animations_;	  // Vector con las animaciones de los globos
-	std::vector<std::vector<std::string>> explosions_animations_; // Vector con las animaciones de las explosiones
 
 	std::unique_ptr<Fade> fade_;					  // Objeto para renderizar fades
+	std::unique_ptr<BalloonManager> balloon_manager_; // Objeto para gestionar los globos
 	std::vector<Path> paths_;						  // Vector con los recorridos precalculados almacenados
 
 	// Variables
@@ -157,7 +149,6 @@ private:
 		options.game.hi_score_table[0].name,
 		options.game.hi_score_table[0].score); // Máxima puntuación y nombre de quien la ostenta
 
-	int current_stage_;									  // Indica la fase actual
 	Demo demo_;											  // Variable con todas las variables relacionadas con el modo demo
 	GameDifficulty difficulty_ = options.game.difficulty; // Dificultad del juego
 	Helper helper_;										  // Variable para gestionar las ayudas
@@ -165,22 +156,14 @@ private:
 	bool coffee_machine_enabled_ = false;				  // Indica si hay una máquina de café en el terreno de juego
 	bool hi_score_achieved_ = false;					  // Indica si se ha superado la puntuación máxima
 	bool paused_ = false;								  // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
-	bool power_ball_enabled_ = false;					  // Indica si hay una powerball ya activa
-	float balloon_speed_;								  // Velocidad a la que se mueven los enemigos
-	float default_balloon_speed_;						  // Velocidad base de los enemigos, sin incrementar
 	float difficulty_score_multiplier_;					  // Multiplicador de puntos en función de la dificultad
-	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
-	int balloons_popped_ = 0;							  // Lleva la cuenta de los globos explotados
 	int counter_ = 0;									  // Contador para el juego
-	int current_power_ = 0;								  // Poder actual almacenado para completar la fase
 	int game_completed_counter_ = 0;					  // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
 	int game_over_counter_ = GAME_OVER_COUNTER_;		  // Contador para el estado de fin de partida
-	int last_balloon_deploy_ = 0;						  // Guarda cual ha sido la última formación desplegada para no repetir;
-	int menace_current_ = 0;							  // Nivel de amenaza actual
-	int menace_threshold_ = 0;							  // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
-	int power_ball_counter_ = 0;						  // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
 	int time_stopped_counter_ = 0;						  // Temporizador para llevar la cuenta del tiempo detenido
 	int total_power_to_complete_game_;					  // La suma del poder necesario para completar todas las fases
+	int menace_current_ = 0;							  // Nivel de amenaza actual
+	int menace_threshold_ = 0;							  // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
 	GameState state_ = GameState::PLAYING;				  // Estado
 #ifdef DEBUG
 	bool auto_pop_balloons_ = false; // Si es true, incrementa automaticamente los globos explotados
@@ -198,12 +181,6 @@ private:
 	// Asigna texturas y animaciones
 	void setResources();
 
-	// Crea una formación de enemigos
-	void deployBalloonFormation();
-
-	// Aumenta el poder de la fase
-	void increaseStageCurrentPower(int power);
-
 	// Actualiza el valor de HiScore en caso necesario
 	void updateHiScore();
 
@@ -219,54 +196,9 @@ private:
 	// Actualiza el estado de fin de la partida
 	void updateGameOverState();
 
-	// Actualiza los globos
-	void updateBalloons();
-
-	// Pinta en pantalla todos los globos activos
-	void renderBalloons();
-
-	// Crea un globo nuevo en el vector de globos
-	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();
-
-	// Establece la velocidad de los globos
-	void setBalloonSpeed(float speed);
-
-	// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
-	void checkAndUpdateBalloonSpeed();
-
-	// Explosiona un globo. Lo destruye y crea otros dos si es el caso
-	void popBalloon(std::shared_ptr<Balloon> balloon);
-
-	// Explosiona un globo. Lo destruye
-	void destroyBalloon(std::shared_ptr<Balloon> &balloon);
-
-	// Destruye todos los globos
-	void destroyAllBalloons();
-
 	// Destruye todos los items
 	void destroyAllItems();
 
-	// Detiene todos los globos
-	void stopAllBalloons();
-
-	// Pone en marcha todos los globos
-	void startAllBalloons();
-
-	// Cambia el color de todos los globos
-	void reverseColorsToAllBalloons();
-
-	// Cambia el color de todos los globos
-	void normalColorsToAllBalloons();
-
-	// Vacia el vector de globos
-	void freeBalloons();
-
 	// Comprueba la colisión entre el jugador y los globos activos
 	bool checkPlayerBalloonCollision(std::shared_ptr<Player> &player);
 
@@ -333,18 +265,9 @@ private:
 	// Acciones a realizar cuando el jugador muere
 	void killPlayer(std::shared_ptr<Player> &player);
 
-	// Calcula y establece el valor de amenaza en funcion de los globos activos
-	void evaluateAndSetMenace();
-
-	// Actualiza la variable EnemyDeployCounter
-	void updateBalloonDeployCounter();
-
 	// Actualiza y comprueba el valor de la variable
 	void updateTimeStopped();
 
-	// Gestiona el nivel de amenaza
-	void updateMenace();
-
 	// Actualiza el fondo
 	void updateBackground();
 
@@ -357,12 +280,6 @@ private:
 	// Deshabilita el efecto del item de detener el tiempo
 	void disableTimeStopItem();
 
-	// Indica si se puede crear una powerball
-	bool canPowerBallBeCreated();
-
-	// Calcula el poder actual de los globos en pantalla
-	int calculateScreenPower();
-
 	// Actualiza las variables de ayuda
 	void updateHelper();
 
@@ -450,9 +367,6 @@ private:
 	// Inicializa los jugadores
 	void initPlayers(int player_id);
 
-	// Crea dos globos gordos
-	void createTwoBigBalloons();
-
 	// Pausa la música
 	void pauseMusic();
 
@@ -471,9 +385,6 @@ private:
 	// 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();
 
@@ -483,6 +394,15 @@ private:
 	// Vacía los vectores de elementos deshabilitados
 	void cleanVectors();
 
+	// Gestiona el nivel de amenaza
+	void updateMenace();
+
+	// Calcula y establece el valor de amenaza en funcion de los globos activos
+	void evaluateAndSetMenace();
+
+	// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
+	void checkAndUpdateBalloonSpeed();
+
 public:
 	// Constructor
 	Game(int playerID, int current_stage, bool demo);

source/game_logo.cpp

@@ -15,30 +15,24 @@ GameLogo::GameLogo(int x, int y)
       coffee_texture_(Resource::get()->getTexture("title_coffee.png")),
       crisis_texture_(Resource::get()->getTexture("title_crisis.png")),
       arcade_edition_texture_(Resource::get()->getTexture("title_arcade_edition.png")),
-
       dust_left_sprite_(std::make_unique<AnimatedSprite>(dust_texture_, Resource::get()->getAnimation("title_dust.ani"))),
       dust_right_sprite_(std::make_unique<AnimatedSprite>(dust_texture_, Resource::get()->getAnimation("title_dust.ani"))),
-
       coffee_sprite_(std::make_unique<SmartSprite>(coffee_texture_)),
       crisis_sprite_(std::make_unique<SmartSprite>(crisis_texture_)),
-
       arcade_edition_sprite_(std::make_unique<Sprite>(arcade_edition_texture_, (param.game.width - arcade_edition_texture_->getWidth()) / 2, param.title.arcade_edition_position, arcade_edition_texture_->getWidth(), arcade_edition_texture_->getHeight())),
-
       x_(x),
-      y_(y)
-{
-    // Inicializa las variables
-    init();
-}
+      y_(y) { }
 
 // Inicializa las variables
 void GameLogo::init()
 {
-    const auto xp = x_ - coffee_sprite_->getWidth() / 2;
+    const auto xp = x_ - coffee_texture_->getWidth() / 2;
     const auto desp = getInitialVerticalDesp();
 
     // Variables
-    status_ = Status::DISABLED;
+    coffee_crisis_status_ = Status::DISABLED;
+    arcade_edition_status_ = Status::DISABLED;
+
     shake_.desp = 1;
     shake_.delay = 2;
     shake_.lenght = 8;
@@ -46,6 +40,8 @@ void GameLogo::init()
     shake_.counter = shake_.delay;
     shake_.origin = xp;
 
+    zoom_ = 3.0f;
+
     // Inicializa el bitmap de 'Coffee'
     coffee_sprite_->setPosX(xp);
     coffee_sprite_->setPosY(y_ - coffee_texture_->getHeight() - desp);
@@ -90,6 +86,9 @@ void GameLogo::init()
     dust_left_sprite_->setPosY(y_);
     dust_left_sprite_->setWidth(16);
     dust_left_sprite_->setHeight(16);
+
+    // Inicializa el bitmap de 'Arcade Edition'
+    arcade_edition_sprite_->setZoom(zoom_);
 }
 
 // Pinta la clase en pantalla
@@ -99,8 +98,10 @@ void GameLogo::render()
     coffee_sprite_->render();
     crisis_sprite_->render();
 
-    if (status_ == Status::FINISHED)
+    if (arcade_edition_status_ != Status::DISABLED)
+    {
         arcade_edition_sprite_->render();
+    }
 
     // Dibuja el polvillo del logo
     dust_right_sprite_->render();
@@ -110,17 +111,18 @@ void GameLogo::render()
 // Actualiza la lógica de la clase
 void GameLogo::update()
 {
-    switch (status_)
+    switch (coffee_crisis_status_)
     {
     case Status::MOVING:
     {
         coffee_sprite_->update();
         crisis_sprite_->update();
 
-        // Si los objetos han llegado a su destino, cambiamos de Sección
+        // Si los objetos han llegado a su destino, cambia el estado
         if (coffee_sprite_->hasFinished() && crisis_sprite_->hasFinished())
         {
-            status_ = Status::SHAKING;
+            coffee_crisis_status_ = Status::SHAKING;
+            arcade_edition_status_ = Status::MOVING;
 
             // Reproduce el efecto sonoro
             JA_PlaySound(Resource::get()->getSound("title.wav"));
@@ -151,7 +153,7 @@ void GameLogo::update()
         {
             coffee_sprite_->setPosX(shake_.origin);
             crisis_sprite_->setPosX(shake_.origin + 15);
-            status_ = Status::FINISHED;
+            coffee_crisis_status_ = Status::FINISHED;
         }
 
         dust_right_sprite_->update();
@@ -171,19 +173,37 @@ void GameLogo::update()
     default:
         break;
     }
+
+    switch (arcade_edition_status_)
+    {
+    case Status::MOVING:
+    {
+        zoom_ -= 0.1f;
+        arcade_edition_sprite_->setZoom(zoom_);
+        if (zoom_ <= 1.0f)
+        {
+            arcade_edition_status_ = Status::FINISHED;
+            zoom_ = 1.0f;
+        }
+        break;
+    }
+
+    default:
+        break;
+    }
 }
 
 // Activa la clase
 void GameLogo::enable()
 {
     init();
-    status_ = Status::MOVING;
+    coffee_crisis_status_ = Status::MOVING;
 }
 
 // Indica si ha terminado la animación
 bool GameLogo::hasFinished() const
 {
-    return status_ == Status::FINISHED;
+    return coffee_crisis_status_ == Status::FINISHED && arcade_edition_status_ == Status::FINISHED;
 }
 
 // Recarga las texturas
@@ -192,6 +212,7 @@ void GameLogo::reLoad()
     dust_texture_->reLoad();
     coffee_texture_->reLoad();
     crisis_texture_->reLoad();
+    arcade_edition_texture_->reLoad();
 }
 
 // Calcula el desplazamiento vertical inicial

source/game_logo.h

@@ -45,8 +45,10 @@ private:
     // Variables
     int x_;      // Posición donde dibujar el logo
     int y_;      // Posición donde dibujar el logo
+    float zoom_; // Zoom aplicado al texto "ARCADE EDITION"
 
-    Status status_; // Estado en el que se encuentra la clase
+    Status coffee_crisis_status_ = Status::DISABLED;  // Estado en el que se encuentra el texto "COFFEE CRISIS"
+    Status arcade_edition_status_ = Status::DISABLED; // Estado en el que se encuentra el texto "ARCADE_EDITION"
     Shake shake_;                                     // Estructura para generar el efecto de agitación
 
     // Inicializa las variables

source/global_inputs.cpp

@@ -1,6 +1,7 @@
 #include "global_inputs.h"
 #include <string>  // Para operator+, string
 #include "input.h" // Para Input, InputType, INPUT_DO_NOT_ALLOW_REPEAT
+#include "asset.h"
 #include "jail_audio.h"     // Para JA_EnableMusic, JA_EnableSound
 #include "lang.h"           // Para getText
 #include "notifier.h"       // Para Notifier
@@ -13,18 +14,8 @@
 namespace globalInputs
 {
     // Variables
-    std::vector<int> service_pressed_counter;
-
-    // Inicializa variables
-    void init()
-    {
-        const auto num_inputs = Input::get()->getNumControllers() + 1;
-        service_pressed_counter.reserve(num_inputs);
-        for (int i = 0; i < num_inputs; ++i)
-        {
-            service_pressed_counter.push_back(0);
-        }
-    }
+    int service_pressed_counter = 0;
+    bool service_pressed = false;
 
     // Termina
     void quit(section::Options code)
@@ -33,11 +24,13 @@ namespace globalInputs
         auto code_found = stringInVector(Notifier::get()->getCodes(), exit_code);
         if (code_found)
         {
+            // Si la notificación de salir está activa, cambia de sección
             section::name = section::Name::QUIT;
             section::options = code;
         }
         else
         {
+            // Si la notificación de salir no está activa, muestra la notificación
 #ifdef ARCADE
             const int index = code == section::Options::QUIT_WITH_CONTROLLER ? 116 : 94;
             Notifier::get()->showText({lang::getText(index), std::string()}, -1, exit_code);
@@ -71,6 +64,50 @@ namespace globalInputs
         Notifier::get()->showText({"Audio " + boolToOnOff(options.audio.enabled)});
     }
 
+    // Obtiene una fichero a partir de un lang::Code
+    std::string getLangFile(lang::Code code)
+    {
+        switch (code)
+        {
+        case lang::Code::ba_BA:
+            return Asset::get()->get("ba_BA.txt");
+            break;
+        case lang::Code::es_ES:
+            return Asset::get()->get("es_ES.txt");
+            break;
+        default:
+            return Asset::get()->get("en_UK.txt");
+            break;
+        }
+    }
+
+    // Obtiene una cadena a partir de un lang::Code
+    std::string getLangName(lang::Code code)
+    {
+        switch (code)
+        {
+        case lang::Code::ba_BA:
+            return "ba_BA";
+            break;
+        case lang::Code::es_ES:
+            return "es_ES";
+            break;
+        default:
+            return "en_UK";
+            break;
+        }
+    }
+
+    // Cambia el idioma
+    void changeLang()
+    {
+        options.game.language = lang::change(options.game.language);
+        lang::loadFromFile(getLangFile(static_cast<lang::Code>(options.game.language)));
+        section::name = section::Name::INIT;
+        section::options = section::Options::RELOAD;
+        Notifier::get()->showText({getLangName(options.game.language)});
+    }
+
     // Comprueba los inputs que se pueden introducir en cualquier sección del juego
     void check()
     {
@@ -125,6 +162,13 @@ namespace globalInputs
                 return;
             }
 
+            // Idioma
+            if (Input::get()->checkInput(InputType::CHANGE_LANG, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
+            {
+                changeLang();
+                return;
+            }
+
             // Shaders
             if (Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {
@@ -143,17 +187,9 @@ namespace globalInputs
             // OnScreenHelp
             if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {
-                service_pressed_counter[0]++;
-
-                if (service_pressed_counter[0] >= 3000)
-                {
-                    OnScreenHelp::get()->toggleState();
-                    service_pressed_counter[0] = 0;
-                }
+                service_pressed = true;
                 return;
             }
-
-            service_pressed_counter[0] = 0;
         }
 
         // Mandos
@@ -203,18 +239,30 @@ namespace globalInputs
                 // 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;
-                    }
+                    service_pressed = true;
                     return;
                 }
+            }
+        }
+    }
 
-                service_pressed_counter[i + 1] = 0;
+    // Actualiza variables
+    void update()
+    {
+        if (service_pressed)
+        {
+            ++service_pressed_counter;
+            if (service_pressed_counter >= 200)
+            {
+                OnScreenHelp::get()->toggleState();
+                service_pressed_counter = 0;
             }
         }
+        else
+        {
+            service_pressed_counter = 0;
+        }
+
+        service_pressed = false;
     }
 }

source/global_inputs.h

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

source/hiscore_table.cpp

@@ -27,7 +27,7 @@ HiScoreTable::HiScoreTable()
 	  backbuffer_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
 	  fade_(std::make_unique<Fade>()),
 	  background_(std::make_unique<Background>()),
-	  text_(std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"))),
+	  text_(Resource::get()->getText("smb2")),
 	  counter_(0),
 	  ticks_(0),
 	  view_area_({0, 0, param.game.width, param.game.height}),
@@ -77,6 +77,9 @@ void HiScoreTable::update()
 		// Actualiza el objeto screen
 		Screen::get()->update();
 
+		// Actualiza las variables de globalInputs
+        globalInputs::update();
+
 		// Actualiza el fondo
 		background_->update();
 

source/hiscore_table.h

@@ -33,7 +33,7 @@ private:
 
 	std::unique_ptr<Fade> fade_;			 // Objeto para renderizar fades
 	std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego
-	std::unique_ptr<Text> text_;			 // Objeto para escribir texto
+	std::shared_ptr<Text> text_;			 // Objeto para escribir texto
 
 	// Variables
 	Uint16 counter_;	 // Contador

source/input.h

@@ -40,6 +40,7 @@ enum class InputType : int
 	VIDEO_SHADERS,
 	RESET,
 	MUTE,
+	CHANGE_LANG,
 	SHOWINFO,
 	CONFIG,
 	SWAP_CONTROLLERS,

source/instructions.cpp

@@ -26,19 +26,17 @@ Instructions::Instructions()
 	: renderer_(Screen::get()->getRenderer()),
 	  texture_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
 	  backbuffer_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
-	  text_(std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"))),
-	  tiled_bg_(std::make_unique<TiledBG>((SDL_Rect){0, 0, param.game.width, param.game.height}, TiledBGMode::STATIC)),
+	  text_(Resource::get()->getText("smb2")),
+	  tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::STATIC)),
 	  fade_(std::make_unique<Fade>())
 {
-	// Crea un backbuffer para el renderizador
+	// Configura las texturas
 	SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
-
-	// Crea una textura para el texto fijo
 	SDL_SetTextureBlendMode(texture_, SDL_BLENDMODE_BLEND);
 
 	// Inicializa variables
 	section::name = section::Name::INSTRUCTIONS;
-	view_ = {0, 0, param.game.width, param.game.height};
+	view_ = param.game.game_area.rect;
 
 	// Inicializa objetos
 	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
@@ -211,11 +209,16 @@ void Instructions::update()
 
 		// Mantiene la música sonando
 		if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
+		{
 			JA_PlayMusic(Resource::get()->getMusic("title.ogg"));
+		}
 
 		// Actualiza el objeto screen
 		Screen::get()->update();
 
+		// Actualiza las variables de globalInputs
+        globalInputs::update();
+
 		// Incrementa el contador
 		counter_++;
 

source/instructions.h

@@ -35,7 +35,7 @@ private:
 
 	std::vector<std::shared_ptr<Texture>> item_textures_; // Vector con las texturas de los items
 	std::vector<std::unique_ptr<Sprite>> sprites_;		  // Vector con los sprites de los items
-	std::unique_ptr<Text> text_;						  // Objeto para escribir texto
+	std::shared_ptr<Text> text_;						  // Objeto para escribir texto
 	std::unique_ptr<TiledBG> tiled_bg_;					  // Objeto para dibujar el mosaico animado de fondo
 	std::unique_ptr<Fade> fade_;						  // Objeto para renderizar fades
 

source/intro.cpp

@@ -20,7 +20,7 @@
 // Constructor
 Intro::Intro()
 	: texture_(Resource::get()->getTexture("intro.png")),
-	  text_(std::make_shared<Text>(Resource::get()->getTexture("nokia.png"), Resource::get()->getTextFile("nokia.txt")))
+	  text_(Resource::get()->getText("nokia"))
 {
 
 	// Inicializa variables
@@ -382,6 +382,9 @@ void Intro::update()
 
 		// Actualiza las escenas de la intro
 		updateScenes();
+
+		// Actualiza las variables de globalInputs
+        globalInputs::update();
 	}
 }
 

source/item.cpp

@@ -1,10 +1,10 @@
 #include "item.h"
-#include <stdlib.h>			 // para rand
-#include "animated_sprite.h" // para SpriteAnimated
-#include "param.h"			 // para param
-class Texture;
+#include <stdlib.h>			 // Para rand
+#include <algorithm>		 // Para clamp
+#include "animated_sprite.h" // Para AnimatedSprite
+#include "param.h"			 // Para Param, ParamGame, param
+class Texture;				 // lines 6-6
 
-// Constructor
 Item::Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
 	: sprite_(std::make_unique<AnimatedSprite>(texture, animation)),
 	  type_(type),
@@ -38,34 +38,26 @@ Item::Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr
 	}
 	}
 
-	sprite_->setPosX(pos_x_);
-	sprite_->setPosY(pos_y_);
+	// Actualiza el sprite
+	shiftSprite();
 	shiftColliders();
 }
 
-// Centra el objeto en la posición X
 void Item::alignTo(int x)
 {
-	pos_x_ = static_cast<float>(x - (width_ / 2));
+	const float min_x = param.game.play_area.rect.x + 1;
+	const float max_x = play_area_.w - width_ - 1;
 
-	if (pos_x_ < param.game.play_area.rect.x)
-	{
-		pos_x_ = param.game.play_area.rect.x + 1;
-	}
-	else if (pos_x_ + width_ > play_area_.w)
-	{
-		pos_x_ = static_cast<float>(play_area_.w - width_ - 1);
-	}
+	pos_x_ = x - (width_ / 2);
 
-	// Posición X,Y del sprite
-	sprite_->setPosX(pos_x_);
-	sprite_->setPosY(pos_y_);
+	// Ajusta para que no quede fuera de la zona de juego
+	pos_x_ = std::clamp(pos_x_, min_x, max_x);
 
-	// Alinea el circulo de colisión con el objeto
+	// Actualiza el sprite
+	shiftSprite();
 	shiftColliders();
 }
 
-// Pinta el objeto en la pantalla
 void Item::render()
 {
 	if (enabled_)
@@ -81,7 +73,6 @@ void Item::render()
 	}
 }
 
-// Actualiza la posición y estados del objeto
 void Item::move()
 {
 	floor_collision_ = false;
@@ -94,129 +85,90 @@ void Item::move()
 	vel_x_ += accel_x_;
 	vel_y_ += accel_y_;
 
-	// Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido
-	if ((pos_x_ < param.game.play_area.rect.x) || (pos_x_ + width_ > play_area_.w))
-	{
-		// Corregir posición
-		pos_x_ -= vel_x_;
+	// Comprueba los laterales de la zona de juego
+	const float min_x = param.game.play_area.rect.x;
+	const float max_x = play_area_.w - width_;
+	pos_x_ = std::clamp(pos_x_, min_x, max_x);
 
-		// Invertir sentido
+	// Si toca el borde lateral, invierte la velocidad horizontal
+	if (pos_x_ == min_x || pos_x_ == max_x)
+	{
 		vel_x_ = -vel_x_;
 	}
 
-	// Si se sale por arriba rebota (excepto la maquina de café)
+	// Si colisiona por arriba, rebota (excepto la máquina de café)
 	if ((pos_y_ < param.game.play_area.rect.y) && !(type_ == ItemType::COFFEE_MACHINE))
 	{
 		// Corrige
 		pos_y_ = param.game.play_area.rect.y;
 
-		// Invierte el sentido
+		// Invierte la velocidad
 		vel_y_ = -vel_y_;
 	}
 
-	// Si el objeto se sale por la parte inferior
-	if (pos_y_ + height_ > play_area_.h)
+	// Si colisiona con la parte inferior
+	if (pos_y_ > play_area_.h - height_)
 	{
-		// Detiene el objeto
-		vel_y_ = 0;
-		vel_x_ = 0;
-		accel_x_ = 0;
-		accel_y_ = 0;
+		// Corrige la posición
 		pos_y_ = play_area_.h - height_;
+
 		if (type_ == ItemType::COFFEE_MACHINE)
 		{
+			// Si es una máquina de café, detiene el objeto
+			vel_y_ = vel_x_ = accel_x_ = accel_y_ = 0;
 			floor_collision_ = true;
 		}
+		else
+		{
+			// Si no es una máquina de café
+			if (vel_y_ < 1.0f)
+			{
+				// Si la velocidad vertical es baja, detiene el objeto
+				vel_y_ = vel_x_ = accel_x_ = accel_y_ = 0;
+			}
+			else
+			{
+				// Si la velocidad vertical es alta, el objeto rebota y pierde velocidad
+				vel_y_ *= -0.5f;
+				vel_x_ *= 0.75f;
+			}
+		}
 	}
 
 	// Actualiza la posición del sprite
-	sprite_->setPosX(int(pos_x_));
-	sprite_->setPosY(int(pos_y_));
+	shiftSprite();
 	shiftColliders();
 }
 
-// Pone a cero todos los valores del objeto
-void Item::disable()
-{
-	enabled_ = false;
-}
+void Item::disable() { enabled_ = false; }
 
-// Actualiza el objeto a su posicion, animación y controla los contadores
 void Item::update()
 {
 	move();
 	sprite_->update();
 	updateTimeToLive();
-	checkTimeToLive();
 }
 
-// Actualiza el contador
 void Item::updateTimeToLive()
 {
 	if (time_to_live_ > 0)
 	{
 		time_to_live_--;
 	}
-}
-
-// Comprueba si el objeto sigue vivo
-void Item::checkTimeToLive()
-{
-	if (time_to_live_ == 0)
+	else
+	{
 		disable();
+	}
 }
 
-// Obtiene del valor de la variable
-float Item::getPosX()
-{
-	return pos_x_;
-}
-
-// Obtiene del valor de la variable
-float Item::getPosY()
-{
-	return pos_y_;
-}
-
-// Obtiene del valor de la variable
-int Item::getWidth()
-{
-	return width_;
-}
-
-// Obtiene del valor de la variable
-int Item::getHeight()
-{
-	return height_;
-}
-
-// Obtiene del valor de la variable
-ItemType Item::getType()
-{
-	return type_;
-}
-
-// Obtiene el valor de la variable
-bool Item::isEnabled()
-{
-	return enabled_;
-}
-
-// Obtiene el circulo de colisión
-Circle &Item::getCollider()
-{
-	return collider_;
-}
-
-// Alinea el circulo de colisión con la posición del objeto
 void Item::shiftColliders()
 {
-	collider_.x = int(pos_x_ + (width_ / 2));
-	collider_.y = int(pos_y_ + (height_ / 2));
+	collider_.x = static_cast<int>(pos_x_ + (width_ / 2));
+	collider_.y = static_cast<int>(pos_y_ + (height_ / 2));
 }
 
-// Informa si el objeto ha colisionado con el suelo
-bool Item::isOnFloor()
+void Item::shiftSprite()
 {
-	return floor_collision_;
+	sprite_->setPosX(pos_x_);
+	sprite_->setPosY(pos_y_);
 }

source/item.h

@@ -9,93 +9,147 @@
 #include "utils.h"           // para Circle
 class Texture;
 
-// Tipos de objetos
+/**
+ * @brief Tipos de objetos disponibles en el juego.
+ *
+ * Esta enumeración define los diferentes tipos de objetos que pueden existir en el juego, 
+ * cada uno con un identificador único.
+ */
 enum class ItemType : int
 {
-    DISK = 1,
-    GAVINA = 2,
-    PACMAR = 3,
-    CLOCK = 4,
-    COFFEE = 5,
-    COFFEE_MACHINE = 6,
-    NONE = 7,
+    DISK = 1,          /**< Disco */
+    GAVINA = 2,        /**< Gavina */
+    PACMAR = 3,        /**< Pacman */
+    CLOCK = 4,         /**< Reloj */
+    COFFEE = 5,        /**< Café */
+    COFFEE_MACHINE = 6,/**< Máquina de café */
+    NONE = 7,          /**< Ninguno */
 };
 
-// Clase Item
+/**
+ * @brief Clase Item.
+ *
+ * Esta clase representa un objeto en el juego, con sus propiedades y métodos para gestionar su comportamiento.
+ */
 class Item
 {
 private:
     // Objetos y punteros
-    std::unique_ptr<AnimatedSprite> sprite_; // Sprite con los graficos del objeto
+    std::unique_ptr<AnimatedSprite> sprite_; /**< Sprite con los gráficos del objeto */
 
     // Variables
-    float pos_x_;                  // Posición X del objeto
-    float pos_y_;                  // Posición Y del objeto
-    int width_;                    // Ancho del objeto
-    int height_;                   // Alto del objeto
-    float vel_x_;                  // Velocidad en el eje X
-    float vel_y_;                  // Velocidad en el eje Y
-    float accel_x_ = 0.0f;         // Aceleración en el eje X
-    float accel_y_;                // Aceleración en el eje Y
-    bool floor_collision_ = false; // Indica si el objeto colisiona con el suelo
-    ItemType type_;                // Especifica el tipo de objeto que es
-    bool enabled_ = true;          // Especifica si el objeto está habilitado
-    Circle collider_;              // Circulo de colisión del objeto
-    SDL_Rect play_area_;           // Rectangulo con la zona de juego
-    Uint16 time_to_live_ = 600;    // Temporizador con el tiempo que el objeto está presente
+    float pos_x_;                  /**< Posición X del objeto */
+    float pos_y_;                  /**< Posición Y del objeto */
+    int width_;                    /**< Ancho del objeto */
+    int height_;                   /**< Alto del objeto */
+    float vel_x_;                  /**< Velocidad en el eje X */
+    float vel_y_;                  /**< Velocidad en el eje Y */
+    float accel_x_ = 0.0f;         /**< Aceleración en el eje X */
+    float accel_y_;                /**< Aceleración en el eje Y */
+    bool floor_collision_ = false; /**< Indica si el objeto colisiona con el suelo */
+    ItemType type_;                /**< Especifica el tipo de objeto que es */
+    bool enabled_ = true;          /**< Especifica si el objeto está habilitado */
+    Circle collider_;              /**< Círculo de colisión del objeto */
+    SDL_Rect play_area_;           /**< Rectángulo con la zona de juego */
+    Uint16 time_to_live_ = 600;    /**< Temporizador con el tiempo que el objeto está presente */
 
-    // Alinea el circulo de colisión con la posición del objeto
+    /**
+     * @brief Alinea el círculo de colisión con la posición del objeto.
+     *
+     * Esta función ajusta la posición del círculo de colisión para que coincida con la posición del objeto.
+     * Actualiza las coordenadas X e Y del colisionador basándose en las coordenadas del objeto.
+     */
     void shiftColliders();
 
-    // Actualiza la posición y estados del objeto
+    /**
+     * @brief Coloca el sprite en la posición del objeto.
+     *
+     * Esta función ajusta la posición del sprite para que coincida con la posición del objeto.
+     * Actualiza las coordenadas X e Y del sprite basándose en las coordenadas del objeto.
+     */
+    void shiftSprite();
+
+    /**
+     * @brief Actualiza la posición y estados del objeto.
+     *
+     * Esta función actualiza la posición del objeto basándose en su velocidad y aceleración.
+     * Controla las colisiones con los límites del área de juego, ajustando la posición y la velocidad en consecuencia.
+     * También actualiza la posición del sprite y el colisionador del objeto.
+     */
     void move();
 
-    // Actualiza el contador
+    /**
+     * @brief Actualiza el contador de tiempo de vida del objeto.
+     *
+     * Esta función decrementa el contador de tiempo de vida del objeto.
+     * Si el tiempo de vida es mayor a 0, se decrementa en 1.
+     * Si el tiempo de vida es 0 o menos, se desactiva el objeto llamando a la función `disable()`.
+     */
     void updateTimeToLive();
 
-    // Comprueba si el objeto sigue vivo
-    void checkTimeToLive();
-
 public:
-    // Constructor
+    /**
+     * @brief Constructor de la clase Item.
+     *
+     * Este constructor inicializa un objeto Item con el tipo especificado, posición inicial, área de juego, textura y animación.
+     *
+     * @param type El tipo de objeto (ItemType).
+     * @param x La posición X inicial del objeto.
+     * @param y La posición Y inicial del objeto.
+     * @param play_area El área de juego donde el objeto se moverá.
+     * @param texture La textura del objeto.
+     * @param animation La animación asociada al objeto.
+     */
     Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
 
-    // Destructor
+    /**
+     * @brief Destructor de la clase Item.
+     *
+     * Este destructor libera los recursos asociados con el objeto Item.
+     */
     ~Item() = default;
 
-    // Centra el objeto en la posición X
+    /**
+     * @brief Centra el objeto en la posición X.
+     *
+     * Esta función ajusta la posición X del objeto para que esté centrado en la posición X especificada.
+     * Además, asegura que el objeto no se salga de los límites del área de juego.
+     *
+     * @param x La posición X en la que se desea centrar el objeto.
+     */
     void alignTo(int x);
 
-    // Pinta el objeto en la pantalla
+    /**
+     * @brief Pinta el objeto en la pantalla.
+     *
+     * Esta función renderiza el objeto en la pantalla si está habilitado.
+     * Si el tiempo de vida (`time_to_live_`) es mayor que 200, renderiza el sprite.
+     * Si el tiempo de vida es menor o igual a 200, renderiza el sprite de forma intermitente, basándose en un cálculo de módulo.
+     */
     void render();
 
-    // Pone a cero todos los valores del objeto
+    /**
+     * @brief Pone a cero todos los valores del objeto.
+     *
+     * Esta función desactiva el objeto estableciendo su estado `enabled_` a `false`.
+     */
     void disable();
 
-    // Actualiza al objeto a su posicion, animación y controla los contadores
+    /**
+     * @brief Actualiza el objeto a su posición, animación y controla los contadores.
+     *
+     * Esta función mueve el objeto, actualiza su animación y controla el contador de tiempo de vida.
+     * Llama a las funciones `move()`, `sprite_->update()` y `updateTimeToLive()`.
+     */
     void update();
 
-    // Obtiene del valor de la variable
-    float getPosX();
-
-    // Obtiene del valor de la variable
-    float getPosY();
-
-    // Obtiene del valor de la variable
-    int getWidth();
-
-    // Obtiene del valor de la variable
-    int getHeight();
-
-    // Obtiene del valor de la variable
-    ItemType getType();
-
-    // Obtiene el valor de la variable
-    bool isEnabled();
-
-    // Obtiene el circulo de colisión
-    Circle &getCollider();
-
-    // Informa si el objeto ha colisionado con el suelo
-    bool isOnFloor();
+    // Getters
+    float getPosX() const { return pos_x_; }
+    float getPosY() const { return pos_y_; }
+    int getWidth() const { return width_; }
+    int getHeight() const { return height_; }
+    ItemType getType() const { return type_; }
+    bool isEnabled() const { return enabled_; }
+    bool isOnFloor() const { return floor_collision_; }
+    Circle &getCollider() { return collider_; }
 };

source/lang.cpp

@@ -40,4 +40,12 @@ namespace lang
     {
         return texts.at(index);
     }
+
+    // Cambia el idioma seleccionado al siguiente idioma disponible
+    Code change(Code current_lang)
+    {
+        auto index = static_cast<int>(current_lang);
+        index = (index + 1) % 3;
+        return static_cast<Code>(index);
+    }
 }

source/lang.h

@@ -16,4 +16,7 @@ namespace lang
 
     // Obtiene la cadena de texto del indice
     std::string getText(int index);
+
+    // Cambia el idioma seleccionado al siguiente idioma disponible
+    Code change(Code current_lang);
 }

source/logo.cpp

@@ -59,6 +59,7 @@ Logo::~Logo()
 {
 	jail_texture_->setColor(255, 255, 255);
 	since_texture_->setColor(255, 255, 255);
+	JA_PauseChannel(-1);
 }
 
 // Recarga todas las texturas
@@ -113,6 +114,11 @@ void Logo::checkInput()
 // Gestiona el logo de JAILGAME
 void Logo::updateJAILGAMES()
 {
+	if (counter_ == 30)
+	{
+		JA_PlaySound(Resource::get()->getSound("logo.wav"));
+	}
+
 	if (counter_ > 30)
 	{
 		for (int i = 0; i < (int)jail_sprite_.size(); ++i)
@@ -195,6 +201,9 @@ void Logo::update()
 		{
 			section::name = section::Name::INTRO;
 		}
+
+		// Actualiza las variables de globalInputs
+        globalInputs::update();
 	}
 }
 

source/manage_hiscore_table.cpp

@@ -12,16 +12,18 @@ void ManageHiScoreTable::clear()
     table_.clear();
 
     // Añade 10 entradas predefinidas
-    table_.push_back(HiScoreEntry("Bry", 1000000));
-    table_.push_back(HiScoreEntry("Usufondo", 500000));
-    table_.push_back(HiScoreEntry("G.Lucas", 100000));
-    table_.push_back(HiScoreEntry("P.Delgat", 50000));
-    table_.push_back(HiScoreEntry("P.Arrabalera", 10000));
-    table_.push_back(HiScoreEntry("Pelechano", 5000));
-    table_.push_back(HiScoreEntry("Sahuquillo", 1000));
-    table_.push_back(HiScoreEntry("Bacteriol", 500));
-    table_.push_back(HiScoreEntry("Pepe", 200));
-    table_.push_back(HiScoreEntry("Rosita", 100));
+    table_.push_back(HiScoreEntry("BRY", 1000000));
+    table_.push_back(HiScoreEntry("USUFON", 500000));
+    table_.push_back(HiScoreEntry("GLUCAS", 100000));
+    table_.push_back(HiScoreEntry("PDLGAT", 50000));
+    table_.push_back(HiScoreEntry("PARRAB", 10000));
+    table_.push_back(HiScoreEntry("PELECH", 5000));
+    table_.push_back(HiScoreEntry("SAHUQU", 1000));
+    table_.push_back(HiScoreEntry("BACTER", 500));
+    table_.push_back(HiScoreEntry("PEPE", 200));
+    table_.push_back(HiScoreEntry("ROSITA", 100));
+
+    sort();
 }
 
 // Añade un elemento a la tabla

source/moving_sprite.cpp

@@ -96,6 +96,12 @@ void MovingSprite::setAngle(double value)
 	rotate_.angle = value;
 }
 
+// Establece el valor de la variable
+void MovingSprite::setRotatingCenter(SDL_Point *point)
+{
+	rotate_.center = point;
+}
+
 // Incrementa el valor del ángulo
 void MovingSprite::updateAngle()
 {
@@ -122,17 +128,10 @@ void MovingSprite::rotate()
 	}
 }
 
-// Establece el valor de la variable
-void MovingSprite::enableRotate()
+// Activa o desactiva el efecto de rotación
+void MovingSprite::setRotate(bool enable)
 {
-	rotate_.enabled = true;
-	rotate_.counter = 0;
-}
-
-// Establece el valor de la variable
-void MovingSprite::disableRotate()
-{
-	rotate_.enabled = false;
+	rotate_.enabled = enable;
 	rotate_.counter = 0;
 }
 
@@ -172,41 +171,6 @@ SDL_RendererFlip MovingSprite::getFlip()
 	return flip_;
 }
 
-// Obtiene el valor de la variable
-float MovingSprite::getPosX() const
-{
-	return x_;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getPosY() const
-{
-	return y_;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getVelX() const
-{
-	return vx_;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getVelY() const
-{
-	return vy_;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getAccelX() const
-{
-	return ax_;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getAccelY() const
-{
-	return ay_;
-}
 
 // Establece la posición y_ el tamaño del objeto
 void MovingSprite::setPos(SDL_Rect rect)

source/moving_sprite.h

@@ -19,7 +19,7 @@ public:
         float amount;      // Cantidad de grados a girar en cada iteración
         SDL_Point *center; // Centro de rotación
 
-        Rotate() : enabled(false), counter(0), speed(0), angle(0.0), amount(0.0f), center(nullptr) {}
+        Rotate() : enabled(false), counter(0), speed(1), angle(0.0), amount(0.0f), center(nullptr) {}
     };
 
 protected:
@@ -65,12 +65,12 @@ public:
     void render() override;
 
     // Obtiene la variable
-    float getPosX() const;
-    float getPosY() const;
-    float getVelX() const;
-    float getVelY() const;
-    float getAccelX() const;
-    float getAccelY() const;
+    float getPosX() const { return x_; }
+    float getPosY() const { return y_; }
+    float getVelX() const { return vx_; }
+    float getVelY() const { return vy_; }
+    float getAccelX() const { return ax_; }
+    float getAccelY() const { return ay_; }
 
     // Establece la variable
     void setVelX(float value);
@@ -87,10 +87,10 @@ public:
 
     // Establece el valor de la variable
     void setAngle(double vaue);
+    void setRotatingCenter(SDL_Point *point);
 
-    // Activa o desactiva el efecto derotación
-    void enableRotate();
-    void disableRotate();
+    // Activa o desactiva el efecto de rotación
+    void setRotate(bool enable);
 
     // Establece el valor de la variable
     void setRotateSpeed(int value);

source/notifier.cpp

@@ -10,14 +10,15 @@
 #include "sprite.h"     // Para Sprite
 #include "text.h"       // Para Text
 #include "texture.h"    // Para Texture
+#include "resource.h"
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Notifier *Notifier::notifier_ = nullptr;
 
 // [SINGLETON] Crearemos el objeto screen con esta función estática
-void Notifier::init(const std::string &icon_file, std::shared_ptr<Text> text, const std::string &sound_file)
+void Notifier::init(const std::string &icon_file, std::shared_ptr<Text> text)
 {
-    Notifier::notifier_ = new Notifier(icon_file, text, sound_file);
+    Notifier::notifier_ = new Notifier(icon_file, text);
 }
 
 // [SINGLETON] Destruiremos el objeto screen con esta función estática
@@ -33,21 +34,14 @@ Notifier *Notifier::get()
 }
 
 // Constructor
-Notifier::Notifier(std::string icon_file, std::shared_ptr<Text> text, const std::string &sound_file)
+Notifier::Notifier(std::string icon_file, std::shared_ptr<Text> text)
     : 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),
-      has_icons_(!icon_file.empty()),
-      sound_(JA_LoadSound(sound_file.c_str())) {}
-
-// Destructor
-Notifier::~Notifier()
-{
-    JA_DeleteSound(sound_);
-}
+      has_icons_(!icon_file.empty()) {}
 
 // Dibuja las notificaciones por pantalla
 void Notifier::render()
@@ -80,8 +74,9 @@ void Notifier::update()
             if (param.notification.sound)
             {
                 if (notifications_[i].status == NotificationStatus::RISING)
-                { // Reproduce el sonido de la notificación
-                    JA_PlaySound(sound_);
+                { 
+                    // Reproduce el sonido de la notificación
+                    JA_PlaySound(Resource::get()->getSound("notify.wav"));
                 }
             }
         }

source/notifier.h

@@ -62,7 +62,6 @@ private:
 	std::vector<Notification> notifications_; // La lista de notificaciones activas
 	bool stack_;							  // Indica si las notificaciones se apilan
 	bool has_icons_;						  // Indica si el notificador tiene textura para iconos
-	JA_Sound_t *sound_;						  // Sonido a reproducir cuando suena la notificación
 
 	// Elimina las notificaciones finalizadas
 	void clearFinishedNotifications();
@@ -73,14 +72,14 @@ private:
 	// [SINGLETON] Ahora el constructor y el destructor son privados, para no poder crear objetos notifier desde fuera
 
 	// Constructor
-	Notifier(std::string icon_file, std::shared_ptr<Text> text, const std::string &sound_file);
+	Notifier(std::string icon_file, std::shared_ptr<Text> text);
 
 	// Destructor
-	~Notifier();
+	~Notifier() = default;
 
 public:
 	// [SINGLETON] Crearemos el objeto notifier con esta función estática
-	static void init(const std::string &icon_file, std::shared_ptr<Text> text, const std::string &sound_file);
+	static void init(const std::string &icon_file, std::shared_ptr<Text> text);
 
 	// [SINGLETON] Destruiremos el objeto notifier con esta función estática
 	static void destroy();

source/on_screen_help.cpp

@@ -94,7 +94,7 @@ void OnScreenHelp::fillTexture()
     SDL_SetRenderTarget(Screen::get()->getRenderer(), texture);
 
     // Crea el objeto para el texto
-    auto text = std::make_unique<Text>(Resource::get()->getTexture("8bithud.png"), Resource::get()->getTextFile("8bithud.txt"));
+    auto text = Resource::get()->getText("8bithud");
 
     // Crea la textura con los gráficos
     auto controllersTexture = Resource::get()->getTexture("controllers.png");
@@ -169,7 +169,7 @@ void OnScreenHelp::toggleState()
 // Calcula la longitud en pixels del texto más largo
 auto OnScreenHelp::getLargestStringSize() -> int const
 {
-    auto text = std::make_unique<Text>(Resource::get()->getTexture("8bithud.png"), Resource::get()->getTextFile("8bithud.txt"));
+    auto text = Resource::get()->getText("8bithud");
     auto size = 0;
 
     for (int i = 107; i <= 113; ++i)

source/path_sprite.cpp

@@ -1,6 +1,5 @@
 #include "path_sprite.h"
-#include <cmath>	  // Para abs
-#include <stdlib.h>	  // Para abs
+#include <cstdlib>	  // Para abs
 #include <functional> // Para function
 #include <utility>	  // Para move
 

source/player.cpp

@@ -1,12 +1,10 @@
 #include "player.h"
-#include <SDL2/SDL_render.h>	  // Para SDL_FLIP_HORIZONTAL, SDL_FLIP_NONE
+#include <SDL2/SDL_render.h> // Para SDL_FLIP_HORIZONTAL, SDL_FLIP_NONE, SDL...
 #include <SDL2/SDL_timer.h>	 // Para SDL_GetTicks
 #include <stdlib.h>			 // Para rand
-#include <algorithm>			  // Para max, min
+#include <algorithm>		 // Para clamp, max, min
 #include "animated_sprite.h" // Para AnimatedSprite
 #include "input.h"			 // Para InputType
-#include "manage_hiscore_table.h" // Para HiScoreEntry
-#include "options.h"			  // Para Options, OptionsGame, options
 #include "param.h"			 // Para Param, ParamGame, param
 #include "scoreboard.h"		 // Para Scoreboard, ScoreboardMode
 #include "texture.h"		 // Para Texture
@@ -29,7 +27,7 @@ Player::Player(int id, float x, int y, bool demo, SDL_Rect &play_area, std::vect
 	power_sprite_->setPosY(y - (power_sprite_->getHeight() - player_sprite_->getHeight()));
 
 	// Inicializa variables
-	setRecordName(enter_name_->getName());
+	pos_x_ = default_pos_x_;
 	init();
 }
 
@@ -37,7 +35,6 @@ Player::Player(int id, float x, int y, bool demo, SDL_Rect &play_area, std::vect
 void Player::init()
 {
 	// Inicializa variables de estado
-	pos_x_ = default_pos_x_;
 	pos_y_ = default_pos_y_;
 	walking_state_ = PlayerState::WALKING_STOP;
 	firing_state_ = PlayerState::FIRING_NONE;
@@ -58,6 +55,7 @@ void Player::init()
 	score_ = 0;
 	score_multiplier_ = 1.0f;
 	cooldown_ = 10;
+	enter_name_->init();
 
 	// Establece la posición del sprite
 	player_sprite_->clear();
@@ -147,12 +145,10 @@ void Player::setInputEnteringName(InputType input)
 		enter_name_->decIndex();
 		break;
 	case InputType::START:
-		setRecordName(enter_name_->getName());
 		break;
 	default:
 		break;
 	}
-	setRecordName(enter_name_->getName());
 }
 
 // Mueve el jugador a la posición y animación que le corresponde
@@ -166,7 +162,7 @@ void Player::move()
 		pos_x_ += vel_x_;
 
 		// Si el jugador abandona el area de juego por los laterales, restaura su posición
-		const float min_x = param.game.play_area.rect.x - 5;
+		const float min_x = play_area_.x - 5;
 		const float max_x = play_area_.w + 5 - WIDTH_;
 		pos_x_ = std::clamp(pos_x_, min_x, max_x);
 
@@ -176,15 +172,34 @@ void Player::move()
 	case PlayerState::DYING:
 	{
 		// Si el cadaver abandona el area de juego por los laterales lo hace rebotar
-		if ((player_sprite_->getPosX() < param.game.play_area.rect.x) || (player_sprite_->getPosX() + WIDTH_ > play_area_.w))
+		if ((player_sprite_->getPosX() < play_area_.x) || (player_sprite_->getPosX() + WIDTH_ > play_area_.w))
+		{
 			player_sprite_->setVelX(-player_sprite_->getVelX());
+		}
 
-		// Si el cadaver abandona el area de juego por abajo
-		if (player_sprite_->getPosY() > param.game.play_area.rect.h)
+		// Si el cadaver toca el suelo cambia el estado
+		if (player_sprite_->getPosY() > play_area_.h - HEIGHT_)
+		{
+			if (player_sprite_->getVelY() < 2.0f)
+			{
+				// Si la velocidad de rebote es baja, termina de rebotar y cambia de estado
 				setPlayingState(PlayerState::DIED);
+				pos_x_ = player_sprite_->getPosX();
+				pos_y_ = default_pos_y_;
+				player_sprite_->clear();
+				shiftSprite();
+			}
+			else
+			{
+				// Decrementa las velocidades de rebote
+				player_sprite_->setPosY(play_area_.h - HEIGHT_);
+				player_sprite_->setVelY(player_sprite_->getVelY() * -0.5f);
+				player_sprite_->setVelX(player_sprite_->getVelX() * 0.75f);
+			}
+		}
 		break;
 	}
-	case PlayerState::GAME_COMPLETED:
+	case PlayerState::LEAVING_SCREEN:
 	{
 		switch (id_)
 		{
@@ -207,6 +222,41 @@ void Player::move()
 			setPlayingState(PlayerState::GAME_OVER);
 		break;
 	}
+	case PlayerState::CREDITS:
+	{
+		pos_x_ += vel_x_ / 2.0f;
+		if (vel_x_ > 0)
+		{
+			// setInputPlaying(InputType::RIGHT);
+			if (pos_x_ > param.game.game_area.rect.w - WIDTH_)
+			{
+				pos_x_ = param.game.game_area.rect.w - WIDTH_;
+				vel_x_ *= -1;
+				// setInputPlaying(InputType::LEFT);
+			}
+		}
+		else
+		{
+			// setInputPlaying(InputType::LEFT);
+			if (pos_x_ < param.game.game_area.rect.x)
+			{
+				pos_x_ = param.game.game_area.rect.x;
+				vel_x_ *= -1;
+				// setInputPlaying(InputType::RIGHT);
+			}
+		}
+
+		if (pos_x_ > param.game.game_area.center_x - WIDTH_ / 2)
+		{
+			setWalkingState(PlayerState::WALKING_LEFT);
+		}
+		else
+		{
+			setWalkingState(PlayerState::WALKING_RIGHT);
+		}
+		shiftSprite();
+		break;
+	}
 	default:
 		break;
 	}
@@ -216,16 +266,29 @@ 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 la animación correspondiente al estado
 void Player::setAnimation()
 {
+	switch (playing_state_)
+	{
+	case PlayerState::PLAYING:
+	case PlayerState::ENTERING_NAME_GAME_COMPLETED:
+	case PlayerState::LEAVING_SCREEN:
+	case PlayerState::CREDITS:
+	{
 		// Crea cadenas de texto para componer el nombre de la animación
 		const std::string a_walking = walking_state_ == PlayerState::WALKING_STOP ? "stand" : "walk";
 		const std::string a_firing = firing_state_ == PlayerState::FIRING_UP ? "centershoot" : "sideshoot";
@@ -236,8 +299,6 @@ void Player::setAnimation()
 		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() || isEnteringNameGameCompleted() || isGameCompleted())
-	{
 		if (firing_state_ == PlayerState::FIRING_NONE)
 		{ // No esta disparando
 			player_sprite_->setCurrentAnimation(a_walking);
@@ -255,14 +316,27 @@ void Player::setAnimation()
 			// Si dispara recto, invierte el sprite segun hacia donde camina
 			player_sprite_->setFlip(a_firing == "centershoot" ? flip_walk : flip_fire);
 		}
+		break;
 	}
-	else if (isDying() || hasDied())
+	case PlayerState::DYING:
 	{
-		player_sprite_->setCurrentAnimation("death");
+		player_sprite_->setCurrentAnimation("dying");
+		break;
 	}
-	else if (isCelebrating())
+	case PlayerState::DIED:
+	case PlayerState::ENTERING_NAME:
+	case PlayerState::CONTINUE:
+	{
+		player_sprite_->setCurrentAnimation("dead");
+		break;
+	}
+	case PlayerState::CELEBRATING:
 	{
 		player_sprite_->setCurrentAnimation("celebration");
+		break;
+	}
+	default:
+		break;
 	}
 
 	// Actualiza las animaciones de los sprites
@@ -344,7 +418,7 @@ void Player::updateScoreboard()
 	case PlayerState::ENTERING_NAME:
 	case PlayerState::ENTERING_NAME_GAME_COMPLETED:
 	{
-		Scoreboard::get()->setRecordName(getScoreBoardPanel(), getRecordName());
+		Scoreboard::get()->setRecordName(getScoreBoardPanel(), enter_name_->getName());
 		Scoreboard::get()->setSelectorPos(getScoreBoardPanel(), getRecordNamePos());
 		break;
 	}
@@ -381,7 +455,6 @@ void Player::setPlayingState(PlayerState state)
 		// Inicializa el contador de continuar
 		continue_ticks_ = SDL_GetTicks();
 		continue_counter_ = 9;
-		enter_name_->init();
 		setScoreboardMode(ScoreboardMode::CONTINUE);
 		break;
 	}
@@ -426,11 +499,16 @@ void Player::setPlayingState(PlayerState state)
 		setScoreboardMode(ScoreboardMode::ENTER_NAME);
 		break;
 	}
-	case PlayerState::GAME_COMPLETED:
+	case PlayerState::LEAVING_SCREEN:
 	{
 		setScoreboardMode(ScoreboardMode::GAME_COMPLETED);
 		break;
 	}
+	case PlayerState::CREDITS:
+	{
+		vel_x_ = (walking_state_ == PlayerState::WALKING_RIGHT) ? BASE_SPEED_ : -BASE_SPEED_;
+		break;
+	}
 	default:
 		break;
 	}
@@ -576,9 +654,13 @@ void Player::decEnterNameCounter()
 	{
 		enter_name_counter_ = param.game.enter_name_seconds;
 		if (playing_state_ == PlayerState::ENTERING_NAME)
+		{
 			setPlayingState(PlayerState::CONTINUE);
+		}
 		else
-			setPlayingState(PlayerState::GAME_COMPLETED);
+		{
+			setPlayingState(PlayerState::LEAVING_SCREEN);
+		}
 	}
 }
 
@@ -586,7 +668,9 @@ void Player::decEnterNameCounter()
 int Player::getRecordNamePos() const
 {
 	if (enter_name_)
+	{
 		return enter_name_->getPosition();
+	}
 
 	return 0;
 }
@@ -598,49 +682,3 @@ void Player::shiftSprite()
 	player_sprite_->setPosY(pos_y_);
 	power_sprite_->setPosX(getPosX() - power_up_desp_x_);
 }
-
-int Player::getScore() const { return score_; }
-void Player::setScore(int score) { score_ = score; }
-PlayerState Player::getPlayingState() const { return playing_state_; }
-float Player::getScoreMultiplier() const { return score_multiplier_; }
-void Player::setScoreMultiplier(float value) { score_multiplier_ = value; }
-bool Player::isInvulnerable() const { return invulnerable_; }
-int Player::getInvulnerableCounter() const { return invulnerable_counter_; }
-void Player::setInvulnerableCounter(int value) { invulnerable_counter_ = value; }
-bool Player::isPowerUp() const { return power_up_; }
-int Player::getPowerUpCounter() const { return power_up_counter_; }
-void Player::setPowerUpCounter(int value) { power_up_counter_ = value; }
-bool Player::hasExtraHit() const { return extra_hit_; }
-void Player::setScoreBoardPanel(int panel) { scoreboard_panel_ = panel; }
-int Player::getScoreBoardPanel() const { return scoreboard_panel_; }
-int Player::getCoffees() const { return coffees_; }
-Circle &Player::getCollider() { return collider_; }
-int Player::getContinueCounter() const { return continue_counter_; }
-void Player::setName(const std::string &name) { name_ = name; }
-void Player::setRecordName(const std::string &record_name) { record_name_ = record_name.substr(0, 8); }
-std::string Player::getName() const { return name_; }
-std::string Player::getRecordName() const { return record_name_; }
-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; }

source/player.h

@@ -1,17 +1,18 @@
 #pragma once
 
-#include "animated_sprite.h" // Para AnimatedSprite
-#include "enter_name.h"		 // Para EnterName
-#include "utils.h"			 // Para Circle
 #include <SDL2/SDL_rect.h>		  // Para SDL_Rect
 #include <SDL2/SDL_stdinc.h>	  // Para Uint32
 #include <memory>				  // Para unique_ptr, shared_ptr
 #include <string>				  // Para string
 #include <vector>				  // Para vector
-
-class Texture;				// lines 12-12
-enum class InputType : int; // lines 13-13
-enum class ScoreboardMode;	// lines 14-14
+#include "animated_sprite.h"	  // Para AnimatedSprite
+#include "enter_name.h"			  // Para EnterName
+#include "manage_hiscore_table.h" // Para HiScoreEntry
+#include "options.h"			  // Para Options, OptionsGame, options
+#include "utils.h"				  // Para Circle
+class Texture;					  // lines 13-13
+enum class InputType : int;		  // lines 14-14
+enum class ScoreboardMode;		  // lines 15-15
 
 // Estados del jugador
 enum class PlayerState
@@ -38,7 +39,8 @@ enum class PlayerState
 	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
+	LEAVING_SCREEN,				  // Moviendose fuera de la pantalla
+	CREDITS,					  // Estado para los creditos del juego
 };
 
 // Clase Player
@@ -85,7 +87,6 @@ private:
 	Uint32 continue_ticks_ = 0;								// Variable para poder cambiar el contador de continue en función del tiempo
 	int scoreboard_panel_ = 0;								// Panel del marcador asociado al jugador
 	std::string name_;										// Nombre del jugador
-	std::string record_name_;								// Nombre del jugador para la tabla de mejores puntuaciones
 	int controller_index_ = 0;								// Indice del array de mandos que utilizará para moverse
 	bool demo_;												// Para que el jugador sepa si está en el modo demostración
 	int enter_name_counter_;								// Contador para poner nombre
@@ -109,17 +110,13 @@ private:
 	// Decrementa el contador de entrar nombre
 	void decEnterNameCounter();
 
-	// Indica si el jugador se puede dibujar
-	bool isRenderable() const;
-
 	// Actualiza el panel del marcador
 	void updateScoreboard();
 
 	// Cambia el modo del marcador
 	void setScoreboardMode(ScoreboardMode mode);
 
-	// Se encuentra en alguno de los estados "COOLING"
-	bool isCooling();
+	bool isRenderable() const { return !isWaiting() && !isGameOver(); }
 
 public:
 	// Constructor
@@ -152,153 +149,91 @@ public:
 	// Mueve el jugador a la posición y animación que le corresponde
 	void move();
 
-	// Establece el estado del jugador
-	void setWalkingState(PlayerState state);
-
-	// Establece el estado del jugador
-	void setFiringState(PlayerState state);
-
 	// Establece la animación correspondiente al estado
 	void setAnimation();
 
-	// Obtiene el valor de la variable
-	int getPosX() const;
-
-	// Obtiene el valor de la variable
-	int getPosY() const;
-
-	// Obtiene el valor de la variable
-	int getWidth() const;
-
-	// Obtiene el valor de la variable
-	int getHeight() const;
-
-	// Indica si el jugador puede disparar
-	bool canFire() const;
-
-	// Establece el valor de la variable
-	void setFireCooldown(int time);
-
 	// Actualiza el valor de la variable
 	void updateCooldown();
 
-	// Obtiene la puntuación del jugador
-	int getScore() const;
-
-	// Asigna un valor a la puntuación del jugador
-	void setScore(int score);
-
 	// Incrementa la puntuación del jugador
 	void addScore(int score);
 
-	// Indica si el jugador se encuentra en ese estado
-	bool isPlaying() const;
-	bool isContinue() const;
-	bool isWaiting() const;
-	bool isEnteringName() const;
-	bool isDying() const;
-	bool hasDied() const;
-	bool isGameOver() const;
-	bool isEnteringNameGameCompleted() const;
-	bool isGameCompleted() const;
-	bool isCelebrating() const;
-
 	// Establece el estado del jugador en el juego
 	void setPlayingState(PlayerState state);
 
-	// Obtiene el estado del jugador en el juego
-	PlayerState getPlayingState() const;
-
-	// Obtiene el valor de la variable
-	float getScoreMultiplier() const;
-
-	// Establece el valor de la variable
-	void setScoreMultiplier(float value);
-
 	// Aumenta el valor de la variable hasta un máximo
 	void incScoreMultiplier();
 
 	// Decrementa el valor de la variable hasta un mínimo
 	void decScoreMultiplier();
 
-	// Obtiene el valor de la variable
-	bool isInvulnerable() const;
-
 	// Establece el valor del estado
 	void setInvulnerable(bool value);
 
-	// Obtiene el valor de la variable
-	int getInvulnerableCounter() const;
-
-	// Establece el valor de la variable
-	void setInvulnerableCounter(int value);
-
-	// Obtiene el valor de la variable
-	bool isPowerUp() const;
-
 	// Establece el valor de la variable a verdadero
 	void setPowerUp();
 
-	// Obtiene el valor de la variable
-	int getPowerUpCounter() const;
-
-	// Establece el valor de la variable
-	void setPowerUpCounter(int value);
-
 	// Actualiza el valor de la variable
 	void updatePowerUp();
 
-	// Obtiene el valor de la variable
-	bool hasExtraHit() const;
-
 	// Concede un toque extra al jugador
 	void giveExtraHit();
 
 	// Quita el toque extra al jugador
 	void removeExtraHit();
 
-	// Devuelve el número de cafes actuales
-	int getCoffees() const;
-
-	// Obtiene el circulo de colisión
-	Circle &getCollider();
-
-	// Obtiene el valor de la variable
-	int getContinueCounter() const;
-
-	// Le asigna un panel en el marcador al jugador
-	void setScoreBoardPanel(int panel);
-
-	// Obtiene el valor de la variable
-	int getScoreBoardPanel() const;
-
 	// Decrementa el contador de continuar
 	void decContinueCounter();
 
-	// Establece el nombre del jugador
-	void setName(const std::string &name);
-
-	// Establece el nombre del jugador para la tabla de mejores puntuaciones
-	void setRecordName(const std::string &record_name);
-
-	// Obtiene el nombre del jugador
-	std::string getName() const;
-
-	// Obtiene el nombre del jugador para la tabla de mejores puntuaciones
-	std::string getRecordName() const;
-
 	// 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
-	void setController(int index);
+	// Comprobación de playing_state
+	bool hasDied() const { return playing_state_ == PlayerState::DIED; }
+	bool isCelebrating() const { return playing_state_ == PlayerState::CELEBRATING; }
+	bool isContinue() const { return playing_state_ == PlayerState::CONTINUE; }
+	bool isDying() const { return playing_state_ == PlayerState::DYING; }
+	bool isEnteringName() const { return playing_state_ == PlayerState::ENTERING_NAME; }
+	bool isEnteringNameGameCompleted() const { return playing_state_ == PlayerState::ENTERING_NAME_GAME_COMPLETED; }
+	bool isLeavingScreen() const { return playing_state_ == PlayerState::LEAVING_SCREEN; }
+	bool isGameOver() const { return playing_state_ == PlayerState::GAME_OVER; }
+	bool isPlaying() const { return playing_state_ == PlayerState::PLAYING; }
+	bool isWaiting() const { return playing_state_ == PlayerState::WAITING; }
 
-	// Obtiene el mando que usa para ser controlado
-	int getController() const;
+	// Getters
+	bool canFire() const { return cooldown_ > 0 ? false : true; }
+	bool hasExtraHit() const { return extra_hit_; }
+	bool isCooling() { return firing_state_ == PlayerState::COOLING_LEFT || firing_state_ == PlayerState::COOLING_UP || firing_state_ == PlayerState::COOLING_RIGHT; }
+	bool IsEligibleForHighScore() { return score_ > options.game.hi_score_table.back().score; }
+	bool isInvulnerable() const { return invulnerable_; }
+	bool isPowerUp() const { return power_up_; }
+	Circle &getCollider() { return collider_; }
+	float getScoreMultiplier() const { return score_multiplier_; }
+	int getCoffees() const { return coffees_; }
+	int getContinueCounter() const { return continue_counter_; }
+	int getController() const { return controller_index_; }
+	int getHeight() const { return HEIGHT_; }
+	int getId() const { return id_; }
+	int getInvulnerableCounter() const { return invulnerable_counter_; }
+	int getPosX() const { return static_cast<int>(pos_x_); }
+	int getPosY() const { return pos_y_; }
+	int getPowerUpCounter() const { return power_up_counter_; }
+	std::string getRecordName() const { return enter_name_->getName(); }
+	int getScore() const { return score_; }
+	int getScoreBoardPanel() const { return scoreboard_panel_; }
+	int getWidth() const { return WIDTH_; }
+	PlayerState getPlayingState() const { return playing_state_; }
+	std::string getName() const { return name_; }
 
-	// Obtiene el "id" del jugador
-	int getId() const;
-
-	// Comprueba si la puntuación entra en la tabla de mejores puntuaciones
-	bool IsEligibleForHighScore();
+	// Setters
+	void setController(int index) { controller_index_ = index; }
+	void setFireCooldown(int time) { cooldown_ = time; }
+	void setFiringState(PlayerState state) { firing_state_ = state; }
+	void setInvulnerableCounter(int value) { invulnerable_counter_ = value; }
+	void setName(const std::string &name) { name_ = name; }
+	void setPowerUpCounter(int value) { power_up_counter_ = value; }
+	void setScore(int score) { score_ = score; }
+	void setScoreBoardPanel(int panel) { scoreboard_panel_ = panel; }
+	void setScoreMultiplier(float value) { score_multiplier_ = value; }
+	void setWalkingState(PlayerState state) { walking_state_ = state; }
 };

source/resource.cpp

@@ -2,13 +2,14 @@
 #include <algorithm>    // Para find_if
 #include <iostream>     // Para basic_ostream, operator<<, endl, cout, cerr
 #include <stdexcept>    // Para runtime_error
+#include <utility>      // Para pair
 #include "asset.h"      // Para Asset, AssetType
-#include "lang.h"       // Para lang
 #include "jail_audio.h" // Para JA_LoadMusic, JA_LoadSound
+#include "lang.h"       // Para getText
 #include "screen.h"     // Para Screen
-#include "text.h"       // Para Text
-struct JA_Music_t;
-struct JA_Sound_t;
+#include "text.h"       // Para Text, loadTextFile
+struct JA_Music_t;      // lines 10-10
+struct JA_Sound_t;      // lines 11-11
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Resource *Resource::resource_ = nullptr;
@@ -33,6 +34,24 @@ Resource *Resource::get()
 
 // Constructor
 Resource::Resource()
+{
+    load();
+}
+
+// Vacia todos los vectores de recursos
+void Resource::clear()
+{
+    clearSounds();
+    clearMusics();
+    textures_.clear();
+    text_files_.clear();
+    texts_.clear();
+    animations_.clear();
+    demos_.clear();
+}
+
+// Carga todos los recursos
+void Resource::load()
 {
     std::cout << "** LOADING RESOURCES" << std::endl;
     loadSounds();
@@ -42,10 +61,18 @@ Resource::Resource()
     loadAnimations();
     loadDemoData();
     addPalettes();
+    createText();
     createTextures();
     std::cout << "\n** RESOURCES LOADED" << std::endl;
 }
 
+// Recarga todos los recursos
+void Resource::reload()
+{
+    clear();
+    load();
+}
+
 // Obtiene el sonido a partir de un nombre
 JA_Sound_t *Resource::getSound(const std::string &name)
 {
@@ -106,6 +133,21 @@ std::shared_ptr<TextFile> Resource::getTextFile(const std::string &name)
     throw std::runtime_error("TextFile no encontrado: " + name);
 }
 
+// Obtiene el objeto de texto a partir de un nombre
+std::shared_ptr<Text> Resource::getText(const std::string &name)
+{
+    auto it = std::find_if(texts_.begin(), texts_.end(), [&name](const auto &t)
+                           { return t.name == name; });
+
+    if (it != texts_.end())
+    {
+        return it->text;
+    }
+
+    std::cerr << "Error: Text no encontrado " << name << std::endl;
+    throw std::runtime_error("Text no encontrado: " + name);
+}
+
 // Obtiene la animación a partir de un nombre
 AnimationsFileBuffer &Resource::getAnimation(const std::string &name)
 {
@@ -239,7 +281,6 @@ void Resource::createTextures()
     };
 
     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 = {
@@ -251,6 +292,7 @@ void Resource::createTextures()
         NameAndText("game_text_stop", lang::getText(119)),
         NameAndText("1000000_points", lang::getText(76))};
 
+    auto text = getText("04b_25");
     for (const auto &s : strings)
     {
         textures_.emplace_back(ResourceTexture(s.name, text->writeToTexture(s.text, 1, -2)));
@@ -264,9 +306,59 @@ void Resource::createTextures()
         NameAndText("congratulations", lang::getText(50)),
         NameAndText("game_over", "Game Over")};
 
+    auto text2 = getText("04b_25_2x");
     for (const auto &s : strings2X)
     {
-        textures_.emplace_back(ResourceTexture(s.name, text->writeToTexture(s.text, 2, -2)));
+        textures_.emplace_back(ResourceTexture(s.name, text2->writeToTexture(s.text, 1, -4)));
         printWithDots("Texture : ", s.name, "[  DONE  ]");
     }
 }
+
+// Crea los objetos de texto
+void Resource::createText()
+{
+    std::cout << "\n>> CREATING TEXT_OBJECTS" << std::endl;
+
+    std::vector<std::pair<std::string, std::string>> resources = {
+        {"04b_25", "04b_25.png"},
+        {"04b_25_2x", "04b_25_2x.png"},
+        {"8bithud", "8bithud.png"},
+        {"nokia", "nokia.png"},
+        {"smb2", "smb2.gif"}};
+
+    for (const auto &resource : resources)
+    {
+        texts_.emplace_back(ResourceText(resource.first, std::make_shared<Text>(getTexture(resource.second), getTextFile(resource.first + ".txt"))));
+        printWithDots("Text : ", resource.first, "[  DONE  ]");
+    }
+}
+
+// Vacía el vector de sonidos
+void Resource::clearSounds()
+{
+    // Itera sobre el vector y libera los recursos asociados a cada JA_Sound_t
+    for (auto &sound : sounds_)
+    {
+        if (sound.sound)
+        {
+            JA_DeleteSound(sound.sound);
+            sound.sound = nullptr;
+        }
+    }
+    sounds_.clear(); // Limpia el vector después de liberar todos los recursos
+}
+
+// Vacía el vector de musicas
+void Resource::clearMusics()
+{
+    // Itera sobre el vector y libera los recursos asociados a cada JA_Music_t
+    for (auto &music : musics_)
+    {
+        if (music.music)
+        {
+            JA_DeleteMusic(music.music);
+            music.music = nullptr;
+        }
+    }
+    musics_.clear(); // Limpia el vector después de liberar todos los recursos
+}

source/resource.h

@@ -54,6 +54,17 @@ struct ResourceTextFile
         : name(name), text_file(text_file) {}
 };
 
+// Estructura para almacenar objetos Text y su nombre
+struct ResourceText
+{
+    std::string name;           // Nombre del objeto
+    std::shared_ptr<Text> text; // Objeto
+
+    // Constructor
+    ResourceText(const std::string &name, std::shared_ptr<Text> text)
+        : name(name), text(text) {}
+};
+
 // Estructura para almacenar ficheros animaciones y su nombre
 struct ResourceAnimation
 {
@@ -75,6 +86,7 @@ private:
     std::vector<ResourceMusic> musics_;         // Vector con las musicas
     std::vector<ResourceTexture> textures_;     // Vector con las musicas
     std::vector<ResourceTextFile> text_files_;  // Vector con los ficheros de texto
+    std::vector<ResourceText> texts_;           // Vector con los objetos de texto
     std::vector<ResourceAnimation> animations_; // Vector con las animaciones
     std::vector<DemoData> demos_;               // Vector con los ficheros de datos para el modo demostración
 
@@ -102,6 +114,21 @@ private:
     // Crea texturas
     void createTextures();
 
+    // Crea los objetos de texto
+    void createText();
+
+    // Vacia todos los vectores de recursos
+    void clear();
+
+    // Carga todos los recursos
+    void load();
+
+    // Vacía el vector de sonidos
+    void clearSounds();
+
+    // Vacía el vector de musicas
+    void clearMusics();
+
     // [SINGLETON] Ahora el constructor y el destructor son privados, para no poder crear objetos resource desde fuera
 
     // Constructor
@@ -132,9 +159,15 @@ public:
     // Obtiene el fichero de texto a partir de un nombre
     std::shared_ptr<TextFile> getTextFile(const std::string &name);
 
+    // Obtiene el objeto de texto a partir de un nombre
+    std::shared_ptr<Text> getText(const std::string &name);
+
     // Obtiene la animación a partir de un nombre
     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);
+
+    // Recarga todos los recursos
+    void reload();
 };

source/scoreboard.cpp

@@ -10,6 +10,7 @@
 #include "screen.h"				// Para Screen
 #include "sprite.h"				// Para Sprite
 #include "text.h"				// Para Text
+#include "enter_name.h"
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Scoreboard *Scoreboard::scoreboard_ = nullptr;
@@ -37,7 +38,7 @@ Scoreboard::Scoreboard()
 	: renderer_(Screen::get()->getRenderer()),
 	  game_power_meter_texture_(Resource::get()->getTexture("game_power_meter.png")),
 	  power_meter_sprite_(std::make_unique<Sprite>(game_power_meter_texture_)),
-	  text_scoreboard_(std::make_unique<Text>(Resource::get()->getTexture("8bithud.png"), Resource::get()->getTextFile("8bithud.txt")))
+	  text_scoreboard_(Resource::get()->getText("8bithud"))
 {
 	// Inicializa variables
 	for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
@@ -118,17 +119,6 @@ void Scoreboard::render()
 	SDL_RenderCopy(renderer_, background_, nullptr, &rect_);
 }
 
-void Scoreboard::setName(int panel, const std::string &name) { name_[panel] = 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; }
-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::setColor(Color color)
 {
@@ -180,7 +170,7 @@ void Scoreboard::fillPanelTextures()
 
 			// MULT
 			text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(55));
-			text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, std::to_string(mult_[i]).substr(0, 3));
+			text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, "x" + std::to_string(mult_[i]).substr(0, 3));
 			break;
 		}
 
@@ -239,7 +229,8 @@ void Scoreboard::fillPanelTextures()
 
 			// HI-SCORE
 			text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(56));
-			text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, hi_score_name_ + " - " + updateScoreText(hi_score_));
+			const std::string name = hi_score_name_ == "" ? "" : hi_score_name_ + " - ";
+			text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, name + updateScoreText(hi_score_));
 			break;
 		}
 
@@ -267,21 +258,6 @@ void Scoreboard::fillPanelTextures()
 			SDL_SetRenderDrawColor(renderer_, 0xFF, 0xFF, 0xEB, 255);
 			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)
-					{
-						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));
-					}
-				}
-				else
-				{
-					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);
@@ -372,7 +348,7 @@ void Scoreboard::recalculateAnchors()
 	slot4_4_ = {col, row4};
 
 	// Primer cuadrado para poner el nombre de record
-	const int enterNameLenght = 8 * 7;
+	const int enterNameLenght = NAME_LENGHT * 7;
 	enter_name_pos_.x = (panelWidth - enterNameLenght) / 2;
 	enter_name_pos_.y = row4;
 
@@ -384,9 +360,6 @@ void Scoreboard::recalculateAnchors()
 	}
 }
 
-// Establece el modo del marcador
-void Scoreboard::setMode(int index, ScoreboardMode mode) { panel_[index].mode = mode; }
-
 // Crea la textura de fondo
 void Scoreboard::createBackgroundTexture()
 {

source/scoreboard.h

@@ -52,7 +52,7 @@ private:
 
 	std::shared_ptr<Texture> game_power_meter_texture_; // Textura con el marcador de poder de la fase
 	std::unique_ptr<Sprite> power_meter_sprite_;		// Sprite para el medidor de poder de la fase
-	std::unique_ptr<Text> text_scoreboard_;				// Fuente para el marcador del juego
+	std::shared_ptr<Text> text_scoreboard_;				// Fuente para el marcador del juego
 
 	SDL_Texture *background_ = nullptr;		   // Textura para dibujar el marcador
 	std::vector<SDL_Texture *> panel_texture_; // Texturas para dibujar cada panel
@@ -126,42 +126,21 @@ public:
 	// Pinta el marcador
 	void render();
 
-	// Establece el valor de la variable
-	void setName(int panel, const std::string &name);
-
-	// Establece el valor de la variable
-	void setRecordName(int panel, const std::string &record_name);
-
-	// Establece el valor de la variable
-	void setSelectorPos(int panel, int pos);
-
-	// Establece el valor de la variable
-	void setScore(int panel, int score);
-
-	// Establece el valor de la variable
-	void setMult(int panel, float mult);
-
-	// Establece el valor de la variable
-	void setContinue(int panel, int score);
-
-	// Establece el valor de la variable
-	void setStage(int stage);
-
-	// Establece el valor de la variable
-	void setHiScore(int hi_score);
-
-	// Establece el valor de la variable
-	void setPower(float power);
-
-	// Establece el valor de la variable
-	void setHiScoreName(const std::string &name);
-
 	// Establece el valor de la variable
 	void setColor(Color color);
 
 	// Establece el valor de la variable
 	void setPos(SDL_Rect rect);
 
-	// Establece el modo del marcador
-	void setMode(int index, ScoreboardMode mode);
+	void setContinue(int panel, int continue_counter) { continue_counter_[panel] = continue_counter; }
+	void setHiScore(int hi_score) { hi_score_ = hi_score; }
+	void setHiScoreName(const std::string &name) { hi_score_name_ = name; }
+	void setMode(int index, ScoreboardMode mode) { panel_[index].mode = mode; }
+	void setMult(int panel, float mult) { mult_[panel] = mult; }
+	void setName(int panel, const std::string &name) { name_[panel] = name; }
+	void setPower(float power) { power_ = power; }
+	void setRecordName(int panel, const std::string &record_name) { record_name_[panel] = record_name; }
+	void setScore(int panel, int score) { score_[panel] = score; }
+	void setSelectorPos(int panel, int pos) { selector_pos_[panel] = pos; }
+	void setStage(int stage) { stage_ = stage; }
 };

source/screen.cpp

@@ -11,7 +11,6 @@
 #include "asset.h"           // Para Asset
 #include "dbgtxt.h"          // Para dbg_print
 #include "global_inputs.h"   // Para service_pressed_counter
-#include "jail_shader.h"     // Para init, render
 #include "notifier.h"        // Para Notifier
 #include "on_screen_help.h"  // Para OnScreenHelp
 #include "options.h"         // Para Options, OptionsVideo, options, Options...
@@ -89,10 +88,10 @@ void Screen::blit()
     fps_counter_++;
 
     // Actualiza y dibuja el efecto de flash en la pantalla
-    doFlash();
+    renderFlash();
 
     // Atenua la pantalla
-    doAttenuate();
+    renderAttenuate();
 
     // Muestra la ayuda por pantalla
     OnScreenHelp::get()->render();
@@ -201,7 +200,8 @@ void Screen::setVideoMode(ScreenVideoMode videoMode)
     if (options.video.shaders)
     {
 #ifndef NO_SHADERS
-        std::ifstream f(Asset::get()->get("crtpi.glsl").c_str());
+        const std::string glsl_file = param.game.game_area.rect.h == 256 ? "crtpi_256.glsl" : "crtpi_240.glsl";
+        std::ifstream f(Asset::get()->get(glsl_file).c_str());
         std::string source((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
 
         shader::init(window_, shader_canvas_, source.c_str());
@@ -255,6 +255,7 @@ void Screen::setBlendMode(SDL_BlendMode blendMode)
 void Screen::update()
 {
     updateShakeEffect();
+    updateFlash();
     Notifier::get()->update();
     updateFPS();
     OnScreenHelp::get()->update();
@@ -313,21 +314,26 @@ void Screen::flash(Color color, int lenght)
 }
 
 // Actualiza y dibuja el efecto de flash en la pantalla
-void Screen::doFlash()
+void Screen::renderFlash()
 {
     if (flash_effect_.enabled)
     {
-        // Dibuja el color del flash en la textura
         SDL_SetRenderDrawColor(renderer_, flash_effect_.color.r, flash_effect_.color.g, flash_effect_.color.b, 0xFF);
         SDL_RenderClear(renderer_);
+    }
+}
 
-        // Actualiza la lógica del efecto
+// Actualiza el efecto de flash
+void Screen::updateFlash()
+{
+    if (flash_effect_.enabled)
+    {
         flash_effect_.counter > 0 ? flash_effect_.counter-- : flash_effect_.enabled = false;
     }
 }
 
 // Atenua la pantalla
-void Screen::doAttenuate()
+void Screen::renderAttenuate()
 {
     if (attenuate_effect_)
     {
@@ -387,7 +393,7 @@ void Screen::renderInfo()
         dbg_print(0, 0, info_resolution_.c_str(), 255, 255, 0);
 
         // Contador de service_pressed_counter
-        if (const int counter = globalInputs::service_pressed_counter[0]; counter > 0)
+        if (const int counter = globalInputs::service_pressed_counter; counter > 0)
             dbg_print(0, 8, std::to_string(counter).c_str(), 255, 0, 255);
     }
 }

source/screen.h

@@ -82,11 +82,14 @@ private:
 	// Actualiza la logica para agitar la pantalla
 	void updateShakeEffect();
 
-	// Actualiza y dibuja el efecto de flash en la pantalla
-	void doFlash();
+	// Dibuja el efecto de flash en la pantalla
+	void renderFlash();
+
+	// Actualiza el efecto de flash
+	void updateFlash();
 
 	// Atenua la pantalla
-	void doAttenuate();
+	void renderAttenuate();
 
 	// Calcula los frames por segundo
 	void updateFPS();

source/section.h

@@ -13,7 +13,8 @@ namespace section
         HI_SCORE_TABLE = 5,
         GAME_DEMO = 6,
         INSTRUCTIONS = 7,
-        QUIT = 8,
+        CREDITS = 8,
+        QUIT = 9,
     };
 
     // Opciones para la sección
@@ -26,7 +27,8 @@ namespace section
         QUIT_WITH_KEYBOARD = 4,
         QUIT_WITH_CONTROLLER = 5,
         QUIT_FROM_EVENT = 6,
-        NONE = 7,
+        RELOAD = 7,
+        NONE = 8,
     };
 
     // Variables para el Attract Mode

source/sprite.cpp

@@ -19,31 +19,7 @@ Sprite::Sprite(std::shared_ptr<Texture> texture)
 // Muestra el sprite por pantalla
 void Sprite::render()
 {
-	texture_->render(pos_.x, pos_.y, &sprite_clip_);
-}
-
-// Obten el valor de la variable
-int Sprite::getX() const
-{
-	return pos_.x;
-}
-
-// Obten el valor de la variable
-int Sprite::getY() const
-{
-	return pos_.y;
-}
-
-// Obten el valor de la variable
-int Sprite::getWidth() const
-{
-	return pos_.w;
-}
-
-// Obten el valor de la variable
-int Sprite::getHeight() const
-{
-	return pos_.h;
+	texture_->render(pos_.x, pos_.y, &sprite_clip_, zoom_, zoom_);
 }
 
 // Establece la posición del objeto
@@ -60,84 +36,6 @@ void Sprite::setPosition(SDL_Point p)
 	pos_.y = p.y;
 }
 
-// Establece la posición del objeto
-void Sprite::setPosition(SDL_Rect r)
-{
-	pos_ = r;
-}
-
-// Establece el valor de la variable
-void Sprite::setX(int x)
-{
-	pos_.x = x;
-}
-
-// Establece el valor de la variable
-void Sprite::setY(int y)
-{
-	pos_.y = y;
-}
-
-// Establece el valor de la variable
-void Sprite::setWidth(int w)
-{
-	pos_.w = w;
-}
-
-// Establece el valor de la variable
-void Sprite::setHeight(int h)
-{
-	pos_.h = h;
-}
-
-// Obten el valor de la variable
-SDL_Rect Sprite::getSpriteClip() const
-{
-	return sprite_clip_;
-}
-
-// Establece el valor de la variable
-void Sprite::setSpriteClip(SDL_Rect rect)
-{
-	sprite_clip_ = rect;
-}
-
-// Establece el valor de la variable
-void Sprite::setSpriteClip(int x, int y, int w, int h)
-{
-	sprite_clip_ = (SDL_Rect){x, y, w, h};
-}
-
-// Obten el valor de la variable
-std::shared_ptr<Texture> Sprite::getTexture() const
-{
-	return texture_;
-}
-
-// Establece el valor de la variable
-void Sprite::setTexture(std::shared_ptr<Texture> texture)
-{
-	texture_ = texture;
-}
-
-// Devuelve el rectangulo donde está el sprite
-SDL_Rect Sprite::getPosition() const
-{
-	return pos_;
-}
-
-// Incrementa el valor de la variable
-void Sprite::incX(int value)
-{
-	pos_.x += value;
-}
-
-// Incrementa el valor de la variable
-void Sprite::incY(int value)
-{
-	pos_.y += value;
-}
-
 // Reinicia las variables a cero
 void Sprite::clear()
 {

source/sprite.h

@@ -12,6 +12,7 @@ protected:
     std::shared_ptr<Texture> texture_; // Textura donde estan todos los dibujos del sprite
     SDL_Rect pos_;                     // Posición y tamaño donde dibujar el sprite
     SDL_Rect sprite_clip_;             // Rectangulo de origen de la textura que se dibujará en pantalla
+    double zoom_ = 1.0f;               // Zoom aplicado a la textura
 
 public:
     // Constructor
@@ -28,40 +29,43 @@ public:
     // Reinicia las variables a cero
     virtual void clear();
 
-    // Obten el valor de la variable
-    int getX() const;
-    int getY() const;
-    int getWidth() const;
-    int getHeight() const;
+    // Obtiene la posición y el tamaño
+    int getX() const { return pos_.x; }
+    int getY() const { return pos_.y; }
+    int getWidth() const { return pos_.w; }
+    int getHeight() const { return pos_.h; }
 
     // Devuelve el rectangulo donde está el sprite
-    SDL_Rect getPosition() const;
+    SDL_Rect getPosition() const { return pos_; }
 
-    // Establece el valor de la variable
-    void setX(int x);
-    void setY(int y);
-    void setWidth(int w);
-    void setHeight(int h);
+    // Establece la posición y el tamaño
+    void setX(int x) { pos_.x = x; }
+    void setY(int y) { pos_.y = y; }
+    void setWidth(int w) { pos_.w = w; }
+    void setHeight(int h) { pos_.h = h; }
 
     // Establece la posición del objeto
     void setPosition(int x, int y);
     void setPosition(SDL_Point p);
-    void setPosition(SDL_Rect r);
+    void setPosition(SDL_Rect r) { pos_ = r; }
 
-    // Incrementa el valor de la variable
-    void incX(int value);
-    void incY(int value);
+    // Establece el nivel de zoom
+    void setZoom(float zoom) { zoom_ = zoom; }
 
-    // Obten el valor de la variable
-    SDL_Rect getSpriteClip() const;
+    // Aumenta o disminuye la posición
+    void incX(int value) { pos_.x += value; }
+    void incY(int value) { pos_.y += value; }
 
-    // Establece el valor de la variable
-    void setSpriteClip(SDL_Rect rect);
-    void setSpriteClip(int x, int y, int w, int h);
+    // Obtiene el rectangulo que se dibuja de la textura
+    SDL_Rect getSpriteClip() const { return sprite_clip_; }
 
-    // Obten el valor de la variable
-    std::shared_ptr<Texture> getTexture() const;
+    // Establece el rectangulo que se dibuja de la textura
+    void setSpriteClip(SDL_Rect rect) { sprite_clip_ = rect; }
+    void setSpriteClip(int x, int y, int w, int h) { sprite_clip_ = (SDL_Rect){x, y, w, h}; }
 
-    // Establece el valor de la variable
-    void setTexture(std::shared_ptr<Texture> texture);
+    // Obtiene un puntero a la textura
+    std::shared_ptr<Texture> getTexture() const { return texture_; }
+
+    // Establece la textura a utilizar
+    void setTexture(std::shared_ptr<Texture> texture) { texture_ = texture; }
 };

source/stage.cpp

@@ -0,0 +1,41 @@
+#include "stage.h"
+#include <algorithm> // Para min
+#include <vector>    // Para vector
+
+namespace Stage
+{
+
+    std::vector<Stage> stages; // Variable con los datos de cada pantalla
+    int power = 0;             // Poder acumulado en la fase
+    int total_power = 0;       // Poder total necesario para completar el juego
+    int number = 0;            // Fase actual
+
+    // Devuelve una fase
+    Stage get(int index) { return stages.at(std::min(9, index)); }
+
+    // Inicializa las variables del namespace Stage
+    void init()
+    {
+        stages.emplace_back(Stage(200, 7 + (4 * 1), 7 + (4 * 3)));
+        stages.emplace_back(Stage(300, 7 + (4 * 2), 7 + (4 * 4)));
+        stages.emplace_back(Stage(600, 7 + (4 * 3), 7 + (4 * 5)));
+        stages.emplace_back(Stage(600, 7 + (4 * 3), 7 + (4 * 5)));
+        stages.emplace_back(Stage(600, 7 + (4 * 4), 7 + (4 * 6)));
+        stages.emplace_back(Stage(600, 7 + (4 * 4), 7 + (4 * 6)));
+        stages.emplace_back(Stage(650, 7 + (4 * 5), 7 + (4 * 7)));
+        stages.emplace_back(Stage(750, 7 + (4 * 5), 7 + (4 * 7)));
+        stages.emplace_back(Stage(850, 7 + (4 * 6), 7 + (4 * 8)));
+        stages.emplace_back(Stage(950, 7 + (4 * 7), 7 + (4 * 10)));
+
+        power = 0;
+        total_power = 0;
+        number = 0;
+    }
+
+    // Añade poder
+    void addPower(int amount)
+    {
+        power += amount;
+        total_power += amount;
+    }
+}

source/stage.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <vector>
+
+namespace Stage
+{
+    struct Stage
+    {
+        int power_to_complete; // Cantidad de poder que se necesita para completar la fase
+        int min_menace;        // Umbral mínimo de amenaza de la fase
+        int max_menace;        // Umbral máximo de amenaza de la fase
+
+        // Constructor
+        Stage(int power_to_complete, int min_menace, int max_menace)
+            : power_to_complete(power_to_complete), min_menace(min_menace), max_menace(max_menace) {}
+    };
+
+    extern std::vector<Stage> stages; // Variable con los datos de cada pantalla
+    extern int power;                 // Poder acumulado en la fase
+    extern int total_power;           // Poder total necesario para completar el juego
+    extern int number;                // Fase actual
+
+    // Devuelve una fase
+    Stage get(int index);
+
+    // Inicializa las variables del namespace Stage
+    void init();
+
+    // Añade poder
+    void addPower(int amount);
+}

source/text.cpp

@@ -164,6 +164,8 @@ std::shared_ptr<Texture> Text::writeToTexture(const std::string &text, int zoom,
 	texture->createBlank(width, height, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
 	texture->setBlendMode(SDL_BLENDMODE_BLEND);
 	texture->setAsRenderTarget(renderer);
+	SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
+	SDL_RenderClear(renderer);
 	zoom == 1 ? write(0, 0, text, kerning) : write2X(0, 0, text, kerning);
 
 	return texture;
@@ -263,3 +265,12 @@ void Text::setFixedWidth(bool value)
 {
 	fixed_width_ = value;
 }
+
+// Establece una paleta
+void Text::setPalette(int number)
+{
+	auto temp = SDL_GetRenderTarget(Screen::get()->getRenderer());
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), nullptr);
+	sprite_->getTexture()->setPalette(number);
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), temp);
+}

source/text.h

@@ -78,4 +78,7 @@ public:
 
 	// Establece si se usa un tamaño fijo de letra
 	void setFixedWidth(bool value);
+
+	// Establece una paleta
+	void setPalette(int number);
 };

source/texture.cpp

@@ -190,8 +190,16 @@ void Texture::render(int x, int y, SDL_Rect *clip, float zoomW, float zoomH, dou
 		renderQuad.h = clip->h;
 	}
 
+	// Calcula el zoom y las coordenadas
+	if (zoomH != 1.0f || zoomW != 1.0f)
+	{
+		renderQuad.x = renderQuad.x + (renderQuad.w / 2);
+		renderQuad.y = renderQuad.y + (renderQuad.h / 2);
 		renderQuad.w = renderQuad.w * zoomW;
 		renderQuad.h = renderQuad.h * zoomH;
+		renderQuad.x = renderQuad.x - (renderQuad.w / 2);
+		renderQuad.y = renderQuad.y - (renderQuad.h / 2);
+	}
 
 	// Renderiza a pantalla
 	SDL_RenderCopyEx(renderer_, texture_, clip, &renderQuad, angle, center, flip);

source/title.cpp

@@ -5,7 +5,6 @@
 #include <SDL2/SDL_timer.h>	  // Para SDL_GetTicks
 #include <stddef.h>			  // Para size_t
 #include <string>			  // Para char_traits, operator+, basic_string
-#include <utility>			  // Para move
 #include <vector>			  // Para vector
 #include "define_buttons.h"	  // Para DefineButtons
 #include "fade.h"			  // Para Fade, FadeType
@@ -21,25 +20,24 @@
 #include "screen.h"			  // Para Screen
 #include "section.h"		  // Para Options, options, Name, name, AttractMode
 #include "sprite.h"			  // Para Sprite
-#include "text.h"			  // Para Text, TEXT_CENTER, TEXT_SHADOW
+#include "text.h"			  // Para TEXT_CENTER, TEXT_SHADOW, Text
 #include "texture.h"		  // Para Texture
 #include "tiled_bg.h"		  // Para TiledBG, TiledBGMode
 #include "utils.h"			  // Para Color, Zone, fade_color, no_color, BLOCK
 
 // Constructor
 Title::Title()
-	: text1_(std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"))),
-	  text2_(std::make_unique<Text>(Resource::get()->getTexture("8bithud.png"), Resource::get()->getTextFile("8bithud.txt"))),
+	: text_(Resource::get()->getText("smb2")),
 	  fade_(std::make_unique<Fade>()),
-	  tiled_bg_(std::make_unique<TiledBG>((SDL_Rect){0, 0, param.game.width, param.game.height}, TiledBGMode::RANDOM)),
+	  tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::RANDOM)),
 	  game_logo_(std::make_unique<GameLogo>(param.game.game_area.center_x, param.title.title_c_c_position)),
-	  mini_logo_texture_(Resource::get()->getTexture("logo_jailgames_mini.png")),
-	  mini_logo_sprite_(std::make_unique<Sprite>(mini_logo_texture_, param.game.game_area.center_x - mini_logo_texture_->getWidth() / 2, 0, mini_logo_texture_->getWidth(), mini_logo_texture_->getHeight())),
-	  define_buttons_(std::make_unique<DefineButtons>(std::move(text2_))),
+	  mini_logo_sprite_(std::make_unique<Sprite>(Resource::get()->getTexture("logo_jailgames_mini.png"))), 
+	  define_buttons_(std::make_unique<DefineButtons>()),
 	  num_controllers_(Input::get()->getNumControllers())
 {
 	// Configura objetos
 	game_logo_->enable();
+	mini_logo_sprite_->setX(param.game.game_area.center_x - mini_logo_sprite_->getWidth() / 2);
 	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
 	fade_->setType(FadeType::RANDOM_SQUARE);
 	fade_->setPost(param.fade.post_duration);
@@ -71,7 +69,10 @@ void Title::update()
 		// Actualiza el objeto screen
 		Screen::get()->update();
 
-		// Comprueba el fade_ y si se ha acabado
+		// Actualiza las variables de globalInputs
+        globalInputs::update();
+
+		// Comprueba el fundido y si se ha acabado
 		fade_->update();
 		if (fade_->hasEnded())
 		{
@@ -146,7 +147,7 @@ void Title::render()
 		// 'PRESS TO PLAY'
 		if (counter_ % 50 > 14 && !define_buttons_->isEnabled())
 		{
-			text1_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, param.title.press_start_position, lang::getText(23), 1, no_color, 1, shadow);
+			text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, param.title.press_start_position, lang::getText(23), 1, no_color, 1, shadow);
 		}
 
 		// Mini logo
@@ -156,7 +157,7 @@ void Title::render()
 		mini_logo_sprite_->render();
 
 		// Texto con el copyright
-		text1_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, pos2, TEXT_COPYRIGHT, 1, no_color, 1, shadow);
+		text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, pos2, TEXT_COPYRIGHT, 1, no_color, 1, shadow);
 	}
 
 	// Define Buttons

source/title.h

@@ -40,12 +40,10 @@ class Title
 {
 private:
 	// Objetos y punteros
-	std::unique_ptr<Text> text1_;					// Objeto de texto para poder escribir textos en pantalla
-	std::unique_ptr<Text> text2_;					// Objeto de texto para poder escribir textos en pantalla
+	std::shared_ptr<Text> text_;					// Objeto de texto para poder escribir textos en pantalla
 	std::unique_ptr<Fade> fade_;					// Objeto para realizar fundidos en pantalla
 	std::unique_ptr<TiledBG> tiled_bg_;				// Objeto para dibujar el mosaico animado de fondo
 	std::unique_ptr<GameLogo> game_logo_;			// Objeto para dibujar el logo con el título del juego
-	std::shared_ptr<Texture> mini_logo_texture_;	// Textura con el logo de JailGames mini
 	std::unique_ptr<Sprite> mini_logo_sprite_;		// Sprite con el logo de JailGames mini
 	std::unique_ptr<DefineButtons> define_buttons_; // Objeto para definir los botones del joystic