El game_text ara gasta PathSprites en lloc d'SmartSprites

fix: la paleta dels jugadors no s'iniciava correctament

README.md

@@ -1,67 +1,39 @@
-# Coffee Crisis
+# Coffee Crisis Arcade Edition
 
-Coffee Crisis es un juego arcade que pondrá a prueba tus reflejos. Empezado durante el verano de 2020 y terminado un año despues, en el verano de 2021. Intenta conseguir todos los puntos que puedas con una sola vida a traves de los 10 niveles de juego y ayuda a Bal1 a defender la UPV de la invasión de la cafeína esférica y saltarina.
+Coffee Crisis Arcade Edition es la versió ampliada i millorada del aclamat Coffee Crisis. Preparat per a jugar sense parar amn dos jugadors, nous gràfics i moltes sorpreses mes.
 
-![alt text](https://php.sustancia.synology.me/images/cc1.png)
+<p align="center">
+    <img src="https://php.sustancia.synology.me/images/ccae_title.png" alt="Titol" 
+</p>
 
-## Teclado
-El juego se maneja con teclado, aunque tambien se puede conectar un mando de control.
-Las teclas son las siguientes:
+## Controls
+El joc està optimitzat per a ser jugat amb un mando de jocs, encara que un dels jugadors pot utilitzar el teclat.
+Les tecles son les següents:
 
-* **Cursores**: Mover al personaje, moverse por los menus
-* **Q, W, E**: Disparar a la izquierda, al centro y a la derecha respectivamente
-* **ESCAPE**: Pone en pausa el juego durante la partida. Sale de los menus. Cierra el juego
-* **ENTER**: Acepta las opciones en los menus
+* **Fletxes**: Mou al personatge
+* **Q, W, E**: Disparar a la esquerra, al centre i a la dreta respectivament
 
-![alt text](https://php.sustancia.synology.me/images/cc2.png)
+<p align="center">
+    <img src="https://php.sustancia.synology.me/images/ccae1.png" alt="Joc" 
+</p>
 
-## Compilar
+## Altres tecles
+- **Tecla ESC**: Tancar el joc
 
-Para compilar el código se necesitan tener las librerías SDL instaladas en el sistema y el compilador g++.
+- **Tecla F1**: Fa la finestra mes xicoteta
 
-En Linux:
-```bash
-sudo apt install libsdl2-dev g++
-```
+- **Tecla F2**: Fa la finestra mes gran
 
-En macOS se pueden instalar fácilmente con [brew](https://brew.sh):
-```bash
-brew install sdl2 g++
-```
+- **Tecla F3**: Alterna entre el mode de pantalla completa i el de finestra
 
-Una vez instaladas las librerías SDL, se puede compilar utilizando el fichero Makefile suministrado.
+- **Tecla F4**: Activa o desactiva els shaders
 
-En Linux:
-```bash
-make linux
-```
+- **Tecla F10**: Reset
 
-En macOS:
-```bash
-make macos
-```
-![alt text](https://php.sustancia.synology.me/images/cc3.png)
+<p align="center">
+    <img src="https://php.sustancia.synology.me/images/ccae2.png" alt="Joc" 
+</p>
 
-## Como ejecutar
 
-Para ejecutar el juego hay que escribir en la terminal la orden que se muestra a continuación.
-
-En Linux:
-```bash
-./coffee_crisis_linux
-```
-
-En macOS:
-```bash
-./coffee_crisis_macos
-```
-
-En macOS tambien puedes hacer doble click sobre el archivo coffee_crisis_macos
-
-## Agradecimientos
-A los jailers y a la jail. Y entre ellos, a JailDoctor por estar siempre ahí apoyándonos/obligándonos a sacar un Jailgame más.
-
-Y por supuesto a ti por estar aquí.
-
-## Licencia
-Usa el código para lo que quieras: aprender, reirte, curiosear... excepto para sacar beneficio económico. Si lo consigues, por favor avísame y vamos a medias.
+## Agraiments
+A chatGPT i sobretot a Copilot. Gracies per estar sempre quan vos he necesitat.

data/config/param_320x256.txt

@@ -7,6 +7,7 @@ game.play_area.rect.y    0 # Rectangulo con la posición de la zona de juego
 game.play_area.rect.w  320 # Rectangulo con la posición de la zona de juego
 game.play_area.rect.h  216 # Rectangulo con la posición de la zona de juego
 game.enter_name_seconds 30 # Duración en segundos para introducir el nombre al finalizar la partida
+game.game_text.dest_y
 
 ## FADE
 fade.num_squares_width    160

linux-utils/run_valgrind.sh

@@ -1,3 +0,0 @@
-#!/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/check_all_includes.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+SOURCEPATH=../source/
+
+for i in "$SOURCEPATH"/*.cpp
+do
+    include-what-you-use -D DEBUG -D VERBOSE -std=c++20 -Wall "$i"
+done

linux_utils/check_includes.sh

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

linux_utils/cppcheck_run.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+# warning,style,performance
+#cppcheck --force --enable=warning,style,performance --std=c++20 \
+# --suppressions-list=/home/sergio/gitea/coffee_crisis_arcade_edition/linux-utils/cppcheck_suppressions \
+# /home/sergio/gitea/coffee_crisis_arcade_edition/source/ \
+# 2>/home/sergio/cppcheck-result-warning-style-performance.txt
+
+# all
+#cppcheck --force --enable=all -I /usr/include --std=c++20 \
+#--suppress=missingIncludeSystem \
+#--suppressions-list=/home/sergio/gitea/coffee_crisis_arcade_edition/linux-utils/cppcheck_suppressions \
+#/home/sergio/gitea/coffee_crisis_arcade_edition/source/ \
+#2>/home/sergio/cppcheck-result-all.txt
+
+# unusedFunction
+cppcheck --enable=style --std=c++20 \
+--suppressions-list=./cppcheck_suppressions \
+../source/ \
+2>/home/sergio/cppcheck-result-all.txt

linux_utils/cppcheck_suppressions

@@ -0,0 +1,8 @@
+*:/home/sergio/gitea/coffee_crisis_arcade_edition/source/stb*
+*:/home/sergio/gitea/coffee_crisis_arcade_edition/source/gif.c
+*:/home/sergio/gitea/coffee_crisis_arcade_edition/source/jail*
+*:/usr/include/*
+*:../source/stb*
+*:../source/gif.c
+*:../source/jail*
+*:/usr/include/*

linux_utils/run_valgrind.sh

@@ -0,0 +1,6 @@
+#!/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

source/animated_sprite.cpp

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

source/animated_sprite.h

@@ -1,12 +1,11 @@
 #pragma once
 
-#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;
+#include <SDL2/SDL_rect.h> // Para SDL_Rect
+#include <memory>          // Para shared_ptr
+#include <string>          // Para string
+#include <vector>          // Para vector
+#include "moving_sprite.h" // Para MovingSprite
+class Texture;             // lines 9-9
 
 struct Animation
 {
@@ -21,67 +20,40 @@ struct Animation
     Animation() : name(std::string()), speed(5), loop(0), completed(false), current_frame(0), counter(0) {}
 };
 
-using Animations = std::vector<std::string>;
+using AnimationsFileBuffer = std::vector<std::string>;
 
 // Carga las animaciones en un vector(Animations) desde un fichero
-Animations loadAnimationsFromFile(const std::string &file_path);
+AnimationsFileBuffer loadAnimationsFromFile(const std::string &file_path);
 
 class AnimatedSprite : public MovingSprite
 {
 protected:
     // Variables
     std::vector<Animation> animations_; // Vector con las diferentes animaciones
-    int current_animation_;             // Animacion activa
+    int current_animation_ = 0;         // Animacion activa
 
     // Calcula el frame correspondiente a la animación actual
     void animate();
 
-    // Carga la animación desde un fichero
-    std::vector<Animation> loadFromFile(const std::string &file_path);
-
-    // Carga la animación desde un vector
-    bool loadFromVector(const Animations &source);
+    // Carga la animación desde un vector de cadenas
+    void loadFromAnimationsFileBuffer(const AnimationsFileBuffer &source);
 
 public:
     // Constructor
     AnimatedSprite(std::shared_ptr<Texture> texture, const std::string &file_path);
-    AnimatedSprite(std::shared_ptr<Texture> texture, const Animations &animations);
-    explicit AnimatedSprite(std::shared_ptr<Texture> texture);
+    AnimatedSprite(std::shared_ptr<Texture> texture, const AnimationsFileBuffer &animations);
+    explicit AnimatedSprite(std::shared_ptr<Texture> texture)
+        : MovingSprite(texture) {}
 
     // Destructor
-    virtual ~AnimatedSprite();
+    virtual ~AnimatedSprite() = default;
 
     // Actualiza las variables del objeto
     void update() override;
 
-    // Obtiene el número de frames de la animación actual
-    int getNumFrames();
-
-    // Establece el frame actual de la animación
-    void setCurrentFrame(int num);
-
-    // Establece el valor del contador
-    void setAnimationCounter(const std::string &name, int num);
-
-    // Establece la velocidad de una animación
-    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(const std::string &name, int loop);
-    void setAnimationLoop(int index, int loop);
-
-    // Establece el valor de la variable
-    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(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(const std::string &name);
 
@@ -89,12 +61,6 @@ public:
     void setCurrentAnimation(const std::string &name = "default");
     void setCurrentAnimation(int index = 0);
 
-    // 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);
-
-    // OLD - Establece el contador para todas las animaciones
-    void setAnimationCounter(int value);
-
     // Reinicia la animación
     void resetAnimation();
 };

source/asset.cpp

@@ -1,9 +1,9 @@
 #include "asset.h"
-#include "utils.h"
-#include <SDL2/SDL_rwops.h>  // for SDL_RWFromFile, SDL_RWclose, SDL_RWops
-#include <SDL2/SDL_stdinc.h> // for SDL_max
-#include <stddef.h>          // for size_t
-#include <iostream>          // for basic_ostream, operator<<, cout, endl
+#include <algorithm> // Para find_if, max
+#include <fstream>   // Para basic_ostream, operator<<, basic_ifstream, endl
+#include <iostream>  // Para cout
+#include <string>    // Para allocator, char_traits, string, operator+, oper...
+#include "utils.h"   // Para getFileName, printWithDots
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Asset *Asset::asset_ = nullptr;
@@ -26,42 +26,31 @@ Asset *Asset::get()
     return Asset::asset_;
 }
 
-// Constructor
-Asset::Asset(const std::string &executable_path)
-    : executable_path_(executable_path.substr(0, executable_path.find_last_of("\\/")))
-{
-    longest_name_ = 0;
-}
-
 // Añade un elemento a la lista
 void Asset::add(const std::string &file, AssetType type, bool required, bool absolute)
 {
-    AssetItem ai;
-    ai.file = absolute ? file : executable_path_ + file;
-    ai.type = type;
-    ai.required = required;
-    file_list_.push_back(ai);
-
-    const std::string file_name = file.substr(file.find_last_of("\\/") + 1);
-    longest_name_ = SDL_max(longest_name_, file_name.size());
+    file_list_.emplace_back(absolute ? file : executable_path_ + file, type, required);
+    longest_name_ = std::max(longest_name_, static_cast<int>(file_list_.back().file.size()));
 }
 
-// Devuelve el fichero de un elemento de la lista a partir de una cadena
+// Devuelve la ruta completa a un fichero a partir de una cadena
 std::string Asset::get(const std::string &text) const
 {
-    for (const auto &f : file_list_)
+    auto it = std::find_if(file_list_.begin(), file_list_.end(),
+                           [&text](const auto &f)
+                           {
+                               return getFileName(f.file) == text;
+                           });
+
+    if (it != file_list_.end())
     {
-        const size_t last_index = f.file.find_last_of("/") + 1;
-        const std::string file = f.file.substr(last_index, std::string::npos);
-
-        if (file == text)
-        {
-            return f.file;
-        }
+        return it->file;
+    }
+    else
+    {
+        std::cout << "Warning: file " << text << " not found" << std::endl;
+        return "";
     }
-
-    std::cout << "Warning: file " << text.c_str() << " not found" << std::endl;
-    return "";
 }
 
 // Comprueba que existen todos los elementos
@@ -114,20 +103,12 @@ bool Asset::check() const
 // Comprueba que existe un fichero
 bool Asset::checkFile(const std::string &path) const
 {
-    auto success = false;
+    std::ifstream file(path);
+    bool success = file.good();
+    file.close();
 
-    // Comprueba si existe el fichero
-    auto file = SDL_RWFromFile(path.c_str(), "rb");
-
-    if (file)
-    {
-        success = true;
-        SDL_RWclose(file);
-    }
-
-    const std::string file_name = path.substr(path.find_last_of("\\/") + 1);
     if (!success)
-        printWithDots("Checking file : ", file_name, (success ? " [ OK ]" : " [ ERROR ]"));
+        printWithDots("Checking file : ", getFileName(path), "[ ERROR ]");
 
     return success;
 }

source/asset.h

@@ -1,7 +1,8 @@
 #pragma once
 
-#include <string> // for string, basic_string
-#include <vector> // for vector
+#include <string> // para string, basic_string
+#include <vector> // para vector
+#include "utils.h"
 
 enum class AssetType : int
 {
@@ -27,14 +28,17 @@ private:
 	// Estructura para definir un item
 	struct AssetItem
 	{
-		std::string file;	 // Ruta del fichero desde la raiz del directorio
-		enum AssetType type; // Indica el tipo de recurso
-		bool required;		 // Indica si es un fichero que debe de existir
-							 // bool absolute;		 // Indica si la ruta que se ha proporcionado es una ruta absoluta
+		std::string file; // Ruta del fichero desde la raíz del directorio
+		AssetType type;	  // Indica el tipo de recurso
+		bool required;	  // Indica si es un fichero que debe de existir
+
+		// Constructor
+		AssetItem(const std::string &filePath, AssetType assetType, bool isRequired)
+			: file(filePath), type(assetType), required(isRequired) {}
 	};
 
 	// Variables
-	int longest_name_;				   // Contiene la longitud del nombre de fichero mas largo
+	int longest_name_ = 0;			   // 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
 
@@ -45,7 +49,8 @@ private:
 	std::string getTypeName(AssetType type) const;
 
 	// Constructor
-	explicit Asset(const std::string &executable_path);
+	explicit Asset(const std::string &executable_path)
+		: executable_path_(getPath(executable_path)) {}
 
 	// Destructor
 	~Asset() = default;
@@ -63,7 +68,7 @@ public:
 	// Añade un elemento a la lista
 	void add(const std::string &file, AssetType type, bool required = true, bool absolute = false);
 
-	// Devuelve un elemento de la lista a partir de una cadena
+	// Devuelve la ruta completa a un fichero a partir de una cadena
 	std::string get(const std::string &text) const;
 
 	// Comprueba que existen todos los elementos

source/background.cpp

@@ -1,14 +1,13 @@
 #include "background.h"
-#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_pixels.h>    // for SDL_PIXELFORMAT_RGBA8888
-#include <algorithm>            // for clamp, max
-#include "asset.h"              // for Asset
-#include "moving_sprite.h"      // for MovingSprite
-#include "param.h"              // for param
-#include "resource.h"           // for Resource
-#include "screen.h"
-#include "sprite.h"  // for Sprite
-#include "texture.h" // for Texture
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888
+#include <algorithm>            // Para clamp, max
+#include "moving_sprite.h"      // Para MovingSprite
+#include "param.h"              // Para Param, ParamBackground, param
+#include "resource.h"           // Para Resource
+#include "screen.h"             // Para Screen
+#include "sprite.h"             // Para Sprite
+#include "texture.h"            // Para Texture
 
 // Constructor
 Background::Background()
@@ -20,16 +19,11 @@ Background::Background()
       grass_texture_(Resource::get()->getTexture("game_grass.png")),
       gradients_texture_(Resource::get()->getTexture("game_sky_colors.png")),
 
-      gradient_number_(0),
-      alpha_(0),
-      clouds_speed_(0),
-      transition_(0),
-      counter_(0),
       rect_({0, 0, gradients_texture_->getWidth() / 2, gradients_texture_->getHeight() / 2}),
       src_rect_({0, 0, 320, 240}),
       dst_rect_({0, 0, 320, 240}),
       base_(rect_.h),
-      color_({param.background.attenuate_color.r, param.background.attenuate_color.g, param.background.attenuate_color.b}),
+      color_(Color(param.background.attenuate_color.r, param.background.attenuate_color.g, param.background.attenuate_color.b)),
       alpha_color_text_(param.background.attenuate_alpha),
       alpha_color_text_temp_(param.background.attenuate_alpha)
 
@@ -253,18 +247,6 @@ void Background::setPos(SDL_Rect pos)
     src_rect_.h = pos.h;
 }
 
-// Ajusta el valor de la variable
-void Background::setSrcRect(SDL_Rect value)
-{
-    src_rect_ = value;
-}
-
-// Ajusta el valor de la variable
-void Background::setDstRect(SDL_Rect value)
-{
-    dst_rect_ = value;
-}
-
 // Establece el color_ de atenuación
 void Background::setColor(Color color)
 {

source/background.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>   // for SDL_Rect
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
-#include <memory>            // for unique_ptr, shared_ptr
-#include "utils.h"           // for Color
+#include <SDL2/SDL_rect.h>   // para SDL_Rect
+#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
+#include <memory>            // para unique_ptr, shared_ptr
+#include "utils.h"           // para Color
 class MovingSprite;
 class Sprite;
 class Texture;
@@ -32,12 +32,6 @@ class Texture;
         - setTransition(float value)
           Porcentaje (entre 0.0f (textura actual) y 1.0f (textura siguiente)) para mostrar entre la textura de fondo actual y la siguiente
 
-        - setSrcRect(SDL_Rect value)
-          Rectangulo de la textura de fondo que se desea mostrar
-
-        - 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 color)
           Establece el color de la textura de superposición
 
@@ -74,11 +68,11 @@ private:
   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
+  int gradient_number_ = 0;        // Indica el número de degradado de fondo que se va a dibujar
+  int alpha_ = 0;                  // Transparencia entre los dos degradados
+  float clouds_speed_ = 0;         // Velocidad a la que se desplazan las nubes
+  float transition_ = 0;           // Nivel de transición del fondo 0..1
+  int counter_ = 0;                // 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
@@ -133,12 +127,6 @@ public:
   // Ajusta el valor de la variable
   void setTransition(float value);
 
-  // Ajusta el valor de la variable
-  void setSrcRect(SDL_Rect value);
-
-  // Ajusta el valor de la variable
-  void setDstRect(SDL_Rect value);
-
   // Establece el color de atenuación
   void setColor(Color color);
 

source/balloon.cpp

@@ -1,310 +1,131 @@
 #include "balloon.h"
-#include <cmath>			 // for abs
-#include "animated_sprite.h" // for SpriteAnimated
-#include "moving_sprite.h"	 // for MovingSprite
-#include "param.h"			 // for param
-#include "sprite.h"			 // for Sprite
-#include "texture.h"		 // for Texture
+#include <algorithm>		 // Para clamp
+#include <cmath>			 // Para fabs
+#include "animated_sprite.h" // Para AnimatedSprite
+#include "param.h"			 // Para Param, param, ParamBalloon, ParamGame
+#include "sprite.h"			 // Para Sprite
+#include "texture.h"		 // Para Texture
 
 // Constructor
-Balloon::Balloon(float x, float y, Uint8 kind, float vel_x, float speed, Uint16 creation_timer, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
+Balloon::Balloon(float x, float y, BalloonType type, BalloonSize size, float vel_x, float speed, Uint16 creation_timer, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
 	: sprite_(std::make_unique<AnimatedSprite>(texture, animation)),
-	  pos_x_(x),
-	  pos_y_(y),
-	  vel_x_(vel_x),
+	  x_(x),
+	  y_(y),
+	  vx_(vel_x),
 	  being_created_(creation_timer > 0),
-	  blinking_(false),
-	  enabled_(true),
 	  invulnerable_(creation_timer > 0),
-	  stopped_(true),
-	  visible_(true),
+	  stopped_(creation_timer > 0),
 	  creation_counter_(creation_timer),
 	  creation_counter_ini_(creation_timer),
-	  stopped_counter_(0),
-	  kind_(kind),
-	  counter_(0),
-	  travel_y_(1.0f),
+	  type_(type),
+	  size_(size),
 	  speed_(speed)
 {
-
-	switch (kind_)
+	switch (type_)
 	{
-	case BALLOON_1:
-		// Alto y ancho del objeto
-		width_ = BALLOON_WIDTH_1;
-		height_ = BALLOON_WIDTH_1;
-		size_ = BALLOON_SIZE_1;
-		power_ = 1;
+	case BalloonType::BALLOON:
+	{
+		vy_ = 0;
+		max_vy_ = 3.0f;
 
-		// Inicializa los valores de velocidad y gravedad
-		vel_y_ = 0;
-		max_vel_y_ = 3.0f;
-		gravity_ = param.balloon_1.grav;
-		default_vel_y_ = param.balloon_1.vel;
-
-		// Puntos que da el globo al ser destruido
-		score_ = BALLOON_SCORE_1;
-
-		// Amenaza que genera el globo
-		menace_ = 1;
+		const int size = static_cast<int>(size_);
+		gravity_ = param.balloon.at(size).grav;
+		default_vy_ = param.balloon.at(size).vel;
+		h_ = w_ = BALLOON_SIZE[size];
+		power_ = BALLOON_POWER[size];
+		menace_ = BALLOON_MENACE[size];
+		score_ = BALLOON_SCORE[size];
 
 		break;
+	}
 
-	case BALLOON_2:
-		// Alto y ancho del objeto
-		width_ = BALLOON_WIDTH_2;
-		height_ = BALLOON_WIDTH_2;
-		size_ = BALLOON_SIZE_2;
-		power_ = 3;
-
-		// Inicializa los valores de velocidad y gravedad
-		vel_y_ = 0;
-		max_vel_y_ = 3.0f;
-		gravity_ = param.balloon_2.grav;
-		default_vel_y_ = param.balloon_2.vel;
-
-		// Puntos que da el globo al ser destruido
-		score_ = BALLOON_SCORE_2;
-
-		// Amenaza que genera el globo
-		menace_ = 2;
-
-		break;
-
-	case BALLOON_3:
-		// Alto y ancho del objeto
-		width_ = BALLOON_WIDTH_3;
-		height_ = BALLOON_WIDTH_3;
-		size_ = BALLOON_SIZE_3;
-		power_ = 7;
-
-		// Inicializa los valores de velocidad y gravedad
-		vel_y_ = 0;
-		max_vel_y_ = 3.0f;
-		gravity_ = param.balloon_3.grav;
-		default_vel_y_ = param.balloon_3.vel;
-
-		// Puntos que da el globo al ser destruido
-		score_ = BALLOON_SCORE_3;
-
-		// Amenaza que genera el globo
-		menace_ = 4;
-
-		break;
-
-	case BALLOON_4:
-		// Alto y ancho del objeto
-		width_ = BALLOON_WIDTH_4;
-		height_ = BALLOON_WIDTH_4;
-		size_ = BALLOON_SIZE_4;
-		power_ = 15;
-
-		// Inicializa los valores de velocidad y gravedad
-		vel_y_ = 0;
-		max_vel_y_ = 3.0f;
-		gravity_ = param.balloon_4.grav;
-		default_vel_y_ = param.balloon_4.vel;
-
-		// Puntos que da el globo al ser destruido
-		score_ = BALLOON_SCORE_4;
-
-		// Amenaza que genera el globo
-		menace_ = 8;
-
-		break;
-
-	case HEXAGON_1:
-		// Alto y ancho del objeto
-		width_ = BALLOON_WIDTH_1;
-		height_ = BALLOON_WIDTH_1;
-		size_ = BALLOON_SIZE_1;
-		power_ = 1;
-
-		// Inicializa los valores de velocidad y gravedad
-		vel_y_ = fabs(vel_x_ * 2.0f);
-		max_vel_y_ = vel_y_;
+	case BalloonType::FLOATER:
+	{
+		default_vy_ = max_vy_ = vy_ = fabs(vx_ * 2.0f);
 		gravity_ = 0.00f;
-		default_vel_y_ = vel_y_;
 
-		// Puntos que da el globo al ser destruido
-		score_ = BALLOON_SCORE_1;
-
-		// Amenaza que genera el globo
-		menace_ = 1;
+		const int size = static_cast<int>(size_);
+		h_ = w_ = BALLOON_SIZE[size];
+		power_ = BALLOON_POWER[size];
+		menace_ = BALLOON_MENACE[size];
+		score_ = BALLOON_SCORE[size];
 
 		break;
+	}
 
-	case HEXAGON_2:
-		// Alto y ancho del objeto
-		width_ = BALLOON_WIDTH_2;
-		height_ = BALLOON_WIDTH_2;
-		size_ = BALLOON_SIZE_2;
-		power_ = 3;
+	case BalloonType::POWERBALL:
+	{
+		const int size = 3;
+		h_ = w_ = BALLOON_SIZE[size];
+		power_ = score_ = menace_ = 0;
 
-		// Inicializa los valores de velocidad y gravedad
-		vel_y_ = fabs(vel_x_ * 2.0f);
-		max_vel_y_ = vel_y_;
-		gravity_ = 0.00f;
-		default_vel_y_ = vel_y_;
+		vy_ = 0;
+		max_vy_ = 3.0f;
+		gravity_ = param.balloon.at(size).grav;
+		default_vy_ = param.balloon.at(size).vel;
 
-		// Puntos que da el globo al ser destruido
-		score_ = BALLOON_SCORE_2;
-
-		// Amenaza que genera el globo
-		menace_ = 2;
-
-		break;
-
-	case HEXAGON_3:
-		// Alto y ancho del objeto
-		width_ = BALLOON_WIDTH_3;
-		height_ = BALLOON_WIDTH_3;
-		size_ = BALLOON_SIZE_3;
-		power_ = 7;
-
-		// Inicializa los valores de velocidad y gravedad
-		vel_y_ = fabs(vel_x_ * 2.0f);
-		max_vel_y_ = vel_y_;
-		gravity_ = 0.00f;
-		default_vel_y_ = vel_y_;
-
-		// Puntos que da el globo al ser destruido
-		score_ = BALLOON_SCORE_3;
-
-		// Amenaza que genera el globo
-		menace_ = 4;
-
-		break;
-
-	case HEXAGON_4:
-		// Alto y ancho del objeto
-		width_ = BALLOON_WIDTH_4;
-		height_ = BALLOON_WIDTH_4;
-		size_ = BALLOON_SIZE_4;
-		power_ = 15;
-
-		// Inicializa los valores de velocidad y gravedad
-		vel_y_ = fabs(vel_x_ * 2.0f);
-		max_vel_y_ = vel_y_;
-		gravity_ = 0.00f;
-		default_vel_y_ = vel_y_;
-
-		// Puntos que da el globo al ser destruido
-		score_ = BALLOON_SCORE_4;
-
-		// Amenaza que genera el globo
-		menace_ = 8;
-
-		break;
-
-	case POWER_BALL:
-		// Alto y ancho del objeto
-		width_ = BALLOON_WIDTH_4;
-		height_ = BALLOON_WIDTH_4;
-		size_ = 4;
-		power_ = 0;
-
-		// Inicializa los valores de velocidad y gravedad
-		vel_y_ = 0;
-		max_vel_y_ = 3.0f;
-		gravity_ = param.balloon_4.grav;
-		default_vel_y_ = param.balloon_4.vel;
-
-		// Puntos que da el globo al ser destruido
-		score_ = 0;
-
-		// Amenaza que genera el globo
-		menace_ = 0;
-
-		// Añade rotación al sprite_
 		sprite_->disableRotate();
 		sprite_->setRotateSpeed(0);
-		vel_x_ > 0.0f ? sprite_->setRotateAmount(2.0) : sprite_->setRotateAmount(-2.0);
+		sprite_->setRotateAmount(vx_ > 0.0f ? 2.0 : -2.0);
 
 		break;
+	}
 
 	default:
 		break;
 	}
 
-	// Valores para el efecto de rebote
-	bouncing_.enabled = false;
-	bouncing_.counter = 0;
-	bouncing_.speed = 2;
-	bouncing_.zoomW = 1.0f;
-	bouncing_.zoomH = 1.0f;
-	bouncing_.despX = 0.0f;
-	bouncing_.despY = 0.0f;
-	bouncing_.w = {1.10f, 1.05f, 1.00f, 0.95f, 0.90f, 0.95f, 1.00f, 1.02f, 1.05f, 1.02f};
-	bouncing_.h = {0.90f, 0.95f, 1.00f, 1.05f, 1.10f, 1.05f, 1.00f, 0.98f, 0.95f, 0.98f};
-
 	// Configura el sprite
-	sprite_->setPos({static_cast<int>(pos_x_), static_cast<int>(pos_y_), width_, height_});
-
-	// Tamaño del circulo de colisión
-	collider_.r = width_ / 2;
+	sprite_->setWidth(w_);
+	sprite_->setHeight(h_);
+	shiftSprite();
 
 	// Alinea el circulo de colisión con el objeto
-	updateColliders();
+	collider_.r = w_ / 2;
+	shiftColliders();
+
+	// Establece la animación a usar
+	setAnimation();
 }
 
 // Centra el globo en la posición X
-void Balloon::allignTo(int x)
+void Balloon::alignTo(int x)
 {
-	pos_x_ = float(x - (width_ / 2));
-
-	if (pos_x_ < param.game.play_area.rect.x)
-	{
-		pos_x_ = param.game.play_area.rect.x + 1;
-	}
-	else if ((pos_x_ + width_) > param.game.play_area.rect.w)
-	{
-		pos_x_ = float(param.game.play_area.rect.w - width_ - 1);
-	}
-
-	// Posición X,Y del sprite_
-	sprite_->setPosX(getPosX());
-	sprite_->setPosY(getPosY());
-
-	// Alinea el circulo de colisión con el objeto
-	updateColliders();
+	x_ = static_cast<float>(x - (w_ / 2));
+	const int min_x = param.game.play_area.rect.x;
+	const int max_x = param.game.play_area.rect.w - w_;
+	x_ = std::clamp(x_, static_cast<float>(min_x), static_cast<float>(max_x));
 }
 
 // Pinta el globo en la pantalla
 void Balloon::render()
 {
-	if (visible_ && enabled_)
+	if (isBeingCreated())
+	{
+		// Aplica alpha blending
+		sprite_->getTexture()->setAlpha(255 - (int)((float)creation_counter_ * (255.0f / (float)creation_counter_ini_)));
+		sprite_->render();
+		sprite_->getTexture()->setAlpha(255);
+	}
+	else
 	{
 		if (bouncing_.enabled)
 		{
-			if (kind_ != POWER_BALL)
-			{
-				// Aplica desplazamiento para el zoom
-				sprite_->setPosX(getPosX() + bouncing_.despX);
-				sprite_->setPosY(getPosY() + bouncing_.despY);
-				sprite_->render();
-				sprite_->setPosX(getPosX() - bouncing_.despX);
-				sprite_->setPosY(getPosY() - bouncing_.despY);
-			}
-		}
-		else if (isBeingCreated())
-		{
-			// Aplica alpha blending
-			sprite_->getTexture()->setAlpha(255 - (int)((float)creation_counter_ * (255.0f / (float)creation_counter_ini_)));
+			// Aplica efecto de bouncing
+			sprite_->setPos(x_ + bouncing_.despX, y_ + bouncing_.despY);
 			sprite_->render();
-			sprite_->getTexture()->setAlpha(255);
+			sprite_->setPos(x_ - bouncing_.despX, y_ - bouncing_.despY);
 		}
 		else
-		{
 			sprite_->render();
-		}
+	}
 
-		if (kind_ == POWER_BALL && !isBeingCreated())
-		{
-			auto sp = std::make_unique<Sprite>(sprite_->getTexture(), sprite_->getPosition());
-			sp->setSpriteClip(BALLOON_WIDTH_4, 0, BALLOON_WIDTH_4, BALLOON_WIDTH_4);
-			sp->render();
-		}
+	// Añade la máscara del borde a la PowerBall
+	if (type_ == BalloonType::POWERBALL && !isBeingCreated())
+	{
+		auto sp = std::make_unique<Sprite>(sprite_->getTexture(), sprite_->getPosition());
+		sp->setSpriteClip(BALLOON_SIZE[3], 0, BALLOON_SIZE[3], BALLOON_SIZE[3]);
+		sp->render();
 	}
 }
 
@@ -314,61 +135,45 @@ void Balloon::move()
 	// Comprueba si se puede mover
 	if (!isStopped())
 	{
-		// Lo mueve a izquierda o derecha
-		pos_x_ += (vel_x_ * speed_);
+		// Mueve el globo en horizontal
+		x_ += vx_ * speed_;
 
-		// Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido
-		if ((pos_x_ < param.game.play_area.rect.x) || (pos_x_ + width_ > param.game.play_area.rect.w))
+		// Colisión en las partes laterales de la zona de juego
+		const int clip = 2;
+		const float min_x = param.game.play_area.rect.x - clip;
+		const float max_x = param.game.play_area.rect.w - w_ + clip;
+		if (x_ < min_x || x_ > max_x)
 		{
-			// Corrige posición
-			pos_x_ -= (vel_x_ * speed_);
-
-			// Invierte sentido
-			vel_x_ = -vel_x_;
-
-			// Invierte la rotación
-			sprite_->switchRotate();
-
-			// Activa el efecto de rebote
-			if (kind_ != POWER_BALL)
-			{
-				bounceStart();
-			}
+			x_ = std::clamp(x_, min_x, max_x);
+			vx_ = -vx_;
+			// Activa el efecto de rebote o invierte la rotación
+			if (type_ == BalloonType::POWERBALL)
+				sprite_->switchRotate();
+			else
+				enableBounce();
 		}
 
-		// Mueve el globo hacia arriba o hacia abajo
-		pos_y_ += (vel_y_ * speed_);
+		// Mueve el globo en vertical
+		y_ += vy_ * speed_;
 
-		// Si se sale por arriba
-		if (pos_y_ < param.game.play_area.rect.y)
+		// Colisión en la parte superior de la zona de juego
+		const int min_y = param.game.play_area.rect.y;
+		if (y_ < min_y)
 		{
-			// Corrige
-			pos_y_ = param.game.play_area.rect.y;
-
-			// Invierte sentido
-			vel_y_ = -vel_y_;
-
-			// Activa el efecto de rebote
-			if (kind_ != POWER_BALL)
-			{
-				bounceStart();
-			}
+			y_ = min_y;
+			vy_ = -vy_;
+			if (type_ != BalloonType::POWERBALL)
+				enableBounce();
 		}
 
-		// Si el globo se sale por la parte inferior
-		if (pos_y_ + height_ > param.game.play_area.rect.h)
+		// Colisión en la parte inferior de la zona de juego
+		const int max_y = param.game.play_area.rect.h - h_;
+		if (y_ > max_y)
 		{
-			// Corrige
-			pos_y_ = param.game.play_area.rect.h - height_;
-
-			// Invierte colocando una velocidad por defecto
-			vel_y_ = -default_vel_y_;
-
-			// Activa el efecto de rebote
-			if (kind_ != POWER_BALL)
-			{
-				bounceStart();
-			}
+			y_ = max_y;
+			vy_ = -default_vy_;
+			if (type_ != BalloonType::POWERBALL)
+				enableBounce();
 		}
 
 		/*
@@ -390,48 +195,15 @@ void Balloon::move()
 			travel_y_ -= 1.0f;
 
 			// Aplica la gravedad al objeto sin pasarse de una velocidad máxima
-			vel_y_ += gravity_;
+			vy_ += gravity_;
 		}
-
-		// Actualiza la posición del sprite_
-		sprite_->setPosX(getPosX());
-		sprite_->setPosY(getPosY());
 	}
 }
 
 // Deshabilita el globo y pone a cero todos los valores
 void Balloon::disable()
 {
-	being_created_ = false;
-	blinking_ = false;
-	collider_.r = 0;
-	collider_.x = 0;
-	collider_.y = 0;
-	counter_ = 0;
-	creation_counter_ = 0;
-	creation_counter_ini_ = 0;
-	default_vel_y_ = 0.0f;
 	enabled_ = false;
-	gravity_ = 0.0f;
-	height_ = 0;
-	invulnerable_ = false;
-	kind_ = 0;
-	max_vel_y_ = 0.0f;
-	menace_ = 0;
-	pos_x_ = 0.0f;
-	pos_y_ = 0.0f;
-	power_ = 0;
-	score_ = 0;
-	size_ = 0;
-	speed_ = 0;
-	stopped_ = false;
-	stopped_counter_ = 0;
-	travel_y_ = 0;
-	vel_x_ = 0.0f;
-	vel_y_ = 0.0f;
-	visible_ = false;
-	width_ = 0;
-	sprite_->clear();
 }
 
 // Explosiona el globo
@@ -443,16 +215,13 @@ void Balloon::pop()
 // Actualiza al globo a su posicion, animación y controla los contadores
 void Balloon::update()
 {
-	if (enabled_)
-	{
-		sprite_->update();
-		move();
-		updateAnimation();
-		updateColliders();
-		updateState();
-		updateBounce();
-		++counter_;
-	}
+	move();
+	updateState();
+	updateBounce();
+	shiftSprite();
+	shiftColliders();
+	sprite_->update();
+	++counter_;
 }
 
 // Actualiza los estados del globo
@@ -462,105 +231,69 @@ void Balloon::updateState()
 	if (isBeingCreated())
 	{
 		// Actualiza el valor de las variables
-		setStop(true);
+		stop();
 		setInvulnerable(true);
 
-		// Todavia tiene tiempo en el contador
 		if (creation_counter_ > 0)
 		{
 			// Desplaza lentamente el globo hacia abajo y hacia un lado
 			if (creation_counter_ % 10 == 0)
 			{
-				pos_y_++;
-				pos_x_ += vel_x_;
+				y_++;
+				x_ += vx_;
 
 				// Comprueba no se salga por los laterales
-				if ((pos_x_ < param.game.play_area.rect.x) || (pos_x_ > (param.game.play_area.rect.w - width_)))
+				const int min_x = param.game.play_area.rect.x;
+				const int max_x = param.game.play_area.rect.w - w_;
+
+				if (x_ < min_x || x_ > max_x)
 				{
 					// Corrige y cambia el sentido de la velocidad
-					pos_x_ -= vel_x_;
-					vel_x_ = -vel_x_;
+					x_ -= vx_;
+					vx_ = -vx_;
 				}
-
-				// Actualiza la posición del sprite_
-				sprite_->setPosX(getPosX());
-				sprite_->setPosY(getPosY());
-
-				// Actualiza la posición del circulo de colisión
-				updateColliders();
 			}
-
-			creation_counter_--;
+			--creation_counter_;
 		}
-		// El contador ha llegado a cero
+
 		else
 		{
-			setBeingCreated(false);
-			setStop(false);
-			setVisible(true);
+			// El contador ha llegado a cero
+			being_created_ = false;
+			start();
 			setInvulnerable(false);
-			if (kind_ == POWER_BALL)
-			{
-				sprite_->enableRotate();
-			}
-		}
-	}
-	// Solo comprueba el estado detenido cuando no se está creando
-	else if (isStopped())
-	{
-		// Si es una powerball deja de rodar
-		if (kind_ == POWER_BALL)
-		{
-			sprite_->disableRotate();
-		}
-
-		// Reduce el contador
-		if (stopped_counter_ > 0)
-		{
-			stopped_counter_--;
-		}
-		// Si el contador ha llegado a cero
-		else
-		{ // Quitarles el estado "detenido"
-			setStop(false);
-
-			// Si es una powerball vuelve a rodar
-			if (kind_ == POWER_BALL)
-			{
-				sprite_->enableRotate();
-			}
+			setAnimation();
 		}
 	}
 }
 
 // Establece la animación correspondiente al estado
-void Balloon::updateAnimation()
+void Balloon::setAnimation()
 {
-	std::string creating_animation = "blue";
-	std::string normal_animation = "orange";
+	std::string creating_animation;
+	std::string normal_animation;
 
-	if (kind_ == POWER_BALL)
+	switch (type_)
 	{
+	case BalloonType::POWERBALL:
 		creating_animation = "powerball";
 		normal_animation = "powerball";
-	}
-	else if (getClass() == HEXAGON_CLASS)
-	{
+		break;
+	case BalloonType::FLOATER:
 		creating_animation = "red";
 		normal_animation = "green";
+		break;
+	default:
+		creating_animation = "blue";
+		normal_animation = "orange";
+		break;
 	}
 
 	// Establece el frame de animación
-	if (isBeingCreated())
-	{
+	if (use_reversed_colors_)
 		sprite_->setCurrentAnimation(creating_animation);
-	}
 	else
-	{
-		sprite_->setCurrentAnimation(normal_animation);
-	}
-
-	sprite_->update();
+		sprite_->setCurrentAnimation(isBeingCreated() ? creating_animation : normal_animation);
 }
 
 // Comprueba si el globo está habilitado
@@ -572,37 +305,31 @@ bool Balloon::isEnabled() const
 // Obtiene del valor de la variable
 float Balloon::getPosX() const
 {
-	return pos_x_;
+	return x_;
 }
 
 // Obtiene del valor de la variable
 float Balloon::getPosY() const
 {
-	return pos_y_;
-}
-
-// Obtiene del valor de la variable
-float Balloon::getVelY() const
-{
-	return vel_y_;
+	return y_;
 }
 
 // Obtiene del valor de la variable
 int Balloon::getWidth() const
 {
-	return width_;
+	return w_;
 }
 
 // Obtiene del valor de la variable
 int Balloon::getHeight() const
 {
-	return height_;
+	return h_;
 }
 
 // Establece el valor de la variable
 void Balloon::setVelY(float vel_y)
 {
-	vel_y_ = vel_y;
+	vy_ = vel_y;
 }
 
 // Establece el valor de la variable
@@ -611,38 +338,32 @@ void Balloon::setSpeed(float speed)
 	speed_ = speed;
 }
 
-// Obtiene del valor de la variable
-int Balloon::getKind() const
-{
-	return kind_;
-}
-
-// Obtiene del valor de la variable
-Uint8 Balloon::getSize() const
+// Obtiene el tamaño del globo
+BalloonSize Balloon::getSize() const
 {
 	return size_;
 }
 
-// Obtiene la clase a la que pertenece el globo
-Uint8 Balloon::getClass() const
+// Obtiene el tipo de globo
+BalloonType Balloon::getType() const
 {
-	if ((kind_ >= BALLOON_1) && (kind_ <= BALLOON_4))
-	{
-		return BALLOON_CLASS;
-	}
-
-	else if ((kind_ >= HEXAGON_1) && (kind_ <= HEXAGON_4))
-	{
-		return HEXAGON_CLASS;
-	}
-
-	return BALLOON_CLASS;
+	return type_;
 }
 
-// Establece el valor de la variable
-void Balloon::setStop(bool state)
+// Detiene el globo
+void Balloon::stop()
 {
-	stopped_ = state;
+	stopped_ = true;
+	if (type_ == BalloonType::POWERBALL)
+		sprite_->disableRotate();
+}
+
+// Pone el globo en movimiento
+void Balloon::start()
+{
+	stopped_ = false;
+	if (type_ == BalloonType::POWERBALL)
+		sprite_->enableRotate();
 }
 
 // Obtiene del valor de la variable
@@ -651,30 +372,6 @@ bool Balloon::isStopped() const
 	return stopped_;
 }
 
-// Establece el valor de la variable
-void Balloon::setBlink(bool value)
-{
-	blinking_ = value;
-}
-
-// Obtiene del valor de la variable
-bool Balloon::isBlinking() const
-{
-	return blinking_;
-}
-
-// Establece el valor de la variable
-void Balloon::setVisible(bool value)
-{
-	visible_ = value;
-}
-
-// Obtiene del valor de la variable
-bool Balloon::isVisible() const
-{
-	return visible_;
-}
-
 // Establece el valor de la variable
 void Balloon::setInvulnerable(bool value)
 {
@@ -687,30 +384,12 @@ bool Balloon::isInvulnerable() const
 	return invulnerable_;
 }
 
-// Establece el valor de la variable
-void Balloon::setBeingCreated(bool value)
-{
-	being_created_ = value;
-}
-
 // Obtiene del valor de la variable
 bool Balloon::isBeingCreated() const
 {
 	return being_created_;
 }
 
-// Establece el valor de la variable
-void Balloon::setStoppedTimer(Uint16 time)
-{
-	stopped_counter_ = time;
-}
-
-// Obtiene del valor de la variable
-Uint16 Balloon::getStoppedTimer() const
-{
-	return stopped_counter_;
-}
-
 // Obtiene del valor de la variable
 Uint16 Balloon::getScore() const
 {
@@ -724,10 +403,24 @@ Circle &Balloon::getCollider()
 }
 
 // Alinea el circulo de colisión con la posición del objeto globo
-void Balloon::updateColliders()
+void Balloon::shiftColliders()
 {
-	collider_.x = Uint16(pos_x_ + collider_.r);
-	collider_.y = pos_y_ + collider_.r;
+	collider_.x = static_cast<int>(x_) + collider_.r;
+	collider_.y = static_cast<int>(y_) + collider_.r;
+}
+
+// Alinea el sprite con la posición del objeto globo
+void Balloon::shiftSprite()
+{
+	sprite_->setPosX(x_);
+	sprite_->setPosY(y_);
+}
+
+// Establece el nivel de zoom del sprite
+void Balloon::zoomSprite()
+{
+	sprite_->setZoomW(bouncing_.zoomW);
+	sprite_->setZoomH(bouncing_.zoomH);
 }
 
 // Obtiene le valor de la variable
@@ -742,44 +435,39 @@ Uint8 Balloon::getPower() const
 	return power_;
 }
 
-void Balloon::bounceStart()
+// Activa el efecto
+void Balloon::enableBounce()
 {
 	bouncing_.enabled = true;
-	bouncing_.zoomW = 1;
-	bouncing_.zoomH = 1;
-	sprite_->setZoomW(bouncing_.zoomW);
-	sprite_->setZoomH(bouncing_.zoomH);
-	bouncing_.despX = 0;
-	bouncing_.despY = 0;
+	bouncing_.reset();
+	zoomSprite();
 }
 
-void Balloon::bounceStop()
+// Detiene el efecto
+void Balloon::disableBounce()
 {
 	bouncing_.enabled = false;
-	bouncing_.counter = 0;
-	bouncing_.zoomW = 1.0f;
-	bouncing_.zoomH = 1.0f;
-	sprite_->setZoomW(bouncing_.zoomW);
-	sprite_->setZoomH(bouncing_.zoomH);
-	bouncing_.despX = 0.0f;
-	bouncing_.despY = 0.0f;
+	bouncing_.reset();
+	zoomSprite();
 }
 
+// Aplica el efecto
 void Balloon::updateBounce()
 {
 	if (bouncing_.enabled)
 	{
-		bouncing_.zoomW = bouncing_.w[bouncing_.counter / bouncing_.speed];
-		bouncing_.zoomH = bouncing_.h[bouncing_.counter / bouncing_.speed];
-		sprite_->setZoomW(bouncing_.zoomW);
-		sprite_->setZoomH(bouncing_.zoomH);
-		bouncing_.despX = (sprite_->getSpriteClip().w - (sprite_->getSpriteClip().w * bouncing_.zoomW));
-		bouncing_.despY = (sprite_->getSpriteClip().h - (sprite_->getSpriteClip().h * bouncing_.zoomH));
-		++bouncing_.counter;
-		if ((bouncing_.counter / bouncing_.speed) > (MAX_BOUNCE - 1))
-		{
-			bounceStop();
-		}
+		const int index = bouncing_.counter / bouncing_.speed;
+		bouncing_.zoomW = bouncing_.w[index];
+		bouncing_.zoomH = bouncing_.h[index];
+
+		zoomSprite();
+
+		const auto spriteClip = sprite_->getSpriteClip();
+		bouncing_.despX = spriteClip.w * (1.0f - bouncing_.zoomW);
+		bouncing_.despY = spriteClip.h * (1.0f - bouncing_.zoomH);
+
+		if (++bouncing_.counter / bouncing_.speed >= MAX_BOUNCE)
+			disableBounce();
 	}
 }
 
@@ -793,4 +481,27 @@ bool Balloon::canBePopped() const
 bool Balloon::canBeDestroyed() const
 {
 	return isEnabled();
+}
+
+// Pone el color alternativo en el globo
+void Balloon::useReverseColor()
+{
+	if (!isBeingCreated())
+	{
+		use_reversed_colors_ = true;
+		setAnimation();
+	}
+}
+
+// Pone el color normal en el globo
+void Balloon::useNormalColor()
+{
+	use_reversed_colors_ = false;
+	setAnimation();
+}
+
+// Indica si está usando el color alternativo
+bool Balloon::isUsingReversedColor()
+{
+	return use_reversed_colors_;
 }

source/balloon.h

@@ -1,42 +1,38 @@
 #pragma once
 
-#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 SpriteAnimated
-#include "utils.h"			 // for Circle
-class Texture;
+#include <SDL2/SDL_stdinc.h> // Para Uint8, Uint16, Uint32
+#include <memory>			 // Para shared_ptr, unique_ptr
+#include <string>			 // Para string
+#include <vector>			 // Para vector
+#include "animated_sprite.h" // Para AnimatedSprite
+#include "utils.h"			 // Para Circle
+class Texture;				 // lines 10-10
 
 // Cantidad de elementos del vector con los valores de la deformación del globo al rebotar
 constexpr int MAX_BOUNCE = 10;
 
-// Tipos de globo
-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
-constexpr int BALLOON_SCORE_1 = 50;
-constexpr int BALLOON_SCORE_2 = 100;
-constexpr int BALLOON_SCORE_3 = 200;
-constexpr int BALLOON_SCORE_4 = 400;
+constexpr int BALLOON_SCORE[] = {50, 100, 200, 400};
+constexpr int BALLOON_POWER[] = {1, 3, 7, 15};
+constexpr int BALLOON_MENACE[] = {1, 2, 4, 8};
+constexpr int BALLOON_SIZE[] = {10, 16, 26, 46};
 
 // Tamaños de globo
-constexpr int BALLOON_SIZE_1 = 1;
-constexpr int BALLOON_SIZE_2 = 2;
-constexpr int BALLOON_SIZE_3 = 3;
-constexpr int BALLOON_SIZE_4 = 4;
+enum class BalloonSize : Uint8
+{
+	SIZE1 = 0,
+	SIZE2 = 1,
+	SIZE3 = 2,
+	SIZE4 = 3,
+};
 
 // Clases de globo
-constexpr int BALLOON_CLASS = 0;
-constexpr int HEXAGON_CLASS = 1;
+enum class BalloonType : Uint8
+{
+	BALLOON = 0,
+	FLOATER = 1,
+	POWERBALL = 2,
+};
 
 // Velocidad del globo
 constexpr float BALLOON_VELX_POSITIVE = 0.7f;
@@ -47,21 +43,8 @@ constexpr int BALLOON_MOVING_ANIMATION = 0;
 constexpr int BALLOON_POP_ANIMATION = 1;
 constexpr int BALLOON_BORN_ANIMATION = 2;
 
-// Cantidad posible de globos
-constexpr int MAX_BALLOONS = 100;
-
 // Velocidades a las que se mueven los globos
-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
-constexpr int BALLOON_WIDTH_1 = 10;
-constexpr int BALLOON_WIDTH_2 = 16;
-constexpr int BALLOON_WIDTH_3 = 26;
-constexpr int BALLOON_WIDTH_4 = 46;
+constexpr float BALLOON_SPEED[] = {0.60f, 0.70f, 0.80f, 0.90f, 1.00f};
 
 // PowerBall
 constexpr int POWERBALL_SCREENPOWER_MINIMUM = 10;
@@ -71,61 +54,78 @@ constexpr int POWERBALL_COUNTER = 8;
 class Balloon
 {
 private:
-	// Estructura para las variables para el efecto de los rebotes
+	// Estructura para el efecto de los rebotes en los globos
 	struct Bouncing
 	{
-		bool enabled;		  // Si el efecto está activo
-		Uint8 counter;		  // Countador para el efecto
-		Uint8 speed;		  // Velocidad a la que transcurre el efecto
-		float zoomW;		  // Zoom aplicado a la anchura
-		float zoomH;		  // Zoom aplicado a la altura
-		float despX;		  // Desplazamiento de pixeles en el eje X antes de pintar el objeto con zoom
-		float despY;		  // Desplazamiento de pixeles en el eje Y antes de pintar el objeto con zoom
-		std::vector<float> w; // Vector con los valores de zoom para el ancho del globo
-		std::vector<float> h; // Vector con los valores de zoom para el alto del globo
-	};
+		bool enabled = false; // Si el efecto está activo
+		Uint8 counter = 0;	  // Contador para el efecto
+		Uint8 speed = 2;	  // Velocidad a la que transcurre el efecto
+		float zoomW = 1.0f;	  // Zoom aplicado a la anchura
+		float zoomH = 1.0f;	  // Zoom aplicado a la altura
+		float despX = 0.0f;	  // Desplazamiento de pixeles en el eje X antes de pintar el objeto con zoom
+		float despY = 0.0f;	  // Desplazamiento de pixeles en el eje Y antes de pintar el objeto con zoom
+
+		float w[MAX_BOUNCE] = {1.10f, 1.05f, 1.00f, 0.95f, 0.90f, 0.95f, 1.00f, 1.02f, 1.05f, 1.02f}; // Vector con los valores de zoom para el ancho del globo
+		float h[MAX_BOUNCE] = {0.90f, 0.95f, 1.00f, 1.05f, 1.10f, 1.05f, 1.00f, 0.98f, 0.95f, 0.98f}; // Vector con los valores de zoom para el alto del globo
+
+		// Constructor por defecto
+		Bouncing() = default;
+
+		// Método reset
+		void reset()
+		{
+			counter = 0;
+			zoomW = 1.0f;
+			zoomH = 1.0f;
+			despX = 0.0f;
+			despY = 0.0f;
+		}
+	} bouncing_;
 
 	// Objetos y punteros
 	std::unique_ptr<AnimatedSprite> sprite_; // Sprite del objeto globo
 
 	// Variables
-	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
+	float x_;						   // Posición en el eje X
+	float y_;						   // Posición en el eje Y
+	Uint8 w_;						   // Ancho
+	Uint8 h_;						   // Alto
+	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 gravity_;					   // Aceleración en el eje Y. Modifica la velocidad
+	float default_vy_;				   // Velocidad inicial que tienen al rebotar contra el suelo
+	float max_vy_;					   // Máxima velocidad que puede alcanzar el objeto en el eje Y
+	bool being_created_;			   // Indica si el globo se está creando
+	bool enabled_ = true;			   // Indica si el globo esta activo
+	bool invulnerable_;				   // Indica si el globo es invulnerable
+	bool stopped_;					   // Indica si el globo está parado
+	bool use_reversed_colors_ = false; // Indica si se ha de usar el color secundario del globo como color principal
+	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
+	BalloonType type_;				   // Clase de globo
+	BalloonSize size_;				   // Tamaño del globo
+	Uint8 menace_;					   // Cantidad de amenaza que genera el globo
+	Uint32 counter_ = 0;			   // Contador interno
+	float travel_y_ = 1.0f;			   // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
+	float speed_;					   // Velocidad a la que se mueven los globos
+	Uint8 power_;					   // Cantidad de poder que alberga el globo
 
 	// Alinea el circulo de colisión con la posición del objeto globo
-	void updateColliders();
+	void shiftColliders();
+
+	// Alinea el sprite con la posición del objeto globo
+	void shiftSprite();
+
+	// Establece el nivel de zoom del sprite
+	void zoomSprite();
 
 	// Activa el efecto
-	void bounceStart();
+	void enableBounce();
 
 	// Detiene el efecto
-	void bounceStop();
+	void disableBounce();
 
 	// Aplica el efecto
 	void updateBounce();
@@ -134,20 +134,17 @@ private:
 	void updateState();
 
 	// Establece la animación correspondiente
-	void updateAnimation();
-
-	// Establece el valor de la variable
-	void setBeingCreated(bool value);
+	void setAnimation();
 
 public:
 	// Constructor
-	Balloon(float x, float y, Uint8 kind, float vel_x, float speed, Uint16 creation_timer, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
+	Balloon(float x, float y, BalloonType type, BalloonSize size, float vel_x, float speed, Uint16 creation_timer, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
 
 	// Destructor
 	~Balloon() = default;
 
 	// Centra el globo en la posición X
-	void allignTo(int x);
+	void alignTo(int x);
 
 	// Pinta el globo en la pantalla
 	void render();
@@ -173,9 +170,6 @@ public:
 	// Obtiene del valor de la variable
 	float getPosY() const;
 
-	// Obtiene del valor de la variable
-	float getVelY() const;
-
 	// Obtiene del valor de la variable
 	int getWidth() const;
 
@@ -188,33 +182,21 @@ public:
 	// Establece el valor de la variable
 	void setSpeed(float speed);
 
-	// Obtiene del valor de la variable
-	int getKind() const;
+	// Obtiene el tamaño del globo
+	BalloonSize getSize() const;
 
-	// Obtiene del valor de la variable
-	Uint8 getSize() const;
+	// Obtiene el tipo de globo
+	BalloonType getType() const;
 
-	// Obtiene la clase a la que pertenece el globo
-	Uint8 getClass() const;
+	// Detiene el globo
+	void stop();
 
-	// Establece el valor de la variable
-	void setStop(bool value);
+	// Pone el globo en movimiento
+	void start();
 
 	// Obtiene del valor de la variable
 	bool isStopped() const;
 
-	// Establece el valor de la variable
-	void setBlink(bool value);
-
-	// Obtiene del valor de la variable
-	bool isBlinking() const;
-
-	// Establece el valor de la variable
-	void setVisible(bool value);
-
-	// Obtiene del valor de la variable
-	bool isVisible() const;
-
 	// Establece el valor de la variable
 	void setInvulnerable(bool value);
 
@@ -224,12 +206,6 @@ public:
 	// Obtiene del valor de la variable
 	bool isBeingCreated() const;
 
-	// Establece el valor de la variable
-	void setStoppedTimer(Uint16 time);
-
-	// Obtiene del valor de la variable
-	Uint16 getStoppedTimer() const;
-
 	// Obtiene del valor de la variable
 	Uint16 getScore() const;
 
@@ -247,4 +223,13 @@ public:
 
 	// Indica si el globo se puede destruir
 	bool canBeDestroyed() const;
+
+	// Pone el color alternativo en el globo
+	void useReverseColor();
+
+	// Pone el color normal en el globo
+	void useNormalColor();
+
+	// Indica si está usando el color alternativo
+	bool isUsingReversedColor();
 };

source/balloon_formations.cpp

@@ -1,7 +1,7 @@
 #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
+#include "balloon.h" // para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
+#include "param.h"	 // para param
+#include "utils.h"	 // para ParamGame, Param, Zone, BLOCK
 
 // Constructor
 BalloonFormations::BalloonFormations()
@@ -16,28 +16,28 @@ 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;
+	const int x4_100 = param.game.play_area.rect.w - BALLOON_SIZE[3];
 
 	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;
+	const int x3_100 = param.game.play_area.rect.w - BALLOON_SIZE[2];
 
 	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;
+	const int x2_100 = param.game.play_area.rect.w - BALLOON_SIZE[1];
 
 	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;
+	const int x1_50 = param.game.play_area.center_x - (BALLOON_SIZE[0] / 2);
+	const int x1_100 = param.game.play_area.rect.w - BALLOON_SIZE[0];
 
 	// Inicializa a cero las variables
-	for (int i = 0; i < NUMBER_OF_BALLOON_FORMATIONS; i++)
+	for (int j = 0; j < NUMBER_OF_BALLOON_FORMATIONS; ++j)
 	{
-		balloon_formation_[i].number_of_balloons = 0;
-		for (int j = 0; j < MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION; j++)
+		balloon_formation_[j].number_of_balloons = 0;
+		for (int i = 0; i < MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION; ++i)
 		{
-			balloon_formation_[i].init[j] = BalloonFormationParams();
+			balloon_formation_[j].init[i] = BalloonFormationParams();
 		}
 	}
 
@@ -56,7 +56,7 @@ void BalloonFormations::initBalloonFormations()
 		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].size = BalloonSize::SIZE4;
 		balloon_formation_[j].init[i].creation_counter = CREATION_TIME + (inc_time * i);
 	}
 
@@ -67,269 +67,269 @@ void BalloonFormations::initBalloonFormations()
 	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].x = param.game.play_area.first_quarter_x - (BALLOON_SIZE[3] / 2) + (i * inc_x);
 		balloon_formation_[j].init[i].y = y4;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
-		balloon_formation_[j].init[i].kind = BALLOON_4;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE4;
 		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_x = BALLOON_SIZE[1] + 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].size = BalloonSize::SIZE2;
 		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_x = BALLOON_SIZE[1] + 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].size = BalloonSize::SIZE2;
 		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_x = BALLOON_SIZE[2] * 2;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
 		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_x = BALLOON_SIZE[2] * 2;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
 		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_x = BALLOON_SIZE[2] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
 		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_x = BALLOON_SIZE[2] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
 		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_x = BALLOON_SIZE[0] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x1_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y1;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE1;
 		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_x = BALLOON_SIZE[0] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x1_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y1;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE1;
 		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_x = BALLOON_SIZE[3] + 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].size = BalloonSize::SIZE4;
 		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_x = BALLOON_SIZE[3] + 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].size = BalloonSize::SIZE4;
 		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_x = BALLOON_SIZE[1] + 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].size = BalloonSize::SIZE2;
 		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_x = BALLOON_SIZE[1] + 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].size = BalloonSize::SIZE2;
 		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_x = BALLOON_SIZE[2] * 2;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
 		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_x = BALLOON_SIZE[2] * 2;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
 		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_x = BALLOON_SIZE[2] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
 		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_x = BALLOON_SIZE[2] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x3_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y3;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_3;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
 		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_x = BALLOON_SIZE[0] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x1_0 + (i * inc_x);
 		balloon_formation_[j].init[i].y = y1;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_POSITIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE1;
 		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_x = BALLOON_SIZE[0] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
 		balloon_formation_[j].init[i].x = x1_100 - (i * inc_x);
 		balloon_formation_[j].init[i].y = y1;
 		balloon_formation_[j].init[i].vel_x = BALLOON_VELX_NEGATIVE;
-		balloon_formation_[j].init[i].kind = BALLOON_1;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE1;
 		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_x = BALLOON_SIZE[3] + 1;
 	inc_time = 0;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
@@ -345,14 +345,14 @@ void BalloonFormations::initBalloonFormations()
 			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].size = BalloonSize::SIZE4;
 		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_x = BALLOON_SIZE[1] + 1;
 	inc_time = 3;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
@@ -370,13 +370,13 @@ void BalloonFormations::initBalloonFormations()
 			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;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE2;
 	}
 
 	// #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_x = BALLOON_SIZE[2] * 2;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
@@ -394,13 +394,13 @@ void BalloonFormations::initBalloonFormations()
 			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;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
 	}
 
 	// #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_x = BALLOON_SIZE[2] + 1;
 	inc_time = 10;
 	for (int i = 0; i < balloon_formation_[j].number_of_balloons; i++)
 	{
@@ -418,7 +418,7 @@ void BalloonFormations::initBalloonFormations()
 			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;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE3;
 	}
 
 	// #24 - Treinta enemigos BALLOON1. Del centro hacia los extremos. Juntos. Simetricos
@@ -441,7 +441,7 @@ void BalloonFormations::initBalloonFormations()
 			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;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE1;
 	}
 
 	// #25 - Treinta enemigos BALLOON1. Del centro hacia adentro. Juntos. Simetricos
@@ -464,7 +464,7 @@ void BalloonFormations::initBalloonFormations()
 			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;
+		balloon_formation_[j].init[i].size = BalloonSize::SIZE1;
 	}
 
 	// Crea las mismas formaciones pero con hexagonos a partir de la posición 50 del vector
@@ -477,7 +477,8 @@ void BalloonFormations::initBalloonFormations()
 			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;
+			balloon_formation_[k + 50].init[i].size = balloon_formation_[k].init[i].size;
+			balloon_formation_[k + 50].init[i].type = BalloonType::FLOATER;
 		}
 	}
 
@@ -487,25 +488,25 @@ void BalloonFormations::initBalloonFormations()
 	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].size = BalloonSize::SIZE1;
 	balloon_formation_[99].init[0].creation_counter = 200;
 
 	balloon_formation_[99].init[1].x = 50;
 	balloon_formation_[99].init[1].y = y1;
 	balloon_formation_[99].init[1].vel_x = 0;
-	balloon_formation_[99].init[1].kind = BALLOON_2;
+	balloon_formation_[99].init[1].size = BalloonSize::SIZE2;
 	balloon_formation_[99].init[1].creation_counter = 200;
 
 	balloon_formation_[99].init[2].x = 90;
 	balloon_formation_[99].init[2].y = y1;
 	balloon_formation_[99].init[2].vel_x = 0;
-	balloon_formation_[99].init[2].kind = BALLOON_3;
+	balloon_formation_[99].init[2].size = BalloonSize::SIZE3;
 	balloon_formation_[99].init[2].creation_counter = 200;
 
 	balloon_formation_[99].init[3].x = 140;
 	balloon_formation_[99].init[3].y = y1;
 	balloon_formation_[99].init[3].vel_x = 0;
-	balloon_formation_[99].init[3].kind = BALLOON_4;
+	balloon_formation_[99].init[3].size = BalloonSize::SIZE4;
 	balloon_formation_[99].init[3].creation_counter = 200;
 }
 
@@ -513,124 +514,124 @@ void BalloonFormations::initBalloonFormations()
 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];
+	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];
+	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];
+	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];
+	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];
+	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];
+	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];
+	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];
+	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];
+	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];
+	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
@@ -641,70 +642,70 @@ void BalloonFormations::initGameStages()
 	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_[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_[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_[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_[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_[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_[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_[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_[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_[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];
+	stage_[9].balloon_pool = balloon_formation_pool_[9];
 }
 
 // Devuelve una fase

source/balloon_formations.h

@@ -1,40 +1,48 @@
 #pragma once
 
+#include "balloon.h"
+
 constexpr int NUMBER_OF_BALLOON_FORMATIONS = 100;
 constexpr int MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION = 50;
+constexpr int NUMBER_OF_SETS_PER_POOL = 10;
+constexpr int NUMBER_OF_STAGES = 10;
 
 // Estructuras
 struct BalloonFormationParams
 {
-    int x = 0;                // Posición en el eje X donde crear al enemigo
-    int y = 0;                // Posición en el eje Y donde crear al enemigo
-    float vel_x = 0.0f;       // Velocidad inicial en el eje X
-    int kind = 0;             // Tipo de enemigo
-    int creation_counter = 0; // Temporizador para la creación del enemigo
+    int x = 0;                               // Posición en el eje X donde crear el globo
+    int y = 0;                               // Posición en el eje Y donde crear el globo
+    float vel_x = 0.0f;                      // Velocidad inicial en el eje X
+    BalloonType type = BalloonType::BALLOON; // Tipo de globo
+    BalloonSize size = BalloonSize::SIZE1;   // Tamaño de globo
+    int creation_counter = 0;                // Temporizador para la creación del globo
 
-    // Constructor que inicializa todos los campos con valores proporcionados o predeterminados
-    BalloonFormationParams(int x_val = 0, int y_val = 0, float vel_x_val = 0.0f, int kind_val = 0, int creation_counter_val = 0)
-        : x(x_val), y(y_val), vel_x(vel_x_val), kind(kind_val), creation_counter(creation_counter_val) {}
+    // Constructor por defecto
+    BalloonFormationParams() = default;
+
+    // Constructor con parámetros
+    BalloonFormationParams(int x_val, int y_val, float vel_x_val, BalloonType type_val, BalloonSize size_val, int creation_counter_val)
+        : x(x_val), y(y_val), vel_x(vel_x_val), type(type_val), size(size_val), creation_counter(creation_counter_val) {}
 };
 
 struct BalloonFormationUnit // Contiene la información de una formación enemiga
 {
-    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
+    int number_of_balloons;                                             // Cantidad de globos que forman la formación
+    BalloonFormationParams init[MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION]; // Vector con todas las inicializaciones de los globos de la formación
 };
 
 struct BalloonFormationPool
 {
-    BalloonFormationUnit *set[10]; // Conjunto de formaciones de globos
+    BalloonFormationUnit set[NUMBER_OF_SETS_PER_POOL]; // 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
+    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
@@ -42,9 +50,9 @@ class BalloonFormations
 {
 private:
     // Variables
-    Stage stage_[10];                                                      // Variable con los datos de cada pantalla
+    Stage stage_[NUMBER_OF_STAGES];                                        // Variable con los datos de cada pantalla
     BalloonFormationUnit balloon_formation_[NUMBER_OF_BALLOON_FORMATIONS]; // Vector con todas las formaciones enemigas
-    BalloonFormationPool balloon_formation_pool_[10];                      // Variable con los diferentes conjuntos de formaciones enemigas
+    BalloonFormationPool balloon_formation_pool_[NUMBER_OF_STAGES];        // Variable con los diferentes conjuntos de formaciones enemigas
 
     // Inicializa las formaciones enemigas
     void initBalloonFormations();

source/bullet.cpp

@@ -1,36 +1,27 @@
 #include "bullet.h"
-#include <memory>    // for unique_ptr, make_unique, shared_ptr
-#include "param.h"   // for param
-#include "sprite.h"  // for Sprite
-class Texture;
-
-constexpr int BULLET_WIDTH = 12;
-constexpr int BULLET_HEIGHT = 12;
-constexpr int BULLET_VELY = -3;
-constexpr int BULLET_VELX_LEFT = -2;
-constexpr int BULLET_VELX_RIGHT = 2;
+#include <SDL2/SDL_rect.h> // Para SDL_Rect
+#include <memory>          // Para unique_ptr, make_unique, shared_ptr
+#include "param.h"         // Para Param, ParamGame, param
+#include "sprite.h"        // Para Sprite
+class Texture;             // lines 5-5
 
 // Constructor
-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>(texture, SDL_Rect{x, y, BULLET_WIDTH, BULLET_HEIGHT})),
+Bullet::Bullet(int x, int y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture)
+    : sprite_(std::make_unique<Sprite>(texture, SDL_Rect{x, y, BULLET_WIDTH_, BULLET_HEIGHT_})),
       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)
+      bullet_type_(bullet_type),
+      owner_(owner)
 {
-    vel_x_ = (kind_ == BulletType::LEFT) ? BULLET_VELX_LEFT : (kind_ == BulletType::RIGHT) ? BULLET_VELX_RIGHT
-                                                                                           : 0;
+    vel_x_ = (bullet_type_ == BulletType::LEFT)    ? BULLET_VEL_X_LEFT_
+             : (bullet_type_ == BulletType::RIGHT) ? BULLET_VEL_X_RIGHT_
+                                                   : 0;
 
-    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());
+    int sprite_offset = powered_up ? 3 : 0;
+    int offset = (static_cast<int>(bullet_type) + sprite_offset) * BULLET_WIDTH_;
+    sprite_->setSpriteClip(offset, 0, BULLET_WIDTH_, BULLET_HEIGHT_);
 
-    collider_.r = width_ / 2;
+    collider_.r = BULLET_WIDTH_ / 2;
     shiftColliders();
 }
 
@@ -44,21 +35,20 @@ void Bullet::render()
 BulletMoveStatus Bullet::move()
 {
     pos_x_ += vel_x_;
-    if (pos_x_ < param.game.play_area.rect.x - width_ || pos_x_ > play_area_->w)
+    if (pos_x_ < param.game.play_area.rect.x - BULLET_WIDTH_ || pos_x_ > param.game.play_area.rect.w)
     {
         disable();
         return BulletMoveStatus::OUT;
     }
 
-    pos_y_ += vel_y_;
-    if (pos_y_ < param.game.play_area.rect.y - height_)
+    pos_y_ += BULLET_VEL_Y_;
+    if (pos_y_ < param.game.play_area.rect.y - BULLET_HEIGHT_)
     {
         disable();
         return BulletMoveStatus::OUT;
     }
 
-    sprite_->setX(pos_x_);
-    sprite_->setY(pos_y_);
+    shiftSprite();
     shiftColliders();
 
     return BulletMoveStatus::OK;
@@ -66,42 +56,12 @@ BulletMoveStatus Bullet::move()
 
 bool Bullet::isEnabled() const
 {
-    return kind_ != BulletType::NONE;
+    return bullet_type_ != BulletType::NONE;
 }
 
 void Bullet::disable()
 {
-    kind_ = BulletType::NONE;
-}
-
-int Bullet::getPosX() const
-{
-    return pos_x_;
-}
-
-int Bullet::getPosY() const
-{
-    return pos_y_;
-}
-
-void Bullet::setPosX(int x)
-{
-    pos_x_ = x;
-}
-
-void Bullet::setPosY(int y)
-{
-    pos_y_ = y;
-}
-
-int Bullet::getVelY() const
-{
-    return vel_y_;
-}
-
-BulletType Bullet::getKind() const
-{
-    return kind_;
+    bullet_type_ = BulletType::NONE;
 }
 
 int Bullet::getOwner() const
@@ -119,3 +79,9 @@ void Bullet::shiftColliders()
     collider_.x = pos_x_ + collider_.r;
     collider_.y = pos_y_ + collider_.r;
 }
+
+void Bullet::shiftSprite()
+{
+    sprite_->setX(pos_x_);
+    sprite_->setY(pos_y_);
+}

source/bullet.h

@@ -1,14 +1,13 @@
 #pragma once
 
-#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;
+#include <SDL2/SDL_stdinc.h> // Para Uint8
+#include <memory>			 // Para shared_ptr, unique_ptr
+#include "sprite.h"			 // Para Sprite
+#include "utils.h"			 // Para Circle
+class Texture;				 // lines 8-8
 
-// Enumeración para los diferentes tipos de balas
-enum class BulletType
+// Tipos de balas
+enum class BulletType : Uint8
 {
 	UP,
 	LEFT,
@@ -16,7 +15,7 @@ enum class BulletType
 	NONE
 };
 
-// Enumeración para los resultados del movimiento de la bala
+// Resultado del movimiento de la bala
 enum class BulletMoveStatus : Uint8
 {
 	OK = 0,
@@ -27,26 +26,29 @@ enum class BulletMoveStatus : Uint8
 class Bullet
 {
 private:
+	// Constantes
+	static constexpr int BULLET_WIDTH_ = 12;
+	static constexpr int BULLET_HEIGHT_ = 12;
+	static constexpr int BULLET_VEL_Y_ = -3;
+	static constexpr int BULLET_VEL_X_LEFT_ = -2;
+	static constexpr int BULLET_VEL_X_RIGHT_ = 2;
+
 	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 pos_x_; // Posición en el eje X
+	int pos_y_; // Posición en el eje Y
 	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
+	BulletType bullet_type_; // Tipo de objeto
+	int owner_;				 // Identificador del dueño del objeto
+	Circle collider_;		 // Círculo de colisión del objeto
 
 	void shiftColliders(); // Alinea el círculo de colisión con el objeto
+	void shiftSprite();	   // Alinea el sprite con el objeto
 
 public:
 	// Constructor
-	Bullet(int x, int y, BulletType kind, bool powered_up, int owner, SDL_Rect *play_area, std::shared_ptr<Texture> texture);
+	Bullet(int x, int y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture);
 
 	// Destructor
 	~Bullet() = default;
@@ -63,17 +65,7 @@ public:
 	// 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 &getCollider();
 };

source/dbgtxt.cpp

@@ -1,7 +1,7 @@
 #include "dbgtxt.h"
-#include <SDL2/SDL_rect.h>     // for SDL_Rect
-#include <SDL2/SDL_rwops.h>    // for SDL_RWFromMem
-#include <SDL2/SDL_surface.h>  // for SDL_LoadBMP_RW
+#include <SDL2/SDL_rect.h>    // para SDL_Rect
+#include <SDL2/SDL_rwops.h>   // para SDL_RWFromMem
+#include <SDL2/SDL_surface.h> // para SDL_LoadBMP_RW
 
 namespace
 {

source/dbgtxt.h

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

source/define_buttons.cpp

@@ -1,58 +1,30 @@
 #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, Options, name, options
-#include "text.h"    // for Text
-#include "utils.h"   // for OptionsController, Options, Param, ParamGame
+#include <utility>   // Para move
+#include "input.h"   // Para Input, InputType
+#include "lang.h"    // Para getText
+#include "options.h" // Para OptionsController, Options, options
+#include "param.h"   // Para Param, param, ParamGame, ParamTitle
+#include "section.h" // Para Name, Options, name, options
+#include "text.h"    // Para Text
 
 // Constructor
 DefineButtons::DefineButtons(std::unique_ptr<Text> text_)
-    : text_(std::move(text_))
+    : input_(Input::get()),
+      text_(std::move(text_))
 {
-    // Copia punteros a los objetos
-    input_ = Input::get();
-
     // Inicializa variables
-    enabled_ = false;
     x_ = param.game.width / 2;
     y_ = param.title.press_start_position;
-    index_controller_ = 0;
-    index_button_ = 0;
 
-    buttons_.clear();
-    DefineButtonsButton button;
-
-    button.label = lang::getText(95);
-    button.input = InputType::FIRE_LEFT;
-    button.button = SDL_CONTROLLER_BUTTON_X;
-    buttons_.push_back(button);
-
-    button.label = lang::getText(96);
-    button.input = InputType::FIRE_CENTER;
-    button.button = SDL_CONTROLLER_BUTTON_Y;
-    buttons_.push_back(button);
-
-    button.label = lang::getText(97);
-    button.input = InputType::FIRE_RIGHT;
-    button.button = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
-    buttons_.push_back(button);
-
-    button.label = lang::getText(98);
-    button.input = InputType::START;
-    button.button = SDL_CONTROLLER_BUTTON_START;
-    buttons_.push_back(button);
-
-    button.label = lang::getText(99);
-    button.input = InputType::EXIT;
-    button.button = SDL_CONTROLLER_BUTTON_BACK;
-    buttons_.push_back(button);
+    buttons_.emplace_back(lang::getText(95), InputType::FIRE_LEFT, SDL_CONTROLLER_BUTTON_X);
+    buttons_.emplace_back(lang::getText(96), InputType::FIRE_CENTER, SDL_CONTROLLER_BUTTON_Y);
+    buttons_.emplace_back(lang::getText(97), InputType::FIRE_RIGHT, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER);
+    buttons_.emplace_back(lang::getText(98), InputType::START, SDL_CONTROLLER_BUTTON_START);
+    buttons_.emplace_back(lang::getText(99), InputType::EXIT, SDL_CONTROLLER_BUTTON_BACK);
 
     for (int i = 0; i < input_->getNumControllers(); ++i)
     {
-        controller_names_.push_back(input_->getControllerName(i));
+        controller_names_.emplace_back(input_->getControllerName(i));
     }
 }
 

source/define_buttons.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include <SDL2/SDL_events.h>          // for SDL_ControllerButtonEvent
-#include <SDL2/SDL_gamecontroller.h>  // for SDL_GameControllerButton
-#include <memory>                     // for shared_ptr, unique_ptr
-#include <string>                     // for string
-#include <vector>                     // for vector
+#include <SDL2/SDL_events.h>         // para SDL_ControllerButtonEvent
+#include <SDL2/SDL_gamecontroller.h> // para SDL_GameControllerButton
+#include <memory>                    // para shared_ptr, unique_ptr
+#include <string>                    // para string
+#include <vector>                    // para vector
 class Input;
 class Text;
 enum class InputType : int;
@@ -14,6 +14,10 @@ struct DefineButtonsButton
     std::string label;               // Texto en pantalla para el botón
     InputType input;                 // Input asociado
     SDL_GameControllerButton button; // Botón del mando correspondiente
+
+    // Constructor
+    DefineButtonsButton(const std::string &lbl, InputType inp, SDL_GameControllerButton btn)
+        : label(lbl), input(inp), button(btn) {}
 };
 
 // Clase Bullet
@@ -25,12 +29,12 @@ private:
     std::shared_ptr<Text> text_; // Objeto para escribir texto
 
     // Variables
-    bool enabled_;                              // Indica si el objeto está habilitado
+    bool enabled_ = false;                      // 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
+    int index_controller_ = 0;                  // Indice del controlador a reasignar
+    int index_button_ = 0;                      // 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

source/director.cpp

@@ -1,47 +1,49 @@
 #include "director.h"
-#include <SDL2/SDL.h>				 // for SDL_Init, SDL_Quit, SDL_INIT_EV...
-#include <SDL2/SDL_audio.h>			 // for AUDIO_S16
-#include <SDL2/SDL_blendmode.h>		 // for SDL_BLENDMODE_BLEND
-#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_0, SDL_SCANCODE_DOWN
-#include <SDL2/SDL_stdinc.h>		 // for SDL_bool, Uint32
-#include <SDL2/SDL_timer.h>			 // for SDL_GetTicks
-#include <cstdlib>					 // for system
-#include <errno.h>					 // for errno, EEXIST, EACCES, ENAMETOO...
-#include <stdio.h>					 // for printf, perror
-#include <string.h>					 // for strcmp
-#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 <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 Input, InputType
-#include "instructions.h"			 // for Instructions
-#include "intro.h"					 // for Intro
-#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 "notifier.h"				 // for Notifier
-#include "on_screen_help.h"			 // for OnScreenHelp
-#include "options.h"				 // for options, loadOptionsFile, saveO...
-#include "param.h"					 // for param, loadParamsFromFile
-#include "resource.h"				 //for Resource
-#include "screen.h"					 // for Screen
-#include "section.h"				 // for Name, name, Options, options
-#include "title.h"					 // for Title
-#include "utils.h"					 // for MusicFile, SoundFile, Options
+#include <SDL2/SDL.h>				 // Para SDL_Init, SDL_Quit, SDL_INIT_EV...
+#include <SDL2/SDL_audio.h>			 // Para AUDIO_S16
+#include <SDL2/SDL_blendmode.h>		 // Para SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_error.h>			 // Para SDL_GetError
+#include <SDL2/SDL_gamecontroller.h> // Para SDL_CONTROLLER_BUTTON_B, SDL_CO...
+#include <SDL2/SDL_hints.h>			 // Para SDL_SetHint, SDL_HINT_RENDER_DR...
+#include <SDL2/SDL_scancode.h>		 // Para SDL_SCANCODE_0, SDL_SCANCODE_DOWN
+#include <SDL2/SDL_stdinc.h>		 // Para SDL_bool, Uint32
+#include <SDL2/SDL_timer.h>			 // Para SDL_GetTicks
+#include <errno.h>					 // Para errno, EEXIST, EACCES, ENAMETOO...
+#include <stdio.h>					 // Para printf, perror
+#include <string.h>					 // Para strcmp
+#include <sys/stat.h>				 // Para mkdir, stat, S_IRWXU
+#include <unistd.h>					 // Para getuid
+#include <cstdlib>					 // Para exit, EXIT_FAILURE, rand, srand
+#include <iostream>					 // Para basic_ostream, operator<<, cout
+#include <memory>					 // Para make_unique, unique_ptr, make_s...
+#include <stdexcept>				 // Para runtime_error
+#include <string>					 // Para operator+, allocator, char_traits
+#include <vector>					 // Para vector
+#include "asset.h"					 // Para Asset, AssetType
+#include "dbgtxt.h"					 // Para dbg_init
+#include "game.h"					 // Para Game, GAME_MODE_DEMO_OFF, GAME_...
+#include "global_inputs.h"			 // Para init
+#include "hiscore_table.h"			 // Para HiScoreTable
+#include "input.h"					 // Para Input, InputType
+#include "instructions.h"			 // Para Instructions
+#include "intro.h"					 // Para Intro
+#include "jail_audio.h"				 // Para JA_EnableMusic, JA_EnableSound
+#include "lang.h"					 // Para Code, loadFromFile
+#include "logo.h"					 // Para Logo
+#include "manage_hiscore_table.h"	 // Para ManageHiScoreTable
+#include "notifier.h"				 // Para Notifier
+#include "on_screen_help.h"			 // Para OnScreenHelp
+#include "options.h"				 // Para Options, options, OptionsContro...
+#include "param.h"					 // Para Param, ParamGame, param, loadPa...
+#include "resource.h"				 // Para Resource
+#include "screen.h"					 // Para Screen
+#include "section.h"				 // Para Name, Options, name, options
+#include "text.h"					 // Para Text
+#include "title.h"					 // Para Title
+#include "utils.h"					 // Para Overrides, overrides
 
 #ifndef _WIN32
-#include <pwd.h> // for getpwuid, passwd
+#include <pwd.h> // para getpwuid, passwd
 #endif
 
 // Constructor
@@ -84,13 +86,22 @@ Director::Director(int argc, const char *argv[])
 #ifdef ANBERNIC
 	const std::string paramFilePath = asset->get("param_320x240.txt");
 #else
-	const std::string paramFilePath = param_file_argument_ == "--320x240" ? Asset::get()->get("param_320x240.txt") : Asset::get()->get("param_320x256.txt");
+	const std::string paramFilePath = overrides.param_file == "--320x240" ? Asset::get()->get("param_320x240.txt") : Asset::get()->get("param_320x256.txt");
 #endif
 	loadParams(paramFilePath);
 
 	// Carga el fichero de puntuaciones
-	auto manager = std::make_unique<ManageHiScoreTable>(&options.game.hi_score_table);
-	manager->loadFromFile(Asset::get()->get("score.bin"));
+	{
+		auto manager = std::make_unique<ManageHiScoreTable>(options.game.hi_score_table);
+		if (overrides.clear_hi_score_table)
+		{
+			manager->clear();
+		}
+		else
+		{
+			manager->loadFromFile(Asset::get()->get("score.bin"));
+		}
+	}
 
 	// Inicializa SDL
 	initSDL();
@@ -422,6 +433,7 @@ void Director::setFileList()
 		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_5000_points.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_powerup.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_one_hit.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/game_text/game_text_stop.png", AssetType::BITMAP);
 	}
 
 	{ // Intro
@@ -513,18 +525,33 @@ void Director::loadParams(const std::string &file_path)
 // Comprueba los parametros del programa
 void Director::checkProgramArguments(int argc, const char *argv[])
 {
+	const std::vector<std::string> argument_list = {"--h", "--320x240", "--clear_score"};
+
 	// Establece la ruta del programa
 	executable_path_ = argv[0];
 
-	// Valores por defecto
-	param_file_argument_.clear();
-
 	// Comprueba el resto de parámetros
 	for (int i = 1; i < argc; ++i)
 	{
+		if (strcmp(argv[i], "--h") == 0)
+		{
+			for (const auto &argument : argument_list)
+			{
+				std::cout << argument << std::endl;
+			}
+			// std::exit(EXIT_SUCCESS);
+			section::name = section::Name::QUIT;
+			section::options = section::Options::QUIT_FROM_EVENT;
+		}
+
 		if (strcmp(argv[i], "--320x240") == 0)
 		{
-			param_file_argument_ = argv[i];
+			overrides.param_file = argv[i];
+		}
+
+		if (strcmp(argv[i], "--clear_score") == 0)
+		{
+			overrides.clear_hi_score_table = true;
 		}
 	}
 }
@@ -728,6 +755,7 @@ std::string Director::getLangFile(lang::Code code)
 	return Asset::get()->get("en_UK.txt");
 }
 
+#ifdef ARCADE
 // Apaga el sistema
 void Director::shutdownSystem()
 {
@@ -744,4 +772,5 @@ void Director::shutdownSystem()
 // Sistema operativo no compatible
 #error "Sistema operativo no soportado"
 #endif
-}
+}
+#endif // ARCADE

source/director.h

@@ -1,15 +1,12 @@
 #pragma once
 
-#include <SDL2/SDL_render.h> // for SDL_Renderer
-#include <SDL2/SDL_video.h>	 // for SDL_Window
-#include <string>			 // for string
-#include <vector>			 // for vector
+#include <SDL2/SDL_render.h> // Para SDL_Renderer
+#include <SDL2/SDL_video.h>	 // Para SDL_Window
+#include <string>			 // Para string
 namespace lang
 {
 	enum class Code : int;
-}
-struct ResourceMusic;
-struct ResourceSound;
+} // lines 9-9
 
 // Textos
 constexpr char WINDOW_CAPTION[] = "Coffee Crisis Arcade Edition";
@@ -18,14 +15,15 @@ class Director
 {
 private:
 	// Objetos y punteros
-	SDL_Window *window_;	  // La ventana donde dibujamos
-	SDL_Renderer *renderer_;  // El renderizador de la ventana
+	SDL_Window *window_;	 // La ventana donde dibujamos
+	SDL_Renderer *renderer_; // El renderizador de la ventana
+#ifndef VERBOSE
 	std::streambuf *orig_buf; // Puntero al buffer de flujo original para restaurar std::cout
+#endif
 
 	// Variables
-	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::string executable_path_; // Path del ejecutable
+	std::string system_folder_;	  // Carpeta del sistema donde guardar datos
 
 	// Inicializa jail_audio
 	void initJailAudio();
@@ -71,9 +69,10 @@ private:
 
 	// Obtiene una fichero a partir de un lang::Code
 	std::string getLangFile(lang::Code code);
-
+#ifdef ARCADE
 	// Apaga el sistema
 	void shutdownSystem();
+#endif
 
 public:
 	// Constructor

source/enter_name.cpp

@@ -1,5 +1,6 @@
 #include "enter_name.h"
-#include <algorithm> // for max, min
+#include <stddef.h>  // Para size_t
+#include <algorithm> // Para max, min
 
 // Constructor
 EnterName::EnterName()
@@ -16,7 +17,7 @@ void EnterName::init()
     // Inicia la lista de caracteres permitidos
     character_list_ = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()";
     position_ = 0;
-    num_characters_ = (int)character_list_.size();
+    num_characters_ = static_cast<int>(character_list_.size());
 
     // Pone la lista de indices para que refleje el nombre
     updateCharacterIndex();
@@ -36,7 +37,7 @@ void EnterName::incPosition()
 // Decrementa la posición
 void EnterName::decPosition()
 {
-    position_--;
+    --position_;
     position_ = std::max(position_, 0);
 }
 
@@ -76,14 +77,14 @@ void EnterName::updateName()
 void EnterName::updateCharacterIndex()
 {
     // Rellena de espacios y marca como no usados
-    for (int i = 0; i < NAME_LENGHT; ++i)
+    for (size_t i = 0; i < NAME_LENGHT; ++i)
     {
         character_index_[i] = 0;
         position_has_been_used_[i] = false;
     }
 
-    // Coloca los índices en funcion de los caracteres que forman el nombre
-    for (int i = 0; i < (int)name_.size(); ++i)
+    // Coloca los índices en función de los caracteres que forman el nombre
+    for (size_t i = 0; i < name_.size(); ++i)
     {
         character_index_[i] = findIndex(name_.at(i));
         position_has_been_used_[i] = true;
@@ -91,15 +92,11 @@ void EnterName::updateCharacterIndex()
 }
 
 // Encuentra el indice de un caracter en "character_list_"
-int EnterName::findIndex(char character)
+int EnterName::findIndex(char character) const
 {
-    for (int i = 0; i < (int)character_list_.size(); ++i)
-    {
-        if (character == character_list_[i])
-        {
+    for (size_t i = 0; i < character_list_.size(); ++i)
+        if (character == character_list_.at(i))
             return i;
-        }
-    }
     return 0;
 }
 
@@ -121,9 +118,7 @@ void EnterName::checkIfPositionHasBeenUsed()
     auto used = position_has_been_used_[position_];
 
     if (!used && position_ > 0)
-    {
         character_index_[position_] = character_index_[position_ - 1];
-    }
 
     position_has_been_used_[position_] = true;
     updateName();

source/enter_name.h

@@ -30,7 +30,7 @@ private:
     void updateCharacterIndex();
 
     // Encuentra el indice de un caracter en "characterList"
-    int findIndex(char character);
+    int findIndex(char character) const;
 
     // Comprueba la posición y copia el caracter si es necesario
     void checkIfPositionHasBeenUsed();

source/explosions.cpp

@@ -1,20 +1,6 @@
 #include "explosions.h"
-#include <utility>           // for move
-#include "animated_sprite.h" // for SpriteAnimated
-class Texture;               // lines 3-3
-
-// Constructor
-Explosions::Explosions()
-{
-    textures_.clear();
-    explosions_.clear();
-}
-
-// Destructor
-Explosions::~Explosions()
-{
-    explosions_.clear();
-}
+#include "animated_sprite.h" // Para AnimatedSprite
+class Texture;               // lines 4-4
 
 // Actualiza la lógica de la clase
 void Explosions::update()
@@ -38,7 +24,7 @@ void Explosions::render()
 }
 
 // Añade texturas al objeto
-void Explosions::addTexture(int size, std::shared_ptr<Texture> texture, std::vector<std::string> &animation)
+void Explosions::addTexture(int size, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
 {
     textures_.emplace_back(ExplosionTexture(size, texture, animation));
 }

source/explosions.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include <memory> // for shared_ptr, unique_ptr
-#include <string> // for string
-#include <vector> // for vector
-class AnimatedSprite;
-class Texture;
+#include <memory>            // Para unique_ptr, shared_ptr
+#include <string>            // Para string
+#include <vector>            // Para vector
+#include "animated_sprite.h" // Para AnimatedSprite
+class Texture;               // lines 7-7
 
 struct ExplosionTexture
 {
@@ -13,7 +13,7 @@ struct ExplosionTexture
     std::vector<std::string> animation; // Animación para la textura
 
     // Constructor
-    ExplosionTexture(int sz, std::shared_ptr<Texture> tex, std::vector<std::string> anim)
+    ExplosionTexture(int sz, std::shared_ptr<Texture> tex, const std::vector<std::string> &anim)
         : size(sz), texture(tex), animation(anim) {}
 };
 
@@ -33,10 +33,10 @@ private:
 
 public:
     // Constructor
-    Explosions();
+    Explosions() = default;
 
     // Destructor
-    ~Explosions();
+    ~Explosions() = default;
 
     // Actualiza la lógica de la clase
     void update();
@@ -45,7 +45,7 @@ public:
     void render();
 
     // Añade texturas al objeto
-    void addTexture(int size, std::shared_ptr<Texture> texture, std::vector<std::string> &animation);
+    void addTexture(int size, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
 
     // Añade una explosión
     void add(int x, int y, int size);

source/fade.cpp

@@ -1,11 +1,10 @@
 #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 "screen.h"
-#include "utils.h"				// for Param, ParamGame, ParamFade
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND, SDL_BLENDMODE_NONE
+#include <SDL2/SDL_pixels.h>	// Para SDL_PIXELFORMAT_RGBA8888
+#include <stdlib.h>				// Para rand
+#include <algorithm>			// Para min, max
+#include "param.h"				// Para Param, param, ParamGame, ParamFade
+#include "screen.h"				// Para Screen
 
 // Constructor
 Fade::Fade()

source/fade.h

@@ -1,9 +1,9 @@
 #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>	 // para SDL_Rect
+#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_stdinc.h> // para Uint8, Uint16
+#include <vector>			 // para vector
 
 // Tipos de fundido
 enum class FadeType : Uint8

source/game.h

@@ -1,30 +1,31 @@
 #pragma once
 
-#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 "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
-enum class ItemType;
+#include <SDL2/SDL_render.h>	  // Para SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_stdinc.h>	  // Para Uint32, Uint8
+#include <memory>				  // Para shared_ptr, unique_ptr
+#include <string>				  // Para string
+#include <vector>				  // Para vector
+#include "balloon.h"			  // Para Balloon
+#include "manage_hiscore_table.h" // Para HiScoreEntry
+#include "options.h"			  // Para Options, OptionsGame, options
+#include "player.h"				  // Para Player
+#include "utils.h"				  // Para Demo
+class Asset;					  // lines 12-12
+class Background;				  // lines 13-13
+class BalloonFormations;		  // lines 14-14
+class Bullet;					  // lines 15-15
+class Explosions;				  // lines 16-16
+class Fade;						  // lines 17-17
+class Input;					  // lines 18-18
+class Item;						  // lines 19-19
+class PathSprite;				  // 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 : Uint8;	  // lines 26-26
+enum class ItemType;			  // lines 27-27
 
 // Modo demo
 constexpr bool GAME_MODE_DEMO_OFF = false;
@@ -63,6 +64,25 @@ constexpr int TOTAL_SCORE_DATA = 3;
 class Game
 {
 private:
+	// Constantes
+
+	// Contadores
+	static constexpr int STAGE_COUNTER_ = 200;
+	static constexpr int HELP_COUNTER_ = 1000;
+	static constexpr int GAME_COMPLETED_START_FADE_ = 500;
+	static constexpr int GAME_COMPLETED_END_ = 700;
+	static constexpr int GAME_OVER_COUNTER_ = 350;
+	static constexpr int TIME_STOPPED_COUNTER_ = 360;
+
+	// Porcentaje de aparición de los objetos
+	static constexpr int ITEM_POINTS_1_DISK_ODDS_ = 10;
+	static constexpr int ITEM_POINTS_2_GAVINA_ODDS_ = 6;
+	static constexpr int ITEM_POINTS_3_PACMAR_ODDS_ = 3;
+	static constexpr int ITEM_CLOCK_ODDS_ = 5;
+	static constexpr int ITEM_COFFEE_ODDS_ = 5;
+	static constexpr int ITEM_POWER_BALL_ODDS_ = 0;
+	static constexpr int ITEM_COFFEE_MACHINE_ODDS_ = 4;
+
 	// Estructuras
 	struct Helper
 	{
@@ -76,28 +96,21 @@ private:
 		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
+
+		// Constructor con valores predeterminados
+		Helper()
+			: need_coffee(false),
+			  need_coffee_machine(false),
+			  need_power_ball(false),
+			  counter(HELP_COUNTER_),
+			  item_disk_odds(ITEM_POINTS_1_DISK_ODDS_),
+			  item_gavina_odds(ITEM_POINTS_2_GAVINA_ODDS_),
+			  item_pacmar_odds(ITEM_POINTS_3_PACMAR_ODDS_),
+			  item_clock_odds(ITEM_CLOCK_ODDS_),
+			  item_coffee_odds(ITEM_COFFEE_ODDS_),
+			  item_coffee_machine_odds(ITEM_COFFEE_MACHINE_ODDS_) {}
 	};
 
-	// Constantes
-
-	// Contadores
-	static constexpr int STAGE_COUNTER_ = 200;
-	static constexpr int HELP_COUNTER_ = 1000;
-	static constexpr int GAME_COMPLETED_START_FADE_ = 500;
-	static constexpr int GAME_COMPLETED_END_ = 700;
-	static constexpr int GAME_OVER_COUNTER_ = 350;
-	static constexpr int TIME_STOPPED_COUNTER_ = 300;
-	static constexpr int TICKS_SPEED_ = 15;
-
-	// Porcentaje de aparición de los objetos
-	static constexpr int ITEM_POINTS_1_DISK_ODDS_ = 10;
-	static constexpr int ITEM_POINTS_2_GAVINA_ODDS_ = 6;
-	static constexpr int ITEM_POINTS_3_PACMAR_ODDS_ = 3;
-	static constexpr int ITEM_CLOCK_ODDS_ = 5;
-	static constexpr int ITEM_COFFEE_ODDS_ = 5;
-	static constexpr int ITEM_POWER_BALL_ODDS_ = 0;
-	static constexpr int ITEM_COFFEE_MACHINE_ODDS_ = 4;
-
 	// Objetos y punteros
 	SDL_Renderer *renderer_; // El renderizador de la ventana
 	Screen *screen_;		 // Objeto encargado de dibujar en pantalla
@@ -116,6 +129,7 @@ private:
 	std::vector<std::unique_ptr<Bullet>> bullets_;			  // Vector con las balas
 	std::vector<std::unique_ptr<Item>> items_;				  // Vector con los items
 	std::vector<std::unique_ptr<SmartSprite>> smart_sprites_; // Vector con los smartsprites
+	std::vector<std::unique_ptr<PathSprite>> path_sprites_;	  // Vector con los smartsprites
 
 	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
@@ -138,40 +152,41 @@ private:
 	std::unique_ptr<Fade> fade_; // Objeto para renderizar fades
 
 	// Variables
-	Uint32 ticks_;								  // Contador de ticks para ajustar la velocidad 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
+	HiScoreEntry hi_score_ = HiScoreEntry(
+		options.game.hi_score_table[0].name,
+		options.game.hi_score_table[0].score); // Máxima puntuación y nombre de quien la ostenta
+
+	int current_stage_;									  // Indica la fase actual
+	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
+	GameDifficulty difficulty_ = options.game.difficulty; // Dificultad del juego
+	Helper helper_;										  // Variable para gestionar las ayudas
+	Uint32 ticks_ = 0;									  // Contador de ticks para ajustar la velocidad del programa
+	bool coffee_machine_enabled_ = false;				  // Indica si hay una máquina de café en el terreno de juego
+	bool game_completed_ = false;						  // Indica si se ha completado la partida, llegando al final de la ultima pantalla
+	bool hi_score_achieved_ = false;					  // Indica si se ha superado la puntuación máxima
+	bool paused_ = false;								  // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
+	bool power_ball_enabled_ = false;					  // Indica si hay una powerball ya activa
+	float balloon_speed_;								  // Velocidad a la que se mueven los enemigos
+	float default_balloon_speed_;						  // Velocidad base de los enemigos, sin incrementar
+	float difficulty_score_multiplier_;					  // Multiplicador de puntos en función de la dificultad
+	float get_ready_bitmap_path_[STAGE_COUNTER_];		  // Vector con los puntos X por donde se desplaza el texto
+	int stage_bitmap_path_[STAGE_COUNTER_];				  // Vector con los puntos Y por donde se desplaza el texto
+	int balloon_deploy_counter_ = 0;					  // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
+	int balloons_popped_ = 0;							  // Lleva la cuenta de los globos explotados
+	int counter_ = 0;									  // Contador para el juego
+	int current_power_ = 0;								  // Poder actual almacenado para completar la fase
+	int game_completed_counter_ = 0;					  // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
+	int game_over_counter_ = GAME_OVER_COUNTER_;		  // Contador para el estado de fin de partida
+	int last_balloon_deploy_ = 0;						  // Guarda cual ha sido la última formación desplegada para no repetir;
+	int menace_current_ = 0;							  // Nivel de amenaza actual
+	int menace_threshold_ = 0;							  // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
+	int power_ball_counter_ = 0;						  // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
+	int stage_bitmap_counter_ = STAGE_COUNTER_;			  // Contador para el tiempo visible del texto de Stage
+	int time_stopped_counter_ = 0;						  // Temporizador para llevar la cuenta del tiempo detenido
+	int total_power_to_complete_game_;					  // La suma del poder necesario para completar todas las fases
 #ifdef DEBUG
-	bool auto_pop_balloons_; // Si es true, incrementa automaticamente los globos explotados
+	bool auto_pop_balloons_ = false; // Si es true, incrementa automaticamente los globos explotados
 #endif
 
 	// Actualiza el juego
@@ -183,14 +198,8 @@ private:
 	// Comprueba los eventos que hay en cola
 	void checkEvents();
 
-	// Inicializa las variables necesarias para la sección 'Game'
-	void init(int player_id);
-
-	// Carga los recursos necesarios para la sección 'Game'
-	void loadMedia();
-
-	// Libera los recursos previamente cargados
-	void unloadMedia();
+	// Asigna texturas y animaciones
+	void setResources();
 
 	// Crea una formación de enemigos
 	void deployBalloonFormation();
@@ -220,7 +229,10 @@ private:
 	void renderBalloons();
 
 	// Crea un globo nuevo en el vector de globos
-	std::shared_ptr<Balloon> createBalloon(float x, int y, int kind, float velx, float speed, int stopped_counter);
+	std::shared_ptr<Balloon> createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int stopped_counter);
+
+	// Crea un globo a partir de otro globo
+	void createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction);
 
 	// Crea una PowerBall
 	void createPowerBall();
@@ -241,11 +253,17 @@ private:
 	void destroyAllBalloons();
 
 	// Detiene todos los globos
-	void stopAllBalloons(int time);
+	void stopAllBalloons();
 
 	// Pone en marcha todos los globos
 	void startAllBalloons();
 
+	// Cambia el color de todos los globos
+	void reverseColorsToAllBalloons();
+
+	// Cambia el color de todos los globos
+	void normalColorsToAllBalloons();
+
 	// Vacia el vector de globos
 	void freeBalloons();
 
@@ -285,20 +303,29 @@ private:
 	// Vacia el vector de items
 	void freeItems();
 
-	// Crea un objeto SpriteSmart
-	void createItemScoreSprite(int x, int y, std::shared_ptr<Texture> texture);
+	// Crea un objeto PathSprite
+	void createPathSprite(int x, std::shared_ptr<Texture> texture);
 
 	// Vacia el vector de smartsprites
-	void freeSpriteSmarts();
+	void freeSmartSprites();
+
+	// Vacia el vector de pathsprites
+	void freePathSprites();
 
 	// Crea un SpriteSmart para arrojar el item café al recibir un impacto
 	void throwCoffee(int x, int y);
 
 	// Actualiza los SpriteSmarts
-	void updateSpriteSmarts();
+	void updateSmartSprites();
 
 	// Pinta los SpriteSmarts activos
-	void renderSpriteSmarts();
+	void renderSmartSprites();
+
+	// Actualiza los PathSprites
+	void updatePathSprites();
+
+	// Pinta los PathSprites activos
+	void renderPathSprites();
 
 	// Acciones a realizar cuando el jugador muere
 	void killPlayer(std::shared_ptr<Player> &player);
@@ -306,26 +333,11 @@ private:
 	// Calcula y establece el valor de amenaza en funcion de los globos activos
 	void evaluateAndSetMenace();
 
-	// Obtiene el valor de la variable
-	int getMenace() const;
-
-	// Establece el valor de la variable
-	void setTimeStopped(bool value);
-
-	// Obtiene el valor de la variable
-	bool isTimeStopped() const;
-
-	// Establece el valor de la variable
-	void setTimeStoppedCounter(int value);
-
-	// Incrementa el valor de la variable
-	void incTimeStoppedCounter(int value);
-
 	// Actualiza la variable EnemyDeployCounter
 	void updateBalloonDeployCounter();
 
 	// Actualiza y comprueba el valor de la variable
-	void updateTimeStoppedCounter();
+	void updateTimeStopped();
 
 	// Gestiona el nivel de amenaza
 	void updateMenace();
@@ -333,6 +345,9 @@ private:
 	// Actualiza el fondo
 	void updateBackground();
 
+	// Inicializa las variables que contienen puntos de ruta para mover objetos
+	void initPaths();
+
 	// Pinta diferentes mensajes en la pantalla
 	void renderMessages();
 
@@ -348,9 +363,6 @@ private:
 	// Calcula el poder actual de los globos en pantalla
 	int calculateScreenPower();
 
-	// Inicializa las variables que contienen puntos de ruta para mover objetos
-	void initPaths();
-
 	// Actualiza el tramo final de juego, una vez completado
 	void updateGameCompleted();
 
@@ -366,9 +378,6 @@ private:
 	// Comprueba si todos los jugadores han terminado de jugar
 	bool allPlayersAreNotPlaying();
 
-	// Elimina todos los objetos contenidos en vectores
-	void deleteAllVectorObjects();
-
 	// Recarga las texturas
 	void reloadTextures();
 
@@ -409,7 +418,6 @@ private:
 	void handleDemoMode();
 
 	// Procesa las entradas para un jugador específico durante el modo demo.
-	// Incluye movimientos (izquierda, derecha, sin movimiento) y disparos automáticos.
 	void handleDemoPlayerInput(const std::shared_ptr<Player> &player, int index);
 
 	// Maneja el disparo de un jugador, incluyendo la creación de balas y la gestión del tiempo de espera entre disparos.
@@ -430,6 +438,33 @@ private:
 	// Procesa las entradas para la introducción del nombre del jugador.
 	void handleNameInput(const std::shared_ptr<Player> &player);
 
+	// Inicializa las variables para el modo DEMO
+	void initDemo(int player_id);
+
+	// Calcula el poder total necesario para completar el juego
+	void setTotalPower();
+
+	// Inicializa el marcador
+	void initScoreboard();
+
+	// Inicializa las opciones relacionadas con la dificultad
+	void initDifficultyVars();
+
+	// Inicializa los jugadores
+	void initPlayers(int player_id);
+
+	// Crea dos globos gordos
+	void createTwoBigBalloons();
+
+	// Pausa la música
+	void pauseMusic();
+
+	// Reanuda la música
+	void resumeMusic();
+
+	// Detiene la música
+	void stopMusic();
+
 public:
 	// Constructor
 	Game(int playerID, int current_stage, bool demo);

source/game_logo.cpp

@@ -1,16 +1,13 @@
 #include "game_logo.h"
-#include <SDL2/SDL_render.h> // for SDL_FLIP_HORIZONTAL
-#include <algorithm>         // for max
-#include "animated_sprite.h" // for SpriteAnimated
-#include "asset.h"           // for Asset
-#include "jail_audio.h"      // JA_PlaySound
-#include "param.h"           // for param
-#include "resource.h"        // for Resource
-#include "screen.h"          // for Screen
-#include "smart_sprite.h"    // for SpriteSmart
-#include "sprite.h"          // for Sprite
-#include "texture.h"         // for Texture
-#include "utils.h"           // for Param, ParamGame, ParamTitle
+#include <SDL2/SDL_render.h> // Para SDL_FLIP_HORIZONTAL
+#include <algorithm>         // Para max
+#include "animated_sprite.h" // Para AnimatedSprite
+#include "jail_audio.h"      // Para JA_PlaySound
+#include "param.h"           // Para Param, param, ParamGame, ParamTitle
+#include "resource.h"        // Para Resource
+#include "smart_sprite.h"    // Para SmartSprite
+#include "sprite.h"          // Para Sprite
+#include "texture.h"         // Para Texture
 
 // Constructor
 GameLogo::GameLogo(int x, int y)
@@ -27,7 +24,6 @@ GameLogo::GameLogo(int x, int y)
 
       arcade_edition_sprite_(std::make_unique<Sprite>(arcade_edition_texture_, (param.game.width - arcade_edition_texture_->getWidth()) / 2, param.title.arcade_edition_position, arcade_edition_texture_->getWidth(), arcade_edition_texture_->getHeight())),
 
-
       x_(x),
       y_(y)
 {
@@ -51,7 +47,6 @@ void GameLogo::init()
     shake_.origin = xp;
 
     // Inicializa el bitmap de 'Coffee'
-    coffee_sprite_->init();
     coffee_sprite_->setPosX(xp);
     coffee_sprite_->setPosY(y_ - coffee_texture_->getHeight() - desp);
     coffee_sprite_->setWidth(coffee_texture_->getWidth());
@@ -67,7 +62,6 @@ void GameLogo::init()
     coffee_sprite_->setDestY(y_ - coffee_texture_->getHeight());
 
     // Inicializa el bitmap de 'Crisis'
-    crisis_sprite_->init();
     crisis_sprite_->setPosX(xp + 15);
     crisis_sprite_->setPosY(y_ + desp);
     crisis_sprite_->setWidth(crisis_texture_->getWidth());

source/game_logo.h

@@ -1,11 +1,10 @@
 #pragma once
 
-#include <memory> // for unique_ptr, shared_ptr
-#include "animated_sprite.h"
-#include "smart_sprite.h"
-class Sprite;
-class Texture;
-struct JA_Sound_t; // lines 10-10
+#include <memory>            // Para unique_ptr, shared_ptr
+#include "animated_sprite.h" // Para AnimatedSprite
+#include "smart_sprite.h"    // Para SmartSprite
+#include "sprite.h"          // Para Sprite
+class Texture;               // lines 7-7
 
 // Clase GameLogo
 class GameLogo

source/global_inputs.cpp

@@ -1,14 +1,13 @@
 #include "global_inputs.h"
-#include <string>       // for basic_string, operator+
-#include "input.h"      // for Input, inputs_e, INPUT_DO_NOT_ALLOW_REPEAT
-#include "jail_audio.h" // for JA_EnableMusic, JA_EnableSound
-#include "lang.h"       // for getText
-#include "notifier.h"   // for Notifier
-#include "options.h"    // for options
-#include "on_screen_help.h"
-#include "screen.h"  // for Screen
-#include "section.h" // for SectionOptions, name, SectionName, options
-#include "utils.h"   // for OptionsAudio, Options, OptionsMusic, boolToOnOff
+#include <string>           // Para operator+, string
+#include "input.h"          // Para Input, InputType, INPUT_DO_NOT_ALLOW_REPEAT
+#include "jail_audio.h"     // Para JA_EnableMusic, JA_EnableSound
+#include "lang.h"           // Para getText
+#include "notifier.h"       // Para Notifier
+#include "on_screen_help.h" // Para OnScreenHelp
+#include "options.h"        // Para Options, OptionsAudio, options, OptionsM...
+#include "section.h"        // Para Name, Options, name, options
+#include "utils.h"          // Para boolToOnOff, stringInVector
 
 namespace globalInputs
 {

source/hiscore_table.cpp

@@ -1,25 +1,25 @@
 #include "hiscore_table.h"
-#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 "resource.h"			// for Resource
-#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
+#include <SDL2/SDL_blendmode.h>	  // Para SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_events.h>	  // Para SDL_PollEvent, SDL_Event, SDL_QUIT
+#include <SDL2/SDL_pixels.h>	  // Para SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_timer.h>		  // Para SDL_GetTicks
+#include <SDL2/SDL_video.h>		  // Para SDL_WINDOWEVENT_SIZE_CHANGED
+#include <algorithm>			  // Para max
+#include <vector>				  // Para vector
+#include "background.h"			  // Para Background
+#include "fade.h"				  // Para Fade, FadeMode, FadeType
+#include "global_inputs.h"		  // Para check
+#include "input.h"				  // Para Input
+#include "jail_audio.h"			  // Para JA_GetMusicState, JA_Music_state
+#include "lang.h"				  // Para getText
+#include "manage_hiscore_table.h" // Para HiScoreEntry
+#include "options.h"			  // Para Options, OptionsGame, options
+#include "param.h"				  // Para Param, param, ParamGame, ParamFade
+#include "resource.h"			  // Para Resource
+#include "screen.h"				  // Para Screen
+#include "section.h"			  // Para Name, name, Options, options
+#include "text.h"				  // Para Text, TEXT_CENTER, TEXT_SHADOW
+#include "utils.h"				  // Para Color, Zone, fade_color, orange_color
 
 // Constructor
 HiScoreTable::HiScoreTable()
@@ -61,8 +61,9 @@ HiScoreTable::~HiScoreTable()
 // Actualiza las variables
 void HiScoreTable::update()
 {
-	// Actualiza las variables
-	if (SDL_GetTicks() - ticks_ > TICKS_SPEED_)
+	constexpr int TICKS_SPEED = 15;
+
+	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		// Actualiza el contador de ticks
 		ticks_ = SDL_GetTicks();
@@ -87,7 +88,7 @@ void HiScoreTable::update()
 
 		if (counter_ == 150)
 		{
-			background_->setColor({0, 0, 0});
+			background_->setColor(Color(0, 0, 0));
 			background_->setAlpha(96);
 		}
 

source/hiscore_table.h

@@ -1,10 +1,10 @@
 #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 Uint16, Uint32, Uint8
-#include <memory>			 // for unique_ptr
-#include <string>			 // for string
+#include <SDL2/SDL_rect.h>	 // para SDL_Rect
+#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_stdinc.h> // para Uint16, Uint32, Uint8
+#include <memory>			 // para unique_ptr
+#include <string>			 // para string
 class Background;			 // lines 8-8
 class Fade;					 // lines 9-9
 class Text;					 // lines 10-10
@@ -26,7 +26,6 @@ class HiScoreTable
 private:
 	// Constantes
 	static constexpr Uint16 COUNTER_END_ = 800; // Valor final para el contador
-	static constexpr Uint32 TICKS_SPEED_ = 15;	// Velocidad a la que se repiten los bucles del programa
 
 	// Objetos y punteros
 	SDL_Renderer *renderer_;  // El renderizador de la ventana

source/input.cpp

@@ -1,9 +1,9 @@
 #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>		   // para SDL_INIT_GAMECONTROLLER, SDL_InitSubS...
+#include <SDL2/SDL_error.h>	   // para SDL_GetError
+#include <SDL2/SDL_events.h>   // para SDL_ENABLE
+#include <SDL2/SDL_keyboard.h> // para SDL_GetKeyboardState
+#include <iostream>			   // para 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;

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> // para SDL_GameControllerButton, SDL_G...
+#include <SDL2/SDL_joystick.h>		 // para SDL_Joystick
+#include <SDL2/SDL_scancode.h>		 // para SDL_Scancode
+#include <SDL2/SDL_stdinc.h>		 // para Uint8
+#include <string>					 // para string, basic_string
+#include <vector>					 // para vector
 
 /*
 connectedControllers es un vector donde estan todos los mandos encontrados [0 .. n]

source/instructions.cpp

@@ -1,56 +1,44 @@
 #include "instructions.h"
-#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 "resource.h"			// for Resource
-#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
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_events.h>	// Para SDL_PollEvent, SDL_Event, SDL_QUIT
+#include <SDL2/SDL_pixels.h>	// Para SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_timer.h>		// Para SDL_GetTicks
+#include <SDL2/SDL_video.h>		// Para SDL_WINDOWEVENT_SIZE_CHANGED
+#include <algorithm>			// Para max
+#include <utility>				// Para move
+#include "fade.h"				// Para Fade, FadeMode, FadeType
+#include "global_inputs.h"		// Para check
+#include "input.h"				// Para Input
+#include "jail_audio.h"			// Para JA_GetMusicState, JA_Music_state
+#include "lang.h"				// Para getText
+#include "param.h"				// Para Param, param, ParamGame, ParamFade
+#include "resource.h"			// Para Resource
+#include "screen.h"				// Para Screen
+#include "section.h"			// Para Name, name, Options, options
+#include "sprite.h"				// Para Sprite
+#include "text.h"				// Para Text, TEXT_CENTER, TEXT_COLOR, TEXT_...
+#include "texture.h"			// Para Texture
+#include "tiled_bg.h"			// Para TiledBG, TiledBGMode
+#include "utils.h"				// Para Color, shdw_txt_color, Zone, no_color
 
 // Constructor
 Instructions::Instructions()
+	: renderer_(Screen::get()->getRenderer()),
+	  texture_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
+	  backbuffer_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
+	  text_(std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"))),
+	  tiled_bg_(std::make_unique<TiledBG>((SDL_Rect){0, 0, param.game.width, param.game.height}, TiledBGMode::STATIC)),
+	  fade_(std::make_unique<Fade>())
 {
-	// Copia los punteros
-	renderer_ = Screen::get()->getRenderer();
-
-	// Crea objetos
-	text_ = std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"));
-	tiled_bg_ = std::make_unique<TiledBG>((SDL_Rect){0, 0, param.game.width, param.game.height}, TiledBGMode::STATIC);
-	fade_ = std::make_unique<Fade>();
-
 	// 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);
 
 	// 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);
 
 	// Inicializa variables
 	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(fade_color.r, fade_color.g, fade_color.b);
@@ -214,8 +202,9 @@ void Instructions::fillBackbuffer()
 // Actualiza las variables
 void Instructions::update()
 {
-	// Actualiza las variables
-	if (SDL_GetTicks() - ticks_ > ticks_speed_)
+	constexpr int TICKS_SPEED = 15;
+
+	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		// Actualiza el contador de ticks
 		ticks_ = SDL_GetTicks();

source/instructions.h

@@ -1,16 +1,15 @@
 #pragma once
 
-#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 Fade;
-class Sprite;
-class Text;
-class Texture;
-class TiledBG;
-struct JA_Music_t; // lines 14-14
+#include <SDL2/SDL_rect.h>	 // Para SDL_Point, SDL_Rect
+#include <SDL2/SDL_render.h> // Para SDL_Texture, SDL_Renderer
+#include <SDL2/SDL_stdinc.h> // Para Uint32
+#include <memory>			 // Para unique_ptr, shared_ptr
+#include <vector>			 // Para vector
+class Fade;					 // lines 8-8
+class Sprite;				 // lines 9-9
+class Text;					 // lines 10-10
+class Texture;				 // lines 11-11
+class TiledBG;				 // lines 12-12
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de poner en pantalla
@@ -30,24 +29,23 @@ class Instructions
 {
 private:
 	// Objetos y punteros
+	SDL_Renderer *renderer_;  // El renderizador de la ventana
+	SDL_Texture *texture_;	  // Textura fija con el texto
+	SDL_Texture *backbuffer_; // Textura para usar como backbuffer
+
 	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
-	SDL_Texture *texture_;	  // Textura fija con el texto
-	SDL_Texture *backbuffer_; // Textura para usar como backbuffer
-
 	// Variables
-	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
+	int counter_ = 0;				// Contador
+	int counter_end_ = 700;			// Valor final para el contador
+	Uint32 ticks_ = 0;				// Contador de ticks para ajustar la velocidad del programa
+	SDL_Rect view_;					// Vista del backbuffer que se va amostrar por pantalla
+	SDL_Point sprite_pos_ = {0, 0}; // Posición del primer sprite
+	int item_space_ = 2;			// Espacio entre los items
 
 	// Actualiza las variables
 	void update();

source/intro.cpp

@@ -1,37 +1,31 @@
 #include "intro.h"
-#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 <utility>			 // for move
-#include "asset.h"			 // for Asset
-#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 "resource.h"		 // for Resource
-#include "screen.h"			 // for Screen
-#include "section.h"		 // for Name, name, Options, options
-#include "smart_sprite.h"	 // for SpriteSmart
-#include "text.h"			 // for Text
-#include "texture.h"		 // for Texture
-#include "utils.h"			 // for Param, ParamGame, Zone, BLOCK, Color
-#include "writer.h"			 // for Writer
-struct JA_Music_t;			 // lines 19-19
+#include <SDL2/SDL_events.h> // Para SDL_PollEvent, SDL_Event, SDL_QUIT, SDL...
+#include <SDL2/SDL_timer.h>	 // Para SDL_GetTicks
+#include <SDL2/SDL_video.h>	 // Para SDL_WINDOWEVENT_SIZE_CHANGED
+#include <utility>			 // Para move
+#include "global_inputs.h"	 // Para check
+#include "input.h"			 // Para Input
+#include "jail_audio.h"		 // Para JA_StopMusic, JA_PlayMusic
+#include "lang.h"			 // Para getText
+#include "param.h"			 // Para Param, ParamGame, param
+#include "resource.h"		 // Para Resource
+#include "screen.h"			 // Para Screen
+#include "section.h"		 // Para Name, name, Options, options
+#include "smart_sprite.h"	 // Para SmartSprite
+#include "text.h"			 // Para Text
+#include "texture.h"		 // Para Texture
+#include "utils.h"			 // Para Zone, BLOCK, Color, bg_color
+#include "writer.h"			 // Para Writer
 
 // Constructor
 Intro::Intro()
+	: texture_(Resource::get()->getTexture("intro.png")),
+	  text_(std::make_shared<Text>(Resource::get()->getTexture("nokia.png"), Resource::get()->getTextFile("nokia.txt")))
 {
-	// Reserva memoria para los objetos
-	texture_ = Resource::get()->getTexture("intro.png");
-	text_ = std::make_shared<Text>(Resource::get()->getTexture("nokia.png"), Resource::get()->getTextFile("nokia.txt"));
 
 	// Inicializa variables
 	section::name = section::Name::INTRO;
 	section::options = section::Options::NONE;
-	ticks_ = 0;
-	ticks_speed_ = 15;
-	scene_ = 1;
 
 	// Inicializa los bitmaps de la intro
 	constexpr int totalBitmaps = 6;
@@ -372,7 +366,9 @@ void Intro::updateScenes()
 // Actualiza las variables del objeto
 void Intro::update()
 {
-	if (SDL_GetTicks() - ticks_ > ticks_speed_)
+	constexpr int TICKS_SPEED = 15;
+
+	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		// Actualiza el contador de ticks
 		ticks_ = SDL_GetTicks();

source/intro.h

@@ -1,13 +1,12 @@
 #pragma once
 
-#include <SDL2/SDL_stdinc.h> // for Uint32, Uint8
-#include <memory>			 // for unique_ptr, shared_ptr
-#include <vector>			 // for vector
-#include "smart_sprite.h"	 // for SpriteSmart
-#include "writer.h"			 // for Writer
-class Text;
-class Texture;
-struct JA_Music_t; // lines 11-11
+#include <SDL2/SDL_stdinc.h> // Para Uint32
+#include <memory>			 // Para unique_ptr, shared_ptr
+#include <vector>			 // Para vector
+#include "smart_sprite.h"	 // Para SmartSprite
+#include "writer.h"			 // Para Writer
+class Text;					 // lines 8-8
+class Texture;				 // lines 9-9
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de mostrar la secuencia
@@ -26,9 +25,8 @@ private:
 	std::vector<std::unique_ptr<Writer>> texts_;		// Textos de la intro
 
 	// Variables
-	Uint32 ticks_;		// Contador de ticks para ajustar la velocidad del programa
-	Uint8 ticks_speed_; // Velocidad a la que se repiten los bucles del programa
-	int scene_;			// Indica que escena está activa
+	Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
+	int scene_ = 1;	   // Indica que escena está activa
 
 	// Actualiza las variables del objeto
 	void update();

source/item.cpp

@@ -1,31 +1,30 @@
 #include "item.h"
-#include <stdlib.h>			 // for rand
-#include "animated_sprite.h" // for SpriteAnimated
-#include "param.h"			 // for param
+#include <stdlib.h>			 // para rand
+#include "animated_sprite.h" // para SpriteAnimated
+#include "param.h"			 // para param
 class Texture;
 
 // Constructor
-Item::Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
+Item::Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
 	: sprite_(std::make_unique<AnimatedSprite>(texture, animation)),
-	  accel_x_(0.0f),
-	  floor_collision_(false),
 	  type_(type),
-	  enabled_(true),
-	  play_area_(play_area),
-	  time_to_live_(600)
+	  play_area_(play_area)
 {
-	if (type == ItemType::COFFEE_MACHINE)
+	switch (type)
+	{
+	case ItemType::COFFEE_MACHINE:
 	{
 		width_ = 28;
 		height_ = 37;
-		pos_x_ = (((int)x + (play_area->w / 2)) % (play_area->w - width_ - 5)) + 2;
+		pos_x_ = ((static_cast<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;
+		break;
 	}
-	else
+	default:
 	{
 		width_ = 20;
 		height_ = 20;
@@ -35,6 +34,8 @@ Item::Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr
 		vel_y_ = -4.0f;
 		accel_y_ = 0.2f;
 		collider_.r = width_ / 2;
+		break;
+	}
 	}
 
 	sprite_->setPosX(pos_x_);
@@ -43,22 +44,22 @@ Item::Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr
 }
 
 // Centra el objeto en la posición X
-void Item::allignTo(int x)
+void Item::alignTo(int x)
 {
-	pos_x_ = float(x - (width_ / 2));
+	pos_x_ = static_cast<float>(x - (width_ / 2));
 
 	if (pos_x_ < param.game.play_area.rect.x)
 	{
 		pos_x_ = param.game.play_area.rect.x + 1;
 	}
-	else if ((pos_x_ + width_) > play_area_->w)
+	else if (pos_x_ + width_ > play_area_.w)
 	{
-		pos_x_ = float(play_area_->w - width_ - 1);
+		pos_x_ = static_cast<float>(play_area_.w - width_ - 1);
 	}
 
 	// Posición X,Y del sprite
-	sprite_->setPosX(int(pos_x_));
-	sprite_->setPosY(int(pos_y_));
+	sprite_->setPosX(pos_x_);
+	sprite_->setPosY(pos_y_);
 
 	// Alinea el circulo de colisión con el objeto
 	shiftColliders();
@@ -94,7 +95,7 @@ void Item::move()
 	vel_y_ += accel_y_;
 
 	// Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido
-	if ((pos_x_ < param.game.play_area.rect.x) || (pos_x_ + width_ > play_area_->w))
+	if ((pos_x_ < param.game.play_area.rect.x) || (pos_x_ + width_ > play_area_.w))
 	{
 		// Corregir posición
 		pos_x_ -= vel_x_;
@@ -114,14 +115,14 @@ void Item::move()
 	}
 
 	// Si el objeto se sale por la parte inferior
-	if (pos_y_ + height_ > play_area_->h)
+	if (pos_y_ + height_ > play_area_.h)
 	{
 		// Detiene el objeto
 		vel_y_ = 0;
 		vel_x_ = 0;
 		accel_x_ = 0;
 		accel_y_ = 0;
-		pos_y_ = play_area_->h - height_;
+		pos_y_ = play_area_.h - height_;
 		if (type_ == ItemType::COFFEE_MACHINE)
 		{
 			floor_collision_ = true;

source/item.h

@@ -1,12 +1,12 @@
 #pragma once
 
-#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 "animated_sprite.h" // for SpriteAnimated
-#include "utils.h"           // for Circle
+#include <SDL2/SDL_rect.h>   // para SDL_Rect
+#include <SDL2/SDL_stdinc.h> // para Uint16
+#include <memory>            // para shared_ptr, unique_ptr
+#include <string>            // para string
+#include <vector>            // para vector
+#include "animated_sprite.h" // para SpriteAnimated
+#include "utils.h"           // para Circle
 class Texture;
 
 // Tipos de objetos
@@ -29,20 +29,20 @@ private:
     std::unique_ptr<AnimatedSprite> sprite_; // Sprite con los graficos del objeto
 
     // Variables
-    float pos_x_;          // Posición X del objeto
-    float pos_y_;          // Posición Y del objeto
-    int width_;            // Ancho del objeto
-    int height_;           // Alto del objeto
-    float vel_x_;          // Velocidad en el eje X
-    float vel_y_;          // Velocidad en el eje Y
-    float accel_x_;        // 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
-    ItemType type_;        // 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
+    float pos_x_;                  // Posición X del objeto
+    float pos_y_;                  // Posición Y del objeto
+    int width_;                    // Ancho del objeto
+    int height_;                   // Alto del objeto
+    float vel_x_;                  // Velocidad en el eje X
+    float vel_y_;                  // Velocidad en el eje Y
+    float accel_x_ = 0.0f;         // Aceleración en el eje X
+    float accel_y_;                // Aceleración en el eje Y
+    bool floor_collision_ = false; // Indica si el objeto colisiona con el suelo
+    ItemType type_;                // Especifica el tipo de objeto que es
+    bool enabled_ = true;          // Especifica si el objeto está habilitado
+    Circle collider_;              // Circulo de colisión del objeto
+    SDL_Rect play_area_;           // Rectangulo con la zona de juego
+    Uint16 time_to_live_ = 600;    // Temporizador con el tiempo que el objeto está presente
 
     // Alinea el circulo de colisión con la posición del objeto
     void shiftColliders();
@@ -58,13 +58,13 @@ private:
 
 public:
     // Constructor
-    Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
+    Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
 
     // Destructor
     ~Item() = default;
 
     // Centra el objeto en la posición X
-    void allignTo(int x);
+    void alignTo(int x);
 
     // Pinta el objeto en la pantalla
     void render();

source/jail_audio.cpp

@@ -1,74 +1,91 @@
 #ifndef JA_USESDLMIXER
 
 #include "jail_audio.h"
-#include <stdint.h>      // for uint8_t
-#include <stdio.h>       // for NULL, fseek, fclose, fopen, fread, ftell, FILE
-#include <stdlib.h>      // for free, malloc
-#include "stb_vorbis.c"  // for stb_vorbis_decode_memory
+#include <stdint.h>     // para uint8_t
+#include <stdio.h>      // para NULL, fseek, fclose, fopen, fread, ftell, FILE
+#include <stdlib.h>     // para free, malloc
+#include "stb_vorbis.c" // para stb_vorbis_decode_memory
 
 #define JA_MAX_SIMULTANEOUS_CHANNELS 5
 
-struct JA_Sound_t {
-    Uint32  length {0};
-    Uint8*  buffer {NULL};
+struct JA_Sound_t
+{
+    Uint32 length{0};
+    Uint8 *buffer{NULL};
 };
 
-struct JA_Channel_t {
-    JA_Sound_t          *sound;
-    int                 pos {0};
-    int                 times {0};
-    JA_Channel_state    state { JA_CHANNEL_FREE };
+struct JA_Channel_t
+{
+    JA_Sound_t *sound;
+    int pos{0};
+    int times{0};
+    JA_Channel_state state{JA_CHANNEL_FREE};
 };
 
-struct JA_Music_t {
-    int             samples {0};
-    int             pos {0};
-    int             times {0};
-    short*          output {NULL};
-    JA_Music_state  state {JA_MUSIC_INVALID};
+struct JA_Music_t
+{
+    int samples{0};
+    int pos{0};
+    int times{0};
+    short *output{NULL};
+    JA_Music_state state{JA_MUSIC_INVALID};
 };
 
-JA_Music_t      *current_music{NULL};
-JA_Channel_t    channels[JA_MAX_SIMULTANEOUS_CHANNELS];
+JA_Music_t *current_music{NULL};
+JA_Channel_t channels[JA_MAX_SIMULTANEOUS_CHANNELS];
 
-int             JA_freq {48000};
-SDL_AudioFormat JA_format {AUDIO_S16};
-Uint8           JA_channels {2};
-int             JA_musicVolume = 128;
-int             JA_soundVolume = 64;
-bool            JA_musicEnabled = true;
-bool            JA_soundEnabled = true;
+int JA_freq{48000};
+SDL_AudioFormat JA_format{AUDIO_S16};
+Uint8 JA_channels{2};
+int JA_musicVolume = 128;
+int JA_soundVolume = 64;
+bool JA_musicEnabled = true;
+bool JA_soundEnabled = true;
 SDL_AudioDeviceID sdlAudioDevice = 0;
 
-void audioCallback(void * userdata, uint8_t * stream, int len) {
+void audioCallback(void *userdata, uint8_t *stream, int len)
+{
     SDL_memset(stream, 0, len);
-    if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING) {
-        const int size = SDL_min(len, current_music->samples*2-current_music->pos);
-        SDL_MixAudioFormat(stream, (Uint8*)(current_music->output+current_music->pos), AUDIO_S16, size, JA_musicVolume);
-        current_music->pos += size/2;
-        if (size < len) {
-            if (current_music->times != 0) {
-                SDL_MixAudioFormat(stream+size, (Uint8*)current_music->output, AUDIO_S16, len-size, JA_musicVolume);
-                current_music->pos = (len-size)/2;
-                if (current_music->times > 0) current_music->times--;
-            } else {
+    if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING)
+    {
+        const int size = SDL_min(len, current_music->samples * 2 - current_music->pos);
+        SDL_MixAudioFormat(stream, (Uint8 *)(current_music->output + current_music->pos), AUDIO_S16, size, JA_musicVolume);
+        current_music->pos += size / 2;
+        if (size < len)
+        {
+            if (current_music->times != 0)
+            {
+                SDL_MixAudioFormat(stream + size, (Uint8 *)current_music->output, AUDIO_S16, len - size, JA_musicVolume);
+                current_music->pos = (len - size) / 2;
+                if (current_music->times > 0)
+                    current_music->times--;
+            }
+            else
+            {
                 current_music->pos = 0;
                 current_music->state = JA_MUSIC_STOPPED;
             }
         }
     }
     // Mixar els channels mi amol
-    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-        if (channels[i].state == JA_CHANNEL_PLAYING) {
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+    {
+        if (channels[i].state == JA_CHANNEL_PLAYING)
+        {
             const int size = SDL_min(len, channels[i].sound->length - channels[i].pos);
             SDL_MixAudioFormat(stream, channels[i].sound->buffer + channels[i].pos, AUDIO_S16, size, JA_soundVolume);
             channels[i].pos += size;
-            if (size < len) {
-                if (channels[i].times != 0) {
-                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len-size, JA_soundVolume);
-                    channels[i].pos = len-size;
-                    if (channels[i].times > 0) channels[i].times--;
-                } else {
+            if (size < len)
+            {
+                if (channels[i].times != 0)
+                {
+                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len - size, JA_soundVolume);
+                    channels[i].pos = len - size;
+                    if (channels[i].times > 0)
+                        channels[i].times--;
+                }
+                else
+                {
                     JA_StopChannel(i);
                 }
             }
@@ -76,23 +93,28 @@ void audioCallback(void * userdata, uint8_t * stream, int len) {
     }
 }
 
-void JA_Init(const int freq, const SDL_AudioFormat format, const int channels) {
+void JA_Init(const int freq, const SDL_AudioFormat format, const int channels)
+{
     JA_freq = freq;
     JA_format = format;
     JA_channels = channels;
     SDL_AudioSpec audioSpec{JA_freq, JA_format, JA_channels, 0, 1024, 0, 0, audioCallback, NULL};
-    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
+    if (sdlAudioDevice != 0)
+        SDL_CloseAudioDevice(sdlAudioDevice);
     sdlAudioDevice = SDL_OpenAudioDevice(NULL, 0, &audioSpec, NULL, 0);
     SDL_PauseAudioDevice(sdlAudioDevice, 0);
 }
 
-void JA_Quit() {
+void JA_Quit()
+{
     SDL_PauseAudioDevice(sdlAudioDevice, 1);
-    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
+    if (sdlAudioDevice != 0)
+        SDL_CloseAudioDevice(sdlAudioDevice);
     sdlAudioDevice = 0;
 }
 
-JA_Music_t *JA_LoadMusic(const char* filename) {
+JA_Music_t *JA_LoadMusic(const char *filename)
+{
     int chan, samplerate;
 
     // [RZC 28/08/22] Carreguem primer el arxiu en memòria i després el descomprimim. Es algo més rapid.
@@ -100,8 +122,9 @@ JA_Music_t *JA_LoadMusic(const char* filename) {
     fseek(f, 0, SEEK_END);
     long fsize = ftell(f);
     fseek(f, 0, SEEK_SET);
-    Uint8 *buffer = (Uint8*)malloc(fsize + 1);
-    if (fread(buffer, fsize, 1, f)!=1) return NULL;
+    Uint8 *buffer = (Uint8 *)malloc(fsize + 1);
+    if (fread(buffer, fsize, 1, f) != 1)
+        return NULL;
     fclose(f);
 
     JA_Music_t *music = new JA_Music_t();
@@ -109,17 +132,18 @@ JA_Music_t *JA_LoadMusic(const char* filename) {
     music->samples = stb_vorbis_decode_memory(buffer, fsize, &chan, &samplerate, &music->output);
     free(buffer);
     // [RZC 28/08/22] Abans el descomprimiem mentre el teniem obert
-//    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
+    //    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
 
     SDL_AudioCVT cvt;
     SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq);
-    if (cvt.needed) {
+    if (cvt.needed)
+    {
         cvt.len = music->samples * chan * 2;
-        cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
+        cvt.buf = (Uint8 *)SDL_malloc(cvt.len * cvt.len_mult);
         SDL_memcpy(cvt.buf, music->output, cvt.len);
         SDL_ConvertAudio(&cvt);
         free(music->output);
-        music->output = (short*)cvt.buf;
+        music->output = (short *)cvt.buf;
     }
     music->pos = 0;
     music->state = JA_MUSIC_STOPPED;
@@ -129,9 +153,11 @@ JA_Music_t *JA_LoadMusic(const char* filename) {
 
 void JA_PlayMusic(JA_Music_t *music, const int loop)
 {
-    if (!JA_musicEnabled || !music) return;
+    if (!JA_musicEnabled || !music)
+        return;
 
-    if (current_music != NULL) {
+    if (current_music != NULL)
+    {
         current_music->pos = 0;
         current_music->state = JA_MUSIC_STOPPED;
     }
@@ -143,67 +169,78 @@ void JA_PlayMusic(JA_Music_t *music, const int loop)
 
 void JA_PauseMusic()
 {
-    if (!JA_musicEnabled) return;
+    if (!JA_musicEnabled)
+        return;
 
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
+        return;
     current_music->state = JA_MUSIC_PAUSED;
 }
 
 void JA_ResumeMusic()
 {
-    if (!JA_musicEnabled) return;
+    if (!JA_musicEnabled)
+        return;
 
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
+        return;
     current_music->state = JA_MUSIC_PLAYING;
 }
 
 void JA_StopMusic()
 {
-    if (!JA_musicEnabled) return;
+    if (!JA_musicEnabled)
+        return;
 
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
+        return;
     current_music->pos = 0;
     current_music->state = JA_MUSIC_STOPPED;
 }
 
-JA_Music_state JA_GetMusicState() {
-    if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
+JA_Music_state JA_GetMusicState()
+{
+    if (!JA_musicEnabled)
+        return JA_MUSIC_DISABLED;
 
-    if (current_music == NULL) return JA_MUSIC_INVALID;
+    if (current_music == NULL)
+        return JA_MUSIC_INVALID;
     return current_music->state;
 }
 
-void JA_DeleteMusic(JA_Music_t *music) {
-    if (current_music == music) current_music = NULL;
+void JA_DeleteMusic(JA_Music_t *music)
+{
+    if (current_music == music)
+        current_music = NULL;
     free(music->output);
     delete music;
 }
 
 int JA_SetMusicVolume(int volume)
 {
-    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0
+                                                     : volume;
     return JA_musicVolume;
 }
 
 void JA_EnableMusic(const bool value)
 {
-    if (!value && current_music != NULL && current_music->state==JA_MUSIC_PLAYING) JA_StopMusic();
+    if (!value && current_music != NULL && current_music->state == JA_MUSIC_PLAYING)
+        JA_StopMusic();
 
     JA_musicEnabled = value;
 }
 
-
-
-
-
-JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length) {
+JA_Sound_t *JA_NewSound(Uint8 *buffer, Uint32 length)
+{
     JA_Sound_t *sound = new JA_Sound_t();
     sound->buffer = buffer;
     sound->length = length;
     return sound;
 }
 
-JA_Sound_t *JA_LoadSound(const char* filename) {
+JA_Sound_t *JA_LoadSound(const char *filename)
+{
     JA_Sound_t *sound = new JA_Sound_t();
     SDL_AudioSpec wavSpec;
     SDL_LoadWAV(filename, &wavSpec, &sound->buffer, &sound->length);
@@ -211,7 +248,7 @@ JA_Sound_t *JA_LoadSound(const char* filename) {
     SDL_AudioCVT cvt;
     SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq);
     cvt.len = sound->length;
-    cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
+    cvt.buf = (Uint8 *)SDL_malloc(cvt.len * cvt.len_mult);
     SDL_memcpy(cvt.buf, sound->buffer, sound->length);
     SDL_ConvertAudio(&cvt);
     SDL_FreeWAV(sound->buffer);
@@ -223,11 +260,16 @@ JA_Sound_t *JA_LoadSound(const char* filename) {
 
 int JA_PlaySound(JA_Sound_t *sound, const int loop)
 {
-    if (!JA_soundEnabled || !sound) return 0;
+    if (!JA_soundEnabled || !sound)
+        return 0;
 
     int channel = 0;
-    while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE) { channel++; }
-    if (channel == JA_MAX_SIMULTANEOUS_CHANNELS) channel = 0;
+    while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE)
+    {
+        channel++;
+    }
+    if (channel == JA_MAX_SIMULTANEOUS_CHANNELS)
+        channel = 0;
 
     channels[channel].sound = sound;
     channels[channel].times = loop;
@@ -238,8 +280,10 @@ int JA_PlaySound(JA_Sound_t *sound, const int loop)
 
 void JA_DeleteSound(JA_Sound_t *sound)
 {
-    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-        if (channels[i].sound == sound) JA_StopChannel(i);
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+    {
+        if (channels[i].sound == sound)
+            JA_StopChannel(i);
     }
     SDL_free(sound->buffer);
     delete sound;
@@ -247,41 +291,60 @@ void JA_DeleteSound(JA_Sound_t *sound)
 
 void JA_PauseChannel(const int channel)
 {
-    if (!JA_soundEnabled) return;
+    if (!JA_soundEnabled)
+        return;
 
-    if (channel == -1) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-            if (channels[i].state == JA_CHANNEL_PLAYING) channels[i].state = JA_CHANNEL_PAUSED;
+    if (channel == -1)
+    {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+        {
+            if (channels[i].state == JA_CHANNEL_PLAYING)
+                channels[i].state = JA_CHANNEL_PAUSED;
         }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-        if (channels[channel].state == JA_CHANNEL_PLAYING) channels[channel].state = JA_CHANNEL_PAUSED;
+    }
+    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
+    {
+        if (channels[channel].state == JA_CHANNEL_PLAYING)
+            channels[channel].state = JA_CHANNEL_PAUSED;
     }
 }
 
 void JA_ResumeChannel(const int channel)
 {
-    if (!JA_soundEnabled) return;
+    if (!JA_soundEnabled)
+        return;
 
-    if (channel == -1) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-            if (channels[i].state == JA_CHANNEL_PAUSED) channels[i].state = JA_CHANNEL_PLAYING;
+    if (channel == -1)
+    {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+        {
+            if (channels[i].state == JA_CHANNEL_PAUSED)
+                channels[i].state = JA_CHANNEL_PLAYING;
         }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-        if (channels[channel].state == JA_CHANNEL_PAUSED) channels[channel].state = JA_CHANNEL_PLAYING;
+    }
+    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
+    {
+        if (channels[channel].state == JA_CHANNEL_PAUSED)
+            channels[channel].state = JA_CHANNEL_PLAYING;
     }
 }
 
 void JA_StopChannel(const int channel)
 {
-    if (!JA_soundEnabled) return;
+    if (!JA_soundEnabled)
+        return;
 
-    if (channel == -1) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+    if (channel == -1)
+    {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+        {
             channels[i].state = JA_CHANNEL_FREE;
             channels[i].pos = 0;
             channels[i].sound = NULL;
         }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+    }
+    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
+    {
         channels[channel].state = JA_CHANNEL_FREE;
         channels[channel].pos = 0;
         channels[channel].sound = NULL;
@@ -290,15 +353,18 @@ void JA_StopChannel(const int channel)
 
 JA_Channel_state JA_GetChannelState(const int channel)
 {
-    if (!JA_soundEnabled) return JA_SOUND_DISABLED;
+    if (!JA_soundEnabled)
+        return JA_SOUND_DISABLED;
 
-    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return JA_CHANNEL_INVALID;
+    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS)
+        return JA_CHANNEL_INVALID;
     return channels[channel].state;
 }
 
 int JA_SetSoundVolume(int volume)
 {
-    JA_soundVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    JA_soundVolume = volume > 128 ? 128 : volume < 0 ? 0
+                                                     : volume;
     return JA_soundVolume;
 }
 
@@ -306,15 +372,17 @@ void JA_EnableSound(const bool value)
 {
     for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
     {
-        if (channels[i].state == JA_CHANNEL_PLAYING) JA_StopChannel(i);
+        if (channels[i].state == JA_CHANNEL_PLAYING)
+            JA_StopChannel(i);
     }
     JA_soundEnabled = value;
 }
 
 int JA_SetVolume(int volume)
 {
-    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
-    JA_soundVolume = JA_musicVolume/2;
+    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0
+                                                     : volume;
+    JA_soundVolume = JA_musicVolume / 2;
     return JA_musicVolume;
 }
 

source/jail_audio.h

@@ -1,17 +1,31 @@
 #pragma once
 
-#include <SDL2/SDL_audio.h>   // for SDL_AudioFormat
-#include <SDL2/SDL_stdinc.h>  // for Uint32, Uint8
-struct JA_Music_t;  // lines 5-5
-struct JA_Sound_t;  // lines 6-6
+#include <SDL2/SDL_audio.h>  // para SDL_AudioFormat
+#include <SDL2/SDL_stdinc.h> // para Uint32, Uint8
+struct JA_Music_t;           // lines 5-5
+struct JA_Sound_t;           // lines 6-6
 
-enum JA_Channel_state { JA_CHANNEL_INVALID, JA_CHANNEL_FREE, JA_CHANNEL_PLAYING, JA_CHANNEL_PAUSED, JA_SOUND_DISABLED };
-enum JA_Music_state { JA_MUSIC_INVALID, JA_MUSIC_PLAYING, JA_MUSIC_PAUSED, JA_MUSIC_STOPPED, JA_MUSIC_DISABLED };
+enum JA_Channel_state
+{
+    JA_CHANNEL_INVALID,
+    JA_CHANNEL_FREE,
+    JA_CHANNEL_PLAYING,
+    JA_CHANNEL_PAUSED,
+    JA_SOUND_DISABLED
+};
+enum JA_Music_state
+{
+    JA_MUSIC_INVALID,
+    JA_MUSIC_PLAYING,
+    JA_MUSIC_PAUSED,
+    JA_MUSIC_STOPPED,
+    JA_MUSIC_DISABLED
+};
 
 void JA_Init(const int freq, const SDL_AudioFormat format, const int channels);
 void JA_Quit();
 
-JA_Music_t *JA_LoadMusic(const char* filename);
+JA_Music_t *JA_LoadMusic(const char *filename);
 void JA_PlayMusic(JA_Music_t *music, const int loop = -1);
 void JA_PauseMusic();
 void JA_ResumeMusic();
@@ -21,8 +35,8 @@ void JA_DeleteMusic(JA_Music_t *music);
 int JA_SetMusicVolume(int volume);
 void JA_EnableMusic(const bool value);
 
-JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length);
-JA_Sound_t *JA_LoadSound(const char* filename);
+JA_Sound_t *JA_NewSound(Uint8 *buffer, Uint32 length);
+JA_Sound_t *JA_LoadSound(const char *filename);
 int JA_PlaySound(JA_Sound_t *sound, const int loop = 0);
 void JA_PauseChannel(const int channel);
 void JA_ResumeChannel(const int channel);

source/jail_shader.cpp

@@ -1,10 +1,10 @@
 #ifndef NO_SHADERS
 
 #include "jail_shader.h"
-#include <SDL2/SDL_rect.h>    // for SDL_Point
-#include <stdlib.h>           // for NULL, free, malloc, exit
-#include <string.h>           // for strncmp
-#include <iostream>           // for basic_ostream, char_traits, operator<<
+#include <SDL2/SDL_rect.h> // para SDL_Point
+#include <stdlib.h>        // para NULL, free, malloc, exit
+#include <string.h>        // para strncmp
+#include <iostream>        // para basic_ostream, char_traits, operator<<
 
 #ifdef __APPLE__
 #include "CoreFoundation/CoreFoundation.h"
@@ -14,7 +14,7 @@
 #include <OpenGL/gl3.h>
 #else
 #include <OpenGL/gl.h>
-#endif //!ESSENTIAL_GL_PRACTICES_SUPPORT_GL3
+#endif //! ESSENTIAL_GL_PRACTICES_SUPPORT_GL3
 #else
 #include <SDL2/SDL_opengl.h>
 #endif
@@ -24,14 +24,14 @@ namespace shader
     SDL_Window *win = nullptr;
     SDL_Renderer *renderer = nullptr;
     GLuint programId = 0;
-    SDL_Texture* backBuffer = nullptr;
-    SDL_Point win_size = {320*4, 256*4};
+    SDL_Texture *backBuffer = nullptr;
+    SDL_Point win_size = {320 * 4, 256 * 4};
     SDL_Point tex_size = {320, 256};
     bool usingOpenGL;
 
-    #ifndef __APPLE__
+#ifndef __APPLE__
 
-    // I'm avoiding the use of GLEW or some extensions handler, but that 
+    // I'm avoiding the use of GLEW or some extensions handler, but that
     // doesn't mean you should...
     PFNGLCREATESHADERPROC glCreateShader;
     PFNGLSHADERSOURCEPROC glShaderSource;
@@ -47,7 +47,8 @@ namespace shader
     PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
     PFNGLUSEPROGRAMPROC glUseProgram;
 
-    bool initGLExtensions() {
+    bool initGLExtensions()
+    {
         glCreateShader = (PFNGLCREATESHADERPROC)SDL_GL_GetProcAddress("glCreateShader");
         glShaderSource = (PFNGLSHADERSOURCEPROC)SDL_GL_GetProcAddress("glShaderSource");
         glCompileShader = (PFNGLCOMPILESHADERPROC)SDL_GL_GetProcAddress("glCompileShader");
@@ -62,56 +63,60 @@ namespace shader
         glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)SDL_GL_GetProcAddress("glGetProgramInfoLog");
         glUseProgram = (PFNGLUSEPROGRAMPROC)SDL_GL_GetProcAddress("glUseProgram");
 
-        return glCreateShader && glShaderSource && glCompileShader && glGetShaderiv && 
-            glGetShaderInfoLog && glDeleteShader && glAttachShader && glCreateProgram &&
-            glLinkProgram && glValidateProgram && glGetProgramiv && glGetProgramInfoLog &&
-            glUseProgram;
+        return glCreateShader && glShaderSource && glCompileShader && glGetShaderiv &&
+               glGetShaderInfoLog && glDeleteShader && glAttachShader && glCreateProgram &&
+               glLinkProgram && glValidateProgram && glGetProgramiv && glGetProgramInfoLog &&
+               glUseProgram;
     }
 
-    #endif
+#endif
 
-    GLuint compileShader(const char* source, GLuint shaderType) {
+    GLuint compileShader(const char *source, GLuint shaderType)
+    {
         // Create ID for shader
         GLuint result = glCreateShader(shaderType);
         // Add define depending on shader type
-        const char *sources[2] = { shaderType==GL_VERTEX_SHADER?"#define VERTEX\n":"#define FRAGMENT\n", source };
+        const char *sources[2] = {shaderType == GL_VERTEX_SHADER ? "#define VERTEX\n" : "#define FRAGMENT\n", source};
         // Define shader text
         glShaderSource(result, 2, sources, NULL);
         // Compile shader
         glCompileShader(result);
 
-        //Check vertex shader for errors
+        // Check vertex shader for errors
         GLint shaderCompiled = GL_FALSE;
-        glGetShaderiv( result, GL_COMPILE_STATUS, &shaderCompiled );
-        if( shaderCompiled != GL_TRUE ) {
+        glGetShaderiv(result, GL_COMPILE_STATUS, &shaderCompiled);
+        if (shaderCompiled != GL_TRUE)
+        {
             std::cout << "Error en la compilación: " << result << "!" << std::endl;
             GLint logLength;
             glGetShaderiv(result, GL_INFO_LOG_LENGTH, &logLength);
             if (logLength > 0)
             {
-                GLchar *log = (GLchar*)malloc(logLength);
+                GLchar *log = (GLchar *)malloc(logLength);
                 glGetShaderInfoLog(result, logLength, &logLength, log);
                 std::cout << "Shader compile log:" << log << std::endl;
                 free(log);
             }
             glDeleteShader(result);
             result = 0;
-//        } else {
-//            std::cout << "Shader compilado correctamente. Id = " << result << std::endl;
+            //        } else {
+            //            std::cout << "Shader compilado correctamente. Id = " << result << std::endl;
         }
         return result;
     }
 
-    GLuint compileProgram(const char* vertexShaderSource, const char* fragmentShaderSource) {
+    GLuint compileProgram(const char *vertexShaderSource, const char *fragmentShaderSource)
+    {
         GLuint programId = 0;
         GLuint vtxShaderId, fragShaderId;
 
         programId = glCreateProgram();
 
         vtxShaderId = compileShader(vertexShaderSource, GL_VERTEX_SHADER);
-        fragShaderId = compileShader(fragmentShaderSource?fragmentShaderSource:vertexShaderSource, GL_FRAGMENT_SHADER);
+        fragShaderId = compileShader(fragmentShaderSource ? fragmentShaderSource : vertexShaderSource, GL_FRAGMENT_SHADER);
 
-        if(vtxShaderId && fragShaderId) {
+        if (vtxShaderId && fragShaderId)
+        {
             // Associate shader with program
             glAttachShader(programId, vtxShaderId);
             glAttachShader(programId, fragShaderId);
@@ -121,24 +126,28 @@ namespace shader
             // Check the status of the compile/link
             GLint logLen;
             glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &logLen);
-            if(logLen > 0) {
-                char* log = (char*) malloc(logLen * sizeof(char));
+            if (logLen > 0)
+            {
+                char *log = (char *)malloc(logLen * sizeof(char));
                 // Show any errors as appropriate
                 glGetProgramInfoLog(programId, logLen, &logLen, log);
-                std::cout << "Prog Info Log: " << std::endl << log << std::endl;
+                std::cout << "Prog Info Log: " << std::endl
+                          << log << std::endl;
                 free(log);
             }
         }
-        if(vtxShaderId) {
+        if (vtxShaderId)
+        {
             glDeleteShader(vtxShaderId);
         }
-        if(fragShaderId) {
+        if (fragShaderId)
+        {
             glDeleteShader(fragShaderId);
         }
         return programId;
     }
 
-    const bool init(SDL_Window* win, SDL_Texture* backBuffer, const char* vertexShader, const char* fragmentShader)
+    const bool init(SDL_Window *win, SDL_Texture *backBuffer, const char *vertexShader, const char *fragmentShader)
     {
         shader::win = win;
         shader::renderer = SDL_GetRenderer(win);
@@ -155,19 +164,23 @@ namespace shader
         SDL_RendererInfo rendererInfo;
         SDL_GetRendererInfo(renderer, &rendererInfo);
 
-        if(!strncmp(rendererInfo.name, "opengl", 6)) {
-            //std::cout << "Es OpenGL!" << std::endl;
-    #ifndef __APPLE__
-            if (!initGLExtensions()) {
+        if (!strncmp(rendererInfo.name, "opengl", 6))
+        {
+            // std::cout << "Es OpenGL!" << std::endl;
+#ifndef __APPLE__
+            if (!initGLExtensions())
+            {
                 std::cout << "WARNING: No s'han pogut inicialitzar les extensions d'OpenGL!" << std::endl;
                 usingOpenGL = false;
                 return false;
             }
-    #endif
+#endif
             // Compilar el shader y dejarlo listo para usar.
             programId = compileProgram(vertexShader, fragmentShader);
-            //std::cout << "programId = " << programId << std::endl;
-        } else {
+            // std::cout << "programId = " << programId << std::endl;
+        }
+        else
+        {
             std::cout << "WARNING: El driver del renderer no es OpenGL." << std::endl;
             usingOpenGL = false;
             return false;
@@ -180,19 +193,21 @@ namespace shader
     {
         GLint oldProgramId;
         // Guarrada para obtener el textureid (en driverdata->texture)
-        //Detach the texture
+        // Detach the texture
         SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
 
         SDL_SetRenderTarget(renderer, NULL);
         SDL_RenderClear(renderer);
 
-        if (usingOpenGL) {
+        if (usingOpenGL)
+        {
             SDL_GL_BindTexture(backBuffer, NULL, NULL);
-            if(programId != 0) {
-                glGetIntegerv(GL_CURRENT_PROGRAM,&oldProgramId);
+            if (programId != 0)
+            {
+                glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgramId);
                 glUseProgram(programId);
             }
-            
+
             GLfloat minx, miny, maxx, maxy;
             GLfloat minu, maxu, minv, maxv;
 
@@ -210,21 +225,24 @@ namespace shader
             glViewport(0, 0, win_size.x, win_size.y);
 
             glBegin(GL_TRIANGLE_STRIP);
-                glTexCoord2f(minu, minv);
-                glVertex2f(minx, miny);
-                glTexCoord2f(maxu, minv);
-                glVertex2f(maxx, miny);
-                glTexCoord2f(minu, maxv);
-                glVertex2f(minx, maxy);
-                glTexCoord2f(maxu, maxv);
-                glVertex2f(maxx, maxy);
+            glTexCoord2f(minu, minv);
+            glVertex2f(minx, miny);
+            glTexCoord2f(maxu, minv);
+            glVertex2f(maxx, miny);
+            glTexCoord2f(minu, maxv);
+            glVertex2f(minx, maxy);
+            glTexCoord2f(maxu, maxv);
+            glVertex2f(maxx, maxy);
             glEnd();
             SDL_GL_SwapWindow(win);
 
-            if(programId != 0) {
+            if (programId != 0)
+            {
                 glUseProgram(oldProgramId);
             }
-        } else {
+        }
+        else
+        {
             SDL_RenderCopy(renderer, backBuffer, NULL, NULL);
             SDL_RenderPresent(renderer);
         }

source/jail_shader.h

@@ -2,8 +2,8 @@
 
 #pragma once
 
-#include <SDL2/SDL_render.h>  // for SDL_Texture
-#include <SDL2/SDL_video.h>   // for SDL_Window
+#include <SDL2/SDL_render.h> // para SDL_Texture
+#include <SDL2/SDL_video.h>  // para SDL_Window
 
 // TIPS:
 // =======================================================================
@@ -27,7 +27,7 @@
 // Els shaders li'ls passem com una cadena, som nosaltres els que s'encarreguem
 // de carregarlos de disc, amb fopen, ifstream, jfile o el que vullgues.
 // Si els tens en un std::string, passa-li-la com "cadena.c_str()".
-// 
+//
 // Poden ser els dos el mateix arxiu, com fa libRetro, jo desde dins ja fique
 // els defines necessaris. Si es el mateix arxiu, pots no ficar el quart paràmetre.
 //
@@ -40,8 +40,8 @@
 
 namespace shader
 {
-    const bool init(SDL_Window* win, SDL_Texture* backBuffer,
-                    const char* vertexShader, const char* fragmentShader=nullptr);
+    const bool init(SDL_Window *win, SDL_Texture *backBuffer,
+                    const char *vertexShader, const char *fragmentShader = nullptr);
 
     void render();
 }

source/lang.cpp

@@ -1,11 +1,11 @@
 #include "lang.h"
-#include <fstream>  // for basic_ifstream, basic_istream, ifstream
-#include <vector>   // for vector
+#include <fstream> // para basic_ifstream, basic_istream, ifstream
+#include <vector>  // para vector
 
 namespace lang
-{ 
+{
     std::vector<std::string> texts; // Vector con los textos
-    
+
     // Inicializa los textos del juego en el idioma seleccionado
     bool loadFromFile(std::string file_path)
     {

source/lang.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <string>  // for string
+#include <string> // para string
 
 namespace lang
 {

source/logo.cpp

@@ -1,31 +1,29 @@
 #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 <utility>			 // for move
-#include "asset.h"			 // for Asset
-#include "global_inputs.h"	 // for check
-#include "input.h"			 // for Input
-#include "jail_audio.h"		 // for JA_StopMusic
-#include "param.h"			 // for param
-#include "resource.h"		 // for Resource
-#include "screen.h"			 // for Screen
-#include "section.h"		 // for Name, name, Options, options
-#include "sprite.h"			 // for Sprite
-#include "texture.h"		 // for Texture
+#include <SDL2/SDL_events.h> // Para SDL_PollEvent, SDL_Event, SDL_QUIT, SDL...
+#include <SDL2/SDL_timer.h>	 // Para SDL_GetTicks
+#include <SDL2/SDL_video.h>	 // Para SDL_WINDOWEVENT_SIZE_CHANGED
+#include <utility>			 // Para move
+#include "global_inputs.h"	 // Para check
+#include "input.h"			 // Para Input
+#include "jail_audio.h"		 // Para JA_StopMusic
+#include "param.h"			 // Para Param, ParamGame, param
+#include "resource.h"		 // Para Resource
+#include "screen.h"			 // Para Screen
+#include "section.h"		 // Para Name, name, Options, options
+#include "sprite.h"			 // Para Sprite
+#include "texture.h"		 // Para Texture
 
 // Constructor
 Logo::Logo()
 	: since_texture_(Resource::get()->getTexture("logo_since_1998.png")),
 	  since_sprite_(std::make_unique<Sprite>(since_texture_)),
-	  jail_texture_(Resource::get()->getTexture("logo_jailgames.png"))
+	  jail_texture_(Resource::get()->getTexture("logo_jailgames.png")),
+	  ticks_(0)
 {
 
 	// Inicializa variables
 	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_->setPosition({(param.game.width - since_texture_->getWidth()) / 2, 83 + jail_texture_->getHeight() + 5, since_texture_->getWidth(), since_texture_->getHeight()});
@@ -45,14 +43,14 @@ Logo::Logo()
 	}
 
 	// 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
+	color_.push_back(Color(0x00, 0x00, 0x00)); // Black
+	color_.push_back(Color(0x00, 0x00, 0xd8)); // Blue
+	color_.push_back(Color(0xd8, 0x00, 0x00)); // Red
+	color_.push_back(Color(0xd8, 0x00, 0xd8)); // Magenta
+	color_.push_back(Color(0x00, 0xd8, 0x00)); // Green
+	color_.push_back(Color(0x00, 0xd8, 0xd8)); // Cyan
+	color_.push_back(Color(0xd8, 0xd8, 0x00)); // Yellow
+	color_.push_back(Color(0xFF, 0xFF, 0xFF)); // Bright white
 }
 
 // Recarga todas las texturas
@@ -165,7 +163,8 @@ void Logo::updateTextureColors()
 // Actualiza las variables
 void Logo::update()
 {
-	// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
+	constexpr int TICKS_SPEED = 15;
+
 	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		// Actualiza el contador de ticks

source/logo.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#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 "sprite.h"           // for Sprite
-#include "utils.h"            // for Color
+#include <SDL2/SDL_rect.h>	 // para SDL_Point
+#include <SDL2/SDL_stdinc.h> // para Uint32
+#include <memory>			 // para unique_ptr, shared_ptr
+#include <vector>			 // para vector
+#include "sprite.h"			 // para Sprite
+#include "utils.h"			 // para Color
 class Texture;
 
 /*
@@ -21,13 +21,12 @@ 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
 	std::shared_ptr<Texture> since_texture_;		   // Textura con los graficos "Since 1998"
 	std::unique_ptr<Sprite> since_sprite_;			   // Sprite para manejar la sinceTexture

source/main.cpp

@@ -7,9 +7,8 @@ Actualizando a la versión "Arcade Edition" en 08/05/2024
 
 */
 
-#include <iostream>    // for char_traits, basic_ostream, operator<<, cout
-#include <memory>      // for make_unique, unique_ptr
-#include "director.h"  // for Director
+#include <memory>     // Para make_unique, unique_ptr
+#include "director.h" // Para Director
 
 int main(int argc, char *argv[])
 {

source/manage_hiscore_table.cpp

@@ -1,48 +1,40 @@
 #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
-
-// Constructor
-ManageHiScoreTable::ManageHiScoreTable(std::vector<HiScoreEntry> *table)
-    : table_(table) {}
+#include <SDL2/SDL_error.h> // Para SDL_GetError
+#include <SDL2/SDL_rwops.h> // Para SDL_RWread, SDL_RWwrite, SDL_RWFromFile
+#include <algorithm>        // Para sort
+#include <iostream>         // Para basic_ostream, operator<<, cout, endl
+#include "utils.h"          // Para HiScoreEntry, getFileName
 
 // 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(HiScoreEntry("Bry", 1000000));
+    table_.push_back(HiScoreEntry("Usufondo", 500000));
+    table_.push_back(HiScoreEntry("G.Lucas", 100000));
+    table_.push_back(HiScoreEntry("P.Delgat", 50000));
+    table_.push_back(HiScoreEntry("P.Arrabalera", 10000));
+    table_.push_back(HiScoreEntry("Pelechano", 5000));
+    table_.push_back(HiScoreEntry("Sahuquillo", 1000));
+    table_.push_back(HiScoreEntry("Bacteriol", 500));
+    table_.push_back(HiScoreEntry("Pepe", 200));
+    table_.push_back(HiScoreEntry("Rosita", 100));
 }
 
 // Añade un elemento a la tabla
 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 (static_cast<int>(table_->size()) > 10)
-    {
-        table_->resize(10);
-    }
+    table_.resize(10);
 }
 
 // Ordena la tabla
@@ -51,28 +43,27 @@ void ManageHiScoreTable::sort()
     struct
     {
         bool operator()(const HiScoreEntry &a, const HiScoreEntry &b) const { return a.score > b.score; }
-    } custom_less;
+    } scoreDescendingComparator;
 
-    std::sort(table_->begin(), table_->end(), custom_less);
+    std::sort(table_.begin(), table_.end(), scoreDescendingComparator);
 }
 
 // Carga la tabla con los datos de un fichero
 bool ManageHiScoreTable::loadFromFile(const std::string &file_path)
 {
     clear();
-
     auto success = true;
     auto file = SDL_RWFromFile(file_path.c_str(), "r+b");
 
     if (file)
     {
-        const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
-        std::cout << "Reading file: " << file_name.c_str() << std::endl;
-        for (int i = 0; i < (int)table_->size(); ++i)
+        std::cout << "Reading file: " << getFileName(file_path) << std::endl;
+
+        for (auto &entry : table_)
         {
             int nameSize = 0;
 
-            if (SDL_RWread(file, &table_->at(i).score, sizeof(int), 1) == 0)
+            if (SDL_RWread(file, &entry.score, sizeof(int), 1) == 0)
             {
                 success = false;
                 break;
@@ -84,19 +75,15 @@ bool ManageHiScoreTable::loadFromFile(const std::string &file_path)
                 break;
             }
 
-            char *name = static_cast<char *>(malloc(nameSize + 1));
-            if (SDL_RWread(file, name, sizeof(char) * nameSize, 1) == 0)
+            std::vector<char> nameBuffer(nameSize + 1);
+            if (SDL_RWread(file, nameBuffer.data(), sizeof(char) * nameSize, 1) == 0)
             {
                 success = false;
-                free(name);
                 break;
             }
-            else
-            {
-                name[nameSize] = 0;
-                table_->at(i).name = name;
-                free(name);
-            }
+
+            nameBuffer[nameSize] = '\0';
+            entry.name = std::string(nameBuffer.data());
         }
 
         SDL_RWclose(file);
@@ -113,28 +100,26 @@ bool ManageHiScoreTable::loadFromFile(const std::string &file_path)
 // Guarda la tabla en un fichero
 bool ManageHiScoreTable::saveToFile(const std::string &file_path)
 {
-    const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
     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);
         }
 
-        std::cout << "Writing file: " << file_name.c_str() << std::endl;
-        // Cierra el fichero
+        std::cout << "Writing file: " << getFileName(file_path).c_str() << std::endl;
         SDL_RWclose(file);
     }
     else
     {
-        std::cout << "Error: Unable to save " << file_name.c_str() << " file! " << SDL_GetError() << std::endl;
+        std::cout << "Error: Unable to save " << getFileName(file_path).c_str() << " file! " << SDL_GetError() << std::endl;
     }
     return success;
 }

