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

@@ -25,8 +25,8 @@ INCLUDES:= -I$(DIR_SOURCES)
 ifeq ($(OS),Windows_NT)
     FixPath = $(subst /,\,$1)
 	SOURCES := source/*.cpp
-	CXXFLAGS:= -std=c++11 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows
+	CXXFLAGS:= -std=c++20 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows
-	CXXFLAGS_DEBUG:= -std=c++11 -Wall
+	CXXFLAGS_DEBUG:= -std=c++20 -Wall -g
 	LDFLAGS := -lmingw32 -lws2_32 -lSDL2main -lSDL2 -lopengl32
 	RM = del /Q
 	MKD:= mkdir
@@ -34,8 +34,8 @@ else
     FixPath = $1
 	SOURCES := $(shell find $(DIR_SOURCES) -name '*.cpp')
 	SOURCES := source/*.cpp
-	CXXFLAGS:= -std=c++11 -Wall -Os -ffunction-sections -fdata-sections
+	CXXFLAGS:= -std=c++20 -Wall -Os -ffunction-sections -fdata-sections
-	CXXFLAGS_DEBUG:= -std=c++11 -Wall
+	CXXFLAGS_DEBUG:= -std=c++20 -Wall -g
 	LDFLAGS := -lSDL2
 	RM = rm -f
 	MKD:= mkdir -p
@@ -260,4 +260,5 @@ anbernic:
 	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).game
+	$(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_320x240.txt

@@ -1,19 +1,19 @@
 ## GAME
-game.itemSize           20
+game.item_size           20
 game.width              320
 game.height             240
-game.playArea.rect.x     0
+game.play_area.rect.x     0
-game.playArea.rect.y     0
+game.play_area.rect.y     0
-game.playArea.rect.w   320
+game.play_area.rect.w   320
-game.playArea.rect.h   200
+game.play_area.rect.h   200
 
 ## FADE
-fade.numSquaresWidth    160
+fade.num_squares_width    160
-fade.numSquaresHeight   120
+fade.num_squares_height   120
-fade.randomSquaresDelay   1
+fade.random_squares_delay   1
-fade.randomSquaresMult  500
+fade.random_squares_mult  500
-fade.postDuration        80
+fade.post_duration         80
-fade.venetianSize        16
+fade.venetian_size         16
 
 ## SCOREBOARD
 scoreboard.x   0
@@ -22,23 +22,31 @@ scoreboard.w 320
 scoreboard.h  40
 
 ## TITLE
-title.pressStartPosition    170
+title.press_start_position     170
-title.titleDuration         800
+title.title_duration           800
-title.arcadeEditionPosition 123
+title.arcade_edition_position  123
-title.titleCCPosition        80
+title.title_c_c_position        80
 
 ## BACKGROUND
-background.attenuateColor.r 255
+background.attenuate_color.r 255
-background.attenuateColor.g 255
+background.attenuate_color.g 255
-background.attenuateColor.b 255
+background.attenuate_color.b 255
-background.attenuateAlpha     0
+background.attenuate_alpha     0
 
 ## BALLOONS
-balloon1.vel  2.75f
+balloon_1.vel  2.75f
-balloon1.grav 0.09f
+balloon_1.grav 0.09f
-balloon2.vel  3.70f
+balloon_2.vel  3.70f
-balloon2.grav 0.10f
+balloon_2.grav 0.10f
-balloon3.vel  4.70f
+balloon_3.vel  4.70f
-balloon3.grav 0.10f
+balloon_3.grav 0.10f
-balloon4.vel  5.45f
+balloon_4.vel  5.45f
-balloon4.grav 0.10f
+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

@@ -1,19 +1,19 @@
 ## GAME
-game.itemSize           20
+game.item_size          20
 game.width             320
 game.height            256
-game.playArea.rect.x     0
+game.play_area.rect.x    0
-game.playArea.rect.y     0
+game.play_area.rect.y    0
-game.playArea.rect.w   320
+game.play_area.rect.w  320
-game.playArea.rect.h   216
+game.play_area.rect.h  216
 
 ## FADE
-fade.numSquaresWidth    160
+fade.num_squares_width    160
-fade.numSquaresHeight   128
+fade.num_squares_height   128
-fade.randomSquaresDelay   1
+fade.random_squares_delay   1
-fade.randomSquaresMult  500
+fade.random_squares_mult  500
-fade.postDuration        80
+fade.post_duration         80
-fade.venetianSize        16
+fade.venetian_size         16
 
 ## SCOREBOARD
 scoreboard.x   0
@@ -22,23 +22,31 @@ scoreboard.w 320
 scoreboard.h  40
 
 ## TITLE
-title.pressStartPosition    170
+title.press_start_position     180
-title.titleDuration         800
+title.title_duration           800
-title.arcadeEditionPosition 123
+title.arcade_edition_position  123
-title.titleCCPosition        80
+title.title_c_c_position        80
 
 ## BACKGROUND
-background.attenuateColor.r 255
+background.attenuate_color.r 255
-background.attenuateColor.g 255
+background.attenuate_color.g 255
-background.attenuateColor.b 255
+background.attenuate_color.b 255
-background.attenuateAlpha     0
+background.attenuate_alpha     0
 
 ## BALLOONS
-balloon1.vel  2.75f
+balloon_1.vel  2.75f
-balloon1.grav 0.09f
+balloon_1.grav 0.09f
-balloon2.vel  3.70f
+balloon_2.vel  3.70f
-balloon2.grav 0.10f
+balloon_2.grav 0.10f
-balloon3.vel  4.70f
+balloon_3.vel  4.70f
-balloon3.grav 0.10f
+balloon_3.grav 0.10f
-balloon4.vel  5.45f
+balloon_4.vel  5.45f
-balloon4.grav 0.10f
+balloon_4.grav 0.10f
+
+## NOTIFICATION
+notification.pos_v     TOP
+notification.pos_h    LEFT
+notification.sound   false
+notification.color.r    48
+notification.color.g    48
+notification.color.b    48

data/gfx/balloon/balloon1.ani

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

data/gfx/balloon/balloon2.ani

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

data/gfx/balloon/balloon3.ani

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

data/gfx/balloon/balloon4.ani

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

data/gfx/balloon/explosion1.ani

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

data/gfx/balloon/explosion2.ani

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

data/gfx/balloon/explosion3.ani

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

data/gfx/balloon/explosion4.ani

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

data/gfx/balloon/powerball.ani

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

data/gfx/item/item_clock.ani

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

data/gfx/item/item_coffee.ani

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

data/gfx/item/item_coffee_machine.ani

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

data/gfx/item/item_points1_disk.ani

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

data/gfx/item/item_points2_gavina.ani

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

data/gfx/item/item_points3_pacmar.ani

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

data/gfx/player/player.ani

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

data/gfx/player/player_power.ani

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

data/gfx/title/title_dust.ani

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

data/lang/ba_BA.txt

@@ -315,3 +315,33 @@ 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

@@ -315,3 +315,33 @@ 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

@@ -315,3 +315,33 @@ 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;
+	AnimatedFile af;
-	as.texture = texture;
+	af.texture = texture;
-	int framesPerRow = 0;
+	auto frames_per_row = 0;
-	int frameWidth = 0;
+	auto frame_width = 0;
-	int frameHeight = 0;
+	auto frame_height = 0;
-	int maxTiles = 0;
+	auto max_tiles = 0;
 
-	const std::string filename = filePath.substr(filePath.find_last_of("\\/") + 1);
+#ifdef VERBOSE
-	std::ifstream file(filePath);
+	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)
+#ifdef VERBOSE
-		{
+		std::cout << "Animation loaded: " << file_name << std::endl;
-			std::cout << "Animation loaded: " << filename << 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);
+								const auto num_tile = std::stoi(tmp) > max_tiles ? 0 : std::stoi(tmp);
-								rect.x = (numTile % framesPerRow) * frameWidth;
+								rect.x = (num_tile % frames_per_row) * frame_width;
-								rect.y = (numTile / framesPerRow) * frameHeight;
+								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 auto w = texture->getWidth() / frame_width;
-						const int h = texture->getHeight() / frameHeight;
+						const auto h = texture->getHeight() / frame_height;
-						maxTiles = w * h;
+						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)
+#ifdef VERBOSE
-		{
+		std::cout << "Warning: Unable to open " << file_name.c_str() << " file" << std::endl;
-			std::cout << "Warning: Unable to open " << filename.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)
+		std::copy(as.animations.begin(), as.animations.end(), std::back_inserter(animations_));
-		{
-			this->animation.push_back(animation);
-		}
 	}
 
 	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)
+	std::copy(animation->animations.begin(), animation->animations.end(), std::back_inserter(animations_));
-	{
-		this->animation.push_back(a);
-	}
 }
 
 // Destructor
 AnimatedSprite::~AnimatedSprite()
 {
-	for (auto &a : animation)
+	animations_.clear();
-	{
-		a.frames.clear();
-	}
-	animation.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();
+			animations_[current_animation_].current_frame = animations_[current_animation_].frames.size();
-			animation[currentAnimation].completed = true;
+			animations_[current_animation_].completed = true;
 		}
 		else
 		{ // Si hay loop, vuelve al frame indicado
-			animation[currentAnimation].counter = 0;
+			animations_[current_animation_].counter = 0;
-			animation[currentAnimation].currentFrame = animation[currentAnimation].loop;
+			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;
+	animations_[current_animation_].current_frame = num;
-	animation[currentAnimation].counter = 0;
+	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;
+	auto frames_per_row = 0;
-	int frameWidth = 0;
+	auto frame_width = 0;
-	int frameHeight = 0;
+	auto frame_height = 0;
-	int maxTiles = 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);
+							const int num_tile = std::stoi(tmp) > max_tiles ? 0 : std::stoi(tmp);
-							rect.x = (numTile % framesPerRow) * frameWidth;
+							rect.x = (num_tile % frames_per_row) * frame_width;
-							rect.y = (numTile / framesPerRow) * frameHeight;
+							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 w = texture_->getWidth() / frame_width;
-					const int h = texture->getHeight() / frameHeight;
+					const int h = texture_->getHeight() / frame_height;
-					maxTiles = w * h;
+					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);
+	const auto new_animation = getIndex(name);
-	if (currentAnimation != newAnimation)
+	if (current_animation_ != new_animation)
 	{
-		currentAnimation = newAnimation;
+		current_animation_ = new_animation;
-		animation[currentAnimation].currentFrame = 0;
+		animations_[current_animation_].current_frame = 0;
-		animation[currentAnimation].counter = 0;
+		animations_[current_animation_].counter = 0;
-		animation[currentAnimation].completed = false;
+		animations_[current_animation_].completed = false;
 	}
 }
 
 // Establece la animacion actual
 void AnimatedSprite::setCurrentAnimation(int index)
 {
-	const int newAnimation = index;
+	const auto new_animation = index;
-	if (currentAnimation != newAnimation)
+	if (current_animation_ != new_animation)
 	{
-		currentAnimation = newAnimation;
+		current_animation_ = new_animation;
-		animation[currentAnimation].currentFrame = 0;
+		animations_[current_animation_].current_frame = 0;
-		animation[currentAnimation].counter = 0;
+		animations_[current_animation_].counter = 0;
-		animation[currentAnimation].completed = false;
+		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;
+	animations_[current_animation_].current_frame = 0;
-	animation[currentAnimation].counter = 0;
+	animations_[current_animation_].counter = 0;
-	animation[currentAnimation].completed = false;
+	animations_[current_animation_].completed = false;
 }

source/animated_sprite.h

@@ -1,47 +1,47 @@
 #pragma once
 
-#include <SDL2/SDL.h>
+#include <SDL2/SDL_rect.h>   // for SDL_Rect
-#include "movingsprite.h"
+#include <SDL2/SDL_stdinc.h> // for Uint8
-#include <fstream>
+#include <memory>            // for shared_ptr
-#include <iostream>
+#include <string>            // for string
-#include <sstream>
+#include <vector>            // for vector
-#include <string>
+#include "moving_sprite.h"   // for MovingSprite
-#include <vector>
+class Texture;
 
-struct animation_t
+struct Animation
 {
     std::string name;             // Nombre de la animacion
     std::vector<SDL_Rect> frames; // Cada uno de los frames que componen la animación
     int speed;                    // Velocidad de la animación
     int loop;                     // Indica a que frame vuelve la animación al terminar. -1 para que no vuelva
     bool completed;               // Indica si ha finalizado la animación
-    int currentFrame;             // Frame actual
+    int current_frame;            // Frame actual
     int counter;                  // Contador para las animaciones
 };
 
-struct animatedSprite_t
+struct AnimatedFile
 {
-    std::vector<animation_t> animations; // Vector con las diferentes animaciones
+    std::vector<Animation> animations; // Vector con las diferentes animaciones
-    Texture *texture;                    // Textura con los graficos para el sprite
+    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
+    std::vector<Animation> animations_; // Vector con las diferentes animaciones
-    int currentAnimation;               // Animacion activa
+    int current_animation_;             // Animacion activa
 
 public:
     // Constructor
-    AnimatedSprite(Texture *texture = nullptr, std::string file = "", std::vector<std::string> *buffer = nullptr);
+    explicit AnimatedSprite(std::shared_ptr<Texture> texture = nullptr, const std::string &file = std::string(), std::vector<std::string> *buffer = nullptr);
-    AnimatedSprite(animatedSprite_t *animation);
+    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

@@ -1,34 +1,57 @@
 #include "asset.h"
-#include <iostream>
+#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(std::string executablePath)
+Asset::Asset(const std::string &executable_path)
+    : executable_path_(executable_path.substr(0, executable_path.find_last_of("\\/")))
 {
-    this->executablePath = executablePath.substr(0, executablePath.find_last_of("\\/"));
+    longest_name_ = 0;
-    longestName = 0;
-    verbose = true;
 }
 
 // Añade un elemento a la lista
-void Asset::add(std::string file, enum assetType type, bool required, bool absolute)
+void Asset::add(const std::string &file, AssetType type, bool required, bool absolute)
 {
-    item_t temp;
+    AssetItem ai;
-    temp.file = absolute ? file : executablePath + file;
+    ai.file = absolute ? file : executable_path_ + file;
-    temp.type = type;
+    ai.type = type;
-    temp.required = required;
+    ai.required = required;
-    fileList.push_back(temp);
+    file_list_.push_back(ai);
 
-    const std::string filename = file.substr(file.find_last_of("\\/") + 1);
+    const std::string file_name = file.substr(file.find_last_of("\\/") + 1);
-    longestName = SDL_max(longestName, filename.size());
+    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(std::string text)
+std::string Asset::get(const std::string &text) const
 {
-    for (auto f : fileList)
+    for (const auto &f : file_list_)
     {
-        const size_t lastIndex = f.file.find_last_of("/") + 1;
+        const size_t last_index = f.file.find_last_of("/") + 1;
-        const std::string file = f.file.substr(lastIndex, std::string::npos);
+        const std::string file = f.file.substr(last_index, std::string::npos);
 
         if (file == text)
         {
@@ -36,35 +59,33 @@ std::string Asset::get(std::string text)
         }
     }
 
-    if (verbose)
+#ifdef VERBOSE
-    {
     std::cout << "Warning: file " << text.c_str() << " not found" << std::endl;
-    }
+#endif
     return "";
 }
 
 // Comprueba que existen todos los elementos
-bool Asset::check()
+bool Asset::check() const
 {
     bool success = true;
 
-    if (verbose)
+#ifdef VERBOSE
-    {
     std::cout << "\n** Checking files" << std::endl;
 
-        std::cout << "Executable path is:  " << executablePath << std::endl;
+    std::cout << "Executable path is:  " << executable_path_ << std::endl;
-        std::cout << "Sample filepath:  " << fileList.back().file << 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 < t_maxAssetType; ++type)
+    for (int type = 0; type < static_cast<int>(AssetType::MAX_ASSET_TYPE); ++type)
     {
         // Comprueba si hay ficheros de ese tipo
         bool any = false;
 
-        for (auto f : fileList)
+        for (const auto &f : file_list_)
         {
-            if ((f.required) && (f.type == type))
+            if (f.required && f.type == static_cast<AssetType>(type))
             {
                 any = true;
             }
@@ -73,14 +94,13 @@ bool Asset::check()
         // Si hay ficheros de ese tipo, comprueba si existen
         if (any)
         {
-            if (verbose)
+#ifdef VERBOSE
-            {
+            std::cout << "\n>> " << getTypeName(static_cast<AssetType>(type)).c_str() << " FILES" << std::endl;
-                std::cout << "\n>> " << getTypeName(type).c_str() << " FILES" << std::endl;
+#endif
-            }
 
-            for (auto f : fileList)
+            for (const auto &f : file_list_)
             {
-                if ((f.required) && (f.type == type))
+                if (f.required && f.type == static_cast<AssetType>(type))
                 {
                     success &= checkFile(f.file);
                 }
@@ -89,91 +109,78 @@ bool Asset::check()
     }
 
 // Resultado
-    if (verbose)
+#ifdef VERBOSE
-    {
+    std::cout << (success ? "\n** All files OK.\n" : "\n** A file is missing. Exiting.\n") << std::endl;
-        if (success)
+#endif
-        {
-            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 Asset::checkFile(const std::string &path) const
 {
-    bool success = false;
+    auto success = false;
-    std::string result = "ERROR";
 
     // Comprueba si existe el fichero
-    const std::string filename = path.substr(path.find_last_of("\\/") + 1);
+    auto file = SDL_RWFromFile(path.c_str(), "rb");
-    SDL_RWops *file = SDL_RWFromFile(path.c_str(), "rb");
 
-    if (file != nullptr)
+    if (file)
     {
-        result = "OK";
         success = true;
         SDL_RWclose(file);
     }
 
-    if (verbose)
+#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(longestName + 2);
+    std::cout.width(longest_name_ + 2);
     std::cout.fill('.');
-        std::cout << filename + " ";
+    std::cout << file_name;
-        std::cout << " [" + result + "]" << std::endl;
+    std::cout << (success ? " [OK]" : " [ERROR]") << std::endl;
-    }
+#endif
 
     return success;
 }
 
 // Devuelve el nombre del tipo de recurso
-std::string Asset::getTypeName(int type)
+std::string Asset::getTypeName(AssetType type) const
 {
     switch (type)
     {
-    case t_bitmap:
+    case AssetType::BITMAP:
         return "BITMAP";
         break;
 
-    case t_music:
+    case AssetType::MUSIC:
         return "MUSIC";
         break;
 
-    case t_sound:
+    case AssetType::SOUND:
         return "SOUND";
         break;
 
-    case t_font:
+    case AssetType::FONT:
         return "FONT";
         break;
 
-    case t_lang:
+    case AssetType::LANG:
         return "LANG";
         break;
 
-    case t_data:
+    case AssetType::DATA:
         return "DATA";
         break;
 
-    case t_animation:
+    case AssetType::ANIMATION:
         return "ANIMATION";
         break;
 
-    case t_palette:
+    case AssetType::PALETTE:
         return "PALETTE";
         break;
 
-    case t_item:
+    case AssetType::ITEM:
         return "ITEM";
         break;
 
@@ -183,18 +190,12 @@ std::string Asset::getTypeName(int type)
     }
 }
 
-// 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> Asset::getListByType(AssetType type) const
 {
     std::vector<std::string> list;
 
-    for (auto f : fileList)
+    for (auto f : file_list_)
     {
         if (f.type == type)
         {

source/asset.h

@@ -1,64 +1,74 @@
 #pragma once
 
-#include <SDL2/SDL.h>
+#include <string> // for string, basic_string
-#include <string>
+#include <vector> // for vector
-#include <vector>
 
-enum assetType
+enum class AssetType : int
 {
-	t_bitmap,
+	BITMAP,
-	t_music,
+	MUSIC,
-	t_sound,
+	SOUND,
-	t_font,
+	FONT,
-	t_lang,
+	LANG,
-	t_data,
+	DATA,
-	t_animation,
+	ANIMATION,
-	t_palette,
+	PALETTE,
-	t_item,
+	ITEM,
-	t_maxAssetType
+	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 item_t
+	struct AssetItem
 	{
 		std::string file;	 // Ruta del fichero desde la raiz del directorio
-		enum assetType type; // Indica el tipo de recurso
+		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
+	int longest_name_;				   // Contiene la longitud del nombre de fichero mas largo
-	std::vector<item_t> fileList; // Listado con todas las rutas a los ficheros
+	std::vector<AssetItem> file_list_; // Listado con todas las rutas a los ficheros
-	std::string executablePath;	  // Ruta al ejecutable
+	std::string executable_path_;	   // Ruta al ejecutable
-	bool verbose;				  // Indica si ha de mostrar información por pantalla
 
 	// Comprueba que existe un fichero
-	bool checkFile(std::string executablePath);
+	bool checkFile(const std::string &path) const;
 
 	// Devuelve el nombre del tipo de recurso
-	std::string getTypeName(int type);
+	std::string getTypeName(AssetType type) const;
+
+	// Constructor
+	explicit Asset(const std::string &executable_path);
+
+	// Destructor
+	~Asset() = default;
 
 public:
-	// Constructor
+	// [SINGLETON] Crearemos el objeto screen con esta función estática
-	Asset(std::string path);
+	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(std::string file, enum assetType type, bool required = true, bool absolute = false);
+	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(std::string text);
+	std::string get(const std::string &text) const;
 
 	// Comprueba que existen todos los elementos
-	bool check();
+	bool check() const;
-
-	// 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);
+	std::vector<std::string> getListByType(AssetType type) const;
 };

source/background.cpp

@@ -1,179 +1,170 @@
 #include "background.h"
-#include "param.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)
+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;
-
-    // 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;
+    gradient_number_ = 0;
-    alpha = 0;
+    alpha_ = 0;
-    cloudsSpeed = 0;
+    clouds_speed_ = 0;
-    transition = 0;
+    transition_ = 0;
-    counter = 0;
+    counter_ = 0;
 
-    rect = {0, 0, gradientsTexture->getWidth() / 2, gradientsTexture->getHeight() / 2};
+    rect_ = {0, 0, gradients_texture_->getWidth() / 2, gradients_texture_->getHeight() / 2};
-    srcRect = {0, 0, 320, 240};
+    src_rect_ = {0, 0, 320, 240};
-    dstRect = {0, 0, 320, 240};
+    dst_rect_ = {0, 0, 320, 240};
 
-    base = rect.h;
+    base_ = rect_.h;
-    color = {param.background.attenuateColor.r, param.background.attenuateColor.g, param.background.attenuateColor.b};
+    color_ = {param.background.attenuate_color.r, param.background.attenuate_color.g, param.background.attenuate_color.b};
-    alphaColorText = alphaColorTextTemp = param.background.attenuateAlpha;
+    alpha_color_text_ = alpha_color_text_temp_ = param.background.attenuate_alpha;
 
-    gradientRect[0] = {0, 0, rect.w, rect.h};
+    gradient_rect_[0] = {0, 0, rect_.w, rect_.h};
-    gradientRect[1] = {rect.w, 0, rect.w, rect.h};
+    gradient_rect_[1] = {rect_.w, 0, rect_.w, rect_.h};
-    gradientRect[2] = {0, rect.h, rect.w, rect.h};
+    gradient_rect_[2] = {0, rect_.h, rect_.w, rect_.h};
-    gradientRect[3] = {rect.w, 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 top_clouds_texture_height = top_clouds_texture_->getHeight() / 4;
-    const int bottomCloudsTextureHeight = bottomCloudsTexture->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};
+        top_clouds_rect_[i] = {0, i * top_clouds_texture_height, top_clouds_texture_->getWidth(), top_clouds_texture_height};
-        bottomCloudsRect[i] = {0, i * bottomCloudsTextureHeight, bottomCloudsTexture->getWidth(), bottomCloudsTextureHeight};
+        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 top_clouds_y = base_ - 165;
-    const int bottomClouds_y = base - 101;
+    const int bottom_clouds_y = base_ - 101;
-    const float topCloudsSpeed = 0.1f;
+    constexpr float top_clouds_speed = 0.1f;
-    const float bottomCloudsSpeed = 0.05f;
+    constexpr float bottom_clouds_speed = 0.05f;
-    topCloudsSprite_A = new MovingSprite(0, topClouds_y, rect.w, topCloudsTexture->getHeight(), -topCloudsSpeed, 0.0f, 0.0f, 0.0f, topCloudsTexture);
+    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_);
-    topCloudsSprite_B = new MovingSprite(rect.w, topClouds_y, rect.w, topCloudsTexture->getHeight(), -topCloudsSpeed, 0.0f, 0.0f, 0.0f, topCloudsTexture);
+    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);
+    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_);
-    bottomCloudsSprite_B = new MovingSprite(rect.w, bottomClouds_y, rect.w, bottomCloudsTexture->getHeight(), -bottomCloudsSpeed, 0.0f, 0.0f, 0.0f, bottomCloudsTexture);
+    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);
+    buildings_sprite_ = std::make_unique<Sprite>(0, 0, buildings_texture_->getWidth(), buildings_texture_->getHeight(), buildings_texture_);
-    gradientSprite = new Sprite(0, 0, rect.w, rect.h, gradientsTexture);
+    gradient_sprite_ = std::make_unique<Sprite>(0, 0, rect_.w, rect_.h, gradients_texture_);
-    grassSprite = new Sprite(0, 0, grassTexture->getWidth(), grassTexture->getHeight() / 2, grassTexture);
+    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());
+    top_clouds_sprite_a_->setSpriteClip(0, 0, top_clouds_texture_->getWidth(), top_clouds_texture_->getHeight());
-    topCloudsSprite_B->setSpriteClip(0, 0, topCloudsTexture->getWidth(), topCloudsTexture->getHeight());
+    top_clouds_sprite_b_->setSpriteClip(0, 0, top_clouds_texture_->getWidth(), top_clouds_texture_->getHeight());
-    bottomCloudsSprite_A->setSpriteClip(0, 0, bottomCloudsTexture->getWidth(), bottomCloudsTexture->getHeight());
+    bottom_clouds_sprite_a_->setSpriteClip(0, 0, bottom_clouds_texture_->getWidth(), bottom_clouds_texture_->getHeight());
-    bottomCloudsSprite_B->setSpriteClip(0, 0, bottomCloudsTexture->getWidth(), bottomCloudsTexture->getHeight());
+    bottom_clouds_sprite_b_->setSpriteClip(0, 0, bottom_clouds_texture_->getWidth(), bottom_clouds_texture_->getHeight());
-    buildingsSprite->setPosY(base - buildingsSprite->getHeight());
+    buildings_sprite_->setPosY(base_ - buildings_sprite_->getHeight());
-    grassSprite->setPosY(base - grassSprite->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);
+    canvas_ = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
-    SDL_SetTextureBlendMode(canvas, SDL_BLENDMODE_BLEND);
+    SDL_SetTextureBlendMode(canvas_, SDL_BLENDMODE_BLEND);
 
     // Crea la textura para atenuar el fondo
-    colorTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
+    color_texture_ = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
-    SDL_SetTextureBlendMode(colorTexture, SDL_BLENDMODE_BLEND);
+    SDL_SetTextureBlendMode(color_texture_, SDL_BLENDMODE_BLEND);
-    setColor(color);
+    setColor(color_);
-    SDL_SetTextureAlphaMod(colorTexture, alphaColorText);
+    SDL_SetTextureAlphaMod(color_texture_, alpha_color_text_);
 }
 
 // Destructor
 Background::~Background()
 {
-    delete buildingsTexture;
+    SDL_DestroyTexture(canvas_);
-    delete topCloudsTexture;
+    SDL_DestroyTexture(color_texture_);
-    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);
 }
 
 // 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
+    // Calcula el valor de alpha_
-    alpha = std::max((255 - (int)(255 * transition)), 0);
+    alpha_ = std::max((255 - (int)(255 * transition_)), 0);
 
     // Incrementa el contador
-    counter++;
+    counter_++;
 
+    // Compone todos los elementos del fondo en la textura
     fillCanvas();
 }
 
 // Dibuja el gradiente de fondo
 void Background::renderGradient()
 {
-    // Dibuja el gradiente 2
+    // Dibuja el gradiente de detras
-    gradientsTexture->setAlpha(255);
+    gradients_texture_->setAlpha(255);
-    gradientSprite->setSpriteClip(gradientRect[(gradientNumber + 1) % 4]);
+    gradient_sprite_->setSpriteClip(gradient_rect_[(gradient_number_ + 1) % 4]);
-    gradientSprite->render();
+    gradient_sprite_->render();
 
-    // Dibuja el gradiente 1 con una opacidad cada vez menor
+    // Dibuja el gradiente de delante con una opacidad cada vez menor
-    gradientsTexture->setAlpha(alpha);
+    gradients_texture_->setAlpha(alpha_);
-    gradientSprite->setSpriteClip(gradientRect[gradientNumber]);
+    gradient_sprite_->setSpriteClip(gradient_rect_[gradient_number_]);
-    gradientSprite->render();
+    gradient_sprite_->render();
 }
 
 // Dibuja las nubes de arriba
 void Background::renderTopClouds()
 {
-    // Dibuja el primer conjunto de nubes
+    // Dibuja el primer conjunto de nubes, las de detras
-    topCloudsTexture->setAlpha(255);
+    top_clouds_texture_->setAlpha(255);
-    topCloudsSprite_A->setSpriteClip(topCloudsRect[(gradientNumber + 1) % 4]);
+    top_clouds_sprite_a_->setSpriteClip(top_clouds_rect_[(gradient_number_ + 1) % 4]);
-    topCloudsSprite_A->render();
+    top_clouds_sprite_b_->setSpriteClip(top_clouds_rect_[(gradient_number_ + 1) % 4]);
-    topCloudsSprite_B->setSpriteClip(topCloudsRect[(gradientNumber + 1) % 4]);
+    top_clouds_sprite_a_->render();
-    topCloudsSprite_B->render();
+    top_clouds_sprite_b_->render();
 
-    // Dibuja el segundo conjunto de nubes
+    // Dibuja el segundo conjunto de nubes, las de delante
-    topCloudsTexture->setAlpha(alpha);
+    top_clouds_texture_->setAlpha(alpha_);
-    topCloudsSprite_A->setSpriteClip(topCloudsRect[gradientNumber]);
+    top_clouds_sprite_a_->setSpriteClip(top_clouds_rect_[gradient_number_]);
-    topCloudsSprite_A->render();
+    top_clouds_sprite_b_->setSpriteClip(top_clouds_rect_[gradient_number_]);
-    topCloudsSprite_B->setSpriteClip(topCloudsRect[gradientNumber]);
+    top_clouds_sprite_a_->render();
-    topCloudsSprite_B->render();
+    top_clouds_sprite_b_->render();
 }
 
 // Dibuja las nubes de abajo
 void Background::renderBottomClouds()
 {
-    // Dibuja el primer conjunto de nubes
+    // Dibuja el primer conjunto de nubes, las de detras
-    bottomCloudsTexture->setAlpha(255);
+    bottom_clouds_texture_->setAlpha(255);
-    bottomCloudsSprite_A->setSpriteClip(bottomCloudsRect[(gradientNumber + 1) % 4]);
+    bottom_clouds_sprite_a_->setSpriteClip(bottom_clouds_rect_[(gradient_number_ + 1) % 4]);
-    bottomCloudsSprite_A->render();
+    bottom_clouds_sprite_b_->setSpriteClip(bottom_clouds_rect_[(gradient_number_ + 1) % 4]);
-    bottomCloudsSprite_B->setSpriteClip(bottomCloudsRect[(gradientNumber + 1) % 4]);
+    bottom_clouds_sprite_a_->render();
-    bottomCloudsSprite_B->render();
+    bottom_clouds_sprite_b_->render();
 
-    // Dibuja el segundo conjunto de nubes
+    // Dibuja el segundo conjunto de nubes, las de delante
-    bottomCloudsTexture->setAlpha(alpha);
+    bottom_clouds_texture_->setAlpha(alpha_);
-    bottomCloudsSprite_A->setSpriteClip(bottomCloudsRect[gradientNumber]);
+    bottom_clouds_sprite_a_->setSpriteClip(bottom_clouds_rect_[gradient_number_]);
-    bottomCloudsSprite_A->render();
+    bottom_clouds_sprite_b_->setSpriteClip(bottom_clouds_rect_[gradient_number_]);
-    bottomCloudsSprite_B->setSpriteClip(bottomCloudsRect[gradientNumber]);
+    bottom_clouds_sprite_a_->render();
-    bottomCloudsSprite_B->render();
+    bottom_clouds_sprite_b_->render();
 }
 
 // Compone todos los elementos del fondo en la textura
 void Background::fillCanvas()
 {
     // Cambia el destino del renderizador
-    SDL_Texture *temp = SDL_GetRenderTarget(renderer);
+    auto temp = SDL_GetRenderTarget(renderer_);
-    SDL_SetRenderTarget(renderer, canvas);
+    SDL_SetRenderTarget(renderer_, canvas_);
 
     // Dibuja el gradiente 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();
+    buildings_texture_->reLoad();
-    topCloudsTexture->reLoad();
+    top_clouds_texture_->reLoad();
-    bottomCloudsTexture->reLoad();
+    bottom_clouds_texture_->reLoad();
-    grassTexture->reLoad();
+    grass_texture_->reLoad();
-    gradientsTexture->reLoad();
+    gradients_texture_->reLoad();
 }
 
 // Ajusta el valor de la variable
 void Background::setCloudsSpeed(float value)
 {
-    cloudsSpeed = value;
+    clouds_speed_ = value;
 }
 
 // Ajusta el valor de la variable
 void Background::setGradientNumber(int value)
 {
-    gradientNumber = value % 4;
+    gradient_number_ = value % 4;
 }
 
 // Ajusta el valor de la variable
 void Background::setTransition(float value)
 {
-    value = std::min(value, 1.0f);
+    transition_ = std::clamp(value, 0.0f, 1.0f);
-    value = std::max(value, 0.0f);
-    transition = value;
 }
 
 // Establece la posición del objeto
 void Background::setPos(SDL_Rect 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;
+    src_rect_.x = 0;
-    this->srcRect.y = rect.h - pos.h;
+    src_rect_.y = rect_.h - pos.h;
-    this->srcRect.w = pos.w;
+    src_rect_.w = pos.w;
-    this->srcRect.h = pos.h;
+    src_rect_.h = pos.h;
 }
 
 // Ajusta el valor de la variable
 void Background::setSrcRect(SDL_Rect value)
 {
-    srcRect = value;
+    src_rect_ = value;
 }
 
 // Ajusta el valor de la variable
 void Background::setDstRect(SDL_Rect value)
 {
-    dstRect = value;
+    dst_rect_ = value;
 }
 
-// Establece el color de atenuación
+// Establece el color_ de atenuación
-void Background::setColor(color_t color)
+void Background::setColor(Color color)
 {
-    this->color = color;
+    color_ = color;
 
     // Colorea la textura
-    SDL_Texture *temp = SDL_GetRenderTarget(renderer);
+    auto temp = SDL_GetRenderTarget(renderer_);
-    SDL_SetRenderTarget(renderer, colorTexture);
+    SDL_SetRenderTarget(renderer_, color_texture_);
 
-    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 255);
+    SDL_SetRenderDrawColor(renderer_, color_.r, color_.g, color_.b, 255);
-    SDL_RenderClear(renderer);
+    SDL_RenderClear(renderer_);
 
-    SDL_SetRenderTarget(renderer, temp);
+    SDL_SetRenderTarget(renderer_, temp);
 }
 
 // Establece la transparencia de la atenuación
 void Background::setAlpha(int alpha)
 {
     // Evita que se asignen valores fuera de rango
-    alpha = std::min(alpha, 255);
+    alpha_ = std::clamp(alpha, 0, 255);
-    alpha = std::max(alpha, 0);
 
-    // Guarda el valor actual
+    // Guarda el valor actual y establece el nuevo valor
-    alphaColorTextTemp = alphaColorText;
+    alpha_color_text_temp_ = alpha_color_text_;
-
+    alpha_color_text_ = alpha_;
-    // Establece el nuevo valor
-    alphaColorText = alpha;
 }
 
-// Actualiza el valor de alpha
+// Actualiza el valor de alpha_
 void Background::updateAlphaColorText()
 {
-    if (alphaColorText == alphaColorTextTemp)
+    if (alpha_color_text_ == alpha_color_text_temp_)
     {
         return;
     }
     else
     {
-        alphaColorText > alphaColorTextTemp ? alphaColorTextTemp++ : alphaColorTextTemp--;
+        alpha_color_text_ > alpha_color_text_temp_ ? ++alpha_color_text_temp_ : --alpha_color_text_temp_;
-        SDL_SetTextureAlphaMod(colorTexture, alphaColorTextTemp);
+        SDL_SetTextureAlphaMod(color_texture_, alpha_color_text_temp_);
     }
 }
 
@@ -305,35 +291,35 @@ void Background::updateAlphaColorText()
 void Background::updateClouds()
 {
     // Aplica la velocidad calculada a las nubes
-    topCloudsSprite_A->setVelX(cloudsSpeed);
+    top_clouds_sprite_a_->setVelX(clouds_speed_);
-    topCloudsSprite_B->setVelX(cloudsSpeed);
+    top_clouds_sprite_b_->setVelX(clouds_speed_);
-    bottomCloudsSprite_A->setVelX(cloudsSpeed / 2);
+    bottom_clouds_sprite_a_->setVelX(clouds_speed_ / 2);
-    bottomCloudsSprite_B->setVelX(cloudsSpeed / 2);
+    bottom_clouds_sprite_b_->setVelX(clouds_speed_ / 2);
 
     // Mueve las nubes
-    topCloudsSprite_A->move();
+    top_clouds_sprite_a_->move();
-    topCloudsSprite_B->move();
+    top_clouds_sprite_b_->move();
-    bottomCloudsSprite_A->move();
+    bottom_clouds_sprite_a_->move();
-    bottomCloudsSprite_B->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 <SDL2/SDL_rect.h>    // for SDL_Rect
-#include "asset.h"
+#include <SDL2/SDL_render.h>  // for SDL_Renderer, SDL_Texture
-#include "movingsprite.h"
+#include <memory>             // for unique_ptr, shared_ptr
-#include "utils.h"
+#include "utils.h"            // for Color
+class MovingSprite;
+class Sprite;
+class Texture;
 
 /*
     Esta clase es la encargada de dibujar el fondo que aparece durante la sección
@@ -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,43 +50,42 @@ class Background
 {
 private:
   // Objetos y punteros
-  SDL_Renderer *renderer; // El renderizador de la ventana
+  SDL_Renderer *renderer_; // El renderizador de la ventana
-  Asset *asset;           // Objeto que gestiona todos los ficheros de recursos
 
-  Texture *buildingsTexture;    // Textura con los edificios de fondo
+  std::shared_ptr<Texture> buildings_texture_;     // Textura con los edificios de fondo
-  Texture *topCloudsTexture;    // Textura con las nubes de fondo
+  std::shared_ptr<Texture> top_clouds_texture_;    // Textura con las nubes de fondo
-  Texture *bottomCloudsTexture; // Textura con las nubes de fondo
+  std::shared_ptr<Texture> bottom_clouds_texture_; // Textura con las nubes de fondo
-  Texture *grassTexture;        // Textura con la hierba del suelo
+  std::shared_ptr<Texture> grass_texture_;         // Textura con la hierba del suelo
-  Texture *gradientsTexture;    // Textura con los diferentes colores de fondo del juego
+  std::shared_ptr<Texture> gradients_texture_;     // Textura con los diferentes colores de fondo del juego
 
-  MovingSprite *topCloudsSprite_A;    // Sprite para las nubes superiores
+  std::unique_ptr<MovingSprite> top_clouds_sprite_a_;    // Sprite para las nubes superiores
-  MovingSprite *topCloudsSprite_B;    // Sprite para las nubes superiores
+  std::unique_ptr<MovingSprite> top_clouds_sprite_b_;    // Sprite para las nubes superiores
-  MovingSprite *bottomCloudsSprite_A; // Sprite para las nubes inferiores
+  std::unique_ptr<MovingSprite> bottom_clouds_sprite_a_; // Sprite para las nubes inferiores
-  MovingSprite *bottomCloudsSprite_B; // Sprite para las nubes inferiores
+  std::unique_ptr<MovingSprite> bottom_clouds_sprite_b_; // Sprite para las nubes inferiores
 
-  Sprite *buildingsSprite; // Sprite con los edificios de fondo
+  std::unique_ptr<Sprite> buildings_sprite_; // Sprite con los edificios de fondo
-  Sprite *gradientSprite;  // Sprite con los graficos del degradado de color de fondo
+  std::unique_ptr<Sprite> gradient_sprite_;  // Sprite con los graficos del degradado de color de fondo
-  Sprite *grassSprite;     // Sprite para la hierba
+  std::unique_ptr<Sprite> grass_sprite_;     // Sprite para la hierba
 
-  SDL_Texture *canvas;       // Textura para componer el fondo
+  SDL_Texture *canvas_;        // Textura para componer el fondo
-  SDL_Texture *colorTexture; // Textura para atenuar el fondo
+  SDL_Texture *color_texture_; // Textura para atenuar el fondo
 
   // Variables
-  SDL_Rect gradientRect[4];     // Vector con las coordenadas de los 4 degradados para el cielo
+  SDL_Rect gradient_rect_[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 top_clouds_rect_[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
+  SDL_Rect bottom_clouds_rect_[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 gradient_number_;            // Indica el número de degradado de fondo que se va a dibujar
-  int alpha;                    // Transparencia entre los dos degradados
+  int alpha_;                      // Transparencia entre los dos degradados
-  float cloudsSpeed;            // Velocidad a la que se desplazan las nubes
+  float clouds_speed_;             // Velocidad a la que se desplazan las nubes
-  float transition;             // Nivel de transición del fondo 0..1
+  float transition_;               // Nivel de transición del fondo 0..1
-  int counter;                  // Contador interno
+  int counter_;                    // Contador interno
-  SDL_Rect rect;                // Tamaño del objeto fondo
+  SDL_Rect rect_;                  // Tamaño del objeto fondo
-  SDL_Rect srcRect;             // Parte del objeto fondo que se va a dibujará en pantalla
+  SDL_Rect src_rect_;              // 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
+  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
+  int base_;                       // Linea de fondo coincidente con el area inferior de la zona de juego
-  color_t color;                // Color para atenuar el fondo
+  Color color_;                    // Color para atenuar el fondo
-  int alphaColorText;           // Alpha para atenuar el fondo
+  int alpha_color_text_;           // Alpha para atenuar el fondo
-  int alphaColorTextTemp;       // Valor temporal para hacer la transición de alpha
+  int alpha_color_text_temp_;      // Valor temporal para hacer la transición de alpha
 
   // Dibuja el gradiente de fondo
   void renderGradient();
@@ -105,7 +107,7 @@ private:
 
 public:
   // Constructor
-  Background(SDL_Renderer *renderer, Asset *asset);
+  explicit Background(SDL_Renderer *renderer);
 
   // Destructor
   ~Background();
@@ -138,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 <SDL2/SDL_stdinc.h> // for Uint8, Uint16, Uint32
-#include "animatedsprite.h"
+#include <memory>			 // for shared_ptr, unique_ptr
-#include "utils.h"
+#include <string>			 // for string
-#include <sstream>
+#include <vector>			 // for vector
-#include <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
+constexpr int BALLOON_1 = 1;
-#define BALLOON_2 2
+constexpr int BALLOON_2 = 2;
-#define BALLOON_3 3
+constexpr int BALLOON_3 = 3;
-#define BALLOON_4 4
+constexpr int BALLOON_4 = 4;
-#define HEXAGON_1 5
+constexpr int HEXAGON_1 = 5;
-#define HEXAGON_2 6
+constexpr int HEXAGON_2 = 6;
-#define HEXAGON_3 7
+constexpr int HEXAGON_3 = 7;
-#define HEXAGON_4 8
+constexpr int HEXAGON_4 = 8;
-#define POWER_BALL 9
+constexpr int POWER_BALL = 9;
 
 // Puntos de globo
-#define BALLOON_SCORE_1 50
+constexpr int BALLOON_SCORE_1 = 50;
-#define BALLOON_SCORE_2 100
+constexpr int BALLOON_SCORE_2 = 100;
-#define BALLOON_SCORE_3 200
+constexpr int BALLOON_SCORE_3 = 200;
-#define BALLOON_SCORE_4 400
+constexpr int BALLOON_SCORE_4 = 400;
 
 // Tamaños de globo
-#define BALLOON_SIZE_1 1
+constexpr int BALLOON_SIZE_1 = 1;
-#define BALLOON_SIZE_2 2
+constexpr int BALLOON_SIZE_2 = 2;
-#define BALLOON_SIZE_3 3
+constexpr int BALLOON_SIZE_3 = 3;
-#define BALLOON_SIZE_4 4
+constexpr int BALLOON_SIZE_4 = 4;
 
 // Clases de globo
-#define BALLOON_CLASS 0
+constexpr int BALLOON_CLASS = 0;
-#define HEXAGON_CLASS 1
+constexpr int HEXAGON_CLASS = 1;
 
 // Velocidad del globo
-#define BALLOON_VELX_POSITIVE 0.7f
+constexpr float BALLOON_VELX_POSITIVE = 0.7f;
-#define BALLOON_VELX_NEGATIVE -0.7f
+constexpr float BALLOON_VELX_NEGATIVE = -0.7f;
 
 // Indice para las animaciones de los globos
-#define BALLOON_MOVING_ANIMATION 0
+constexpr int BALLOON_MOVING_ANIMATION = 0;
-#define BALLOON_POP_ANIMATION 1
+constexpr int BALLOON_POP_ANIMATION = 1;
-#define BALLOON_BORN_ANIMATION 2
+constexpr int BALLOON_BORN_ANIMATION = 2;
 
 // Cantidad posible de globos
-#define MAX_BALLOONS 100
+constexpr int MAX_BALLOONS = 100;
 
 // Velocidades a las que se mueven los globos
-#define BALLOON_SPEED_1 0.60f
+constexpr float BALLOON_SPEED_1 = 0.60f;
-#define BALLOON_SPEED_2 0.70f
+constexpr float BALLOON_SPEED_2 = 0.70f;
-#define BALLOON_SPEED_3 0.80f
+constexpr float BALLOON_SPEED_3 = 0.80f;
-#define BALLOON_SPEED_4 0.90f
+constexpr float BALLOON_SPEED_4 = 0.90f;
-#define BALLOON_SPEED_5 1.00f
+constexpr float BALLOON_SPEED_5 = 1.00f;
 
 // Tamaño de los globos
-#define BALLOON_WIDTH_1 10
+constexpr int BALLOON_WIDTH_1 = 10;
-#define BALLOON_WIDTH_2 16
+constexpr int BALLOON_WIDTH_2 = 16;
-#define BALLOON_WIDTH_3 26
+constexpr int BALLOON_WIDTH_3 = 26;
-#define BALLOON_WIDTH_4 46
+constexpr int BALLOON_WIDTH_4 = 46;
 
 // PowerBall
-#define POWERBALL_SCREENPOWER_MINIMUM 10
+constexpr int POWERBALL_SCREENPOWER_MINIMUM = 10;
-#define POWERBALL_COUNTER 8
+constexpr int POWERBALL_COUNTER = 8;
 
 // Clase Balloon
 class Balloon
 {
 private:
 	// Estructura para las variables para el efecto de los rebotes
-	struct bouncing
+	struct Bouncing
 	{
 		bool enabled;		  // Si el efecto está activo
 		Uint8 counter;		  // Countador para el efecto
@@ -84,37 +86,37 @@ private:
 	};
 
 	// Objetos y punteros
-	AnimatedSprite *sprite; // Sprite del objeto globo
+	std::unique_ptr<AnimatedSprite> sprite_; // Sprite del objeto globo
 
 	// Variables
-	float posX;				   // Posición en el eje X
+	float pos_x_;				  // Posición en el eje X
-	float posY;				   // Posición en el eje Y
+	float pos_y_;				  // Posición en el eje Y
-	Uint8 width;			   // Ancho
+	Uint8 width_;				  // Ancho
-	Uint8 height;			   // Alto
+	Uint8 height_;				  // Alto
-	float velX;				   // Velocidad en el eje X. Cantidad de pixeles a desplazarse
+	float vel_x_;				  // Velocidad en el eje X. Cantidad de pixeles a desplazarse
-	float velY;				   // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
+	float vel_y_;				  // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
-	float gravity;			   // Aceleración en el eje Y. Modifica la velocidad
+	float gravity_;				  // Aceleración en el eje Y. Modifica la velocidad
-	float defaultVelY;		   // Velocidad inicial que tienen al rebotar contra el suelo
+	float default_vel_y_;		  // Velocidad inicial que tienen al rebotar contra el suelo
-	float maxVelY;			   // Máxima velocidad que puede alcanzar el objeto en el eje Y
+	float max_vel_y_;			  // Máxima velocidad que puede alcanzar el objeto en el eje Y
-	bool beingCreated;		   // Indica si el globo se está creando
+	bool being_created_;		  // Indica si el globo se está creando
-	bool blinking;			   // Indica si el globo está intermitente
+	bool blinking_;				  // Indica si el globo está intermitente
-	bool enabled;			   // Indica si el globo esta activo
+	bool enabled_;				  // Indica si el globo esta activo
-	bool invulnerable;		   // Indica si el globo es invulnerable
+	bool invulnerable_;			  // Indica si el globo es invulnerable
-	bool stopped;			   // Indica si el globo está parado
+	bool stopped_;				  // Indica si el globo está parado
-	bool visible;			   // Indica si el globo es visible
+	bool visible_;				  // Indica si el globo es visible
-	circle_t collider;		   // Circulo de colisión del objeto
+	Circle collider_;			  // Circulo de colisión del objeto
-	Uint16 creationCounter;	   // Temporizador para controlar el estado "creandose"
+	Uint16 creation_counter_;	  // Temporizador para controlar el estado "creandose"
-	Uint16 creationCounterIni; // Valor inicial para el temporizador para controlar el estado "creandose"
+	Uint16 creation_counter_ini_; // Valor inicial para el temporizador para controlar el estado "creandose"
-	Uint16 score;			   // Puntos que da el globo al ser destruido
+	Uint16 score_;				  // Puntos que da el globo al ser destruido
-	Uint16 stoppedCounter;	   // Contador para controlar el estado "parado"
+	Uint16 stopped_counter_;	  // Contador para controlar el estado "parado"
-	Uint8 kind;				   // Tipo de globo
+	Uint8 kind_;				  // Tipo de globo
-	Uint8 menace;			   // Cantidad de amenaza que genera el globo
+	Uint8 menace_;				  // Cantidad de amenaza que genera el globo
-	Uint32 counter;			   // Contador interno
+	Uint32 counter_;			  // Contador interno
-	float travelY;			   // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
+	float travel_y_;			  // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
-	float speed;			   // Velocidad a la que se mueven los globos
+	float speed_;				  // Velocidad a la que se mueven los globos
-	Uint8 size;				   // Tamaño del globo
+	Uint8 size_;				  // Tamaño del globo
-	Uint8 power;			   // Cantidad de poder que alberga el globo
+	Uint8 power_;				  // Cantidad de poder que alberga el globo
-	bouncing bouncing;		   // Contiene las variables para el efecto de rebote
+	Bouncing bouncing_;			  // Contiene las variables para el efecto de rebote
 
 	// Alinea el circulo de colisión con la posición del objeto globo
 	void updateColliders();
@@ -139,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);
+	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);
@@ -163,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
+    vel_x_ = (kind_ == BulletType::LEFT) ? BULLET_VELX_LEFT : (kind_ == BulletType::RIGHT) ? BULLET_VELX_RIGHT
-	this->playArea = playArea;
+                                                                                           : 0;
 
-	// Posición inicial del objeto
+    auto sprite_offset = powered_up ? 3 : 0;
-	posX = x;
+    auto kind_index = static_cast<int>(kind);
-	posY = y;
+    sprite_->setSpriteClip((kind_index + sprite_offset) * width_, 0, sprite_->getWidth(), sprite_->getHeight());
 
-	// Alto y ancho del objeto
+    collider_.r = width_ / 2;
-	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();
 }
 
-// Destructor
+// Implementación de render (llama al render del sprite_)
-Bullet::~Bullet()
-{
-	delete sprite;
-}
-
-// Pinta el objeto en pantalla
 void Bullet::render()
 {
-	sprite->render();
+    sprite_->render();
 }
 
-// Actualiza la posición y estado del objeto en horizontal
+// Implementación del movimiento usando BulletMoveStatus
-Uint8 Bullet::move()
+BulletMoveStatus Bullet::move()
 {
-	// Variable con el valor de retorno
+    pos_x_ += vel_x_;
-	Uint8 msg = BULLET_MOVE_OK;
+    if (pos_x_ < param.game.play_area.rect.x - width_ || pos_x_ > play_area_->w)
-
-	// Mueve el objeto a su nueva posición
-	posX += velX;
-
-	// Si el objeto se sale del area de juego por los laterales
-	if ((posX < PLAY_AREA_LEFT - width) || (posX > playArea->w))
     {
-		// Se deshabilita
+        disable();
-		kind = NO_KIND;
+        return BulletMoveStatus::OUT;
-
-		// Mensaje de salida
-		msg = BULLET_MOVE_OUT;
     }
 
-	// Mueve el objeto a su nueva posición en vertical
+    pos_y_ += vel_y_;
-	posY += int(velY);
+    if (pos_y_ < param.game.play_area.rect.y - height_)
-
-	// Si el objeto se sale del area de juego por la parte superior
-	if (posY < PLAY_AREA_TOP - height)
     {
-		// Se deshabilita
+        disable();
-		kind = NO_KIND;
+        return BulletMoveStatus::OUT;
-
-		// Mensaje de salida
-		msg = BULLET_MOVE_OUT;
     }
 
-	// Actualiza la posición del sprite
+    sprite_->setPosX(pos_x_);
-	sprite->setPosX(posX);
+    sprite_->setPosY(pos_y_);
-	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() const
-bool Bullet::isEnabled()
 {
-	if (kind == NO_KIND)
+    return kind_ != BulletType::NONE;
-	{
-		return false;
-	}
-	else
-	{
-		return true;
-	}
 }
 
-// Deshabilita el objeto
 void Bullet::disable()
 {
-	kind = NO_KIND;
+    kind_ = BulletType::NONE;
 }
 
-// Obtiene el valor de la variable
+int Bullet::getPosX() const
-int Bullet::getPosX()
 {
-	return posX;
+    return pos_x_;
 }
 
-// Obtiene el valor de la variable
+int Bullet::getPosY() const
-int Bullet::getPosY()
 {
-	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() const
-int Bullet::getVelY()
 {
-	return velY;
+    return vel_y_;
 }
 
-// Obtiene el valor de la variable
+BulletType Bullet::getKind() const
-int Bullet::getKind()
 {
-	return kind;
+    return kind_;
 }
 
-// Obtiene el valor de la variable
+int Bullet::getOwner() const
-int Bullet::getOwner()
 {
-	return owner;
+    return owner_;
 }
 
-// Obtiene el circulo de colisión
+Circle &Bullet::getCollider()
-circle_t &Bullet::getCollider()
 {
-	return collider;
+    return collider_;
 }
 
-// Alinea el circulo de colisión con el objeto
 void Bullet::shiftColliders()
 {
-	collider.x = posX + collider.r;
+    collider_.x = pos_x_ + collider_.r;
-	collider.y = posY + collider.r;
+    collider_.y = pos_y_ + collider_.r;
 }

source/bullet.h

@@ -1,80 +1,79 @@
 #pragma once
 
-#include <SDL2/SDL.h>
+#include <SDL2/SDL_rect.h>    // for SDL_Rect
-#include "sprite.h"
+#include <SDL2/SDL_stdinc.h>  // for Uint8
-#include "utils.h"
+#include <memory>             // for shared_ptr, unique_ptr
+#include "sprite.h"           // for Sprite
+#include "utils.h"            // for Circle
+class Texture;
 
-// Tipos de bala
+// Enumeración para los diferentes tipos de balas
-#define BULLET_UP 1
+enum class BulletType
-#define BULLET_LEFT 2
+{
-#define BULLET_RIGHT 3
+	UP,
+	LEFT,
+	RIGHT,
+	NONE
+};
 
-// Tipos de retorno de la funcion move de la bala
+// Enumeración para los resultados del movimiento de la bala
-#define BULLET_MOVE_OK 0
+enum class BulletMoveStatus : Uint8
-#define BULLET_MOVE_OUT 1
+{
+	OK = 0,
+	OUT = 1
+};
 
 // Clase Bullet
 class Bullet
 {
 private:
-	// Objetos y punteros
+	std::unique_ptr<Sprite> sprite_; // Sprite con los gráficos y métodos de pintado
-	Sprite *sprite; // Sprite con los graficos y métodos de pintado
 
-	// Variables
+	int pos_x_;	   // Posición en el eje X
-	int posX;		   // Posición en el eje X
+	int pos_y_;	   // Posición en el eje Y
-	int posY;		   // Posición en el eje Y
+	Uint8 width_;  // Ancho del objeto
-	Uint8 width;	   // Ancho del objeto
+	Uint8 height_; // Alto 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
 
-	// Alinea el circulo de colisión con el objeto
+	int vel_x_; // Velocidad en el eje X
-	void shiftColliders();
+	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
+	// Obtiene la posición
-	int getPosX();
+	int getPosX() const;
+	int getPosY() const;
 
-	// Obtiene el valor de la variable
+	// Establece la posición
-	int getPosY();
-
-	// Establece el valor de la variable
 	void setPosX(int x);
-
-	// Establece el valor de la variable
 	void setPosY(int y);
 
-	// Obtiene el valor de la variable
+	// Obtiene parámetros
-	int getVelY();
+	int getVelY() const;
-
+	BulletType getKind() const;
-	// Obtiene el valor de la variable
+	int getOwner() const;
-	int getKind();
+	Circle &getCollider();
-
-	// Obtiene el valor de la variable
-	int getOwner();
-
-	// Obtiene el circulo de colisión
-	circle_t &getCollider();
 };

source/const.h

@@ -1,46 +0,0 @@
-#pragma once
-
-#include <SDL2/SDL.h>
-#include "utils.h"
-
-// Tamaño de bloque
-#define BLOCK 8
-
-// Para mejor visibilidad
-#define PLAY_AREA_LEFT 0
-#define PLAY_AREA_TOP 0
-
-// Secciones del programa
-#define SECTION_PROG_INIT 8
-#define SECTION_PROG_LOGO 0
-#define SECTION_PROG_INTRO 1
-#define SECTION_PROG_TITLE 2
-#define SECTION_PROG_GAME 3
-#define SECTION_PROG_HI_SCORE_TABLE 4
-#define SECTION_PROG_GAME_DEMO 5
-#define SECTION_PROG_INSTRUCTIONS 6
-#define SECTION_PROG_QUIT 7
-
-// Subsecciones
-#define SECTION_OPTIONS_GAME_PLAY_1P 0
-#define SECTION_OPTIONS_GAME_PLAY_2P 1
-#define SECTION_OPTIONS_TITLE_1 3
-#define SECTION_OPTIONS_TITLE_2 4
-#define SECTION_OPTIONS_QUIT_NORMAL 5
-#define SECTION_OPTIONS_QUIT_SHUTDOWN 6
-
-// Ningun tipo
-#define NO_KIND 0
-
-// Colores
-const color_t bgColor = {0x27, 0x27, 0x36};
-const color_t noColor = {0xFF, 0xFF, 0xFF};
-const color_t shdwTxtColor = {0x43, 0x43, 0x4F};
-const color_t separatorColor = {0x0D, 0x1A, 0x2B};
-const color_t scoreboardColor = {0x2E, 0x3F, 0x47};
-const color_t difficultyEasyColor = {0x4B, 0x69, 0x2F};
-const color_t difficultyNormalColor = {0xFF, 0x7A, 0x00};
-const color_t difficultyHardColor = {0x76, 0x42, 0x8A};
-const color_t flashColor = {0xFF, 0xFF, 0xFF};
-const color_t fadeColor = {0x27, 0x27, 0x36};
-const color_t orangeColor = {0xFF, 0x7A, 0x00};

source/dbgtxt.cpp

@@ -1,9 +1,12 @@
 #include "dbgtxt.h"
+#include <SDL2/SDL_rect.h>     // for SDL_Rect
+#include <SDL2/SDL_rwops.h>    // for SDL_RWFromMem
+#include <SDL2/SDL_surface.h>  // for SDL_LoadBMP_RW
 
 namespace
 {
-    SDL_Texture *dbg_tex = NULL;
+    SDL_Texture *dbg_tex = nullptr;
-    SDL_Renderer *dbg_ren = NULL;
+    SDL_Renderer *dbg_ren = nullptr;
 }
 
 void dbg_init(SDL_Renderer *renderer)

source/dbgtxt.h

@@ -1,6 +1,7 @@
 #pragma once
 
-#include <SDL2/SDL.h>
+#include <SDL2/SDL_render.h>  // for SDL_Renderer
+#include <SDL2/SDL_stdinc.h>  // for Uint8
 
 void dbg_init(SDL_Renderer *renderer);
 void dbg_print(int x, int y, const char *text, Uint8 r, Uint8 g, Uint8 b);

source/define_buttons.cpp

@@ -1,124 +1,123 @@
 #include "define_buttons.h"
-#include "param.h"
+#include <utility>    // for move
+#include "input.h"    // for Input, InputType
+#include "lang.h"     // for getText
+#include "options.h"  // for options
+#include "param.h"    // for param
+#include "section.h"  // for Name, Options, name, options
+#include "text.h"     // for Text
+#include "utils.h"    // for OptionsController, Options, Param, ParamGame
 
 // Constructor
-DefineButtons::DefineButtons(Input *input, Text *text, options_t *options, section_t *section)
+DefineButtons::DefineButtons(std::unique_ptr<Text> text_)
+    : text_(std::move(text_))
 {
     // Copia punteros a los objetos
-    this->input = input;
+    input_ = Input::get();
-    this->text = text;
-    this->options = options;
-    this->section = section;
 
     // Inicializa variables
-    enabled = false;
+    enabled_ = false;
-    x = param.game.width / 2;
+    x_ = param.game.width / 2;
-    y = param.title.pressStartPosition;
+    y_ = param.title.press_start_position;
-    indexController = 0;
+    index_controller_ = 0;
-    indexButton = 0;
+    index_button_ = 0;
 
-    buttons.clear();
+    buttons_.clear();
-    db_button_t button;
+    DefineButtonsButton button;
 
     button.label = lang::getText(95);
-    button.input = input_fire_left;
+    button.input = InputType::FIRE_LEFT;
     button.button = SDL_CONTROLLER_BUTTON_X;
-    buttons.push_back(button);
+    buttons_.push_back(button);
 
     button.label = lang::getText(96);
-    button.input = input_fire_center;
+    button.input = InputType::FIRE_CENTER;
     button.button = SDL_CONTROLLER_BUTTON_Y;
-    buttons.push_back(button);
+    buttons_.push_back(button);
 
     button.label = lang::getText(97);
-    button.input = input_fire_right;
+    button.input = InputType::FIRE_RIGHT;
     button.button = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
-    buttons.push_back(button);
+    buttons_.push_back(button);
 
     button.label = lang::getText(98);
-    button.input = input_start;
+    button.input = InputType::START;
     button.button = SDL_CONTROLLER_BUTTON_START;
-    buttons.push_back(button);
+    buttons_.push_back(button);
 
     button.label = lang::getText(99);
-    button.input = input_exit;
+    button.input = InputType::EXIT;
     button.button = SDL_CONTROLLER_BUTTON_BACK;
-    buttons.push_back(button);
+    buttons_.push_back(button);
 
-    for (int i = 0; i < input->getNumControllers(); ++i)
+    for (int i = 0; i < input_->getNumControllers(); ++i)
-    {
-        controllerNames.push_back(input->getControllerName(i));
-    }
-}
-
-// Destructor
-DefineButtons::~DefineButtons()
-{
-}
-
-// Actualiza las variables del objeto
-void DefineButtons::update()
-{
-    if (enabled)
     {
+        controller_names_.push_back(input_->getControllerName(i));
     }
 }
 
 // Dibuja el objeto en pantalla
 void DefineButtons::render()
 {
-    if (enabled)
+    if (enabled_)
     {
-        text->writeCentered(x, y - 10, lang::getText(100) + std::to_string(options->controller[indexController].playerId));
+        text_->writeCentered(x_, y_ - 10, lang::getText(100) + std::to_string(options.controller[index_controller_].player_id));
-        text->writeCentered(x, y, controllerNames[indexController]);
+        text_->writeCentered(x_, y_, controller_names_[index_controller_]);
-        text->writeCentered(x, y + 10, buttons[indexButton].label);
+        text_->writeCentered(x_, y_ + 10, buttons_[index_button_].label);
     }
 }
 
 // Comprueba el botón que se ha pulsado
 void DefineButtons::doControllerButtonDown(SDL_ControllerButtonEvent *event)
 {
-    int i = input->getJoyIndex(event->which);
+    int i = input_->getJoyIndex(event->which);
 
     // Solo pillamos botones del mando que toca
-    if (i != indexController)
+    if (i != index_controller_)
     {
         return;
     }
 
-    buttons[indexButton].button = (SDL_GameControllerButton)event->button;
+    buttons_[index_button_].button = (SDL_GameControllerButton)event->button;
     incIndexButton();
 }
 
-// Asigna los botones definidos al input
+// Asigna los botones definidos al input_
 void DefineButtons::bindButtons()
 {
-    for (int i = 0; i < (int)buttons.size(); ++i)
+    for (int i = 0; i < (int)buttons_.size(); ++i)
     {
-        input->bindGameControllerButton(indexController, buttons[i].input, buttons[i].button);
+        input_->bindGameControllerButton(index_controller_, buttons_[i].input, buttons_[i].button);
     }
 }
 
 // Comprueba las entradas
 void DefineButtons::checkInput()
 {
-    if (enabled)
+    if (enabled_)
     {
         SDL_Event event;
 
         // Comprueba los eventos que hay en la cola
         while (SDL_PollEvent(&event))
         {
-            // Evento de salida de la aplicación
+            switch (event.type)
-            if (event.type == SDL_QUIT)
             {
-                section->name = SECTION_PROG_QUIT;
+            case SDL_QUIT:
+            {
+                section::name = section::Name::QUIT;
+                section::options = section::Options::QUIT_NORMAL;
                 break;
             }
 
-            if (event.type == SDL_CONTROLLERBUTTONDOWN)
+            case SDL_CONTROLLERBUTTONDOWN:
             {
                 doControllerButtonDown(&event.cbutton);
+                break;
+            }
+
+            default:
+                break;
             }
         }
     }
@@ -127,11 +126,11 @@ void DefineButtons::checkInput()
 // Habilita el objeto
 bool DefineButtons::enable(int index)
 {
-    if (index < input->getNumControllers())
+    if (index < input_->getNumControllers())
     {
-        enabled = true;
+        enabled_ = true;
-        indexController = index;
+        index_controller_ = index;
-        indexButton = 0;
+        index_button_ = 0;
         return true;
     }
 
@@ -141,29 +140,29 @@ bool DefineButtons::enable(int index)
 // Comprueba si está habilitado
 bool DefineButtons::isEnabled()
 {
-    return enabled;
+    return enabled_;
 }
 
 // Incrementa el indice de los botones
 void DefineButtons::incIndexButton()
 {
-    indexButton++;
+    index_button_++;
 
     // Comprueba si ha finalizado
-    if (indexButton == (int)buttons.size())
+    if (index_button_ == (int)buttons_.size())
     {
-        // Asigna los botones definidos al input
+        // Asigna los botones definidos al input_
         bindButtons();
 
         // Guarda los cambios en las opciones
         saveBindingsToOptions();
 
-        input->allActive(indexController);
+        //input_->allActive(index_controller_);
 
         // Reinicia variables
-        indexButton = 0;
+        index_button_ = 0;
-        indexController = 0;
+        index_controller_ = 0;
-        enabled = false;
+        enabled_ = false;
     }
 }
 
@@ -171,17 +170,17 @@ void DefineButtons::incIndexButton()
 void DefineButtons::saveBindingsToOptions()
 {
     // Modifica las opciones para colocar los valores asignados
-    options->controller[indexController].name = input->getControllerName(indexController);
+    options.controller[index_controller_].name = input_->getControllerName(index_controller_);
-    for (int j = 0; j < (int)options->controller[indexController].inputs.size(); ++j)
+    for (int j = 0; j < (int)options.controller[index_controller_].inputs.size(); ++j)
     {
-        options->controller[indexController].buttons[j] = input->getControllerBinding(indexController, options->controller[indexController].inputs[j]);
+        options.controller[index_controller_].buttons[j] = input_->getControllerBinding(index_controller_, options.controller[index_controller_].inputs[j]);
     }
 }
 
 // Intercambia los jugadores asignados a los dos primeros mandos
 void DefineButtons::swapControllers()
 {
-    const int temp = options->controller[0].playerId;
+    const int temp = options.controller[0].player_id;
-    options->controller[0].playerId = options->controller[1].playerId;
+    options.controller[0].player_id = options.controller[1].player_id;
-    options->controller[1].playerId = temp;
+    options.controller[1].player_id = temp;
 }

source/define_buttons.h

@@ -1,15 +1,18 @@
 #pragma once
 
-#include <SDL2/SDL.h>
+#include <SDL2/SDL_events.h>          // for SDL_ControllerButtonEvent
-#include "input.h"
+#include <SDL2/SDL_gamecontroller.h>  // for SDL_GameControllerButton
-#include "text.h"
+#include <memory>                     // for shared_ptr, unique_ptr
-#include "const.h"
+#include <string>                     // for string
-#include "lang.h"
+#include <vector>                     // for vector
+class Input;
+class Text;
+enum class InputType : int;
 
-struct db_button_t
+struct DefineButtonsButton
 {
     std::string label;               // Texto en pantalla para el botón
-    inputs_e input;                  // Input asociado
+    InputType input;                 // Input asociado
     SDL_GameControllerButton button; // Botón del mando correspondiente
 };
 
@@ -18,19 +21,17 @@ class DefineButtons
 {
 private:
     // Objetos
-    Input *input; // Objeto pata gestionar la entrada
+    Input *input_;               // Objeto pata gestionar la entrada
-    Text *text;   // Objeto para escribir texto
+    std::shared_ptr<Text> text_; // Objeto para escribir texto
 
     // Variables
-    options_t *options;                       // Opciones del programa
+    bool enabled_;                              // Indica si el objeto está habilitado
-    section_t *section;                       // Indicador para el bucle del titulo
+    int x_;                                     // Posición donde dibujar el texto
-    bool enabled;                             // Indica si el objeto está habilitado
+    int y_;                                     // Posición donde dibujar el texto
-    int x;                                    // Posición donde dibujar el texto
+    std::vector<DefineButtonsButton> buttons_;  // Vector con las nuevas definiciones de botones/acciones
-    int y;                                    // Posición donde dibujar el texto
+    int index_controller_;                      // Indice del controlador a reasignar
-    std::vector<db_button_t> buttons;         // Vector con las nuevas definiciones de botones/acciones
+    int index_button_;                          // Indice para saber qué bot´çon se está definiendo
-    int indexController;                      // Indice del controlador a reasignar
+    std::vector<std::string> controller_names_; // Nombres de los mandos
-    int indexButton;                          // Indice para saber qué bot´çon se está definiendo
-    std::vector<std::string> controllerNames; // Nombres de los mandos
 
     // Incrementa el indice de los botones
     void incIndexButton();
@@ -46,13 +47,10 @@ private:
 
 public:
     // Constructor
-    DefineButtons(Input *input, Text *text, options_t *options, section_t *section);
+    explicit DefineButtons(std::unique_ptr<Text> text);
 
     // Destructor
-    ~DefineButtons();
+    ~DefineButtons() = default;
-
-    // Actualiza las variables del objeto
-    void update();
 
     // Dibuja el objeto en pantalla
     void render();

source/director.h

@@ -1,52 +1,29 @@
 #pragma once
 
-#include <SDL2/SDL.h>
+#include <SDL2/SDL_render.h>  // for SDL_Renderer
-#include "asset.h"
+#include <SDL2/SDL_video.h>   // for SDL_Window
-#include "input.h"
+#include <string>             // for string
-#include "jail_audio.h"
+#include <vector>             // for vector
-#include "screen.h"
+namespace lang { enum class Code : int; }
-#include "text.h"
+struct MusicFile;
-#include "utils.h"
+struct SoundFile;
-#include "const.h"
-#include "fade.h"
-#include "game.h"
-#include "intro.h"
-#include "item.h"
-#include "lang.h"
-#include "logo.h"
-#include "player.h"
-#include "title.h"
-#include "param.h"
-#include "manage_hiscore_table.h"
 
 // Textos
-#define WINDOW_CAPTION "Coffee Crisis Arcade Edition"
+constexpr char WINDOW_CAPTION[] = "Coffee Crisis Arcade Edition";
 
 class Director
 {
 private:
 	// Objetos y punteros
-	SDL_Window *window;			// La ventana donde dibujamos
+	SDL_Window *window_;		// La ventana donde dibujamos
-	SDL_Renderer *renderer;		// El renderizador de la ventana
+	SDL_Renderer *renderer_; // El renderizador de la ventana
-	Screen *screen;				// Objeto encargado de dibujar en pantalla
-	Logo *logo;					// Objeto para la sección del logo
-	Intro *intro;				// Objeto para la sección de la intro
-	Title *title;				// Objeto para la sección del titulo y el menu de opciones
-	Game *game;					// Objeto para la sección del juego
-	Instructions *instructions; // Objeto para la sección de las instrucciones
-	HiScoreTable *hiScoreTable; // Objeto para mostrar las mejores puntuaciones online
-	Game *demoGame;				// Objeto para lanzar la demo del juego
-	Input *input;				// Objeto Input para gestionar las entradas
-	Asset *asset;				// Objeto que gestiona todos los ficheros de recursos
-	section_t *section;			// Sección y subsección actual del programa;
 
 	// Variables
-	options_t *options;				  // Opciones del programa
+	std::string executable_path_;	   // Path del ejecutable
-	std::string executablePath;		  // Path del ejecutable
+	std::string system_folder_;	   // Carpeta del sistema donde guardar datos
-	std::string systemFolder;		  // Carpeta del sistema donde guardar datos
+	std::string param_file_argument_; // Argumento para gestionar el fichero con los parametros del programa
-	std::string paramFileArgument;	  // Argumento para gestionar el fichero con los parametros del programa
+	std::vector<SoundFile> sounds_; // Vector con los sonidos
-	std::vector<sound_file_t> sounds; // Vector con los sonidos
+	std::vector<MusicFile> musics_; // Vector con las musicas
-	std::vector<music_file_t> musics; // Vector con las musicas
 
 	// Inicializa jail_audio
 	void initJailAudio();
@@ -58,40 +35,22 @@ private:
 	void initInput();
 
 	// Carga los parametros para configurar el juego
-	void loadParams(std::string filepath);
+	void loadParams(const std::string &file_path);
-
-	// Inicializa las opciones del programa
-	void initOptions();
-
-	// Asigna variables a partir de dos cadenas
-	bool setOptions(options_t *options, std::string var, std::string value);
 
 	// Crea el indice de ficheros
 	bool setFileList();
 
-	// Carga el fichero de configuración
-	bool loadConfigFile();
-
-	// Guarda el fichero de configuración
-	bool saveConfigFile();
-
 	// Carga los sonidos del juego
 	void loadSounds();
 
 	// Carga las musicas del juego
 	void loadMusics();
 
-	// Libera la memoria usada por los sonidos del juego
-	void deleteSounds();
-
-	// Libera la memoria usada por las músicas del juego
-	void deleteMusics();
-
 	// Comprueba los parametros del programa
-	void checkProgramArguments(int argc, char *argv[]);
+	void checkProgramArguments(int argc, const char *argv[]);
 
 	// Crea la carpeta del sistema donde guardar datos
-	void createSystemFolder(std::string folder);
+	void createSystemFolder(const std::string &folder);
 
 	// Ejecuta la sección con el logo
 	void runLogo();
@@ -114,12 +73,12 @@ private:
 	// Ejecuta el juego en modo demo
 	void runDemoGame();
 
-	// Obtiene una fichero a partir de un lang_e
+	// Obtiene una fichero a partir de un lang::Code
-	std::string getLangFile(lang::lang_e lang);
+	std::string getLangFile(lang::Code code);
 
 public:
 	// Constructor
-	Director(int argc, char *argv[]);
+	Director(int argc, const char *argv[]);
 
 	// Destructor
 	~Director();

source/enemy_formations.cpp

@@ -1,723 +0,0 @@
-#include "enemy_formations.h"
-#include "param.h"
-
-// Constructor
-EnemyFormations::EnemyFormations()
-{
-	initEnemyFormations();
-	initEnemyPools();
-	initGameStages();
-}
-
-// Destructor
-EnemyFormations::~EnemyFormations()
-{
-}
-
-// Inicializa las formaciones enemigas
-void EnemyFormations::initEnemyFormations()
-{
-	const int y4 =  - BLOCK;
-	const int x4_0 = PLAY_AREA_LEFT;
-	const int x4_100 = param.game.playArea.rect.w - BALLOON_WIDTH_4;
-
-	const int y3 =  - BLOCK;
-	const int x3_0 = PLAY_AREA_LEFT;
-	const int x3_100 = param.game.playArea.rect.w - BALLOON_WIDTH_3;
-
-	const int y2 =  - BLOCK;
-	const int x2_0 = PLAY_AREA_LEFT;
-	const int x2_100 = param.game.playArea.rect.w - BALLOON_WIDTH_2;
-
-	const int y1 =  - BLOCK;
-	const int x1_0 = PLAY_AREA_LEFT;
-	const int x1_50 = param.game.playArea.centerX - (BALLOON_WIDTH_1 / 2);
-	const int x1_100 = param.game.playArea.rect.w - BALLOON_WIDTH_1;
-
-	// Inicializa a cero las variables
-	for (int i = 0; i < NUMBER_OF_ENEMY_FORMATIONS; i++)
-	{
-		enemyFormation[i].numberOfEnemies = 0;
-		for (int j = 0; j < MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION; j++)
-		{
-			enemyFormation[i].init[j].x = 0;
-			enemyFormation[i].init[j].y = 0;
-			enemyFormation[i].init[j].velX = 0;
-			enemyFormation[i].init[j].kind = 0;
-			enemyFormation[i].init[j].creationCounter = 0;
-		}
-	}
-
-	const int creationTime = 300;
-	int incX = 0;
-	int incTime = 0;
-	int j = 0;
-
-	// #00 - Dos enemigos BALLOON4 uno a cada extremo
-	j = 0;
-	enemyFormation[j].numberOfEnemies = 2;
-	incX = x4_100;
-	incTime = 0;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x4_0 + (i * incX);
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime + (incTime * i);
-	}
-
-	// #01 - Dos enemigos BALLOON4 uno a cada cuarto. Ambos van hacia el centro
-	j = 1;
-	enemyFormation[j].numberOfEnemies = 2;
-	incX = param.game.playArea.centerX;
-	incTime = 0;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = param.game.playArea.firstQuarterX - (BALLOON_WIDTH_4 / 2) + (i * incX);
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime + (incTime * i);
-	}
-
-	// #02 - Cuatro enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
-	j = 2;
-	enemyFormation[j].numberOfEnemies = 4;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x2_0 + (i * incX);
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #03 - Cuatro enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
-	j = 3;
-	enemyFormation[j].numberOfEnemies = 4;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x2_100 - (i * incX);
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #04 - Tres enemigos BALLOON3. 0, 25, 50. Hacia la derecha
-	j = 4;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_0 + (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #05 - Tres enemigos BALLOON3. 50, 75, 100. Hacia la izquierda
-	j = 5;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_100 - (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #06 - Tres enemigos BALLOON3. 0, 0, 0. Hacia la derecha
-	j = 6;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_0 + (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #07 - Tres enemigos BALLOON3. 100, 100, 100. Hacia la izquierda
-	j = 7;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_100 - (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #08 - Seis enemigos BALLOON1. 0, 0, 0, 0, 0, 0. Hacia la derecha
-	j = 8;
-	enemyFormation[j].numberOfEnemies = 6;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x1_0 + (i * incX);
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #09 - Seis enemigos BALLOON1. 100, 100, 100, 100, 100, 100. Hacia la izquierda
-	j = 9;
-	enemyFormation[j].numberOfEnemies = 6;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x1_100 - (i * incX);
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #10 - Tres enemigos BALLOON4 seguidos desde la izquierda
-	j = 10;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_4 + 1;
-	incTime = 15;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x4_0 + (i * incX);
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #11 - Tres enemigos BALLOON4 seguidos desde la derecha
-	j = 11;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_4 + 1;
-	incTime = 15;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x4_100 - (i * incX);
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #12 - Seis enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
-	j = 12;
-	enemyFormation[j].numberOfEnemies = 6;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x2_0 + (i * incX);
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #13 - Seis enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
-	j = 13;
-	enemyFormation[j].numberOfEnemies = 6;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x2_100 - (i * incX);
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #14 - Cinco enemigos BALLOON3. Hacia la derecha. Separados
-	j = 14;
-	enemyFormation[j].numberOfEnemies = 5;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_0 + (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #15 - Cinco enemigos BALLOON3. Hacia la izquierda. Separados
-	j = 15;
-	enemyFormation[j].numberOfEnemies = 5;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_100 - (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #16 - Cinco enemigos BALLOON3. Hacia la derecha. Juntos
-	j = 16;
-	enemyFormation[j].numberOfEnemies = 5;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_0 + (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #17 - Cinco enemigos BALLOON3. Hacia la izquierda. Juntos
-	j = 17;
-	enemyFormation[j].numberOfEnemies = 5;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_100 - (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #18 - Doce enemigos BALLOON1. Hacia la derecha. Juntos
-	j = 18;
-	enemyFormation[j].numberOfEnemies = 12;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x1_0 + (i * incX);
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #19 - Doce enemigos BALLOON1. Hacia la izquierda. Juntos
-	j = 19;
-	enemyFormation[j].numberOfEnemies = 12;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x1_100 - (i * incX);
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #20 - Dos enemigos BALLOON4 seguidos desde la izquierda/derecha. Simetricos
-	j = 20;
-	enemyFormation[j].numberOfEnemies = 4;
-	incX = BALLOON_WIDTH_4 + 1;
-	incTime = 0;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x4_0 + (i * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x4_100 - ((i - half) * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		}
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime + (incTime * i);
-	}
-
-	// #21 - Diez enemigos BALLOON2 uno detras del otro. Izquierda/derecha. Simetricos
-	j = 21;
-	enemyFormation[j].numberOfEnemies = 10;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 3;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x2_0 + (i * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x2_100 - ((i - half) * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-	}
-
-	// #22 - Diez enemigos BALLOON3. Hacia la derecha/izquierda. Separados. Simetricos
-	j = 22;
-	enemyFormation[j].numberOfEnemies = 10;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x3_0 + (i * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x3_100 - ((i - half) * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-	}
-
-	// #23 - Diez enemigos BALLOON3. Hacia la derecha. Juntos. Simetricos
-	j = 23;
-	enemyFormation[j].numberOfEnemies = 10;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x3_0 + (i * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x3_100 - ((i - half) * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-	}
-
-	// #24 - Treinta enemigos BALLOON1. Del centro hacia los extremos. Juntos. Simetricos
-	j = 24;
-	enemyFormation[j].numberOfEnemies = 30;
-	incX = 0;
-	incTime = 5;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x1_50;
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) + (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x1_50;
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) + (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-	}
-
-	// #25 - Treinta enemigos BALLOON1. Del centro hacia adentro. Juntos. Simetricos
-	j = 25;
-	enemyFormation[j].numberOfEnemies = 30;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 5;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x1_50 + 20;
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x1_50 - 20;
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[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++)
-	{
-		enemyFormation[k + 50].numberOfEnemies = enemyFormation[k].numberOfEnemies;
-		for (int i = 0; i < enemyFormation[k + 50].numberOfEnemies; i++)
-		{
-			enemyFormation[k + 50].init[i].x = enemyFormation[k].init[i].x;
-			enemyFormation[k + 50].init[i].y = enemyFormation[k].init[i].y;
-			enemyFormation[k + 50].init[i].velX = enemyFormation[k].init[i].velX;
-			enemyFormation[k + 50].init[i].creationCounter = enemyFormation[k].init[i].creationCounter;
-			enemyFormation[k + 50].init[i].kind = enemyFormation[k].init[i].kind + 4;
-		}
-	}
-
-	// TEST
-	enemyFormation[99].numberOfEnemies = 4;
-
-	enemyFormation[99].init[0].x = 10;
-	enemyFormation[99].init[0].y = y1;
-	enemyFormation[99].init[0].velX = 0;
-	enemyFormation[99].init[0].kind = BALLOON_1;
-	enemyFormation[99].init[0].creationCounter = 200;
-
-	enemyFormation[99].init[1].x = 50;
-	enemyFormation[99].init[1].y = y1;
-	enemyFormation[99].init[1].velX = 0;
-	enemyFormation[99].init[1].kind = BALLOON_2;
-	enemyFormation[99].init[1].creationCounter = 200;
-
-	enemyFormation[99].init[2].x = 90;
-	enemyFormation[99].init[2].y = y1;
-	enemyFormation[99].init[2].velX = 0;
-	enemyFormation[99].init[2].kind = BALLOON_3;
-	enemyFormation[99].init[2].creationCounter = 200;
-
-	enemyFormation[99].init[3].x = 140;
-	enemyFormation[99].init[3].y = y1;
-	enemyFormation[99].init[3].velX = 0;
-	enemyFormation[99].init[3].kind = BALLOON_4;
-	enemyFormation[99].init[3].creationCounter = 200;
-}
-
-// Inicializa los conjuntos de formaciones
-void EnemyFormations::initEnemyPools()
-{
-	// EnemyPool #0
-	enemyPool[0].set[0] = &enemyFormation[0];
-	enemyPool[0].set[1] = &enemyFormation[1];
-	enemyPool[0].set[2] = &enemyFormation[2];
-	enemyPool[0].set[3] = &enemyFormation[3];
-	enemyPool[0].set[4] = &enemyFormation[4];
-	enemyPool[0].set[5] = &enemyFormation[5];
-	enemyPool[0].set[6] = &enemyFormation[6];
-	enemyPool[0].set[7] = &enemyFormation[7];
-	enemyPool[0].set[8] = &enemyFormation[8];
-	enemyPool[0].set[9] = &enemyFormation[9];
-
-	// EnemyPool #1
-	enemyPool[1].set[0] = &enemyFormation[10];
-	enemyPool[1].set[1] = &enemyFormation[11];
-	enemyPool[1].set[2] = &enemyFormation[12];
-	enemyPool[1].set[3] = &enemyFormation[13];
-	enemyPool[1].set[4] = &enemyFormation[14];
-	enemyPool[1].set[5] = &enemyFormation[15];
-	enemyPool[1].set[6] = &enemyFormation[16];
-	enemyPool[1].set[7] = &enemyFormation[17];
-	enemyPool[1].set[8] = &enemyFormation[18];
-	enemyPool[1].set[9] = &enemyFormation[19];
-
-	// EnemyPool #2
-	enemyPool[2].set[0] = &enemyFormation[0];
-	enemyPool[2].set[1] = &enemyFormation[1];
-	enemyPool[2].set[2] = &enemyFormation[2];
-	enemyPool[2].set[3] = &enemyFormation[3];
-	enemyPool[2].set[4] = &enemyFormation[4];
-	enemyPool[2].set[5] = &enemyFormation[55];
-	enemyPool[2].set[6] = &enemyFormation[56];
-	enemyPool[2].set[7] = &enemyFormation[57];
-	enemyPool[2].set[8] = &enemyFormation[58];
-	enemyPool[2].set[9] = &enemyFormation[59];
-
-	// EnemyPool #3
-	enemyPool[3].set[0] = &enemyFormation[50];
-	enemyPool[3].set[1] = &enemyFormation[51];
-	enemyPool[3].set[2] = &enemyFormation[52];
-	enemyPool[3].set[3] = &enemyFormation[53];
-	enemyPool[3].set[4] = &enemyFormation[54];
-	enemyPool[3].set[5] = &enemyFormation[5];
-	enemyPool[3].set[6] = &enemyFormation[6];
-	enemyPool[3].set[7] = &enemyFormation[7];
-	enemyPool[3].set[8] = &enemyFormation[8];
-	enemyPool[3].set[9] = &enemyFormation[9];
-
-	// EnemyPool #4
-	enemyPool[4].set[0] = &enemyFormation[60];
-	enemyPool[4].set[1] = &enemyFormation[61];
-	enemyPool[4].set[2] = &enemyFormation[62];
-	enemyPool[4].set[3] = &enemyFormation[63];
-	enemyPool[4].set[4] = &enemyFormation[64];
-	enemyPool[4].set[5] = &enemyFormation[65];
-	enemyPool[4].set[6] = &enemyFormation[66];
-	enemyPool[4].set[7] = &enemyFormation[67];
-	enemyPool[4].set[8] = &enemyFormation[68];
-	enemyPool[4].set[9] = &enemyFormation[69];
-
-	// EnemyPool #5
-	enemyPool[5].set[0] = &enemyFormation[10];
-	enemyPool[5].set[1] = &enemyFormation[61];
-	enemyPool[5].set[2] = &enemyFormation[12];
-	enemyPool[5].set[3] = &enemyFormation[63];
-	enemyPool[5].set[4] = &enemyFormation[14];
-	enemyPool[5].set[5] = &enemyFormation[65];
-	enemyPool[5].set[6] = &enemyFormation[16];
-	enemyPool[5].set[7] = &enemyFormation[67];
-	enemyPool[5].set[8] = &enemyFormation[18];
-	enemyPool[5].set[9] = &enemyFormation[69];
-
-	// EnemyPool #6
-	enemyPool[6].set[0] = &enemyFormation[60];
-	enemyPool[6].set[1] = &enemyFormation[11];
-	enemyPool[6].set[2] = &enemyFormation[62];
-	enemyPool[6].set[3] = &enemyFormation[13];
-	enemyPool[6].set[4] = &enemyFormation[64];
-	enemyPool[6].set[5] = &enemyFormation[15];
-	enemyPool[6].set[6] = &enemyFormation[66];
-	enemyPool[6].set[7] = &enemyFormation[17];
-	enemyPool[6].set[8] = &enemyFormation[68];
-	enemyPool[6].set[9] = &enemyFormation[19];
-
-	// EnemyPool #7
-	enemyPool[7].set[0] = &enemyFormation[20];
-	enemyPool[7].set[1] = &enemyFormation[21];
-	enemyPool[7].set[2] = &enemyFormation[22];
-	enemyPool[7].set[3] = &enemyFormation[23];
-	enemyPool[7].set[4] = &enemyFormation[24];
-	enemyPool[7].set[5] = &enemyFormation[65];
-	enemyPool[7].set[6] = &enemyFormation[66];
-	enemyPool[7].set[7] = &enemyFormation[67];
-	enemyPool[7].set[8] = &enemyFormation[68];
-	enemyPool[7].set[9] = &enemyFormation[69];
-
-	// EnemyPool #8
-	enemyPool[8].set[0] = &enemyFormation[70];
-	enemyPool[8].set[1] = &enemyFormation[71];
-	enemyPool[8].set[2] = &enemyFormation[72];
-	enemyPool[8].set[3] = &enemyFormation[73];
-	enemyPool[8].set[4] = &enemyFormation[74];
-	enemyPool[8].set[5] = &enemyFormation[15];
-	enemyPool[8].set[6] = &enemyFormation[16];
-	enemyPool[8].set[7] = &enemyFormation[17];
-	enemyPool[8].set[8] = &enemyFormation[18];
-	enemyPool[8].set[9] = &enemyFormation[19];
-
-	// EnemyPool #9
-	enemyPool[9].set[0] = &enemyFormation[20];
-	enemyPool[9].set[1] = &enemyFormation[21];
-	enemyPool[9].set[2] = &enemyFormation[22];
-	enemyPool[9].set[3] = &enemyFormation[23];
-	enemyPool[9].set[4] = &enemyFormation[24];
-	enemyPool[9].set[5] = &enemyFormation[70];
-	enemyPool[9].set[6] = &enemyFormation[71];
-	enemyPool[9].set[7] = &enemyFormation[72];
-	enemyPool[9].set[8] = &enemyFormation[73];
-	enemyPool[9].set[9] = &enemyFormation[74];
-}
-
-// Inicializa las fases del juego
-void EnemyFormations::initGameStages()
-{
-	// STAGE 1
-	stage[0].number = 1;
-	stage[0].powerToComplete = 200;
-	stage[0].minMenace = 7 + (4 * 1);
-	stage[0].maxMenace = 7 + (4 * 3);
-	stage[0].enemyPool = &enemyPool[0];
-
-	// STAGE 2
-	stage[1].number = 2;
-	stage[1].powerToComplete = 300;
-	stage[1].minMenace = 7 + (4 * 2);
-	stage[1].maxMenace = 7 + (4 * 4);
-	stage[1].enemyPool = &enemyPool[1];
-
-	// STAGE 3
-	stage[2].number = 3;
-	stage[2].powerToComplete = 600;
-	stage[2].minMenace = 7 + (4 * 3);
-	stage[2].maxMenace = 7 + (4 * 5);
-	stage[2].enemyPool = &enemyPool[2];
-
-	// STAGE 4
-	stage[3].number = 4;
-	stage[3].powerToComplete = 600;
-	stage[3].minMenace = 7 + (4 * 3);
-	stage[3].maxMenace = 7 + (4 * 5);
-	stage[3].enemyPool = &enemyPool[3];
-
-	// STAGE 5
-	stage[4].number = 5;
-	stage[4].powerToComplete = 600;
-	stage[4].minMenace = 7 + (4 * 4);
-	stage[4].maxMenace = 7 + (4 * 6);
-	stage[4].enemyPool = &enemyPool[4];
-
-	// STAGE 6
-	stage[5].number = 6;
-	stage[5].powerToComplete = 600;
-	stage[5].minMenace = 7 + (4 * 4);
-	stage[5].maxMenace = 7 + (4 * 6);
-	stage[5].enemyPool = &enemyPool[5];
-
-	// STAGE 7
-	stage[6].number = 7;
-	stage[6].powerToComplete = 650;
-	stage[6].minMenace = 7 + (4 * 5);
-	stage[6].maxMenace = 7 + (4 * 7);
-	stage[6].enemyPool = &enemyPool[6];
-
-	// STAGE 8
-	stage[7].number = 8;
-	stage[7].powerToComplete = 750;
-	stage[7].minMenace = 7 + (4 * 5);
-	stage[7].maxMenace = 7 + (4 * 7);
-	stage[7].enemyPool = &enemyPool[7];
-
-	// STAGE 9
-	stage[8].number = 9;
-	stage[8].powerToComplete = 850;
-	stage[8].minMenace = 7 + (4 * 6);
-	stage[8].maxMenace = 7 + (4 * 8);
-	stage[8].enemyPool = &enemyPool[8];
-
-	// STAGE 10
-	stage[9].number = 10;
-	stage[9].powerToComplete = 950;
-	stage[9].minMenace = 7 + (4 * 7);
-	stage[9].maxMenace = 7 + (4 * 10);
-	stage[9].enemyPool = &enemyPool[9];
-}
-
-// Devuelve una fase
-stage_t EnemyFormations::getStage(int index)
-{
-	return stage[index];
-}

source/enemy_formations.h

@@ -1,68 +0,0 @@
-#pragma once
-
-#include <SDL2/SDL.h>
-#include "utils.h"
-#include "const.h"
-#include "balloon.h"
-
-#define NUMBER_OF_ENEMY_FORMATIONS 100
-#define MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION 50
-
-// Estructuras
-struct enemyInits_t
-{
-    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 velX;          // Velocidad inicial en el eje X
-    int kind;            // Tipo de enemigo
-    int creationCounter; // Temporizador para la creación del enemigo
-};
-
-struct enemyFormation_t // Contiene la información de una formación enemiga
-{
-    int numberOfEnemies;                                     // Cantidad de enemigos que forman la formación
-    enemyInits_t init[MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION]; // Vector con todas las inicializaciones de los enemigos de la formación
-};
-
-struct enemyPool_t
-{
-    enemyFormation_t *set[10]; // Conjunto de formaciones enemigas
-};
-
-struct stage_t // Contiene todas las variables relacionadas con una fase
-{
-    enemyPool_t *enemyPool; // El conjunto de formaciones enemigas de la fase
-    int powerToComplete;    // Cantidad de poder que se necesita para completar la fase
-    int maxMenace;          // Umbral máximo de amenaza de la fase
-    int minMenace;          // Umbral mínimo de amenaza de la fase
-    int number;             // Número de fase
-};
-
-// Clase EnemyFormations, para gestionar las formaciones enemigas
-class EnemyFormations
-{
-private:
-    // Variables
-    stage_t stage[10];                                           // Variable con los datos de cada pantalla
-    enemyFormation_t enemyFormation[NUMBER_OF_ENEMY_FORMATIONS]; // Vector con todas las formaciones enemigas
-    enemyPool_t enemyPool[10];                                   // Variable con los diferentes conjuntos de formaciones enemigas
-
-    // Inicializa las formaciones enemigas
-    void initEnemyFormations();
-
-    // Inicializa los conjuntos de formaciones
-    void initEnemyPools();
-
-    // Inicializa las fases del juego
-    void initGameStages();
-
-public:
-    // Constructor
-    EnemyFormations();
-
-    // Destructor
-    ~EnemyFormations();
-
-    // Devuelve una fase
-    stage_t getStage(int index);
-};

source/enter_name.cpp

@@ -1,44 +1,113 @@
 #include "enter_name.h"
+#include <algorithm> // for max, min
 
 // Constructor
-EnterName::EnterName(std::string *name)
+EnterName::EnterName()
 {
-    characterList = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    init();
-    this->name = name;
-    pos = 0;
-    numCharacters = (int)characterList.size();
-    for (int i = 0; i < NAME_LENGHT; ++i)
-    {
-        characterIndex[i] = 0;
-    }
 }
 
-// Destructor
+// Inicializa el objeto
-EnterName::~EnterName()
+void EnterName::init()
 {
+    // Obtiene el puntero al nombre
+    name_ = "A";
+
+    // Inicia la lista de caracteres permitidos
+    character_list_ = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()";
+    pos_ = 0;
+    num_characters_ = (int)character_list_.size();
+
+    // Pone la lista de indices para que refleje el nombre
+    updateCharacterIndex();
+
+    // Actualiza el nombre para que ocupe 8 espacios
+    updateName();
 }
 
 // Incrementa la posición
 void EnterName::incPos()
 {
-    pos++;
+    pos_++;
-    pos = std::min(pos, NAME_LENGHT - 1);
+    pos_ = std::min(pos_, NAME_LENGHT - 1);
 }
 
 // Decrementa la posición
 void EnterName::decPos()
 {
-    pos--;
+    pos_--;
-    pos = std::max(pos, 0);
+    pos_ = std::max(pos_, 0);
+}
+
+// Incrementa el índice
+void EnterName::incIndex()
+{
+    ++character_index_[pos_];
+    if (character_index_[pos_] >= num_characters_)
+    {
+        character_index_[pos_] = 0;
+    }
+    updateName();
+}
+
+// Decrementa el índice
+void EnterName::decIndex()
+{
+    --character_index_[pos_];
+    if (character_index_[pos_] < 0)
+    {
+        character_index_[pos_] = num_characters_ - 1;
+    }
+    updateName();
 }
 
 // Actualiza la variable
 void EnterName::updateName()
 {
-    name->clear();
+    name_.clear();
     for (int i = 0; i < NAME_LENGHT; ++i)
     {
-        name->append("a");
+        name_.push_back(character_list_[character_index_[i]]);
-        //name->append(characterIndex[i] = 0;
     }
 }
+
+// Actualiza la variable
+void EnterName::updateCharacterIndex()
+{
+    // Rellena de espacios
+    for (int i = 0; i < NAME_LENGHT; ++i)
+    {
+        character_index_[i] = 0;
+    }
+
+    // Coloca los índices en funcion de los caracteres que forman el nombre
+    for (int i = 0; i < (int)name_.size(); ++i)
+    {
+        character_index_[i] = findIndex(name_.at(i));
+    }
+}
+
+// Encuentra el indice de un caracter en "character_list_"
+int EnterName::findIndex(char character)
+{
+    for (int i = 0; i < (int)character_list_.size(); ++i)
+    {
+        if (character == character_list_[i])
+        {
+            return i;
+        }
+    }
+    return 0;
+}
+
+// Obtiene el nombre
+std::string EnterName::getName() const
+{
+    return name_;
+}
+
+// Obtiene la posición que se está editando
+int EnterName::getPos() const
+{
+    return pos_;
+}

source/enter_name.h

@@ -2,17 +2,44 @@
 
 #include <string>
 
-#define NAME_LENGHT 8
+constexpr int NAME_LENGHT = 8;
+
+/*
+    Un array, "characterList", contiene la lista de caracteres
+    Un segundo array, "characterIndex", contiene el indice a "characterList" de cada una de las letras que conforman el nombre
+    "pos" es la posición de "characterIndex" que se está modificando
+    Izquierda o derecha modifican "pos", arriba o abajo modifican el índice de "characterIndex[pos]"
+    Pulsar cualquier botón, mueve "pos" a la derecha. Al pulsar el botón en la ´´ultima posición se finaliza la introducción de nombres
+*/
 
 // Clase EnterName
 class EnterName
 {
 private:
-    std::string characterList;       // Lista de todos los caracteres permitidos
+    std::string character_list_;       // Lista de todos los caracteres permitidos
-    std::string *name;                // Nombre introducido
+    std::string name_;                 // Nombre introducido
-    int pos;                         // Posición a editar del nombre
+    int pos_;                          // Posición a editar del nombre
-    int numCharacters;               // Cantidad de caracteres de la lista de caracteres
+    int num_characters_;               // Cantidad de caracteres de la lista de caracteres
-    int characterIndex[NAME_LENGHT]; // Indice de la lista para cada uno de los caracteres que forman el nombre
+    int character_index_[NAME_LENGHT]; // Indice de la lista para cada uno de los caracteres que forman el nombre
+
+    // Actualiza la variable
+    void updateName();
+
+    // Actualiza la variable
+    void updateCharacterIndex();
+
+    // Encuentra el indice de un caracter en "characterList"
+    int findIndex(char character);
+
+public:
+    // Constructor
+    EnterName();
+
+    // Destructor
+    ~EnterName() = default;
+
+    // Inicializa el objeto
+    void init();
 
     // Incrementa la posición
     void incPos();
@@ -20,13 +47,15 @@ private:
     // Decrementa la posición
     void decPos();
 
-    // Actualiza la variable
+    // Incrementa el índice
-    void updateName();
+    void incIndex();
 
-public:
+    // Decrementa el índice
-    // Constructor
+    void decIndex();
-    EnterName(std::string *name);
 
-    // Destructor
+    // Obtiene el nombre
-    ~EnterName();
+    std::string getName() const;
+
+    // Obtiene la posición que se está editando
+    int getPos() const;
 };