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_DEBUG:= -std=c++11 -Wall
+	CXXFLAGS:= -std=c++20 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows
+	CXXFLAGS_DEBUG:= -std=c++20 -Wall -g
 	LDFLAGS := -lmingw32 -lws2_32 -lSDL2main -lSDL2 -lopengl32
 	RM = del /Q
 	MKD:= mkdir
@@ -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_DEBUG:= -std=c++11 -Wall
+	CXXFLAGS:= -std=c++20 -Wall -Os -ffunction-sections -fdata-sections
+	CXXFLAGS_DEBUG:= -std=c++20 -Wall -g
 	LDFLAGS := -lSDL2
 	RM = rm -f
 	MKD:= mkdir -p

data/config/param_320x240.txt

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

data/config/param_320x256.txt

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

data/gfx/balloon/balloon1.ani

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

data/gfx/balloon/balloon2.ani

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

data/gfx/balloon/balloon3.ani

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

data/gfx/balloon/balloon4.ani

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

data/gfx/balloon/explosion1.ani

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

data/gfx/balloon/explosion2.ani

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

data/gfx/balloon/explosion3.ani

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

data/gfx/balloon/explosion4.ani

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

data/gfx/balloon/powerball.ani

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

data/gfx/item/item_clock.ani

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

data/gfx/item/item_coffee.ani

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

data/gfx/item/item_coffee_machine.ani

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

data/gfx/item/item_points1_disk.ani

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

data/gfx/item/item_points2_gavina.ani

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

data/gfx/item/item_points3_pacmar.ani

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

data/gfx/player/player.ani

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

data/gfx/player/player_power.ani

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

data/gfx/title/title_dust.ani

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

data/lang/ba_BA.txt

@@ -320,22 +320,28 @@ Continuar?
 Posa el nom
 
 ## 107 - AJUDA
-Canvia mandos
+Intercanviar mandos
 
 ## 108 - AJUDA
 Configuracio
 
 ## 109 - AJUDA
-Des-activa el so
+Alternar el audio
 
 ## 110 - AJUDA
-Filtros
+Filtres
 
 ## 111 - AJUDA
-Reset
+Reiniciar
 
 ## 112 - AJUDA
-Pausa
+Pausar
 
 ## 113 - AJUDA
-Eixir
+Eixir
+
+## 114 - MARCADOR
+Per favor
+
+## 115 - MARCADOR
+espere

data/lang/en_UK.txt

@@ -323,10 +323,10 @@ Enter name
 Swap Controllers
 
 ## 108 - AJUDA
-Config
+Configuration
 
 ## 109 - AJUDA
-Un-mute audio
+Toggle audio
 
 ## 110 - AJUDA
 Shaders
@@ -338,4 +338,10 @@ Reset
 Pause
 
 ## 113 - AJUDA
-Exit
+Exit
+
+## 114 - MARCADOR
+Please
+
+## 115 - MARCADOR
+wait

data/lang/es_ES.txt

@@ -320,22 +320,28 @@ Continuar?
 Pon tu nombre
 
 ## 107 - AJUDA
-Intercambia mandos
+Intercambiar mandos
 
 ## 108 - AJUDA
 Configuracion
 
 ## 109 - AJUDA
-Des-activa el sonido
+Alternar el audio
 
 ## 110 - AJUDA
 Filtros
 
 ## 111 - AJUDA
-Reset
+Reiniciar
 
 ## 112 - AJUDA
-Pausa
+Pausar
 
 ## 113 - AJUDA
-Salir
+Salir
+
+## 114 - MARCADOR
+Por favor
+
+## 115 - MARCADOR
+espere

linux-utils/check-includes.sh

@@ -4,5 +4,7 @@ SOURCEPATH=../source/
 
 for i in "$SOURCEPATH"/*.cpp
 do
-    include-what-you-use -D DEBUG -D VERBOSE -std=c++11 -Wall "$i"
+    include-what-you-use -D DEBUG -D VERBOSE -std=c++20 -Wall "$i"
+    read -p "Presiona cualquier tecla para continuar..."
+    clear
 done

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

source/animated_sprite.h

@@ -1,46 +1,47 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>    // for SDL_Rect
-#include <SDL2/SDL_stdinc.h>  // for Uint8
-#include <string>             // for string, basic_string
-#include <vector>             // for vector
-#include "moving_sprite.h"     // for MovingSprite
+#include <SDL2/SDL_rect.h>   // for SDL_Rect
+#include <SDL2/SDL_stdinc.h> // for Uint8
+#include <memory>            // for shared_ptr
+#include <string>            // for string
+#include <vector>            // for vector
+#include "moving_sprite.h"   // for MovingSprite
 class Texture;
 
-struct animation_t
+struct Animation
 {
     std::string name;             // Nombre de la animacion
     std::vector<SDL_Rect> frames; // Cada uno de los frames que componen la animación
     int speed;                    // Velocidad de la animación
     int loop;                     // Indica a que frame vuelve la animación al terminar. -1 para que no vuelva
     bool completed;               // Indica si ha finalizado la animación
-    int currentFrame;             // Frame actual
+    int current_frame;            // Frame actual
     int counter;                  // Contador para las animaciones
 };
 
-struct animatedSprite_t
+struct AnimatedFile
 {
-    std::vector<animation_t> animations; // Vector con las diferentes animaciones
-    Texture *texture;                    // Textura con los graficos para el sprite
+    std::vector<Animation> animations; // Vector con las diferentes animaciones
+    std::shared_ptr<Texture> texture;  // Textura con los graficos para el sprite
 };
 
 // Carga la animación desde un fichero
-animatedSprite_t loadAnimationFromFile(Texture *texture, std::string filePath, bool verbose = false);
+AnimatedFile loadAnimationFromFile(std::shared_ptr<Texture> texture, std::string filePath);
 
 class AnimatedSprite : public MovingSprite
 {
-private:
+protected:
     // Variables
-    std::vector<animation_t> animation; // Vector con las diferentes animaciones
-    int currentAnimation;               // Animacion activa
+    std::vector<Animation> animations_; // Vector con las diferentes animaciones
+    int current_animation_;             // Animacion activa
 
 public:
     // Constructor
-    AnimatedSprite(Texture *texture = nullptr, std::string file = "", std::vector<std::string> *buffer = nullptr);
-    AnimatedSprite(animatedSprite_t *animation);
+    explicit AnimatedSprite(std::shared_ptr<Texture> texture = nullptr, const std::string &file = std::string(), std::vector<std::string> *buffer = nullptr);
+    explicit AnimatedSprite(const AnimatedFile *animation);
 
     // Destructor
-    ~AnimatedSprite();
+    virtual ~AnimatedSprite();
 
     // Calcula el frame correspondiente a la animación actual
     void animate();
@@ -52,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,68 +1,57 @@
 #include "asset.h"
-#include <SDL2/SDL_rwops.h>   // for SDL_RWFromFile, SDL_RWclose, SDL_RWops
-#include <SDL2/SDL_stdinc.h>  // for SDL_max
-#include <stddef.h>           // for size_t
-#include <iostream>           // for basic_ostream, operator<<, cout, endl
+#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;
+Asset *Asset::asset_ = nullptr;
 
 // [SINGLETON] Crearemos el objeto asset con esta función estática
-void Asset::init(std::string executablePath)
+void Asset::init(const std::string &executable_path)
 {
-    Asset::asset = new Asset(executablePath);
+    Asset::asset_ = new Asset(executable_path);
 }
 
 // [SINGLETON] Destruiremos el objeto asset con esta función estática
 void Asset::destroy()
 {
-    delete Asset::asset;
+    delete Asset::asset_;
 }
 
 // [SINGLETON] Con este método obtenemos el objeto asset y podemos trabajar con él
 Asset *Asset::get()
 {
-    return Asset::asset;
+    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("\\/"));
-    longestName = 0;
-#ifdef VERBOSE
-    verbose = true;
-#else
-    verbose = false;
-#endif
-}
-
-// Destructor
-Asset::~Asset()
-{
-
+    longest_name_ = 0;
 }
 
 // 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;
-    temp.file = absolute ? file : executablePath + file;
-    temp.type = type;
-    temp.required = required;
-    fileList.push_back(temp);
+    AssetItem ai;
+    ai.file = absolute ? file : executable_path_ + file;
+    ai.type = type;
+    ai.required = required;
+    file_list_.push_back(ai);
 
-    const std::string filename = file.substr(file.find_last_of("\\/") + 1);
-    longestName = SDL_max(longestName, filename.size());
+    const std::string file_name = file.substr(file.find_last_of("\\/") + 1);
+    longest_name_ = SDL_max(longest_name_, file_name.size());
 }
 
 // Devuelve el fichero de un elemento de la lista a partir de una cadena
-std::string Asset::get(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 std::string file = f.file.substr(lastIndex, std::string::npos);
+        const size_t last_index = f.file.find_last_of("/") + 1;
+        const std::string file = f.file.substr(last_index, std::string::npos);
 
         if (file == text)
         {
@@ -70,35 +59,33 @@ std::string Asset::get(std::string text)
         }
     }
 
-    if (verbose)
-    {
-        std::cout << "Warning: file " << text.c_str() << " not found" << std::endl;
-    }
+#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)
-    {
-        std::cout << "\n** Checking files" << std::endl;
+#ifdef VERBOSE
+    std::cout << "\n** Checking files" << std::endl;
 
-        std::cout << "Executable path is:  " << executablePath << std::endl;
-        std::cout << "Sample filepath:  " << fileList.back().file << std::endl;
-    }
+    std::cout << "Executable path is:  " << executable_path_ << std::endl;
+    std::cout << "Sample filepath:  " << file_list_.back().file << std::endl;
+#endif
 
     // Comprueba la lista de ficheros clasificandolos por tipo
-    for (int type = 0; type < 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;
             }
@@ -107,14 +94,13 @@ bool Asset::check()
         // Si hay ficheros de ese tipo, comprueba si existen
         if (any)
         {
-            if (verbose)
-            {
-                std::cout << "\n>> " << getTypeName(type).c_str() << " FILES" << std::endl;
-            }
+#ifdef VERBOSE
+            std::cout << "\n>> " << getTypeName(static_cast<AssetType>(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);
                 }
@@ -122,92 +108,79 @@ bool Asset::check()
         }
     }
 
-    // Resultado
-    if (verbose)
-    {
-        if (success)
-        {
-            std::cout << "\n** All files OK.\n"
-                      << std::endl;
-        }
-        else
-        {
-            std::cout << "\n** A file is missing. Exiting.\n"
-                      << std::endl;
-        }
-    }
+// Resultado
+#ifdef VERBOSE
+    std::cout << (success ? "\n** All files OK.\n" : "\n** A file is missing. Exiting.\n") << std::endl;
+#endif
 
     return success;
 }
 
 // Comprueba que existe un fichero
-bool Asset::checkFile(std::string path)
+bool Asset::checkFile(const std::string &path) const
 {
-    bool success = false;
-    std::string result = "ERROR";
+    auto success = false;
 
     // Comprueba si existe el fichero
-    const std::string filename = path.substr(path.find_last_of("\\/") + 1);
-    SDL_RWops *file = SDL_RWFromFile(path.c_str(), "rb");
+    auto file = SDL_RWFromFile(path.c_str(), "rb");
 
-    if (file != nullptr)
+    if (file)
     {
-        result = "OK";
         success = true;
         SDL_RWclose(file);
     }
 
-    if (verbose)
-    {
-        std::cout.setf(std::ios::left, std::ios::adjustfield);
-        std::cout << "Checking file: ";
-        std::cout.width(longestName + 2);
-        std::cout.fill('.');
-        std::cout << filename + " ";
-        std::cout << " [" + result + "]" << std::endl;
-    }
+#ifdef VERBOSE
+    const std::string file_name = path.substr(path.find_last_of("\\/") + 1);
+    std::cout.setf(std::ios::left, std::ios::adjustfield);
+    std::cout << "Checking file: ";
+    std::cout.width(longest_name_ + 2);
+    std::cout.fill('.');
+    std::cout << file_name;
+    std::cout << (success ? " [OK]" : " [ERROR]") << std::endl;
+#endif
 
     return success;
 }
 
 // Devuelve el nombre del tipo de recurso
-std::string Asset::getTypeName(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;
 
@@ -217,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,20 +1,20 @@
 #pragma once
 
-#include <string>  // for string, basic_string
-#include <vector>  // for vector
+#include <string> // for string, basic_string
+#include <vector> // for vector
 
-enum assetType
+enum class AssetType : int
 {
-	t_bitmap,
-	t_music,
-	t_sound,
-	t_font,
-	t_lang,
-	t_data,
-	t_animation,
-	t_palette,
-	t_item,
-	t_maxAssetType
+	BITMAP,
+	MUSIC,
+	SOUND,
+	FONT,
+	LANG,
+	DATA,
+	ANIMATION,
+	PALETTE,
+	ITEM,
+	MAX_ASSET_TYPE,
 };
 
 // Clase Asset
@@ -22,38 +22,37 @@ class Asset
 {
 private:
 	// [SINGLETON] Objeto asset privado para Don Melitón
-	static Asset *asset;
+	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
-	std::vector<item_t> fileList; // Listado con todas las rutas a los ficheros
-	std::string executablePath;	  // Ruta al ejecutable
-	bool verbose;				  // Indica si ha de mostrar información por pantalla
+	int longest_name_;				   // Contiene la longitud del nombre de fichero mas largo
+	std::vector<AssetItem> file_list_; // Listado con todas las rutas a los ficheros
+	std::string executable_path_;	   // Ruta al ejecutable
 
 	// Comprueba que existe un fichero
-	bool checkFile(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
-	Asset(std::string path);
+	explicit Asset(const std::string &executable_path);
 
 	// Destructor
-	~Asset();
+	~Asset() = default;
 
 public:
 	// [SINGLETON] Crearemos el objeto screen con esta función estática
-	static void init(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();
@@ -62,17 +61,14 @@ public:
 	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();
-
-	// Establece si ha de mostrar texto por pantalla
-	void setVerbose(bool value);
+	bool check() const;
 
 	// 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,187 +1,170 @@
 #include "background.h"
 #include <SDL2/SDL_blendmode.h>  // for SDL_BLENDMODE_BLEND
 #include <SDL2/SDL_pixels.h>     // for SDL_PIXELFORMAT_RGBA8888
-#include <algorithm>             // for max, min
-#include <string>                // for basic_string
+#include <algorithm>             // for clamp, max
 #include "asset.h"               // for Asset
-#include "moving_sprite.h"        // for MovingSprite
+#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)
+    : 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;
-    asset = Asset::get();
-
-    // Carga las texturas
-    buildingsTexture = new Texture(renderer, asset->get("game_buildings.png"));
-    topCloudsTexture = new Texture(renderer, asset->get("game_clouds1.png"));
-    bottomCloudsTexture = new Texture(renderer, asset->get("game_clouds2.png"));
-    grassTexture = new Texture(renderer, asset->get("game_grass.png"));
-    gradientsTexture = new Texture(renderer, asset->get("game_sky_colors.png"));
-
     // Inicializa variables
-    gradientNumber = 0;
-    alpha = 0;
-    cloudsSpeed = 0;
-    transition = 0;
-    counter = 0;
+    gradient_number_ = 0;
+    alpha_ = 0;
+    clouds_speed_ = 0;
+    transition_ = 0;
+    counter_ = 0;
 
-    rect = {0, 0, gradientsTexture->getWidth() / 2, gradientsTexture->getHeight() / 2};
-    srcRect = {0, 0, 320, 240};
-    dstRect = {0, 0, 320, 240};
+    rect_ = {0, 0, gradients_texture_->getWidth() / 2, gradients_texture_->getHeight() / 2};
+    src_rect_ = {0, 0, 320, 240};
+    dst_rect_ = {0, 0, 320, 240};
 
-    base = rect.h;
-    color = {param.background.attenuateColor.r, param.background.attenuateColor.g, param.background.attenuateColor.b};
-    alphaColorText = alphaColorTextTemp = param.background.attenuateAlpha;
+    base_ = rect_.h;
+    color_ = {param.background.attenuate_color.r, param.background.attenuate_color.g, param.background.attenuate_color.b};
+    alpha_color_text_ = alpha_color_text_temp_ = param.background.attenuate_alpha;
 
-    gradientRect[0] = {0, 0, rect.w, rect.h};
-    gradientRect[1] = {rect.w, 0, rect.w, rect.h};
-    gradientRect[2] = {0, rect.h, rect.w, rect.h};
-    gradientRect[3] = {rect.w, rect.h, rect.w, rect.h};
+    gradient_rect_[0] = {0, 0, rect_.w, rect_.h};
+    gradient_rect_[1] = {rect_.w, 0, rect_.w, rect_.h};
+    gradient_rect_[2] = {0, rect_.h, rect_.w, rect_.h};
+    gradient_rect_[3] = {rect_.w, rect_.h, rect_.w, rect_.h};
 
-    const int topCloudsTextureHeight = topCloudsTexture->getHeight() / 4;
-    const int bottomCloudsTextureHeight = bottomCloudsTexture->getHeight() / 4;
+    const int top_clouds_texture_height = top_clouds_texture_->getHeight() / 4;
+    const int bottom_clouds_texture_height = bottom_clouds_texture_->getHeight() / 4;
     for (int i = 0; i < 4; ++i)
     {
-        topCloudsRect[i] = {0, i * topCloudsTextureHeight, topCloudsTexture->getWidth(), topCloudsTextureHeight};
-        bottomCloudsRect[i] = {0, i * bottomCloudsTextureHeight, bottomCloudsTexture->getWidth(), bottomCloudsTextureHeight};
+        top_clouds_rect_[i] = {0, i * top_clouds_texture_height, top_clouds_texture_->getWidth(), top_clouds_texture_height};
+        bottom_clouds_rect_[i] = {0, i * bottom_clouds_texture_height, bottom_clouds_texture_->getWidth(), bottom_clouds_texture_height};
     }
 
     // Crea los sprites
-    const int topClouds_y = base - 165;
-    const int bottomClouds_y = base - 101;
-    const float topCloudsSpeed = 0.1f;
-    const float bottomCloudsSpeed = 0.05f;
-    topCloudsSprite_A = new MovingSprite(0, topClouds_y, rect.w, topCloudsTexture->getHeight(), -topCloudsSpeed, 0.0f, 0.0f, 0.0f, topCloudsTexture);
-    topCloudsSprite_B = new MovingSprite(rect.w, topClouds_y, rect.w, topCloudsTexture->getHeight(), -topCloudsSpeed, 0.0f, 0.0f, 0.0f, topCloudsTexture);
+    const int top_clouds_y = base_ - 165;
+    const int bottom_clouds_y = base_ - 101;
+    constexpr float top_clouds_speed = 0.1f;
+    constexpr float bottom_clouds_speed = 0.05f;
+    top_clouds_sprite_a_ = std::make_unique<MovingSprite>(0, top_clouds_y, rect_.w, top_clouds_texture_->getHeight(), -top_clouds_speed, 0.0f, 0.0f, 0.0f, top_clouds_texture_);
+    top_clouds_sprite_b_ = std::make_unique<MovingSprite>(rect_.w, top_clouds_y, rect_.w, top_clouds_texture_->getHeight(), -top_clouds_speed, 0.0f, 0.0f, 0.0f, top_clouds_texture_);
 
-    bottomCloudsSprite_A = new MovingSprite(0, bottomClouds_y, rect.w, bottomCloudsTexture->getHeight(), -bottomCloudsSpeed, 0.0f, 0.0f, 0.0f, bottomCloudsTexture);
-    bottomCloudsSprite_B = new MovingSprite(rect.w, bottomClouds_y, rect.w, bottomCloudsTexture->getHeight(), -bottomCloudsSpeed, 0.0f, 0.0f, 0.0f, bottomCloudsTexture);
+    bottom_clouds_sprite_a_ = std::make_unique<MovingSprite>(0, bottom_clouds_y, rect_.w, bottom_clouds_texture_->getHeight(), -bottom_clouds_speed, 0.0f, 0.0f, 0.0f, bottom_clouds_texture_);
+    bottom_clouds_sprite_b_ = std::make_unique<MovingSprite>(rect_.w, bottom_clouds_y, rect_.w, bottom_clouds_texture_->getHeight(), -bottom_clouds_speed, 0.0f, 0.0f, 0.0f, bottom_clouds_texture_);
 
-    buildingsSprite = new Sprite(0, 0, buildingsTexture->getWidth(), buildingsTexture->getHeight(), buildingsTexture);
-    gradientSprite = new Sprite(0, 0, rect.w, rect.h, gradientsTexture);
-    grassSprite = new Sprite(0, 0, grassTexture->getWidth(), grassTexture->getHeight() / 2, grassTexture);
+    buildings_sprite_ = std::make_unique<Sprite>(0, 0, buildings_texture_->getWidth(), buildings_texture_->getHeight(), buildings_texture_);
+    gradient_sprite_ = std::make_unique<Sprite>(0, 0, rect_.w, rect_.h, gradients_texture_);
+    grass_sprite_ = std::make_unique<Sprite>(0, 0, grass_texture_->getWidth(), grass_texture_->getHeight() / 2, grass_texture_);
 
     // Inicializa objetos
-    topCloudsSprite_A->setSpriteClip(0, 0, topCloudsTexture->getWidth(), topCloudsTexture->getHeight());
-    topCloudsSprite_B->setSpriteClip(0, 0, topCloudsTexture->getWidth(), topCloudsTexture->getHeight());
-    bottomCloudsSprite_A->setSpriteClip(0, 0, bottomCloudsTexture->getWidth(), bottomCloudsTexture->getHeight());
-    bottomCloudsSprite_B->setSpriteClip(0, 0, bottomCloudsTexture->getWidth(), bottomCloudsTexture->getHeight());
-    buildingsSprite->setPosY(base - buildingsSprite->getHeight());
-    grassSprite->setPosY(base - grassSprite->getHeight());
+    top_clouds_sprite_a_->setSpriteClip(0, 0, top_clouds_texture_->getWidth(), top_clouds_texture_->getHeight());
+    top_clouds_sprite_b_->setSpriteClip(0, 0, top_clouds_texture_->getWidth(), top_clouds_texture_->getHeight());
+    bottom_clouds_sprite_a_->setSpriteClip(0, 0, bottom_clouds_texture_->getWidth(), bottom_clouds_texture_->getHeight());
+    bottom_clouds_sprite_b_->setSpriteClip(0, 0, bottom_clouds_texture_->getWidth(), bottom_clouds_texture_->getHeight());
+    buildings_sprite_->setPosY(base_ - buildings_sprite_->getHeight());
+    grass_sprite_->setPosY(base_ - grass_sprite_->getHeight());
 
     // Crea la textura para componer el fondo
-    canvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
-    SDL_SetTextureBlendMode(canvas, SDL_BLENDMODE_BLEND);
+    canvas_ = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
+    SDL_SetTextureBlendMode(canvas_, SDL_BLENDMODE_BLEND);
 
     // Crea la textura para atenuar el fondo
-    colorTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
-    SDL_SetTextureBlendMode(colorTexture, SDL_BLENDMODE_BLEND);
-    setColor(color);
-    SDL_SetTextureAlphaMod(colorTexture, alphaColorText);
+    color_texture_ = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
+    SDL_SetTextureBlendMode(color_texture_, SDL_BLENDMODE_BLEND);
+    setColor(color_);
+    SDL_SetTextureAlphaMod(color_texture_, alpha_color_text_);
 }
 
 // Destructor
 Background::~Background()
 {
-    delete buildingsTexture;
-    delete topCloudsTexture;
-    delete bottomCloudsTexture;
-    delete grassTexture;
-    delete gradientsTexture;
-
-    delete topCloudsSprite_A;
-    delete topCloudsSprite_B;
-    delete bottomCloudsSprite_A;
-    delete bottomCloudsSprite_B;
-    delete buildingsSprite;
-    delete gradientSprite;
-    delete grassSprite;
-    SDL_DestroyTexture(canvas);
-    SDL_DestroyTexture(colorTexture);
+    SDL_DestroyTexture(canvas_);
+    SDL_DestroyTexture(color_texture_);
 }
 
 // Actualiza la lógica del objeto
 void Background::update()
 {
-    // Actualiza el valor de alpha
+    // Actualiza el valor de alpha_
     updateAlphaColorText();
 
     // Actualiza las nubes
     updateClouds();
 
     // Calcula el frame de la hierba
-    grassSprite->setSpriteClip(0, (10 * (counter / 20 % 2)), 320, 10);
+    grass_sprite_->setSpriteClip(0, (10 * (counter_ / 20 % 2)), 320, 10);
 
-    // Calcula el valor de alpha
-    alpha = std::max((255 - (int)(255 * transition)), 0);
+    // Calcula el valor de alpha_
+    alpha_ = std::max((255 - (int)(255 * transition_)), 0);
 
     // Incrementa el contador
-    counter++;
+    counter_++;
 
+    // Compone todos los elementos del fondo en la textura
     fillCanvas();
 }
 
 // Dibuja el gradiente de fondo
 void Background::renderGradient()
 {
-    // Dibuja el gradiente 2
-    gradientsTexture->setAlpha(255);
-    gradientSprite->setSpriteClip(gradientRect[(gradientNumber + 1) % 4]);
-    gradientSprite->render();
+    // Dibuja el gradiente de detras
+    gradients_texture_->setAlpha(255);
+    gradient_sprite_->setSpriteClip(gradient_rect_[(gradient_number_ + 1) % 4]);
+    gradient_sprite_->render();
 
-    // Dibuja el gradiente 1 con una opacidad cada vez menor
-    gradientsTexture->setAlpha(alpha);
-    gradientSprite->setSpriteClip(gradientRect[gradientNumber]);
-    gradientSprite->render();
+    // Dibuja el gradiente de delante con una opacidad cada vez menor
+    gradients_texture_->setAlpha(alpha_);
+    gradient_sprite_->setSpriteClip(gradient_rect_[gradient_number_]);
+    gradient_sprite_->render();
 }
 
 // Dibuja las nubes de arriba
 void Background::renderTopClouds()
 {
-    // Dibuja el primer conjunto de nubes
-    topCloudsTexture->setAlpha(255);
-    topCloudsSprite_A->setSpriteClip(topCloudsRect[(gradientNumber + 1) % 4]);
-    topCloudsSprite_A->render();
-    topCloudsSprite_B->setSpriteClip(topCloudsRect[(gradientNumber + 1) % 4]);
-    topCloudsSprite_B->render();
+    // Dibuja el primer conjunto de nubes, las de detras
+    top_clouds_texture_->setAlpha(255);
+    top_clouds_sprite_a_->setSpriteClip(top_clouds_rect_[(gradient_number_ + 1) % 4]);
+    top_clouds_sprite_b_->setSpriteClip(top_clouds_rect_[(gradient_number_ + 1) % 4]);
+    top_clouds_sprite_a_->render();
+    top_clouds_sprite_b_->render();
 
-    // Dibuja el segundo conjunto de nubes
-    topCloudsTexture->setAlpha(alpha);
-    topCloudsSprite_A->setSpriteClip(topCloudsRect[gradientNumber]);
-    topCloudsSprite_A->render();
-    topCloudsSprite_B->setSpriteClip(topCloudsRect[gradientNumber]);
-    topCloudsSprite_B->render();
+    // Dibuja el segundo conjunto de nubes, las de delante
+    top_clouds_texture_->setAlpha(alpha_);
+    top_clouds_sprite_a_->setSpriteClip(top_clouds_rect_[gradient_number_]);
+    top_clouds_sprite_b_->setSpriteClip(top_clouds_rect_[gradient_number_]);
+    top_clouds_sprite_a_->render();
+    top_clouds_sprite_b_->render();
 }
 
 // Dibuja las nubes de abajo
 void Background::renderBottomClouds()
 {
-    // Dibuja el primer conjunto de nubes
-    bottomCloudsTexture->setAlpha(255);
-    bottomCloudsSprite_A->setSpriteClip(bottomCloudsRect[(gradientNumber + 1) % 4]);
-    bottomCloudsSprite_A->render();
-    bottomCloudsSprite_B->setSpriteClip(bottomCloudsRect[(gradientNumber + 1) % 4]);
-    bottomCloudsSprite_B->render();
+    // Dibuja el primer conjunto de nubes, las de detras
+    bottom_clouds_texture_->setAlpha(255);
+    bottom_clouds_sprite_a_->setSpriteClip(bottom_clouds_rect_[(gradient_number_ + 1) % 4]);
+    bottom_clouds_sprite_b_->setSpriteClip(bottom_clouds_rect_[(gradient_number_ + 1) % 4]);
+    bottom_clouds_sprite_a_->render();
+    bottom_clouds_sprite_b_->render();
 
-    // Dibuja el segundo conjunto de nubes
-    bottomCloudsTexture->setAlpha(alpha);
-    bottomCloudsSprite_A->setSpriteClip(bottomCloudsRect[gradientNumber]);
-    bottomCloudsSprite_A->render();
-    bottomCloudsSprite_B->setSpriteClip(bottomCloudsRect[gradientNumber]);
-    bottomCloudsSprite_B->render();
+    // Dibuja el segundo conjunto de nubes, las de delante
+    bottom_clouds_texture_->setAlpha(alpha_);
+    bottom_clouds_sprite_a_->setSpriteClip(bottom_clouds_rect_[gradient_number_]);
+    bottom_clouds_sprite_b_->setSpriteClip(bottom_clouds_rect_[gradient_number_]);
+    bottom_clouds_sprite_a_->render();
+    bottom_clouds_sprite_b_->render();
 }
 
 // Compone todos los elementos del fondo en la textura
 void Background::fillCanvas()
 {
     // Cambia el destino del renderizador
-    SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-    SDL_SetRenderTarget(renderer, canvas);
+    auto temp = SDL_GetRenderTarget(renderer_);
+    SDL_SetRenderTarget(renderer_, canvas_);
 
     // Dibuja el gradiente de fondo
     renderGradient();
@@ -193,119 +176,114 @@ void Background::fillCanvas()
     renderBottomClouds();
 
     // Dibuja los edificios
-    buildingsSprite->render();
+    buildings_sprite_->render();
 
     // Dibuja la hierba
-    grassSprite->render();
+    grass_sprite_->render();
 
     // Deja el renderizador apuntando donde estaba
-    SDL_SetRenderTarget(renderer, temp);
+    SDL_SetRenderTarget(renderer_, temp);
 }
 
 // Dibuja el objeto
 void Background::render()
 {
     // Fondo
-    SDL_RenderCopy(renderer, canvas, &srcRect, &dstRect);
+    SDL_RenderCopy(renderer_, canvas_, &src_rect_, &dst_rect_);
 
     // Atenuación
-    SDL_RenderCopy(renderer, colorTexture, &srcRect, &dstRect);
+    SDL_RenderCopy(renderer_, color_texture_, &src_rect_, &dst_rect_);
 }
 
 // Vuelve a cargar las texturas
 void Background::reloadTextures()
 {
-    buildingsTexture->reLoad();
-    topCloudsTexture->reLoad();
-    bottomCloudsTexture->reLoad();
-    grassTexture->reLoad();
-    gradientsTexture->reLoad();
+    buildings_texture_->reLoad();
+    top_clouds_texture_->reLoad();
+    bottom_clouds_texture_->reLoad();
+    grass_texture_->reLoad();
+    gradients_texture_->reLoad();
 }
 
 // Ajusta el valor de la variable
 void Background::setCloudsSpeed(float value)
 {
-    cloudsSpeed = value;
+    clouds_speed_ = value;
 }
 
 // Ajusta el valor de la variable
 void Background::setGradientNumber(int value)
 {
-    gradientNumber = value % 4;
+    gradient_number_ = value % 4;
 }
 
 // Ajusta el valor de la variable
 void Background::setTransition(float value)
 {
-    value = std::min(value, 1.0f);
-    value = std::max(value, 0.0f);
-    transition = value;
+    transition_ = std::clamp(value, 0.0f, 1.0f);
 }
 
 // Establece la posición del objeto
 void Background::setPos(SDL_Rect pos)
 {
-    this->dstRect = pos;
+    dst_rect_ = pos;
 
     // Si cambian las medidas del destino, hay que cambiar las del origen para evitar deformar la imagen
-    this->srcRect.x = 0;
-    this->srcRect.y = rect.h - pos.h;
-    this->srcRect.w = pos.w;
-    this->srcRect.h = pos.h;
+    src_rect_.x = 0;
+    src_rect_.y = rect_.h - pos.h;
+    src_rect_.w = pos.w;
+    src_rect_.h = pos.h;
 }
 
 // Ajusta el valor de la variable
 void Background::setSrcRect(SDL_Rect value)
 {
-    srcRect = value;
+    src_rect_ = value;
 }
 
 // Ajusta el valor de la variable
 void Background::setDstRect(SDL_Rect value)
 {
-    dstRect = value;
+    dst_rect_ = value;
 }
 
-// Establece el color de atenuación
-void Background::setColor(color_t color)
+// Establece el color_ de atenuación
+void Background::setColor(Color color)
 {
-    this->color = color;
+    color_ = color;
 
     // Colorea la textura
-    SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-    SDL_SetRenderTarget(renderer, colorTexture);
+    auto temp = SDL_GetRenderTarget(renderer_);
+    SDL_SetRenderTarget(renderer_, color_texture_);
 
-    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 255);
-    SDL_RenderClear(renderer);
+    SDL_SetRenderDrawColor(renderer_, color_.r, color_.g, color_.b, 255);
+    SDL_RenderClear(renderer_);
 
-    SDL_SetRenderTarget(renderer, temp);
+    SDL_SetRenderTarget(renderer_, temp);
 }
 
 // Establece la transparencia de la atenuación
 void Background::setAlpha(int alpha)
 {
     // Evita que se asignen valores fuera de rango
-    alpha = std::min(alpha, 255);
-    alpha = std::max(alpha, 0);
+    alpha_ = std::clamp(alpha, 0, 255);
 
-    // Guarda el valor actual
-    alphaColorTextTemp = alphaColorText;
-
-    // Establece el nuevo valor
-    alphaColorText = alpha;
+    // Guarda el valor actual y establece el nuevo valor
+    alpha_color_text_temp_ = alpha_color_text_;
+    alpha_color_text_ = alpha_;
 }
 
-// Actualiza el valor de alpha
+// Actualiza el valor de alpha_
 void Background::updateAlphaColorText()
 {
-    if (alphaColorText == alphaColorTextTemp)
+    if (alpha_color_text_ == alpha_color_text_temp_)
     {
         return;
     }
     else
     {
-        alphaColorText > alphaColorTextTemp ? alphaColorTextTemp++ : alphaColorTextTemp--;
-        SDL_SetTextureAlphaMod(colorTexture, alphaColorTextTemp);
+        alpha_color_text_ > alpha_color_text_temp_ ? ++alpha_color_text_temp_ : --alpha_color_text_temp_;
+        SDL_SetTextureAlphaMod(color_texture_, alpha_color_text_temp_);
     }
 }
 
@@ -313,35 +291,35 @@ void Background::updateAlphaColorText()
 void Background::updateClouds()
 {
     // Aplica la velocidad calculada a las nubes
-    topCloudsSprite_A->setVelX(cloudsSpeed);
-    topCloudsSprite_B->setVelX(cloudsSpeed);
-    bottomCloudsSprite_A->setVelX(cloudsSpeed / 2);
-    bottomCloudsSprite_B->setVelX(cloudsSpeed / 2);
+    top_clouds_sprite_a_->setVelX(clouds_speed_);
+    top_clouds_sprite_b_->setVelX(clouds_speed_);
+    bottom_clouds_sprite_a_->setVelX(clouds_speed_ / 2);
+    bottom_clouds_sprite_b_->setVelX(clouds_speed_ / 2);
 
     // Mueve las nubes
-    topCloudsSprite_A->move();
-    topCloudsSprite_B->move();
-    bottomCloudsSprite_A->move();
-    bottomCloudsSprite_B->move();
+    top_clouds_sprite_a_->move();
+    top_clouds_sprite_b_->move();
+    bottom_clouds_sprite_a_->move();
+    bottom_clouds_sprite_b_->move();
 
     // Calcula el offset de las nubes
-    if (topCloudsSprite_A->getPosX() < -topCloudsSprite_A->getWidth())
+    if (top_clouds_sprite_a_->getPosX() < -top_clouds_sprite_a_->getWidth())
     {
-        topCloudsSprite_A->setPosX(topCloudsSprite_A->getWidth());
+        top_clouds_sprite_a_->setPosX(top_clouds_sprite_a_->getWidth());
     }
 
-    if (topCloudsSprite_B->getPosX() < -topCloudsSprite_B->getWidth())
+    if (top_clouds_sprite_b_->getPosX() < -top_clouds_sprite_b_->getWidth())
     {
-        topCloudsSprite_B->setPosX(topCloudsSprite_B->getWidth());
+        top_clouds_sprite_b_->setPosX(top_clouds_sprite_b_->getWidth());
     }
 
-    if (bottomCloudsSprite_A->getPosX() < -bottomCloudsSprite_A->getWidth())
+    if (bottom_clouds_sprite_a_->getPosX() < -bottom_clouds_sprite_a_->getWidth())
     {
-        bottomCloudsSprite_A->setPosX(bottomCloudsSprite_A->getWidth());
+        bottom_clouds_sprite_a_->setPosX(bottom_clouds_sprite_a_->getWidth());
     }
 
-    if (bottomCloudsSprite_B->getPosX() < -bottomCloudsSprite_B->getWidth())
+    if (bottom_clouds_sprite_b_->getPosX() < -bottom_clouds_sprite_b_->getWidth())
     {
-        bottomCloudsSprite_B->setPosX(bottomCloudsSprite_B->getWidth());
+        bottom_clouds_sprite_b_->setPosX(bottom_clouds_sprite_b_->getWidth());
     }
 }

source/background.h

@@ -2,8 +2,8 @@
 
 #include <SDL2/SDL_rect.h>    // for SDL_Rect
 #include <SDL2/SDL_render.h>  // for SDL_Renderer, SDL_Texture
-#include "utils.h"            // for color_t
-class Asset;
+#include <memory>             // for unique_ptr, shared_ptr
+#include "utils.h"            // for Color
 class MovingSprite;
 class Sprite;
 class Texture;
@@ -38,7 +38,7 @@ class Texture;
         - 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)
@@ -50,43 +50,42 @@ class Background
 {
 private:
   // Objetos y punteros
-  SDL_Renderer *renderer; // El renderizador de la ventana
-  Asset *asset;           // Objeto que gestiona todos los ficheros de recursos
+  SDL_Renderer *renderer_; // El renderizador de la ventana
 
-  Texture *buildingsTexture;    // Textura con los edificios de fondo
-  Texture *topCloudsTexture;    // Textura con las nubes de fondo
-  Texture *bottomCloudsTexture; // Textura con las nubes de fondo
-  Texture *grassTexture;        // Textura con la hierba del suelo
-  Texture *gradientsTexture;    // Textura con los diferentes colores de fondo del juego
+  std::shared_ptr<Texture> buildings_texture_;     // Textura con los edificios de fondo
+  std::shared_ptr<Texture> top_clouds_texture_;    // Textura con las nubes de fondo
+  std::shared_ptr<Texture> bottom_clouds_texture_; // Textura con las nubes de fondo
+  std::shared_ptr<Texture> grass_texture_;         // Textura con la hierba del suelo
+  std::shared_ptr<Texture> gradients_texture_;     // Textura con los diferentes colores de fondo del juego
 
-  MovingSprite *topCloudsSprite_A;    // Sprite para las nubes superiores
-  MovingSprite *topCloudsSprite_B;    // Sprite para las nubes superiores
-  MovingSprite *bottomCloudsSprite_A; // Sprite para las nubes inferiores
-  MovingSprite *bottomCloudsSprite_B; // Sprite para las nubes inferiores
+  std::unique_ptr<MovingSprite> top_clouds_sprite_a_;    // Sprite para las nubes superiores
+  std::unique_ptr<MovingSprite> top_clouds_sprite_b_;    // Sprite para las nubes superiores
+  std::unique_ptr<MovingSprite> bottom_clouds_sprite_a_; // Sprite para las nubes inferiores
+  std::unique_ptr<MovingSprite> bottom_clouds_sprite_b_; // Sprite para las nubes inferiores
 
-  Sprite *buildingsSprite; // Sprite con los edificios de fondo
-  Sprite *gradientSprite;  // Sprite con los graficos del degradado de color de fondo
-  Sprite *grassSprite;     // Sprite para la hierba
+  std::unique_ptr<Sprite> buildings_sprite_; // Sprite con los edificios de fondo
+  std::unique_ptr<Sprite> gradient_sprite_;  // Sprite con los graficos del degradado de color de fondo
+  std::unique_ptr<Sprite> grass_sprite_;     // Sprite para la hierba
 
-  SDL_Texture *canvas;       // Textura para componer el fondo
-  SDL_Texture *colorTexture; // Textura para atenuar el fondo
+  SDL_Texture *canvas_;        // Textura para componer el fondo
+  SDL_Texture *color_texture_; // Textura para atenuar el fondo
 
   // Variables
-  SDL_Rect gradientRect[4];     // Vector con las coordenadas de los 4 degradados para el cielo
-  SDL_Rect topCloudsRect[4];    // Vector con las coordenadas de los 4 nubes de arriba
-  SDL_Rect bottomCloudsRect[4]; // Vector con las coordenadas de los 4 nubes de abajo
-  int gradientNumber;           // Indica el número de degradado de fondo que se va a dibujar
-  int alpha;                    // Transparencia entre los dos degradados
-  float cloudsSpeed;            // Velocidad a la que se desplazan las nubes
-  float transition;             // Nivel de transición del fondo 0..1
-  int counter;                  // Contador interno
-  SDL_Rect rect;                // Tamaño del objeto fondo
-  SDL_Rect srcRect;             // Parte del objeto fondo que se va a dibujará en pantalla
-  SDL_Rect dstRect;             // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
-  int base;                     // Linea de fondo coincidente con el area inferior de la zona de juego
-  color_t color;                // Color para atenuar el fondo
-  int alphaColorText;           // Alpha para atenuar el fondo
-  int alphaColorTextTemp;       // Valor temporal para hacer la transición de alpha
+  SDL_Rect gradient_rect_[4];      // Vector con las coordenadas de los 4 degradados para el cielo
+  SDL_Rect top_clouds_rect_[4];    // Vector con las coordenadas de los 4 nubes de arriba
+  SDL_Rect bottom_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de abajo
+  int gradient_number_;            // Indica el número de degradado de fondo que se va a dibujar
+  int alpha_;                      // Transparencia entre los dos degradados
+  float clouds_speed_;             // Velocidad a la que se desplazan las nubes
+  float transition_;               // Nivel de transición del fondo 0..1
+  int counter_;                    // Contador interno
+  SDL_Rect rect_;                  // Tamaño del objeto fondo
+  SDL_Rect src_rect_;              // Parte del objeto fondo que se va a dibujará en pantalla
+  SDL_Rect dst_rect_;              // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
+  int base_;                       // Linea de fondo coincidente con el area inferior de la zona de juego
+  Color color_;                    // Color para atenuar el fondo
+  int alpha_color_text_;           // Alpha para atenuar el fondo
+  int alpha_color_text_temp_;      // Valor temporal para hacer la transición de alpha
 
   // Dibuja el gradiente de fondo
   void renderGradient();
@@ -108,7 +107,7 @@ private:
 
 public:
   // Constructor
-  Background(SDL_Renderer *renderer);
+  explicit Background(SDL_Renderer *renderer);
 
   // Destructor
   ~Background();
@@ -141,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,77 +1,78 @@
 #pragma once
 
-#include <SDL2/SDL_stdinc.h>  // for Uint8, Uint16, Uint32
-#include <string>             // for string
-#include <vector>             // for vector
-#include "utils.h"            // for circle_t
-class AnimatedSprite;
+#include <SDL2/SDL_stdinc.h> // for Uint8, Uint16, Uint32
+#include <memory>			 // for shared_ptr, unique_ptr
+#include <string>			 // for string
+#include <vector>			 // for vector
+#include "animated_sprite.h" // for AnimatedSprite
+#include "utils.h"			 // for Circle
 class Texture;
 
 // Cantidad de elementos del vector con los valores de la deformación del globo al rebotar
-#define MAX_BOUNCE 10
+constexpr int MAX_BOUNCE = 10;
 
 // Tipos de globo
-#define BALLOON_1 1
-#define BALLOON_2 2
-#define BALLOON_3 3
-#define BALLOON_4 4
-#define HEXAGON_1 5
-#define HEXAGON_2 6
-#define HEXAGON_3 7
-#define HEXAGON_4 8
-#define POWER_BALL 9
+constexpr int BALLOON_1 = 1;
+constexpr int BALLOON_2 = 2;
+constexpr int BALLOON_3 = 3;
+constexpr int BALLOON_4 = 4;
+constexpr int HEXAGON_1 = 5;
+constexpr int HEXAGON_2 = 6;
+constexpr int HEXAGON_3 = 7;
+constexpr int HEXAGON_4 = 8;
+constexpr int POWER_BALL = 9;
 
 // Puntos de globo
-#define BALLOON_SCORE_1 50
-#define BALLOON_SCORE_2 100
-#define BALLOON_SCORE_3 200
-#define BALLOON_SCORE_4 400
+constexpr int BALLOON_SCORE_1 = 50;
+constexpr int BALLOON_SCORE_2 = 100;
+constexpr int BALLOON_SCORE_3 = 200;
+constexpr int BALLOON_SCORE_4 = 400;
 
 // Tamaños de globo
-#define BALLOON_SIZE_1 1
-#define BALLOON_SIZE_2 2
-#define BALLOON_SIZE_3 3
-#define BALLOON_SIZE_4 4
+constexpr int BALLOON_SIZE_1 = 1;
+constexpr int BALLOON_SIZE_2 = 2;
+constexpr int BALLOON_SIZE_3 = 3;
+constexpr int BALLOON_SIZE_4 = 4;
 
 // Clases de globo
-#define BALLOON_CLASS 0
-#define HEXAGON_CLASS 1
+constexpr int BALLOON_CLASS = 0;
+constexpr int HEXAGON_CLASS = 1;
 
 // Velocidad del globo
-#define BALLOON_VELX_POSITIVE 0.7f
-#define BALLOON_VELX_NEGATIVE -0.7f
+constexpr float BALLOON_VELX_POSITIVE = 0.7f;
+constexpr float BALLOON_VELX_NEGATIVE = -0.7f;
 
 // Indice para las animaciones de los globos
-#define BALLOON_MOVING_ANIMATION 0
-#define BALLOON_POP_ANIMATION 1
-#define BALLOON_BORN_ANIMATION 2
+constexpr int BALLOON_MOVING_ANIMATION = 0;
+constexpr int BALLOON_POP_ANIMATION = 1;
+constexpr int BALLOON_BORN_ANIMATION = 2;
 
 // Cantidad posible de globos
-#define MAX_BALLOONS 100
+constexpr int MAX_BALLOONS = 100;
 
 // Velocidades a las que se mueven los globos
-#define BALLOON_SPEED_1 0.60f
-#define BALLOON_SPEED_2 0.70f
-#define BALLOON_SPEED_3 0.80f
-#define BALLOON_SPEED_4 0.90f
-#define BALLOON_SPEED_5 1.00f
+constexpr float BALLOON_SPEED_1 = 0.60f;
+constexpr float BALLOON_SPEED_2 = 0.70f;
+constexpr float BALLOON_SPEED_3 = 0.80f;
+constexpr float BALLOON_SPEED_4 = 0.90f;
+constexpr float BALLOON_SPEED_5 = 1.00f;
 
 // Tamaño de los globos
-#define BALLOON_WIDTH_1 10
-#define BALLOON_WIDTH_2 16
-#define BALLOON_WIDTH_3 26
-#define BALLOON_WIDTH_4 46
+constexpr int BALLOON_WIDTH_1 = 10;
+constexpr int BALLOON_WIDTH_2 = 16;
+constexpr int BALLOON_WIDTH_3 = 26;
+constexpr int BALLOON_WIDTH_4 = 46;
 
 // PowerBall
-#define POWERBALL_SCREENPOWER_MINIMUM 10
-#define POWERBALL_COUNTER 8
+constexpr int POWERBALL_SCREENPOWER_MINIMUM = 10;
+constexpr int POWERBALL_COUNTER = 8;
 
 // Clase Balloon
 class Balloon
 {
 private:
 	// Estructura para las variables para el efecto de los rebotes
-	struct bouncing
+	struct Bouncing
 	{
 		bool enabled;		  // Si el efecto está activo
 		Uint8 counter;		  // Countador para el efecto
@@ -85,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 posY;				   // Posición en el eje Y
-	Uint8 width;			   // Ancho
-	Uint8 height;			   // Alto
-	float velX;				   // Velocidad en el eje X. Cantidad de pixeles a desplazarse
-	float velY;				   // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
-	float gravity;			   // Aceleración en el eje Y. Modifica la velocidad
-	float defaultVelY;		   // Velocidad inicial que tienen al rebotar contra el suelo
-	float maxVelY;			   // Máxima velocidad que puede alcanzar el objeto en el eje Y
-	bool beingCreated;		   // Indica si el globo se está creando
-	bool blinking;			   // Indica si el globo está intermitente
-	bool enabled;			   // Indica si el globo esta activo
-	bool invulnerable;		   // Indica si el globo es invulnerable
-	bool stopped;			   // Indica si el globo está parado
-	bool visible;			   // Indica si el globo es visible
-	circle_t collider;		   // Circulo de colisión del objeto
-	Uint16 creationCounter;	   // Temporizador para controlar el estado "creandose"
-	Uint16 creationCounterIni; // Valor inicial para el temporizador para controlar el estado "creandose"
-	Uint16 score;			   // Puntos que da el globo al ser destruido
-	Uint16 stoppedCounter;	   // Contador para controlar el estado "parado"
-	Uint8 kind;				   // Tipo de globo
-	Uint8 menace;			   // Cantidad de amenaza que genera el globo
-	Uint32 counter;			   // Contador interno
-	float travelY;			   // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
-	float speed;			   // Velocidad a la que se mueven los globos
-	Uint8 size;				   // Tamaño del globo
-	Uint8 power;			   // Cantidad de poder que alberga el globo
-	bouncing bouncing;		   // Contiene las variables para el efecto de rebote
+	float pos_x_;				  // Posición en el eje X
+	float pos_y_;				  // Posición en el eje Y
+	Uint8 width_;				  // Ancho
+	Uint8 height_;				  // Alto
+	float vel_x_;				  // Velocidad en el eje X. Cantidad de pixeles a desplazarse
+	float vel_y_;				  // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
+	float gravity_;				  // Aceleración en el eje Y. Modifica la velocidad
+	float default_vel_y_;		  // Velocidad inicial que tienen al rebotar contra el suelo
+	float max_vel_y_;			  // Máxima velocidad que puede alcanzar el objeto en el eje Y
+	bool being_created_;		  // Indica si el globo se está creando
+	bool blinking_;				  // Indica si el globo está intermitente
+	bool enabled_;				  // Indica si el globo esta activo
+	bool invulnerable_;			  // Indica si el globo es invulnerable
+	bool stopped_;				  // Indica si el globo está parado
+	bool visible_;				  // Indica si el globo es visible
+	Circle collider_;			  // Circulo de colisión del objeto
+	Uint16 creation_counter_;	  // Temporizador para controlar el estado "creandose"
+	Uint16 creation_counter_ini_; // Valor inicial para el temporizador para controlar el estado "creandose"
+	Uint16 score_;				  // Puntos que da el globo al ser destruido
+	Uint16 stopped_counter_;	  // Contador para controlar el estado "parado"
+	Uint8 kind_;				  // Tipo de globo
+	Uint8 menace_;				  // Cantidad de amenaza que genera el globo
+	Uint32 counter_;			  // Contador interno
+	float travel_y_;			  // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
+	float speed_;				  // Velocidad a la que se mueven los globos
+	Uint8 size_;				  // Tamaño del globo
+	Uint8 power_;				  // Cantidad de poder que alberga el globo
+	Bouncing bouncing_;			  // Contiene las variables para el efecto de rebote
 
 	// Alinea el circulo de colisión con la posición del objeto globo
 	void updateColliders();
@@ -140,10 +141,10 @@ private:
 
 public:
 	// Constructor
-	Balloon(float x, float y, Uint8 kind, float velx, float speed, Uint16 creationtimer, Texture *texture, std::vector<std::string> *animation);
+	Balloon(float x, float y, Uint8 kind, float vel_x, float speed, Uint16 creation_timer, std::shared_ptr<Texture> texture, std::vector<std::string> *animation);
 
 	// Destructor
-	~Balloon();
+	~Balloon() = default;
 
 	// Centra el globo en la posición X
 	void allignTo(int x);
@@ -164,86 +165,86 @@ public:
 	void update();
 
 	// Comprueba si el globo está habilitado
-	bool isEnabled();
+	bool isEnabled() const;
 
 	// Obtiene del valor de la variable
-	float getPosX();
+	float getPosX() const;
 
 	// Obtiene del valor de la variable
-	float getPosY();
+	float getPosY() const;
 
 	// Obtiene del valor de la variable
-	float getVelY();
+	float getVelY() const;
 
 	// Obtiene del valor de la variable
-	int getWidth();
+	int getWidth() const;
 
 	// Obtiene del valor de la variable
-	int getHeight();
+	int getHeight() const;
 
 	// Establece el valor de la variable
-	void setVelY(float velY);
+	void setVelY(float vel_y);
 
 	// Establece el valor de la variable
 	void setSpeed(float speed);
 
 	// Obtiene del valor de la variable
-	int getKind();
+	int getKind() const;
 
 	// Obtiene del valor de la variable
-	Uint8 getSize();
+	Uint8 getSize() const;
 
 	// Obtiene la clase a la que pertenece el globo
-	Uint8 getClass();
+	Uint8 getClass() const;
 
 	// Establece el valor de la variable
 	void setStop(bool value);
 
 	// Obtiene del valor de la variable
-	bool isStopped();
+	bool isStopped() const;
 
 	// Establece el valor de la variable
 	void setBlink(bool value);
 
 	// Obtiene del valor de la variable
-	bool isBlinking();
+	bool isBlinking() const;
 
 	// Establece el valor de la variable
 	void setVisible(bool value);
 
 	// Obtiene del valor de la variable
-	bool isVisible();
+	bool isVisible() const;
 
 	// Establece el valor de la variable
 	void setInvulnerable(bool value);
 
 	// Obtiene del valor de la variable
-	bool isInvulnerable();
+	bool isInvulnerable() const;
 
 	// Obtiene del valor de la variable
-	bool isBeingCreated();
+	bool isBeingCreated() const;
 
 	// Establece el valor de la variable
 	void setStoppedTimer(Uint16 time);
 
 	// Obtiene del valor de la variable
-	Uint16 getStoppedTimer();
+	Uint16 getStoppedTimer() const;
 
 	// Obtiene del valor de la variable
-	Uint16 getScore();
+	Uint16 getScore() const;
 
 	// Obtiene el circulo de colisión
-	circle_t &getCollider();
+	Circle &getCollider();
 
 	// Obtiene le valor de la variable
-	Uint8 getMenace();
+	Uint8 getMenace() const;
 
 	// Obtiene le valor de la variable
-	Uint8 getPower();
+	Uint8 getPower() const;
 
 	// Indica si el globo se puede explotar
-	bool canBePopped();
+	bool canBePopped() const;
 
 	// Indica si el globo se puede destruir
-	bool canBeDestroyed();
+	bool canBeDestroyed() const;
 };

source/balloon_formations.cpp

@@ -0,0 +1,718 @@
+#include "balloon_formations.h"
+#include "balloon.h" // for BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
+#include "param.h"	 // for param
+#include "utils.h"	 // for ParamGame, Param, Zone, BLOCK
+
+// Constructor
+BalloonFormations::BalloonFormations()
+{
+	initBalloonFormations();
+	initBalloonFormationPools();
+	initGameStages();
+}
+
+// Inicializa las formaciones enemigas
+void BalloonFormations::initBalloonFormations()
+{
+	constexpr int y4 = -BLOCK;
+	const int x4_0 = param.game.play_area.rect.x;
+	const int x4_100 = param.game.play_area.rect.w - BALLOON_WIDTH_4;
+
+	constexpr int y3 = -BLOCK;
+	const int x3_0 = param.game.play_area.rect.x;
+	const int x3_100 = param.game.play_area.rect.w - BALLOON_WIDTH_3;
+
+	constexpr int y2 = -BLOCK;
+	const int x2_0 = param.game.play_area.rect.x;
+	const int x2_100 = param.game.play_area.rect.w - BALLOON_WIDTH_2;
+
+	constexpr int y1 = -BLOCK;
+	const int x1_0 = param.game.play_area.rect.x;
+	const int x1_50 = param.game.play_area.center_x - (BALLOON_WIDTH_1 / 2);
+	const int x1_100 = param.game.play_area.rect.w - BALLOON_WIDTH_1;
+
+	// Inicializa a cero las variables
+	for (int i = 0; i < NUMBER_OF_BALLOON_FORMATIONS; i++)
+	{
+		balloon_formation_[i].number_of_balloons = 0;
+		for (int j = 0; j < MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION; j++)
+		{
+			balloon_formation_[i].init[j].x = 0;
+			balloon_formation_[i].init[j].y = 0;
+			balloon_formation_[i].init[j].vel_x = 0;
+			balloon_formation_[i].init[j].kind = 0;
+			balloon_formation_[i].init[j].creation_counter = 0;
+		}
+	}
+
+	const int creation_time = 300;
+	int inc_x = 0;
+	int inc_time = 0;
+	int j = 0;
+
+	// #00 - Dos enemigos BALLOON4 uno a cada extremo
+	j = 0;
+	balloon_formation_[j].number_of_balloons = 2;
+	inc_x = x4_100;
+	inc_time = 0;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x4_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y4;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
+		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].creation_counter = creation_time + (inc_time * i);
+	}
+
+	// #01 - Dos enemigos BALLOON4 uno a cada cuarto. Ambos van hacia el centro
+	j = 1;
+	balloon_formation_[j].number_of_balloons = 2;
+	inc_x = param.game.play_area.center_x;
+	inc_time = 0;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = param.game.play_area.first_quarter_x - (BALLOON_WIDTH_4 / 2) + (i * inc_x);
+		balloon_formation_[j].init[i].y = y4;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
+		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].creation_counter = creation_time + (inc_time * i);
+	}
+
+	// #02 - Cuatro enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
+	j = 2;
+	balloon_formation_[j].number_of_balloons = 4;
+	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x2_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y2;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_2;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #03 - Cuatro enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
+	j = 3;
+	balloon_formation_[j].number_of_balloons = 4;
+	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x2_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y2;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_2;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #04 - Tres enemigos BALLOON3. 0, 25, 50. Hacia la derecha
+	j = 4;
+	balloon_formation_[j].number_of_balloons = 3;
+	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #05 - Tres enemigos BALLOON3. 50, 75, 100. Hacia la izquierda
+	j = 5;
+	balloon_formation_[j].number_of_balloons = 3;
+	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #06 - Tres enemigos BALLOON3. 0, 0, 0. Hacia la derecha
+	j = 6;
+	balloon_formation_[j].number_of_balloons = 3;
+	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #07 - Tres enemigos BALLOON3. 100, 100, 100. Hacia la izquierda
+	j = 7;
+	balloon_formation_[j].number_of_balloons = 3;
+	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #08 - Seis enemigos BALLOON1. 0, 0, 0, 0, 0, 0. Hacia la derecha
+	j = 8;
+	balloon_formation_[j].number_of_balloons = 6;
+	inc_x = BALLOON_WIDTH_1 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x1_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y1;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #09 - Seis enemigos BALLOON1. 100, 100, 100, 100, 100, 100. Hacia la izquierda
+	j = 9;
+	balloon_formation_[j].number_of_balloons = 6;
+	inc_x = BALLOON_WIDTH_1 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x1_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y1;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #10 - Tres enemigos BALLOON4 seguidos desde la izquierda
+	j = 10;
+	balloon_formation_[j].number_of_balloons = 3;
+	inc_x = BALLOON_WIDTH_4 + 1;
+	inc_time = 15;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x4_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y4;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #11 - Tres enemigos BALLOON4 seguidos desde la derecha
+	j = 11;
+	balloon_formation_[j].number_of_balloons = 3;
+	inc_x = BALLOON_WIDTH_4 + 1;
+	inc_time = 15;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x4_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y4;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #12 - Seis enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
+	j = 12;
+	balloon_formation_[j].number_of_balloons = 6;
+	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x2_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y2;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_2;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #13 - Seis enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
+	j = 13;
+	balloon_formation_[j].number_of_balloons = 6;
+	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x2_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y2;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_2;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #14 - Cinco enemigos BALLOON3. Hacia la derecha. Separados
+	j = 14;
+	balloon_formation_[j].number_of_balloons = 5;
+	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #15 - Cinco enemigos BALLOON3. Hacia la izquierda. Separados
+	j = 15;
+	balloon_formation_[j].number_of_balloons = 5;
+	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #16 - Cinco enemigos BALLOON3. Hacia la derecha. Juntos
+	j = 16;
+	balloon_formation_[j].number_of_balloons = 5;
+	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #17 - Cinco enemigos BALLOON3. Hacia la izquierda. Juntos
+	j = 17;
+	balloon_formation_[j].number_of_balloons = 5;
+	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #18 - Doce enemigos BALLOON1. Hacia la derecha. Juntos
+	j = 18;
+	balloon_formation_[j].number_of_balloons = 12;
+	inc_x = BALLOON_WIDTH_1 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x1_0 + (i * inc_x);
+		balloon_formation_[j].init[i].y = y1;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #19 - Doce enemigos BALLOON1. Hacia la izquierda. Juntos
+	j = 19;
+	balloon_formation_[j].number_of_balloons = 12;
+	inc_x = BALLOON_WIDTH_1 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		balloon_formation_[j].init[i].x = x1_100 - (i * inc_x);
+		balloon_formation_[j].init[i].y = y1;
+		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].creation_counter = creation_time - (inc_time * i);
+	}
+
+	// #20 - Dos enemigos BALLOON4 seguidos desde la izquierda/derecha. Simetricos
+	j = 20;
+	balloon_formation_[j].number_of_balloons = 4;
+	inc_x = BALLOON_WIDTH_4 + 1;
+	inc_time = 0;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		const int half = balloon_formation_[j].number_of_balloons / 2;
+		if (i < half)
+		{
+			balloon_formation_[j].init[i].x = x4_0 + (i * inc_x);
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+		}
+		else
+		{
+			balloon_formation_[j].init[i].x = x4_100 - ((i - half) * inc_x);
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+		}
+		balloon_formation_[j].init[i].y = y4;
+		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].creation_counter = creation_time + (inc_time * i);
+	}
+
+	// #21 - Diez enemigos BALLOON2 uno detras del otro. Izquierda/derecha. Simetricos
+	j = 21;
+	balloon_formation_[j].number_of_balloons = 10;
+	inc_x = BALLOON_WIDTH_2 + 1;
+	inc_time = 3;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		const int half = balloon_formation_[j].number_of_balloons / 2;
+		if (i < half)
+		{
+			balloon_formation_[j].init[i].x = x2_0 + (i * inc_x);
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * i);
+		}
+		else
+		{
+			balloon_formation_[j].init[i].x = x2_100 - ((i - half) * inc_x);
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * (i - half));
+		}
+		balloon_formation_[j].init[i].y = y2;
+		balloon_formation_[j].init[i].kind = BALLOON_2;
+	}
+
+	// #22 - Diez enemigos BALLOON3. Hacia la derecha/izquierda. Separados. Simetricos
+	j = 22;
+	balloon_formation_[j].number_of_balloons = 10;
+	inc_x = BALLOON_WIDTH_3 * 2;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		const int half = balloon_formation_[j].number_of_balloons / 2;
+		if (i < half)
+		{
+			balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * i);
+		}
+		else
+		{
+			balloon_formation_[j].init[i].x = x3_100 - ((i - half) * inc_x);
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * (i - half));
+		}
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+	}
+
+	// #23 - Diez enemigos BALLOON3. Hacia la derecha. Juntos. Simetricos
+	j = 23;
+	balloon_formation_[j].number_of_balloons = 10;
+	inc_x = BALLOON_WIDTH_3 + 1;
+	inc_time = 10;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		const int half = balloon_formation_[j].number_of_balloons / 2;
+		if (i < half)
+		{
+			balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * i);
+		}
+		else
+		{
+			balloon_formation_[j].init[i].x = x3_100 - ((i - half) * inc_x);
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * (i - half));
+		}
+		balloon_formation_[j].init[i].y = y3;
+		balloon_formation_[j].init[i].kind = BALLOON_3;
+	}
+
+	// #24 - Treinta enemigos BALLOON1. Del centro hacia los extremos. Juntos. Simetricos
+	j = 24;
+	balloon_formation_[j].number_of_balloons = 30;
+	inc_time = 5;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		const int half = balloon_formation_[j].number_of_balloons / 2;
+		if (i < half)
+		{
+			balloon_formation_[j].init[i].x = x1_50;
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+			balloon_formation_[j].init[i].creation_counter = (creation_time) + (inc_time * i);
+		}
+		else
+		{
+			balloon_formation_[j].init[i].x = x1_50;
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+			balloon_formation_[j].init[i].creation_counter = (creation_time) + (inc_time * (i - half));
+		}
+		balloon_formation_[j].init[i].y = y1;
+		balloon_formation_[j].init[i].kind = BALLOON_1;
+	}
+
+	// #25 - Treinta enemigos BALLOON1. Del centro hacia adentro. Juntos. Simetricos
+	j = 25;
+	balloon_formation_[j].number_of_balloons = 30;
+	inc_time = 5;
+	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
+	{
+		const int half = balloon_formation_[j].number_of_balloons / 2;
+		if (i < half)
+		{
+			balloon_formation_[j].init[i].x = x1_50 + 20;
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
+			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * i);
+		}
+		else
+		{
+			balloon_formation_[j].init[i].x = x1_50 - 20;
+			balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
+			balloon_formation_[j].init[i].creation_counter = (creation_time) - (inc_time * (i - half));
+		}
+		balloon_formation_[j].init[i].y = y1;
+		balloon_formation_[j].init[i].kind = BALLOON_1;
+	}
+
+	// Crea las mismas formaciones pero con hexagonos a partir de la posición 50 del vector
+	for (int k = 0; k < j + 1; k++)
+	{
+		balloon_formation_[k + 50].number_of_balloons = balloon_formation_[k].number_of_balloons;
+		for (int i = 0; i < balloon_formation_[k + 50].number_of_balloons; i++)
+		{
+			balloon_formation_[k + 50].init[i].x = balloon_formation_[k].init[i].x;
+			balloon_formation_[k + 50].init[i].y = balloon_formation_[k].init[i].y;
+			balloon_formation_[k + 50].init[i].vel_x = balloon_formation_[k].init[i].vel_x;
+			balloon_formation_[k + 50].init[i].creation_counter = balloon_formation_[k].init[i].creation_counter;
+			balloon_formation_[k + 50].init[i].kind = balloon_formation_[k].init[i].kind + 4;
+		}
+	}
+
+	// TEST
+	balloon_formation_[99].number_of_balloons = 4;
+
+	balloon_formation_[99].init[0].x = 10;
+	balloon_formation_[99].init[0].y = y1;
+	balloon_formation_[99].init[0].vel_x = 0;
+	balloon_formation_[99].init[0].kind = BALLOON_1;
+	balloon_formation_[99].init[0].creation_counter = 200;
+
+	balloon_formation_[99].init[1].x = 50;
+	balloon_formation_[99].init[1].y = y1;
+	balloon_formation_[99].init[1].vel_x = 0;
+	balloon_formation_[99].init[1].kind = BALLOON_2;
+	balloon_formation_[99].init[1].creation_counter = 200;
+
+	balloon_formation_[99].init[2].x = 90;
+	balloon_formation_[99].init[2].y = y1;
+	balloon_formation_[99].init[2].vel_x = 0;
+	balloon_formation_[99].init[2].kind = BALLOON_3;
+	balloon_formation_[99].init[2].creation_counter = 200;
+
+	balloon_formation_[99].init[3].x = 140;
+	balloon_formation_[99].init[3].y = y1;
+	balloon_formation_[99].init[3].vel_x = 0;
+	balloon_formation_[99].init[3].kind = BALLOON_4;
+	balloon_formation_[99].init[3].creation_counter = 200;
+}
+
+// Inicializa los conjuntos de formaciones
+void BalloonFormations::initBalloonFormationPools()
+{
+	// EnemyPool #0
+	balloon_formation_pool_[0].set[0] = &balloon_formation_[0];
+	balloon_formation_pool_[0].set[1] = &balloon_formation_[1];
+	balloon_formation_pool_[0].set[2] = &balloon_formation_[2];
+	balloon_formation_pool_[0].set[3] = &balloon_formation_[3];
+	balloon_formation_pool_[0].set[4] = &balloon_formation_[4];
+	balloon_formation_pool_[0].set[5] = &balloon_formation_[5];
+	balloon_formation_pool_[0].set[6] = &balloon_formation_[6];
+	balloon_formation_pool_[0].set[7] = &balloon_formation_[7];
+	balloon_formation_pool_[0].set[8] = &balloon_formation_[8];
+	balloon_formation_pool_[0].set[9] = &balloon_formation_[9];
+
+	// EnemyPool #1
+	balloon_formation_pool_[1].set[0] = &balloon_formation_[10];
+	balloon_formation_pool_[1].set[1] = &balloon_formation_[11];
+	balloon_formation_pool_[1].set[2] = &balloon_formation_[12];
+	balloon_formation_pool_[1].set[3] = &balloon_formation_[13];
+	balloon_formation_pool_[1].set[4] = &balloon_formation_[14];
+	balloon_formation_pool_[1].set[5] = &balloon_formation_[15];
+	balloon_formation_pool_[1].set[6] = &balloon_formation_[16];
+	balloon_formation_pool_[1].set[7] = &balloon_formation_[17];
+	balloon_formation_pool_[1].set[8] = &balloon_formation_[18];
+	balloon_formation_pool_[1].set[9] = &balloon_formation_[19];
+
+	// EnemyPool #2
+	balloon_formation_pool_[2].set[0] = &balloon_formation_[0];
+	balloon_formation_pool_[2].set[1] = &balloon_formation_[1];
+	balloon_formation_pool_[2].set[2] = &balloon_formation_[2];
+	balloon_formation_pool_[2].set[3] = &balloon_formation_[3];
+	balloon_formation_pool_[2].set[4] = &balloon_formation_[4];
+	balloon_formation_pool_[2].set[5] = &balloon_formation_[55];
+	balloon_formation_pool_[2].set[6] = &balloon_formation_[56];
+	balloon_formation_pool_[2].set[7] = &balloon_formation_[57];
+	balloon_formation_pool_[2].set[8] = &balloon_formation_[58];
+	balloon_formation_pool_[2].set[9] = &balloon_formation_[59];
+
+	// EnemyPool #3
+	balloon_formation_pool_[3].set[0] = &balloon_formation_[50];
+	balloon_formation_pool_[3].set[1] = &balloon_formation_[51];
+	balloon_formation_pool_[3].set[2] = &balloon_formation_[52];
+	balloon_formation_pool_[3].set[3] = &balloon_formation_[53];
+	balloon_formation_pool_[3].set[4] = &balloon_formation_[54];
+	balloon_formation_pool_[3].set[5] = &balloon_formation_[5];
+	balloon_formation_pool_[3].set[6] = &balloon_formation_[6];
+	balloon_formation_pool_[3].set[7] = &balloon_formation_[7];
+	balloon_formation_pool_[3].set[8] = &balloon_formation_[8];
+	balloon_formation_pool_[3].set[9] = &balloon_formation_[9];
+
+	// EnemyPool #4
+	balloon_formation_pool_[4].set[0] = &balloon_formation_[60];
+	balloon_formation_pool_[4].set[1] = &balloon_formation_[61];
+	balloon_formation_pool_[4].set[2] = &balloon_formation_[62];
+	balloon_formation_pool_[4].set[3] = &balloon_formation_[63];
+	balloon_formation_pool_[4].set[4] = &balloon_formation_[64];
+	balloon_formation_pool_[4].set[5] = &balloon_formation_[65];
+	balloon_formation_pool_[4].set[6] = &balloon_formation_[66];
+	balloon_formation_pool_[4].set[7] = &balloon_formation_[67];
+	balloon_formation_pool_[4].set[8] = &balloon_formation_[68];
+	balloon_formation_pool_[4].set[9] = &balloon_formation_[69];
+
+	// EnemyPool #5
+	balloon_formation_pool_[5].set[0] = &balloon_formation_[10];
+	balloon_formation_pool_[5].set[1] = &balloon_formation_[61];
+	balloon_formation_pool_[5].set[2] = &balloon_formation_[12];
+	balloon_formation_pool_[5].set[3] = &balloon_formation_[63];
+	balloon_formation_pool_[5].set[4] = &balloon_formation_[14];
+	balloon_formation_pool_[5].set[5] = &balloon_formation_[65];
+	balloon_formation_pool_[5].set[6] = &balloon_formation_[16];
+	balloon_formation_pool_[5].set[7] = &balloon_formation_[67];
+	balloon_formation_pool_[5].set[8] = &balloon_formation_[18];
+	balloon_formation_pool_[5].set[9] = &balloon_formation_[69];
+
+	// EnemyPool #6
+	balloon_formation_pool_[6].set[0] = &balloon_formation_[60];
+	balloon_formation_pool_[6].set[1] = &balloon_formation_[11];
+	balloon_formation_pool_[6].set[2] = &balloon_formation_[62];
+	balloon_formation_pool_[6].set[3] = &balloon_formation_[13];
+	balloon_formation_pool_[6].set[4] = &balloon_formation_[64];
+	balloon_formation_pool_[6].set[5] = &balloon_formation_[15];
+	balloon_formation_pool_[6].set[6] = &balloon_formation_[66];
+	balloon_formation_pool_[6].set[7] = &balloon_formation_[17];
+	balloon_formation_pool_[6].set[8] = &balloon_formation_[68];
+	balloon_formation_pool_[6].set[9] = &balloon_formation_[19];
+
+	// EnemyPool #7
+	balloon_formation_pool_[7].set[0] = &balloon_formation_[20];
+	balloon_formation_pool_[7].set[1] = &balloon_formation_[21];
+	balloon_formation_pool_[7].set[2] = &balloon_formation_[22];
+	balloon_formation_pool_[7].set[3] = &balloon_formation_[23];
+	balloon_formation_pool_[7].set[4] = &balloon_formation_[24];
+	balloon_formation_pool_[7].set[5] = &balloon_formation_[65];
+	balloon_formation_pool_[7].set[6] = &balloon_formation_[66];
+	balloon_formation_pool_[7].set[7] = &balloon_formation_[67];
+	balloon_formation_pool_[7].set[8] = &balloon_formation_[68];
+	balloon_formation_pool_[7].set[9] = &balloon_formation_[69];
+
+	// EnemyPool #8
+	balloon_formation_pool_[8].set[0] = &balloon_formation_[70];
+	balloon_formation_pool_[8].set[1] = &balloon_formation_[71];
+	balloon_formation_pool_[8].set[2] = &balloon_formation_[72];
+	balloon_formation_pool_[8].set[3] = &balloon_formation_[73];
+	balloon_formation_pool_[8].set[4] = &balloon_formation_[74];
+	balloon_formation_pool_[8].set[5] = &balloon_formation_[15];
+	balloon_formation_pool_[8].set[6] = &balloon_formation_[16];
+	balloon_formation_pool_[8].set[7] = &balloon_formation_[17];
+	balloon_formation_pool_[8].set[8] = &balloon_formation_[18];
+	balloon_formation_pool_[8].set[9] = &balloon_formation_[19];
+
+	// EnemyPool #9
+	balloon_formation_pool_[9].set[0] = &balloon_formation_[20];
+	balloon_formation_pool_[9].set[1] = &balloon_formation_[21];
+	balloon_formation_pool_[9].set[2] = &balloon_formation_[22];
+	balloon_formation_pool_[9].set[3] = &balloon_formation_[23];
+	balloon_formation_pool_[9].set[4] = &balloon_formation_[24];
+	balloon_formation_pool_[9].set[5] = &balloon_formation_[70];
+	balloon_formation_pool_[9].set[6] = &balloon_formation_[71];
+	balloon_formation_pool_[9].set[7] = &balloon_formation_[72];
+	balloon_formation_pool_[9].set[8] = &balloon_formation_[73];
+	balloon_formation_pool_[9].set[9] = &balloon_formation_[74];
+}
+
+// Inicializa las fases del juego
+void BalloonFormations::initGameStages()
+{
+	// STAGE 1
+	stage_[0].number = 1;
+	stage_[0].power_to_complete = 200;
+	stage_[0].min_menace = 7 + (4 * 1);
+	stage_[0].max_menace = 7 + (4 * 3);
+	stage_[0].balloon_pool = &balloon_formation_pool_[0];
+
+	// STAGE 2
+	stage_[1].number = 2;
+	stage_[1].power_to_complete = 300;
+	stage_[1].min_menace = 7 + (4 * 2);
+	stage_[1].max_menace = 7 + (4 * 4);
+	stage_[1].balloon_pool = &balloon_formation_pool_[1];
+
+	// STAGE 3
+	stage_[2].number = 3;
+	stage_[2].power_to_complete = 600;
+	stage_[2].min_menace = 7 + (4 * 3);
+	stage_[2].max_menace = 7 + (4 * 5);
+	stage_[2].balloon_pool = &balloon_formation_pool_[2];
+
+	// STAGE 4
+	stage_[3].number = 4;
+	stage_[3].power_to_complete = 600;
+	stage_[3].min_menace = 7 + (4 * 3);
+	stage_[3].max_menace = 7 + (4 * 5);
+	stage_[3].balloon_pool = &balloon_formation_pool_[3];
+
+	// STAGE 5
+	stage_[4].number = 5;
+	stage_[4].power_to_complete = 600;
+	stage_[4].min_menace = 7 + (4 * 4);
+	stage_[4].max_menace = 7 + (4 * 6);
+	stage_[4].balloon_pool = &balloon_formation_pool_[4];
+
+	// STAGE 6
+	stage_[5].number = 6;
+	stage_[5].power_to_complete = 600;
+	stage_[5].min_menace = 7 + (4 * 4);
+	stage_[5].max_menace = 7 + (4 * 6);
+	stage_[5].balloon_pool = &balloon_formation_pool_[5];
+
+	// STAGE 7
+	stage_[6].number = 7;
+	stage_[6].power_to_complete = 650;
+	stage_[6].min_menace = 7 + (4 * 5);
+	stage_[6].max_menace = 7 + (4 * 7);
+	stage_[6].balloon_pool = &balloon_formation_pool_[6];
+
+	// STAGE 8
+	stage_[7].number = 8;
+	stage_[7].power_to_complete = 750;
+	stage_[7].min_menace = 7 + (4 * 5);
+	stage_[7].max_menace = 7 + (4 * 7);
+	stage_[7].balloon_pool = &balloon_formation_pool_[7];
+
+	// STAGE 9
+	stage_[8].number = 9;
+	stage_[8].power_to_complete = 850;
+	stage_[8].min_menace = 7 + (4 * 6);
+	stage_[8].max_menace = 7 + (4 * 8);
+	stage_[8].balloon_pool = &balloon_formation_pool_[8];
+
+	// STAGE 10
+	stage_[9].number = 10;
+	stage_[9].power_to_complete = 950;
+	stage_[9].min_menace = 7 + (4 * 7);
+	stage_[9].max_menace = 7 + (4 * 10);
+	stage_[9].balloon_pool = &balloon_formation_pool_[9];
+}
+
+// Devuelve una fase
+Stage BalloonFormations::getStage(int index) const
+{
+	return stage_[index];
+}

source/balloon_formations.h

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

source/bullet.cpp

@@ -1,9 +1,9 @@
 #include "bullet.h"
-#include "param.h"  // for param
-#include "sprite.h" // for Sprite
-#include <memory>   // for std::unique_ptr
+#include <memory>    // for unique_ptr, make_unique, shared_ptr
+#include "param.h"   // for param
+#include "sprite.h"  // for Sprite
+class Texture;
 
-// Constantes evaluables en tiempo de compilación
 constexpr int BULLET_WIDTH = 12;
 constexpr int BULLET_HEIGHT = 12;
 constexpr int BULLET_VELY = -3;
@@ -11,47 +11,54 @@ constexpr int BULLET_VELX_LEFT = -2;
 constexpr int BULLET_VELX_RIGHT = 2;
 
 // Constructor
-Bullet::Bullet(int x, int y, BulletType kind, bool poweredUp, int owner, SDL_Rect *playArea, Texture *texture)
-    : posX(x), posY(y), width(BULLET_WIDTH), height(BULLET_HEIGHT), velX(0), velY(BULLET_VELY),
-      kind(kind), owner(owner), playArea(playArea),
-      sprite(std::unique_ptr<Sprite>(new Sprite(SDL_Rect{x, y, BULLET_WIDTH, BULLET_HEIGHT}, texture))) // Crear manualmente el std::unique_ptr
+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)
 {
-    velX = (kind == BulletType::LEFT) ? BULLET_VELX_LEFT : (kind == BulletType::RIGHT) ? BULLET_VELX_RIGHT
-                                                                                       : 0;
+    vel_x_ = (kind_ == BulletType::LEFT) ? BULLET_VELX_LEFT : (kind_ == BulletType::RIGHT) ? BULLET_VELX_RIGHT
+                                                                                           : 0;
 
-    auto spriteOffset = poweredUp ? 3 : 0;
-    auto kindIndex = static_cast<int>(kind);
-    sprite->setSpriteClip((kindIndex + spriteOffset) * width, 0, sprite->getWidth(), sprite->getHeight());
+    auto sprite_offset = powered_up ? 3 : 0;
+    auto kind_index = static_cast<int>(kind);
+    sprite_->setSpriteClip((kind_index + sprite_offset) * width_, 0, sprite_->getWidth(), sprite_->getHeight());
 
-    collider.r = width / 2;
+    collider_.r = width_ / 2;
     shiftColliders();
 }
 
-// Implementación de render (llama al render del sprite)
+// Implementación de render (llama al render del sprite_)
 void Bullet::render()
 {
-    sprite->render();
+    sprite_->render();
 }
 
 // Implementación del movimiento usando BulletMoveStatus
 BulletMoveStatus Bullet::move()
 {
-    posX += velX;
-    if (posX < param.game.playArea.rect.x - width || posX > playArea->w)
+    pos_x_ += vel_x_;
+    if (pos_x_ < param.game.play_area.rect.x - width_ || pos_x_ > play_area_->w)
     {
         disable();
         return BulletMoveStatus::OUT;
     }
 
-    posY += velY;
-    if (posY < param.game.playArea.rect.y - height)
+    pos_y_ += vel_y_;
+    if (pos_y_ < param.game.play_area.rect.y - height_)
     {
         disable();
         return BulletMoveStatus::OUT;
     }
 
-    sprite->setPosX(posX);
-    sprite->setPosY(posY);
+    sprite_->setPosX(pos_x_);
+    sprite_->setPosY(pos_y_);
     shiftColliders();
 
     return BulletMoveStatus::OK;
@@ -59,56 +66,56 @@ BulletMoveStatus Bullet::move()
 
 bool Bullet::isEnabled() const
 {
-    return kind != BulletType::NULL_TYPE;
+    return kind_ != BulletType::NONE;
 }
 
 void Bullet::disable()
 {
-    kind = BulletType::NULL_TYPE;
+    kind_ = BulletType::NONE;
 }
 
 int Bullet::getPosX() const
 {
-    return posX;
+    return pos_x_;
 }
 
 int Bullet::getPosY() const
 {
-    return posY;
+    return pos_y_;
 }
 
 void Bullet::setPosX(int x)
 {
-    posX = x;
+    pos_x_ = x;
 }
 
 void Bullet::setPosY(int y)
 {
-    posY = y;
+    pos_y_ = y;
 }
 
 int Bullet::getVelY() const
 {
-    return velY;
+    return vel_y_;
 }
 
 BulletType Bullet::getKind() const
 {
-    return kind;
+    return kind_;
 }
 
 int Bullet::getOwner() const
 {
-    return owner;
+    return owner_;
 }
 
-circle_t &Bullet::getCollider()
+Circle &Bullet::getCollider()
 {
-    return collider;
+    return collider_;
 }
 
 void Bullet::shiftColliders()
 {
-    collider.x = posX + collider.r;
-    collider.y = posY + collider.r;
+    collider_.x = pos_x_ + collider_.r;
+    collider_.y = pos_y_ + collider_.r;
 }

source/bullet.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>	 // for SDL_Rect
-#include <SDL2/SDL_stdinc.h> // for Uint8
-#include <memory>			 // for unique_ptr
-#include "sprite.h"			 // for Sprite
-#include "utils.h"			 // for circle_t
-class Texture;				 // lines 9-9
+#include <SDL2/SDL_rect.h>    // for SDL_Rect
+#include <SDL2/SDL_stdinc.h>  // for Uint8
+#include <memory>             // for shared_ptr, unique_ptr
+#include "sprite.h"           // for Sprite
+#include "utils.h"            // for Circle
+class Texture;
 
 // Enumeración para los diferentes tipos de balas
 enum class BulletType
@@ -13,7 +13,7 @@ enum class BulletType
 	UP,
 	LEFT,
 	RIGHT,
-	NULL_TYPE
+	NONE
 };
 
 // Enumeración para los resultados del movimiento de la bala
@@ -27,36 +27,53 @@ enum class BulletMoveStatus : Uint8
 class Bullet
 {
 private:
-	int posX;						// Posición en el eje X
-	int posY;						// Posición en el eje Y
-	Uint8 width;					// Ancho del objeto
-	Uint8 height;					// Alto del objeto
-	int velX;						// Velocidad en el eje X
-	int velY;						// Velocidad en el eje Y
-	BulletType kind;				// Tipo de objeto
-	int owner;						// Identificador del dueño del objeto
-	circle_t collider;				// Círculo de colisión del objeto
-	SDL_Rect *playArea;				// Rectángulo con la zona de juego
-	std::unique_ptr<Sprite> sprite; // Sprite con los gráficos y métodos de pintado
+	std::unique_ptr<Sprite> sprite_; // Sprite con los gráficos y métodos de pintado
+
+	int pos_x_;	   // Posición en el eje X
+	int pos_y_;	   // Posición en el eje Y
+	Uint8 width_;  // Ancho del objeto
+	Uint8 height_; // Alto del objeto
+
+	int vel_x_; // Velocidad en el eje X
+	int vel_y_; // Velocidad en el eje Y
+
+	BulletType kind_;	  // Tipo de objeto
+	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:
-	Bullet(int x, int y, BulletType kind, bool poweredUp, int owner, SDL_Rect *playArea, Texture *texture);
+	// Constructor
+	Bullet(int x, int y, BulletType kind, bool powered_up, int owner, SDL_Rect *play_area, std::shared_ptr<Texture> texture);
+
+	// Destructor
 	~Bullet() = default;
 
-	void render();			 // Pinta el objeto en pantalla
-	BulletMoveStatus move(); // Actualiza la posición y estado del objeto
+	// Pinta el objeto en pantalla
+	void render();
 
-	bool isEnabled() const; // Comprueba si el objeto está habilitado
-	void disable();			// Deshabilita el objeto
+	// Actualiza la posición y estado del objeto
+	BulletMoveStatus move();
 
+	// Comprueba si el objeto está habilitado
+	bool isEnabled() const;
+
+	// Deshabilita el objeto
+	void disable();
+
+	// Obtiene la posición
 	int getPosX() const;
 	int getPosY() const;
+
+	// Establece la posición
 	void setPosX(int x);
 	void setPosY(int y);
+
+	// Obtiene parámetros
 	int getVelY() const;
 	BulletType getKind() const;
 	int getOwner() const;
-	circle_t &getCollider();
+	Circle &getCollider();
 };

source/define_buttons.cpp

@@ -1,128 +1,123 @@
 #include "define_buttons.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, name_e, options, options_e
+#include "section.h"  // for Name, Options, name, options
 #include "text.h"     // for Text
-#include "utils.h"    // for op_controller_t, options_t, param_t, paramGame_t
+#include "utils.h"    // for OptionsController, Options, Param, ParamGame
 
 // Constructor
-DefineButtons::DefineButtons(Text *text)
+DefineButtons::DefineButtons(std::unique_ptr<Text> text_)
+    : text_(std::move(text_))
 {
     // Copia punteros a los objetos
-    input = Input::get();
-    this->text = text;
+    input_ = Input::get();
 
     // Inicializa variables
-    enabled = false;
-    x = param.game.width / 2;
-    y = param.title.pressStartPosition;
-    indexController = 0;
-    indexButton = 0;
+    enabled_ = false;
+    x_ = param.game.width / 2;
+    y_ = param.title.press_start_position;
+    index_controller_ = 0;
+    index_button_ = 0;
 
-    buttons.clear();
-    db_button_t button;
+    buttons_.clear();
+    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)
-    {
-        controllerNames.push_back(input->getControllerName(i));
-    }
-}
-
-// Destructor
-DefineButtons::~DefineButtons()
-{
-}
-
-// Actualiza las variables del objeto
-void DefineButtons::update()
-{
-    if (enabled)
+    for (int i = 0; i < input_->getNumControllers(); ++i)
     {
+        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, controllerNames[indexController]);
-        text->writeCentered(x, y + 10, buttons[indexButton].label);
+        text_->writeCentered(x_, y_ - 10, lang::getText(100) + std::to_string(options.controller[index_controller_].player_id));
+        text_->writeCentered(x_, y_, controller_names_[index_controller_]);
+        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
-            if (event.type == SDL_QUIT)
+            switch (event.type)
             {
-                section::name = section::NAME_QUIT;
-                section::options = section::OPTIONS_QUIT_NORMAL;
+            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;
             }
         }
     }
@@ -131,11 +126,11 @@ void DefineButtons::checkInput()
 // Habilita el objeto
 bool DefineButtons::enable(int index)
 {
-    if (index < input->getNumControllers())
+    if (index < input_->getNumControllers())
     {
-        enabled = true;
-        indexController = index;
-        indexButton = 0;
+        enabled_ = true;
+        index_controller_ = index;
+        index_button_ = 0;
         return true;
     }
 
@@ -145,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;
-        indexController = 0;
-        enabled = false;
+        index_button_ = 0;
+        index_controller_ = 0;
+        enabled_ = false;
     }
 }
 
@@ -175,17 +170,17 @@ void DefineButtons::incIndexButton()
 void DefineButtons::saveBindingsToOptions()
 {
     // Modifica las opciones para colocar los valores asignados
-    options.controller[indexController].name = input->getControllerName(indexController);
-    for (int j = 0; j < (int)options.controller[indexController].inputs.size(); ++j)
+    options.controller[index_controller_].name = input_->getControllerName(index_controller_);
+    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;
-    options.controller[0].playerId = options.controller[1].playerId;
-    options.controller[1].playerId = temp;
+    const int temp = options.controller[0].player_id;
+    options.controller[0].player_id = options.controller[1].player_id;
+    options.controller[1].player_id = temp;
 }

source/define_buttons.h

@@ -2,15 +2,17 @@
 
 #include <SDL2/SDL_events.h>          // for SDL_ControllerButtonEvent
 #include <SDL2/SDL_gamecontroller.h>  // for SDL_GameControllerButton
-#include <string>                     // for string, basic_string
+#include <memory>                     // for shared_ptr, unique_ptr
+#include <string>                     // for string
 #include <vector>                     // for vector
-#include "input.h"                    // for inputs_e
+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
 };
 
@@ -19,17 +21,17 @@ class DefineButtons
 {
 private:
     // Objetos
-    Input *input; // Objeto pata gestionar la entrada
-    Text *text;   // Objeto para escribir texto
+    Input *input_;               // Objeto pata gestionar la entrada
+    std::shared_ptr<Text> text_; // Objeto para escribir texto
 
     // Variables
-    bool enabled;                             // Indica si el objeto está habilitado
-    int x;                                    // Posición donde dibujar el texto
-    int y;                                    // Posición donde dibujar el texto
-    std::vector<db_button_t> buttons;         // Vector con las nuevas definiciones de botones/acciones
-    int indexController;                      // Indice del controlador a reasignar
-    int indexButton;                          // Indice para saber qué bot´çon se está definiendo
-    std::vector<std::string> controllerNames; // Nombres de los mandos
+    bool enabled_;                              // Indica si el objeto está habilitado
+    int x_;                                     // Posición donde dibujar el texto
+    int y_;                                     // Posición donde dibujar el texto
+    std::vector<DefineButtonsButton> buttons_;  // Vector con las nuevas definiciones de botones/acciones
+    int index_controller_;                      // Indice del controlador a reasignar
+    int index_button_;                          // Indice para saber qué bot´çon se está definiendo
+    std::vector<std::string> controller_names_; // Nombres de los mandos
 
     // Incrementa el indice de los botones
     void incIndexButton();
@@ -45,13 +47,10 @@ private:
 
 public:
     // Constructor
-    DefineButtons(Text *text);
+    explicit DefineButtons(std::unique_ptr<Text> text);
 
     // Destructor
-    ~DefineButtons();
-
-    // Actualiza las variables del objeto
-    void update();
+    ~DefineButtons() = default;
 
     // Dibuja el objeto en pantalla
     void render();

source/director.cpp

@@ -5,49 +5,52 @@
 #include <SDL2/SDL_error.h>			 // for SDL_GetError
 #include <SDL2/SDL_gamecontroller.h> // for SDL_CONTROLLER_BUTTON_B, SDL_CO...
 #include <SDL2/SDL_hints.h>			 // for SDL_SetHint, SDL_HINT_RENDER_DR...
-#include <SDL2/SDL_scancode.h>		 // for SDL_SCANCODE_DOWN, SDL_SCANCODE_E
-#include <SDL2/SDL_stdinc.h>		 // for Uint32
+#include <SDL2/SDL_scancode.h>		 // for SDL_SCANCODE_0, SDL_SCANCODE_DOWN
+#include <SDL2/SDL_stdinc.h>		 // for SDL_bool, Uint32
 #include <SDL2/SDL_timer.h>			 // for SDL_GetTicks
-#include <errno.h>					 // for errno, EACCES, EEXIST, ENAMETOO...
-#include <stdio.h>					 // for printf, perror, size_t
+#include <errno.h>					 // for errno, EEXIST, EACCES, ENAMETOO...
+#include <stdio.h>					 // for printf, perror
 #include <string.h>					 // for strcmp
-#include <sys/stat.h>				 // for stat, mkdir, S_IRWXU
+#include <sys/stat.h>				 // for mkdir, stat, S_IRWXU
 #include <unistd.h>					 // for getuid
 #include <cstdlib>					 // for exit, EXIT_FAILURE, rand, srand
 #include <iostream>					 // for basic_ostream, operator<<, cout
-#include <string>					 // for basic_string, operator+, allocator
-#include "asset.h"					 // for Asset, assetType
+#include <memory>					 // for make_unique, unique_ptr
+#include <string>					 // for operator+, allocator, char_traits
+#include "asset.h"					 // for Asset, AssetType
 #include "dbgtxt.h"					 // for dbg_init
 #include "game.h"					 // for Game, GAME_MODE_DEMO_OFF, GAME_...
+#include "global_inputs.h"			 // for init
 #include "hiscore_table.h"			 // for HiScoreTable
-#include "input.h"					 // for inputs_e, Input
+#include "input.h"					 // for Input, InputType
 #include "instructions.h"			 // for Instructions
 #include "intro.h"					 // for Intro
-#include "jail_audio.h"				 // for JA_DeleteMusic, JA_DeleteSound
+#include "jail_audio.h"				 // for JA_LoadMusic, JA_LoadSound, JA_...
+#include "lang.h"					 // for Code, loadFromFile
 #include "logo.h"					 // for Logo
 #include "manage_hiscore_table.h"	 // for ManageHiScoreTable
 #include "on_screen_help.h"			 // for OnScreenHelp
 #include "options.h"				 // for options, loadOptionsFile, saveO...
 #include "param.h"					 // for param, loadParamsFromFile
 #include "screen.h"					 // for Screen
-#include "section.h"				 // for name_e, name, options, options_e
+#include "section.h"				 // for Name, name, Options, options
 #include "title.h"					 // for Title
-#include "utils.h"					 // for music_file_t, sound_file_t, opt...
+#include "utils.h"					 // for MusicFile, SoundFile, Options
 
 #ifndef _WIN32
 #include <pwd.h> // for getpwuid, passwd
 #endif
 
 // Constructor
-Director::Director(int argc, char *argv[])
+Director::Director(int argc, const char *argv[])
 {
 #ifdef RECORDING
-	section::name = section::NAME_GAME;
-	section::options = section::OPTIONS_GAME_PLAY_1P;
+	section::name = section::Name::GAME;
+	section::options = section::Options::GAME_PLAY_1P;
 #elif DEBUG
-	section::name = section::NAME_LOGO;
+	section::name = section::Name::LOGO;
 #else
-	section::name = section::NAME_LOGO;
+	section::name = section::Name::LOGO;
 #endif
 
 	// Comprueba los parametros del programa
@@ -58,8 +61,7 @@ Director::Director(int argc, char *argv[])
 	createSystemFolder("jailgames/coffee_crisis_arcade_edition");
 
 	// Crea el objeto que controla los ficheros de recursos
-	Asset::init(executablePath);
-	asset = Asset::get();
+	Asset::init(executable_path_);
 
 	// Si falta algún fichero no inicia el programa
 	if (!setFileList())
@@ -68,20 +70,19 @@ Director::Director(int argc, char *argv[])
 	}
 
 	// Carga el fichero de configuración
-	loadOptionsFile(asset->get("config.txt"));
+	loadOptionsFile(Asset::get()->get("config.txt"));
 
 	// Carga los parametros para configurar el juego
 #ifdef ANBERNIC
 	const std::string paramFilePath = asset->get("param_320x240.txt");
 #else
-	const std::string paramFilePath = paramFileArgument == "--320x240" ? asset->get("param_320x240.txt") : asset->get("param_320x256.txt");
+	const std::string paramFilePath = param_file_argument_ == "--320x240" ? Asset::get()->get("param_320x240.txt") : Asset::get()->get("param_320x256.txt");
 #endif
 	loadParams(paramFilePath);
 
 	// Carga el fichero de puntuaciones
-	ManageHiScoreTable *manager = new ManageHiScoreTable(&options.game.hiScoreTable);
-	manager->loadFromFile(asset->get("score.bin"));
-	delete manager;
+	auto manager = std::make_unique<ManageHiScoreTable>(&options.game.hi_score_table);
+	manager->loadFromFile(Asset::get()->get("score.bin"));
 
 	// Inicializa SDL
 	initSDL();
@@ -90,17 +91,15 @@ Director::Director(int argc, char *argv[])
 	initJailAudio();
 
 	// Inicializa el texto de debug
-	dbg_init(renderer);
+	dbg_init(renderer_);
 
 	// Crea los objetos
-	lang::loadFromFile(getLangFile((lang::lang_e)options.game.language));
+	lang::loadFromFile(getLangFile((lang::Code)options.game.language));
 
-	Input::init(asset->get("gamecontrollerdb.txt"));
-	input = Input::get();
+	Input::init(Asset::get()->get("gamecontrollerdb.txt"));
 	initInput();
 
-	Screen::init(window, renderer);
-	screen = Screen::get();
+	Screen::init(window_, renderer_);
 
 	OnScreenHelp::init();
 
@@ -109,119 +108,118 @@ Director::Director(int argc, char *argv[])
 
 	// Carga las musicas del juego
 	loadMusics();
+
+	globalInputs::init();
 }
 
 Director::~Director()
 {
-	saveOptionsFile(asset->get("config.txt"));
+	saveOptionsFile(Asset::get()->get("config.txt"));
 
 	Asset::destroy();
 	Input::destroy();
 	Screen::destroy();
 	OnScreenHelp::destroy();
 
-	deleteSounds();
-	deleteMusics();
+	sounds_.clear();
+	musics_.clear();
 
-	SDL_DestroyRenderer(renderer);
-	SDL_DestroyWindow(window);
+	SDL_DestroyRenderer(renderer_);
+	SDL_DestroyWindow(window_);
 
 	SDL_Quit();
 }
 
-// Inicializa el objeto input
+/// Inicializa el objeto input
 void Director::initInput()
 {
-	// Establece si ha de mostrar mensajes
-#ifdef VERBOSE
-	input->setVerbose(true);
-#else
-	input->setVerbose(false);
-#endif
 	// Busca si hay mandos conectados
-	input->discoverGameControllers();
+	Input::get()->discoverGameControllers();
 
 	// Teclado - Movimiento del jugador
-	input->bindKey(input_up, SDL_SCANCODE_UP);
-	input->bindKey(input_down, SDL_SCANCODE_DOWN);
-	input->bindKey(input_left, SDL_SCANCODE_LEFT);
-	input->bindKey(input_right, SDL_SCANCODE_RIGHT);
+	Input::get()->bindKey(InputType::UP, SDL_SCANCODE_UP);
+	Input::get()->bindKey(InputType::DOWN, SDL_SCANCODE_DOWN);
+	Input::get()->bindKey(InputType::LEFT, SDL_SCANCODE_LEFT);
+	Input::get()->bindKey(InputType::RIGHT, SDL_SCANCODE_RIGHT);
 
-	input->bindKey(input_fire_left, SDL_SCANCODE_Q);
-	input->bindKey(input_fire_center, SDL_SCANCODE_W);
-	input->bindKey(input_fire_right, SDL_SCANCODE_E);
+	Input::get()->bindKey(InputType::FIRE_LEFT, SDL_SCANCODE_Q);
+	Input::get()->bindKey(InputType::FIRE_CENTER, SDL_SCANCODE_W);
+	Input::get()->bindKey(InputType::FIRE_RIGHT, SDL_SCANCODE_E);
 
-	input->bindKey(input_start, SDL_SCANCODE_RETURN);
+	Input::get()->bindKey(InputType::START, SDL_SCANCODE_RETURN);
 
 	// Teclado - Control del programa
-	input->bindKey(input_service, SDL_SCANCODE_0);
-	input->bindKey(input_exit, SDL_SCANCODE_ESCAPE);
-	input->bindKey(input_pause, SDL_SCANCODE_P);
-	input->bindKey(input_window_dec_size, SDL_SCANCODE_F1);
-	input->bindKey(input_window_inc_size, SDL_SCANCODE_F2);
-	input->bindKey(input_window_fullscreen, SDL_SCANCODE_F3);
-	input->bindKey(input_video_shaders, SDL_SCANCODE_F4);
-	input->bindKey(input_mute, SDL_SCANCODE_F5);
-	input->bindKey(input_showinfo, SDL_SCANCODE_F6);
-	input->bindKey(input_reset, SDL_SCANCODE_F10);
+	Input::get()->bindKey(InputType::SERVICE, SDL_SCANCODE_0);
+	Input::get()->bindKey(InputType::EXIT, SDL_SCANCODE_ESCAPE);
+	Input::get()->bindKey(InputType::PAUSE, SDL_SCANCODE_P);
+	Input::get()->bindKey(InputType::WINDOW_DEC_SIZE, SDL_SCANCODE_F1);
+	Input::get()->bindKey(InputType::WINDOW_INC_SIZE, SDL_SCANCODE_F2);
+	Input::get()->bindKey(InputType::WINDOW_FULLSCREEN, SDL_SCANCODE_F3);
+	Input::get()->bindKey(InputType::VIDEO_SHADERS, SDL_SCANCODE_F4);
+	Input::get()->bindKey(InputType::MUTE, SDL_SCANCODE_F5);
+	Input::get()->bindKey(InputType::SHOWINFO, SDL_SCANCODE_F6);
+	Input::get()->bindKey(InputType::RESET, SDL_SCANCODE_F10);
 
 	// Asigna botones a inputs
-	const int numGamePads = input->getNumControllers();
-	for (int i = 0; i < numGamePads; ++i)
+	const int num_gamepads = Input::get()->getNumControllers();
+	for (int i = 0; i < num_gamepads; ++i)
 	{
 		// Mando - Movimiento del jugador
-		input->bindGameControllerButton(i, input_up, SDL_CONTROLLER_BUTTON_DPAD_UP);
-		input->bindGameControllerButton(i, input_down, SDL_CONTROLLER_BUTTON_DPAD_DOWN);
-		input->bindGameControllerButton(i, input_left, SDL_CONTROLLER_BUTTON_DPAD_LEFT);
-		input->bindGameControllerButton(i, input_right, SDL_CONTROLLER_BUTTON_DPAD_RIGHT);
+		Input::get()->bindGameControllerButton(i, InputType::UP, SDL_CONTROLLER_BUTTON_DPAD_UP);
+		Input::get()->bindGameControllerButton(i, InputType::DOWN, SDL_CONTROLLER_BUTTON_DPAD_DOWN);
+		Input::get()->bindGameControllerButton(i, InputType::LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT);
+		Input::get()->bindGameControllerButton(i, InputType::RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT);
 
-		input->bindGameControllerButton(i, input_fire_left, SDL_CONTROLLER_BUTTON_X);
-		input->bindGameControllerButton(i, input_fire_center, SDL_CONTROLLER_BUTTON_Y);
-		input->bindGameControllerButton(i, input_fire_right, SDL_CONTROLLER_BUTTON_B);
+		Input::get()->bindGameControllerButton(i, InputType::FIRE_LEFT, SDL_CONTROLLER_BUTTON_X);
+		Input::get()->bindGameControllerButton(i, InputType::FIRE_CENTER, SDL_CONTROLLER_BUTTON_Y);
+		Input::get()->bindGameControllerButton(i, InputType::FIRE_RIGHT, SDL_CONTROLLER_BUTTON_B);
 
-		input->bindGameControllerButton(i, input_start, SDL_CONTROLLER_BUTTON_START);
+		Input::get()->bindGameControllerButton(i, InputType::START, SDL_CONTROLLER_BUTTON_START);
 
 		// Mando - Control del programa
-		input->bindGameControllerButton(i, input_service, SDL_CONTROLLER_BUTTON_BACK);
-		input->bindGameControllerButton(i, input_exit, input_start);
-		input->bindGameControllerButton(i, input_pause, input_fire_right);
-		input->bindGameControllerButton(i, input_video_shaders, input_fire_left);
-		input->bindGameControllerButton(i, input_mute, input_left);
-		input->bindGameControllerButton(i, input_showinfo, input_right);
-		input->bindGameControllerButton(i, input_reset, input_fire_center);
-		input->bindGameControllerButton(i, input_config, input_down);
-		input->bindGameControllerButton(i, input_swap_controllers, input_up);
+		Input::get()->bindGameControllerButton(i, InputType::SERVICE, SDL_CONTROLLER_BUTTON_BACK);
+		Input::get()->bindGameControllerButton(i, InputType::EXIT, InputType::START);
+		Input::get()->bindGameControllerButton(i, InputType::PAUSE, InputType::FIRE_RIGHT);
+		Input::get()->bindGameControllerButton(i, InputType::VIDEO_SHADERS, InputType::FIRE_LEFT);
+		Input::get()->bindGameControllerButton(i, InputType::MUTE, InputType::LEFT);
+		Input::get()->bindGameControllerButton(i, InputType::SHOWINFO, InputType::RIGHT);
+		Input::get()->bindGameControllerButton(i, InputType::RESET, InputType::FIRE_CENTER);
+		Input::get()->bindGameControllerButton(i, InputType::CONFIG, InputType::DOWN);
+		Input::get()->bindGameControllerButton(i, InputType::SWAP_CONTROLLERS, InputType::UP);
 	}
 
 	// Mapea las asignaciones a los botones desde el archivo de configuración, si se da el caso
-	for (int i = 0; i < numGamePads; ++i)
+	for (int i = 0; i < num_gamepads; ++i)
 		for (int index = 0; index < (int)options.controller.size(); ++index)
-			if (input->getControllerName(i) == options.controller[index].name)
+			if (Input::get()->getControllerName(i) == options.controller[index].name)
+			{
+				options.controller[index].plugged = true;
 				for (int j = 0; j < (int)options.controller[index].inputs.size(); ++j)
 				{
-					input->bindGameControllerButton(i, options.controller[index].inputs[j], options.controller[index].buttons[j]);
+					Input::get()->bindGameControllerButton(i, options.controller[index].inputs[j], options.controller[index].buttons[j]);
 				}
+			}
 
 	// Asigna botones a inputs desde otros inputs
-	for (int i = 0; i < numGamePads; ++i)
+	for (int i = 0; i < num_gamepads; ++i)
 	{
-		input->bindGameControllerButton(i, input_exit, input_start);
-		input->bindGameControllerButton(i, input_reset, input_fire_center);
-		input->bindGameControllerButton(i, input_pause, input_fire_right);
-		input->bindGameControllerButton(i, input_video_shaders, input_fire_left);
-		input->bindGameControllerButton(i, input_mute, input_left);
-		input->bindGameControllerButton(i, input_showinfo, input_right);
-		input->bindGameControllerButton(i, input_config, input_down);
-		input->bindGameControllerButton(i, input_swap_controllers, input_up);
+		Input::get()->bindGameControllerButton(i, InputType::EXIT, InputType::START);
+		Input::get()->bindGameControllerButton(i, InputType::RESET, InputType::FIRE_CENTER);
+		Input::get()->bindGameControllerButton(i, InputType::PAUSE, InputType::FIRE_RIGHT);
+		Input::get()->bindGameControllerButton(i, InputType::VIDEO_SHADERS, InputType::FIRE_LEFT);
+		Input::get()->bindGameControllerButton(i, InputType::MUTE, InputType::LEFT);
+		Input::get()->bindGameControllerButton(i, InputType::SHOWINFO, InputType::RIGHT);
+		Input::get()->bindGameControllerButton(i, InputType::CONFIG, InputType::DOWN);
+		Input::get()->bindGameControllerButton(i, InputType::SWAP_CONTROLLERS, InputType::UP);
 	}
 
 	// Guarda las asignaciones de botones en las opciones
-	for (int i = 0; i < numGamePads; ++i)
+	for (int i = 0; i < num_gamepads; ++i)
 	{
-		options.controller[i].name = input->getControllerName(i);
+		options.controller[i].name = Input::get()->getControllerName(i);
 		for (int j = 0; j < (int)options.controller[i].inputs.size(); ++j)
 		{
-			options.controller[i].buttons[j] = input->getControllerBinding(i, options.controller[i].inputs[j]);
+			options.controller[i].buttons[j] = Input::get()->getControllerBinding(i, options.controller[i].inputs[j]);
 		}
 	}
 }
@@ -240,7 +238,7 @@ void Director::initJailAudio()
 bool Director::initSDL()
 {
 	// Indicador de éxito
-	bool success = true;
+	auto success = true;
 
 	// Inicializa SDL
 	if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
@@ -272,7 +270,7 @@ bool Director::initSDL()
 #endif
 
 		// Establece el filtro de la textura
-		if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, std::to_string(options.video.filter).c_str()))
+		if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, std::to_string(static_cast<int>(options.video.filter)).c_str()))
 		{
 #ifdef VERBOSE
 			std::cout << "Warning: texture filtering not enabled!\n";
@@ -287,8 +285,8 @@ bool Director::initSDL()
 		}
 #endif // NO_SHADERS
 	   // Crea la ventana
-		window = SDL_CreateWindow(WINDOW_CAPTION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, param.game.width * options.video.window.size, param.game.height * options.video.window.size, SDL_WINDOW_HIDDEN);
-		if (window == nullptr)
+		window_ = SDL_CreateWindow(WINDOW_CAPTION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, param.game.width * options.video.window.size, param.game.height * options.video.window.size, SDL_WINDOW_HIDDEN);
+		if (!window_)
 		{
 #ifdef VERBOSE
 			std::cout << "Window could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
@@ -299,17 +297,17 @@ bool Director::initSDL()
 		{
 			// Crea un renderizador para la ventana. El vsync se activa en funcion de las opciones
 			Uint32 flags = 0;
-			if (options.video.vSync)
+			if (options.video.v_sync)
 			{
-				flags = flags | SDL_RENDERER_PRESENTVSYNC;
+				flags = SDL_RENDERER_PRESENTVSYNC;
 			}
 #ifndef NO_SHADERS
 			// La aceleración se activa según el define
 			flags = flags | SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
 #endif
-			renderer = SDL_CreateRenderer(window, -1, flags);
+			renderer_ = SDL_CreateRenderer(window_, -1, flags);
 
-			if (renderer == nullptr)
+			if (!renderer_)
 			{
 #ifdef VERBOSE
 				std::cout << "Renderer could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
@@ -319,13 +317,14 @@ bool Director::initSDL()
 			else
 			{
 				// Inicializa el color de renderizado
-				SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0xFF);
+				SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
 
 				// Establece el tamaño del buffer de renderizado
-				SDL_RenderSetLogicalSize(renderer, param.game.width, param.game.height);
+				SDL_RenderSetLogicalSize(renderer_, param.game.width, param.game.height);
+				SDL_RenderSetIntegerScale(renderer_, static_cast<SDL_bool>(options.video.integer_scale));
 
 				// Establece el modo de mezcla
-				SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
+				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
 			}
 		}
 	}
@@ -342,197 +341,202 @@ bool Director::setFileList()
 #ifdef MACOS_BUNDLE
 	const std::string prefix = "/../Resources";
 #else
-	const std::string prefix = "";
+	const std::string prefix;
 #endif
 
 	// Ficheros de configuración
-	asset->add(systemFolder + "/config.txt", t_data, false, true);
-	asset->add(systemFolder + "/score.bin", t_data, false, true);
-	asset->add(prefix + "/data/config/param_320x240.txt", t_data);
-	asset->add(prefix + "/data/config/param_320x256.txt", t_data);
-	asset->add(prefix + "/data/config/demo1.bin", t_data);
-	asset->add(prefix + "/data/config/demo2.bin", t_data);
-	asset->add(prefix + "/data/config/gamecontrollerdb.txt", t_data);
+	Asset::get()->add(system_folder_ + "/config.txt", AssetType::DATA, false, true);
+	Asset::get()->add(system_folder_ + "/score.bin", AssetType::DATA, false, true);
+	Asset::get()->add(prefix + "/data/config/param_320x240.txt", AssetType::DATA);
+	Asset::get()->add(prefix + "/data/config/param_320x256.txt", AssetType::DATA);
+	Asset::get()->add(prefix + "/data/config/demo1.bin", AssetType::DATA);
+	Asset::get()->add(prefix + "/data/config/demo2.bin", AssetType::DATA);
+	Asset::get()->add(prefix + "/data/config/gamecontrollerdb.txt", AssetType::DATA);
 
 	// Musicas
-	asset->add(prefix + "/data/music/intro.ogg", t_music);
-	asset->add(prefix + "/data/music/playing.ogg", t_music);
-	asset->add(prefix + "/data/music/title.ogg", t_music);
+	Asset::get()->add(prefix + "/data/music/intro.ogg", AssetType::MUSIC);
+	Asset::get()->add(prefix + "/data/music/playing.ogg", AssetType::MUSIC);
+	Asset::get()->add(prefix + "/data/music/title.ogg", AssetType::MUSIC);
 
 	// Sonidos
-	asset->add(prefix + "/data/sound/balloon.wav", t_sound);
-	asset->add(prefix + "/data/sound/bubble1.wav", t_sound);
-	asset->add(prefix + "/data/sound/bubble2.wav", t_sound);
-	asset->add(prefix + "/data/sound/bubble3.wav", t_sound);
-	asset->add(prefix + "/data/sound/bubble4.wav", t_sound);
-	asset->add(prefix + "/data/sound/bullet.wav", t_sound);
-	asset->add(prefix + "/data/sound/coffeeout.wav", t_sound);
-	asset->add(prefix + "/data/sound/hiscore.wav", t_sound);
-	asset->add(prefix + "/data/sound/itemdrop.wav", t_sound);
-	asset->add(prefix + "/data/sound/itempickup.wav", t_sound);
-	asset->add(prefix + "/data/sound/player_collision.wav", t_sound);
-	asset->add(prefix + "/data/sound/stage_change.wav", t_sound);
-	asset->add(prefix + "/data/sound/title.wav", t_sound);
-	asset->add(prefix + "/data/sound/clock.wav", t_sound);
-	asset->add(prefix + "/data/sound/powerball.wav", t_sound);
-	asset->add(prefix + "/data/sound/notify.wav", t_sound);
+	Asset::get()->add(prefix + "/data/sound/balloon.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/bubble1.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/bubble2.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/bubble3.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/bubble4.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/bullet.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/coffeeout.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/hiscore.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/itemdrop.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/itempickup.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/player_collision.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/stage_change.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/title.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/clock.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/powerball.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/notify.wav", AssetType::SOUND);
 
 	// Shaders
-	asset->add(prefix + "/data/shaders/crtpi.glsl", t_data);
+	Asset::get()->add(prefix + "/data/shaders/crtpi.glsl", AssetType::DATA);
 
 	// Texturas
-	asset->add(prefix + "/data/gfx/controllers/controllers.png", t_bitmap);
+	Asset::get()->add(prefix + "/data/gfx/controllers/controllers.png", AssetType::BITMAP);
 
-	asset->add(prefix + "/data/gfx/balloon/balloon1.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/balloon/balloon1.ani", t_animation);
-	asset->add(prefix + "/data/gfx/balloon/balloon2.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/balloon/balloon2.ani", t_animation);
-	asset->add(prefix + "/data/gfx/balloon/balloon3.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/balloon/balloon3.ani", t_animation);
-	asset->add(prefix + "/data/gfx/balloon/balloon4.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/balloon/balloon4.ani", t_animation);
+	Asset::get()->add(prefix + "/data/gfx/balloon/balloon1.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/balloon/balloon1.ani", AssetType::ANIMATION);
+	Asset::get()->add(prefix + "/data/gfx/balloon/balloon2.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/balloon/balloon2.ani", AssetType::ANIMATION);
+	Asset::get()->add(prefix + "/data/gfx/balloon/balloon3.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/balloon/balloon3.ani", AssetType::ANIMATION);
+	Asset::get()->add(prefix + "/data/gfx/balloon/balloon4.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/balloon/balloon4.ani", AssetType::ANIMATION);
 
-	asset->add(prefix + "/data/gfx/balloon/explosion1.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/balloon/explosion1.ani", t_animation);
-	asset->add(prefix + "/data/gfx/balloon/explosion2.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/balloon/explosion2.ani", t_animation);
-	asset->add(prefix + "/data/gfx/balloon/explosion3.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/balloon/explosion3.ani", t_animation);
-	asset->add(prefix + "/data/gfx/balloon/explosion4.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/balloon/explosion4.ani", t_animation);
+	Asset::get()->add(prefix + "/data/gfx/balloon/explosion1.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/balloon/explosion1.ani", AssetType::ANIMATION);
+	Asset::get()->add(prefix + "/data/gfx/balloon/explosion2.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/balloon/explosion2.ani", AssetType::ANIMATION);
+	Asset::get()->add(prefix + "/data/gfx/balloon/explosion3.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/balloon/explosion3.ani", AssetType::ANIMATION);
+	Asset::get()->add(prefix + "/data/gfx/balloon/explosion4.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/balloon/explosion4.ani", AssetType::ANIMATION);
 
-	asset->add(prefix + "/data/gfx/balloon/powerball.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/balloon/powerball.ani", t_animation);
+	Asset::get()->add(prefix + "/data/gfx/balloon/powerball.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/balloon/powerball.ani", AssetType::ANIMATION);
 
-	asset->add(prefix + "/data/gfx/bullet/bullet.png", t_bitmap);
+	Asset::get()->add(prefix + "/data/gfx/bullet/bullet.png", AssetType::BITMAP);
 
-	asset->add(prefix + "/data/gfx/game/game_buildings.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/game/game_clouds1.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/game/game_clouds2.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/game/game_grass.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/game/game_power_meter.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/game/game_sky_colors.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/game/game_text.png", t_bitmap);
+	Asset::get()->add(prefix + "/data/gfx/game/game_buildings.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/game/game_clouds1.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/game/game_clouds2.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/game/game_grass.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/game/game_power_meter.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/game/game_sky_colors.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/game/game_text.png", AssetType::BITMAP);
 
-	asset->add(prefix + "/data/gfx/intro/intro.png", t_bitmap);
+	Asset::get()->add(prefix + "/data/gfx/intro/intro.png", AssetType::BITMAP);
 
-	asset->add(prefix + "/data/gfx/logo/logo_jailgames.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/logo/logo_jailgames_mini.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/logo/logo_since_1998.png", t_bitmap);
+	Asset::get()->add(prefix + "/data/gfx/logo/logo_jailgames.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/logo/logo_jailgames_mini.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/logo/logo_since_1998.png", AssetType::BITMAP);
 
-	asset->add(prefix + "/data/gfx/item/item_points1_disk.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/item/item_points1_disk.ani", t_animation);
-	asset->add(prefix + "/data/gfx/item/item_points2_gavina.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/item/item_points2_gavina.ani", t_animation);
-	asset->add(prefix + "/data/gfx/item/item_points3_pacmar.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/item/item_points3_pacmar.ani", t_animation);
-	asset->add(prefix + "/data/gfx/item/item_clock.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/item/item_clock.ani", t_animation);
-	asset->add(prefix + "/data/gfx/item/item_coffee.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/item/item_coffee.ani", t_animation);
-	asset->add(prefix + "/data/gfx/item/item_coffee_machine.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/item/item_coffee_machine.ani", t_animation);
+	Asset::get()->add(prefix + "/data/gfx/item/item_points1_disk.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/item/item_points1_disk.ani", AssetType::ANIMATION);
+	Asset::get()->add(prefix + "/data/gfx/item/item_points2_gavina.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/item/item_points2_gavina.ani", AssetType::ANIMATION);
+	Asset::get()->add(prefix + "/data/gfx/item/item_points3_pacmar.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/item/item_points3_pacmar.ani", AssetType::ANIMATION);
+	Asset::get()->add(prefix + "/data/gfx/item/item_clock.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/item/item_clock.ani", AssetType::ANIMATION);
+	Asset::get()->add(prefix + "/data/gfx/item/item_coffee.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/item/item_coffee.ani", AssetType::ANIMATION);
+	Asset::get()->add(prefix + "/data/gfx/item/item_coffee_machine.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/item/item_coffee_machine.ani", AssetType::ANIMATION);
 
-	asset->add(prefix + "/data/gfx/title/title_bg_tile.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/title/title_coffee.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/title/title_crisis.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/title/title_arcade_edition.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/title/title_dust.png", t_bitmap);
-	asset->add(prefix + "/data/gfx/title/title_dust.ani", t_animation);
+	Asset::get()->add(prefix + "/data/gfx/title/title_bg_tile.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/title/title_coffee.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/title/title_crisis.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/title/title_arcade_edition.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/title/title_dust.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/title/title_dust.ani", AssetType::ANIMATION);
 
-	asset->add(prefix + "/data/gfx/player/player1.gif", t_bitmap);
-	asset->add(prefix + "/data/gfx/player/player1_pal1.gif", t_palette);
-	asset->add(prefix + "/data/gfx/player/player1_pal2.gif", t_palette);
-	asset->add(prefix + "/data/gfx/player/player1_pal3.gif", t_palette);
+	Asset::get()->add(prefix + "/data/gfx/player/player1.gif", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/player/player1_pal1.gif", AssetType::PALETTE);
+	Asset::get()->add(prefix + "/data/gfx/player/player1_pal2.gif", AssetType::PALETTE);
+	Asset::get()->add(prefix + "/data/gfx/player/player1_pal3.gif", AssetType::PALETTE);
 
-	asset->add(prefix + "/data/gfx/player/player2.gif", t_bitmap);
-	asset->add(prefix + "/data/gfx/player/player2_pal1.gif", t_palette);
-	asset->add(prefix + "/data/gfx/player/player2_pal2.gif", t_palette);
-	asset->add(prefix + "/data/gfx/player/player2_pal3.gif", t_palette);
+	Asset::get()->add(prefix + "/data/gfx/player/player2.gif", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/player/player2_pal1.gif", AssetType::PALETTE);
+	Asset::get()->add(prefix + "/data/gfx/player/player2_pal2.gif", AssetType::PALETTE);
+	Asset::get()->add(prefix + "/data/gfx/player/player2_pal3.gif", AssetType::PALETTE);
 
-	asset->add(prefix + "/data/gfx/player/player.ani", t_animation);
+	Asset::get()->add(prefix + "/data/gfx/player/player.ani", AssetType::ANIMATION);
 
-	asset->add(prefix + "/data/gfx/player/player_power.gif", t_bitmap);
-	asset->add(prefix + "/data/gfx/player/player_power_pal.gif", t_palette);
-	asset->add(prefix + "/data/gfx/player/player_power.ani", t_animation);
+	Asset::get()->add(prefix + "/data/gfx/player/player_power.gif", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/gfx/player/player_power_pal.gif", AssetType::PALETTE);
+	Asset::get()->add(prefix + "/data/gfx/player/player_power.ani", AssetType::ANIMATION);
 
 	// Fuentes de texto
-	asset->add(prefix + "/data/font/8bithud.png", t_font);
-	asset->add(prefix + "/data/font/8bithud.txt", t_font);
-	asset->add(prefix + "/data/font/nokia.png", t_font);
-	asset->add(prefix + "/data/font/nokia_big2.png", t_font);
-	asset->add(prefix + "/data/font/nokia.txt", t_font);
-	asset->add(prefix + "/data/font/nokia2.png", t_font);
-	asset->add(prefix + "/data/font/nokia2.txt", t_font);
-	asset->add(prefix + "/data/font/nokia_big2.txt", t_font);
-	asset->add(prefix + "/data/font/smb2_big.png", t_font);
-	asset->add(prefix + "/data/font/smb2_big.txt", t_font);
-	asset->add(prefix + "/data/font/smb2.gif", t_font);
-	asset->add(prefix + "/data/font/smb2_pal1.gif", t_palette);
-	asset->add(prefix + "/data/font/smb2.txt", t_font);
+	Asset::get()->add(prefix + "/data/font/8bithud.png", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/8bithud.txt", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/nokia.png", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/nokia_big2.png", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/nokia.txt", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/nokia2.png", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/nokia2.txt", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/nokia_big2.txt", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/smb2_big.png", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/smb2_big.txt", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/smb2.gif", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/smb2_pal1.gif", AssetType::PALETTE);
+	Asset::get()->add(prefix + "/data/font/smb2.txt", AssetType::FONT);
 
 	// Textos
-	asset->add(prefix + "/data/lang/es_ES.txt", t_lang);
-	asset->add(prefix + "/data/lang/en_UK.txt", t_lang);
-	asset->add(prefix + "/data/lang/ba_BA.txt", t_lang);
+	Asset::get()->add(prefix + "/data/lang/es_ES.txt", AssetType::LANG);
+	Asset::get()->add(prefix + "/data/lang/en_UK.txt", AssetType::LANG);
+	Asset::get()->add(prefix + "/data/lang/ba_BA.txt", AssetType::LANG);
 
-	return asset->check();
+	return Asset::get()->check();
 }
 
 // Carga los parametros para configurar el juego
-void Director::loadParams(std::string filepath)
+void Director::loadParams(const std::string &file_path)
 {
-	loadParamsFromFile(filepath);
-
-	// Modifica las opciones desde el fichero de parametros
-	options.video.window.width = options.video.window.size * param.game.width;
-	options.video.window.height = options.video.window.size * param.game.height;
-	options.video.gameWidth = param.game.width;
-	options.video.gameHeight = param.game.height;
+	loadParamsFromFile(file_path);
 }
 
 // Comprueba los parametros del programa
-void Director::checkProgramArguments(int argc, char *argv[])
+void Director::checkProgramArguments(int argc, const char *argv[])
 {
 	// Establece la ruta del programa
-	executablePath = argv[0];
+	executable_path_ = argv[0];
 
 	// Valores por defecto
-	paramFileArgument = "";
+	param_file_argument_.clear();
 
-	// Comprueba el resto de parametros
+	// Comprueba el resto de parámetros
 	for (int i = 1; i < argc; ++i)
 	{
 		if (strcmp(argv[i], "--320x240") == 0)
 		{
-			paramFileArgument = argv[i];
+			param_file_argument_ = argv[i];
 		}
 	}
 }
 
 // Crea la carpeta del sistema donde guardar datos
-void Director::createSystemFolder(std::string folder)
+void Director::createSystemFolder(const std::string &folder)
 {
 #ifdef _WIN32
-	systemFolder = std::string(getenv("APPDATA")) + "/" + folder;
+	system_folder_ = std::string(getenv("APPDATA")) + "/" + folder;
 #elif __APPLE__
 	struct passwd *pw = getpwuid(getuid());
 	const char *homedir = pw->pw_dir;
-	systemFolder = std::string(homedir) + "/Library/Application Support" + "/" + folder;
+	system_folder_ = std::string(homedir) + "/Library/Application Support" + "/" + folder;
 #elif __linux__
 	struct passwd *pw = getpwuid(getuid());
 	const char *homedir = pw->pw_dir;
-	systemFolder = std::string(homedir) + "/." + folder;
+	system_folder_ = std::string(homedir) + "/.config/" + folder;
+
+	{
+		// Intenta crear ".config", per si no existeix
+		std::string config_base_folder = std::string(homedir) + "/.config";
+		int ret = mkdir(config_base_folder.c_str(), S_IRWXU);
+		if (ret == -1 && errno != EEXIST)
+		{
+			printf("ERROR CREATING CONFIG BASE FOLDER.");
+			exit(EXIT_FAILURE);
+		}
+	}
 #endif
 
 	struct stat st = {0};
-	if (stat(systemFolder.c_str(), &st) == -1)
+	if (stat(system_folder_.c_str(), &st) == -1)
 	{
 		errno = 0;
 #ifdef _WIN32
-		int ret = mkdir(systemFolder.c_str());
+		int ret = mkdir(system_folder_.c_str());
 #else
-		int ret = mkdir(systemFolder.c_str(), S_IRWXU);
+		int ret = mkdir(system_folder_.c_str(), S_IRWXU);
 #endif
 
 		if (ret == -1)
@@ -563,17 +567,15 @@ void Director::createSystemFolder(std::string folder)
 void Director::loadSounds()
 {
 	// Obtiene la lista con las rutas a los ficheros de sonidos
-	std::vector<std::string> list = asset->getListByType(t_sound);
-	sounds.clear();
+	auto list = Asset::get()->getListByType(AssetType::SOUND);
+	sounds_.clear();
 
-	for (auto l : list)
+	for (const auto &l : list)
 	{
-		const size_t lastIndex = l.find_last_of("/") + 1;
-		const std::string name = l.substr(lastIndex, std::string::npos);
-		sound_file_t temp;
-		temp.name = name;					 // Añade el nombre del fichero
-		temp.file = JA_LoadSound(l.c_str()); // Carga el fichero de audio
-		sounds.push_back(temp);
+		auto last_index = l.find_last_of('/') + 1;
+		auto name = l.substr(last_index);
+
+		sounds_.emplace_back(SoundFile{name, JA_LoadSound(l.c_str())});
 	}
 }
 
@@ -581,136 +583,107 @@ void Director::loadSounds()
 void Director::loadMusics()
 {
 	// Obtiene la lista con las rutas a los ficheros musicales
-	std::vector<std::string> list = asset->getListByType(t_music);
-	musics.clear();
+	auto list = Asset::get()->getListByType(AssetType::MUSIC);
+	musics_.clear();
 
-	for (auto l : list)
+	for (const auto &l : list)
 	{
-		const size_t lastIndex = l.find_last_of("/") + 1;
-		const std::string name = l.substr(lastIndex, std::string::npos);
-		music_file_t temp;
-		temp.name = name;					 // Añade el nombre del fichero
-		temp.file = JA_LoadMusic(l.c_str()); // Carga el fichero de audio
-		musics.push_back(temp);
-	}
-}
+		auto last_index = l.find_last_of('/') + 1;
+		auto name = l.substr(last_index);
 
-// Libera la memoria usada por los sonidos del juego
-void Director::deleteSounds()
-{
-	for (auto s : sounds)
-	{
-		JA_DeleteSound(s.file);
+		musics_.emplace_back(MusicFile{name, JA_LoadMusic(l.c_str())});
 	}
-	sounds.clear();
-}
-
-// Libera la memoria usada por las músicas del juego
-void Director::deleteMusics()
-{
-	for (auto m : musics)
-	{
-		JA_DeleteMusic(m.file);
-	}
-	musics.clear();
 }
 
 // Ejecuta la sección con el logo
 void Director::runLogo()
 {
-	logo = new Logo();
+	auto logo = std::make_unique<Logo>();
 	logo->run();
-	delete logo;
 }
 
 // Ejecuta la sección con la secuencia de introducción
 void Director::runIntro()
 {
-	intro = new Intro(getMusic(musics, "intro.ogg"));
+	auto intro = std::make_unique<Intro>(getMusic(musics_, "intro.ogg"));
 	intro->run();
-	delete intro;
 }
 
-// Ejecuta la sección con el titulo del juego
+// Ejecuta la sección con el título del juego
 void Director::runTitle()
 {
-	title = new Title(getMusic(musics, "title.ogg"));
+	auto title = std::make_unique<Title>(getMusic(musics_, "title.ogg"));
 	title->run();
-	delete title;
 }
 
 // Ejecuta la sección donde se juega al juego
 void Director::runGame()
 {
-	const int playerID = section::options == section::OPTIONS_GAME_PLAY_1P ? 1 : 2;
-	const int currentStage = 0;
-	game = new Game(playerID, currentStage, GAME_MODE_DEMO_OFF, getMusic(musics, "playing.ogg"));
+	const auto player_id = section::options == section::Options::GAME_PLAY_1P ? 1 : 2;
+	constexpr auto current_stage = 0;
+	auto game = std::make_unique<Game>(player_id, current_stage, GAME_MODE_DEMO_OFF, getMusic(musics_, "playing.ogg"));
 	game->run();
-	delete game;
 }
 
 // Ejecuta la sección donde se muestran las instrucciones
 void Director::runInstructions()
 {
-	instructions = new Instructions(getMusic(musics, "title.ogg"));
+	auto instructions = std::make_unique<Instructions>(getMusic(musics_, "title.ogg"));
 	instructions->run();
-	delete instructions;
 }
 
 // Ejecuta la sección donde se muestra la tabla de puntuaciones
 void Director::runHiScoreTable()
 {
-	hiScoreTable = new HiScoreTable(getMusic(musics, "title.ogg"));
-	hiScoreTable->run();
-	delete hiScoreTable;
+	auto hi_score_table = std::make_unique<HiScoreTable>(getMusic(musics_, "title.ogg"));
+	hi_score_table->run();
 }
 
 // Ejecuta el juego en modo demo
 void Director::runDemoGame()
 {
-	const int playerID = (rand() % 2) + 1;
-	const int currentStage = 0;
-	demoGame = new Game(playerID, currentStage, GAME_MODE_DEMO_ON, nullptr);
-	demoGame->run();
-	delete demoGame;
+	const auto player_id = (rand() % 2) + 1;
+	constexpr auto current_stage = 0;
+	auto game = std::make_unique<Game>(player_id, current_stage, GAME_MODE_DEMO_ON, nullptr);
+	game->run();
 }
 
 int Director::run()
 {
 	// Bucle principal
-	while (section::name != section::NAME_QUIT)
+	while (section::name != section::Name::QUIT)
 	{
 		switch (section::name)
 		{
-		case section::NAME_INIT:
-			section::name = section::NAME_LOGO;
+		case section::Name::INIT:
+			section::name = section::Name::LOGO;
 			break;
 
-		case section::NAME_LOGO:
+		case section::Name::LOGO:
 			runLogo();
 			break;
 
-		case section::NAME_INTRO:
+		case section::Name::INTRO:
 			runIntro();
 			break;
 
-		case section::NAME_TITLE:
+		case section::Name::TITLE:
 			runTitle();
 			break;
 
-		case section::NAME_GAME:
+		case section::Name::GAME:
 			runGame();
 			break;
 
-		case section::NAME_HI_SCORE_TABLE:
+		case section::Name::HI_SCORE_TABLE:
 			runHiScoreTable();
 			break;
 
-		case section::NAME_GAME_DEMO:
+		case section::Name::GAME_DEMO:
 			runDemoGame();
 			break;
 
-		case section::NAME_INSTRUCTIONS:
+		case section::Name::INSTRUCTIONS:
 			runInstructions();
 			break;
 
@@ -719,30 +692,30 @@ int Director::run()
 		}
 	}
 
-	const int returnCode = section::options == section::OPTIONS_QUIT_NORMAL ? 0 : 1;
-	return returnCode;
+	const int return_code = section::options == section::Options::QUIT_NORMAL ? 0 : 1;
+	return return_code;
 }
 
-// Obtiene una fichero a partir de un lang_e
-std::string Director::getLangFile(lang::lang_e lang)
+// Obtiene una fichero a partir de un lang::Code
+std::string Director::getLangFile(lang::Code code)
 {
-	switch (lang)
+	switch (code)
 	{
-	case lang::ba_BA:
-		return asset->get("ba_BA.txt");
+	case lang::Code::ba_BA:
+		return Asset::get()->get("ba_BA.txt");
 		break;
 
-	case lang::es_ES:
-		return asset->get("es_ES.txt");
+	case lang::Code::es_ES:
+		return Asset::get()->get("es_ES.txt");
 		break;
 
-	case lang::en_UK:
-		return asset->get("en_UK.txt");
+	case lang::Code::en_UK:
+		return Asset::get()->get("en_UK.txt");
 		break;
 
 	default:
 		break;
 	}
 
-	return asset->get("en_UK.txt");
+	return Asset::get()->get("en_UK.txt");
 }

source/director.h

@@ -2,46 +2,28 @@
 
 #include <SDL2/SDL_render.h>  // for SDL_Renderer
 #include <SDL2/SDL_video.h>   // for SDL_Window
-#include <string>             // for string, basic_string
+#include <string>             // for string
 #include <vector>             // for vector
-#include "lang.h"             // for lang_e
-#include "utils.h"            // for music_file_t, sound_file_t
-class Asset;
-class Game;
-class HiScoreTable;
-class Input;
-class Instructions;
-class Intro;
-class Logo;
-class Screen;
-class Title;
+namespace lang { enum class Code : int; }
+struct MusicFile;
+struct SoundFile;
 
 // 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_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
+	SDL_Window *window_;		// La ventana donde dibujamos
+	SDL_Renderer *renderer_; // El renderizador de la ventana
 
 	// Variables
-	std::string executablePath;		  // Path del ejecutable
-	std::string systemFolder;		  // Carpeta del sistema donde guardar datos
-	std::string paramFileArgument;	  // Argumento para gestionar el fichero con los parametros del programa
-	std::vector<sound_file_t> sounds; // Vector con los sonidos
-	std::vector<music_file_t> musics; // Vector con las musicas
+	std::string executable_path_;	   // Path del ejecutable
+	std::string system_folder_;	   // Carpeta del sistema donde guardar datos
+	std::string param_file_argument_; // Argumento para gestionar el fichero con los parametros del programa
+	std::vector<SoundFile> sounds_; // Vector con los sonidos
+	std::vector<MusicFile> musics_; // Vector con las musicas
 
 	// Inicializa jail_audio
 	void initJailAudio();
@@ -53,7 +35,7 @@ private:
 	void initInput();
 
 	// Carga los parametros para configurar el juego
-	void loadParams(std::string filepath);
+	void loadParams(const std::string &file_path);
 
 	// Crea el indice de ficheros
 	bool setFileList();
@@ -64,17 +46,11 @@ private:
 	// 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();
@@ -97,12 +73,12 @@ private:
 	// Ejecuta el juego en modo demo
 	void runDemoGame();
 
-	// Obtiene una fichero a partir de un lang_e
-	std::string getLangFile(lang::lang_e lang);
+	// Obtiene una fichero a partir de un lang::Code
+	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,725 +0,0 @@
-#include "enemy_formations.h"
-#include "balloon.h"  // for BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
-#include "param.h"    // for param
-#include "utils.h"    // for paramGame_t, param_t, zone_t, BLOCK
-
-// Constructor
-EnemyFormations::EnemyFormations()
-{
-	initEnemyFormations();
-	initEnemyPools();
-	initGameStages();
-}
-
-// Destructor
-EnemyFormations::~EnemyFormations()
-{
-}
-
-// Inicializa las formaciones enemigas
-void EnemyFormations::initEnemyFormations()
-{
-	const int y4 =  - BLOCK;
-	const int x4_0 = param.game.playArea.rect.x;
-	const int x4_100 = param.game.playArea.rect.w - BALLOON_WIDTH_4;
-
-	const int y3 =  - BLOCK;
-	const int x3_0 = param.game.playArea.rect.x;
-	const int x3_100 = param.game.playArea.rect.w - BALLOON_WIDTH_3;
-
-	const int y2 =  - BLOCK;
-	const int x2_0 = param.game.playArea.rect.x;
-	const int x2_100 = param.game.playArea.rect.w - BALLOON_WIDTH_2;
-
-	const int y1 =  - BLOCK;
-	const int x1_0 = param.game.playArea.rect.x;
-	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,63 +0,0 @@
-#pragma once
-
-#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

@@ -3,15 +3,20 @@
 
 // Constructor
 EnterName::EnterName()
+{
+    init();
+}
+
+// Inicializa el objeto
+void EnterName::init()
 {
     // Obtiene el puntero al nombre
-    name = "A";
+    name_ = "A";
 
     // Inicia la lista de caracteres permitidos
-    // characterList = " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-    characterList = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()";
-    pos = 0;
-    numCharacters = (int)characterList.size();
+    character_list_ = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()";
+    pos_ = 0;
+    num_characters_ = (int)character_list_.size();
 
     // Pone la lista de indices para que refleje el nombre
     updateCharacterIndex();
@@ -20,32 +25,27 @@ EnterName::EnterName()
     updateName();
 }
 
-// Destructor
-EnterName::~EnterName()
-{
-}
-
 // Incrementa la posición
 void EnterName::incPos()
 {
-    pos++;
-    pos = std::min(pos, NAME_LENGHT - 1);
+    pos_++;
+    pos_ = std::min(pos_, NAME_LENGHT - 1);
 }
 
 // Decrementa la posición
 void EnterName::decPos()
 {
-    pos--;
-    pos = std::max(pos, 0);
+    pos_--;
+    pos_ = std::max(pos_, 0);
 }
 
 // Incrementa el índice
 void EnterName::incIndex()
 {
-    ++characterIndex[pos];
-    if (characterIndex[pos] >= numCharacters)
+    ++character_index_[pos_];
+    if (character_index_[pos_] >= num_characters_)
     {
-        characterIndex[pos] = 0;
+        character_index_[pos_] = 0;
     }
     updateName();
 }
@@ -53,10 +53,10 @@ void EnterName::incIndex()
 // Decrementa el índice
 void EnterName::decIndex()
 {
-    --characterIndex[pos];
-    if (characterIndex[pos] < 0)
+    --character_index_[pos_];
+    if (character_index_[pos_] < 0)
     {
-        characterIndex[pos] = numCharacters - 1;
+        character_index_[pos_] = num_characters_ - 1;
     }
     updateName();
 }
@@ -64,10 +64,10 @@ void EnterName::decIndex()
 // Actualiza la variable
 void EnterName::updateName()
 {
-    name.clear();
+    name_.clear();
     for (int i = 0; i < NAME_LENGHT; ++i)
     {
-        name.push_back(characterList[characterIndex[i]]);
+        name_.push_back(character_list_[character_index_[i]]);
     }
 }
 
@@ -77,22 +77,22 @@ void EnterName::updateCharacterIndex()
     // Rellena de espacios
     for (int i = 0; i < NAME_LENGHT; ++i)
     {
-        characterIndex[i] = 0;
+        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)
+    for (int i = 0; i < (int)name_.size(); ++i)
     {
-        characterIndex[i] = findIndex(name.at(i));
+        character_index_[i] = findIndex(name_.at(i));
     }
 }
 
-// Encuentra el indice de un caracter en "characterList"
+// Encuentra el indice de un caracter en "character_list_"
 int EnterName::findIndex(char character)
 {
-    for (int i = 0; i < (int)characterList.size(); ++i)
+    for (int i = 0; i < (int)character_list_.size(); ++i)
     {
-        if (character == characterList[i])
+        if (character == character_list_[i])
         {
             return i;
         }
@@ -101,13 +101,13 @@ int EnterName::findIndex(char character)
 }
 
 // Obtiene el nombre
-std::string EnterName::getName()
+std::string EnterName::getName() const
 {
-    return name;
+    return name_;
 }
 
 // Obtiene la posición que se está editando
-int EnterName::getPos()
+int EnterName::getPos() const
 {
-    return pos;
+    return pos_;
 }

source/enter_name.h

@@ -2,7 +2,7 @@
 
 #include <string>
 
-#define NAME_LENGHT 8
+constexpr int NAME_LENGHT = 8;
 
 /*
     Un array, "characterList", contiene la lista de caracteres
@@ -16,11 +16,11 @@
 class EnterName
 {
 private:
-    std::string characterList;       // Lista de todos los caracteres permitidos
-    std::string name;                // Nombre introducido
-    int pos;                         // Posición a editar del nombre
-    int numCharacters;               // 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
+    std::string character_list_;       // Lista de todos los caracteres permitidos
+    std::string name_;                 // Nombre introducido
+    int pos_;                          // Posición a editar del nombre
+    int num_characters_;               // Cantidad de caracteres de la lista de caracteres
+    int character_index_[NAME_LENGHT]; // Indice de la lista para cada uno de los caracteres que forman el nombre
 
     // Actualiza la variable
     void updateName();
@@ -36,7 +36,10 @@ public:
     EnterName();
 
     // Destructor
-    ~EnterName();
+    ~EnterName() = default;
+
+    // Inicializa el objeto
+    void init();
 
     // Incrementa la posición
     void incPos();
@@ -51,8 +54,8 @@ public:
     void decIndex();
 
     // Obtiene el nombre
-    std::string getName();
+    std::string getName() const;
 
     // Obtiene la posición que se está editando
-    int getPos();
+    int getPos() const;
 };

source/explosions.cpp

@@ -1,30 +1,25 @@
 #include "explosions.h"
-#include "animated_sprite.h"  // for AnimatedSprite
-class Texture;
+#include <utility>           // for move
+#include "animated_sprite.h" // for AnimatedSprite
+class Texture;               // lines 3-3
 
 // Constructor
 Explosions::Explosions()
 {
-    textures.clear();
-    explosions.clear();
+    textures_.clear();
+    explosions_.clear();
 }
 
 // Destructor
 Explosions::~Explosions()
 {
-    for (auto explosion : explosions)
-    {
-        if (explosion)
-        {
-            delete explosion;
-        }
-    }
+    explosions_.clear();
 }
 
 // Actualiza la lógica de la clase
 void Explosions::update()
 {
-    for (auto explosion : explosions)
+    for (auto &explosion : explosions_)
     {
         explosion->update();
     }
@@ -36,42 +31,41 @@ void Explosions::update()
 // Dibuja el objeto en pantalla
 void Explosions::render()
 {
-    for (auto explosion : explosions)
+    for (auto &explosion : explosions_)
     {
         explosion->render();
     }
 }
 
-// Añade texturas al objetp
-void Explosions::addTexture(int size, Texture *texture, std::vector<std::string> *animation)
+// Añade texturas al objeto
+void Explosions::addTexture(int size, std::shared_ptr<Texture> texture, std::vector<std::string> *animation)
 {
-    explosion_texture_t temp;
+    ExplosionTexture temp;
     temp.size = size;
     temp.texture = texture;
     temp.animation = animation;
-    textures.push_back(temp);
+    textures_.push_back(temp);
 }
 
 // Añade una explosión
 void Explosions::add(int x, int y, int size)
 {
     const int index = getIndexBySize(size);
-    AnimatedSprite *sprite = new AnimatedSprite(textures[index].texture, "", textures[index].animation);
+    auto sprite = std::make_unique<AnimatedSprite>(textures_[index].texture, "", textures_[index].animation);
     sprite->setPos(x, y);
-    explosions.push_back(sprite);
+    explosions_.push_back(std::move(sprite));
 }
 
 // Vacia el vector de elementos finalizados
 void Explosions::freeExplosions()
 {
-    if (explosions.empty() == false)
+    if (explosions_.empty() == false)
     {
-        for (int i = explosions.size() - 1; i >= 0; --i)
+        for (int i = explosions_.size() - 1; i >= 0; --i)
         {
-            if (explosions[i]->animationIsCompleted())
+            if (explosions_[i]->animationIsCompleted())
             {
-                delete explosions[i];
-                explosions.erase(explosions.begin() + i);
+                explosions_.erase(explosions_.begin() + i);
             }
         }
     }
@@ -80,9 +74,9 @@ void Explosions::freeExplosions()
 // Busca una textura a partir del tamaño
 int Explosions::getIndexBySize(int size)
 {
-    for (int i = 0; i < (int)textures.size();++i)
+    for (int i = 0; i < (int)textures_.size(); ++i)
     {
-        if (size == textures[i].size)
+        if (size == textures_[i].size)
         {
             return i;
         }

source/explosions.h

@@ -1,13 +1,14 @@
 #pragma once
 
+#include <memory>  // for shared_ptr, unique_ptr
 #include <string>  // for string
 #include <vector>  // for vector
 class AnimatedSprite;
 class Texture;
 
-struct explosion_texture_t
+struct ExplosionTexture
 {
-    Texture *texture;                    // Textura para la explosión
+    std::shared_ptr<Texture> texture;    // Textura para la explosión
     std::vector<std::string> *animation; // Animación para la textura
     int size;                            // Tamaño de la explosión
 };
@@ -17,8 +18,8 @@ class Explosions
 {
 private:
     // Variables
-    std::vector<explosion_texture_t> textures; // Vector con las texturas a utilizar
-    std::vector<AnimatedSprite *> explosions;  // Lista con todas las explosiones
+    std::vector<ExplosionTexture> textures_;                  // Vector con las texturas a utilizar
+    std::vector<std::unique_ptr<AnimatedSprite>> explosions_; // Lista con todas las explosiones
 
     // Vacia el vector de elementos finalizados
     void freeExplosions();
@@ -39,8 +40,8 @@ public:
     // Dibuja el objeto en pantalla
     void render();
 
-    // Añade texturas al objetp
-    void addTexture(int size, Texture *texture, std::vector<std::string> *animation);
+    // Añade texturas al objeto
+    void addTexture(int size, std::shared_ptr<Texture> texture, std::vector<std::string> *animation);
 
     // Añade una explosión
     void add(int x, int y, int size);

source/fade.cpp

@@ -1,20 +1,18 @@
 #include "fade.h"
-#include <SDL2/SDL_blendmode.h>  // for SDL_BLENDMODE_BLEND, SDL_BLENDMODE_NONE
-#include <SDL2/SDL_pixels.h>     // for SDL_PIXELFORMAT_RGBA8888
-#include <stdlib.h>              // for rand
-#include <algorithm>             // for min, max
-#include "param.h"               // for param
-#include "utils.h"               // for param_t, paramGame_t, paramFade_t
+#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND, SDL_BLENDMODE_NONE
+#include <SDL2/SDL_pixels.h>	// for SDL_PIXELFORMAT_RGBA8888
+#include <stdlib.h>				// for rand
+#include <algorithm>			// for min, max
+#include "param.h"				// for param
+#include "utils.h"				// for Param, ParamGame, ParamFade
 
 // Constructor
 Fade::Fade(SDL_Renderer *renderer)
+	: renderer_(renderer)
 {
-	// Copia punteros y objetos
-	this->renderer = renderer;
-
 	// Crea la textura donde dibujar el fade
-	backbuffer = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
-	SDL_SetTextureBlendMode(backbuffer, SDL_BLENDMODE_BLEND);
+	backbuffer_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
+	SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
 
 	// Inicializa las variables
 	init();
@@ -23,179 +21,177 @@ Fade::Fade(SDL_Renderer *renderer)
 // Destructor
 Fade::~Fade()
 {
-	SDL_DestroyTexture(backbuffer);
-	backbuffer = nullptr;
+	SDL_DestroyTexture(backbuffer_);
+	backbuffer_ = nullptr;
 }
 
 // Inicializa las variables
 void Fade::init()
 {
-	type = FADE_CENTER;
-	mode = FADE_OUT;
-	enabled = false;
-	finished = false;
-	counter = 0;
-	r = 0;
-	g = 0;
-	b = 0;
-	postDuration = 20;
-	postCounter = 0;
-	numSquaresWidth = param.fade.numSquaresWidth;
-	numSquaresHeight = param.fade.numSquaresHeight;
-	fadeRandomSquaresDelay = param.fade.randomSquaresDelay;
-	fadeRandomSquaresMult = param.fade.randomSquaresMult;
+	type_ = FadeType::CENTER;
+	mode_ = FadeMode::OUT;
+	enabled_ = false;
+	finished_ = false;
+	counter_ = 0;
+	r_ = 0;
+	g_ = 0;
+	b_ = 0;
+	a_ = 0;
+	post_duration_ = 20;
+	post_counter_ = 0;
+	num_squares_width_ = param.fade.num_squares_width;
+	num_squares_height_ = param.fade.num_squares_height;
+	fade_random_squares_delay_ = param.fade.random_squares_delay;
+	fade_random_squares_mult_ = param.fade.random_squares_mult;
 }
 
 // Resetea algunas variables para volver a hacer el fade sin perder ciertos parametros
 void Fade::reset()
 {
-	enabled = false;
-	finished = false;
-	counter = 0;
+	enabled_ = false;
+	finished_ = false;
+	counter_ = 0;
 }
 
 // Pinta una transición en pantalla
 void Fade::render()
 {
-	if (enabled || finished)
+	if (enabled_ || finished_)
 	{
-		SDL_RenderCopy(renderer, backbuffer, nullptr, nullptr);
+		SDL_RenderCopy(renderer_, backbuffer_, nullptr, nullptr);
 	}
 }
 
 // Actualiza las variables internas
 void Fade::update()
 {
-	if (enabled)
+	if (enabled_)
 	{
-		switch (type)
+		switch (type_)
 		{
-		case FADE_FULLSCREEN:
+		case FadeType::FULLSCREEN:
 		{
-			// Modifica la transparencia de la 
-			if (mode == FADE_OUT)
-				a = std::min(counter * 4, 255);
-			else
-				a = 255 - std::min(counter * 4, 255);
+			// Modifica la transparencia
+			a_ = mode_ == FadeMode::OUT ? std::min(counter_ * 4, 255) : 255 - std::min(counter_ * 4, 255);
 
-			SDL_SetTextureAlphaMod(backbuffer, a);
+			SDL_SetTextureAlphaMod(backbuffer_, a_);
 
 			// Comprueba si ha terminado
-			if (counter >= 255 / 4)
+			if (counter_ >= 255 / 4)
 			{
-				finished = true;
+				finished_ = true;
 			}
 
 			break;
 		}
 
-		case FADE_CENTER:
+		case FadeType::CENTER:
 		{
-			// Dibuja sobre el backbuffer
-			SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-			SDL_SetRenderTarget(renderer, backbuffer);
+			// Dibuja sobre el backbuffer_
+			auto temp = SDL_GetRenderTarget(renderer_);
+			SDL_SetRenderTarget(renderer_, backbuffer_);
 
-			SDL_SetRenderDrawColor(renderer, r, g, b, a);
+			SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
 
-			for (int i = 0; i < counter; i++)
+			for (int i = 0; i < counter_; i++)
 			{
-				rect1.h = rect2.h = i * 4;
-				rect2.y = param.game.height - (i * 4);
+				rect1_.h = rect2_.h = i * 4;
+				rect2_.y = param.game.height - (i * 4);
 
-				SDL_RenderFillRect(renderer, &rect1);
-				SDL_RenderFillRect(renderer, &rect2);
+				SDL_RenderFillRect(renderer_, &rect1_);
+				SDL_RenderFillRect(renderer_, &rect2_);
 			}
 
 			// Deja el renderizador como estaba
-			SDL_SetRenderTarget(renderer, temp);
+			SDL_SetRenderTarget(renderer_, temp);
 
 			// Comprueba si ha terminado
-			if ((counter * 4) > param.game.height)
+			if ((counter_ * 4) > param.game.height)
 			{
-				finished = true;
-				a = 255;
+				finished_ = true;
+				a_ = 255;
 			}
 			break;
 		}
 
-		case FADE_RANDOM_SQUARE:
+		case FadeType::RANDOM_SQUARE:
 		{
-			if (counter % fadeRandomSquaresDelay == 0)
+			if (counter_ % fade_random_squares_delay_ == 0)
 			{
-				// Dibuja sobre el backbuffer
-				SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-				SDL_SetRenderTarget(renderer, backbuffer);
+				// Dibuja sobre el backbuffer_
+				auto temp = SDL_GetRenderTarget(renderer_);
+				SDL_SetRenderTarget(renderer_, backbuffer_);
 
-				SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
-				SDL_SetRenderDrawColor(renderer, r, g, b, a);
+				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
+				SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
 
 				// Dibuja el cuadrado correspondiente
-				const int index = std::min(counter / fadeRandomSquaresDelay, (numSquaresWidth * numSquaresHeight) - 1);
-				for (int i = 0; i < fadeRandomSquaresMult; ++i)
+				const int index = std::min(counter_ / fade_random_squares_delay_, (num_squares_width_ * num_squares_height_) - 1);
+				for (int i = 0; i < fade_random_squares_mult_; ++i)
 				{
-					const int index2 = std::min(index * fadeRandomSquaresMult + i, (int)square.size() - 1);
-					SDL_RenderFillRect(renderer, &square[index2]);
+					const int index2 = std::min(index * fade_random_squares_mult_ + i, (int)square_.size() - 1);
+					SDL_RenderFillRect(renderer_, &square_[index2]);
 				}
 
-				SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
+				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
 
 				// Deja el renderizador como estaba
-				SDL_SetRenderTarget(renderer, temp);
+				SDL_SetRenderTarget(renderer_, temp);
 			}
 
 			// Comprueba si ha terminado
-			if (counter * fadeRandomSquaresMult / fadeRandomSquaresDelay >= numSquaresWidth * numSquaresHeight)
+			if (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_ >= num_squares_width_ * num_squares_height_)
 			{
-				finished = true;
+				finished_ = true;
 			}
 
 			break;
 		}
 
-		case FADE_VENETIAN:
+		case FadeType::VENETIAN:
 		{
 			// Counter debe ir de 0 a 150
-			if (square.back().h < param.fade.venetianSize)
+			if (square_.back().h < param.fade.venetian_size)
 			{
-				// Dibuja sobre el backbuffer
-				SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-				SDL_SetRenderTarget(renderer, backbuffer);
+				// Dibuja sobre el backbuffer_
+				auto temp = SDL_GetRenderTarget(renderer_);
+				SDL_SetRenderTarget(renderer_, backbuffer_);
 
-				SDL_SetRenderDrawColor(renderer, r, g, b, a);
-				for (auto rect : square)
+				SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
+				for (auto rect : square_)
 				{
-					SDL_RenderFillRect(renderer, &rect);
+					SDL_RenderFillRect(renderer_, &rect);
 				}
 
 				// Deja el renderizador como estaba
-				SDL_SetRenderTarget(renderer, temp);
+				SDL_SetRenderTarget(renderer_, temp);
 
-				const Uint8 h = counter / 3;
-				for (int i = 0; i < (int)square.size(); ++i)
+				const auto h = counter_ / 3;
+				for (int i = 0; i < (int)square_.size(); ++i)
 				{
 					// A partir del segundo rectangulo se pinta en función del anterior
-					i == 0 ? square[i].h = h : square[i].h = std::max(square[i - 1].h - 3, 0);
+					square_[i].h = i == 0 ? h : std::max(square_[i - 1].h - 3, 0);
 				}
 			}
 			else
 			{
-				finished = true;
+				finished_ = true;
 			}
 
 			break;
 		}
 		}
 
-		if (finished)
+		if (finished_)
 		{
 			// Actualiza el contador
-			postCounter == postDuration ? enabled = false : postCounter++;
+			post_counter_ == post_duration_ ? enabled_ = false : post_counter_++;
 
-			// Deja el backbuffer todo del mismo color
-			cleanBackbuffer(r, g, b, a);
+			// Deja el backbuffer_ todo del mismo color
+			cleanBackbuffer(r_, g_, b_, a_);
 		}
 
-		counter++;
+		counter_++;
 	}
 }
 
@@ -203,84 +199,85 @@ void Fade::update()
 void Fade::activate()
 {
 	// Si ya está habilitado, no hay que volverlo a activar
-	if (enabled)
+	if (enabled_)
 	{
 		return;
 	}
 
-	enabled = true;
-	finished = false;
-	counter = 0;
-	postCounter = 0;
+	enabled_ = true;
+	finished_ = false;
+	counter_ = 0;
+	post_counter_ = 0;
 
-	switch (type)
+	switch (type_)
 	{
-	case FADE_FULLSCREEN:
+	case FadeType::FULLSCREEN:
 	{
-		// Pinta el backbuffer de color sólido
-		cleanBackbuffer(r, g, b, 255);
+		// Pinta el backbuffer_ de color sólido
+		cleanBackbuffer(r_, g_, b_, 255);
 		break;
 	}
 
-	case FADE_CENTER:
+	case FadeType::CENTER:
 	{
-		rect1 = {0, 0, param.game.width, 0};
-		rect2 = {0, 0, param.game.width, 0};
-		a = 64;
+		rect1_ = {0, 0, param.game.width, 0};
+		rect2_ = {0, 0, param.game.width, 0};
+		a_ = 64;
 		break;
 	}
 
-	case FADE_RANDOM_SQUARE:
+	case FadeType::RANDOM_SQUARE:
 	{
-		rect1 = {0, 0, param.game.width / numSquaresWidth, param.game.height / numSquaresHeight};
-		square.clear();
+		rect1_ = {0, 0, param.game.width / num_squares_width_, param.game.height / num_squares_height_};
+		square_.clear();
 
 		// Añade los cuadrados al vector
-		for (int i = 0; i < numSquaresWidth * numSquaresHeight; ++i)
+		for (int i = 0; i < num_squares_width_ * num_squares_height_; ++i)
 		{
-			rect1.x = (i % numSquaresWidth) * rect1.w;
-			rect1.y = (i / numSquaresWidth) * rect1.h;
-			square.push_back(rect1);
+			rect1_.x = (i % num_squares_width_) * rect1_.w;
+			rect1_.y = (i / num_squares_width_) * rect1_.h;
+			square_.push_back(rect1_);
 		}
 
 		// Desordena el vector de cuadrados
-		int num = numSquaresWidth * numSquaresHeight;
+		auto num = num_squares_width_ * num_squares_height_;
 		while (num > 1)
 		{
-			int num_arreu = rand() % num;
-			SDL_Rect temp = square[num_arreu];
-			square[num_arreu] = square[num - 1];
-			square[num - 1] = temp;
+			auto num_arreu = rand() % num;
+			SDL_Rect temp = square_[num_arreu];
+			square_[num_arreu] = square_[num - 1];
+			square_[num - 1] = temp;
 			num--;
 		}
 
 		// Limpia la textura
-		SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-		SDL_SetRenderTarget(renderer, backbuffer);
-		a = mode == FADE_OUT ? 0 : 255;
-		SDL_SetRenderDrawColor(renderer, r, g, b, a);
-		SDL_RenderClear(renderer);
-		SDL_SetRenderTarget(renderer, temp);
+		auto temp = SDL_GetRenderTarget(renderer_);
+		SDL_SetRenderTarget(renderer_, backbuffer_);
+		a_ = mode_ == FadeMode::OUT ? 0 : 255;
+		SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
+		SDL_RenderClear(renderer_);
+		SDL_SetRenderTarget(renderer_, temp);
 
 		// Deja el color listo para usar
-		a = mode == FADE_OUT ? 255 : 0;
+		a_ = mode_ == FadeMode::OUT ? 255 : 0;
 
 		break;
 	}
 
-	case FADE_VENETIAN:
+	case FadeType::VENETIAN:
 	{
-		rect1 = {0, 0, param.game.width, 0};
-		square.clear();
-		a = 255;
+		cleanBackbuffer(0, 0, 0, 0);
+		rect1_ = {0, 0, param.game.width, 0};
+		square_.clear();
+		a_ = 255;
 
 		// Añade los cuadrados al vector
-		const int max = param.game.height / param.fade.venetianSize;
+		const int max = param.game.height / param.fade.venetian_size;
 
 		for (int i = 0; i < max; ++i)
 		{
-			rect1.y = i * param.fade.venetianSize;
-			square.push_back(rect1);
+			rect1_.y = i * param.fade.venetian_size;
+			square_.push_back(rect1_);
 		}
 
 		break;
@@ -289,55 +286,55 @@ void Fade::activate()
 }
 
 // Comprueba si está activo
-bool Fade::isEnabled()
+bool Fade::isEnabled() const
 {
-	return enabled;
+	return enabled_;
 }
 
 // Comprueba si ha terminado la transicion
-bool Fade::hasEnded()
+bool Fade::hasEnded() const
 {
 	// Ha terminado cuando ha finalizado la transición y se ha deshabilitado
-	return !enabled && finished;
+	return !enabled_ && finished_;
 }
 
 // Establece el tipo de fade
-void Fade::setType(Uint8 type)
+void Fade::setType(FadeType type)
 {
-	this->type = type;
+	type_ = type;
 }
 
 // Establece el modo de fade
-void Fade::setMode(Uint8 mode)
+void Fade::setMode(FadeMode mode)
 {
-	this->mode = mode;
+	mode_ = mode;
 }
 
 // Establece el color del fade
 void Fade::setColor(Uint8 r, Uint8 g, Uint8 b)
 {
-	this->r = r;
-	this->g = g;
-	this->b = b;
+	r_ = r;
+	g_ = g;
+	b_ = b;
 }
 
 // Establece la duración posterior
 void Fade::setPost(int value)
 {
-	postDuration = value;
+	post_duration_ = value;
 }
 
 // Limpia el backbuffer
-void Fade::cleanBackbuffer(int r, int g, int b, int a)
+void Fade::cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a)
 {
-	// Dibujamos sobre el backbuffer
-	SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-	SDL_SetRenderTarget(renderer, backbuffer);
+	// Dibujamos sobre el backbuffer_
+	auto temp = SDL_GetRenderTarget(renderer_);
+	SDL_SetRenderTarget(renderer_, backbuffer_);
 
 	// Pintamos la textura con el color del fade
-	SDL_SetRenderDrawColor(renderer, r, g, b, a);
-	SDL_RenderClear(renderer);
+	SDL_SetRenderDrawColor(renderer_, r, g, b, a);
+	SDL_RenderClear(renderer_);
 
 	// Vuelve a dejar el renderizador como estaba
-	SDL_SetRenderTarget(renderer, temp);
+	SDL_SetRenderTarget(renderer_, temp);
 }

source/fade.h

@@ -1,54 +1,60 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>    // for SDL_Rect
-#include <SDL2/SDL_render.h>  // for SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h>  // for Uint8, Uint16
-#include <vector>             // for vector
+#include <SDL2/SDL_rect.h>	 // for SDL_Rect
+#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_stdinc.h> // for Uint8, Uint16
+#include <vector>			 // for vector
 
 // Tipos de fundido
-#define FADE_FULLSCREEN 0
-#define FADE_CENTER 1
-#define FADE_RANDOM_SQUARE 2
-#define FADE_VENETIAN 3
+enum class FadeType : Uint8
+{
+	FULLSCREEN = 0,
+	CENTER = 1,
+	RANDOM_SQUARE = 2,
+	VENETIAN = 3,
+};
 
 // Modos de fundido
-#define FADE_IN 0
-#define FADE_OUT 1
+enum class FadeMode : Uint8
+{
+	IN = 0,
+	OUT = 1,
+};
 
 // Clase Fade
 class Fade
 {
 private:
 	// Objetos y punteros
-	SDL_Renderer *renderer;	 // El renderizador de la ventana
-	SDL_Texture *backbuffer; // Textura para usar como backbuffer con SDL_TEXTUREACCESS_TARGET
+	SDL_Renderer *renderer_;  // El renderizador de la ventana
+	SDL_Texture *backbuffer_; // Textura para usar como backbuffer con SDL_TEXTUREACCESS_TARGET
 
 	// Variables
-	Uint8 type;					  // Tipo de fade a realizar
-	Uint8 mode;					  // Modo de fade a realizar
-	Uint16 counter;				  // Contador interno
-	bool enabled;				  // Indica si el fade está activo
-	bool finished;				  // Indica si ha terminado la transición
-	Uint8 r, g, b, a;			  // Colores para el fade
-	SDL_Rect rect1;				  // Rectangulo usado para crear los efectos de transición
-	SDL_Rect rect2;				  // Rectangulo usado para crear los efectos de transición
-	int numSquaresWidth;		  // Cantidad total de cuadraditos en horizontal para el FADE_RANDOM_SQUARE
-	int numSquaresHeight;		  // Cantidad total de cuadraditos en vertical para el FADE_RANDOM_SQUARE
-	std::vector<SDL_Rect> square; // Vector con los indices de los cuadrados para el FADE_RANDOM_SQUARE
-	int fadeRandomSquaresDelay;	  // Duración entre cada pintado de cuadrados
-	int fadeRandomSquaresMult;	  // Cantidad de cuadrados que se pintaran cada vez
-	int postDuration;			  // Duración posterior del fade tras finalizar
-	int postCounter;			  // Contador para la duración posterior
+	FadeType type_;					// Tipo de fade a realizar
+	FadeMode mode_;					// Modo de fade a realizar
+	Uint16 counter_;				// Contador interno
+	bool enabled_;					// Indica si el fade está activo
+	bool finished_;					// Indica si ha terminado la transición
+	Uint8 r_, g_, b_, a_;			// Colores para el fade
+	SDL_Rect rect1_;				// Rectangulo usado para crear los efectos de transición
+	SDL_Rect rect2_;				// Rectangulo usado para crear los efectos de transición
+	int num_squares_width_;			// Cantidad total de cuadraditos en horizontal para el FadeType::RANDOM_SQUARE
+	int num_squares_height_;		// Cantidad total de cuadraditos en vertical para el FadeType::RANDOM_SQUARE
+	std::vector<SDL_Rect> square_;	// Vector con los indices de los cuadrados para el FadeType::RANDOM_SQUARE
+	int fade_random_squares_delay_; // Duración entre cada pintado de cuadrados
+	int fade_random_squares_mult_;	// Cantidad de cuadrados que se pintaran cada vez
+	int post_duration_;				// Duración posterior del fade tras finalizar
+	int post_counter_;				// Contador para la duración posterior
 
 	// Inicializa las variables
 	void init();
 
 	// Limpia el backbuffer
-	void cleanBackbuffer(int r, int g, int b, int a);
+	void cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a);
 
 public:
 	// Constructor
-	Fade(SDL_Renderer *renderer);
+	explicit Fade(SDL_Renderer *renderer);
 
 	// Destructor
 	~Fade();
@@ -66,16 +72,16 @@ public:
 	void activate();
 
 	// Comprueba si ha terminado la transicion
-	bool hasEnded();
+	bool hasEnded() const;
 
 	// Comprueba si está activo
-	bool isEnabled();
+	bool isEnabled() const;
 
 	// Establece el tipo de fade
-	void setType(Uint8 type);
+	void setType(FadeType type);
 
 	// Establece el modo de fade
-	void setMode(Uint8 mode);
+	void setMode(FadeMode mode);
 
 	// Establece el color del fade
 	void setColor(Uint8 r, Uint8 g, Uint8 b);

source/game.h

@@ -1,55 +1,56 @@
 #pragma once
 
-#include <SDL2/SDL_events.h> // for SDL_Event
 #include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
 #include <SDL2/SDL_stdinc.h> // for Uint32
+#include <memory>			 // for shared_ptr, unique_ptr
 #include <string>			 // for string
 #include <vector>			 // for vector
-#include "section.h"		 // for options_e
-#include "utils.h"			 // for demoKeys_t, color_t, hiScoreEntry_t
-class Asset;				 // lines 11-11
-class Background;			 // lines 12-12
-class Balloon;				 // lines 13-13
-class Bullet;				 // lines 14-14
-class EnemyFormations;		 // lines 15-15
-class Explosions;			 // lines 16-16
-class Fade;					 // lines 17-17
-class Input;				 // lines 18-18
-class Item;					 // lines 19-19
-class Player;				 // lines 20-20
-class Scoreboard;			 // lines 21-21
-class Screen;				 // lines 22-22
-class SmartSprite;			 // lines 23-23
-class Text;					 // lines 24-24
-class Texture;				 // lines 25-25
-enum class BulletType;
-struct JA_Music_t; // lines 26-26
-struct JA_Sound_t; // lines 27-27
+#include "balloon.h"		 // for Balloon
+#include "player.h"			 // for Player
+#include "utils.h"			 // for DemoKeys, Color, HiScoreEntry
+class Asset;
+class Background;
+class BalloonFormations;
+class Bullet;
+class Explosions;
+class Fade;
+class Input;
+class Item;
+class Scoreboard;
+class Screen;
+class SmartSprite;
+class Text;
+class Texture;
+enum class BulletType; // lines 26-26
+struct JA_Music_t;	   // lines 27-27
+struct JA_Sound_t;	   // lines 28-28
 
-#define GAME_MODE_DEMO_OFF false
-#define GAME_MODE_DEMO_ON true
+// Modo demo
+constexpr bool GAME_MODE_DEMO_OFF = false;
+constexpr bool GAME_MODE_DEMO_ON = true;
 
 // Cantidad de elementos a escribir en los ficheros de datos
-#define TOTAL_SCORE_DATA 3
-#define TOTAL_DEMO_DATA 2000
+constexpr int TOTAL_SCORE_DATA = 3;
+constexpr int TOTAL_DEMO_DATA = 2000;
 
 // Contadores
-#define STAGE_COUNTER 200
-#define HELP_COUNTER 1000
-#define GAME_COMPLETED_START_FADE 500
-#define GAME_COMPLETED_END 700
+constexpr int STAGE_COUNTER = 200;
+constexpr int HELP_COUNTER = 1000;
+constexpr int GAME_COMPLETED_START_FADE = 500;
+constexpr int GAME_COMPLETED_END = 700;
+constexpr int GAME_OVER_COUNTER = 350;
 
 // Porcentaje de aparición de los objetos
-#define ITEM_POINTS_1_DISK_ODDS 10
-#define ITEM_POINTS_2_GAVINA_ODDS 6
-#define ITEM_POINTS_3_PACMAR_ODDS 3
-#define ITEM_CLOCK_ODDS 5
-#define ITEM_COFFEE_ODDS 5
-#define ITEM_POWER_BALL_ODDS 0
-#define ITEM_COFFEE_MACHINE_ODDS 4
+constexpr int ITEM_POINTS_1_DISK_ODDS = 10;
+constexpr int ITEM_POINTS_2_GAVINA_ODDS = 6;
+constexpr int ITEM_POINTS_3_PACMAR_ODDS = 3;
+constexpr int ITEM_CLOCK_ODDS = 5;
+constexpr int ITEM_COFFEE_ODDS = 5;
+constexpr int ITEM_POWER_BALL_ODDS = 0;
+constexpr int ITEM_COFFEE_MACHINE_ODDS = 4;
 
 // Valores para las variables asociadas a los objetos
-#define TIME_STOPPED_COUNTER 300
+constexpr int TIME_STOPPED_COUNTER = 300;
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de toda la parte en la
@@ -81,127 +82,128 @@ struct JA_Sound_t; // lines 27-27
 class Game
 {
 private:
-	struct helper_t
+	struct Helper
 	{
-		bool needCoffee;		   // Indica si se necesitan cafes
-		bool needCoffeeMachine;	   // Indica si se necesita PowerUp
-		bool needPowerBall;		   // Indica si se necesita una PowerBall
-		int counter;			   // Contador para no dar ayudas consecutivas
-		int itemPoints1Odds;	   // Probabilidad de aparición del objeto
-		int itemPoints2Odds;	   // Probabilidad de aparición del objeto
-		int itemPoints3Odds;	   // Probabilidad de aparición del objeto
-		int itemClockOdds;		   // Probabilidad de aparición del objeto
-		int itemCoffeeOdds;		   // Probabilidad de aparición del objeto
-		int itemCoffeeMachineOdds; // Probabilidad de aparición del objeto
+		bool need_coffee;			  // Indica si se necesitan cafes
+		bool need_coffee_machine;	  // Indica si se necesita PowerUp
+		bool need_power_ball;		  // Indica si se necesita una PowerBall
+		int counter;				  // Contador para no dar ayudas consecutivas
+		int item_disk_odds;			  // Probabilidad de aparición del objeto
+		int item_gavina_odds;		  // Probabilidad de aparición del objeto
+		int item_pacmar_odds;		  // Probabilidad de aparición del objeto
+		int item_clock_odds;		  // Probabilidad de aparición del objeto
+		int item_coffee_odds;		  // Probabilidad de aparición del objeto
+		int item_coffee_machine_odds; // Probabilidad de aparición del objeto
 	};
 
-	struct demo_t
+	struct Demo
 	{
-		bool enabled;							 // Indica si está activo el modo demo
-		bool recording;							 // Indica si está activado el modo para grabar la demo
-		int counter;							 // Contador para el modo demo
-		demoKeys_t keys;						 // Variable con las pulsaciones de teclas del modo demo
-		demoKeys_t dataFile[2][TOTAL_DEMO_DATA]; // Vector con diferentes sets de datos con los movimientos para la demo
+		bool enabled;							// Indica si está activo el modo demo
+		bool recording;							// Indica si está activado el modo para grabar la demo
+		int counter;							// Contador para el modo demo
+		DemoKeys keys;							// Variable con las pulsaciones de teclas del modo demo
+		DemoKeys data_file[2][TOTAL_DEMO_DATA]; // Vector con diferentes sets de datos con los movimientos para la demo
 	};
 
 	// Objetos y punteros
-	SDL_Renderer *renderer;			  // El renderizador de la ventana
-	Screen *screen;					  // Objeto encargado de dibujar en pantalla
-	Asset *asset;					  // Objeto que gestiona todos los ficheros de recursos
-	Input *input;					  // Manejador de entrada
-	Scoreboard *scoreboard;			  // Objeto para dibujar el marcador
-	Background *background;			  // Objeto para dibujar el fondo del juego
-	Explosions *explosions;			  // Objeto para dibujar explosiones
-	EnemyFormations *enemyFormations; // Objeto para gestionar las oleadas enemigas
-	SDL_Texture *canvas;			  // Textura para dibujar la zona de juego
+	SDL_Renderer *renderer_; // El renderizador de la ventana
+	Screen *screen_;		 // Objeto encargado de dibujar en pantalla
+	Asset *asset_;			 // Objeto que gestiona todos los ficheros de recursos
+	Input *input_;			 // Manejador de entrada
+	Scoreboard *scoreboard_; // Objeto para dibujar el marcador
 
-	std::vector<Player *> players;			 // Vector con los jugadores
-	std::vector<Balloon *> balloons;		 // Vector con los globos
-	std::vector<Bullet *> bullets;			 // Vector con las balas
-	std::vector<Item *> items;				 // Vector con los items
-	std::vector<SmartSprite *> smartSprites; // Vector con los smartsprites
+	std::unique_ptr<Background> background_;				// Objeto para dibujar el fondo del juego
+	std::unique_ptr<Explosions> explosions_;				// Objeto para dibujar explosiones
+	std::unique_ptr<BalloonFormations> balloon_formations_; // Objeto para gestionar las oleadas enemigas
 
-	Texture *bulletTexture;								// Textura para las balas
-	std::vector<Texture *> itemTextures;				// Vector con las texturas de los items
-	std::vector<Texture *> balloonTextures;				// Vector con las texturas de los globos
-	std::vector<Texture *> explosionsTextures;			// Vector con las texturas de las explosiones
-	std::vector<Texture *> player1Textures;				// Vector con las texturas del jugador
-	std::vector<Texture *> player2Textures;				// Vector con las texturas del jugador
-	std::vector<std::vector<Texture *>> playerTextures; // Vector con todas las texturas de los jugadores;
+	SDL_Texture *canvas_; // Textura para dibujar la zona de juego
 
-	Texture *gameTextTexture; // Textura para los sprites con textos
+	std::vector<std::shared_ptr<Player>> players_;	 // Vector con los jugadores
+	std::vector<std::shared_ptr<Balloon>> balloons_; // Vector con los globos
+	std::vector<std::unique_ptr<Bullet>> bullets_;	 // Vector con las balas
+	std::vector<std::unique_ptr<Item>> items_;		 // Vector con los items
+	std::vector<SmartSprite *> smart_sprites_;		 // Vector con los smartsprites
 
-	std::vector<std::vector<std::string> *> itemAnimations;		  // Vector con las animaciones de los items
-	std::vector<std::vector<std::string> *> playerAnimations;	  // Vector con las animaciones del jugador
-	std::vector<std::vector<std::string> *> balloonAnimations;	  // Vector con las animaciones de los globos
-	std::vector<std::vector<std::string> *> explosionsAnimations; // Vector con las animaciones de las explosiones
+	std::shared_ptr<Texture> bullet_texture_;							 // Textura para las balas
+	std::vector<std::shared_ptr<Texture>> item_textures_;				 // Vector con las texturas de los items
+	std::vector<std::shared_ptr<Texture>> balloon_textures_;			 // Vector con las texturas de los globos
+	std::vector<std::shared_ptr<Texture>> explosions_textures_;			 // Vector con las texturas de las explosiones
+	std::vector<std::shared_ptr<Texture>> player1_textures_;			 // Vector con las texturas del jugador
+	std::vector<std::shared_ptr<Texture>> player2_textures_;			 // Vector con las texturas del jugador
+	std::vector<std::vector<std::shared_ptr<Texture>>> player_textures_; // Vector con todas las texturas de los jugadores;
 
-	Text *text;			 // Fuente para los textos del juego
-	Text *textBig;		 // Fuente de texto grande
-	Text *textNokia2;	 // Otra fuente de texto para mensajes
-	Text *textNokiaBig2; // Y la versión en grande
+	std::shared_ptr<Texture> game_text_texture_; // Textura para los sprites con textos
 
-	Fade *fade;				 // Objeto para renderizar fades
-	SDL_Event *eventHandler; // Manejador de eventos
+	std::vector<std::vector<std::string> *> item_animations_;		// Vector con las animaciones de los items
+	std::vector<std::vector<std::string> *> player_animations_;		// Vector con las animaciones del jugador
+	std::vector<std::vector<std::string> *> balloon_animations_;	// Vector con las animaciones de los globos
+	std::vector<std::vector<std::string> *> explosions_animations_; // Vector con las animaciones de las explosiones
 
-	SmartSprite *n1000Sprite; // Sprite con el texto 1.000
-	SmartSprite *n2500Sprite; // Sprite con el texto 2.500
-	SmartSprite *n5000Sprite; // Sprite con el texto 5.000
+	std::unique_ptr<Text> text_;			// Fuente para los textos del juego
+	std::unique_ptr<Text> text_big_;		// Fuente de texto grande
+	std::unique_ptr<Text> text_nokia2_;		// Otra fuente de texto para mensajes
+	std::unique_ptr<Text> text_nokia2_big_; // Y la versión en grande
 
-	JA_Sound_t *balloonSound;		  // Sonido para la explosión del globo
-	JA_Sound_t *bulletSound;		  // Sonido para los disparos
-	JA_Sound_t *playerCollisionSound; // Sonido para la colisión del jugador con un enemigo
-	JA_Sound_t *hiScoreSound;		  // Sonido para cuando se alcanza la máxima puntuación
-	JA_Sound_t *itemDropSound;		  // Sonido para cuando se genera un item
-	JA_Sound_t *itemPickUpSound;	  // Sonido para cuando se recoge un item
-	JA_Sound_t *coffeeOutSound;		  // Sonido para cuando el jugador pierde el café al recibir un impacto
-	JA_Sound_t *stageChangeSound;	  // Sonido para cuando se cambia de fase
-	JA_Sound_t *bubble1Sound;		  // Sonido para cuando el jugador muere
-	JA_Sound_t *bubble2Sound;		  // Sonido para cuando el jugador muere
-	JA_Sound_t *bubble3Sound;		  // Sonido para cuando el jugador muere
-	JA_Sound_t *bubble4Sound;		  // Sonido para cuando el jugador muere
-	JA_Sound_t *clockSound;			  // Sonido para cuando se detiene el tiempo con el item reloj
-	JA_Sound_t *powerBallSound;		  // Sonido para cuando se explota una Power Ball
-	JA_Sound_t *coffeeMachineSound;	  // Sonido para cuando la máquina de café toca el suelo
+	std::unique_ptr<Fade> fade_; // Objeto para renderizar fades
 
-	JA_Music_t *music; // Musica de fondo
+	std::shared_ptr<SmartSprite> p1000_sprite_; // Sprite con el texto 1.000
+	std::shared_ptr<SmartSprite> p2500_sprite_; // Sprite con el texto 2.500
+	std::shared_ptr<SmartSprite> p5000_sprite_; // Sprite con el texto 5.000
+
+	JA_Sound_t *balloon_sound_;			 // Sonido para la explosión del globo
+	JA_Sound_t *bullet_sound_;			 // Sonido para los disparos
+	JA_Sound_t *player_collision_sound_; // Sonido para la colisión del jugador con un enemigo
+	JA_Sound_t *hi_score_sound_;		 // Sonido para cuando se alcanza la máxima puntuación
+	JA_Sound_t *item_drop_sound_;		 // Sonido para cuando se genera un item
+	JA_Sound_t *item_pick_up_sound_;	 // Sonido para cuando se recoge un item
+	JA_Sound_t *coffee_out_sound_;		 // Sonido para cuando el jugador pierde el café al recibir un impacto
+	JA_Sound_t *stage_change_sound_;	 // Sonido para cuando se cambia de fase
+	JA_Sound_t *bubble1_sound_;			 // Sonido para cuando el jugador muere
+	JA_Sound_t *bubble2_sound_;			 // Sonido para cuando el jugador muere
+	JA_Sound_t *bubble3_sound_;			 // Sonido para cuando el jugador muere
+	JA_Sound_t *bubble4_sound_;			 // Sonido para cuando el jugador muere
+	JA_Sound_t *clock_sound_;			 // Sonido para cuando se detiene el tiempo con el item reloj
+	JA_Sound_t *power_ball_sound_;		 // Sonido para cuando se explota una Power Ball
+	JA_Sound_t *coffee_machine_sound_;	 // Sonido para cuando la máquina de café toca el suelo
+
+	JA_Music_t *music_; // Musica de fondo
 
 	// Variables
-	Uint32 ticks;							 // Contador de ticks para ajustar la velocidad del programa
-	Uint32 ticksSpeed;						 // Velocidad a la que se repiten los bucles del programa
-	bool hiScoreAchieved;					 // Indica si se ha superado la puntuación máxima
-	hiScoreEntry_t hiScore;					 // Máxima puntuación y nombre de quien la ostenta
-	int currentStage;						 // Indica la fase actual
-	int stageBitmapCounter;					 // Contador para el tiempo visible del texto de Stage
-	float stageBitmapPath[STAGE_COUNTER];	 // Vector con los puntos Y por donde se desplaza el texto
-	float getReadyBitmapPath[STAGE_COUNTER]; // Vector con los puntos X por donde se desplaza el texto
-	int gameOverCounter;					 // Contador para el estado de fin de partida
-	int menaceCurrent;						 // Nivel de amenaza actual
-	int menaceThreshold;					 // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
-	bool timeStopped;						 // Indica si el tiempo está detenido
-	int timeStoppedCounter;					 // Temporizador para llevar la cuenta del tiempo detenido
-	int counter;							 // Contador para el juego
-	int balloonsPopped;						 // Lleva la cuenta de los globos explotados
-	int lastEnemyDeploy;					 // Guarda cual ha sido la última formación desplegada para no repetir;
-	int enemyDeployCounter;					 // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
-	float enemySpeed;						 // Velocidad a la que se mueven los enemigos
-	float defaultEnemySpeed;				 // Velocidad base de los enemigos, sin incrementar
-	helper_t helper;						 // Variable para gestionar las ayudas
-	bool powerBallEnabled;					 // Indica si hay una powerball ya activa
-	int powerBallCounter;					 // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
-	bool coffeeMachineEnabled;				 // Indica si hay una máquina de café en el terreno de juego
-	bool gameCompleted;						 // Indica si se ha completado la partida, llegando al final de la ultima pantalla
-	int gameCompletedCounter;				 // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
-	int difficulty;							 // Dificultad del juego
-	float difficultyScoreMultiplier;		 // Multiplicador de puntos en función de la dificultad
-	color_t difficultyColor;				 // Color asociado a la dificultad
-	int lastStageReached;					 // Contiene el número de la última pantalla que se ha alcanzado
-	demo_t demo;							 // Variable con todas las variables relacionadas con el modo demo
-	int totalPowerToCompleteGame;			 // La suma del poder necesario para completar todas las fases
-	bool paused;							 // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
-	int currentPower;						 // Poder actual almacenado para completar la fase
+	Uint32 ticks_;								 // Contador de ticks para ajustar la velocidad del programa
+	Uint32 ticks_speed_;						 // Velocidad a la que se repiten los bucles del programa
+	bool hi_score_achieved_;					 // Indica si se ha superado la puntuación máxima
+	HiScoreEntry hi_score_;						 // Máxima puntuación y nombre de quien la ostenta
+	int current_stage_;							 // Indica la fase actual
+	int stage_bitmap_counter_;					 // Contador para el tiempo visible del texto de Stage
+	float stage_bitmap_path_[STAGE_COUNTER];	 // Vector con los puntos Y por donde se desplaza el texto
+	float get_ready_bitmap_path_[STAGE_COUNTER]; // Vector con los puntos X por donde se desplaza el texto
+	int game_over_counter_;						 // Contador para el estado de fin de partida
+	int menace_current_;						 // Nivel de amenaza actual
+	int menace_threshold_;						 // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
+	bool time_stopped_;							 // Indica si el tiempo está detenido
+	int time_stopped_counter_;					 // Temporizador para llevar la cuenta del tiempo detenido
+	int counter_;								 // Contador para el juego
+	int balloons_popped_;						 // Lleva la cuenta de los globos explotados
+	int last_ballon_deploy_;					 // Guarda cual ha sido la última formación desplegada para no repetir;
+	int balloon_deploy_counter_;				 // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
+	float balloon_speed_;						 // Velocidad a la que se mueven los enemigos
+	float default_balloon_speed_;				 // Velocidad base de los enemigos, sin incrementar
+	Helper helper_;								 // Variable para gestionar las ayudas
+	bool power_ball_enabled_;					 // Indica si hay una powerball ya activa
+	int power_ball_counter_;					 // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
+	bool coffee_machine_enabled_;				 // Indica si hay una máquina de café en el terreno de juego
+	bool game_completed_;						 // Indica si se ha completado la partida, llegando al final de la ultima pantalla
+	int game_completed_counter_;				 // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
+	GameDifficulty difficulty_;					 // Dificultad del juego
+	float difficulty_score_multiplier_;			 // Multiplicador de puntos en función de la dificultad
+	Color difficulty_color_;					 // Color asociado a la dificultad
+	int last_stage_reached_;					 // Contiene el número de la última pantalla que se ha alcanzado
+	Demo demo_;									 // Variable con todas las variables relacionadas con el modo demo
+	int total_power_to_complete_game_;			 // La suma del poder necesario para completar todas las fases
+	bool paused_;								 // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
+	int current_power_;							 // Poder actual almacenado para completar la fase
 #ifdef DEBUG
-	bool autoPopBalloons; // Si es true, incrementa automaticamente los globos explotados
+	bool auto_pop_balloons_; // Si es true, incrementa automaticamente los globos explotados
 #endif
 
 	// Actualiza el juego
@@ -214,7 +216,7 @@ private:
 	void checkEvents();
 
 	// Inicializa las variables necesarias para la sección 'Game'
-	void init(int playerID);
+	void init(int player_id);
 
 	// Carga los recursos necesarios para la sección 'Game'
 	void loadMedia();
@@ -223,13 +225,13 @@ private:
 	void unloadMedia();
 
 	// Carga el fichero de datos para la demo
-	bool loadDemoFile(std::string filePath, demoKeys_t (*dataFile)[TOTAL_DEMO_DATA]);
+	bool loadDemoFile(const std::string &file_path, DemoKeys (*data_file)[TOTAL_DEMO_DATA]);
 #ifdef RECORDING
 	// Guarda el fichero de datos para la demo
-	bool saveDemoFile(std::string filePath);
+	bool saveDemoFile(const std::string &file_path);
 #endif
 	// Crea una formación de enemigos
-	void deployEnemyFormation();
+	void deployBalloonFormation();
 
 	// Aumenta el poder de la fase
 	void increaseStageCurrentPower(int power);
@@ -256,7 +258,7 @@ private:
 	void renderBalloons();
 
 	// Crea un globo nuevo en el vector de globos
-	int createBalloon(float x, int y, int kind, float velx, float speed, int stoppedcounter);
+	std::shared_ptr<Balloon> createBalloon(float x, int y, int kind, float velx, float speed, int stopped_counter);
 
 	// Crea una PowerBall
 	void createPowerBall();
@@ -264,23 +266,14 @@ private:
 	// Establece la velocidad de los globos
 	void setBalloonSpeed(float speed);
 
-	// Incrementa la velocidad de los globos
-	void incBalloonSpeed();
-
-	// Decrementa la velocidad de los globos
-	void decBalloonSpeed();
-
 	// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
 	void updateBalloonSpeed();
 
 	// Explosiona un globo. Lo destruye y crea otros dos si es el caso
-	void popBalloon(Balloon *balloon);
+	void popBalloon(std::shared_ptr<Balloon> balloon);
 
 	// Explosiona un globo. Lo destruye
-	void destroyBalloon(Balloon *balloon);
-
-	// Explosiona todos los globos
-	void popAllBalloons();
+	void destroyBalloon(std::shared_ptr<Balloon> &balloon);
 
 	// Destruye todos los globos
 	void destroyAllBalloons();
@@ -291,17 +284,14 @@ private:
 	// Pone en marcha todos los globos
 	void startAllBalloons();
 
-	// Obtiene el número de globos activos
-	int countBalloons();
-
 	// Vacia el vector de globos
 	void freeBalloons();
 
 	// Comprueba la colisión entre el jugador y los globos activos
-	bool checkPlayerBalloonCollision(Player *player);
+	bool checkPlayerBalloonCollision(std::shared_ptr<Player> &player);
 
 	// Comprueba la colisión entre el jugador y los items
-	void checkPlayerItemCollision(Player *player);
+	void checkPlayerItemCollision(std::shared_ptr<Player> &player);
 
 	// Comprueba la colisión entre las balas y los globos
 	void checkBulletBalloonCollision();
@@ -313,7 +303,7 @@ private:
 	void renderBullets();
 
 	// Crea un objeto bala
-	void createBullet(int x, int y, BulletType kind, bool poweredUp, int owner);
+	void createBullet(int x, int y, BulletType kind, bool powered_up, int owner);
 
 	// Vacia el vector de balas
 	void freeBullets();
@@ -334,7 +324,7 @@ private:
 	void freeItems();
 
 	// Crea un objeto SmartSprite
-	void createItemScoreSprite(int x, int y, SmartSprite *sprite);
+	void createItemScoreSprite(int x, int y, std::shared_ptr<SmartSprite> sprite);
 
 	// Vacia el vector de smartsprites
 	void freeSmartSprites();
@@ -349,19 +339,19 @@ private:
 	void renderSmartSprites();
 
 	// Acciones a realizar cuando el jugador muere
-	void killPlayer(Player *player);
+	void killPlayer(std::shared_ptr<Player> &player);
 
 	// Calcula y establece el valor de amenaza en funcion de los globos activos
 	void evaluateAndSetMenace();
 
 	// Obtiene el valor de la variable
-	int getMenace();
+	int getMenace() const;
 
 	// Establece el valor de la variable
 	void setTimeStopped(bool value);
 
 	// Obtiene el valor de la variable
-	bool isTimeStopped();
+	bool isTimeStopped() const;
 
 	// Establece el valor de la variable
 	void setTimeStoppedCounter(int value);
@@ -370,7 +360,7 @@ private:
 	void incTimeStoppedCounter(int value);
 
 	// Actualiza la variable EnemyDeployCounter
-	void updateEnemyDeployCounter();
+	void updateBalloonDeployCounter();
 
 	// Actualiza y comprueba el valor de la variable
 	void updateTimeStoppedCounter();
@@ -409,13 +399,16 @@ private:
 	void updateHelper();
 
 	// Comprueba si todos los jugadores han terminado de jugar
-	bool allPlayersAreWaiting();
+	bool allPlayersAreWaitingOrGameOver();
+
+	// Comprueba si todos los jugadores han terminado de jugar
+	bool allPlayersAreGameOver();
 
 	// Comprueba si todos los jugadores han terminado de jugar
 	bool allPlayersAreNotPlaying();
 
 	// Carga las animaciones
-	void loadAnimations(std::string filePath, std::vector<std::string> *buffer);
+	void loadAnimations(std::string file_path, std::vector<std::string> *buffer);
 
 	// Elimina todos los objetos contenidos en vectores
 	void deleteAllVectorObjects();
@@ -436,26 +429,23 @@ private:
 	void checkMusicStatus();
 
 	// Añade una puntuación a la tabla de records
-	void addScoreToScoreBoard(std::string name, int score);
+	void addScoreToScoreBoard(const std::string &name, int score);
 
-	// Comprueba si la puntuación entra en la tabla de mejores puntuaciones
-	bool IsEligibleForHighScore(int score);
+	// Saca del estado de GAME OVER al jugador si el otro está activo
+	void checkAndUpdatePlayerStatus(int active_player_index, int inactive_player_index);
 
 	// Comprueba el estado de juego de los jugadores
 	void checkPlayersStatusPlaying();
 
 	// Obtiene un jugador a partir de su "id"
-	Player *getPlayer(int id);
+	std::shared_ptr<Player> getPlayer(int id);
 
 	// Obtiene un controlador a partir del "id" del jugador
 	int getController(int playerId);
 
-	// Termina
-	void quit(section::options_e code);
-
 public:
 	// Constructor
-	Game(int playerID, int currentStage, bool demo, JA_Music_t *music);
+	Game(int playerID, int current_stage, bool demo, JA_Music_t *music);
 
 	// Destructor
 	~Game();

source/game_logo.cpp

@@ -1,41 +1,36 @@
 #include "game_logo.h"
+#include <SDL2/SDL_render.h> // for SDL_FLIP_HORIZONTAL
 #include <algorithm>         // for max
-#include <string>            // for basic_string
-#include "animated_sprite.h"  // for AnimatedSprite
+#include "animated_sprite.h" // for AnimatedSprite
 #include "asset.h"           // for Asset
 #include "jail_audio.h"      // for JA_DeleteSound, JA_LoadSound, JA_PlaySound
 #include "param.h"           // for param
 #include "screen.h"          // for Screen
-#include "smart_sprite.h"     // for SmartSprite
+#include "smart_sprite.h"    // for SmartSprite
 #include "sprite.h"          // for Sprite
 #include "texture.h"         // for Texture
-#include "utils.h"           // for param_t, paramGame_t, paramTitle_t
+#include "utils.h"           // for Param, ParamGame, ParamTitle
 
 // Constructor
 GameLogo::GameLogo(int x, int y)
+    : dust_texture_(std::make_shared<Texture>(Screen::get()->getRenderer(), Asset::get()->get("title_dust.png"))),
+      coffee_texture_(std::make_shared<Texture>(Screen::get()->getRenderer(), Asset::get()->get("title_coffee.png"))),
+      crisis_texture_(std::make_shared<Texture>(Screen::get()->getRenderer(), Asset::get()->get("title_crisis.png"))),
+      arcade_edition_texture_(std::make_shared<Texture>(Screen::get()->getRenderer(), Asset::get()->get("title_arcade_edition.png"))),
+
+      dust_left_sprite_(std::make_unique<AnimatedSprite>(dust_texture_, Asset::get()->get("title_dust.ani"))),
+      dust_right_sprite_(std::make_unique<AnimatedSprite>(dust_texture_, Asset::get()->get("title_dust.ani"))),
+
+      coffee_sprite_(std::make_unique<SmartSprite>(coffee_texture_)),
+      crisis_sprite_(std::make_unique<SmartSprite>(crisis_texture_)),
+
+      arcade_edition_sprite_(std::make_unique<Sprite>((param.game.width - arcade_edition_texture_->getWidth()) / 2, param.title.arcade_edition_position, arcade_edition_texture_->getWidth(), arcade_edition_texture_->getHeight(), arcade_edition_texture_)),
+
+      crash_sound_(JA_LoadSound(Asset::get()->get("title.wav").c_str())),
+
+      x_(x),
+      y_(y)
 {
-    // Copia los punteros
-    screen = Screen::get();
-    renderer = screen->getRenderer();
-    asset = Asset::get();
-    this->x = x;
-    this->y = y;
-
-    // Crea los objetos
-    dustTexture = new Texture(renderer, asset->get("title_dust.png"));
-    coffeeTexture = new Texture(renderer, asset->get("title_coffee.png"));
-    crisisTexture = new Texture(renderer, asset->get("title_crisis.png"));
-    arcadeEditionTexture = new Texture(renderer, asset->get("title_arcade_edition.png"));
-
-    coffeeBitmap = new SmartSprite(coffeeTexture);
-    crisisBitmap = new SmartSprite(crisisTexture);
-    arcadeEditionBitmap = new Sprite((param.game.width - arcadeEditionTexture->getWidth()) / 2, param.title.arcadeEditionPosition, arcadeEditionTexture->getWidth(), arcadeEditionTexture->getHeight(), arcadeEditionTexture);
-    dustBitmapL = new AnimatedSprite(dustTexture, asset->get("title_dust.ani"));
-    dustBitmapR = new AnimatedSprite(dustTexture, asset->get("title_dust.ani"));
-
-    // Sonidos
-    crashSound = JA_LoadSound(asset->get("title.wav").c_str());
-
     // Inicializa las variables
     init();
 }
@@ -43,152 +38,140 @@ GameLogo::GameLogo(int x, int y)
 // Destructor
 GameLogo::~GameLogo()
 {
-    delete dustTexture;
-    delete coffeeTexture;
-    delete crisisTexture;
-    delete arcadeEditionTexture;
-
-    delete coffeeBitmap;
-    delete crisisBitmap;
-    delete arcadeEditionBitmap;
-    delete dustBitmapL;
-    delete dustBitmapR;
-
-    JA_DeleteSound(crashSound);
+    JA_DeleteSound(crash_sound_);
 }
 
 // Inicializa las variables
 void GameLogo::init()
 {
-    const int xp = x - coffeeBitmap->getWidth() / 2;
-    const int desp = getInitialVerticalDesp();
-    
+    const auto xp = x_ - coffee_sprite_->getWidth() / 2;
+    const auto desp = getInitialVerticalDesp();
+
     // Variables
-    status = disabled;
-    shake.desp = 1;
-    shake.delay = 2;
-    shake.lenght = 8;
-    shake.remaining = shake.lenght;
-    shake.counter = shake.delay;
-    shake.origin = xp;
+    status_ = Status::DISABLED;
+    shake_.desp = 1;
+    shake_.delay = 2;
+    shake_.lenght = 8;
+    shake_.remaining = shake_.lenght;
+    shake_.counter = shake_.delay;
+    shake_.origin = xp;
 
     // Inicializa el bitmap de 'Coffee'
-    coffeeBitmap->init();
-    coffeeBitmap->setPosX(xp);
-    coffeeBitmap->setPosY(y - coffeeTexture->getHeight() - desp);
-    coffeeBitmap->setWidth(coffeeTexture->getWidth());
-    coffeeBitmap->setHeight(coffeeTexture->getHeight());
-    coffeeBitmap->setVelX(0.0f);
-    coffeeBitmap->setVelY(2.5f);
-    coffeeBitmap->setAccelX(0.0f);
-    coffeeBitmap->setAccelY(0.1f);
-    coffeeBitmap->setSpriteClip(0, 0, coffeeTexture->getWidth(), coffeeTexture->getHeight());
-    coffeeBitmap->setEnabled(true);
-    coffeeBitmap->setEnabledCounter(0);
-    coffeeBitmap->setDestX(xp);
-    coffeeBitmap->setDestY(y - coffeeTexture->getHeight());
+    coffee_sprite_->init();
+    coffee_sprite_->setPosX(xp);
+    coffee_sprite_->setPosY(y_ - coffee_texture_->getHeight() - desp);
+    coffee_sprite_->setWidth(coffee_texture_->getWidth());
+    coffee_sprite_->setHeight(coffee_texture_->getHeight());
+    coffee_sprite_->setVelX(0.0f);
+    coffee_sprite_->setVelY(2.5f);
+    coffee_sprite_->setAccelX(0.0f);
+    coffee_sprite_->setAccelY(0.1f);
+    coffee_sprite_->setSpriteClip(0, 0, coffee_texture_->getWidth(), coffee_texture_->getHeight());
+    coffee_sprite_->setEnabled(true);
+    coffee_sprite_->setFinishedCounter(0);
+    coffee_sprite_->setDestX(xp);
+    coffee_sprite_->setDestY(y_ - coffee_texture_->getHeight());
 
     // Inicializa el bitmap de 'Crisis'
-    crisisBitmap->init();
-    crisisBitmap->setPosX(xp + 15);
-    crisisBitmap->setPosY(y + desp);
-    crisisBitmap->setWidth(crisisTexture->getWidth());
-    crisisBitmap->setHeight(crisisTexture->getHeight());
-    crisisBitmap->setVelX(0.0f);
-    crisisBitmap->setVelY(-2.5f);
-    crisisBitmap->setAccelX(0.0f);
-    crisisBitmap->setAccelY(-0.1f);
-    crisisBitmap->setSpriteClip(0, 0, crisisTexture->getWidth(), crisisTexture->getHeight());
-    crisisBitmap->setEnabled(true);
-    crisisBitmap->setEnabledCounter(0);
-    crisisBitmap->setDestX(xp + 15);
-    crisisBitmap->setDestY(y);
+    crisis_sprite_->init();
+    crisis_sprite_->setPosX(xp + 15);
+    crisis_sprite_->setPosY(y_ + desp);
+    crisis_sprite_->setWidth(crisis_texture_->getWidth());
+    crisis_sprite_->setHeight(crisis_texture_->getHeight());
+    crisis_sprite_->setVelX(0.0f);
+    crisis_sprite_->setVelY(-2.5f);
+    crisis_sprite_->setAccelX(0.0f);
+    crisis_sprite_->setAccelY(-0.1f);
+    crisis_sprite_->setSpriteClip(0, 0, crisis_texture_->getWidth(), crisis_texture_->getHeight());
+    crisis_sprite_->setEnabled(true);
+    crisis_sprite_->setFinishedCounter(0);
+    crisis_sprite_->setDestX(xp + 15);
+    crisis_sprite_->setDestY(y_);
 
     // Inicializa el bitmap de 'DustRight'
-    dustBitmapR->resetAnimation();
-    dustBitmapR->setPosX(coffeeBitmap->getPosX() + coffeeBitmap->getWidth());
-    dustBitmapR->setPosY(y);
-    dustBitmapR->setWidth(16);
-    dustBitmapR->setHeight(16);
-    dustBitmapR->setFlip(SDL_FLIP_HORIZONTAL);
+    dust_right_sprite_->resetAnimation();
+    dust_right_sprite_->setPosX(coffee_sprite_->getPosX() + coffee_sprite_->getWidth());
+    dust_right_sprite_->setPosY(y_);
+    dust_right_sprite_->setWidth(16);
+    dust_right_sprite_->setHeight(16);
+    dust_right_sprite_->setFlip(SDL_FLIP_HORIZONTAL);
 
     // Inicializa el bitmap de 'DustLeft'
-    dustBitmapL->resetAnimation();
-    dustBitmapL->setPosX(coffeeBitmap->getPosX() - 16);
-    dustBitmapL->setPosY(y);
-    dustBitmapL->setWidth(16);
-    dustBitmapL->setHeight(16);
+    dust_left_sprite_->resetAnimation();
+    dust_left_sprite_->setPosX(coffee_sprite_->getPosX() - 16);
+    dust_left_sprite_->setPosY(y_);
+    dust_left_sprite_->setWidth(16);
+    dust_left_sprite_->setHeight(16);
 }
 
 // Pinta la clase en pantalla
 void GameLogo::render()
 {
     // Dibuja el logo
-    coffeeBitmap->render();
-    crisisBitmap->render();
+    coffee_sprite_->render();
+    crisis_sprite_->render();
 
-    if (status == finished)
-        arcadeEditionBitmap->render();
+    if (status_ == Status::FINISHED)
+    {
+        arcade_edition_sprite_->render();
+    }
 
     // Dibuja el polvillo del logo
-    dustBitmapR->render();
-    dustBitmapL->render();
+    dust_right_sprite_->render();
+    dust_left_sprite_->render();
 }
 
 // Actualiza la lógica de la clase
 void GameLogo::update()
 {
-    if (status == moving)
+    if (status_ == Status::MOVING)
     {
-        coffeeBitmap->update();
-        crisisBitmap->update();
+        coffee_sprite_->update();
+        crisis_sprite_->update();
 
         // Si los objetos han llegado a su destino, cambiamos de Sección
-        if (coffeeBitmap->hasFinished() && crisisBitmap->hasFinished())
+        if (coffee_sprite_->hasFinished() && crisis_sprite_->hasFinished())
         {
-            status = shaking;
-
-            // Pantallazo blanco
-            //screen->flash(flashColor, 10);
+            status_ = Status::SHAKING;
 
             // Reproduce el efecto sonoro
-            JA_PlaySound(crashSound);
+            JA_PlaySound(crash_sound_);
         }
     }
 
-    else if (status == shaking)
+    else if (status_ == Status::SHAKING)
     {
         // Agita el logo
-        if (shake.remaining > 0)
+        if (shake_.remaining > 0)
         {
-            if (shake.counter > 0)
+            if (shake_.counter > 0)
             {
-                shake.counter--;
+                shake_.counter--;
             }
             else
             {
-                shake.counter = shake.delay;
-                const int desp = shake.remaining % 2 == 0 ? shake.desp * (-1) : shake.desp;
-                coffeeBitmap->setPosX(shake.origin + desp);
-                crisisBitmap->setPosX(shake.origin + desp + 15);
-                shake.remaining--;
+                shake_.counter = shake_.delay;
+                const auto desp = shake_.remaining % 2 == 0 ? shake_.desp * (-1) : shake_.desp;
+                coffee_sprite_->setPosX(shake_.origin + desp);
+                crisis_sprite_->setPosX(shake_.origin + desp + 15);
+                shake_.remaining--;
             }
         }
         else
         {
-            coffeeBitmap->setPosX(shake.origin);
-            crisisBitmap->setPosX(shake.origin + 15);
-            status = finished;
+            coffee_sprite_->setPosX(shake_.origin);
+            crisis_sprite_->setPosX(shake_.origin + 15);
+            status_ = Status::FINISHED;
         }
 
-        dustBitmapR->update();
-        dustBitmapL->update();
+        dust_right_sprite_->update();
+        dust_left_sprite_->update();
     }
 
-    else if (status == finished)
+    else if (status_ == Status::FINISHED)
     {
-        dustBitmapR->update();
-        dustBitmapL->update();
+        dust_right_sprite_->update();
+        dust_left_sprite_->update();
     }
 }
 
@@ -196,28 +179,28 @@ void GameLogo::update()
 void GameLogo::enable()
 {
     init();
-    status = moving;
+    status_ = Status::MOVING;
 }
 
 // Indica si ha terminado la animación
-bool GameLogo::hasFinished()
+bool GameLogo::hasFinished() const
 {
-    return (status == finished);
+    return status_ == Status::FINISHED;
 }
 
 // Recarga las texturas
 void GameLogo::reLoad()
 {
-    dustTexture->reLoad();
-    coffeeTexture->reLoad();
-    crisisTexture->reLoad();
+    dust_texture_->reLoad();
+    coffee_texture_->reLoad();
+    crisis_texture_->reLoad();
 }
 
 // Calcula el desplazamiento vertical inicial
 int GameLogo::getInitialVerticalDesp()
 {
-    int despUp = y;
-    int despDown = param.game.height - y;
+    auto desp_up = y_;
+    auto desp_down = param.game.height - y_;
 
-    return std::max(despUp, despDown);
+    return std::max(desp_up, desp_down);
 }

source/game_logo.h

@@ -1,51 +1,25 @@
 #pragma once
 
-#include <SDL2/SDL_render.h>  // for SDL_Renderer
+#include <memory> // for unique_ptr, shared_ptr
 class AnimatedSprite;
-class Asset;
-class Screen;
 class SmartSprite;
 class Sprite;
 class Texture;
-struct JA_Sound_t;
+struct JA_Sound_t; // lines 10-10
 
 // Clase GameLogo
 class GameLogo
 {
 private:
-    // Objetos y punteros
-    SDL_Renderer *renderer; // El renderizador de la ventana
-    Screen *screen;         // Objeto encargado de dibujar en pantalla
-    Asset *asset;           // Objeto que gestiona todos los ficheros de recursos
-
-    Texture *dustTexture;          // Textura con los graficos del polvo
-    Texture *coffeeTexture;        // Textura con los graficos de la palabra "COFFEE"
-    Texture *crisisTexture;        // Textura con los graficos de la plabra "CRISIS"
-    Texture *arcadeEditionTexture; // Textura con los graficos de "Arcade Edition"
-
-    AnimatedSprite *dustBitmapL; // Sprite con la el polvo que aparece al colisionar el texto de la pantalla de titulo
-    AnimatedSprite *dustBitmapR; // Sprite con la el polvo que aparece al colisionar el texto de la pantalla de titulo
-
-    SmartSprite *coffeeBitmap; // Sprite con la palabra "COFFEE" para la pantalla de titulo
-    SmartSprite *crisisBitmap; // Sprite con la palabra "CRISIS" para la pantalla de titulo
-
-    Sprite *arcadeEditionBitmap; // Sprite con los graficos de "Arcade Edition"
-
-    JA_Sound_t *crashSound; // Sonido con el impacto del título
-
-    // Variables
-    int x; // Posición donde dibujar el logo
-    int y; // Posición donde dibujar el logo
-
-    enum status_e
+    enum class Status
     {
-        disabled,
-        moving,
-        shaking,
-        finished
-    } status; // Estado en el que se encuentra la clase
+        DISABLED,
+        MOVING,
+        SHAKING,
+        FINISHED,
+    };
 
-    struct shake_t
+    struct Shake
     {
         int desp;      // Pixels de desplazamiento para agitar la pantalla en el eje x
         int delay;     // Retraso entre cada desplazamiento de la pantalla al agitarse
@@ -53,7 +27,30 @@ private:
         int lenght;    // Cantidad de desplazamientos a realizar
         int remaining; // Cantidad de desplazamientos pendientes a realizar
         int origin;    // Valor inicial de la pantalla para dejarla igual tras el desplazamiento
-    } shake;           // Estructura para generar el efecto de agitación
+    };
+
+    // Objetos y punteros
+    std::shared_ptr<Texture> dust_texture_;           // Textura con los graficos del polvo
+    std::shared_ptr<Texture> coffee_texture_;         // Textura con los graficos de la palabra "COFFEE"
+    std::shared_ptr<Texture> crisis_texture_;         // Textura con los graficos de la plabra "CRISIS"
+    std::shared_ptr<Texture> arcade_edition_texture_; // Textura con los graficos de "Arcade Edition"
+
+    std::unique_ptr<AnimatedSprite> dust_left_sprite_;  // Sprite con la el polvo que aparece al colisionar el texto de la pantalla de titulo
+    std::unique_ptr<AnimatedSprite> dust_right_sprite_; // Sprite con la el polvo que aparece al colisionar el texto de la pantalla de titulo
+
+    std::unique_ptr<SmartSprite> coffee_sprite_; // Sprite con la palabra "COFFEE" para la pantalla de titulo
+    std::unique_ptr<SmartSprite> crisis_sprite_; // Sprite con la palabra "CRISIS" para la pantalla de titulo
+
+    std::unique_ptr<Sprite> arcade_edition_sprite_; // Sprite con los graficos de "Arcade Edition"
+
+    JA_Sound_t *crash_sound_; // Sonido con el impacto del título
+
+    // Variables
+    int x_; // Posición donde dibujar el logo
+    int y_; // Posición donde dibujar el logo
+
+    Status status_; // Estado en el que se encuentra la clase
+    Shake shake_;   // Estructura para generar el efecto de agitación
 
     // Inicializa las variables
     void init();
@@ -78,7 +75,7 @@ public:
     void enable();
 
     // Indica si ha terminado la animación
-    bool hasFinished();
+    bool hasFinished() const;
 
     // Recarga las texturas
     void reLoad();

source/global_inputs.cpp

@@ -6,89 +6,132 @@
 #include "options.h"    // for options
 #include "on_screen_help.h"
 #include "screen.h"  // for Screen
-#include "section.h" // for options_e, name, name_e, options
-#include "utils.h"   // for op_audio_t, options_t, op_music_t, boolToOnOff
+#include "section.h" // for SectionOptions, name, SectionName, options
+#include "utils.h"   // for OptionsAudio, Options, OptionsMusic, boolToOnOff
 
-// Termina
-void quit(section::options_e code)
+namespace globalInputs
 {
-    if (Screen::get()->notificationsAreActive())
-    {
-        section::name = section::NAME_QUIT;
-        section::options = code;
-    }
-    else
-    {
-        Screen::get()->showNotification(lang::getText(94));
-    }
-}
+    // Variables
+    std::vector<int> service_pressed_counter;
 
-// Reinicia
-void reset()
-{
-    section::name = section::NAME_INIT;
-    Screen::get()->showNotification("Reset");
-}
-
-// Activa o desactiva el audio
-void switchAudio()
-{
-    options.audio.sound.enabled = options.audio.music.enabled = !options.audio.music.enabled;
-    JA_EnableMusic(options.audio.music.enabled);
-    JA_EnableSound(options.audio.sound.enabled);
-    Screen::get()->showNotification("Audio " + boolToOnOff(options.audio.music.enabled));
-}
-
-// Comprueba los inputs que se pueden introducir en cualquier sección del juego
-void checkGlobalInputs()
-{
-    // Comprueba si se sale con el teclado
-    if (Input::get()->checkInput(input_exit, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
+    // Inicializa variables
+    void init()
     {
-        quit(section::OPTIONS_QUIT_NORMAL);
-        return;
-    }
-
-    // Comprueba si se va a resetear el juego
-    else if (Input::get()->checkInput(input_reset, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
-    {
-        reset();
-        return;
-    }
-
-    else if (Input::get()->checkInput(input_mute, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
-    {
-        switchAudio();
-        return;
-    }
-
-    else if (Input::get()->checkInput(input_service, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
-    {
-        OnScreenHelp::get()->toggleState();
-        return;
-    }
-
-    for (int i = 0; i < Input::get()->getNumControllers(); ++i)
-    {
-        // Comprueba si se sale con el mando
-        if (Input::get()->checkModInput(input_service, input_exit, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+        const auto num_inputs = Input::get()->getNumControllers() + 1;
+        service_pressed_counter.reserve(num_inputs);
+        for (int i = 0; i < num_inputs; ++i)
         {
-            quit(section::OPTIONS_QUIT_SHUTDOWN);
+            service_pressed_counter.push_back(0);
+        }
+    }
+
+    // Termina
+    void quit(section::Options code)
+    {
+        if (Screen::get()->notificationsAreActive())
+        {
+            section::name = section::Name::QUIT;
+            section::options = code;
+        }
+        else
+        {
+            Screen::get()->showNotification(lang::getText(94));
+        }
+    }
+
+    // Reinicia
+    void reset()
+    {
+        section::name = section::Name::INIT;
+        Screen::get()->showNotification("Reset");
+    }
+
+    // Activa o desactiva el audio
+    void switchAudio()
+    {
+        options.audio.sound.enabled = options.audio.music.enabled = !options.audio.music.enabled;
+        JA_EnableMusic(options.audio.music.enabled);
+        JA_EnableSound(options.audio.sound.enabled);
+        Screen::get()->showNotification("Audio " + boolToOnOff(options.audio.music.enabled));
+    }
+
+    // Comprueba los inputs que se pueden introducir en cualquier sección del juego
+    void check()
+    {
+        // Comprueba si se sale con el teclado
+        if (Input::get()->checkInput(InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
+        {
+            quit(section::Options::QUIT_NORMAL);
             return;
         }
 
         // Comprueba si se va a resetear el juego
-        else if (Input::get()->checkModInput(input_service, input_reset, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+        else if (Input::get()->checkInput(InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
         {
             reset();
             return;
         }
 
-        // Comprueba si se va a activar o desactivar el audio
-        else if (Input::get()->checkModInput(input_service, input_mute, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+        else if (Input::get()->checkInput(InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
         {
             switchAudio();
             return;
         }
+
+        else if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
+        {
+            service_pressed_counter[0]++;
+
+            if (service_pressed_counter[0] >= 3000)
+            {
+                OnScreenHelp::get()->toggleState();
+                service_pressed_counter[0] = 0;
+            }
+            return;
+        }
+        else
+        {
+            service_pressed_counter[0] = 0;
+        }
+
+        for (int i = 0; i < Input::get()->getNumControllers(); ++i)
+        {
+            // Comprueba si se sale con el mando
+            if (Input::get()->checkModInput(InputType::SERVICE, InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+            {
+                quit(section::Options::QUIT_SHUTDOWN);
+                return;
+            }
+
+            // Comprueba si se va a resetear el juego
+            else if (Input::get()->checkModInput(InputType::SERVICE, InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+            {
+                reset();
+                return;
+            }
+
+            // Comprueba si se va a activar o desactivar el audio
+            else if (Input::get()->checkModInput(InputType::SERVICE, InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+            {
+                switchAudio();
+                return;
+            }
+
+            if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+            {
+                service_pressed_counter[i + 1]++;
+
+                if (service_pressed_counter[i + 1] >= 3000)
+                {
+                    OnScreenHelp::get()->toggleState();
+                    service_pressed_counter[i + 1] = 0;
+                }
+                return;
+            }
+            else
+            {
+                service_pressed_counter[i + 1] = 0;
+            }
+        }
     }
 }

source/global_inputs.h

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

source/hiscore_table.cpp

@@ -1,62 +1,60 @@
 #include "hiscore_table.h"
-#include <SDL2/SDL_blendmode.h>  // for SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_pixels.h>     // for SDL_PIXELFORMAT_RGBA8888
-#include <SDL2/SDL_timer.h>      // for SDL_GetTicks
-#include <SDL2/SDL_video.h>      // for SDL_WINDOWEVENT_SIZE_CHANGED
-#include <algorithm>             // for max
-#include <vector>                // for vector
-#include "asset.h"               // for Asset
-#include "background.h"          // for Background
-#include "fade.h"                // for Fade, FADE_IN, FADE_OUT, FADE_RANDOM...
-#include "global_inputs.h"       // for checkGlobalInputs
-#include "input.h"               // for Input
-#include "jail_audio.h"          // for JA_GetMusicState, JA_Music_state
-#include "lang.h"                // for getText
-#include "options.h"             // for options
-#include "param.h"               // for param
-#include "screen.h"              // for Screen
-#include "text.h"                // for Text, TXT_CENTER, TXT_SHADOW, TXT_COLOR
-#include "utils.h"               // for param_t, paramGame_t, hiScoreEntry_t
+#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_events.h>	// for SDL_PollEvent, SDL_Event, SDL_QUIT
+#include <SDL2/SDL_pixels.h>	// for SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_timer.h>		// for SDL_GetTicks
+#include <SDL2/SDL_video.h>		// for SDL_WINDOWEVENT_SIZE_CHANGED
+#include <algorithm>			// for max
+#include <vector>				// for vector
+#include "asset.h"				// for Asset
+#include "background.h"			// for Background
+#include "fade.h"				// for Fade, FadeMode, FadeType
+#include "global_inputs.h"		// for check
+#include "input.h"				// for Input
+#include "jail_audio.h"			// for JA_GetMusicState, JA_Music_state
+#include "lang.h"				// for getText
+#include "options.h"			// for options
+#include "param.h"				// for param
+#include "screen.h"				// for Screen
+#include "section.h"			// for Name, name, Options, options
+#include "text.h"				// for Text, TEXT_CENTER, TEXT_SHADOW, TEXT...
+#include "utils.h"				// for Param, ParamGame, Color, HiScoreEntry
 
 // Constructor
 HiScoreTable::HiScoreTable(JA_Music_t *music)
+	: music_(music)
 {
 	// Copia punteros
-	this->music = music;
-	asset = Asset::get();
-	input = Input::get();
-	screen = Screen::get();
-	renderer = screen->getRenderer();
+	renderer_ = Screen::get()->getRenderer();
 
 	// Objetos
-	eventHandler = new SDL_Event();
-	fade = new Fade(renderer);
-	background = new Background(renderer);
-	text = new Text(asset->get("smb2.gif"), asset->get("smb2.txt"), renderer);
+	fade_ = std::make_unique<Fade>(renderer_);
+	background_ = std::make_unique<Background>(renderer_);
+	text_ = std::make_unique<Text>(Asset::get()->get("smb2.gif"), Asset::get()->get("smb2.txt"), renderer_);
 
 	// Crea un backbuffer para el renderizador
-	backbuffer = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
-	SDL_SetTextureBlendMode(backbuffer, SDL_BLENDMODE_BLEND);
+	backbuffer_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
+	SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
 
 	// Inicializa variables
-	section::name = section::NAME_HI_SCORE_TABLE;
-	ticks = 0;
-	ticksSpeed = 15;
-	counter = 0;
-	counterEnd = 800;
-	viewArea = {0, 0, param.game.width, param.game.height};
-	fadeMode = FADE_IN;
+	section::name = section::Name::HI_SCORE_TABLE;
+	ticks_ = 0;
+	ticks_speed_ = 15;
+	counter_ = 0;
+	counter_end_ = 800;
+	view_area_ = {0, 0, param.game.width, param.game.height};
+	fade_mode_ = FadeMode::IN;
 
 	// Inicializa objetos
-	background->setPos(param.game.gameArea.rect);
-	background->setCloudsSpeed(-0.1f);
-	background->setGradientNumber(1);
-	background->setTransition(0.8f);
-	fade->setColor(fadeColor.r, fadeColor.g, fadeColor.b);
-	fade->setType(FADE_RANDOM_SQUARE);
-	fade->setPost(param.fade.postDuration);
-	fade->setMode(fadeMode);
-	fade->activate();
+	background_->setPos(param.game.game_area.rect);
+	background_->setCloudsSpeed(-0.1f);
+	background_->setGradientNumber(1);
+	background_->setTransition(0.8f);
+	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
+	fade_->setType(FadeType::RANDOM_SQUARE);
+	fade_->setPost(param.fade.post_duration);
+	fade_->setMode(fade_mode_);
+	fade_->activate();
 
 	// Crea el contenido de la textura con la lista de puntuaciones
 	fillTexture();
@@ -65,47 +63,45 @@ HiScoreTable::HiScoreTable(JA_Music_t *music)
 // Destructor
 HiScoreTable::~HiScoreTable()
 {
-	delete text;
-	delete eventHandler;
-	delete background;
-
-	SDL_DestroyTexture(backbuffer);
+	SDL_DestroyTexture(backbuffer_);
 }
 
 // Actualiza las variables
 void HiScoreTable::update()
 {
 	// Actualiza las variables
-	if (SDL_GetTicks() - ticks > ticksSpeed)
+	if (SDL_GetTicks() - ticks_ > ticks_speed_)
 	{
 		// Actualiza el contador de ticks
-		ticks = SDL_GetTicks();
+		ticks_ = SDL_GetTicks();
 
 		// Mantiene la música sonando
 		if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
-			JA_PlayMusic(music);
+		{
+			JA_PlayMusic(music_);
+		}
 
 		// Actualiza el objeto screen
-		screen->update();
+		Screen::get()->update();
 
 		// Actualiza el fondo
-		background->update();
+		background_->update();
 
 		// Gestiona el fade
 		updateFade();
 
 		// Gestiona el contador y sus eventos
-		counter++;
+		counter_++;
 
-		if (counter == 150)
+		if (counter_ == 150)
 		{
-			background->setColor({0, 0, 0});
-			background->setAlpha(96);
+			background_->setColor({0, 0, 0});
+			background_->setAlpha(96);
 		}
 
-		if (counter == counterEnd)
+		if (counter_ == counter_end_)
 		{
-			fade->activate();
+			fade_->activate();
 		}
 	}
 }
@@ -113,70 +109,71 @@ void HiScoreTable::update()
 // Crea el contenido de la textura con la lista de puntuaciones
 void HiScoreTable::fillTexture()
 {
-	// hay 27 letras - 7 de puntos quedan 20 caracteres 20 - nameLenght 0 numDots
-	const int maxNames = 10;
-	const int spaceBetweenHeader = 32;
-	const int spaceBetweenLines = text->getCharacterSize() * 2.0f;
-	const int size = spaceBetweenHeader + spaceBetweenLines * (maxNames - 1) + text->getCharacterSize();
-	const int firstLine = (param.game.height - size) / 2;
+	// hay 27 letras - 7 de puntos quedan 20 caracteres 20 - name_lenght 0 num_dots
+	constexpr auto max_names = 10;
+	constexpr auto space_between_header = 32;
+	const auto space_between_lines = text_->getCharacterSize() * 2.0f;
+	const auto size = space_between_header + space_between_lines * (max_names - 1) + text_->getCharacterSize();
+	const auto first_line = (param.game.height - size) / 2;
 
 	// Pinta en el backbuffer el texto y los sprites
-	SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-	SDL_SetRenderTarget(renderer, backbuffer);
-	SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
-	SDL_RenderClear(renderer);
+	auto temp = SDL_GetRenderTarget(renderer_);
+	SDL_SetRenderTarget(renderer_, backbuffer_);
+	SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
+	SDL_RenderClear(renderer_);
 
 	// Escribe el texto: Mejores puntuaciones
-	text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, param.game.gameArea.centerX, firstLine, lang::getText(42), 1, orangeColor, 1, shdwTxtColor);
+	text_->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, first_line, lang::getText(42), 1, orange_color, 1, shdw_txt_color);
 
 	// Escribe los nombres de la tabla de puntuaciones
-	for (int i = 0; i < maxNames; ++i)
+	for (int i = 0; i < max_names; ++i)
 	{
-		const int nameLenght = options.game.hiScoreTable[i].name.length();
-		const std::string score = format(options.game.hiScoreTable[i].score);
-		const int scoreLenght = score.size();
-		const int numDots = 25 - nameLenght - scoreLenght;
-		std::string dots = "";
-		for (int j = 0; j < numDots; ++j)
+		const auto name_lenght = options.game.hi_score_table[i].name.length();
+		const auto score = format(options.game.hi_score_table[i].score);
+		const auto score_lenght = score.size();
+		const auto num_dots = 25 - name_lenght - score_lenght;
+		std::string dots;
+		for (int j = 0; j < (int)num_dots; ++j)
 		{
 			dots = dots + ".";
 		}
-		const std::string line = options.game.hiScoreTable[i].name + dots + score;
-		text->writeDX(TXT_CENTER | TXT_SHADOW, param.game.gameArea.centerX, (i * spaceBetweenLines) + firstLine + spaceBetweenHeader, line, 1, orangeColor, 1, shdwTxtColor);
+		const auto line = options.game.hi_score_table[i].name + dots + score;
+		text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, (i * space_between_lines) + first_line + space_between_header, line, 1, orange_color, 1, shdw_txt_color);
 	}
 
 	// Cambia el destino de renderizado
-	SDL_SetRenderTarget(renderer, temp);
+	SDL_SetRenderTarget(renderer_, temp);
 }
 
 // Pinta en pantalla
 void HiScoreTable::render()
 {
 	// Prepara para empezar a dibujar en la textura de juego
-	screen->start();
+	Screen::get()->start();
 
 	// Limpia la pantalla
-	screen->clean(bgColor);
+	Screen::get()->clean(bg_color);
 
 	// Pinta el fondo
-	background->render();
+	background_->render();
 
 	// Establece la ventana del backbuffer
-	viewArea.y = std::max(0, param.game.height - counter + 100);
+	view_area_.y = std::max(0, param.game.height - counter_ + 100);
 
 	// Copia el backbuffer al renderizador
-	SDL_RenderCopy(renderer, backbuffer, nullptr, &viewArea);
+	SDL_RenderCopy(renderer_, backbuffer_, nullptr, &view_area_);
 
-	fade->render();
+	// Renderiza el fade
+	fade_->render();
 
 	// Vuelca el contenido del renderizador en pantalla
-	screen->blit();
+	Screen::get()->blit();
 }
 
 // Recarga todas las texturas
 void HiScoreTable::reloadTextures()
 {
-	text->reLoadTexture();
+	text_->reLoadTexture();
 	fillTexture();
 }
 
@@ -184,19 +181,20 @@ void HiScoreTable::reloadTextures()
 void HiScoreTable::checkEvents()
 {
 	// Comprueba los eventos que hay en la cola
-	while (SDL_PollEvent(eventHandler) != 0)
+	SDL_Event event;
+	while (SDL_PollEvent(&event))
 	{
 		// Evento de salida de la aplicación
-		if (eventHandler->type == SDL_QUIT)
+		if (event.type == SDL_QUIT)
 		{
-			section::name = section::NAME_QUIT;
+			section::name = section::Name::QUIT;
 			break;
 		}
 
 		// Comprueba si se ha cambiado el tamaño de la ventana
-		else if (eventHandler->type == SDL_WINDOWEVENT)
+		else if (event.type == SDL_WINDOWEVENT)
 		{
-			if (eventHandler->window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
+			if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
 			{
 				reloadTextures();
 			}
@@ -208,25 +206,25 @@ void HiScoreTable::checkEvents()
 void HiScoreTable::checkInput()
 {
 	// Comprueba si se ha pulsado cualquier botón (de los usados para jugar)
-	if (input->checkAnyButtonPressed())
+	if (Input::get()->checkAnyButtonPressed())
 	{
 		JA_StopMusic();
-		section::name = section::NAME_TITLE;
-		section::options = section::OPTIONS_TITLE_1;
+		section::name = section::Name::TITLE;
+		section::options = section::Options::TITLE_1;
 		return;
 	}
 
 	// Comprueba el input para el resto de objetos
-	screen->checkInput();
+	Screen::get()->checkInput();
 
 	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
-	checkGlobalInputs();
+	globalInputs::check();
 }
 
 // Bucle para la pantalla de instrucciones
 void HiScoreTable::run()
 {
-	while (section::name == section::NAME_HI_SCORE_TABLE)
+	while (section::name == section::Name::HI_SCORE_TABLE)
 	{
 		checkInput();
 		update();
@@ -235,62 +233,21 @@ void HiScoreTable::run()
 	}
 }
 
-// Transforma un valor numérico en una cadena de 6 cifras
-std::string HiScoreTable::scoreToString(int num)
-{
-	if ((num >= 0) && (num <= 9))
-	{
-		return ("000000" + std::to_string(num));
-	}
-
-	if ((num >= 10) && (num <= 99))
-	{
-		return ("00000" + std::to_string(num));
-	}
-
-	if ((num >= 100) && (num <= 999))
-	{
-		return ("0000" + std::to_string(num));
-	}
-
-	if ((num >= 1000) && (num <= 9999))
-	{
-		return ("000" + std::to_string(num));
-	}
-
-	if ((num >= 010000) && (num <= 99999))
-	{
-		return ("00" + std::to_string(num));
-	}
-
-	if ((num >= 100000) && (num <= 999999))
-	{
-		return ("0" + std::to_string(num));
-	}
-
-	if ((num >= 1000000) && (num <= 9999999))
-	{
-		return (std::to_string(num));
-	}
-
-	return (std::to_string(num));
-}
-
 // Gestiona el fade
 void HiScoreTable::updateFade()
 {
-	fade->update();
+	fade_->update();
 
-	if (fade->hasEnded() && fadeMode == FADE_IN)
+	if (fade_->hasEnded() && fade_mode_ == FadeMode::IN)
 	{
-		fade->reset();
-		fadeMode = FADE_OUT;
-		fade->setMode(fadeMode);
+		fade_->reset();
+		fade_mode_ = FadeMode::OUT;
+		fade_->setMode(fade_mode_);
 	}
 
-	if (fade->hasEnded() && fadeMode == FADE_OUT)
+	if (fade_->hasEnded() && fade_mode_ == FadeMode::OUT)
 	{
-		section::name = section::NAME_INSTRUCTIONS;
+		section::name = section::Name::INSTRUCTIONS;
 	}
 }
 
@@ -300,9 +257,9 @@ std::string HiScoreTable::format(int number)
 	const std::string separator = ".";
 	const std::string score = std::to_string(number);
 
-	int index = (int)score.size() - 1;
-	std::string result = "";
-	int i = 0;
+	auto index = (int)score.size() - 1;
+	std::string result;
+	auto i = 0;
 	while (index >= 0)
 	{
 		result = score.at(index) + result;

source/hiscore_table.h

@@ -1,18 +1,15 @@
 #pragma once
 
-#include <SDL2/SDL_events.h>  // for SDL_Event
-#include <SDL2/SDL_rect.h>    // for SDL_Rect
-#include <SDL2/SDL_render.h>  // for SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h>  // for Uint16, Uint32
-#include <string>             // for string
-#include "section.h"          // for options_e
-class Asset;
-class Background;
-class Fade;
-class Input;
-class Screen;
-class Text;
-struct JA_Music_t;
+#include <SDL2/SDL_rect.h>	 // for SDL_Rect
+#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_stdinc.h> // for Uint16, Uint32, Uint8
+#include <memory>			 // for unique_ptr
+#include <string>			 // for string
+class Background;			 // lines 8-8
+class Fade;					 // lines 9-9
+class Text;					 // lines 10-10
+enum class FadeMode : Uint8; // lines 11-11
+struct JA_Music_t;			 // lines 12-12
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de mostrar la tabla con las puntuaciones
@@ -29,24 +26,21 @@ class HiScoreTable
 {
 private:
 	// Objetos y punteros
-	SDL_Renderer *renderer;	 // El renderizador de la ventana
-	Screen *screen;			 // Objeto encargado de dibujar en pantalla
-	SDL_Event *eventHandler; // Manejador de eventos
-	SDL_Texture *backbuffer; // Textura para usar como backbuffer
-	Asset *asset;			 // Objeto que gestiona todos los ficheros de recursos
-	Input *input;			 // Objeto pata gestionar la entrada
-	Background *background;	 // Objeto para dibujar el fondo del juego
-	Fade *fade;				 // Objeto para renderizar fades
-	Text *text;				 // Objeto para escribir texto
-	JA_Music_t *music;		 // Musica de fondo
+	SDL_Renderer *renderer_;  // El renderizador de la ventana
+	SDL_Texture *backbuffer_; // Textura para usar como backbuffer
+	JA_Music_t *music_;		  // Musica de fondo
+
+	std::unique_ptr<Fade> fade_;			 // Objeto para renderizar fades
+	std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego
+	std::unique_ptr<Text> text_;			 // Objeto para escribir texto
 
 	// Variables
-	Uint16 counter;	   // Contador
-	Uint16 counterEnd; // Valor final para el contador
-	Uint32 ticks;	   // Contador de ticks para ajustar la velocidad del programa
-	Uint32 ticksSpeed; // Velocidad a la que se repiten los bucles del programa
-	SDL_Rect viewArea; // Parte de la textura que se muestra en pantalla
-	int fadeMode;	   // Modo de fade a utilizar
+	Uint16 counter_;	 // Contador
+	Uint16 counter_end_; // Valor final para el contador
+	Uint32 ticks_;		 // Contador de ticks para ajustar la velocidad del programa
+	Uint32 ticks_speed_; // Velocidad a la que se repiten los bucles del programa
+	SDL_Rect view_area_; // Parte de la textura que se muestra en pantalla
+	FadeMode fade_mode_; // Modo de fade a utilizar
 
 	// Actualiza las variables
 	void update();
@@ -63,9 +57,6 @@ private:
 	// Convierte un entero a un string con separadores de miles
 	std::string format(int number);
 
-	// Transforma un valor numérico en una cadena de 6 cifras
-	std::string scoreToString(int num);
-
 	// Crea el contenido de la textura con la lista de puntuaciones
 	void fillTexture();
 
@@ -75,12 +66,9 @@ private:
 	// Gestiona el fade
 	void updateFade();
 
-	// Termina
-	void quit(section::options_e code);
-
 public:
 	// Constructor
-	HiScoreTable(JA_Music_t *music);
+	explicit HiScoreTable(JA_Music_t *music);
 
 	// Destructor
 	~HiScoreTable();

source/input.cpp

@@ -1,130 +1,111 @@
 #include "input.h"
-#include <SDL2/SDL.h>           // for SDL_INIT_GAMECONTROLLER, SDL_InitSubS...
-#include <SDL2/SDL_error.h>     // for SDL_GetError
-#include <SDL2/SDL_events.h>    // for SDL_ENABLE
-#include <SDL2/SDL_keyboard.h>  // for SDL_GetKeyboardState
-#include <iostream>             // for basic_ostream, operator<<, cout, basi...
+#include <SDL2/SDL.h>		   // for SDL_INIT_GAMECONTROLLER, SDL_InitSubS...
+#include <SDL2/SDL_error.h>	   // for SDL_GetError
+#include <SDL2/SDL_events.h>   // for SDL_ENABLE
+#include <SDL2/SDL_keyboard.h> // for SDL_GetKeyboardState
+#include <iostream>			   // for basic_ostream, operator<<, cout, basi...
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
-Input *Input::input = nullptr;
+Input *Input::input_ = nullptr;
 
 // [SINGLETON] Crearemos el objeto input con esta función estática
-void Input::init(std::string file)
+void Input::init(const std::string &game_controller_db_path)
 {
-    Input::input = new Input(file);
+	Input::input_ = new Input(game_controller_db_path);
 }
 
 // [SINGLETON] Destruiremos el objeto input con esta función estática
 void Input::destroy()
 {
-    delete Input::input;
+	delete Input::input_;
 }
 
 // [SINGLETON] Con este método obtenemos el objeto input y podemos trabajar con él
 Input *Input::get()
 {
-    return Input::input;
+	return Input::input_;
 }
 
 // Constructor
-Input::Input(std::string file)
+Input::Input(const std::string &game_controller_db_path)
+	: game_controller_db_path_(game_controller_db_path),
+	  enabled_(true)
 {
-	// Inicializa variables
-	verbose = false;
-	enabled = true;
-
-	// Fichero gamecontrollerdb.txt
-	dbPath = file;
-
 	// Busca si hay mandos conectados
 	discoverGameControllers();
 
 	// Inicializa las vectores
-	keyBindings_t kb;
+	KeyBindings kb;
 	kb.scancode = 0;
 	kb.active = false;
-	keyBindings.resize(input_number_of_inputs, kb);
+	key_bindings_.resize(static_cast<int>(InputType::NUMBER_OF_INPUTS), kb);
 
-	GameControllerBindings_t gcb;
+	ControllerBindings gcb;
 	gcb.button = SDL_CONTROLLER_BUTTON_INVALID;
 	gcb.active = false;
-	gameControllerBindings.resize(numGamepads);
-	for (int i = 0; i < numGamepads; ++i)
+	controller_bindings_.resize(num_gamepads_);
+	for (int i = 0; i < num_gamepads_; ++i)
 	{
-		gameControllerBindings[i].resize(input_number_of_inputs, gcb);
+		controller_bindings_[i].resize(static_cast<int>(InputType::NUMBER_OF_INPUTS), gcb);
 	}
 
 	// Listado de los inputs usados para jugar, excluyendo botones para la interfaz
-	gameInputs.clear();
-	gameInputs.push_back(input_fire_left);
-	gameInputs.push_back(input_fire_center);
-	gameInputs.push_back(input_fire_right);
-	gameInputs.push_back(input_up);
-	gameInputs.push_back(input_down);
-	gameInputs.push_back(input_left);
-	gameInputs.push_back(input_right);
+	game_inputs_.clear();
+	game_inputs_.push_back(InputType::FIRE_LEFT);
+	game_inputs_.push_back(InputType::FIRE_CENTER);
+	game_inputs_.push_back(InputType::FIRE_RIGHT);
+	game_inputs_.push_back(InputType::UP);
+	game_inputs_.push_back(InputType::DOWN);
+	game_inputs_.push_back(InputType::LEFT);
+	game_inputs_.push_back(InputType::RIGHT);
 
 	// Listado de los inputs para jugar que utilizan botones, ni palancas ni crucetas
-	buttonInputs.clear();
-	buttonInputs.push_back(input_fire_left);
-	buttonInputs.push_back(input_fire_center);
-	buttonInputs.push_back(input_fire_right);
-	buttonInputs.push_back(input_start);
-}
-
-// Destructor
-Input::~Input()
-{
-	
-}
-
-// Actualiza el estado del objeto
-void Input::update()
-{
-	if (disabledUntil == d_keyPressed && !checkAnyInput())
-	{
-		enable();
-	}
+	button_inputs_.clear();
+	button_inputs_.push_back(InputType::FIRE_LEFT);
+	button_inputs_.push_back(InputType::FIRE_CENTER);
+	button_inputs_.push_back(InputType::FIRE_RIGHT);
+	button_inputs_.push_back(InputType::START);
 }
 
 // Asigna inputs a teclas
-void Input::bindKey(inputs_e input, SDL_Scancode code)
+void Input::bindKey(InputType input, SDL_Scancode code)
 {
-	keyBindings[input].scancode = code;
+	key_bindings_[static_cast<int>(input)].scancode = code;
 }
 
 // Asigna inputs a botones del mando
-void Input::bindGameControllerButton(int index, inputs_e input, SDL_GameControllerButton button)
+void Input::bindGameControllerButton(int controller_index, InputType input, SDL_GameControllerButton button)
 {
-	if (index < numGamepads)
+	if (controller_index < num_gamepads_)
 	{
-		gameControllerBindings[index][input].button = button;
+		controller_bindings_[controller_index][static_cast<int>(input)].button = button;
 	}
 }
 
 // Asigna inputs a botones del mando
-void Input::bindGameControllerButton(int index, inputs_e inputTarget, inputs_e inputSource)
+void Input::bindGameControllerButton(int controller_index, InputType input_target, InputType input_source)
 {
-	if (index < numGamepads)
+	if (controller_index < num_gamepads_)
 	{
-		gameControllerBindings[index][inputTarget].button = gameControllerBindings[index][inputSource].button;
+		controller_bindings_[controller_index][static_cast<int>(input_target)].button = controller_bindings_[controller_index][static_cast<int>(input_source)].button;
 	}
 }
 
 // Comprueba si un input esta activo
-bool Input::checkInput(inputs_e input, bool repeat, int device, int index)
+bool Input::checkInput(InputType input, bool repeat, int device, int controller_index)
 {
-	if (!enabled)
+	if (!enabled_)
 	{
 		return false;
 	}
 
-	bool successKeyboard = false;
-	bool successGameController = false;
+	bool success_keyboard = false;
+	bool success_controller = false;
+	const int input_index = static_cast<int>(input);
 
 	if (device == INPUT_USE_ANY)
 	{
-		index = 0;
+		controller_index = 0;
 	}
 
 	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
@@ -133,108 +114,109 @@ bool Input::checkInput(inputs_e input, bool repeat, int device, int index)
 
 		if (repeat)
 		{
-			if (keyStates[keyBindings[input].scancode] != 0)
+			if (keyStates[key_bindings_[input_index].scancode] != 0)
 			{
-				successKeyboard = true;
+				success_keyboard = true;
 			}
 			else
 			{
-				successKeyboard = false;
+				success_keyboard = false;
 			}
 		}
 		else
 		{
-			if (!keyBindings[input].active)
+			if (!key_bindings_[input_index].active)
 			{
-				if (keyStates[keyBindings[input].scancode] != 0)
+				if (keyStates[key_bindings_[input_index].scancode] != 0)
 				{
-					keyBindings[input].active = true;
-					successKeyboard = true;
+					key_bindings_[input_index].active = true;
+					success_keyboard = true;
 				}
 				else
 				{
-					successKeyboard = false;
+					success_keyboard = false;
 				}
 			}
 			else
 			{
-				if (keyStates[keyBindings[input].scancode] == 0)
+				if (keyStates[key_bindings_[input_index].scancode] == 0)
 				{
-					keyBindings[input].active = false;
-					successKeyboard = false;
+					key_bindings_[input_index].active = false;
+					success_keyboard = false;
 				}
 				else
 				{
-					successKeyboard = false;
+					success_keyboard = false;
 				}
 			}
 		}
 	}
 
-	if (gameControllerFound() &&  index < numGamepads)
+	if (gameControllerFound() && controller_index < num_gamepads_)
 		if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY))
 		{
-			successGameController = checkAxisInput(input, index);
-			if (!successGameController)
+			success_controller = checkAxisInput(input, controller_index);
+			if (!success_controller)
 			{
 				if (repeat)
 				{
-					if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0)
+					if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0)
 					{
-						successGameController = true;
+						success_controller = true;
 					}
 					else
 					{
-						successGameController = false;
+						success_controller = false;
 					}
 				}
 				else
 				{
-					if (!gameControllerBindings[index][input].active)
+					if (!controller_bindings_[controller_index][input_index].active)
 					{
-						if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0)
+						if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0)
 						{
-							gameControllerBindings[index][input].active = true;
-							successGameController = true;
+							controller_bindings_[controller_index][input_index].active = true;
+							success_controller = true;
 						}
 						else
 						{
-							successGameController = false;
+							success_controller = false;
 						}
 					}
 					else
 					{
-						if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) == 0)
+						if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) == 0)
 						{
-							gameControllerBindings[index][input].active = false;
-							successGameController = false;
+							controller_bindings_[controller_index][input_index].active = false;
+							success_controller = false;
 						}
 						else
 						{
-							successGameController = false;
+							success_controller = false;
 						}
 					}
 				}
 			}
 		}
 
-	return (successKeyboard || successGameController);
+	return (success_keyboard || success_controller);
 }
 
 // Comprueba si un input con modificador esta activo
-bool Input::checkModInput(inputs_e inputMod, inputs_e input, bool repeat, int device, int index)
+bool Input::checkModInput(InputType input_mod, InputType input, bool repeat, int device, int controller_index)
 {
-	if (!enabled || index >= numGamepads || !checkInput(inputMod, INPUT_ALLOW_REPEAT, device, index))
+	if (!enabled_ || controller_index >= num_gamepads_ || !checkInput(input_mod, INPUT_ALLOW_REPEAT, device, controller_index))
 	{
 		return false;
 	}
 
-	bool successKeyboard = false;
-	bool successGameController = false;
+	bool success_keyboard = false;
+	bool success_controller = false;
+	const int input_index = static_cast<int>(input);
 
 	if (device == INPUT_USE_ANY)
 	{
-		index = 0;
+		controller_index = 0;
 	}
 
 	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
@@ -243,111 +225,111 @@ bool Input::checkModInput(inputs_e inputMod, inputs_e input, bool repeat, int de
 
 		if (repeat)
 		{
-			if (keyStates[keyBindings[input].scancode] != 0)
+			if (keyStates[key_bindings_[input_index].scancode] != 0)
 			{
-				successKeyboard = true;
+				success_keyboard = true;
 			}
 			else
 			{
-				successKeyboard = false;
+				success_keyboard = false;
 			}
 		}
 		else
 		{
-			if (!keyBindings[input].active)
+			if (!key_bindings_[input_index].active)
 			{
-				if (keyStates[keyBindings[input].scancode] != 0)
+				if (keyStates[key_bindings_[input_index].scancode] != 0)
 				{
-					keyBindings[input].active = true;
-					successKeyboard = true;
+					key_bindings_[input_index].active = true;
+					success_keyboard = true;
 				}
 				else
 				{
-					successKeyboard = false;
+					success_keyboard = false;
 				}
 			}
 			else
 			{
-				if (keyStates[keyBindings[input].scancode] == 0)
+				if (keyStates[key_bindings_[input_index].scancode] == 0)
 				{
-					keyBindings[input].active = false;
-					successKeyboard = false;
+					key_bindings_[input_index].active = false;
+					success_keyboard = false;
 				}
 				else
 				{
-					successKeyboard = false;
+					success_keyboard = false;
 				}
 			}
 		}
 	}
 
-	if (gameControllerFound() && index < numGamepads)
+	if (gameControllerFound() && controller_index < num_gamepads_)
 		if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY))
 		{
-			successGameController = checkAxisInput(input, index);
-			if (!successGameController)
+			success_controller = checkAxisInput(input, controller_index);
+			if (!success_controller)
 			{
 				if (repeat)
 				{
-					if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0)
+					if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0)
 					{
-						successGameController = true;
+						success_controller = true;
 					}
 					else
 					{
-						successGameController = false;
+						success_controller = false;
 					}
 				}
 				else
 				{
-					if (!gameControllerBindings[index][input].active)
+					if (!controller_bindings_[controller_index][input_index].active)
 					{
-						if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0)
+						if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0)
 						{
-							gameControllerBindings[index][input].active = true;
-							successGameController = true;
+							controller_bindings_[controller_index][input_index].active = true;
+							success_controller = true;
 						}
 						else
 						{
-							successGameController = false;
+							success_controller = false;
 						}
 					}
 					else
 					{
-						if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) == 0)
+						if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) == 0)
 						{
-							gameControllerBindings[index][input].active = false;
-							successGameController = false;
+							controller_bindings_[controller_index][input_index].active = false;
+							success_controller = false;
 						}
 						else
 						{
-							successGameController = false;
+							success_controller = false;
 						}
 					}
 				}
 			}
 		}
 
-	return (successKeyboard || successGameController);
+	return (success_keyboard || success_controller);
 }
 
 // Comprueba si hay almenos un input activo
-bool Input::checkAnyInput(int device, int index)
+bool Input::checkAnyInput(int device, int controller_index)
 {
 	if (device == INPUT_USE_ANY)
 	{
-		index = 0;
+		controller_index = 0;
 	}
 
 	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
 	{
 		const Uint8 *mKeystates = SDL_GetKeyboardState(nullptr);
 
-		for (int i = 0; i < (int)keyBindings.size(); ++i)
+		for (int i = 0; i < (int)key_bindings_.size(); ++i)
 		{
-			if (mKeystates[keyBindings[i].scancode] != 0 && !keyBindings[i].active)
+			if (mKeystates[key_bindings_[i].scancode] != 0 && !key_bindings_[i].active)
 			{
-				keyBindings[i].active = true;
+				key_bindings_[i].active = true;
 				return true;
 			}
 		}
@@ -357,11 +339,11 @@ bool Input::checkAnyInput(int device, int index)
 	{
 		if (device == INPUT_USE_GAMECONTROLLER || device == INPUT_USE_ANY)
 		{
-			for (int i = 0; i < (int)gameControllerBindings.size(); ++i)
+			for (int i = 0; i < (int)controller_bindings_.size(); ++i)
 			{
-				if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][i].button) != 0 && !gameControllerBindings[index][i].active)
+				if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][i].button) != 0 && !controller_bindings_[controller_index][i].active)
 				{
-					gameControllerBindings[index][i].active = true;
+					controller_bindings_[controller_index][i].active = true;
 					return true;
 				}
 			}
@@ -375,13 +357,13 @@ bool Input::checkAnyInput(int device, int index)
 int Input::checkAnyButtonPressed(bool repeat)
 {
 	// Si está pulsado el botón de servicio, ningún botón se puede considerar pulsado
-	if (checkInput(input_service, INPUT_ALLOW_REPEAT, INPUT_USE_ANY))
+	if (checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_ANY))
 	{
 		return 0;
 	}
 
 	// Solo comprueba los botones definidos previamente
-	for (auto bi : buttonInputs)
+	for (auto bi : button_inputs_)
 	{
 		// Comprueba el teclado
 		if (checkInput(bi, repeat, INPUT_USE_KEYBOARD))
@@ -390,7 +372,7 @@ int Input::checkAnyButtonPressed(bool repeat)
 		}
 
 		// Comprueba los mandos
-		for (int i = 0; i < numGamepads; ++i)
+		for (int i = 0; i < num_gamepads_; ++i)
 		{
 			if (checkInput(bi, repeat, INPUT_USE_GAMECONTROLLER, i))
 			{
@@ -412,62 +394,63 @@ bool Input::discoverGameControllers()
 		SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER);
 	}
 
-	if (SDL_GameControllerAddMappingsFromFile(dbPath.c_str()) < 0)
+	if (SDL_GameControllerAddMappingsFromFile(game_controller_db_path_.c_str()) < 0)
 	{
-		if (verbose)
+#ifdef VERBOSE
 		{
-			std::cout << "Error, could not load " << dbPath.c_str() << " file: " << SDL_GetError() << std::endl;
+			std::cout << "Error, could not load " << game_controller_db_path_.c_str() << " file: " << SDL_GetError() << std::endl;
 		}
+#endif
 	}
 
-	numJoysticks = SDL_NumJoysticks();
-	numGamepads = 0;
+	num_joysticks_ = SDL_NumJoysticks();
+	num_gamepads_ = 0;
 
 	// Cuenta el número de mandos
-	joysticks.clear();
-	for (int i = 0; i < numJoysticks; ++i)
+	joysticks_.clear();
+	for (int i = 0; i < num_joysticks_; ++i)
 	{
 		SDL_Joystick *joy = SDL_JoystickOpen(i);
-		joysticks.push_back(joy);
+		joysticks_.push_back(joy);
 		if (SDL_IsGameController(i))
 		{
-			numGamepads++;
+			num_gamepads_++;
 		}
 	}
 
-	if (verbose)
+#ifdef VERBOSE
 	{
 		std::cout << "\nChecking for game controllers...\n";
-		std::cout << numJoysticks << " joysticks found, " << numGamepads << " are gamepads\n";
+		std::cout << num_joysticks_ << " joysticks found, " << num_gamepads_ << " are gamepads\n";
 	}
+#endif
 
-	if (numGamepads > 0)
+	if (num_gamepads_ > 0)
 	{
 		found = true;
 
-		for (int i = 0; i < numGamepads; i++)
+		for (int i = 0; i < num_gamepads_; i++)
 		{
 			// Abre el mando y lo añade a la lista
-			SDL_GameController *pad = SDL_GameControllerOpen(i);
+			auto pad = SDL_GameControllerOpen(i);
 			if (SDL_GameControllerGetAttached(pad) == 1)
 			{
-				connectedControllers.push_back(pad);
-				const std::string separator(" #");
-				std::string name = SDL_GameControllerNameForIndex(i);
-				// name.resize(25);
-				// name = name + separator + std::to_string(i);
-				if (verbose)
+				connected_controllers_.push_back(pad);
+				const std::string name = SDL_GameControllerNameForIndex(i);
+#ifdef VERBOSE
 				{
 					std::cout << name << std::endl;
 				}
-				controllerNames.push_back(name);
+#endif
+				controller_names_.push_back(name);
 			}
 			else
 			{
-				if (verbose)
+#ifdef VERBOSE
 				{
 					std::cout << "SDL_GetError() = " << SDL_GetError() << std::endl;
 				}
+#endif
 			}
 		}
 
@@ -480,47 +463,27 @@ bool Input::discoverGameControllers()
 // Comprueba si hay algun mando conectado
 bool Input::gameControllerFound()
 {
-	return numGamepads > 0 ? true : false;
+	return num_gamepads_ > 0 ? true : false;
 }
 
 // Obten el nombre de un mando de juego
-std::string Input::getControllerName(int index)
+std::string Input::getControllerName(int controller_index) const
 {
-	return numGamepads > 0 ? controllerNames[index] : "";
+	return num_gamepads_ > 0 ? controller_names_[controller_index] : "";
 }
 
 // Obten el número de mandos conectados
-int Input::getNumControllers()
+int Input::getNumControllers() const
 {
-	return numGamepads;
-}
-
-// Establece si ha de mostrar mensajes
-void Input::setVerbose(bool value)
-{
-	verbose = value;
-}
-
-// Deshabilita las entradas durante un periodo de tiempo
-void Input::disableUntil(i_disable_e value)
-{
-	disabledUntil = value;
-	enabled = false;
-}
-
-// Hablita las entradas
-void Input::enable()
-{
-	enabled = true;
-	disabledUntil = d_notDisabled;
+	return num_gamepads_;
 }
 
 // Obtiene el indice del controlador a partir de un event.id
-int Input::getJoyIndex(int id)
+int Input::getJoyIndex(int id) const
 {
-	for (int i = 0; i < numJoysticks; ++i)
+	for (int i = 0; i < num_joysticks_; ++i)
 	{
-		if (SDL_JoystickInstanceID(joysticks[i]) == id)
+		if (SDL_JoystickInstanceID(joysticks_[i]) == id)
 		{
 			return i;
 		}
@@ -529,7 +492,7 @@ int Input::getJoyIndex(int id)
 }
 
 // Muestra por consola los controles asignados
-void Input::printBindings(int device, int index)
+void Input::printBindings(int device, int controller_index) const
 {
 	if (device == INPUT_USE_ANY || device == INPUT_USE_KEYBOARD)
 	{
@@ -538,35 +501,35 @@ void Input::printBindings(int device, int index)
 
 	if (device == INPUT_USE_GAMECONTROLLER)
 	{
-		if (index >= numGamepads)
+		if (controller_index >= num_gamepads_)
 		{
 			return;
 		}
 
 		// Muestra el nombre del mando
 		std::cout << "\n"
-				  << controllerNames[index] << std::endl;
+				  << controller_names_[controller_index] << std::endl;
 
 		// Muestra los botones asignados
-		for (auto bi : buttonInputs)
+		for (auto bi : button_inputs_)
 		{
-			std::cout << to_string(bi) << " : " << gameControllerBindings[index][bi].button << std::endl;
+			std::cout << to_string(bi) << " : " << controller_bindings_[controller_index][static_cast<int>(bi)].button << std::endl;
 		}
 	}
 }
 
 // Obtiene el SDL_GameControllerButton asignado a un input
-SDL_GameControllerButton Input::getControllerBinding(int index, inputs_e input)
+SDL_GameControllerButton Input::getControllerBinding(int controller_index, InputType input) const
 {
-	return gameControllerBindings[index][input].button;
+	return controller_bindings_[controller_index][static_cast<int>(input)].button;
 }
 
 // Obtiene el indice a partir del nombre del mando
-int Input::getIndexByName(std::string name)
+int Input::getIndexByName(const std::string &name) const
 {
-	for (int i = 0; i < numGamepads; ++i)
+	for (int i = 0; i < num_gamepads_; ++i)
 	{
-		if (controllerNames[i] == name)
+		if (controller_names_[i] == name)
 		{
 			return i;
 		}
@@ -574,30 +537,30 @@ int Input::getIndexByName(std::string name)
 	return -1;
 }
 
-// Convierte un inputs_e a std::string
-std::string Input::to_string(inputs_e input)
+// Convierte un InputType a std::string
+std::string Input::to_string(InputType input) const
 {
-	if (input == input_fire_left)
+	if (input == InputType::FIRE_LEFT)
 	{
 		return "input_fire_left";
 	}
 
-	if (input == input_fire_center)
+	if (input == InputType::FIRE_CENTER)
 	{
 		return "input_fire_center";
 	}
 
-	if (input == input_fire_right)
+	if (input == InputType::FIRE_RIGHT)
 	{
 		return "input_fire_right";
 	}
 
-	if (input == input_start)
+	if (input == InputType::START)
 	{
 		return "input_start";
 	}
 
-	if (input == input_service)
+	if (input == InputType::SERVICE)
 	{
 		return "input_service";
 	}
@@ -605,76 +568,67 @@ std::string Input::to_string(inputs_e input)
 	return "";
 }
 
-// Convierte un std::string a inputs_e
-inputs_e Input::to_inputs_e(std::string name)
+// Convierte un std::string a InputType
+InputType Input::to_inputs_e(const std::string &name) const
 {
 	if (name == "input_fire_left")
 	{
-		return input_fire_left;
+		return InputType::FIRE_LEFT;
 	}
 
 	if (name == "input_fire_center")
 	{
-		return input_fire_center;
+		return InputType::FIRE_CENTER;
 	}
 
 	if (name == "input_fire_right")
 	{
-		return input_fire_right;
+		return InputType::FIRE_RIGHT;
 	}
 
 	if (name == "input_start")
 	{
-		return input_start;
+		return InputType::START;
 	}
 
 	if (name == "input_service")
 	{
-		return input_service;
+		return InputType::SERVICE;
 	}
 
-	return input_null;
-}
-
-// Activa todos los inputs. Sirve para evitar inputs sin repeticiones pero que ya vienen pulsados cuando checkInput no estaba monitorizando
-void Input::allActive(int index)
-{
-	for (int i = 0; i < (int)buttonInputs.size(); ++i)
-	{
-		gameControllerBindings[index][i].active = true;
-	}
+	return InputType::NONE;
 }
 
 // Comprueba el eje del mando
-bool Input::checkAxisInput(inputs_e input, int index)
+bool Input::checkAxisInput(InputType input, int controller_index) const
 {
 	bool success = false;
 
 	switch (input)
 	{
-	case input_left:
-		if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTX) < -30000)
+	case InputType::LEFT:
+		if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) < -30000)
 		{
 			success = true;
 		}
 		break;
 
-	case input_right:
-		if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTX) > 30000)
+	case InputType::RIGHT:
+		if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) > 30000)
 		{
 			success = true;
 		}
 		break;
 
-	case input_up:
-		if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTY) < -30000)
+	case InputType::UP:
+		if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) < -30000)
 		{
 			success = true;
 		}
 		break;
 
-	case input_down:
-		if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTY) > 30000)
+	case InputType::DOWN:
+		if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) > 30000)
 		{
 			success = true;
 		}

source/input.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#include <SDL2/SDL_gamecontroller.h>  // for SDL_GameControllerButton, SDL_G...
-#include <SDL2/SDL_joystick.h>        // for SDL_Joystick
-#include <SDL2/SDL_scancode.h>        // for SDL_Scancode
-#include <SDL2/SDL_stdinc.h>          // for Uint8
-#include <string>                     // for string, basic_string
-#include <vector>                     // for vector
+#include <SDL2/SDL_gamecontroller.h> // for SDL_GameControllerButton, SDL_G...
+#include <SDL2/SDL_joystick.h>		 // for SDL_Joystick
+#include <SDL2/SDL_scancode.h>		 // for SDL_Scancode
+#include <SDL2/SDL_stdinc.h>		 // for Uint8
+#include <string>					 // for string, basic_string
+#include <vector>					 // for vector
 
 /*
 connectedControllers es un vector donde estan todos los mandos encontrados [0 .. n]
@@ -16,98 +16,89 @@ device contiene el tipo de dispositivo a comprobar:
 	INPUT_USE_ANY mirará tanto el teclado como el PRIMER controlador
 */
 
-enum inputs_e
+enum class InputType : int
 {
 	// Inputs de movimiento
-	input_up,
-	input_down,
-	input_left,
-	input_right,
+	UP,
+	DOWN,
+	LEFT,
+	RIGHT,
 
 	// Inputs personalizados
-	input_fire_left,
-	input_fire_center,
-	input_fire_right,
-	input_start,
+	FIRE_LEFT,
+	FIRE_CENTER,
+	FIRE_RIGHT,
+	START,
 
 	// Inputs de control
-	input_exit,
-	input_pause,
-	input_service,
-	input_window_fullscreen,
-	input_window_inc_size,
-	input_window_dec_size,
-	input_video_shaders,
-	input_reset,
-	input_mute,
-	input_showinfo,
-	input_config,
-	input_swap_controllers,
+	EXIT,
+	PAUSE,
+	SERVICE,
+	WINDOW_FULLSCREEN,
+	WINDOW_INC_SIZE,
+	WINDOW_DEC_SIZE,
+	VIDEO_SHADERS,
+	RESET,
+	MUTE,
+	SHOWINFO,
+	CONFIG,
+	SWAP_CONTROLLERS,
 
 	// Input obligatorio
-	input_null,
-	input_number_of_inputs,
+	NONE,
+	NUMBER_OF_INPUTS,
 };
 
-#define INPUT_ALLOW_REPEAT true
-#define INPUT_DO_NOT_ALLOW_REPEAT false
+constexpr bool INPUT_ALLOW_REPEAT = true;
+constexpr bool INPUT_DO_NOT_ALLOW_REPEAT = false;
 
-#define INPUT_USE_KEYBOARD 0
-#define INPUT_USE_GAMECONTROLLER 1
-#define INPUT_USE_ANY 2
-
-enum i_disable_e
-{
-	d_notDisabled,
-	d_forever,
-	d_keyPressed
-};
+constexpr int INPUT_USE_KEYBOARD = 0;
+constexpr int INPUT_USE_GAMECONTROLLER = 1;
+constexpr int INPUT_USE_ANY = 2;
 
 class Input
 {
 private:
 	// [SINGLETON] Objeto screen privado para Don Melitón
-	static Input *input;
+	static Input *input_;
 
-	struct keyBindings_t
+	struct KeyBindings
 	{
 		Uint8 scancode; // Scancode asociado
 		bool active;	// Indica si está activo
 	};
 
-	struct GameControllerBindings_t
+	struct ControllerBindings
 	{
 		SDL_GameControllerButton button; // GameControllerButton asociado
 		bool active;					 // Indica si está activo
 	};
 
 	// Variables
-	std::vector<SDL_GameController *> connectedControllers;					   // Vector con todos los mandos conectados
-	std::vector<SDL_Joystick *> joysticks;									   // Vector con todos los joysticks conectados
-	std::vector<keyBindings_t> keyBindings;									   // Vector con las teclas asociadas a los inputs predefinidos
-	std::vector<std::vector<GameControllerBindings_t>> gameControllerBindings; // Vector con los botones asociadas a los inputs predefinidos para cada mando
-	std::vector<std::string> controllerNames;								   // Vector con los nombres de los mandos
-	std::vector<inputs_e> gameInputs;										   // Inputs usados para jugar, normalmente direcciones y botones
-	std::vector<inputs_e> buttonInputs;										   // Inputs asignados al jugador y a botones, excluyendo direcciones
-	int numJoysticks;														   // Número de joysticks conectados
-	int numGamepads;														   // Número de mandos conectados
-	std::string dbPath;														   // Ruta al archivo gamecontrollerdb.txt
-	bool verbose;															   // Indica si ha de mostrar mensajes
-	i_disable_e disabledUntil;												   // Tiempo que esta deshabilitado
-	bool enabled;															   // Indica si está habilitado
+	std::vector<SDL_GameController *> connected_controllers_;		   // Vector con todos los mandos conectados
+	std::vector<SDL_Joystick *> joysticks_;							   // Vector con todos los joysticks conectados
+	std::vector<KeyBindings> key_bindings_;							   // Vector con las teclas asociadas a los inputs predefinidos
+	std::vector<std::vector<ControllerBindings>> controller_bindings_; // Vector con los botones asociadas a los inputs predefinidos para cada mando
+	std::vector<std::string> controller_names_;						   // Vector con los nombres de los mandos
+	std::vector<InputType> game_inputs_;							   // Inputs usados para jugar, normalmente direcciones y botones
+	std::vector<InputType> button_inputs_;							   // Inputs asignados al jugador y a botones, excluyendo direcciones
+	int num_joysticks_;												   // Número de joysticks conectados
+	int num_gamepads_;												   // Número de mandos conectados
+	std::string game_controller_db_path_;							   // Ruta al archivo gamecontrollerdb.txt
+	bool enabled_;													   // Indica si está habilitado
 
 	// Comprueba el eje del mando
-	bool checkAxisInput(inputs_e input, int index = 0);
+	bool checkAxisInput(InputType input, int controller_index = 0) const;
 
 	// Constructor
-	Input(std::string file);
+	explicit Input(const std::string &game_controller_db_path);
 
 	// Destructor
-	~Input();
+	~Input() = default;
 
 public:
 	// [SINGLETON] Crearemos el objeto screen con esta función estática
-	static void init(std::string file);
+	static void init(const std::string &game_controller_db_path);
 
 	// [SINGLETON] Destruiremos el objeto screen con esta función estática
 	static void destroy();
@@ -115,24 +106,21 @@ public:
 	// [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
 	static Input *get();
 
-	// Actualiza el estado del objeto
-	void update();
-
 	// Asigna inputs a teclas
-	void bindKey(inputs_e input, SDL_Scancode code);
+	void bindKey(InputType input, SDL_Scancode code);
 
 	// Asigna inputs a botones del mando
-	void bindGameControllerButton(int index, inputs_e input, SDL_GameControllerButton button);
-	void bindGameControllerButton(int index, inputs_e inputTarget, inputs_e inputSource);
+	void bindGameControllerButton(int controller_index, InputType input, SDL_GameControllerButton button);
+	void bindGameControllerButton(int controller_index, InputType inputTarget, InputType inputSource);
 
 	// Comprueba si un input esta activo
-	bool checkInput(inputs_e input, bool repeat = true, int device = INPUT_USE_ANY, int index = 0);
+	bool checkInput(InputType input, bool repeat = true, int device = INPUT_USE_ANY, int controller_index = 0);
 
 	// Comprueba si un input con modificador esta activo
-	bool checkModInput(inputs_e inputMod, inputs_e input, bool repeat = true, int device = INPUT_USE_ANY, int index = 0);
+	bool checkModInput(InputType input_mod, InputType input, bool repeat = true, int device = INPUT_USE_ANY, int controller_index = 0);
 
 	// Comprueba si hay almenos un input activo
-	bool checkAnyInput(int device = INPUT_USE_ANY, int index = 0);
+	bool checkAnyInput(int device = INPUT_USE_ANY, int controller_index = 0);
 
 	// Comprueba si hay algún botón pulsado
 	int checkAnyButtonPressed(bool repeat = INPUT_DO_NOT_ALLOW_REPEAT);
@@ -144,38 +132,26 @@ public:
 	bool gameControllerFound();
 
 	// Obten el número de mandos conectados
-	int getNumControllers();
+	int getNumControllers() const;
 
 	// Obten el nombre de un mando de juego
-	std::string getControllerName(int index);
-
-	// Establece si ha de mostrar mensajes
-	void setVerbose(bool value);
-
-	// Deshabilita las entradas durante un periodo de tiempo
-	void disableUntil(i_disable_e value);
-
-	// Hablita las entradas
-	void enable();
+	std::string getControllerName(int controller_index) const;
 
 	// Obtiene el indice del controlador a partir de un event.id
-	int getJoyIndex(int id);
+	int getJoyIndex(int id) const;
 
 	// Muestra por consola los controles asignados
-	void printBindings(int device = INPUT_USE_KEYBOARD, int index = 0);
+	void printBindings(int device = INPUT_USE_KEYBOARD, int controller_index = 0) const;
 
 	// Obtiene el SDL_GameControllerButton asignado a un input
-	SDL_GameControllerButton getControllerBinding(int index, inputs_e input);
+	SDL_GameControllerButton getControllerBinding(int controller_index, InputType input) const;
 
-	// Convierte un inputs_e a std::string
-	std::string to_string(inputs_e input);
+	// Convierte un InputType a std::string
+	std::string to_string(InputType input) const;
 
-	// Convierte un std::string a inputs_e
-	inputs_e to_inputs_e(std::string name);
+	// Convierte un std::string a InputType
+	InputType to_inputs_e(const std::string &name) const;
 
 	// Obtiene el indice a partir del nombre del mando
-	int getIndexByName(std::string name);
-
-	// Activa todos los inputs. Sirve para evitar inputs sin repeticiones pero que ya vienen pulsados cuando checkInput no estaba monitorizando
-	void allActive(int index);
+	int getIndexByName(const std::string &name) const;
 };

source/instructions.cpp

@@ -1,66 +1,63 @@
 #include "instructions.h"
-#include <SDL2/SDL_blendmode.h>  // for SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_pixels.h>     // for SDL_PIXELFORMAT_RGBA8888
-#include <SDL2/SDL_timer.h>      // for SDL_GetTicks
-#include <SDL2/SDL_video.h>      // for SDL_WINDOWEVENT_SIZE_CHANGED
-#include <algorithm>             // for max
-#include <string>                // for basic_string
-#include "asset.h"               // for Asset
-#include "fade.h"                // for Fade, FADE_FULLSCREEN, FADE_IN
-#include "global_inputs.h"       // for checkGlobalInputs
-#include "input.h"               // for Input
-#include "jail_audio.h"          // for JA_GetMusicState, JA_Music_state
-#include "lang.h"                // for getText
-#include "param.h"               // for param
-#include "screen.h"              // for Screen
-#include "section.h"             // for name, name_e, options, options_e
-#include "sprite.h"              // for Sprite
-#include "text.h"                // for Text, TXT_CENTER, TXT_COLOR, TXT_SHADOW
-#include "texture.h"             // for Texture
-#include "tiled_bg.h"             // for Tiledbg, TILED_MODE_STATIC
-#include "utils.h"               // for param_t, paramGame_t, color_t, shdwT...
-struct JA_Music_t;
+#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_events.h>	// for SDL_PollEvent, SDL_Event, SDL_QUIT
+#include <SDL2/SDL_pixels.h>	// for SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_timer.h>		// for SDL_GetTicks
+#include <SDL2/SDL_video.h>		// for SDL_WINDOWEVENT_SIZE_CHANGED
+#include <algorithm>			// for max
+#include <utility>				// for move
+#include "asset.h"				// for Asset
+#include "fade.h"				// for Fade, FadeMode, FadeType
+#include "global_inputs.h"		// for check
+#include "input.h"				// for Input
+#include "jail_audio.h"			// for JA_GetMusicState, JA_Music_state
+#include "lang.h"				// for getText
+#include "param.h"				// for param
+#include "screen.h"				// for Screen
+#include "section.h"			// for Name, name, Options, options
+#include "sprite.h"				// for Sprite
+#include "text.h"				// for Text, TEXT_CENTER, TEXT_COLOR, TEXT_...
+#include "texture.h"			// for Texture
+#include "tiled_bg.h"			// for Tiledbg, TILED_MODE_STATIC
+#include "utils.h"				// for Param, ParamGame, Color, shdw_txt_color
+struct JA_Music_t;				// lines 22-22
 
 // Constructor
 Instructions::Instructions(JA_Music_t *music)
+	: music_(music)
 {
 	// Copia los punteros
-	this->music = music;
-	input = Input::get();
-	screen = Screen::get();
-	asset = Asset::get();
-	renderer = screen->getRenderer();
+	renderer_ = Screen::get()->getRenderer();
 
 	// Crea objetos
-	eventHandler = new SDL_Event();
-	text = new Text(asset->get("smb2.gif"), asset->get("smb2.txt"), renderer);
-	tiledbg = new Tiledbg(asset->get("title_bg_tile.png"), {0, 0, param.game.width, param.game.height}, TILED_MODE_STATIC);
-	fade = new Fade(renderer);
+	text_ = std::make_unique<Text>(Asset::get()->get("smb2.gif"), Asset::get()->get("smb2.txt"), renderer_);
+	tiled_bg_ = std::make_unique<Tiledbg>(Asset::get()->get("title_bg_tile.png"), (SDL_Rect){0, 0, param.game.width, param.game.height}, TILED_MODE_STATIC);
+	fade_ = std::make_unique<Fade>(renderer_);
 
 	// Crea un backbuffer para el renderizador
-	backbuffer = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
-	SDL_SetTextureBlendMode(backbuffer, SDL_BLENDMODE_BLEND);
+	backbuffer_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
+	SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
 
 	// Crea una textura para el texto fijo
-	texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
-	SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+	texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
+	SDL_SetTextureBlendMode(texture_, SDL_BLENDMODE_BLEND);
 
 	// Inicializa variables
-	section::name = section::NAME_INSTRUCTIONS;
-	ticks = 0;
-	ticksSpeed = 15;
-	counter = 0;
-	counterEnd = 700;
-	view = {0, 0, param.game.width, param.game.height};
-	spritePos = {0, 0};
-	itemSpace = 2;
+	section::name = section::Name::INSTRUCTIONS;
+	ticks_ = 0;
+	ticks_speed_ = 15;
+	counter_ = 0;
+	counter_end_ = 700;
+	view_ = {0, 0, param.game.width, param.game.height};
+	sprite_pos_ = {0, 0};
+	item_space_ = 2;
 
 	// Inicializa objetos
-	fade->setColor(fadeColor.r, fadeColor.g, fadeColor.b);
-	fade->setType(FADE_FULLSCREEN);
-	fade->setPost(param.fade.postDuration);
-	fade->setMode(FADE_IN);
-	fade->activate();
+	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
+	fade_->setType(FadeType::FULLSCREEN);
+	fade_->setPost(param.fade.post_duration);
+	fade_->setMode(FadeMode::IN);
+	fade_->activate();
 
 	// Rellena la textura de texto
 	fillTexture();
@@ -72,205 +69,190 @@ Instructions::Instructions(JA_Music_t *music)
 // Destructor
 Instructions::~Instructions()
 {
-	for (auto texture : itemTextures)
-	{
-		texture->unload();
-		delete texture;
-	}
-	itemTextures.clear();
+	item_textures_.clear();
+	sprites_.clear();
 
-	for (auto sprite : sprites)
-	{
-		delete sprite;
-	}
-	sprites.clear();
-
-	delete eventHandler;
-	delete text;
-	delete tiledbg;
-	delete fade;
-
-	SDL_DestroyTexture(backbuffer);
-	SDL_DestroyTexture(texture);
+	SDL_DestroyTexture(backbuffer_);
+	SDL_DestroyTexture(texture_);
 }
 
 // Inicializa los sprites de los items
 void Instructions::iniSprites()
 {
 	// Inicializa las texturas
-	Texture *item1 = new Texture(renderer, asset->get("item_points1_disk.png"));
-	itemTextures.push_back(item1);
+	auto item1 = std::make_shared<Texture>(renderer_, Asset::get()->get("item_points1_disk.png"));
+	item_textures_.push_back(item1);
 
-	Texture *item2 = new Texture(renderer, asset->get("item_points2_gavina.png"));
-	itemTextures.push_back(item2);
+	auto item2 = std::make_shared<Texture>(renderer_, Asset::get()->get("item_points2_gavina.png"));
+	item_textures_.push_back(item2);
 
-	Texture *item3 = new Texture(renderer, asset->get("item_points3_pacmar.png"));
-	itemTextures.push_back(item3);
+	auto item3 = std::make_shared<Texture>(renderer_, Asset::get()->get("item_points3_pacmar.png"));
+	item_textures_.push_back(item3);
 
-	Texture *item4 = new Texture(renderer, asset->get("item_clock.png"));
-	itemTextures.push_back(item4);
+	auto item4 = std::make_shared<Texture>(renderer_, Asset::get()->get("item_clock.png"));
+	item_textures_.push_back(item4);
 
-	Texture *item5 = new Texture(renderer, asset->get("item_coffee.png"));
-	itemTextures.push_back(item5);
+	auto item5 = std::make_shared<Texture>(renderer_, Asset::get()->get("item_coffee.png"));
+	item_textures_.push_back(item5);
 
 	// Inicializa los sprites
-	for (int i = 0; i < (int)itemTextures.size(); ++i)
+	for (int i = 0; i < (int)item_textures_.size(); ++i)
 	{
-		Sprite *sprite = new Sprite(0, 0, param.game.itemSize, param.game.itemSize, itemTextures[i]);
-		sprite->setPos((SDL_Point){spritePos.x, spritePos.y + ((param.game.itemSize + itemSpace) * i)});
-		sprites.push_back(sprite);
+		auto sprite = std::make_unique<Sprite>(0, 0, param.game.item_size, param.game.item_size, item_textures_[i]);
+		sprite->setPos((SDL_Point){sprite_pos_.x, sprite_pos_.y + ((param.game.item_size + item_space_) * i)});
+		sprites_.push_back(std::move(sprite));
 	}
 }
 
 // Actualiza los sprites
 void Instructions::updateSprites()
 {
-	SDL_Rect srcRect = {0, 0, param.game.itemSize, param.game.itemSize};
+	SDL_Rect src_rect = {0, 0, param.game.item_size, param.game.item_size};
 
 	// Disquito
-	srcRect.y = param.game.itemSize * (((counter + 12) / 36) % 2);
-	sprites[0]->setSpriteClip(srcRect);
+	src_rect.y = param.game.item_size * (((counter_ + 12) / 36) % 2);
+	sprites_[0]->setSpriteClip(src_rect);
 
-	// Gavineixon
-	srcRect.y = param.game.itemSize * (((counter + 9) / 36) % 2);
-	sprites[1]->setSpriteClip(srcRect);
+	// Gavina
+	src_rect.y = param.game.item_size * (((counter_ + 9) / 36) % 2);
+	sprites_[1]->setSpriteClip(src_rect);
 
 	// Pacmar
-	srcRect.y = param.game.itemSize * (((counter + 6) / 36) % 2);
-	sprites[2]->setSpriteClip(srcRect);
+	src_rect.y = param.game.item_size * (((counter_ + 6) / 36) % 2);
+	sprites_[2]->setSpriteClip(src_rect);
 
 	// Time Stopper
-	srcRect.y = param.game.itemSize * (((counter + 3) / 36) % 2);
-	sprites[3]->setSpriteClip(srcRect);
+	src_rect.y = param.game.item_size * (((counter_ + 3) / 36) % 2);
+	sprites_[3]->setSpriteClip(src_rect);
 
 	// Coffee
-	srcRect.y = param.game.itemSize * (((counter + 0) / 36) % 2);
-	sprites[4]->setSpriteClip(srcRect);
+	src_rect.y = param.game.item_size * (((counter_ + 0) / 36) % 2);
+	sprites_[4]->setSpriteClip(src_rect);
 }
 
 // Rellena la textura de texto
 void Instructions::fillTexture()
 {
-	const int despX = param.game.itemSize + 8;
+	const int desp_x = param.game.item_size + 8;
 
 	// Modifica el renderizador para pintar en la textura
-	SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-	SDL_SetRenderTarget(renderer, texture);
+	auto temp = SDL_GetRenderTarget(renderer_);
+	SDL_SetRenderTarget(renderer_, texture_);
 
 	// Limpia la textura
-	SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
-	SDL_RenderClear(renderer);
+	SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
+	SDL_RenderClear(renderer_);
 
 	// Constantes
-	const int numLines = 4;
-	const int numItemLines = 4;
-	const int numPostHeaders = 2;
-	const int numPreHeaders = 1;
+	constexpr int num_lines = 4;
+	constexpr int num_item_lines = 4;
+	constexpr int num_post_headers = 2;
+	constexpr int num_pre_headers = 1;
 
-	const int spacePostHeader = 20;
-	const int spacePreHeader = 28;
-	const int spaceBetweenLines = text->getCharacterSize() * 1.5f;
-	const int spaceBetweenItemLines = param.game.itemSize + itemSpace;
-	const int spaceNewParagraph = spaceBetweenLines * 0.5f;
+	constexpr int space_post_header = 20;
+	constexpr int space_pre_header = 28;
+	const int space_between_lines = text_->getCharacterSize() * 1.5f;
+	const int space_between_item_lines = param.game.item_size + item_space_;
+	const int space_new_paragraph = space_between_lines * 0.5f;
 
-	const int size = (numLines * spaceBetweenLines) + (numItemLines * spaceBetweenItemLines) + (numPostHeaders * spacePostHeader) + (numPreHeaders * spacePreHeader) + (spaceNewParagraph);
-	const int firstLine = (param.game.height - size) / 2;
+	const int size = (num_lines * space_between_lines) + (num_item_lines * space_between_item_lines) + (num_post_headers * space_post_header) + (num_pre_headers * space_pre_header) + (space_new_paragraph);
+	const int first_line = (param.game.height - size) / 2;
 
 	// Calcula cual es el texto más largo de las descripciones de los items
 	int lenght = 0;
 	for (int i = 17; i <= 21; ++i)
 	{
-		const int l = text->lenght(lang::getText(i));
+		const int l = text_->lenght(lang::getText(i));
 		lenght = l > lenght ? l : lenght;
 	}
-	const int anchorItem = (param.game.width - (lenght + despX)) / 2;
+	const int anchor_item = (param.game.width - (lenght + desp_x)) / 2;
 
 	// Escribe el texto de las instrucciones
-	text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, param.game.gameArea.centerX, firstLine, lang::getText(11), 1, orangeColor, 1, shdwTxtColor);
+	text_->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, first_line, lang::getText(11), 1, orange_color, 1, shdw_txt_color);
 
-	const int anchor1 = firstLine + spacePostHeader;
-	text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, param.game.gameArea.centerX, anchor1 + spaceBetweenLines * 0, lang::getText(12), 1, noColor, 1, shdwTxtColor);
-	text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, param.game.gameArea.centerX, anchor1 + spaceBetweenLines * 1, lang::getText(13), 1, noColor, 1, shdwTxtColor);
-	text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, param.game.gameArea.centerX, anchor1 + spaceNewParagraph + spaceBetweenLines * 2, lang::getText(14), 1, noColor, 1, shdwTxtColor);
-	text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, param.game.gameArea.centerX, anchor1 + spaceNewParagraph + spaceBetweenLines * 3, lang::getText(15), 1, noColor, 1, shdwTxtColor);
+	const int anchor1 = first_line + space_post_header;
+	text_->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, anchor1 + space_between_lines * 0, lang::getText(12), 1, no_color, 1, shdw_txt_color);
+	text_->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, anchor1 + space_between_lines * 1, lang::getText(13), 1, no_color, 1, shdw_txt_color);
+	text_->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, anchor1 + space_new_paragraph + space_between_lines * 2, lang::getText(14), 1, no_color, 1, shdw_txt_color);
+	text_->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, anchor1 + space_new_paragraph + space_between_lines * 3, lang::getText(15), 1, no_color, 1, shdw_txt_color);
 
 	// Escribe el texto de los objetos y sus puntos
-	const int anchor2 = anchor1 + spacePreHeader + spaceNewParagraph + spaceBetweenLines * 3;
-	text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, param.game.gameArea.centerX, anchor2, lang::getText(16), 1, orangeColor, 1, shdwTxtColor);
+	const int anchor2 = anchor1 + space_pre_header + space_new_paragraph + space_between_lines * 3;
+	text_->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, anchor2, lang::getText(16), 1, orange_color, 1, shdw_txt_color);
 
-	const int anchor3 = anchor2 + spacePostHeader;
-	// const int anchor4 = anchor3 + ((param.game.itemSize + text->getCharacterSize()) / 2);
-	text->writeShadowed(anchorItem + despX, anchor3 + spaceBetweenItemLines * 0, lang::getText(17), shdwTxtColor);
-	text->writeShadowed(anchorItem + despX, anchor3 + spaceBetweenItemLines * 1, lang::getText(18), shdwTxtColor);
-	text->writeShadowed(anchorItem + despX, anchor3 + spaceBetweenItemLines * 2, lang::getText(19), shdwTxtColor);
-	text->writeShadowed(anchorItem + despX, anchor3 + spaceBetweenItemLines * 3, lang::getText(20), shdwTxtColor);
-	text->writeShadowed(anchorItem + despX, anchor3 + spaceBetweenItemLines * 4, lang::getText(21), shdwTxtColor);
+	const int anchor3 = anchor2 + space_post_header;
+	// const int anchor4 = anchor3 + ((param.game.item_size + text->getCharacterSize()) / 2);
+	text_->writeShadowed(anchor_item + desp_x, anchor3 + space_between_item_lines * 0, lang::getText(17), shdw_txt_color);
+	text_->writeShadowed(anchor_item + desp_x, anchor3 + space_between_item_lines * 1, lang::getText(18), shdw_txt_color);
+	text_->writeShadowed(anchor_item + desp_x, anchor3 + space_between_item_lines * 2, lang::getText(19), shdw_txt_color);
+	text_->writeShadowed(anchor_item + desp_x, anchor3 + space_between_item_lines * 3, lang::getText(20), shdw_txt_color);
+	text_->writeShadowed(anchor_item + desp_x, anchor3 + space_between_item_lines * 4, lang::getText(21), shdw_txt_color);
 
 	// Deja el renderizador como estaba
-	SDL_SetRenderTarget(renderer, temp);
+	SDL_SetRenderTarget(renderer_, temp);
 
 	// Da valor a la variable
-	spritePos.x = anchorItem;
-	spritePos.y = anchor3 - ((param.game.itemSize - text->getCharacterSize()) / 2);
+	sprite_pos_.x = anchor_item;
+	sprite_pos_.y = anchor3 - ((param.game.item_size - text_->getCharacterSize()) / 2);
 }
 
 // Rellena el backbuffer
 void Instructions::fillBackbuffer()
 {
 	// Modifica el renderizador para pintar en la textura
-	SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-	SDL_SetRenderTarget(renderer, backbuffer);
+	auto temp = SDL_GetRenderTarget(renderer_);
+	SDL_SetRenderTarget(renderer_, backbuffer_);
 
 	// Limpia la textura
-	SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
-	SDL_RenderClear(renderer);
+	SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
+	SDL_RenderClear(renderer_);
 
 	// Coloca el texto de fondo
-	SDL_RenderCopy(renderer, texture, nullptr, nullptr);
+	SDL_RenderCopy(renderer_, texture_, nullptr, nullptr);
 
 	// Dibuja los sprites
-	for (auto sprite : sprites)
+	for (auto &sprite : sprites_)
 	{
 		sprite->render();
 	}
 
 	// Deja el renderizador como estaba
-	SDL_SetRenderTarget(renderer, temp);
+	SDL_SetRenderTarget(renderer_, temp);
 }
 
 // Actualiza las variables
 void Instructions::update()
 {
 	// Actualiza las variables
-	if (SDL_GetTicks() - ticks > ticksSpeed)
+	if (SDL_GetTicks() - ticks_ > ticks_speed_)
 	{
 		// Actualiza el contador de ticks
-		ticks = SDL_GetTicks();
+		ticks_ = SDL_GetTicks();
 
 		// Mantiene la música sonando
 		if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
-			JA_PlayMusic(music);
+			JA_PlayMusic(music_);
 
 		// Actualiza el objeto screen
-		screen->update();
+		Screen::get()->update();
 
 		// Incrementa el contador
-		counter++;
+		counter_++;
 
 		// Actualiza los sprites
 		updateSprites();
 
 		// Actualiza el mosaico de fondo
-		tiledbg->update();
+		tiled_bg_->update();
 
 		// Actualiza el objeto "fade"
-		fade->update();
+		fade_->update();
 
 		// Comprueba si el contador ha llegado al final
-		if (counter == counterEnd)
+		if (counter_ == counter_end_)
 		{
-			section::name = section::NAME_TITLE;
-			section::options = section::OPTIONS_TITLE_1;
+			section::name = section::Name::TITLE;
+			section::options = section::Options::TITLE_1;
 		}
 	}
 }
@@ -282,34 +264,34 @@ void Instructions::render()
 	fillBackbuffer();
 
 	// Prepara para empezar a dibujar en la textura de juego
-	screen->start();
+	Screen::get()->start();
 
 	// Limpia la pantalla
-	screen->clean(bgColor);
+	Screen::get()->clean(bg_color);
 
 	// Dibuja el mosacico de fondo
-	tiledbg->render();
+	tiled_bg_->render();
 
 	// Establece la ventana del backbuffer
-	view.y = std::max(0, param.game.height - counter + 100);
+	view_.y = std::max(0, param.game.height - counter_ + 100);
 
 	// Copia la textura y el backbuffer al renderizador
-	SDL_RenderCopy(renderer, backbuffer, nullptr, &view);
+	SDL_RenderCopy(renderer_, backbuffer_, nullptr, &view_);
 
-	fade->render();
+	fade_->render();
 
 	// Vuelca el contenido del renderizador en pantalla
-	screen->blit();
+	Screen::get()->blit();
 }
 
 // Recarga todas las texturas
 void Instructions::reloadTextures()
 {
-	for (auto tex : itemTextures)
+	for (auto &texture : item_textures_)
 	{
-		tex->reLoad();
+		texture->reLoad();
 	}
-	text->reLoadTexture();
+	text_->reLoadTexture();
 	fillTexture();
 }
 
@@ -317,19 +299,20 @@ void Instructions::reloadTextures()
 void Instructions::checkEvents()
 {
 	// Comprueba los eventos que hay en la cola
-	while (SDL_PollEvent(eventHandler) != 0)
+	SDL_Event event;
+	while (SDL_PollEvent(&event))
 	{
 		// Evento de salida de la aplicación
-		if (eventHandler->type == SDL_QUIT)
+		if (event.type == SDL_QUIT)
 		{
-			section::name = section::NAME_QUIT;
+			section::name = section::Name::QUIT;
 			break;
 		}
 
 		// Comprueba si se ha cambiado el tamaño de la ventana
-		else if (eventHandler->type == SDL_WINDOWEVENT)
+		else if (event.type == SDL_WINDOWEVENT)
 		{
-			if (eventHandler->window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
+			if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
 			{
 				reloadTextures();
 			}
@@ -341,25 +324,25 @@ void Instructions::checkEvents()
 void Instructions::checkInput()
 {
 	// Comprueba si se ha pulsado cualquier botón (de los usados para jugar)
-	if (input->checkAnyButtonPressed())
+	if (Input::get()->checkAnyButtonPressed())
 	{
 		JA_StopMusic();
-		section::name = section::NAME_TITLE;
-		section::options = section::OPTIONS_TITLE_1;
+		section::name = section::Name::TITLE;
+		section::options = section::Options::TITLE_1;
 		return;
 	}
 
 	// Comprueba el input para el resto de objetos
-	screen->checkInput();
+	Screen::get()->checkInput();
 
 	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
-	checkGlobalInputs();
+	globalInputs::check();
 }
 
 // Bucle para la pantalla de instrucciones
 void Instructions::run()
 {
-	while (section::name == section::NAME_INSTRUCTIONS)
+	while (section::name == section::Name::INSTRUCTIONS)
 	{
 		checkInput();
 		update();

source/instructions.h

@@ -1,19 +1,16 @@
 #pragma once
 
-#include <SDL2/SDL_events.h>  // for SDL_Event
 #include <SDL2/SDL_rect.h>    // for SDL_Point, SDL_Rect
 #include <SDL2/SDL_render.h>  // for SDL_Texture, SDL_Renderer
 #include <SDL2/SDL_stdinc.h>  // for Uint32
+#include <memory>             // for unique_ptr, shared_ptr
 #include <vector>             // for vector
-class Asset;
 class Fade;
-class Input;
-class Screen;
 class Sprite;
 class Text;
 class Texture;
 class Tiledbg;
-struct JA_Music_t;
+struct JA_Music_t;  // lines 14-14
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de poner en pantalla
@@ -33,28 +30,25 @@ class Instructions
 {
 private:
 	// Objetos y punteros
-	SDL_Renderer *renderer;				 // El renderizador de la ventana
-	Screen *screen;						 // Objeto encargado de dibujar en pantalla
-	std::vector<Texture *> itemTextures; // Vector con las texturas de los items
-	std::vector<Sprite *> sprites;		 // Vector con los sprites de los items
-	SDL_Event *eventHandler;			 // Manejador de eventos
-	SDL_Texture *backbuffer;			 // Textura para usar como backbuffer
-	SDL_Texture *texture;				 // Textura fija con el texto
-	Asset *asset;						 // Objeto que gestiona todos los ficheros de recursos
-	Input *input;						 // Objeto pata gestionar la entrada
-	Text *text;							 // Objeto para escribir texto
-	Tiledbg *tiledbg;					 // Objeto para dibujar el mosaico animado de fondo
-	Fade *fade;							 // Objeto para renderizar fades
-	JA_Music_t *music;					 // Musica de fondo
+	std::vector<std::shared_ptr<Texture>> item_textures_; // Vector con las texturas de los items
+	std::vector<std::unique_ptr<Sprite>> sprites_;		  // Vector con los sprites de los items
+	std::unique_ptr<Text> text_;						  // Objeto para escribir texto
+	std::unique_ptr<Tiledbg> tiled_bg_;					  // Objeto para dibujar el mosaico animado de fondo
+	std::unique_ptr<Fade> fade_;						  // Objeto para renderizar fades
+
+	SDL_Renderer *renderer_;  // El renderizador de la ventana
+	JA_Music_t *music_;		  // Musica de fondo
+	SDL_Texture *texture_;	  // Textura fija con el texto
+	SDL_Texture *backbuffer_; // Textura para usar como backbuffer
 
 	// Variables
-	int counter;		 // Contador
-	int counterEnd;		 // Valor final para el contador
-	Uint32 ticks;		 // Contador de ticks para ajustar la velocidad del programa
-	Uint32 ticksSpeed;	 // Velocidad a la que se repiten los bucles del programa
-	SDL_Rect view;		 // Vista del backbuffer que se va amostrar por pantalla
-	SDL_Point spritePos; // Posición del primer sprite
-	int itemSpace;		 // Espacio entre los items
+	int counter_;		   // Contador
+	int counter_end_;	   // Valor final para el contador
+	Uint32 ticks_;		   // Contador de ticks para ajustar la velocidad del programa
+	Uint32 ticks_speed_;   // Velocidad a la que se repiten los bucles del programa
+	SDL_Rect view_;		   // Vista del backbuffer que se va amostrar por pantalla
+	SDL_Point sprite_pos_; // Posición del primer sprite
+	int item_space_;	   // Espacio entre los items
 
 	// Actualiza las variables
 	void update();
@@ -85,7 +79,7 @@ private:
 
 public:
 	// Constructor
-	Instructions(JA_Music_t *music);
+	explicit Instructions(JA_Music_t *music);
 
 	// Destructor
 	~Instructions();

source/intro.cpp

@@ -1,206 +1,192 @@
 #include "intro.h"
-#include <SDL2/SDL_render.h>  // for SDL_Renderer
+#include <SDL2/SDL_events.h>  // for SDL_PollEvent, SDL_Event, SDL_QUIT, SDL...
 #include <SDL2/SDL_timer.h>   // for SDL_GetTicks
 #include <SDL2/SDL_video.h>   // for SDL_WINDOWEVENT_SIZE_CHANGED
-#include <string>             // for basic_string
+#include <utility>            // for move
 #include "asset.h"            // for Asset
-#include "global_inputs.h"    // for checkGlobalInputs
+#include "global_inputs.h"    // for check
 #include "input.h"            // for Input
 #include "jail_audio.h"       // for JA_StopMusic, JA_PlayMusic
 #include "lang.h"             // for getText
 #include "param.h"            // for param
 #include "screen.h"           // for Screen
-#include "section.h"          // for name, name_e, options, options_e
-#include "smart_sprite.h"      // for SmartSprite
+#include "section.h"          // for Name, name, Options, options
+#include "smart_sprite.h"     // for SmartSprite
 #include "text.h"             // for Text
 #include "texture.h"          // for Texture
-#include "utils.h"            // for paramGame_t, param_t, zone_t, BLOCK
+#include "utils.h"            // for Param, ParamGame, Zone, BLOCK, Color
 #include "writer.h"           // for Writer
-struct JA_Music_t;
+struct JA_Music_t;  // lines 19-19
 
 // Constructor
 Intro::Intro(JA_Music_t *music)
+	: music_(music)
 {
 	// Copia los punteros
-	this->music = music;
-	input = Input::get();
-	asset = Asset::get();
-	screen = Screen::get();
-	SDL_Renderer *renderer = screen->getRenderer();
+	auto renderer = Screen::get()->getRenderer();
 
 	// Reserva memoria para los objetos
-	eventHandler = new SDL_Event();
-	texture = new Texture(renderer, asset->get("intro.png"));
-	text = new Text(asset->get("nokia.png"), asset->get("nokia.txt"), renderer);
+	texture_ = std::make_shared<Texture>(renderer, Asset::get()->get("intro.png"));
+	text_ = std::make_shared<Text>(Asset::get()->get("nokia.png"), Asset::get()->get("nokia.txt"), renderer);
 
 	// Inicializa variables
-	section::name = section::NAME_INTRO;
-	section::options = section::OPTIONS_NULL;
-	ticks = 0;
-	ticksSpeed = 15;
-	scene = 1;
+	section::name = section::Name::INTRO;
+	section::options = section::Options::NONE;
+	ticks_ = 0;
+	ticks_speed_ = 15;
+	scene_ = 1;
 
 	// Inicializa los bitmaps de la intro
-	const int totalBitmaps = 6;
+	constexpr int totalBitmaps = 6;
 	for (int i = 0; i < totalBitmaps; ++i)
 	{
-		SmartSprite *ss = new SmartSprite(texture);
+		auto ss = std::make_unique<SmartSprite>(texture_);
 		ss->setWidth(128);
 		ss->setHeight(96);
-		ss->setEnabledCounter(20);
-		ss->setDestX(param.game.gameArea.centerX - 64);
-		ss->setDestY(param.game.gameArea.firstQuarterY - 24);
-		bitmaps.push_back(ss);
+		ss->setFinishedCounter(20);
+		ss->setDestX(param.game.game_area.center_x - 64);
+		ss->setDestY(param.game.game_area.first_quarter_y - 24);
+		bitmaps_.push_back(std::move(ss));
 	}
 
-	bitmaps[0]->setPosX(-128);
-	bitmaps[0]->setPosY(param.game.gameArea.firstQuarterY - 24);
-	bitmaps[0]->setVelX(0.0f);
-	bitmaps[0]->setVelY(0.0f);
-	bitmaps[0]->setAccelX(0.6f);
-	bitmaps[0]->setAccelY(0.0f);
-	bitmaps[0]->setSpriteClip(0, 0, 128, 96);
+	bitmaps_[0]->setPosX(-128);
+	bitmaps_[0]->setPosY(param.game.game_area.first_quarter_y - 24);
+	bitmaps_[0]->setVelX(0.0f);
+	bitmaps_[0]->setVelY(0.0f);
+	bitmaps_[0]->setAccelX(0.6f);
+	bitmaps_[0]->setAccelY(0.0f);
+	bitmaps_[0]->setSpriteClip(0, 0, 128, 96);
 
-	bitmaps[1]->setPosX(param.game.width);
-	bitmaps[1]->setPosY(param.game.gameArea.firstQuarterY - 24);
-	bitmaps[1]->setVelX(-1.0f);
-	bitmaps[1]->setVelY(0.0f);
-	bitmaps[1]->setAccelX(-0.3f);
-	bitmaps[1]->setAccelY(0.0f);
-	bitmaps[1]->setSpriteClip(128, 0, 128, 96);
+	bitmaps_[1]->setPosX(param.game.width);
+	bitmaps_[1]->setPosY(param.game.game_area.first_quarter_y - 24);
+	bitmaps_[1]->setVelX(-1.0f);
+	bitmaps_[1]->setVelY(0.0f);
+	bitmaps_[1]->setAccelX(-0.3f);
+	bitmaps_[1]->setAccelY(0.0f);
+	bitmaps_[1]->setSpriteClip(128, 0, 128, 96);
 
-	bitmaps[2]->setPosX(param.game.gameArea.centerX - 64);
-	bitmaps[2]->setPosY(-96);
-	bitmaps[2]->setVelX(0.0f);
-	bitmaps[2]->setVelY(3.0f);
-	bitmaps[2]->setAccelX(0.1f);
-	bitmaps[2]->setAccelY(0.3f);
-	bitmaps[2]->setSpriteClip(0, 96, 128, 96);
-	bitmaps[2]->setEnabledCounter(250);
+	bitmaps_[2]->setPosX(param.game.game_area.center_x - 64);
+	bitmaps_[2]->setPosY(-96);
+	bitmaps_[2]->setVelX(0.0f);
+	bitmaps_[2]->setVelY(3.0f);
+	bitmaps_[2]->setAccelX(0.1f);
+	bitmaps_[2]->setAccelY(0.3f);
+	bitmaps_[2]->setSpriteClip(0, 96, 128, 96);
+	bitmaps_[2]->setFinishedCounter(250);
 
-	bitmaps[3]->setPosX(param.game.gameArea.centerX - 64);
-	bitmaps[3]->setPosY(param.game.height);
-	bitmaps[3]->setVelX(0.0f);
-	bitmaps[3]->setVelY(-0.7f);
-	bitmaps[3]->setAccelX(0.0f);
-	bitmaps[3]->setAccelY(0.0f);
-	bitmaps[3]->setSpriteClip(128, 96, 128, 96);
+	bitmaps_[3]->setPosX(param.game.game_area.center_x - 64);
+	bitmaps_[3]->setPosY(param.game.height);
+	bitmaps_[3]->setVelX(0.0f);
+	bitmaps_[3]->setVelY(-0.7f);
+	bitmaps_[3]->setAccelX(0.0f);
+	bitmaps_[3]->setAccelY(0.0f);
+	bitmaps_[3]->setSpriteClip(128, 96, 128, 96);
 
-	bitmaps[4]->setPosX(param.game.gameArea.centerX - 64);
-	bitmaps[4]->setPosY(-96);
-	bitmaps[4]->setVelX(0.0f);
-	bitmaps[4]->setVelY(3.0f);
-	bitmaps[4]->setAccelX(0.1f);
-	bitmaps[4]->setAccelY(0.3f);
-	bitmaps[4]->setSpriteClip(0, 192, 128, 96);
+	bitmaps_[4]->setPosX(param.game.game_area.center_x - 64);
+	bitmaps_[4]->setPosY(-96);
+	bitmaps_[4]->setVelX(0.0f);
+	bitmaps_[4]->setVelY(3.0f);
+	bitmaps_[4]->setAccelX(0.1f);
+	bitmaps_[4]->setAccelY(0.3f);
+	bitmaps_[4]->setSpriteClip(0, 192, 128, 96);
 
-	bitmaps[5]->setPosX(param.game.width);
-	bitmaps[5]->setPosY(param.game.gameArea.firstQuarterY - 24);
-	bitmaps[5]->setVelX(-0.7f);
-	bitmaps[5]->setVelY(0.0f);
-	bitmaps[5]->setAccelX(0.0f);
-	bitmaps[5]->setAccelY(0.0f);
-	bitmaps[5]->setSpriteClip(128, 192, 128, 96);
+	bitmaps_[5]->setPosX(param.game.width);
+	bitmaps_[5]->setPosY(param.game.game_area.first_quarter_y - 24);
+	bitmaps_[5]->setVelX(-0.7f);
+	bitmaps_[5]->setVelY(0.0f);
+	bitmaps_[5]->setAccelX(0.0f);
+	bitmaps_[5]->setAccelY(0.0f);
+	bitmaps_[5]->setSpriteClip(128, 192, 128, 96);
 
 	// Inicializa los textos de la intro
-	const int totalTexts = 9;
+	constexpr int totalTexts = 9;
 	for (int i = 0; i < totalTexts; ++i)
 	{
-		Writer *w = new Writer(text);
+		auto w = std::make_unique<Writer>(text_);
 		w->setPosX(BLOCK * 0);
 		w->setPosY(param.game.height - (BLOCK * 6));
 		w->setKerning(-1);
 		w->setEnabled(false);
-		w->setEnabledCounter(180);
-		texts.push_back(w);
+		w->setFinishedCounter(180);
+		texts_.push_back(std::move(w));
 	}
 
 	// Un dia qualsevol de l'any 2000
-	texts[0]->setCaption(lang::getText(27));
-	texts[0]->setSpeed(8);
+	texts_[0]->setCaption(lang::getText(27));
+	texts_[0]->setSpeed(8);
 
 	// Tot esta tranquil a la UPV
-	texts[1]->setCaption(lang::getText(28));
-	texts[1]->setSpeed(8);
+	texts_[1]->setCaption(lang::getText(28));
+	texts_[1]->setSpeed(8);
 
 	// Fins que un desaprensiu...
-	texts[2]->setCaption(lang::getText(29));
-	texts[2]->setSpeed(12);
+	texts_[2]->setCaption(lang::getText(29));
+	texts_[2]->setSpeed(12);
 
 	// HEY! ME ANE A FERME UN CORTAET...
-	texts[3]->setCaption(lang::getText(30));
-	texts[3]->setSpeed(8);
+	texts_[3]->setCaption(lang::getText(30));
+	texts_[3]->setSpeed(8);
 
 	// UAAAAAAAAAAAAA!!!
-	texts[4]->setCaption(lang::getText(31));
-	texts[4]->setSpeed(1);
+	texts_[4]->setCaption(lang::getText(31));
+	texts_[4]->setSpeed(1);
 
 	// Espera un moment...
-	texts[5]->setCaption(lang::getText(32));
-	texts[5]->setSpeed(16);
+	texts_[5]->setCaption(lang::getText(32));
+	texts_[5]->setSpeed(16);
 
 	// Si resulta que no tinc solt!
-	texts[6]->setCaption(lang::getText(33));
-	texts[6]->setSpeed(2);
+	texts_[6]->setCaption(lang::getText(33));
+	texts_[6]->setSpeed(2);
 
 	// MERDA DE MAQUINA!
-	texts[7]->setCaption(lang::getText(34));
-	texts[7]->setSpeed(3);
+	texts_[7]->setCaption(lang::getText(34));
+	texts_[7]->setSpeed(3);
 
 	// Blop... blop... blop...
-	texts[8]->setCaption(lang::getText(35));
-	texts[8]->setSpeed(16);
+	texts_[8]->setCaption(lang::getText(35));
+	texts_[8]->setSpeed(16);
 
-	for (auto text : texts)
+	for (auto &text : texts_)
 	{
-		text->center(param.game.gameArea.centerX);
-	}
-}
-
-// Destructor
-Intro::~Intro()
-{
-	delete eventHandler;
-	delete texture;
-
-	for (auto bitmap : bitmaps)
-	{
-		delete bitmap;
-	}
-
-	for (auto text : texts)
-	{
-		delete text;
+		text->center(param.game.game_area.center_x);
 	}
 }
 
 // Recarga todas las texturas
 void Intro::reloadTextures()
 {
-	texture->reLoad();
-	text->reLoadTexture();
+	texture_->reLoad();
+	text_->reLoadTexture();
 }
 
 // Comprueba los eventos
 void Intro::checkEvents()
 {
+	SDL_Event event;
+
 	// Comprueba los eventos que hay en la cola
-	while (SDL_PollEvent(eventHandler) != 0)
+	while (SDL_PollEvent(&event))
 	{
-		// Evento de salida de la aplicación
-		if (eventHandler->type == SDL_QUIT)
+		switch (event.type)
 		{
-			section::name = section::NAME_QUIT;
+		case SDL_QUIT:
+		{
+			section::name = section::Name::QUIT;
 			break;
 		}
 
-		// Comprueba si se ha cambiado el tamaño de la ventana
-		else if (eventHandler->type == SDL_WINDOWEVENT)
+		case SDL_WINDOWEVENT:
 		{
-			if (eventHandler->window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
+			if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
 			{
 				reloadTextures();
 			}
+			break;
+		}
+
+		default:
+			break;
 		}
 	}
 }
@@ -209,171 +195,176 @@ void Intro::checkEvents()
 void Intro::checkInput()
 {
 	// Comprueba si se ha pulsado cualquier botón (de los usados para jugar)
-	if (input->checkAnyButtonPressed())
+	if (Input::get()->checkAnyButtonPressed())
 	{
 		JA_StopMusic();
-		section::name = section::NAME_TITLE;
-		section::options = section::OPTIONS_TITLE_1;
+		section::name = section::Name::TITLE;
+		section::options = section::Options::TITLE_1;
 		return;
 	}
 
 	// Comprueba el input para el resto de objetos
-	screen->checkInput();
+	Screen::get()->checkInput();
 
 	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
-	checkGlobalInputs();
+	globalInputs::check();
 }
 
 // Actualiza las escenas de la intro
 void Intro::updateScenes()
 {
-	switch (scene)
+	switch (scene_)
 	{
 	case 1:
-		// Primera imagen - UPV
-		if (!bitmaps[0]->hasFinished())
+	{ // Primera imagen - UPV
+		if (!bitmaps_[0]->hasFinished())
 		{
-			bitmaps[0]->setEnabled(true);
+			bitmaps_[0]->setEnabled(true);
 		}
 
 		// Primer texto de la primera imagen
-		if (bitmaps[0]->hasFinished() && !texts[0]->hasFinished())
+		if (bitmaps_[0]->hasFinished() && !texts_[0]->hasFinished())
 		{
-			texts[0]->setEnabled(true);
+			texts_[0]->setEnabled(true);
 		}
 
 		// Segundo texto de la primera imagen
-		if (texts[0]->hasFinished() && !texts[1]->hasFinished())
+		if (texts_[0]->hasFinished() && !texts_[1]->hasFinished())
 		{
-			texts[0]->setEnabled(false);
-			texts[1]->setEnabled(true);
+			texts_[0]->setEnabled(false);
+			texts_[1]->setEnabled(true);
 		}
 
 		// Tercer texto de la primera imagen
-		if (texts[1]->hasFinished() && !texts[2]->hasFinished())
+		if (texts_[1]->hasFinished() && !texts_[2]->hasFinished())
 		{
-			texts[1]->setEnabled(false);
-			texts[2]->setEnabled(true);
+			texts_[1]->setEnabled(false);
+			texts_[2]->setEnabled(true);
 		}
 
 		// Fin de la primera escena
-		if (texts[2]->hasFinished())
+		if (texts_[2]->hasFinished())
 		{
-			bitmaps[0]->setEnabled(false);
-			texts[2]->setEnabled(false);
-			scene++;
+			bitmaps_[0]->setEnabled(false);
+			texts_[2]->setEnabled(false);
+			scene_++;
 		}
 
 		break;
+	}
 
 	case 2:
-		// Segunda imagen - Máquina
-		if (!bitmaps[1]->hasFinished())
+	{ // Segunda imagen - Máquina
+		if (!bitmaps_[1]->hasFinished())
 		{
-			bitmaps[1]->setEnabled(true);
+			bitmaps_[1]->setEnabled(true);
 		}
 
 		// Primer texto de la segunda imagen
-		if (bitmaps[1]->hasFinished() && !texts[3]->hasFinished())
+		if (bitmaps_[1]->hasFinished() && !texts_[3]->hasFinished())
 		{
-			texts[3]->setEnabled(true);
+			texts_[3]->setEnabled(true);
 		}
 
 		// Fin de la segunda escena
-		if (texts[3]->hasFinished())
+		if (texts_[3]->hasFinished())
 		{
-			bitmaps[1]->setEnabled(false);
-			texts[3]->setEnabled(false);
-			scene++;
+			bitmaps_[1]->setEnabled(false);
+			texts_[3]->setEnabled(false);
+			scene_++;
 		}
 
 		break;
-
+	}
 	case 3:
-		// Tercera imagen junto con primer texto - GRITO
-		if (!bitmaps[2]->hasFinished() && !texts[4]->hasFinished())
+	{ // Tercera imagen junto con primer texto - GRITO
+		if (!bitmaps_[2]->hasFinished() && !texts_[4]->hasFinished())
 		{
-			bitmaps[2]->setEnabled(true);
-			texts[4]->setEnabled(true);
+			bitmaps_[2]->setEnabled(true);
+			texts_[4]->setEnabled(true);
 		}
 
 		// Fin de la tercera escena
-		if (bitmaps[2]->hasFinished() && texts[4]->hasFinished())
+		if (bitmaps_[2]->hasFinished() && texts_[4]->hasFinished())
 		{
-			bitmaps[2]->setEnabled(false);
-			texts[4]->setEnabled(false);
-			scene++;
+			bitmaps_[2]->setEnabled(false);
+			texts_[4]->setEnabled(false);
+			scene_++;
 		}
 
 		break;
+	}
 
 	case 4:
-		// Cuarta imagen junto con primer texto - Reflexión
-		if (!bitmaps[3]->hasFinished() && !texts[5]->hasFinished())
+	{ // Cuarta imagen junto con primer texto - Reflexión
+		if (!bitmaps_[3]->hasFinished() && !texts_[5]->hasFinished())
 		{
-			bitmaps[3]->setEnabled(true);
-			texts[5]->setEnabled(true);
+			bitmaps_[3]->setEnabled(true);
+			texts_[5]->setEnabled(true);
 		}
 
 		// Segundo texto de la cuarta imagen
-		if (texts[5]->hasFinished() && !texts[6]->hasFinished())
+		if (texts_[5]->hasFinished() && !texts_[6]->hasFinished())
 		{
-			texts[5]->setEnabled(false);
-			texts[6]->setEnabled(true);
+			texts_[5]->setEnabled(false);
+			texts_[6]->setEnabled(true);
 		}
 
 		// Fin de la cuarta escena
-		if (bitmaps[3]->hasFinished() && texts[6]->hasFinished())
+		if (bitmaps_[3]->hasFinished() && texts_[6]->hasFinished())
 		{
-			bitmaps[3]->setEnabled(false);
-			texts[6]->setEnabled(false);
-			scene++;
+			bitmaps_[3]->setEnabled(false);
+			texts_[6]->setEnabled(false);
+			scene_++;
 		}
 
 		break;
+	}
 
 	case 5:
-		// Quinta imagen - Patada
-		if (!bitmaps[4]->hasFinished())
+	{ // Quinta imagen - Patada
+		if (!bitmaps_[4]->hasFinished())
 		{
-			bitmaps[4]->setEnabled(true);
+			bitmaps_[4]->setEnabled(true);
 		}
 
 		// Primer texto de la quinta imagen
-		if (bitmaps[4]->hasFinished() && !texts[7]->hasFinished())
+		if (bitmaps_[4]->hasFinished() && !texts_[7]->hasFinished())
 		{
-			texts[7]->setEnabled(true);
+			texts_[7]->setEnabled(true);
 		}
 
 		// Fin de la quinta escena
-		if (bitmaps[4]->hasFinished() && texts[7]->hasFinished())
+		if (bitmaps_[4]->hasFinished() && texts_[7]->hasFinished())
 		{
-			bitmaps[4]->setEnabled(false);
-			texts[7]->setEnabled(false);
-			scene++;
+			bitmaps_[4]->setEnabled(false);
+			texts_[7]->setEnabled(false);
+			scene_++;
 		}
 
 		break;
+	}
 
 	case 6:
-		// Sexta imagen junto con texto - Globos de café
-		if (!bitmaps[5]->hasFinished() && !texts[8]->hasFinished())
+	{ // Sexta imagen junto con texto - Globos de café
+		if (!bitmaps_[5]->hasFinished() && !texts_[8]->hasFinished())
 		{
-			bitmaps[5]->setEnabled(true);
-			texts[8]->setEnabled(true);
+			bitmaps_[5]->setEnabled(true);
+			texts_[8]->setEnabled(true);
 		}
 
 		// Acaba el último texto
-		if (bitmaps[5]->hasFinished() && texts[8]->hasFinished())
+		if (bitmaps_[5]->hasFinished() && texts_[8]->hasFinished())
 		{
-			bitmaps[5]->setEnabled(false);
-			texts[8]->setEnabled(false);
+			bitmaps_[5]->setEnabled(false);
+			texts_[8]->setEnabled(false);
 			JA_StopMusic();
-			section::name = section::NAME_TITLE;
-			section::options = section::OPTIONS_TITLE_1;
+			section::name = section::Name::TITLE;
+			section::options = section::Options::TITLE_1;
 		}
 
 		break;
+	}
 
 	default:
 		break;
@@ -383,21 +374,21 @@ void Intro::updateScenes()
 // Actualiza las variables del objeto
 void Intro::update()
 {
-	if (SDL_GetTicks() - ticks > ticksSpeed)
+	if (SDL_GetTicks() - ticks_ > ticks_speed_)
 	{
 		// Actualiza el contador de ticks
-		ticks = SDL_GetTicks();
+		ticks_ = SDL_GetTicks();
 
 		// Actualiza el objeto screen
-		screen->update();
+		Screen::get()->update();
 
 		// Actualiza los objetos
-		for (auto bitmap : bitmaps)
+		for (auto &bitmap : bitmaps_)
 		{
 			bitmap->update();
 		}
 
-		for (auto text : texts)
+		for (auto &text : texts_)
 		{
 			text->update();
 		}
@@ -411,32 +402,32 @@ void Intro::update()
 void Intro::render()
 {
 	// Prepara para empezar a dibujar en la textura de juego
-	screen->start();
+	Screen::get()->start();
 
 	// Limpia la pantalla
-	screen->clean(bgColor);
+	Screen::get()->clean(bg_color);
 
 	// Dibuja los objetos
-	for (auto bitmap : bitmaps)
+	for (const auto &bitmap : bitmaps_)
 	{
 		bitmap->render();
 	}
 
-	for (auto text : texts)
+	for (const auto &text : texts_)
 	{
 		text->render();
 	}
 
 	// Vuelca el contenido del renderizador en pantalla
-	screen->blit();
+	Screen::get()->blit();
 }
 
 // Bucle principal
 void Intro::run()
 {
-	JA_PlayMusic(music, 0);
+	JA_PlayMusic(music_, 0);
 
-	while (section::name == section::NAME_INTRO)
+	while (section::name == section::Name::INTRO)
 	{
 		checkInput();
 		update();

source/intro.h

@@ -1,16 +1,13 @@
 #pragma once
 
-#include <SDL2/SDL_events.h>  // for SDL_Event
 #include <SDL2/SDL_stdinc.h>  // for Uint32, Uint8
+#include <memory>             // for unique_ptr, shared_ptr
 #include <vector>             // for vector
-class Asset;
-class Input;
-class Screen;
-class SmartSprite;
+#include "smart_sprite.h"     // for SmartSprite
+#include "writer.h"           // for Writer
 class Text;
 class Texture;
-class Writer;
-struct JA_Music_t;
+struct JA_Music_t;  // lines 11-11
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de mostrar la secuencia
@@ -21,21 +18,18 @@ struct JA_Music_t;
 class Intro
 {
 private:
-	// Objetos y punteros
-	Screen *screen;						// Objeto encargado de dibujar en pantalla
-	Texture *texture;					// Textura con los graficos
-	SDL_Event *eventHandler;			// Manejador de eventos
-	Asset *asset;						// Objeto que gestiona todos los ficheros de recursos
-	Input *input;						// Objeto pata gestionar la entrada
-	std::vector<SmartSprite *> bitmaps; // Vector con los sprites inteligentes para los dibujos de la intro
-	std::vector<Writer *> texts;		// Textos de la intro
-	Text *text;							// Textos de la intro
+	// Objetos
+	std::shared_ptr<Texture> texture_; // Textura con los graficos
+	std::shared_ptr<Text> text_;	   // Textos de la intro
+
+	std::vector<std::unique_ptr<SmartSprite>> bitmaps_; // Vector con los sprites inteligentes para los dibujos de la intro
+	std::vector<std::unique_ptr<Writer>> texts_;		// Textos de la intro
 
 	// Variables
-	Uint32 ticks;	   // Contador de ticks para ajustar la velocidad del programa
-	Uint8 ticksSpeed;  // Velocidad a la que se repiten los bucles del programa
-	JA_Music_t *music; // Musica para la intro
-	int scene;		   // Indica que escena está activa
+	Uint32 ticks_;		// Contador de ticks para ajustar la velocidad del programa
+	Uint8 ticks_speed_; // Velocidad a la que se repiten los bucles del programa
+	JA_Music_t *music_; // Musica para la intro
+	int scene_;			// Indica que escena está activa
 
 	// Actualiza las variables del objeto
 	void update();
@@ -57,10 +51,10 @@ private:
 
 public:
 	// Constructor
-	Intro(JA_Music_t *music);
+	explicit Intro(JA_Music_t *music);
 
 	// Destructor
-	~Intro();
+	~Intro() = default;
 
 	// Bucle principal
 	void run();

source/item.cpp

@@ -1,72 +1,64 @@
 #include "item.h"
-#include <stdlib.h>          // for rand
-#include "animated_sprite.h"  // for AnimatedSprite
-#include "param.h"           // for param
+#include <stdlib.h>			 // for rand
+#include "animated_sprite.h" // for AnimatedSprite
+#include "param.h"			 // for param
 class Texture;
 
 // Constructor
-Item::Item(int kind, float x, float y, SDL_Rect *playArea, Texture *texture, std::vector<std::string> *animation)
+Item::Item(int kind, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, std::vector<std::string> *animation)
+	: sprite_(std::make_unique<AnimatedSprite>(texture, "", animation)),
+	  accel_x_(0.0f),
+	  floor_collision_(false),
+	  kind_(kind),
+	  enabled_(true),
+	  play_area_(play_area),
+	  time_to_live_(600)
 {
-	sprite = new AnimatedSprite(texture, "", animation);
-
-	this->kind = kind;
-	this->playArea = playArea;
-	enabled = true;
-	timeToLive = 600;
-	accelX = 0.0f;
-	floorCollision = false;
-
 	if (kind == ITEM_COFFEE_MACHINE)
 	{
-		width = 28;
-		height = 37;
-		posX = (((int)x + (playArea->w / 2)) % (playArea->w - width - 5)) + 2;
-		posY = -height;
-		velX = 0.0f;
-		velY = -0.1f;
-		accelY = 0.1f;
-		collider.r = 10;
+		width_ = 28;
+		height_ = 37;
+		pos_x_ = (((int)x + (play_area->w / 2)) % (play_area->w - width_ - 5)) + 2;
+		pos_y_ = -height_;
+		vel_x_ = 0.0f;
+		vel_y_ = -0.1f;
+		accel_y_ = 0.1f;
+		collider_.r = 10;
 	}
 	else
 	{
-		width = 20;
-		height = 20;
-		posX = x;
-		posY = y;
-		velX = -1.0f + ((rand() % 5) * 0.5f);
-		velY = -4.0f;
-		accelY = 0.2f;
-		collider.r = width / 2;
+		width_ = 20;
+		height_ = 20;
+		pos_x_ = x;
+		pos_y_ = y;
+		vel_x_ = -1.0f + ((rand() % 5) * 0.5f);
+		vel_y_ = -4.0f;
+		accel_y_ = 0.2f;
+		collider_.r = width_ / 2;
 	}
 
-	sprite->setPosX(posX);
-	sprite->setPosY(posY);
+	sprite_->setPosX(pos_x_);
+	sprite_->setPosY(pos_y_);
 	shiftColliders();
 }
 
-// Destructor
-Item::~Item()
-{
-	delete sprite;
-}
-
 // Centra el objeto en la posición X
 void Item::allignTo(int x)
 {
-	posX = float(x - (width / 2));
+	pos_x_ = float(x - (width_ / 2));
 
-	if (posX < param.game.playArea.rect.x)
+	if (pos_x_ < param.game.play_area.rect.x)
 	{
-		posX = param.game.playArea.rect.x + 1;
+		pos_x_ = param.game.play_area.rect.x + 1;
 	}
-	else if ((posX + width) > playArea->w)
+	else if ((pos_x_ + width_) > play_area_->w)
 	{
-		posX = float(playArea->w - width - 1);
+		pos_x_ = float(play_area_->w - width_ - 1);
 	}
 
 	// Posición X,Y del sprite
-	sprite->setPosX(int(posX));
-	sprite->setPosY(int(posY));
+	sprite_->setPosX(int(pos_x_));
+	sprite_->setPosY(int(pos_y_));
 
 	// Alinea el circulo de colisión con el objeto
 	shiftColliders();
@@ -75,15 +67,15 @@ void Item::allignTo(int x)
 // Pinta el objeto en la pantalla
 void Item::render()
 {
-	if (enabled)
+	if (enabled_)
 	{
-		if (timeToLive > 200)
+		if (time_to_live_ > 200)
 		{
-			sprite->render();
+			sprite_->render();
 		}
-		else if (timeToLive % 20 > 10)
+		else if (time_to_live_ % 20 > 10)
 		{
-			sprite->render();
+			sprite_->render();
 		}
 	}
 }
@@ -91,68 +83,68 @@ void Item::render()
 // Actualiza la posición y estados del objeto
 void Item::move()
 {
-	floorCollision = false;
+	floor_collision_ = false;
 
 	// Calcula la nueva posición
-	posX += velX;
-	posY += velY;
+	pos_x_ += vel_x_;
+	pos_y_ += vel_y_;
 
 	// Aplica las aceleraciones a la velocidad
-	velX += accelX;
-	velY += accelY;
+	vel_x_ += accel_x_;
+	vel_y_ += accel_y_;
 
 	// Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido
-	if ((posX < param.game.playArea.rect.x) || (posX + width > playArea->w))
+	if ((pos_x_ < param.game.play_area.rect.x) || (pos_x_ + width_ > play_area_->w))
 	{
 		// Corregir posición
-		posX -= velX;
+		pos_x_ -= vel_x_;
 
 		// Invertir sentido
-		velX = -velX;
+		vel_x_ = -vel_x_;
 	}
 
 	// Si se sale por arriba rebota (excepto la maquina de café)
-	if ((posY < param.game.playArea.rect.y) && !(kind == ITEM_COFFEE_MACHINE))
+	if ((pos_y_ < param.game.play_area.rect.y) && !(kind_ == ITEM_COFFEE_MACHINE))
 	{
 		// Corrige
-		posY = param.game.playArea.rect.y;
+		pos_y_ = param.game.play_area.rect.y;
 
 		// Invierte el sentido
-		velY = -velY;
+		vel_y_ = -vel_y_;
 	}
 
 	// Si el objeto se sale por la parte inferior
-	if (posY + height > playArea->h)
+	if (pos_y_ + height_ > play_area_->h)
 	{
 		// Detiene el objeto
-		velY = 0;
-		velX = 0;
-		accelX = 0;
-		accelY = 0;
-		posY = playArea->h - height;
-		if (kind == ITEM_COFFEE_MACHINE)
+		vel_y_ = 0;
+		vel_x_ = 0;
+		accel_x_ = 0;
+		accel_y_ = 0;
+		pos_y_ = play_area_->h - height_;
+		if (kind_ == ITEM_COFFEE_MACHINE)
 		{
-			floorCollision = true;
+			floor_collision_ = true;
 		}
 	}
 
 	// Actualiza la posición del sprite
-	sprite->setPosX(int(posX));
-	sprite->setPosY(int(posY));
+	sprite_->setPosX(int(pos_x_));
+	sprite_->setPosY(int(pos_y_));
 	shiftColliders();
 }
 
 // Pone a cero todos los valores del objeto
 void Item::disable()
 {
-	enabled = false;
+	enabled_ = false;
 }
 
 // Actualiza el objeto a su posicion, animación y controla los contadores
 void Item::update()
 {
 	move();
-	sprite->animate();
+	sprite_->animate();
 	updateTimeToLive();
 	checkTimeToLive();
 }
@@ -160,70 +152,70 @@ void Item::update()
 // Actualiza el contador
 void Item::updateTimeToLive()
 {
-	if (timeToLive > 0)
+	if (time_to_live_ > 0)
 	{
-		timeToLive--;
+		time_to_live_--;
 	}
 }
 
 // Comprueba si el objeto sigue vivo
 void Item::checkTimeToLive()
 {
-	if (timeToLive == 0)
+	if (time_to_live_ == 0)
 		disable();
 }
 
 // Obtiene del valor de la variable
 float Item::getPosX()
 {
-	return posX;
+	return pos_x_;
 }
 
 // Obtiene del valor de la variable
 float Item::getPosY()
 {
-	return posY;
+	return pos_y_;
 }
 
 // Obtiene del valor de la variable
 int Item::getWidth()
 {
-	return width;
+	return width_;
 }
 
 // Obtiene del valor de la variable
 int Item::getHeight()
 {
-	return height;
+	return height_;
 }
 
 // Obtiene del valor de la variable
 int Item::getClass()
 {
-	return kind;
+	return kind_;
 }
 
 // Obtiene el valor de la variable
 bool Item::isEnabled()
 {
-	return enabled;
+	return enabled_;
 }
 
 // Obtiene el circulo de colisión
-circle_t &Item::getCollider()
+Circle &Item::getCollider()
 {
-	return collider;
+	return collider_;
 }
 
 // Alinea el circulo de colisión con la posición del objeto
 void Item::shiftColliders()
 {
-	collider.x = int(posX + (width / 2));
-	collider.y = int(posY + (height / 2));
+	collider_.x = int(pos_x_ + (width_ / 2));
+	collider_.y = int(pos_y_ + (height_ / 2));
 }
 
 // Informa si el objeto ha colisionado con el suelo
 bool Item::isOnFloor()
 {
-	return floorCollision;
+	return floor_collision_;
 }

source/item.h

@@ -2,42 +2,44 @@
 
 #include <SDL2/SDL_rect.h>    // for SDL_Rect
 #include <SDL2/SDL_stdinc.h>  // for Uint16
+#include <memory>             // for shared_ptr, unique_ptr
 #include <string>             // for string
 #include <vector>             // for vector
-#include "utils.h"            // for circle_t
-class AnimatedSprite;
+#include "animated_sprite.h"  // for AnimatedSprite
+#include "utils.h"            // for Circle
 class Texture;
 
 // Tipos de objetos
-#define ITEM_POINTS_1_DISK 1
-#define ITEM_POINTS_2_GAVINA 2
-#define ITEM_POINTS_3_PACMAR 3
-#define ITEM_CLOCK 4
-#define ITEM_COFFEE 5
-#define ITEM_COFFEE_MACHINE 6
-#define ITEM_NULL 7
+constexpr int ITEM_POINTS_1_DISK = 1;
+constexpr int ITEM_POINTS_2_GAVINA = 2;
+constexpr int ITEM_POINTS_3_PACMAR = 3;
+constexpr int ITEM_CLOCK = 4;
+constexpr int ITEM_COFFEE = 5;
+constexpr int ITEM_COFFEE_MACHINE = 6;
+constexpr int ITEM_NULL = 7;
 
 // Clase Item
 class Item
 {
 private:
     // Objetos y punteros
-    AnimatedSprite *sprite; // Sprite con los graficos del objeto
+    std::unique_ptr<AnimatedSprite> sprite_; // Sprite con los graficos del objeto
 
     // Variables
-    float posX;          // Posición X del objeto
-    float posY;          // Posición Y del objeto
-    int width;           // Ancho del objeto
-    int height;          // Alto del objeto
-    float velX;          // Velocidad en el eje X
-    float velY;          // Velocidad en el eje Y
-    float accelX;        // Aceleración en el eje X
-    float accelY;        // Aceleración en el eje Y
-    bool floorCollision; // Indica si el objeto colisiona con el suelo
-    int kind;            // Especifica el tipo de objeto que es
-    bool enabled;        // Especifica si el objeto está habilitado
-    circle_t collider;   // Circulo de colisión del objeto
-    SDL_Rect *playArea;   // Rectangulo con la zona de juego
+    float pos_x_;          // Posición X del objeto
+    float pos_y_;          // Posición Y del objeto
+    int width_;            // Ancho del objeto
+    int height_;           // Alto del objeto
+    float vel_x_;          // Velocidad en el eje X
+    float vel_y_;          // Velocidad en el eje Y
+    float accel_x_;        // Aceleración en el eje X
+    float accel_y_;        // Aceleración en el eje Y
+    bool floor_collision_; // Indica si el objeto colisiona con el suelo
+    int kind_;             // Especifica el tipo de objeto que es
+    bool enabled_;         // Especifica si el objeto está habilitado
+    Circle collider_;      // Circulo de colisión del objeto
+    SDL_Rect *play_area_;  // Rectangulo con la zona de juego
+    Uint16 time_to_live_;  // Temporizador con el tiempo que el objeto está presente
 
     // Alinea el circulo de colisión con la posición del objeto
     void shiftColliders();
@@ -45,14 +47,18 @@ private:
     // Actualiza la posición y estados del objeto
     void move();
 
-public:
-    Uint16 timeToLive; // Temporizador con el tiempo que el objeto está presente
+    // Actualiza el contador
+    void updateTimeToLive();
 
+    // Comprueba si el objeto sigue vivo
+    void checkTimeToLive();
+
+public:
     // Constructor
-    Item(int kind, float x, float y, SDL_Rect *playArea, Texture *texture, std::vector<std::string> *animation);
+    Item(int kind, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, std::vector<std::string> *animation);
 
     // Destructor
-    ~Item();
+    ~Item() = default;
 
     // Centra el objeto en la posición X
     void allignTo(int x);
@@ -66,12 +72,6 @@ public:
     // Actualiza al objeto a su posicion, animación y controla los contadores
     void update();
 
-    // Actualiza el contador
-    void updateTimeToLive();
-
-    // Comprueba si el objeto sigue vivo
-    void checkTimeToLive();
-
     // Obtiene del valor de la variable
     float getPosX();
 
@@ -91,7 +91,7 @@ public:
     bool isEnabled();
 
     // Obtiene el circulo de colisión
-    circle_t &getCollider();
+    Circle &getCollider();
 
     // Informa si el objeto ha colisionado con el suelo
     bool isOnFloor();

source/lang.cpp

@@ -7,13 +7,13 @@ namespace lang
     std::vector<std::string> texts; // Vector con los textos
     
     // Inicializa los textos del juego en el idioma seleccionado
-    bool loadFromFile(std::string filePath)
+    bool loadFromFile(std::string file_path)
     {
         texts.clear();
 
         bool success = false;
 
-        std::ifstream rfile(filePath);
+        std::ifstream rfile(file_path);
         if (rfile.is_open() && rfile.good())
         {
             success = true;

source/lang.h

@@ -4,7 +4,7 @@
 
 namespace lang
 {
-    enum lang_e
+    enum class Code : int
     {
         es_ES = 0,
         ba_BA = 1,
@@ -12,7 +12,7 @@ namespace lang
     };
 
     // Inicializa los textos del juego en el idioma seleccionado
-    bool loadFromFile(std::string filePath);
+    bool loadFromFile(std::string file_path);
 
     // Obtiene la cadena de texto del indice
     std::string getText(int index);

source/logo.cpp

@@ -1,15 +1,16 @@
 #include "logo.h"
+#include <SDL2/SDL_events.h>  // for SDL_PollEvent, SDL_Event, SDL_QUIT, SDL...
 #include <SDL2/SDL_render.h>  // for SDL_Renderer
 #include <SDL2/SDL_timer.h>   // for SDL_GetTicks
 #include <SDL2/SDL_video.h>   // for SDL_WINDOWEVENT_SIZE_CHANGED
-#include <string>             // for basic_string
+#include <utility>            // for move
 #include "asset.h"            // for Asset
-#include "global_inputs.h"    // for checkGlobalInputs
+#include "global_inputs.h"    // for check
 #include "input.h"            // for Input
 #include "jail_audio.h"       // for JA_StopMusic
 #include "param.h"            // for param
 #include "screen.h"           // for Screen
-#include "section.h"          // for name, name_e, options, options_e
+#include "section.h"          // for Name, name, Options, options
 #include "sprite.h"           // for Sprite
 #include "texture.h"          // for Texture
 
@@ -17,92 +18,70 @@
 Logo::Logo()
 {
 	// Copia la dirección de los objetos
-	input = Input::get();
-	screen = Screen::get();
-	asset = Asset::get();
-	SDL_Renderer *renderer = screen->getRenderer();
+	SDL_Renderer *renderer = Screen::get()->getRenderer();
 
 	// Reserva memoria para los punteros
-	eventHandler = new SDL_Event();
-	jailTexture = new Texture(renderer, asset->get("logo_jailgames.png"));
-	sinceTexture = new Texture(renderer, asset->get("logo_since_1998.png"));
-	sinceSprite = new Sprite((param.game.width - sinceTexture->getWidth()) / 2, 83 + jailTexture->getHeight() + 5, sinceTexture->getWidth(), sinceTexture->getHeight(), sinceTexture);
+	jail_texture_ = std::make_shared<Texture>(renderer, Asset::get()->get("logo_jailgames.png"));
+	since_texture_ = std::make_shared<Texture>(renderer, Asset::get()->get("logo_since_1998.png"));
+	since_sprite_ = std::make_unique<Sprite>((param.game.width - since_texture_->getWidth()) / 2, 83 + jail_texture_->getHeight() + 5, since_texture_->getWidth(), since_texture_->getHeight(), since_texture_);
 
 	// Inicializa variables
-	counter = 0;
-	section::name = section::NAME_LOGO;
-	ticks = 0;
-	ticksSpeed = 15;
-	showSinceSprite_cm = 70;
-	initFade_cm = 300;
-	endLogo_cm = 400;
-	postLogoDuration = 20;
-	speed = 8;
-	dest.x = param.game.gameArea.centerX - jailTexture->getWidth() / 2;
-	dest.y = param.game.gameArea.centerY - jailTexture->getHeight() / 2;
-	sinceSprite->setPosY(dest.y + jailTexture->getHeight() + 5);
-	sinceSprite->setSpriteClip(0, 0, sinceTexture->getWidth(), sinceTexture->getHeight());
-	sinceSprite->setEnabled(false);
-	sinceTexture->setColor(0x00, 0x00, 0x00); // Esto en linux no hace nada ??
+	counter_ = 0;
+	section::name = section::Name::LOGO;
+	ticks_ = 0;
+	dest_.x = param.game.game_area.center_x - jail_texture_->getWidth() / 2;
+	dest_.y = param.game.game_area.center_y - jail_texture_->getHeight() / 2;
+	since_sprite_->setPosY(dest_.y + jail_texture_->getHeight() + 5);
+	since_sprite_->setSpriteClip(0, 0, since_texture_->getWidth(), since_texture_->getHeight());
+	since_texture_->setColor(0x00, 0x00, 0x00); // Esto en linux no hace nada ??
 
 	// Crea los sprites de cada linea
-	for (int i = 0; i < jailTexture->getHeight(); ++i)
+	for (int i = 0; i < jail_texture_->getHeight(); ++i)
 	{
-		Sprite *temp = new Sprite(0, i, jailTexture->getWidth(), 1, jailTexture);
-		temp->setSpriteClip(0, i, jailTexture->getWidth(), 1);
-		const int posX = (i % 2 == 0) ? param.game.width + (i * 3) : -jailTexture->getWidth() - (i * 3);
+		auto temp = std::make_unique<Sprite>(0, i, jail_texture_->getWidth(), 1, jail_texture_);
+		temp->setSpriteClip(0, i, jail_texture_->getWidth(), 1);
+		const int posX = (i % 2 == 0) ? param.game.width + (i * 3) : -jail_texture_->getWidth() - (i * 3);
 		temp->setPosX(posX);
-		temp->setPosY(dest.y + i);
-		jailSprite.push_back(temp);
+		temp->setPosY(dest_.y + i);
+		jail_sprite_.push_back(std::move(temp));
 	}
 
 	// Inicializa el vector de colores
-	color.push_back({0x00, 0x00, 0x00}); // Black
-	color.push_back({0x00, 0x00, 0xd8}); // Blue
-	color.push_back({0xd8, 0x00, 0x00}); // Red
-	color.push_back({0xd8, 0x00, 0xd8}); // Magenta
-	color.push_back({0x00, 0xd8, 0x00}); // Green
-	color.push_back({0x00, 0xd8, 0xd8}); // Cyan
-	color.push_back({0xd8, 0xd8, 0x00}); // Yellow
-	color.push_back({0xFF, 0xFF, 0xFF}); // Bright white
-}
-
-// Destructor
-Logo::~Logo()
-{
-	for (auto sprite : jailSprite)
-	{
-		delete sprite;
-	}
-
-	delete sinceSprite;
-	delete eventHandler;
+	color_.push_back({0x00, 0x00, 0x00}); // Black
+	color_.push_back({0x00, 0x00, 0xd8}); // Blue
+	color_.push_back({0xd8, 0x00, 0x00}); // Red
+	color_.push_back({0xd8, 0x00, 0xd8}); // Magenta
+	color_.push_back({0x00, 0xd8, 0x00}); // Green
+	color_.push_back({0x00, 0xd8, 0xd8}); // Cyan
+	color_.push_back({0xd8, 0xd8, 0x00}); // Yellow
+	color_.push_back({0xFF, 0xFF, 0xFF}); // Bright white
 }
 
 // Recarga todas las texturas
 void Logo::reloadTextures()
 {
-	jailTexture->reLoad();
-	sinceTexture->reLoad();
+	jail_texture_->reLoad();
+	since_texture_->reLoad();
 }
 
 // Comprueba el manejador de eventos
 void Logo::checkEvents()
 {
+	SDL_Event event;
 	// Comprueba los eventos que hay en la cola
-	while (SDL_PollEvent(eventHandler) != 0)
+	while (SDL_PollEvent(&event))
 	{
 		// Evento de salida de la aplicación
-		if (eventHandler->type == SDL_QUIT)
+		if (event.type == SDL_QUIT)
 		{
-			section::name = section::NAME_QUIT;
+			section::name = section::Name::QUIT;
 			break;
 		}
 
 		// Comprueba si se ha cambiado el tamaño de la ventana
-		else if (eventHandler->type == SDL_WINDOWEVENT)
+		else if (event.type == SDL_WINDOWEVENT)
 		{
-			if (eventHandler->window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
+			if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
 			{
 				reloadTextures();
 			}
@@ -114,44 +93,44 @@ void Logo::checkEvents()
 void Logo::checkInput()
 {
 	// Comprueba si se ha pulsado cualquier botón (de los usados para jugar)
-	if (input->checkAnyButtonPressed())
+	if (Input::get()->checkAnyButtonPressed())
 	{
 		JA_StopMusic();
-		section::name = section::NAME_TITLE;
-		section::options = section::OPTIONS_TITLE_1;
+		section::name = section::Name::TITLE;
+		section::options = section::Options::TITLE_1;
 		return;
 	}
 
 	// Comprueba el input para el resto de objetos
-	screen->checkInput();
+	Screen::get()->checkInput();
 
 	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
-	checkGlobalInputs();
+	globalInputs::check();
 }
 
 // Gestiona el logo de JAILGAME
 void Logo::updateJAILGAMES()
 {
-	if (counter > 30)
+	if (counter_ > 30)
 	{
-		for (int i = 0; i < (int)jailSprite.size(); ++i)
+		for (int i = 0; i < (int)jail_sprite_.size(); ++i)
 		{
-			if (jailSprite[i]->getPosX() != dest.x)
+			if (jail_sprite_[i]->getIntPosX() != dest_.x)
 			{
 				if (i % 2 == 0)
 				{
-					jailSprite[i]->incPosX(-speed);
-					if (jailSprite[i]->getPosX() < dest.x)
+					jail_sprite_[i]->incPosX(-SPEED);
+					if (jail_sprite_[i]->getIntPosX() < dest_.x)
 					{
-						jailSprite[i]->setPosX(dest.x);
+						jail_sprite_[i]->setPosX(dest_.x);
 					}
 				}
 				else
 				{
-					jailSprite[i]->incPosX(speed);
-					if (jailSprite[i]->getPosX() > dest.x)
+					jail_sprite_[i]->incPosX(SPEED);
+					if (jail_sprite_[i]->getIntPosX() > dest_.x)
 					{
-						jailSprite[i]->setPosX(dest.x);
+						jail_sprite_[i]->setPosX(dest_.x);
 					}
 				}
 			}
@@ -162,88 +141,25 @@ void Logo::updateJAILGAMES()
 // Gestiona el color de las texturas
 void Logo::updateTextureColors()
 {
-	const int inc = 4;
+	constexpr int inc = 4;
 
-	if (counter <= showSinceSprite_cm + inc * 0)
+	// Manejo de 'sinceTexture'
+	for (int i = 0; i <= 7; ++i)
 	{
-		sinceTexture->setColor(color[0].r, color[0].g, color[0].b);
+		if (counter_ == SHOW_SINCE_SPRITE_COUNTER_MARK + inc * i)
+		{
+			since_texture_->setColor(color_[i].r, color_[i].g, color_[i].b);
+		}
 	}
 
-	else if (counter == showSinceSprite_cm + inc * 1)
+	// Manejo de 'jailTexture' y 'sinceTexture' en el fade
+	for (int i = 0; i <= 6; ++i)
 	{
-		sinceTexture->setColor(color[1].r, color[1].g, color[1].b);
-	}
-
-	else if (counter == showSinceSprite_cm + inc * 2)
-	{
-		sinceTexture->setColor(color[2].r, color[2].g, color[2].b);
-	}
-
-	else if (counter == showSinceSprite_cm + inc * 3)
-	{
-		sinceTexture->setColor(color[3].r, color[3].g, color[3].b);
-	}
-
-	else if (counter == showSinceSprite_cm + inc * 4)
-	{
-		sinceTexture->setColor(color[4].r, color[4].g, color[4].b);
-	}
-
-	else if (counter == showSinceSprite_cm + inc * 5)
-	{
-		sinceTexture->setColor(color[5].r, color[5].g, color[5].b);
-	}
-
-	else if (counter == showSinceSprite_cm + inc * 6)
-	{
-		sinceTexture->setColor(color[6].r, color[6].g, color[6].b);
-	}
-
-	else if (counter == showSinceSprite_cm + inc * 7)
-	{
-		sinceTexture->setColor(color[7].r, color[7].g, color[7].b);
-	}
-
-	else if (counter == initFade_cm + inc * 0)
-	{
-		jailTexture->setColor(color[6].r, color[6].g, color[6].b);
-		sinceTexture->setColor(color[6].r, color[6].g, color[6].b);
-	}
-
-	else if (counter == initFade_cm + inc * 1)
-	{
-		jailTexture->setColor(color[5].r, color[5].g, color[5].b);
-		sinceTexture->setColor(color[5].r, color[5].g, color[5].b);
-	}
-
-	else if (counter == initFade_cm + inc * 2)
-	{
-		jailTexture->setColor(color[4].r, color[4].g, color[4].b);
-		sinceTexture->setColor(color[4].r, color[4].g, color[4].b);
-	}
-
-	else if (counter == initFade_cm + inc * 3)
-	{
-		jailTexture->setColor(color[3].r, color[3].g, color[3].b);
-		sinceTexture->setColor(color[3].r, color[3].g, color[3].b);
-	}
-
-	else if (counter == initFade_cm + inc * 4)
-	{
-		jailTexture->setColor(color[2].r, color[2].g, color[2].b);
-		sinceTexture->setColor(color[2].r, color[2].g, color[2].b);
-	}
-
-	else if (counter == initFade_cm + inc * 5)
-	{
-		jailTexture->setColor(color[1].r, color[1].g, color[1].b);
-		sinceTexture->setColor(color[1].r, color[1].g, color[1].b);
-	}
-
-	else if (counter == initFade_cm + inc * 6)
-	{
-		jailTexture->setColor(color[0].r, color[0].g, color[0].b);
-		sinceTexture->setColor(color[0].r, color[0].g, color[0].b);
+		if (counter_ == INIT_FADE_COUNTER_MARK + inc * i)
+		{
+			jail_texture_->setColor(color_[6 - i].r, color_[6 - i].g, color_[6 - i].b);
+			since_texture_->setColor(color_[6 - i].r, color_[6 - i].g, color_[6 - i].b);
+		}
 	}
 }
 
@@ -251,13 +167,13 @@ void Logo::updateTextureColors()
 void Logo::update()
 {
 	// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
-	if (SDL_GetTicks() - ticks > ticksSpeed)
+	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		// Actualiza el contador de ticks
-		ticks = SDL_GetTicks();
+		ticks_ = SDL_GetTicks();
 
 		// Actualiza el objeto screen
-		screen->update();
+		Screen::get()->update();
 
 		// Comprueba las entradas
 		checkInput();
@@ -269,18 +185,12 @@ void Logo::update()
 		updateTextureColors();
 
 		// Gestiona el contador y sus eventos
-		counter++;
+		counter_++;
 
 		// Comprueba si ha terminado el logo
-		if (counter == endLogo_cm + postLogoDuration)
+		if (counter_ == END_LOGO_COUNTER_MARK + POST_LOGO_DURATION)
 		{
-			section::name = section::NAME_INTRO;
-		}
-
-		// Comprueba si se ha de mostrar el sprite
-		else if (counter == showSinceSprite_cm)
-		{
-			sinceSprite->setEnabled(true);
+			section::name = section::Name::INTRO;
 		}
 	}
 }
@@ -289,20 +199,24 @@ void Logo::update()
 void Logo::render()
 {
 	// Prepara para empezar a dibujar en la textura de juego
-	screen->start();
+	Screen::get()->start();
 
 	// Limpia la pantalla
-	screen->clean();
+	Screen::get()->clean();
 
 	// Dibuja los sprites
-	for (auto sprite : jailSprite)
+	for (auto &sprite : jail_sprite_)
 	{
 		sprite->render();
 	}
-	sinceSprite->render();
+
+	if (counter_ >= SHOW_SINCE_SPRITE_COUNTER_MARK)
+	{
+		since_sprite_->render();
+	}
 
 	// Vuelca el contenido del renderizador en pantalla
-	screen->blit();
+	Screen::get()->blit();
 }
 
 // Bucle para el logo del juego
@@ -311,7 +225,7 @@ void Logo::run()
 	// Detiene la música
 	JA_StopMusic();
 
-	while (section::name == section::NAME_LOGO)
+	while (section::name == section::Name::LOGO)
 	{
 		checkInput();
 		update();

source/logo.h

@@ -1,14 +1,11 @@
 #pragma once
 
-#include <SDL2/SDL_events.h>  // for SDL_Event
 #include <SDL2/SDL_rect.h>    // for SDL_Point
 #include <SDL2/SDL_stdinc.h>  // for Uint32
+#include <memory>             // for unique_ptr, shared_ptr
 #include <vector>             // for vector
-#include "utils.h"            // for color_t
-class Asset;
-class Input;
-class Screen;
-class Sprite;
+#include "sprite.h"           // for Sprite
+#include "utils.h"            // for Color
 class Texture;
 
 /*
@@ -23,27 +20,25 @@ class Texture;
 class Logo
 {
 private:
+	// Constantes
+	static constexpr Uint32 TICKS_SPEED = 15;				  // Velocidad a la que se repiten los bucles del programa
+	static constexpr int SHOW_SINCE_SPRITE_COUNTER_MARK = 70; // Tiempo del contador en el que empieza a verse el sprite de "SINCE 1998"
+	static constexpr int INIT_FADE_COUNTER_MARK = 300;		  // Tiempo del contador cuando inicia el fade a negro
+	static constexpr int END_LOGO_COUNTER_MARK = 400;		  // Tiempo del contador para terminar el logo
+	static constexpr int POST_LOGO_DURATION = 20;			  // Tiempo que dura el logo con el fade al maximo
+	static constexpr int SPEED = 8;							  // Velocidad de desplazamiento de cada linea
+	
 	// Objetos y punteros
-	Screen *screen;					  // Objeto encargado de dibujar en pantalla
-	Asset *asset;					  // Objeto con los ficheros de recursos
-	Input *input;					  // Objeto pata gestionar la entrada
-	Texture *jailTexture;			  // Textura con los graficos "JAILGAMES"
-	Texture *sinceTexture;			  // Textura con los graficos "Since 1998"
-	SDL_Event *eventHandler;		  // Manejador de eventos
-	std::vector<Sprite *> jailSprite; // Vector con los sprites de cada linea que forman el bitmap JAILGAMES
-	Sprite *sinceSprite;			  // Sprite para manejar la sinceTexture
+	std::shared_ptr<Texture> since_texture_;		   // Textura con los graficos "Since 1998"
+	std::unique_ptr<Sprite> since_sprite_;			   // Sprite para manejar la sinceTexture
+	std::shared_ptr<Texture> jail_texture_;			   // Textura con los graficos "JAILGAMES"
+	std::vector<std::unique_ptr<Sprite>> jail_sprite_; // Vector con los sprites de cada linea que forman el bitmap JAILGAMES
 
 	// Variables
-	std::vector<color_t> color; // Vector con los colores para el fade
-	int counter;				// Contador
-	Uint32 ticks;				// Contador de ticks para ajustar la velocidad del programa
-	Uint32 ticksSpeed;			// Velocidad a la que se repiten los bucles del programa
-	int showSinceSprite_cm;		// Tiempo del contador en el que empieza a verse el sprite de "SINCE 1998"
-	int initFade_cm;			// Tiempo del contador cuando inicia el fade a negro
-	int endLogo_cm;				// Tiempo del contador para terminar el logo
-	int postLogoDuration;		// Tiempo que dura el logo con el fade al maximo
-	int speed;					// Velocidad de desplazamiento de cada linea
-	SDL_Point dest;				// Posición X donde dibujar el logo
+	std::vector<Color> color_; // Vector con los colores para el fade
+	int counter_;			   // Contador
+	Uint32 ticks_;			   // Contador de ticks para ajustar la velocidad del programa
+	SDL_Point dest_;		   // Posición X donde dibujar el logo
 
 	// Actualiza las variables
 	void update();
@@ -71,7 +66,7 @@ public:
 	Logo();
 
 	// Destructor
-	~Logo();
+	~Logo() = default;
 
 	// Bucle principal
 	void run();

source/main.cpp

@@ -7,25 +7,22 @@ Actualizando a la versión "Arcade Edition" en 08/05/2024
 
 */
 
-#include <iostream>    // for basic_ostream, char_traits, operator<<, cout
-#include <string>      // for basic_string, operator<<, string
+#include <iostream>    // for char_traits, basic_ostream, operator<<, cout
+#include <memory>      // for make_unique, unique_ptr
 #include "director.h"  // for Director
 
 int main(int argc, char *argv[])
 {
-	std::cout << "Game start" << std::endl;
+    std::cout << "Game start" << std::endl;
 
-	// Crea el objeto Director
-	Director *director = new Director(argc, argv);
+    // Crea el objeto Director
+    auto director = std::make_unique<Director>(argc, const_cast<const char **>(argv));
 
-	// Bucle principal
-	const int exit = director->run();
+    // Bucle principal
+    const auto exit = director->run();
 
-	// Destruye el objeto Director
-	delete director;
+    const auto endType = exit == 0 ? "keyboard" : "controller";
+    std::cout << "\nGame end with " << endType << std::endl;
 
-	const std::string endType = exit == 0 ? "keyboard" : "controller";
-	std::cout << "\nGame end with " << endType << std::endl;
-
-	return exit;
+    return exit;
 }

source/manage_hiscore_table.cpp

@@ -1,54 +1,47 @@
 #include "manage_hiscore_table.h"
-#include <SDL2/SDL_error.h>  // for SDL_GetError
-#include <SDL2/SDL_rwops.h>  // for SDL_RWread, SDL_RWwrite, SDL_RWFromFile
-#include <stdlib.h>          // for free, malloc
-#include <algorithm>         // for sort
-#include <iostream>          // for basic_ostream, char_traits, operator<<
-#include "utils.h"           // for hiScoreEntry_t
+#include <SDL2/SDL_error.h> // for SDL_GetError
+#include <SDL2/SDL_rwops.h> // for SDL_RWread, SDL_RWwrite, SDL_RWFromFile
+#include <stdlib.h>         // for free, malloc
+#include <algorithm>        // for sort
+#include <iostream>         // for basic_ostream, char_traits, operator<<
+#include "utils.h"          // for HiScoreEntry
 
 // Constructor
-ManageHiScoreTable::ManageHiScoreTable(std::vector<hiScoreEntry_t> *table)
-{
-    this->table = table;
-}
-
-// Destructor
-ManageHiScoreTable::~ManageHiScoreTable()
-{
-}
+ManageHiScoreTable::ManageHiScoreTable(std::vector<HiScoreEntry> *table)
+    : table_(table) {}
 
 // Resetea la tabla a los valores por defecto
 void ManageHiScoreTable::clear()
 {
     // Limpia la tabla
-    table->clear();
+    table_->clear();
 
     // Añade 10 entradas predefinidas
-    table->push_back({"Bry", 1000000});
-    table->push_back({"Usufondo", 500000});
-    table->push_back({"G.Lucas", 100000});
-    table->push_back({"P.Delgat", 50000});
-    table->push_back({"P.Arrabalera", 10000});
-    table->push_back({"Pelechano", 5000});
-    table->push_back({"Sahuquillo", 1000});
-    table->push_back({"Bacteriol", 500});
-    table->push_back({"Pepe", 200});
-    table->push_back({"Rosita", 100});
+    table_->push_back({"Bry", 1000000});
+    table_->push_back({"Usufondo", 500000});
+    table_->push_back({"G.Lucas", 100000});
+    table_->push_back({"P.Delgat", 50000});
+    table_->push_back({"P.Arrabalera", 10000});
+    table_->push_back({"Pelechano", 5000});
+    table_->push_back({"Sahuquillo", 1000});
+    table_->push_back({"Bacteriol", 500});
+    table_->push_back({"Pepe", 200});
+    table_->push_back({"Rosita", 100});
 }
 
 // Añade un elemento a la tabla
-void ManageHiScoreTable::add(hiScoreEntry_t entry)
+void ManageHiScoreTable::add(HiScoreEntry entry)
 {
     // Añade la entrada a la tabla
-    table->push_back(entry);
+    table_->push_back(entry);
 
     // Ordena la tabla
     sort();
 
     // Deja solo las 10 primeras entradas
-    if ((int)table->size() > 10)
+    if (static_cast<int>(table_->size()) > 10)
     {
-        table->resize(10);
+        table_->resize(10);
     }
 }
 
@@ -57,31 +50,31 @@ void ManageHiScoreTable::sort()
 {
     struct
     {
-        bool operator()(hiScoreEntry_t a, hiScoreEntry_t b) const { return a.score > b.score; }
-    } customLess;
+        bool operator()(const HiScoreEntry &a, const HiScoreEntry &b) const { return a.score > b.score; }
+    } custom_less;
 
-    std::sort(table->begin(), table->end(), customLess);
+    std::sort(table_->begin(), table_->end(), custom_less);
 }
 
 // Carga la tabla con los datos de un fichero
-bool ManageHiScoreTable::loadFromFile(std::string filePath)
+bool ManageHiScoreTable::loadFromFile(const std::string &file_path)
 {
     clear();
-    
-    bool success = true;
-    const std::string filename = filePath.substr(filePath.find_last_of("\\/") + 1);
-    SDL_RWops *file = SDL_RWFromFile(filePath.c_str(), "r+b");
+
+    auto success = true;
+    auto file = SDL_RWFromFile(file_path.c_str(), "r+b");
 
     if (file)
     {
-#ifdef DEBUG
-        std::cout << "Reading file: " << filename.c_str() << std::endl;
+#ifdef VERBOSE
+        const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
+        std::cout << "Reading file: " << file_name.c_str() << std::endl;
 #endif
-        for (int i = 0; i < (int)table->size(); ++i)
+        for (int i = 0; i < (int)table_->size(); ++i)
         {
             int nameSize = 0;
 
-            if (SDL_RWread(file, &table->at(i).score, sizeof(int), 1) == 0)
+            if (SDL_RWread(file, &table_->at(i).score, sizeof(int), 1) == 0)
             {
                 success = false;
                 break;
@@ -93,7 +86,7 @@ bool ManageHiScoreTable::loadFromFile(std::string filePath)
                 break;
             }
 
-            char *name = (char *)malloc(nameSize + 1);
+            char *name = static_cast<char *>(malloc(nameSize + 1));
             if (SDL_RWread(file, name, sizeof(char) * nameSize, 1) == 0)
             {
                 success = false;
@@ -103,7 +96,7 @@ bool ManageHiScoreTable::loadFromFile(std::string filePath)
             else
             {
                 name[nameSize] = 0;
-                table->at(i).name = name;
+                table_->at(i).name = name;
                 free(name);
             }
         }
@@ -120,33 +113,35 @@ bool ManageHiScoreTable::loadFromFile(std::string filePath)
 }
 
 // Guarda la tabla en un fichero
-bool ManageHiScoreTable::saveToFile(std::string filePath)
+bool ManageHiScoreTable::saveToFile(const std::string &file_path)
 {
-    bool success = true;
-    const std::string fileName = filePath.substr(filePath.find_last_of("\\/") + 1);
-    SDL_RWops *file = SDL_RWFromFile(filePath.c_str(), "w+b");
+#ifdef VERBOSE
+    const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
+#endif
+    auto success = true;
+    auto file = SDL_RWFromFile(file_path.c_str(), "w+b");
 
     if (file)
     {
         // Guarda los datos
-        for (int i = 0; i < (int)table->size(); ++i)
+        for (int i = 0; i < (int)table_->size(); ++i)
         {
-            SDL_RWwrite(file, &table->at(i).score, sizeof(int), 1);
-            const int nameSize = (int)table->at(i).name.size();
+            SDL_RWwrite(file, &table_->at(i).score, sizeof(int), 1);
+            const int nameSize = (int)table_->at(i).name.size();
             SDL_RWwrite(file, &nameSize, sizeof(int), 1);
-            SDL_RWwrite(file, table->at(i).name.c_str(), nameSize, 1);
+            SDL_RWwrite(file, table_->at(i).name.c_str(), nameSize, 1);
         }
 
-#ifdef DEBUG
-        std::cout << "Writing file: " << fileName.c_str() << std::endl;
+#ifdef VERBOSE
+        std::cout << "Writing file: " << file_name.c_str() << std::endl;
 #endif
         // Cierra el fichero
         SDL_RWclose(file);
     }
     else
     {
-#ifdef DEBUG
-        std::cout << "Error: Unable to save " << fileName.c_str() << " file! " << SDL_GetError() << std::endl;
+#ifdef VERBOSE
+        std::cout << "Error: Unable to save " << file_name.c_str() << " file! " << SDL_GetError() << std::endl;
 #endif
     }
     return success;

source/manage_hiscore_table.h

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <string>  // for string
-#include <vector>  // for vector
-struct hiScoreEntry_t;
+#include <string> // for string
+#include <vector> // for vector
+struct HiScoreEntry;
 
 /*
     Esta clase sirve para añadir elementos hiScoreEntry_r a un vector (tabla), de manera
     que la tabla siempre está ordenada.
-    
+
     Además tiene un método para dejar la tabla con sus valores iniciales y métodos para
     leer y escribir la tabla a un fichero
 */
@@ -17,27 +17,27 @@ class ManageHiScoreTable
 {
 private:
     // Variables
-    std::vector<hiScoreEntry_t> *table; // Tabla con los records
+    std::vector<HiScoreEntry> *table_; // Tabla con los records
 
     // Ordena la tabla
     void sort();
 
 public:
     // Constructor
-    ManageHiScoreTable(std::vector<hiScoreEntry_t> *table);
+    explicit ManageHiScoreTable(std::vector<HiScoreEntry> *table);
 
     // Destructor
-    ~ManageHiScoreTable();
+    ~ManageHiScoreTable() = default;
 
     // Resetea la tabla a los valores por defecto
     void clear();
 
     // Añade un elemento a la tabla
-    void add(hiScoreEntry_t entry);
+    void add(HiScoreEntry entry);
 
     // Carga la tabla con los datos de un fichero
-    bool loadFromFile(std::string filePath);
+    bool loadFromFile(const std::string &file_path);
 
     // Guarda la tabla en un fichero
-    bool saveToFile(std::string filePath);
+    bool saveToFile(const std::string &file_path);
 };

source/moving_sprite.cpp

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

source/moving_sprite.h

@@ -3,6 +3,7 @@
 #include <SDL2/SDL_rect.h>    // for SDL_Rect, SDL_Point
 #include <SDL2/SDL_render.h>  // for SDL_RendererFlip
 #include <SDL2/SDL_stdinc.h>  // for Uint16
+#include <memory>             // for shared_ptr
 #include "sprite.h"           // for Sprite
 class Texture;
 
@@ -10,32 +11,38 @@ class Texture;
 class MovingSprite : public Sprite
 {
 protected:
-    float x; // Posición en el eje X
-    float y; // Posición en el eje Y
+    struct Rotate
+    {
+        bool enabled;      // Indica si ha de rotar
+        int speed;         // Velocidad de giro
+        float angle;      // Angulo para dibujarlo
+        float amount;     // Cantidad de grados a girar en cada iteración
+        SDL_Point *center; // Centro de rotación
+    };
 
-    float xPrev; // Posición anterior en el eje X
-    float yPrev; // Posición anterior en el eje Y
+    float x_; // Posición en el eje X
+    float y_; // Posición en el eje Y
 
-    float vx; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
-    float vy; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
+    float vx_; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
+    float vy_; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
 
-    float ax; // Aceleración en el eje X. Variación de la velocidad
-    float ay; // Aceleración en el eje Y. Variación de la velocidad
+    float ax_; // Aceleración en el eje X. Variación de la velocidad
+    float ay_; // Aceleración en el eje Y. Variación de la velocidad
 
-    float zoomW; // Zoom aplicado a la anchura
-    float zoomH; // Zoom aplicado a la altura
+    float zoom_w_; // Zoom aplicado a la anchura
+    float zoom_h_; // Zoom aplicado a la altura
 
-    double angle;                 // Angulo para dibujarlo
-    bool rotateEnabled;           // Indica si ha de rotar
-    int rotateSpeed;              // Velocidad de giro
-    double rotateAmount;          // Cantidad de grados a girar en cada iteración
-    int counter;                  // Contador interno
-    SDL_Point *center;            // Centro de rotación
-    SDL_RendererFlip currentFlip; // Indica como se voltea el sprite
+    int counter_;           // Contador interno
+    Rotate rotate_;         // Variables usada para controlar la rotación del sprite
+    SDL_RendererFlip flip_; // Indica como se voltea el sprite
 
 public:
     // Constructor
-    MovingSprite(float x = 0, float y = 0, int w = 0, int h = 0, float velx = 0, float vely = 0, float accelx = 0, float accely = 0, Texture *texture = nullptr);
+    explicit MovingSprite(float x = 0, float y = 0, int w = 0, int h = 0, float velx = 0, float vely = 0, float accelx = 0, float accely = 0, std::shared_ptr<Texture> texture = nullptr);
+    explicit MovingSprite(std::shared_ptr<Texture> texture = nullptr);
+
+    // Destructor
+    virtual ~MovingSprite() = default;
 
     // Mueve el sprite
     void move();
@@ -44,93 +51,66 @@ public:
     void rotate();
 
     // Actualiza las variables internas del objeto
-    void update();
+    virtual void update();
 
     // Reinicia todas las variables
     void clear();
 
     // Muestra el sprite por pantalla
-    void render();
+    void render() override;
 
     // Obten el valor de la variable
-    float getPosX();
+    float getPosX() const;
+    float getPosY() const;
 
     // Obten el valor de la variable
-    float getPosY();
+    float getVelX() const;
+    float getVelY() const;
 
     // Obten el valor de la variable
-    float getVelX();
+    float getAccelX() const;
+    float getAccelY() const;
 
     // Obten el valor de la variable
-    float getVelY();
+    float getZoomW() const;
+    float getZoomH() const;
 
     // Obten el valor de la variable
-    float getAccelX();
+    float getAngle() const;
+    bool getRotate() const;
+    Uint16 getRotateSpeed() const;
 
-    // Obten el valor de la variable
-    float getAccelY();
-
-    // Obten el valor de la variable
-    float getZoomW();
-
-    // Obten el valor de la variable
-    float getZoomH();
-
-    // Obten el valor de la variable
-    double getAngle();
-
-    // Obtiene el valor de la variable
-    bool getRotate();
-
-    // Obtiene el valor de la variable
-    Uint16 getRotateSpeed();
-
-    // Establece la posición y el tamaño del objeto
-    void setRect(SDL_Rect rect);
-
-    // Establece el valor de las variables
+    // Establece la posición del objeto
+    void setPos(SDL_Rect rect) override;
     void setPos(float x, float y);
 
+    // Devuelve el rectangulo donde está el sprite
+    SDL_Rect getPos() const override;
+
     // Establece el valor de la variable
     void setPosX(float value);
-
-    // Establece el valor de la variable
     void setPosY(float value);
 
     // Establece el valor de la variable
     void setVelX(float value);
-
-    // Establece el valor de la variable
     void setVelY(float value);
 
     // Establece el valor de la variable
     void setAccelX(float value);
-
-    // Establece el valor de la variable
     void setAccelY(float value);
 
     // Establece el valor de la variable
     void setZoomW(float value);
-
-    // Establece el valor de la variable
     void setZoomH(float value);
 
     // Establece el valor de la variable
     void setAngle(double vaue);
-
-    // Incrementa el valor de la variable
     void incAngle(double value);
-
-    // Decrementa el valor de la variable
     void decAngle(double value);
 
     // Establece el valor de la variable
     void setRotate(bool value);
-
-    // Establece el valor de la variable
     void setRotateSpeed(int value);
-
-    // Establece el valor de la variable
     void setRotateAmount(double value);
 
     // Quita el efecto de rotación y deja el sprite en su angulo inicial.
@@ -148,21 +128,5 @@ public:
     // Obtiene el valor de la variable
     SDL_RendererFlip getFlip();
 
-    // Devuelve el rectangulo donde está el sprite
-    SDL_Rect getRect();
 
-    // Deshace el último movimiento
-    void undoMove();
-
-    // Deshace el último movimiento en el eje X
-    void undoMoveX();
-
-    // Deshace el último movimiento en el eje Y
-    void undoMoveY();
-
-    // Pone a cero las velocidades de desplacamiento
-    void clearVel();
-
-    // Devuelve el incremento en el eje X en pixels
-    int getIncX();
 };

source/notify.cpp

@@ -1,56 +1,36 @@
 #include "notify.h"
 #include <SDL2/SDL_blendmode.h>  // for SDL_BLENDMODE_BLEND
 #include <SDL2/SDL_pixels.h>     // for SDL_PIXELFORMAT_RGBA8888
-#include <string>                // for basic_string, char_traits, string
+#include <string>                // for string
 #include "jail_audio.h"          // for JA_DeleteSound, JA_LoadSound, JA_Pla...
-#include "options.h"             // for options
+#include "param.h"               // for param
 #include "sprite.h"              // for Sprite
 #include "text.h"                // for Text
 #include "texture.h"             // for Texture
 
 // Constructor
-Notify::Notify(SDL_Renderer *renderer, std::string iconFile, std::string bitmapFile, std::string textFile, std::string soundFile)
+Notify::Notify(SDL_Renderer *renderer, std::string iconFile, std::string bitmapFile, std::string textFile, const std::string &soundFile)
+    : renderer(renderer),
+      text(std::make_unique<Text>(bitmapFile, textFile, renderer)),
+      bgColor(param.notification.color),
+      waitTime(150),
+      stack(false),
+      sound(JA_LoadSound(soundFile.c_str()))
 {
     // Inicializa variables
-    this->renderer = renderer;
-    bgColor = options.notification.color;
-    waitTime = 150;
-    stack = false;
-    hasIcons = iconFile == "" ? false : true;
-    iconTexture = nullptr;
-    textTexture = nullptr;
-    text = nullptr;
+    hasIcons = !iconFile.empty();
 
     // Crea objetos
-    if (hasIcons)
-    {
-        iconTexture = new Texture(renderer, iconFile);
-    }
-    textTexture = new Texture(renderer, bitmapFile);
-    text = new Text(textFile, textTexture, renderer);
-    sound = JA_LoadSound(soundFile.c_str());
+    iconTexture = hasIcons ? std::make_unique<Texture>(renderer, iconFile) : nullptr;
 }
 
 // Destructor
 Notify::~Notify()
 {
     // Libera la memoria de los objetos
-    if (textTexture)
-        delete textTexture;
-    
-    if (iconTexture)
-        delete iconTexture;
-    
-    if (text)
-        delete text;
-    
     JA_DeleteSound(sound);
 
-    for (auto notification : notifications)
-    {
-        delete notification.sprite;
-        delete notification.texture;
-    }
+    notifications.clear();
 }
 
 // Dibuja las notificaciones por pantalla
@@ -70,7 +50,7 @@ void Notify::update()
         // Si la notificación anterior está "saliendo", no hagas nada
         if (i > 0)
         {
-            if (notifications[i - 1].state == ns_rising)
+            if (notifications[i - 1].status == NotificationStatus::RISING)
             {
                 break;
             }
@@ -81,9 +61,9 @@ void Notify::update()
         // Hace sonar la notificación en el primer frame
         if (notifications[i].counter == 1)
         {
-            if (options.notification.sound)
+            if (param.notification.sound)
             {
-                if (notifications[i].state == ns_rising)
+                if (notifications[i].status == NotificationStatus::RISING)
                 { // Reproduce el sonido de la notificación
                     JA_PlaySound(sound);
                 }
@@ -91,12 +71,12 @@ void Notify::update()
         }
 
         // Comprueba los estados
-        if (notifications[i].state == ns_rising)
+        if (notifications[i].status == NotificationStatus::RISING)
         {
             const float step = ((float)notifications[i].counter / notifications[i].travelDist);
             const int alpha = 255 * step;
 
-            if (options.notification.posV == pos_top)
+            if (param.notification.pos_v == NotifyPosition::TOP)
             {
                 notifications[i].rect.y++;
             }
@@ -108,27 +88,27 @@ void Notify::update()
 
             if (notifications[i].rect.y == notifications[i].y)
             {
-                notifications[i].state = ns_stay;
+                notifications[i].status = NotificationStatus::STAY;
                 notifications[i].texture->setAlpha(255);
                 notifications[i].counter = 0;
             }
         }
 
-        else if (notifications[i].state == ns_stay)
+        else if (notifications[i].status == NotificationStatus::STAY)
         {
             if (notifications[i].counter == waitTime)
             {
-                notifications[i].state = ns_vanishing;
+                notifications[i].status = NotificationStatus::VANISHING;
                 notifications[i].counter = 0;
             }
         }
-        else if (notifications[i].state == ns_vanishing)
+        else if (notifications[i].status == NotificationStatus::VANISHING)
         {
 
             const float step = (notifications[i].counter / (float)notifications[i].travelDist);
             const int alpha = 255 * (1 - step);
 
-            if (options.notification.posV == pos_top)
+            if (param.notification.pos_v == NotifyPosition::TOP)
             {
                 notifications[i].rect.y--;
             }
@@ -140,11 +120,11 @@ void Notify::update()
 
             if (notifications[i].rect.y == notifications[i].y - notifications[i].travelDist)
             {
-                notifications[i].state = ns_finished;
+                notifications[i].status = NotificationStatus::FINISHED;
             }
         }
 
-        notifications[i].sprite->setRect(notifications[i].rect);
+        notifications[i].sprite->setPos(notifications[i].rect);
     }
 
     clearFinishedNotifications();
@@ -155,10 +135,8 @@ void Notify::clearFinishedNotifications()
 {
     for (int i = (int)notifications.size() - 1; i >= 0; --i)
     {
-        if (notifications[i].state == ns_finished)
+        if (notifications[i].status == NotificationStatus::FINISHED)
         {
-            delete notifications[i].sprite;
-            delete notifications[i].texture;
             notifications.erase(notifications.begin() + i);
         }
     }
@@ -168,22 +146,19 @@ void Notify::clearFinishedNotifications()
 void Notify::showText(std::string text1, std::string text2, int icon)
 {
     // Cuenta el número de textos a mostrar
-    int numTexts = 0;
-    if (text1 != "")
-        numTexts++;
-    if (text2 != "")
-        numTexts++;
+    const int numTexts = !text1.empty() + !text2.empty();
 
     // Si no hay texto, acaba
     if (numTexts == 0)
     {
         return;
     }
+    
     // Si solo hay un texto, lo coloca en la primera variable
-    else if (numTexts == 1)
+    if (numTexts == 1)
     {
-        text1 = text1 + text2;
-        text2 = "";
+        text1 += text2;
+        text2.clear();
     }
 
     // Si las notificaciones no se apilan, elimina las anteriores
@@ -193,46 +168,37 @@ void Notify::showText(std::string text1, std::string text2, int icon)
     }
 
     // Inicializa variables
-    const int iconSize = 16;
-    const int paddingOut = 1;
-    const int paddingIn = text->getCharacterSize() / 2;
-    const int iconSpace = icon >= 0 ? iconSize + paddingIn : 0;
+    constexpr auto iconSize = 16;
+    constexpr auto paddingOut = 1;
+    const auto paddingIn = text->getCharacterSize() / 2;
+    const auto iconSpace = icon >= 0 ? iconSize + paddingIn : 0;
     const std::string txt = text1.length() > text2.length() ? text1 : text2;
-    const int width = text->lenght(txt) + (paddingIn * 2) + iconSpace;
-    const int height = (text->getCharacterSize() * numTexts) + (paddingIn * 2);
-    const notification_shape_t shape = notification_shape_squared;
+    const auto width = text->lenght(txt) + (paddingIn * 2) + iconSpace;
+    const auto height = (text->getCharacterSize() * numTexts) + (paddingIn * 2);
+    const auto shape = NotificationShape::SQUARED;
 
     // Posición horizontal
-    int despH = 0;
-    if (options.notification.posH == pos_left)
+    auto despH = 0;
+    if (param.notification.pos_h == NotifyPosition::LEFT)
     {
         despH = paddingOut;
     }
-    else if (options.notification.posH == pos_middle)
+    else if (param.notification.pos_h == NotifyPosition::MIDDLE)
     {
-        despH = ((options.video.gameWidth / 2) - (width / 2));
+        despH = ((param.game.width / 2) - (width / 2));
     }
     else
     {
-        despH = options.video.gameWidth - width - paddingOut;
+        despH = param.game.width - width - paddingOut;
     }
 
     // Posición vertical
-    int despV = 0;
-    if (options.notification.posV == pos_top)
-    {
-        despV = paddingOut;
-    }
-    else
-    {
-        despV = options.video.gameHeight - height - paddingOut;
-    }
-
-    const int travelDist = height + paddingOut;
+    const int despV = (param.notification.pos_v == NotifyPosition::TOP) ? paddingOut : (param.game.height - height - paddingOut);
 
     // Offset
-    int offset = 0;
-    if (options.notification.posV == pos_top)
+    const auto travelDist = height + paddingOut;
+    auto offset = 0;
+    if (param.notification.pos_v == NotifyPosition::TOP)
     {
         offset = (int)notifications.size() > 0 ? notifications.back().y + travelDist : despV;
     }
@@ -242,27 +208,21 @@ void Notify::showText(std::string text1, std::string text2, int icon)
     }
 
     // Crea la notificacion
-    notification_t n;
+    Notification n;
 
     // Inicializa variables
     n.y = offset;
     n.travelDist = travelDist;
     n.counter = 0;
-    n.state = ns_rising;
+    n.status = NotificationStatus::RISING;
     n.text1 = text1;
     n.text2 = text2;
     n.shape = shape;
-    if (options.notification.posV == pos_top)
-    {
-        n.rect = {despH, offset - travelDist, width, height};
-    }
-    else
-    {
-        n.rect = {despH, offset + travelDist, width, height};
-    }
+    auto yPos = offset + (param.notification.pos_v == NotifyPosition::TOP ? -travelDist : travelDist);
+    n.rect = {despH, yPos, width, height};
 
     // Crea la textura
-    n.texture = new Texture(renderer);
+    n.texture = std::make_shared<Texture>(renderer);
     n.texture->createBlank(width, height, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
     n.texture->setBlendMode(SDL_BLENDMODE_BLEND);
 
@@ -272,7 +232,7 @@ void Notify::showText(std::string text1, std::string text2, int icon)
     // Dibuja el fondo de la notificación
     SDL_SetRenderDrawColor(renderer, bgColor.r, bgColor.g, bgColor.b, 255);
     SDL_Rect rect;
-    if (shape == notification_shape_rounded)
+    if (shape == NotificationShape::ROUNDED)
     {
         rect = {4, 0, width - (4 * 2), height};
         SDL_RenderFillRect(renderer, &rect);
@@ -287,7 +247,7 @@ void Notify::showText(std::string text1, std::string text2, int icon)
         SDL_RenderFillRect(renderer, &rect);
     }
 
-    else if (shape == notification_shape_squared)
+    else if (shape == NotificationShape::SQUARED)
     {
         SDL_RenderClear(renderer);
     }
@@ -295,15 +255,14 @@ void Notify::showText(std::string text1, std::string text2, int icon)
     // Dibuja el icono de la notificación
     if (hasIcons && icon >= 0 && numTexts == 2)
     {
-        Sprite *sp = new Sprite({0, 0, iconSize, iconSize}, iconTexture);
+        auto sp = std::make_unique<Sprite>((SDL_Rect){0, 0, iconSize, iconSize}, iconTexture);
         sp->setPos({paddingIn, paddingIn, iconSize, iconSize});
         sp->setSpriteClip({iconSize * (icon % 10), iconSize * (icon / 10), iconSize, iconSize});
         sp->render();
-        delete sp;
     }
 
     // Escribe el texto de la notificación
-    color_t color = {255, 255, 255};
+    Color color = {255, 255, 255};
     if (numTexts == 2)
     { // Dos lineas de texto
         text->writeColored(paddingIn + iconSpace, paddingIn, text1, color);
@@ -318,7 +277,7 @@ void Notify::showText(std::string text1, std::string text2, int icon)
     SDL_SetRenderTarget(renderer, nullptr);
 
     // Crea el sprite de la notificación
-    n.sprite = new Sprite(n.rect, n.texture);
+    n.sprite = std::make_shared<Sprite>(n.rect, n.texture);
 
     // Deja la notificación invisible
     n.texture->setAlpha(0);
@@ -343,7 +302,7 @@ void Notify::clearNotifications()
 {
     for (int i = 0; i < (int)notifications.size(); ++i)
     {
-        notifications[i].state = ns_finished;
+        notifications[i].status = NotificationStatus::FINISHED;
     }
 
     clearFinishedNotifications();

source/notify.h

@@ -2,74 +2,72 @@
 
 #include <SDL2/SDL_rect.h>    // for SDL_Rect
 #include <SDL2/SDL_render.h>  // for SDL_Renderer
-#include <string>             // for basic_string, string
+#include <memory>             // for shared_ptr, unique_ptr
+#include <string>             // for string, basic_string
 #include <vector>             // for vector
-#include "utils.h"            // for color_t
+#include "utils.h"            // for Color
 class Sprite;
 class Text;
 class Texture;
-struct JA_Sound_t;
-
-#ifndef NOTIFY_H
-#define NOTIFY_H
+struct JA_Sound_t;  // lines 12-12
 
 class Notify
 {
 private:
-	enum notification_state_e
+	enum class NotificationStatus
 	{
-		ns_rising,
-		ns_stay,
-		ns_vanishing,
-		ns_finished
+		RISING,
+		STAY,
+		VANISHING,
+		FINISHED,
 	};
 
-	enum notification_position_e
+	enum class NotificationPosition
 	{
-		upperLeft,
-		upperCenter,
-		upperRight,
-		middleLeft,
-		middleRight,
-		bottomLeft,
-		bottomCenter,
-		bottomRight
+		UPPER_LEFT,
+		UPPER_CENTER,
+		UPPER_RIGHT,
+		MIDDLE_LEFT,
+		MIDDLE_RIGHT,
+		BOTTOM_LEFT,
+		BOTTOM_CENTER,
+		BOTTOM_RIGHT,
 	};
 
-	enum notification_shape_t
+	enum class NotificationShape
 	{
-		notification_shape_rounded,
-		notification_shape_squared,
+		ROUNDED,
+		SQUARED,
 	};
 
-	struct notification_t
+	struct Notification
 	{
+		std::shared_ptr<Texture> texture;
+		std::shared_ptr<Sprite> sprite;
 		std::string text1;
 		std::string text2;
 		int counter;
-		notification_state_e state;
-		notification_position_e position;
-		Texture *texture;
-		Sprite *sprite;
+		NotificationStatus status;
+		NotificationPosition position;
+		NotificationShape shape;
 		SDL_Rect rect;
 		int y;
 		int travelDist;
-		notification_shape_t shape;
 	};
 
 	// Objetos y punteros
 	SDL_Renderer *renderer; // El renderizador de la ventana
-	Texture *textTexture;	// Textura para la fuente de las notificaciones
-	Texture *iconTexture;	// Textura para los iconos de las notificaciones
-	Text *text;				// Objeto para dibujar texto
+
+	std::shared_ptr<Texture> iconTexture; // Textura para los iconos de las notificaciones
+	std::unique_ptr<Text> text;			  // Objeto para dibujar texto
 
 	// Variables
-	color_t bgColor;						   // Color de fondo de las notificaciones
-	int waitTime;							   // Tiempo que se ve la notificación
-	std::vector<notification_t> notifications; // La lista de notificaciones activas
-	JA_Sound_t *sound;						   // Sonido a reproducir cuando suena la notificación
-	bool stack;								   // Indica si las notificaciones se apilan
-	bool hasIcons;							   // Indica si el notificador tiene textura para iconos
+	Color bgColor;							 // Color de fondo de las notificaciones
+	int waitTime;							 // Tiempo que se ve la notificación
+	std::vector<Notification> notifications; // La lista de notificaciones activas
+	bool stack;								 // Indica si las notificaciones se apilan
+	bool hasIcons;							 // Indica si el notificador tiene textura para iconos
+	JA_Sound_t *sound;						 // Sonido a reproducir cuando suena la notificación
 
 	// Elimina las notificaciones finalizadas
 	void clearFinishedNotifications();
@@ -79,7 +77,7 @@ private:
 
 public:
 	// Constructor
-	Notify(SDL_Renderer *renderer, std::string iconFile, std::string bitmapFile, std::string textFile, std::string soundFile);
+	Notify(SDL_Renderer *renderer, std::string iconFile, std::string bitmapFile, std::string textFile, const std::string &soundFile);
 
 	// Destructor
 	~Notify();
@@ -91,10 +89,8 @@ public:
 	void update();
 
 	// Muestra una notificación de texto por pantalla;
-	void showText(std::string text1 = "", std::string text2 = "", int icon = -1);
+	void showText(std::string text1 = std::string(), std::string text2 = std::string(), int icon = -1);
 
 	// Indica si hay notificaciones activas
 	bool active();
 };
-
-#endif

source/on_screen_help.cpp

@@ -1,12 +1,15 @@
 #include "on_screen_help.h"
-#include "screen.h"
-#include "asset.h"
-#include "input.h"
-#include "sprite.h"
-#include "texture.h"
-#include "lang.h"
-#include "param.h"
-#include <memory> // Para std::unique_ptr
+#include <SDL2/SDL_blendmode.h>  // for SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_pixels.h>     // for SDL_PIXELFORMAT_RGBA8888
+#include <memory>                // for make_unique, make_shared, unique_ptr
+#include "asset.h"               // for Asset
+#include "lang.h"                // for getText
+#include "param.h"               // for param
+#include "screen.h"              // for Screen
+#include "sprite.h"              // for Sprite
+#include "text.h"                // for Text
+#include "texture.h"             // for Texture
+#include "utils.h"               // for easeInOutSine, Param, ParamGame
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 OnScreenHelp *OnScreenHelp::onScreenHelp = nullptr;
@@ -16,13 +19,13 @@ constexpr int ICONSIZE = 16;
 constexpr SDL_Point PADDING = {8, 8};
 constexpr SDL_Point DESP = {ICONSIZE + 4, 5};
 
-constexpr SDL_Rect CONTROLLER_UP = {16, 16, ICONSIZE, ICONSIZE};
-constexpr SDL_Rect CONTROLLER_DOWN = {48, 16, ICONSIZE, ICONSIZE};
-constexpr SDL_Rect CONTROLLER_LEFT = {64, 16, ICONSIZE, ICONSIZE};
-constexpr SDL_Rect LEFT_BUTTON = {48, 144, ICONSIZE, ICONSIZE};
-constexpr SDL_Rect TOP_BUTTON = {0, 144, ICONSIZE, ICONSIZE};
-constexpr SDL_Rect RIGHT_BUTTON = {16, 144, ICONSIZE, ICONSIZE};
-constexpr SDL_Rect START_BUTTON = {128, 320, ICONSIZE, ICONSIZE};
+constexpr SDL_Rect CONTROLLER_UP = {16, 0, ICONSIZE, ICONSIZE};
+constexpr SDL_Rect CONTROLLER_DOWN = {48, 0, ICONSIZE, ICONSIZE};
+constexpr SDL_Rect CONTROLLER_LEFT = {64, 0, ICONSIZE, ICONSIZE};
+constexpr SDL_Rect LEFT_BUTTON = {112, 0, ICONSIZE, ICONSIZE};
+constexpr SDL_Rect TOP_BUTTON = {80, 0, ICONSIZE, ICONSIZE};
+constexpr SDL_Rect RIGHT_BUTTON = {96, 0, ICONSIZE, ICONSIZE};
+constexpr SDL_Rect START_BUTTON = {0, 0, ICONSIZE, ICONSIZE};
 
 constexpr SDL_Rect CONTROLLER_UP_POS = {PADDING.x, PADDING.y + 18 * 0, ICONSIZE, ICONSIZE};
 constexpr SDL_Rect CONTROLLER_DOWN_POS = {PADDING.x, PADDING.y + 18 * 1, ICONSIZE, ICONSIZE};
@@ -51,7 +54,7 @@ OnScreenHelp *OnScreenHelp::get()
 }
 
 // Constructor
-OnScreenHelp::OnScreenHelp() : state(OnScreenHelpStatus::hidden)
+OnScreenHelp::OnScreenHelp() : state(OnScreenHelpStatus::hidden), index(0)
 {
     setSize();
 
@@ -59,6 +62,7 @@ OnScreenHelp::OnScreenHelp() : state(OnScreenHelpStatus::hidden)
     SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
 
     fillTexture();
+    precalculatePath(hiddenPos, showingPos, 60);
 }
 
 // Destructor
@@ -87,17 +91,17 @@ void OnScreenHelp::render()
 void OnScreenHelp::fillTexture()
 {
     // Cambia el renderizador a la textura
-    SDL_Texture *temp = SDL_GetRenderTarget(Screen::get()->getRenderer());
+    auto temp = SDL_GetRenderTarget(Screen::get()->getRenderer());
     SDL_SetRenderTarget(Screen::get()->getRenderer(), texture);
 
     // Crea el objeto para el texto
-    std::unique_ptr<Text> text(new Text(Asset::get()->get("8bithud.png"), Asset::get()->get("8bithud.txt"), Screen::get()->getRenderer()));
+    auto text = std::make_unique<Text>(Asset::get()->get("8bithud.png"), Asset::get()->get("8bithud.txt"), Screen::get()->getRenderer());
 
     // Crea la textura con los gráficos
-    std::unique_ptr<Texture> controllersTexture(new Texture(Screen::get()->getRenderer(), Asset::get()->get("controllers.png")));
+    auto controllersTexture = std::make_shared<Texture>(Screen::get()->getRenderer(), Asset::get()->get("controllers.png"));
 
     // Crea el sprite para dibujar los gráficos
-    std::unique_ptr<Sprite> sprite(new Sprite({0, 0, 16, 16}, controllersTexture.get()));
+    auto sprite = std::make_unique<Sprite>((SDL_Rect){0, 0, 16, 16}, controllersTexture);
 
     // Borra la textura
     SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 0, 0, 0);
@@ -137,11 +141,11 @@ void OnScreenHelp::fillTexture()
 // Define el ancho y alto de la textura
 void OnScreenHelp::setSize()
 {
-    const int textSize = getLargestStringSize();
-    const int width = PADDING.x + DESP.x + textSize + PADDING.x;
-    const int height = PADDING.y + (7 * 18) + PADDING.y;
-    const int x = 0;
-    const int y = (param.game.height - height) / 2;
+    const auto textSize = getLargestStringSize();
+    const auto width = PADDING.x + DESP.x + textSize + PADDING.x;
+    const auto height = PADDING.y + (7 * 18) + PADDING.y;
+    const auto x = 0;
+    const auto y = (param.game.height - height) / 2;
 
     dest = (SDL_Rect){x, y, width, height};
 
@@ -157,21 +161,21 @@ void OnScreenHelp::toggleState()
         state = OnScreenHelpStatus::exitting;
     }
 
-    if (state == OnScreenHelpStatus::hidden || state == OnScreenHelpStatus::exitting)
+    else if (state == OnScreenHelpStatus::hidden || state == OnScreenHelpStatus::exitting)
     {
         state = OnScreenHelpStatus::entering;
     }
 }
 
 // Calcula la longitud en pixels del texto más largo
-int OnScreenHelp::getLargestStringSize() const
+auto OnScreenHelp::getLargestStringSize() -> int const
 {
-    std::unique_ptr<Text> text(new Text(Asset::get()->get("8bithud.png"), Asset::get()->get("8bithud.txt"), Screen::get()->getRenderer()));
-    int size = 0;
+    auto text = std::make_unique<Text>(Asset::get()->get("8bithud.png"), Asset::get()->get("8bithud.txt"), Screen::get()->getRenderer());
+    auto size = 0;
 
     for (int i = 107; i <= 113; ++i)
     {
-        const int textSize = text->lenght(lang::getText(i));
+        const auto textSize = text->lenght(lang::getText(i));
         size = textSize > size ? textSize : size;
     }
 
@@ -193,39 +197,59 @@ void OnScreenHelp::updatePosition()
     switch (state)
     {
     case OnScreenHelpStatus::hidden:
-        dest.x = hiddenPos;
+    {
+        index = 0;
         break;
+    }
 
     case OnScreenHelpStatus::showing:
-        dest.x = showingPos;
+    {
+        index = path.size() - 1;
         break;
+    }
 
     case OnScreenHelpStatus::exitting:
-        if (dest.x > hiddenPos)
+    {
+        if (index > 0)
         {
-            dest.x -= 8;
+            index--;
         }
         else
         {
             state = OnScreenHelpStatus::hidden;
         }
         break;
+    }
 
     case OnScreenHelpStatus::entering:
-        if (dest.x < showingPos)
+    {
+        if (index < (int)path.size() - 1)
         {
-            dest.x += 8;
+            index++;
         }
         else
         {
             state = OnScreenHelpStatus::showing;
         }
         break;
+    }
 
     default:
         break;
     }
 
-    dest.x = std::max(hiddenPos, dest.x);
-    dest.x = std::min(showingPos, dest.x);
+    dest.x = path[index];
+}
+
+// Rellena los puntos por donde pasa la animación
+void OnScreenHelp::precalculatePath(double start, double end, int steps)
+{
+    path.reserve(steps);
+
+    for (int i = 0; i <= steps; ++i)
+    {
+        double t = static_cast<double>(i) / steps;
+        double value = start + (end - start) * easeInOutSine(t);
+        path.push_back(static_cast<int>(value));
+    }
 }

source/on_screen_help.h

@@ -1,12 +1,10 @@
 #pragma once
 
-#include <SDL2/SDL.h>
-#include "text.h"
-class Screen;
-class Asset;
-class Input;
-class Texture;
+#include <SDL2/SDL_rect.h>    // for SDL_Rect
+#include <SDL2/SDL_render.h>  // for SDL_Texture
+#include <vector>             // for vector
 class Sprite;
+class Text;
 
 enum class OnScreenHelpStatus
 {
@@ -28,6 +26,8 @@ private:
     int hiddenPos, showingPos; // Las dos posiciones donde colocar la textura
 
     OnScreenHelpStatus state; // Estado del objeto
+    std::vector<int> path;    // Puntos por donde pasa la animación de la tarjeta
+    int index;                // Indice para recorrer la animación
 
     // [SINGLETON] Ahora el constructor y el destructor son privados, para no poder crear objetos screen desde fuera
 
@@ -44,7 +44,7 @@ private:
     void setSize();
 
     // Calcula la longitud en pixels del texto más largo
-    int getLargestStringSize() const;
+    auto getLargestStringSize() -> int const;
 
     // Renderizara el boton y el texto
     void renderButton(Sprite *sprite, Text *text, const SDL_Rect &buttonClip, const SDL_Rect &buttonPos, int textId);
@@ -52,6 +52,9 @@ private:
     // Actualiza la posición
     void updatePosition();
 
+    // Rellena los puntos por donde pasa la animación
+    void precalculatePath(double start, double end, int steps);
+
 public:
     // [SINGLETON] Crearemos el objeto screen con esta función estática
     static void init();

source/options.cpp

@@ -1,44 +1,36 @@
 #include "options.h"
-#include <SDL2/SDL_gamecontroller.h>  // for SDL_GameControllerButton, SDL_C...
-#include <SDL2/SDL_video.h>           // for SDL_WINDOW_FULLSCREEN, SDL_WIND...
-#include <algorithm>                  // for max, min
-#include <fstream>                    // for char_traits, basic_ostream, ope...
-#include <iostream>                   // for cout
-#include <vector>                     // for vector
-#include "input.h"                    // for inputs_e, INPUT_USE_ANY, INPUT_...
-#include "lang.h"                     // for lang_e
-#include "screen.h"                   // for SCREEN_FILTER_NEAREST, SCREEN_V...
-#include "utils.h"                    // for op_controller_t, options_t, op_...
+#include <SDL2/SDL_gamecontroller.h> // for SDL_GameControllerButton, SDL_C...
+#include <algorithm>				 // for max, min
+#include <fstream>					 // for basic_ostream, operator<<, basi...
+#include <iostream>					 // for cout
+#include <vector>					 // for vector
+#include "input.h"					 // for inputs_e, INPUT_USE_ANY, INPUT_...
+#include "lang.h"					 // for lang_e
+#include "screen.h"					 // for ScreenVideoMode, ScreenFilter
+#include "utils.h"					 // for OptionsController, Options, op_...
 
 // Variables
-options_t options;
+Options options;
 
 // Declaraciones
-bool setOptions(std::string var, std::string value);
+bool setOptions(const std::string &var, const std::string &value);
 
 // Inicializa las opciones del programa
 void initOptions()
 {
 	// Opciones de video
 #ifdef ANBERNIC
-	options.video.mode = 0;
+	options.video.mode = ScreenVideoMode::WINDOW;
 	options.video.window.size = 3;
 #else
-	options.video.mode = 0;
+	options.video.mode = ScreenVideoMode::WINDOW;
 	options.video.window.size = 2;
 #endif
-	options.video.filter = SCREEN_FILTER_NEAREST;
-	options.video.vSync = true;
-	options.video.integerScale = true;
-	options.video.keepAspect = true;
+	options.video.filter = ScreenFilter::NEAREST;
+	options.video.v_sync = true;
+	options.video.integer_scale = true;
 	options.video.shaders = true;
 
-	// Opciones de las notificaciones
-	options.notification.posV = pos_top;
-	options.notification.posH = pos_left;
-	options.notification.sound = false;
-	options.notification.color = {48, 48, 48};
-
 	// Opciones de audio
 	options.audio.music.enabled = true;
 	options.audio.music.volume = 128;
@@ -46,29 +38,30 @@ void initOptions()
 	options.audio.sound.volume = 64;
 
 	// Opciones de juego
-	options.game.difficulty = DIFFICULTY_NORMAL;
-	options.game.language = lang::ba_BA;
+	options.game.difficulty = GameDifficulty::NORMAL;
+	options.game.language = lang::Code::ba_BA;
 	options.game.autofire = true;
 
 	// Opciones de control
 	options.controller.clear();
-	op_controller_t c;
+	OptionsController c;
 
-	const int numPlayers = 2;
-	for (int index = 0; index < numPlayers; ++index)
+	constexpr int num_players = 2;
+	for (int index = 0; index < num_players; ++index)
 	{
 		c.index = index;
-		c.playerId = index + 1;
-		c.deviceType = INPUT_USE_GAMECONTROLLER;
+		c.player_id = index + 1;
+		c.device_type = INPUT_USE_GAMECONTROLLER;
 		c.name = "NO NAME";
+		c.plugged = false;
 
 		// Inputs que se guardan en las opciones y, por tanto, a disco
 		c.inputs.clear();
-		c.inputs.push_back(input_fire_left);
-		c.inputs.push_back(input_fire_center);
-		c.inputs.push_back(input_fire_right);
-		c.inputs.push_back(input_start);
-		c.inputs.push_back(input_service);
+		c.inputs.push_back(InputType::FIRE_LEFT);
+		c.inputs.push_back(InputType::FIRE_CENTER);
+		c.inputs.push_back(InputType::FIRE_RIGHT);
+		c.inputs.push_back(InputType::START);
+		c.inputs.push_back(InputType::SERVICE);
 
 		// Botones asociados a los inputs anteriores
 		c.buttons.clear();
@@ -80,11 +73,11 @@ void initOptions()
 
 		options.controller.push_back(c);
 	}
-	options.controller[0].deviceType = INPUT_USE_ANY; // El primer jugador puede usar tanto el teclado como el primer mando
+	options.controller[0].device_type = INPUT_USE_ANY; // El primer jugador puede usar tanto el teclado como el primer mando
 }
 
 // Carga el fichero de configuración
-bool loadOptionsFile(std::string filePath)
+bool loadOptionsFile(std::string file_path)
 {
 	// Inicializa las opciones del programa
 	initOptions();
@@ -93,15 +86,17 @@ bool loadOptionsFile(std::string filePath)
 	bool success = true;
 
 	// Variables para manejar el fichero
-	const std::string fileName = filePath.substr(filePath.find_last_of("\\/") + 1);
-	std::ifstream file(filePath);
+#ifdef VERBOSE
+	const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
+#endif
+	std::ifstream file(file_path);
 
 	// Si el fichero se puede abrir
 	if (file.good())
 	{
 		// Procesa el fichero linea a linea
 #ifdef VERBOSE
-		std::cout << "Reading file: " << fileName << std::endl;
+		std::cout << "Reading file: " << file_name << std::endl;
 #endif
 		std::string line;
 		while (std::getline(file, line))
@@ -115,7 +110,7 @@ bool loadOptionsFile(std::string filePath)
 				if (!setOptions(line.substr(0, pos), line.substr(pos + 1, line.length())))
 				{
 #ifdef VERBOSE
-					std::cout << "Warning: file " << fileName << std::endl;
+					std::cout << "Warning: file " << file_name << std::endl;
 					std::cout << "Unknown parameter " << line.substr(0, pos).c_str() << std::endl;
 #endif
 					success = false;
@@ -130,16 +125,15 @@ bool loadOptionsFile(std::string filePath)
 	// El fichero no existe
 	else
 	{ // Crea el fichero con los valores por defecto
-		saveOptionsFile(filePath);
+		saveOptionsFile(file_path);
 	}
 
 	// Normaliza los valores
-	const bool a = options.video.mode == 0;
-	const bool b = options.video.mode == SDL_WINDOW_FULLSCREEN;
-	const bool c = options.video.mode == SDL_WINDOW_FULLSCREEN_DESKTOP;
-	if (!(a || b || c))
+	const bool a = options.video.mode == ScreenVideoMode::WINDOW;
+	const bool b = options.video.mode == ScreenVideoMode::FULLSCREEN;
+	if (!(a || b))
 	{
-		options.video.mode = SCREEN_VIDEO_MODE_WINDOW;
+		options.video.mode = ScreenVideoMode::WINDOW;
 	}
 
 	if (options.video.window.size < 1 || options.video.window.size > 4)
@@ -147,89 +141,56 @@ bool loadOptionsFile(std::string filePath)
 		options.video.window.size = 3;
 	}
 
-	if (options.game.language < 0 || options.game.language > 2)
+	if (options.game.language != lang::Code::en_UK && options.game.language != lang::Code::ba_BA && options.game.language != lang::Code::es_ES)
 	{
-		options.game.language = lang::en_UK;
+		options.game.language = lang::Code::en_UK;
 	}
 
 	return success;
 }
 
 // Guarda el fichero de configuración
-bool saveOptionsFile(std::string filePath)
+bool saveOptionsFile(std::string file_path)
 {
-	const std::string fileName = filePath.substr(filePath.find_last_of("\\/") + 1);
-	std::ofstream file(filePath);
+#ifdef VERBOSE
+	const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
+#endif
+	std::ofstream file(file_path);
 
 	if (!file.good())
 	{
 #ifdef VERBOSE
-		std::cout << fileName << " can't be opened" << std::endl;
+		std::cout << file_name << " can't be opened" << std::endl;
 #endif
 		return false;
 	}
 
 #ifdef VERBOSE
-	std::cout << "Writing file: " << fileName << std::endl;
+	std::cout << "Writing file: " << file_name << std::endl;
 #endif
 
 	// Opciones de video
+	const auto value_video_mode_winow = std::to_string(static_cast<int>(ScreenVideoMode::WINDOW));
+	const auto value_video_mode_fullscreen = std::to_string(static_cast<int>(ScreenVideoMode::FULLSCREEN));
+	const auto value_filter_nearest = std::to_string(static_cast<int>(ScreenFilter::NEAREST));
+	const auto value_filter_lineal = std::to_string(static_cast<int>(ScreenFilter::LINEAL));
+
 	file << "## VIDEO\n";
-	file << "## video.mode [0: window, 1: full screen]\n";
-	file << "## video.filter [0: nearest, 1: lineal]\n";
+	file << "## video.mode [" << value_video_mode_winow << ": window, " << value_video_mode_fullscreen << ": fullscreen]\n";
+	file << "## video.filter [" << value_filter_nearest << ": nearest, " << value_filter_lineal << ": lineal]\n";
 	file << "\n";
 
-	if (options.video.mode == SCREEN_VIDEO_MODE_WINDOW)
-	{
-		file << "video.mode=0\n";
-	}
-
-	else if (options.video.mode == SCREEN_VIDEO_MODE_FULLSCREEN)
-	{
-		file << "video.mode=1\n";
-	}
+	const auto valueVideoMode = std::to_string(static_cast<int>(options.video.mode));
+	file << "video.mode=" << valueVideoMode << "\n";
 
 	file << "video.window.size=" + std::to_string(options.video.window.size) + "\n";
 
-	options.video.filter == SCREEN_FILTER_NEAREST ? file << "video.filter=0\n" : file << "video.filter=1\n";
+	const auto valueFilter = std::to_string(static_cast<int>(options.video.filter));
+	file << "video.filter=" << valueFilter << "\n";
 
+	file << "video.v_sync=" + boolToString(options.video.v_sync) + "\n";
+	file << "video.integer_scale=" + boolToString(options.video.integer_scale) + "\n";
 	file << "video.shaders=" + boolToString(options.video.shaders) + "\n";
-	file << "video.vSync=" + boolToString(options.video.vSync) + "\n";
-	file << "video.integerScale=" + boolToString(options.video.integerScale) + "\n";
-	file << "video.keepAspect=" + boolToString(options.video.keepAspect) + "\n";
-
-	// Opciones de notificaciones
-	file << "\n\n## NOTIFICATION\n";
-	file << "## notification.posV [pos_top | pos_bottom]\n";
-	file << "## notification.posH [pos_left | pos_middle | pos_right]\n";
-	file << "\n";
-
-	if (options.notification.posV == pos_top)
-	{
-		file << "notification.posV=pos_top\n";
-	}
-
-	else
-	{
-		file << "notification.posV=pos_bottom\n";
-	}
-
-	if (options.notification.posH == pos_left)
-	{
-		file << "notification.posH=pos_left\n";
-	}
-
-	else if (options.notification.posH == pos_middle)
-	{
-		file << "notification.posH=pos_middle\n";
-	}
-
-	else
-	{
-		file << "notification.posH=pos_right\n";
-	}
-
-	file << "notification.sound=" + boolToString(options.notification.sound) + "\n";
 
 	// Opciones de audio
 	file << "\n\n## AUDIO\n";
@@ -242,32 +203,35 @@ bool saveOptionsFile(std::string filePath)
 	file << "audio.sound.volume=" + std::to_string(options.audio.sound.volume) + "\n";
 
 	// Opciones del juego
+	const auto value_difficulty_easy = std::to_string(static_cast<int>(GameDifficulty::EASY));
+	const auto value_difficulty_normal = std::to_string(static_cast<int>(GameDifficulty::NORMAL));
+	const auto value_difficulty_hard = std::to_string(static_cast<int>(GameDifficulty::HARD));
 	file << "\n\n## GAME\n";
 	file << "## game.language [0: spanish, 1: valencian, 2: english]\n";
-	file << "## game.difficulty [0: easy, 1: normal, 2: hard]\n";
+	file << "## game.difficulty [" << value_difficulty_easy << ": easy, " << value_difficulty_normal << ": normal, " << value_difficulty_hard << ": hard]\n";
 	file << "\n";
 
-	file << "game.language=" + std::to_string(options.game.language) + "\n";
-	file << "game.difficulty=" + std::to_string(options.game.difficulty) + "\n";
+	file << "game.language=" + std::to_string(static_cast<int>(options.game.language)) + "\n";
+	file << "game.difficulty=" + std::to_string(static_cast<int>(options.game.difficulty)) + "\n";
 	file << "game.autofire=" + boolToString(options.game.autofire) + "\n";
 
 	// Opciones de mandos
 	file << "\n\n## CONTROLLERS\n";
 	file << "\n";
 
-	const int numPlayers = 2;
-	for (int index = 0; index < numPlayers; ++index)
+	const int num_players = 2;
+	for (int index = 0; index < num_players; ++index)
 	{
 		const std::string joyIndex = std::to_string(index + 1);
 		file << "controller" + joyIndex + ".name=" + options.controller[index].name + "\n";
-		file << "controller" + joyIndex + ".player=" + std::to_string(options.controller[index].playerId) + "\n";
+		file << "controller" + joyIndex + ".player=" + std::to_string(options.controller[index].player_id) + "\n";
 		file << "controller" + joyIndex + ".button.fire_left=" + std::to_string((int)options.controller[index].buttons[0]) + "\n";
 		file << "controller" + joyIndex + ".button.fire_center=" + std::to_string((int)options.controller[index].buttons[1]) + "\n";
 		file << "controller" + joyIndex + ".button.fire_right=" + std::to_string((int)options.controller[index].buttons[2]) + "\n";
 		file << "controller" + joyIndex + ".button.start=" + std::to_string((int)options.controller[index].buttons[3]) + "\n";
 		file << "controller" + joyIndex + ".button.service=" + std::to_string((int)options.controller[index].buttons[4]) + "\n";
 
-		if (index < numPlayers - 1)
+		if (index < num_players - 1)
 		{
 			file << "\n";
 		}
@@ -280,15 +244,15 @@ bool saveOptionsFile(std::string filePath)
 }
 
 // Asigna variables a partir de dos cadenas
-bool setOptions(std::string var, std::string value)
+bool setOptions(const std::string &var, const std::string &value)
 {
 	// Indicador de éxito en la asignación
-	bool success = true;
+	auto success = true;
 
 	// Opciones de video
 	if (var == "video.mode")
 	{
-		options.video.mode = value == std::to_string(SCREEN_VIDEO_MODE_WINDOW) ? SCREEN_VIDEO_MODE_WINDOW : SCREEN_VIDEO_MODE_FULLSCREEN;
+		options.video.mode = static_cast<ScreenVideoMode>(std::stoi(value));
 	}
 
 	else if (var == "video.window.size")
@@ -302,7 +266,7 @@ bool setOptions(std::string var, std::string value)
 
 	else if (var == "video.filter")
 	{
-		options.video.filter = value == std::to_string(SCREEN_FILTER_NEAREST) ? SCREEN_FILTER_NEAREST : SCREEN_FILTER_LINEAL;
+		options.video.filter = static_cast<ScreenFilter>(std::stoi(value));
 	}
 
 	else if (var == "video.shaders")
@@ -310,46 +274,14 @@ bool setOptions(std::string var, std::string value)
 		options.video.shaders = stringToBool(value);
 	}
 
-	else if (var == "video.vSync")
+	else if (var == "video.integer_scale")
 	{
-		options.video.vSync = stringToBool(value);
+		options.video.integer_scale = stringToBool(value);
 	}
 
-	else if (var == "video.integerScale")
+	else if (var == "video.v_sync")
 	{
-		options.video.integerScale = stringToBool(value);
-	}
-
-	else if (var == "video.keepAspect")
-	{
-		options.video.keepAspect = stringToBool(value);
-	}
-
-	// Opciones de notificaciones
-	else if (var == "notification.posH")
-	{
-		if (value == "pos_left")
-		{
-			options.notification.posH = pos_left;
-		}
-		else if (value == "pos_middle")
-		{
-			options.notification.posH = pos_middle;
-		}
-		else
-		{
-			options.notification.posH = pos_right;
-		}
-	}
-
-	else if (var == "notification.posV")
-	{
-		options.notification.posV = value == "pos_top" ? pos_top : pos_bottom;
-	}
-
-	else if (var == "notification.sound")
-	{
-		options.notification.sound = stringToBool(value);
+		options.video.v_sync = stringToBool(value);
 	}
 
 	// Opciones de audio
@@ -376,12 +308,12 @@ bool setOptions(std::string var, std::string value)
 	// Opciones de juego
 	else if (var == "game.language")
 	{
-		options.game.language = std::stoi(value);
+		options.game.language = static_cast<lang::Code>(std::stoi(value));
 	}
 
 	else if (var == "game.difficulty")
 	{
-		options.game.difficulty = std::stoi(value);
+		options.game.difficulty = static_cast<GameDifficulty>(std::stoi(value));
 	}
 
 	else if (var == "game.autofire")
@@ -397,7 +329,7 @@ bool setOptions(std::string var, std::string value)
 
 	else if (var == "controller1.player")
 	{
-		options.controller[0].playerId = std::max(1, std::min(2, std::stoi(value)));
+		options.controller[0].player_id = std::max(1, std::min(2, std::stoi(value)));
 	}
 
 	else if (var == "controller1.button.fire_left")
@@ -432,7 +364,7 @@ bool setOptions(std::string var, std::string value)
 
 	else if (var == "controller2.player")
 	{
-		options.controller[1].playerId = std::max(1, std::min(2, std::stoi(value)));
+		options.controller[1].player_id = std::max(1, std::min(2, std::stoi(value)));
 	}
 
 	else if (var == "controller2.button.fire_left")
@@ -461,7 +393,7 @@ bool setOptions(std::string var, std::string value)
 	}
 
 	// Lineas vacias o que empiezan por comentario
-	else if (var == "" || var.substr(0, 1) == "#")
+	else if (var.empty() || var.starts_with("#"))
 	{
 	}
 

source/options.h

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <string>  // for string
-struct options_t;
+#include <string> // for string
+struct Options;
 
 // Variables
-extern options_t options;
+extern Options options;
 
 // Carga el fichero de configuración
-bool loadOptionsFile(std::string filePath);
+bool loadOptionsFile(std::string file_path);
 
 // Guarda el fichero de configuración
-bool saveOptionsFile(std::string filePath);
+bool saveOptionsFile(std::string file_path);

source/param.cpp

@@ -1,12 +1,15 @@
 #include "param.h"
-#include <fstream>   // for char_traits, basic_ostream, basic_ifstream, basi...
-#include <iostream>  // for cout
-#include "utils.h"   // for param_t, paramGame_t, zone_t, paramBalloon_t
+#include <fstream>	// for char_traits, basic_ostream, basic_ifstream, basi...
+#include <iostream> // for cout
+#include <sstream>
+#include <string>
+#include <stdexcept>
+#include "utils.h" // for Param, ParamGame, Zone, ParamBalloon
 
-param_t param;
+Param param;
 
 // Asigna variables a partir de dos cadenas
-bool setParams(std::string var, std::string value);
+bool setParams(const std::string &var, const std::string &value);
 
 // Calcula variables a partir de otras variables
 void precalculateZones();
@@ -17,51 +20,59 @@ void initParam()
 	// GAME
 	param.game.width = 320;
 	param.game.height = 256;
-	param.game.itemSize = 20;
-	param.game.gameArea.rect = {0, 0, param.game.width, param.game.height};
-	param.game.playArea.rect = {0, 0, param.game.width, 216};
+	param.game.item_size = 20;
+	param.game.game_area.rect = {0, 0, param.game.width, param.game.height};
+	param.game.play_area.rect = {0, 0, param.game.width, 216};
 	precalculateZones();
 
 	// SCOREBOARD
 	param.scoreboard = {0, 216, param.game.width, 40};
 
 	// FADE
-	param.fade.numSquaresWidth = param.game.width / 2;
-	param.fade.numSquaresHeight = param.game.height / 2;
-	param.fade.randomSquaresDelay = 1;
-	param.fade.randomSquaresMult = 500;
-	param.fade.postDuration = 80;
-	param.fade.venetianSize = 16;
+	param.fade.num_squares_width = param.game.width / 2;
+	param.fade.num_squares_height = param.game.height / 2;
+	param.fade.random_squares_delay = 1;
+	param.fade.random_squares_mult = 500;
+	param.fade.post_duration = 80;
+	param.fade.venetian_size = 16;
 
 	// TITLE
-	param.title.pressStartPosition = 160;
-	param.title.titleDuration = 800;
-	param.title.arcadeEditionPosition = 123;
-	param.title.titleCCPosition = 11;
+	param.title.press_start_position = 160;
+	param.title.title_duration = 800;
+	param.title.arcade_edition_position = 123;
+	param.title.title_c_c_position = 11;
 
 	// BACKGROUND
-	param.background.attenuateColor = {255, 255, 255};
-	param.background.attenuateAlpha = 32;
+	param.background.attenuate_color = (Color){255, 255, 255};
+	param.background.attenuate_alpha = 32;
 
 	// BALLOONS
-	param.balloon1.vel = 2.60f;
-	param.balloon1.grav = 0.09f;
-	param.balloon2.vel = 3.50f;
-	param.balloon2.grav = 0.10f;
-	param.balloon3.vel = 4.50f;
-	param.balloon3.grav = 0.10f;
-	param.balloon4.vel = 4.95f;
-	param.balloon4.grav = 0.10f;
+	param.balloon_1.vel = 2.60f;
+	param.balloon_1.grav = 0.09f;
+	param.balloon_2.vel = 3.50f;
+	param.balloon_2.grav = 0.10f;
+	param.balloon_3.vel = 4.50f;
+	param.balloon_3.grav = 0.10f;
+	param.balloon_4.vel = 4.95f;
+	param.balloon_4.grav = 0.10f;
+
+	// NOTIFICATION
+	param.notification.pos_v = NotifyPosition::TOP;
+	param.notification.pos_h = NotifyPosition::LEFT;
+	param.notification.sound = false;
+	param.notification.color.r = 48;
+	param.notification.color.g = 48;
+	param.notification.color.b = 48;
 }
 
 // Establece valores para los parametros a partir de un fichero de texto
-void loadParamsFromFile(std::string filePath)
+/*void loadParamsFromFile(std::string file_path)
 {
 	// Pone valores por defecto a las variables
 	initParam();
 
 	// Variables para manejar el fichero
-	std::ifstream file(filePath);
+	std::ifstream file(file_path);
 	std::string line;
 	std::string param1;
 	std::string param2;
@@ -70,18 +81,25 @@ void loadParamsFromFile(std::string filePath)
 	if (file.good())
 	{
 #ifdef VERBOSE
-		const std::string filename = filePath.substr(filePath.find_last_of("\\/") + 1);
-		std::cout << "Reading file: " << filename << std::endl;
+		const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
+		std::cout << "Reading file: " << file_name << std::endl;
 #endif
 		// Procesa cada linea del fichero
 		while (std::getline(file, line))
 		{
 			// Reinicia variables
-			param1 = "";
-			param2 = "";
+			param1.clear();
+			param2.clear();
 
-			// Elimina los comentarios
-			line = line.substr(0, line.find("#"));
+			// Elimina los comentarios al final de una linea
+			{
+				// line = line.substr(0, line.find("#"));
+				auto pos = line.find("#");
+				if (pos != std::string::npos)
+				{
+					line.resize(pos);
+				}
+			}
 
 			// Ignora los espacios en blanco
 			int pos = 0;
@@ -145,17 +163,61 @@ void loadParamsFromFile(std::string filePath)
 	}
 #ifdef VERBOSE
 	else
-		std::cout << "Failed to load file: " << filePath << std::endl;
+		std::cout << "Failed to load file: " << file_path << std::endl;
 #endif
 
+	precalculateZones();
+}*/
+void loadParamsFromFile(const std::string &file_path)
+{
+	// Inicializa los parámetros con valores por defecto
+	initParam();
+
+	// Abre el archivo
+	std::ifstream file(file_path);
+	if (!file.is_open())
+	{
+#ifdef VERBOSE
+		std::cerr << "Error: No se pudo abrir el archivo " << file_path << std::endl;
+#endif
+		throw std::runtime_error("No se pudo abrir el archivo: " + file_path);
+	}
+
+#ifdef VERBOSE
+	const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
+	std::cout << "Reading file: " << file_name << std::endl;
+#endif
+
+	std::string line, param1, param2;
+	while (std::getline(file, line))
+	{
+		// Elimina comentarios
+		auto comment_pos = line.find('#');
+		if (comment_pos != std::string::npos)
+		{
+			line.resize(comment_pos);
+		}
+
+		// Usa un stream para separar palabras
+		std::istringstream iss(line);
+		if (iss >> param1 >> param2)
+		{
+			setParams(param1, param2);
+		}
+	}
+
+	// Cierra el archivo
+	file.close();
+
+	// Realiza cálculos adicionales después de cargar los parámetros
 	precalculateZones();
 }
 
 // Asigna variables a partir de dos cadenas
-bool setParams(std::string var, std::string value)
+bool setParams(const std::string &var, const std::string &value)
 {
 	// Indicador de éxito en la asignación
-	bool success = true;
+	auto success = true;
 
 	// GAME
 	if (var == "game.width")
@@ -168,60 +230,60 @@ bool setParams(std::string var, std::string value)
 		param.game.height = std::stoi(value);
 	}
 
-	else if (var == "game.itemSize")
+	else if (var == "game.item_size")
 	{
-		param.game.itemSize = std::stoi(value);
+		param.game.item_size = std::stoi(value);
 	}
 
-	else if (var == "game.playArea.rect.x")
+	else if (var == "game.play_area.rect.x")
 	{
-		param.game.playArea.rect.x = std::stoi(value);
+		param.game.play_area.rect.x = std::stoi(value);
 	}
 
-	else if (var == "game.playArea.rect.y")
+	else if (var == "game.play_area.rect.y")
 	{
-		param.game.playArea.rect.y = std::stoi(value);
+		param.game.play_area.rect.y = std::stoi(value);
 	}
 
-	else if (var == "game.playArea.rect.w")
+	else if (var == "game.play_area.rect.w")
 	{
-		param.game.playArea.rect.w = std::stoi(value);
+		param.game.play_area.rect.w = std::stoi(value);
 	}
 
-	else if (var == "game.playArea.rect.h")
+	else if (var == "game.play_area.rect.h")
 	{
-		param.game.playArea.rect.h = std::stoi(value);
+		param.game.play_area.rect.h = std::stoi(value);
 	}
 
 	// FADE
-	else if (var == "fade.numSquaresWidth")
+	else if (var == "fade.num_squares_width")
 	{
-		param.fade.numSquaresWidth = std::stoi(value);
+		param.fade.num_squares_width = std::stoi(value);
 	}
 
-	else if (var == "fade.numSquaresHeight")
+	else if (var == "fade.num_squares_height")
 	{
-		param.fade.numSquaresHeight = std::stoi(value);
+		param.fade.num_squares_height = std::stoi(value);
 	}
 
-	else if (var == "fade.randomSquaresDelay")
+	else if (var == "fade.random_squares_delay")
 	{
-		param.fade.randomSquaresDelay = std::stoi(value);
+		param.fade.random_squares_delay = std::stoi(value);
 	}
 
-	else if (var == "fade.randomSquaresMult")
+	else if (var == "fade.random_squares_mult")
 	{
-		param.fade.randomSquaresMult = std::stoi(value);
+		param.fade.random_squares_mult = std::stoi(value);
 	}
 
-	else if (var == "fade.postDuration")
+	else if (var == "fade.post_duration")
 	{
-		param.fade.postDuration = std::stoi(value);
+		param.fade.post_duration = std::stoi(value);
 	}
 
-	else if (var == "fade.venetianSize")
+	else if (var == "fade.venetian_size")
 	{
-		param.fade.venetianSize = std::stoi(value);
+		param.fade.venetian_size = std::stoi(value);
 	}
 
 	// SCOREBOARD
@@ -246,86 +308,128 @@ bool setParams(std::string var, std::string value)
 	}
 
 	// TITLE
-	else if (var == "title.pressStartPosition")
+	else if (var == "title.press_start_position")
 	{
-		param.title.pressStartPosition = std::stoi(value);
+		param.title.press_start_position = std::stoi(value);
 	}
 
-	else if (var == "title.titleDuration")
+	else if (var == "title.title_duration")
 	{
-		param.title.titleDuration = std::stoi(value);
+		param.title.title_duration = std::stoi(value);
 	}
 
-	else if (var == "title.arcadeEditionPosition")
+	else if (var == "title.arcade_edition_position")
 	{
-		param.title.arcadeEditionPosition = std::stoi(value);
+		param.title.arcade_edition_position = std::stoi(value);
 	}
 
-	else if (var == "title.titleCCPosition")
+	else if (var == "title.title_c_c_position")
 	{
-		param.title.titleCCPosition = std::stoi(value);
+		param.title.title_c_c_position = std::stoi(value);
 	}
 
 	// BACKGROUND
-	else if (var == "background.attenuateColor.r")
+	else if (var == "background.attenuate_color.r")
 	{
-		param.background.attenuateColor.r = std::stoi(value);
+		param.background.attenuate_color.r = std::stoi(value);
 	}
 
-	else if (var == "background.attenuateColor.g")
+	else if (var == "background.attenuate_color.g")
 	{
-		param.background.attenuateColor.g = std::stoi(value);
+		param.background.attenuate_color.g = std::stoi(value);
 	}
 
-	else if (var == "background.attenuateColor.b")
+	else if (var == "background.attenuate_color.b")
 	{
-		param.background.attenuateColor.b = std::stoi(value);
+		param.background.attenuate_color.b = std::stoi(value);
 	}
 
-	else if (var == "background.attenuateAlpha")
+	else if (var == "background.attenuate_alpha")
 	{
-		param.background.attenuateAlpha = std::stoi(value);
+		param.background.attenuate_alpha = std::stoi(value);
 	}
 
 	// BALLOON
-	else if (var == "balloon1.vel")
+	else if (var == "balloon_1.vel")
 	{
-		param.balloon1.vel = std::stof(value);
+		param.balloon_1.vel = std::stof(value);
 	}
 
-	else if (var == "balloon1.grav")
+	else if (var == "balloon_1.grav")
 	{
-		param.balloon1.grav = std::stof(value);
+		param.balloon_1.grav = std::stof(value);
 	}
 
-	else if (var == "balloon2.vel")
+	else if (var == "balloon_2.vel")
 	{
-		param.balloon2.vel = std::stof(value);
+		param.balloon_2.vel = std::stof(value);
 	}
 
-	else if (var == "balloon2.grav")
+	else if (var == "balloon_2.grav")
 	{
-		param.balloon2.grav = std::stof(value);
+		param.balloon_2.grav = std::stof(value);
 	}
 
-	else if (var == "balloon3.vel")
+	else if (var == "balloon_3.vel")
 	{
-		param.balloon3.vel = std::stof(value);
+		param.balloon_3.vel = std::stof(value);
 	}
 
-	else if (var == "balloon3.grav")
+	else if (var == "balloon_3.grav")
 	{
-		param.balloon3.grav = std::stof(value);
+		param.balloon_3.grav = std::stof(value);
 	}
 
-	else if (var == "balloon4.vel")
+	else if (var == "balloon_4.vel")
 	{
-		param.balloon4.vel = std::stof(value);
+		param.balloon_4.vel = std::stof(value);
 	}
 
-	else if (var == "balloon4.grav")
+	else if (var == "balloon_4.grav")
 	{
-		param.balloon4.grav = std::stof(value);
+		param.balloon_4.grav = std::stof(value);
+	}
+
+	// NOTIFICACIONES
+	else if (var == "notification.pos_h")
+	{
+		if (value == "LEFT")
+		{
+			param.notification.pos_h = NotifyPosition::LEFT;
+		}
+		else if (value == "MIDDLE")
+		{
+			param.notification.pos_h = NotifyPosition::MIDDLE;
+		}
+		else
+		{
+			param.notification.pos_h = NotifyPosition::RIGHT;
+		}
+	}
+
+	else if (var == "notification.pos_v")
+	{
+		param.notification.pos_v = value == "TOP" ? NotifyPosition::TOP : NotifyPosition::BOTTOM;
+	}
+
+	else if (var == "notification.sound")
+	{
+		param.notification.sound = stringToBool(value);
+	}
+
+	else if (var == "notification.color.r")
+	{
+		param.notification.color.r = std::stoi(value);
+	}
+
+	else if (var == "notification.color.g")
+	{
+		param.notification.color.g = std::stoi(value);
+	}
+
+	else if (var == "notification.color.b")
+	{
+		param.notification.color.b = std::stoi(value);
 	}
 
 	// RESTO
@@ -341,19 +445,19 @@ bool setParams(std::string var, std::string value)
 void precalculateZones()
 {
 	// playArea
-	param.game.playArea.centerX = param.game.playArea.rect.w / 2;
-	param.game.playArea.firstQuarterX = param.game.playArea.rect.w / 4;
-	param.game.playArea.thirdQuarterX = param.game.playArea.rect.w / 4 * 3;
-	param.game.playArea.centerY = param.game.playArea.rect.h / 2;
-	param.game.playArea.firstQuarterY = param.game.playArea.rect.h / 4;
-	param.game.playArea.thirdQuarterY = param.game.playArea.rect.h / 4 * 3;
+	param.game.play_area.center_x = param.game.play_area.rect.w / 2;
+	param.game.play_area.first_quarter_x = param.game.play_area.rect.w / 4;
+	param.game.play_area.third_quarter_x = param.game.play_area.rect.w / 4 * 3;
+	param.game.play_area.center_y = param.game.play_area.rect.h / 2;
+	param.game.play_area.first_quarter_y = param.game.play_area.rect.h / 4;
+	param.game.play_area.third_quarter_y = param.game.play_area.rect.h / 4 * 3;
 
 	// gameArea
-	param.game.gameArea.rect = {0, 0, param.game.width, param.game.height};
-	param.game.gameArea.centerX = param.game.gameArea.rect.w / 2;
-	param.game.gameArea.firstQuarterX = param.game.gameArea.rect.w / 4;
-	param.game.gameArea.thirdQuarterX = param.game.gameArea.rect.w / 4 * 3;
-	param.game.gameArea.centerY = param.game.gameArea.rect.h / 2;
-	param.game.gameArea.firstQuarterY = param.game.gameArea.rect.h / 4;
-	param.game.gameArea.thirdQuarterY = param.game.gameArea.rect.h / 4 * 3;
+	param.game.game_area.rect = {0, 0, param.game.width, param.game.height};
+	param.game.game_area.center_x = param.game.game_area.rect.w / 2;
+	param.game.game_area.first_quarter_x = param.game.game_area.rect.w / 4;
+	param.game.game_area.third_quarter_x = param.game.game_area.rect.w / 4 * 3;
+	param.game.game_area.center_y = param.game.game_area.rect.h / 2;
+	param.game.game_area.first_quarter_y = param.game.game_area.rect.h / 4;
+	param.game.game_area.third_quarter_y = param.game.game_area.rect.h / 4 * 3;
 }

source/param.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include <string>  // for string
-struct param_t;
+#include <string> // for string
+struct Param;
 
-extern param_t param;
+extern Param param;
 
 // Establece valores para los parametros a partir de un fichero de texto
-void loadParamsFromFile(std::string filePath);
+void loadParamsFromFile(const std::string &file_path);

source/player.h

@@ -1,77 +1,85 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>	 // for SDL_Rect
-#include <SDL2/SDL_stdinc.h> // for Uint32
-#include <string>			 // for string, basic_string
-#include <vector>			 // for vector
-#include "utils.h"			 // for circle_t
-class AnimatedSprite;
-class EnterName;
+#include <SDL2/SDL_rect.h>    // for SDL_Rect
+#include <SDL2/SDL_stdinc.h>  // for Uint32
+#include <memory>             // for unique_ptr, shared_ptr
+#include <string>             // for string
+#include <vector>             // for vector
+#include "animated_sprite.h"  // for AnimatedSprite
+#include "enter_name.h"       // for EnterName
+#include "utils.h"            // for Circle
 class Texture;
+enum class InputType : int;
+enum class ScoreboardMode;  // lines 12-12
 
 // Estados del jugador
-#define PLAYER_STATUS_WALKING_LEFT 0
-#define PLAYER_STATUS_WALKING_RIGHT 1
-#define PLAYER_STATUS_WALKING_STOP 2
+enum class PlayerStatus
+{
+	WALKING_LEFT,
+	WALKING_RIGHT,
+	WALKING_STOP,
 
-#define PLAYER_STATUS_FIRING_UP 0
-#define PLAYER_STATUS_FIRING_LEFT 1
-#define PLAYER_STATUS_FIRING_RIGHT 2
-#define PLAYER_STATUS_FIRING_NO 3
+	FIRING_UP,
+	FIRING_LEFT,
+	FIRING_RIGHT,
+	FIRING_NO,
 
-#define PLAYER_STATUS_PLAYING 0
-#define PLAYER_STATUS_CONTINUE 1
-#define PLAYER_STATUS_WAITING 2
-#define PLAYER_STATUS_ENTERING_NAME 3
-#define PLAYER_STATUS_DYING 4
-#define PLAYER_STATUS_DIED 5
+	PLAYING,
+	CONTINUE,
+	WAITING,
+	ENTERING_NAME,
+	DYING,
+	DIED,
+	GAME_OVER,
+};
 
 // Variables del jugador
-#define PLAYER_INVULNERABLE_COUNTER 200
-#define PLAYER_POWERUP_COUNTER 1500
+constexpr int PLAYER_INVULNERABLE_COUNTER = 200;
+constexpr int PLAYER_POWERUP_COUNTER = 1500;
 
 // Clase Player
 class Player
 {
 private:
 	// Objetos y punteros
-	AnimatedSprite *playerSprite; // Sprite para dibujar el jugador
-	AnimatedSprite *powerSprite;  // Sprite para dibujar el aura del jugador con el poder a tope
-	SDL_Rect *playArea;			  // Rectangulo con la zona de juego
-	EnterName *enterName;
+	std::unique_ptr<AnimatedSprite> player_sprite_; // Sprite para dibujar el jugador
+	std::unique_ptr<AnimatedSprite> power_sprite_;	// Sprite para dibujar el aura del jugador con el poder a tope
+	std::unique_ptr<EnterName> enter_name_;			// Clase utilizada para introducir el nombre
+	SDL_Rect *play_area_;							// Rectangulo con la zona de juego
 
 	// Variables
-	int id;					 // Numero de identificación para el jugador
-	float posX;				 // Posicion en el eje X
-	int posY;				 // Posicion en el eje Y
-	float defaultPosX;		 // Posición inicial para el jugador
-	int defaultPosY;		 // Posición inicial para el jugador
-	int width;				 // Anchura
-	int height;				 // Altura
-	float velX;				 // Cantidad de pixeles a desplazarse en el eje X
-	int velY;				 // Cantidad de pixeles a desplazarse en el eje Y
-	float baseSpeed;		 // Velocidad base del jugador
-	int cooldown;			 // Contador durante el cual no puede disparar
-	int score;				 // Puntos del jugador
-	float scoreMultiplier;	 // Multiplicador de puntos
-	int statusWalking;		 // Estado del jugador al moverse
-	int statusFiring;		 // Estado del jugador al disparar
-	int statusPlaying;		 // Estado del jugador en el juego
-	bool invulnerable;		 // Indica si el jugador es invulnerable
-	int invulnerableCounter; // Contador para la invulnerabilidad
-	bool extraHit;			 // Indica si el jugador tiene un toque extra
-	int coffees;			 // Indica cuantos cafes lleva acumulados
-	bool powerUp;			 // Indica si el jugador tiene activo el modo PowerUp
-	int powerUpCounter;		 // Temporizador para el modo PowerUp
-	int powerUpDespX;		 // Desplazamiento del sprite de PowerUp respecto al sprite del jugador
-	bool input;				 // Indica si puede recibir ordenes de entrada
-	circle_t collider;		 // Circulo de colisión del jugador
-	int continueCounter;	 // Contador para poder continuar
-	Uint32 continueTicks;	 // Variable para poder cambiar el contador de continue en función del tiempo
-	int scoreBoardPanel;	 // Panel del marcador asociado al jugador
-	std::string name;		 // Nombre del jugador
-	std::string recordName;	 // Nombre del jugador para l atabla de mejores puntuaciones
-	int controllerIndex;	 // Indice del array de mandos que utilizará para moverse
+	int id_;					  // Numero de identificación para el jugador
+	float pos_x_;				  // Posicion en el eje X
+	int pos_y_;					  // Posicion en el eje Y
+	float default_pos_x_;		  // Posición inicial para el jugador
+	int default_pos_y_;			  // Posición inicial para el jugador
+	int width_;					  // Anchura
+	int height_;				  // Altura
+	float vel_x_;				  // Cantidad de pixeles a desplazarse en el eje X
+	int vel_y_;					  // Cantidad de pixeles a desplazarse en el eje Y
+	float base_speed_;			  // Velocidad base del jugador
+	int cooldown_;				  // Contador durante el cual no puede disparar
+	int score_;					  // Puntos del jugador
+	float score_multiplier_;	  // Multiplicador de puntos
+	PlayerStatus status_walking_; // Estado del jugador al moverse
+	PlayerStatus status_firing_;  // Estado del jugador al disparar
+	PlayerStatus status_playing_; // Estado del jugador en el juego
+	bool invulnerable_;			  // Indica si el jugador es invulnerable
+	int invulnerable_counter_;	  // Contador para la invulnerabilidad
+	bool extra_hit_;			  // Indica si el jugador tiene un toque extra
+	int coffees_;				  // Indica cuantos cafes lleva acumulados
+	bool power_up_;				  // Indica si el jugador tiene activo el modo PowerUp
+	int power_up_counter_;		  // Temporizador para el modo PowerUp
+	int power_up_desp_x_;		  // Desplazamiento del sprite de PowerUp respecto al sprite del jugador
+	bool input_;				  // Indica si puede recibir ordenes de entrada
+	Circle collider_;			  // Circulo de colisión del jugador
+	int continue_counter_;		  // Contador para poder continuar
+	Uint32 continue_ticks_;		  // Variable para poder cambiar el contador de continue en función del tiempo
+	int scoreboard_panel_;		  // Panel del marcador asociado al jugador
+	std::string name_;			  // Nombre del jugador
+	std::string record_name_;	  // Nombre del jugador para l atabla de mejores puntuaciones
+	int controller_index_;		  // Indice del array de mandos que utilizará para moverse
+	bool demo_;					  // Para que el jugador sepa si está en el modo demostración
 
 	// Actualiza el circulo de colisión a la posición del jugador
 	void shiftColliders();
@@ -82,12 +90,24 @@ private:
 	// Actualiza el contador de continue
 	void updateContinueCounter();
 
+	// Indica si el jugador se puede dibujar
+	bool isRenderable() const;
+
+	// Actualiza el panel del marcador
+	void updateScoreboard();
+
+	// Comprueba si la puntuación entra en la tabla de mejores puntuaciones
+	bool IsEligibleForHighScore();
+
+	// Cambia el modo del marcador
+	void setScoreboardMode(ScoreboardMode mode);
+
 public:
 	// Constructor
-	Player(int id, float x, int y, SDL_Rect *playArea, std::vector<Texture *> texture, std::vector<std::vector<std::string> *> animations);
+	Player(int id, float x, int y, bool demo, SDL_Rect *play_area, std::vector<std::shared_ptr<Texture>> texture, std::vector<std::vector<std::string> *> animations);
 
 	// Destructor
-	~Player();
+	~Player() = default;
 
 	// Iniciador
 	void init();
@@ -99,43 +119,43 @@ public:
 	void render();
 
 	// Pone las texturas del jugador
-	void setPlayerTextures(std::vector<Texture *> texture);
+	void setPlayerTextures(const std::vector<std::shared_ptr<Texture>> &texture);
 
 	// Actua en consecuencia de la entrada recibida
-	void setInput(int input);
+	void setInput(InputType input);
 
 	// Procesa inputs para cuando está jugando
-	void setInputPlaying(int input);
+	void setInputPlaying(InputType input);
 
 	// Procesa inputs para cuando está introduciendo el nombre
-	void setInputEnteringName(int input);
+	void setInputEnteringName(InputType input);
 
 	// Mueve el jugador a la posición y animación que le corresponde
 	void move();
 
 	// Establece el estado del jugador
-	void setWalkingStatus(int status);
+	void setWalkingStatus(PlayerStatus status);
 
 	// Establece el estado del jugador
-	void setFiringStatus(int status);
+	void setFiringStatus(PlayerStatus status);
 
 	// Establece la animación correspondiente al estado
 	void setAnimation();
 
 	// Obtiene el valor de la variable
-	int getPosX();
+	int getPosX() const;
 
 	// Obtiene el valor de la variable
-	int getPosY();
+	int getPosY() const;
 
 	// Obtiene el valor de la variable
-	int getWidth();
+	int getWidth() const;
 
 	// Obtiene el valor de la variable
-	int getHeight();
+	int getHeight() const;
 
 	// Indica si el jugador puede disparar
-	bool canFire();
+	bool canFire() const;
 
 	// Establece el valor de la variable
 	void setFireCooldown(int time);
@@ -144,7 +164,7 @@ public:
 	void updateCooldown();
 
 	// Obtiene la puntuación del jugador
-	int getScore();
+	int getScore() const;
 
 	// Asigna un valor a la puntuación del jugador
 	void setScore(int score);
@@ -153,31 +173,34 @@ public:
 	void addScore(int score);
 
 	// Indica si el jugador está jugando
-	bool isPlaying();
+	bool isPlaying() const;
 
 	// Indica si el jugador está continuando
-	bool isContinue();
+	bool isContinue() const;
 
 	// Indica si el jugador está esperando
-	bool isWaiting();
+	bool isWaiting() const;
 
 	// Indica si el jugador está introduciendo su nombre
-	bool isEnteringName();
+	bool isEnteringName() const;
 
 	// Indica si el jugador está muriendose
-	bool isDying();
+	bool isDying() const;
 
 	// Indica si el jugador ha terminado de morir
-	bool hasDied();
+	bool hasDied() const;
+
+	// Indica si el jugador ya ha terminado de jugar
+	bool isGameOver() const;
 
 	// Establece el estado del jugador en el juego
-	void setStatusPlaying(int value);
+	void setStatusPlaying(PlayerStatus value);
 
 	// Obtiene el estado del jugador en el juego
-	int getStatusPlaying();
+	PlayerStatus getStatusPlaying() const;
 
 	// Obtiene el valor de la variable
-	float getScoreMultiplier();
+	float getScoreMultiplier() const;
 
 	// Establece el valor de la variable
 	void setScoreMultiplier(float value);
@@ -189,25 +212,25 @@ public:
 	void decScoreMultiplier();
 
 	// Obtiene el valor de la variable
-	bool isInvulnerable();
+	bool isInvulnerable() const;
 
 	// Establece el valor del estado
 	void setInvulnerable(bool value);
 
 	// Obtiene el valor de la variable
-	int getInvulnerableCounter();
+	int getInvulnerableCounter() const;
 
 	// Establece el valor de la variable
 	void setInvulnerableCounter(int value);
 
 	// Obtiene el valor de la variable
-	bool isPowerUp();
+	bool isPowerUp() const;
 
 	// Establece el valor de la variable a verdadero
 	void setPowerUp();
 
 	// Obtiene el valor de la variable
-	int getPowerUpCounter();
+	int getPowerUpCounter() const;
 
 	// Establece el valor de la variable
 	void setPowerUpCounter(int value);
@@ -216,7 +239,7 @@ public:
 	void updatePowerUpCounter();
 
 	// Obtiene el valor de la variable
-	bool hasExtraHit();
+	bool hasExtraHit() const;
 
 	// Concede un toque extra al jugador
 	void giveExtraHit();
@@ -231,44 +254,44 @@ public:
 	void disableInput();
 
 	// Devuelve el número de cafes actuales
-	int getCoffees();
+	int getCoffees() const;
 
 	// Obtiene el circulo de colisión
-	circle_t &getCollider();
+	Circle &getCollider();
 
 	// Obtiene el valor de la variable
-	int getContinueCounter();
+	int getContinueCounter() const;
 
 	// Le asigna un panel en el marcador al jugador
 	void setScoreBoardPanel(int panel);
 
 	// Obtiene el valor de la variable
-	int getScoreBoardPanel();
+	int getScoreBoardPanel() const;
 
 	// Decrementa el contador de continuar
 	void decContinueCounter();
 
 	// Establece el nombre del jugador
-	void setName(std::string name);
+	void setName(const std::string &name);
 
 	// Establece el nombre del jugador para la tabla de mejores puntuaciones
-	void setRecordName(std::string recordName);
+	void setRecordName(const std::string &record_name);
 
 	// Obtiene el nombre del jugador
-	std::string getName();
+	std::string getName() const;
 
 	// Obtiene el nombre del jugador para la tabla de mejores puntuaciones
-	std::string getRecordName();
+	std::string getRecordName() const;
 
 	// Obtiene la posici´´on que se está editando del nombre del jugador para la tabla de mejores puntuaciones
-	int getRecordNamePos();
+	int getRecordNamePos() const;
 
 	// Establece el mando que usará para ser controlado
 	void setController(int index);
 
 	// Obtiene el mando que usa para ser controlado
-	int getController();
+	int getController() const;
 
 	// Obtiene el "id" del jugador
-	int getId();
+	int getId() const;
 };

source/scoreboard.cpp

@@ -3,56 +3,73 @@
 #include <SDL2/SDL_pixels.h>	// for SDL_PIXELFORMAT_RGBA8888
 #include <SDL2/SDL_timer.h>		// for SDL_GetTicks
 #include <math.h>				// for roundf
-#include "asset.h"				// for Asset
-#include "lang.h"				// for getText
-#include "sprite.h"				// for Sprite
-#include "text.h"				// for Text
-#include "texture.h"			// for Texture
+#include <iomanip>
+#include <sstream>
+#include "asset.h"	 // for Asset
+#include "lang.h"	 // for getText
+#include "sprite.h"	 // for Sprite
+#include "text.h"	 // for Text
+#include "texture.h" // for Texture
+
+// [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
+Scoreboard *Scoreboard::scoreboard_ = nullptr;
+
+// [SINGLETON] Crearemos el objeto score_board con esta función estática
+void Scoreboard::init(SDL_Renderer *renderer)
+{
+	Scoreboard::scoreboard_ = new Scoreboard(renderer);
+}
+
+// [SINGLETON] Destruiremos el objeto score_board con esta función estática
+void Scoreboard::destroy()
+{
+	delete Scoreboard::scoreboard_;
+}
+
+// [SINGLETON] Con este método obtenemos el objeto score_board y podemos trabajar con él
+Scoreboard *Scoreboard::get()
+{
+	return Scoreboard::scoreboard_;
+}
 
 // Constructor
 Scoreboard::Scoreboard(SDL_Renderer *renderer)
+	: renderer_(renderer),
+	  
+	  game_power_meter_texture_(std::make_shared<Texture>(renderer, Asset::get()->get("game_power_meter.png"))),
+	  power_meter_sprite_(std::make_unique<Sprite>(game_power_meter_texture_)),
+	  text_scoreboard_(std::make_unique<Text>(Asset::get()->get("8bithud.png"), Asset::get()->get("8bithud.txt"), renderer)),
+	  
+	  stage_(1),
+	  hi_score_(0),
+	  power_(0),
+	  hi_score_name_(std::string()),
+	  color_({0, 0, 0}),
+	  rect_({0, 0, 320, 40}),
+	  ticks_(SDL_GetTicks()),
+	  counter_(0)
 {
-	// Copia los punteros
-	this->renderer = renderer;
-	asset = Asset::get();
-
-	// Inicializa punteros
-	gamePowerMeterTexture = nullptr;
-	powerMeterSprite = nullptr;
-	textScoreBoard = nullptr;
-
 	// Inicializa variables
-	stage = 1;
 	for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
 	{
-		name[i] = "";
-		recordName[i] = "";
-		selectorPos[i] = 0;
-		score[i] = 0;
-		mult[i] = 0;
-		continueCounter[i] = 0;
+		name_[i].clear();
+		record_name_[i].clear();
+		selector_pos_[i] = 0;
+		score_[i] = 0;
+		mult_[i] = 0;
+		continue_counter_[i] = 0;
 	}
-	hiScore = 0;
-	power = 0;
-	hiScoreName = "";
-	color = {0, 0, 0};
-	rect = {0, 0, 320, 40};
-	panel[SCOREBOARD_LEFT_PANEL].mode = SCOREBOARD_MODE_SCORE;
-	panel[SCOREBOARD_RIGHT_PANEL].mode = SCOREBOARD_MODE_SCORE;
-	panel[SCOREBOARD_CENTER_PANEL].mode = SCOREBOARD_MODE_STAGE_INFO;
-	ticks = SDL_GetTicks();
-	counter = 0;
+
+	panel_[SCOREBOARD_LEFT_PANEL].mode = ScoreboardMode::SCORE;
+	panel_[SCOREBOARD_RIGHT_PANEL].mode = ScoreboardMode::SCORE;
+	panel_[SCOREBOARD_CENTER_PANEL].mode = ScoreboardMode::STAGE_INFO;
 
 	// Recalcula las anclas de los elementos
 	recalculateAnchors();
-
-	// Crea objetos
-	gamePowerMeterTexture = new Texture(renderer, asset->get("game_power_meter.png"));
-	powerMeterSprite = new Sprite(slot4_2.x - 20, slot4_2.y, 40, 7, gamePowerMeterTexture);
-	textScoreBoard = new Text(asset->get("8bithud.png"), asset->get("8bithud.txt"), renderer);
+	power_meter_sprite_->setPos({slot4_2_.x - 20, slot4_2_.y, 40, 7});
 
 	// Crea la textura de fondo
-	background = nullptr;
+	background_ = nullptr;
 	createBackgroundTexture();
 
 	// Crea las texturas de los paneles
@@ -64,15 +81,12 @@ Scoreboard::Scoreboard(SDL_Renderer *renderer)
 
 Scoreboard::~Scoreboard()
 {
-	gamePowerMeterTexture->unload();
-	delete gamePowerMeterTexture;
-	delete powerMeterSprite;
-	delete textScoreBoard;
-	if (background)
+	if (background_)
 	{
-		SDL_DestroyTexture(background);
+		SDL_DestroyTexture(background_);
 	}
-	for (auto texture : panelTexture)
+
+	for (auto texture : panel_texture_)
 	{
 		if (texture)
 		{
@@ -82,53 +96,20 @@ Scoreboard::~Scoreboard()
 }
 
 // Transforma un valor numérico en una cadena de 6 cifras
-std::string Scoreboard::updateScoreText(Uint32 num)
+std::string Scoreboard::updateScoreText(int num)
 {
-	if ((num >= 0) && (num <= 9))
-	{
-		return ("000000" + std::to_string(num));
-	}
-
-	if ((num >= 10) && (num <= 99))
-	{
-		return ("00000" + std::to_string(num));
-	}
-
-	if ((num >= 100) && (num <= 999))
-	{
-		return ("0000" + std::to_string(num));
-	}
-
-	if ((num >= 1000) && (num <= 9999))
-	{
-		return ("000" + std::to_string(num));
-	}
-
-	if ((num >= 010000) && (num <= 99999))
-	{
-		return ("00" + std::to_string(num));
-	}
-
-	if ((num >= 100000) && (num <= 999999))
-	{
-		return ("0" + std::to_string(num));
-	}
-
-	if ((num >= 1000000) && (num <= 9999999))
-	{
-		return (std::to_string(num));
-	}
-
-	return (std::to_string(num));
+	std::ostringstream oss;
+	oss << std::setw(8) << std::setfill('0') << num;
+	return oss.str();
 }
 
 // Actualiza el contador
 void Scoreboard::updateCounter()
 {
-	if (SDL_GetTicks() - ticks > SCOREBOARD_TICK_SPEED)
+	if (SDL_GetTicks() - ticks_ > SCOREBOARD_TICK_SPEED)
 	{
-		ticks = SDL_GetTicks();
-		counter++;
+		ticks_ = SDL_GetTicks();
+		counter_++;
 	}
 }
 
@@ -142,80 +123,80 @@ void Scoreboard::update()
 // Pinta el marcador
 void Scoreboard::render()
 {
-	SDL_RenderCopy(renderer, background, nullptr, &rect);
+	SDL_RenderCopy(renderer_, background_, nullptr, &rect_);
 }
 
 // Establece el valor de la variable
-void Scoreboard::setName(int panel, std::string name)
+void Scoreboard::setName(int panel_, const std::string &name_)
 {
-	this->name[panel] = name;
+	this->name_[panel_] = name_;
 }
 
 // Establece el valor de la variable
-void Scoreboard::setRecordName(int panel, std::string recordName)
+void Scoreboard::setRecordName(int panel_, const std::string &record_name_)
 {
-	this->recordName[panel] = recordName;
+	this->record_name_[panel_] = record_name_;
 }
 
 // Establece el valor de la variable
-void Scoreboard::setSelectorPos(int panel, int pos)
+void Scoreboard::setSelectorPos(int panel_, int pos)
 {
-	selectorPos[panel] = pos;
+	selector_pos_[panel_] = pos;
 }
 
 // Establece el valor de la variable
-void Scoreboard::setScore(int panel, int score)
+void Scoreboard::setScore(int panel_, int score_)
 {
-	this->score[panel] = score;
+	this->score_[panel_] = score_;
 }
 
 // Establece el valor de la variable
-void Scoreboard::setMult(int panel, float mult)
+void Scoreboard::setMult(int panel_, float mult_)
 {
-	this->mult[panel] = mult;
+	this->mult_[panel_] = mult_;
 }
 
 // Establece el valor de la variable
-void Scoreboard::setContinue(int panel, int value)
+void Scoreboard::setContinue(int panel_, int value)
 {
-	continueCounter[panel] = value;
+	continue_counter_[panel_] = value;
 }
 
 // Establece el valor de la variable
-void Scoreboard::setStage(int stage)
+void Scoreboard::setStage(int stage_)
 {
-	this->stage = stage;
+	this->stage_ = stage_;
 }
 
 // Establece el valor de la variable
-void Scoreboard::setHiScore(int hiScore)
+void Scoreboard::setHiScore(int hi_score_)
 {
-	this->hiScore = hiScore;
+	this->hi_score_ = hi_score_;
 }
 
 // Establece el valor de la variable
-void Scoreboard::setPower(float power)
+void Scoreboard::setPower(float power_)
 {
-	this->power = power;
+	this->power_ = power_;
 }
 
 // Establece el valor de la variable
-void Scoreboard::setHiScoreName(std::string name)
+void Scoreboard::setHiScoreName(const std::string &name_)
 {
-	hiScoreName = name;
+	hi_score_name_ = name_;
 }
 
 // Establece el valor de la variable
-void Scoreboard::setColor(color_t color)
+void Scoreboard::setColor(Color color_)
 {
-	this->color = color;
+	this->color_ = color_;
 	fillBackgroundTexture();
 }
 
 // Establece el valor de la variable
-void Scoreboard::setPos(SDL_Rect rect)
+void Scoreboard::setPos(SDL_Rect rect_)
 {
-	this->rect = rect;
+	this->rect_ = rect_;
 
 	// Recalcula las anclas de los elementos
 	recalculateAnchors();
@@ -234,97 +215,127 @@ void Scoreboard::setPos(SDL_Rect rect)
 void Scoreboard::fillPanelTextures()
 {
 	// Guarda a donde apunta actualmente el renderizador
-	SDL_Texture *temp = SDL_GetRenderTarget(renderer);
+	SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
 
-	// Genera el contenidoi de cada panel
+	// Genera el contenidoi de cada panel_
 	for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
 	{
 		// Cambia el destino del renderizador
-		SDL_SetRenderTarget(renderer, panelTexture[i]);
+		SDL_SetRenderTarget(renderer_, panel_texture_[i]);
 
 		// Dibuja el fondo de la textura
-		SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
-		SDL_RenderClear(renderer);
+		SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
+		SDL_RenderClear(renderer_);
 
-		switch (panel[i].mode)
+		switch (panel_[i].mode)
+		{
+		case ScoreboardMode::SCORE:
 		{
-		case SCOREBOARD_MODE_SCORE:
 			// SCORE
-			textScoreBoard->writeCentered(slot4_1.x, slot4_1.y, name[i]);
-			textScoreBoard->writeCentered(slot4_2.x, slot4_2.y, updateScoreText(score[i]));
+			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, name_[i]);
+			text_scoreboard_->writeCentered(slot4_2_.x, slot4_2_.y, updateScoreText(score_[i]));
 
 			// MULT
-			textScoreBoard->writeCentered(slot4_3.x, slot4_3.y, lang::getText(55));
-			textScoreBoard->writeCentered(slot4_4.x, slot4_4.y, std::to_string(mult[i]).substr(0, 3));
+			text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(55));
+			text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, std::to_string(mult_[i]).substr(0, 3));
 			break;
+		}
 
-		case SCOREBOARD_MODE_DEMO:
-			textScoreBoard->writeCentered(slot4_1.x, slot4_1.y + 4, lang::getText(101));
-			if (counter % 10 < 8)
+		case ScoreboardMode::DEMO:
+		{
+			// DEMO MODE
+			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(101));
+
+			// PRESS START TO PLAY
+			if (counter_ % 10 < 8)
 			{
-				textScoreBoard->writeCentered(slot4_3.x, slot4_3.y - 2, lang::getText(103));
-				textScoreBoard->writeCentered(slot4_4.x, slot4_4.y - 2, lang::getText(104));
+				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(103));
+				text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(104));
 			}
 			break;
+		}
 
-		case SCOREBOARD_MODE_GAME_OVER:
-			textScoreBoard->writeCentered(slot4_1.x, slot4_1.y + 4, lang::getText(102));
-			if (counter % 10 < 8)
+		case ScoreboardMode::WAITING:
+		{
+			// GAME OVER
+			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(102));
+
+			// PRESS START TO PLAY
+			if (counter_ % 10 < 8)
 			{
-				textScoreBoard->writeCentered(slot4_3.x, slot4_3.y - 2, lang::getText(103));
-				textScoreBoard->writeCentered(slot4_4.x, slot4_4.y - 2, lang::getText(104));
+				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(103));
+				text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(104));
 			}
 			break;
+		}
 
-		case SCOREBOARD_MODE_STAGE_INFO:
+		case ScoreboardMode::GAME_OVER:
+		{
+			// GAME OVER
+			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(102));
+
+			// PLEASE WAIT
+			if (counter_ % 10 < 8)
+			{
+				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(114));
+				text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(115));
+			}
+			break;
+		}
+
+		case ScoreboardMode::STAGE_INFO:
+		{
 			// STAGE
-			textScoreBoard->writeCentered(slot4_1.x, slot4_1.y, lang::getText(57) + std::to_string(stage));
+			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, lang::getText(57) + std::to_string(stage_));
 
 			// POWERMETER
-			powerMeterSprite->setSpriteClip(0, 0, 40, 7);
-			powerMeterSprite->render();
-			powerMeterSprite->setSpriteClip(40, 0, int(power * 40.0f), 7);
-			powerMeterSprite->render();
+			power_meter_sprite_->setSpriteClip(0, 0, 40, 7);
+			power_meter_sprite_->render();
+			power_meter_sprite_->setSpriteClip(40, 0, int(power_ * 40.0f), 7);
+			power_meter_sprite_->render();
 
 			// HI-SCORE
-			textScoreBoard->writeCentered(slot4_3.x, slot4_3.y, lang::getText(56));
-			textScoreBoard->writeCentered(slot4_4.x, slot4_4.y, hiScoreName + " - " + updateScoreText(hiScore));
+			text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(56));
+			text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, hi_score_name_ + " - " + updateScoreText(hi_score_));
 			break;
+		}
 
-		case SCOREBOARD_MODE_CONTINUE:
-			// SCORE
-			textScoreBoard->writeCentered(slot4_1.x, slot4_1.y, name[i]);
-			textScoreBoard->writeCentered(slot4_2.x, slot4_2.y, updateScoreText(score[i]));
-
-			// CONTINUE
-			textScoreBoard->writeCentered(slot4_3.x, slot4_3.y, lang::getText(105));
-			textScoreBoard->writeCentered(slot4_4.x, slot4_4.y, std::to_string(continueCounter[i]));
-			break;
-
-		case SCOREBOARD_MODE_ENTER_NAME:
+		case ScoreboardMode::CONTINUE:
 		{
 			// SCORE
-			textScoreBoard->writeCentered(slot4_1.x, slot4_1.y, name[i]);
-			textScoreBoard->writeCentered(slot4_2.x, slot4_2.y, updateScoreText(score[i]));
+			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, name_[i]);
+			text_scoreboard_->writeCentered(slot4_2_.x, slot4_2_.y, updateScoreText(score_[i]));
+
+			// CONTINUE
+			text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(105));
+			text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, std::to_string(continue_counter_[i]));
+			break;
+		}
+
+		case ScoreboardMode::ENTER_NAME:
+		{
+			// SCORE
+			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, name_[i]);
+			text_scoreboard_->writeCentered(slot4_2_.x, slot4_2_.y, updateScoreText(score_[i]));
 
 			// ENTER NAME
-			textScoreBoard->writeCentered(slot4_3.x, slot4_3.y, lang::getText(106));
-			SDL_Rect rect = {enterNamePos.x, enterNamePos.y, 5, 7};
-			SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xEB, 255);
-			for (int j = 0; j < (int)recordName[i].size(); ++j)
+			text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(106));
+			SDL_Rect rect = {enter_name_pos_.x, enter_name_pos_.y, 5, 7};
+			SDL_SetRenderDrawColor(renderer_, 0xFF, 0xFF, 0xEB, 255);
+			for (int j = 0; j < (int)record_name_[i].size(); ++j)
 			{
-				if (j == selectorPos[i])
-				{// La letra seleccionada se pinta de forma intermitente
-					if (counter % 3 > 0)
+				if (j == selector_pos_[i])
+				{ // La letra seleccionada se pinta de forma intermitente
+					if (counter_ % 3 > 0)
 					{
-						SDL_RenderDrawLine(renderer, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
-						textScoreBoard->write(rect.x, rect.y, recordName[i].substr(j, 1));
+						SDL_RenderDrawLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
+						text_scoreboard_->write(rect.x, rect.y, record_name_[i].substr(j, 1));
 					}
 				}
 				else
 				{
-					SDL_RenderDrawLine(renderer, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
-					textScoreBoard->write(rect.x, rect.y, recordName[i].substr(j, 1));
+					SDL_RenderDrawLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
+					text_scoreboard_->write(rect.x, rect.y, record_name_[i].substr(j, 1));
 				}
 				rect.x += 7;
 			}
@@ -337,7 +348,7 @@ void Scoreboard::fillPanelTextures()
 	}
 
 	// Deja el renderizador apuntando donde estaba
-	SDL_SetRenderTarget(renderer, temp);
+	SDL_SetRenderTarget(renderer_, temp);
 }
 
 // Rellena la textura de fondo
@@ -347,41 +358,41 @@ void Scoreboard::fillBackgroundTexture()
 	fillPanelTextures();
 
 	// Cambia el destino del renderizador
-	SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-	SDL_SetRenderTarget(renderer, background);
+	SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
+	SDL_SetRenderTarget(renderer_, background_);
 
 	// Dibuja el fondo del marcador
-	SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 255);
-	SDL_RenderClear(renderer);
+	SDL_SetRenderDrawColor(renderer_, color_.r, color_.g, color_.b, 255);
+	SDL_RenderClear(renderer_);
 
 	// Copia las texturas de los paneles
 	for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
 	{
-		SDL_RenderCopy(renderer, panelTexture[i], nullptr, &panel[i].pos);
+		SDL_RenderCopy(renderer_, panel_texture_[i], nullptr, &panel_[i].pos);
 	}
 
 	// Dibuja la linea que separa la zona de juego del marcador
 	renderSeparator();
 
 	// Deja el renderizador apuntando donde estaba
-	SDL_SetRenderTarget(renderer, temp);
+	SDL_SetRenderTarget(renderer_, temp);
 }
 
 // Recalcula las anclas de los elementos
 void Scoreboard::recalculateAnchors()
 {
 	// Recalcula la posición y el tamaño de los paneles
-	const float panelWidth = (float)rect.w / (float)SCOREBOARD_MAX_PANELS;
+	const float panelWidth = (float)rect_.w / (float)SCOREBOARD_MAX_PANELS;
 	for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
 	{
-		panel[i].pos.x = roundf(panelWidth * i);
-		panel[i].pos.y = 0;
-		panel[i].pos.w = roundf(panelWidth * (i + 1)) - panel[i].pos.x;
-		panel[i].pos.h = rect.h;
+		panel_[i].pos.x = roundf(panelWidth * i);
+		panel_[i].pos.y = 0;
+		panel_[i].pos.w = roundf(panelWidth * (i + 1)) - panel_[i].pos.x;
+		panel_[i].pos.h = rect_.h;
 	}
 
-	// Constantes para definir las zonas del panel: 4 filas y 1 columna
-	const int rowSize = rect.h / 4;
+	// Constantes para definir las zonas del panel_: 4 filas y 1 columna
+	const int rowSize = rect_.h / 4;
 	const int textHeight = 7;
 
 	// Filas
@@ -394,63 +405,63 @@ void Scoreboard::recalculateAnchors()
 	const int col = panelWidth / 2;
 
 	// Slots de 4
-	slot4_1 = {col, row1};
-	slot4_2 = {col, row2};
-	slot4_3 = {col, row3};
-	slot4_4 = {col, row4};
+	slot4_1_ = {col, row1};
+	slot4_2_ = {col, row2};
+	slot4_3_ = {col, row3};
+	slot4_4_ = {col, row4};
 
 	// Primer cuadrado para poner el nombre de record
 	const int enterNameLenght = 8 * 7;
-	enterNamePos.x = (panelWidth - enterNameLenght) / 2;
-	enterNamePos.y = row4;
+	enter_name_pos_.x = (panelWidth - enterNameLenght) / 2;
+	enter_name_pos_.y = row4;
 
 	// Recoloca los sprites
-	if (powerMeterSprite)
+	if (power_meter_sprite_)
 	{
-		powerMeterSprite->setPosX(slot4_2.x - 20);
-		powerMeterSprite->setPosY(slot4_2.y);
+		power_meter_sprite_->setPosX(slot4_2_.x - 20);
+		power_meter_sprite_->setPosY(slot4_2_.y);
 	}
 }
 
 // Establece el modo del marcador
-void Scoreboard::setMode(int index, scoreboard_modes_e mode)
+void Scoreboard::setMode(int index, ScoreboardMode mode)
 {
-	panel[index].mode = mode;
+	panel_[index].mode = mode;
 }
 
 // Crea la textura de fondo
 void Scoreboard::createBackgroundTexture()
 {
 	// Elimina la textura en caso de existir
-	if (background)
+	if (background_)
 	{
-		SDL_DestroyTexture(background);
+		SDL_DestroyTexture(background_);
 	}
 
 	// Recrea la textura de fondo
-	background = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
-	SDL_SetTextureBlendMode(background, SDL_BLENDMODE_BLEND);
+	background_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
+	SDL_SetTextureBlendMode(background_, SDL_BLENDMODE_BLEND);
 }
 
 // Crea las texturas de los paneles
 void Scoreboard::createPanelTextures()
 {
 	// Elimina las texturas en caso de existir
-	for (auto texture : panelTexture)
+	for (auto texture : panel_texture_)
 	{
 		if (texture != nullptr)
 		{
 			SDL_DestroyTexture(texture);
 		}
 	}
-	panelTexture.clear();
+	panel_texture_.clear();
 
-	// Crea las texturas para cada panel
+	// Crea las texturas para cada panel_
 	for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
 	{
-		SDL_Texture *tex = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, panel[i].pos.w, panel[i].pos.h);
+		SDL_Texture *tex = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, panel_[i].pos.w, panel_[i].pos.h);
 		SDL_SetTextureBlendMode(tex, SDL_BLENDMODE_BLEND);
-		panelTexture.push_back(tex);
+		panel_texture_.push_back(tex);
 	}
 }
 
@@ -458,6 +469,6 @@ void Scoreboard::createPanelTextures()
 void Scoreboard::renderSeparator()
 {
 	// Dibuja la linea que separa el marcador de la zona de juego
-	SDL_SetRenderDrawColor(renderer, separatorColor.r, separatorColor.g, separatorColor.b, 255);
-	SDL_RenderDrawLine(renderer, 0, 0, rect.w, 0);
+	SDL_SetRenderDrawColor(renderer_, separator_color.r, separator_color.g, separator_color.b, 255);
+	SDL_RenderDrawLine(renderer_, 0, 0, rect_.w, 0);
 }

source/scoreboard.h

@@ -1,82 +1,86 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>	 // for SDL_Point, SDL_Rect
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h> // for Uint32
-#include <string>			 // for string, basic_string
-#include <vector>			 // for vector
-#include "utils.h"			 // for color_t
-class Asset;
+#include <SDL2/SDL_rect.h>    // for SDL_Point, SDL_Rect
+#include <SDL2/SDL_render.h>  // for SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_stdinc.h>  // for Uint32
+#include <memory>             // for unique_ptr, shared_ptr
+#include <string>             // for string
+#include <vector>             // for vector
+#include "utils.h"            // for Color
 class Sprite;
 class Text;
 class Texture;
 
 // Defines
-#define SCOREBOARD_LEFT_PANEL 0
-#define SCOREBOARD_CENTER_PANEL 1
-#define SCOREBOARD_RIGHT_PANEL 2
-#define SCOREBOARD_MAX_PANELS 3
-
-#define SCOREBOARD_TICK_SPEED 100
+constexpr int SCOREBOARD_LEFT_PANEL = 0;
+constexpr int SCOREBOARD_CENTER_PANEL = 1;
+constexpr int SCOREBOARD_RIGHT_PANEL = 2;
+constexpr int SCOREBOARD_MAX_PANELS = 3;
+constexpr int SCOREBOARD_TICK_SPEED = 100;
 
 // Enums
-enum scoreboard_modes_e
+enum class ScoreboardMode : int
 {
-	SCOREBOARD_MODE_SCORE,
-	SCOREBOARD_MODE_STAGE_INFO,
-	SCOREBOARD_MODE_CONTINUE,
-	SCOREBOARD_MODE_GAME_OVER,
-	SCOREBOARD_MODE_DEMO,
-	SCOREBOARD_MODE_ENTER_NAME,
-	SCOREBOARD_MODE_NUM_MODES,
+	SCORE,
+	STAGE_INFO,
+	CONTINUE,
+	WAITING,
+	GAME_OVER,
+	DEMO,
+	ENTER_NAME,
+	NUM_MODES,
 };
 
 // Structs
-struct panel_t
+struct Panel
 {
-	scoreboard_modes_e mode; // Modo en el que se encuentra el panel
-	SDL_Rect pos;			 // Posición donde dibujar el panel dentro del marcador
+	ScoreboardMode mode; // Modo en el que se encuentra el panel
+	SDL_Rect pos;		 // Posición donde dibujar el panel dentro del marcador
 };
 
 // Clase Scoreboard
 class Scoreboard
 {
 private:
+	// [SINGLETON] Objeto scoreboard privado para Don Melitón
+	static Scoreboard *scoreboard_;
+
 	// Objetos y punteros
-	SDL_Renderer *renderer;					 // El renderizador de la ventana
-	Asset *asset;							 // Objeto que gestiona todos los ficheros de recursos
-	Texture *gamePowerMeterTexture;			 // Textura con el marcador de poder de la fase
-	Sprite *powerMeterSprite;				 // Sprite para el medidor de poder de la fase
-	Text *textScoreBoard;					 // Fuente para el marcador del juego
-	SDL_Texture *background;				 // Textura para dibujar el marcador
-	std::vector<SDL_Texture *> panelTexture; // Texturas para dibujar cada panel;
+	SDL_Renderer *renderer_; // El renderizador de la ventana
+
+	std::shared_ptr<Texture> game_power_meter_texture_; // Textura con el marcador de poder de la fase
+	std::unique_ptr<Sprite> power_meter_sprite_;		// Sprite para el medidor de poder de la fase
+	std::unique_ptr<Text> text_scoreboard_;				// Fuente para el marcador del juego
+
+	SDL_Texture *background_;				   // Textura para dibujar el marcador
+	std::vector<SDL_Texture *> panel_texture_; // Texturas para dibujar cada panel
 
 	// Variables
-	int stage;									   // Número de fase actual
-	std::string name[SCOREBOARD_MAX_PANELS];	   // Nom de cada jugador
-	std::string recordName[SCOREBOARD_MAX_PANELS]; // Nombre introducido para la tabla de records
-	int selectorPos[SCOREBOARD_MAX_PANELS];		   // Posición del selector de letra para introducir el nombre
-	int score[SCOREBOARD_MAX_PANELS];			   // Puntuación de los jugadores
-	float mult[SCOREBOARD_MAX_PANELS];			   // Multiplicador de los jugadores
-	int continueCounter[SCOREBOARD_MAX_PANELS];	   // Tiempo para continuar de los jugadores
-	int hiScore;								   // Máxima puntuación
-	float power;								   // Poder actual de la fase
-	std::string hiScoreName;					   // Nombre del jugador con la máxima puntuación
-	color_t color;								   // Color del marcador
-	SDL_Rect rect;								   // Posición y dimensiones del marcador
-	panel_t panel[SCOREBOARD_MAX_PANELS];		   // Lista con todos los paneles del marcador
-	Uint32 ticks;								   // Variable donde almacenar el valor de SDL_GetTiks()
-	int counter;								   // Contador
+	std::string name_[SCOREBOARD_MAX_PANELS];		 // Nom de cada jugador
+	std::string record_name_[SCOREBOARD_MAX_PANELS]; // Nombre introducido para la tabla de records
+	int selector_pos_[SCOREBOARD_MAX_PANELS];		 // Posición del selector de letra para introducir el nombre
+	int score_[SCOREBOARD_MAX_PANELS];				 // Puntuación de los jugadores
+	float mult_[SCOREBOARD_MAX_PANELS];				 // Multiplicador de los jugadores
+	int continue_counter_[SCOREBOARD_MAX_PANELS];	 // Tiempo para continuar de los jugadores
+	Panel panel_[SCOREBOARD_MAX_PANELS];			 // Lista con todos los paneles del marcador
+	int stage_;										 // Número de fase actual
+	int hi_score_;									 // Máxima puntuación
+	float power_;									 // Poder actual de la fase
+	std::string hi_score_name_;						 // Nombre del jugador con la máxima puntuación
+	Color color_;									 // Color del marcador
+	SDL_Rect rect_;									 // Posición y dimensiones del marcador
+	Uint32 ticks_;									 // Variable donde almacenar el valor de SDL_GetTiks()
+	int counter_;									 // Contador
 
 	// Puntos predefinidos para colocar elementos en los paneles
-	SDL_Point slot4_1, slot4_2, slot4_3, slot4_4;
-	SDL_Point enterNamePos;
+	SDL_Point slot4_1_, slot4_2_, slot4_3_, slot4_4_;
+	SDL_Point enter_name_pos_;
 
 	// Recalcula las anclas de los elementos
 	void recalculateAnchors();
 
 	// Transforma un valor numérico en una cadena de 6 cifras
-	std::string updateScoreText(Uint32 num);
+	std::string updateScoreText(int num);
 
 	// Crea la textura de fondo
 	void createBackgroundTexture();
@@ -96,13 +100,24 @@ private:
 	// Dibuja la linea que separa la zona de juego del marcador
 	void renderSeparator();
 
-public:
+	// [SINGLETON] Ahora el constructor y el destructor son privados
+
 	// Constructor
-	Scoreboard(SDL_Renderer *renderer);
+	explicit Scoreboard(SDL_Renderer *renderer);
 
 	// Destructor
 	~Scoreboard();
 
+public:
+	// [SINGLETON] Crearemos el objeto scoreboard con esta función estática
+	static void init(SDL_Renderer *renderer);
+
+	// [SINGLETON] Destruiremos el objeto scoreboard con esta función estática
+	static void destroy();
+
+	// [SINGLETON] Con este método obtenemos el objeto scoreboard y podemos trabajar con él
+	static Scoreboard *get();
+
 	// Actualiza la lógica del marcador
 	void update();
 
@@ -110,10 +125,10 @@ public:
 	void render();
 
 	// Establece el valor de la variable
-	void setName(int panel, std::string name);
+	void setName(int panel, const std::string &name);
 
 	// Establece el valor de la variable
-	void setRecordName(int panel, std::string recordName);
+	void setRecordName(int panel, const std::string &record_name);
 
 	// Establece el valor de la variable
 	void setSelectorPos(int panel, int pos);
@@ -131,20 +146,20 @@ public:
 	void setStage(int stage);
 
 	// Establece el valor de la variable
-	void setHiScore(int hiScore);
+	void setHiScore(int hi_score);
 
 	// Establece el valor de la variable
 	void setPower(float power);
 
 	// Establece el valor de la variable
-	void setHiScoreName(std::string name);
+	void setHiScoreName(const std::string &name);
 
 	// Establece el valor de la variable
-	void setColor(color_t color);
+	void setColor(Color color);
 
 	// Establece el valor de la variable
 	void setPos(SDL_Rect rect);
 
 	// Establece el modo del marcador
-	void setMode(int index, scoreboard_modes_e mode);
+	void setMode(int index, ScoreboardMode mode);
 };

source/screen.cpp

@@ -7,115 +7,112 @@
 #include <fstream>           // for basic_ifstream, ifstream
 #include <iterator>          // for istreambuf_iterator, operator!=
 #include <string>            // for basic_string, operator+, to_string, cha...
+#include <vector>            // for vector
 #include "asset.h"           // for Asset
 #include "dbgtxt.h"          // for dbg_print
+#include "global_inputs.h"   // for servicePressedCounter
 #include "input.h"           // for Input, inputs_e, INPUT_DO_NOT_ALLOW_REPEAT
 #include "notify.h"          // for Notify
+#include "on_screen_help.h"  // for OnScreenHelp
 #include "options.h"         // for options
-#include "on_screen_help.h"
+#include "param.h"           // for param
 
 #ifndef NO_SHADERS
 #include "jail_shader.h" // for init, render
 #endif
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
-Screen *Screen::screen = nullptr;
+Screen *Screen::screen_ = nullptr;
 
 // [SINGLETON] Crearemos el objeto screen con esta función estática
 void Screen::init(SDL_Window *window, SDL_Renderer *renderer)
 {
-    Screen::screen = new Screen(window, renderer);
+    Screen::screen_ = new Screen(window, renderer);
 }
 
 // [SINGLETON] Destruiremos el objeto screen con esta función estática
 void Screen::destroy()
 {
-    delete Screen::screen;
+    delete Screen::screen_;
 }
 
 // [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
 Screen *Screen::get()
 {
-    return Screen::screen;
+    return Screen::screen_;
 }
 
 // Constructor
-Screen::Screen(SDL_Window *window, SDL_Renderer *renderer) : window(window), renderer(renderer)
-{
-    // Copia punteros
-    input = Input::get();
-    asset = Asset::get();
+Screen::Screen(SDL_Window *window, SDL_Renderer *renderer)
+    : window_(window),
+      renderer_(renderer),
 
-    // Inicializa variables
-    SDL_GetRendererOutputSize(renderer, &windowWidth, &windowHeight);
-    gameCanvasWidth = options.video.gameWidth;
-    gameCanvasHeight = options.video.gameHeight;
-    dest = {0, 0, 0, 0};
-    borderColor = {0, 0, 0};
-    flashEffect.enabled = false;
-    flashEffect.counter = 0;
-    flashEffect.lenght = 0;
-    flashEffect.color = {0xFF, 0xFF, 0xFF};
-    shakeEffect.desp = 1;
-    shakeEffect.delay = 3;
-    shakeEffect.counter = 0;
-    shakeEffect.lenght = 8;
-    shakeEffect.remaining = 0;
-    shakeEffect.origin = 0;
-    attenuateEffect = false;
-    fpsTicks = 0;
-    fpsCounter = 0;
-    fps = 0;
+      notify_(std::make_unique<Notify>(renderer_, std::string(), Asset::get()->get("8bithud.png"), Asset::get()->get("8bithud.txt"), Asset::get()->get("notify.wav"))),
+      game_canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
+      shader_canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
+
+      src_rect_({0, 0, param.game.width, param.game.height}),
+      dst_rect_({0, 0, param.game.width, param.game.height}),
+      border_color_({0x00, 0x00, 0x00}),
+      attenuate_effect_(false),
+      fps_ticks_(0),
+      fps_counter_(0),
+      fps_(0),
 #ifdef DEBUG
-    showInfo = false;
+      show_info_(true)
 #else
-    showInfo = false;
+      show_info_(false)
 #endif
+{
+    // Inicializa variables
+    flash_effect_.enabled = false;
+    flash_effect_.counter = 0;
+    flash_effect_.lenght = 0;
+    flash_effect_.color = {0xFF, 0xFF, 0xFF};
+    shake_effect_.enabled = false;
+    shake_effect_.desp = 2;
+    shake_effect_.delay = 3;
+    shake_effect_.counter = 0;
+    shake_effect_.lenght = 8;
+    shake_effect_.remaining = 0;
+    shake_effect_.originalPos = 0;
+    shake_effect_.originalWidth = param.game.width;
     SDL_DisplayMode DM;
     SDL_GetCurrentDisplayMode(0, &DM);
-    infoResolution = std::to_string(DM.w) + " X " + std::to_string(DM.h) + " AT " + std::to_string(DM.refresh_rate) + " HZ";
-
-    // Crea los objetos
-    notify = new Notify(renderer, "", asset->get("8bithud.png"), asset->get("8bithud.txt"), asset->get("notify.wav"));
-
-    // Define el color del borde para el modo de pantalla completa
-    borderColor = {0x00, 0x00, 0x00};
-
-    // Crea la textura donde se dibujan los graficos del juego
-    gameCanvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, gameCanvasWidth, gameCanvasHeight);
+    info_resolution_ = std::to_string(DM.w) + " X " + std::to_string(DM.h) + " AT " + std::to_string(DM.refresh_rate) + " HZ";
 
     // Establece el modo de video
     setVideoMode(options.video.mode);
 
     // Muestra la ventana
-    SDL_ShowWindow(window);
+    SDL_ShowWindow(window_);
 }
 
 // Destructor
 Screen::~Screen()
 {
-    delete notify;
-    SDL_DestroyTexture(gameCanvas);
+    SDL_DestroyTexture(game_canvas_);
+    SDL_DestroyTexture(shader_canvas_);
 }
 
 // Limpia la pantalla
-void Screen::clean(color_t color)
+void Screen::clean(Color color)
 {
-    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
-    SDL_RenderClear(renderer);
+    SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 0xFF);
+    SDL_RenderClear(renderer_);
 }
 
 // Prepara para empezar a dibujar en la textura de juego
 void Screen::start()
 {
-    SDL_SetRenderTarget(renderer, gameCanvas);
+    SDL_SetRenderTarget(renderer_, game_canvas_);
 }
 
 // Vuelca el contenido del renderizador en pantalla
 void Screen::blit()
 {
     // Actualiza el contador de FPS
-    fpsCounter++;
+    fps_counter_++;
 
     // Actualiza y dibuja el efecto de flash en la pantalla
     doFlash();
@@ -130,57 +127,70 @@ void Screen::blit()
     displayInfo();
 
     // Muestra las notificaciones
-    notify->render();
+    notify_->render();
 
 #ifdef NO_SHADERS
     // Vuelve a dejar el renderizador en modo normal
-    SDL_SetRenderTarget(renderer, nullptr);
+    SDL_SetRenderTarget(renderer_, nullptr);
 
     // Borra el contenido previo
-    SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
-    SDL_RenderClear(renderer);
+    SDL_SetRenderDrawColor(renderer_, border_color_.r, border_color_.g, border_color_.b, 0xFF);
+    SDL_RenderClear(renderer_);
 
     // Copia la textura de juego en el renderizador en la posición adecuada
-    SDL_RenderCopy(renderer, gameCanvas, nullptr, &dest);
+    if (shake_effect_.enabled)
+        SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
+    SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
 
     // Muestra por pantalla el renderizador
-    SDL_RenderPresent(renderer);
+    SDL_RenderPresent(renderer_);
 #else
     if (options.video.shaders)
     {
+        SDL_SetRenderTarget(renderer_, shader_canvas_);
+        SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
+        SDL_RenderClear(renderer_);
+        if (shake_effect_.enabled)
+            SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
+        SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
+        SDL_SetRenderTarget(renderer_, nullptr);
         shader::render();
     }
     else
     {
         // Vuelve a dejar el renderizador en modo normal
-        SDL_SetRenderTarget(renderer, nullptr);
+        SDL_SetRenderTarget(renderer_, nullptr);
 
-        // Borra el contenido previo
-        SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
-        SDL_RenderClear(renderer);
+        // Borra el render
+        SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
+        SDL_RenderClear(renderer_);
 
         // Copia la textura de juego en el renderizador en la posición adecuada
-        SDL_RenderCopy(renderer, gameCanvas, nullptr, &dest);
+        if (shake_effect_.enabled)
+            SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
+        SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
 
         // Muestra por pantalla el renderizador
-        SDL_RenderPresent(renderer);
+        SDL_RenderPresent(renderer_);
     }
 #endif
 }
 
 // Establece el modo de video
-void Screen::setVideoMode(int videoMode)
+void Screen::setVideoMode(ScreenVideoMode videoMode)
 {
 #ifdef ARCADE
-    videoMode = SCREEN_VIDEO_MODE_WINDOW;
-    // videoMode = SCREEN_VIDEO_MODE_FULLSCREEN;
+    options.video.mode = ScreenVideoMode::WINDOW;
+#else
+    options.video.mode = videoMode;
 #endif
 
-    // Si está activo el modo ventana quita el borde
-    if (videoMode == SCREEN_VIDEO_MODE_WINDOW)
+    switch (options.video.mode)
     {
-        // Aplica el modo de video
-        SDL_SetWindowFullscreen(window, 0);
+    case ScreenVideoMode::WINDOW:
+    {
+        // Cambia a modo de ventana
+        SDL_SetWindowFullscreen(window_, 0);
 
 #ifdef ARCADE
         // Oculta el puntero
@@ -189,117 +199,45 @@ void Screen::setVideoMode(int videoMode)
         // Muestra el puntero
         SDL_ShowCursor(SDL_ENABLE);
 #endif
-
-        windowWidth = gameCanvasWidth;
-        windowHeight = gameCanvasHeight;
-        dest = {0, 0, windowWidth, windowHeight};
-
         // Modifica el tamaño de la ventana
-        SDL_SetWindowSize(window, windowWidth * options.video.window.size, windowHeight * options.video.window.size);
-        SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+        SDL_SetWindowSize(window_, param.game.width * options.video.window.size, param.game.height * options.video.window.size);
+        SDL_SetWindowPosition(window_, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+
+        break;
     }
 
     // Si está activo el modo de pantalla completa añade el borde
-    else if (videoMode == SCREEN_VIDEO_MODE_FULLSCREEN)
+    case ScreenVideoMode::FULLSCREEN:
     {
         // Aplica el modo de video
-        SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
-#ifdef ARCADE
-        /*SDL_DisplayMode DM;
-        DM.w = 1024;
-        DM.h = 600;
-        DM.refresh_rate = 60;
-        if (!SDL_SetWindowDisplayMode(window, &DM))
-        {
-            std::cout << SDL_GetError() << std::endl;
-        }
-        else
-        {
-            std::cout << "Changed windows display mode" << std::endl;
-        }*/
-#endif
+        SDL_SetWindowFullscreen(window_, SDL_WINDOW_FULLSCREEN_DESKTOP);
 
         // Oculta el puntero
         SDL_ShowCursor(SDL_DISABLE);
 
-        // Obten el alto y el ancho de la ventana
-        // SDL_GetWindowSize(window, &windowWidth, &windowHeight);
-
-        // Aplica el escalado al rectangulo donde se pinta la textura del juego
-        if (options.video.integerScale)
-        {
-            // Calcula el tamaño de la escala máxima
-            int scale = 0;
-            while (((gameCanvasWidth * (scale + 1)) <= windowWidth) && ((gameCanvasHeight * (scale + 1)) <= windowHeight))
-            {
-                scale++;
-            }
-
-            dest.w = gameCanvasWidth * scale;
-            dest.h = gameCanvasHeight * scale;
-            dest.x = (windowWidth - dest.w) / 2;
-            dest.y = (windowHeight - dest.h) / 2;
-        }
-        else if (options.video.keepAspect)
-        {
-            float ratio = (float)gameCanvasWidth / (float)gameCanvasHeight;
-            if ((windowWidth - gameCanvasWidth) >= (windowHeight - gameCanvasHeight))
-            {
-                dest.h = windowHeight;
-                dest.w = (int)((windowHeight * ratio) + 0.5f);
-                dest.x = (windowWidth - dest.w) / 2;
-                dest.y = (windowHeight - dest.h) / 2;
-            }
-            else
-            {
-                dest.w = windowWidth;
-                dest.h = (int)((windowWidth / ratio) + 0.5f);
-                dest.x = (windowWidth - dest.w) / 2;
-                dest.y = (windowHeight - dest.h) / 2;
-            }
-        }
-        else
-        {
-            // dest = {0, 0, windowWidth, windowHeight};
-            dest = {0, 0, gameCanvasWidth, gameCanvasHeight};
-        }
+        break;
+    }
+
+    default:
+        break;
     }
 
-#ifdef NO_SHADERS
-    // El renderizador pasa a tener el tamaño de la pantalla en fullscreen o del juego en modo ventana
-    SDL_RenderSetLogicalSize(renderer, windowWidth, windowHeight);
-#else
     // Reinicia los shaders
     if (options.video.shaders)
     {
-        std::ifstream f(asset->get("crtpi.glsl").c_str());
+#ifndef NO_SHADERS
+        std::ifstream f(Asset::get()->get("crtpi.glsl").c_str());
         std::string source((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
 
-        shader::init(window, gameCanvas, source.c_str());
-    }
-
-    // Modifica el tamaño del renderizador
-    else
-    {
-        // El renderizador pasa a tener el tamaño de la pantalla en fullscreen o del juego en modo ventana
-        // SDL_RenderSetLogicalSize(renderer, windowWidth, windowHeight);
-        SDL_RenderSetLogicalSize(renderer, gameCanvasWidth, gameCanvasHeight);
-    }
+        shader::init(window_, shader_canvas_, source.c_str());
 #endif
-
-    // Actualiza las opciones
-    options.video.mode = videoMode;
-    options.video.window.width = windowWidth;
-    options.video.window.height = windowHeight;
-
-    // Actualiza variables
-    shakeEffect.origin = dest.x;
+    }
 }
 
 // Camibia entre pantalla completa y ventana
 void Screen::switchVideoMode()
 {
-    options.video.mode = options.video.mode == SCREEN_VIDEO_MODE_WINDOW ? SCREEN_VIDEO_MODE_FULLSCREEN : SCREEN_VIDEO_MODE_WINDOW;
+    options.video.mode = options.video.mode == ScreenVideoMode::WINDOW ? ScreenVideoMode::FULLSCREEN : ScreenVideoMode::WINDOW;
     setVideoMode(options.video.mode);
 }
 
@@ -307,7 +245,7 @@ void Screen::switchVideoMode()
 void Screen::setWindowSize(int size)
 {
     options.video.window.size = size;
-    setVideoMode(SCREEN_VIDEO_MODE_WINDOW);
+    setVideoMode(ScreenVideoMode::WINDOW);
 }
 
 // Reduce el tamaño de la ventana
@@ -315,7 +253,7 @@ void Screen::decWindowSize()
 {
     --options.video.window.size;
     options.video.window.size = std::max(options.video.window.size, 1);
-    setVideoMode(SCREEN_VIDEO_MODE_WINDOW);
+    setVideoMode(ScreenVideoMode::WINDOW);
 }
 
 // Aumenta el tamaño de la ventana
@@ -323,26 +261,26 @@ void Screen::incWindowSize()
 {
     ++options.video.window.size;
     options.video.window.size = std::min(options.video.window.size, 4);
-    setVideoMode(SCREEN_VIDEO_MODE_WINDOW);
+    setVideoMode(ScreenVideoMode::WINDOW);
 }
 
 // Cambia el color del borde
-void Screen::setBorderColor(color_t color)
+void Screen::setBorderColor(Color color)
 {
-    borderColor = color;
+    border_color_ = color;
 }
 
 // Cambia el tipo de mezcla
 void Screen::setBlendMode(SDL_BlendMode blendMode)
 {
-    SDL_SetRenderDrawBlendMode(renderer, blendMode);
+    SDL_SetRenderDrawBlendMode(renderer_, blendMode);
 }
 
 // Actualiza la lógica de la clase
 void Screen::update()
 {
-    updateShake();
-    notify->update();
+    updateShakeEffect();
+    notify_->update();
     updateFPS();
     OnScreenHelp::get()->update();
 }
@@ -352,16 +290,16 @@ void Screen::checkInput()
 {
 #ifndef ARCADE
     // Comprueba el teclado para cambiar entre pantalla completa y ventana
-    if (input->checkInput(input_window_fullscreen, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
+    if (Input::get()->checkInput(InputType::WINDOW_FULLSCREEN, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
     {
         switchVideoMode();
-        const std::string mode = options.video.mode == SCREEN_VIDEO_MODE_WINDOW ? "Window" : "Fullscreen";
+        const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? "Window" : "Fullscreen";
         showNotification(mode + " mode");
         return;
     }
 
     // Comprueba el teclado para decrementar el tamaño de la ventana
-    if (input->checkInput(input_window_dec_size, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
+    if (Input::get()->checkInput(InputType::WINDOW_DEC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
     {
         decWindowSize();
         const std::string size = std::to_string(options.video.window.size);
@@ -370,7 +308,7 @@ void Screen::checkInput()
     }
 
     // Comprueba el teclado para incrementar el tamaño de la ventana
-    if (input->checkInput(input_window_inc_size, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
+    if (Input::get()->checkInput(InputType::WINDOW_INC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
     {
         incWindowSize();
         const std::string size = std::to_string(options.video.window.size);
@@ -380,7 +318,7 @@ void Screen::checkInput()
 #endif
 
     // Comprueba el teclado para activar o desactivar los shaders
-    if (input->checkInput(input_video_shaders, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
+    if (Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
     {
         switchShaders();
         return;
@@ -388,26 +326,26 @@ void Screen::checkInput()
 
 #ifdef DEBUG
     // Comprueba el teclado para mostrar la información de debug
-    if (input->checkInput(input_showinfo, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
+    if (Input::get()->checkInput(InputType::SHOWINFO, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
     {
-        showInfo = !showInfo;
+        show_info_ = !show_info_;
         return;
     }
 #endif
 
-    for (int i = 0; i < input->getNumControllers(); ++i)
+    for (int i = 0; i < Input::get()->getNumControllers(); ++i)
     {
         // Comprueba los mandos para activar o desactivar los shaders
-        if (input->checkModInput(input_service, input_video_shaders, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+        if (Input::get()->checkModInput(InputType::SERVICE, InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
         {
             switchShaders();
             return;
         }
 
         // Comprueba los mandos para mostrar la información de debug
-        if (input->checkModInput(input_service, input_showinfo, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+        if (Input::get()->checkModInput(InputType::SERVICE, InputType::SHOWINFO, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
         {
-            showInfo = !showInfo;
+            show_info_ = !show_info_;
             return;
         }
     }
@@ -416,75 +354,85 @@ void Screen::checkInput()
 // Agita la pantalla
 void Screen::shake()
 {
-    // Si ya hay un shake effect en marcha no se pilla el origen, solo se renuevan los contadores
-    if (shakeEffect.remaining == 0)
+    // Si no hay un shake effect activo, se guarda una copia de los valores actuales antes de modificarlos
+    if (!shake_effect_.enabled)
     {
-        shakeEffect.origin = dest.x;
+        shake_effect_.enabled = true;
+        shake_effect_.originalPos = src_rect_.x;
+        shake_effect_.originalWidth = src_rect_.w;
+        src_rect_.w -= shake_effect_.desp;
+        dst_rect_.w = src_rect_.w;
     }
 
-    shakeEffect.remaining = shakeEffect.lenght;
-    shakeEffect.counter = shakeEffect.delay;
+    // Si ya hay un shake effect en marcha no se pilla el origen, solo se renuevan los contadores
+    shake_effect_.remaining = shake_effect_.lenght;
+    shake_effect_.counter = shake_effect_.delay;
 }
 
 // Actualiza la logica para agitar la pantalla
-void Screen::updateShake()
+void Screen::updateShakeEffect()
 {
-    if (shakeEffect.remaining > 0)
+    if (shake_effect_.enabled)
     {
-        if (shakeEffect.counter > 0)
+        if (shake_effect_.counter > 0)
         {
-            shakeEffect.counter--;
+            shake_effect_.counter--;
         }
         else
         {
-            shakeEffect.counter = shakeEffect.delay;
-            const int desp = shakeEffect.remaining % 2 == 0 ? shakeEffect.desp * (-1) : shakeEffect.desp;
-            dest.x = shakeEffect.origin + desp;
-            shakeEffect.remaining--;
+            shake_effect_.counter = shake_effect_.delay;
+            const auto srcdesp = shake_effect_.remaining % 2 == 0 ? 0 : shake_effect_.desp;
+            const auto dstdesp = shake_effect_.remaining % 2 == 1 ? 0 : shake_effect_.desp;
+            src_rect_.x = shake_effect_.originalPos + srcdesp;
+            dst_rect_.x = shake_effect_.originalPos + dstdesp;
+            shake_effect_.remaining--;
+            shake_effect_.enabled = shake_effect_.remaining == -1 ? false : true;
+            if (!shake_effect_.enabled)
+            {
+                src_rect_.x = shake_effect_.originalPos;
+                src_rect_.w = shake_effect_.originalWidth;
+                dst_rect_ = src_rect_;
+            }
         }
     }
-    else
-    {
-        dest.x = shakeEffect.origin;
-    }
 }
 
 // Pone la pantalla de color
-void Screen::flash(color_t color, int lenght)
+void Screen::flash(Color color, int lenght)
 {
-    flashEffect.enabled = true;
-    flashEffect.counter = 0;
-    flashEffect.lenght = lenght;
-    flashEffect.color = color;
+    flash_effect_.enabled = true;
+    flash_effect_.counter = 0;
+    flash_effect_.lenght = lenght;
+    flash_effect_.color = color;
 }
 
 // Actualiza y dibuja el efecto de flash en la pantalla
 void Screen::doFlash()
 {
-    if (flashEffect.enabled)
+    if (flash_effect_.enabled)
     {
         // Dibuja el color del flash en la textura
-        SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-        SDL_SetRenderTarget(renderer, gameCanvas);
-        SDL_SetRenderDrawColor(renderer, flashEffect.color.r, flashEffect.color.g, flashEffect.color.b, 0xFF);
-        SDL_RenderClear(renderer);
-        SDL_SetRenderTarget(renderer, temp);
+        SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
+        SDL_SetRenderTarget(renderer_, game_canvas_);
+        SDL_SetRenderDrawColor(renderer_, flash_effect_.color.r, flash_effect_.color.g, flash_effect_.color.b, 0xFF);
+        SDL_RenderClear(renderer_);
+        SDL_SetRenderTarget(renderer_, temp);
 
         // Actualiza la lógica del efecto
-        flashEffect.counter < flashEffect.lenght ? flashEffect.counter++ : flashEffect.enabled = false;
+        flash_effect_.counter < flash_effect_.lenght ? flash_effect_.counter++ : flash_effect_.enabled = false;
     }
 }
 
 // Atenua la pantalla
 void Screen::doAttenuate()
 {
-    if (attenuateEffect)
+    if (attenuate_effect_)
     {
-        SDL_Texture *temp = SDL_GetRenderTarget(renderer);
-        SDL_SetRenderTarget(renderer, gameCanvas);
-        SDL_SetRenderDrawColor(renderer, 0, 0, 0, 64);
-        SDL_RenderFillRect(renderer, nullptr);
-        SDL_SetRenderTarget(renderer, temp);
+        SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
+        SDL_SetRenderTarget(renderer_, game_canvas_);
+        SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 64);
+        SDL_RenderFillRect(renderer_, nullptr);
+        SDL_SetRenderTarget(renderer_, temp);
     }
 }
 
@@ -500,48 +448,50 @@ void Screen::switchShaders()
 // Atenua la pantalla
 void Screen::attenuate(bool value)
 {
-    attenuateEffect = value;
+    attenuate_effect_ = value;
 }
 
 // Muestra una notificación de texto por pantalla;
-void Screen::showNotification(std::string text1, std::string text2, int icon)
+void Screen::showNotification(const std::string &text1, const std::string &text2, int icon)
 {
-    notify->showText(text1, text2, icon);
+    notify_->showText(text1, text2, icon);
 }
 
 // Obtiene el puntero al renderizador
 SDL_Renderer *Screen::getRenderer()
 {
-    return renderer;
+    return renderer_;
 }
 
 // Calcula los frames por segundo
 void Screen::updateFPS()
 {
-    if (SDL_GetTicks() - fpsTicks > 1000)
+    if (SDL_GetTicks() - fps_ticks_ > 1000)
     {
-        fpsTicks = SDL_GetTicks();
-        fps = fpsCounter;
-        fpsCounter = 0;
+        fps_ticks_ = SDL_GetTicks();
+        fps_ = fps_counter_;
+        fps_counter_ = 0;
     }
 }
 
 // Muestra información por pantalla
 void Screen::displayInfo()
 {
-    if (showInfo)
+    if (show_info_)
     {
         // FPS
-        const std::string fpstext = std::to_string(fps) + " FPS";
-        dbg_print(gameCanvasWidth - fpstext.length() * 8, 0, fpstext.c_str(), 255, 255, 0);
+        const std::string fpstext = std::to_string(fps_) + " FPS";
+        dbg_print(param.game.width - fpstext.length() * 8, 0, fpstext.c_str(), 255, 255, 0);
 
         // Resolution
-        dbg_print(0, 0, infoResolution.c_str(), 255, 255, 0);
+        dbg_print(0, 0, info_resolution_.c_str(), 255, 255, 0);
+
+        dbg_print(0, 8, std::to_string(globalInputs::service_pressed_counter[0]).c_str(), 255, 255, 0);
     }
 }
 
 // Indica si hay alguna notificación activa en pantalla
-bool Screen::notificationsAreActive()
+bool Screen::notificationsAreActive() const
 {
-    return notify->active();
+    return notify_->active();
 }

source/screen.h

@@ -1,73 +1,77 @@
 #pragma once
 
-#include <SDL2/SDL_blendmode.h>  // for SDL_BlendMode
-#include <SDL2/SDL_rect.h>       // for SDL_Rect
-#include <SDL2/SDL_render.h>     // for SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h>     // for Uint32
-#include <SDL2/SDL_video.h>      // for SDL_Window
-#include <string>                // for basic_string, string
-#include "utils.h"               // for color_t
-class Asset;
-class Input;
+#include <SDL2/SDL_blendmode.h> // for SDL_BlendMode
+#include <SDL2/SDL_rect.h>		// for SDL_Rect
+#include <SDL2/SDL_render.h>	// for SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_stdinc.h>	// for Uint32
+#include <SDL2/SDL_video.h>		// for SDL_Window
+#include <string>				// for basic_string, string
+#include "utils.h"				// for Color
+#include <memory>
 class Notify;
 
-#define SCREEN_FILTER_NEAREST 0
-#define SCREEN_FILTER_LINEAL 1
+enum class ScreenFilter : int
+{
+	NEAREST = 0,
+	LINEAL = 1,
+};
 
-#define SCREEN_VIDEO_MODE_WINDOW 0
-#define SCREEN_VIDEO_MODE_FULLSCREEN 1
+enum class ScreenVideoMode : int
+{
+	WINDOW = 0,
+	FULLSCREEN = 1,
+};
 
 class Screen
 {
 private:
 	// [SINGLETON] Objeto screen privado para Don Melitón
-	static Screen *screen;
+	static Screen *screen_;
 
 	// Objetos y punteros
-	SDL_Window *window;		 // Ventana de la aplicación
-	SDL_Renderer *renderer;	 // El renderizador de la ventana
-	Asset *asset;			 // Objeto con el listado de recursos
-	Input *input;			 // Objeto para leer las entradas de teclado o mando
-	Notify *notify;			 // Pinta notificaciones en pantalla
-	SDL_Texture *gameCanvas; // Textura para completar la ventana de juego hasta la pantalla completa
+	SDL_Window *window_;			 // Ventana de la aplicación
+	SDL_Renderer *renderer_;		 // El renderizador de la ventana
+	std::unique_ptr<Notify> notify_; // Pinta notificaciones en pantalla
+	SDL_Texture *game_canvas_;		 // Textura donde se dibuja todo antes de volcarse al renderizador
+	SDL_Texture *shader_canvas_;	 // Textura para pasarle al shader desde gameCanvas
 
 	// Variables
-	int windowWidth;			// Ancho de la pantalla o ventana
-	int windowHeight;			// Alto de la pantalla o ventana
-	int gameCanvasWidth;		// Resolución interna del juego. Es el ancho de la textura donde se dibuja el juego
-	int gameCanvasHeight;		// Resolución interna del juego. Es el alto de la textura donde se dibuja el juego
-	SDL_Rect dest;				// Coordenadas donde se va a dibujar la textura del juego sobre la pantalla o ventana
-	color_t borderColor;		// Color del borde añadido a la textura de juego para rellenar la pantalla
-	bool attenuateEffect;		// Indica si la pantalla ha de estar atenuada
-	Uint32 fpsTicks;			// Ticks para contar los frames por segundo
-	int fpsCounter;				// Contador de frames por segundo
-	int fps;					// Frames calculados en el último segundo
-	bool showInfo;				// Indica si ha de mostrar/ocultar la información de la pantalla
-	std::string infoResolution; // Texto con la informacion de la pantalla
+	SDL_Rect src_rect_;			  // Coordenadas de donde va a pillar la textura del juego para dibujarla
+	SDL_Rect dst_rect_;			  // Coordenadas donde se va a dibujar la textura del juego sobre la pantalla o ventana
+	Color border_color_;		  // Color del borde añadido a la textura de juego para rellenar la pantalla
+	bool attenuate_effect_;		  // Indica si la pantalla ha de estar atenuada
+	Uint32 fps_ticks_;			  // Ticks para contar los frames por segundo
+	int fps_counter_;			  // Contador de frames por segundo
+	int fps_;					  // Frames calculados en el último segundo
+	bool show_info_;			  // Indica si ha de mostrar/ocultar la información de la pantalla
+	std::string info_resolution_; // Texto con la informacion de la pantalla
 
-	struct effect_t
+	struct FlashEffect
 	{
-		bool enabled;  // Indica si el efecto está activo
-		int counter;   // Contador para el efecto
-		int lenght;	   // Duración del efecto
-		color_t color; // Color del efecto
+		bool enabled; // Indica si el efecto está activo
+		int counter;  // Contador para el efecto
+		int lenght;	  // Duración del efecto
+		Color color;  // Color del efecto
+	};
+
+	struct ShakeEffect
+	{
+		int desp;		   // Pixels de desplazamiento para agitar la pantalla en el eje x
+		int delay;		   // Retraso entre cada desplazamiento de la pantalla al agitarse
+		int counter;	   // Contador para el retraso
+		int lenght;		   // Cantidad de desplazamientos a realizar
+		int remaining;	   // Cantidad de desplazamientos pendientes a realizar
+		int originalPos;   // Posición inicial de la pantalla para dejarla igual tras el desplazamiento
+		int originalWidth; // Anchura inicial de la pantalla para dejarla igual tras el desplazamiento
+		bool enabled;	   // Indica si el efecto está activo
 	};
 
 	// Variables - Efectos
-	effect_t flashEffect; // Variable para gestionar el efecto de flash
-
-	struct shake_t
-	{
-		int desp;	   // Pixels de desplazamiento para agitar la pantalla en el eje x
-		int delay;	   // Retraso entre cada desplazamiento de la pantalla al agitarse
-		int counter;   // Contador para el retraso
-		int lenght;	   // Cantidad de desplazamientos a realizar
-		int remaining; // Cantidad de desplazamientos pendientes a realizar
-		int origin;	   // Valor inicial de la pantalla para dejarla igual tras el desplazamiento
-	} shakeEffect;
+	FlashEffect flash_effect_; // Variable para gestionar el efecto de flash
+	ShakeEffect shake_effect_; // Variable para gestionar el efecto de agitar la pantalla
 
 	// Actualiza la logica para agitar la pantalla
-	void updateShake();
+	void updateShakeEffect();
 
 	// Actualiza y dibuja el efecto de flash en la pantalla
 	void doFlash();
@@ -81,7 +85,6 @@ private:
 	// Muestra información por pantalla
 	void displayInfo();
 
-
 	// [SINGLETON] Ahora el constructor y el destructor son privados, para no poder crear objetos screen desde fuera
 
 	// Constructor
@@ -107,7 +110,7 @@ public:
 	void checkInput();
 
 	// Limpia la pantalla
-	void clean(color_t color = {0x00, 0x00, 0x00});
+	void clean(Color color = {0x00, 0x00, 0x00});
 
 	// Prepara para empezar a dibujar en la textura de juego
 	void start();
@@ -116,7 +119,7 @@ public:
 	void blit();
 
 	// Establece el modo de video
-	void setVideoMode(int videoMode);
+	void setVideoMode(ScreenVideoMode video_mode);
 
 	// Camibia entre pantalla completa y ventana
 	void switchVideoMode();
@@ -131,16 +134,16 @@ public:
 	void incWindowSize();
 
 	// Cambia el color del borde
-	void setBorderColor(color_t color);
+	void setBorderColor(Color color);
 
 	// Cambia el tipo de mezcla
-	void setBlendMode(SDL_BlendMode blendMode);
+	void setBlendMode(SDL_BlendMode blend_mode);
 
 	// Agita la pantalla
 	void shake();
 
 	// Pone la pantalla de color
-	void flash(color_t color, int lenght);
+	void flash(Color color, int lenght);
 
 	// Activa/desactiva los shaders
 	void switchShaders();
@@ -149,10 +152,10 @@ public:
 	void attenuate(bool value);
 
 	// Muestra una notificación de texto por pantalla;
-	void showNotification(std::string text1 = "", std::string text2 = "", int icon = -1);
+	void showNotification(const std::string &text1 = std::string(), const std::string &text2 = std::string(), int icon = -1);
 
 	// Indica si hay alguna notificación activa en pantalla
-	bool notificationsAreActive();
+	bool notificationsAreActive() const;
 
 	// Obtiene el puntero al renderizador
 	SDL_Renderer *getRenderer();

source/section.cpp

@@ -2,6 +2,6 @@
 
 namespace section
 {
-    name_e name;
-    options_e options;
+    Name name;
+    Options options;
 }

source/section.h

@@ -3,31 +3,31 @@
 namespace section
 {
     // Secciones del programa
-    enum name_e
+    enum class Name
     {
-        NAME_INIT = 0,
-        NAME_LOGO = 1,
-        NAME_INTRO = 2,
-        NAME_TITLE = 3,
-        NAME_GAME = 4,
-        NAME_HI_SCORE_TABLE = 5,
-        NAME_GAME_DEMO = 6,
-        NAME_INSTRUCTIONS = 7,
-        NAME_QUIT = 8,
+        INIT = 0,
+        LOGO = 1,
+        INTRO = 2,
+        TITLE = 3,
+        GAME = 4,
+        HI_SCORE_TABLE = 5,
+        GAME_DEMO = 6,
+        INSTRUCTIONS = 7,
+        QUIT = 8,
     };
 
     // Opciones para la sección
-    enum options_e
+    enum class Options
     {
-        OPTIONS_GAME_PLAY_1P = 0,
-        OPTIONS_GAME_PLAY_2P = 1,
-        OPTIONS_TITLE_1 = 2,
-        OPTIONS_TITLE_2 = 3,
-        OPTIONS_QUIT_NORMAL = 4,
-        OPTIONS_QUIT_SHUTDOWN = 5,
-        OPTIONS_NULL = 6,
+        GAME_PLAY_1P = 0,
+        GAME_PLAY_2P = 1,
+        TITLE_1 = 2,
+        TITLE_2 = 3,
+        QUIT_NORMAL = 4,
+        QUIT_SHUTDOWN = 5,
+        NONE = 6,
     };
 
-    extern name_e name;
-    extern options_e options;
+    extern Name name;
+    extern Options options;
 }

source/smart_sprite.cpp

@@ -1,101 +1,64 @@
 #include "smart_sprite.h"
-#include "moving_sprite.h"  // for MovingSprite
+#include "moving_sprite.h" // for MovingSprite
 class Texture;
 
 // Constructor
-SmartSprite::SmartSprite(Texture *texture)
+SmartSprite::SmartSprite(std::shared_ptr<Texture> texture)
+	: AnimatedSprite(texture)
 {
-	// Copia punteros
-	setTexture(texture);
-
-	// Inicializa el objeto
 	init();
 }
 
 // Inicializa el objeto
 void SmartSprite::init()
 {
-	enabled = false;
-	enabledCounter = 0;
-	onDestination = false;
-	destX = 0;
-	destY = 0;
-	counter = 0;
-	finished = false;
+	finished_counter_ = 0;
+	on_destination_ = false;
+	dest_x_ = 0;
+	dest_y_ = 0;
+	finished_ = false;
+	enabled_ = false;
 }
 
 // Actualiza la posición y comprueba si ha llegado a su destino
 void SmartSprite::update()
 {
-	if (enabled)
+	if (enabled_)
 	{
-		// Actualiza las variables internas del objeto
 		MovingSprite::update();
-
-		// Comprueba el movimiento
 		checkMove();
-
-		// Comprueba si ha terminado
 		checkFinished();
 	}
 }
 
-// Pinta el objeto en pantalla
-void SmartSprite::render()
-{
-	if (enabled)
-	{
-		// Muestra el sprite por pantalla
-		MovingSprite::render();
-	}
-}
-
-// Obtiene el valor de la variable
-bool SmartSprite::isEnabled()
-{
-	return enabled;
-}
-
 // Establece el valor de la variable
-void SmartSprite::setEnabled(bool enabled)
+void SmartSprite::setFinishedCounter(int value)
 {
-	this->enabled = enabled;
-}
-
-// Obtiene el valor de la variable
-int SmartSprite::getEnabledCounter()
-{
-	return enabledCounter;
-}
-
-// Establece el valor de la variable
-void SmartSprite::setEnabledCounter(int value)
-{
-	enabledCounter = value;
+	finished_counter_ = value;
 }
 
 // Establece el valor de la variable
 void SmartSprite::setDestX(int x)
 {
-	destX = x;
+	dest_x_ = x;
 }
 
 // Establece el valor de la variable
 void SmartSprite::setDestY(int y)
 {
-	destY = y;
+	dest_y_ = y;
 }
 
 // Obtiene el valor de la variable
-int SmartSprite::getDestX()
+int SmartSprite::getDestX() const
 {
-	return destX;
+	return dest_x_;
 }
 
 // Obtiene el valor de la variable
-int SmartSprite::getDestY()
+int SmartSprite::getDestY() const
 {
-	return destY;
+	return dest_y_;
 }
 
 // Comprueba el movimiento
@@ -105,10 +68,10 @@ void SmartSprite::checkMove()
 	if (getAccelX() > 0 || getVelX() > 0)
 	{
 		// Comprueba si ha llegado al destino
-		if (getPosX() > destX)
+		if (getPosX() > dest_x_)
 		{
 			// Lo coloca en posición
-			setPosX(destX);
+			setPosX(dest_x_);
 
 			// Lo detiene
 			setVelX(0.0f);
@@ -119,10 +82,10 @@ void SmartSprite::checkMove()
 	else if (getAccelX() < 0 || getVelX() < 0)
 	{
 		// Comprueba si ha llegado al destino
-		if (getPosX() < destX)
+		if (getPosX() < dest_x_)
 		{
 			// Lo coloca en posición
-			setPosX(destX);
+			setPosX(dest_x_);
 
 			// Lo detiene
 			setVelX(0.0f);
@@ -134,10 +97,10 @@ void SmartSprite::checkMove()
 	if (getAccelY() > 0 || getVelY() > 0)
 	{
 		// Comprueba si ha llegado al destino
-		if (getPosY() > destY)
+		if (getPosY() > dest_y_)
 		{
 			// Lo coloca en posición
-			setPosY(destY);
+			setPosY(dest_y_);
 
 			// Lo detiene
 			setVelY(0.0f);
@@ -148,10 +111,10 @@ void SmartSprite::checkMove()
 	else if (getAccelY() < 0 || getVelY() < 0)
 	{
 		// Comprueba si ha llegado al destino
-		if (getPosY() < destY)
+		if (getPosY() < dest_y_)
 		{
 			// Lo coloca en posición
-			setPosY(destY);
+			setPosY(dest_y_);
 
 			// Lo detiene
 			setVelY(0.0f);
@@ -164,29 +127,34 @@ void SmartSprite::checkMove()
 void SmartSprite::checkFinished()
 {
 	// Comprueba si ha llegado a su destino
-	onDestination = (getPosX() == destX && getPosY() == destY) ? true : false;
+	on_destination_ = (getPosX() == dest_x_ && getPosY() == dest_y_) ? true : false;
 
-	if (onDestination)
-	{ // Si esta en el destino comprueba su contador
-		if (enabledCounter == 0)
-		{ // Si ha llegado a cero, deshabilita el objeto y lo marca como finalizado
-			finished = true;
+	if (on_destination_)
+	{
+		if (finished_counter_ == 0)
+		{
+			finished_ = true;
 		}
 		else
-		{ // Si no ha llegado a cero, decrementa el contador
-			enabledCounter--;
+		{
+			--finished_counter_;
 		}
 	}
 }
 
 // Obtiene el valor de la variable
-bool SmartSprite::isOnDestination()
+bool SmartSprite::isOnDestination() const
 {
-	return onDestination;
+	return on_destination_;
 }
 
 // Obtiene el valor de la variable
-bool SmartSprite::hasFinished()
+bool SmartSprite::hasFinished() const
 {
-	return finished;
+	return finished_;
+}
+
+void SmartSprite::setEnabled(bool value)
+{
+	enabled_ = value;
 }

source/smart_sprite.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <memory>             // for shared_ptr
 #include "animated_sprite.h"  // for AnimatedSprite
 class Texture;
 
@@ -8,12 +9,12 @@ class SmartSprite : public AnimatedSprite
 {
 private:
 	// Variables
-	bool enabled;		// Indica si esta habilitado
-	bool onDestination; // Indica si está en el destino
-	int destX;			// Posicion de destino en el eje X
-	int destY;			// Posicion de destino en el eje Y
-	int enabledCounter; // Contador para deshabilitarlo
-	bool finished;		// Indica si ya ha terminado
+	bool on_destination_;  // Indica si está en el destino
+	int dest_x_;		   // Posicion de destino en el eje X
+	int dest_y_;		   // Posicion de destino en el eje Y
+	int finished_counter_; // Contador para deshabilitarlo
+	bool finished_;		   // Indica si ya ha terminado
+	bool enabled_;		   // Indica si el objeto está habilitado
 
 	// Comprueba el movimiento
 	void checkMove();
@@ -23,28 +24,19 @@ private:
 
 public:
 	// Constructor
-	SmartSprite(Texture *texture);
+	explicit SmartSprite(std::shared_ptr<Texture> texture);
+
+	// Destructor
+	~SmartSprite() = default;
 
 	// Inicializa el objeto
 	void init();
 
 	// Actualiza la posición y comprueba si ha llegado a su destino
-	void update();
-
-	// Pinta el objeto en pantalla
-	void render();
-
-	// Obtiene el valor de la variable
-	bool isEnabled();
+	void update() override;
 
 	// Establece el valor de la variable
-	void setEnabled(bool enabled);
-
-	// Obtiene el valor de la variable
-	int getEnabledCounter();
-
-	// Establece el valor de la variable
-	void setEnabledCounter(int value);
+	void setFinishedCounter(int value);
 
 	// Establece el valor de la variable
 	void setDestX(int x);
@@ -53,14 +45,16 @@ public:
 	void setDestY(int y);
 
 	// Obtiene el valor de la variable
-	int getDestX();
+	int getDestX() const;
 
 	// Obtiene el valor de la variable
-	int getDestY();
+	int getDestY() const;
 
 	// Obtiene el valor de la variable
-	bool isOnDestination();
+	bool isOnDestination() const;
 
 	// Obtiene el valor de la variable
-	bool hasFinished();
+	bool hasFinished() const;
+
+	void setEnabled(bool value);
 };

source/sprite.cpp

@@ -1,192 +1,137 @@
 #include "sprite.h"
-#include "texture.h"  // for Texture
 
 // Constructor
-Sprite::Sprite(int x, int y, int w, int h, Texture *texture)
-{
-	// Establece la posición X,Y del sprite
-	this->x = x;
-	this->y = y;
+Sprite::Sprite(int x, int y, int w, int h, std::shared_ptr<Texture> texture)
+	: texture_(texture),
+	  pos_((SDL_Rect){x, y, w, h}),
+	  sprite_clip_((SDL_Rect){0, 0, pos_.w, pos_.h}) {}
 
-	// Establece el alto y el ancho del sprite
-	this->w = w;
-	this->h = h;
+Sprite::Sprite(SDL_Rect rect, std::shared_ptr<Texture> texture)
+	: texture_(texture),
+	  pos_(rect),
+	  sprite_clip_((SDL_Rect){0, 0, pos_.w, pos_.h}) {}
 
-	// Establece la textura donde están los gráficos para el sprite
-	this->texture = texture;
-
-	// Establece el rectangulo de donde coger la imagen
-	spriteClip = {0, 0, w, h};
-
-	// Inicializa variables
-	enabled = true;
-}
-
-Sprite::Sprite(SDL_Rect rect, Texture *texture)
-{
-	// Establece la posición X,Y del sprite
-	x = rect.x;
-	y = rect.y;
-
-	// Establece el alto y el ancho del sprite
-	w = rect.w;
-	h = rect.h;
-
-	// Establece la textura donde están los gráficos para el sprite
-	this->texture = texture;
-
-	// Establece el rectangulo de donde coger la imagen
-	spriteClip = {0, 0, w, h};
-
-	// Inicializa variables
-	enabled = true;
-}
-
-// Destructor
-Sprite::~Sprite()
-{
-	texture = nullptr;
-}
+Sprite::Sprite(std::shared_ptr<Texture> texture)
+	: texture_(texture) {}
 
 // Muestra el sprite por pantalla
 void Sprite::render()
 {
-	if (enabled)
-	{
-		texture->render(x, y, &spriteClip);
-	}
+	texture_->render(pos_.x, pos_.y, &sprite_clip_);
 }
 
 // Obten el valor de la variable
-int Sprite::getPosX()
+int Sprite::getIntPosX() const
 {
-	return x;
+	return pos_.x;
 }
 
 // Obten el valor de la variable
-int Sprite::getPosY()
+int Sprite::getIntPosY() const
 {
-	return y;
+	return pos_.y;
 }
 
 // Obten el valor de la variable
-int Sprite::getWidth()
+int Sprite::getWidth() const
 {
-	return w;
+	return pos_.w;
 }
 
 // Obten el valor de la variable
-int Sprite::getHeight()
+int Sprite::getHeight() const
 {
-	return h;
+	return pos_.h;
+}
+
+// Establece la posición del objeto
+void Sprite::setPos(int x, int y)
+{
+	pos_.x = x;
+	pos_.y = y;
 }
 
 // Establece la posición del objeto
 void Sprite::setPos(SDL_Point p)
 {
-	this->x = p.x;
-	this->y = p.y;
+	pos_.x = p.x;
+	pos_.y = p.y;
 }
 
 // Establece la posición del objeto
 void Sprite::setPos(SDL_Rect r)
 {
-	this->x = r.x;
-	this->y = r.y;
-	this->w = r.w;
-	this->h = r.h;
+	pos_ = r;
 }
 
 // Establece el valor de la variable
 void Sprite::setPosX(int x)
 {
-	this->x = x;
+	pos_.x = x;
 }
 
 // Establece el valor de la variable
 void Sprite::setPosY(int y)
 {
-	this->y = y;
+	pos_.y = y;
 }
 
 // Establece el valor de la variable
 void Sprite::setWidth(int w)
 {
-	this->w = w;
+	pos_.w = w;
 }
 
 // Establece el valor de la variable
 void Sprite::setHeight(int h)
 {
-	this->h = h;
+	pos_.h = h;
 }
 
 // Obten el valor de la variable
-SDL_Rect Sprite::getSpriteClip()
+SDL_Rect Sprite::getSpriteClip() const
 {
-	return spriteClip;
+	return sprite_clip_;
 }
 
 // Establece el valor de la variable
 void Sprite::setSpriteClip(SDL_Rect rect)
 {
-	spriteClip = rect;
+	sprite_clip_ = rect;
 }
 
 // Establece el valor de la variable
 void Sprite::setSpriteClip(int x, int y, int w, int h)
 {
-	spriteClip = {x, y, w, h};
+	sprite_clip_ = (SDL_Rect){x, y, w, h};
 }
 
 // Obten el valor de la variable
-Texture *Sprite::getTexture()
+std::shared_ptr<Texture> Sprite::getTexture() const
 {
-	return texture;
+	return texture_;
 }
 
 // Establece el valor de la variable
-void Sprite::setTexture(Texture *texture)
+void Sprite::setTexture(std::shared_ptr<Texture> texture)
 {
-	this->texture = texture;
-}
-
-// Establece el valor de la variable
-void Sprite::setEnabled(bool value)
-{
-	enabled = value;
-}
-
-// Comprueba si el objeto está habilitado
-bool Sprite::isEnabled()
-{
-	return enabled;
+	texture_ = texture;
 }
 
 // Devuelve el rectangulo donde está el sprite
-SDL_Rect Sprite::getRect()
+SDL_Rect Sprite::getPos() const
 {
-	SDL_Rect rect = {x, y, w, h};
-	return rect;
-}
-
-// Establece los valores de posición y tamaño del sprite
-void Sprite::setRect(SDL_Rect rect)
-{
-	x = rect.x;
-	y = rect.y;
-	w = rect.w;
-	h = rect.h;
+	return pos_;
 }
 
 // Incrementa el valor de la variable
 void Sprite::incPosX(int value)
 {
-	x += value;
+	pos_.x += value;
 }
 
 // Incrementa el valor de la variable
 void Sprite::incPosY(int value)
 {
-	y += value;
+	pos_.y += value;
 }

source/sprite.h

@@ -1,91 +1,64 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>  // for SDL_Rect, SDL_Point
-class Texture;
+#include <SDL2/SDL_rect.h> // for SDL_Rect, SDL_Point
+#include "texture.h"
+#include <memory>
 
 // Clase sprite
 class Sprite
 {
 protected:
-    int x; // Posición en el eje X donde dibujar el sprite
-    int y; // Posición en el eje Y donde dibujar el sprite
-    int w; // Ancho del sprite
-    int h; // Alto del sprite
-
-    Texture *texture;       // Textura donde estan todos los dibujos del sprite
-    SDL_Rect spriteClip;    // Rectangulo de origen de la textura que se dibujará en pantalla
-
-    bool enabled; // Indica si el sprite esta habilitado
+    // Variables
+    std::shared_ptr<Texture> texture_; // Textura donde estan todos los dibujos del sprite
+    SDL_Rect pos_;                     // Posición y tamaño donde dibujar el sprite
+    SDL_Rect sprite_clip_;             // Rectangulo de origen de la textura que se dibujará en pantalla
 
 public:
     // Constructor
-    Sprite(int x = 0, int y = 0, int w = 0, int h = 0, Texture *texture = nullptr);
-    Sprite(SDL_Rect rect, Texture *texture);
+    explicit Sprite(int x = 0, int y = 0, int w = 0, int h = 0, std::shared_ptr<Texture> texture = nullptr);
+    explicit Sprite(SDL_Rect rect, std::shared_ptr<Texture> texture = nullptr);
+    explicit Sprite(std::shared_ptr<Texture> texture = nullptr);
 
     // Destructor
-    ~Sprite();
+    virtual ~Sprite() = default;
 
     // Muestra el sprite por pantalla
-    void render();
+    virtual void render();
 
     // Obten el valor de la variable
-    int getPosX();
-
-    // Obten el valor de la variable
-    int getPosY();
-
-    // Obten el valor de la variable
-    int getWidth();
-
-    // Obten el valor de la variable
-    int getHeight();
-
-    // Establece la posición del objeto
-    void setPos(SDL_Point p);
-    void setPos(SDL_Rect r);
+    int getIntPosX() const;
+    int getIntPosY() const;
+    int getWidth() const;
+    int getHeight() const;
 
+    // Devuelve el rectangulo donde está el sprite
+    virtual SDL_Rect getPos() const;
+    
     // Establece el valor de la variable
     void setPosX(int x);
-
-    // Establece el valor de la variable
     void setPosY(int y);
+    void setWidth(int w);
+    void setHeight(int h);
+
+    // Establece la posición del objeto
+    void setPos(int x, int y);
+    void setPos(SDL_Point p);
+    virtual void setPos(SDL_Rect r);
 
     // Incrementa el valor de la variable
     void incPosX(int value);
-
-    // Incrementa el valor de la variable
     void incPosY(int value);
 
-    // Establece el valor de la variable
-    void setWidth(int w);
-
-    // Establece el valor de la variable
-    void setHeight(int h);
-
     // Obten el valor de la variable
-    SDL_Rect getSpriteClip();
+    SDL_Rect getSpriteClip() const;
 
     // Establece el valor de la variable
     void setSpriteClip(SDL_Rect rect);
-
-    // Establece el valor de la variable
     void setSpriteClip(int x, int y, int w, int h);
 
     // Obten el valor de la variable
-    Texture *getTexture();
+    std::shared_ptr<Texture> getTexture() const;
 
     // Establece el valor de la variable
-    void setTexture(Texture *texture);
-
-    // Establece el valor de la variable
-    void setEnabled(bool value);
-
-    // Comprueba si el objeto está habilitado
-    bool isEnabled();
-
-    // Devuelve el rectangulo donde está el sprite
-    SDL_Rect getRect();
-
-    // Establece los valores de posición y tamaño del sprite
-    void setRect(SDL_Rect rect);
+    void setTexture(std::shared_ptr<Texture> texture);
 };

source/stb_image.h

@@ -1,4 +1,4 @@
-/* stb_image - v2.27 - public domain image loader - http://nothings.org/stb
+/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb
                                   no warranty implied; use at your own risk
 
    Do this:
@@ -48,6 +48,9 @@ LICENSE
 
 RECENT REVISION HISTORY:
 
+      2.30  (2024-05-31) avoid erroneous gcc warning
+      2.29  (2023-05-xx) optimizations
+      2.28  (2023-01-29) many error fixes, security errors, just tons of stuff
       2.27  (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes
       2.26  (2020-07-13) many minor fixes
       2.25  (2020-02-02) fix warnings
@@ -108,7 +111,7 @@ RECENT REVISION HISTORY:
     Cass Everitt            Ryamond Barbiero                        github:grim210
     Paul Du Bois            Engin Manap        Aldo Culquicondor    github:sammyhw
     Philipp Wiesemann       Dale Weiler        Oriol Ferrer Mesia   github:phprus
-    Josh Tobin                                 Matthew Gregan       github:poppolopoppo
+    Josh Tobin              Neil Bickford      Matthew Gregan       github:poppolopoppo
     Julian Raschke          Gregory Mullen     Christian Floisand   github:darealshinji
     Baldur Karlsson         Kevin Schmidt      JR Smith             github:Michaelangel007
                             Brad Weinberger    Matvey Cherevko      github:mosra
@@ -140,7 +143,7 @@ RECENT REVISION HISTORY:
 //    // ... x = width, y = height, n = # 8-bit components per pixel ...
 //    // ... replace '0' with '1'..'4' to force that many components per pixel
 //    // ... but 'n' will always be the number that it would have been if you said 0
-//    stbi_image_free(data)
+//    stbi_image_free(data);
 //
 // Standard parameters:
 //    int *x                 -- outputs image width in pixels
@@ -635,7 +638,7 @@ STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const ch
    #endif
 #endif
 
-#ifdef _MSC_VER
+#if defined(_MSC_VER) || defined(__SYMBIAN32__)
 typedef unsigned short stbi__uint16;
 typedef   signed short stbi__int16;
 typedef unsigned int   stbi__uint32;
@@ -1063,6 +1066,23 @@ static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
 }
 #endif
 
+// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow.
+static int stbi__addints_valid(int a, int b)
+{
+   if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow
+   if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0.
+   return a <= INT_MAX - b;
+}
+
+// returns 1 if the product of two ints fits in a signed short, 0 on overflow.
+static int stbi__mul2shorts_valid(int a, int b)
+{
+   if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow
+   if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid
+   if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN
+   return a >= SHRT_MIN / b;
+}
+
 // stbi__err - error
 // stbi__errpf - error returning pointer to float
 // stbi__errpuc - error returning pointer to unsigned char
@@ -1985,9 +2005,12 @@ static int stbi__build_huffman(stbi__huffman *h, int *count)
    int i,j,k=0;
    unsigned int code;
    // build size list for each symbol (from JPEG spec)
-   for (i=0; i < 16; ++i)
-      for (j=0; j < count[i]; ++j)
+   for (i=0; i < 16; ++i) {
+      for (j=0; j < count[i]; ++j) {
          h->size[k++] = (stbi_uc) (i+1);
+         if(k >= 257) return stbi__err("bad size list","Corrupt JPEG");
+      }
+   }
    h->size[k] = 0;
 
    // compute actual symbols (from jpeg spec)
@@ -2112,6 +2135,8 @@ stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
 
    // convert the huffman code to the symbol id
    c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
+   if(c < 0 || c >= 256) // symbol id out of bounds!
+       return -1;
    STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
 
    // convert the id to a symbol
@@ -2130,6 +2155,7 @@ stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
    unsigned int k;
    int sgn;
    if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+   if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
 
    sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative)
    k = stbi_lrot(j->code_buffer, n);
@@ -2144,6 +2170,7 @@ stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
 {
    unsigned int k;
    if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+   if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
    k = stbi_lrot(j->code_buffer, n);
    j->code_buffer = k & ~stbi__bmask[n];
    k &= stbi__bmask[n];
@@ -2155,6 +2182,7 @@ stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
 {
    unsigned int k;
    if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
+   if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing
    k = j->code_buffer;
    j->code_buffer <<= 1;
    --j->code_bits;
@@ -2192,8 +2220,10 @@ static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman
    memset(data,0,64*sizeof(data[0]));
 
    diff = t ? stbi__extend_receive(j, t) : 0;
+   if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG");
    dc = j->img_comp[b].dc_pred + diff;
    j->img_comp[b].dc_pred = dc;
+   if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
    data[0] = (short) (dc * dequant[0]);
 
    // decode AC components, see JPEG spec
@@ -2207,6 +2237,7 @@ static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman
       if (r) { // fast-AC path
          k += (r >> 4) & 15; // run
          s = r & 15; // combined length
+         if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
          j->code_buffer <<= s;
          j->code_bits -= s;
          // decode into unzigzag'd location
@@ -2246,8 +2277,10 @@ static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__
       if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
       diff = t ? stbi__extend_receive(j, t) : 0;
 
+      if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG");
       dc = j->img_comp[b].dc_pred + diff;
       j->img_comp[b].dc_pred = dc;
+      if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
       data[0] = (short) (dc * (1 << j->succ_low));
    } else {
       // refinement scan for DC coefficient
@@ -2282,6 +2315,7 @@ static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__
          if (r) { // fast-AC path
             k += (r >> 4) & 15; // run
             s = r & 15; // combined length
+            if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
             j->code_buffer <<= s;
             j->code_bits -= s;
             zig = stbi__jpeg_dezigzag[k++];
@@ -3102,6 +3136,7 @@ static int stbi__process_marker(stbi__jpeg *z, int m)
                sizes[i] = stbi__get8(z->s);
                n += sizes[i];
             }
+            if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values!
             L -= 17;
             if (tc == 0) {
                if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
@@ -3351,6 +3386,28 @@ static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
    return 1;
 }
 
+static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)
+{
+   // some JPEGs have junk at end, skip over it but if we find what looks
+   // like a valid marker, resume there
+   while (!stbi__at_eof(j->s)) {
+      stbi_uc x = stbi__get8(j->s);
+      while (x == 0xff) { // might be a marker
+         if (stbi__at_eof(j->s)) return STBI__MARKER_none;
+         x = stbi__get8(j->s);
+         if (x != 0x00 && x != 0xff) {
+            // not a stuffed zero or lead-in to another marker, looks
+            // like an actual marker, return it
+            return x;
+         }
+         // stuffed zero has x=0 now which ends the loop, meaning we go
+         // back to regular scan loop.
+         // repeated 0xff keeps trying to read the next byte of the marker.
+      }
+   }
+   return STBI__MARKER_none;
+}
+
 // decode image to YCbCr format
 static int stbi__decode_jpeg_image(stbi__jpeg *j)
 {
@@ -3367,25 +3424,22 @@ static int stbi__decode_jpeg_image(stbi__jpeg *j)
          if (!stbi__process_scan_header(j)) return 0;
          if (!stbi__parse_entropy_coded_data(j)) return 0;
          if (j->marker == STBI__MARKER_none ) {
-            // handle 0s at the end of image data from IP Kamera 9060
-            while (!stbi__at_eof(j->s)) {
-               int x = stbi__get8(j->s);
-               if (x == 255) {
-                  j->marker = stbi__get8(j->s);
-                  break;
-               }
-            }
+         j->marker = stbi__skip_jpeg_junk_at_end(j);
             // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
          }
+         m = stbi__get_marker(j);
+         if (STBI__RESTART(m))
+            m = stbi__get_marker(j);
       } else if (stbi__DNL(m)) {
          int Ld = stbi__get16be(j->s);
          stbi__uint32 NL = stbi__get16be(j->s);
          if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
          if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");
+         m = stbi__get_marker(j);
       } else {
-         if (!stbi__process_marker(j, m)) return 0;
+         if (!stbi__process_marker(j, m)) return 1;
+         m = stbi__get_marker(j);
       }
-      m = stbi__get_marker(j);
    }
    if (j->progressive)
       stbi__jpeg_finish(j);
@@ -3976,6 +4030,7 @@ static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int re
    unsigned char* result;
    stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
    if (!j) return stbi__errpuc("outofmem", "Out of memory");
+   memset(j, 0, sizeof(stbi__jpeg));
    STBI_NOTUSED(ri);
    j->s = s;
    stbi__setup_jpeg(j);
@@ -3989,6 +4044,7 @@ static int stbi__jpeg_test(stbi__context *s)
    int r;
    stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
    if (!j) return stbi__err("outofmem", "Out of memory");
+   memset(j, 0, sizeof(stbi__jpeg));
    j->s = s;
    stbi__setup_jpeg(j);
    r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
@@ -4014,6 +4070,7 @@ static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
    int result;
    stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));
    if (!j) return stbi__err("outofmem", "Out of memory");
+   memset(j, 0, sizeof(stbi__jpeg));
    j->s = s;
    result = stbi__jpeg_info_raw(j, x, y, comp);
    STBI_FREE(j);
@@ -4121,6 +4178,7 @@ typedef struct
 {
    stbi_uc *zbuffer, *zbuffer_end;
    int num_bits;
+   int hit_zeof_once;
    stbi__uint32 code_buffer;
 
    char *zout;
@@ -4187,9 +4245,20 @@ stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
    int b,s;
    if (a->num_bits < 16) {
       if (stbi__zeof(a)) {
-         return -1;   /* report error for unexpected end of data. */
+         if (!a->hit_zeof_once) {
+            // This is the first time we hit eof, insert 16 extra padding btis
+            // to allow us to keep going; if we actually consume any of them
+            // though, that is invalid data. This is caught later.
+            a->hit_zeof_once = 1;
+            a->num_bits += 16; // add 16 implicit zero bits
+         } else {
+            // We already inserted our extra 16 padding bits and are again
+            // out, this stream is actually prematurely terminated.
+            return -1;
+         }
+      } else {
+         stbi__fill_bits(a);
       }
-      stbi__fill_bits(a);
    }
    b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
    if (b) {
@@ -4254,17 +4323,25 @@ static int stbi__parse_huffman_block(stbi__zbuf *a)
          int len,dist;
          if (z == 256) {
             a->zout = zout;
+            if (a->hit_zeof_once && a->num_bits < 16) {
+               // The first time we hit zeof, we inserted 16 extra zero bits into our bit
+               // buffer so the decoder can just do its speculative decoding. But if we
+               // actually consumed any of those bits (which is the case when num_bits < 16),
+               // the stream actually read past the end so it is malformed.
+               return stbi__err("unexpected end","Corrupt PNG");
+            }
             return 1;
          }
+         if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data
          z -= 257;
          len = stbi__zlength_base[z];
          if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
          z = stbi__zhuffman_decode(a, &a->z_distance);
-         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG");
+         if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data
          dist = stbi__zdist_base[z];
          if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
          if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
-         if (zout + len > a->zout_end) {
+         if (len > a->zout_end - zout) {
             if (!stbi__zexpand(a, zout, len)) return 0;
             zout = a->zout;
          }
@@ -4408,6 +4485,7 @@ static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
       if (!stbi__parse_zlib_header(a)) return 0;
    a->num_bits = 0;
    a->code_buffer = 0;
+   a->hit_zeof_once = 0;
    do {
       final = stbi__zreceive(a,1);
       type = stbi__zreceive(a,2);
@@ -4563,9 +4641,8 @@ enum {
    STBI__F_up=2,
    STBI__F_avg=3,
    STBI__F_paeth=4,
-   // synthetic filters used for first scanline to avoid needing a dummy row of 0s
-   STBI__F_avg_first,
-   STBI__F_paeth_first
+   // synthetic filter used for first scanline to avoid needing a dummy row of 0s
+   STBI__F_avg_first
 };
 
 static stbi_uc first_row_filter[5] =
@@ -4574,29 +4651,56 @@ static stbi_uc first_row_filter[5] =
    STBI__F_sub,
    STBI__F_none,
    STBI__F_avg_first,
-   STBI__F_paeth_first
+   STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub
 };
 
 static int stbi__paeth(int a, int b, int c)
 {
-   int p = a + b - c;
-   int pa = abs(p-a);
-   int pb = abs(p-b);
-   int pc = abs(p-c);
-   if (pa <= pb && pa <= pc) return a;
-   if (pb <= pc) return b;
-   return c;
+   // This formulation looks very different from the reference in the PNG spec, but is
+   // actually equivalent and has favorable data dependencies and admits straightforward
+   // generation of branch-free code, which helps performance significantly.
+   int thresh = c*3 - (a + b);
+   int lo = a < b ? a : b;
+   int hi = a < b ? b : a;
+   int t0 = (hi <= thresh) ? lo : c;
+   int t1 = (thresh <= lo) ? hi : t0;
+   return t1;
 }
 
 static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
 
+// adds an extra all-255 alpha channel
+// dest == src is legal
+// img_n must be 1 or 3
+static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n)
+{
+   int i;
+   // must process data backwards since we allow dest==src
+   if (img_n == 1) {
+      for (i=x-1; i >= 0; --i) {
+         dest[i*2+1] = 255;
+         dest[i*2+0] = src[i];
+      }
+   } else {
+      STBI_ASSERT(img_n == 3);
+      for (i=x-1; i >= 0; --i) {
+         dest[i*4+3] = 255;
+         dest[i*4+2] = src[i*3+2];
+         dest[i*4+1] = src[i*3+1];
+         dest[i*4+0] = src[i*3+0];
+      }
+   }
+}
+
 // create the png data from post-deflated data
 static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
 {
-   int bytes = (depth == 16? 2 : 1);
+   int bytes = (depth == 16 ? 2 : 1);
    stbi__context *s = a->s;
    stbi__uint32 i,j,stride = x*out_n*bytes;
    stbi__uint32 img_len, img_width_bytes;
+   stbi_uc *filter_buf;
+   int all_ok = 1;
    int k;
    int img_n = s->img_n; // copy it into a local for later
 
@@ -4608,8 +4712,11 @@ static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 r
    a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into
    if (!a->out) return stbi__err("outofmem", "Out of memory");
 
+   // note: error exits here don't need to clean up a->out individually,
+   // stbi__do_png always does on error.
    if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");
    img_width_bytes = (((img_n * x * depth) + 7) >> 3);
+   if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG");
    img_len = (img_width_bytes + 1) * y;
 
    // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,
@@ -4617,189 +4724,137 @@ static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 r
    // so just check for raw_len < img_len always.
    if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");
 
+   // Allocate two scan lines worth of filter workspace buffer.
+   filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0);
+   if (!filter_buf) return stbi__err("outofmem", "Out of memory");
+
+   // Filtering for low-bit-depth images
+   if (depth < 8) {
+      filter_bytes = 1;
+      width = img_width_bytes;
+   }
+
    for (j=0; j < y; ++j) {
-      stbi_uc *cur = a->out + stride*j;
-      stbi_uc *prior;
+      // cur/prior filter buffers alternate
+      stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes;
+      stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes;
+      stbi_uc *dest = a->out + stride*j;
+      int nk = width * filter_bytes;
       int filter = *raw++;
 
-      if (filter > 4)
-         return stbi__err("invalid filter","Corrupt PNG");
-
-      if (depth < 8) {
-         if (img_width_bytes > x) return stbi__err("invalid width","Corrupt PNG");
-         cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place
-         filter_bytes = 1;
-         width = img_width_bytes;
+      // check filter type
+      if (filter > 4) {
+         all_ok = stbi__err("invalid filter","Corrupt PNG");
+         break;
       }
-      prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above
 
       // if first row, use special filter that doesn't sample previous row
       if (j == 0) filter = first_row_filter[filter];
 
-      // handle first byte explicitly
-      for (k=0; k < filter_bytes; ++k) {
-         switch (filter) {
-            case STBI__F_none       : cur[k] = raw[k]; break;
-            case STBI__F_sub        : cur[k] = raw[k]; break;
-            case STBI__F_up         : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
-            case STBI__F_avg        : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break;
-            case STBI__F_paeth      : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break;
-            case STBI__F_avg_first  : cur[k] = raw[k]; break;
-            case STBI__F_paeth_first: cur[k] = raw[k]; break;
-         }
+      // perform actual filtering
+      switch (filter) {
+      case STBI__F_none:
+         memcpy(cur, raw, nk);
+         break;
+      case STBI__F_sub:
+         memcpy(cur, raw, filter_bytes);
+         for (k = filter_bytes; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]);
+         break;
+      case STBI__F_up:
+         for (k = 0; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + prior[k]);
+         break;
+      case STBI__F_avg:
+         for (k = 0; k < filter_bytes; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1));
+         for (k = filter_bytes; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1));
+         break;
+      case STBI__F_paeth:
+         for (k = 0; k < filter_bytes; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0)
+         for (k = filter_bytes; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes]));
+         break;
+      case STBI__F_avg_first:
+         memcpy(cur, raw, filter_bytes);
+         for (k = filter_bytes; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1));
+         break;
       }
 
-      if (depth == 8) {
-         if (img_n != out_n)
-            cur[img_n] = 255; // first pixel
-         raw += img_n;
-         cur += out_n;
-         prior += out_n;
-      } else if (depth == 16) {
-         if (img_n != out_n) {
-            cur[filter_bytes]   = 255; // first pixel top byte
-            cur[filter_bytes+1] = 255; // first pixel bottom byte
-         }
-         raw += filter_bytes;
-         cur += output_bytes;
-         prior += output_bytes;
-      } else {
-         raw += 1;
-         cur += 1;
-         prior += 1;
-      }
+      raw += nk;
 
-      // this is a little gross, so that we don't switch per-pixel or per-component
-      if (depth < 8 || img_n == out_n) {
-         int nk = (width - 1)*filter_bytes;
-         #define STBI__CASE(f) \
-             case f:     \
-                for (k=0; k < nk; ++k)
-         switch (filter) {
-            // "none" filter turns into a memcpy here; make that explicit.
-            case STBI__F_none:         memcpy(cur, raw, nk); break;
-            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break;
-            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
-            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break;
-            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break;
-            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break;
-            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break;
-         }
-         #undef STBI__CASE
-         raw += nk;
-      } else {
-         STBI_ASSERT(img_n+1 == out_n);
-         #define STBI__CASE(f) \
-             case f:     \
-                for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \
-                   for (k=0; k < filter_bytes; ++k)
-         switch (filter) {
-            STBI__CASE(STBI__F_none)         { cur[k] = raw[k]; } break;
-            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break;
-            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
-            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break;
-            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break;
-            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break;
-            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break;
-         }
-         #undef STBI__CASE
-
-         // the loop above sets the high byte of the pixels' alpha, but for
-         // 16 bit png files we also need the low byte set. we'll do that here.
-         if (depth == 16) {
-            cur = a->out + stride*j; // start at the beginning of the row again
-            for (i=0; i < x; ++i,cur+=output_bytes) {
-               cur[filter_bytes+1] = 255;
-            }
-         }
-      }
-   }
-
-   // we make a separate pass to expand bits to pixels; for performance,
-   // this could run two scanlines behind the above code, so it won't
-   // intefere with filtering but will still be in the cache.
-   if (depth < 8) {
-      for (j=0; j < y; ++j) {
-         stbi_uc *cur = a->out + stride*j;
-         stbi_uc *in  = a->out + stride*j + x*out_n - img_width_bytes;
-         // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit
-         // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop
+      // expand decoded bits in cur to dest, also adding an extra alpha channel if desired
+      if (depth < 8) {
          stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range
+         stbi_uc *in = cur;
+         stbi_uc *out = dest;
+         stbi_uc inb = 0;
+         stbi__uint32 nsmp = x*img_n;
 
-         // note that the final byte might overshoot and write more data than desired.
-         // we can allocate enough data that this never writes out of memory, but it
-         // could also overwrite the next scanline. can it overwrite non-empty data
-         // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel.
-         // so we need to explicitly clamp the final ones
-
+         // expand bits to bytes first
          if (depth == 4) {
-            for (k=x*img_n; k >= 2; k-=2, ++in) {
-               *cur++ = scale * ((*in >> 4)       );
-               *cur++ = scale * ((*in     ) & 0x0f);
+            for (i=0; i < nsmp; ++i) {
+               if ((i & 1) == 0) inb = *in++;
+               *out++ = scale * (inb >> 4);
+               inb <<= 4;
             }
-            if (k > 0) *cur++ = scale * ((*in >> 4)       );
          } else if (depth == 2) {
-            for (k=x*img_n; k >= 4; k-=4, ++in) {
-               *cur++ = scale * ((*in >> 6)       );
-               *cur++ = scale * ((*in >> 4) & 0x03);
-               *cur++ = scale * ((*in >> 2) & 0x03);
-               *cur++ = scale * ((*in     ) & 0x03);
+            for (i=0; i < nsmp; ++i) {
+               if ((i & 3) == 0) inb = *in++;
+               *out++ = scale * (inb >> 6);
+               inb <<= 2;
             }
-            if (k > 0) *cur++ = scale * ((*in >> 6)       );
-            if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);
-            if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);
-         } else if (depth == 1) {
-            for (k=x*img_n; k >= 8; k-=8, ++in) {
-               *cur++ = scale * ((*in >> 7)       );
-               *cur++ = scale * ((*in >> 6) & 0x01);
-               *cur++ = scale * ((*in >> 5) & 0x01);
-               *cur++ = scale * ((*in >> 4) & 0x01);
-               *cur++ = scale * ((*in >> 3) & 0x01);
-               *cur++ = scale * ((*in >> 2) & 0x01);
-               *cur++ = scale * ((*in >> 1) & 0x01);
-               *cur++ = scale * ((*in     ) & 0x01);
+         } else {
+            STBI_ASSERT(depth == 1);
+            for (i=0; i < nsmp; ++i) {
+               if ((i & 7) == 0) inb = *in++;
+               *out++ = scale * (inb >> 7);
+               inb <<= 1;
             }
-            if (k > 0) *cur++ = scale * ((*in >> 7)       );
-            if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01);
-            if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01);
-            if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01);
-            if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01);
-            if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01);
-            if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01);
          }
-         if (img_n != out_n) {
-            int q;
-            // insert alpha = 255
-            cur = a->out + stride*j;
+
+         // insert alpha=255 values if desired
+         if (img_n != out_n)
+            stbi__create_png_alpha_expand8(dest, dest, x, img_n);
+      } else if (depth == 8) {
+         if (img_n == out_n)
+            memcpy(dest, cur, x*img_n);
+         else
+            stbi__create_png_alpha_expand8(dest, cur, x, img_n);
+      } else if (depth == 16) {
+         // convert the image data from big-endian to platform-native
+         stbi__uint16 *dest16 = (stbi__uint16*)dest;
+         stbi__uint32 nsmp = x*img_n;
+
+         if (img_n == out_n) {
+            for (i = 0; i < nsmp; ++i, ++dest16, cur += 2)
+               *dest16 = (cur[0] << 8) | cur[1];
+         } else {
+            STBI_ASSERT(img_n+1 == out_n);
             if (img_n == 1) {
-               for (q=x-1; q >= 0; --q) {
-                  cur[q*2+1] = 255;
-                  cur[q*2+0] = cur[q];
+               for (i = 0; i < x; ++i, dest16 += 2, cur += 2) {
+                  dest16[0] = (cur[0] << 8) | cur[1];
+                  dest16[1] = 0xffff;
                }
             } else {
                STBI_ASSERT(img_n == 3);
-               for (q=x-1; q >= 0; --q) {
-                  cur[q*4+3] = 255;
-                  cur[q*4+2] = cur[q*3+2];
-                  cur[q*4+1] = cur[q*3+1];
-                  cur[q*4+0] = cur[q*3+0];
+               for (i = 0; i < x; ++i, dest16 += 4, cur += 6) {
+                  dest16[0] = (cur[0] << 8) | cur[1];
+                  dest16[1] = (cur[2] << 8) | cur[3];
+                  dest16[2] = (cur[4] << 8) | cur[5];
+                  dest16[3] = 0xffff;
                }
             }
          }
       }
-   } else if (depth == 16) {
-      // force the image data from big-endian to platform-native.
-      // this is done in a separate pass due to the decoding relying
-      // on the data being untouched, but could probably be done
-      // per-line during decode if care is taken.
-      stbi_uc *cur = a->out;
-      stbi__uint16 *cur16 = (stbi__uint16*)cur;
-
-      for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) {
-         *cur16 = (cur[0] << 8) | cur[1];
-      }
    }
 
+   STBI_FREE(filter_buf);
+   if (!all_ok) return 0;
+
    return 1;
 }
 
@@ -4955,7 +5010,7 @@ STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
 static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;
 static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;
 
-STBIDEF void stbi__unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)
+STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)
 {
    stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;
    stbi__unpremultiply_on_load_set = 1;
@@ -5064,14 +5119,13 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
             if (!pal_img_n) {
                s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
                if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");
-               if (scan == STBI__SCAN_header) return 1;
             } else {
                // if paletted, then pal_n is our final components, and
                // img_n is # components to decompress/filter.
                s->img_n = 1;
                if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");
-               // if SCAN_header, have to scan to see if we have a tRNS
             }
+            // even with SCAN_header, have to scan to see if we have a tRNS
             break;
          }
 
@@ -5103,10 +5157,14 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
                if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
                if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
                has_trans = 1;
+               // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now.
+               if (scan == STBI__SCAN_header) { ++s->img_n; return 1; }
                if (z->depth == 16) {
-                  for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
+                  for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning
+                     tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
                } else {
-                  for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
+                  for (k = 0; k < s->img_n && k < 3; ++k)
+                     tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
                }
             }
             break;
@@ -5115,7 +5173,13 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
          case STBI__PNG_TYPE('I','D','A','T'): {
             if (first) return stbi__err("first not IHDR", "Corrupt PNG");
             if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
-            if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; }
+            if (scan == STBI__SCAN_header) {
+               // header scan definitely stops at first IDAT
+               if (pal_img_n)
+                  s->img_n = pal_img_n;
+               return 1;
+            }
+            if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes");
             if ((int)(ioff + c.length) < (int)ioff) return 0;
             if (ioff + c.length > idata_limit) {
                stbi__uint32 idata_limit_old = idata_limit;
@@ -5498,8 +5562,22 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
          psize = (info.offset - info.extra_read - info.hsz) >> 2;
    }
    if (psize == 0) {
-      if (info.offset != s->callback_already_read + (s->img_buffer - s->img_buffer_original)) {
-        return stbi__errpuc("bad offset", "Corrupt BMP");
+      // accept some number of extra bytes after the header, but if the offset points either to before
+      // the header ends or implies a large amount of extra data, reject the file as malformed
+      int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original);
+      int header_limit = 1024; // max we actually read is below 256 bytes currently.
+      int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size.
+      if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) {
+         return stbi__errpuc("bad header", "Corrupt BMP");
+      }
+      // we established that bytes_read_so_far is positive and sensible.
+      // the first half of this test rejects offsets that are either too small positives, or
+      // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn
+      // ensures the number computed in the second half of the test can't overflow.
+      if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) {
+         return stbi__errpuc("bad offset", "Corrupt BMP");
+      } else {
+         stbi__skip(s, info.offset - bytes_read_so_far);
       }
    }
 
@@ -7187,12 +7265,12 @@ static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int re
                   // Run
                   value = stbi__get8(s);
                   count -= 128;
-                  if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+                  if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
                   for (z = 0; z < count; ++z)
                      scanline[i++ * 4 + k] = value;
                } else {
                   // Dump
-                  if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+                  if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
                   for (z = 0; z < count; ++z)
                      scanline[i++ * 4 + k] = stbi__get8(s);
                }
@@ -7446,10 +7524,17 @@ static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req
 
    out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0);
    if (!out) return stbi__errpuc("outofmem", "Out of memory");
-   stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8));
+   if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) {
+      STBI_FREE(out);
+      return stbi__errpuc("bad PNM", "PNM file truncated");
+   }
 
    if (req_comp && req_comp != s->img_n) {
-      out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
+      if (ri->bits_per_channel == 16) {
+         out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y);
+      } else {
+         out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
+      }
       if (out == NULL) return out; // stbi__convert_format frees input on failure
    }
    return out;
@@ -7486,6 +7571,8 @@ static int      stbi__pnm_getinteger(stbi__context *s, char *c)
    while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
       value = value*10 + (*c - '0');
       *c = (char) stbi__get8(s);
+      if((value > 214748364) || (value == 214748364 && *c > '7'))
+          return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int");
    }
 
    return value;
@@ -7516,9 +7603,13 @@ static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
    stbi__pnm_skip_whitespace(s, &c);
 
    *x = stbi__pnm_getinteger(s, &c); // read width
+   if(*x == 0)
+       return stbi__err("invalid width", "PPM image header had zero or overflowing width");
    stbi__pnm_skip_whitespace(s, &c);
 
    *y = stbi__pnm_getinteger(s, &c); // read height
+   if (*y == 0)
+       return stbi__err("invalid width", "PPM image header had zero or overflowing width");
    stbi__pnm_skip_whitespace(s, &c);
 
    maxv = stbi__pnm_getinteger(s, &c);  // read max value

source/text.cpp

@@ -1,14 +1,15 @@
 #include "text.h"
-#include <fstream>    // for char_traits, basic_ostream, basic_ifstream, ope...
-#include <iostream>   // for cout
-#include "sprite.h"   // for Sprite
-#include "texture.h"  // for Texture
-#include "utils.h"    // for color_t
+#include <SDL2/SDL_rect.h>  // for SDL_Rect
+#include <fstream>          // for basic_ostream, basic_ifstream, basic_istream
+#include <iostream>         // for cout
+#include "sprite.h"         // for Sprite
+#include "texture.h"        // for Texture
+#include "utils.h"          // for Color
 
-// Llena una estructuta textFile_t desde un fichero
-textFile_t LoadTextFile(std::string file, bool verbose)
+// Llena una estructuta TextFile desde un fichero
+TextFile LoadTextFile(std::string file_path)
 {
-	textFile_t tf;
+	TextFile tf;
 
 	// Inicializa a cero el vector con las coordenadas
 	for (int i = 0; i < 128; ++i)
@@ -16,29 +17,33 @@ textFile_t LoadTextFile(std::string file, bool verbose)
 		tf.offset[i].x = 0;
 		tf.offset[i].y = 0;
 		tf.offset[i].w = 0;
+		tf.box_width = 0;
+		tf.box_height = 0;
 	}
 
 	// Abre el fichero para leer los valores
-	const std::string filename = file.substr(file.find_last_of("\\/") + 1).c_str();
-	std::ifstream rfile(file);
+#ifdef VERBOSE
+	const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1).c_str();
+#endif
+	std::ifstream file(file_path);
 
-	if (rfile.is_open() && rfile.good())
+	if (file.is_open() && file.good())
 	{
 		std::string buffer;
 
 		// Lee los dos primeros valores del fichero
-		std::getline(rfile, buffer);
-		std::getline(rfile, buffer);
-		tf.boxWidth = std::stoi(buffer);
+		std::getline(file, buffer);
+		std::getline(file, buffer);
+		tf.box_width = std::stoi(buffer);
 
-		std::getline(rfile, buffer);
-		std::getline(rfile, buffer);
-		tf.boxHeight = std::stoi(buffer);
+		std::getline(file, buffer);
+		std::getline(file, buffer);
+		tf.box_height = std::stoi(buffer);
 
 		// lee el resto de datos del fichero
-		int index = 32;
-		int line_read = 0;
-		while (std::getline(rfile, buffer))
+		auto index = 32;
+		auto line_read = 0;
+		while (std::getline(file, buffer))
 		{
 			// Almacena solo las lineas impares
 			if (line_read % 2 == 1)
@@ -51,166 +56,152 @@ textFile_t LoadTextFile(std::string file, bool verbose)
 			line_read++;
 		};
 
-		// Cierra el fichero
-		if (verbose)
-		{
-			std::cout << "Text loaded: " << filename.c_str() << std::endl;
-		}
-		rfile.close();
+// Cierra el fichero
+#ifdef VERBOSE
+		std::cout << "Text loaded: " << file_name << std::endl;
+#endif
+		file.close();
 	}
 
 	// El fichero no se puede abrir
 	else
 	{
-		if (verbose)
-		{
-			std::cout << "Warning: Unable to open " << filename.c_str() << " file" << std::endl;
-		}
+#ifdef VERBOSE
+		std::cout << "Warning: Unable to open " << file_name << " file" << std::endl;
+#endif
 	}
 
 	// Establece las coordenadas para cada caracter ascii de la cadena y su ancho
 	for (int i = 32; i < 128; ++i)
 	{
-		tf.offset[i].x = ((i - 32) % 15) * tf.boxWidth;
-		tf.offset[i].y = ((i - 32) / 15) * tf.boxHeight;
+		tf.offset[i].x = ((i - 32) % 15) * tf.box_width;
+		tf.offset[i].y = ((i - 32) / 15) * tf.box_height;
 	}
 
 	return tf;
 }
 
 // Constructor
-Text::Text(std::string bitmapFile, std::string textFile, SDL_Renderer *renderer)
+Text::Text(const std::string &bitmap_file, const std::string &text_file, SDL_Renderer *renderer)
 {
 	// Carga los offsets desde el fichero
-	textFile_t tf = LoadTextFile(textFile);
+	auto tf = LoadTextFile(text_file);
 
 	// Inicializa variables desde la estructura
-	boxHeight = tf.boxHeight;
-	boxWidth = tf.boxWidth;
+	box_height_ = tf.box_height;
+	box_width_ = tf.box_width;
 	for (int i = 0; i < 128; ++i)
 	{
-		offset[i].x = tf.offset[i].x;
-		offset[i].y = tf.offset[i].y;
-		offset[i].w = tf.offset[i].w;
+		offset_[i].x = tf.offset[i].x;
+		offset_[i].y = tf.offset[i].y;
+		offset_[i].w = tf.offset[i].w;
 	}
 
 	// Crea los objetos
-	texture = new Texture(renderer, bitmapFile);
-	sprite = new Sprite({0, 0, boxWidth, boxHeight}, texture);
+	texture_ = std::make_shared<Texture>(renderer, bitmap_file);
+	sprite_ = std::make_unique<Sprite>((SDL_Rect){0, 0, box_width_, box_height_}, texture_);
 
 	// Inicializa variables
-	fixedWidth = false;
+	fixed_width_ = false;
 }
 
 // Constructor
-Text::Text(std::string textFile, Texture *texture, SDL_Renderer *renderer)
+Text::Text(const std::string &text_file, std::shared_ptr<Texture> texture)
 {
 	// Carga los offsets desde el fichero
-	textFile_t tf = LoadTextFile(textFile);
+	auto tf = LoadTextFile(text_file);
 
 	// Inicializa variables desde la estructura
-	boxHeight = tf.boxHeight;
-	boxWidth = tf.boxWidth;
+	box_height_ = tf.box_height;
+	box_width_ = tf.box_width;
 	for (int i = 0; i < 128; ++i)
 	{
-		offset[i].x = tf.offset[i].x;
-		offset[i].y = tf.offset[i].y;
-		offset[i].w = tf.offset[i].w;
+		offset_[i].x = tf.offset[i].x;
+		offset_[i].y = tf.offset[i].y;
+		offset_[i].w = tf.offset[i].w;
 	}
 
 	// Crea los objetos
-	this->texture = nullptr;
-	sprite = new Sprite({0, 0, boxWidth, boxHeight}, texture);
+	sprite_ = std::make_unique<Sprite>((SDL_Rect){0, 0, box_width_, box_height_}, texture);
 
 	// Inicializa variables
-	fixedWidth = false;
+	fixed_width_ = false;
 }
 
 // Constructor
-Text::Text(textFile_t *textFile, Texture *texture, SDL_Renderer *renderer)
+Text::Text(TextFile *text_file, std::shared_ptr<Texture> texture)
 {
 	// Inicializa variables desde la estructura
-	boxHeight = textFile->boxHeight;
-	boxWidth = textFile->boxWidth;
+	box_height_ = text_file->box_height;
+	box_width_ = text_file->box_width;
 	for (int i = 0; i < 128; ++i)
 	{
-		offset[i].x = textFile->offset[i].x;
-		offset[i].y = textFile->offset[i].y;
-		offset[i].w = textFile->offset[i].w;
+		offset_[i].x = text_file->offset[i].x;
+		offset_[i].y = text_file->offset[i].y;
+		offset_[i].w = text_file->offset[i].w;
 	}
 
 	// Crea los objetos
-	this->texture = nullptr;
-	sprite = new Sprite({0, 0, boxWidth, boxHeight}, texture);
+	sprite_ = std::make_unique<Sprite>((SDL_Rect){0, 0, box_width_, box_height_}, texture);
 
 	// Inicializa variables
-	fixedWidth = false;
-}
-
-// Destructor
-Text::~Text()
-{
-	delete sprite;
-	if (texture != nullptr)
-	{
-		delete texture;
-	}
+	fixed_width_ = false;
 }
 
 // Escribe texto en pantalla
-void Text::write(int x, int y, std::string text, int kerning, int lenght)
+void Text::write(int x, int y, const std::string &text, int kerning, int lenght)
 {
-	int shift = 0;
+	auto shift = 0;
 
 	if (lenght == -1)
 	{
 		lenght = text.length();
 	}
 
-	sprite->setPosY(y);
-	const int width = sprite->getWidth();
-	const int height = sprite->getHeight();
+	sprite_->setPosY(y);
+	const auto width = sprite_->getWidth();
+	const auto height = sprite_->getHeight();
 	for (int i = 0; i < lenght; ++i)
 	{
-		const int index = text[i];
-		sprite->setSpriteClip(offset[index].x, offset[index].y, width, height);
-		sprite->setPosX(x + shift);
-		sprite->render();
-		shift += fixedWidth ? boxWidth : (offset[int(text[i])].w + kerning);
+		const auto index = static_cast<int>(text[i]);
+		sprite_->setSpriteClip(offset_[index].x, offset_[index].y, width, height);
+		sprite_->setPosX(x + shift);
+		sprite_->render();
+		shift += fixed_width_ ? box_width_ : (offset_[int(text[i])].w + kerning);
 	}
 }
 
 // Escribe el texto con colores
-void Text::writeColored(int x, int y, std::string text, color_t color, int kerning, int lenght)
+void Text::writeColored(int x, int y, const std::string &text, Color color, int kerning, int lenght)
 {
-	sprite->getTexture()->setColor(color.r, color.g, color.b);
+	sprite_->getTexture()->setColor(color.r, color.g, color.b);
 	write(x, y, text, kerning, lenght);
-	sprite->getTexture()->setColor(255, 255, 255);
+	sprite_->getTexture()->setColor(255, 255, 255);
 }
 
 // Escribe el texto con sombra
-void Text::writeShadowed(int x, int y, std::string text, color_t color, Uint8 shadowDistance, int kerning, int lenght)
+void Text::writeShadowed(int x, int y, const std::string &text, Color color, Uint8 shadow_distance, int kerning, int lenght)
 {
-	sprite->getTexture()->setColor(color.r, color.g, color.b);
-	write(x + shadowDistance, y + shadowDistance, text, kerning, lenght);
-	sprite->getTexture()->setColor(255, 255, 255);
+	sprite_->getTexture()->setColor(color.r, color.g, color.b);
+	write(x + shadow_distance, y + shadow_distance, text, kerning, lenght);
+	sprite_->getTexture()->setColor(255, 255, 255);
 	write(x, y, text, kerning, lenght);
 }
 
 // Escribe el texto centrado en un punto x
-void Text::writeCentered(int x, int y, std::string text, int kerning, int lenght)
+void Text::writeCentered(int x, int y, const std::string &text, int kerning, int lenght)
 {
 	x -= (Text::lenght(text, kerning) / 2);
 	write(x, y, text, kerning, lenght);
 }
 
 // Escribe texto con extras
-void Text::writeDX(Uint8 flags, int x, int y, std::string text, int kerning, color_t textColor, Uint8 shadowDistance, color_t shadowColor, int lenght)
+void Text::writeDX(Uint8 flags, int x, int y, const std::string &text, int kerning, Color textColor, Uint8 shadow_distance, Color shadow_color, int lenght)
 {
-	const bool centered = ((flags & TXT_CENTER) == TXT_CENTER);
-	const bool shadowed = ((flags & TXT_SHADOW) == TXT_SHADOW);
-	const bool colored = ((flags & TXT_COLOR) == TXT_COLOR);
-	const bool stroked = ((flags & TXT_STROKE) == TXT_STROKE);
+	const auto centered = ((flags & TEXT_CENTER) == TEXT_CENTER);
+	const auto shadowed = ((flags & TEXT_SHADOW) == TEXT_SHADOW);
+	const auto colored = ((flags & TEXT_COLOR) == TEXT_COLOR);
+	const auto stroked = ((flags & TEXT_STROKE) == TEXT_STROKE);
 
 	if (centered)
 	{
@@ -219,18 +210,18 @@ void Text::writeDX(Uint8 flags, int x, int y, std::string text, int kerning, col
 
 	if (shadowed)
 	{
-		writeColored(x + shadowDistance, y + shadowDistance, text, shadowColor, kerning, lenght);
+		writeColored(x + shadow_distance, y + shadow_distance, text, shadow_color, kerning, lenght);
 	}
 
 	if (stroked)
 	{
-		for (int dist = 1; dist <= shadowDistance; ++dist)
+		for (int dist = 1; dist <= shadow_distance; ++dist)
 		{
 			for (int dy = -dist; dy <= dist; ++dy)
 			{
 				for (int dx = -dist; dx <= dist; ++dx)
 				{
-					writeColored(x + dx, y + dy, text, shadowColor, kerning, lenght);
+					writeColored(x + dx, y + dy, text, shadow_color, kerning, lenght);
 				}
 			}
 		}
@@ -247,43 +238,45 @@ void Text::writeDX(Uint8 flags, int x, int y, std::string text, int kerning, col
 }
 
 // Obtiene la longitud en pixels de una cadena
-int Text::lenght(std::string text, int kerning)
+int Text::lenght(const std::string &text, int kerning) const
 {
-	int shift = 0;
+	auto shift = 0;
 
 	for (int i = 0; i < (int)text.length(); ++i)
-		shift += (offset[int(text[i])].w + kerning);
+	{
+		shift += (offset_[int(text[i])].w + kerning);
+	}
 
 	// Descuenta el kerning del último caracter
 	return shift - kerning;
 }
 
 // Devuelve el valor de la variable
-int Text::getCharacterSize()
+int Text::getCharacterSize() const
 {
-	return boxWidth;
+	return box_width_;
 }
 
 // Recarga la textura
 void Text::reLoadTexture()
 {
-	sprite->getTexture()->reLoad();
+	sprite_->getTexture()->reLoad();
 }
 
 // Establece si se usa un tamaño fijo de letra
 void Text::setFixedWidth(bool value)
 {
-	fixedWidth = value;
+	fixed_width_ = value;
 }
 
 // Carga una paleta de colores para el texto
-void Text::addPalette(std::string path)
+void Text::addPalette(const std::string &path)
 {
-	texture->addPalette(path);
+	texture_->addPalette(path);
 }
 
 // Establece una paleta de colores para el texto
 void Text::setPalette(int index)
 {
-	texture->setPalette(index);
+	texture_->setPalette(index);
 }