source/manage_hiscore_table.h

@@ -1,8 +1,7 @@
 #pragma once
 
-#include <string> // for string
-#include <vector> // for vector
-struct HiScoreEntry;
+#include <string> // para string
+#include <vector> // para vector
 
 /*
     Esta clase sirve para añadir elementos hiScoreEntry_r a un vector (tabla), de manera
@@ -12,19 +11,31 @@ struct HiScoreEntry;
     leer y escribir la tabla a un fichero
 */
 
+// Estructura para las entradas de la tabla de recirds
+struct HiScoreEntry
+{
+	std::string name; // Nombre
+	int score;		  // Puntuación
+
+	// Constructor
+	explicit HiScoreEntry(const std::string &n = "", int s = 0)
+		: name(n), score(s) {}
+};
+
 // Clase ManageHiScoreTable
 class ManageHiScoreTable
 {
 private:
     // Variables
-    std::vector<HiScoreEntry> *table_; // Tabla con los records
+    std::vector<HiScoreEntry> &table_; // Tabla con los records
 
     // Ordena la tabla
     void sort();
 
 public:
     // Constructor
-    explicit ManageHiScoreTable(std::vector<HiScoreEntry> *table);
+    explicit ManageHiScoreTable(std::vector<HiScoreEntry> &table)
+        : table_(table) {}
 
     // Destructor
     ~ManageHiScoreTable() = default;

source/moving_sprite.cpp

@@ -1,15 +1,12 @@
 #include "moving_sprite.h"
-#include "texture.h" // for Texture
+#include <algorithm> // Para max
+#include "texture.h" // Para Texture
 
 // Constructor
 MovingSprite::MovingSprite(std::shared_ptr<Texture> texture, SDL_Rect pos, Rotate rotate, float zoom_w, float zoom_h, SDL_RendererFlip flip)
 	: Sprite(texture, pos),
 	  x_(pos.x),
 	  y_(pos.y),
-	  vx_(0.0f),
-	  vy_(0.0f),
-	  ax_(0.0f),
-	  ay_(0.0f),
 	  rotate_(rotate),
 	  zoom_w_(zoom_w),
 	  zoom_h_(zoom_h),
@@ -19,10 +16,6 @@ MovingSprite::MovingSprite(std::shared_ptr<Texture> texture, SDL_Rect pos)
 	: Sprite(texture, pos),
 	  x_(pos.x),
 	  y_(pos.y),
-	  vx_(0.0f),
-	  vy_(0.0f),
-	  ax_(0.0f),
-	  ay_(0.0f),
 	  rotate_(Rotate()),
 	  zoom_w_(1.0f),
 	  zoom_h_(1.0f),
@@ -32,10 +25,6 @@ MovingSprite::MovingSprite(std::shared_ptr<Texture> texture)
 	: Sprite(texture),
 	  x_(0.0f),
 	  y_(0.0f),
-	  vx_(0.0f),
-	  vy_(0.0f),
-	  ax_(0.0f),
-	  ay_(0.0f),
 	  rotate_(Rotate()),
 	  zoom_w_(1.0f),
 	  zoom_h_(1.0f),
@@ -89,24 +78,6 @@ void MovingSprite::render()
 	texture_->render(pos_.x, pos_.y, &sprite_clip_, zoom_w_, zoom_h_, rotate_.angle, rotate_.center, flip_);
 }
 
