fix: els globos tenien un parell de setters mal asignats per culpa de buscar y reemplazar

fix: els globos verds s'inicialitzaven amb vy = 0 per gastar abs en lloc de fabs
fix: corregit un bug milenari que de sempre havia creat els balloons verds al popar al pare amb la meitat de velocitat en y. Lo que jo no se es com anava res. Supose que ara el joc serà un poc mes xungo. Quan rebotaven en el piso ja se'ls posava la velocitat bona (crec)

.gitignore

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

Makefile

@@ -24,17 +24,18 @@ INCLUDES:= -I$(DIR_SOURCES)
 # Variables según el sistema operativo
 ifeq ($(OS),Windows_NT)
     FixPath = $(subst /,\,$1)
-	SOURCES := source/*.cpp source/common/*.cpp
+	SOURCES := source/*.cpp
-	CXXFLAGS:= -std=c++11 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows
+	CXXFLAGS:= -std=c++20 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows
-	CXXFLAGS_DEBUG:= -std=c++11 -Wall
+	CXXFLAGS_DEBUG:= -std=c++20 -Wall -g
 	LDFLAGS := -lmingw32 -lws2_32 -lSDL2main -lSDL2 -lopengl32
 	RM = del /Q
 	MKD:= mkdir
 else
     FixPath = $1
 	SOURCES := $(shell find $(DIR_SOURCES) -name '*.cpp')
-	CXXFLAGS:= -std=c++11 -Wall -Os -ffunction-sections -fdata-sections
+	SOURCES := source/*.cpp
-	CXXFLAGS_DEBUG:= -std=c++11 -Wall
+	CXXFLAGS:= -std=c++20 -Wall -Os -ffunction-sections -fdata-sections
+	CXXFLAGS_DEBUG:= -std=c++20 -Wall -g
 	LDFLAGS := -lSDL2
 	RM = rm -f
 	MKD:= mkdir -p
@@ -120,13 +121,12 @@ print-variables:
 
 	@echo RM: $(RM)
 
-raspi3:
+raspi:
-	$(CXX) $(SOURCES) -D NO_SHADERS -D VERBOSE $(CXXFLAGS) -lSDL2 -o $(TARGET_FILE)
+	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(TARGET_FILE)
 	strip -s -R .comment -R .gnu.version $(TARGET_FILE) --strip-unneeded
 
-raspi5:
+raspi_debug:
-	$(CXX) $(SOURCES) -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(TARGET_FILE)
+	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE -D DEBUG $(CXXFLAGS_DEBUG) $(LDFLAGS) -o "$(TARGET_FILE)_debug"
-	strip -s -R .comment -R .gnu.version $(TARGET_FILE) --strip-unneeded
 
 windows:
 	@echo off
@@ -225,7 +225,6 @@ linux:
 
 linux_debug:
 	$(CXX) $(SOURCES) -D DEBUG -D VERBOSE $(CXXFLAGS_DEBUG) $(LDFLAGS) -o "$(TARGET_FILE)_debug"
-	strip -s -R .comment -R .gnu.version "$(TARGET_FILE)_debug" --strip-unneeded
 
 linux_release:
 # Elimina carpetas previas
@@ -248,4 +247,18 @@ linux_release:
 	cd "$(RELEASE_FOLDER)" && tar -czvf "../$(LINUX_RELEASE)" *
 
 # Elimina la carpeta temporal
-	$(RM) "$(RELEASE_FOLDER)"
+	$(RM) "$(RELEASE_FOLDER)"
+
+anbernic:
+# Elimina carpetas previas
+	$(RM) "$(RELEASE_FOLDER)"_anbernic
+
+# Crea la carpeta temporal para realizar el lanzamiento
+	mkdir -p "$(RELEASE_FOLDER)"_anbernic
+
+# Copia ficheros
+	cp -R data "$(RELEASE_FOLDER)"_anbernic
+
+# Complia
+	$(CXX) $(SOURCES) -D ANBERNIC -D NO_SHADERS -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(RELEASE_FOLDER)_anbernic/$(TARGET_NAME)
+	$(CXX) $(SOURCES) -D ANBERNIC -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(RELEASE_FOLDER)_anbernic/$(TARGET_NAME).shaders

data/config/gamecontrollerdb.txt

@@ -1,3 +1,14 @@
+# JailDesigner - Custom mappings
+
+# RAP4
+030086650d0f00008c000000140100003853140,Generic X-Box pad,platform:Linux,a:b0,b:b1,x:b2,y:b3,back:b6,start:b7,guide:b8,leftshoulder:b4,rightshoulder:b5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,
+
+# Mad Catz FightStick Alpha PS4
+03007fcb380700008081000011010000184833152,Mad Catz FightStick Alpha PS4,platform:Linux,a:b1,b:b2,x:b0,y:b3,back:b8,start:b9,guide:b12,leftshoulder:b4,rightshoulder:b5,leftstick:b13,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:b6,righttrigger:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,
+
+# Mando custom de Dani en madera + Agetec 
+030020617900000006000000100100001216,DragonRise Inc. Generic USB Joystick,platform:Linux,a:b2,b:b1,x:b0,y:b6,start:b5,leftx:a0,lefty:a1,
+
 # Game Controller DB for SDL in 2.0.16 format
 # Source: https://github.com/gabomdq/SDL_GameControllerDB
 
@@ -1724,8 +1735,6 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 03000000120c0000100e000011010000,Zeroplus P4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,
 03000000120c0000101e000011010000,Zeroplus P4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,
-030086650d0f00008c000000140100003853140,Generic X-Box pad,platform:Linux,a:b0,b:b1,x:b2,y:b3,back:b6,start:b7,guide:b8,leftshoulder:b4,rightshoulder:b5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,
-03007fcb380700008081000011010000184833152,Mad Catz FightStick Alpha PS4,platform:Linux,a:b1,b:b2,x:b0,y:b3,back:b8,start:b9,guide:b12,leftshoulder:b4,rightshoulder:b5,leftstick:b13,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:b6,righttrigger:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,
 
 # Android
 38653964633230666463343334313533,8BitDo Adapter,a:b0,b:b1,back:b15,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b9,leftstick:b7,lefttrigger:b17,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:b18,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Android,

data/config/param.txt

@@ -1,41 +0,0 @@
-## GAME
-gameWidth  320
-gameHeight 240
-itemSize    20
-autofire  true
-
-## FADE
-numSquaresWidth       160
-numSquaresHeight      120
-fadeRandomSquaresDelay  1
-fadeRandomSquaresMult 500
-fadePostDuration       80
-venetianSize           16
-
-## SCOREBOARD
-scoreboard.x   0
-scoreboard.y 200
-scoreboard.w 320
-scoreboard.h  40
-
-## TITLE
-pressStart    170
-titleCounter  800
-arcadeEdition 123
-titleCC        80
-
-## BACKGROUND
-backgroundAttenuateColor.r 255
-backgroundAttenuateColor.g 255
-backgroundAttenuateColor.b 255
-backgroundAttenuateColor.a   0
-
-## BALLOONS
-balloon1.vel  2.75f
-balloon1.grav 0.09f
-balloon2.vel  3.70f
-balloon2.grav 0.10f
-balloon3.vel  4.70f
-balloon3.grav 0.10f
-balloon4.vel  5.45f
-balloon4.grav 0.10f

data/config/param_320x240.txt

@@ -0,0 +1,53 @@
+## GAME
+game.item_size           20 # Tamaño de los items del juego
+game.width              320 # Ancho de la resolucion nativa del juego
+game.height             240 # Alto de la resolucion nativa del juego
+game.play_area.rect.x     0 # Rectangulo con la posición de la zona de juego
+game.play_area.rect.y     0 # Rectangulo con la posición de la zona de juego
+game.play_area.rect.w   320 # Rectangulo con la posición de la zona de juego
+game.play_area.rect.h   200 # Rectangulo con la posición de la zona de juego
+game.enter_name_seconds  30 # Duración en segundos para introducir el nombre al finalizar la partida
+
+## FADE
+fade.num_squares_width    160
+fade.num_squares_height   120
+fade.random_squares_delay   1
+fade.random_squares_mult  500
+fade.post_duration         80
+fade.venetian_size         16
+
+## SCOREBOARD
+scoreboard.x   0
+scoreboard.y 200
+scoreboard.w 320
+scoreboard.h  40
+
+## TITLE
+title.press_start_position     170
+title.title_duration           800
+title.arcade_edition_position  123
+title.title_c_c_position        80
+
+## BACKGROUND
+background.attenuate_color.r 255
+background.attenuate_color.g 255
+background.attenuate_color.b 255
+background.attenuate_alpha     0
+
+## BALLOONS
+balloon_1.vel  2.75f
+balloon_1.grav 0.09f
+balloon_2.vel  3.70f
+balloon_2.grav 0.10f
+balloon_3.vel  4.70f
+balloon_3.grav 0.10f
+balloon_4.vel  5.45f
+balloon_4.grav 0.10f
+
+## NOTIFICATION
+notification.pos_v     TOP
+notification.pos_h    LEFT
+notification.sound   false
+notification.color.r    48
+notification.color.g    48
+notification.color.b    48

data/config/param_320x256.txt

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

data/gfx/balloon/balloon1.ani

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

data/gfx/balloon/balloon2.ani

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

data/gfx/balloon/balloon3.ani

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

data/gfx/balloon/balloon4.ani

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

data/gfx/balloon/explosion1.ani

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

data/gfx/balloon/explosion2.ani

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

data/gfx/balloon/explosion3.ani

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

data/gfx/balloon/explosion4.ani

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

data/gfx/balloon/powerball.ani

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

data/gfx/item/item_clock.ani

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

data/gfx/item/item_coffee.ani

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

data/gfx/item/item_coffee_machine.ani

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

data/gfx/item/item_points1_disk.ani

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

data/gfx/item/item_points2_gavina.ani

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

data/gfx/item/item_points3_pacmar.ani

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

data/gfx/player/player.ani

@@ -1,5 +1,5 @@
-frameWidth=30
+frame_width=30
-frameHeight=30
+frame_height=30
 
 [animation]
 name=walk

data/gfx/player/player_power.ani

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

data/gfx/title/title_dust.ani

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

data/lang/ba_BA.txt

@@ -278,4 +278,73 @@ DEIXA BUIT PER A
 MODE FORA DE LINEA
 
 ## 93 - MENU OPCIONES
-TAULER DE PUNTS
+TAULER DE PUNTS
+
+## 94 - NOTIFICACIONES
+Torna a polsar per eixir
+
+## 95 - DEFINE BUTTONS
+Disparar cap a l'esquerra
+
+## 96 - DEFINE BUTTONS
+Disparar cap amunt
+
+## 97 - DEFINE BUTTONS
+Disparar cap a la dreta
+
+## 98 - DEFINE BUTTONS
+Start
+
+## 99 - DEFINE BUTTONS
+Servei
+
+## 100 - DEFINE BUTTONS
+Jugador 
+
+## 101 - MARCADOR
+Mode demostracio
+
+## 102 - MARCADOR
+Game Over
+
+## 103 - MARCADOR
+Pulsa START
+
+## 104 - MARCADOR
+per jugar
+
+## 105 - MARCADOR
+Continuar?
+
+## 106 - MARCADOR
+Posa el nom
+
+## 107 - AJUDA
+Intercanviar mandos
+
+## 108 - AJUDA
+Configuracio
+
+## 109 - AJUDA
+Alternar el audio
+
+## 110 - AJUDA
+Filtres
+
+## 111 - AJUDA
+Reiniciar
+
+## 112 - AJUDA
+Pausar
+
+## 113 - AJUDA
+Eixir
+
+## 114 - MARCADOR
+Per favor
+
+## 115 - MARCADOR
+espere
+
+## 116 - NOTIFICACIONES
+Torna a polsar per apagar el sistema

data/lang/en_UK.txt

@@ -278,4 +278,73 @@ LEAVE BLANK FOR
 OFFLINE MODE
 
 ## 93 - MENU OPCIONES
-HISCORE TABLE
+HISCORE TABLE
+
+## 94 - NOTIFICACIONES
+Press again to quit
+
+## 95 - DEFINE BUTTONS
+Fire left
+
+## 96 - DEFINE BUTTONS
+Fire up
+
+## 97 - DEFINE BUTTONS
+Fire right
+
+## 98 - DEFINE BUTTONS
+Start
+
+## 99 - DEFINE BUTTONS
+Service
+
+## 100 - DEFINE BUTTONS
+Player
+
+## 101 - MARCADOR
+Demo mode
+
+## 102 - MARCADOR
+Game Over
+
+## 103 - MARCADOR
+Press START
+
+## 104 - MARCADOR
+to play
+
+## 105 - MARCADOR
+Continue?
+
+## 106 - MARCADOR
+Enter name
+
+## 107 - AJUDA
+Swap Controllers
+
+## 108 - AJUDA
+Configuration
+
+## 109 - AJUDA
+Toggle audio
+
+## 110 - AJUDA
+Shaders
+
+## 111 - AJUDA
+Reset
+
+## 112 - AJUDA
+Pause
+
+## 113 - AJUDA
+Exit
+
+## 114 - MARCADOR
+Please
+
+## 115 - MARCADOR
+wait
+
+## 116 - NOTIFICACIONES
+Press again to shutdown system

data/lang/es_ES.txt

@@ -278,4 +278,73 @@ DEJA EN BLANCO PARA
 MODO SIN CONEXION
 
 ## 93 - MENU OPCIONES
-TABLA DE PUNTUACIONES
+TABLA DE PUNTUACIONES
+
+## 94 - NOTIFICACIONES
+Pulsa otra vez para salir
+
+## 95 - DEFINE BUTTONS
+Disparar a la izquierda
+
+## 96 - DEFINE BUTTONS
+Disparar hacia arriba
+
+## 97 - DEFINE BUTTONS
+Disparar hacia la derecha
+
+## 98 - DEFINE BUTTONS
+Start
+
+## 99 - DEFINE BUTTONS
+Servicio
+
+## 100 - DEFINE BUTTONS
+Jugador 
+
+## 101 - MARCADOR
+Mode demostracion
+
+## 102 - MARCADOR
+Game Over
+
+## 103 - MARCADOR
+Pulsa START
+
+## 104 - MARCADOR
+para jugar
+
+## 105 - MARCADOR
+Continuar?
+
+## 106 - MARCADOR
+Pon tu nombre
+
+## 107 - AJUDA
+Intercambiar mandos
+
+## 108 - AJUDA
+Configuracion
+
+## 109 - AJUDA
+Alternar el audio
+
+## 110 - AJUDA
+Filtros
+
+## 111 - AJUDA
+Reiniciar
+
+## 112 - AJUDA
+Pausar
+
+## 113 - AJUDA
+Salir
+
+## 114 - MARCADOR
+Por favor
+
+## 115 - MARCADOR
+espere
+
+## 94 - NOTIFICACIONES
+Pulsa otra vez para apagar el sistema

data/shaders/crtpi.glsl

@@ -97,7 +97,8 @@ void main()
 #if defined(CURVATURE)
 	screenScale = vec2(1.0, 1.0); //TextureSize / InputSize;
 #endif
-	filterWidth = (768.0 / 240.0) / 3.0;
+	//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;
 }
@@ -146,7 +147,7 @@ float CalcScanLine(float dy)
 
 void main()
 {
-	vec2 TextureSize = vec2(320.0, 240.0);
+	vec2 TextureSize = vec2(320.0, 256.0);
 #if defined(CURVATURE)
 	vec2 texcoord = Distort(TEX0);
 	if (texcoord.x < 0.0)

linux-utils/check-includes.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+SOURCEPATH=../source/
+
+for i in "$SOURCEPATH"/*.cpp
+do
+    include-what-you-use -D DEBUG -D VERBOSE -std=c++20 -Wall "$i"
+    read -p "Presiona cualquier tecla para continuar..."
+    clear
+done

linux-utils/go.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+SECONDS=0
+make linux_debug
+duration=$SECONDS
+echo "$((duration / 60)) minutes and $((duration % 60)) seconds elapsed."

linux-utils/run_valgrind.sh

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

linux-utils/valgrind_exceptions

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

source/animated_sprite.cpp

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

source/animated_sprite.h

@@ -1,51 +1,59 @@
 #pragma once
 
-#include <SDL2/SDL.h>
+#include <SDL2/SDL_rect.h>   // for SDL_Rect
-#include "movingsprite.h"
+#include <SDL2/SDL_stdinc.h> // for Uint8
-#include <fstream>
+#include <memory>            // for shared_ptr
-#include <iostream>
+#include <string>            // for string
-#include <sstream>
+#include <vector>            // for vector
-#include <string>
+#include "moving_sprite.h"   // for MovingSprite
-#include <vector>
+class Texture;
 
-struct animation_t
+struct Animation
 {
     std::string name;             // Nombre de la animacion
     std::vector<SDL_Rect> frames; // Cada uno de los frames que componen la animación
     int speed;                    // Velocidad de la animación
     int loop;                     // Indica a que frame vuelve la animación al terminar. -1 para que no vuelva
     bool completed;               // Indica si ha finalizado la animación
-    int currentFrame;             // Frame actual
+    int current_frame;            // Frame actual
     int counter;                  // Contador para las animaciones
+
+    Animation() : name(std::string()), speed(5), loop(0), completed(false), current_frame(0), counter(0) {}
 };
 
-struct animatedSprite_t
+using Animations = std::vector<std::string>;
-{
-    std::vector<animation_t> animations; // Vector con las diferentes animaciones
-    Texture *texture;                    // Textura con los graficos para el sprite
-};
 
-// Carga la animación desde un fichero
+// Carga las animaciones en un vector(Animations) desde un fichero
-animatedSprite_t loadAnimationFromFile(Texture *texture, std::string filePath, bool verbose = false);
+Animations loadAnimationsFromFile(const std::string &file_path);
 
 class AnimatedSprite : public MovingSprite
 {
-private:
+protected:
     // Variables
-    std::vector<animation_t> animation; // Vector con las diferentes animaciones
+    std::vector<Animation> animations_; // Vector con las diferentes animaciones
-    int currentAnimation;               // Animacion activa
+    int current_animation_;             // Animacion activa
-
-public:
-    // Constructor
-    AnimatedSprite(Texture *texture = nullptr, std::string file = "", std::vector<std::string> *buffer = nullptr);
-    AnimatedSprite(animatedSprite_t *animation);
-
-    // Destructor
-    ~AnimatedSprite();
 
     // Calcula el frame correspondiente a la animación actual
     void animate();
 
+    // Carga la animación desde un fichero
+    std::vector<Animation> loadFromFile(const std::string &file_path);
+
+    // Carga la animación desde un vector
+    bool loadFromVector(const Animations &source);
+
+public:
+    // Constructor
+    AnimatedSprite(std::shared_ptr<Texture> texture, const std::string &file_path);
+    AnimatedSprite(std::shared_ptr<Texture> texture, const Animations &animations);
+    explicit AnimatedSprite(std::shared_ptr<Texture> texture);
+
+    // Destructor
+    virtual ~AnimatedSprite();
+
+    // Actualiza las variables del objeto
+    void update() override;
+
     // Obtiene el número de frames de la animación actual
     int getNumFrames();
 
@@ -53,40 +61,34 @@ public:
     void setCurrentFrame(int num);
 
     // Establece el valor del contador
-    void setAnimationCounter(std::string name, int num);
+    void setAnimationCounter(const std::string &name, int num);
 
     // Establece la velocidad de una animación
-    void setAnimationSpeed(std::string name, int speed);
+    void setAnimationSpeed(const std::string &name, int speed);
     void setAnimationSpeed(int index, int speed);
 
     // Establece el frame al que vuelve la animación al finalizar
-    void setAnimationLoop(std::string name, int loop);
+    void setAnimationLoop(const std::string &name, int loop);
     void setAnimationLoop(int index, int loop);
 
     // Establece el valor de la variable
-    void setAnimationCompleted(std::string name, bool value);
+    void setAnimationCompleted(const std::string &name, bool value);
     void setAnimationCompleted(int index, bool value);
 
     // Comprueba si ha terminado la animación
     bool animationIsCompleted();
 
     // Devuelve el rectangulo de una animación y frame concreto
-    SDL_Rect getAnimationClip(std::string name = "default", Uint8 index = 0);
+    SDL_Rect getAnimationClip(const std::string &name = "default", Uint8 index = 0);
     SDL_Rect getAnimationClip(int indexA = 0, Uint8 indexF = 0);
 
     // Obtiene el indice de la animación a partir del nombre
-    int getIndex(std::string name);
+    int getIndex(const std::string &name);
-
-    // Carga la animación desde un vector
-    bool loadFromVector(std::vector<std::string> *source);
 
     // Establece la animacion actual
-    void setCurrentAnimation(std::string name = "default");
+    void setCurrentAnimation(const std::string &name = "default");
     void setCurrentAnimation(int index = 0);
 
-    // Actualiza las variables del objeto
-    void update();
-
     // OLD - Establece el rectangulo para un frame de una animación
     void setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h);
 

source/asset.cpp

@@ -0,0 +1,196 @@
+#include "asset.h"
+#include "utils.h"
+#include <SDL2/SDL_rwops.h>  // for SDL_RWFromFile, SDL_RWclose, SDL_RWops
+#include <SDL2/SDL_stdinc.h> // for SDL_max
+#include <stddef.h>          // for size_t
+#include <iostream>          // for basic_ostream, operator<<, cout, endl
+
+// [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
+Asset *Asset::asset_ = nullptr;
+
+// [SINGLETON] Crearemos el objeto asset con esta función estática
+void Asset::init(const std::string &executable_path)
+{
+    Asset::asset_ = new Asset(executable_path);
+}
+
+// [SINGLETON] Destruiremos el objeto asset con esta función estática
+void Asset::destroy()
+{
+    delete Asset::asset_;
+}
+
+// [SINGLETON] Con este método obtenemos el objeto asset y podemos trabajar con él
+Asset *Asset::get()
+{
+    return Asset::asset_;
+}
+
+// Constructor
+Asset::Asset(const std::string &executable_path)
+    : executable_path_(executable_path.substr(0, executable_path.find_last_of("\\/")))
+{
+    longest_name_ = 0;
+}
+
+// Añade un elemento a la lista
+void Asset::add(const std::string &file, AssetType type, bool required, bool absolute)
+{
+    AssetItem ai;
+    ai.file = absolute ? file : executable_path_ + file;
+    ai.type = type;
+    ai.required = required;
+    file_list_.push_back(ai);
+
+    const std::string file_name = file.substr(file.find_last_of("\\/") + 1);
+    longest_name_ = SDL_max(longest_name_, file_name.size());
+}
+
+// Devuelve el fichero de un elemento de la lista a partir de una cadena
+std::string Asset::get(const std::string &text) const
+{
+    for (const auto &f : file_list_)
+    {
+        const size_t last_index = f.file.find_last_of("/") + 1;
+        const std::string file = f.file.substr(last_index, std::string::npos);
+
+        if (file == text)
+        {
+            return f.file;
+        }
+    }
+
+    std::cout << "Warning: file " << text.c_str() << " not found" << std::endl;
+    return "";
+}
+
+// Comprueba que existen todos los elementos
+bool Asset::check() const
+{
+    bool success = true;
+
+    std::cout << "\n** CHECKING FILES" << std::endl;
+
+    // std::cout << "Executable path is:  " << executable_path_ << std::endl;
+    // std::cout << "Sample filepath:  " << file_list_.back().file << std::endl;
+
+    // Comprueba la lista de ficheros clasificandolos por tipo
+    for (int type = 0; type < static_cast<int>(AssetType::MAX_ASSET_TYPE); ++type)
+    {
+        // Comprueba si hay ficheros de ese tipo
+        bool any = false;
+
+        for (const auto &f : file_list_)
+        {
+            if (f.required && f.type == static_cast<AssetType>(type))
+            {
+                any = true;
+            }
+        }
+
+        // Si hay ficheros de ese tipo, comprueba si existen
+        if (any)
+        {
+            std::cout << "\n>> " << getTypeName(static_cast<AssetType>(type)).c_str() << " FILES" << std::endl;
+
+            for (const auto &f : file_list_)
+            {
+                if (f.required && f.type == static_cast<AssetType>(type))
+                {
+                    success &= checkFile(f.file);
+                }
+            }
+            if (success)
+                std::cout << "   All files are OK." << std::endl;
+        }
+    }
+
+    // Resultado
+    std::cout << (success ? "\n** CHECKING FILES COMPLETED.\n" : "\n** CHECKING FILES FAILED.\n") << std::endl;
+
+    return success;
+}
+
+// Comprueba que existe un fichero
+bool Asset::checkFile(const std::string &path) const
+{
+    auto success = false;
+
+    // Comprueba si existe el fichero
+    auto file = SDL_RWFromFile(path.c_str(), "rb");
+
+    if (file)
+    {
+        success = true;
+        SDL_RWclose(file);
+    }
+
+    const std::string file_name = path.substr(path.find_last_of("\\/") + 1);
+    if (!success)
+        printWithDots("Checking file : ", file_name, (success ? " [ OK ]" : " [ ERROR ]"));
+
+    return success;
+}
+
+// Devuelve el nombre del tipo de recurso
+std::string Asset::getTypeName(AssetType type) const
+{
+    switch (type)
+    {
+    case AssetType::BITMAP:
+        return "BITMAP";
+        break;
+
+    case AssetType::MUSIC:
+        return "MUSIC";
+        break;
+
+    case AssetType::SOUND:
+        return "SOUND";
+        break;
+
+    case AssetType::FONT:
+        return "FONT";
+        break;
+
+    case AssetType::LANG:
+        return "LANG";
+        break;
+
+    case AssetType::DATA:
+        return "DATA";
+        break;
+
+    case AssetType::ANIMATION:
+        return "ANIMATION";
+        break;
+
+    case AssetType::PALETTE:
+        return "PALETTE";
+        break;
+
+    case AssetType::ITEM:
+        return "ITEM";
+        break;
+
+    default:
+        return "ERROR";
+        break;
+    }
+}
+
+// Devuelve la lista de recursos de un tipo
+std::vector<std::string> Asset::getListByType(AssetType type) const
+{
+    std::vector<std::string> list;
+
+    for (auto f : file_list_)
+    {
+        if (f.type == type)
+        {
+            list.push_back(f.file);
+        }
+    }
+
+    return list;
+}

source/asset.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <string> // for string, basic_string
+#include <vector> // for vector
+
+enum class AssetType : int
+{
+	BITMAP,
+	MUSIC,
+	SOUND,
+	FONT,
+	LANG,
+	DATA,
+	ANIMATION,
+	PALETTE,
+	ITEM,
+	MAX_ASSET_TYPE,
+};
+
+// Clase Asset
+class Asset
+{
+private:
+	// [SINGLETON] Objeto asset privado para Don Melitón
+	static Asset *asset_;
+
+	// Estructura para definir un item
+	struct AssetItem
+	{
+		std::string file;	 // Ruta del fichero desde la raiz del directorio
+		enum AssetType type; // Indica el tipo de recurso
+		bool required;		 // Indica si es un fichero que debe de existir
+							 // bool absolute;		 // Indica si la ruta que se ha proporcionado es una ruta absoluta
+	};
+
+	// Variables
+	int longest_name_;				   // Contiene la longitud del nombre de fichero mas largo
+	std::vector<AssetItem> file_list_; // Listado con todas las rutas a los ficheros
+	std::string executable_path_;	   // Ruta al ejecutable
+
+	// Comprueba que existe un fichero
+	bool checkFile(const std::string &path) const;
+
+	// Devuelve el nombre del tipo de recurso
+	std::string getTypeName(AssetType type) const;
+
+	// Constructor
+	explicit Asset(const std::string &executable_path);
+
+	// Destructor
+	~Asset() = default;
+
+public:
+	// [SINGLETON] Crearemos el objeto screen con esta función estática
+	static void init(const std::string &executable_path);
+
+	// [SINGLETON] Destruiremos el objeto screen con esta función estática
+	static void destroy();
+
+	// [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
+	static Asset *get();
+
+	// Añade un elemento a la lista
+	void add(const std::string &file, AssetType type, bool required = true, bool absolute = false);
+
+	// Devuelve un elemento de la lista a partir de una cadena
+	std::string get(const std::string &text) const;
+
+	// Comprueba que existen todos los elementos
+	bool check() const;
+
+	// Devuelve la lista de recursos de un tipo
+	std::vector<std::string> getListByType(AssetType type) const;
+};

source/background.cpp

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

source/background.h

@@ -1,9 +1,12 @@
 #pragma once
 
-#include <SDL2/SDL.h>
+#include <SDL2/SDL_rect.h>   // for SDL_Rect
-#include "common/screen.h"
+#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
-#include "common/asset.h"
+#include <memory>            // for unique_ptr, shared_ptr
-#include "common/movingsprite.h"
+#include "utils.h"           // for Color
+class MovingSprite;
+class Sprite;
+class Texture;
 
 /*
     Esta clase es la encargada de dibujar el fondo que aparece durante la sección
@@ -14,9 +17,11 @@
 
     El objeto tiene un tamaño total definido en la variable "rect". En principio este
     tamaño coincide con el tamaño de la ventana o resolución del juego, pero se pinta
-    solo el rectangulo definido en srcRect en la posición de la pantalla definida en 
+    solo el rectangulo definido en srcRect en la posición de la pantalla definida en
     dstRect.
 
+    Ambos rectangulos han de coincidir en tamaño y por definición, el punto comun es el inferior derecho el rectangulo.
+
     Utiliza varios métodos para definir su comportamiento:
         - setCloudsSpeed(float value)
           Velocidad a la que se desplazan las nubes cada frame
@@ -27,13 +32,13 @@
         - setTransition(float value)
           Porcentaje (entre 0.0f (textura actual) y 1.0f (textura siguiente)) para mostrar entre la textura de fondo actual y la siguiente
 
-        - setSrcDest(SDL_Rect value)
+        - setSrcRect(SDL_Rect value)
           Rectangulo de la textura de fondo que se desea mostrar
 
-        - setDstDest(SDL_Rect value)
+        - setDstRecr(SDL_Rect value)
-          Rectangulo de destino donde se mostrará el rectángulo antrior
+          Rectangulo de destino donde se mostrará el rectángulo antrior. Automaticamente modifica srcRect para coincidor en tamaño con el destino.
 
-        - setColor(color_t color)
+        - setColor(Color color)
           Establece el color de la textura de superposición
 
         - setAlpha(int alpha)
@@ -44,92 +49,99 @@
 class Background
 {
 private:
-    // Objetos y punteros
+  // Objetos y punteros
-    SDL_Renderer *renderer; // El renderizador de la ventana
+  SDL_Renderer *renderer_; // El renderizador de la ventana
-    Screen *screen;         // Objeto encargado de dibujar en pantalla
-    Asset *asset;           // Objeto que gestiona todos los ficheros de recursos
 
-    Texture *buildingsTexture; // Textura con los edificios de fondo
+  std::shared_ptr<Texture> buildings_texture_;     // Textura con los edificios de fondo
-    Texture *clouds1Texture;   // Textura con las nubes de fondo
+  std::shared_ptr<Texture> top_clouds_texture_;    // Textura con las nubes de fondo
-    Texture *clouds2Texture;   // Textura con las nubes de fondo
+  std::shared_ptr<Texture> bottom_clouds_texture_; // Textura con las nubes de fondo
-    Texture *grassTexture;     // Textura con la hierba del suelo
+  std::shared_ptr<Texture> grass_texture_;         // Textura con la hierba del suelo
-    Texture *gradientsTexture; // Textura con los diferentes colores de fondo del juego
+  std::shared_ptr<Texture> gradients_texture_;     // Textura con los diferentes colores de fondo del juego
 
-    MovingSprite *clouds1A; // Sprite para las nubes superiores
+  std::unique_ptr<MovingSprite> top_clouds_sprite_a_;    // Sprite para las nubes superiores
-    MovingSprite *clouds1B; // Sprite para las nubes superiores
+  std::unique_ptr<MovingSprite> top_clouds_sprite_b_;    // Sprite para las nubes superiores
-    MovingSprite *clouds2A; // Sprite para las nubes inferiores
+  std::unique_ptr<MovingSprite> bottom_clouds_sprite_a_; // Sprite para las nubes inferiores
-    MovingSprite *clouds2B; // Sprite para las nubes inferiores
+  std::unique_ptr<MovingSprite> bottom_clouds_sprite_b_; // Sprite para las nubes inferiores
 
-    Sprite *buildingsSprite; // Sprite con los edificios de fondo
+  std::unique_ptr<Sprite> buildings_sprite_; // Sprite con los edificios de fondo
-    Sprite *gradientSprite;  // Sprite con los graficos del degradado de color de fondo
+  std::unique_ptr<Sprite> gradient_sprite_;  // Sprite con los graficos del degradado de color de fondo
-    Sprite *grassSprite;     // Sprite para la hierba
+  std::unique_ptr<Sprite> grass_sprite_;     // Sprite para la hierba
 
-    SDL_Texture *canvas;       // Textura para componer el fondo
+  SDL_Texture *canvas_;        // Textura para componer el fondo
-    SDL_Texture *colorTexture; // Textura para atenuar el fondo
+  SDL_Texture *color_texture_; // Textura para atenuar el fondo
 
-    param_t *param; // Puntero con todos los parametros del programa
+  // Variables
+  SDL_Rect gradient_rect_[4];      // Vector con las coordenadas de los 4 degradados para el cielo
+  SDL_Rect top_clouds_rect_[4];    // Vector con las coordenadas de los 4 nubes de arriba
+  SDL_Rect bottom_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de abajo
+  int gradient_number_;            // Indica el número de degradado de fondo que se va a dibujar
+  int alpha_;                      // Transparencia entre los dos degradados
+  float clouds_speed_;             // Velocidad a la que se desplazan las nubes
+  float transition_;               // Nivel de transición del fondo 0..1
+  int counter_;                    // Contador interno
+  SDL_Rect rect_;                  // Tamaño del objeto fondo
+  SDL_Rect src_rect_;              // Parte del objeto fondo que se va a dibujará en pantalla
+  SDL_Rect dst_rect_;              // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
+  int base_;                       // Linea de fondo coincidente con el area inferior de la zona de juego
+  Color color_;                    // Color para atenuar el fondo
+  int alpha_color_text_;           // Alpha para atenuar el fondo
+  int alpha_color_text_temp_;      // Valor temporal para hacer la transición de alpha
 
-    // Variables
+  // Dibuja el gradiente de fondo
-    SDL_Rect gradientRect[4]; // Vector con las coordenadas de los 4 degradados para el cielo
+  void renderGradient();
-    int gradientNumber;       // Indica el número de degradado de fondo que se va a dibujar
-    int alpha;                // Transparencia entre los dos degradados
-    float cloudsSpeed;        // Velocidad a la que se desplazan las nubes
-    float transition;         // Nivel de transición del fondo 0..1
-    int counter;              // Contador interno
-    SDL_Rect rect;            // Tamaño del objeto fondo
-    SDL_Rect srcRect;         // Parte del objeto fondo que se va a dibujará en pantalla
-    SDL_Rect dstRect;         // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
-    int base;                 // Linea de fondo coincidente con el area inferior de la zona de juego
-    color_t color;            // Color para atenuar el fondo
-    int alphaColorText;       // Alpha para atenuar el fondo
-    int alphaColorTextTemp;   // Valor temporal para hacer la transición de alpha
 
-    // Compone todos los elementos del fondo en la textura
+  // Dibuja las nubes de arriba
-    void fillCanvas();
+  void renderTopClouds();
 
-    // Actualiza el valor de alpha
+  // Dibuja las nubes de abajo
-    void updateAlphaColorText();
+  void renderBottomClouds();
 
-    // Actualiza las nubes
+  // Compone todos los elementos del fondo en la textura
-    void updateCLouds();
+  void fillCanvas();
+
+  // Actualiza el valor de alpha
+  void updateAlphaColorText();
+
+  // Actualiza las nubes
+  void updateClouds();
 
 public:
-    // Constructor
+  // Constructor
-    Background(SDL_Renderer *renderer, Screen *screen, Asset *asset, param_t *param);
+  Background();
 
-    // Destructor
+  // Destructor
-    ~Background();
+  ~Background();
 
-    // Actualiza la lógica del objeto
+  // Actualiza la lógica del objeto
-    void update();
+  void update();
 
-    // Dibuja el objeto
+  // Dibuja el objeto
-    void render();
+  void render();
 
-    // Establece la posición del objeto
+  // Establece la posición del objeto
-    void setPos(SDL_Rect);
+  void setPos(SDL_Rect pos);
 
-    // Vuelve a cargar las texturas
+  // Vuelve a cargar las texturas
-    void reloadTextures();
+  void reloadTextures();
 
-    // Ajusta el valor de la variable
+  // Ajusta el valor de la variable
-    void setCloudsSpeed(float value);
+  void setCloudsSpeed(float value);
 
-    // Ajusta el valor de la variable
+  // Ajusta el valor de la variable
-    void setGradientNumber(int value);
+  void setGradientNumber(int value);
 
-    // Ajusta el valor de la variable
+  // Ajusta el valor de la variable
-    void setTransition(float value);
+  void setTransition(float value);
 
-    // Ajusta el valor de la variable
+  // Ajusta el valor de la variable
-    void setSrcRect(SDL_Rect value);
+  void setSrcRect(SDL_Rect value);
 
-    // Ajusta el valor de la variable
+  // Ajusta el valor de la variable
-    void setDstRect(SDL_Rect value);
+  void setDstRect(SDL_Rect value);
 
-    // Establece el color de atenuación
+  // Establece el color de atenuación
-    void setColor(color_t color);
+  void setColor(Color color);
 
-    // Establece la transparencia de la atenuación
+  // Establece la transparencia de la atenuación
-    void setAlpha(int alpha);
+  void setAlpha(int alpha);
 };

source/balloon.h

@@ -1,76 +1,78 @@
 #pragma once
 
-#include <SDL2/SDL.h>
+#include <SDL2/SDL_stdinc.h> // for Uint8, Uint16, Uint32
-#include "common/animatedsprite.h"
+#include <memory>			 // for shared_ptr, unique_ptr
-#include "common/utils.h"
+#include <string>			 // for string
-#include <sstream>
+#include <vector>			 // for vector
-#include <vector>
+#include "animated_sprite.h" // for SpriteAnimated
+#include "utils.h"			 // for Circle
+class Texture;
 
 // Cantidad de elementos del vector con los valores de la deformación del globo al rebotar
-#define MAX_BOUNCE 10
+constexpr int MAX_BOUNCE = 10;
 
 // Tipos de globo
-#define BALLOON_1 1
+constexpr int BALLOON_1 = 1;
-#define BALLOON_2 2
+constexpr int BALLOON_2 = 2;
-#define BALLOON_3 3
+constexpr int BALLOON_3 = 3;
-#define BALLOON_4 4
+constexpr int BALLOON_4 = 4;
-#define HEXAGON_1 5
+constexpr int HEXAGON_1 = 5;
-#define HEXAGON_2 6
+constexpr int HEXAGON_2 = 6;
-#define HEXAGON_3 7
+constexpr int HEXAGON_3 = 7;
-#define HEXAGON_4 8
+constexpr int HEXAGON_4 = 8;
-#define POWER_BALL 9
+constexpr int POWER_BALL = 9;
 
 // Puntos de globo
-#define BALLOON_SCORE_1 50
+constexpr int BALLOON_SCORE_1 = 50;
-#define BALLOON_SCORE_2 100
+constexpr int BALLOON_SCORE_2 = 100;
-#define BALLOON_SCORE_3 200
+constexpr int BALLOON_SCORE_3 = 200;
-#define BALLOON_SCORE_4 400
+constexpr int BALLOON_SCORE_4 = 400;
 
 // Tamaños de globo
-#define BALLOON_SIZE_1 1
+constexpr int BALLOON_SIZE_1 = 1;
-#define BALLOON_SIZE_2 2
+constexpr int BALLOON_SIZE_2 = 2;
-#define BALLOON_SIZE_3 3
+constexpr int BALLOON_SIZE_3 = 3;
-#define BALLOON_SIZE_4 4
+constexpr int BALLOON_SIZE_4 = 4;
 
 // Clases de globo
-#define BALLOON_CLASS 0
+constexpr int BALLOON_CLASS = 0;
-#define HEXAGON_CLASS 1
+constexpr int HEXAGON_CLASS = 1;
 
 // Velocidad del globo
-#define BALLOON_VELX_POSITIVE 0.7f
+constexpr float BALLOON_VELX_POSITIVE = 0.7f;
-#define BALLOON_VELX_NEGATIVE -0.7f
+constexpr float BALLOON_VELX_NEGATIVE = -0.7f;
 
 // Indice para las animaciones de los globos
-#define BALLOON_MOVING_ANIMATION 0
+constexpr int BALLOON_MOVING_ANIMATION = 0;
-#define BALLOON_POP_ANIMATION 1
+constexpr int BALLOON_POP_ANIMATION = 1;
-#define BALLOON_BORN_ANIMATION 2
+constexpr int BALLOON_BORN_ANIMATION = 2;
 
 // Cantidad posible de globos
-#define MAX_BALLOONS 100
+constexpr int MAX_BALLOONS = 100;
 
 // Velocidades a las que se mueven los globos
-#define BALLOON_SPEED_1 0.60f
+constexpr float BALLOON_SPEED_1 = 0.60f;
-#define BALLOON_SPEED_2 0.70f
+constexpr float BALLOON_SPEED_2 = 0.70f;
-#define BALLOON_SPEED_3 0.80f
+constexpr float BALLOON_SPEED_3 = 0.80f;
-#define BALLOON_SPEED_4 0.90f
+constexpr float BALLOON_SPEED_4 = 0.90f;
-#define BALLOON_SPEED_5 1.00f
+constexpr float BALLOON_SPEED_5 = 1.00f;
 
 // Tamaño de los globos
-#define BALLOON_WIDTH_1 10
+constexpr int BALLOON_WIDTH_1 = 10;
-#define BALLOON_WIDTH_2 16
+constexpr int BALLOON_WIDTH_2 = 16;
-#define BALLOON_WIDTH_3 26
+constexpr int BALLOON_WIDTH_3 = 26;
-#define BALLOON_WIDTH_4 46
+constexpr int BALLOON_WIDTH_4 = 46;
 
 // PowerBall
-#define POWERBALL_SCREENPOWER_MINIMUM 10
+constexpr int POWERBALL_SCREENPOWER_MINIMUM = 10;
-#define POWERBALL_COUNTER 8
+constexpr int POWERBALL_COUNTER = 8;
 
 // Clase Balloon
 class Balloon
 {
 private:
 	// Estructura para las variables para el efecto de los rebotes
-	struct bouncing
+	struct Bouncing
 	{
 		bool enabled;		  // Si el efecto está activo
 		Uint8 counter;		  // Countador para el efecto
@@ -84,38 +86,37 @@ private:
 	};
 
 	// Objetos y punteros
-	AnimatedSprite *sprite; // Sprite del objeto globo
+	std::unique_ptr<AnimatedSprite> sprite_; // Sprite del objeto globo
-	param_t *param;			// Puntero con todos los parametros del programa
 
 	// Variables
-	float posX;				   // Posición en el eje X
+	float pos_x_;				  // Posición en el eje X
-	float posY;				   // Posición en el eje Y
+	float pos_y_;				  // Posición en el eje Y
-	Uint8 width;			   // Ancho
+	Uint8 width_;				  // Ancho
-	Uint8 height;			   // Alto
+	Uint8 height_;				  // Alto
-	float velX;				   // Velocidad en el eje X. Cantidad de pixeles a desplazarse
+	float vel_x_;				  // Velocidad en el eje X. Cantidad de pixeles a desplazarse
-	float velY;				   // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
+	float vel_y_;				  // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
-	float gravity;			   // Aceleración en el eje Y. Modifica la velocidad
+	float gravity_;				  // Aceleración en el eje Y. Modifica la velocidad
-	float defaultVelY;		   // Velocidad inicial que tienen al rebotar contra el suelo
+	float default_vel_y_;		  // Velocidad inicial que tienen al rebotar contra el suelo
-	float maxVelY;			   // Máxima velocidad que puede alcanzar el objeto en el eje Y
+	float max_vel_y_;			  // Máxima velocidad que puede alcanzar el objeto en el eje Y
-	bool beingCreated;		   // Indica si el globo se está creando
+	bool being_created_;		  // Indica si el globo se está creando
-	bool blinking;			   // Indica si el globo está intermitente
+	bool blinking_;				  // Indica si el globo está intermitente
-	bool enabled;			   // Indica si el globo esta activo
+	bool enabled_;				  // Indica si el globo esta activo
-	bool invulnerable;		   // Indica si el globo es invulnerable
+	bool invulnerable_;			  // Indica si el globo es invulnerable
-	bool stopped;			   // Indica si el globo está parado
+	bool stopped_;				  // Indica si el globo está parado
-	bool visible;			   // Indica si el globo es visible
+	bool visible_;				  // Indica si el globo es visible
-	circle_t collider;		   // Circulo de colisión del objeto
+	Circle collider_;			  // Circulo de colisión del objeto
-	Uint16 creationCounter;	   // Temporizador para controlar el estado "creandose"
+	Uint16 creation_counter_;	  // Temporizador para controlar el estado "creandose"
-	Uint16 creationCounterIni; // Valor inicial para el temporizador para controlar el estado "creandose"
+	Uint16 creation_counter_ini_; // Valor inicial para el temporizador para controlar el estado "creandose"
-	Uint16 score;			   // Puntos que da el globo al ser destruido
+	Uint16 score_;				  // Puntos que da el globo al ser destruido
-	Uint16 stoppedCounter;	   // Contador para controlar el estado "parado"
+	Uint16 stopped_counter_;	  // Contador para controlar el estado "parado"
-	Uint8 kind;				   // Tipo de globo
+	Uint8 kind_;				  // Tipo de globo
-	Uint8 menace;			   // Cantidad de amenaza que genera el globo
+	Uint8 menace_;				  // Cantidad de amenaza que genera el globo
-	Uint32 counter;			   // Contador interno
+	Uint32 counter_;			  // Contador interno
-	float travelY;			   // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
+	float travel_y_;			  // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
-	float speed;			   // Velocidad a la que se mueven los globos
+	float speed_;				  // Velocidad a la que se mueven los globos
-	Uint8 size;				   // Tamaño del globo
+	Uint8 size_;				  // Tamaño del globo
-	Uint8 power;			   // Cantidad de poder que alberga el globo
+	Uint8 power_;				  // Cantidad de poder que alberga el globo
-	bouncing bouncing;		   // Contiene las variables para el efecto de rebote
+	Bouncing bouncing_;			  // Contiene las variables para el efecto de rebote
 
 	// Alinea el circulo de colisión con la posición del objeto globo
 	void updateColliders();
@@ -140,10 +141,10 @@ private:
 
 public:
 	// Constructor
-	Balloon(float x, float y, Uint8 kind, float velx, float speed, Uint16 creationtimer, Texture *texture, std::vector<std::string> *animation, param_t *param);
+	Balloon(float x, float y, Uint8 kind, float vel_x, float speed, Uint16 creation_timer, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
 
 	// Destructor
-	~Balloon();
+	~Balloon() = default;
 
 	// Centra el globo en la posición X
 	void allignTo(int x);
@@ -164,86 +165,86 @@ public:
 	void update();
 
 	// Comprueba si el globo está habilitado
-	bool isEnabled();
+	bool isEnabled() const;
 
 	// Obtiene del valor de la variable
-	float getPosX();
+	float getPosX() const;
 
 	// Obtiene del valor de la variable
-	float getPosY();
+	float getPosY() const;
 
 	// Obtiene del valor de la variable
-	float getVelY();
+	float getVelY() const;
 
 	// Obtiene del valor de la variable
-	int getWidth();
+	int getWidth() const;
 
 	// Obtiene del valor de la variable
-	int getHeight();
+	int getHeight() const;
 
 	// Establece el valor de la variable
-	void setVelY(float velY);
+	void setVelY(float vel_y);
 
 	// Establece el valor de la variable
 	void setSpeed(float speed);
 
 	// Obtiene del valor de la variable
-	int getKind();
+	int getKind() const;
 
 	// Obtiene del valor de la variable
-	Uint8 getSize();
+	Uint8 getSize() const;
 
 	// Obtiene la clase a la que pertenece el globo
-	Uint8 getClass();
+	Uint8 getClass() const;
 
 	// Establece el valor de la variable
 	void setStop(bool value);
 
 	// Obtiene del valor de la variable
-	bool isStopped();
+	bool isStopped() const;
 
 	// Establece el valor de la variable
 	void setBlink(bool value);
 
 	// Obtiene del valor de la variable
-	bool isBlinking();
+	bool isBlinking() const;
 
 	// Establece el valor de la variable
 	void setVisible(bool value);
 
 	// Obtiene del valor de la variable
-	bool isVisible();
+	bool isVisible() const;
 
 	// Establece el valor de la variable
 	void setInvulnerable(bool value);
 
 	// Obtiene del valor de la variable
-	bool isInvulnerable();
+	bool isInvulnerable() const;
 
 	// Obtiene del valor de la variable
-	bool isBeingCreated();
+	bool isBeingCreated() const;
 
 	// Establece el valor de la variable
 	void setStoppedTimer(Uint16 time);
 
 	// Obtiene del valor de la variable
-	Uint16 getStoppedTimer();
+	Uint16 getStoppedTimer() const;
 
 	// Obtiene del valor de la variable
-	Uint16 getScore();
+	Uint16 getScore() const;
 
 	// Obtiene el circulo de colisión
-	circle_t &getCollider();
+	Circle &getCollider();
 
 	// Obtiene le valor de la variable
-	Uint8 getMenace();
+	Uint8 getMenace() const;
 
 	// Obtiene le valor de la variable
-	Uint8 getPower();
+	Uint8 getPower() const;
 
 	// Indica si el globo se puede explotar
-	bool canBePopped();
+	bool canBePopped() const;
 
 	// Indica si el globo se puede destruir
-	bool canBeDestroyed();
+	bool canBeDestroyed() const;
 };

source/balloon_formations.cpp

@@ -0,0 +1,714 @@
+#include "balloon_formations.h"
+#include "balloon.h" // for BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
+#include "param.h"	 // for param
+#include "utils.h"	 // for ParamGame, Param, Zone, BLOCK
+
+// Constructor
+BalloonFormations::BalloonFormations()
+{
+	initBalloonFormations();
+	initBalloonFormationPools();
+	initGameStages();
+}
+
+// Inicializa las formaciones enemigas
+void BalloonFormations::initBalloonFormations()
+{
+	constexpr int y4 = -BLOCK;
+	const int x4_0 = param.game.play_area.rect.x;
+	const int x4_100 = param.game.play_area.rect.w - BALLOON_WIDTH_4;
+
+	constexpr int y3 = -BLOCK;
+	const int x3_0 = param.game.play_area.rect.x;
+	const int x3_100 = param.game.play_area.rect.w - BALLOON_WIDTH_3;
+
+	constexpr int y2 = -BLOCK;
+	const int x2_0 = param.game.play_area.rect.x;
+	const int x2_100 = param.game.play_area.rect.w - BALLOON_WIDTH_2;
+
+	constexpr int y1 = -BLOCK;
+	const int x1_0 = param.game.play_area.rect.x;
+	const int x1_50 = param.game.play_area.center_x - (BALLOON_WIDTH_1 / 2);
+	const int x1_100 = param.game.play_area.rect.w - BALLOON_WIDTH_1;
+
+	// Inicializa a cero las variables
+	for (int i = 0; i < NUMBER_OF_BALLOON_FORMATIONS; i++)
+	{
+		balloon_formation_[i].number_of_balloons = 0;
+		for (int j = 0; j < MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION; j++)
+		{
+			balloon_formation_[i].init[j] = BalloonFormationParams();
+		}
+	}
+
+	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].kind = BALLOON_4;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME + (inc_time * i);
+	}
+
+	// #01 - Dos enemigos BALLOON4 uno a cada cuarto. Ambos van hacia el centro
+	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_WIDTH_4 / 2) + (i * inc_x);
+		balloon_formation_[j].init[i].y = y4;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
+		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME + (inc_time * i);
+	}
+
+	// #02 - Cuatro enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
+	j = 2;
+	balloon_formation_[j].number_of_balloons = 4;
+	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x2_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y2;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_2;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #03 - Cuatro enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
+	j = 3;
+	balloon_formation_[j].number_of_balloons = 4;
+	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x2_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y2;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_2;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #04 - Tres enemigos BALLOON3. 0, 25, 50. Hacia la derecha
+	j = 4;
+	balloon_formation_[j].number_of_balloons = 3;
+	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #05 - Tres enemigos BALLOON3. 50, 75, 100. Hacia la izquierda
+	j = 5;
+	balloon_formation_[j].number_of_balloons = 3;
+	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #06 - Tres enemigos BALLOON3. 0, 0, 0. Hacia la derecha
+	j = 6;
+	balloon_formation_[j].number_of_balloons = 3;
+	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #07 - Tres enemigos BALLOON3. 100, 100, 100. Hacia la izquierda
+	j = 7;
+	balloon_formation_[j].number_of_balloons = 3;
+	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #08 - Seis enemigos BALLOON1. 0, 0, 0, 0, 0, 0. Hacia la derecha
+	j = 8;
+	balloon_formation_[j].number_of_balloons = 6;
+	inc_x = BALLOON_WIDTH_1 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x1_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y1;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #09 - Seis enemigos BALLOON1. 100, 100, 100, 100, 100, 100. Hacia la izquierda
+	j = 9;
+	balloon_formation_[j].number_of_balloons = 6;
+	inc_x = BALLOON_WIDTH_1 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x1_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y1;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #10 - Tres enemigos BALLOON4 seguidos desde la izquierda
+	j = 10;
+	balloon_formation_[j].number_of_balloons = 3;
+	inc_x = BALLOON_WIDTH_4 + 1;
+	inc_time = 15;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x4_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y4;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #11 - Tres enemigos BALLOON4 seguidos desde la derecha
+	j = 11;
+	balloon_formation_[j].number_of_balloons = 3;
+	inc_x = BALLOON_WIDTH_4 + 1;
+	inc_time = 15;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x4_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y4;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #12 - Seis enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
+	j = 12;
+	balloon_formation_[j].number_of_balloons = 6;
+	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x2_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y2;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_2;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #13 - Seis enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
+	j = 13;
+	balloon_formation_[j].number_of_balloons = 6;
+	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x2_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y2;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_2;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #14 - Cinco enemigos BALLOON3. Hacia la derecha. Separados
+	j = 14;
+	balloon_formation_[j].number_of_balloons = 5;
+	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #15 - Cinco enemigos BALLOON3. Hacia la izquierda. Separados
+	j = 15;
+	balloon_formation_[j].number_of_balloons = 5;
+	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #16 - Cinco enemigos BALLOON3. Hacia la derecha. Juntos
+	j = 16;
+	balloon_formation_[j].number_of_balloons = 5;
+	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #17 - Cinco enemigos BALLOON3. Hacia la izquierda. Juntos
+	j = 17;
+	balloon_formation_[j].number_of_balloons = 5;
+	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #18 - Doce enemigos BALLOON1. Hacia la derecha. Juntos
+	j = 18;
+	balloon_formation_[j].number_of_balloons = 12;
+	inc_x = BALLOON_WIDTH_1 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x1_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y1;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #19 - Doce enemigos BALLOON1. Hacia la izquierda. Juntos
+	j = 19;
+	balloon_formation_[j].number_of_balloons = 12;
+	inc_x = BALLOON_WIDTH_1 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x1_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y1;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME - (inc_time * i);
+	}
+
+	// #20 - Dos enemigos BALLOON4 seguidos desde la izquierda/derecha. Simetricos
+	j = 20;
+	balloon_formation_[j].number_of_balloons = 4;
+	inc_x = BALLOON_WIDTH_4 + 1;
+	inc_time = 0;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; 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;
+		}
+		else
+		{
+			balloon_formation_[j].init[i].x = x4_100 - ((i - half) * inc_x);
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		}
+		balloon_formation_[j].init[i].y = y4;
+		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].creation_counter = CREATION_TIME + (inc_time * i);
+	}
+
+	// #21 - Diez enemigos BALLOON2 uno detras del otro. Izquierda/derecha. Simetricos
+	j = 21;
+	balloon_formation_[j].number_of_balloons = 10;
+	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_time = 3;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; 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);
+		}
+		else
+		{
+			balloon_formation_[j].init[i].x = x2_100 - ((i - half) * inc_x);
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) - (inc_time * (i - half));
+		}
+		balloon_formation_[j].init[i].y = y2;
+		balloon_formation_[j].init[i].kind = BALLOON_2;
+	}
+
+	// #22 - Diez enemigos BALLOON3. Hacia la derecha/izquierda. Separados. Simetricos
+	j = 22;
+	balloon_formation_[j].number_of_balloons = 10;
+	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; 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);
+		}
+		else
+		{
+			balloon_formation_[j].init[i].x = x3_100 - ((i - half) * inc_x);
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) - (inc_time * (i - half));
+		}
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+	}
+
+	// #23 - Diez enemigos BALLOON3. Hacia la derecha. Juntos. Simetricos
+	j = 23;
+	balloon_formation_[j].number_of_balloons = 10;
+	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; 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);
+		}
+		else
+		{
+			balloon_formation_[j].init[i].x = x3_100 - ((i - half) * inc_x);
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) - (inc_time * (i - half));
+		}
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+	}
+
+	// #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++)
+	{
+		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);
+		}
+		else
+		{
+			balloon_formation_[j].init[i].x = x1_50;
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) + (inc_time * (i - half));
+		}
+		balloon_formation_[j].init[i].y = y1;
+		balloon_formation_[j].init[i].kind = BALLOON_1;
+	}
+
+	// #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++)
+	{
+		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);
+		}
+		else
+		{
+			balloon_formation_[j].init[i].x = x1_50 - 20;
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+			balloon_formation_[j].init[i].creation_counter = (CREATION_TIME) - (inc_time * (i - half));
+		}
+		balloon_formation_[j].init[i].y = y1;
+		balloon_formation_[j].init[i].kind = BALLOON_1;
+	}
+
+	// Crea las mismas formaciones pero con hexagonos a partir de la posición 50 del vector
+	for (int k = 0; k < j + 1; k++)
+	{
+		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++)
+		{
+			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].kind = balloon_formation_[k].init[i].kind + 4;
+		}
+	}
+
+	// TEST
+	balloon_formation_[99].number_of_balloons = 4;
+
+	balloon_formation_[99].init[0].x = 10;
+	balloon_formation_[99].init[0].y = y1;
+	balloon_formation_[99].init[0].vel_x = 0;
+	balloon_formation_[99].init[0].kind = BALLOON_1;
+	balloon_formation_[99].init[0].creation_counter = 200;
+
+	balloon_formation_[99].init[1].x = 50;
+	balloon_formation_[99].init[1].y = y1;
+	balloon_formation_[99].init[1].vel_x = 0;
+	balloon_formation_[99].init[1].kind = BALLOON_2;
+	balloon_formation_[99].init[1].creation_counter = 200;
+
+	balloon_formation_[99].init[2].x = 90;
+	balloon_formation_[99].init[2].y = y1;
+	balloon_formation_[99].init[2].vel_x = 0;
+	balloon_formation_[99].init[2].kind = BALLOON_3;
+	balloon_formation_[99].init[2].creation_counter = 200;
+
+	balloon_formation_[99].init[3].x = 140;
+	balloon_formation_[99].init[3].y = y1;
+	balloon_formation_[99].init[3].vel_x = 0;
+	balloon_formation_[99].init[3].kind = BALLOON_4;
+	balloon_formation_[99].init[3].creation_counter = 200;
+}
+
+// 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];
+
+	// 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];
+
+	// 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];
+
+	// 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];
+
+	// 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];
+
+	// 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];
+
+	// 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];
+
+	// 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];
+
+	// 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];
+
+	// 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];
+}