Pasaeta de include-what-you-use

Arreglades les herencies de les classes Sprite

.gitignore

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

Makefile

@@ -24,18 +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
-	CXXFLAGS:= -std=c++11 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows
-	CXXFLAGS_DEBUG:= -std=c++11 -Wall
+	SOURCES := source/*.cpp
+	CXXFLAGS:= -std=c++20 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows
+	CXXFLAGS_DEBUG:= -std=c++20 -Wall -g
 	LDFLAGS := -lmingw32 -lws2_32 -lSDL2main -lSDL2 -lopengl32
 	RM = del /Q
 	MKD:= mkdir
 else
     FixPath = $1
 	SOURCES := $(shell find $(DIR_SOURCES) -name '*.cpp')
-	SOURCES := source/*.cpp source/common/*.cpp
-	CXXFLAGS:= -std=c++11 -Wall -Os -ffunction-sections -fdata-sections
-	CXXFLAGS_DEBUG:= -std=c++11 -Wall
+	SOURCES := source/*.cpp
+	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
@@ -121,14 +121,13 @@ print-variables:
 
 	@echo RM: $(RM)
 
-raspi3:
-	$(CXX) $(SOURCES) -D NO_SHADERS -D ARCADE -D VERBOSE $(CXXFLAGS) -o $(TARGET_FILE)
-	strip -s -R .comment -R .gnu.version $(TARGET_FILE) --strip-unneeded
-
-raspi5:
+raspi:
 	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(TARGET_FILE)
 	strip -s -R .comment -R .gnu.version $(TARGET_FILE) --strip-unneeded
 
+raspi_debug:
+	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE -D DEBUG $(CXXFLAGS_DEBUG) $(LDFLAGS) -o "$(TARGET_FILE)_debug"
+
 windows:
 	@echo off
 	$(CXX) $(SOURCES) $(CXXFLAGS) $(LDFLAGS) -o "$(TARGET_FILE).exe"
@@ -226,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
@@ -249,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/param.txt

@@ -1,44 +0,0 @@
-## GAME
-game.itemSize           20
-game.width             320
-game.height            256
-game.playArea.rect.x     0
-game.playArea.rect.y     0
-game.playArea.rect.w   320
-game.playArea.rect.h   216
-
-## FADE
-fade.numSquaresWidth    160
-fade.numSquaresHeight   128
-fade.randomSquaresDelay   1
-fade.randomSquaresMult  500
-fade.postDuration        80
-fade.venetianSize        16
-
-## SCOREBOARD
-scoreboard.x   0
-scoreboard.y 216
-scoreboard.w 320
-scoreboard.h  40
-
-## TITLE
-title.pressStartPosition    170
-title.titleDuration         800
-title.arcadeEditionPosition 123
-title.titleCCPosition        80
-
-## BACKGROUND
-background.attenuateColor.r 255
-background.attenuateColor.g 255
-background.attenuateColor.b 255
-background.attenuateAlpha     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,52 @@
+## GAME
+game.item_size           20
+game.width              320
+game.height             240
+game.play_area.rect.x     0
+game.play_area.rect.y     0
+game.play_area.rect.w   320
+game.play_area.rect.h   200
+
+## 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,52 @@
+## GAME
+game.item_size          20
+game.width             320
+game.height            256
+game.play_area.rect.x    0
+game.play_area.rect.y    0
+game.play_area.rect.w  320
+game.play_area.rect.h  216
+
+## 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
-frameHeight=10
+frame_width=10
+frame_height=10
 
 [animation]
 name=orange

data/gfx/balloon/balloon2.ani

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

data/gfx/balloon/balloon3.ani

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

data/gfx/balloon/balloon4.ani

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

data/gfx/balloon/explosion1.ani

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

data/gfx/balloon/explosion2.ani

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

data/gfx/balloon/explosion3.ani

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

data/gfx/balloon/explosion4.ani

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

data/gfx/balloon/powerball.ani

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

data/gfx/item/item_clock.ani

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

data/gfx/item/item_coffee.ani

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

data/gfx/item/item_coffee_machine.ani

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

data/gfx/item/item_points1_disk.ani

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

data/gfx/item/item_points2_gavina.ani

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

data/gfx/item/item_points3_pacmar.ani

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

data/gfx/player/player.ani

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

data/gfx/player/player_power.ani

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

data/gfx/title/title_dust.ani

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

data/lang/ba_BA.txt

@@ -278,4 +278,70 @@ 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

data/lang/en_UK.txt

@@ -278,4 +278,70 @@ 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

data/lang/es_ES.txt

@@ -278,4 +278,70 @@ 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

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

@@ -1,37 +1,48 @@
-#include "animatedsprite.h"
+#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
 
 // Carga la animación desde un fichero
-animatedSprite_t loadAnimationFromFile(Texture *texture, std::string filePath, bool verbose)
+AnimatedFile loadAnimationFromFile(std::shared_ptr<Texture> texture, std::string file_path)
 {
 	// Inicializa variables
-	animatedSprite_t as;
-	as.texture = texture;
-	int framesPerRow = 0;
-	int frameWidth = 0;
-	int frameHeight = 0;
-	int maxTiles = 0;
+	AnimatedFile af;
+	af.texture = texture;
+	auto frames_per_row = 0;
+	auto frame_width = 0;
+	auto frame_height = 0;
+	auto max_tiles = 0;
 
-	const std::string filename = filePath.substr(filePath.find_last_of("\\/") + 1);
-	std::ifstream file(filePath);
+#ifdef VERBOSE
+	const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
+#endif
+	std::ifstream file(file_path);
 	std::string line;
 
 	// El fichero se puede abrir
 	if (file.good())
 	{
 		// Procesa el fichero linea a linea
-		if (verbose)
-		{
-			std::cout << "Animation loaded: " << filename << std::endl;
-		}
+#ifdef VERBOSE
+		std::cout << "Animation loaded: " << file_name << std::endl;
+#endif
 		while (std::getline(file, line))
 		{
 			// Si la linea contiene el texto [animation] se realiza el proceso de carga de una animación
 			if (line == "[animation]")
 			{
-				animation_t buffer;
+				Animation buffer;
 				buffer.counter = 0;
-				buffer.currentFrame = 0;
+				buffer.current_frame = 0;
 				buffer.completed = false;
+				buffer.name.clear();
+				buffer.speed = 5;
+				buffer.loop = 0;
+				buffer.frames.clear();
 
 				do
 				{
@@ -41,7 +52,7 @@ animatedSprite_t loadAnimationFromFile(Texture *texture, std::string filePath, b
 					int pos = line.find("=");
 
 					// Procesa las dos subcadenas
-					if (pos != (int)line.npos)
+					if (pos != static_cast<int>(line.npos))
 					{
 						if (line.substr(0, pos) == "name")
 						{
@@ -63,26 +74,28 @@ animatedSprite_t loadAnimationFromFile(Texture *texture, std::string filePath, b
 							// Se introducen los valores separados por comas en un vector
 							std::stringstream ss(line.substr(pos + 1, line.length()));
 							std::string tmp;
-							SDL_Rect rect = {0, 0, frameWidth, frameHeight};
+							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 numTile = std::stoi(tmp) > maxTiles ? 0 : std::stoi(tmp);
-								rect.x = (numTile % framesPerRow) * frameWidth;
-								rect.y = (numTile / framesPerRow) * frameHeight;
+								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;
 								buffer.frames.push_back(rect);
 							}
 						}
 
 						else
 						{
-							std::cout << "Warning: file " << filename.c_str() << "\n, unknown parameter \"" << line.substr(0, pos).c_str() << "\"" << std::endl;
+#ifdef VERBOSE
+							std::cout << "Warning: file " << file_name.c_str() << "\n, unknown parameter \"" << line.substr(0, pos).c_str() << "\"" << std::endl;
+#endif
 						}
 					}
 				} while (line != "[/animation]");
 
 				// Añade la animación al vector de animaciones
-				as.animations.push_back(buffer);
+				af.animations.push_back(buffer);
 			}
 
 			// En caso contrario se parsea el fichero para buscar las variables y los valores
@@ -94,37 +107,39 @@ animatedSprite_t loadAnimationFromFile(Texture *texture, std::string filePath, b
 				// Procesa las dos subcadenas
 				if (pos != (int)line.npos)
 				{
-					if (line.substr(0, pos) == "framesPerRow")
+					if (line.substr(0, pos) == "frames_per_row")
 					{
-						framesPerRow = std::stoi(line.substr(pos + 1, line.length()));
+						frames_per_row = std::stoi(line.substr(pos + 1, line.length()));
 					}
 
-					else if (line.substr(0, pos) == "frameWidth")
+					else if (line.substr(0, pos) == "frame_width")
 					{
-						frameWidth = std::stoi(line.substr(pos + 1, line.length()));
+						frame_width = std::stoi(line.substr(pos + 1, line.length()));
 					}
 
-					else if (line.substr(0, pos) == "frameHeight")
+					else if (line.substr(0, pos) == "frame_height")
 					{
-						frameHeight = std::stoi(line.substr(pos + 1, line.length()));
+						frame_height = std::stoi(line.substr(pos + 1, line.length()));
 					}
 
 					else
 					{
-						std::cout << "Warning: file " << filename.c_str() << "\n, unknown parameter \"" << line.substr(0, pos).c_str() << "\"" << std::endl;
+#ifdef VERBOSE
+						std::cout << "Warning: file " << file_name.c_str() << "\n, unknown parameter \"" << line.substr(0, pos).c_str() << "\"" << std::endl;
+#endif
 					}
 
 					// Normaliza valores
-					if (framesPerRow == 0 && frameWidth > 0)
+					if (frames_per_row == 0 && frame_width > 0)
 					{
-						framesPerRow = texture->getWidth() / frameWidth;
+						frames_per_row = texture->getWidth() / frame_width;
 					}
 
-					if (maxTiles == 0 && frameWidth > 0 && frameHeight > 0)
+					if (max_tiles == 0 && frame_width > 0 && frame_height > 0)
 					{
-						const int w = texture->getWidth() / frameWidth;
-						const int h = texture->getHeight() / frameHeight;
-						maxTiles = w * h;
+						const auto w = texture->getWidth() / frame_width;
+						const auto h = texture->getHeight() / frame_height;
+						max_tiles = w * h;
 					}
 				}
 			}
@@ -136,74 +151,55 @@ animatedSprite_t loadAnimationFromFile(Texture *texture, std::string filePath, b
 	// El fichero no se puede abrir
 	else
 	{
-		if (verbose)
-		{
-			std::cout << "Warning: Unable to open " << filename.c_str() << " file" << std::endl;
-		}
+#ifdef VERBOSE
+		std::cout << "Warning: Unable to open " << file_name.c_str() << " file" << std::endl;
+#endif
 	}
 
-	return as;
+	return af;
 }
 
 // Constructor
-AnimatedSprite::AnimatedSprite(Texture *texture, std::string file, std::vector<std::string> *buffer)
+AnimatedSprite::AnimatedSprite(std::shared_ptr<Texture> texture, const std::string &file, std::vector<std::string> *buffer)
+	: MovingSprite(texture),
+	  current_animation_(0)
 {
-	// Copia los punteros
-	setTexture(texture);
-
 	// Carga las animaciones
-	if (file != "")
+	if (!file.empty())
 	{
-		animatedSprite_t as = loadAnimationFromFile(texture, file);
+		AnimatedFile as = loadAnimationFromFile(texture, file);
 
 		// Copia los datos de las animaciones
-		for (auto animation : as.animations)
-		{
-			this->animation.push_back(animation);
-		}
+		std::copy(as.animations.begin(), as.animations.end(), std::back_inserter(animations_));
 	}
 
 	else if (buffer)
 	{
 		loadFromVector(buffer);
 	}
-
-	// Inicializa variables
-	currentAnimation = 0;
 }
 
 // Constructor
-AnimatedSprite::AnimatedSprite(animatedSprite_t *animation)
+AnimatedSprite::AnimatedSprite(const AnimatedFile *animation)
+	: MovingSprite(animation->texture),
+	  current_animation_(0)
 {
-	// Copia los punteros
-	setTexture(animation->texture);
-
-	// Inicializa variables
-	currentAnimation = 0;
-
 	// Copia los datos de las animaciones
-	for (auto a : animation->animations)
-	{
-		this->animation.push_back(a);
-	}
+	std::copy(animation->animations.begin(), animation->animations.end(), std::back_inserter(animations_));
 }
 
 // Destructor
 AnimatedSprite::~AnimatedSprite()
 {
-	for (auto &a : animation)
-	{
-		a.frames.clear();
-	}
-	animation.clear();
+	animations_.clear();
 }
 
 // Obtiene el indice de la animación a partir del nombre
-int AnimatedSprite::getIndex(std::string name)
+int AnimatedSprite::getIndex(const std::string &name)
 {
-	int index = -1;
+	auto index = -1;
 
-	for (auto a : animation)
+	for (const auto &a : animations_)
 	{
 		index++;
 		if (a.name == name)
@@ -211,147 +207,147 @@ int AnimatedSprite::getIndex(std::string name)
 			return index;
 		}
 	}
-
+#ifdef VERBOSE
 	std::cout << "** Warning: could not find \"" << name.c_str() << "\" animation" << std::endl;
-
+#endif
 	return -1;
 }
 
 // Calcula el frame correspondiente a la animación
 void AnimatedSprite::animate()
 {
-	if (!enabled || animation[currentAnimation].speed == 0)
+	if (animations_[current_animation_].speed == 0)
 	{
 		return;
 	}
 
 	// Calcula el frame actual a partir del contador
-	animation[currentAnimation].currentFrame = animation[currentAnimation].counter / animation[currentAnimation].speed;
+	animations_[current_animation_].current_frame = animations_[current_animation_].counter / animations_[current_animation_].speed;
 
 	// Si alcanza el final de la animación, reinicia el contador de la animación
 	// en función de la variable loop y coloca el nuevo frame
-	if (animation[currentAnimation].currentFrame >= (int)animation[currentAnimation].frames.size())
+	if (animations_[current_animation_].current_frame >= (int)animations_[current_animation_].frames.size())
 	{
-		if (animation[currentAnimation].loop == -1)
+		if (animations_[current_animation_].loop == -1)
 		{ // Si no hay loop, deja el último frame
-			animation[currentAnimation].currentFrame = animation[currentAnimation].frames.size();
-			animation[currentAnimation].completed = true;
+			animations_[current_animation_].current_frame = animations_[current_animation_].frames.size();
+			animations_[current_animation_].completed = true;
 		}
 		else
 		{ // Si hay loop, vuelve al frame indicado
-			animation[currentAnimation].counter = 0;
-			animation[currentAnimation].currentFrame = animation[currentAnimation].loop;
+			animations_[current_animation_].counter = 0;
+			animations_[current_animation_].current_frame = animations_[current_animation_].loop;
 		}
 	}
 	// En caso contrario
 	else
 	{
 		// Escoge el frame correspondiente de la animación
-		setSpriteClip(animation[currentAnimation].frames[animation[currentAnimation].currentFrame]);
+		setSpriteClip(animations_[current_animation_].frames[animations_[current_animation_].current_frame]);
 
 		// Incrementa el contador de la animacion
-		animation[currentAnimation].counter++;
+		animations_[current_animation_].counter++;
 	}
 }
 
 // Obtiene el número de frames de la animación actual
 int AnimatedSprite::getNumFrames()
 {
-	return (int)animation[currentAnimation].frames.size();
+	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)animation[currentAnimation].frames.size())
+	if (num >= (int)animations_[current_animation_].frames.size())
 	{
 		num = 0;
 	}
 
 	// Cambia el valor de la variable
-	animation[currentAnimation].currentFrame = num;
-	animation[currentAnimation].counter = 0;
+	animations_[current_animation_].current_frame = num;
+	animations_[current_animation_].counter = 0;
 
 	// Escoge el frame correspondiente de la animación
-	setSpriteClip(animation[currentAnimation].frames[animation[currentAnimation].currentFrame]);
+	setSpriteClip(animations_[current_animation_].frames[animations_[current_animation_].current_frame]);
 }
 
 // Establece el valor del contador
-void AnimatedSprite::setAnimationCounter(std::string name, int num)
+void AnimatedSprite::setAnimationCounter(const std::string &name, int num)
 {
-	animation[getIndex(name)].counter = num;
+	animations_[getIndex(name)].counter = num;
 }
 
 // Establece la velocidad de una animación
-void AnimatedSprite::setAnimationSpeed(std::string name, int speed)
+void AnimatedSprite::setAnimationSpeed(const std::string &name, int speed)
 {
-	animation[getIndex(name)].counter = speed;
+	animations_[getIndex(name)].counter = speed;
 }
 
 // Establece la velocidad de una animación
 void AnimatedSprite::setAnimationSpeed(int index, int speed)
 {
-	animation[index].counter = speed;
+	animations_[index].counter = speed;
 }
 
 // Establece si la animación se reproduce en bucle
-void AnimatedSprite::setAnimationLoop(std::string name, int loop)
+void AnimatedSprite::setAnimationLoop(const std::string &name, int loop)
 {
-	animation[getIndex(name)].loop = loop;
+	animations_[getIndex(name)].loop = loop;
 }
 
 // Establece si la animación se reproduce en bucle
 void AnimatedSprite::setAnimationLoop(int index, int loop)
 {
-	animation[index].loop = loop;
+	animations_[index].loop = loop;
 }
 
 // Establece el valor de la variable
-void AnimatedSprite::setAnimationCompleted(std::string name, bool value)
+void AnimatedSprite::setAnimationCompleted(const std::string &name, bool value)
 {
-	animation[getIndex(name)].completed = value;
+	animations_[getIndex(name)].completed = value;
 }
 
 // OLD - Establece el valor de la variable
 void AnimatedSprite::setAnimationCompleted(int index, bool value)
 {
-	animation[index].completed = value;
+	animations_[index].completed = value;
 }
 
 // Comprueba si ha terminado la animación
 bool AnimatedSprite::animationIsCompleted()
 {
-	return animation[currentAnimation].completed;
+	return animations_[current_animation_].completed;
 }
 
 // Devuelve el rectangulo de una animación y frame concreto
-SDL_Rect AnimatedSprite::getAnimationClip(std::string name, Uint8 index)
+SDL_Rect AnimatedSprite::getAnimationClip(const std::string &name, Uint8 index)
 {
-	return animation[getIndex(name)].frames[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 animation[indexA].frames[indexF];
+	return animations_[indexA].frames[indexF];
 }
 
 // Carga la animación desde un vector
 bool AnimatedSprite::loadFromVector(std::vector<std::string> *source)
 {
 	// Inicializa variables
-	int framesPerRow = 0;
-	int frameWidth = 0;
-	int frameHeight = 0;
-	int maxTiles = 0;
+	auto frames_per_row = 0;
+	auto frame_width = 0;
+	auto frame_height = 0;
+	auto max_tiles = 0;
 
 	// Indicador de éxito en el proceso
-	bool success = true;
+	auto success = true;
 	std::string line;
 
 	// Recorre todo el vector
-	int index = 0;
+	auto index = 0;
 	while (index < (int)source->size())
 	{
 		// Lee desde el vector
@@ -360,10 +356,14 @@ bool AnimatedSprite::loadFromVector(std::vector<std::string> *source)
 		// Si la linea contiene el texto [animation] se realiza el proceso de carga de una animación
 		if (line == "[animation]")
 		{
-			animation_t buffer;
+			Animation buffer;
 			buffer.counter = 0;
-			buffer.currentFrame = 0;
+			buffer.current_frame = 0;
 			buffer.completed = false;
+			buffer.name.clear();
+			buffer.speed = 5;
+			buffer.loop = 0;
+			buffer.frames.clear();
 
 			do
 			{
@@ -375,7 +375,7 @@ bool AnimatedSprite::loadFromVector(std::vector<std::string> *source)
 				int pos = line.find("=");
 
 				// Procesa las dos subcadenas
-				if (pos != (int)line.npos)
+				if (pos != static_cast<int>(line.npos))
 				{
 					if (line.substr(0, pos) == "name")
 					{
@@ -397,27 +397,29 @@ bool AnimatedSprite::loadFromVector(std::vector<std::string> *source)
 						// Se introducen los valores separados por comas en un vector
 						std::stringstream ss(line.substr(pos + 1, line.length()));
 						std::string tmp;
-						SDL_Rect rect = {0, 0, frameWidth, frameHeight};
+						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 numTile = std::stoi(tmp) > maxTiles ? 0 : std::stoi(tmp);
-							rect.x = (numTile % framesPerRow) * frameWidth;
-							rect.y = (numTile / framesPerRow) * frameHeight;
+							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;
 							buffer.frames.push_back(rect);
 						}
 					}
 
 					else
 					{
+#ifdef VERBOSE
 						std::cout << "Warning: unknown parameter " << line.substr(0, pos).c_str() << std::endl;
+#endif
 						success = false;
 					}
 				}
 			} while (line != "[/animation]");
 
 			// Añade la animación al vector de animaciones
-			animation.push_back(buffer);
+			animations_.push_back(buffer);
 		}
 
 		// En caso contrario se parsea el fichero para buscar las variables y los valores
@@ -429,38 +431,40 @@ bool AnimatedSprite::loadFromVector(std::vector<std::string> *source)
 			// Procesa las dos subcadenas
 			if (pos != (int)line.npos)
 			{
-				if (line.substr(0, pos) == "framesPerRow")
+				if (line.substr(0, pos) == "frames_per_row")
 				{
-					framesPerRow = std::stoi(line.substr(pos + 1, line.length()));
+					frames_per_row = std::stoi(line.substr(pos + 1, line.length()));
 				}
 
-				else if (line.substr(0, pos) == "frameWidth")
+				else if (line.substr(0, pos) == "frame_width")
 				{
-					frameWidth = std::stoi(line.substr(pos + 1, line.length()));
+					frame_width = std::stoi(line.substr(pos + 1, line.length()));
 				}
 
-				else if (line.substr(0, pos) == "frameHeight")
+				else if (line.substr(0, pos) == "frame_height")
 				{
-					frameHeight = std::stoi(line.substr(pos + 1, line.length()));
+					frame_height = std::stoi(line.substr(pos + 1, line.length()));
 				}
 
 				else
 				{
+#ifdef VERBOSE
 					std::cout << "Warning: unknown parameter " << line.substr(0, pos).c_str() << std::endl;
+#endif
 					success = false;
 				}
 
 				// Normaliza valores
-				if (framesPerRow == 0 && frameWidth > 0)
+				if (frames_per_row == 0 && frame_width > 0)
 				{
-					framesPerRow = texture->getWidth() / frameWidth;
+					frames_per_row = texture_->getWidth() / frame_width;
 				}
 
-				if (maxTiles == 0 && frameWidth > 0 && frameHeight > 0)
+				if (max_tiles == 0 && frame_width > 0 && frame_height > 0)
 				{
-					const int w = texture->getWidth() / frameWidth;
-					const int h = texture->getHeight() / frameHeight;
-					maxTiles = w * h;
+					const int w = texture_->getWidth() / frame_width;
+					const int h = texture_->getHeight() / frame_height;
+					max_tiles = w * h;
 				}
 			}
 		}
@@ -470,34 +474,34 @@ bool AnimatedSprite::loadFromVector(std::vector<std::string> *source)
 	}
 
 	// Pone un valor por defecto
-	setRect({0, 0, frameWidth, frameHeight});
+	setPos((SDL_Rect){0, 0, frame_width, frame_height});
 
 	return success;
 }
 
 // Establece la animacion actual
-void AnimatedSprite::setCurrentAnimation(std::string name)
+void AnimatedSprite::setCurrentAnimation(const std::string &name)
 {
-	const int newAnimation = getIndex(name);
-	if (currentAnimation != newAnimation)
+	const auto new_animation = getIndex(name);
+	if (current_animation_ != new_animation)
 	{
-		currentAnimation = newAnimation;
-		animation[currentAnimation].currentFrame = 0;
-		animation[currentAnimation].counter = 0;
-		animation[currentAnimation].completed = false;
+		current_animation_ = new_animation;
+		animations_[current_animation_].current_frame = 0;
+		animations_[current_animation_].counter = 0;
+		animations_[current_animation_].completed = false;
 	}
 }
 
 // Establece la animacion actual
 void AnimatedSprite::setCurrentAnimation(int index)
 {
-	const int newAnimation = index;
-	if (currentAnimation != newAnimation)
+	const auto new_animation = index;
+	if (current_animation_ != new_animation)
 	{
-		currentAnimation = newAnimation;
-		animation[currentAnimation].currentFrame = 0;
-		animation[currentAnimation].counter = 0;
-		animation[currentAnimation].completed = false;
+		current_animation_ = new_animation;
+		animations_[current_animation_].current_frame = 0;
+		animations_[current_animation_].counter = 0;
+		animations_[current_animation_].completed = false;
 	}
 }
 
@@ -511,13 +515,13 @@ void AnimatedSprite::update()
 // Establece el rectangulo para un frame de una animación
 void AnimatedSprite::setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h)
 {
-	animation[index_animation].frames.push_back({x, y, w, h});
+	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 : animation)
+	for (auto &a : animations_)
 	{
 		a.counter = value;
 	}
@@ -526,7 +530,7 @@ void AnimatedSprite::setAnimationCounter(int value)
 // Reinicia la animación
 void AnimatedSprite::resetAnimation()
 {
-	animation[currentAnimation].currentFrame = 0;
-	animation[currentAnimation].counter = 0;
-	animation[currentAnimation].completed = false;
+	animations_[current_animation_].current_frame = 0;
+	animations_[current_animation_].counter = 0;
+	animations_[current_animation_].completed = false;
 }

source/animated_sprite.h

@@ -1,47 +1,47 @@
 #pragma once
 
-#include <SDL2/SDL.h>
-#include "movingsprite.h"
-#include <fstream>
-#include <iostream>
-#include <sstream>
-#include <string>
-#include <vector>
+#include <SDL2/SDL_rect.h>   // for SDL_Rect
+#include <SDL2/SDL_stdinc.h> // for Uint8
+#include <memory>            // for shared_ptr
+#include <string>            // for string
+#include <vector>            // for vector
+#include "moving_sprite.h"   // for MovingSprite
+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
 };
 
-struct animatedSprite_t
+struct AnimatedFile
 {
-    std::vector<animation_t> animations; // Vector con las diferentes animaciones
-    Texture *texture;                    // Textura con los graficos para el sprite
+    std::vector<Animation> animations; // Vector con las diferentes animaciones
+    std::shared_ptr<Texture> texture;  // Textura con los graficos para el sprite
 };
 
 // Carga la animación desde un fichero
-animatedSprite_t loadAnimationFromFile(Texture *texture, std::string filePath, bool verbose = false);
+AnimatedFile loadAnimationFromFile(std::shared_ptr<Texture> texture, std::string filePath);
 
 class AnimatedSprite : public MovingSprite
 {
-private:
+protected:
     // Variables
-    std::vector<animation_t> animation; // Vector con las diferentes animaciones
-    int currentAnimation;               // Animacion activa
+    std::vector<Animation> animations_; // Vector con las diferentes animaciones
+    int current_animation_;             // Animacion activa
 
 public:
     // Constructor
-    AnimatedSprite(Texture *texture = nullptr, std::string file = "", std::vector<std::string> *buffer = nullptr);
-    AnimatedSprite(animatedSprite_t *animation);
+    explicit AnimatedSprite(std::shared_ptr<Texture> texture = nullptr, const std::string &file = std::string(), std::vector<std::string> *buffer = nullptr);
+    explicit AnimatedSprite(const AnimatedFile *animation);
 
     // Destructor
-    ~AnimatedSprite();
+    virtual ~AnimatedSprite();
 
     // Calcula el frame correspondiente a la animación actual
     void animate();
@@ -53,39 +53,39 @@ 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();
+    void update() override;
 
     // 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,207 @@
+#include "asset.h"
+#include <SDL2/SDL_rwops.h>  // for SDL_RWFromFile, SDL_RWclose, SDL_RWops
+#include <SDL2/SDL_stdinc.h> // for SDL_max
+#include <stddef.h>          // for size_t
+#include <iostream>          // for basic_ostream, operator<<, cout, endl
+
+// [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;
+        }
+    }
+
+#ifdef VERBOSE
+    std::cout << "Warning: file " << text.c_str() << " not found" << std::endl;
+#endif
+    return "";
+}
+
+// Comprueba que existen todos los elementos
+bool Asset::check() const
+{
+    bool success = true;
+
+#ifdef VERBOSE
+    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;
+#endif
+
+    // 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)
+        {
+#ifdef VERBOSE
+            std::cout << "\n>> " << getTypeName(static_cast<AssetType>(type)).c_str() << " FILES" << std::endl;
+#endif
+
+            for (const auto &f : file_list_)
+            {
+                if (f.required && f.type == static_cast<AssetType>(type))
+                {
+                    success &= checkFile(f.file);
+                }
+            }
+        }
+    }
+
+// Resultado
+#ifdef VERBOSE
+    std::cout << (success ? "\n** All files OK.\n" : "\n** A file is missing. Exiting.\n") << std::endl;
+#endif
+
+    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);
+    }
+
+#ifdef VERBOSE
+    const std::string file_name = path.substr(path.find_last_of("\\/") + 1);
+    std::cout.setf(std::ios::left, std::ios::adjustfield);
+    std::cout << "Checking file: ";
+    std::cout.width(longest_name_ + 2);
+    std::cout.fill('.');
+    std::cout << file_name;
+    std::cout << (success ? " [OK]" : " [ERROR]") << std::endl;
+#endif
+
+    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,179 +1,170 @@
 #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 "sprite.h"              // for Sprite
+#include "texture.h"             // for Texture
 
 // Constructor
-Background::Background(SDL_Renderer *renderer, Asset *asset, param_t *param)
+Background::Background(SDL_Renderer *renderer)
+    : renderer_(renderer),
+      buildings_texture_(std::make_shared<Texture>(renderer, Asset::get()->get("game_buildings.png"))),
+      top_clouds_texture_(std::make_shared<Texture>(renderer, Asset::get()->get("game_clouds1.png"))),
+      bottom_clouds_texture_(std::make_shared<Texture>(renderer, Asset::get()->get("game_clouds2.png"))),
+      grass_texture_(std::make_shared<Texture>(renderer, Asset::get()->get("game_grass.png"))),
+      gradients_texture_(std::make_shared<Texture>(renderer, Asset::get()->get("game_sky_colors.png")))
+
 {
-    // Copia los punteros
-    this->renderer = renderer;
-    this->asset = asset;
-    this->param = param;
-
-    // Carga las texturas
-    buildingsTexture = new Texture(renderer, asset->get("game_buildings.png"));
-    topCloudsTexture = new Texture(renderer, asset->get("game_clouds1.png"));
-    bottomCloudsTexture = new Texture(renderer, asset->get("game_clouds2.png"));
-    grassTexture = new Texture(renderer, asset->get("game_grass.png"));
-    gradientsTexture = new Texture(renderer, asset->get("game_sky_colors.png"));
-
     // Inicializa variables
-    gradientNumber = 0;
-    alpha = 0;
-    cloudsSpeed = 0;
-    transition = 0;
-    counter = 0;
+    gradient_number_ = 0;
+    alpha_ = 0;
+    clouds_speed_ = 0;
+    transition_ = 0;
+    counter_ = 0;
 
-    rect = {0, 0, gradientsTexture->getWidth() / 2, gradientsTexture->getHeight() / 2};
-    srcRect = {0, 0, 320, 240};
-    dstRect = {0, 0, 320, 240};
+    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.attenuateColor.r, param->background.attenuateColor.g, param->background.attenuateColor.b};
-    alphaColorText = alphaColorTextTemp = param->background.attenuateAlpha;
+    base_ = rect_.h;
+    color_ = {param.background.attenuate_color.r, param.background.attenuate_color.g, param.background.attenuate_color.b};
+    alpha_color_text_ = alpha_color_text_temp_ = param.background.attenuate_alpha;
 
-    gradientRect[0] = {0, 0, rect.w, rect.h};
-    gradientRect[1] = {rect.w, 0, rect.w, rect.h};
-    gradientRect[2] = {0, rect.h, rect.w, rect.h};
-    gradientRect[3] = {rect.w, rect.h, rect.w, rect.h};
+    gradient_rect_[0] = {0, 0, rect_.w, rect_.h};
+    gradient_rect_[1] = {rect_.w, 0, rect_.w, rect_.h};
+    gradient_rect_[2] = {0, rect_.h, rect_.w, rect_.h};
+    gradient_rect_[3] = {rect_.w, rect_.h, rect_.w, rect_.h};
 
-    const int topCloudsTextureHeight = topCloudsTexture->getHeight() / 4;
-    const int bottomCloudsTextureHeight = bottomCloudsTexture->getHeight() / 4;
+    const int top_clouds_texture_height = top_clouds_texture_->getHeight() / 4;
+    const int bottom_clouds_texture_height = bottom_clouds_texture_->getHeight() / 4;
     for (int i = 0; i < 4; ++i)
     {
-        topCloudsRect[i] = {0, i * topCloudsTextureHeight, topCloudsTexture->getWidth(), topCloudsTextureHeight};
-        bottomCloudsRect[i] = {0, i * bottomCloudsTextureHeight, bottomCloudsTexture->getWidth(), bottomCloudsTextureHeight};
+        top_clouds_rect_[i] = {0, i * top_clouds_texture_height, top_clouds_texture_->getWidth(), top_clouds_texture_height};
+        bottom_clouds_rect_[i] = {0, i * bottom_clouds_texture_height, bottom_clouds_texture_->getWidth(), bottom_clouds_texture_height};
     }
 
     // Crea los sprites
-    const int topClouds_y = base - 165;
-    const int bottomClouds_y = base - 101;
-    const float topCloudsSpeed = 0.1f;
-    const float bottomCloudsSpeed = 0.05f;
-    topCloudsSprite_A = new MovingSprite(0, topClouds_y, rect.w, topCloudsTexture->getHeight(), -topCloudsSpeed, 0.0f, 0.0f, 0.0f, topCloudsTexture);
-    topCloudsSprite_B = new MovingSprite(rect.w, topClouds_y, rect.w, topCloudsTexture->getHeight(), -topCloudsSpeed, 0.0f, 0.0f, 0.0f, topCloudsTexture);
+    const int top_clouds_y = base_ - 165;
+    const int bottom_clouds_y = base_ - 101;
+    constexpr float top_clouds_speed = 0.1f;
+    constexpr float bottom_clouds_speed = 0.05f;
+    top_clouds_sprite_a_ = std::make_unique<MovingSprite>(0, top_clouds_y, rect_.w, top_clouds_texture_->getHeight(), -top_clouds_speed, 0.0f, 0.0f, 0.0f, top_clouds_texture_);
+    top_clouds_sprite_b_ = std::make_unique<MovingSprite>(rect_.w, top_clouds_y, rect_.w, top_clouds_texture_->getHeight(), -top_clouds_speed, 0.0f, 0.0f, 0.0f, top_clouds_texture_);
 
-    bottomCloudsSprite_A = new MovingSprite(0, bottomClouds_y, rect.w, bottomCloudsTexture->getHeight(), -bottomCloudsSpeed, 0.0f, 0.0f, 0.0f, bottomCloudsTexture);
-    bottomCloudsSprite_B = new MovingSprite(rect.w, bottomClouds_y, rect.w, bottomCloudsTexture->getHeight(), -bottomCloudsSpeed, 0.0f, 0.0f, 0.0f, bottomCloudsTexture);
+    bottom_clouds_sprite_a_ = std::make_unique<MovingSprite>(0, bottom_clouds_y, rect_.w, bottom_clouds_texture_->getHeight(), -bottom_clouds_speed, 0.0f, 0.0f, 0.0f, bottom_clouds_texture_);
+    bottom_clouds_sprite_b_ = std::make_unique<MovingSprite>(rect_.w, bottom_clouds_y, rect_.w, bottom_clouds_texture_->getHeight(), -bottom_clouds_speed, 0.0f, 0.0f, 0.0f, bottom_clouds_texture_);
 
-    buildingsSprite = new Sprite(0, 0, buildingsTexture->getWidth(), buildingsTexture->getHeight(), buildingsTexture);
-    gradientSprite = new Sprite(0, 0, rect.w, rect.h, gradientsTexture);
-    grassSprite = new Sprite(0, 0, grassTexture->getWidth(), grassTexture->getHeight() / 2, grassTexture);
+    buildings_sprite_ = std::make_unique<Sprite>(0, 0, buildings_texture_->getWidth(), buildings_texture_->getHeight(), buildings_texture_);
+    gradient_sprite_ = std::make_unique<Sprite>(0, 0, rect_.w, rect_.h, gradients_texture_);
+    grass_sprite_ = std::make_unique<Sprite>(0, 0, grass_texture_->getWidth(), grass_texture_->getHeight() / 2, grass_texture_);
 
     // Inicializa objetos
-    topCloudsSprite_A->setSpriteClip(0, 0, topCloudsTexture->getWidth(), topCloudsTexture->getHeight());
-    topCloudsSprite_B->setSpriteClip(0, 0, topCloudsTexture->getWidth(), topCloudsTexture->getHeight());
-    bottomCloudsSprite_A->setSpriteClip(0, 0, bottomCloudsTexture->getWidth(), bottomCloudsTexture->getHeight());
-    bottomCloudsSprite_B->setSpriteClip(0, 0, bottomCloudsTexture->getWidth(), bottomCloudsTexture->getHeight());
-    buildingsSprite->setPosY(base - buildingsSprite->getHeight());
-    grassSprite->setPosY(base - grassSprite->getHeight());
+    top_clouds_sprite_a_->setSpriteClip(0, 0, top_clouds_texture_->getWidth(), top_clouds_texture_->getHeight());
+    top_clouds_sprite_b_->setSpriteClip(0, 0, top_clouds_texture_->getWidth(), top_clouds_texture_->getHeight());
+    bottom_clouds_sprite_a_->setSpriteClip(0, 0, bottom_clouds_texture_->getWidth(), bottom_clouds_texture_->getHeight());
+    bottom_clouds_sprite_b_->setSpriteClip(0, 0, bottom_clouds_texture_->getWidth(), bottom_clouds_texture_->getHeight());
+    buildings_sprite_->setPosY(base_ - buildings_sprite_->getHeight());
+    grass_sprite_->setPosY(base_ - grass_sprite_->getHeight());
 
     // Crea la textura para componer el fondo
-    canvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
-    SDL_SetTextureBlendMode(canvas, SDL_BLENDMODE_BLEND);
+    canvas_ = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
+    SDL_SetTextureBlendMode(canvas_, SDL_BLENDMODE_BLEND);
 
     // Crea la textura para atenuar el fondo
-    colorTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
-    SDL_SetTextureBlendMode(colorTexture, SDL_BLENDMODE_BLEND);
-    setColor(color);
-    SDL_SetTextureAlphaMod(colorTexture, alphaColorText);
+    color_texture_ = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
+    SDL_SetTextureBlendMode(color_texture_, SDL_BLENDMODE_BLEND);
+    setColor(color_);
+    SDL_SetTextureAlphaMod(color_texture_, alpha_color_text_);
 }
 
 // Destructor
 Background::~Background()
 {
-    delete buildingsTexture;
-    delete topCloudsTexture;
-    delete bottomCloudsTexture;
-    delete grassTexture;
-    delete gradientsTexture;
-
-    delete topCloudsSprite_A;
-    delete topCloudsSprite_B;
-    delete bottomCloudsSprite_A;
-    delete bottomCloudsSprite_B;
-    delete buildingsSprite;
-    delete gradientSprite;
-    delete grassSprite;
-    SDL_DestroyTexture(canvas);
-    SDL_DestroyTexture(colorTexture);
+    SDL_DestroyTexture(canvas_);
+    SDL_DestroyTexture(color_texture_);
 }
 
 // Actualiza la lógica del objeto
 void Background::update()
 {
-    // Actualiza el valor de alpha
+    // Actualiza el valor de alpha_
     updateAlphaColorText();
 
     // Actualiza las nubes
     updateClouds();
 
     // Calcula el frame de la hierba
-    grassSprite->setSpriteClip(0, (10 * (counter / 20 % 2)), 320, 10);
+    grass_sprite_->setSpriteClip(0, (10 * (counter_ / 20 % 2)), 320, 10);
 
-    // Calcula el valor de alpha
-    alpha = std::max((255 - (int)(255 * transition)), 0);
+    // Calcula el valor de alpha_
+    alpha_ = std::max((255 - (int)(255 * transition_)), 0);
 
     // Incrementa el contador
-    counter++;
+    counter_++;
 
+    // Compone todos los elementos del fondo en la textura
     fillCanvas();
 }
 
 // Dibuja el gradiente de fondo
 void Background::renderGradient()
 {
-    // Dibuja el gradiente 2
-    gradientsTexture->setAlpha(255);
-    gradientSprite->setSpriteClip(gradientRect[(gradientNumber + 1) % 4]);
-    gradientSprite->render();
+    // Dibuja el gradiente de detras
+    gradients_texture_->setAlpha(255);
+    gradient_sprite_->setSpriteClip(gradient_rect_[(gradient_number_ + 1) % 4]);
+    gradient_sprite_->render();
 
-    // Dibuja el gradiente 1 con una opacidad cada vez menor
-    gradientsTexture->setAlpha(alpha);
-    gradientSprite->setSpriteClip(gradientRect[gradientNumber]);
-    gradientSprite->render();
+    // Dibuja el gradiente de delante con una opacidad cada vez menor
+    gradients_texture_->setAlpha(alpha_);
+    gradient_sprite_->setSpriteClip(gradient_rect_[gradient_number_]);
+    gradient_sprite_->render();
 }
 
 // Dibuja las nubes de arriba
 void Background::renderTopClouds()
 {
-    // Dibuja el primer conjunto de nubes
-    topCloudsTexture->setAlpha(255);
-    topCloudsSprite_A->setSpriteClip(topCloudsRect[(gradientNumber + 1) % 4]);
-    topCloudsSprite_A->render();
-    topCloudsSprite_B->setSpriteClip(topCloudsRect[(gradientNumber + 1) % 4]);
-    topCloudsSprite_B->render();
+    // Dibuja el primer conjunto de nubes, las de detras
+    top_clouds_texture_->setAlpha(255);
+    top_clouds_sprite_a_->setSpriteClip(top_clouds_rect_[(gradient_number_ + 1) % 4]);
+    top_clouds_sprite_b_->setSpriteClip(top_clouds_rect_[(gradient_number_ + 1) % 4]);
+    top_clouds_sprite_a_->render();
+    top_clouds_sprite_b_->render();
 
-    // Dibuja el segundo conjunto de nubes
-    topCloudsTexture->setAlpha(alpha);
-    topCloudsSprite_A->setSpriteClip(topCloudsRect[gradientNumber]);
-    topCloudsSprite_A->render();
-    topCloudsSprite_B->setSpriteClip(topCloudsRect[gradientNumber]);
-    topCloudsSprite_B->render();
+    // Dibuja el segundo conjunto de nubes, las de delante
+    top_clouds_texture_->setAlpha(alpha_);
+    top_clouds_sprite_a_->setSpriteClip(top_clouds_rect_[gradient_number_]);
+    top_clouds_sprite_b_->setSpriteClip(top_clouds_rect_[gradient_number_]);
+    top_clouds_sprite_a_->render();
+    top_clouds_sprite_b_->render();
 }
 
 // Dibuja las nubes de abajo
 void Background::renderBottomClouds()
 {
-    // Dibuja el primer conjunto de nubes
-    bottomCloudsTexture->setAlpha(255);
-    bottomCloudsSprite_A->setSpriteClip(bottomCloudsRect[(gradientNumber + 1) % 4]);
-    bottomCloudsSprite_A->render();
-    bottomCloudsSprite_B->setSpriteClip(bottomCloudsRect[(gradientNumber + 1) % 4]);
-    bottomCloudsSprite_B->render();
+    // Dibuja el primer conjunto de nubes, las de detras
+    bottom_clouds_texture_->setAlpha(255);
+    bottom_clouds_sprite_a_->setSpriteClip(bottom_clouds_rect_[(gradient_number_ + 1) % 4]);
+    bottom_clouds_sprite_b_->setSpriteClip(bottom_clouds_rect_[(gradient_number_ + 1) % 4]);
+    bottom_clouds_sprite_a_->render();
+    bottom_clouds_sprite_b_->render();
 
-    // Dibuja el segundo conjunto de nubes
-    bottomCloudsTexture->setAlpha(alpha);
-    bottomCloudsSprite_A->setSpriteClip(bottomCloudsRect[gradientNumber]);
-    bottomCloudsSprite_A->render();
-    bottomCloudsSprite_B->setSpriteClip(bottomCloudsRect[gradientNumber]);
-    bottomCloudsSprite_B->render();
+    // Dibuja el segundo conjunto de nubes, las de delante
+    bottom_clouds_texture_->setAlpha(alpha_);
+    bottom_clouds_sprite_a_->setSpriteClip(bottom_clouds_rect_[gradient_number_]);
+    bottom_clouds_sprite_b_->setSpriteClip(bottom_clouds_rect_[gradient_number_]);
+    bottom_clouds_sprite_a_->render();
+    bottom_clouds_sprite_b_->render();
 }
 
 // Compone todos los elementos del fondo en la textura
 void Background::fillCanvas()
 {
     // Cambia el destino del renderizador
-    SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-    SDL_SetRenderTarget(renderer, canvas);
+    auto temp = SDL_GetRenderTarget(renderer_);
+    SDL_SetRenderTarget(renderer_, canvas_);
 
     // Dibuja el gradiente de fondo
     renderGradient();
@@ -185,119 +176,114 @@ void Background::fillCanvas()
     renderBottomClouds();
 
     // Dibuja los edificios
-    buildingsSprite->render();
+    buildings_sprite_->render();
 
     // Dibuja la hierba
-    grassSprite->render();
+    grass_sprite_->render();
 
     // Deja el renderizador apuntando donde estaba
-    SDL_SetRenderTarget(renderer, temp);
+    SDL_SetRenderTarget(renderer_, temp);
 }
 
 // Dibuja el objeto
 void Background::render()
 {
     // Fondo
-    SDL_RenderCopy(renderer, canvas, &srcRect, &dstRect);
+    SDL_RenderCopy(renderer_, canvas_, &src_rect_, &dst_rect_);
 
     // Atenuación
-    SDL_RenderCopy(renderer, colorTexture, &srcRect, &dstRect);
+    SDL_RenderCopy(renderer_, color_texture_, &src_rect_, &dst_rect_);
 }
 
 // Vuelve a cargar las texturas
 void Background::reloadTextures()
 {
-    buildingsTexture->reLoad();
-    topCloudsTexture->reLoad();
-    bottomCloudsTexture->reLoad();
-    grassTexture->reLoad();
-    gradientsTexture->reLoad();
+    buildings_texture_->reLoad();
+    top_clouds_texture_->reLoad();
+    bottom_clouds_texture_->reLoad();
+    grass_texture_->reLoad();
+    gradients_texture_->reLoad();
 }
 
 // Ajusta el valor de la variable
 void Background::setCloudsSpeed(float value)
 {
-    cloudsSpeed = value;
+    clouds_speed_ = value;
 }
 
 // Ajusta el valor de la variable
 void Background::setGradientNumber(int value)
 {
-    gradientNumber = value % 4;
+    gradient_number_ = value % 4;
 }
 
 // Ajusta el valor de la variable
 void Background::setTransition(float value)
 {
-    value = std::min(value, 1.0f);
-    value = std::max(value, 0.0f);
-    transition = value;
+    transition_ = std::clamp(value, 0.0f, 1.0f);
 }
 
 // Establece la posición del objeto
 void Background::setPos(SDL_Rect pos)
 {
-    this->dstRect = pos;
+    dst_rect_ = pos;
 
     // Si cambian las medidas del destino, hay que cambiar las del origen para evitar deformar la imagen
-    this->srcRect.x = 0;
-    this->srcRect.y = rect.h - pos.h;
-    this->srcRect.w = pos.w;
-    this->srcRect.h = pos.h;
+    src_rect_.x = 0;
+    src_rect_.y = rect_.h - pos.h;
+    src_rect_.w = pos.w;
+    src_rect_.h = pos.h;
 }
 
 // Ajusta el valor de la variable
 void Background::setSrcRect(SDL_Rect value)
 {
-    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
-void Background::setColor(color_t color)
+// Establece el color_ de atenuación
+void Background::setColor(Color color)
 {
-    this->color = color;
+    color_ = color;
 
     // Colorea la textura
-    SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-    SDL_SetRenderTarget(renderer, colorTexture);
+    auto temp = SDL_GetRenderTarget(renderer_);
+    SDL_SetRenderTarget(renderer_, color_texture_);
 
-    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 255);
-    SDL_RenderClear(renderer);
+    SDL_SetRenderDrawColor(renderer_, color_.r, color_.g, color_.b, 255);
+    SDL_RenderClear(renderer_);
 
-    SDL_SetRenderTarget(renderer, temp);
+    SDL_SetRenderTarget(renderer_, temp);
 }
 
 // Establece la transparencia de la atenuación
 void Background::setAlpha(int alpha)
 {
     // Evita que se asignen valores fuera de rango
-    alpha = std::min(alpha, 255);
-    alpha = std::max(alpha, 0);
+    alpha_ = std::clamp(alpha, 0, 255);
 
-    // Guarda el valor actual
-    alphaColorTextTemp = alphaColorText;
-
-    // Establece el nuevo valor
-    alphaColorText = alpha;
+    // Guarda el valor actual y establece el nuevo valor
+    alpha_color_text_temp_ = alpha_color_text_;
+    alpha_color_text_ = alpha_;
 }
 
-// Actualiza el valor de alpha
+// Actualiza el valor de alpha_
 void Background::updateAlphaColorText()
 {
-    if (alphaColorText == alphaColorTextTemp)
+    if (alpha_color_text_ == alpha_color_text_temp_)
     {
         return;
     }
     else
     {
-        alphaColorText > alphaColorTextTemp ? alphaColorTextTemp++ : alphaColorTextTemp--;
-        SDL_SetTextureAlphaMod(colorTexture, alphaColorTextTemp);
+        alpha_color_text_ > alpha_color_text_temp_ ? ++alpha_color_text_temp_ : --alpha_color_text_temp_;
+        SDL_SetTextureAlphaMod(color_texture_, alpha_color_text_temp_);
     }
 }
 
@@ -305,35 +291,35 @@ void Background::updateAlphaColorText()
 void Background::updateClouds()
 {
     // Aplica la velocidad calculada a las nubes
-    topCloudsSprite_A->setVelX(cloudsSpeed);
-    topCloudsSprite_B->setVelX(cloudsSpeed);
-    bottomCloudsSprite_A->setVelX(cloudsSpeed / 2);
-    bottomCloudsSprite_B->setVelX(cloudsSpeed / 2);
+    top_clouds_sprite_a_->setVelX(clouds_speed_);
+    top_clouds_sprite_b_->setVelX(clouds_speed_);
+    bottom_clouds_sprite_a_->setVelX(clouds_speed_ / 2);
+    bottom_clouds_sprite_b_->setVelX(clouds_speed_ / 2);
 
     // Mueve las nubes
-    topCloudsSprite_A->move();
-    topCloudsSprite_B->move();
-    bottomCloudsSprite_A->move();
-    bottomCloudsSprite_B->move();
+    top_clouds_sprite_a_->move();
+    top_clouds_sprite_b_->move();
+    bottom_clouds_sprite_a_->move();
+    bottom_clouds_sprite_b_->move();
 
     // Calcula el offset de las nubes
-    if (topCloudsSprite_A->getPosX() < -topCloudsSprite_A->getWidth())
+    if (top_clouds_sprite_a_->getPosX() < -top_clouds_sprite_a_->getWidth())
     {
-        topCloudsSprite_A->setPosX(topCloudsSprite_A->getWidth());
+        top_clouds_sprite_a_->setPosX(top_clouds_sprite_a_->getWidth());
     }
 
-    if (topCloudsSprite_B->getPosX() < -topCloudsSprite_B->getWidth())
+    if (top_clouds_sprite_b_->getPosX() < -top_clouds_sprite_b_->getWidth())
     {
-        topCloudsSprite_B->setPosX(topCloudsSprite_B->getWidth());
+        top_clouds_sprite_b_->setPosX(top_clouds_sprite_b_->getWidth());
     }
 
-    if (bottomCloudsSprite_A->getPosX() < -bottomCloudsSprite_A->getWidth())
+    if (bottom_clouds_sprite_a_->getPosX() < -bottom_clouds_sprite_a_->getWidth())
     {
-        bottomCloudsSprite_A->setPosX(bottomCloudsSprite_A->getWidth());
+        bottom_clouds_sprite_a_->setPosX(bottom_clouds_sprite_a_->getWidth());
     }
 
-    if (bottomCloudsSprite_B->getPosX() < -bottomCloudsSprite_B->getWidth())
+    if (bottom_clouds_sprite_b_->getPosX() < -bottom_clouds_sprite_b_->getWidth())
     {
-        bottomCloudsSprite_B->setPosX(bottomCloudsSprite_B->getWidth());
+        bottom_clouds_sprite_b_->setPosX(bottom_clouds_sprite_b_->getWidth());
     }
 }

source/background.h

@@ -1,9 +1,12 @@
 #pragma once
 
-#include <SDL2/SDL.h>
-#include "common/screen.h"
-#include "common/asset.h"
-#include "common/movingsprite.h"
+#include <SDL2/SDL_rect.h>    // for SDL_Rect
+#include <SDL2/SDL_render.h>  // for SDL_Renderer, SDL_Texture
+#include <memory>             // for unique_ptr, shared_ptr
+#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
@@ -35,7 +38,7 @@
         - setDstRecr(SDL_Rect value)
           Rectangulo de destino donde se mostrará el rectángulo antrior. Automaticamente modifica srcRect para coincidor en tamaño con el destino.
 
-        - setColor(color_t color)
+        - setColor(Color color)
           Establece el color de la textura de superposición
 
         - setAlpha(int alpha)
@@ -47,45 +50,42 @@ class Background
 {
 private:
   // Objetos y punteros
-  SDL_Renderer *renderer; // El renderizador de la ventana
-  Asset *asset;           // Objeto que gestiona todos los ficheros de recursos
+  SDL_Renderer *renderer_; // El renderizador de la ventana
 
-  Texture *buildingsTexture;    // Textura con los edificios de fondo
-  Texture *topCloudsTexture;    // Textura con las nubes de fondo
-  Texture *bottomCloudsTexture; // Textura con las nubes de fondo
-  Texture *grassTexture;        // Textura con la hierba del suelo
-  Texture *gradientsTexture;    // Textura con los diferentes colores de fondo del juego
+  std::shared_ptr<Texture> buildings_texture_;     // Textura con los edificios de fondo
+  std::shared_ptr<Texture> top_clouds_texture_;    // Textura con las nubes de fondo
+  std::shared_ptr<Texture> bottom_clouds_texture_; // Textura con las nubes de fondo
+  std::shared_ptr<Texture> grass_texture_;         // Textura con la hierba del suelo
+  std::shared_ptr<Texture> gradients_texture_;     // Textura con los diferentes colores de fondo del juego
 
-  MovingSprite *topCloudsSprite_A;    // Sprite para las nubes superiores
-  MovingSprite *topCloudsSprite_B;    // Sprite para las nubes superiores
-  MovingSprite *bottomCloudsSprite_A; // Sprite para las nubes inferiores
-  MovingSprite *bottomCloudsSprite_B; // Sprite para las nubes inferiores
+  std::unique_ptr<MovingSprite> top_clouds_sprite_a_;    // Sprite para las nubes superiores
+  std::unique_ptr<MovingSprite> top_clouds_sprite_b_;    // Sprite para las nubes superiores
+  std::unique_ptr<MovingSprite> bottom_clouds_sprite_a_; // Sprite para las nubes inferiores
+  std::unique_ptr<MovingSprite> bottom_clouds_sprite_b_; // Sprite para las nubes inferiores
 
-  Sprite *buildingsSprite; // Sprite con los edificios de fondo
-  Sprite *gradientSprite;  // Sprite con los graficos del degradado de color de fondo
-  Sprite *grassSprite;     // Sprite para la hierba
+  std::unique_ptr<Sprite> buildings_sprite_; // Sprite con los edificios de fondo
+  std::unique_ptr<Sprite> gradient_sprite_;  // Sprite con los graficos del degradado de color de fondo
+  std::unique_ptr<Sprite> grass_sprite_;     // Sprite para la hierba
 
-  SDL_Texture *canvas;       // Textura para componer el fondo
-  SDL_Texture *colorTexture; // Textura para atenuar el fondo
-
-  param_t *param; // Puntero con todos los parametros del programa
+  SDL_Texture *canvas_;        // Textura para componer el fondo
+  SDL_Texture *color_texture_; // Textura para atenuar el fondo
 
   // Variables
-  SDL_Rect gradientRect[4];     // Vector con las coordenadas de los 4 degradados para el cielo
-  SDL_Rect topCloudsRect[4];    // Vector con las coordenadas de los 4 nubes de arriba
-  SDL_Rect bottomCloudsRect[4]; // Vector con las coordenadas de los 4 nubes de abajo
-  int gradientNumber;           // Indica el número de degradado de fondo que se va a dibujar
-  int alpha;                    // Transparencia entre los dos degradados
-  float cloudsSpeed;            // Velocidad a la que se desplazan las nubes
-  float transition;             // Nivel de transición del fondo 0..1
-  int counter;                  // Contador interno
-  SDL_Rect rect;                // Tamaño del objeto fondo
-  SDL_Rect srcRect;             // Parte del objeto fondo que se va a dibujará en pantalla
-  SDL_Rect dstRect;             // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
-  int base;                     // Linea de fondo coincidente con el area inferior de la zona de juego
-  color_t color;                // Color para atenuar el fondo
-  int alphaColorText;           // Alpha para atenuar el fondo
-  int alphaColorTextTemp;       // Valor temporal para hacer la transición de alpha
+  SDL_Rect gradient_rect_[4];      // Vector con las coordenadas de los 4 degradados para el cielo
+  SDL_Rect top_clouds_rect_[4];    // Vector con las coordenadas de los 4 nubes de arriba
+  SDL_Rect bottom_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de abajo
+  int gradient_number_;            // 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
 
   // Dibuja el gradiente de fondo
   void renderGradient();
@@ -107,7 +107,7 @@ private:
 
 public:
   // Constructor
-  Background(SDL_Renderer *renderer, Asset *asset, param_t *param);
+  explicit Background(SDL_Renderer *renderer);
 
   // Destructor
   ~Background();
@@ -140,7 +140,7 @@ public:
   void setDstRect(SDL_Rect value);
 
   // Establece el color de atenuación
-  void setColor(color_t color);
+  void setColor(Color color);
 
   // Establece la transparencia de la atenuación
   void setAlpha(int alpha);

source/balloon.h

@@ -1,76 +1,78 @@
 #pragma once
 
-#include <SDL2/SDL.h>
-#include "common/animatedsprite.h"
-#include "common/utils.h"
-#include <sstream>
-#include <vector>
+#include <SDL2/SDL_stdinc.h> // for Uint8, Uint16, Uint32
+#include <memory>			 // for shared_ptr, unique_ptr
+#include <string>			 // for string
+#include <vector>			 // for vector
+#include "animated_sprite.h" // for AnimatedSprite
+#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
-#define BALLOON_2 2
-#define BALLOON_3 3
-#define BALLOON_4 4
-#define HEXAGON_1 5
-#define HEXAGON_2 6
-#define HEXAGON_3 7
-#define HEXAGON_4 8
-#define POWER_BALL 9
+constexpr int BALLOON_1 = 1;
+constexpr int BALLOON_2 = 2;
+constexpr int BALLOON_3 = 3;
+constexpr int BALLOON_4 = 4;
+constexpr int HEXAGON_1 = 5;
+constexpr int HEXAGON_2 = 6;
+constexpr int HEXAGON_3 = 7;
+constexpr int HEXAGON_4 = 8;
+constexpr int POWER_BALL = 9;
 
 // Puntos de globo
-#define BALLOON_SCORE_1 50
-#define BALLOON_SCORE_2 100
-#define BALLOON_SCORE_3 200
-#define BALLOON_SCORE_4 400
+constexpr int BALLOON_SCORE_1 = 50;
+constexpr int BALLOON_SCORE_2 = 100;
+constexpr int BALLOON_SCORE_3 = 200;
+constexpr int BALLOON_SCORE_4 = 400;
 
 // Tamaños de globo
-#define BALLOON_SIZE_1 1
-#define BALLOON_SIZE_2 2
-#define BALLOON_SIZE_3 3
-#define BALLOON_SIZE_4 4
+constexpr int BALLOON_SIZE_1 = 1;
+constexpr int BALLOON_SIZE_2 = 2;
+constexpr int BALLOON_SIZE_3 = 3;
+constexpr int BALLOON_SIZE_4 = 4;
 
 // Clases de globo
-#define BALLOON_CLASS 0
-#define HEXAGON_CLASS 1
+constexpr int BALLOON_CLASS = 0;
+constexpr int HEXAGON_CLASS = 1;
 
 // Velocidad del globo
-#define BALLOON_VELX_POSITIVE 0.7f
-#define BALLOON_VELX_NEGATIVE -0.7f
+constexpr float BALLOON_VELX_POSITIVE = 0.7f;
+constexpr float BALLOON_VELX_NEGATIVE = -0.7f;
 
 // Indice para las animaciones de los globos
-#define BALLOON_MOVING_ANIMATION 0
-#define BALLOON_POP_ANIMATION 1
-#define BALLOON_BORN_ANIMATION 2
+constexpr int BALLOON_MOVING_ANIMATION = 0;
+constexpr int BALLOON_POP_ANIMATION = 1;
+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
-#define BALLOON_SPEED_2 0.70f
-#define BALLOON_SPEED_3 0.80f
-#define BALLOON_SPEED_4 0.90f
-#define BALLOON_SPEED_5 1.00f
+constexpr float BALLOON_SPEED_1 = 0.60f;
+constexpr float BALLOON_SPEED_2 = 0.70f;
+constexpr float BALLOON_SPEED_3 = 0.80f;
+constexpr float BALLOON_SPEED_4 = 0.90f;
+constexpr float BALLOON_SPEED_5 = 1.00f;
 
 // Tamaño de los globos
-#define BALLOON_WIDTH_1 10
-#define BALLOON_WIDTH_2 16
-#define BALLOON_WIDTH_3 26
-#define BALLOON_WIDTH_4 46
+constexpr int BALLOON_WIDTH_1 = 10;
+constexpr int BALLOON_WIDTH_2 = 16;
+constexpr int BALLOON_WIDTH_3 = 26;
+constexpr int BALLOON_WIDTH_4 = 46;
 
 // PowerBall
-#define POWERBALL_SCREENPOWER_MINIMUM 10
-#define POWERBALL_COUNTER 8
+constexpr int POWERBALL_SCREENPOWER_MINIMUM = 10;
+constexpr int POWERBALL_COUNTER = 8;
 
 // Clase Balloon
 class Balloon
 {
 private:
 	// Estructura para las variables para el efecto de los rebotes
-	struct bouncing
+	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
-	param_t *param;			// Puntero con todos los parametros del programa
+	std::unique_ptr<AnimatedSprite> sprite_; // Sprite del objeto globo
 
 	// Variables
-	float posX;				   // Posición en el eje X
-	float posY;				   // Posición en el eje Y
-	Uint8 width;			   // Ancho
-	Uint8 height;			   // Alto
-	float velX;				   // Velocidad en el eje X. Cantidad de pixeles a desplazarse
-	float velY;				   // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
-	float gravity;			   // Aceleración en el eje Y. Modifica la velocidad
-	float defaultVelY;		   // Velocidad inicial que tienen al rebotar contra el suelo
-	float maxVelY;			   // Máxima velocidad que puede alcanzar el objeto en el eje Y
-	bool beingCreated;		   // Indica si el globo se está creando
-	bool blinking;			   // Indica si el globo está intermitente
-	bool enabled;			   // Indica si el globo esta activo
-	bool invulnerable;		   // Indica si el globo es invulnerable
-	bool stopped;			   // Indica si el globo está parado
-	bool visible;			   // Indica si el globo es visible
-	circle_t collider;		   // Circulo de colisión del objeto
-	Uint16 creationCounter;	   // Temporizador para controlar el estado "creandose"
-	Uint16 creationCounterIni; // Valor inicial para el temporizador para controlar el estado "creandose"
-	Uint16 score;			   // Puntos que da el globo al ser destruido
-	Uint16 stoppedCounter;	   // Contador para controlar el estado "parado"
-	Uint8 kind;				   // Tipo de globo
-	Uint8 menace;			   // Cantidad de amenaza que genera el globo
-	Uint32 counter;			   // Contador interno
-	float travelY;			   // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
-	float speed;			   // Velocidad a la que se mueven los globos
-	Uint8 size;				   // Tamaño del globo
-	Uint8 power;			   // Cantidad de poder que alberga el globo
-	bouncing bouncing;		   // Contiene las variables para el efecto de rebote
+	float pos_x_;				  // Posición en el eje X
+	float pos_y_;				  // Posición en el eje Y
+	Uint8 width_;				  // Ancho
+	Uint8 height_;				  // Alto
+	float vel_x_;				  // Velocidad en el eje X. 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 default_vel_y_;		  // Velocidad inicial que tienen al rebotar contra el suelo
+	float max_vel_y_;			  // Máxima velocidad que puede alcanzar el objeto en el eje Y
+	bool being_created_;		  // Indica si el globo se está creando
+	bool blinking_;				  // Indica si el globo está intermitente
+	bool enabled_;				  // Indica si el globo esta activo
+	bool invulnerable_;			  // Indica si el globo es invulnerable
+	bool stopped_;				  // Indica si el globo está parado
+	bool visible_;				  // Indica si el globo es visible
+	Circle collider_;			  // Circulo de colisión del objeto
+	Uint16 creation_counter_;	  // Temporizador para controlar el estado "creandose"
+	Uint16 creation_counter_ini_; // Valor inicial para el temporizador para controlar el estado "creandose"
+	Uint16 score_;				  // Puntos que da el globo al ser destruido
+	Uint16 stopped_counter_;	  // Contador para controlar el estado "parado"
+	Uint8 kind_;				  // Tipo de globo
+	Uint8 menace_;				  // Cantidad de amenaza que genera el globo
+	Uint32 counter_;			  // Contador interno
+	float 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
+	Uint8 size_;				  // Tamaño del globo
+	Uint8 power_;				  // Cantidad de poder que alberga el globo
+	Bouncing bouncing_;			  // Contiene las variables para el efecto de rebote
 
 	// Alinea el circulo de colisión con la posición del objeto globo
 	void updateColliders();
@@ -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, 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,718 @@
+#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].x = 0;
+			balloon_formation_[i].init[j].y = 0;
+			balloon_formation_[i].init[j].vel_x = 0;
+			balloon_formation_[i].init[j].kind = 0;
+			balloon_formation_[i].init[j].creation_counter = 0;
+		}
+	}
+
+	const int creation_time = 300;
+	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];
+}

source/balloon_formations.h

@@ -0,0 +1,63 @@
+#pragma once
+
+constexpr int NUMBER_OF_BALLOON_FORMATIONS = 100;
+constexpr int MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION = 50;
+
+// Estructuras
+struct BalloonFormationParams
+{
+    int x;                // Posición en el eje X donde crear al enemigo
+    int y;                // Posición en el eje Y donde crear al enemigo
+    float vel_x;          // Velocidad inicial en el eje X
+    int kind;             // Tipo de enemigo
+    int creation_counter; // Temporizador para la creación del enemigo
+};
+
+struct BalloonFormationUnit // Contiene la información de una formación enemiga
+{
+    int number_of_balloons;                                             // Cantidad de enemigos que forman la formación
+    BalloonFormationParams init[MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION]; // Vector con todas las inicializaciones de los enemigos de la formación
+};
+
+struct BalloonFormationPool
+{
+    BalloonFormationUnit *set[10]; // Conjunto de formaciones de globos
+};
+
+struct Stage // Contiene todas las variables relacionadas con una fase
+{
+    BalloonFormationPool *balloon_pool; // El conjunto de formaciones de globos de la fase
+    int power_to_complete;              // Cantidad de poder que se necesita para completar la fase
+    int max_menace;                     // Umbral máximo de amenaza de la fase
+    int min_menace;                     // Umbral mínimo de amenaza de la fase
+    int number;                         // Número de fase
+};
+
+// Clase BalloonFormations, para gestionar las formaciones de globos
+class BalloonFormations
+{
+private:
+    // Variables
+    Stage stage_[10];                                                      // Variable con los datos de cada pantalla
+    BalloonFormationUnit balloon_formation_[NUMBER_OF_BALLOON_FORMATIONS]; // Vector con todas las formaciones enemigas
+    BalloonFormationPool balloon_formation_pool_[10];                      // Variable con los diferentes conjuntos de formaciones enemigas
+
+    // Inicializa las formaciones enemigas
+    void initBalloonFormations();
+
+    // Inicializa los conjuntos de formaciones
+    void initBalloonFormationPools();
+
+    // Inicializa las fases del juego
+    void initGameStages();
+
+public:
+    // Constructor
+    BalloonFormations();
+
+    // Destructor
+    ~BalloonFormations() = default;
+
+    // Devuelve una fase
+    Stage getStage(int index) const;
+};

source/bullet.cpp

@@ -1,215 +1,121 @@
-#include "const.h"
 #include "bullet.h"
+#include <memory>    // for unique_ptr, make_unique, shared_ptr
+#include "param.h"   // for param
+#include "sprite.h"  // for Sprite
+class Texture;
+
+constexpr int BULLET_WIDTH = 12;
+constexpr int BULLET_HEIGHT = 12;
+constexpr int BULLET_VELY = -3;
+constexpr int BULLET_VELX_LEFT = -2;
+constexpr int BULLET_VELX_RIGHT = 2;
 
 // Constructor
-Bullet::Bullet(int x, int y, int kind, bool poweredUp, int owner, SDL_Rect *playArea, Texture *texture)
+Bullet::Bullet(int x, int y, BulletType kind, bool powered_up, int owner, SDL_Rect *play_area, std::shared_ptr<Texture> texture)
+    : sprite_(std::make_unique<Sprite>(SDL_Rect{x, y, BULLET_WIDTH, BULLET_HEIGHT}, texture)),
+      pos_x_(x),
+      pos_y_(y),
+      width_(BULLET_WIDTH),
+      height_(BULLET_HEIGHT),
+      vel_x_(0),
+      vel_y_(BULLET_VELY),
+      kind_(kind),
+      owner_(owner),
+      play_area_(play_area)
 {
-	// Rectangulo con la zona de juego
-	this->playArea = playArea;
+    vel_x_ = (kind_ == BulletType::LEFT) ? BULLET_VELX_LEFT : (kind_ == BulletType::RIGHT) ? BULLET_VELX_RIGHT
+                                                                                           : 0;
 
-	// Posición inicial del objeto
-	posX = x;
-	posY = y;
+    auto sprite_offset = powered_up ? 3 : 0;
+    auto kind_index = static_cast<int>(kind);
+    sprite_->setSpriteClip((kind_index + sprite_offset) * width_, 0, sprite_->getWidth(), sprite_->getHeight());
 
-	// Alto y ancho del objeto
-	width = 12;
-	height = 12;
-
-	// Crea el sprite
-	sprite = new Sprite({x, y, width, height}, texture);
-
-	// Velocidad inicial en el eje Y
-	velY = -3;
-
-	// Tipo de bala
-	this->kind = kind;
-
-	// Identificador del dueño del objeto
-	this->owner = owner;
-
-	// Valores especificos según el tipo
-	switch (kind)
-	{
-	case BULLET_UP:
-		// Establece la velocidad inicial
-		velX = 0;
-
-		// Rectangulo con los gráficos del objeto
-		if (!poweredUp)
-		{
-			sprite->setSpriteClip(0 * width, 0, sprite->getWidth(), sprite->getHeight());
-		}
-		else
-		{
-			sprite->setSpriteClip((0 + 3) * width, 0, sprite->getWidth(), sprite->getHeight());
-		}
-		break;
-
-	case BULLET_LEFT:
-		// Establece la velocidad inicial
-		velX = -2;
-
-		// Rectangulo con los gráficos del objeto
-		if (!poweredUp)
-		{
-			sprite->setSpriteClip(1 * width, 0, sprite->getWidth(), sprite->getHeight());
-		}
-		else
-		{
-			sprite->setSpriteClip((1 + 3) * width, 0, sprite->getWidth(), sprite->getHeight());
-		}
-		break;
-
-	case BULLET_RIGHT:
-		// Establece la velocidad inicial
-		velX = 2;
-
-		// Rectangulo con los gráficos del objeto
-		if (!poweredUp)
-		{
-			sprite->setSpriteClip(2 * width, 0, sprite->getWidth(), sprite->getHeight());
-		}
-		else
-		{
-			sprite->setSpriteClip((2 + 3) * width, 0, sprite->getWidth(), sprite->getHeight());
-		}
-		break;
-
-	default:
-		break;
-	}
-
-	// Establece el tamaño del circulo de colisión
-	collider.r = width / 2;
-
-	// Alinea el circulo de colisión con el objeto
-	shiftColliders();
+    collider_.r = width_ / 2;
+    shiftColliders();
 }
 
-// Destructor
-Bullet::~Bullet()
-{
-	delete sprite;
-}
-
-// Pinta el objeto en pantalla
+// Implementación de render (llama al render del sprite_)
 void Bullet::render()
 {
-	sprite->render();
+    sprite_->render();
 }
 
-// Actualiza la posición y estado del objeto en horizontal
-Uint8 Bullet::move()
+// Implementación del movimiento usando BulletMoveStatus
+BulletMoveStatus Bullet::move()
 {
-	// Variable con el valor de retorno
-	Uint8 msg = BULLET_MOVE_OK;
+    pos_x_ += vel_x_;
+    if (pos_x_ < param.game.play_area.rect.x - width_ || pos_x_ > play_area_->w)
+    {
+        disable();
+        return BulletMoveStatus::OUT;
+    }
 
-	// Mueve el objeto a su nueva posición
-	posX += velX;
+    pos_y_ += vel_y_;
+    if (pos_y_ < param.game.play_area.rect.y - height_)
+    {
+        disable();
+        return BulletMoveStatus::OUT;
+    }
 
-	// Si el objeto se sale del area de juego por los laterales
-	if ((posX < PLAY_AREA_LEFT - width) || (posX > playArea->w))
-	{
-		// Se deshabilita
-		kind = NO_KIND;
+    sprite_->setPosX(pos_x_);
+    sprite_->setPosY(pos_y_);
+    shiftColliders();
 
-		// Mensaje de salida
-		msg = BULLET_MOVE_OUT;
-	}
-
-	// Mueve el objeto a su nueva posición en vertical
-	posY += int(velY);
-
-	// Si el objeto se sale del area de juego por la parte superior
-	if (posY < PLAY_AREA_TOP - height)
-	{
-		// Se deshabilita
-		kind = NO_KIND;
-
-		// Mensaje de salida
-		msg = BULLET_MOVE_OUT;
-	}
-
-	// Actualiza la posición del sprite
-	sprite->setPosX(posX);
-	sprite->setPosY(posY);
-
-	// Alinea el circulo de colisión con el objeto
-	shiftColliders();
-
-	return msg;
+    return BulletMoveStatus::OK;
 }
 
-// Comprueba si el objeto está habilitado
-bool Bullet::isEnabled()
+bool Bullet::isEnabled() const
 {
-	if (kind == NO_KIND)
-	{
-		return false;
-	}
-	else
-	{
-		return true;
-	}
+    return kind_ != BulletType::NONE;
 }
 
-// Deshabilita el objeto
 void Bullet::disable()
 {
-	kind = NO_KIND;
+    kind_ = BulletType::NONE;
 }
 
-// Obtiene el valor de la variable
-int Bullet::getPosX()
+int Bullet::getPosX() const
 {
-	return posX;
+    return pos_x_;
 }
 
-// Obtiene el valor de la variable
-int Bullet::getPosY()
+int Bullet::getPosY() const
 {
-	return posY;
+    return pos_y_;
 }
 
-// Establece el valor de la variable
 void Bullet::setPosX(int x)
 {
-	posX = x;
+    pos_x_ = x;
 }
 
-// Establece el valor de la variable
 void Bullet::setPosY(int y)
 {
-	posY = y;
+    pos_y_ = y;
 }
 
-// Obtiene el valor de la variable
-int Bullet::getVelY()
+int Bullet::getVelY() const
 {
-	return velY;
+    return vel_y_;
 }
 
-// Obtiene el valor de la variable
-int Bullet::getKind()
+BulletType Bullet::getKind() const
 {
-	return kind;
+    return kind_;
 }
 
-// Obtiene el valor de la variable
-int Bullet::getOwner()
+int Bullet::getOwner() const
 {
-	return owner;
+    return owner_;
 }
 
-// Obtiene el circulo de colisión
-circle_t &Bullet::getCollider()
+Circle &Bullet::getCollider()
 {
-	return collider;
+    return collider_;
 }
 
-// Alinea el circulo de colisión con el objeto
 void Bullet::shiftColliders()
 {
-	collider.x = posX + collider.r;
-	collider.y = posY + collider.r;
+    collider_.x = pos_x_ + collider_.r;
+    collider_.y = pos_y_ + collider_.r;
 }

source/bullet.h

@@ -1,80 +1,79 @@
 #pragma once
 
-#include <SDL2/SDL.h>
-#include "common/sprite.h"
-#include "common/utils.h"
+#include <SDL2/SDL_rect.h>    // for SDL_Rect
+#include <SDL2/SDL_stdinc.h>  // for Uint8
+#include <memory>             // for shared_ptr, unique_ptr
+#include "sprite.h"           // for Sprite
+#include "utils.h"            // for Circle
+class Texture;
 
-// Tipos de bala
-#define BULLET_UP 1
-#define BULLET_LEFT 2
-#define BULLET_RIGHT 3
+// Enumeración para los diferentes tipos de balas
+enum class BulletType
+{
+	UP,
+	LEFT,
+	RIGHT,
+	NONE
+};
 
-// Tipos de retorno de la funcion move de la bala
-#define BULLET_MOVE_OK 0
-#define BULLET_MOVE_OUT 1
+// Enumeración para los resultados del movimiento de la bala
+enum class BulletMoveStatus : Uint8
+{
+	OK = 0,
+	OUT = 1
+};
 
 // Clase Bullet
 class Bullet
 {
 private:
-	// Objetos y punteros
-	Sprite *sprite; // Sprite con los graficos y métodos de pintado
+	std::unique_ptr<Sprite> sprite_; // Sprite con los gráficos y métodos de pintado
 
-	// Variables
-	int posX;		   // Posición en el eje X
-	int posY;		   // Posición en el eje Y
-	Uint8 width;	   // Ancho del objeto
-	Uint8 height;	   // Alto del objeto
-	int velX;		   // Velocidad en el eje X
-	int velY;		   // Velocidad en el eje Y
-	int kind;		   // Tipo de objeto
-	int owner;		   // Identificador del dueño del objeto
-	circle_t collider; // Circulo de colisión del objeto
-	SDL_Rect *playArea; // Rectangulo con la zona de juego
+	int pos_x_;	   // Posición en el eje X
+	int pos_y_;	   // Posición en el eje Y
+	Uint8 width_;  // Ancho del objeto
+	Uint8 height_; // Alto del objeto
 
-	// Alinea el circulo de colisión con el objeto
-	void shiftColliders();
+	int vel_x_; // Velocidad en el eje X
+	int vel_y_; // Velocidad en el eje Y
+
+	BulletType kind_;	  // Tipo de objeto
+	int owner_;			  // Identificador del dueño del objeto
+	Circle collider_;	  // Círculo de colisión del objeto
+	SDL_Rect *play_area_; // Rectángulo con la zona de juego
+
+	void shiftColliders(); // Alinea el círculo de colisión con el objeto
 
 public:
 	// Constructor
-	Bullet(int x, int y, int kind, bool poweredUp, int owner, SDL_Rect *playArea, Texture *texture);
+	Bullet(int x, int y, BulletType kind, bool powered_up, int owner, SDL_Rect *play_area, std::shared_ptr<Texture> texture);
 
 	// Destructor
-	~Bullet();
+	~Bullet() = default;
 
 	// Pinta el objeto en pantalla
 	void render();
 
 	// Actualiza la posición y estado del objeto
-	Uint8 move();
+	BulletMoveStatus move();
 
 	// Comprueba si el objeto está habilitado
-	bool isEnabled();
+	bool isEnabled() const;
 
 	// Deshabilita el objeto
 	void disable();
 
-	// Obtiene el valor de la variable
-	int getPosX();
+	// Obtiene la posición
+	int getPosX() const;
+	int getPosY() const;
 
-	// Obtiene el valor de la variable
-	int getPosY();
-
-	// Establece el valor de la variable
+	// Establece la posición
 	void setPosX(int x);
-
-	// Establece el valor de la variable
 	void setPosY(int y);
 
-	// Obtiene el valor de la variable
-	int getVelY();
-
-	// Obtiene el valor de la variable
-	int getKind();
-
-	// Obtiene el valor de la variable
-	int getOwner();
-
-	// Obtiene el circulo de colisión
-	circle_t &getCollider();
+	// Obtiene parámetros
+	int getVelY() const;
+	BulletType getKind() const;
+	int getOwner() const;
+	Circle &getCollider();
 };

source/common/asset.cpp

@@ -1,206 +0,0 @@
-#include "asset.h"
-#include <iostream>
-
-// Constructor
-Asset::Asset(std::string executablePath)
-{
-    this->executablePath = executablePath.substr(0, executablePath.find_last_of("\\/"));
-    longestName = 0;
-    verbose = true;
-}
-
-// Añade un elemento a la lista
-void Asset::add(std::string file, enum assetType type, bool required, bool absolute)
-{
-    item_t temp;
-    temp.file = absolute ? file : executablePath + file;
-    temp.type = type;
-    temp.required = required;
-    fileList.push_back(temp);
-
-    const std::string filename = file.substr(file.find_last_of("\\/") + 1);
-    longestName = SDL_max(longestName, filename.size());
-}
-
-// Devuelve el fichero de un elemento de la lista a partir de una cadena
-std::string Asset::get(std::string text)
-{
-    for (auto f : fileList)
-    {
-        const size_t lastIndex = f.file.find_last_of("/") + 1;
-        const std::string file = f.file.substr(lastIndex, std::string::npos);
-
-        if (file == text)
-        {
-            return f.file;
-        }
-    }
-
-    if (verbose)
-    {
-        std::cout << "Warning: file " << text.c_str() << " not found" << std::endl;
-    }
-    return "";
-}
-
-// Comprueba que existen todos los elementos
-bool Asset::check()
-{
-    bool success = true;
-
-    if (verbose)
-    {
-        std::cout << "\n** Checking files" << std::endl;
-
-        std::cout << "Executable path is:  " << executablePath << std::endl;
-        std::cout << "Sample filepath:  " << fileList.back().file << std::endl;
-    }
-
-    // Comprueba la lista de ficheros clasificandolos por tipo
-    for (int type = 0; type < t_maxAssetType; ++type)
-    {
-        // Comprueba si hay ficheros de ese tipo
-        bool any = false;
-
-        for (auto f : fileList)
-        {
-            if ((f.required) && (f.type == type))
-            {
-                any = true;
-            }
-        }
-
-        // Si hay ficheros de ese tipo, comprueba si existen
-        if (any)
-        {
-            if (verbose)
-            {
-                std::cout << "\n>> " << getTypeName(type).c_str() << " FILES" << std::endl;
-            }
-
-            for (auto f : fileList)
-            {
-                if ((f.required) && (f.type == type))
-                {
-                    success &= checkFile(f.file);
-                }
-            }
-        }
-    }
-
-    // Resultado
-    if (verbose)
-    {
-        if (success)
-        {
-            std::cout << "\n** All files OK.\n"
-                      << std::endl;
-        }
-        else
-        {
-            std::cout << "\n** A file is missing. Exiting.\n"
-                      << std::endl;
-        }
-    }
-
-    return success;
-}
-
-// Comprueba que existe un fichero
-bool Asset::checkFile(std::string path)
-{
-    bool success = false;
-    std::string result = "ERROR";
-
-    // Comprueba si existe el fichero
-    const std::string filename = path.substr(path.find_last_of("\\/") + 1);
-    SDL_RWops *file = SDL_RWFromFile(path.c_str(), "rb");
-
-    if (file != nullptr)
-    {
-        result = "OK";
-        success = true;
-        SDL_RWclose(file);
-    }
-
-    if (verbose)
-    {
-        std::cout.setf(std::ios::left, std::ios::adjustfield);
-        std::cout << "Checking file: ";
-        std::cout.width(longestName + 2);
-        std::cout.fill('.');
-        std::cout << filename + " ";
-        std::cout << " [" + result + "]" << std::endl;
-    }
-
-    return success;
-}
-
-// Devuelve el nombre del tipo de recurso
-std::string Asset::getTypeName(int type)
-{
-    switch (type)
-    {
-    case t_bitmap:
-        return "BITMAP";
-        break;
-
-    case t_music:
-        return "MUSIC";
-        break;
-
-    case t_sound:
-        return "SOUND";
-        break;
-
-    case t_font:
-        return "FONT";
-        break;
-
-    case t_lang:
-        return "LANG";
-        break;
-
-    case t_data:
-        return "DATA";
-        break;
-
-    case t_animation:
-        return "ANIMATION";
-        break;
-
-    case t_palette:
-        return "PALETTE";
-        break;
-
-    case t_item:
-        return "ITEM";
-        break;
-
-    default:
-        return "ERROR";
-        break;
-    }
-}
-
-// Establece si ha de mostrar texto por pantalla
-void Asset::setVerbose(bool value)
-{
-    verbose = value;
-}
-
-// Devuelve la lista de recursos de un tipo
-std::vector<std::string> Asset::getListByType(assetType type)
-{
-    std::vector<std::string> list;
-
-    for (auto f : fileList)
-    {
-        if (f.type == type)
-        {
-            list.push_back(f.file);
-        }
-    }
-
-    return list;
-}

source/common/asset.h

@@ -1,64 +0,0 @@
-#pragma once
-
-#include <SDL2/SDL.h>
-#include <string>
-#include <vector>
-
-enum assetType
-{
-	t_bitmap,
-	t_music,
-	t_sound,
-	t_font,
-	t_lang,
-	t_data,
-	t_animation,
-	t_palette,
-	t_item,
-	t_maxAssetType
-};
-
-// Clase Asset
-class Asset
-{
-private:
-	// Estructura para definir un item
-	struct item_t
-	{
-		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 longestName;			  // Contiene la longitud del nombre de fichero mas largo
-	std::vector<item_t> fileList; // Listado con todas las rutas a los ficheros
-	std::string executablePath;	  // Ruta al ejecutable
-	bool verbose;				  // Indica si ha de mostrar información por pantalla
-
-	// Comprueba que existe un fichero
-	bool checkFile(std::string executablePath);
-
-	// Devuelve el nombre del tipo de recurso
-	std::string getTypeName(int type);
-
-public:
-	// Constructor
-	Asset(std::string path);
-
-	// Añade un elemento a la lista
-	void add(std::string file, enum assetType type, bool required = true, bool absolute = false);
-
-	// Devuelve un elemento de la lista a partir de una cadena
-	std::string get(std::string text);
-
-	// Comprueba que existen todos los elementos
-	bool check();
-
-	// Establece si ha de mostrar texto por pantalla
-	void setVerbose(bool value);
-
-	// Devuelve la lista de recursos de un tipo
-	std::vector<std::string> getListByType(assetType type);
-};

source/common/input.cpp

@@ -1,542 +0,0 @@
-#include "input.h"
-#include <iostream>
-
-// Constructor
-Input::Input(std::string file)
-{
-	// Inicializa variables
-	verbose = false;
-	enabled = true;
-
-	// Fichero gamecontrollerdb.txt
-	dbPath = file;
-
-	// Busca si hay mandos conectados
-	discoverGameControllers();
-
-	// Inicializa las vectores
-	keyBindings_t kb;
-	kb.scancode = 0;
-	kb.active = false;
-	keyBindings.resize(input_number_of_inputs, kb);
-
-	GameControllerBindings_t gcb;
-	gcb.button = SDL_CONTROLLER_BUTTON_INVALID;
-	gcb.active = false;
-	gameControllerBindings.resize(numGamepads);
-	for (int i = 0; i < numGamepads; ++i)
-	{
-		gameControllerBindings[i].resize(input_number_of_inputs, gcb);
-	}
-
-	// Listado de los inputs usados para jugar, excluyendo botones para la interfaz
-	gameInputs.clear();
-	gameInputs.push_back(input_fire_left);
-	gameInputs.push_back(input_fire_center);
-	gameInputs.push_back(input_fire_right);
-	gameInputs.push_back(input_up);
-	gameInputs.push_back(input_down);
-	gameInputs.push_back(input_left);
-	gameInputs.push_back(input_right);
-
-	// Listado de los inputs para jugar que utilizan botones, ni palancas ni crucetas
-	buttonInputs.clear();
-	buttonInputs.push_back(input_fire_left);
-	buttonInputs.push_back(input_fire_center);
-	buttonInputs.push_back(input_fire_right);
-	buttonInputs.push_back(input_start);
-}
-
-// Actualiza el estado del objeto
-void Input::update()
-{
-	if (disabledUntil == d_keyPressed && !checkAnyInput())
-	{
-		enable();
-	}
-}
-
-// Asigna inputs a teclas
-void Input::bindKey(inputs_e input, SDL_Scancode code)
-{
-	keyBindings[input].scancode = code;
-}
-
-// Asigna inputs a botones del mando
-void Input::bindGameControllerButton(int index, inputs_e input, SDL_GameControllerButton button)
-{
-	if (index >= (int)connectedControllers.size())
-	{
-		return;
-	}
-	gameControllerBindings[index][input].button = button;
-}
-
-// Comprueba si un input esta activo
-bool Input::checkInput(inputs_e input, bool repeat, int device, int index)
-{
-	if (!enabled)
-	{
-		return false;
-	}
-
-	bool successKeyboard = false;
-	bool successGameController = false;
-
-	if (device == INPUT_USE_ANY)
-	{
-		index = 0;
-	}
-
-	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
-	{
-		const Uint8 *keyStates = SDL_GetKeyboardState(nullptr);
-
-		if (repeat)
-		{
-			if (keyStates[keyBindings[input].scancode] != 0)
-			{
-				successKeyboard = true;
-			}
-			else
-			{
-				successKeyboard = false;
-			}
-		}
-		else
-		{
-			if (!keyBindings[input].active)
-			{
-				if (keyStates[keyBindings[input].scancode] != 0)
-				{
-					keyBindings[input].active = true;
-					successKeyboard = true;
-				}
-				else
-				{
-					successKeyboard = false;
-				}
-			}
-			else
-			{
-				if (keyStates[keyBindings[input].scancode] == 0)
-				{
-					keyBindings[input].active = false;
-					successKeyboard = false;
-				}
-				else
-				{
-					successKeyboard = false;
-				}
-			}
-		}
-	}
-
-	if (gameControllerFound() && index < numGamepads)
-		if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY))
-		{
-			successGameController = checkAxisInput(input, index);
-			if (!successGameController)
-			{
-				if (repeat)
-				{
-					if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0)
-					{
-						successGameController = true;
-					}
-					else
-					{
-						successGameController = false;
-					}
-				}
-				else
-				{
-					if (!gameControllerBindings[index][input].active)
-					{
-						if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0)
-						{
-							gameControllerBindings[index][input].active = true;
-							successGameController = true;
-						}
-						else
-						{
-							successGameController = false;
-						}
-					}
-					else
-					{
-						if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) == 0)
-						{
-							gameControllerBindings[index][input].active = false;
-							successGameController = false;
-						}
-						else
-						{
-							successGameController = false;
-						}
-					}
-				}
-			}
-		}
-
-	return (successKeyboard || successGameController);
-}
-
-// Comprueba si hay almenos un input activo
-bool Input::checkAnyInput(int device, int index)
-{
-	if (device == INPUT_USE_ANY)
-	{
-		index = 0;
-	}
-
-	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
-	{
-		const Uint8 *mKeystates = SDL_GetKeyboardState(nullptr);
-
-		for (int i = 0; i < (int)keyBindings.size(); ++i)
-		{
-			if (mKeystates[keyBindings[i].scancode] != 0 && !keyBindings[i].active)
-			{
-				keyBindings[i].active = true;
-				return true;
-			}
-		}
-	}
-
-	if (gameControllerFound())
-	{
-		if (device == INPUT_USE_GAMECONTROLLER || device == INPUT_USE_ANY)
-		{
-			for (int i = 0; i < (int)gameControllerBindings.size(); ++i)
-			{
-				if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][i].button) != 0 && !gameControllerBindings[index][i].active)
-				{
-					gameControllerBindings[index][i].active = true;
-					return true;
-				}
-			}
-		}
-	}
-
-	return false;
-}
-
-// Comprueba si hay algún botón pulsado. Devuelve 0 en caso de no encontrar nada o el indice del dispositivo + 1. Se hace así para poder gastar el valor devuelto como un valor "booleano"
-int Input::checkAnyButtonPressed(bool repeat)
-{
-	// Solo comprueba los botones
-	for (auto bi : buttonInputs)
-	{
-		// Comprueba el teclado
-		if (checkInput(bi, repeat, INPUT_USE_KEYBOARD))
-		{
-			return 1;
-		}
-
-		// Comprueba los mandos
-		for (int i = 0; i < numGamepads; ++i)
-		{
-			if (checkInput(bi, repeat, INPUT_USE_GAMECONTROLLER, i))
-			{
-				return i + 1;
-			}
-		}
-	}
-
-	return 0;
-}
-
-// Busca si hay mandos conectados
-bool Input::discoverGameControllers()
-{
-	bool found = false;
-
-	if (SDL_WasInit(SDL_INIT_GAMECONTROLLER) != 1)
-	{
-		SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER);
-	}
-
-	if (SDL_GameControllerAddMappingsFromFile(dbPath.c_str()) < 0)
-	{
-		if (verbose)
-		{
-			std::cout << "Error, could not load " << dbPath.c_str() << " file: " << SDL_GetError() << std::endl;
-		}
-	}
-
-	numJoysticks = SDL_NumJoysticks();
-	numGamepads = 0;
-
-	// Cuenta el número de mandos
-	joysticks.clear();
-	for (int i = 0; i < numJoysticks; ++i)
-	{
-		SDL_Joystick *joy = SDL_JoystickOpen(i);
-		joysticks.push_back(joy);
-		if (SDL_IsGameController(i))
-		{
-			numGamepads++;
-		}
-	}
-
-	if (verbose)
-	{
-		std::cout << "\nChecking for game controllers...\n";
-		std::cout << numJoysticks << " joysticks found, " << numGamepads << " are gamepads\n";
-	}
-
-	if (numGamepads > 0)
-	{
-		found = true;
-
-		for (int i = 0; i < numGamepads; i++)
-		{
-			// Abre el mando y lo añade a la lista
-			SDL_GameController *pad = SDL_GameControllerOpen(i);
-			if (SDL_GameControllerGetAttached(pad) == 1)
-			{
-				connectedControllers.push_back(pad);
-				const std::string separator(" #");
-				std::string name = SDL_GameControllerNameForIndex(i);
-				// name.resize(25);
-				// name = name + separator + std::to_string(i);
-				if (verbose)
-				{
-					std::cout << name << std::endl;
-				}
-				controllerNames.push_back(name);
-			}
-			else
-			{
-				if (verbose)
-				{
-					std::cout << "SDL_GetError() = " << SDL_GetError() << std::endl;
-				}
-			}
-		}
-
-		SDL_GameControllerEventState(SDL_ENABLE);
-	}
-
-	return found;
-}
-
-// Comprueba si hay algun mando conectado
-bool Input::gameControllerFound()
-{
-	if (numGamepads > 0)
-	{
-		return true;
-	}
-	else
-	{
-		return false;
-	}
-}
-
-// Obten el nombre de un mando de juego
-std::string Input::getControllerName(int index)
-{
-	if (numGamepads > 0)
-	{
-		return controllerNames[index];
-	}
-	else
-	{
-		return "";
-	}
-}
-
-// Obten el número de mandos conectados
-int Input::getNumControllers()
-{
-	return numGamepads;
-}
-
-// Establece si ha de mostrar mensajes
-void Input::setVerbose(bool value)
-{
-	verbose = value;
-}
-
-// Deshabilita las entradas durante un periodo de tiempo
-void Input::disableUntil(i_disable_e value)
-{
-	disabledUntil = value;
-	enabled = false;
-}
-
-// Hablita las entradas
-void Input::enable()
-{
-	enabled = true;
-	disabledUntil = d_notDisabled;
-}
-
-// Obtiene el indice del controlador a partir de un event.id
-int Input::getJoyIndex(int id)
-{
-	for (int i = 0; i < numJoysticks; ++i)
-	{
-		if (SDL_JoystickInstanceID(joysticks[i]) == id)
-		{
-			return i;
-		}
-	}
-	return -1;
-}
-
-// Muestra por consola los controles asignados
-void Input::printBindings(int device, int index)
-{
-	if (device == INPUT_USE_ANY)
-	{
-		return;
-	}
-
-	if (device == INPUT_USE_KEYBOARD)
-	{
-		return;
-	}
-
-	if (device == INPUT_USE_GAMECONTROLLER)
-	{
-		if (index >= numGamepads)
-		{
-			return;
-		}
-
-		// Muestra el nombre del mando
-		std::cout << "\n"
-				  << controllerNames[index] << std::endl;
-
-		// Muestra los botones asignados
-		for (auto bi : buttonInputs)
-		{
-			std::cout << to_string(bi) << " : " << gameControllerBindings[index][bi].button << std::endl;
-		}
-	}
-}
-
-// Obtiene el SDL_GameControllerButton asignado a un input
-SDL_GameControllerButton Input::getControllerBinding(int index, inputs_e input)
-{
-	return gameControllerBindings[index][input].button;
-}
-
-// Obtiene el indice a partir del nombre del mando
-int Input::getIndexByName(std::string name)
-{
-	for (int i = 0; i < numGamepads; ++i)
-	{
-		if (controllerNames[i] == name)
-		{
-			return i;
-		}
-	}
-	return -1;
-}
-
-// Convierte un inputs_e a std::string
-std::string Input::to_string(inputs_e input)
-{
-	if (input == input_fire_left)
-	{
-		return "input_fire_left";
-	}
-
-	if (input == input_fire_center)
-	{
-		return "input_fire_center";
-	}
-
-	if (input == input_fire_right)
-	{
-		return "input_fire_right";
-	}
-
-	if (input == input_start)
-	{
-		return "input_start";
-	}
-
-	return "";
-}
-
-// Convierte un std::string a inputs_e
-inputs_e Input::to_inputs_e(std::string name)
-{
-	if (name == "input_fire_left")
-	{
-		return input_fire_left;
-	}
-
-	if (name == "input_fire_center")
-	{
-		return input_fire_center;
-	}
-
-	if (name == "input_fire_right")
-	{
-		return input_fire_right;
-	}
-
-	if (name == "input_start")
-	{
-		return input_start;
-	}
-
-	return input_null;
-}
-
-// Activa todos los inputs. Sirve para evitar inputs sin repeticiones pero que ya vienen pulsados cuando checkInput no estaba monitorizando
-void Input::allActive(int index)
-{
-	for (int i = 0; i < (int)buttonInputs.size(); ++i)
-	{
-		gameControllerBindings[index][i].active = true;
-	}
-}
-
-// Comprueba el eje del mando
-bool Input::checkAxisInput(inputs_e input, int index)
-{
-	bool success = false;
-	
-	switch (input)
-	{
-	case input_left:
-		if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTX) < -30000)
-		{
-			success = true;
-		}
-		break;
-
-	case input_right:
-		if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTX) > 30000)
-		{
-			success = true;
-		}
-		break;
-
-	case input_up:
-		if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTY) < -30000)
-		{
-			success = true;
-		}
-		break;
-
-	case input_down:
-		if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTY) > 30000)
-		{
-			success = true;
-		}
-		break;
-
-	default:
-		break;
-	}
-
-	return success;
-}

source/common/input.h

@@ -1,157 +0,0 @@
-#pragma once
-
-#include <SDL2/SDL.h>
-#include <string>
-#include <vector>
-
-/*
-connectedControllers es un vector donde estan todos los mandos encontrados [0 .. n]
-checkInput requiere de un indice para comprobar las pulsaciónes de un controlador en concreto [0 .. n]
-device contiene el tipo de dispositivo a comprobar:
-	INPUT_USE_KEYBOARD solo mirará el teclado
-	INPUT_USE_GAMECONTROLLER solo mirará el controlador especificado (Si no se especifica, el primero)
-	INPUT_USE_ANY mirará tanto el teclado como el PRIMER controlador
-*/
-
-enum inputs_e
-{
-	// Inputs de movimiento
-	input_up,
-	input_down,
-	input_left,
-	input_right,
-
-	// Inputs personalizados
-	input_fire_left,
-	input_fire_center,
-	input_fire_right,
-	input_start,
-
-	// Inputs de control
-	input_exit,
-	input_pause,
-	input_service,
-	input_window_fullscreen,
-	input_window_inc_size,
-	input_window_dec_size,
-	input_video_shaders,
-	input_reset,
-	input_mute,
-	input_showfps,
-
-	// Input obligatorio
-	input_null,
-	input_number_of_inputs
-};
-
-#define ALLOW_REPEAT true
-#define DO_NOT_ALLOW_REPEAT false
-
-#define INPUT_USE_KEYBOARD 0
-#define INPUT_USE_GAMECONTROLLER 1
-#define INPUT_USE_ANY 2
-
-enum i_disable_e
-{
-	d_notDisabled,
-	d_forever,
-	d_keyPressed
-};
-
-class Input
-{
-private:
-	struct keyBindings_t
-	{
-		Uint8 scancode; // Scancode asociado
-		bool active;	// Indica si está activo
-	};
-
-	struct GameControllerBindings_t
-	{
-		SDL_GameControllerButton button; // GameControllerButton asociado
-		bool active;					 // Indica si está activo
-	};
-
-	// Variables
-	std::vector<SDL_GameController *> connectedControllers;					   // Vector con todos los mandos conectados
-	std::vector<SDL_Joystick *> joysticks;									   // Vector con todos los joysticks conectados
-	std::vector<keyBindings_t> keyBindings;									   // Vector con las teclas asociadas a los inputs predefinidos
-	std::vector<std::vector<GameControllerBindings_t>> gameControllerBindings; // Vector con los botones asociadas a los inputs predefinidos para cada mando
-	std::vector<std::string> controllerNames;								   // Vector con los nombres de los mandos
-	std::vector<inputs_e> gameInputs;										   // Inputs usados para jugar, normalmente direcciones y botones
-	std::vector<inputs_e> buttonInputs;										   // Inputs asignados al jugador y a botones, excluyendo direcciones
-	int numJoysticks;														   // Número de joysticks conectados
-	int numGamepads;														   // Número de mandos conectados
-	std::string dbPath;														   // Ruta al archivo gamecontrollerdb.txt
-	bool verbose;															   // Indica si ha de mostrar mensajes
-	i_disable_e disabledUntil;												   // Tiempo que esta deshabilitado
-	bool enabled;															   // Indica si está habilitado
-
-	// Comprueba el eje del mando
-	bool checkAxisInput(inputs_e input, int index = 0);
-
-public:
-	// Constructor
-	Input(std::string file);
-
-	// Actualiza el estado del objeto
-	void update();
-
-	// Asigna inputs a teclas
-	void bindKey(inputs_e input, SDL_Scancode code);
-
-	// Asigna inputs a botones del mando
-	void bindGameControllerButton(int index, inputs_e input, SDL_GameControllerButton button);
-
-	// Comprueba si un input esta activo
-	bool checkInput(inputs_e input, bool repeat = true, int device = INPUT_USE_ANY, int index = 0);
-
-	// Comprueba si hay almenos un input activo
-	bool checkAnyInput(int device = INPUT_USE_ANY, int index = 0);
-
-	// Comprueba si hay algún botón pulsado
-	int checkAnyButtonPressed(bool repeat = DO_NOT_ALLOW_REPEAT);
-
-	// Busca si hay mandos conectados
-	bool discoverGameControllers();
-
-	// Comprueba si hay algun mando conectado
-	bool gameControllerFound();
-
-	// Obten el número de mandos conectados
-	int getNumControllers();
-
-	// Obten el nombre de un mando de juego
-	std::string getControllerName(int index);
-
-	// Establece si ha de mostrar mensajes
-	void setVerbose(bool value);
-
-	// Deshabilita las entradas durante un periodo de tiempo
-	void disableUntil(i_disable_e value);
-
-	// Hablita las entradas
-	void enable();
-
-	// Obtiene el indice del controlador a partir de un event.id
-	int getJoyIndex(int id);
-
-	// Muestra por consola los controles asignados
-	void printBindings(int device = INPUT_USE_KEYBOARD, int index = 0);
-
-	// Obtiene el SDL_GameControllerButton asignado a un input
-	SDL_GameControllerButton getControllerBinding(int index, inputs_e input);
-
-	// Convierte un inputs_e a std::string
-	std::string to_string(inputs_e input);
-
-	// Convierte un std::string a inputs_e
-	inputs_e to_inputs_e(std::string name);
-
-	// Obtiene el indice a partir del nombre del mando
-	int getIndexByName(std::string name);
-
-	// Activa todos los inputs. Sirve para evitar inputs sin repeticiones pero que ya vienen pulsados cuando checkInput no estaba monitorizando
-	void allActive(int index);
-};