-// Obtiene el valor de la variable
-float MovingSprite::getZoomW() const
-{
-	return zoom_w_;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getZoomH() const
-{
-	return zoom_h_;
-}
-
-// Obtiene el valor de la variable
-double MovingSprite::getAngle() const
-{
-	return rotate_.angle;
-}
-
 // Establece el valor de la variable
 void MovingSprite::setZoomW(float value)
 {
@@ -137,12 +108,6 @@ bool MovingSprite::isRotating() const
 	return rotate_.enabled;
 }
 
-// Obtiene el valor de la variable
-int MovingSprite::getRotateSpeed() const
-{
-	return rotate_.speed;
-}
-
 // Establece la rotacion
 void MovingSprite::rotate()
 {

source/moving_sprite.h

@@ -1,11 +1,10 @@
 #pragma once
 
-#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;
+#include <SDL2/SDL_rect.h>   // Para SDL_Rect, SDL_Point
+#include <SDL2/SDL_render.h> // Para SDL_RendererFlip
+#include <memory>            // Para shared_ptr
+#include "sprite.h"          // Para Sprite
+class Texture;               // lines 8-8
 
 // Clase MovingSprite. Añade movimiento y efectos de rotación, zoom y flip al sprite
 class MovingSprite : public Sprite
@@ -27,11 +26,11 @@ protected:
     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_ = 0.0f; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
+    float vy_ = 0.0f; // 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_ = 0.0f; // Aceleración en el eje X. Variación de la velocidad
+    float ay_ = 0.0f; // Aceleración en el eje Y. Variación de la velocidad
 
     Rotate rotate_;         // Variables usada para controlar la rotación del sprite
     float zoom_w_;          // Zoom aplicado a la anchura
@@ -54,7 +53,7 @@ public:
     explicit MovingSprite(std::shared_ptr<Texture> texture);
 
     // Destructor
-    ~MovingSprite() = default;
+    virtual ~MovingSprite() = default;
 
     // Actualiza las variables internas del objeto
     virtual void update();
@@ -79,14 +78,8 @@ public:
     void setAccelX(float value);
     void setAccelY(float value);
 
-    // Obten el valor de la variable
-    float getZoomW() const;
-    float getZoomH() const;
-
     // Obten el valor de la variable
     bool isRotating() const;
-    double getAngle() const;
-    int getRotateSpeed() const;
 
     // Establece el valor de la variable
     void setZoomW(float value);

source/notifier.cpp

@@ -1,20 +1,19 @@
 #include "notifier.h"
-#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_pixels.h>    // for SDL_PIXELFORMAT_RGBA8888
-#include <string>               // for string
-#include "jail_audio.h"         // for JA_DeleteSound, JA_LoadSound, JA_Pla...
-#include "param.h"              // for param
-#include "resource.h"           // for Resource
-#include "screen.h"             // for Screen
-#include "sprite.h"             // for Sprite
-#include "text.h"               // for Text
-#include "texture.h"            // for Texture
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888
+#include <string>               // Para string
+#include "jail_audio.h"         // Para JA_DeleteSound, JA_LoadSound, JA_Pla...
+#include "param.h"              // Para Param, param, ParamNotification, Par...
+#include "screen.h"             // Para Screen
+#include "sprite.h"             // Para Sprite
+#include "text.h"               // Para Text
+#include "texture.h"            // Para Texture
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Notifier *Notifier::notifier_ = nullptr;
 
 // [SINGLETON] Crearemos el objeto screen con esta función estática
-void Notifier::init(std::string icon_file, std::shared_ptr<Text> text, const std::string &sound_file)
+void Notifier::init(const std::string &icon_file, std::shared_ptr<Text> text, const std::string &sound_file)
 {
     Notifier::notifier_ = new Notifier(icon_file, text, sound_file);
 }
@@ -34,35 +33,25 @@ Notifier *Notifier::get()
 // Constructor
 Notifier::Notifier(std::string icon_file, std::shared_ptr<Text> text, const std::string &sound_file)
     : renderer_(Screen::get()->getRenderer()),
+      icon_texture_(!icon_file.empty() ? std::make_unique<Texture>(renderer_, icon_file) : nullptr),
       text_(text),
       bg_color_(param.notification.color),
       wait_time_(150),
       stack_(false),
-      sound_(JA_LoadSound(sound_file.c_str()))
-{
-    // Inicializa variables
-    has_icons_ = !icon_file.empty();
-
-    // Crea objetos
-    icon_texture_ = has_icons_ ? std::make_unique<Texture>(renderer_, icon_file) : nullptr;
-}
+      has_icons_(!icon_file.empty()),
+      sound_(JA_LoadSound(sound_file.c_str())) {}
 
 // Destructor
 Notifier::~Notifier()
 {
-    // Libera la memoria de los objetos
     JA_DeleteSound(sound_);
-
-    notifications_.clear();
 }
 
 // Dibuja las notificaciones por pantalla
 void Notifier::render()
 {
     for (int i = (int)notifications_.size() - 1; i >= 0; --i)
-    {
         notifications_[i].sprite->render();
-    }
 }
 
 // Actualiza el estado de las notificaiones
@@ -165,7 +154,7 @@ void Notifier::clearFinishedNotifications()
     }
 }
 
-void Notifier::showText(std::string text1, std::string text2, int icon, std::string code)
+void Notifier::showText(std::string text1, std::string text2, int icon, const std::string &code)
 {
     // Cuenta el número de textos a mostrar
     const int num_texts = !text1.empty() + !text2.empty();
@@ -237,8 +226,6 @@ void Notifier::showText(std::string text1, std::string text2, int icon, std::str
     n.code = code;
     n.y = offset;
     n.travel_dist = travel_dist;
-    n.counter = 0;
-    n.status = NotificationStatus::RISING;
     n.text1 = text1;
     n.text2 = text2;
     n.shape = shape;
@@ -286,7 +273,7 @@ void Notifier::showText(std::string text1, std::string text2, int icon, std::str
     }
 
     // Escribe el texto de la notificación
-    Color color = {255, 255, 255};
+    Color color{255, 255, 255};
     if (num_texts == 2)
     { // Dos lineas de texto
         text_->writeColored(padding_in_h + icon_space, padding_in_v, text1, color);

source/notifier.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>	 // for SDL_Rect
-#include <SDL2/SDL_render.h> // for SDL_Renderer
-#include <memory>			 // for shared_ptr, unique_ptr
-#include <string>			 // for string, basic_string
-#include <vector>			 // for vector
-#include "utils.h"			 // for Color
+#include <SDL2/SDL_rect.h>	 // para SDL_Rect
+#include <SDL2/SDL_render.h> // para SDL_Renderer
+#include <memory>			 // para shared_ptr, unique_ptr
+#include <string>			 // para string, basic_string
+#include <vector>			 // para vector
+#include "utils.h"			 // para Color
 class Sprite;
 class Text;
 class Texture;
@@ -25,18 +25,6 @@ private:
 		FINISHED,
 	};
 
-	enum class NotificationPosition
-	{
-		UPPER_LEFT,
-		UPPER_CENTER,
-		UPPER_RIGHT,
-		MIDDLE_LEFT,
-		MIDDLE_RIGHT,
-		BOTTOM_LEFT,
-		BOTTOM_CENTER,
-		BOTTOM_RIGHT,
-	};
-
 	enum class NotificationShape
 	{
 		ROUNDED,
@@ -51,12 +39,16 @@ private:
 		std::string text2;
 		int counter;
 		NotificationStatus status;
-		NotificationPosition position;
 		NotificationShape shape;
 		SDL_Rect rect;
 		int y;
 		int travel_dist;
 		std::string code; // Permite asignar un código a la notificación
+
+		// Constructor
+		explicit Notification()
+			: texture(nullptr), sprite(nullptr), text1(""), text2(""), counter(0), status(NotificationStatus::RISING),
+			  shape(NotificationShape::SQUARED), rect{0, 0, 0, 0}, y(0), travel_dist(0), code("") {}
 	};
 
 	// Objetos y punteros
@@ -89,7 +81,7 @@ private:
 
 public:
 	// [SINGLETON] Crearemos el objeto notifier con esta función estática
-	static void init(std::string icon_file, std::shared_ptr<Text> text, const std::string &sound_file);
+	static void init(const std::string &icon_file, std::shared_ptr<Text> text, const std::string &sound_file);
 
 	// [SINGLETON] Destruiremos el objeto notifier con esta función estática
 	static void destroy();
@@ -111,7 +103,7 @@ public:
 	 * @param icon Icono opcional para mostrar (valor predeterminado: -1).
 	 * @param code Permite asignar un código a la notificación (valor predeterminado: cadena vacía).
 	 */
-	void showText(std::string text1 = std::string(), std::string text2 = std::string(), int icon = -1, std::string code = std::string());
+	void showText(std::string text1 = std::string(), std::string text2 = std::string(), int icon = -1, const std::string &code = std::string());
 
 	// Indica si hay notificaciones activas
 	bool isActive();

source/on_screen_help.cpp

@@ -1,16 +1,14 @@
 #include "on_screen_help.h"
-#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 "resource.h"           // for Resource
-#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
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888
+#include <memory>               // Para make_unique, unique_ptr
+#include "lang.h"               // Para getText
+#include "param.h"              // Para Param, ParamGame, param
+#include "resource.h"           // Para Resource
+#include "screen.h"             // Para Screen
+#include "sprite.h"             // Para Sprite
+#include "text.h"               // Para Text
+#include "utils.h"              // Para easeInOutSine
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 OnScreenHelp *OnScreenHelp::onScreenHelp = nullptr;

source/on_screen_help.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>    // for SDL_Rect
-#include <SDL2/SDL_render.h>  // for SDL_Texture
-#include <vector>             // for vector
+#include <SDL2/SDL_rect.h>   // para SDL_Rect
+#include <SDL2/SDL_render.h> // para SDL_Texture
+#include <vector>            // para vector
 class Sprite;
 class Text;
 

source/options.cpp

@@ -1,13 +1,13 @@
 #include "options.h"
-#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_...
+#include <SDL2/SDL_gamecontroller.h> // para SDL_GameControllerButton, SDL_C...
+#include <algorithm>				 // para max, min
+#include <fstream>					 // para basic_ostream, operator<<, basi...
+#include <iostream>					 // para cout
+#include <vector>					 // para vector
+#include "input.h"					 // para inputs_e, INPUT_USE_ANY, INPUT_...
+#include "lang.h"					 // para lang_e
+#include "screen.h"					 // para ScreenVideoMode, ScreenFilter
+#include "utils.h"					 // para OptionsController, Options, op_...
 
 // Variables
 Options options;
@@ -86,14 +86,13 @@ bool loadOptionsFile(std::string file_path)
 	bool success = true;
 
 	// Variables para manejar el fichero
-	const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
 	std::ifstream file(file_path);
 
 	// Si el fichero se puede abrir
 	if (file.good())
 	{
 		// Procesa el fichero linea a linea
-		std::cout << "Reading file: " << file_name << std::endl;
+		std::cout << "Reading file: " << getFileName(file_path) << std::endl;
 		std::string line;
 		while (std::getline(file, line))
 		{
@@ -105,14 +104,12 @@ bool loadOptionsFile(std::string file_path)
 				// Procesa las dos subcadenas
 				if (!setOptions(line.substr(0, pos), line.substr(pos + 1, line.length())))
 				{
-					std::cout << "Warning: file " << file_name << std::endl;
+					std::cout << "Warning: file " << getFileName(file_path) << std::endl;
 					std::cout << "Unknown parameter " << line.substr(0, pos).c_str() << std::endl;
 					success = false;
 				}
 			}
 		}
-
-		// Cierra el fichero
 		file.close();
 	}
 
@@ -146,16 +143,15 @@ bool loadOptionsFile(std::string file_path)
 // Guarda el fichero de configuración
 bool saveOptionsFile(std::string file_path)
 {
-	const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
 	std::ofstream file(file_path);
 
 	if (!file.good())
 	{
-		std::cout << file_name << " can't be opened" << std::endl;
+		std::cout << getFileName(file_path) << " can't be opened" << std::endl;
 		return false;
 	}
 
-	std::cout << "Writing file: " << file_name << std::endl;
+	std::cout << "Writing file: " << getFileName(file_path) << std::endl;
 
 	// Opciones de video
 	const auto value_video_mode_winow = std::to_string(static_cast<int>(ScreenVideoMode::WINDOW));

source/options.h

@@ -1,7 +1,93 @@
 #pragma once
 
-#include <string> // for string
-struct Options;
+#include <SDL2/SDL_gamecontroller.h> // Para SDL_GameControllerButton
+#include <SDL2/SDL_stdinc.h>		 // Para Uint8
+#include "manage_hiscore_table.h"
+#include <vector> // Para vector
+#include <string>
+enum class InputType : int;
+enum class ScreenFilter : int;
+enum class ScreenVideoMode : int;
+namespace lang
+{
+	enum class Code : int;
+}
+
+// Dificultad del juego
+enum class GameDifficulty
+{
+	EASY = 0,
+	NORMAL = 1,
+	HARD = 2,
+};
+
+// Estructura para las opciones de la ventana
+struct OptionsWindow
+{
+	int size; // Contiene el valor por el que se multiplica el tamaño de la ventana
+};
+
+// Estructura con opciones para el video
+struct OptionsVideo
+{
+	OptionsWindow window; // Opciones para la ventana del programa
+	ScreenVideoMode mode; // Contiene el valor del modo de pantalla completa
+	ScreenFilter filter;  // Filtro usado para el escalado de la imagen
+	bool v_sync;		  // Indica si se quiere usar vsync o no
+	bool integer_scale;	  // Indica si se va a usar el escalado entero
+	bool shaders;		  // Indica si se van a usar shaders para los filtros de video
+};
+
+// Estructura para las opciones de musica
+struct OptionsMusic
+{
+	bool enabled; // Indica si la musica suena o no
+	int volume;	  // Volumen al que suena la música
+};
+
+// Estructura para las opciones de sonido
+struct OptionsSound
+{
+	bool enabled; // Indica si los sonidos suenan o no
+	int volume;	  // Volumen al que suenan los sonidos
+};
+
+// Estructura para las opciones de audio
+struct OptionsAudio
+{
+	OptionsMusic music; // Opciones para la música
+	OptionsSound sound; // Opciones para los efectos de sonido
+};
+
+// Estructura para las opciones del juego
+struct OptionsGame
+{
+	GameDifficulty difficulty;				  // Dificultad del juego
+	lang::Code language;					  // Idioma usado en el juego
+	bool autofire;							  // Indica si el jugador ha de pulsar repetidamente para disparar o basta con mantener pulsado
+	std::vector<HiScoreEntry> hi_score_table; // Tabla con las mejores puntuaciones
+};
+
+// Estructura para los controles del juego
+struct OptionsController
+{
+	int index;									   // Indice en el vector de mandos
+	int player_id;								   // Jugador asociado al mando
+	Uint8 device_type;							   // Indica si se utilizará teclado o mando o ambos
+	std::string name;							   // Nombre del dispositivo
+	bool plugged;								   // Indica si el mando se encuentra conectado
+	std::vector<InputType> inputs;				   // Listado de inputs
+	std::vector<SDL_GameControllerButton> buttons; // Listado de botones asignados a cada input
+};
+
+// Estructura con todas las opciones de configuración del programa
+struct Options
+{
+	OptionsGame game;						   // Opciones para el propio juego
+	OptionsVideo video;						   // Opciones relativas a la clase screen
+	OptionsAudio audio;						   // Opciones para el audio
+	std::vector<OptionsController> controller; // Opciones con las asignaciones del mando para cada jugador
+};
 
 // Variables
 extern Options options;

source/param.cpp

@@ -1,10 +1,10 @@
 #include "param.h"
-#include <fstream>	// for char_traits, basic_ostream, basic_ifstream, basi...
-#include <iostream> // for cout
+#include <fstream>	// para char_traits, basic_ostream, basic_ifstream, basi...
+#include <iostream> // para cout
 #include <sstream>
 #include <string>
 #include <stdexcept>
-#include "utils.h" // for Param, ParamGame, Zone, ParamBalloon
+#include "utils.h" // para Param, ParamGame, Zone, ParamBalloon
 
 Param param;
 
@@ -43,18 +43,14 @@ void initParam()
 	param.title.title_c_c_position = 11;
 
 	// BACKGROUND
-	param.background.attenuate_color = (Color){255, 255, 255};
+	param.background.attenuate_color = Color(255, 255, 255);
 	param.background.attenuate_alpha = 32;
 
 	// BALLOONS
-	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;
+	param.balloon.emplace_back(0.09f, 2.60f);
+	param.balloon.emplace_back(0.10f, 3.50f);
+	param.balloon.emplace_back(0.10f, 4.50f);
+	param.balloon.emplace_back(0.10f, 4.95f);
 
 	// NOTIFICATION
 	param.notification.pos_v = NotifyPosition::TOP;
@@ -78,8 +74,7 @@ void loadParamsFromFile(const std::string &file_path)
 		throw std::runtime_error("No se pudo abrir el archivo: " + file_path);
 	}
 
-	const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
-	std::cout << "Reading file: " << file_name << std::endl;
+	std::cout << "Reading file: " << getFileName(file_path) << std::endl;
 
 	std::string line, param1, param2;
 	while (std::getline(file, line))
@@ -250,42 +245,42 @@ bool setParams(const std::string &var, const std::string &value)
 	// BALLOON
 	else if (var == "balloon_1.vel")
 	{
-		param.balloon_1.vel = std::stof(value);
+		param.balloon.at(0).vel = std::stof(value);
 	}
 
 	else if (var == "balloon_1.grav")
 	{
-		param.balloon_1.grav = std::stof(value);
+		param.balloon.at(0).grav = std::stof(value);
 	}
 
 	else if (var == "balloon_2.vel")
 	{
-		param.balloon_2.vel = std::stof(value);
+		param.balloon.at(1).vel = std::stof(value);
 	}
 
 	else if (var == "balloon_2.grav")
 	{
-		param.balloon_2.grav = std::stof(value);
+		param.balloon.at(1).grav = std::stof(value);
 	}
 
 	else if (var == "balloon_3.vel")
 	{
-		param.balloon_3.vel = std::stof(value);
+		param.balloon.at(2).vel = std::stof(value);
 	}
 
 	else if (var == "balloon_3.grav")
 	{
-		param.balloon_3.grav = std::stof(value);
+		param.balloon.at(2).grav = std::stof(value);
 	}
 
 	else if (var == "balloon_4.vel")
 	{
-		param.balloon_4.vel = std::stof(value);
+		param.balloon.at(3).vel = std::stof(value);
 	}
 
 	else if (var == "balloon_4.grav")
 	{
-		param.balloon_4.grav = std::stof(value);
+		param.balloon.at(3).grav = std::stof(value);
 	}
 
 	// NOTIFICACIONES

source/param.h

@@ -1,7 +1,80 @@
 #pragma once
 
-#include <string> // for string
-struct Param;
+#include <SDL2/SDL_rect.h> // Para SDL_Rect
+#include <string>          // Para string
+#include <vector>          // Para vector
+#include "utils.h"         // Para Color, Zone
+
+// param.game
+struct ParamGame
+{
+    int width;              // Ancho de la resolucion nativa del juego
+    int height;             // Alto de la resolucion nativa del juego
+    int item_size;          // Tamaño de los items del juego
+    Zone play_area;         // Rectangulo con la posición de la zona de juego
+    Zone game_area;         // Rectangulo con las dimensiones del juego
+    int enter_name_seconds; // Duración en segundos para introducir el nombre al finalizar la partida
+};
+
+// param.fade
+struct ParamFade
+{
+    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
+    int random_squares_delay; // Duración entre cada pintado de cuadrados
+    int random_squares_mult;  // Cantidad de cuadrados que se pintaran cada vez
+    int post_duration;        // Duración final del fade
+    int venetian_size;        // Altura de los rectangulos para FadeType::VENETIAN
+};
+
+// param.title
+struct ParamTitle
+{
+    int press_start_position;    // Posición del texto para empezar a jugar
+    int title_duration;          // Tiempo de inactividad del titulo
+    int arcade_edition_position; // Posición del bitmap
+    int title_c_c_position;      // Posición del bitmap
+};
+
+// param.background
+struct ParamBackground
+{
+    Color attenuate_color;
+    int attenuate_alpha;
+};
+
+struct ParamBalloon
+{
+    float grav; // Aceleración en el eje Y. Modifica la velocidad
+    float vel;  // Velocidad inicial que tienen al rebotar contra el suelo
+
+    // Constructor
+    explicit ParamBalloon(float grav_val = 0.0f, float vel_val = 0.0f)
+        : grav(grav_val), vel(vel_val) {}
+};
+
+// Estructura para las opciones de las notificaciones
+struct ParamNotification
+{
+    NotifyPosition pos_h; // Ubicación de las notificaciones en pantalla
+    NotifyPosition pos_v; // Ubicación de las notificaciones en pantalla
+    bool sound;           // Indica si las notificaciones suenan
+    Color color;          // Color de las notificaciones
+};
+
+// Estructura para almacenar todos los parámetros del juego
+struct Param
+{
+    ParamGame game;                    // Parametros relacionados con el juego
+    ParamFade fade;                    // Parametros para ajustar el fade
+    SDL_Rect scoreboard;               // Posición y tamaño del marcador
+    ParamTitle title;                  // Parametros con ajustes para la sección Title
+    ParamBackground background;        // Parametros que afectan a la clase Background
+    std::vector<ParamBalloon> balloon; // Parametros de velocidad y gravedad de cada tipo de globo
+    ParamNotification notification;    // Opciones para las notificaciones
+
+    Param() { balloon.reserve(4); }
+};
 
 extern Param param;
 

source/path_sprite.cpp

@@ -0,0 +1,124 @@
+#include "path_sprite.h"
+#include <bits/std_abs.h>  // Para abs
+#include <stdlib.h>		   // Para abs
+#include <utility>		   // Para move
+#include "moving_sprite.h" // Para MovingSprite
+#include "utils.h"		   // Para easeOutQuint
+#include <functional>
+class Texture; // lines 3-3
+
+// Constructor
+PathSprite::PathSprite(std::shared_ptr<Texture> texture)
+	: AnimatedSprite(texture) {}
+
+// Actualiza la posición y comprueba si ha llegado a su destino
+void PathSprite::update()
+{
+	if (enabled_)
+	{
+		moveThroughCurrentPath();
+		goToNextPathOrDie();
+	}
+}
+
+// Añade un recorrido
+void PathSprite::addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction, int waiting_counter)
+{
+	paths_.emplace_back(createPath(start, end, type, fixed_pos, steps, easingFunction), waiting_counter);
+}
+
+// Añade un recorrido
+void PathSprite::addPath(std::vector<SDL_Point> spots, int waiting_counter)
+{
+	paths_.emplace_back(std::move(spots), waiting_counter);
+}
+
+// Devuelve un vector con los puntos que conforman la ruta
+std::vector<SDL_Point> PathSprite::createPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction)
+{
+	std::vector<SDL_Point> v;
+	v.reserve(steps);
+
+	for (int i = 0; i < steps; ++i)
+	{
+		double t = static_cast<double>(i) / (steps - 1);
+		double value = start + (end - start) * easingFunction(t);
+
+		if (start > 0 && end < 0)
+		{
+			value = start - std::abs(end - start) * easingFunction(t);
+		}
+		else if (start < 0 && end > 0)
+		{
+			value = start + std::abs(end - start) * easingFunction(t);
+		}
+
+		switch (type)
+		{
+		case PathType::HORIZONTAL:
+			v.emplace_back(SDL_Point{static_cast<int>(value), fixed_pos});
+			break;
+		case PathType::VERTICAL:
+			v.emplace_back(SDL_Point{fixed_pos, static_cast<int>(value)});
+			break;
+		default:
+			break;
+		}
+	}
+
+	return v;
+}
+
+// Habilita el objeto
+void PathSprite::enable()
+{
+	enabled_ = true;
+}
+
+// Coloca el sprite en los diferentes puntos del recorrido
+void PathSprite::moveThroughCurrentPath()
+{
+	auto &path = paths_.at(current_path_);
+
+	// Establece la posición
+	const auto &p = path.spots.at(path.counter);
+	MovingSprite::setPos(p.x, p.y);
+
+	// Comprobar si ha terminado el recorrido
+	if (!path.on_destination)
+	{
+		++path.counter;
+		if (path.counter >= static_cast<int>(path.spots.size()))
+		{
+			path.on_destination = true;
+			path.counter = static_cast<int>(path.spots.size()) - 1;
+		}
+	}
+
+	// Comprobar si ha terminado la espera
+	if (path.on_destination)
+	{
+		if (path.waiting_counter == 0)
+			path.finished = true;
+		else
+		--path.waiting_counter;
+	}
+}
+
+// Cambia de recorrido o finaliza
+void PathSprite::goToNextPathOrDie()
+{
+	// Comprueba si ha terminado el recorrdo actual
+	if (paths_.at(current_path_).finished)
+		++current_path_;
+
+	// Comprueba si quedan mas recorridos
+	if (current_path_ >= static_cast<int>(paths_.size()))
+		enabled_ = false;
+}
+
+// Indica si ha terminado todos los recorridos
+bool PathSprite::hasFinished()
+{
+	return !enabled_;
+}