source/common/movingsprite.cpp

@@ -1,367 +0,0 @@
-#include "movingsprite.h"
-
-// Constructor
-MovingSprite::MovingSprite(float x, float y, int w, int h, float velx, float vely, float accelx, float accely, Texture *texture)
-{
-	// Copia los punteros
-	this->texture = texture;
-
-	// Establece el alto y el ancho del sprite
-	this->w = w;
-	this->h = h;
-
-	// Establece la posición X,Y del sprite
-	this->x = x;
-	this->y = y;
-	xPrev = x;
-	yPrev = y;
-
-	// Establece la velocidad X,Y del sprite
-	vx = velx;
-	vy = vely;
-
-	// Establece la aceleración X,Y del sprite
-	ax = accelx;
-	ay = accely;
-
-	// Establece el zoom W,H del sprite
-	zoomW = 1;
-	zoomH = 1;
-
-	// Establece el angulo con el que se dibujará
-	angle = (double)0;
-
-	// Establece los valores de rotacion
-	rotateEnabled = false;
-	rotateSpeed = 0;
-	rotateAmount = (double)0;
-
-	// Contador interno
-	counter = 0;
-
-	// Establece el rectangulo de donde coger la imagen
-	spriteClip = {0, 0, w, h};
-
-	// Establece el centro de rotación
-	center = nullptr;
-
-	// Establece el tipo de volteado
-	currentFlip = SDL_FLIP_NONE;
-};
-
-// Reinicia todas las variables
-void MovingSprite::clear()
-{
-	x = 0.0f; // Posición en el eje X
-	y = 0.0f; // Posición en el eje Y
-
-	vx = 0.0f; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
-	vy = 0.0f; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
-
-	ax = 0.0f; // Aceleración en el eje X. Variación de la velocidad
-	ay = 0.0f; // Aceleración en el eje Y. Variación de la velocidad
-
-	zoomW = 1.0f; // Zoom aplicado a la anchura
-	zoomH = 1.0f; // Zoom aplicado a la altura
-
-	angle = 0.0;		   // Angulo para dibujarlo
-	rotateEnabled = false; // Indica si ha de rotar
-	center = nullptr;	   // Centro de rotación
-	rotateSpeed = 0;	   // Velocidad de giro
-	rotateAmount = 0.0;	   // Cantidad de grados a girar en cada iteración
-	counter = 0;		   // Contador interno
-
-	currentFlip = SDL_FLIP_NONE; // Establece como se ha de voltear el sprite
-}
-
-// Mueve el sprite
-void MovingSprite::move()
-{
-	if (enabled)
-	{
-		xPrev = x;
-		yPrev = y;
-
-		x += vx;
-		y += vy;
-
-		vx += ax;
-		vy += ay;
-	}
-}
-
-// Muestra el sprite por pantalla
-void MovingSprite::render()
-{
-	if (enabled)
-	{
-		texture->render((int)x, (int)y, &spriteClip, zoomW, zoomH, angle, center, currentFlip);
-	}
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getPosX()
-{
-	return x;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getPosY()
-{
-	return y;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getVelX()
-{
-	return vx;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getVelY()
-{
-	return vy;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getAccelX()
-{
-	return ax;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getAccelY()
-{
-	return ay;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getZoomW()
-{
-	return zoomW;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getZoomH()
-{
-	return zoomH;
-}
-
-// Obtiene el valor de la variable
-double MovingSprite::getAngle()
-{
-	return angle;
-}
-
-// Establece la posición y el tamaño del objeto
-void MovingSprite::setRect(SDL_Rect rect)
-{
-	x = (float)rect.x;
-	y = (float)rect.y;
-	w = rect.w;
-	h = rect.h;
-}
-
-// Establece el valor de las variables
-void MovingSprite::setPos(float x, float y)
-{
-	this->x = x;
-	this->y = y;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setPosX(float value)
-{
-	x = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setPosY(float value)
-{
-	y = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setVelX(float value)
-{
-	vx = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setVelY(float value)
-{
-	vy = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setAccelX(float value)
-{
-	ax = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setAccelY(float value)
-{
-	ay = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setZoomW(float value)
-{
-	zoomW = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setZoomH(float value)
-{
-	zoomH = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setAngle(double value)
-{
-	angle = value;
-}
-
-// Incrementa el valor de la variable
-void MovingSprite::incAngle(double value)
-{
-	angle += value;
-}
-
-// Decrementa el valor de la variable
-void MovingSprite::decAngle(double value)
-{
-	angle -= value;
-}
-
-// Obtiene el valor de la variable
-bool MovingSprite::getRotate()
-{
-	return rotateEnabled;
-}
-
-// Obtiene el valor de la variable
-Uint16 MovingSprite::getRotateSpeed()
-{
-	return rotateSpeed;
-}
-
-// Establece la rotacion
-void MovingSprite::rotate()
-{
-	if (enabled)
-		if (rotateEnabled)
-		{
-			if (counter % rotateSpeed == 0)
-			{
-				incAngle(rotateAmount);
-			}
-		}
-}
-
-// Establece el valor de la variable
-void MovingSprite::setRotate(bool value)
-{
-	rotateEnabled = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setRotateSpeed(int value)
-{
-	if (value < 1)
-	{
-		rotateSpeed = 1;
-	}
-	else
-	{
-		rotateSpeed = value;
-	}
-}
-
-// Establece el valor de la variable
-void MovingSprite::setRotateAmount(double value)
-{
-	rotateAmount = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::disableRotate()
-{
-	rotateEnabled = false;
-	angle = (double)0;
-}
-
-// Actualiza las variables internas del objeto
-void MovingSprite::update()
-{
-	move();
-	rotate();
-
-	if (enabled)
-	{
-		++counter %= 60000;
-	}
-}
-
-// Cambia el sentido de la rotación
-void MovingSprite::switchRotate()
-{
-	rotateAmount *= -1;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setFlip(SDL_RendererFlip flip)
-{
-	currentFlip = flip;
-}
-
-// Gira el sprite horizontalmente
-void MovingSprite::flip()
-{
-	currentFlip = (currentFlip == SDL_FLIP_HORIZONTAL) ? SDL_FLIP_NONE : SDL_FLIP_HORIZONTAL;
-}
-
-// Obtiene el valor de la variable
-SDL_RendererFlip MovingSprite::getFlip()
-{
-	return currentFlip;
-}
-
-// Devuelve el rectangulo donde está el sprite
-SDL_Rect MovingSprite::getRect()
-{
-	const SDL_Rect rect = {(int)x, (int)y, w, h};
-	return rect;
-}
-
-// Deshace el último movimiento
-void MovingSprite::undoMove()
-{
-	x = xPrev;
-	y = yPrev;
-}
-
-// Deshace el último movimiento en el eje X
-void MovingSprite::undoMoveX()
-{
-	x = xPrev;
-}
-
-// Deshace el último movimiento en el eje Y
-void MovingSprite::undoMoveY()
-{
-	y = yPrev;
-}
-
-// Pone a cero las velocidades de desplacamiento
-void MovingSprite::clearVel()
-{
-	vx = vy = 0.0f;
-}
-
-// Devuelve el incremento en el eje X en pixels
-int MovingSprite::getIncX()
-{
-	return (int)x - (int)xPrev;
-}

source/common/movingsprite.h

@@ -1,165 +0,0 @@
-#pragma once
-
-#include <SDL2/SDL.h>
-#include "sprite.h"
-
-// Clase MovingSprite. Añade posicion y velocidad en punto flotante
-class MovingSprite : public Sprite
-{
-protected:
-    float x; // Posición en el eje X
-    float y; // Posición en el eje Y
-
-    float xPrev; // Posición anterior en el eje X
-    float yPrev; // Posición anterior en el eje Y
-
-    float vx; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
-    float vy; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
-
-    float ax; // Aceleración en el eje X. Variación de la velocidad
-    float ay; // Aceleración en el eje Y. Variación de la velocidad
-
-    float zoomW; // Zoom aplicado a la anchura
-    float zoomH; // Zoom aplicado a la altura
-
-    double angle;                 // Angulo para dibujarlo
-    bool rotateEnabled;           // Indica si ha de rotar
-    int rotateSpeed;              // Velocidad de giro
-    double rotateAmount;          // Cantidad de grados a girar en cada iteración
-    int counter;                  // Contador interno
-    SDL_Point *center;            // Centro de rotación
-    SDL_RendererFlip currentFlip; // Indica como se voltea el sprite
-
-public:
-    // Constructor
-    MovingSprite(float x = 0, float y = 0, int w = 0, int h = 0, float velx = 0, float vely = 0, float accelx = 0, float accely = 0, Texture *texture = nullptr);
-
-    // Mueve el sprite
-    void move();
-
-    // Rota el sprite
-    void rotate();
-
-    // Actualiza las variables internas del objeto
-    void update();
-
-    // Reinicia todas las variables
-    void clear();
-
-    // Muestra el sprite por pantalla
-    void render();
-
-    // Obten el valor de la variable
-    float getPosX();
-
-    // Obten el valor de la variable
-    float getPosY();
-
-    // Obten el valor de la variable
-    float getVelX();
-
-    // Obten el valor de la variable
-    float getVelY();
-
-    // Obten el valor de la variable
-    float getAccelX();
-
-    // Obten el valor de la variable
-    float getAccelY();
-
-    // Obten el valor de la variable
-    float getZoomW();
-
-    // Obten el valor de la variable
-    float getZoomH();
-
-    // Obten el valor de la variable
-    double getAngle();
-
-    // Obtiene el valor de la variable
-    bool getRotate();
-
-    // Obtiene el valor de la variable
-    Uint16 getRotateSpeed();
-
-    // Establece la posición y el tamaño del objeto
-    void setRect(SDL_Rect rect);
-
-    // Establece el valor de las variables
-    void setPos(float x, float y);
-
-    // Establece el valor de la variable
-    void setPosX(float value);
-
-    // Establece el valor de la variable
-    void setPosY(float value);
-
-    // Establece el valor de la variable
-    void setVelX(float value);
-
-    // Establece el valor de la variable
-    void setVelY(float value);
-
-    // Establece el valor de la variable
-    void setAccelX(float value);
-
-    // Establece el valor de la variable
-    void setAccelY(float value);
-
-    // Establece el valor de la variable
-    void setZoomW(float value);
-
-    // Establece el valor de la variable
-    void setZoomH(float value);
-
-    // Establece el valor de la variable
-    void setAngle(double vaue);
-
-    // Incrementa el valor de la variable
-    void incAngle(double value);
-
-    // Decrementa el valor de la variable
-    void decAngle(double value);
-
-    // Establece el valor de la variable
-    void setRotate(bool value);
-
-    // Establece el valor de la variable
-    void setRotateSpeed(int value);
-
-    // Establece el valor de la variable
-    void setRotateAmount(double value);
-
-    // Quita el efecto de rotación y deja el sprite en su angulo inicial.
-    void disableRotate();
-
-    // Cambia el sentido de la rotación
-    void switchRotate();
-
-    // Establece el valor de la variable
-    void setFlip(SDL_RendererFlip flip);
-
-    // Gira el sprite horizontalmente
-    void flip();
-
-    // Obtiene el valor de la variable
-    SDL_RendererFlip getFlip();
-
-    // Devuelve el rectangulo donde está el sprite
-    SDL_Rect getRect();
-
-    // Deshace el último movimiento
-    void undoMove();
-
-    // Deshace el último movimiento en el eje X
-    void undoMoveX();
-
-    // Deshace el último movimiento en el eje Y
-    void undoMoveY();
-
-    // Pone a cero las velocidades de desplacamiento
-    void clearVel();
-
-    // Devuelve el incremento en el eje X en pixels
-    int getIncX();
-};

source/common/notify.h

@@ -1,94 +0,0 @@
-#pragma once
-
-#include <SDL2/SDL.h>
-#include "jail_audio.h"
-#include "sprite.h"
-#include "text.h"
-#include "texture.h"
-#include "utils.h"
-#include <vector>
-
-#ifndef NOTIFY_H
-#define NOTIFY_H
-
-class Notify
-{
-private:
-	enum notification_state_e
-	{
-		ns_rising,
-		ns_stay,
-		ns_vanishing,
-		ns_finished
-	};
-
-	enum notification_position_e
-	{
-		upperLeft,
-		upperCenter,
-		upperRight,
-		middleLeft,
-		middleRight,
-		bottomLeft,
-		bottomCenter,
-		bottomRight
-	};
-
-	enum notification_shape_t
-	{
-		notification_shape_rounded,
-		notification_shape_squared,
-	};
-
-	struct notification_t
-	{
-		std::string text1;
-		std::string text2;
-		int counter;
-		notification_state_e state;
-		notification_position_e position;
-		Texture *texture;
-		Sprite *sprite;
-		SDL_Rect rect;
-		int y;
-		int travelDist;
-		notification_shape_t shape;
-	};
-
-	// Objetos y punteros
-	SDL_Renderer *renderer; // El renderizador de la ventana
-	Texture *textTexture;	// Textura para la fuente de las notificaciones
-	Texture *iconTexture;	// Textura para los iconos de las notificaciones
-	Text *text;				// Objeto para dibujar texto
-	options_t *options;		// Variable con todas las opciones del programa
-
-	// Variables
-	color_t bgColor;						   // Color de fondo de las notificaciones
-	int waitTime;							   // Tiempo que se ve la notificación
-	std::vector<notification_t> notifications; // La lista de notificaciones activas
-	JA_Sound_t *sound;						   // Sonido a reproducir cuando suena la notificación
-
-	// Elimina las notificaciones finalizadas
-	void clearFinishedNotifications();
-
-public:
-	// Dibuja las notificaciones por pantalla
-	void render();
-
-	// Actualiza el estado de las notificaiones
-	void update();
-
-	// Constructor
-	Notify(SDL_Renderer *renderer, std::string iconFile, std::string bitmapFile, std::string textFile, std::string soundFile, options_t *options);
-
-	// Destructor
-	~Notify();
-
-	// Muestra una notificación de texto por pantalla;
-	void showText(std::string text1 = "", std::string text2 = "", int icon = -1);
-
-	// Indica si hay notificaciones activas
-	bool active();
-};
-
-#endif

source/common/screen.cpp

@@ -1,451 +0,0 @@
-#include "screen.h"
-#include <string>
-#include <iostream>
-#include <fstream>
-#include <streambuf>
-#ifndef NO_SHADERS
-#include "jshader.h"
-#endif
-#include "dbgtxt.h"
-
-// Constructor
-Screen::Screen(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, Input *input, options_t *options)
-{
-    // Copia punteros
-    this->window = window;
-    this->renderer = renderer;
-    this->asset = asset;
-    this->input = input;
-    this->options = options;
-
-    // Inicializa variables
-    SDL_GetRendererOutputSize(renderer, &windowWidth, &windowHeight);
-    gameCanvasWidth = options->video.gameWidth;
-    gameCanvasHeight = options->video.gameHeight;
-    dest = {0, 0, 0, 0};
-    borderColor = {0, 0, 0};
-    flashEffect.enabled = false;
-    flashEffect.counter = 0;
-    flashEffect.lenght = 0;
-    flashEffect.color = {0xFF, 0xFF, 0xFF};
-    shakeEffect.desp = 1;
-    shakeEffect.delay = 3;
-    shakeEffect.counter = 0;
-    shakeEffect.lenght = 8;
-    shakeEffect.remaining = 0;
-    shakeEffect.origin = 0;
-    attenuateEffect = false;
-    fpsTicks = 0;
-    fpsCounter = 0;
-    fps = 0;
-#ifdef DEBUG
-    showFps = true;
-#else
-    showFps = false;
-#endif
-
-    // Crea los objetos
-    notify = new Notify(renderer, asset->get("notify.png"), asset->get("8bithud.png"), asset->get("8bithud.txt"), asset->get("notify.wav"), options);
-
-    // Define el color del borde para el modo de pantalla completa
-    borderColor = {0x00, 0x00, 0x00};
-
-    // Crea la textura donde se dibujan los graficos del juego
-    gameCanvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, gameCanvasWidth, gameCanvasHeight);
-
-    // Establece el modo de video
-    setVideoMode(options->video.mode);
-
-    // Muestra la ventana
-    SDL_ShowWindow(window);
-}
-
-// Destructor
-Screen::~Screen()
-{
-    delete notify;
-    SDL_DestroyTexture(gameCanvas);
-}
-
-// Limpia la pantalla
-void Screen::clean(color_t color)
-{
-    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
-    SDL_RenderClear(renderer);
-}
-
-// Prepara para empezar a dibujar en la textura de juego
-void Screen::start()
-{
-    SDL_SetRenderTarget(renderer, gameCanvas);
-}
-
-// Vuelca el contenido del renderizador en pantalla
-void Screen::blit()
-{
-    // Actualiza y dibuja el efecto de flash en la pantalla
-    doFlash();
-
-    // Atenua la pantalla
-    doAttenuate();
-
-    // Pinta las notificaciones
-    notify->render();
-
-    // Actualiza el contador de FPS
-    fpsCounter++;
-
-    // Pinta en pantalla el contador de FPS
-    if (showFps)
-    {
-        dbg_print(0, 0, std::to_string(fps).c_str(), 255, 255, 255);
-    }
-
-#ifdef NO_SHADERS
-    // Vuelve a dejar el renderizador en modo normal
-    SDL_SetRenderTarget(renderer, nullptr);
-
-    // Borra el contenido previo
-    SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
-    SDL_RenderClear(renderer);
-
-    // Copia la textura de juego en el renderizador en la posición adecuada
-    SDL_RenderCopy(renderer, gameCanvas, nullptr, &dest);
-
-    // Muestra por pantalla el renderizador
-    SDL_RenderPresent(renderer);
-#else
-    if (options->video.shaders)
-    {
-        shader::render();
-    }
-    else
-    {
-        // Vuelve a dejar el renderizador en modo normal
-        SDL_SetRenderTarget(renderer, nullptr);
-
-        // Borra el contenido previo
-        SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
-        SDL_RenderClear(renderer);
-
-        // Copia la textura de juego en el renderizador en la posición adecuada
-        SDL_RenderCopy(renderer, gameCanvas, nullptr, &dest);
-
-        // Muestra por pantalla el renderizador
-        SDL_RenderPresent(renderer);
-    }
-#endif
-}
-
-// Establece el modo de video
-void Screen::setVideoMode(int videoMode)
-{
-#ifdef ARCADE
-    videoMode = SCREEN_VIDEO_MODE_WINDOW;
-#endif
-
-    // Si está activo el modo ventana quita el borde
-    if (videoMode == SCREEN_VIDEO_MODE_WINDOW)
-    {
-        // Aplica el modo de video
-        SDL_SetWindowFullscreen(window, 0);
-
-#ifdef ARCADE
-        // Oculta el puntero
-        SDL_ShowCursor(SDL_DISABLE);
-#else
-        // Muestra el puntero
-        SDL_ShowCursor(SDL_ENABLE);
-#endif
-
-        windowWidth = gameCanvasWidth;
-        windowHeight = gameCanvasHeight;
-        dest = {0, 0, windowWidth, windowHeight};
-
-        // Modifica el tamaño de la ventana
-        SDL_SetWindowSize(window, windowWidth * options->video.window.size, windowHeight * options->video.window.size);
-        SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
-    }
-
-    // Si está activo el modo de pantalla completa añade el borde
-    else if (videoMode == SCREEN_VIDEO_MODE_FULLSCREEN)
-    {
-        // Aplica el modo de video
-        SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
-
-        // Oculta el puntero
-        SDL_ShowCursor(SDL_DISABLE);
-
-        // Obten el alto y el ancho de la ventana
-        // SDL_GetWindowSize(window, &windowWidth, &windowHeight);
-
-        // Aplica el escalado al rectangulo donde se pinta la textura del juego
-        if (options->video.integerScale)
-        {
-            // Calcula el tamaño de la escala máxima
-            int scale = 0;
-            while (((gameCanvasWidth * (scale + 1)) <= windowWidth) && ((gameCanvasHeight * (scale + 1)) <= windowHeight))
-            {
-                scale++;
-            }
-
-            dest.w = gameCanvasWidth * scale;
-            dest.h = gameCanvasHeight * scale;
-            dest.x = (windowWidth - dest.w) / 2;
-            dest.y = (windowHeight - dest.h) / 2;
-        }
-        else if (options->video.keepAspect)
-        {
-            float ratio = (float)gameCanvasWidth / (float)gameCanvasHeight;
-            if ((windowWidth - gameCanvasWidth) >= (windowHeight - gameCanvasHeight))
-            {
-                dest.h = windowHeight;
-                dest.w = (int)((windowHeight * ratio) + 0.5f);
-                dest.x = (windowWidth - dest.w) / 2;
-                dest.y = (windowHeight - dest.h) / 2;
-            }
-            else
-            {
-                dest.w = windowWidth;
-                dest.h = (int)((windowWidth / ratio) + 0.5f);
-                dest.x = (windowWidth - dest.w) / 2;
-                dest.y = (windowHeight - dest.h) / 2;
-            }
-        }
-        else
-        {
-            // dest = {0, 0, windowWidth, windowHeight};
-            dest = {0, 0, gameCanvasWidth, gameCanvasHeight};
-        }
-    }
-
-#ifdef NO_SHADERS
-    // El renderizador pasa a tener el tamaño de la pantalla en fullscreen o del juego en modo ventana
-    SDL_RenderSetLogicalSize(renderer, windowWidth, windowHeight);
-#else
-    // Reinicia los shaders
-    if (options->video.shaders)
-    {
-        std::ifstream f(asset->get("crtpi.glsl").c_str());
-        std::string source((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
-
-        shader::init(window, gameCanvas, source.c_str());
-    }
-
-    // Modifica el tamaño del renderizador
-    else
-    {
-        // El renderizador pasa a tener el tamaño de la pantalla en fullscreen o del juego en modo ventana
-        // SDL_RenderSetLogicalSize(renderer, windowWidth, windowHeight);
-        SDL_RenderSetLogicalSize(renderer, gameCanvasWidth, gameCanvasHeight);
-    }
-#endif
-
-    // Actualiza las opciones
-    options->video.mode = videoMode;
-    options->video.window.width = windowWidth;
-    options->video.window.height = windowHeight;
-
-    // Actualiza variables
-    shakeEffect.origin = dest.x;
-}
-
-// Camibia entre pantalla completa y ventana
-void Screen::switchVideoMode()
-{
-    options->video.mode = options->video.mode == SCREEN_VIDEO_MODE_WINDOW ? SCREEN_VIDEO_MODE_FULLSCREEN : SCREEN_VIDEO_MODE_WINDOW;
-    setVideoMode(options->video.mode);
-}
-
-// Cambia el tamaño de la ventana
-void Screen::setWindowSize(int size)
-{
-    options->video.window.size = size;
-    setVideoMode(SCREEN_VIDEO_MODE_WINDOW);
-}
-
-// Reduce el tamaño de la ventana
-void Screen::decWindowSize()
-{
-    --options->video.window.size;
-    options->video.window.size = std::max(options->video.window.size, 1);
-    setVideoMode(SCREEN_VIDEO_MODE_WINDOW);
-}
-
-// Aumenta el tamaño de la ventana
-void Screen::incWindowSize()
-{
-    ++options->video.window.size;
-    options->video.window.size = std::min(options->video.window.size, 4);
-    setVideoMode(SCREEN_VIDEO_MODE_WINDOW);
-}
-
-// Cambia el color del borde
-void Screen::setBorderColor(color_t color)
-{
-    borderColor = color;
-}
-
-// Cambia el tipo de mezcla
-void Screen::setBlendMode(SDL_BlendMode blendMode)
-{
-    SDL_SetRenderDrawBlendMode(renderer, blendMode);
-}
-
-// Actualiza la lógica de la clase
-void Screen::update()
-{
-    updateShake();
-    notify->update();
-    updateFPS();
-}
-
-// Comprueba las entradas
-void Screen::checkInput()
-{
-#ifndef ARCADE
-    if (input->checkInput(input_window_fullscreen, DO_NOT_ALLOW_REPEAT))
-    {
-        switchVideoMode();
-        const std::string mode = options->video.mode == SCREEN_VIDEO_MODE_WINDOW ? "Window" : "Fullscreen";
-        showNotification(mode + " mode");
-    }
-
-    else if (input->checkInput(input_window_dec_size, DO_NOT_ALLOW_REPEAT))
-    {
-        decWindowSize();
-        const std::string size = std::to_string(options->video.window.size);
-        showNotification("Window size x" + size);
-    }
-
-    else if (input->checkInput(input_window_inc_size, DO_NOT_ALLOW_REPEAT))
-    {
-        incWindowSize();
-        const std::string size = std::to_string(options->video.window.size);
-        showNotification("Window size x" + size);
-    }
-
-    else if (input->checkInput(input_video_shaders, DO_NOT_ALLOW_REPEAT))
-    {
-        switchShaders();
-    }
-#endif
-
-    if (input->checkInput(input_showfps, DO_NOT_ALLOW_REPEAT))
-    {
-        showFps = !showFps;
-    }
-}
-
-// Agita la pantalla
-void Screen::shake()
-{
-    // Si ya hay un shake effect en marcha no se pilla el origen, solo se renuevan los contadores
-    if (shakeEffect.remaining == 0)
-    {
-        shakeEffect.origin = dest.x;
-    }
-
-    shakeEffect.remaining = shakeEffect.lenght;
-    shakeEffect.counter = shakeEffect.delay;
-}
-
-// Actualiza la logica para agitar la pantalla
-void Screen::updateShake()
-{
-    if (shakeEffect.remaining > 0)
-    {
-        if (shakeEffect.counter > 0)
-        {
-            shakeEffect.counter--;
-        }
-        else
-        {
-            shakeEffect.counter = shakeEffect.delay;
-            const int desp = shakeEffect.remaining % 2 == 0 ? shakeEffect.desp * (-1) : shakeEffect.desp;
-            dest.x = shakeEffect.origin + desp;
-            shakeEffect.remaining--;
-        }
-    }
-    else
-    {
-        dest.x = shakeEffect.origin;
-    }
-}
-
-// Pone la pantalla de color
-void Screen::flash(color_t color, int lenght)
-{
-    flashEffect.enabled = true;
-    flashEffect.counter = 0;
-    flashEffect.lenght = lenght;
-    flashEffect.color = color;
-}
-
-// Actualiza y dibuja el efecto de flash en la pantalla
-void Screen::doFlash()
-{
-    if (flashEffect.enabled)
-    {
-        // Dibuja el color del flash en la textura
-        SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-        SDL_SetRenderTarget(renderer, gameCanvas);
-        SDL_SetRenderDrawColor(renderer, flashEffect.color.r, flashEffect.color.g, flashEffect.color.b, 0xFF);
-        SDL_RenderClear(renderer);
-        SDL_SetRenderTarget(renderer, temp);
-
-        // Actualiza la lógica del efecto
-        flashEffect.counter < flashEffect.lenght ? flashEffect.counter++ : flashEffect.enabled = false;
-    }
-}
-
-// Atenua la pantalla
-void Screen::doAttenuate()
-{
-    if (attenuateEffect)
-    {
-        SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-        SDL_SetRenderTarget(renderer, gameCanvas);
-        SDL_SetRenderDrawColor(renderer, 0, 0, 0, 64);
-        SDL_RenderFillRect(renderer, nullptr);
-        SDL_SetRenderTarget(renderer, temp);
-    }
-}
-
-// Activa/desactiva los shaders
-void Screen::switchShaders()
-{
-    options->video.shaders = !options->video.shaders;
-    setVideoMode(options->video.mode);
-    const std::string value = options->video.shaders ? "on" : "off";
-    showNotification("Shaders " + value);
-}
-
-// Atenua la pantalla
-void Screen::attenuate(bool value)
-{
-    attenuateEffect = value;
-}
-
-// Muestra una notificación de texto por pantalla;
-void Screen::showNotification(std::string text1, std::string text2, int icon)
-{
-    notify->showText(text1, text2, icon);
-}
-
-// Obtiene el puntero al renderizador
-SDL_Renderer *Screen::getRenderer()
-{
-    return renderer;
-}
-
-// Calcula los frames por segundo
-void Screen::updateFPS()
-{
-    if (SDL_GetTicks() - fpsTicks > 1000)
-    {
-        fpsTicks = SDL_GetTicks();
-        fps = fpsCounter;
-        fpsCounter = 0;
-    }
-}

source/common/screen.h

@@ -1,135 +0,0 @@
-#pragma once
-
-#include <SDL2/SDL.h>
-#include "asset.h"
-#include "utils.h"
-#include "notify.h"
-#include "input.h"
-#include "../const.h"
-#include <vector>
-
-#define SCREEN_FILTER_NEAREST 0
-#define SCREEN_FILTER_LINEAL 1
-
-#define SCREEN_VIDEO_MODE_WINDOW 0
-#define SCREEN_VIDEO_MODE_FULLSCREEN 1
-
-class Screen
-{
-private:
-	// Objetos y punteros
-	SDL_Window *window;		 // Ventana de la aplicación
-	SDL_Renderer *renderer;	 // El renderizador de la ventana
-	Asset *asset;			 // Objeto con el listado de recursos
-	Input *input;			 // Objeto para leer las entradas de teclado o mando
-	Notify *notify;			 // Pinta notificaciones en pantalla
-	SDL_Texture *gameCanvas; // Textura para completar la ventana de juego hasta la pantalla completa
-	options_t *options;		 // Variable con todas las opciones del programa
-
-	// Variables
-	int windowWidth;	  // Ancho de la pantalla o ventana
-	int windowHeight;	  // Alto de la pantalla o ventana
-	int gameCanvasWidth;  // Resolución interna del juego. Es el ancho de la textura donde se dibuja el juego
-	int gameCanvasHeight; // Resolución interna del juego. Es el alto de la textura donde se dibuja el juego
-	SDL_Rect dest;		  // Coordenadas donde se va a dibujar la textura del juego sobre la pantalla o ventana
-	color_t borderColor;  // Color del borde añadido a la textura de juego para rellenar la pantalla
-	bool attenuateEffect; // Indica si la pantalla ha de estar atenuada
-	Uint32 fpsTicks;	  // Ticks para contar los frames por segundo
-	int fpsCounter;		  // Contador de frames por segundo
-	int fps;			  // Frames calculados en el último segundo
-	bool showFps;		  // Indica si ha de mostrar/ocultar la información de los frames por segundo en pantalla
-
-	struct effect_t
-	{
-		bool enabled;  // Indica si el efecto está activo
-		int counter;   // Contador para el efecto
-		int lenght;	   // Duración del efecto
-		color_t color; // Color del efecto
-	};
-
-	// Variables - Efectos
-	effect_t flashEffect; // Variable para gestionar el efecto de flash
-
-	struct shake_t
-	{
-		int desp;	   // Pixels de desplazamiento para agitar la pantalla en el eje x
-		int delay;	   // Retraso entre cada desplazamiento de la pantalla al agitarse
-		int counter;   // Contador para el retraso
-		int lenght;	   // Cantidad de desplazamientos a realizar
-		int remaining; // Cantidad de desplazamientos pendientes a realizar
-		int origin;	   // Valor inicial de la pantalla para dejarla igual tras el desplazamiento
-	} shakeEffect;
-
-	// Actualiza la logica para agitar la pantalla
-	void updateShake();
-
-	// Actualiza y dibuja el efecto de flash en la pantalla
-	void doFlash();
-
-	// Atenua la pantalla
-	void doAttenuate();
-
-	// Calcula los frames por segundo
-	void updateFPS();
-
-public:
-	// Constructor
-	Screen(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, Input *input, options_t *options);
-
-	// Destructor
-	~Screen();
-
-	// Actualiza la lógica de la clase
-	void update();
-
-	// Comprueba las entradas
-	void checkInput();
-
-	// Limpia la pantalla
-	void clean(color_t color = {0x00, 0x00, 0x00});
-
-	// Prepara para empezar a dibujar en la textura de juego
-	void start();
-
-	// Vuelca el contenido del renderizador en pantalla
-	void blit();
-
-	// Establece el modo de video
-	void setVideoMode(int videoMode);
-
-	// Camibia entre pantalla completa y ventana
-	void switchVideoMode();
-
-	// Cambia el tamaño de la ventana
-	void setWindowSize(int size);
-
-	// Reduce el tamaño de la ventana
-	void decWindowSize();
-
-	// Aumenta el tamaño de la ventana
-	void incWindowSize();
-
-	// Cambia el color del borde
-	void setBorderColor(color_t color);
-
-	// Cambia el tipo de mezcla
-	void setBlendMode(SDL_BlendMode blendMode);
-
-	// Agita la pantalla
-	void shake();
-
-	// Pone la pantalla de color
-	void flash(color_t color, int lenght);
-
-	// Activa/desactiva los shaders
-	void switchShaders();
-
-	// Atenua la pantalla
-	void attenuate(bool value);
-
-	// Muestra una notificación de texto por pantalla;
-	void showNotification(std::string text1 = "", std::string text2 = "", int icon = -1);
-
-	// Obtiene el puntero al renderizador
-	SDL_Renderer *getRenderer();
-};

source/common/smartsprite.h

@@ -1,68 +0,0 @@
-#pragma once
-
-#include <SDL2/SDL.h>
-#include "animatedsprite.h"
-#include "utils.h"
-#include <vector>
-
-// Clase SmartSprite
-class SmartSprite : public AnimatedSprite
-{
-private:
-	// Variables
-	bool enabled;		// Indica si esta habilitado
-	bool onDestination; // Indica si está en el destino
-	int destX;			// Posicion de destino en el eje X
-	int destY;			// Posicion de destino en el eje Y
-	int enabledCounter; // Contador para deshabilitarlo
-	bool finished;		// Indica si ya ha terminado
-
-	// Comprueba el movimiento
-	void checkMove();
-
-	// Comprueba si ha terminado
-	void checkFinished();
-
-public:
-	// Constructor
-	SmartSprite(Texture *texture);
-
-	// Inicializa el objeto
-	void init();
-
-	// Actualiza la posición y comprueba si ha llegado a su destino
-	void update();
-
-	// Pinta el objeto en pantalla
-	void render();
-
-	// Obtiene el valor de la variable
-	bool isEnabled();
-
-	// Establece el valor de la variable
-	void setEnabled(bool enabled);
-
-	// Obtiene el valor de la variable
-	int getEnabledCounter();
-
-	// Establece el valor de la variable
-	void setEnabledCounter(int value);
-
-	// Establece el valor de la variable
-	void setDestX(int x);
-
-	// Establece el valor de la variable
-	void setDestY(int y);
-
-	// Obtiene el valor de la variable
-	int getDestX();
-
-	// Obtiene el valor de la variable
-	int getDestY();
-
-	// Obtiene el valor de la variable
-	bool isOnDestination();
-
-	// Obtiene el valor de la variable
-	bool hasFinished();
-};