source/path_sprite.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <SDL2/SDL_rect.h>	 // Para SDL_Point
+#include <memory>			 // Para shared_ptr
+#include <functional>
+#include <vector>			 // Para vector
+#include "animated_sprite.h" // Para AnimatedSprite
+class Texture;				 // lines 5-5
+
+enum class PathType
+{
+	VERTICAL,
+	HORIZONTAL,
+};
+
+// Clase PathSprite
+class PathSprite : public AnimatedSprite
+{
+private:
+	// Estructuras
+	struct Path
+	{
+		std::vector<SDL_Point> spots; // Puntos por los que se desplazará el sprite
+		int waiting_counter;		  // Tiempo de espera una vez en el destino
+		bool on_destination = false;  // Indica si ha llegado al destino
+		bool finished = false;		  // Indica si ha terminado de esperarse
+		int counter = 0;			  // Contador interno
+
+		// Constructor
+		Path(const std::vector<SDL_Point> &spots_init, int waiting_counter_init)
+			: spots(spots_init), waiting_counter(waiting_counter_init) {}
+	};
+
+	// Variables
+	bool finished_ = false;	  // Indica si ya ha terminado
+	bool enabled_ = false;	  // Indica si el objeto está habilitado
+	int current_path_ = 0;	  // Path que se está recorriendo actualmente
+	std::vector<Path> paths_; // Caminos a recorrer por el sprite
+
+	// Coloca el sprite en los diferentes puntos del recorrido
+	void moveThroughCurrentPath();
+
+	// Cambia de recorrido o finaliza
+	void goToNextPathOrDie();
+
+public:
+	// Constructor
+	explicit PathSprite(std::shared_ptr<Texture> texture);
+
+	// Destructor
+	~PathSprite() = default;
+
+	// Actualiza la posición del sprite
+	void update() override;
+
+	// Añade un recorrido
+	void addPath(std::vector<SDL_Point> spots, int waiting_counter);
+	void addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction, int waiting_counter);
+
+	// Devuelve un vector con los puntos que conforman la ruta
+	std::vector<SDL_Point> createPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction);
+
+	// Habilita el objeto
+	void enable();
+
+	// Indica si ha terminado todos los recorridos
+	bool hasFinished();
+};

source/player.cpp

@@ -1,36 +1,30 @@
 #include "player.h"
-#include <SDL2/SDL_render.h> // for SDL_FLIP_HORIZONTAL, SDL_FLIP_NONE, SDL...
-#include <SDL2/SDL_timer.h>	 // for SDL_GetTicks
-#include <stdlib.h>			 // for rand
-#include <algorithm>		 // for max, min
-#include "animated_sprite.h" // for SpriteAnimated
-#include "input.h"			 // for inputs_e
-#include "param.h"			 // for param
-#include "texture.h"		 // for Texture
-#include "scoreboard.h"		 // for Texture
-#include "options.h"
+#include <SDL2/SDL_render.h>	  // Para SDL_FLIP_HORIZONTAL, SDL_FLIP_NONE
+#include <SDL2/SDL_timer.h>		  // Para SDL_GetTicks
+#include <stdlib.h>				  // Para rand
+#include <algorithm>			  // Para max, min
+#include "animated_sprite.h"	  // Para AnimatedSprite
+#include "input.h"				  // Para InputType
+#include "manage_hiscore_table.h" // Para HiScoreEntry
+#include "options.h"			  // Para Options, OptionsGame, options
+#include "param.h"				  // Para Param, ParamGame, param
+#include "scoreboard.h"			  // Para Scoreboard, ScoreboardMode
+#include "texture.h"			  // Para Texture
 
 // Constructor
-Player::Player(int id, float x, int y, bool demo, SDL_Rect *play_area, std::vector<std::shared_ptr<Texture>> texture, const std::vector<std::vector<std::string>> &animations)
+Player::Player(int id, float x, int y, bool demo, SDL_Rect &play_area, std::vector<std::shared_ptr<Texture>> texture, const std::vector<std::vector<std::string>> &animations)
 	: player_sprite_(std::make_unique<AnimatedSprite>(texture[0], animations[0])),
 	  power_sprite_(std::make_unique<AnimatedSprite>(texture[1], animations[1])),
 	  enter_name_(std::make_unique<EnterName>()),
-	  play_area_(play_area),
 	  id_(id),
-	  pos_x_(x),
-	  pos_y_(y),
+	  play_area_(play_area),
 	  default_pos_x_(x),
 	  default_pos_y_(y),
-	  status_playing_(PlayerStatus::WAITING),
-	  scoreboard_panel_(0),
-	  name_(std::string()),
-	  controller_index_(0),
 	  demo_(demo)
 {
-	// Reserva memoria para los objetos
+	// Configura objetos
+	player_sprite_->getTexture()->setPalette(coffees_);
 	power_sprite_->getTexture()->setAlpha(224);
-
-	// Establece los offsets para el sprite de PowerUp
 	power_up_desp_x_ = (power_sprite_->getWidth() - player_sprite_->getWidth()) / 2;
 	power_sprite_->setPosY(y - (power_sprite_->getHeight() - player_sprite_->getHeight()));
 
@@ -46,25 +40,21 @@ void Player::init()
 	pos_x_ = default_pos_x_;
 	pos_y_ = default_pos_y_;
 	status_walking_ = PlayerStatus::WALKING_STOP;
-	status_firing_ = PlayerStatus::FIRING_NO;
+	status_firing_ = PlayerStatus::FIRING_NONE;
+	status_playing_ = PlayerStatus::WAITING;
 	invulnerable_ = true;
-	invulnerable_counter_ = PLAYER_INVULNERABLE_COUNTER;
+	invulnerable_counter_ = INVULNERABLE_COUNTER_;
 	power_up_ = false;
-	power_up_counter_ = PLAYER_POWERUP_COUNTER;
+	power_up_counter_ = POWERUP_COUNTER_;
 	extra_hit_ = false;
 	coffees_ = 0;
-	input_ = true;
 	continue_ticks_ = 0;
 	continue_counter_ = 10;
 	enter_name_ticks_ = 0;
 	enter_name_counter_ = param.game.enter_name_seconds;
-	width_ = 30;
-	height_ = 30;
-	collider_.r = 9;
 	shiftColliders();
 	vel_x_ = 0;
 	vel_y_ = 0;
-	base_speed_ = 1.5;
 	score_ = 0;
 	score_multiplier_ = 1.0f;
 	cooldown_ = 10;
@@ -107,14 +97,14 @@ void Player::setInputPlaying(InputType input)
 	{
 	case InputType::LEFT:
 	{
-		vel_x_ = -base_speed_;
+		vel_x_ = -BASE_SPEED_;
 		setWalkingStatus(PlayerStatus::WALKING_LEFT);
 		break;
 	}
 
 	case InputType::RIGHT:
 	{
-		vel_x_ = base_speed_;
+		vel_x_ = BASE_SPEED_;
 		setWalkingStatus(PlayerStatus::WALKING_RIGHT);
 		break;
 	}
@@ -186,7 +176,7 @@ void Player::move()
 		pos_x_ += vel_x_;
 
 		// Si el jugador abandona el area de juego por los laterales
-		if ((pos_x_ < param.game.play_area.rect.x - 5) || (pos_x_ + width_ > play_area_->w + 5))
+		if ((pos_x_ < param.game.play_area.rect.x - 5) || (pos_x_ + WIDTH_ > play_area_.w + 5))
 		{
 			// Restaura su posición
 			pos_x_ -= vel_x_;
@@ -203,7 +193,7 @@ void Player::move()
 		player_sprite_->update();
 
 		// Si el cadaver abandona el area de juego por los laterales
-		if ((player_sprite_->getPosX() < param.game.play_area.rect.x) || (player_sprite_->getPosX() + width_ > play_area_->w))
+		if ((player_sprite_->getPosX() < param.game.play_area.rect.x) || (player_sprite_->getPosX() + WIDTH_ > play_area_.w))
 		{
 			// Restaura su posición
 			const float vx = player_sprite_->getVelX();
@@ -226,7 +216,7 @@ void Player::render()
 {
 	if (power_up_ && isPlaying())
 	{
-		if (power_up_counter_ > (PLAYER_POWERUP_COUNTER / 4) || power_up_counter_ % 20 > 4)
+		if (power_up_counter_ > (POWERUP_COUNTER_ / 4) || power_up_counter_ % 20 > 4)
 		{
 			power_sprite_->render();
 		}
@@ -261,7 +251,7 @@ void Player::setAnimation()
 	// Establece la animación a partir de las cadenas
 	if (isPlaying())
 	{
-		if (status_firing_ == PlayerStatus::FIRING_NO)
+		if (status_firing_ == PlayerStatus::FIRING_NONE)
 		{ // No esta disparando
 			player_sprite_->setCurrentAnimation(a_walking);
 			player_sprite_->setFlip(flip_walk);
@@ -301,13 +291,13 @@ int Player::getPosY() const
 // Obtiene el valor de la variable
 int Player::getWidth() const
 {
-	return width_;
+	return WIDTH_;
 }
 
 // Obtiene el valor de la variable
 int Player::getHeight() const
 {
-	return height_;
+	return HEIGHT_;
 }
 
 // Indica si el jugador puede disparar
@@ -336,7 +326,7 @@ void Player::updateCooldown()
 	}
 	else
 	{
-		setFiringStatus(PlayerStatus::FIRING_NO);
+		setFiringStatus(PlayerStatus::FIRING_NONE);
 	}
 }
 
@@ -459,8 +449,8 @@ void Player::setStatusPlaying(PlayerStatus value)
 	{
 	case PlayerStatus::PLAYING:
 	{
-		status_playing_ = PlayerStatus::PLAYING;
 		init();
+		status_playing_ = PlayerStatus::PLAYING;
 		setScoreboardMode(ScoreboardMode::SCORE);
 		break;
 	}
@@ -556,7 +546,7 @@ bool Player::isInvulnerable() const
 void Player::setInvulnerable(bool value)
 {
 	invulnerable_ = value;
-	invulnerable_counter_ = invulnerable_ ? PLAYER_INVULNERABLE_COUNTER : 0;
+	invulnerable_counter_ = invulnerable_ ? INVULNERABLE_COUNTER_ : 0;
 }
 
 // Obtiene el valor de la variable
@@ -599,7 +589,7 @@ bool Player::isPowerUp() const
 void Player::setPowerUp()
 {
 	power_up_ = true;
-	power_up_counter_ = PLAYER_POWERUP_COUNTER;
+	power_up_counter_ = POWERUP_COUNTER_;
 }
 
 // Obtiene el valor de la variable
@@ -654,18 +644,6 @@ void Player::removeExtraHit()
 	extra_hit_ = coffees_ == 0 ? false : true;
 }
 
-// Habilita la entrada de ordenes
-void Player::enableInput()
-{
-	input_ = true;
-}
-
-// Deshabilita la entrada de ordenes
-void Player::disableInput()
-{
-	input_ = false;
-}
-
 // Devuelve el número de cafes actuales
 int Player::getCoffees() const
 {
@@ -681,8 +659,8 @@ Circle &Player::getCollider()
 // Actualiza el circulo de colisión a la posición del jugador
 void Player::shiftColliders()
 {
-	collider_.x = int(pos_x_ + (width_ / 2));
-	collider_.y = int(pos_y_ + (height_ / 2));
+	collider_.x = static_cast<int>(pos_x_ + (WIDTH_ / 2));
+	collider_.y = static_cast<int>(pos_y_ + (HEIGHT_ / 2));
 }
 
 // Pone las texturas del jugador
@@ -703,9 +681,8 @@ void Player::updateContinueCounter()
 {
 	if (status_playing_ == PlayerStatus::CONTINUE)
 	{
-		constexpr Uint32 ticks_speed = 1000;
-
-		if (SDL_GetTicks() - continue_ticks_ > ticks_speed)
+		constexpr int TICKS_SPEED = 1000;
+		if (SDL_GetTicks() - continue_ticks_ > TICKS_SPEED)
 		{
 			decContinueCounter();
 		}
@@ -717,9 +694,8 @@ void Player::updateEnterNameCounter()
 {
 	if (status_playing_ == PlayerStatus::ENTERING_NAME)
 	{
-		constexpr Uint32 ticks_speed = 1000;
-
-		if (SDL_GetTicks() - enter_name_ticks_ > ticks_speed)
+		constexpr int TICKS_SPEED = 1000;
+		if (SDL_GetTicks() - enter_name_ticks_ > TICKS_SPEED)
 		{
 			decEnterNameCounter();
 		}

source/player.h

@@ -1,17 +1,16 @@
 #pragma once
 
-#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 SpriteAnimated
-#include "smart_sprite.h"	 // for SpriteAnimated
-#include "enter_name.h"		 // for EnterName
-#include "utils.h"			 // for Circle
-class Texture;
-enum class InputType : int;
-enum class ScoreboardMode; // lines 12-12
+#include <SDL2/SDL_rect.h>	 // Para SDL_Rect
+#include <SDL2/SDL_stdinc.h> // Para Uint32
+#include <memory>			 // Para unique_ptr, shared_ptr
+#include <string>			 // Para string
+#include <vector>			 // Para vector
+#include "animated_sprite.h" // Para AnimatedSprite
+#include "enter_name.h"		 // Para EnterName
+#include "utils.h"			 // Para Circle
+class Texture;				 // lines 12-12
+enum class InputType : int;	 // lines 13-13
+enum class ScoreboardMode;	 // lines 14-14
 
 // Estados del jugador
 enum class PlayerStatus
@@ -23,7 +22,7 @@ enum class PlayerStatus
 	FIRING_UP,
 	FIRING_LEFT,
 	FIRING_RIGHT,
-	FIRING_NO,
+	FIRING_NONE,
 
 	PLAYING,
 	CONTINUE,
@@ -35,54 +34,55 @@ enum class PlayerStatus
 };
 
 // Variables del jugador
-constexpr int PLAYER_INVULNERABLE_COUNTER = 200;
-constexpr int PLAYER_POWERUP_COUNTER = 1500;
 
 // Clase Player
 class Player
 {
 private:
+	// Constantes
+	static constexpr int POWERUP_COUNTER_ = 1500;	  // Duración del estado PowerUp
+	static constexpr int INVULNERABLE_COUNTER_ = 200; // Duración del estado invulnerable
+	static constexpr int WIDTH_ = 30;				  // Anchura
+	static constexpr int HEIGHT_ = 30;				  // Altura
+	static constexpr float BASE_SPEED_ = 1.5f;		  // Velocidad base del jugador
+
 	// Objetos y punteros
 	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. Player1 = 1, Player2 = 2
-	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 la tabla 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
-	int enter_name_counter_;	  // Contador para poner nombre
-	Uint32 enter_name_ticks_;	  // Variable para poder cambiar el contador de poner nombre en función del tiempo
+	int id_;												   // Numero de identificación para el jugador. Player1 = 1, Player2 = 2
+	SDL_Rect play_area_;									   // Rectangulo con la zona de juego
+	float pos_x_ = 0.0f;									   // Posicion en el eje X
+	int pos_y_ = 0;											   // 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
+	float vel_x_ = 0.0f;									   // Cantidad de pixeles a desplazarse en el eje X
+	int vel_y_ = 0.0f;										   // Cantidad de pixeles a desplazarse en el eje Y
+	int cooldown_ = 10;										   // Contador durante el cual no puede disparar
+	int score_ = 0;											   // Puntos del jugador
+	float score_multiplier_ = 1.0f;							   // Multiplicador de puntos
+	PlayerStatus status_walking_ = PlayerStatus::WALKING_STOP; // Estado del jugador al moverse
+	PlayerStatus status_firing_ = PlayerStatus::FIRING_NONE;   // Estado del jugador al disparar
+	PlayerStatus status_playing_ = PlayerStatus::WAITING;	   // Estado del jugador en el juego
+	bool invulnerable_ = true;								   // Indica si el jugador es invulnerable
+	int invulnerable_counter_ = INVULNERABLE_COUNTER_;		   // Contador para la invulnerabilidad
+	bool extra_hit_ = false;								   // Indica si el jugador tiene un toque extra
+	int coffees_ = 0;										   // Indica cuantos cafes lleva acumulados
+	bool power_up_ = false;									   // Indica si el jugador tiene activo el modo PowerUp
+	int power_up_counter_ = POWERUP_COUNTER_;				   // Temporizador para el modo PowerUp
+	int power_up_desp_x_ = 0;								   // Desplazamiento del sprite de PowerUp respecto al sprite del jugador
+	Circle collider_ = Circle(0, 0, 9);						   // Circulo de colisión del jugador
+	int continue_counter_ = 10;								   // Contador para poder continuar
+	Uint32 continue_ticks_ = 0;								   // Variable para poder cambiar el contador de continue en función del tiempo
+	int scoreboard_panel_ = 0;								   // Panel del marcador asociado al jugador
+	std::string name_;										   // Nombre del jugador
+	std::string record_name_;								   // Nombre del jugador para la tabla de mejores puntuaciones
+	int controller_index_ = 0;								   // Indice del array de mandos que utilizará para moverse
+	bool demo_;												   // Para que el jugador sepa si está en el modo demostración
+	int enter_name_counter_;								   // Contador para poner nombre
+	Uint32 enter_name_ticks_ = 0;							   // Variable para poder cambiar el contador de poner nombre en función del tiempo
 
 	// Actualiza el circulo de colisión a la posición del jugador
 	void shiftColliders();
@@ -113,7 +113,7 @@ private:
 
 public:
 	// Constructor
-	Player(int id, float x, int y, bool demo, SDL_Rect *play_area, std::vector<std::shared_ptr<Texture>> texture, const 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, const std::vector<std::vector<std::string>> &animations);
 
 	// Destructor
 	~Player() = default;
@@ -256,12 +256,6 @@ public:
 	// Quita el toque extra al jugador
 	void removeExtraHit();
 
-	// Habilita la entrada de ordenes
-	void enableInput();
-
-	// Deshabilita la entrada de ordenes
-	void disableInput();
-
 	// Devuelve el número de cafes actuales
 	int getCoffees() const;
 

source/resource.cpp

@@ -1,7 +1,12 @@
-#include <iostream>
 #include "resource.h"
-#include "asset.h"
-#include "screen.h"
+#include <algorithm>    // Para find_if
+#include <iostream>     // Para basic_ostream, operator<<, endl, cout, cerr
+#include <stdexcept>    // Para runtime_error
+#include "asset.h"      // Para Asset, AssetType
+#include "jail_audio.h" // Para JA_LoadMusic, JA_LoadSound
+#include "screen.h"     // Para Screen
+struct JA_Music_t;
+struct JA_Sound_t;
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Resource *Resource::resource_ = nullptr;
@@ -51,13 +56,14 @@ Resource::~Resource()
 // Obtiene el sonido a partir de un nombre
 JA_Sound_t *Resource::getSound(const std::string &name)
 {
-    for (const auto &s : sounds_)
+    auto it = std::find_if(sounds_.begin(), sounds_.end(), [&name](const auto &s)
+                           { return s.name == name; });
+
+    if (it != sounds_.end())
     {
-        if (s.name == name)
-        {
-            return s.sound;
-        }
+        return it->sound;
     }
+
     std::cerr << "Error: Sonido no encontrado " << name << std::endl;
     throw std::runtime_error("Sonido no encontrado: " + name);
 }
@@ -65,13 +71,14 @@ JA_Sound_t *Resource::getSound(const std::string &name)
 // Obtiene la música a partir de un nombre
 JA_Music_t *Resource::getMusic(const std::string &name)
 {
-    for (const auto &m : musics_)
+    auto it = std::find_if(musics_.begin(), musics_.end(), [&name](const auto &m)
+                           { return m.name == name; });
+
+    if (it != musics_.end())
     {
-        if (m.name == name)
-        {
-            return m.music;
-        }
+        return it->music;
     }
+
     std::cerr << "Error: Música no encontrada " << name << std::endl;
     throw std::runtime_error("Música no encontrada: " + name);
 }
@@ -79,13 +86,14 @@ JA_Music_t *Resource::getMusic(const std::string &name)
 // Obtiene la textura a partir de un nombre
 std::shared_ptr<Texture> Resource::getTexture(const std::string &name)
 {
-    for (const auto &t : textures_)
+    auto it = std::find_if(textures_.begin(), textures_.end(), [&name](const auto &t)
+                           { return t.name == name; });
+
+    if (it != textures_.end())
     {
-        if (t.name == name)
-        {
-            return t.texture;
-        }
+        return it->texture;
     }
+
     std::cerr << "Error: Imagen no encontrada " << name << std::endl;
     throw std::runtime_error("Imagen no encontrada: " + name);
 }
@@ -93,27 +101,29 @@ std::shared_ptr<Texture> Resource::getTexture(const std::string &name)
 // Obtiene el fichero de texto a partir de un nombre
 std::shared_ptr<TextFile> Resource::getTextFile(const std::string &name)
 {
-    for (const auto &t : text_files_)
+    auto it = std::find_if(text_files_.begin(), text_files_.end(), [&name](const auto &t)
+                           { return t.name == name; });
+
+    if (it != text_files_.end())
     {
-        if (t.name == name)
-        {
-            return t.text_file;
-        }
+        return it->text_file;
     }
+
     std::cerr << "Error: TextFile no encontrado " << name << std::endl;
     throw std::runtime_error("TextFile no encontrado: " + name);
 }
 
 // Obtiene la animación a partir de un nombre
-Animations &Resource::getAnimation(const std::string &name)
+AnimationsFileBuffer &Resource::getAnimation(const std::string &name)
 {
-    for (auto &a : animations_)
+    auto it = std::find_if(animations_.begin(), animations_.end(), [&name](const auto &a)
+                           { return a.name == name; });
+
+    if (it != animations_.end())
     {
-        if (a.name == name)
-        {
-            return a.animation;
-        }
+        return it->animation;
     }
+
     std::cerr << "Error: Animación no encontrada " << name << std::endl;
     throw std::runtime_error("Animación no encontrada: " + name);
 }
@@ -128,19 +138,12 @@ DemoData &Resource::getDemoData(int index)
 void Resource::loadSounds()
 {
     std::cout << "\n>> SOUND FILES" << std::endl;
-
-    // Obtiene la lista con las rutas a los ficheros de sonidos
     auto list = Asset::get()->getListByType(AssetType::SOUND);
     sounds_.clear();
 
     for (const auto &l : list)
     {
-        // Encuentra el último índice de '/'
-        auto last_index = l.find_last_of('/') + 1;
-
-        // Obtiene la subcadena desde el último '/'
-        auto name = l.substr(last_index);
-
+        auto name = getFileName(l);
         sounds_.emplace_back(ResourceSound(name, JA_LoadSound(l.c_str())));
         printWithDots("Sound : ", name, "[ LOADED ]");
     }
@@ -150,19 +153,12 @@ void Resource::loadSounds()
 void Resource::loadMusics()
 {
     std::cout << "\n>> MUSIC FILES" << std::endl;
-
-    // Obtiene la lista con las rutas a los ficheros musicales
     auto list = Asset::get()->getListByType(AssetType::MUSIC);
     musics_.clear();
 
     for (const auto &l : list)
     {
-        // Encuentra el último índice de '/'
-        auto last_index = l.find_last_of('/') + 1;
-
-        // Obtiene la subcadena desde el último '/'
-        auto name = l.substr(last_index);
-
+        auto name = getFileName(l);
         musics_.emplace_back(ResourceMusic(name, JA_LoadMusic(l.c_str())));
         printWithDots("Music : ", name, "[ LOADED ]");
     }
@@ -172,19 +168,12 @@ void Resource::loadMusics()
 void Resource::loadTextures()
 {
     std::cout << "\n>> TEXTURES" << std::endl;
-
-    // Obtiene la lista con las rutas a los ficheros png
     auto list = Asset::get()->getListByType(AssetType::BITMAP);
     textures_.clear();
 
     for (const auto &l : list)
     {
-        // Encuentra el último índice de '/'
-        auto last_index = l.find_last_of('/') + 1;
-
-        // Obtiene la subcadena desde el último '/'
-        auto name = l.substr(last_index);
-
+        auto name = getFileName(l);
         textures_.emplace_back(ResourceTexture(name, std::make_shared<Texture>(Screen::get()->getRenderer(), l)));
     }
 }
@@ -193,18 +182,12 @@ void Resource::loadTextures()
 void Resource::loadTextFiles()
 {
     std::cout << "\n>> TEXT FILES" << std::endl;
-    // Obtiene la lista con las rutas a los ficheros png
     auto list = Asset::get()->getListByType(AssetType::FONT);
     text_files_.clear();
 
     for (const auto &l : list)
     {
-        // Encuentra el último índice de '/'
-        auto last_index = l.find_last_of('/') + 1;
-
-        // Obtiene la subcadena desde el último '/'
-        auto name = l.substr(last_index);
-
+        auto name = getFileName(l);
         text_files_.emplace_back(ResourceTextFile(name, loadTextFile(l)));
     }
 }
@@ -213,18 +196,12 @@ void Resource::loadTextFiles()
 void Resource::loadAnimations()
 {
     std::cout << "\n>> ANIMATIONS" << std::endl;
-    // Obtiene la lista con las rutas a los ficheros ani
     auto list = Asset::get()->getListByType(AssetType::ANIMATION);
     animations_.clear();
 
     for (const auto &l : list)
     {
-        // Encuentra el último índice de '/'
-        auto last_index = l.find_last_of('/') + 1;
-
-        // Obtiene la subcadena desde el último '/'
-        auto name = l.substr(last_index);
-
+        auto name = getFileName(l);
         animations_.emplace_back(ResourceAnimation(name, loadAnimationsFromFile(l)));
     }
 }

source/resource.h

@@ -1,14 +1,14 @@
 #pragma once
 
-#include <SDL2/SDL.h>
-#include <vector>
-#include <memory>
-#include <string>
-#include "jail_audio.h"
-#include "texture.h"
-#include "text.h"
-#include "utils.h"
-#include "animated_sprite.h"
+#include <memory>            // Para shared_ptr
+#include <string>            // Para string
+#include <vector>            // Para vector
+#include "animated_sprite.h" // Para AnimationsFileBuffer
+#include "text.h"            // Para TextFile
+#include "texture.h"         // Para Texture
+#include "utils.h"           // Para DemoData
+struct JA_Music_t;
+struct JA_Sound_t;
 
 // Estructura para almacenar ficheros de sonido y su nombre
 struct ResourceSound
@@ -57,11 +57,11 @@ struct ResourceTextFile
 // Estructura para almacenar ficheros animaciones y su nombre
 struct ResourceAnimation
 {
-    std::string name;     // Nombre del fichero
-    Animations animation; // Objeto con las animaciones
+    std::string name;               // Nombre del fichero
+    AnimationsFileBuffer animation; // Objeto con las animaciones
 
     // Constructor
-    ResourceAnimation(const std::string &name, Animations animation)
+    ResourceAnimation(const std::string &name, const AnimationsFileBuffer &animation)
         : name(name), animation(animation) {}
 };
 
@@ -130,7 +130,7 @@ public:
     std::shared_ptr<TextFile> getTextFile(const std::string &name);
 
     // Obtiene la animación a partir de un nombre
-    Animations &getAnimation(const std::string &name);
+    AnimationsFileBuffer &getAnimation(const std::string &name);
 
     // Obtiene el fichero con los datos para el modo demostración a partir de un çindice
     DemoData &getDemoData(int index);

source/scoreboard.cpp

@@ -1,17 +1,15 @@
 #include "scoreboard.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 <math.h>				// for roundf
-#include <iomanip>
-#include <sstream>
-#include "asset.h"	  // for Asset
-#include "lang.h"	  // for getText
-#include "resource.h" // for Resource
-#include "screen.h"
-#include "sprite.h"	 // for Sprite
-#include "text.h"	 // for Text
-#include "texture.h" // for Texture
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_pixels.h>	// Para SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_timer.h>		// Para SDL_GetTicks
+#include <math.h>				// Para roundf
+#include <iomanip>				// Para operator<<, setfill, setw
+#include <sstream>				// Para basic_ostream, basic_ostringstream
+#include "lang.h"				// Para getText
+#include "resource.h"			// Para Resource
+#include "screen.h"				// Para Screen
+#include "sprite.h"				// Para Sprite
+#include "text.h"				// Para Text
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Scoreboard *Scoreboard::scoreboard_ = nullptr;
@@ -37,19 +35,9 @@ Scoreboard *Scoreboard::get()
 // Constructor
 Scoreboard::Scoreboard()
 	: renderer_(Screen::get()->getRenderer()),
-
 	  game_power_meter_texture_(Resource::get()->getTexture("game_power_meter.png")),
 	  power_meter_sprite_(std::make_unique<Sprite>(game_power_meter_texture_)),
-	  text_scoreboard_(std::make_unique<Text>(Resource::get()->getTexture("8bithud.png"), Resource::get()->getTextFile("8bithud.txt"))),
-
-	  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)
+	  text_scoreboard_(std::make_unique<Text>(Resource::get()->getTexture("8bithud.png"), Resource::get()->getTextFile("8bithud.txt")))
 {
 	// Inicializa variables
 	for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
@@ -108,7 +96,9 @@ std::string Scoreboard::updateScoreText(int num)
 // Actualiza el contador
 void Scoreboard::updateCounter()
 {
-	if (SDL_GetTicks() - ticks_ > SCOREBOARD_TICK_SPEED_)
+	constexpr int TICKS_SPEED = 100;
+
+	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		ticks_ = SDL_GetTicks();
 		counter_++;

source/scoreboard.h

@@ -1,12 +1,13 @@
 #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 <memory>			 // for unique_ptr, shared_ptr
-#include <string>			 // for string
-#include <vector>			 // for vector
-#include "utils.h"			 // for Color
+#include <SDL2/SDL_rect.h>	 // para SDL_Point, SDL_Rect
+#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_stdinc.h> // para Uint32
+#include <SDL2/SDL_timer.h>	 // para SDL_GetTicks
+#include <memory>			 // para unique_ptr, shared_ptr
+#include <string>			 // para string
+#include <vector>			 // para vector
+#include "utils.h"			 // para Color
 class Sprite;
 class Text;
 class Texture;
@@ -41,9 +42,6 @@ struct Panel
 class Scoreboard
 {
 private:
-	// Constantes
-	static constexpr int SCOREBOARD_TICK_SPEED_ = 100;
-
 	// [SINGLETON] Objeto scoreboard privado para Don Melitón
 	static Scoreboard *scoreboard_;
 
@@ -54,25 +52,25 @@ private:
 	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
+	SDL_Texture *background_ = nullptr;		   // Textura para dibujar el marcador
 	std::vector<SDL_Texture *> panel_texture_; // Texturas para dibujar cada panel
 
 	// Variables
-	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
+	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_ = 1;										  // Número de fase actual
+	int hi_score_ = 0;									  // Máxima puntuación
+	float power_ = 0;									  // Poder actual de la fase
+	std::string hi_score_name_ = std::string();			  // Nombre del jugador con la máxima puntuación
+	Color color_ = Color();								  // Color del marcador
+	SDL_Rect rect_ = {0, 0, 320, 40};					  // Posición y dimensiones del marcador
+	Uint32 ticks_ = SDL_GetTicks();						  // Variable donde almacenar el valor de SDL_GetTiks()
+	int counter_ = 0;									  // Contador
 
 	// Puntos predefinidos para colocar elementos en los paneles
 	SDL_Point slot4_1_, slot4_2_, slot4_3_, slot4_4_;

source/screen.cpp

@@ -1,24 +1,23 @@
 #include "screen.h"
-#include <SDL2/SDL_events.h> // for SDL_DISABLE, SDL_ENABLE
-#include <SDL2/SDL_mouse.h>  // for SDL_ShowCursor
-#include <SDL2/SDL_pixels.h> // for SDL_PIXELFORMAT_RGBA8888
-#include <SDL2/SDL_timer.h>  // for SDL_GetTicks
-#include <algorithm>         // for max, min
-#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 "notifier.h"        // for Notify
-#include "on_screen_help.h"  // for OnScreenHelp
-#include "options.h"         // for options
-#include "param.h"           // for param
+#include <SDL2/SDL_events.h> // Para SDL_DISABLE, SDL_ENABLE
+#include <SDL2/SDL_mouse.h>  // Para SDL_ShowCursor
+#include <SDL2/SDL_pixels.h> // Para SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_timer.h>  // Para SDL_GetTicks
+#include <algorithm>         // Para clamp, max, min
+#include <fstream>           // Para basic_ifstream, ifstream
+#include <iterator>          // Para istreambuf_iterator, operator==
+#include <string>            // Para allocator, operator+, to_string, char_t...
+#include <vector>            // Para vector
+#include "asset.h"           // Para Asset
+#include "dbgtxt.h"          // Para dbg_print
+#include "global_inputs.h"   // Para service_pressed_counter
+#include "input.h"           // Para Input, InputType, INPUT_DO_NOT_ALLOW_RE...
+#include "notifier.h"        // Para Notifier
+#include "on_screen_help.h"  // Para OnScreenHelp
+#include "options.h"         // Para Options, OptionsVideo, options, Options...
 
 #ifndef NO_SHADERS
-#include "jail_shader.h" // for init, render
+#include "jail_shader.h" // para init, render
 #endif
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
@@ -46,36 +45,12 @@ Screen *Screen::get()
 Screen::Screen(SDL_Window *window, SDL_Renderer *renderer)
     : window_(window),
       renderer_(renderer),
-
       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
-      show_info_(true)
-#else
-      show_info_(false)
-#endif
+      dst_rect_({0, 0, param.game.width, param.game.height})
 {
     // 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);
     info_resolution_ = std::to_string(DM.w) + " X " + std::to_string(DM.h) + " AT " + std::to_string(DM.refresh_rate) + " HZ";
@@ -480,7 +455,9 @@ void Screen::displayInfo()
         // Resolution
         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);
+        // Contador de service_pressed_counter
+        if (const int counter = globalInputs::service_pressed_counter[0]; counter > 0)
+            dbg_print(0, 8, std::to_string(counter).c_str(), 255, 0, 255);
     }
 }
 

source/screen.h

@@ -1,13 +1,13 @@
 #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
-#include <memory>
+#include <SDL2/SDL_blendmode.h> // Para SDL_BlendMode
+#include <SDL2/SDL_rect.h>		// Para SDL_Rect, SDL_Point
+#include <SDL2/SDL_render.h>	// Para SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_stdinc.h>	// Para Uint32
+#include <SDL2/SDL_video.h>		// Para SDL_Window
+#include <string>				// Para string
+#include "param.h"				// Para Param, ParamGame, param
+#include "utils.h"				// Para Color
 
 enum class ScreenFilter : int
 {
@@ -34,15 +34,19 @@ private:
 	SDL_Texture *shader_canvas_; // Textura para pasarle al shader desde gameCanvas
 
 	// Variables
-	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
+	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();	// Color del borde añadido a la textura de juego para rellenar la pantalla
+	bool attenuate_effect_ = false; // Indica si la pantalla ha de estar atenuada
+	Uint32 fps_ticks_ = 0;			// Ticks para contar los frames por segundo
+	int fps_counter_ = 0;			// Contador de frames por segundo
+	int fps_ = 0;					// Frames calculados en el último segundo
+	std::string info_resolution_;	// Texto con la informacion de la pantalla
+#ifdef DEBUG
+	bool show_info_ = true; // Indica si ha de mostrar/ocultar la información de la pantalla
+#else
+	bool show_info_ = false; // Indica si ha de mostrar/ocultar la información de la pantalla
+#endif
 
 	struct FlashEffect
 	{
@@ -50,6 +54,10 @@ private:
 		int counter;  // Contador para el efecto
 		int lenght;	  // Duración del efecto
 		Color color;  // Color del efecto
+
+		// Constructor
+		explicit FlashEffect(bool en = false, int cnt = 0, int len = 0, Color col = Color(0xFF, 0xFF, 0xFF))
+			: enabled(en), counter(cnt), lenght(len), color(col) {}
 	};
 
 	struct ShakeEffect
@@ -62,6 +70,10 @@ private:
 		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
+
+		// Constructor
+		explicit ShakeEffect(bool en = false, int dp = 2, int dl = 3, int cnt = 0, int len = 8, int rem = 0, int origPos = 0, int origWidth = param.game.width)
+			: desp(dp), delay(dl), counter(cnt), lenght(len), remaining(rem), originalPos(origPos), originalWidth(origWidth), enabled(en) {}
 	};
 
 	// Variables - Efectos
@@ -111,7 +123,7 @@ public:
 	void checkInput();
 
 	// Limpia la pantalla
-	void clean(Color color = {0x00, 0x00, 0x00});
+	void clean(Color color = Color(0x00, 0x00, 0x00));
 
 	// Prepara para empezar a dibujar en la textura de juego
 	void start();

source/smart_sprite.cpp

@@ -1,22 +1,10 @@
 #include "smart_sprite.h"
-class Texture;
+#include "moving_sprite.h" // Para MovingSprite
+class Texture;			   // lines 2-2
 
 // Constructor
 SmartSprite::SmartSprite(std::shared_ptr<Texture> texture)
-	: AnimatedSprite(texture)
-{
-	init();
-}
-
-// Inicializa el objeto
-void SmartSprite::init()
-{
-	finished_counter_ = 0;
-	on_destination_ = false;
-	dest_x_ = dest_y_ = 0;
-	finished_ = false;
-	enabled_ = false;
-}
+	: AnimatedSprite(texture) {}
 
 // Actualiza la posición y comprueba si ha llegado a su destino
 void SmartSprite::update()
@@ -47,18 +35,6 @@ void SmartSprite::setDestY(int y)
 	dest_y_ = y;
 }
 
-// Obtiene el valor de la variable
-int SmartSprite::getDestX() const
-{
-	return dest_x_;
-}
-
-// Obtiene el valor de la variable
-int SmartSprite::getDestY() const
-{
-	return dest_y_;
-}
-
 // Comprueba el movimiento
 void SmartSprite::checkMove()
 {
@@ -152,6 +128,7 @@ bool SmartSprite::hasFinished() const
 	return finished_;
 }
 
+// Habilita el objeto
 void SmartSprite::setEnabled(bool value)
 {
 	enabled_ = value;

source/smart_sprite.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <memory>			 // for shared_ptr
-#include "animated_sprite.h" // for SpriteAnimated
+#include <memory>			 // para shared_ptr
+#include "animated_sprite.h" // para SpriteAnimated
 class Texture;
 
 // Clase SpriteSmart
@@ -9,12 +9,12 @@ class SmartSprite : public AnimatedSprite
 {
 private:
 	// Variables
-	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
+	bool on_destination_ = false; // Indica si está en el destino
+	int dest_x_ = 0;			  // Posicion de destino en el eje X
+	int dest_y_ = 0;			  // Posicion de destino en el eje Y
+	int finished_counter_ = 0;	  // Contador para deshabilitarlo
+	bool finished_ = false;		  // Indica si ya ha terminado
+	bool enabled_ = false;		  // Indica si el objeto está habilitado
 
 	// Comprueba si ha terminado
 	void checkFinished();
@@ -29,9 +29,6 @@ public:
 	// Destructor
 	~SmartSprite() = default;
 
-	// Inicializa el objeto
-	void init();
-
 	// Actualiza la posición y comprueba si ha llegado a su destino
 	void update() override;
 
@@ -56,5 +53,6 @@ public:
 	// Obtiene el valor de la variable
 	bool hasFinished() const;
 
+	// Habilita el objeto
 	void setEnabled(bool value);
 };

source/sprite.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h> // for SDL_Rect, SDL_Point
+#include <SDL2/SDL_rect.h> // para SDL_Rect, SDL_Point
 #include "texture.h"
 #include <memory>
 
@@ -20,7 +20,7 @@ public:
     explicit Sprite(std::shared_ptr<Texture>);
 
     // Destructor
-    ~Sprite() = default;
+    virtual ~Sprite() = default;
 
     // Muestra el sprite por pantalla
     virtual void render();

source/text.cpp

@@ -1,11 +1,11 @@
 #include "text.h"
-#include <SDL2/SDL_rect.h> // for SDL_Rect
-#include <fstream>		   // for basic_ostream, basic_ifstream, basic_istream
-#include <iostream>		   // for cout
-#include "resource.h"	   // for Resource
-#include "sprite.h"		   // for Sprite
-#include "texture.h"	   // for Texture
-#include "utils.h"		   // for Color
+#include <SDL2/SDL_rect.h> // Para SDL_Rect
+#include <fstream>		   // Para basic_ifstream, basic_istream, basic_ostream
+#include <iostream>		   // Para cerr
+#include <stdexcept>	   // Para runtime_error
+#include "sprite.h"		   // Para Sprite
+#include "texture.h"	   // Para Texture
+#include "utils.h"		   // Para Color, getFileName, printWithDots
 
 // Llena una estructuta TextFile desde un fichero
 std::shared_ptr<TextFile> loadTextFile(const std::string &file_path)
@@ -23,7 +23,6 @@ std::shared_ptr<TextFile> loadTextFile(const std::string &file_path)
 	}
 
 	// Abre el fichero para leer los valores
-	const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1).c_str();
 	std::ifstream file(file_path);
 
 	if (file.is_open() && file.good())
@@ -56,15 +55,15 @@ std::shared_ptr<TextFile> loadTextFile(const std::string &file_path)
 		};
 
 		// Cierra el fichero
-		printWithDots("Text File : ", file_name, "[ LOADED ]");
+		printWithDots("Text File : ", getFileName(file_path), "[ LOADED ]");
 		file.close();
 	}
 
 	// El fichero no se puede abrir
 	else
 	{
-		std::cerr << "Error: Fichero no encontrado " << file_path << std::endl;
-		throw std::runtime_error("Fichero no encontrado: " + file_path);
+		std::cerr << "Error: Fichero no encontrado " << getFileName(file_path) << std::endl;
+		throw std::runtime_error("Fichero no encontrado: " + getFileName(file_path));
 	}
 
 	// Establece las coordenadas para cada caracter ascii de la cadena y su ancho

source/text.h

@@ -1,12 +1,11 @@
 #pragma once
 
-#include <SDL2/SDL_render.h> // for SDL_Renderer
-#include <SDL2/SDL_stdinc.h> // for Uint8
-#include <memory>			 // for shared_ptr, unique_ptr
-#include <string>			 // for string
-#include "sprite.h"			 // for Sprite
-#include "utils.h"			 // for Color
-class Texture;
+#include <SDL2/SDL_stdinc.h> // Para Uint8
+#include <memory>			 // Para unique_ptr, shared_ptr
+#include <string>			 // Para string
+#include "sprite.h"			 // Para Sprite
+#include "utils.h"			 // Para Color
+class Texture;				 // lines 9-9
 
 constexpr int TEXT_COLOR = 1;
 constexpr int TEXT_SHADOW = 2;
@@ -33,13 +32,13 @@ class Text
 {
 private:
 	// Objetos y punteros
-	std::unique_ptr<Sprite> sprite_;   // Objeto con los graficos para el texto
+	std::unique_ptr<Sprite> sprite_ = nullptr; // Objeto con los graficos para el texto
 
 	// Variables
-	int box_width_;			 // Anchura de la caja de cada caracter en el png
-	int box_height_;		 // Altura de la caja de cada caracter en el png
-	bool fixed_width_;		 // Indica si el texto se ha de escribir con longitud fija en todas las letras
-	TextOffset offset_[128]; // Vector con las posiciones y ancho de cada letra
+	int box_width_ = 0;			  // Anchura de la caja de cada caracter en el png
+	int box_height_ = 0;		  // Altura de la caja de cada caracter en el png
+	bool fixed_width_ = false;	  // Indica si el texto se ha de escribir con longitud fija en todas las letras
+	TextOffset offset_[128] = {}; // Vector con las posiciones y ancho de cada letra
 
 public:
 	// Constructor

source/texture.cpp

@@ -1,27 +1,23 @@
 
 #include "texture.h"
-#include "utils.h"
-#include <SDL2/SDL_error.h>	  // for SDL_GetError
-#include <SDL2/SDL_surface.h> // for SDL_CreateRGBSurfaceWithFormatFrom
-#include <fcntl.h>			  // for SEEK_END, SEEK_SET
-#include <stdio.h>			  // for fseek, fclose, fopen, fread, ftell, NULL
-#include <stdlib.h>			  // for malloc, free, exit
-#include <iostream>			  // for basic_ostream, operator<<, cout, endl
-#include <fstream>
-#include <sstream>
-#include "gif.c" // for LoadGif, LoadPalette
+#include <SDL2/SDL_error.h>	  // Para SDL_GetError
+#include <SDL2/SDL_surface.h> // Para SDL_CreateRGBSurfaceWithFormatFrom
+#include <fcntl.h>			  // Para SEEK_END, SEEK_SET
+#include <stdio.h>			  // Para fseek, fclose, fopen, fread, ftell, FILE
+#include <stdlib.h>			  // Para free, malloc
+#include <fstream>			  // Para basic_ostream, operator<<, basic_ifstream
+#include <iostream>			  // Para cerr, cout
+#include <stdexcept>		  // Para runtime_error
+#include "gif.c"			  // Para LoadGif, LoadPalette
+#include "utils.h"			  // Para getFileName, printWithDots
+
 #define STB_IMAGE_IMPLEMENTATION
-#include "stb_image.h" // for stbi_failure_reason, stbi_image_free
+#include "stb_image.h" // para stbi_failure_reason, stbi_image_free
 
 // Constructor
 Texture::Texture(SDL_Renderer *renderer, const std::string &path)
-	: texture_(nullptr),
-	  renderer_(renderer),
-	  surface_(nullptr),
-	  width_(0),
-	  height_(0),
-	  path_(path),
-	  current_palette_(0)
+	: renderer_(renderer),
+	  path_(path)
 {
 	// Carga el fichero en la textura
 	if (!path_.empty())
@@ -40,10 +36,10 @@ Texture::Texture(SDL_Renderer *renderer, const std::string &path)
 		{
 			// Crea la surface desde un fichero
 			surface_ = loadSurface(path_);
-			
+
 			// Añade la propia paleta del fichero a la lista
-			addPaletteFromFile(path_); 
-			//setPaletteColor(0, 0, 0x00000000);
+			addPaletteFromFile(path_);
+			// setPaletteColor(0, 0, 0x00000000);
 
 			// Crea la textura, establece el BlendMode y copia la surface a la textura
 			createBlank(width_, height_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING);
@@ -69,13 +65,12 @@ bool Texture::loadFromFile(const std::string &file_path)
 	unsigned char *data = stbi_load(file_path.c_str(), &width, &height, &orig_format, req_format);
 	if (!data)
 	{
-		std::cerr << "Error: Fichero no encontrado " << file_path << std::endl;
-		throw std::runtime_error("Fichero no encontrado: " + file_path);
+		std::cerr << "Error: Fichero no encontrado " << getFileName(file_path) << std::endl;
+		throw std::runtime_error("Fichero no encontrado: " + getFileName(file_path));
 	}
 	else
 	{
-		const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
-		printWithDots("Image : ", file_name, "[ LOADED ]");
+		printWithDots("Image : ", getFileName(file_path), "[ LOADED ]");
 	}
 
 	int depth, pitch;
@@ -320,13 +315,12 @@ std::vector<Uint32> Texture::loadPaletteFromFile(const std::string &file_path)
 	FILE *f = fopen(file_path.c_str(), "rb");
 	if (!f)
 	{
-		std::cerr << "Error: Fichero no encontrado " << file_path << std::endl;
-		throw std::runtime_error("Fichero no encontrado: " + file_path);
+		std::cerr << "Error: Fichero no encontrado " << getFileName(file_path) << std::endl;
+		throw std::runtime_error("Fichero no encontrado: " + getFileName(file_path));
 	}
 	else
 	{
-		const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
-		printWithDots("Image : ", file_name, "[ LOADED ]");
+		printWithDots("Image : ", getFileName(file_path), "[ LOADED ]");
 	}
 
 	fseek(f, 0, SEEK_END);

source/texture.h

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <SDL2/SDL_blendmode.h> // for SDL_BlendMode
-#include <SDL2/SDL_pixels.h>    // for SDL_PIXELFORMAT_RGBA8888, SDL_PixelF...
-#include <SDL2/SDL_rect.h>      // for SDL_Point, SDL_Rect
-#include <SDL2/SDL_render.h>    // for SDL_Renderer, SDL_FLIP_NONE, SDL_TEX...
-#include <SDL2/SDL_stdinc.h>    // for Uint8, Uint32, Uint16
-#include <string>               // for string, basic_string
-#include <vector>               // for vector
+#include <SDL2/SDL_blendmode.h> // para SDL_BlendMode
+#include <SDL2/SDL_pixels.h>    // para SDL_PIXELFORMAT_RGBA8888, SDL_PixelF...
+#include <SDL2/SDL_rect.h>      // para SDL_Point, SDL_Rect
+#include <SDL2/SDL_render.h>    // para SDL_Renderer, SDL_FLIP_NONE, SDL_TEX...
+#include <SDL2/SDL_stdinc.h>    // para Uint8, Uint32, Uint16
+#include <string>               // para string, basic_string
+#include <vector>               // para vector
 #include <memory>
 
 // Definiciones de tipos
@@ -24,16 +24,16 @@ class Texture
 {
 private:
     // Objetos y punteros
-    SDL_Texture *texture_;             // La textura
-    SDL_Renderer *renderer_;           // Renderizador donde dibujar la textura
-    std::shared_ptr<Surface> surface_; // Surface para usar imagenes en formato gif con paleta
+    SDL_Renderer *renderer_;                     // Renderizador donde dibujar la textura
+    SDL_Texture *texture_ = nullptr;             // La textura
+    std::shared_ptr<Surface> surface_ = nullptr; // Surface para usar imagenes en formato gif con paleta
 
     // Variables
-    int width_;                                 // Ancho de la imagen
-    int height_;                                // Alto de la imagen
     std::string path_;                          // Ruta de la imagen de la textura
+    int width_ = 0;                             // Ancho de la imagen
+    int height_ = 0;                            // Alto de la imagen
     std::vector<std::vector<Uint32>> palettes_; // Vector con las diferentes paletas
-    int current_palette_;                       // Indice de la paleta en uso
+    int current_palette_ = 0;                   // Indice de la paleta en uso
 
     // Crea una surface desde un fichero .gif
     std::shared_ptr<Surface> loadSurface(const std::string &file_name);

source/tiled_bg.cpp

@@ -1,18 +1,19 @@
 #include "tiled_bg.h"
-#include <SDL2/SDL_pixels.h> // for SDL_PIXELFORMAT_RGBA8888
-#include <stdlib.h>          // for rand
-#include <memory>            // for unique_ptr, make_shared, make_unique
-#include <cmath>             // for sinf
-#include "resource.h"        // for Resource
-#include "screen.h"          // for Screen
-#include "sprite.h"          // for Sprite
-#include "texture.h"         // for Texture
+#include <SDL2/SDL_pixels.h> // Para SDL_PIXELFORMAT_RGBA8888
+#include <stdlib.h>          // Para rand
+#include <cmath>             // Para sin
+#include <memory>            // Para unique_ptr, make_unique
+#include "resource.h"        // Para Resource
+#include "screen.h"          // Para Screen
+#include "sprite.h"          // Para Sprite
 
 // Constructor
 TiledBG::TiledBG(SDL_Rect pos, TiledBGMode mode)
     : renderer_(Screen::get()->getRenderer()),
       pos_(pos),
-      counter_(0),
+      // Coloca la ventana que recorre el mosaico de fondo de manera que coincida
+      // con el mosaico que hay pintado en el titulo al iniciar
+      window_({128, 96, pos_.w, pos_.h}),
       mode_(mode == TiledBGMode::RANDOM ? static_cast<TiledBGMode>(rand() % 2) : mode)
 {
     // Crea la textura para el mosaico de fondo
@@ -21,10 +22,6 @@ TiledBG::TiledBG(SDL_Rect pos, TiledBGMode mode)
     // Rellena la textura con el contenido
     fillTexture();
 
-    // Coloca la ventana que recorre el mosaico de fondo de manera que coincida
-    // con el mosaico que hay pintado en el titulo al iniciar
-    window_ = {128, 96, pos_.w, pos_.h};
-
     // Inicializa los valores del vector con los valores del seno
     for (int i = 0; i < 360; ++i)
     {

source/tiled_bg.h

@@ -1,8 +1,7 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>   // for SDL_Rect
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
-#include <string>            // for string, basic_string
+#include <SDL2/SDL_rect.h>   // Para SDL_Rect
+#include <SDL2/SDL_render.h> // Para SDL_Renderer, SDL_Texture
 
 // Modos de funcionamiento para el tileado de fondo
 enum class TiledBGMode : int
@@ -29,12 +28,12 @@ private:
 
     // Objetos y punteros
     SDL_Renderer *renderer_; // El renderizador de la ventana
-    SDL_Rect window_;        // Ventana visible para la textura de fondo del titulo
     SDL_Texture *canvas_;    // Textura donde dibujar el fondo formado por tiles
 
     // Variables
     SDL_Rect pos_;     // Posición y tamaño del mosaico
-    int counter_;      // Contador
+    SDL_Rect window_;  // Ventana visible para la textura de fondo del titulo
+    int counter_ = 0;  // Contador
     TiledBGMode mode_; // Tipo de movimiento del mosaico
     double sin_[360];  // Vector con los valores del seno precalculados
 

source/title.cpp

@@ -1,26 +1,29 @@
 #include "title.h"
-#include <SDL2/SDL_events.h>  // for SDL_PollEvent, SDL_Event, SDL_KEYDOWN
-#include <SDL2/SDL_keycode.h> // for SDLK_1, SDLK_2, SDLK_3
-#include <SDL2/SDL_rect.h>	  // for SDL_Rect
-#include <SDL2/SDL_render.h>  // for SDL_Renderer
-#include <SDL2/SDL_timer.h>	  // for SDL_GetTicks
-#include <string>			  // for char_traits, operator+, to_string, bas...
-#include <utility>			  // for move
-#include <vector>			  // for vector
-#include "asset.h"			  // for Asset
-#include "global_inputs.h"	  // for check
-#include "input.h"			  // for Input, InputType, INPUT_DO_NOT_ALLOW_R...
-#include "jail_audio.h"		  // for JA_GetMusicState, JA_Music_state, JA_P...
-#include "lang.h"			  // for getText
-#include "notifier.h"		  // for Notifier
-#include "options.h"		  // for options
-#include "param.h"			  // for param
-#include "resource.h"		  // for Resource
-#include "screen.h"			  // for Screen
-#include "section.h"		  // for Options, options, Name, name
-#include "texture.h"		  // for Texture
-#include "utils.h"			  // for Param, OptionsController, Color, Param...
-struct JA_Music_t;			  // lines 17-17
+#include <SDL2/SDL_events.h>  // Para SDL_PollEvent, SDL_Event, SDL_KEYDOWN
+#include <SDL2/SDL_keycode.h> // Para SDLK_1, SDLK_2, SDLK_3
+#include <SDL2/SDL_rect.h>	  // Para SDL_Rect
+#include <SDL2/SDL_timer.h>	  // Para SDL_GetTicks
+#include <string>			  // Para char_traits, operator+, to_string, bas...
+#include <utility>			  // Para move
+#include <vector>			  // Para vector
+#include "define_buttons.h"	  // Para DefineButtons
+#include "fade.h"			  // Para Fade, FadeType
+#include "game_logo.h"		  // Para GameLogo
+#include "global_inputs.h"	  // Para check
+#include "input.h"			  // Para Input, InputType, INPUT_DO_NOT_ALLOW_R...
+#include "jail_audio.h"		  // Para JA_GetMusicState, JA_Music_state, JA_P...
+#include "lang.h"			  // Para getText
+#include "notifier.h"		  // Para Notifier
+#include "options.h"		  // Para OptionsController, Options, options
+#include "param.h"			  // Para Param, param, ParamGame, ParamTitle
+#include "resource.h"		  // Para Resource
+#include "screen.h"			  // Para Screen
+#include "section.h"		  // Para Options, options, name, Name
+#include "sprite.h"			  // Para Sprite
+#include "text.h"			  // Para Text, TEXT_CENTER, TEXT_SHADOW
+#include "texture.h"		  // Para Texture
+#include "tiled_bg.h"		  // Para TiledBG, TiledBGMode
+#include "utils.h"			  // Para Color, Zone, fade_color, no_color, BLOCK
 
 // Constructor
 Title::Title()
@@ -32,11 +35,6 @@ Title::Title()
 	  mini_logo_texture_(Resource::get()->getTexture("logo_jailgames_mini.png")),
 	  mini_logo_sprite_(std::make_unique<Sprite>(mini_logo_texture_, param.game.game_area.center_x - mini_logo_texture_->getWidth() / 2, 0, mini_logo_texture_->getWidth(), mini_logo_texture_->getHeight())),
 	  define_buttons_(std::make_unique<DefineButtons>(std::move(text2_))),
-	  counter_(0),
-	  ticks_(0),
-	  demo_(true),
-	  next_section_(section::Name::GAME),
-	  post_fade_(0),
 	  num_controllers_(Input::get()->getNumControllers())
 {
 	// Configura objetos
@@ -59,8 +57,9 @@ Title::~Title()
 // Actualiza las variables del objeto
 void Title::update()
 {
-	// Calcula la lógica de los objetos
-	if (SDL_GetTicks() - ticks_ > TICKS_SPEED_)
+	constexpr int TICKS_SPEED = 15;
+
+	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		// Actualiza el contador de ticks_
 		ticks_ = SDL_GetTicks();
@@ -74,7 +73,7 @@ void Title::update()
 		{
 			if (post_fade_ == -1)
 			{
-				section::name = section::Name::GAME_DEMO;
+				section::name = next_section_;
 			}
 			else
 			{
@@ -138,7 +137,7 @@ void Title::render()
 
 	if (section::options == section::Options::TITLE_2)
 	{
-		constexpr Color shadow = {0x14, 0x87, 0xc4};
+		constexpr Color shadow = Color(0x14, 0x87, 0xc4);
 
 		// 'PRESS TO PLAY'
 		if (counter_ % 50 > 14 && !define_buttons_->isEnabled())