canvi de pc

Actualitzat el numero de versió a 1.10

Makefile

@@ -2,7 +2,7 @@ executable = jaildoctors_dilemma
 source = source/*.cpp
 appName = JailDoctor's Dilemma
 releaseFolder = jdd_release
-version = v1.09
+version = v1.10
 
 # Release names
 windowsRelease = $(executable)-$(version)-win32-x64.zip
@@ -90,7 +90,7 @@ macos_release:
 	ln -s /Applications "$(releaseFolder)"/Applications
 
 # Build INTEL
-	clang++ $(source) -D MACOS_BUNDLE -std=$(cpp_standard) -Wall -Os -framework SDL2 -F ./Frameworks -framework OpenGL -Wno-deprecated  -ffunction-sections -fdata-sections -o "$(releaseFolder)/$(appName).app/Contents/MacOS/$(executable)" -rpath @executable_path/../Frameworks/ -target x86_64-apple-macos10.12
+	clang++ $(source) -D MACOS_BUNDLE -std=$(cpp_standard) -Wall -Os -framework SDL2 -F ./Frameworks -framework OpenGL -Wno-deprecated  -ffunction-sections -fdata-sections -o "$(releaseFolder)/$(appName).app/Contents/MacOS/$(executable)" -rpath @executable_path/../Frameworks/ -target x86_64-apple-macos10.15
 
 # Build INTEL DMG
 	hdiutil create tmp.dmg -ov -volname "$(appName)" -fs HFS+ -srcfolder "$(releaseFolder)" 

release/Info.plist

@@ -23,11 +23,11 @@
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.09</string>
+	<string>1.10</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>
-	<string>1.09</string>
+	<string>1.10</string>
 	<key>CSResourcesFileMapped</key>
 	<true/>
 	<key>LSMinimumSystemVersion</key>

source/cheevos.cpp

@@ -77,31 +77,31 @@ int Cheevos::find(int id)
 // Desbloquea un logro
 void Cheevos::unlock(int id)
 {
-    const int index = find(id);
+    const int INDEX = find(id);
 
     // Si el índice es inválido, el logro no es válido, ya está completado o el sistema de logros no está habilitado, no hacemos nada
-    if (index == -1 || !cheevos_list_.at(index).valid || cheevos_list_.at(index).completed || !enabled_)
+    if (INDEX == -1 || !cheevos_list_.at(INDEX).obtainable || cheevos_list_.at(INDEX).completed || !enabled_)
     {
         return;
     }
 
     // Marcar el logro como completado
-    cheevos_list_.at(index).completed = true;
+    cheevos_list_.at(INDEX).completed = true;
     // Mostrar notificación en la pantalla
-    Notifier::get()->show({"ACHIEVEMENT UNLOCKED!", cheevos_list_.at(index).caption}, NotificationText::LEFT, cheevos_list_.at(index).icon);
+    Notifier::get()->show({"ACHIEVEMENT UNLOCKED!", cheevos_list_.at(INDEX).caption}, NotificationText::LEFT, cheevos_list_.at(INDEX).icon);
     // Guardar el estado de los logros
     saveToFile();
 }
 
 // Invalida un logro
-void Cheevos::invalidate(int id)
+void Cheevos::setUnobtainable(int id)
 {
     const int index = find(id);
 
     // Si el índice es válido, se invalida el logro
     if (index != -1)
     {
-        cheevos_list_.at(index).valid = false;
+        cheevos_list_.at(index).obtainable = false;
     }
 }
 
@@ -184,10 +184,10 @@ void Cheevos::saveToFile()
 }
 
 // Devuelve el número total de logros desbloqueados
-int Cheevos::unlocked()
+int Cheevos::getTotalUnlockedAchievements()
 {
     int count = 0;
-    for (auto cheevo : cheevos_list_)
+    for (const auto &cheevo : cheevos_list_)
     {
         if (cheevo.completed)
         {
@@ -196,3 +196,12 @@ int Cheevos::unlocked()
     }
     return count;
 }
+
+// Elimina el estado "no obtenible"
+void Cheevos::clearUnobtainableState()
+{
+    for (auto &cheevo : cheevos_list_)
+    {
+        cheevo.obtainable = true;
+    }
+}

source/cheevos.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <string>  // for string
-#include <vector>  // for vector
+#include <string> // for string
+#include <vector> // for vector
 
 // Struct para los logros
 struct Achievement
@@ -11,14 +11,14 @@ struct Achievement
 	std::string description; // Texto que describe el logro
 	int icon;				 // Indice del icono a utilizar en la notificación
 	bool completed;			 // Indica si se ha obtenido el logro
-	bool valid;				 // Indica si se puede obtener el logro
+	bool obtainable;		 // Indica si se puede obtener el logro
 
 	// Constructor vacío
-	Achievement() : id(0), icon(0), completed(false), valid(true) {}
+	Achievement() : id(0), icon(0), completed(false), obtainable(true) {}
 
 	// Constructor parametrizado
-	Achievement(int id, const std::string &caption, const std::string &description, int icon, bool completed = false, bool valid = true)
-		: id(id), caption(caption), description(description), icon(icon), completed(completed), valid(valid) {}
+	Achievement(int id, const std::string &caption, const std::string &description, int icon, bool completed = false, bool obtainable = true)
+		: id(id), caption(caption), description(description), icon(icon), completed(completed), obtainable(obtainable) {}
 };
 
 class Cheevos
@@ -45,7 +45,7 @@ private:
 	void saveToFile();
 
 	// Constructor
-	Cheevos(const std::string &file);
+	explicit Cheevos(const std::string &file);
 
 	// Destructor
 	~Cheevos();
@@ -64,7 +64,10 @@ public:
 	void unlock(int id);
 
 	// Invalida un logro
-	void invalidate(int id);
+	void setUnobtainable(int id);
+
+	// Elimina el estado "no obtenible"
+	void clearUnobtainableState();
 
 	// Habilita o deshabilita los logros
 	void enable(bool value) { enabled_ = value; }
@@ -73,8 +76,8 @@ public:
 	std::vector<Achievement> list() { return cheevos_list_; }
 
 	// Devuelve el número total de logros desbloqueados
-	int unlocked();
+	int getTotalUnlockedAchievements();
 
 	// Devuelve el número total de logros
-	int count() { return cheevos_list_.size(); }
+	int size() { return cheevos_list_.size(); }
 };

source/credits.cpp

@@ -20,15 +20,9 @@
 
 // Constructor
 Credits::Credits()
-	: screen_(Screen::get()),
-	  renderer_(Screen::get()->getRenderer()),
-	  resource_(Resource::get()),
-	  asset_(Asset::get()),
-	  input_(Input::get())
 {
 	// Reserva memoria para los punteros
-	text_ = resource_->getText("smb2");
-	sprite_ = std::make_shared<AnimatedSprite>(resource_->getTexture("shine.png"), resource_->getAnimations("shine.ani"));
+	sprite_ = std::make_shared<AnimatedSprite>(Resource::get()->getTexture("shine.png"), Resource::get()->getAnimations("shine.ani"));
 
 	// Inicializa variables
 	options.section.section = Section::CREDITS;
@@ -36,10 +30,10 @@ Credits::Credits()
 	sprite_->setPosition({194, 174, 8, 8});
 
 	// Cambia el color del borde
-	screen_->setBorderColor(stringToColor(options.video.palette, "black"));
+	Screen::get()->setBorderColor(stringToColor(options.video.palette, "black"));
 
 	// Crea la textura para el texto que se escribe en pantalla
-	text_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT);
+	text_texture_ = SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT);
 	if (text_texture_ == nullptr)
 	{
 		if (options.console)
@@ -50,7 +44,7 @@ Credits::Credits()
 	SDL_SetTextureBlendMode(text_texture_, SDL_BLENDMODE_BLEND);
 
 	// Crea la textura para cubrir el rexto
-	cover_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT);
+	cover_texture_ = SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT);
 	if (cover_texture_ == nullptr)
 	{
 		if (options.console)
@@ -90,21 +84,24 @@ void Credits::checkInput()
 // Inicializa los textos
 void Credits::iniTexts()
 {
+#ifndef GAME_CONSOLE
 	std::string keys = "";
-	if (options.keys == ControlScheme::CURSOR)
+
+	switch (options.keys)
 	{
+	case ControlScheme::CURSOR:
 		keys = "CURSORS";
-	}
-	else if (options.keys == ControlScheme::OPQA)
-	{
+		break;
+	case ControlScheme::OPQA:
 		keys = "O,P AND Q";
-	}
-	else
-	{
+		break;
+	case ControlScheme::WASD:
 		keys = "A,D AND W";
+		break;
+	default:
+		break;
 	}
 
-#ifndef GAME_CONSOLE
 	texts_.clear();
 	texts_.push_back({"", stringToColor(options.video.palette, "white")});
 	texts_.push_back({"INSTRUCTIONS:", stringToColor(options.video.palette, "yellow")});
@@ -172,54 +169,56 @@ void Credits::fillTexture()
 	iniTexts();
 
 	// Rellena la textura de texto
-	SDL_SetRenderTarget(renderer_, text_texture_);
-	Color c = stringToColor(options.video.palette, "black");
-	SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
-	SDL_RenderClear(renderer_);
+	SDL_SetRenderTarget(Screen::get()->getRenderer(), text_texture_);
+	Color color = stringToColor(options.video.palette, "black");
+	SDL_SetRenderDrawColor(Screen::get()->getRenderer(), color.r, color.g, color.b, 0xFF);
+	SDL_RenderClear(Screen::get()->getRenderer());
+
+	auto text = Resource::get()->getText("smb2");
 
 	// Escribe el texto en la textura
-	const int size = text_->getCharacterSize();
-	int i = 0;
+	const int SIZE = text->getCharacterSize();
+	int pos_y = 0;
 
-	for (auto t : texts_)
+	for (const auto &t : texts_)
 	{
-		text_->writeDX(TEXT_CENTER | TEXT_COLOR, PLAY_AREA_CENTER_X, i * size, t.label, 1, t.color);
-		i++;
+		text->writeDX(TEXT_CENTER | TEXT_COLOR, PLAY_AREA_CENTER_X, pos_y * SIZE, t.label, 1, t.color);
+		pos_y++;
 	}
 
 	// Escribe el corazón
-	const int textLenght = text_->lenght(texts_[22].label, 1) - text_->lenght(" ", 1); // Se resta el ultimo caracter que es un espacio
-	const int posX = ((PLAY_AREA_WIDTH - textLenght) / 2) + textLenght;
-	text_->writeColored(posX, 176, "}", stringToColor(options.video.palette, "bright_red"));
+	const int TEXT_LENGHT = text->lenght(texts_[22].label, 1) - text->lenght(" ", 1); // Se resta el ultimo caracter que es un espacio
+	const int POS_X = ((PLAY_AREA_WIDTH - TEXT_LENGHT) / 2) + TEXT_LENGHT;
+	text->writeColored(POS_X, 176, "}", stringToColor(options.video.palette, "bright_red"));
 
 	// Recoloca el sprite del brillo
-	sprite_->setPosX(posX + 2);
+	sprite_->setPosX(POS_X + 2);
 
-	SDL_SetRenderTarget(renderer_, nullptr);
+	SDL_SetRenderTarget(Screen::get()->getRenderer(), nullptr);
 
 	// Rellena la textura que cubre el texto con color transparente
-	SDL_SetRenderTarget(renderer_, cover_texture_);
-	SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0x00);
-	SDL_RenderClear(renderer_);
+	SDL_SetRenderTarget(Screen::get()->getRenderer(), cover_texture_);
+	SDL_SetRenderDrawColor(Screen::get()->getRenderer(), color.r, color.g, color.b, 0x00);
+	SDL_RenderClear(Screen::get()->getRenderer());
 
 	// Los primeros 8 pixels crea una malla
-	SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
+	SDL_SetRenderDrawColor(Screen::get()->getRenderer(), color.r, color.g, color.b, 0xFF);
 	for (int i = 0; i < 256; i += 2)
 	{
-		SDL_RenderDrawPoint(renderer_, i, 0);
-		SDL_RenderDrawPoint(renderer_, i, 2);
-		SDL_RenderDrawPoint(renderer_, i, 4);
-		SDL_RenderDrawPoint(renderer_, i, 6);
+		SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 0);
+		SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 2);
+		SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 4);
+		SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 6);
 
-		SDL_RenderDrawPoint(renderer_, i + 1, 5);
-		SDL_RenderDrawPoint(renderer_, i + 1, 7);
+		SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 1, 5);
+		SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 1, 7);
 	}
 
 	// El resto se rellena de color sólido
 	SDL_Rect rect = {0, 8, 256, 192};
-	SDL_RenderFillRect(renderer_, &rect);
+	SDL_RenderFillRect(Screen::get()->getRenderer(), &rect);
 
-	SDL_SetRenderTarget(renderer_, nullptr);
+	SDL_SetRenderTarget(Screen::get()->getRenderer(), nullptr);
 }
 
 // Actualiza el contador
@@ -266,7 +265,7 @@ void Credits::update()
 		// Actualiza el contador
 		updateCounter();
 
-		screen_->update();
+		Screen::get()->update();
 
 		// Actualiza el sprite con el brillo
 		if (counter_ > 770)
@@ -280,28 +279,28 @@ void Credits::update()
 void Credits::render()
 {
 	// Prepara para empezar a dibujar en la textura de juego
-	screen_->start();
+	Screen::get()->start();
 
 	// Limpia la pantalla
-	screen_->clean();
+	Screen::get()->clean();
 
 	if (counter_ < 1150)
 	{
 		// Dibuja la textura con el texto en pantalla
-		SDL_RenderCopy(renderer_, text_texture_, nullptr, nullptr);
+		SDL_RenderCopy(Screen::get()->getRenderer(), text_texture_, nullptr, nullptr);
 
 		// Dibuja la textura que cubre el texto
 		const int offset = std::min(counter_ / 8, 192 / 2);
 		SDL_Rect srcRect = {0, 0, 256, 192 - (offset * 2)};
 		SDL_Rect dstRect = {0, offset * 2, 256, 192 - (offset * 2)};
-		SDL_RenderCopy(renderer_, cover_texture_, &srcRect, &dstRect);
+		SDL_RenderCopy(Screen::get()->getRenderer(), cover_texture_, &srcRect, &dstRect);
 
 		// Dibuja el sprite con el brillo
 		sprite_->render();
 	}
 
 	// Vuelca el contenido del renderizador en pantalla
-	screen_->render();
+	Screen::get()->render();
 }
 
 // Bucle para el logo del juego
@@ -314,10 +313,3 @@ void Credits::run()
 		render();
 	}
 }
-
-// Cambia la paleta
-void Credits::switchPalette()
-{
-	options.video.palette = options.video.palette == Palette::ZXSPECTRUM ? Palette::ZXARNE : Palette::ZXSPECTRUM;
-	fillTexture();
-}

source/credits.h

@@ -1,44 +1,38 @@
 #pragma once
 
-#include <SDL2/SDL_render.h>  // for SDL_Texture, SDL_Renderer
-#include <SDL2/SDL_stdinc.h>  // for Uint32
-#include <memory>             // for shared_ptr
-#include <string>             // for string
-#include <vector>             // for vector
-#include "utils.h"            // for Color
-class AnimatedSprite;  // lines 10-10
-class Asset;  // lines 11-11
-class Input;  // lines 12-12
-class Resource;  // lines 13-13
-class Screen;  // lines 14-14
-class Text;  // lines 15-15
+#include <SDL2/SDL_render.h> // for SDL_Texture, SDL_Renderer
+#include <SDL2/SDL_stdinc.h> // for Uint32
+#include <memory>			 // for shared_ptr
+#include <string>			 // for string
+#include <vector>			 // for vector
+#include "utils.h"			 // for Color
+class AnimatedSprite;		 // lines 10-10
+class Asset;				 // lines 11-11
+class Input;				 // lines 12-12
+class Resource;				 // lines 13-13
+class Screen;				 // lines 14-14
+class Text;					 // lines 15-15
 
 class Credits
 {
 private:
-	struct captions_t
+	struct Captions
 	{
 		std::string label; // Texto a escribir
 		Color color;	   // Color del texto
 	};
 
 	// Objetos y punteros
-	Screen *screen_;						 // Objeto encargado de dibujar en pantalla
-	SDL_Renderer *renderer_;				 // El renderizador de la ventana
-	Resource *resource_;					 // Objeto con los recursos
-	Asset *asset_;							 // Objeto con los ficheros de recursos
-	Input *input_;							 // Objeto pata gestionar la entrada
-	std::shared_ptr<Text> text_;			 // Objeto para escribir texto en pantalla
 	SDL_Texture *text_texture_;				 // Textura para dibujar el texto
 	SDL_Texture *cover_texture_;			 // Textura para cubrir el texto
 	std::shared_ptr<AnimatedSprite> sprite_; // Sprite para el brillo del corazón
 
 	// Variables
-	int counter_ = 0;				// Contador
-	bool counter_enabled_ = true;	// Indica si esta activo el contador
-	int sub_counter_ = 0;			// Contador secundario
-	Uint32 ticks_ = 0;				// Contador de ticks para ajustar la velocidad del programa
-	std::vector<captions_t> texts_; // Vector con los textos
+	int counter_ = 0;			  // Contador
+	bool counter_enabled_ = true; // Indica si esta activo el contador
+	int sub_counter_ = 0;		  // Contador secundario
+	Uint32 ticks_ = 0;			  // Contador de ticks para ajustar la velocidad del programa
+	std::vector<Captions> texts_; // Vector con los textos
 
 	// Actualiza las variables
 	void update();
@@ -61,9 +55,6 @@ private:
 	// Escribe el texto en la textura
 	void fillTexture();
 
-	// Cambia la paleta
-	void switchPalette();
-
 public:
 	// Constructor
 	Credits();

source/debug.cpp

@@ -1,9 +1,9 @@
 #include "debug.h"
-#include <algorithm>   // for max
-#include "resource.h"  // for Resource
-#include "screen.h"    // for Screen
-#include "text.h"      // for Text
-#include "utils.h"     // for Color
+#include <algorithm>  // for max
+#include "resource.h" // for Resource
+#include "screen.h"	  // for Screen
+#include "text.h"	  // for Text
+#include "utils.h"	  // for Color
 
 // [SINGLETON]
 Debug *Debug::debug_ = nullptr;
@@ -26,45 +26,30 @@ Debug *Debug::get()
 	return Debug::debug_;
 }
 
-// Constructor
-Debug::Debug()
-	// Copia la dirección de los objetos
-	: screen_(Screen::get()),
-	  renderer_(Screen::get()->getRenderer())
-{
-	// Reserva memoria para los punteros
-	texture_ = Resource::get()->getTexture("debug.png");
-	text_ = Resource::get()->getText("debug");
-}
-
-// Actualiza las variables
-void Debug::update()
-{
-}
-
 // Dibuja en pantalla
 void Debug::render()
 {
+	auto text = Resource::get()->getText("debug");
 	int y = y_;
 	int w = 0;
 
-	for (auto s : slot_)
+	for (const auto &s : slot_)
 	{
-		text_->write(x_, y, s);
+		text->write(x_, y, s);
 		w = (std::max(w, (int)s.length()));
-		y += text_->getCharacterSize() + 1;
-		if (y > 192 - text_->getCharacterSize())
+		y += text->getCharacterSize() + 1;
+		if (y > 192 - text->getCharacterSize())
 		{
 			y = y_;
-			x_ += w * text_->getCharacterSize() + 2;
+			x_ += w * text->getCharacterSize() + 2;
 		}
 	}
 
 	y = 0;
-	for (auto l : log_)
+	for (const auto &l : log_)
 	{
-		text_->writeColored(x_ + 10, y, l, Color(255, 255, 255));
-		y += text_->getCharacterSize() + 1;
+		text->writeColored(x_ + 10, y, l, Color(255, 255, 255));
+		y += text->getCharacterSize() + 1;
 	}
 }
 

source/debug.h

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>    // for SDL_Point
-#include <SDL2/SDL_render.h>  // for SDL_Renderer
-#include <memory>             // for shared_ptr
-#include <string>             // for string
-#include <vector>             // for vector
-class Screen;  // lines 9-9
-class Text;  // lines 10-10
-class Texture;  // lines 11-11
+#include <SDL2/SDL_rect.h>	 // for SDL_Point
+#include <SDL2/SDL_render.h> // for SDL_Renderer
+#include <memory>			 // for shared_ptr
+#include <string>			 // for string
+#include <vector>			 // for vector
+class Screen;				 // lines 9-9
+class Text;					 // lines 10-10
+class Texture;				 // lines 11-11
 
 // Clase Debug
 class Debug
@@ -16,12 +16,6 @@ private:
 	// [SINGLETON] Objeto privado
 	static Debug *debug_;
 
-	// Objetos y punteros
-	Screen *screen_;				   // Objeto encargado de dibujar en pantalla
-	SDL_Renderer *renderer_;		   // El renderizador de la ventana
-	std::shared_ptr<Text> text_;	   // Objeto encargado de escribir texto en pantalla
-	std::shared_ptr<Texture> texture_; // Textura para el texto
-
 	// Variables
 	std::vector<std::string> slot_; // Vector con los textos a escribir
 	std::vector<std::string> log_;	// Vector con los textos a escribir
@@ -30,7 +24,7 @@ private:
 	bool enabled_ = false;			// Indica si esta activo el modo debug
 
 	// Constructor
-	Debug();
+	Debug() = default;
 
 	// Destructor
 	~Debug() = default;
@@ -45,9 +39,6 @@ public:
 	// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
 	static Debug *get();
 
-	// Actualiza las variables
-	void update();
-
 	// Dibuja en pantalla
 	void render();
 
@@ -63,5 +54,5 @@ public:
 	void addToLog(std::string text) { log_.push_back(text); }
 	void clearLog() { log_.clear(); }
 	void setEnabled(bool value) { enabled_ = value; }
-	void switchEnabled() { enabled_ = !enabled_; }
+	void toggleEnabled() { enabled_ = !enabled_; }
 };

source/defines.h

@@ -7,10 +7,10 @@
 // Textos
 constexpr const char *WINDOW_CAPTION = "JailDoctor's Dilemma";
 constexpr const char *TEXT_COPYRIGHT = "@2022 JailDesigner";
-constexpr const char *VERSION = "1.09";
+constexpr const char *VERSION = "1.10";
 
 // Velocidad del juego
-constexpr Uint32 GAME_SPEED = 1000 / 60;
+constexpr Uint32 GAME_SPEED = 15;
 
 // Tamaño de bloque
 constexpr int BLOCK = 8;

source/demo.cpp

@@ -19,15 +19,9 @@
 
 // Constructor
 Demo::Demo()
-	: screen_(Screen::get()),
-	  renderer_(Screen::get()->getRenderer()),
-	  resource_(Resource::get()),
-	  asset_(Asset::get()),
-	  input_(Input::get()),
-	  debug_(Debug::get())
+	: board_(std::make_shared<ScoreboardData>())
 {
 	// Inicia algunas variables
-	board_ = std::make_shared<ScoreboardData>();
 	board_->ini_clock = SDL_GetTicks();
 	rooms_.push_back("04.room");
 	rooms_.push_back("54.room");
@@ -44,8 +38,7 @@ Demo::Demo()
 	// Crea los objetos
 	ItemTracker::init();
 	scoreboard_ = std::make_shared<Scoreboard>(board_);
-	room_ = std::make_shared<Room>(resource_->getRoom(current_room_), board_);
-	text_ = resource_->getText("smb2");
+	room_ = std::make_shared<Room>(current_room_, board_);
 
 	// Inicializa el resto de variables
 	counter_ = 0;
@@ -112,7 +105,7 @@ void Demo::update()
 		scoreboard_->update();
 		checkRoomChange();
 
-		screen_->update();
+		Screen::get()->update();
 	}
 }
 
@@ -120,7 +113,7 @@ void Demo::update()
 void Demo::render()
 {
 	// Prepara para dibujar el frame
-	screen_->start();
+	Screen::get()->start();
 
 	// Dibuja los elementos del juego en orden
 	room_->renderMap();
@@ -130,7 +123,7 @@ void Demo::render()
 	scoreboard_->render();
 
 	// Actualiza la pantalla
-	screen_->render();
+	Screen::get()->render();
 }
 
 // Escribe el nombre de la pantalla
@@ -139,55 +132,23 @@ void Demo::renderRoomName()
 	// Texto en el centro de la pantalla
 	SDL_Rect rect = {0, 16 * BLOCK, PLAY_AREA_WIDTH, BLOCK * 2};
 	Color color = stringToColor(options.video.palette, "white");
-	SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 0xFF);
-	SDL_RenderFillRect(renderer_, &rect);
+	SDL_SetRenderDrawColor(Screen::get()->getRenderer(), color.r, color.g, color.b, 0xFF);
+	SDL_RenderFillRect(Screen::get()->getRenderer(), &rect);
 
-	text_->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, 16 * 8 + 4, room_->getName(), 1, room_->getBGColor());
-}
-
-// Recarga todas las texturas
-void Demo::reLoadTextures()
-{
-	if (options.console)
-	{
-		std::cout << "** RELOAD REQUESTED" << std::endl;
-	}
-	room_->reLoadTexture();
-	scoreboard_->reLoadTexture();
-	text_->reLoadTexture();
-}
-
-// Cambia la paleta
-void Demo::switchPalette()
-{
-	// Modifica la variable
-	if (options.video.palette == Palette::ZXSPECTRUM)
-	{
-		options.video.palette = Palette::ZXARNE;
-	}
-	else
-	{
-		options.video.palette = Palette::ZXSPECTRUM;
-	}
-
-	room_->reLoadPalette();
-	scoreboard_->reLoadPalette();
-
-	// Pone el color del marcador en función del color del borde de la habitación
-	setScoreBoardColor();
+	Resource::get()->getText("smb2")->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, 16 * 8 + 4, room_->getName(), 1, room_->getBGColor());
 }
 
 // Cambia de habitación
-bool Demo::changeRoom(std::string file)
+bool Demo::changeRoom(const std::string &room_path)
 {
 	// En las habitaciones los limites tienen la cadena del fichero o un 0 en caso de no limitar con nada
-	if (file != "0")
+	if (room_path != "0")
 	{
 		// Verifica que exista el fichero que se va a cargar
-		if (asset_->get(file) != "")
+		if (Asset::get()->get(room_path) != "")
 		{
 			// Crea un objeto habitación a partir del fichero
-			room_ = std::make_shared<Room>(resource_->getRoom(file), board_);
+			room_ = std::make_shared<Room>(room_path, board_);
 
 			// Pone el color del marcador en función del color del borde de la habitación
 			setScoreBoardColor();

source/demo.h

@@ -19,14 +19,7 @@ class Demo
 {
 private:
 	// Objetos y punteros
-	Screen *screen_;						 // Objeto encargado de manejar el renderizador
-	SDL_Renderer *renderer_;				 // El renderizador de la ventana
-	Resource *resource_;					 // Objeto con los recursos
-	Asset *asset_;							 // Objeto con la ruta a todos los ficheros de recursos
-	Input *input_;							 // Objeto pata gestionar la entrada
-	Debug *debug_;							 // Objeto para gestionar la información de debug
 	std::shared_ptr<Room> room_;			 // Objeto encargado de gestionar cada habitación del juego
-	std::shared_ptr<Text> text_;			 // Objeto para los textos del juego
 	std::shared_ptr<Scoreboard> scoreboard_; // Objeto encargado de gestionar el marcador
 
 	// Variables
@@ -53,14 +46,8 @@ private:
 	// Escribe el nombre de la pantalla
 	void renderRoomName();
 
-	// Recarga todas las texturas
-	void reLoadTextures();
-
-	// Cambia la paleta
-	void switchPalette();
-
 	// Cambia de habitación
-	bool changeRoom(std::string file);
+	bool changeRoom(const std::string &file);
 
 	// Comprueba si se ha de cambiar de habitación
 	void checkRoomChange();

source/director.cpp

@@ -217,60 +217,60 @@ void Director::initInput()
 	// Teclado - Movimiento
 	if (options.keys == ControlScheme::CURSOR)
 	{
-		Input::get()->bindKey(input_jump, SDL_SCANCODE_UP);
-		Input::get()->bindKey(input_left, SDL_SCANCODE_LEFT);
-		Input::get()->bindKey(input_right, SDL_SCANCODE_RIGHT);
-		Input::get()->bindKey(input_up, SDL_SCANCODE_UP);
-		Input::get()->bindKey(input_down, SDL_SCANCODE_DOWN);
+		Input::get()->bindKey(InputAction::JUMP, SDL_SCANCODE_UP);
+		Input::get()->bindKey(InputAction::LEFT, SDL_SCANCODE_LEFT);
+		Input::get()->bindKey(InputAction::RIGHT, SDL_SCANCODE_RIGHT);
+		Input::get()->bindKey(InputAction::UP, SDL_SCANCODE_UP);
+		Input::get()->bindKey(InputAction::DOWN, SDL_SCANCODE_DOWN);
 	}
 	else if (options.keys == ControlScheme::OPQA)
 	{
-		Input::get()->bindKey(input_jump, SDL_SCANCODE_Q);
-		Input::get()->bindKey(input_left, SDL_SCANCODE_O);
-		Input::get()->bindKey(input_right, SDL_SCANCODE_P);
-		Input::get()->bindKey(input_up, SDL_SCANCODE_Q);
-		Input::get()->bindKey(input_down, SDL_SCANCODE_A);
+		Input::get()->bindKey(InputAction::JUMP, SDL_SCANCODE_Q);
+		Input::get()->bindKey(InputAction::LEFT, SDL_SCANCODE_O);
+		Input::get()->bindKey(InputAction::RIGHT, SDL_SCANCODE_P);
+		Input::get()->bindKey(InputAction::UP, SDL_SCANCODE_Q);
+		Input::get()->bindKey(InputAction::DOWN, SDL_SCANCODE_A);
 	}
 	else if (options.keys == ControlScheme::WASD)
 	{
-		Input::get()->bindKey(input_jump, SDL_SCANCODE_W);
-		Input::get()->bindKey(input_left, SDL_SCANCODE_A);
-		Input::get()->bindKey(input_right, SDL_SCANCODE_D);
-		Input::get()->bindKey(input_up, SDL_SCANCODE_W);
-		Input::get()->bindKey(input_down, SDL_SCANCODE_S);
+		Input::get()->bindKey(InputAction::JUMP, SDL_SCANCODE_W);
+		Input::get()->bindKey(InputAction::LEFT, SDL_SCANCODE_A);
+		Input::get()->bindKey(InputAction::RIGHT, SDL_SCANCODE_D);
+		Input::get()->bindKey(InputAction::UP, SDL_SCANCODE_W);
+		Input::get()->bindKey(InputAction::DOWN, SDL_SCANCODE_S);
 	}
 
 	// Teclado - Otros
-	Input::get()->bindKey(input_accept, SDL_SCANCODE_RETURN);
-	Input::get()->bindKey(input_cancel, SDL_SCANCODE_ESCAPE);
-	Input::get()->bindKey(input_pause, SDL_SCANCODE_H);
-	Input::get()->bindKey(input_exit, SDL_SCANCODE_ESCAPE);
-	Input::get()->bindKey(input_window_dec_size, SDL_SCANCODE_F1);
-	Input::get()->bindKey(input_window_inc_size, SDL_SCANCODE_F2);
-	Input::get()->bindKey(input_toggle_videomode, SDL_SCANCODE_F3);
-	Input::get()->bindKey(input_toggle_shaders, SDL_SCANCODE_F4);
-	Input::get()->bindKey(input_toggle_palette, SDL_SCANCODE_F5);
-	Input::get()->bindKey(input_toggle_music, SDL_SCANCODE_M);
-	Input::get()->bindKey(input_toggle_border, SDL_SCANCODE_B);
+	Input::get()->bindKey(InputAction::ACCEPT, SDL_SCANCODE_RETURN);
+	Input::get()->bindKey(InputAction::CANCEL, SDL_SCANCODE_ESCAPE);
+	Input::get()->bindKey(InputAction::PAUSE, SDL_SCANCODE_H);
+	Input::get()->bindKey(InputAction::EXIT, SDL_SCANCODE_ESCAPE);
+	Input::get()->bindKey(InputAction::WINDOW_DEC_ZOOM, SDL_SCANCODE_F1);
+	Input::get()->bindKey(InputAction::WINDOW_INC_ZOOM, SDL_SCANCODE_F2);
+	Input::get()->bindKey(InputAction::TOGGLE_VIDEOMODE, SDL_SCANCODE_F3);
+	Input::get()->bindKey(InputAction::TOGGLE_SHADERS, SDL_SCANCODE_F4);
+	Input::get()->bindKey(InputAction::TOGGLE_PALETTE, SDL_SCANCODE_F5);
+	Input::get()->bindKey(InputAction::TOGGLE_MUSIC, SDL_SCANCODE_M);
+	Input::get()->bindKey(InputAction::TOGGLE_BORDER, SDL_SCANCODE_B);
 
 	// Mando - Movimiento
-	Input::get()->bindGameControllerButton(input_jump, SDL_CONTROLLER_BUTTON_B);
-	Input::get()->bindGameControllerButton(input_left, SDL_CONTROLLER_BUTTON_DPAD_LEFT);
-	Input::get()->bindGameControllerButton(input_right, SDL_CONTROLLER_BUTTON_DPAD_RIGHT);
+	Input::get()->bindGameControllerButton(InputAction::JUMP, SDL_CONTROLLER_BUTTON_B);
+	Input::get()->bindGameControllerButton(InputAction::LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT);
+	Input::get()->bindGameControllerButton(InputAction::RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT);
 
 	// Mando - Otros
-	Input::get()->bindGameControllerButton(input_accept, SDL_CONTROLLER_BUTTON_B);
-	Input::get()->bindGameControllerButton(input_cancel, SDL_CONTROLLER_BUTTON_A);
+	Input::get()->bindGameControllerButton(InputAction::ACCEPT, SDL_CONTROLLER_BUTTON_B);
+	Input::get()->bindGameControllerButton(InputAction::CANCEL, SDL_CONTROLLER_BUTTON_A);
 #ifdef GAME_CONSOLE
-	Input::get()->bindGameControllerButton(input_pause, SDL_CONTROLLER_BUTTON_BACK);
-	Input::get()->bindGameControllerButton(input_exit, SDL_CONTROLLER_BUTTON_START);
+	Input::get()->bindGameControllerButton(InputAction::input_pause, SDL_CONTROLLER_BUTTON_BACK);
+	Input::get()->bindGameControllerButton(InputAction::input_exit, SDL_CONTROLLER_BUTTON_START);
 #else
-	Input::get()->bindGameControllerButton(input_pause, SDL_CONTROLLER_BUTTON_START);
-	Input::get()->bindGameControllerButton(input_exit, SDL_CONTROLLER_BUTTON_BACK);
+	Input::get()->bindGameControllerButton(InputAction::PAUSE, SDL_CONTROLLER_BUTTON_START);
+	Input::get()->bindGameControllerButton(InputAction::EXIT, SDL_CONTROLLER_BUTTON_BACK);
 #endif
-	Input::get()->bindGameControllerButton(input_toggle_palette, SDL_CONTROLLER_BUTTON_LEFTSHOULDER);
-	Input::get()->bindGameControllerButton(input_toggle_music, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER);
-	Input::get()->bindGameControllerButton(input_toggle_border, SDL_CONTROLLER_BUTTON_X);
+	Input::get()->bindGameControllerButton(InputAction::TOGGLE_PALETTE, SDL_CONTROLLER_BUTTON_LEFTSHOULDER);
+	Input::get()->bindGameControllerButton(InputAction::TOGGLE_MUSIC, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER);
+	Input::get()->bindGameControllerButton(InputAction::TOGGLE_BORDER, SDL_CONTROLLER_BUTTON_X);
 }
 
 // Inicializa JailAudio

source/ending.cpp

@@ -23,24 +23,14 @@
 
 // Constructor
 Ending::Ending()
-    : screen_(Screen::get()),
-      renderer_(Screen::get()->getRenderer()),
-      resource_(Resource::get()),
-      asset_(Asset::get()),
-      input_(Input::get())
+    : counter_(-1),
+      pre_counter_(0),
+      cover_counter_(0),
+      ticks_(0),
+      current_scene_(0)
 {
-    // Reserva memoria para los punteros a objetos
-    text_ = resource_->getText("smb2");
-    music = resource_->getMusic("ending1.ogg");
-
-    // Inicializa variables
-    counter_ = -1;
-    pre_counter_ = 0;
-    cover_counter_ = 0;
     options.section.section = Section::ENDING;
     options.section.subsection = Subsection::NONE;
-    ticks_ = 0;
-    current_scene_ = 0;
 
     // Inicializa los textos
     iniTexts();
@@ -52,10 +42,10 @@ Ending::Ending()
     iniScenes();
 
     // Cambia el color del borde
-    screen_->setBorderColor(stringToColor(options.video.palette, "black"));
+    Screen::get()->setBorderColor(stringToColor(options.video.palette, "black"));
 
     // Crea la textura para cubrir el rexto
-    cover_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT + 8);
+    cover_texture_ = SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT + 8);
     if (cover_texture_ == nullptr)
     {
         if (options.console)
@@ -100,7 +90,7 @@ void Ending::update()
         // Actualiza el volumen de la musica
         updateMusicVolume();
 
-        screen_->update();
+        Screen::get()->update();
     }
 }
 
@@ -108,10 +98,10 @@ void Ending::update()
 void Ending::render()
 {
     // Prepara para empezar a dibujar en la textura de juego
-    screen_->start();
+    Screen::get()->start();
 
     // Limpia la pantalla
-    screen_->clean(stringToColor(options.video.palette, "black"));
+    Screen::get()->clean(stringToColor(options.video.palette, "black"));
 
     // Dibuja las imagenes de la escena
     sprite_pics_[current_scene_].sprite->render();
@@ -131,7 +121,7 @@ void Ending::render()
     renderCoverTexture();
 
     // Vuelca el contenido del renderizador en pantalla
-    screen_->render();
+    Screen::get()->render();
 }
 
 // Comprueba el manejador de eventos
@@ -188,53 +178,56 @@ void Ending::iniTexts()
     // Crea los sprites
     sprite_texts_.clear();
 
-    for (auto t : texts)
+    for (const auto &t : texts)
     {
+        auto text = Resource::get()->getText("smb2");
+
+        const int WIDTH = text->lenght(t.caption, 1) + 2 + 2;
+        const int HEIGHT = text->getCharacterSize() + 2 + 2;
+        Color color = stringToColor(options.video.palette, "black");
+        
         EndingTexture st;
-        const int width = text_->lenght(t.caption, 1) + 2 + 2;
-        const int height = text_->getCharacterSize() + 2 + 2;
-        Color c = stringToColor(options.video.palette, "black");
         
         // Crea la texture
-        st.texture = std::make_shared<Texture>(renderer_);
-        st.texture->createBlank(width, height);
-        st.texture->setAsRenderTarget(renderer_);
+        st.texture = std::make_shared<Texture>(Screen::get()->getRenderer());
+        st.texture->createBlank(WIDTH, HEIGHT);
+        st.texture->setAsRenderTarget(Screen::get()->getRenderer());
         st.texture->setBlendMode(SDL_BLENDMODE_BLEND);
-        text_->writeDX(TEXT_STROKE, 2, 2, t.caption, 1, c, 2, c);
+        text->writeDX(TEXT_STROKE, 2, 2, t.caption, 1, color, 2, color);
 
         // Crea el sprite
         st.sprite = std::make_shared<Sprite>(st.texture, 0, 0, st.texture->getWidth(), st.texture->getHeight());
         st.sprite->setPosition((GAMECANVAS_WIDTH - st.texture->getWidth()) / 2, t.pos);
 
         // Crea la coverTexture
-        st.cover_texture = std::make_shared<Texture>(renderer_);
-        st.cover_texture->createBlank(width, height + 8);
-        st.cover_texture->setAsRenderTarget(renderer_);
+        st.cover_texture = std::make_shared<Texture>(Screen::get()->getRenderer());
+        st.cover_texture->createBlank(WIDTH, HEIGHT + 8);
+        st.cover_texture->setAsRenderTarget(Screen::get()->getRenderer());
         st.cover_texture->setBlendMode(SDL_BLENDMODE_BLEND);
 
         // Rellena la coverTexture con color transparente
-        SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
-        SDL_RenderClear(renderer_);
+        SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 0, 0, 0);
+        SDL_RenderClear(Screen::get()->getRenderer());
 
         // Los primeros 8 pixels crea una malla
-        c = stringToColor(options.video.palette, "black");
-        SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
-        for (int i = 0; i < width; i += 2)
+        color = stringToColor(options.video.palette, "black");
+        SDL_SetRenderDrawColor(Screen::get()->getRenderer(), color.r, color.g, color.b, 0xFF);
+        for (int i = 0; i < WIDTH; i += 2)
         {
-            SDL_RenderDrawPoint(renderer_, i, 0);
-            SDL_RenderDrawPoint(renderer_, i, 2);
-            SDL_RenderDrawPoint(renderer_, i, 4);
-            SDL_RenderDrawPoint(renderer_, i, 6);
+            SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 0);
+            SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 2);
+            SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 4);
+            SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 6);
 
-            SDL_RenderDrawPoint(renderer_, i + 1, 5);
-            SDL_RenderDrawPoint(renderer_, i + 1, 7);
+            SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 1, 5);
+            SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 1, 7);
         }
 
         // El resto se rellena de color sólido
-        SDL_Rect rect = {0, 8, width, height};
-        c = stringToColor(options.video.palette, "black");
-        SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
-        SDL_RenderFillRect(renderer_, &rect);
+        SDL_Rect rect = {0, 8, WIDTH, HEIGHT};
+        color = stringToColor(options.video.palette, "black");
+        SDL_SetRenderDrawColor(Screen::get()->getRenderer(), color.r, color.g, color.b, 0xFF);
+        SDL_RenderFillRect(Screen::get()->getRenderer(), &rect);
 
         // Crea el sprite
         st.cover_sprite = std::make_shared<Sprite>(st.cover_texture, 0, 0, st.cover_texture->getWidth(), st.cover_texture->getHeight() - 8);
@@ -243,7 +236,7 @@ void Ending::iniTexts()
 
         // Inicializa variables
         st.clip_desp = 8;
-        st.clip_height = height;
+        st.clip_height = HEIGHT;
 
         sprite_texts_.push_back(st);
     }
@@ -275,12 +268,12 @@ void Ending::iniPics()
     // Crea los sprites
     sprite_pics_.clear();
 
-    for (auto p : pics)
+    for (const auto &p : pics)
     {
         EndingTexture sp;
 
         // Crea la texture
-        sp.texture = resource_->getTexture(p.caption);
+        sp.texture = Resource::get()->getTexture(p.caption);
         const int width = sp.texture->getWidth();
         const int height = sp.texture->getHeight();
 
@@ -289,34 +282,34 @@ void Ending::iniPics()
         sp.sprite->setPosition((GAMECANVAS_WIDTH - width) / 2, p.pos);
 
         // Crea la coverTexture
-        sp.cover_texture = std::make_shared<Texture>(renderer_);
+        sp.cover_texture = std::make_shared<Texture>(Screen::get()->getRenderer());
         sp.cover_texture->createBlank(width, height + 8);
-        sp.cover_texture->setAsRenderTarget(renderer_);
+        sp.cover_texture->setAsRenderTarget(Screen::get()->getRenderer());
         sp.cover_texture->setBlendMode(SDL_BLENDMODE_BLEND);
 
         // Rellena la coverTexture con color transparente
-        SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
-        SDL_RenderClear(renderer_);
+        SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 0, 0, 0);
+        SDL_RenderClear(Screen::get()->getRenderer());
 
         // Los primeros 8 pixels crea una malla
         Color c = stringToColor(options.video.palette, "black");
-        SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
+        SDL_SetRenderDrawColor(Screen::get()->getRenderer(), c.r, c.g, c.b, 0xFF);
         for (int i = 0; i < width; i += 2)
         {
-            SDL_RenderDrawPoint(renderer_, i, 0);
-            SDL_RenderDrawPoint(renderer_, i, 2);
-            SDL_RenderDrawPoint(renderer_, i, 4);
-            SDL_RenderDrawPoint(renderer_, i, 6);
+            SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 0);
+            SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 2);
+            SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 4);
+            SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 6);
 
-            SDL_RenderDrawPoint(renderer_, i + 1, 5);
-            SDL_RenderDrawPoint(renderer_, i + 1, 7);
+            SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 1, 5);
+            SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 1, 7);
         }
 
         // El resto se rellena de color sólido
         SDL_Rect rect = {0, 8, width, height};
         c = stringToColor(options.video.palette, "black");
-        SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
-        SDL_RenderFillRect(renderer_, &rect);
+        SDL_SetRenderDrawColor(Screen::get()->getRenderer(), c.r, c.g, c.b, 0xFF);
+        SDL_RenderFillRect(Screen::get()->getRenderer(), &rect);
 
         // Crea el sprite
         sp.cover_sprite = std::make_shared<Sprite>(sp.cover_texture, 0, 0, sp.cover_texture->getWidth(), sp.cover_texture->getHeight() - 8);
@@ -417,7 +410,7 @@ void Ending::iniScenes()
 // Bucle principal
 void Ending::run()
 {
-    JA_PlayMusic(music);
+    JA_PlayMusic(Resource::get()->getMusic("ending1.ogg"));
 
     while (options.section.section == Section::ENDING)
     {
@@ -516,29 +509,29 @@ void Ending::checkChangeScene()
 void Ending::fillCoverTexture()
 {
     // Rellena la textura que cubre el texto con color transparente
-    SDL_SetRenderTarget(renderer_, cover_texture_);
-    SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
-    SDL_RenderClear(renderer_);
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), cover_texture_);
+    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 0, 0, 0);
+    SDL_RenderClear(Screen::get()->getRenderer());
 
     // Los primeros 8 pixels crea una malla
     const Color color = stringToColor(options.video.palette, "black");
-    SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 0xFF);
+    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), color.r, color.g, color.b, 0xFF);
     for (int i = 0; i < 256; i += 2)
     {
-        SDL_RenderDrawPoint(renderer_, i + 0, GAMECANVAS_HEIGHT + 0);
-        SDL_RenderDrawPoint(renderer_, i + 1, GAMECANVAS_HEIGHT + 1);
-        SDL_RenderDrawPoint(renderer_, i + 0, GAMECANVAS_HEIGHT + 2);
-        SDL_RenderDrawPoint(renderer_, i + 1, GAMECANVAS_HEIGHT + 3);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 0, GAMECANVAS_HEIGHT + 0);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 1, GAMECANVAS_HEIGHT + 1);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 0, GAMECANVAS_HEIGHT + 2);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 1, GAMECANVAS_HEIGHT + 3);
 
-        SDL_RenderDrawPoint(renderer_, i, GAMECANVAS_HEIGHT + 4);
-        SDL_RenderDrawPoint(renderer_, i, GAMECANVAS_HEIGHT + 6);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, GAMECANVAS_HEIGHT + 4);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, GAMECANVAS_HEIGHT + 6);
     }
 
     // El resto se rellena de color sólido
     SDL_Rect rect = {0, 0, 256, GAMECANVAS_HEIGHT};
-    SDL_RenderFillRect(renderer_, &rect);
+    SDL_RenderFillRect(Screen::get()->getRenderer(), &rect);
 
-    SDL_SetRenderTarget(renderer_, nullptr);
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), nullptr);
 }
 
 // Dibuja la cortinilla de cambio de escena
@@ -549,7 +542,7 @@ void Ending::renderCoverTexture()
         const int offset = std::min(cover_counter_, 100);
         SDL_Rect srcRect = {0, 200 - (cover_counter_ * 2), 256, offset * 2};
         SDL_Rect dstRect = {0, 0, 256, offset * 2};
-        SDL_RenderCopy(renderer_, cover_texture_, &srcRect, &dstRect);
+        SDL_RenderCopy(Screen::get()->getRenderer(), cover_texture_, &srcRect, &dstRect);
     }
 }
 

source/ending.h

@@ -34,7 +34,7 @@ private:
 		int pos;			 // Posición
 	};
 
-	struct asdhk
+	struct TextIndex
 	{
 		int index;
 		int trigger;
@@ -42,18 +42,12 @@ private:
 
 	struct SceneData // Estructura para crear cada una de las escenas del final
 	{
-		std::vector<asdhk> text_index; // Indices del vector de textos a mostrar y su disparador
+		std::vector<TextIndex> text_index; // Indices del vector de textos a mostrar y su disparador
 		int picture_index;			   // Indice del vector de imagenes a mostrar
 		int counter_end;			   // Valor del contador en el que finaliza la escena
 	};
 
 	// Objetos y punteros
-	Screen *screen_;			 // Objeto encargado de dibujar en pantalla
-	SDL_Renderer *renderer_;	 // El renderizador de la ventana
-	Resource *resource_;		 // Objeto con los recursos
-	Asset *asset_;				 // Objeto con los ficheros de recursos
-	Input *input_;				 // Objeto pata gestionar la entrada
-	std::shared_ptr<Text> text_; // Objeto para escribir texto en pantalla
 	SDL_Texture *cover_texture_; // Textura para cubrir el texto
 
 	// Variables
@@ -65,7 +59,6 @@ private:
 	std::vector<EndingTexture> sprite_pics_;  // Vector con los sprites de texto con su cortinilla
 	int current_scene_;						  // Escena actual
 	std::vector<SceneData> scenes_;			  // Vector con los textos e imagenes de cada escena
-	JA_Music_t *music;						  // Musica que suena durante el final
 
 	// Actualiza el objeto
 	void update();

source/ending2.cpp

@@ -21,37 +21,24 @@
 
 // Constructor
 Ending2::Ending2()
-    : screen_(Screen::get()),
-      renderer_(Screen::get()->getRenderer()),
-      resource_(Resource::get()),
-      asset_(Asset::get()),
-      input_(Input::get())
+    : counter_enabled_(false),
+      pre_counter_(0),
+      post_counter_(0),
+      post_counter_enabled_(false),
+      ticks_(0)
 {
-    // Reserva memoria para los punteros a objetos
-    text_ = resource_->getText("smb2");
-    music_ = resource_->getMusic("ending2.ogg");
-
-    // Inicializa variables
-    counter_enabled_ = false;
-    pre_counter_ = 0;
-    post_counter_ = 0;
-    post_counter_enabled_ = false;
     options.section.section = Section::ENDING2;
     options.section.subsection = Subsection::NONE;
-    ticks_ = 0;
-    dist_sprite_text_ = 8;
-    dist_sprite_sprite_ = 0;
-    sprite_desp_speed_ = -0.2f;
 
     // Inicializa el vector de colores
     const std::vector<std::string> color_list = {"white", "yellow", "cyan", "green", "magenta", "red", "blue", "black"};
-    for (auto color : color_list)
+    for (const auto &color : color_list)
     {
         colors_.push_back(stringToColor(options.video.palette, color));
     }
 
     // Cambia el color del borde
-    screen_->setBorderColor(stringToColor(options.video.palette, "black"));
+    Screen::get()->setBorderColor(stringToColor(options.video.palette, "black"));
 
     // Inicializa la lista de sprites
     iniSpriteList();
@@ -102,7 +89,8 @@ void Ending2::update()
         // Actualiza el volumen de la musica
         updateMusicVolume();
 
-        screen_->update();
+        // Actualiza el objeto
+        Screen::get()->update();
     }
 }
 
@@ -110,10 +98,10 @@ void Ending2::update()
 void Ending2::render()
 {
     // Prepara para empezar a dibujar en la textura de juego
-    screen_->start();
+    Screen::get()->start();
 
     // Limpia la pantalla
-    screen_->clean(stringToColor(options.video.palette, "black"));
+    Screen::get()->clean(stringToColor(options.video.palette, "black"));
 
     // Dibuja los sprites
     renderSprites();
@@ -124,53 +112,29 @@ void Ending2::render()
     // Dibuja los sprites con el texto del final
     renderTexts();
 
-    const std::string txt = std::to_string(post_counter_);
-    // text->write(0, 192 - 8, txt);
-
-    // Dibuja la cuadricula
-    /*{
-        SDL_SetRenderDrawColor(renderer, 128, 128, 128, 255);
-        const int sw = maxSpriteWidth + 6;
-        const int sh = maxSpriteHeight + 6;
-        for (int i = 0; i < 256; i += sw)
-        {
-            SDL_RenderDrawLine(renderer, i, 0, i, 192);
-        }
-        for (int i = 0; i < 192; i += sh)
-        {
-            SDL_RenderDrawLine(renderer, 0, i, 255, i);
-        }
-    }*/
-
+    // Dibuja una trama arriba y abajo
+    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 0, 0, 0xFF);
+    for (int i = 0; i < 256; i += 2)
     {
-        // Dibuja una trama arriba y abajo
-        SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0xFF);
-        for (int i = 0; i < 256; i += 2)
-        {
-            SDL_RenderDrawPoint(renderer_, i + 0, 0);
-            SDL_RenderDrawPoint(renderer_, i + 1, 1);
-            SDL_RenderDrawPoint(renderer_, i + 0, 2);
-            SDL_RenderDrawPoint(renderer_, i + 1, 3);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 0, 0);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 1, 1);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 0, 2);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 1, 3);
 
-            SDL_RenderDrawPoint(renderer_, i, 4);
-            SDL_RenderDrawPoint(renderer_, i, 6);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 4);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 6);
 
-            SDL_RenderDrawPoint(renderer_, i + 0, 191);
-            SDL_RenderDrawPoint(renderer_, i + 1, 190);
-            SDL_RenderDrawPoint(renderer_, i + 0, 189);
-            SDL_RenderDrawPoint(renderer_, i + 1, 188);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 0, 191);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 1, 190);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 0, 189);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i + 1, 188);
 
-            SDL_RenderDrawPoint(renderer_, i, 187);
-            SDL_RenderDrawPoint(renderer_, i, 185);
-        }
-        // SDL_RenderDrawLine(renderer, 0, 1, 255, 1);
-        // SDL_RenderDrawLine(renderer, 0, 3, 255, 3);
-        // SDL_RenderDrawLine(renderer, 0, 188, 255, 188);
-        // SDL_RenderDrawLine(renderer, 0, 190, 255, 190);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 187);
+        SDL_RenderDrawPoint(Screen::get()->getRenderer(), i, 185);
     }
 
     // Vuelca el contenido del renderizador en pantalla
-    screen_->render();
+    Screen::get()->render();
 }
 
 // Comprueba el manejador de eventos
@@ -192,7 +156,7 @@ void Ending2::checkInput()
 // Bucle principal
 void Ending2::run()
 {
-    JA_PlayMusic(music_);
+    JA_PlayMusic(Resource::get()->getMusic("ending2.ogg"));
 
     while (options.section.section == Section::ENDING2)
     {
@@ -316,9 +280,9 @@ void Ending2::loadSprites()
     sprite_max_height_ = 0;
 
     // Carga los sprites
-    for (auto sl : sprite_list_)
+    for (const auto &sl : sprite_list_)
     {
-        sprites_.emplace_back(std::make_shared<AnimatedSprite>(resource_->getTexture(sl + ".png"), resource_->getAnimations(sl + ".ani")));
+        sprites_.emplace_back(std::make_shared<AnimatedSprite>(Resource::get()->getTexture(sl + ".png"), Resource::get()->getAnimations(sl + ".ani")));
         sprite_max_width_ = std::max(sprites_.back()->getWidth(), sprite_max_width_);
         sprite_max_height_ = std::max(sprites_.back()->getHeight(), sprite_max_height_);
     }
@@ -414,23 +378,23 @@ void Ending2::placeSprites()
 {
     for (int i = 0; i < (int)sprites_.size(); ++i)
     {
-        const int x = i % 2 == 0 ? FIRST_COL_ : SECOND_COL_;
-        const int y = (i / 1) * (sprite_max_height_ + dist_sprite_text_ + text_->getCharacterSize() + dist_sprite_sprite_) + GAMECANVAS_HEIGHT + 40;
-        const int w = sprites_[i]->getWidth();
-        const int h = sprites_[i]->getHeight();
-        const int dx = -(w / 2);
-        const int dy = i % 1 == 0 ? sprite_max_height_ - h : (int)(sprite_max_height_ * 1.5f) - h;
+        const int X = i % 2 == 0 ? FIRST_COL_ : SECOND_COL_;
+        const int Y = (i / 1) * (sprite_max_height_ + DIST_SPRITE_TEXT_ + Resource::get()->getText("smb2")->getCharacterSize() + DIST_SPRITE_SPRITE_) + GAMECANVAS_HEIGHT + 40;
+        const int W = sprites_.at(i)->getWidth();
+        const int H = sprites_.at(i)->getHeight();
+        const int DX = -(W / 2);
+        const int DY = sprite_max_height_ - H;
 
-        sprites_[i]->setPosition({x + dx, y + dy, w, h});
-        sprites_[i]->setVelY(sprite_desp_speed_);
+        sprites_.at(i)->setPosition({X + DX, Y + DY, W, H});
+        sprites_.at(i)->setVelY(SPRITE_DESP_SPEED_);
     }
 
     // Recoloca el último sprite, que es el del jugador
-    const int w = sprites_.back()->getWidth();
-    const int x = GAMECANVAS_CENTER_X - (w / 2);
-    const int y = sprites_.back()->getPosY() + sprite_max_height_ * 2;
-    sprites_.back()->setPosX(x);
-    sprites_.back()->setPosY(y);
+    const int W = sprites_.back()->getWidth();
+    const int X = GAMECANVAS_CENTER_X - (W / 2);
+    const int Y = sprites_.back()->getPosY() + sprite_max_height_ * 2;
+    sprites_.back()->setPosX(X);
+    sprites_.back()->setPosY(Y);
     sprites_.back()->setCurrentAnimation("walk");
 }
 
@@ -438,32 +402,41 @@ void Ending2::placeSprites()
 void Ending2::createSpriteTexts()
 {
     // Crea los sprites de texto a partir de la lista
-    for (int i = 0; i < (int)sprite_list_.size(); ++i)
+    for (int i = 0; i < static_cast<int>(sprite_list_.size()); ++i)
     {
-        // Calcula constantes
-        std::string txt = sprite_list_[i];
-        std::replace(txt.begin(), txt.end(), '_', ' ');
-        txt = txt == "player" ? "JAILDOCTOR" : txt; // Reemplaza el texto
-        const int w = text_->lenght(txt, 1);
-        const int h = text_->getCharacterSize();
-        const int x = i % 2 == 0 ? FIRST_COL_ : SECOND_COL_;
-        const int dx = -(w / 2);
-        const int y = sprites_[i]->getPosY() + sprites_[i]->getHeight() + dist_sprite_text_;
+        auto text = Resource::get()->getText("smb2");
 
-        // Cambia la posición del último sprite
-        const int X = (i == (int)sprite_list_.size() - 1) ? GAMECANVAS_CENTER_X - (w / 2) : x + dx;
+        // Procesa y ajusta el texto del sprite actual
+        std::string txt = sprite_list_[i];
+        std::replace(txt.begin(), txt.end(), '_', ' '); // Reemplaza '_' por ' '
+        if (txt == "player")
+        {
+            txt = "JAILDOCTOR"; // Reemplaza "player" por "JAILDOCTOR"
+        }
+
+        // Calcula las dimensiones del texto
+        const int W = text->lenght(txt, 1);
+        const int H = text->getCharacterSize();
+
+        // Determina la columna y la posición X del texto
+        const int X = (i == static_cast<int>(sprite_list_.size()) - 1)
+                          ? (GAMECANVAS_CENTER_X - (W / 2))
+                          : ((i % 2 == 0 ? FIRST_COL_ : SECOND_COL_) - (W / 2));
+
+        // Calcula la posición Y del texto en base a la posición y altura del sprite
+        const int Y = sprites_.at(i)->getPosY() + sprites_.at(i)->getHeight() + DIST_SPRITE_TEXT_;
 
         // Crea la textura
-        auto texture = std::make_shared<Texture>(renderer_);
-        texture->createBlank(w, h);
-        texture->setAsRenderTarget(renderer_);
+        auto texture = std::make_shared<Texture>(Screen::get()->getRenderer());
+        texture->createBlank(W, H);
+        texture->setAsRenderTarget(Screen::get()->getRenderer());
         texture->setBlendMode(SDL_BLENDMODE_BLEND);
-        text_->write(0, 0, txt);
+        text->write(0, 0, txt);
 
         // Crea el sprite
-        SDL_Rect pos = {X, y, w, h};
+        SDL_Rect pos = {X, Y, W, H};
         sprite_texts_.emplace_back(std::make_shared<MovingSprite>(texture, pos));
-        sprite_texts_.back()->setVelY(sprite_desp_speed_);
+        sprite_texts_.back()->setVelY(SPRITE_DESP_SPEED_);
     }
 }
 
@@ -474,32 +447,34 @@ void Ending2::createTexts()
     std::vector<std::string> list;
     list.push_back("STARRING");
 
+    auto text = Resource::get()->getText("smb2");
+
     // Crea los sprites de texto a partir de la lista
     for (int i = 0; i < (int)list.size(); ++i)
     {
         // Calcula constantes
-        const int w = text_->lenght(list[i], 1);
-        const int h = text_->getCharacterSize();
+        const int w = text->lenght(list[i], 1);
+        const int h = text->getCharacterSize();
         const int x = GAMECANVAS_CENTER_X;
         const int dx = -(w / 2);
-        const int y = GAMECANVAS_HEIGHT + (text_->getCharacterSize() * (i * 2));
+        const int y = GAMECANVAS_HEIGHT + (text->getCharacterSize() * (i * 2));
 
         // Crea la textura
-        auto texture = std::make_shared<Texture>(renderer_);
+        auto texture = std::make_shared<Texture>(Screen::get()->getRenderer());
         texture->createBlank(w, h);
-        texture->setAsRenderTarget(renderer_);
+        texture->setAsRenderTarget(Screen::get()->getRenderer());
         texture->setBlendMode(SDL_BLENDMODE_BLEND);
-        text_->write(0, 0, list[i]);
+        text->write(0, 0, list[i]);
 
         // Crea el sprite
         SDL_Rect pos = {x + dx, y, w, h};
         texts_.emplace_back(std::make_shared<MovingSprite>(texture, pos));
-        texts_.back()->setVelY(sprite_desp_speed_);
+        texts_.back()->setVelY(SPRITE_DESP_SPEED_);
     }
 
     // Crea los últimos textos
     // El primer texto va a continuación del ultimo spriteText
-    const int start = sprite_texts_.back()->getPosY() + text_->getCharacterSize() * 15;
+    const int start = sprite_texts_.back()->getPosY() + text->getCharacterSize() * 15;
     list.clear();
     list.push_back("THANK YOU");
     list.push_back("FOR PLAYING!");
@@ -508,23 +483,23 @@ void Ending2::createTexts()
     for (int i = 0; i < (int)list.size(); ++i)
     {
         // Calcula constantes
-        const int w = text_->lenght(list[i], 1);
-        const int h = text_->getCharacterSize();
+        const int w = text->lenght(list[i], 1);
+        const int h = text->getCharacterSize();
         const int x = GAMECANVAS_CENTER_X;
         const int dx = -(w / 2);
-        const int y = start + (text_->getCharacterSize() * (i * 2));
+        const int y = start + (text->getCharacterSize() * (i * 2));
 
         // Crea la textura
-        auto texture = std::make_shared<Texture>(renderer_);
+        auto texture = std::make_shared<Texture>(Screen::get()->getRenderer());
         texture->createBlank(w, h);
-        texture->setAsRenderTarget(renderer_);
+        texture->setAsRenderTarget(Screen::get()->getRenderer());
         texture->setBlendMode(SDL_BLENDMODE_BLEND);
-        text_->write(0, 0, list[i]);
+        text->write(0, 0, list[i]);
 
         // Crea el sprite
         SDL_Rect pos = {x + dx, y, w, h};
         texts_.emplace_back(std::make_shared<MovingSprite>(texture, pos));
-        texts_.back()->setVelY(sprite_desp_speed_);
+        texts_.back()->setVelY(SPRITE_DESP_SPEED_);
     }
 }
 
@@ -532,12 +507,12 @@ void Ending2::createTexts()
 void Ending2::updateFinalFade()
 {
     // La variable step va de 0 a 40 en el tramo de postCounter que va de 500 a 540. Al dividirlo por 40, va de 0.0f a 1.0f
-    const float step = std::min(std::max(post_counter_, 500) - 500, 40) / 40.0f;
-    const int index = (colors_.size() - 1) * step;
+    const float STEP = std::min(std::max(post_counter_, 500) - 500, 40) / 40.0f;
+    const int INDEX = (colors_.size() - 1) * STEP;
 
-    for (auto t : texts_)
+    for (const auto &text : texts_)
     {
-        t->getTexture()->setColor(colors_[index].r, colors_[index].g, colors_[index].b);
+        text->getTexture()->setColor(colors_.at(INDEX).r, colors_.at(INDEX).g, colors_.at(INDEX).b);
     }
 }
 

source/ending2.h

@@ -20,16 +20,15 @@ class Ending2
 {
 private:
 	// Constantes
-	static constexpr int FIRST_COL_ = GAMECANVAS_FIRST_QUARTER_X + (GAMECANVAS_WIDTH / 16);	 // Primera columna por donde desfilan los sprites
-	static constexpr int SECOND_COL_ = GAMECANVAS_THIRD_QUARTER_X - (GAMECANVAS_WIDTH / 16); // Segunda columna por donde desfilan los sprites
+	static constexpr int FIRST_COL_ =
+		GAMECANVAS_FIRST_QUARTER_X + (GAMECANVAS_WIDTH / 16); // Primera columna por donde desfilan los sprites
+	static constexpr int SECOND_COL_ =
+		GAMECANVAS_THIRD_QUARTER_X - (GAMECANVAS_WIDTH / 16); // Segunda columna por donde desfilan los sprites
+	static constexpr int DIST_SPRITE_TEXT_ = 8;				  // Distancia entre el sprite y el texto que lo acompaña
+	static constexpr int DIST_SPRITE_SPRITE_ = 0;			  // Distancia entre dos sprites de la misma columna
+	static constexpr float SPRITE_DESP_SPEED_ = -0.2f;		  // Velocidad de desplazamiento de los sprites
 
 	// Objetos y punteros
-	Screen *screen_;										  // Objeto encargado de dibujar en pantalla
-	SDL_Renderer *renderer_;								  // El renderizador de la ventana
-	Resource *resource_;									  // Objeto con los recursos
-	Asset *asset_;											  // Objeto con los ficheros de recursos
-	Input *input_;											  // Objeto pata gestionar la entrada
-	std::shared_ptr<Text> text_;							  // Objeto para escribir texto en pantalla
 	std::vector<std::shared_ptr<AnimatedSprite>> sprites_;	  // Vector con todos los sprites a dibujar
 	std::vector<std::shared_ptr<MovingSprite>> sprite_texts_; // Vector con los sprites de texto de los sprites
 	std::vector<std::shared_ptr<MovingSprite>> texts_;		  // Vector con los sprites de texto
@@ -40,14 +39,10 @@ private:
 	int post_counter_;					   // Contador posterior
 	bool post_counter_enabled_;			   // Indica si está habilitado el contador
 	Uint32 ticks_;						   // Contador de ticks para ajustar la velocidad del programa
-	JA_Music_t *music_;					   // Musica que suena durante el final
 	std::vector<std::string> sprite_list_; // Lista con todos los sprites a dibujar
 	std::vector<Color> colors_;			   // Vector con los colores para el fade
 	int sprite_max_width_;				   // El valor de ancho del sprite mas ancho
 	int sprite_max_height_;				   // El valor de alto del sprite mas alto
-	int dist_sprite_text_;				   // Distancia entre el sprite y el texto que lo acompaña
-	int dist_sprite_sprite_;			   // Distancia entre dos sprites de la misma columna
-	float sprite_desp_speed_;			   // Velocidad de desplazamiento de los sprites
 
 	// Actualiza el objeto
 	void update();

source/enemy.cpp

@@ -7,17 +7,17 @@
 #include "texture.h"         // for Texture
 
 // Constructor
-Enemy::Enemy(EnemyData enemy)
+Enemy::Enemy(const EnemyData &enemy)
+    : sprite_(std::make_shared<AnimatedSprite>(Resource::get()->getTexture(enemy.texture_path), Resource::get()->getAnimations(enemy.animation_path))),
+      color_string_(enemy.color),
+      x1_(enemy.x1),
+      x2_(enemy.x2),
+      y1_(enemy.y1),
+      y2_(enemy.y2),
+      should_flip_(enemy.flip),
+      should_mirror_(enemy.mirror)
 {
-    // Crea objetos
-    sprite_ = std::make_shared<AnimatedSprite>(Resource::get()->getTexture(enemy.texture_path), Resource::get()->getAnimations(enemy.animation_path));
-
     // Obten el resto de valores
-    x1_ = enemy.x1;
-    x2_ = enemy.x2;
-    y1_ = enemy.y1;
-    y2_ = enemy.y2;
-    color_string_ = enemy.color;
     setPalette(options.video.palette);
     sprite_->setPosX(enemy.x);
     sprite_->setPosY(enemy.y);
@@ -25,24 +25,16 @@ Enemy::Enemy(EnemyData enemy)
     sprite_->setVelY(enemy.vy);
     sprite_->setWidth(enemy.w);
     sprite_->setHeight(enemy.h);
-    should_flip_ = enemy.flip;
-    should_mirror_ = enemy.mirror;
 
-    const SDL_RendererFlip flip = (should_flip_ && enemy.vx < 0.0f) ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
-    const SDL_RendererFlip mirror = should_mirror_ ? SDL_FLIP_VERTICAL : SDL_FLIP_NONE;
-    sprite_->setFlip(static_cast<SDL_RendererFlip>(flip | mirror));
+    const SDL_RendererFlip FLIP = (should_flip_ && enemy.vx < 0.0f) ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
+    const SDL_RendererFlip MIRROR = should_mirror_ ? SDL_FLIP_VERTICAL : SDL_FLIP_NONE;
+    sprite_->setFlip(static_cast<SDL_RendererFlip>(FLIP | MIRROR));
 
     collider_ = getRect();
 
     // Coloca un frame al azar o el designado
-    if (enemy.frame == -1)
-    {
-        sprite_->setCurrentAnimationFrame(rand() % sprite_->getCurrentAnimationSize());
-    }
-    else
-    {
-        sprite_->setCurrentAnimationFrame(enemy.frame);
-    }
+    sprite_->setCurrentAnimationFrame(
+        (enemy.frame == -1) ? (rand() % sprite_->getCurrentAnimationSize()) : enemy.frame);
 }
 
 // Pinta el enemigo en pantalla

source/enemy.h

@@ -49,7 +49,7 @@ private:
 
 public:
 	// Constructor
-	Enemy(EnemyData enemy);
+	explicit Enemy(const EnemyData &enemy);
 
 	// Destructor
 	~Enemy() = default;

source/game.cpp

@@ -24,87 +24,38 @@
 #include "notifier.h"
 #include "global_inputs.h"
 #include "global_events.h"
-//#include "surface.h"
+// #include "surface.h"
 
 // Constructor
 Game::Game()
-	: screen_(Screen::get()),
-	  renderer_(Screen::get()->getRenderer()),
-	  asset_(Asset::get()),
-	  input_(Input::get()),
-	  resource_(Resource::get()),
-	  debug_(Debug::get()),
-	  cheevos_(Cheevos::get())
-{
-	// Inicia algunas variables
-	//test_surface_ = std::make_shared<Surface>(Screen::get()->getSurface(), "test.gif");
-	board_ = std::make_shared<ScoreboardData>();
-	board_->ini_clock = SDL_GetTicks();
+	: board_(std::make_shared<ScoreboardData>(0, 9, 0, true, Color(0, 0, 0), SDL_GetTicks(), options.cheats.jail_is_open == Cheat::CheatState::ENABLED)),
+	  scoreboard_(std::make_shared<Scoreboard>(board_)),
+	  room_tracker_(std::make_shared<RoomTracker>()),
+	  stats_(std::make_shared<Stats>(Asset::get()->get("stats.csv"), Asset::get()->get("stats_buffer.csv"))),
 #ifdef DEBUG
-	current_room_ = "03.room";
-	constexpr int X = 25;
-	constexpr int Y = 13;
-	spawn_point_ = PlayerSpawn(X * 8, Y * 8, 0, 0, 0, PlayerState::STANDING, SDL_FLIP_HORIZONTAL);
-	debug_->setEnabled(false);
+	  current_room_("03.room"),
+	  spawn_point_(PlayerSpawn(25 * BLOCK, 13 * BLOCK, 0, 0, 0, PlayerState::STANDING, SDL_FLIP_HORIZONTAL))
 #else
-	current_room_ = "03.room";
-	constexpr int X = 25;
-	constexpr int Y = 13;
-	spawn_point_ = PlayerSpawn(X * 8, Y * 8, 0, 0, 0, PlayerState::STANDING, SDL_FLIP_HORIZONTAL);
+	  current_room_("03.room"),
+	  spawn_point_(PlayerSpawn(25 * BLOCK, 13 * BLOCK, 0, 0, 0, PlayerState::STANDING, SDL_FLIP_HORIZONTAL))
 #endif
-
-	// Crea los objetos
-	ItemTracker::init();
-	scoreboard_ = std::make_shared<Scoreboard>(board_);
-	room_tracker_ = std::make_shared<RoomTracker>();
-	room_ = std::make_shared<Room>(resource_->getRoom(current_room_), board_);
-	std::string player_texture = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.png" : "player.png";
-	std::string player_animations = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.ani" : "player.ani";
-	const PlayerData player(spawn_point_, player_texture, player_animations, room_);
-	player_ = std::make_shared<Player>(player);
-	text_ = resource_->getText("smb2");
-	music_ = resource_->getMusic("game.ogg");
-	death_sound_ = resource_->getSound("death.wav");
-	stats_ = std::make_shared<Stats>(asset_->get("stats.csv"), asset_->get("stats_buffer.csv"));
-
-	// Crea la textura para poner el nombre de la habitación
-	room_name_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, text_->getCharacterSize() * 2);
-	if (room_name_texture_ == nullptr)
-	{
-		if (options.console)
-		{
-			std::cout << "Error: roomNameTexture could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
-		}
-	}
-
-	// Establece el blend mode de la textura
-	SDL_SetTextureBlendMode(room_name_texture_, SDL_BLENDMODE_BLEND);
-
-	// Establece el destino de la textura
-	room_name_rect_ = {0, PLAY_AREA_HEIGHT, GAMECANVAS_WIDTH, text_->getCharacterSize() * 2};
-
-	// Pone el nombre de la habitación en la textura
-	fillRoomNameTexture();
-
-	// Inicializa el resto de variables
-	ticks_ = 0;
-	board_->lives = 9;
+{
 #ifdef DEBUG
-	board_->lives = 9;
+	Debug::get()->setEnabled(false);
 #endif
-	board_->items = 0;
-	board_->rooms = 1;
-	board_->music = true;
-	board_->jail_is_open = options.cheats.jail_is_open == Cheat::CheatState::ENABLED;
-	setScoreBoardColor();
-	room_tracker_->addRoom(current_room_);
-	paused_ = false;
-	black_screen_ = false;
-	black_screen_counter_ = 0;
-	total_items_ = getTotalItems();
+
+	// Crea objetos e inicializa variables
+	ItemTracker::init();
+	room_ = std::make_shared<Room>(current_room_, board_);
+	initPlayer(spawn_point_, room_);
 	initStats();
-	stats_->addVisit(room_->getName());
-	cheevos_->enable(!options.cheats.enabled()); // Deshabilita los logros si hay trucos activados
+	total_items_ = getTotalItems();
+
+	createRoomNameTexture();
+	changeRoom(current_room_);
+
+	Cheevos::get()->enable(!options.cheats.enabled()); // Deshabilita los logros si hay trucos activados
+	Cheevos::get()->clearUnobtainableState();
 
 	options.section.section = Section::GAME;
 	options.section.subsection = Subsection::NONE;
@@ -123,58 +74,8 @@ void Game::checkEvents()
 	while (SDL_PollEvent(&event))
 	{
 		globalEvents::check(event);
-
 #ifdef DEBUG
-		if (event.type == SDL_KEYDOWN && event.key.repeat == 0)
-		{
-			switch (event.key.keysym.scancode)
-			{
-			case SDL_SCANCODE_G:
-				debug_->switchEnabled();
-				options.cheats.invincible = static_cast<Cheat::CheatState>(debug_->getEnabled());
-				board_->music = !debug_->getEnabled();
-				board_->music ? JA_ResumeMusic() : JA_PauseMusic();
-				break;
-
-			case SDL_SCANCODE_R:
-				resource_->reload();
-				break;
-
-			case SDL_SCANCODE_W:
-				goToRoom(BORDER_TOP);
-				break;
-
-			case SDL_SCANCODE_A:
-				goToRoom(BORDER_LEFT);
-				break;
-
-			case SDL_SCANCODE_S:
-				goToRoom(BORDER_BOTTOM);
-				break;
-
-			case SDL_SCANCODE_D:
-				goToRoom(BORDER_RIGHT);
-				break;
-
-			case SDL_SCANCODE_F6:
-				Notifier::get()->show({"ACHIEVEMENT UNLOCKED!", "I LIKE MY MULTICOLOURED FRIENDS"}, NotificationText::LEFT, 2, false, "F6");
-				break;
-
-			case SDL_SCANCODE_F7:
-				Notifier::get()->show({"ACHIEVEMENT UNLOCKED!", "I LIKE MY MULTICOLOURED FRIENDS"}, NotificationText::LEFT, 3, false, "F7");
-				break;
-
-			case SDL_SCANCODE_F8:
-				Notifier::get()->show({"JAILDESIGNER", "IS LOGGED IN"}, NotificationText::LEFT, 4, false);
-				break;
-
-			case SDL_SCANCODE_F9:
-				Notifier::get()->show({"JAILDESIGNER", "IS LOGGED IN"}, NotificationText::LEFT, 5, false);
-				break;
-			default:
-				break;
-			}
-		}
+		checkDebugEvents(event);
 #endif
 	}
 }
@@ -182,16 +83,16 @@ void Game::checkEvents()
 // Comprueba el teclado
 void Game::checkInput()
 {
-	if (input_->checkInput(input_toggle_music, REPEAT_FALSE))
+	if (Input::get()->checkInput(InputAction::TOGGLE_MUSIC, REPEAT_FALSE))
 	{
 		board_->music = !board_->music;
 		board_->music ? JA_ResumeMusic() : JA_PauseMusic();
 		Notifier::get()->show({"MUSIC " + std::string(board_->music ? "ENABLED" : "DISABLED")}, NotificationText::CENTER);
 	}
 
-	else if (input_->checkInput(input_pause, REPEAT_FALSE))
+	else if (Input::get()->checkInput(InputAction::PAUSE, REPEAT_FALSE))
 	{
-		switchPause();
+		togglePause();
 		Notifier::get()->show({std::string(paused_ ? "GAME PAUSED" : "GAME RUNNING")}, NotificationText::CENTER);
 	}
 
@@ -201,7 +102,7 @@ void Game::checkInput()
 // Bucle para el juego
 void Game::run()
 {
-	JA_PlayMusic(music_);
+	JA_PlayMusic(Resource::get()->getMusic("game.ogg"));
 	if (!board_->music)
 	{
 		JA_PauseMusic();
@@ -230,7 +131,7 @@ void Game::update()
 		checkInput();
 
 #ifdef DEBUG
-		debug_->clear();
+		Debug::get()->clear();
 #endif
 
 		// Actualiza los objetos
@@ -245,11 +146,10 @@ void Game::update()
 		checkRestoringJail();
 		checkSomeCheevos();
 		scoreboard_->update();
-		input_->update();
 
 		updateBlackScreen();
 
-		screen_->update();
+		Screen::get()->update();
 
 #ifdef DEBUG
 		updateDebugInfo();
@@ -261,8 +161,8 @@ void Game::update()
 void Game::render()
 {
 	// Prepara para dibujar el frame
-	screen_->start();
-	//test_surface_->render(0, 0, 10, 10, 64, 64);
+	Screen::get()->start();
+	// test_surface_->render(0, 0, 10, 10, 64, 64);
 
 	// Dibuja los elementos del juego en orden
 	room_->renderMap();
@@ -279,45 +179,100 @@ void Game::render()
 #endif
 
 	// Actualiza la pantalla
-	screen_->render();
+	Screen::get()->render();
 }
 
 #ifdef DEBUG
 // Pasa la información de debug
 void Game::updateDebugInfo()
 {
-	debug_->add("X = " + std::to_string(static_cast<int>(player_->x_)) + ", Y = " + std::to_string(static_cast<int>(player_->y_)));
-	debug_->add("VX = " + std::to_string(player_->vx_).substr(0, 4) + ", VY = " + std::to_string(player_->vy_).substr(0, 4));
-	debug_->add("STATE = " + std::to_string(static_cast<int>(player_->state_)));
+	Debug::get()->add("X = " + std::to_string(static_cast<int>(player_->x_)) + ", Y = " + std::to_string(static_cast<int>(player_->y_)));
+	Debug::get()->add("VX = " + std::to_string(player_->vx_).substr(0, 4) + ", VY = " + std::to_string(player_->vy_).substr(0, 4));
+	Debug::get()->add("STATE = " + std::to_string(static_cast<int>(player_->state_)));
 }
 
 // Pone la información de debug en pantalla
 void Game::renderDebugInfo()
 {
-	if (!debug_->getEnabled())
+	if (!Debug::get()->getEnabled())
 	{
 		return;
 	}
 
 	// Borra el marcador
 	SDL_Rect rect = {0, 18 * BLOCK, PLAY_AREA_WIDTH, GAMECANVAS_HEIGHT - PLAY_AREA_HEIGHT};
-	SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 255);
-	SDL_RenderFillRect(renderer_, &rect);
+	SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 0, 0, 255);
+	SDL_RenderFillRect(Screen::get()->getRenderer(), &rect);
 
 	// Pinta la rejilla
-	SDL_SetRenderDrawColor(renderer_, 255, 255, 255, 32);
+	SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 255, 255, 255, 32);
 	for (int i = 0; i < PLAY_AREA_BOTTOM; i += 8)
 	{ // Lineas horizontales
-		SDL_RenderDrawLine(renderer_, 0, i, PLAY_AREA_RIGHT, i);
+		SDL_RenderDrawLine(Screen::get()->getRenderer(), 0, i, PLAY_AREA_RIGHT, i);
 	}
 	for (int i = 0; i < PLAY_AREA_RIGHT; i += 8)
 	{ // Lineas verticales
-		SDL_RenderDrawLine(renderer_, i, 0, i, PLAY_AREA_BOTTOM - 1);
+		SDL_RenderDrawLine(Screen::get()->getRenderer(), i, 0, i, PLAY_AREA_BOTTOM - 1);
 	}
 
 	// Pinta el texto
-	debug_->setPos({1, 18 * 8});
-	debug_->render();
+	Debug::get()->setPos({1, 18 * 8});
+	Debug::get()->render();
+}
+
+// Comprueba los eventos
+void Game::checkDebugEvents(const SDL_Event &event)
+{
+	if (event.type == SDL_KEYDOWN && event.key.repeat == 0)
+	{
+		switch (event.key.keysym.scancode)
+		{
+		case SDL_SCANCODE_G:
+			Debug::get()->toggleEnabled();
+			options.cheats.invincible = static_cast<Cheat::CheatState>(Debug::get()->getEnabled());
+			board_->music = !Debug::get()->getEnabled();
+			board_->music ? JA_ResumeMusic() : JA_PauseMusic();
+			break;
+
+		case SDL_SCANCODE_R:
+			Resource::get()->reload();
+			break;
+
+		case SDL_SCANCODE_W:
+			changeRoom(room_->getRoom(BORDER_TOP));
+			break;
+
+		case SDL_SCANCODE_A:
+			changeRoom(room_->getRoom(BORDER_LEFT));
+			break;
+
+		case SDL_SCANCODE_S:
+			changeRoom(room_->getRoom(BORDER_BOTTOM));
+			break;
+
+		case SDL_SCANCODE_D:
+			changeRoom(room_->getRoom(BORDER_RIGHT));
+			break;
+
+		case SDL_SCANCODE_F6:
+			Notifier::get()->show({"ACHIEVEMENT UNLOCKED!", "I LIKE MY MULTICOLOURED FRIENDS"}, NotificationText::LEFT, 2, false, "F6");
+			break;
+
+		case SDL_SCANCODE_F7:
+			Notifier::get()->show({"ACHIEVEMENT UNLOCKED!", "I LIKE MY MULTICOLOURED FRIENDS"}, NotificationText::LEFT, 3, false, "F7");
+			break;
+
+		case SDL_SCANCODE_F8:
+			Notifier::get()->show({"JAILDESIGNER", "IS LOGGED IN"}, NotificationText::LEFT, 4, false);
+			break;
+
+		case SDL_SCANCODE_F9:
+			Notifier::get()->show({"JAILDESIGNER", "IS LOGGED IN"}, NotificationText::LEFT, 5, false);
+			break;
+		default:
+			break;
+		}
+	}
 }
 #endif
 
@@ -325,23 +280,23 @@ void Game::renderDebugInfo()
 void Game::renderRoomName()
 {
 	// Dibuja la textura con el nombre de la habitación
-	SDL_RenderCopy(renderer_, room_name_texture_, nullptr, &room_name_rect_);
+	SDL_RenderCopy(Screen::get()->getRenderer(), room_name_texture_, nullptr, &room_name_rect_);
 }
 
 // Cambia de habitación
-bool Game::changeRoom(std::string file)
+bool Game::changeRoom(const std::string &room_path)
 {
 	// En las habitaciones los limites tienen la cadena del fichero o un 0 en caso de no limitar con nada
-	if (file == "0")
+	if (room_path == "0")
 	{
 		return false;
 	}
 
 	// Verifica que exista el fichero que se va a cargar
-	if (asset_->get(file) != "")
+	if (Asset::get()->get(room_path) != "")
 	{
 		// Crea un objeto habitación nuevo a partir del fichero
-		room_ = std::make_shared<Room>(resource_->getRoom(file), board_);
+		room_ = std::make_shared<Room>(room_path, board_);
 
 		// Pone el nombre de la habitación en la textura
 		fillRoomNameTexture();
@@ -349,7 +304,7 @@ bool Game::changeRoom(std::string file)
 		// Pone el color del marcador en función del color del borde de la habitación
 		setScoreBoardColor();
 
-		if (room_tracker_->addRoom(file))
+		if (room_tracker_->addRoom(room_path))
 		{
 			// Incrementa el contador de habitaciones visitadas
 			board_->rooms++;
@@ -362,6 +317,9 @@ bool Game::changeRoom(std::string file)
 		// Pasa la nueva habitación al jugador
 		player_->setRoom(room_);
 
+		// Cambia la habitación actual
+		current_room_ = room_path;
+
 		return true;
 	}
 
@@ -377,7 +335,6 @@ void Game::checkPlayerOnBorder()
 		if (changeRoom(roomName))
 		{
 			player_->switchBorders();
-			current_room_ = roomName;
 			spawn_point_ = player_->getSpawnParams();
 		}
 	}
@@ -436,37 +393,21 @@ void Game::killPlayer()
 	stats_->addDeath(room_->getName());
 
 	// Invalida el logro de pasarse el juego sin morir
-	cheevos_->invalidate(11);
+	Cheevos::get()->setUnobtainable(11);
 
 	// Sonido
-	JA_PlaySound(death_sound_);
+	JA_PlaySound(Resource::get()->getSound("death.wav"));
 
 	// Pone la pantalla en negro un tiempo
 	setBlackScreen();
 
 	// Crea la nueva habitación y el nuevo jugador
-	room_ = std::make_shared<Room>(resource_->getRoom(current_room_), board_);
-	std::string player_texture = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.png" : "player.png";
-	std::string player_animations = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.ani" : "player.ani";
-	const PlayerData player(spawn_point_, player_texture, player_animations, room_);
-	player_ = std::make_shared<Player>(player);
+	room_ = std::make_shared<Room>(current_room_, board_);
+	initPlayer(spawn_point_, room_);
 
 	// Pone los objetos en pausa mientras esta la habitación en negro
-	room_->pause();
-	player_->pause();
-}
-
-// Recarga todas las texturas
-void Game::reLoadTextures()
-{
-	if (options.console)
-	{
-		std::cout << "** RELOAD REQUESTED" << std::endl;
-	}
-	player_->reLoadTexture();
-	room_->reLoadTexture();
-	scoreboard_->reLoadTexture();
-	text_->reLoadTexture();
+	room_->setPaused(true);
+	player_->setPaused(true);
 }
 
 // Establece la pantalla en negro
@@ -486,9 +427,9 @@ void Game::updateBlackScreen()
 			black_screen_ = false;
 			black_screen_counter_ = 0;
 
-			player_->resume();
-			room_->resume();
-			screen_->setBorderColor(room_->getBorderColor());
+			player_->setPaused(false);
+			room_->setPaused(false);
+			Screen::get()->setBorderColor(room_->getBorderColor());
 		}
 	}
 }
@@ -498,8 +439,8 @@ void Game::renderBlackScreen()
 {
 	if (black_screen_)
 	{
-		screen_->clean();
-		screen_->setBorderColor(stringToColor(options.video.palette, "black"));
+		Screen::get()->clean();
+		Screen::get()->setBorderColor(stringToColor(options.video.palette, "black"));
 	}
 }
 
@@ -544,9 +485,9 @@ bool Game::checkEndGame()
 int Game::getTotalItems()
 {
 	int items = 0;
-	auto rooms = resource_->getRooms();
+	auto rooms = Resource::get()->getRooms();
 
-	for (auto room : rooms)
+	for (const auto &room : rooms)
 	{
 		items += room.room->items.size();
 	}
@@ -554,33 +495,14 @@ int Game::getTotalItems()
 	return items;
 }
 
-// Va a la habitación designada
-void Game::goToRoom(int border)
-{
-	const std::string roomName = room_->getRoom(border);
-	if (changeRoom(roomName))
-	{
-		current_room_ = roomName;
-	}
-}
-
 // Pone el juego en pausa
-void Game::switchPause()
+void Game::togglePause()
 {
-	if (paused_)
-	{
-		player_->resume();
-		room_->resume();
-		scoreboard_->resume();
-		paused_ = false;
-	}
-	else
-	{
-		player_->pause();
-		room_->pause();
-		scoreboard_->pause();
-		paused_ = true;
-	}
+	paused_ = !paused_;
+
+	player_->setPaused(paused_);
+	room_->setPaused(paused_);
+	scoreboard_->setPaused(paused_);
 }
 
 // Da vidas al jugador cuando está en la Jail
@@ -603,13 +525,13 @@ void Game::checkRestoringJail()
 	{
 		counter = 0;
 		board_->lives++;
-		JA_PlaySound(death_sound_);
+		JA_PlaySound(Resource::get()->getSound("death.wav"));
 
 		// Invalida el logro de completar el juego sin entrar a la jail
 		const bool haveTheItems = board_->items >= int(total_items_ * 0.9f);
 		if (!haveTheItems)
 		{
-			cheevos_->invalidate(9);
+			Cheevos::get()->setUnobtainable(9);
 		}
 	}
 }
@@ -617,9 +539,9 @@ void Game::checkRestoringJail()
 // Inicializa el diccionario de las estadísticas
 void Game::initStats()
 {
-	auto rooms = resource_->getRooms();
+	auto rooms = Resource::get()->getRooms();
 
-	for (auto room : rooms)
+	for (const auto &room : rooms)
 	{
 		stats_->addDictionary(room.room->number, room.room->name);
 	}
@@ -631,86 +553,120 @@ void Game::initStats()
 void Game::fillRoomNameTexture()
 {
 	// Pone la textura como destino de renderizado
-	SDL_SetRenderTarget(renderer_, room_name_texture_);
+	SDL_SetRenderTarget(Screen::get()->getRenderer(), room_name_texture_);
 
 	// Rellena la textura de color
 	const Color color = stringToColor(options.video.palette, "white");
-	SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 0xFF);
-	SDL_RenderClear(renderer_);
+	SDL_SetRenderDrawColor(Screen::get()->getRenderer(), color.r, color.g, color.b, 0xFF);
+	SDL_RenderClear(Screen::get()->getRenderer());
 
 	// Escribe el texto en la textura
-	text_->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, text_->getCharacterSize() / 2, room_->getName(), 1, room_->getBGColor());
+	auto text = Resource::get()->getText("smb2");
+	text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, text->getCharacterSize() / 2, room_->getName(), 1, room_->getBGColor());
 
 	// Deja el renderizador por defecto
-	SDL_SetRenderTarget(renderer_, nullptr);
+	SDL_SetRenderTarget(Screen::get()->getRenderer(), nullptr);
 }
 
 // Comprueba algunos logros
 void Game::checkSomeCheevos()
 {
+	auto cheevos = Cheevos::get();
+
 	// Logros sobre la cantidad de items
 	if (board_->items == total_items_)
 	{
-		cheevos_->unlock(4);
-		cheevos_->unlock(3);
-		cheevos_->unlock(2);
-		cheevos_->unlock(1);
+		cheevos->unlock(4);
+		cheevos->unlock(3);
+		cheevos->unlock(2);
+		cheevos->unlock(1);
 	}
 	else if (board_->items >= total_items_ * 0.75f)
 	{
-		cheevos_->unlock(3);
-		cheevos_->unlock(2);
-		cheevos_->unlock(1);
+		cheevos->unlock(3);
+		cheevos->unlock(2);
+		cheevos->unlock(1);
 	}
 	else if (board_->items >= total_items_ * 0.5f)
 	{
-		cheevos_->unlock(2);
-		cheevos_->unlock(1);
+		cheevos->unlock(2);
+		cheevos->unlock(1);
 	}
 	else if (board_->items >= total_items_ * 0.25f)
 	{
-		cheevos_->unlock(1);
+		cheevos->unlock(1);
 	}
 
 	// Logros sobre las habitaciones visitadas
 	if (board_->rooms >= 60)
 	{
-		cheevos_->unlock(7);
-		cheevos_->unlock(6);
-		cheevos_->unlock(5);
+		cheevos->unlock(7);
+		cheevos->unlock(6);
+		cheevos->unlock(5);
 	}
 	else if (board_->rooms >= 40)
 	{
-		cheevos_->unlock(6);
-		cheevos_->unlock(5);
+		cheevos->unlock(6);
+		cheevos->unlock(5);
 	}
 	else if (board_->rooms >= 20)
 	{
-		cheevos_->unlock(5);
+		cheevos->unlock(5);
 	}
 }
 
 // Comprueba los logros de completar el juego
 void Game::checkEndGameCheevos()
 {
+	auto cheevos = Cheevos::get();
+
 	// "Complete the game"
-	cheevos_->unlock(8);
+	cheevos->unlock(8);
 
 	// "Complete the game without entering the jail"
-	cheevos_->unlock(9);
+	cheevos->unlock(9);
 
 	// "Complete the game with all items"
 	if (board_->items == total_items_)
 	{
-		cheevos_->unlock(10);
+		cheevos->unlock(10);
 	}
 
 	// "Complete the game without dying"
-	cheevos_->unlock(11);
+	cheevos->unlock(11);
 
 	// "Complete the game in under 30 minutes"
 	if (scoreboard_->getMinutes() < 30)
 	{
-		cheevos_->unlock(12);
+		cheevos->unlock(12);
 	}
 }
+
+// Inicializa al jugador
+void Game::initPlayer(const PlayerSpawn &spawn_point, std::shared_ptr<Room> room)
+{
+	std::string player_texture = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.png" : "player.png";
+	std::string player_animations = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.ani" : "player.ani";
+	const PlayerData player(spawn_point, player_texture, player_animations, room);
+	player_ = std::make_shared<Player>(player);
+}
+
+// Crea la textura para poner el nombre de la habitación
+void Game::createRoomNameTexture()
+{
+	auto text = Resource::get()->getText("smb2");
+	room_name_texture_ = SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, text->getCharacterSize() * 2);
+	if (room_name_texture_ == nullptr)
+	{
+		if (options.console)
+		{
+			std::cout << "Error: room_name_texture_ could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
+		}
+	}
+
+	// Establece el blend mode de la textura
+	SDL_SetTextureBlendMode(room_name_texture_, SDL_BLENDMODE_BLEND);
+
+	// Establece el destino de la textura
+	room_name_rect_ = {0, PLAY_AREA_HEIGHT, GAMECANVAS_WIDTH, text->getCharacterSize() * 2};
+}

source/game.h

@@ -8,7 +8,6 @@
 #include "player.h"			 // Para playerSpawn_t
 #include "scoreboard.h"		 // Para board_t
 #include "room.h"
-//#include "surface.h"
 class Asset;
 class Cheevos;
 class Debug;
@@ -29,34 +28,23 @@ class Game
 {
 private:
 	// Objetos y punteros
-	Screen *screen_;							// Objeto encargado de manejar el renderizador
-	SDL_Renderer *renderer_;					// El renderizador de la ventana
-	Asset *asset_;								// Objeto con la ruta a todos los ficheros de recursos
-	Input *input_;								// Objeto pata gestionar la entrada
-	Resource *resource_;						// Objeto con los recursos
-	Debug *debug_;								// Objeto para gestionar la información de debug
-	Cheevos *cheevos_;							// Objeto encargado de gestionar los logros del juego
+	std::shared_ptr<ScoreboardData> board_;		// Estructura con los datos del marcador
+	std::shared_ptr<Scoreboard> scoreboard_;	// Objeto encargado de gestionar el marcador
+	std::shared_ptr<RoomTracker> room_tracker_; // Lleva el control de las habitaciones visitadas
 	std::shared_ptr<Room> room_;				// Objeto encargado de gestionar cada habitación del juego
 	std::shared_ptr<Player> player_;			// Objeto con el jugador
-	std::shared_ptr<RoomTracker> room_tracker_; // Lleva el control de las habitaciones visitadas
-	std::shared_ptr<Text> text_;				// Objeto para los textos del juego
-	std::shared_ptr<Scoreboard> scoreboard_;	// Objeto encargado de gestionar el marcador
 	std::shared_ptr<Stats> stats_;				// Objeto encargado de gestionar las estadísticas
 	SDL_Texture *room_name_texture_;			// Textura para escribir el nombre de la habitación
-	//std::shared_ptr<Surface> test_surface_;
 
 	// Variables
-	JA_Music_t *music_;						// Musica que suena durante el juego
-	Uint32 ticks_;							// Contador de ticks para ajustar la velocidad del programa
-	std::string current_room_;				// Fichero de la habitación actual
-	PlayerSpawn spawn_point_;				// Lugar de la habitación donde aparece el jugador
-	JA_Sound_t *death_sound_;				// Sonido a reproducir cuando muere el jugador
-	std::shared_ptr<ScoreboardData> board_; // Estructura con los datos del marcador
-	bool paused_;							// Indica si el juego se encuentra en pausa
-	bool black_screen_;						// Indica si la pantalla está en negro. Se utiliza para la muerte del jugador
-	int black_screen_counter_;				// Contador para temporizar la pantalla en negro
-	int total_items_;						// Cantidad total de items que hay en el mapeado del juego
-	SDL_Rect room_name_rect_;				// Rectangulo donde pintar la textura con el nombre de la habitación
+	Uint32 ticks_ = 0;			   // Contador de ticks para ajustar la velocidad del programa
+	std::string current_room_;	   // Fichero de la habitación actual
+	PlayerSpawn spawn_point_;	   // Lugar de la habitación donde aparece el jugador
+	bool paused_ = false;		   // Indica si el juego se encuentra en pausa
+	bool black_screen_ = false;	   // Indica si la pantalla está en negro. Se utiliza para la muerte del jugador
+	int black_screen_counter_ = 0; // Contador para temporizar la pantalla en negro
+	int total_items_;			   // Cantidad total de items que hay en el mapeado del juego
+	SDL_Rect room_name_rect_;	   // Rectangulo donde pintar la textura con el nombre de la habitación
 
 	// Actualiza el juego, las variables, comprueba la entrada, etc.
 	void update();
@@ -73,13 +61,16 @@ private:
 
 	// Pone la información de debug en pantalla
 	void renderDebugInfo();
+
+	// Comprueba los eventos
+	void checkDebugEvents(const SDL_Event &event);
 #endif
 
 	// Escribe el nombre de la pantalla
 	void renderRoomName();
 
 	// Cambia de habitación
-	bool changeRoom(std::string file);
+	bool changeRoom(const std::string &file);
 
 	// Comprueba el teclado
 	void checkInput();
@@ -102,9 +93,6 @@ private:
 	// Mata al jugador
 	void killPlayer();
 
-	// Recarga todas las texturas
-	void reLoadTextures();
-
 	// Establece la pantalla en negro
 	void setBlackScreen();
 
@@ -123,11 +111,8 @@ private:
 	// Obtiene la cantidad total de items que hay en el mapeado del juego
 	int getTotalItems();
 
-	// Va a la habitación designada
-	void goToRoom(int border);
-
 	// Pone el juego en pausa
-	void switchPause();
+	void togglePause();
 
 	// Da vidas al jugador cuando está en la Jail
 	void checkRestoringJail();
@@ -144,6 +129,12 @@ private:
 	// Comprueba los logros de completar el juego
 	void checkEndGameCheevos();
 
+	// Inicializa al jugador
+	void initPlayer(const PlayerSpawn &spawn_point, std::shared_ptr<Room> room);
+
+	// Crea la textura para poner el nombre de la habitación
+	void createRoomNameTexture();
+
 public:
 	// Constructor
 	Game();

source/game_over.cpp

@@ -18,34 +18,25 @@
 
 // Constructor
 GameOver::GameOver()
-    : screen_(Screen::get()),
-      renderer_(Screen::get()->getRenderer()),
-      resource_(Resource::get()),
-      asset_(Asset::get()),
-      input_(Input::get())
+    : player_sprite_(std::make_shared<AnimatedSprite>(Resource::get()->getTexture("player_game_over.png"), Resource::get()->getAnimations("player_game_over.ani"))),
+      tv_sprite_(std::make_shared<AnimatedSprite>(Resource::get()->getTexture("tv.png"), Resource::get()->getAnimations("tv.ani"))),
+      pre_counter_(0),
+      counter_(0),
+      ticks_(0)
 {
-    // Reserva memoria para los punteros a objetos
-    text_ = resource_->getText("smb2");
-    player_sprite_ = std::make_shared<AnimatedSprite>(resource_->getTexture("player_game_over.png"), resource_->getAnimations("player_game_over.ani"));
-    tv_sprite_ = std::make_shared<AnimatedSprite>(resource_->getTexture("tv.png"), resource_->getAnimations("tv.ani"));
-    music_ = resource_->getMusic("game_over.ogg");
-
-    // Inicializa variables
-    pre_counter_ = 0;
-    counter_ = 0;
     options.section.section = Section::GAME_OVER;
     options.section.subsection = Subsection::NONE;
-    ticks_ = 0;
+    
     player_sprite_->setPosX(GAMECANVAS_CENTER_X + 10);
     player_sprite_->setPosY(30);
     tv_sprite_->setPosX(GAMECANVAS_CENTER_X - tv_sprite_->getWidth() - 10);
     tv_sprite_->setPosY(30);
 
     // Inicializa el vector de colores
-    const std::vector<std::string> colorList = {"white", "yellow", "cyan", "green", "magenta", "red", "blue", "black"};
-    for (auto cl : colorList)
+    const std::vector<std::string> COLORS = {"white", "yellow", "cyan", "green", "magenta", "red", "blue", "black"};
+    for (const auto &color : COLORS)
     {
-        colors_.push_back(stringToColor(options.video.palette, cl));
+        colors_.push_back(stringToColor(options.video.palette, color));
     }
     color_ = colors_.back();
 }
@@ -72,7 +63,7 @@ void GameOver::update()
         player_sprite_->update();
         tv_sprite_->update();
 
-        screen_->update();
+        Screen::get()->update();
     }
 }
 
@@ -81,11 +72,13 @@ void GameOver::render()
 {
     constexpr int Y = 32;
 
-    screen_->start();
-    screen_->clean();
+    Screen::get()->start();
+    Screen::get()->clean();
+
+    auto text = Resource::get()->getText("smb2");
 
     // Escribe el texto de GAME OVER
-    text_->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y, "G A M E   O V E R", 1, color_);
+    text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y, "G A M E   O V E R", 1, color_);
 
     // Dibuja los sprites
     player_sprite_->setPosY(Y + 30);
@@ -95,15 +88,15 @@ void GameOver::render()
     // Escribe el texto con las habitaciones y los items
     const std::string itemsTxt = std::to_string(options.stats.items / 100) + std::to_string((options.stats.items % 100) / 10) + std::to_string(options.stats.items % 10);
     const std::string roomsTxt = std::to_string(options.stats.rooms / 100) + std::to_string((options.stats.rooms % 100) / 10) + std::to_string(options.stats.rooms % 10);
-    text_->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 80, "ITEMS: " + itemsTxt, 1, color_);
-    text_->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 90, "ROOMS: " + roomsTxt, 1, color_);
+    text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 80, "ITEMS: " + itemsTxt, 1, color_);
+    text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 90, "ROOMS: " + roomsTxt, 1, color_);
 
     // Escribe el texto con "Tu peor pesadilla"
-    text_->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 110, "YOUR WORST NIGHTMARE IS", 1, color_);
-    text_->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 120, options.stats.worst_nightmare, 1, color_);
+    text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 110, "YOUR WORST NIGHTMARE IS", 1, color_);
+    text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 120, options.stats.worst_nightmare, 1, color_);
 
     // Vuelca el contenido del renderizador en pantalla
-    screen_->render();
+    Screen::get()->render();
 }
 
 // Comprueba el manejador de eventos
@@ -178,7 +171,7 @@ void GameOver::updateCounters()
     // Hace sonar la música
     if (counter_ == 1)
     {
-        JA_PlayMusic(music_, 0);
+        JA_PlayMusic(Resource::get()->getMusic("game_over.ogg"), 0);
     }
 
     // Comprueba si ha terminado la sección

source/game_over.h

@@ -22,12 +22,6 @@ private:
 	static constexpr int COUNTER_FADE_LENGHT_ = 20;	 // Contador: duración del fade
 
 	// Objetos y punteros
-	Screen *screen_;								// Objeto encargado de dibujar en pantalla
-	SDL_Renderer *renderer_;						// El renderizador de la ventana
-	Resource *resource_;							// Objeto con los recursos
-	Asset *asset_;									// Objeto con los ficheros de recursos
-	Input *input_;									// Objeto pata gestionar la entrada
-	std::shared_ptr<Text> text_;					// Objeto para escribir texto en pantalla
 	std::shared_ptr<AnimatedSprite> player_sprite_; // Sprite con el jugador
 	std::shared_ptr<AnimatedSprite> tv_sprite_;		// Sprite con el televisor
 
@@ -37,7 +31,6 @@ private:
 	Uint32 ticks_ = 0;			// Contador de ticks para ajustar la velocidad del programa
 	std::vector<Color> colors_; // Vector con los colores para el fade
 	Color color_;				// Color usado para el texto y los sprites
-	JA_Music_t *music_;			// Musica que suena durante el juego
 
 	// Actualiza el objeto
 	void update();

source/global_inputs.cpp

@@ -54,29 +54,29 @@ namespace globalInputs
     // Comprueba los inputs que se pueden introducir en cualquier sección del juego
     void check()
     {
-        if (Input::get()->checkInput(input_exit, REPEAT_FALSE))
+        if (Input::get()->checkInput(InputAction::EXIT, REPEAT_FALSE))
         {
             quit();
         }
 
-        else if (Input::get()->checkInput(input_accept, REPEAT_FALSE))
+        else if (Input::get()->checkInput(InputAction::ACCEPT, REPEAT_FALSE))
         {
             skip_section();
         }
 
-        else if (Input::get()->checkInput(input_toggle_border, REPEAT_FALSE))
+        else if (Input::get()->checkInput(InputAction::TOGGLE_BORDER, REPEAT_FALSE))
         {
             Screen::get()->toggleBorder();
             Notifier::get()->show({"BORDER " + std::string(options.video.border.enabled ? "ENABLED" : "DISABLED")}, NotificationText::CENTER);
         }
 
-        else if (Input::get()->checkInput(input_toggle_videomode, REPEAT_FALSE))
+        else if (Input::get()->checkInput(InputAction::TOGGLE_VIDEOMODE, REPEAT_FALSE))
         {
             Screen::get()->toggleVideoMode();
             Notifier::get()->show({"FULLSCREEN " + std::string(options.video.mode == 0 ? "DISABLED" : "ENABLED")}, NotificationText::CENTER);
         }
 
-        else if (Input::get()->checkInput(input_window_dec_size, REPEAT_FALSE))
+        else if (Input::get()->checkInput(InputAction::WINDOW_DEC_ZOOM, REPEAT_FALSE))
         {
             if (Screen::get()->decWindowZoom())
             {
@@ -84,7 +84,7 @@ namespace globalInputs
             }
         }
 
-        else if (Input::get()->checkInput(input_window_inc_size, REPEAT_FALSE))
+        else if (Input::get()->checkInput(InputAction::WINDOW_INC_ZOOM, REPEAT_FALSE))
         {
             if (Screen::get()->incWindowZoom())
             {
@@ -92,13 +92,13 @@ namespace globalInputs
             }
         }
 
-        else if (Input::get()->checkInput(input_toggle_shaders, REPEAT_FALSE))
+        else if (Input::get()->checkInput(InputAction::TOGGLE_SHADERS, REPEAT_FALSE))
         {
             Screen::get()->toggleShaders();
             Notifier::get()->show({"SHADERS " + std::string(options.video.shaders ? "ENABLED" : "DISABLED")}, NotificationText::CENTER);
         }
 
-        else if (Input::get()->checkInput(input_toggle_palette, REPEAT_FALSE))
+        else if (Input::get()->checkInput(InputAction::TOGGLE_PALETTE, REPEAT_FALSE))
         {
             switchPalette();
             Notifier::get()->show({"PALETTE " + std::string(options.video.palette == Palette::ZXSPECTRUM ? "ZX SPECTRUM" : "ZX ARNE")}, NotificationText::CENTER);

source/input.cpp

@@ -35,37 +35,28 @@ Input::Input(const std::string &game_controller_db_path)
 	keyBindings_t kb;
 	kb.scancode = 0;
 	kb.active = false;
-	key_bindings_.resize(input_number_of_inputs, kb);
+	key_bindings_.resize(static_cast<int>(InputAction::SIZE), kb);
 
 	GameControllerBindings_t gcb;
 	gcb.button = SDL_CONTROLLER_BUTTON_INVALID;
 	gcb.active = false;
-	game_controller_bindings_.resize(input_number_of_inputs, gcb);
-}
-
-// Actualiza el estado del objeto
-void Input::update()
-{
-	if (disabled_until_ == d_keyPressed && !checkAnyInput())
-	{
-		enable();
-	}
+	game_controller_bindings_.resize(static_cast<int>(InputAction::SIZE), gcb);
 }
 
 // Asigna inputs a teclas
-void Input::bindKey(Uint8 input, SDL_Scancode code)
+void Input::bindKey(InputAction input, SDL_Scancode code)
 {
-	key_bindings_[input].scancode = code;
+	key_bindings_.at(static_cast<int>(input)).scancode = code;
 }
 
 // Asigna inputs a botones del mando
-void Input::bindGameControllerButton(Uint8 input, SDL_GameControllerButton button)
+void Input::bindGameControllerButton(InputAction input, SDL_GameControllerButton button)
 {
-	game_controller_bindings_[input].button = button;
+	game_controller_bindings_.at(static_cast<int>(input)).button = button;
 }
 
 // Comprueba si un input esta activo
-bool Input::checkInput(Uint8 input, bool repeat, int device, int index)
+bool Input::checkInput(InputAction input, bool repeat, int device, int index)
 {
 	if (!enabled_)
 	{
@@ -86,7 +77,7 @@ bool Input::checkInput(Uint8 input, bool repeat, int device, int index)
 
 		if (repeat)
 		{
-			if (keyStates[key_bindings_[input].scancode] != 0)
+			if (keyStates[key_bindings_.at(static_cast<int>(input)).scancode] != 0)
 			{
 				successKeyboard = true;
 			}
@@ -97,11 +88,11 @@ bool Input::checkInput(Uint8 input, bool repeat, int device, int index)
 		}
 		else
 		{
-			if (!key_bindings_[input].active)
+			if (!key_bindings_.at(static_cast<int>(input)).active)
 			{
-				if (keyStates[key_bindings_[input].scancode] != 0)
+				if (keyStates[key_bindings_.at(static_cast<int>(input)).scancode] != 0)
 				{
-					key_bindings_[input].active = true;
+					key_bindings_.at(static_cast<int>(input)).active = true;
 					successKeyboard = true;
 				}
 				else
@@ -111,9 +102,9 @@ bool Input::checkInput(Uint8 input, bool repeat, int device, int index)
 			}
 			else
 			{
-				if (keyStates[key_bindings_[input].scancode] == 0)
+				if (keyStates[key_bindings_.at(static_cast<int>(input)).scancode] == 0)
 				{
-					key_bindings_[input].active = false;
+					key_bindings_.at(static_cast<int>(input)).active = false;
 					successKeyboard = false;
 				}
 				else
@@ -129,7 +120,7 @@ bool Input::checkInput(Uint8 input, bool repeat, int device, int index)
 		{
 			if (repeat)
 			{
-				if (SDL_GameControllerGetButton(connected_controllers_[index], game_controller_bindings_[input].button) != 0)
+				if (SDL_GameControllerGetButton(connected_controllers_.at(index), game_controller_bindings_.at(static_cast<int>(input)).button) != 0)
 				{
 					successGameController = true;
 				}
@@ -140,11 +131,11 @@ bool Input::checkInput(Uint8 input, bool repeat, int device, int index)
 			}
 			else
 			{
-				if (!game_controller_bindings_[input].active)
+				if (!game_controller_bindings_.at(static_cast<int>(input)).active)
 				{
-					if (SDL_GameControllerGetButton(connected_controllers_[index], game_controller_bindings_[input].button) != 0)
+					if (SDL_GameControllerGetButton(connected_controllers_.at(index), game_controller_bindings_.at(static_cast<int>(input)).button) != 0)
 					{
-						game_controller_bindings_[input].active = true;
+						game_controller_bindings_.at(static_cast<int>(input)).active = true;
 						successGameController = true;
 					}
 					else
@@ -154,9 +145,9 @@ bool Input::checkInput(Uint8 input, bool repeat, int device, int index)
 				}
 				else
 				{
-					if (SDL_GameControllerGetButton(connected_controllers_[index], game_controller_bindings_[input].button) == 0)
+					if (SDL_GameControllerGetButton(connected_controllers_.at(index), game_controller_bindings_.at(static_cast<int>(input)).button) == 0)
 					{
-						game_controller_bindings_[input].active = false;
+						game_controller_bindings_.at(static_cast<int>(input)).active = false;
 						successGameController = false;
 					}
 					else
@@ -197,7 +188,7 @@ bool Input::checkAnyInput(int device, int index)
 		{
 			for (int i = 0; i < (int)game_controller_bindings_.size(); ++i)
 			{
-				if (SDL_GameControllerGetButton(connected_controllers_[index], game_controller_bindings_[i].button) != 0)
+				if (SDL_GameControllerGetButton(connected_controllers_.at(index), game_controller_bindings_[i].button) != 0)
 				{
 					return true;
 				}
@@ -317,17 +308,3 @@ void Input::setVerbose(bool value)
 {
 	verbose_ = value;
 }
-
-// Deshabilita las entradas durante un periodo de tiempo
-void Input::disableUntil(i_disable_e value)
-{
-	disabled_until_ = value;
-	enabled_ = false;
-}
-
-// Hablita las entradas
-void Input::enable()
-{
-	enabled_ = true;
-	disabled_until_ = d_notDisabled;
-}

source/input.h

@@ -15,38 +15,31 @@ constexpr int INPUT_USE_KEYBOARD = 0;
 constexpr int INPUT_USE_GAMECONTROLLER = 1;
 constexpr int INPUT_USE_ANY = 2;
 
-enum inputs_e
+enum class InputAction
 {
 	// Inputs obligatorios
-	input_null,
-	input_up,
-	input_down,
-	input_left,
-	input_right,
-	input_pause,
-	input_exit,
-	input_accept,
-	input_cancel,
+	NONE,
+	UP,
+	DOWN,
+	LEFT,
+	RIGHT,
+	PAUSE,
+	EXIT,
+	ACCEPT,
+	CANCEL,
 
 	// Inputs personalizados
-	input_jump,
-	input_window_inc_size,
-	input_window_dec_size,
-	input_toggle_videomode,
-	input_toggle_border,
-	input_toggle_music,
-	input_toggle_palette,
-	input_toggle_shaders,
+	JUMP,
+	WINDOW_INC_ZOOM,
+	WINDOW_DEC_ZOOM,
+	TOGGLE_VIDEOMODE,
+	TOGGLE_BORDER,
+	TOGGLE_MUSIC,
+	TOGGLE_PALETTE,
+	TOGGLE_SHADERS,
 
 	// Input obligatorio
-	input_number_of_inputs
-};
-
-enum i_disable_e
-{
-	d_notDisabled,
-	d_forever,
-	d_keyPressed
+	SIZE
 };
 
 class Input
@@ -74,10 +67,9 @@ private:
 	std::vector<keyBindings_t> key_bindings_;						 // Vector con las teclas asociadas a los inputs predefinidos
 	std::vector<GameControllerBindings_t> game_controller_bindings_; // Vector con las teclas asociadas a los inputs predefinidos
 	std::vector<std::string> controller_names_;						 // Vector con los nombres de los mandos
-	int num_gamepads_;												 // Numero de mandos conectados
+	int num_gamepads_ = 0;											 // Numero de mandos conectados
 	std::string db_path_;											 // Ruta al archivo gamecontrollerdb.txt
 	bool verbose_ = true;											 // Indica si ha de mostrar mensajes
-	i_disable_e disabled_until_;									 // Tiempo que esta deshabilitado
 	bool enabled_ = true;											 // Indica si está habilitado
 
 	// Constructor
@@ -96,17 +88,14 @@ public:
 	// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
 	static Input *get();
 
-	// Actualiza el estado del objeto
-	void update();
-
 	// Asigna inputs a teclas
-	void bindKey(Uint8 input, SDL_Scancode code);
+	void bindKey(InputAction input, SDL_Scancode code);
 
 	// Asigna inputs a botones del mando
-	void bindGameControllerButton(Uint8 input, SDL_GameControllerButton button);
+	void bindGameControllerButton(InputAction input, SDL_GameControllerButton button);
 
 	// Comprueba si un input esta activo
-	bool checkInput(Uint8 input, bool repeat = true, int device = INPUT_USE_ANY, int index = 0);
+	bool checkInput(InputAction input, bool repeat = true, int device = INPUT_USE_ANY, int index = 0);
 
 	// Comprueba si hay almenos un input activo
 	bool checkAnyInput(int device = INPUT_USE_ANY, int index = 0);
@@ -125,10 +114,4 @@ public:
 
 	// Establece si ha de mostrar mensajes
 	void setVerbose(bool value);
-
-	// Deshabilita las entradas durante un periodo de tiempo
-	void disableUntil(i_disable_e value);
-
-	// Hablita las entradas
-	void enable();
 };

source/item.cpp

@@ -5,16 +5,12 @@
 
 // Constructor
 Item::Item(ItemData item)
+    : sprite_(std::make_shared<Sprite>(Resource::get()->getTexture(item.tile_set_file), item.x, item.y, ITEM_SIZE_, ITEM_SIZE_)),
+      change_color_speed(4)
 {
-    constexpr int ITEMSIZE = 8;
-
-    // Crea objetos;
-    sprite_ = std::make_shared<Sprite>(Resource::get()->getTexture(item.tile_set_file), item.x, item.y, ITEMSIZE, ITEMSIZE);
-
     // Inicia variables
-    sprite_->setClip((item.tile % 10) * ITEMSIZE, (item.tile / 10) * ITEMSIZE, ITEMSIZE, ITEMSIZE);
+    sprite_->setClip((item.tile % 10) * ITEM_SIZE_, (item.tile / 10) * ITEM_SIZE_, ITEM_SIZE_, ITEM_SIZE_);
     collider_ = sprite_->getRect();
-    change_color_speed = 4;
     counter_ = item.counter * change_color_speed;
 
     // Inicializa los colores
@@ -28,8 +24,8 @@ Item::Item(ItemData item)
 // Pinta el objeto en pantalla
 void Item::render()
 {
-    const int index = (counter_ / change_color_speed) % color_.size();
-    sprite_->getTexture()->setColor(color_[index].r, color_[index].g, color_[index].b);
+    const int INDEX = (counter_ / change_color_speed) % color_.size();
+    sprite_->getTexture()->setColor(color_.at(INDEX).r, color_.at(INDEX).g, color_.at(INDEX).b);
     sprite_->render();
     sprite_->getTexture()->setColor(255, 255, 255);
 }

source/item.h

@@ -11,13 +11,13 @@
 
 struct ItemData
 {
-	std::string tile_set_file;		  // Ruta al fichero con los gráficos del item
-	int x;							  // Posición del item en pantalla
-	int y;							  // Posición del item en pantalla
-	int tile;						  // Número de tile dentro de la textura
-	int counter;					  // Contador inicial. Es el que lo hace cambiar de color
-	Color color1;					  // Uno de los dos colores que se utiliza para el item
-	Color color2;					  // Uno de los dos colores que se utiliza para el item
+	std::string tile_set_file; // Ruta al fichero con los gráficos del item
+	int x;					   // Posición del item en pantalla
+	int y;					   // Posición del item en pantalla
+	int tile;				   // Número de tile dentro de la textura
+	int counter;			   // Contador inicial. Es el que lo hace cambiar de color
+	Color color1;			   // Uno de los dos colores que se utiliza para el item
+	Color color2;			   // Uno de los dos colores que se utiliza para el item
 
 	// Constructor
 	ItemData() : x(0), y(0), tile(0), counter(0), color1(), color2() {}
@@ -26,6 +26,9 @@ struct ItemData
 class Item
 {
 private:
+	// Constantes
+	static constexpr int ITEM_SIZE_ = 8;
+
 	// Objetos y punteros
 	std::shared_ptr<Sprite> sprite_; // Sprite del objeto
 
@@ -37,7 +40,7 @@ private:
 
 public:
 	// Constructor
-	Item(ItemData item);
+	explicit Item(ItemData item);
 
 	// Destructor
 	~Item() = default;

source/item_tracker.cpp

@@ -57,7 +57,7 @@ void ItemTracker::addItem(const std::string &name, SDL_Point pos)
 }
 
 // Busca una entrada en la lista por nombre
-int ItemTracker::findByName(std::string name)
+int ItemTracker::findByName(const std::string &name)
 {
     int i = 0;
 

source/item_tracker.h

@@ -27,7 +27,7 @@ private:
 	std::vector<ItemTrackerData> item_list_; // Lista con todos los objetos recogidos
 
 	// Busca una entrada en la lista por nombre
-	int findByName(std::string name);
+	int findByName(const std::string &name);
 
 	// Busca una entrada en la lista por posición
 	int findByPos(int index, SDL_Point pos);

source/loading_screen.cpp

@@ -1,54 +1,46 @@
 #include "loading_screen.h"
-#include <SDL2/SDL_events.h>  // for SDL_PollEvent, SDL_Event
-#include <SDL2/SDL_timer.h>   // for SDL_GetTicks
-#include <stdlib.h>           // for rand
-#include "asset.h"            // for Asset
-#include "defines.h"          // for GAMECANVAS_HEIGHT, GAMECANVAS_WIDTH
-#include "global_events.h"    // for check
-#include "global_inputs.h"    // for check
-#include "input.h"            // for Input
-#include "jail_audio.h"       // for JA_PlayMusic, JA_SetVolume, JA_StopMusic
-#include "options.h"          // for Options, options, OptionsVideo, Section...
-#include "resource.h"         // for Resource
-#include "screen.h"           // for Screen
-#include "sprite.h"           // for Sprite
-#include "texture.h"          // for Texture
-#include "utils.h"            // for Color, stringToColor, Palette
+#include <SDL2/SDL_events.h> // for SDL_PollEvent, SDL_Event
+#include <SDL2/SDL_timer.h>	 // for SDL_GetTicks
+#include <stdlib.h>			 // for rand
+#include "asset.h"			 // for Asset
+#include "defines.h"		 // for GAMECANVAS_HEIGHT, GAMECANVAS_WIDTH
+#include "global_events.h"	 // for check
+#include "global_inputs.h"	 // for check
+#include "input.h"			 // for Input
+#include "jail_audio.h"		 // for JA_PlayMusic, JA_SetVolume, JA_StopMusic
+#include "options.h"		 // for Options, options, OptionsVideo, Section...
+#include "resource.h"		 // for Resource
+#include "screen.h"			 // for Screen
+#include "sprite.h"			 // for Sprite
+#include "texture.h"		 // for Texture
+#include "utils.h"			 // for Color, stringToColor, Palette
 #include <iostream>
 
 // Constructor
 LoadingScreen::LoadingScreen()
-	: screen_(Screen::get()),
-	  renderer_(Screen::get()->getRenderer()),
-	  resource_(Resource::get()),
-	  asset_(Asset::get()),
-	  input_(Input::get())
 {
 	// Reserva memoria para los punteros
 	if (options.video.palette == Palette::ZXSPECTRUM)
 	{
-		mono_loading_screen_texture_ = resource_->getTexture("loading_screen_bn.png");
-		color_loading_screen_texture_ = resource_->getTexture("loading_screen_color.png");
+		mono_loading_screen_texture_ = Resource::get()->getTexture("loading_screen_bn.png");
+		color_loading_screen_texture_ = Resource::get()->getTexture("loading_screen_color.png");
 	}
 	else if (options.video.palette == Palette::ZXARNE)
 	{
-		mono_loading_screen_texture_ = resource_->getTexture("loading_screen_bn_zxarne.png");
-		color_loading_screen_texture_ = resource_->getTexture("loading_screen_color_zxarne.png");
+		mono_loading_screen_texture_ = Resource::get()->getTexture("loading_screen_bn_zxarne.png");
+		color_loading_screen_texture_ = Resource::get()->getTexture("loading_screen_color_zxarne.png");
 	}
 	mono_loading_screen_sprite_ = std::make_shared<Sprite>(mono_loading_screen_texture_, 0, 0, mono_loading_screen_texture_->getWidth(), mono_loading_screen_texture_->getHeight());
 	color_loading_screen_sprite_ = std::make_shared<Sprite>(color_loading_screen_texture_, 0, 0, color_loading_screen_texture_->getWidth(), color_loading_screen_texture_->getHeight());
-	loading_sound1_ = resource_->getMusic("loading_sound1.ogg");
-	loading_sound2_ = resource_->getMusic("loading_sound2.ogg");
-	loading_sound3_ = resource_->getMusic("loading_sound3.ogg");
 
-	texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, options.game.width, options.game.height);
-    if (texture_ == nullptr)
-    {
-        if (options.console)
-        {
-            std::cout << "LoadingScreen::texture_ could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
-        }
-    }
+	texture_ = SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, options.game.width, options.game.height);
+	if (texture_ == nullptr)
+	{
+		if (options.console)
+		{
+			std::cout << "LoadingScreen::texture_ could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
+		}
+	}
 	clearTexture();
 
 	// Inicializa variables
@@ -62,20 +54,18 @@ LoadingScreen::LoadingScreen()
 		{ // Primer bloque de 2K
 			line_index_[i] = ((i % 8) * 8) + (i / 8);
 		}
-
-		else if (i >= 64 && i < 128)
+		else if (i < 128)
 		{ // Segundo bloque de 2K
 			line_index_[i] = 64 + ((i % 8) * 8) + ((i - 64) / 8);
 		}
-
-		else if (i >= 128 && i < 192)
-		{ // tercer bloque de 2K
+		else
+		{ // Tercer bloque de 2K
 			line_index_[i] = 128 + ((i % 8) * 8) + ((i - 128) / 8);
 		}
 	}
 
 	// Cambia el color del borde
-	screen_->setBorderColor(stringToColor(options.video.palette, "black"));
+	Screen::get()->setBorderColor(stringToColor(options.video.palette, "black"));
 }
 
 // Destructor
@@ -127,7 +117,7 @@ void LoadingScreen::updateLoad()
 			load_rect_ = {0, 0, 16, 8};
 			color_loading_screen_sprite_->setClip(load_rect_);
 			color_loading_screen_sprite_->setPosition(load_rect_);
-			JA_PlayMusic(loading_sound3_);
+			JA_PlayMusic(Resource::get()->getMusic("loading_sound3.ogg"));
 		}
 	}
 	// Segunda parte de la carga, la parte de los bloques en color
@@ -156,7 +146,7 @@ void LoadingScreen::updateCounter()
 
 	if (counter_ == 1)
 	{
-		JA_PlayMusic(loading_sound2_);
+		JA_PlayMusic(Resource::get()->getMusic("loading_sound2.ogg"));
 	}
 }
 
@@ -169,30 +159,32 @@ void LoadingScreen::renderLoad()
 // Dibuja el efecto de carga en el borde
 void LoadingScreen::renderBorder()
 {
-	// Pinta el borde de colro azul
-	Color color = stringToColor(options.video.palette, "blue");
-	SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 0xFF);
-	SDL_RenderClear(renderer_);
+    // Pinta el borde de colro azul
+    Color color = stringToColor(options.video.palette, "blue");
+    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), color.r, color.g, color.b, 0xFF);
+    SDL_RenderClear(Screen::get()->getRenderer());
 
-	// Añade lineas amarillas
-	color = stringToColor(options.video.palette, "yellow");
-	SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 0xFF);
-	const int width = options.game.width + (options.video.border.width * 2);
-	const int height = options.game.height + (options.video.border.height * 2);
-	bool drawEnabled = rand() % 2 == 0 ? true : false;
-	int row = 0;
-	int rowSize = 1;
-	while (row < height)
-	{
-		rowSize = (rand() % 4) + 3;
-		if (drawEnabled)
-			for (int i = row; i < row + rowSize; ++i)
-			{
-				SDL_RenderDrawLine(renderer_, 0, i, width, i);
-			}
-		row += rowSize;
-		drawEnabled = !drawEnabled;
-	}
+    // Añade lineas amarillas
+    color = stringToColor(options.video.palette, "yellow");
+    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), color.r, color.g, color.b, 0xFF);
+    const int WIDTH = options.game.width + (options.video.border.width * 2);
+    const int HEIGHT = options.game.height + (options.video.border.height * 2);
+    bool drawEnabled = rand() % 2 == 0 ? true : false;
+
+    int row = 0;
+    while (row < HEIGHT)
+    {
+        const int ROW_HEIGHT = (rand() % 4) + 3;
+        if (drawEnabled)
+        {
+            for (int i = row; i < row + ROW_HEIGHT; ++i)
+            {
+                SDL_RenderDrawLine(Screen::get()->getRenderer(), 0, i, WIDTH, i);
+            }
+        }
+        row += ROW_HEIGHT;
+        drawEnabled = !drawEnabled;
+    }
 }
 
 // Actualiza las variables
@@ -206,7 +198,7 @@ void LoadingScreen::update()
 		updateCounter();
 		updateLoad();
 		fillTexture();
-		screen_->update();
+		Screen::get()->update();
 	}
 }
 
@@ -216,20 +208,20 @@ void LoadingScreen::render()
 	if (options.video.border.enabled)
 	{
 		// Prepara para empezar a dibujar en la textura del borde
-		screen_->startDrawOnBorder();
+		Screen::get()->startDrawOnBorder();
 
 		// Dibuja el efecto de carga en el borde
 		renderBorder();
 	}
 
 	// Prepara para empezar a dibujar en la textura de juego
-	screen_->start();
+	Screen::get()->start();
 
 	// Copila la textura a la pantalla
-	SDL_RenderCopy(renderer_, texture_, nullptr, nullptr);
+	SDL_RenderCopy(Screen::get()->getRenderer(), texture_, nullptr, nullptr);
 
 	// Vuelca el contenido del renderizador en pantalla
-	screen_->render();
+	Screen::get()->render();
 }
 
 // Bucle para el logo del juego
@@ -237,12 +229,12 @@ void LoadingScreen::run()
 {
 	// Inicia el sonido de carga
 	JA_SetVolume(64);
-	JA_PlayMusic(loading_sound1_);
+	JA_PlayMusic(Resource::get()->getMusic("loading_sound1.ogg"));
 
 	// Limpia la pantalla
-	screen_->start();
-	screen_->clean();
-	screen_->render();
+	Screen::get()->start();
+	Screen::get()->clean();
+	Screen::get()->render();
 
 	while (options.section.section == Section::LOADING_SCREEN)
 	{
@@ -254,70 +246,31 @@ void LoadingScreen::run()
 	JA_SetVolume(128);
 }
 
-// Reconstruye la pantalla de carga
-void LoadingScreen::recreateLoadingScreen()
-{
-	// Prepara para empezar a dibujar en la textura de juego
-	screen_->start();
-
-	// Primera parte de la carga, la parte en blanco y negro
-	if (loading_first_part_)
-	{
-		const int numSteps = 5;
-		const int step = 51;
-
-		for (int i = 0; i <= counter_; i++)
-		{
-			load_counter_ = i / numSteps;
-			load_rect_.x = step * (i % numSteps);
-			load_rect_.y = line_index_[load_counter_];
-			mono_loading_screen_sprite_->setClip(load_rect_);
-			mono_loading_screen_sprite_->setPosition(load_rect_);
-			mono_loading_screen_sprite_->render();
-		}
-	}
-	// Segunda parte de la carga, la parte de los bloques en color
-	else
-	{
-		for (int i = 0; i <= load_counter_; i++)
-		{
-			load_rect_.x = (i * 8) % 256;
-			load_rect_.y = (i / 32) * 8;
-			color_loading_screen_sprite_->setClip(load_rect_);
-			color_loading_screen_sprite_->setPosition(load_rect_);
-			color_loading_screen_sprite_->render();
-		}
-	}
-
-	// Vuelca el contenido del renderizador en pantalla
-	screen_->render();
-}
-
 // Dibuja sobre la textura
 void LoadingScreen::fillTexture()
 {
 	// Empieza a dibujar en la textura
-    auto temp = SDL_GetRenderTarget(renderer_);
-    SDL_SetRenderTarget(renderer_, texture_);
+	auto temp = SDL_GetRenderTarget(Screen::get()->getRenderer());
+	SDL_SetRenderTarget(Screen::get()->getRenderer(), texture_);
 
 	// Dibuja la pantalla de carga
 	renderLoad();
 
 	// Deja el renderizador como estaba
-    SDL_SetRenderTarget(renderer_, temp);
+	SDL_SetRenderTarget(Screen::get()->getRenderer(), temp);
 }
 
 // Limpia la textura
 void LoadingScreen::clearTexture()
 {
 	// Empieza a dibujar en la textura
-    auto temp = SDL_GetRenderTarget(renderer_);
-    SDL_SetRenderTarget(renderer_, texture_);
+	auto temp = SDL_GetRenderTarget(Screen::get()->getRenderer());
+	SDL_SetRenderTarget(Screen::get()->getRenderer(), texture_);
 
 	// Limpia
-	SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
-	SDL_RenderClear(renderer_);
+	SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0x00, 0x00, 0x00, 0xFF);
+	SDL_RenderClear(Screen::get()->getRenderer());
 
 	// Deja el renderizador como estaba
-    SDL_SetRenderTarget(renderer_, temp);
+	SDL_SetRenderTarget(Screen::get()->getRenderer(), temp);
 }

source/loading_screen.h

@@ -16,11 +16,6 @@ class LoadingScreen
 {
 private:
 	// Objetos y punteros
-	Screen *screen_;										// Objeto encargado de dibujar en pantalla
-	SDL_Renderer *renderer_;								// El renderizador de la ventana
-	Resource *resource_;									// Objeto con los recursos
-	Asset *asset_;											// Objeto con los ficheros de recursos
-	Input *input_;											// Objeto pata gestionar la entrada
 	std::shared_ptr<Texture> mono_loading_screen_texture_;	// Textura con la pantalla de carga en blanco y negro
 	std::shared_ptr<Texture> color_loading_screen_texture_; // Textura con la pantalla de carga en color
 	std::shared_ptr<Sprite> mono_loading_screen_sprite_;	// Sprite para manejar la textura loadingScreenTexture1
@@ -32,9 +27,6 @@ private:
 	Uint32 ticks_ = 0;					 // Contador de ticks para ajustar la velocidad del programa
 	int load_counter_ = 0;				 // Contador para controlar las cargas
 	bool loading_first_part_ = true;	 // Para saber en que parte de la carga se encuentra
-	JA_Music_t *loading_sound1_;		 // Sonidos para imitar la carga tipo spectrum
-	JA_Music_t *loading_sound2_;		 // Sonidos para imitar la carga tipo spectrum
-	JA_Music_t *loading_sound3_;		 // Sonidos para imitar la carga tipo spectrum
 	int line_index_[192];				 // El orden en el que se procesan las 192 lineas de la pantalla de carga
 	SDL_Rect load_rect_ = {0, 0, 51, 1}; // Rectangulo para dibujar la pantalla de carga
 	SDL_Texture *texture_;				 // Textura para dibujar la pantalla de carga
@@ -63,9 +55,6 @@ private:
 	// Dibuja el efecto de carga en el borde
 	void renderBorder();
 
-	// Reconstruye la pantalla de carga
-	void recreateLoadingScreen();
-
 	// Dibuja sobre la textura
 	void fillTexture();
 

source/logo.cpp

@@ -17,16 +17,10 @@
 
 // Constructor
 Logo::Logo()
-	: screen_(Screen::get()),
-	  renderer_(Screen::get()->getRenderer()),
-	  resource_(Resource::get()),
-	  asset_(Asset::get()),
-	  input_(Input::get())
+	: jailgames_texture_(Resource::get()->getTexture("jailgames.png")),
+	  since_1998_texture_(Resource::get()->getTexture("since_1998.png")),
+	  since_1998_sprite_(std::make_shared<Sprite>(since_1998_texture_, (256 - since_1998_texture_->getWidth()) / 2, 83 + jailgames_texture_->getHeight() + 5, since_1998_texture_->getWidth(), since_1998_texture_->getHeight()))
 {
-	// Reserva memoria para los punteros
-	jailgames_texture_ = resource_->getTexture("jailgames.png");
-	since_1998_texture_ = resource_->getTexture("since_1998.png");
-	since_1998_sprite_ = std::make_shared<Sprite>(since_1998_texture_, (256 - since_1998_texture_->getWidth()) / 2, 83 + jailgames_texture_->getHeight() + 5, since_1998_texture_->getWidth(), since_1998_texture_->getHeight());
 	since_1998_sprite_->setClip(0, 0, since_1998_texture_->getWidth(), since_1998_texture_->getHeight());
 	since_1998_texture_->setColor(0, 0, 0);
 
@@ -35,29 +29,22 @@ Logo::Logo()
 	{
 		jailgames_sprite_.push_back(std::make_shared<Sprite>(jailgames_texture_, 0, i, jailgames_texture_->getWidth(), 1));
 		jailgames_sprite_.back()->setClip(0, i, jailgames_texture_->getWidth(), 1);
-		if (i % 2 == 0)
-		{
-			jailgames_sprite_[i]->setX(256 + (i * 3));
-		}
-		else
-		{
-			jailgames_sprite_[i]->setX(-181 - (i * 3));
-		}
-		jailgames_sprite_[i]->setY(83 + i);
+		jailgames_sprite_.at(i)->setX((i % 2 == 0) ? (256 + (i * 3)) : (-181 - (i * 3)));
+		jailgames_sprite_.at(i)->setY(83 + i);
 	}
 
 	// Inicializa variables
 	options.section.section = Section::LOGO;
 
 	// Inicializa el vector de colores
-	const std::vector<std::string> vColors = {"black", "blue", "red", "magenta", "green", "cyan", "yellow", "bright_white"};
-	for (auto v : vColors)
+	const std::vector<std::string> COLORS = {"black", "blue", "red", "magenta", "green", "cyan", "yellow", "bright_white"};
+	for (const auto &color : COLORS)
 	{
-		color_.push_back(stringToColor(options.video.palette, v));
+		color_.push_back(stringToColor(options.video.palette, color));
 	}
 
 	// Cambia el color del borde
-	screen_->setBorderColor(stringToColor(options.video.palette, "black"));
+	Screen::get()->setBorderColor(stringToColor(options.video.palette, "black"));
 }
 
 // Comprueba el manejador de eventos
@@ -83,24 +70,24 @@ void Logo::updateJAILGAMES()
 	{
 		for (int i = 1; i < (int)jailgames_sprite_.size(); ++i)
 		{
-			const int speed = 8;
-			const int dest = 37;
-			if (jailgames_sprite_[i]->getX() != 37)
+			constexpr int SPEED = 8;
+			constexpr int DEST = 37;
+			if (jailgames_sprite_.at(i)->getX() != 37)
 			{
 				if (i % 2 == 0)
 				{
-					jailgames_sprite_[i]->incX(-speed);
-					if (jailgames_sprite_[i]->getX() < dest)
+					jailgames_sprite_.at(i)->incX(-SPEED);
+					if (jailgames_sprite_.at(i)->getX() < DEST)
 					{
-						jailgames_sprite_[i]->setX(dest);
+						jailgames_sprite_.at(i)->setX(DEST);
 					}
 				}
 				else
 				{
-					jailgames_sprite_[i]->incX(speed);
-					if (jailgames_sprite_[i]->getX() > dest)
+					jailgames_sprite_.at(i)->incX(SPEED);
+					if (jailgames_sprite_.at(i)->getX() > DEST)
 					{
-						jailgames_sprite_[i]->setX(dest);
+						jailgames_sprite_.at(i)->setX(DEST);
 					}
 				}
 			}
@@ -111,89 +98,89 @@ void Logo::updateJAILGAMES()
 // Gestiona el color de las texturas
 void Logo::updateTextureColors()
 {
-	const int ini = 70;
-	const int inc = 4;
+	constexpr int INI = 70;
+	constexpr int INC = 4;
 
-	if (counter_ == ini + inc * 0)
+	if (counter_ == INI + INC * 0)
 	{
-		since_1998_texture_->setColor(color_[0].r, color_[0].g, color_[0].b);
+		since_1998_texture_->setColor(color_.at(0).r, color_.at(0).g, color_.at(0).b);
 	}
 
-	else if (counter_ == ini + inc * 1)
+	else if (counter_ == INI + INC * 1)
 	{
-		since_1998_texture_->setColor(color_[1].r, color_[1].g, color_[1].b);
+		since_1998_texture_->setColor(color_.at(1).r, color_.at(1).g, color_.at(1).b);
 	}
 
-	else if (counter_ == ini + inc * 2)
+	else if (counter_ == INI + INC * 2)
 	{
-		since_1998_texture_->setColor(color_[2].r, color_[2].g, color_[2].b);
+		since_1998_texture_->setColor(color_.at(2).r, color_.at(2).g, color_.at(2).b);
 	}
 
-	else if (counter_ == ini + inc * 3)
+	else if (counter_ == INI + INC * 3)
 	{
-		since_1998_texture_->setColor(color_[3].r, color_[3].g, color_[3].b);
+		since_1998_texture_->setColor(color_.at(3).r, color_.at(3).g, color_.at(3).b);
 	}
 
-	else if (counter_ == ini + inc * 4)
+	else if (counter_ == INI + INC * 4)
 	{
-		since_1998_texture_->setColor(color_[4].r, color_[4].g, color_[4].b);
+		since_1998_texture_->setColor(color_.at(4).r, color_.at(4).g, color_.at(4).b);
 	}
 
-	else if (counter_ == ini + inc * 5)
+	else if (counter_ == INI + INC * 5)
 	{
-		since_1998_texture_->setColor(color_[5].r, color_[5].g, color_[5].b);
+		since_1998_texture_->setColor(color_.at(5).r, color_.at(5).g, color_.at(5).b);
 	}
 
-	else if (counter_ == ini + inc * 6)
+	else if (counter_ == INI + INC * 6)
 	{
-		since_1998_texture_->setColor(color_[6].r, color_[6].g, color_[6].b);
+		since_1998_texture_->setColor(color_.at(6).r, color_.at(6).g, color_.at(6).b);
 	}
 
-	else if (counter_ == ini + inc * 7)
+	else if (counter_ == INI + INC * 7)
 	{
-		since_1998_texture_->setColor(color_[7].r, color_[7].g, color_[7].b);
+		since_1998_texture_->setColor(color_.at(7).r, color_.at(7).g, color_.at(7).b);
 	}
 
-	else if (counter_ == INIT_FADE_ + inc * 0)
+	else if (counter_ == INIT_FADE_ + INC * 0)
 	{
-		jailgames_texture_->setColor(color_[6].r, color_[6].g, color_[6].b);
-		since_1998_texture_->setColor(color_[6].r, color_[6].g, color_[6].b);
+		jailgames_texture_->setColor(color_.at(6).r, color_.at(6).g, color_.at(6).b);
+		since_1998_texture_->setColor(color_.at(6).r, color_.at(6).g, color_.at(6).b);
 	}
 
-	else if (counter_ == INIT_FADE_ + inc * 1)
+	else if (counter_ == INIT_FADE_ + INC * 1)
 	{
-		jailgames_texture_->setColor(color_[5].r, color_[5].g, color_[5].b);
-		since_1998_texture_->setColor(color_[5].r, color_[5].g, color_[5].b);
+		jailgames_texture_->setColor(color_.at(5).r, color_.at(5).g, color_.at(5).b);
+		since_1998_texture_->setColor(color_.at(5).r, color_.at(5).g, color_.at(5).b);
 	}
 
-	else if (counter_ == INIT_FADE_ + inc * 2)
+	else if (counter_ == INIT_FADE_ + INC * 2)
 	{
-		jailgames_texture_->setColor(color_[4].r, color_[4].g, color_[4].b);
-		since_1998_texture_->setColor(color_[4].r, color_[4].g, color_[4].b);
+		jailgames_texture_->setColor(color_.at(4).r, color_.at(4).g, color_.at(4).b);
+		since_1998_texture_->setColor(color_.at(4).r, color_.at(4).g, color_.at(4).b);
 	}
 
-	else if (counter_ == INIT_FADE_ + inc * 3)
+	else if (counter_ == INIT_FADE_ + INC * 3)
 	{
-		jailgames_texture_->setColor(color_[3].r, color_[3].g, color_[3].b);
-		since_1998_texture_->setColor(color_[3].r, color_[3].g, color_[3].b);
+		jailgames_texture_->setColor(color_.at(3).r, color_.at(3).g, color_.at(3).b);
+		since_1998_texture_->setColor(color_.at(3).r, color_.at(3).g, color_.at(3).b);
 	}
 
-	else if (counter_ == INIT_FADE_ + inc * 4)
+	else if (counter_ == INIT_FADE_ + INC * 4)
 	{
-		jailgames_texture_->setColor(color_[2].r, color_[2].g, color_[2].b);
-		since_1998_texture_->setColor(color_[2].r, color_[2].g, color_[2].b);
+		jailgames_texture_->setColor(color_.at(2).r, color_.at(2).g, color_.at(2).b);
+		since_1998_texture_->setColor(color_.at(2).r, color_.at(2).g, color_.at(2).b);
 	}
 
-	else if (counter_ == INIT_FADE_ + inc * 5)
+	else if (counter_ == INIT_FADE_ + INC * 5)
 	{
-		jailgames_texture_->setColor(color_[1].r, color_[1].g, color_[1].b);
-		since_1998_texture_->setColor(color_[1].r, color_[1].g, color_[1].b);
+		jailgames_texture_->setColor(color_.at(1).r, color_.at(1).g, color_.at(1).b);
+		since_1998_texture_->setColor(color_.at(1).r, color_.at(1).g, color_.at(1).b);
 	}
 
-	else if (counter_ == INIT_FADE_ + inc * 6)
+	else if (counter_ == INIT_FADE_ + INC * 6)
 	{
-		jailgames_texture_->setColor(color_[0].r, color_[0].g, color_[0].b);
-		since_1998_texture_->setColor(color_[0].r, color_[0].g, color_[0].b);
+		jailgames_texture_->setColor(color_.at(0).r, color_.at(0).g, color_.at(0).b);
+		since_1998_texture_->setColor(color_.at(0).r, color_.at(0).g, color_.at(0).b);
 	}
 }
 
@@ -218,7 +205,7 @@ void Logo::update()
 		// Gestiona el color de las texturas
 		updateTextureColors();
 
-		screen_->update();
+		Screen::get()->update();
 
 		// Comprueba si ha terminado el logo
 		if (counter_ == END_LOGO_ + POST_LOGO_)
@@ -232,10 +219,10 @@ void Logo::update()
 void Logo::render()
 {
 	// Prepara para empezar a dibujar en la textura de juego
-	screen_->start();
+	Screen::get()->start();
 
 	// Limpia la pantalla
-	screen_->clean();
+	Screen::get()->clean();
 
 	// Dibuja los objetos
 	for (auto s : jailgames_sprite_)
@@ -245,7 +232,7 @@ void Logo::render()
 	since_1998_sprite_->render();
 
 	// Vuelca el contenido del renderizador en pantalla
-	screen_->render();
+	Screen::get()->render();
 }
 
 // Bucle para el logo del juego

source/logo.h

@@ -21,11 +21,6 @@ private:
 	static constexpr int POST_LOGO_ = 20;  // Tiempo que dura el logo con el fade al maximo
 
 	// Objetos y punteros
-	Screen *screen_;										// Objeto encargado de dibujar en pantalla
-	SDL_Renderer *renderer_;								// El renderizador de la ventana
-	Resource *resource_;									// Objeto con los recursos
-	Asset *asset_;											// Objeto con los ficheros de recursos
-	Input *input_;											// Objeto pata gestionar la entrada
 	std::shared_ptr<Texture> jailgames_texture_;			// Textura con los graficos "JAILGAMES"
 	std::shared_ptr<Texture> since_1998_texture_;			// Textura con los graficos "Since 1998"
 	std::vector<std::shared_ptr<Sprite>> jailgames_sprite_; // Vector con los sprites de cada linea que forman el bitmap JAILGAMES

source/notifier.cpp

@@ -35,8 +35,7 @@ Notifier *Notifier::get()
 
 // Constructor
 Notifier::Notifier(const std::string &icon_file, const std::string &text)
-    : renderer_(Screen::get()->getRenderer()),
-      icon_texture_(!icon_file.empty() ? Resource::get()->getTexture(icon_file) : nullptr),
+    : icon_texture_(!icon_file.empty() ? Resource::get()->getTexture(icon_file) : nullptr),
       text_(Resource::get()->getText(text)),
       bg_color_(options.notifications.color),
       wait_time_(150),
@@ -84,8 +83,8 @@ void Notifier::update()
         // Comprueba los estados
         if (notifications_[i].state == NotificationStatus::RISING)
         {
-            //const float step = ((float)notifications_[i].counter / notifications_[i].travel_dist);
-            //const int alpha = 255 * step;
+            // const float step = ((float)notifications_[i].counter / notifications_[i].travel_dist);
+            // const int alpha = 255 * step;
             constexpr int ALPHA = 255;
 
             if (options.notifications.getVerticalPosition() == NotificationPosition::TOP)
@@ -117,11 +116,10 @@ void Notifier::update()
         else if (notifications_[i].state == NotificationStatus::VANISHING)
         {
 
-            //const float step = (notifications_[i].counter / (float)notifications_[i].travel_dist);
-            //const int ALPHA = 255 * (1 - step);
+            // const float step = (notifications_[i].counter / (float)notifications_[i].travel_dist);
+            // const int ALPHA = 255 * (1 - step);
             constexpr int ALPHA = 255;
 
-
             if (options.notifications.getVerticalPosition() == NotificationPosition::TOP)
             {
                 notifications_[i].rect.y--;
@@ -235,34 +233,34 @@ void Notifier::show(std::vector<std::string> texts, NotificationText text_is, in
     n.rect = {desp_h, y_pos, width, height};
 
     // Crea la textura
-    n.texture = std::make_shared<Texture>(renderer_);
+    n.texture = std::make_shared<Texture>(Screen::get()->getRenderer());
     n.texture->createBlank(width, height, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
     n.texture->setBlendMode(SDL_BLENDMODE_BLEND);
 
     // Prepara para dibujar en la textura
-    n.texture->setAsRenderTarget(renderer_);
+    n.texture->setAsRenderTarget(Screen::get()->getRenderer());
 
     // Dibuja el fondo de la notificación
-    SDL_SetRenderDrawColor(renderer_, bg_color_.r, bg_color_.g, bg_color_.b, 255);
+    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), bg_color_.r, bg_color_.g, bg_color_.b, 255);
     SDL_Rect rect;
     if (shape == NotificationShape::ROUNDED)
     {
         rect = {4, 0, width - (4 * 2), height};
-        SDL_RenderFillRect(renderer_, &rect);
+        SDL_RenderFillRect(Screen::get()->getRenderer(), &rect);
 
         rect = {4 / 2, 1, width - 4, height - 2};
-        SDL_RenderFillRect(renderer_, &rect);
+        SDL_RenderFillRect(Screen::get()->getRenderer(), &rect);
 
         rect = {1, 4 / 2, width - 2, height - 4};
-        SDL_RenderFillRect(renderer_, &rect);
+        SDL_RenderFillRect(Screen::get()->getRenderer(), &rect);
 
         rect = {0, 4, width, height - (4 * 2)};
-        SDL_RenderFillRect(renderer_, &rect);
+        SDL_RenderFillRect(Screen::get()->getRenderer(), &rect);
     }
 
     else if (shape == NotificationShape::SQUARED)
     {
-        SDL_RenderClear(renderer_);
+        SDL_RenderClear(Screen::get()->getRenderer());
     }
 
     // Dibuja el icono de la notificación
@@ -291,7 +289,7 @@ void Notifier::show(std::vector<std::string> texts, NotificationText text_is, in
     }
 
     // Deja de dibujar en la textura
-    SDL_SetRenderTarget(renderer_, nullptr);
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), nullptr);
 
     // Crea el sprite de la notificación
     n.sprite = std::make_shared<Sprite>(n.texture, n.rect);

source/notifier.h

@@ -62,9 +62,6 @@ private:
 			  can_be_removed(true), height(0) {}
 	};
 
-	// Objetos y punteros
-	SDL_Renderer *renderer_; // El renderizador de la ventana
-
 	std::shared_ptr<Texture> icon_texture_; // Textura para los iconos de las notificaciones
 	std::shared_ptr<Text> text_;			// Objeto para dibujar texto
 

source/options.cpp

@@ -39,7 +39,6 @@ bool loadOptionsFromFile(const std::string &file_path)
     options.version = "";
 
     // Variables para manejar el fichero
-    std::string line;
     std::ifstream file(file_path);
     
     // Si el fichero se puede abrir
@@ -50,6 +49,7 @@ bool loadOptionsFromFile(const std::string &file_path)
         {
             std::cout << "Reading file config.txt\n";
         }
+        std::string line;
         while (std::getline(file, line))
         {
             // Elimina espacios en blanco iniciales y finales

source/options.h

@@ -71,7 +71,7 @@ constexpr int DEFAULT_BORDER_WIDTH = 32;
 constexpr int DEFAULT_BORDER_HEIGHT = 24;                                                        // Alto del borde por defecto
 constexpr int DEFAULT_SOUND_VOLUME = 100;                                                        // Volumen por defecto de los efectos de sonido
 constexpr bool DEFAULT_SOUND_ENABLED = true;                                                     // Sonido habilitado por defecto
-constexpr int DEFAULT_MUSIC_VOLUME = 80;                                                        // Volumen por defecto de la musica
+constexpr int DEFAULT_MUSIC_VOLUME = 80;                                                         // Volumen por defecto de la musica
 constexpr bool DEFAULT_MUSIC_ENABLED = true;                                                     // Musica habilitada por defecto
 constexpr int DEFAULT_AUDIO_VOLUME = 100;                                                        // Volumen por defecto
 constexpr bool DEFAULT_AUDIO_ENABLED = true;                                                     // Audio por defecto
@@ -83,7 +83,7 @@ constexpr NotificationPosition DEFAULT_NOTIFICATION_POSITION = NotificationPosit
 constexpr bool DEFAULT_NOTIFICATION_SOUND = true;                                                // Sonido de las notificaciones por defecto
 const Color DEFAULT_NOTIFICATION_COLOR = Color(48, 48, 48);                                      // Color de las notificaciones por defecto
 constexpr bool DEFAULT_CONSOLE = false;                                                          // Consola desactivada por defecto
-constexpr const char *DEFAULT_VERSION = "1.09";                                                  // Versión por defecto
+constexpr const char *DEFAULT_VERSION = "1.10";                                                  // Versión por defecto
 
 // Estructura para las opciones de las notificaciones
 struct OptionsNotification
@@ -212,10 +212,10 @@ struct OptionsStats
           worst_nightmare("") {}
 
     // Constructor
-    OptionsStats(int r, int i, std::string wn)
-        : rooms(r),
-          items(i),
-          worst_nightmare(wn) {}
+    OptionsStats(int rooms, int items, const std::string &worst_nightmare)
+        : rooms(rooms),
+          items(items),
+          worst_nightmare(worst_nightmare) {}
 };
 
 // Estructura con opciones de la ventana

source/player.cpp

@@ -16,12 +16,8 @@
 #include "screen.h"
 
 // Constructor
-Player::Player(PlayerData player)
-    : renderer_(Screen::get()->getRenderer()),
-      input_(Input::get()),
-      asset_(Asset::get()),
-      debug_(Debug::get()),
-      room_(player.room)
+Player::Player(const PlayerData &player)
+    : room_(player.room)
 {
     // Inicializa algunas variables
     initSprite(player.texture_path, player.animations_path);
@@ -82,13 +78,13 @@ void Player::checkInput()
     if (!auto_movement_)
     {
         // Comprueba las entradas de desplazamiento lateral solo en el caso de no estar enganchado a una superficie automatica
-        if (input_->checkInput(input_left))
+        if (Input::get()->checkInput(InputAction::LEFT))
         {
             vx_ = -0.6f;
             sprite_->setFlip(SDL_FLIP_HORIZONTAL);
         }
 
-        else if (input_->checkInput(input_right))
+        else if (Input::get()->checkInput(InputAction::RIGHT))
         {
             vx_ = 0.6f;
             sprite_->setFlip(SDL_FLIP_NONE);
@@ -119,7 +115,7 @@ void Player::checkInput()
         }
     }
 
-    if (input_->checkInput(input_jump))
+    if (Input::get()->checkInput(InputAction::JUMP))
     {
         // Solo puede saltar si ademas de estar (state == s_standing)
         // Esta sobre el suelo, rampa o suelo que se mueve
@@ -469,8 +465,8 @@ void Player::move()
     collider_box_ = getRect(); // Actualiza el rectangulo de colisión
 
 #ifdef DEBUG
-    debug_->add("RECT_X: " + std::to_string(debug_rect_x_.x) + "," + std::to_string(debug_rect_x_.y) + "," + std::to_string(debug_rect_x_.w) + "," + std::to_string(debug_rect_x_.h));
-    debug_->add("RECT_Y: " + std::to_string(debug_rect_y_.x) + "," + std::to_string(debug_rect_y_.y) + "," + std::to_string(debug_rect_y_.w) + "," + std::to_string(debug_rect_y_.h));
+    Debug::get()->add("RECT_X: " + std::to_string(debug_rect_x_.x) + "," + std::to_string(debug_rect_x_.y) + "," + std::to_string(debug_rect_x_.w) + "," + std::to_string(debug_rect_x_.h));
+    Debug::get()->add("RECT_Y: " + std::to_string(debug_rect_y_.x) + "," + std::to_string(debug_rect_y_.y) + "," + std::to_string(debug_rect_y_.w) + "," + std::to_string(debug_rect_y_.h));
 #endif
 }
 
@@ -510,7 +506,7 @@ void Player::playJumpSound()
     }
 
 #ifdef DEBUG
-    debug_->add("JUMP: " + std::to_string(jumping_counter_ / 4));
+    Debug::get()->add("JUMP: " + std::to_string(jumping_counter_ / 4));
 #endif
 }
 
@@ -523,7 +519,7 @@ void Player::playFallSound()
     }
 
 #ifdef DEBUG
-    debug_->add("FALL: " + std::to_string(falling_counter_ / 4));
+    Debug::get()->add("FALL: " + std::to_string(falling_counter_ / 4));
 #endif
 }
 
@@ -550,17 +546,17 @@ bool Player::isOnFloor()
 #ifdef DEBUG
     if (onFloor)
     {
-        debug_->add("ON_FLOOR");
+        Debug::get()->add("ON_FLOOR");
     }
 
     if (onSlopeL)
     {
-        debug_->add("ON_SLOPE_L: " + std::to_string(under_feet_[0].x) + "," + std::to_string(under_feet_[0].y));
+        Debug::get()->add("ON_SLOPE_L: " + std::to_string(under_feet_[0].x) + "," + std::to_string(under_feet_[0].y));
     }
 
     if (onSlopeR)
     {
-        debug_->add("ON_SLOPE_R: " + std::to_string(under_feet_[1].x) + "," + std::to_string(under_feet_[1].y));
+        Debug::get()->add("ON_SLOPE_R: " + std::to_string(under_feet_[1].x) + "," + std::to_string(under_feet_[1].y));
     }
 #endif
 
@@ -583,7 +579,7 @@ bool Player::isOnAutoSurface()
 #ifdef DEBUG
     if (onAutoSurface)
     {
-        debug_->add("ON_AUTO_SURFACE");
+        Debug::get()->add("ON_AUTO_SURFACE");
     }
 #endif
 
@@ -609,7 +605,7 @@ bool Player::isOnDownSlope()
 #ifdef DEBUG
     if (onSlope)
     {
-        debug_->add("ON_DOWN_SLOPE");
+        Debug::get()->add("ON_DOWN_SLOPE");
     }
 #endif
 
@@ -744,34 +740,36 @@ void Player::initSprite(const std::string &texture_path, const std::string &anim
 // Pinta la información de debug del jugador
 void Player::renderDebugInfo()
 {
-    if (debug_->getEnabled())
+    if (Debug::get()->getEnabled())
     {
+        auto renderer = Screen::get()->getRenderer();
+
         // Pinta los underfeet
-        SDL_SetRenderDrawColor(renderer_, 255, 0, 255, 255);
-        SDL_RenderDrawPoint(renderer_, under_feet_[0].x, under_feet_[0].y);
-        SDL_RenderDrawPoint(renderer_, under_feet_[1].x, under_feet_[1].y);
+        SDL_SetRenderDrawColor(renderer, 255, 0, 255, 255);
+        SDL_RenderDrawPoint(renderer, under_feet_[0].x, under_feet_[0].y);
+        SDL_RenderDrawPoint(renderer, under_feet_[1].x, under_feet_[1].y);
 
         // Pinta rectangulo del jugador
-        SDL_SetRenderDrawColor(renderer_, debug_color_.r, debug_color_.g, debug_color_.b, 192);
+        SDL_SetRenderDrawColor(renderer, debug_color_.r, debug_color_.g, debug_color_.b, 192);
         SDL_Rect rect = getRect();
-        SDL_RenderFillRect(renderer_, &rect);
-        SDL_SetRenderDrawColor(renderer_, 0, 255, 255, 255);
-        SDL_RenderDrawRect(renderer_, &rect);
+        SDL_RenderFillRect(renderer, &rect);
+        SDL_SetRenderDrawColor(renderer, 0, 255, 255, 255);
+        SDL_RenderDrawRect(renderer, &rect);
 
         // Pinta el rectangulo de movimiento
-        SDL_SetRenderDrawColor(renderer_, 255, 0, 0, 255);
+        SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
         if (vx_ != 0.0f)
         {
-            SDL_RenderFillRect(renderer_, &debug_rect_x_);
+            SDL_RenderFillRect(renderer, &debug_rect_x_);
         }
         if (vy_ != 0.0f)
         {
-            SDL_RenderFillRect(renderer_, &debug_rect_y_);
+            SDL_RenderFillRect(renderer, &debug_rect_y_);
         }
 
         // Pinta el punto de debug
-        SDL_SetRenderDrawColor(renderer_, rand() % 256, rand() % 256, rand() % 256, 255);
-        SDL_RenderDrawPoint(renderer_, debug_point_.x, debug_point_.y);
+        SDL_SetRenderDrawColor(renderer, rand() % 256, rand() % 256, rand() % 256, 255);
+        SDL_RenderDrawPoint(renderer, debug_point_.x, debug_point_.y);
     }
 }
 #endif

source/player.h

@@ -63,10 +63,6 @@ public:
 	static constexpr float MAX_VY_ = 1.2f;				  // Velocidad máxima que puede alcanzar al desplazarse en vertical
 
 	// Objetos y punteros
-	SDL_Renderer *renderer_;				 // El renderizador de la ventana
-	Input *input_;							 // Objeto para gestionar la entrada
-	Asset *asset_;							 // Objeto con la ruta a todos los ficheros de recursos
-	Debug *debug_;							 // Objeto para gestionar la información de debug
 	std::shared_ptr<Room> room_;			 // Objeto encargado de gestionar cada habitación del juego
 	std::shared_ptr<AnimatedSprite> sprite_; // Sprite del jugador
 
@@ -168,7 +164,7 @@ public:
 
 public:
 	// Constructor
-	Player(PlayerData player);
+	explicit Player(const PlayerData &player);
 
 	// Destructor
 	~Player() = default;
@@ -210,8 +206,5 @@ public:
 	bool isAlive() { return is_alive_; }
 
 	// Pone el jugador en modo pausa
-	void pause() { is_paused_ = true; }
-
-	// Quita el modo pausa del jugador
-	void resume() { is_paused_ = false; }
+	void setPaused(bool value) { is_paused_ = value; }
 };

source/room.cpp

@@ -23,12 +23,12 @@ std::vector<int> loadRoomTileFile(const std::string &file_path, bool verbose)
 {
     std::vector<int> tileMapFile;
     const std::string filename = file_path.substr(file_path.find_last_of("\\/") + 1);
-    std::string line;
     std::ifstream file(file_path);
 
     // El fichero se puede abrir
     if (file.good())
     {
+        std::string line;
         // Procesa el fichero linea a linea
         while (std::getline(file, line))
         { // Lee el fichero linea a linea
@@ -81,12 +81,12 @@ RoomData loadRoomFile(const std::string &file_path, bool verbose)
     const std::string fileName = file_path.substr(file_path.find_last_of("\\/") + 1);
     room.number = fileName.substr(0, fileName.find_last_of("."));
 
-    std::string line;
     std::ifstream file(file_path);
 
     // El fichero se puede abrir
     if (file.good())
     {
+        std::string line;
         // Procesa el fichero linea a linea
         while (std::getline(file, line))
         {
@@ -398,13 +398,10 @@ bool setItem(ItemData *item, const std::string &key, const std::string &value)
 }
 
 // Constructor
-Room::Room(std::shared_ptr<RoomData> room, std::shared_ptr<ScoreboardData> data)
-    : screen_(Screen::get()),
-      renderer_(Screen::get()->getRenderer()),
-      asset_(Asset::get()),
-      debug_(Debug::get()),
-      data_(data)
+Room::Room(const std::string &room_path, std::shared_ptr<ScoreboardData> data)
+    : data_(data)
 {
+    auto room = Resource::get()->getRoom(room_path);
     number_ = room->number;
     name_ = room->name;
     bg_color_ = room->bg_color;
@@ -419,11 +416,11 @@ Room::Room(std::shared_ptr<RoomData> room, std::shared_ptr<ScoreboardData> data)
     tile_map_file_ = room->tile_map_file;
     auto_surface_direction_ = room->auto_surface_direction;
     tile_map_ = Resource::get()->getTileMap(room->tile_map_file);
-    texture_ = (options.video.palette == Palette::ZXSPECTRUM) ? Resource::get()->getTexture(room->tile_set_file) : Resource::get()->getTexture(room->tile_set_file);
+    texture_ = Resource::get()->getTexture(room->tile_set_file);
 
     // Inicializa variables
     tile_set_width_ = texture_->getWidth() / TILE_SIZE_;
-    paused_ = false;
+    is_paused_ = false;
     counter_ = 0;
 
     // Crea los enemigos
@@ -445,9 +442,6 @@ Room::Room(std::shared_ptr<RoomData> room, std::shared_ptr<ScoreboardData> data)
         }
     }
 
-    // Carga los sonidos
-    item_sound_ = Resource::get()->getSound("item.wav");
-
     // Abre la jail para poder entrar
     if (data_->jail_is_open)
     {
@@ -467,7 +461,7 @@ Room::Room(std::shared_ptr<RoomData> room, std::shared_ptr<ScoreboardData> data)
     setAnimatedTiles();
 
     // Crea la textura para el mapa de tiles de la habitación
-    map_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT);
+    map_texture_ = SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT);
     if (map_texture_ == nullptr)
     {
         if (options.console)
@@ -481,16 +475,53 @@ Room::Room(std::shared_ptr<RoomData> room, std::shared_ptr<ScoreboardData> data)
     fillMapTexture();
 
     // Establece el color del borde
-    screen_->setBorderColor(stringToColor(options.video.palette, room->border_color));
+    Screen::get()->setBorderColor(stringToColor(options.video.palette, room->border_color));
 }
 
 // Destructor
 Room::~Room()
 {
-    // Reclama la memoria utilizada por los objetos
     SDL_DestroyTexture(map_texture_);
 }
 
+void Room::initializeRoom(const RoomData& room) {
+    // Asignar valores a las variables miembro
+    number_ = room.number;
+    name_ = room.name;
+    bg_color_ = room.bg_color;
+    border_color_ = room.border_color;
+    item_color1_ = room.item_color1.empty() ? "yellow" : room.item_color1;
+    item_color2_ = room.item_color2.empty() ? "magenta" : room.item_color2;
+    room_top_ = room.room_top;
+    room_bottom_ = room.room_bottom;
+    room_left_ = room.room_left;
+    room_right_ = room.room_right;
+    tile_set_file_ = room.tile_set_file;
+    tile_map_file_ = room.tile_map_file;
+    auto_surface_direction_ = room.auto_surface_direction;
+    tile_map_ = Resource::get()->getTileMap(room.tile_map_file);
+    texture_ = Resource::get()->getTexture(room.tile_set_file);
+    tile_set_width_ = texture_->getWidth() / TILE_SIZE_;
+    is_paused_ = false;
+    counter_ = 0;
+
+    // Crear los enemigos
+    for (auto &enemy_data : room.enemies) {
+        enemies_.emplace_back(std::make_shared<Enemy>(enemy_data));
+    }
+
+    // Crear los items
+    for (auto &item : room.items) {
+        const SDL_Point itemPos = {item.x, item.y};
+
+        if (!ItemTracker::get()->hasBeenPicked(room.name, itemPos)) {
+            item.color1 = stringToColor(options.video.palette, item_color1_);
+            item.color2 = stringToColor(options.video.palette, item_color2_);
+            items_.emplace_back(std::make_shared<Item>(item));
+        }
+    }
+}
+
 // Devuelve el nombre de la habitación
 std::string Room::getName()
 {
@@ -513,9 +544,9 @@ Color Room::getBorderColor()
 void Room::fillMapTexture()
 {
     const Color color = stringToColor(options.video.palette, bg_color_);
-    SDL_SetRenderTarget(renderer_, map_texture_);
-    SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 0xFF);
-    SDL_RenderClear(renderer_);
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), map_texture_);
+    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), color.r, color.g, color.b, 0xFF);
+    SDL_RenderClear(Screen::get()->getRenderer());
 
     // Los tileSetFiles son de 20x20 tiles. El primer tile es el 0. Cuentan hacia la derecha y hacia abajo
 
@@ -537,14 +568,14 @@ void Room::fillMapTexture()
                 texture_->render(x * TILE_SIZE_, y * TILE_SIZE_, &clip);
 
 #ifdef DEBUG
-                if (debug_->getEnabled())
+                if (Debug::get()->getEnabled())
                 {
                     if (clip.x != -TILE_SIZE_)
                     {
                         clip.x = x * TILE_SIZE_;
                         clip.y = y * TILE_SIZE_;
-                        SDL_SetRenderDrawColor(renderer_, 64, 64, 64, 224);
-                        SDL_RenderFillRect(renderer_, &clip);
+                        SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 64, 64, 64, 224);
+                        SDL_RenderFillRect(Screen::get()->getRenderer(), &clip);
                     }
                 }
 #endif
@@ -552,16 +583,16 @@ void Room::fillMapTexture()
         }
 
 #ifdef DEBUG
-    if (debug_->getEnabled())
+    if (Debug::get()->getEnabled())
     {
         // BottomSurfaces
         if (true)
         {
             for (auto l : bottom_surfaces_)
             {
-                SDL_SetRenderDrawColor(renderer_, (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
-                SDL_SetRenderDrawColor(renderer_, 255, 0, 0, 0xFF);
-                SDL_RenderDrawLine(renderer_, l.x1, l.y, l.x2, l.y);
+                SDL_SetRenderDrawColor(Screen::get()->getRenderer(), (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
+                SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 255, 0, 0, 0xFF);
+                SDL_RenderDrawLine(Screen::get()->getRenderer(), l.x1, l.y, l.x2, l.y);
             }
         }
 
@@ -570,9 +601,9 @@ void Room::fillMapTexture()
         {
             for (auto l : top_surfaces_)
             {
-                SDL_SetRenderDrawColor(renderer_, (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
-                SDL_SetRenderDrawColor(renderer_, 0, 255, 0, 0xFF);
-                SDL_RenderDrawLine(renderer_, l.x1, l.y, l.x2, l.y);
+                SDL_SetRenderDrawColor(Screen::get()->getRenderer(), (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
+                SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 255, 0, 0xFF);
+                SDL_RenderDrawLine(Screen::get()->getRenderer(), l.x1, l.y, l.x2, l.y);
             }
         }
 
@@ -581,9 +612,9 @@ void Room::fillMapTexture()
         {
             for (auto l : left_surfaces_)
             {
-                SDL_SetRenderDrawColor(renderer_, (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
-                SDL_SetRenderDrawColor(renderer_, 128, 128, 255, 0xFF);
-                SDL_RenderDrawLine(renderer_, l.x, l.y1, l.x, l.y2);
+                SDL_SetRenderDrawColor(Screen::get()->getRenderer(), (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
+                SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 128, 128, 255, 0xFF);
+                SDL_RenderDrawLine(Screen::get()->getRenderer(), l.x, l.y1, l.x, l.y2);
             }
         }
 
@@ -592,9 +623,9 @@ void Room::fillMapTexture()
         {
             for (auto l : right_surfaces_)
             {
-                SDL_SetRenderDrawColor(renderer_, (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
-                SDL_SetRenderDrawColor(renderer_, 255, 255, 0, 0xFF);
-                SDL_RenderDrawLine(renderer_, l.x, l.y1, l.x, l.y2);
+                SDL_SetRenderDrawColor(Screen::get()->getRenderer(), (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
+                SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 255, 255, 0, 0xFF);
+                SDL_RenderDrawLine(Screen::get()->getRenderer(), l.x, l.y1, l.x, l.y2);
             }
         }
 
@@ -603,9 +634,9 @@ void Room::fillMapTexture()
         {
             for (auto l : left_slopes_)
             {
-                SDL_SetRenderDrawColor(renderer_, (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
-                SDL_SetRenderDrawColor(renderer_, 0, 255, 255, 0xFF);
-                SDL_RenderDrawLine(renderer_, l.x1, l.y1, l.x2, l.y2);
+                SDL_SetRenderDrawColor(Screen::get()->getRenderer(), (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
+                SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 255, 255, 0xFF);
+                SDL_RenderDrawLine(Screen::get()->getRenderer(), l.x1, l.y1, l.x2, l.y2);
             }
         }
 
@@ -614,9 +645,9 @@ void Room::fillMapTexture()
         {
             for (auto l : right_slopes_)
             {
-                SDL_SetRenderDrawColor(renderer_, (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
-                SDL_SetRenderDrawColor(renderer_, 255, 0, 255, 0xFF);
-                SDL_RenderDrawLine(renderer_, l.x1, l.y1, l.x2, l.y2);
+                SDL_SetRenderDrawColor(Screen::get()->getRenderer(), (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
+                SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 255, 0, 255, 0xFF);
+                SDL_RenderDrawLine(Screen::get()->getRenderer(), l.x1, l.y1, l.x2, l.y2);
             }
         }
 
@@ -625,14 +656,14 @@ void Room::fillMapTexture()
         {
             for (auto l : auto_surfaces_)
             {
-                SDL_SetRenderDrawColor(renderer_, (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
-                SDL_RenderDrawLine(renderer_, l.x1, l.y, l.x2, l.y);
+                SDL_SetRenderDrawColor(Screen::get()->getRenderer(), (rand() % 128) + 96, (rand() % 128) + 96, (rand() % 128) + 96, 0xFF);
+                SDL_RenderDrawLine(Screen::get()->getRenderer(), l.x1, l.y, l.x2, l.y);
             }
         }
     }
 #endif
 
-    SDL_SetRenderTarget(renderer_, nullptr);
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), nullptr);
 }
 
 // Dibuja el mapa en pantalla
@@ -640,11 +671,11 @@ void Room::renderMap()
 {
     // Dibuja la textura con el mapa en pantalla
     SDL_Rect dest = {0, 0, PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT};
-    SDL_RenderCopy(renderer_, map_texture_, nullptr, &dest);
+    SDL_RenderCopy(Screen::get()->getRenderer(), map_texture_, nullptr, &dest);
 
 // Dibuja los tiles animados
 #ifdef DEBUG
-    if (!debug_->getEnabled())
+    if (!Debug::get()->getEnabled())
     {
         renderAnimatedTiles();
     }
@@ -674,7 +705,7 @@ void Room::renderItems()
 // Actualiza las variables y objetos de la habitación
 void Room::update()
 {
-    if (paused_)
+    if (is_paused_)
     { // Si está en modo pausa no se actualiza nada
         return;
     }
@@ -800,7 +831,7 @@ bool Room::itemCollision(SDL_Rect &rect)
         {
             ItemTracker::get()->addItem(name_, items_[i]->getPos());
             items_.erase(items_.begin() + i);
-            JA_PlaySound(item_sound_);
+            JA_PlaySound(Resource::get()->getSound("item.wav"));
             data_->items++;
             options.stats.items = data_->items;
             return true;
@@ -810,73 +841,19 @@ bool Room::itemCollision(SDL_Rect &rect)
     return false;
 }
 
-// Recarga la textura
-void Room::reLoadTexture()
-{
-    texture_->reLoad();
-    fillMapTexture();
-
-    for (auto enemy : enemies_)
-    {
-        enemy->reLoadTexture();
-    }
-
-    for (auto item : items_)
-    {
-        item->reLoadTexture();
-    }
-}
-
-// Recarga la paleta
-void Room::reLoadPalette()
-{
-    // Cambia el color de los items
-    for (auto item : items_)
-    {
-        item->setColors(stringToColor(options.video.palette, item_color1_), stringToColor(options.video.palette, item_color2_));
-    }
-
-    // Cambia el color de los enemigos
-    for (auto enemy : enemies_)
-    {
-        enemy->setPalette(options.video.palette);
-    }
-
-    // Establece el color del borde
-    screen_->setBorderColor(stringToColor(options.video.palette, border_color_));
-
-    // Cambia la textura
-    //texture_ = (options.video.palette == Palette::ZXSPECTRUM) ? Resource::get()->getTexture(room->tile_set_file) : Resource::get()->getTexture(room->tile_set_file);
-
-    // Pone la nueva textura a los tiles animados
-    for (auto tile : animated_tiles_)
-    {
-        tile.sprite->setTexture(texture_);
-    }
-
-    // Recarga las texturas
-    reLoadTexture();
-}
-
-// Obten el tamaño del tile
-int Room::getTileSize()
-{
-    return TILE_SIZE_;
-}
-
 // Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
 int Room::getSlopeHeight(SDL_Point p, tile_e slope)
 {
     // Calcula la base del tile
     int base = ((p.y / TILE_SIZE_) * TILE_SIZE_) + TILE_SIZE_;
 #ifdef DEBUG
-    debug_->add("BASE = " + std::to_string(base));
+    Debug::get()->add("BASE = " + std::to_string(base));
 #endif
 
     // Calcula cuanto se ha entrado en el tile horizontalmente
     const int pos = (p.x % TILE_SIZE_); // Esto da un valor entre 0 y 7
 #ifdef DEBUG
-    debug_->add("POS = " + std::to_string(pos));
+    Debug::get()->add("POS = " + std::to_string(pos));
 #endif
 
     // Se resta a la base la cantidad de pixeles pos en funcion de la rampa
@@ -884,14 +861,14 @@ int Room::getSlopeHeight(SDL_Point p, tile_e slope)
     {
         base -= pos + 1;
 #ifdef DEBUG
-        debug_->add("BASE_R = " + std::to_string(base));
+        Debug::get()->add("BASE_R = " + std::to_string(base));
 #endif
     }
     else
     {
         base -= (TILE_SIZE_ - pos);
 #ifdef DEBUG
-        debug_->add("BASE_L = " + std::to_string(base));
+        Debug::get()->add("BASE_L = " + std::to_string(base));
 #endif
     }
 
@@ -926,20 +903,19 @@ void Room::setBottomSurfaces()
     if ((int)tile.size() > 1)
     {
         int i = 0;
-        int lastOne = 0;
         do
         {
             h_line_t line;
             line.x1 = (tile[i] % MAP_WIDTH_) * TILE_SIZE_;
             line.y = ((tile[i] / MAP_WIDTH_) * TILE_SIZE_) + TILE_SIZE_ - 1;
-            lastOne = i;
+            int last_one = i;
             i++;
 
             if (i <= (int)tile.size() - 1)
             {
                 while (tile[i] == tile[i - 1] + 1)
                 {
-                    lastOne = i;
+                    last_one = i;
                     if (i == (int)tile.size() - 1)
                     {
                         break;
@@ -948,7 +924,7 @@ void Room::setBottomSurfaces()
                 }
             }
 
-            line.x2 = ((tile[lastOne] % MAP_WIDTH_) * TILE_SIZE_) + TILE_SIZE_ - 1;
+            line.x2 = ((tile[last_one] % MAP_WIDTH_) * TILE_SIZE_) + TILE_SIZE_ - 1;
             bottom_surfaces_.push_back(line);
             if (i <= (int)tile.size() - 1)
             {
@@ -989,20 +965,19 @@ void Room::setTopSurfaces()
     if ((int)tile.size() > 1)
     {
         int i = 0;
-        int lastOne = 0;
         do
         {
             h_line_t line;
             line.x1 = (tile[i] % MAP_WIDTH_) * TILE_SIZE_;
             line.y = (tile[i] / MAP_WIDTH_) * TILE_SIZE_;
-            lastOne = i;
+            int last_one = i;
             i++;
 
             if (i <= (int)tile.size() - 1)
             {
                 while (tile[i] == tile[i - 1] + 1)
                 {
-                    lastOne = i;
+                    last_one = i;
                     if (i == (int)tile.size() - 1)
                     {
                         break;
@@ -1011,7 +986,7 @@ void Room::setTopSurfaces()
                 }
             }
 
-            line.x2 = ((tile[lastOne] % MAP_WIDTH_) * TILE_SIZE_) + TILE_SIZE_ - 1;
+            line.x2 = ((tile[last_one] % MAP_WIDTH_) * TILE_SIZE_) + TILE_SIZE_ - 1;
             top_surfaces_.push_back(line);
             if (i <= (int)tile.size() - 1)
             {
@@ -1224,23 +1199,22 @@ void Room::setAutoSurfaces()
     }
 
     // Recorre el vector de tiles buscando tiles consecutivos para localizar las superficies
-    int i = 0;
-    int lastOne = 0;
     if ((int)tile.size() > 0)
     {
+        int i = 0;
         do
         {
             h_line_t line;
             line.x1 = (tile[i] % MAP_WIDTH_) * TILE_SIZE_;
             line.y = (tile[i] / MAP_WIDTH_) * TILE_SIZE_;
-            lastOne = i;
+            int last_one = i;
             i++;
 
             if (i <= (int)tile.size() - 1)
             {
                 while (tile[i] == tile[i - 1] + 1)
                 {
-                    lastOne = i;
+                    last_one = i;
                     if (i == (int)tile.size() - 1)
                     {
                         break;
@@ -1249,7 +1223,7 @@ void Room::setAutoSurfaces()
                 }
             }
 
-            line.x2 = ((tile[lastOne] % MAP_WIDTH_) * TILE_SIZE_) + TILE_SIZE_ - 1;
+            line.x2 = ((tile[last_one] % MAP_WIDTH_) * TILE_SIZE_) + TILE_SIZE_ - 1;
             auto_surfaces_.push_back(line);
             if (i <= (int)tile.size() - 1)
             {
@@ -1278,7 +1252,7 @@ void Room::setAnimatedTiles()
             const int xc = (tile_map_[i] % tile_set_width_) * TILE_SIZE_;
             const int yc = (tile_map_[i] / tile_set_width_) * TILE_SIZE_;
 
-            aTile_t at;
+            AnimatedTile at;
             at.sprite = std::make_shared<Sprite>(texture_, x, y, 8, 8);
             at.sprite->setClip(xc, yc, 8, 8);
             at.x_orig = xc;
@@ -1417,11 +1391,11 @@ bool Room::checkAutoSurfaces(SDL_Point *p)
 }
 
 // Comprueba las colisiones
-int Room::checkLeftSlopes(v_line_t *line)
+int Room::checkLeftSlopes(const v_line_t *line)
 {
-    for (auto s : left_slopes_)
+    for (auto slope : left_slopes_)
     {
-        const SDL_Point p = checkCollision(s, *line);
+        const SDL_Point p = checkCollision(slope, *line);
         if (p.x != -1)
         {
             return p.y;
@@ -1434,9 +1408,9 @@ int Room::checkLeftSlopes(v_line_t *line)
 // Comprueba las colisiones
 bool Room::checkLeftSlopes(SDL_Point *p)
 {
-    for (auto s : left_slopes_)
+    for (auto slope : left_slopes_)
     {
-        if (checkCollision(*p, s))
+        if (checkCollision(*p, slope))
         {
             return true;
         }
@@ -1446,11 +1420,11 @@ bool Room::checkLeftSlopes(SDL_Point *p)
 }
 
 // Comprueba las colisiones
-int Room::checkRightSlopes(v_line_t *line)
+int Room::checkRightSlopes(const v_line_t *line)
 {
-    for (auto s : right_slopes_)
+    for (auto slope : right_slopes_)
     {
-        const SDL_Point p = checkCollision(s, *line);
+        const SDL_Point p = checkCollision(slope, *line);
         if (p.x != -1)
         {
             return p.y;
@@ -1463,9 +1437,9 @@ int Room::checkRightSlopes(v_line_t *line)
 // Comprueba las colisiones
 bool Room::checkRightSlopes(SDL_Point *p)
 {
-    for (auto s : right_slopes_)
+    for (auto slope : right_slopes_)
     {
-        if (checkCollision(*p, s))
+        if (checkCollision(*p, slope))
         {
             return true;
         }
@@ -1474,18 +1448,6 @@ bool Room::checkRightSlopes(SDL_Point *p)
     return false;
 }
 
-// Pone el mapa en modo pausa
-void Room::pause()
-{
-    paused_ = true;
-}
-
-// Quita el modo pausa del mapa
-void Room::resume()
-{
-    paused_ = false;
-}
-
 // Obten la direccion de las superficies automaticas
 int Room::getAutoSurfaceDirection()
 {

source/room.h

@@ -28,7 +28,7 @@ enum tile_e
 	t_animated
 };
 
-struct aTile_t
+struct AnimatedTile
 {
 	std::shared_ptr<Sprite> sprite; // Sprite para dibujar el tile
 	int x_orig;						// Poicion X donde se encuentra el primer tile de la animacion en la tilesheet
@@ -48,8 +48,8 @@ struct RoomData
 	std::string room_right;			// Identificador de la habitación que se encuentra a la derecha
 	std::string tile_set_file;		// Imagen con los graficos para la habitación
 	std::string tile_map_file;		// Fichero con el mapa de indices de tile
-	std::vector<int> tile_map;		// Indice de los tiles a dibujar en la habitación
 	int auto_surface_direction;		// Sentido en el que arrastran las superficies automáticas de la habitación
+	std::vector<int> tile_map;		// Indice de los tiles a dibujar en la habitación
 	std::vector<EnemyData> enemies; // Listado con los enemigos de la habitación
 	std::vector<ItemData> items;	// Listado con los items que hay en la habitación
 };
@@ -78,10 +78,6 @@ private:
 	static constexpr int MAP_HEIGHT_ = 16; // Alto del mapa en tiles
 
 	// Objetos y punteros
-	Screen *screen_;							  // Objeto encargado de dibujar en pantalla
-	SDL_Renderer *renderer_;					  // El renderizador de la ventana
-	Asset *asset_;								  // Objeto con la ruta a todos los ficheros de recursos
-	Debug *debug_;								  // Objeto para gestionar la información de debug
 	std::vector<std::shared_ptr<Enemy>> enemies_; // Listado con los enemigos de la habitación
 	std::vector<std::shared_ptr<Item>> items_;	  // Listado con los items que hay en la habitación
 	std::shared_ptr<Texture> texture_;			  // Textura con los graficos de la habitación
@@ -89,32 +85,34 @@ private:
 	std::shared_ptr<ScoreboardData> data_;		  // Puntero a los datos del marcador
 
 	// Variables
-	std::string number_;					// Numero de la habitación
-	std::string name_;						// Nombre de la habitación
-	std::string bg_color_;					// Color de fondo de la habitación
-	std::string border_color_;				// Color del borde de la pantalla
-	std::string item_color1_;				// Color 1 para los items de la habitación
-	std::string item_color2_;				// Color 2 para los items de la habitación
-	std::string room_top_;					// Identificador de la habitación que se encuentra arriba
-	std::string room_bottom_;				// Identificador de la habitación que se encuentra abajp
-	std::string room_left_;					// Identificador de la habitación que se encuentra a la izquierda
-	std::string room_right_;				// Identificador de la habitación que se encuentra a la derecha
-	std::string tile_set_file_;				// Imagen con los graficos para la habitación
-	std::string tile_map_file_;				// Fichero con el mapa de indices de tile
-	std::vector<int> tile_map_;				// Indice de los tiles a dibujar en la habitación
-	int auto_surface_direction_;			// Sentido en el que arrastran las superficies automáticas de la habitación
-	JA_Sound_t *item_sound_;				// Sonido producido al coger un objeto
-	std::vector<h_line_t> bottom_surfaces_; // Lista con las superficies inferiores de la habitación
-	std::vector<h_line_t> top_surfaces_;	// Lista con las superficies superiores de la habitación
-	std::vector<v_line_t> left_surfaces_;	// Lista con las superficies laterales de la parte izquierda de la habitación
-	std::vector<v_line_t> right_surfaces_;	// Lista con las superficies laterales de la parte derecha de la habitación
-	std::vector<d_line_t> left_slopes_;		// Lista con todas las rampas que suben hacia la izquierda
-	std::vector<d_line_t> right_slopes_;	// Lista con todas las rampas que suben hacia la derecha
-	int counter_;							// Contador para lo que haga falta
-	bool paused_;							// Indica si el mapa esta en modo pausa
-	std::vector<aTile_t> animated_tiles_;	// Vector con los indices de tiles animados
-	std::vector<h_line_t> auto_surfaces_;	// Lista con las superficies automaticas de la habitación
-	int tile_set_width_;					// Ancho del tileset en tiles
+	std::string number_;					   // Numero de la habitación
+	std::string name_;						   // Nombre de la habitación
+	std::string bg_color_;					   // Color de fondo de la habitación
+	std::string border_color_;				   // Color del borde de la pantalla
+	std::string item_color1_;				   // Color 1 para los items de la habitación
+	std::string item_color2_;				   // Color 2 para los items de la habitación
+	std::string room_top_;					   // Identificador de la habitación que se encuentra arriba
+	std::string room_bottom_;				   // Identificador de la habitación que se encuentra abajp
+	std::string room_left_;					   // Identificador de la habitación que se encuentra a la izquierda
+	std::string room_right_;				   // Identificador de la habitación que se encuentra a la derecha
+	std::string tile_set_file_;				   // Imagen con los graficos para la habitación
+	std::string tile_map_file_;				   // Fichero con el mapa de indices de tile
+	std::vector<int> tile_map_;				   // Indice de los tiles a dibujar en la habitación
+	int auto_surface_direction_;			   // Sentido en el que arrastran las superficies automáticas de la habitación
+	JA_Sound_t *item_sound_;				   // Sonido producido al coger un objeto
+	std::vector<h_line_t> bottom_surfaces_;	   // Lista con las superficies inferiores de la habitación
+	std::vector<h_line_t> top_surfaces_;	   // Lista con las superficies superiores de la habitación
+	std::vector<v_line_t> left_surfaces_;	   // Lista con las superficies laterales de la parte izquierda de la habitación
+	std::vector<v_line_t> right_surfaces_;	   // Lista con las superficies laterales de la parte derecha de la habitación
+	std::vector<d_line_t> left_slopes_;		   // Lista con todas las rampas que suben hacia la izquierda
+	std::vector<d_line_t> right_slopes_;	   // Lista con todas las rampas que suben hacia la derecha
+	int counter_;							   // Contador para lo que haga falta
+	bool is_paused_;						   // Indica si el mapa esta en modo pausa
+	std::vector<AnimatedTile> animated_tiles_; // Vector con los indices de tiles animados
+	std::vector<h_line_t> auto_surfaces_;	   // Lista con las superficies automaticas de la habitación
+	int tile_set_width_;					   // Ancho del tileset en tiles
+
+	void initializeRoom(const RoomData& room);
 
 	// Pinta el mapa de la habitación en la textura
 	void fillMapTexture();
@@ -157,7 +155,7 @@ private:
 
 public:
 	// Constructor
-	Room(std::shared_ptr<RoomData> room, std::shared_ptr<ScoreboardData> data);
+	Room(const std::string &room_path, std::shared_ptr<ScoreboardData> data);
 
 	// Destructor
 	~Room();
@@ -195,14 +193,8 @@ public:
 	// Indica si hay colision con un objeto a partir de un rectangulo
 	bool itemCollision(SDL_Rect &rect);
 
-	// Recarga la textura
-	void reLoadTexture();
-
-	// Recarga la paleta
-	void reLoadPalette();
-
 	// Obten el tamaño del tile
-	int getTileSize();
+	int getTileSize() const { return TILE_SIZE_; }
 
 	// Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
 	int getSlopeHeight(SDL_Point p, tile_e slope);
@@ -229,22 +221,19 @@ public:
 	bool checkAutoSurfaces(SDL_Point *p);
 
 	// Comprueba las colisiones
-	int checkLeftSlopes(v_line_t *line);
+	int checkLeftSlopes(const v_line_t *line);
 
 	// Comprueba las colisiones
 	bool checkLeftSlopes(SDL_Point *p);
 
 	// Comprueba las colisiones
-	int checkRightSlopes(v_line_t *line);
+	int checkRightSlopes(const v_line_t *line);
 
 	// Comprueba las colisiones
 	bool checkRightSlopes(SDL_Point *p);
 
 	// Pone el mapa en modo pausa
-	void pause();
-
-	// Quita el modo pausa del mapa
-	void resume();
+	void setPaused(bool value) { is_paused_ = value; };
 
 	// Obten la direccion de las superficies automaticas
 	int getAutoSurfaceDirection();

source/room_tracker.cpp

@@ -1,20 +1,9 @@
 #include "room_tracker.h"
 
-// Constructor
-RoomTracker::RoomTracker()
-{
-}
-
-// Destructor
-RoomTracker::~RoomTracker()
-{
-    list.clear();
-}
-
 // Comprueba si la habitación ya ha sido visitada
-bool RoomTracker::hasBeenVisited(std::string name)
+bool RoomTracker::hasBeenVisited(const std::string &name)
 {
-    for (auto l : list)
+    for (const auto &l : list)
     {
         if (l == name)
         {
@@ -26,7 +15,7 @@ bool RoomTracker::hasBeenVisited(std::string name)
 }
 
 // Añade la habitación a la lista
-bool RoomTracker::addRoom(std::string name)
+bool RoomTracker::addRoom(const std::string &name)
 {
     // Comprueba si la habitación ya ha sido visitada
     if (!hasBeenVisited(name))

source/room_tracker.h

@@ -10,15 +10,15 @@ private:
 	std::vector<std::string> list; // Lista con las habitaciones visitadas
 
 	// Comprueba si la habitación ya ha sido visitada
-	bool hasBeenVisited(std::string name);
+	bool hasBeenVisited(const std::string &name);
 
 public:
 	// Constructor
-	RoomTracker();
+	RoomTracker() = default;
 
 	// Destructor
-	~RoomTracker();
+	~RoomTracker() = default;
 
 	// Añade la habitación a la lista
-	bool addRoom(std::string name);
+	bool addRoom(const std::string &name);
 };

source/scoreboard.cpp

@@ -13,23 +13,20 @@
 
 // Constructor
 Scoreboard::Scoreboard(std::shared_ptr<ScoreboardData> data)
-    : renderer_(Screen::get()->getRenderer()),
-      resource_(Resource::get()),
-      asset_(Asset::get()),
-      data_(data)
+    : data_(data),
+      clock_(ClockData())
 {
     const int TEXTURE_WIDTH_ = options.game.width;
     constexpr int TEXTURE_HEIGHT_ = 6 * BLOCK;
 
     // Reserva memoria para los objetos
-    item_texture_ = resource_->getTexture("items.png");
-    auto player_texture = resource_->getTexture(options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.png" : "player.png");
-    auto player_animations = resource_->getAnimations(options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.ani" : "player.ani");
+    item_texture_ = Resource::get()->getTexture("items.png");
+    auto player_texture = Resource::get()->getTexture(options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.png" : "player.png");
+    auto player_animations = Resource::get()->getAnimations(options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.ani" : "player.ani");
     player_sprite_ = std::make_shared<AnimatedSprite>(player_texture, player_animations);
     player_sprite_->setCurrentAnimation("walk_menu");
-    text_ = resource_->getText("smb2");
 
-    texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, TEXTURE_WIDTH_, TEXTURE_HEIGHT_);
+    texture_ = SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, TEXTURE_WIDTH_, TEXTURE_HEIGHT_);
     if (texture_ == nullptr)
     {
         if (options.console)
@@ -48,10 +45,10 @@ Scoreboard::Scoreboard(std::shared_ptr<ScoreboardData> data)
     items_color_ = stringToColor(options.video.palette, "white");
 
     // Inicializa el vector de colores
-    const std::vector<std::string> vColors = {"blue", "magenta", "green", "cyan", "yellow", "white", "bright_blue", "bright_magenta", "bright_green", "bright_cyan", "bright_yellow", "bright_white"};
-    for (auto v : vColors)
+    const std::vector<std::string> COLORS = {"blue", "magenta", "green", "cyan", "yellow", "white", "bright_blue", "bright_magenta", "bright_green", "bright_cyan", "bright_yellow", "bright_white"};
+    for (const auto &color : COLORS)
     {
-        color_.push_back(stringToColor(options.video.palette, v));
+        color_.push_back(stringToColor(options.video.palette, color));
     }
 }
 
@@ -64,7 +61,7 @@ Scoreboard::~Scoreboard()
 // Pinta el objeto en pantalla
 void Scoreboard::render()
 {
-    SDL_RenderCopy(renderer_, texture_, nullptr, &texture_dest_);
+    SDL_RenderCopy(Screen::get()->getRenderer(), texture_, nullptr, &texture_dest_);
 }
 
 // Actualiza las variables del objeto
@@ -100,39 +97,27 @@ Scoreboard::ClockData Scoreboard::getTime()
     return time;
 }
 
-// Recarga la textura
-void Scoreboard::reLoadTexture()
-{
-    player_sprite_->getTexture()->reLoad();
-    // playerTexture->reLoad();
-    item_texture_->reLoad();
-    text_->reLoadTexture();
-}
-
-// Recarga la paleta
-void Scoreboard::reLoadPalette()
-{
-    // Reinicia el vector de colores
-    const std::vector<std::string> vColors = {"blue", "magenta", "green", "cyan", "yellow", "white", "bright_blue", "bright_magenta", "bright_green", "bright_cyan", "bright_yellow", "bright_white"};
-    color_.clear();
-    for (auto v : vColors)
-    {
-        color_.push_back(stringToColor(options.video.palette, v));
-    }
-}
-
 // Pone el marcador en modo pausa
-void Scoreboard::pause()
+void Scoreboard::setPaused(bool value)
 {
-    is_paused_ = true;
-    paused_time_ = SDL_GetTicks();
-}
+    if (is_paused_ == value)
+    {
+        // Evita ejecutar lógica si el estado no cambia
+        return;
+    }
 
-// Quita el modo pausa del marcador
-void Scoreboard::resume()
-{
-    is_paused_ = false;
-    paused_time_elapsed_ += SDL_GetTicks() - paused_time_;
+    is_paused_ = value;
+
+    if (is_paused_)
+    {
+        // Guarda el tiempo actual al pausar
+        paused_time_ = SDL_GetTicks();
+    }
+    else
+    {
+        // Calcula el tiempo pausado acumulado al reanudar
+        paused_time_elapsed_ += SDL_GetTicks() - paused_time_;
+    }
 }
 
 // Actualiza el color de la cantidad de items recogidos
@@ -163,12 +148,12 @@ int Scoreboard::getMinutes()
 void Scoreboard::fillTexture()
 {
     // Empieza a dibujar en la textura
-    auto temp = SDL_GetRenderTarget(renderer_);
-    SDL_SetRenderTarget(renderer_, texture_);
+    auto temp = SDL_GetRenderTarget(Screen::get()->getRenderer());
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), texture_);
 
     // Limpia la textura
-    SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 255);
-    SDL_RenderFillRect(renderer_, nullptr);
+    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 0, 0, 255);
+    SDL_RenderFillRect(Screen::get()->getRenderer(), nullptr);
 
     // Anclas
     constexpr int LINE1 = BLOCK;
@@ -197,17 +182,18 @@ void Scoreboard::fillTexture()
     }
 
     // Escribe los textos
-    const std::string timeTxt = std::to_string((clock_.minutes % 100) / 10) + std::to_string(clock_.minutes % 10) + clock_.separator + std::to_string((clock_.seconds % 60) / 10) + std::to_string(clock_.seconds % 10);
-    const std::string itemsTxt = std::to_string(data_->items / 100) + std::to_string((data_->items % 100) / 10) + std::to_string(data_->items % 10);
-    text_->writeColored(BLOCK, LINE1, "Items collected ", data_->color);
-    text_->writeColored(17 * BLOCK, LINE1, itemsTxt, items_color_);
-    text_->writeColored(20 * BLOCK, LINE1, " Time ", data_->color);
-    text_->writeColored(26 * BLOCK, LINE1, timeTxt, stringToColor(options.video.palette, "white"));
+    auto text = Resource::get()->getText("smb2");
+    const std::string TIME_TEXT = std::to_string((clock_.minutes % 100) / 10) + std::to_string(clock_.minutes % 10) + clock_.separator + std::to_string((clock_.seconds % 60) / 10) + std::to_string(clock_.seconds % 10);
+    const std::string ITEMS_TEXT = std::to_string(data_->items / 100) + std::to_string((data_->items % 100) / 10) + std::to_string(data_->items % 10);
+    text->writeColored(BLOCK, LINE1, "Items collected ", data_->color);
+    text->writeColored(17 * BLOCK, LINE1, ITEMS_TEXT, items_color_);
+    text->writeColored(20 * BLOCK, LINE1, " Time ", data_->color);
+    text->writeColored(26 * BLOCK, LINE1, TIME_TEXT, stringToColor(options.video.palette, "white"));
 
-    const std::string roomsTxt = std::to_string(data_->rooms / 100) + std::to_string((data_->rooms % 100) / 10) + std::to_string(data_->rooms % 10);
-    text_->writeColored(22 * BLOCK, LINE2, "Rooms", stringToColor(options.video.palette, "white"));
-    text_->writeColored(28 * BLOCK, LINE2, roomsTxt, stringToColor(options.video.palette, "white"));
+    const std::string ROOMS_TEXT = std::to_string(data_->rooms / 100) + std::to_string((data_->rooms % 100) / 10) + std::to_string(data_->rooms % 10);
+    text->writeColored(22 * BLOCK, LINE2, "Rooms", stringToColor(options.video.palette, "white"));
+    text->writeColored(28 * BLOCK, LINE2, ROOMS_TEXT, stringToColor(options.video.palette, "white"));
 
     // Deja el renderizador como estaba
-    SDL_SetRenderTarget(renderer_, temp);
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), temp);
 }

source/scoreboard.h

@@ -15,16 +15,20 @@ class Texture;
 struct ScoreboardData
 {
 	int items;		   // Lleva la cuenta de los objetos recogidos
-	int lives;		   // Lleva la cuenta de ls vidas restantes del jugador
+	int lives;		   // Lleva la cuenta de las vidas restantes del jugador
 	int rooms;		   // Lleva la cuenta de las habitaciones visitadas
-	bool music;		   // Indica si ha de sonar la musica durante el juego
+	bool music;		   // Indica si ha de sonar la música durante el juego
 	Color color;	   // Color para escribir el texto del marcador
 	Uint32 ini_clock;  // Tiempo inicial para calcular el tiempo transcurrido
 	bool jail_is_open; // Indica si se puede entrar a la Jail
 
-	// Constructor
+	// Constructor por defecto
 	ScoreboardData()
-		: items(0), lives(3), rooms(0), music(true), color({0, 0, 0}), ini_clock(0), jail_is_open(false) {}
+		: items(0), lives(0), rooms(0), music(true), color({0, 0, 0}), ini_clock(0), jail_is_open(false) {}
+
+	// Constructor parametrizado
+	ScoreboardData(int items, int lives, int rooms, bool music, Color color, Uint32 ini_clock, bool jail_is_open)
+		: items(items), lives(lives), rooms(rooms), music(music), color(color), ini_clock(ini_clock), jail_is_open(jail_is_open) {}
 };
 
 class Scoreboard
@@ -36,13 +40,17 @@ private:
 		int minutes;
 		int seconds;
 		std::string separator;
+
+		// Constructor por defecto
+		ClockData()
+			: hours(0), minutes(0), seconds(0), separator(":") {}
+
+		// Constructor parametrizado
+		ClockData(int h, int m, int s, const std::string &sep)
+			: hours(h), minutes(m), seconds(s), separator(sep) {}
 	};
 
 	// Objetos y punteros
-	SDL_Renderer *renderer_;						// El renderizador de la ventana
-	Resource *resource_;							// Objeto con los recursos
-	Asset *asset_;									// Objeto con la ruta a todos los ficheros de recursos
-	std::shared_ptr<Text> text_;					// Objeto para escribir texto
 	std::shared_ptr<AnimatedSprite> player_sprite_; // Sprite para mostrar las vidas en el marcador
 	std::shared_ptr<Texture> item_texture_;			// Textura con los graficos para las vidas
 	std::shared_ptr<ScoreboardData> data_;			// Contiene las variables a mostrar en el marcador
@@ -70,7 +78,7 @@ private:
 
 public:
 	// Constructor
-	Scoreboard(std::shared_ptr<ScoreboardData> data);
+	explicit Scoreboard(std::shared_ptr<ScoreboardData> data);
 
 	// Destructor
 	~Scoreboard();
@@ -81,17 +89,8 @@ public:
 	// Actualiza las variables del objeto
 	void update();
 
-	// Recarga la textura
-	void reLoadTexture();
-
-	// Recarga la paleta
-	void reLoadPalette();
-
 	// Pone el marcador en modo pausa
-	void pause();
-
-	// Quita el modo pausa del marcador
-	void resume();
+	void setPaused(bool value);
 
 	// Devuelve la cantidad de minutos de juego transcurridos
 	int getMinutes();

source/screen.cpp

@@ -416,12 +416,3 @@ int Screen::getMaxZoom()
 
     return max_zoom;
 }
-
-// Renderiza un frame negro
-void Screen::renderBlackFrame()
-{
-    SDL_SetRenderTarget(renderer_, nullptr);
-    SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
-    SDL_RenderClear(renderer_);
-    SDL_RenderPresent(renderer_);
-}

source/screen.h

@@ -58,9 +58,6 @@ private:
 	// Ajusta el tamaño lógico del renderizador
 	void adjustRenderLogicalSize();
 
-	// Renderiza un frame negro
-	void renderBlackFrame();
-
 	// Constructor
 	Screen(SDL_Window *window, SDL_Renderer *renderer);
 

source/stats.cpp

@@ -1,17 +1,12 @@
 #include "stats.h"
-#include <fstream>    // for basic_ostream, basic_ifstream, basic_istream
-#include <sstream>    // for basic_stringstream
-#include "options.h"  // for Options, OptionsStats, options
+#include <fstream>   // for basic_ostream, basic_ifstream, basic_istream
+#include <sstream>   // for basic_stringstream
+#include "options.h" // for Options, OptionsStats, options
 
 // Constructor
-Stats::Stats(std::string file, std::string buffer)
-{
-    bufferPath = buffer;
-    filePath = file;
-    bufferList.clear();
-    list.clear();
-    dictionary.clear();
-}
+Stats::Stats(const std::string &file, const std::string &buffer)
+    : bufferPath(buffer),
+      filePath(file) {}
 
 // Destructor
 Stats::~Stats()
@@ -43,7 +38,7 @@ void Stats::init()
 }
 
 // Añade una muerte a las estadisticas
-void Stats::addDeath(std::string name)
+void Stats::addDeath(const std::string &name)
 {
     // Primero busca si ya hay una entrada con ese nombre
     const int index = findByName(name, bufferList);
@@ -55,7 +50,7 @@ void Stats::addDeath(std::string name)
     // En caso contrario crea la entrada
     else
     {
-        stats_t item;
+        StatsData item;
         item.name = name;
         item.visited = 0;
         item.died = 1;
@@ -64,7 +59,7 @@ void Stats::addDeath(std::string name)
 }
 
 // Añade una visita a las estadisticas
-void Stats::addVisit(std::string name)
+void Stats::addVisit(const std::string &name)
 {
     // Primero busca si ya hay una entrada con ese nombre
     const int index = findByName(name, bufferList);
@@ -76,7 +71,7 @@ void Stats::addVisit(std::string name)
     // En caso contrario crea la entrada
     else
     {
-        stats_t item;
+        StatsData item;
         item.name = name;
         item.visited = 1;
         item.died = 0;
@@ -85,11 +80,11 @@ void Stats::addVisit(std::string name)
 }
 
 // Busca una entrada en la lista por nombre
-int Stats::findByName(std::string name, std::vector<stats_t> &list)
+int Stats::findByName(const std::string &name, const std::vector<StatsData> &list)
 {
     int i = 0;
 
-    for (auto l : list)
+    for (const auto &l : list)
     {
         if (l.name == name)
         {
@@ -102,7 +97,7 @@ int Stats::findByName(std::string name, std::vector<stats_t> &list)
 }
 
 // Carga las estadisticas desde un fichero
-bool Stats::loadFromFile(std::string filePath, std::vector<stats_t> &list)
+bool Stats::loadFromFile(const std::string &file_path, std::vector<StatsData> &list)
 {
     list.clear();
 
@@ -110,19 +105,19 @@ bool Stats::loadFromFile(std::string filePath, std::vector<stats_t> &list)
     bool success = true;
 
     // Variables para manejar el fichero
-    std::string line;
-    std::ifstream file(filePath);
+    std::ifstream file(file_path);
 
     // Si el fichero se puede abrir
     if (file.good())
     {
+        std::string line;
         // Procesa el fichero linea a linea
         while (std::getline(file, line))
         {
             // Comprueba que la linea no sea un comentario
             if (line.substr(0, 1) != "#")
             {
-                stats_t stat;
+                StatsData stat;
                 std::stringstream ss(line);
                 std::string tmp;
 
@@ -150,21 +145,21 @@ bool Stats::loadFromFile(std::string filePath, std::vector<stats_t> &list)
     else
     {
         // Crea el fichero con los valores por defecto
-        saveToFile(filePath, list);
+        saveToFile(file_path, list);
     }
 
     return success;
 }
 
 // Guarda las estadisticas en un fichero
-void Stats::saveToFile(std::string filePath, std::vector<stats_t> &list)
+void Stats::saveToFile(const std::string &file_path, const std::vector<StatsData> &list)
 {
     // Crea y abre el fichero de texto
-    std::ofstream file(filePath);
+    std::ofstream file(file_path);
 
     // Escribe en el fichero
     file << "# ROOM NAME;VISITS;DEATHS" << std::endl;
-    for (auto item : list)
+    for (const auto &item : list)
     {
         file << item.name << ";" << item.visited << ";" << item.died << std::endl;
     }
@@ -177,7 +172,7 @@ void Stats::saveToFile(std::string filePath, std::vector<stats_t> &list)
 void Stats::checkWorstNightmare()
 {
     int deaths = 0;
-    for (auto item : list)
+    for (const auto &item : list)
     {
         if (item.died > deaths)
         {
@@ -188,42 +183,16 @@ void Stats::checkWorstNightmare()
 }
 
 // Añade una entrada al diccionario
-void Stats::addDictionary(std::string number, std::string name)
+void Stats::addDictionary(const std::string &number, const std::string &name)
 {
     dictionary.push_back({number, name});
 }
 
-// Obtiene el nombre de una habitación a partir del número
-std::string Stats::numberToName(std::string number)
-{
-    for (auto l : dictionary)
-    {
-        if (l.number == number)
-        {
-            return l.name;
-        }
-    }
-    return "";
-}
-
-// Obtiene el número de una habitación a partir del nombre
-std::string Stats::nameToNumber(std::string name)
-{
-    for (auto l : dictionary)
-    {
-        if (l.name == name)
-        {
-            return l.number;
-        }
-    }
-    return "";
-}
-
 // Vuelca los datos del buffer en la lista de estadisticas
 void Stats::updateListFromBuffer()
 {
     // Actualiza list desde bufferList
-    for (auto buffer : bufferList)
+    for (const auto &buffer : bufferList)
     {
         int index = findByName(buffer.name, list);
 
@@ -234,7 +203,7 @@ void Stats::updateListFromBuffer()
         }
         else
         { // En caso contrario crea la entrada
-            stats_t item;
+            StatsData item;
             item.name = buffer.name;
             item.visited = buffer.visited;
             item.died = buffer.died;

source/stats.h

@@ -1,55 +1,49 @@
 #pragma once
 
-#include <string>  // for string
-#include <vector>  // for vector
+#include <string> // for string
+#include <vector> // for vector
 
 class Stats
 {
 private:
-	struct stats_t
+	struct StatsData
 	{
 		std::string name; // Nombre de la habitación
 		int visited;	  // Cuenta las veces que se ha visitado una habitación
 		int died;		  // Cuenta las veces que se ha muerto en una habitación
 	};
 
-	struct stats_dictionary_t
+	struct StatsDictionary
 	{
 		std::string number; // Numero de la habitación
 		std::string name;	// Nombre de la habitación
 	};
 
 	// Variables
-	std::vector<stats_dictionary_t> dictionary; // Lista con la equivalencia nombre-numero de habitacion
-	std::vector<stats_t> bufferList;			// Lista con las estadisticas temporales por habitación
-	std::vector<stats_t> list;					// Lista con las estadisticas completas por habitación
+	std::vector<StatsDictionary> dictionary; // Lista con la equivalencia nombre-numero de habitacion
+	std::vector<StatsData> bufferList;			// Lista con las estadisticas temporales por habitación
+	std::vector<StatsData> list;				// Lista con las estadisticas completas por habitación
 	std::string bufferPath;						// Fichero con las estadísticas temporales
 	std::string filePath;						// Fichero con las estadísticas completas
 
 	// Busca una entrada en la lista por nombre
-	int findByName(std::string name, std::vector<stats_t> &list);
+	int findByName(const std::string &name, const std::vector<StatsData> &list);
 
 	// Carga las estadisticas desde un fichero
-	bool loadFromFile(std::string filePath, std::vector<stats_t> &list);
+	bool loadFromFile(const std::string &filePath, std::vector<StatsData> &list);
 
 	// Guarda las estadisticas en un fichero
-	void saveToFile(std::string filePath, std::vector<stats_t> &list);
+	void saveToFile(const std::string &filePath, const std::vector<StatsData> &list);
 
 	// Calcula cual es la habitación con más muertes
 	void checkWorstNightmare();
 
-	// Obtiene el nombre de una habitación a partir del número
-	std::string numberToName(std::string number);
-
-	// Obtiene el número de una habitación a partir del nombre
-	std::string nameToNumber(std::string name);
-
 	// Vuelca los datos del buffer en la lista de estadisticas
 	void updateListFromBuffer();
 
 public:
 	// Constructor
-	Stats(std::string file, std::string buffer);
+	Stats(const std::string &file, const std::string &buffer);
 
 	// Destructor
 	~Stats();
@@ -59,11 +53,11 @@ public:
 	void init();
 
 	// Añade una muerte a las estadisticas
-	void addDeath(std::string name);
+	void addDeath(const std::string &name);
 
 	// Añade una visita a las estadisticas
-	void addVisit(std::string name);
+	void addVisit(const std::string &name);
 
 	// Añade una entrada al diccionario
-	void addDictionary(std::string number, std::string name);
+	void addDictionary(const std::string &number, const std::string &name);
 };

source/surface.cpp

@@ -15,12 +15,10 @@ Surface::Surface(std::shared_ptr<SurfaceData> surface_dest, int w, int h)
       surface_(std::make_shared<SurfaceData>(w, h)),
       transparent_color_(0) {}
 
-Surface::Surface(std::shared_ptr<SurfaceData> surface_dest, std::string file_path)
+Surface::Surface(std::shared_ptr<SurfaceData> surface_dest, const std::string &file_path)
     : surface_dest_(surface_dest),
       surface_(std::make_shared<SurfaceData>(loadSurface(Asset::get()->get(file_path)))),
-      transparent_color_(0) {
-        std::cout << "surface loaded: "<< surface_->width << "x" << surface_->height << std::endl;
-      }
+      transparent_color_(0) {}
 
 Surface::~Surface() {}
 

source/surface.h

@@ -74,7 +74,7 @@ private:
 public:
     // Constructor
     Surface(std::shared_ptr<SurfaceData> surface_dest, int w, int h);
-    Surface(std::shared_ptr<SurfaceData> surface_dest, std::string file_path);
+    Surface(std::shared_ptr<SurfaceData> surface_dest, const std::string &file_path);
 
     // Destructor
     ~Surface();

source/title.cpp

@@ -23,26 +23,11 @@
 
 // Constructor
 Title::Title()
-	: screen_(Screen::get()),
-	  renderer_(Screen::get()->getRenderer()),
-	  resource_(Resource::get()),
-	  input_(Input::get())
+	: texture_(Resource::get()->getTexture("title_logo.png")),
+	  sprite_(std::make_shared<Sprite>(texture_, 0, 0, texture_->getWidth(), texture_->getHeight()))
 {
-	// Reserva memoria para los punteros
-	if (options.video.palette == Palette::ZXSPECTRUM)
-	{
-		texture_ = resource_->getTexture("title_logo.png");
-	}
-	else if (options.video.palette == Palette::ZXARNE)
-	{
-		texture_ = resource_->getTexture("title_logo.png");
-	}
-	sprite_ = std::make_shared<Sprite>(texture_, 0, 0, texture_->getWidth(), texture_->getHeight());
-	text_ = resource_->getText("smb2");
-	info_text_ = resource_->getText("subatomic");
-
 	// Crea la textura para los graficos que aparecen en el fondo de la pantalla de titulo
-	bg_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT);
+	bg_texture_ = SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT);
 	if (bg_texture_ == nullptr)
 	{
 		if (options.console)
@@ -53,13 +38,13 @@ Title::Title()
 	SDL_SetTextureBlendMode(bg_texture_, SDL_BLENDMODE_BLEND);
 
 	// Carga la surface con los gráficos de la pantalla de carga
-	pInit(renderer_, 256, 128);
+	pInit(Screen::get()->getRenderer(), 256, 128);
 	loading_screen_ = pLoadSurface(Asset::get()->get("loading_screen_color.gif").c_str());
 	pLoadPal(Asset::get()->get("loading_screen_color.gif").c_str());
 	pSetSource(loading_screen_);
 
 	// Inicializa variables
-	state_ = options.section.subsection == Subsection::TITLE_WITH_LOADING_SCREEN ? show_loading_screen : show_menu;
+	state_ = options.section.subsection == Subsection::TITLE_WITH_LOADING_SCREEN ? TitleState::SHOW_LOADING_SCREEN : TitleState::SHOW_MENU;
 	options.section.section = Section::TITLE;
 	options.section.subsection = Subsection::NONE;
 	initMarquee();
@@ -68,7 +53,7 @@ Title::Title()
 	createCheevosTexture();
 
 	// Cambia el color del borde
-	screen_->setBorderColor(stringToColor(options.video.palette, "black"));
+	Screen::get()->setBorderColor(stringToColor(options.video.palette, "black"));
 
 	// Rellena la textura de fondo con todos los gráficos
 	fillTexture();
@@ -91,7 +76,7 @@ void Title::initMarquee()
 	long_text_ = "HEY JAILERS!! IT'S 2022 AND WE'RE STILL ROCKING LIKE IT'S 1998!!! HAVE YOU HEARD IT? JAILGAMES ARE BACK!! YEEESSS BACK!! MORE THAN 10 TITLES ON JAILDOC'S KITCHEN!! THATS A LOOOOOOT OF JAILGAMES, BUT WHICH ONE WILL STRIKE FIRST? THERE IS ALSO A NEW DEVICE TO COME THAT WILL BLOW YOUR MIND WITH JAILGAMES ON THE GO: P.A.C.O. BUT WAIT! WHAT'S THAT BEAUTY I'M SEEING RIGHT OVER THERE?? OOOH THAT TINY MINIASCII IS PURE LOVE!! I WANT TO LICK EVERY BYTE OF IT!! OH SHIT! AND DON'T FORGET TO BRING BACK THOSE OLD AND FAT MS-DOS JAILGAMES TO GITHUB TO KEEP THEM ALIVE!! WHAT WILL BE THE NEXT JAILDOC RELEASE? WHAT WILL BE THE NEXT PROJECT TO COME ALIVE?? OH BABY WE DON'T KNOW BUT HERE YOU CAN FIND THE ANSWER, YOU JUST HAVE TO COMPLETE JAILDOCTOR'S DILEMMA ... COULD YOU?";
 	for (int i = 0; i < (int)long_text_.length(); ++i)
 	{
-		letter_t l;
+		TitleLetter l;
 		l.letter = long_text_.substr(i, 1);
 		l.x = 256;
 		l.enabled = false;
@@ -137,26 +122,26 @@ void Title::checkInput()
 {
 	if (show_cheevos_)
 	{
-		if (input_->checkInput(input_down, REPEAT_TRUE))
+		if (Input::get()->checkInput(InputAction::DOWN, REPEAT_TRUE))
 		{
 			moveCheevosList(1);
 		}
-		else if (input_->checkInput(input_up, REPEAT_TRUE))
+		else if (Input::get()->checkInput(InputAction::UP, REPEAT_TRUE))
 		{
 			moveCheevosList(0);
 		}
-		else if (input_->checkInput(input_accept, REPEAT_FALSE))
+		else if (Input::get()->checkInput(InputAction::ACCEPT, REPEAT_FALSE))
 		{
 			hideCheevosList();
 			counter_ = 0;
 		}
 	}
 
-	if (input_->checkInput(input_accept, REPEAT_FALSE))
+	if (Input::get()->checkInput(InputAction::ACCEPT, REPEAT_FALSE))
 	{
-		if (state_ == show_loading_screen)
+		if (state_ == TitleState::SHOW_LOADING_SCREEN)
 		{
-			state_ = fade_loading_screen;
+			state_ = TitleState::FADE_LOADING_SCREEN;
 		}
 	}
 
@@ -166,6 +151,8 @@ void Title::checkInput()
 // Actualiza la marquesina
 void Title::updateMarquee()
 {
+	const auto TEXT = Resource::get()->getText("smb2");
+
 	for (int i = 0; i < (int)letters_.size(); ++i)
 	{
 		if (letters_[i].enabled)
@@ -181,7 +168,7 @@ void Title::updateMarquee()
 			if (i > 0 && letters_[i - 1].x < 256 && letters_[i - 1].enabled)
 			{
 				letters_[i].enabled = true;
-				letters_[i].x = letters_[i - 1].x + text_->lenght(letters_[i - 1].letter) + 1;
+				letters_[i].x = letters_[i - 1].x + TEXT->lenght(letters_[i - 1].letter) + 1;
 			}
 		}
 	}
@@ -196,23 +183,16 @@ void Title::updateMarquee()
 // Dibuja la marquesina
 void Title::renderMarquee()
 {
-	for (auto l : letters_)
+	const auto TEXT = Resource::get()->getText("smb2");
+	for (const auto &l : letters_)
 	{
 		if (l.enabled)
 		{
-			text_->writeColored(l.x, 184, l.letter, stringToColor(options.video.palette, "white"));
+			TEXT->writeColored(l.x, 184, l.letter, stringToColor(options.video.palette, "white"));
 		}
 	}
 }
 
-// Dibuja la linea de información inferior
-void Title::renderInfo()
-{
-	const std::string version = "v.1.09";
-	const int x = GAMECANVAS_WIDTH - info_text_->lenght(version) - 1;
-	info_text_->write(x, 1, version);
-}
-
 // Actualiza las variables
 void Title::update()
 {
@@ -225,31 +205,33 @@ void Title::update()
 		// Comprueba las entradas
 		checkInput();
 
-		screen_->update();
+		Screen::get()->update();
 
 		// Incrementa el contador
 		counter_++;
 
 		switch (state_)
 		{
-		case show_loading_screen:
+		case TitleState::SHOW_LOADING_SCREEN:
 			if (counter_ == 500)
 			{
 				counter_ = 0;
-				state_ = fade_loading_screen;
+				state_ = TitleState::FADE_LOADING_SCREEN;
 			}
 			break;
 
-		case fade_loading_screen:
+		case TitleState::FADE_LOADING_SCREEN:
 			if (counter_ % 4 == 0)
+			{
 				if (pFadePal())
 				{
 					counter_ = 0;
-					state_ = show_menu;
+					state_ = TitleState::SHOW_MENU;
 				}
+			}
 			break;
 
-		case show_menu:
+		case TitleState::SHOW_MENU:
 			// Actualiza la marquesina
 			updateMarquee();
 
@@ -274,13 +256,13 @@ void Title::update()
 void Title::render()
 {
 	// Prepara para empezar a dibujar en la textura de juego
-	screen_->start();
-	screen_->clean(stringToColor(options.video.palette, "black"));
+	Screen::get()->start();
+	Screen::get()->clean(stringToColor(options.video.palette, "black"));
 
-	if (state_ == show_menu)
+	if (state_ == TitleState::SHOW_MENU)
 	{
 		// Dibuja la textura de fondo
-		SDL_RenderCopy(renderer_, bg_texture_, nullptr, nullptr);
+		SDL_RenderCopy(Screen::get()->getRenderer(), bg_texture_, nullptr, nullptr);
 
 		// Dibuja la marquesina
 		renderMarquee();
@@ -296,14 +278,14 @@ void Title::render()
 		// Dibuja la pantalla de carga
 		pCls(4);
 		pBlit(0, 0, 0, 0, 256, 128);
-		pFlip(renderer_);
+		pFlip(Screen::get()->getRenderer());
 
 		// Dibuja el logo del título
 		sprite_->render();
 	}
 
 	// Vuelca el contenido del renderizador en pantalla
-	screen_->render();
+	Screen::get()->render();
 }
 
 // Bucle para el logo del juego
@@ -317,40 +299,6 @@ void Title::run()
 	}
 }
 
-// Recarga las texturas
-void Title::reLoadTextures()
-{
-	// Carga la textura adecuada
-	if (options.video.palette == Palette::ZXSPECTRUM)
-	{
-		texture_ = resource_->getTexture("loading_screen_color.png");
-	}
-	else if (options.video.palette == Palette::ZXARNE)
-	{
-		texture_ = resource_->getTexture("loading_screen_color_zxarne.png");
-	}
-
-	texture_->reLoad();
-}
-
-// Cambia la paleta
-void Title::switchPalette()
-{
-	if (options.video.palette == Palette::ZXSPECTRUM)
-	{
-		options.video.palette = Palette::ZXARNE;
-		sprite_->setTexture(resource_->getTexture("loading_screen_color_zxarne.png"));
-	}
-	else
-	{
-		options.video.palette = Palette::ZXSPECTRUM;
-		sprite_->setTexture(resource_->getTexture("loading_screen_color.png"));
-	}
-
-	// Cambia el color del borde
-	screen_->setBorderColor(stringToColor(options.video.palette, "bright_blue"));
-}
-
 // Desplaza la lista de logros
 void Title::moveCheevosList(int direction)
 {
@@ -373,78 +321,82 @@ void Title::moveCheevosList(int direction)
 // Rellena la textura de fondo con todos los gráficos
 void Title::fillTexture()
 {
+	auto renderer = Screen::get()->getRenderer();
+
 	// Coloca el puntero del renderizador sobre la textura
-	SDL_SetRenderTarget(renderer_, bg_texture_);
+	SDL_SetRenderTarget(renderer, bg_texture_);
 
 	// Rellena la textura de color
 	const Color c = stringToColor(options.video.palette, "black");
-	SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
-	SDL_RenderClear(renderer_);
+	SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0xFF);
+	SDL_RenderClear(renderer);
 
 	// Pinta el gráfico del titulo a partir del sprite
 	sprite_->render();
 
 	// Escribe el texto en la textura
-	const Color textColor = stringToColor(options.video.palette, "green");
-	const int textSize = text_->getCharacterSize();
-	text_->writeDX(TEXT_CENTER | TEXT_COLOR, PLAY_AREA_CENTER_X, 11 * textSize, "1.PLAY", 1, textColor);
-	text_->writeDX(TEXT_CENTER | TEXT_COLOR, PLAY_AREA_CENTER_X, 13 * textSize, "2.ACHIEVEMENTS", 1, textColor);
-	text_->writeDX(TEXT_CENTER | TEXT_COLOR, PLAY_AREA_CENTER_X, 15 * textSize, "3.REDEFINE KEYS", 1, textColor);
-	text_->writeDX(TEXT_CENTER | TEXT_COLOR, PLAY_AREA_CENTER_X, 20 * textSize, "ESC.EXIT GAME", 1, textColor);
+	auto text = Resource::get()->getText("smb2");
+	const Color COLOR = stringToColor(options.video.palette, "green");
+	const int TEXT_SIZE = text->getCharacterSize();
+	text->writeDX(TEXT_CENTER | TEXT_COLOR, PLAY_AREA_CENTER_X, 11 * TEXT_SIZE, "1.PLAY", 1, COLOR);
+	text->writeDX(TEXT_CENTER | TEXT_COLOR, PLAY_AREA_CENTER_X, 13 * TEXT_SIZE, "2.ACHIEVEMENTS", 1, COLOR);
+	text->writeDX(TEXT_CENTER | TEXT_COLOR, PLAY_AREA_CENTER_X, 15 * TEXT_SIZE, "3.REDEFINE KEYS", 1, COLOR);
+	text->writeDX(TEXT_CENTER | TEXT_COLOR, PLAY_AREA_CENTER_X, 20 * TEXT_SIZE, "ESC.EXIT GAME", 1, COLOR);
 
 	// Devuelve el puntero del renderizador a su sitio
-	SDL_SetRenderTarget(renderer_, nullptr);
+	SDL_SetRenderTarget(renderer, nullptr);
 }
 
 // Crea y rellena la textura para mostrar los logros
 void Title::createCheevosTexture()
 {
 	// Crea la textura con el listado de logros
-	const auto cheevosList = Cheevos::get()->list();
-	const int cheevosTextureWidth = 200;
-	const int cheevosTextureViewHeight = 110;
-	const int cheevosTexturePosY = 73;
-	const int cheevosPadding = 10;
-	const int cheevoHeight = cheevosPadding + (info_text_->getCharacterSize() * 2) + 1;
-	const int cheevosTextureHeight = (cheevoHeight * cheevosList.size()) + 2 + info_text_->getCharacterSize() + 8;
-	cheevos_texture_ = std::make_shared<Texture>(renderer_);
-	cheevos_texture_->createBlank(cheevosTextureWidth, cheevosTextureHeight, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
-	cheevos_texture_->setAsRenderTarget(renderer_);
+	const auto CHEEVOS_LIST = Cheevos::get()->list();
+	const auto TEXT = Resource::get()->getText("subatomic");
+	constexpr int CHEEVOS_TEXTURE_WIDTH = 200;
+	constexpr int CHEEVOS_TEXTURE_VIEW_HEIGHT = 110;
+	constexpr int CHEEVOS_TEXTURE_POS_Y = 73;
+	constexpr int CHEEVOS_PADDING = 10;
+	const int CHEEVO_HEIGHT = CHEEVOS_PADDING + (TEXT->getCharacterSize() * 2) + 1;
+	const int CHEEVOS_TEXTURE_HEIGHT = (CHEEVO_HEIGHT * CHEEVOS_LIST.size()) + 2 + TEXT->getCharacterSize() + 8;
+	cheevos_texture_ = std::make_shared<Texture>(Screen::get()->getRenderer());
+	cheevos_texture_->createBlank(CHEEVOS_TEXTURE_WIDTH, CHEEVOS_TEXTURE_HEIGHT, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
+	cheevos_texture_->setAsRenderTarget(Screen::get()->getRenderer());
 	cheevos_texture_->setBlendMode(SDL_BLENDMODE_BLEND);
 
 	// Rellena la textura con color sólido
-	const Color cheevosBGColor = stringToColor(options.video.palette, "black");
-	SDL_SetRenderDrawColor(renderer_, cheevosBGColor.r, cheevosBGColor.g, cheevosBGColor.b, 0xFF);
-	SDL_RenderClear(renderer_);
+	const Color CHEEVOS_BG_COLOR = stringToColor(options.video.palette, "black");
+	SDL_SetRenderDrawColor(Screen::get()->getRenderer(), CHEEVOS_BG_COLOR.r, CHEEVOS_BG_COLOR.g, CHEEVOS_BG_COLOR.b, 0xFF);
+	SDL_RenderClear(Screen::get()->getRenderer());
 
 	// Escribe la lista de logros en la textura
-	const std::string cheevosOwner = "ACHIEVEMENTS";
-	const std::string cheevosListCaption = cheevosOwner + " (" + std::to_string(Cheevos::get()->unlocked()) + " / " + std::to_string(Cheevos::get()->count()) + ")";
+	const std::string CHEEVOS_OWNER = "ACHIEVEMENTS";
+	const std::string CHEEVOS_LIST_CAPTION = CHEEVOS_OWNER + " (" + std::to_string(Cheevos::get()->getTotalUnlockedAchievements()) + " / " + std::to_string(Cheevos::get()->size()) + ")";
 	int pos = 2;
-	info_text_->writeDX(TEXT_CENTER | TEXT_COLOR, cheevos_texture_->getWidth() / 2, pos, cheevosListCaption, 1, stringToColor(options.video.palette, "bright_green"));
-	pos += info_text_->getCharacterSize();
-	const Color cheevoLockedColor = stringToColor(options.video.palette, "white");
-	const Color cheevoUnlockedColor = stringToColor(options.video.palette, "bright_green");
+	TEXT->writeDX(TEXT_CENTER | TEXT_COLOR, cheevos_texture_->getWidth() / 2, pos, CHEEVOS_LIST_CAPTION, 1, stringToColor(options.video.palette, "bright_green"));
+	pos += TEXT->getCharacterSize();
+	const Color CHEEVO_LOCKED_COLOR = stringToColor(options.video.palette, "white");
+	const Color CHEEVO_UNLOCKED_COLOR = stringToColor(options.video.palette, "bright_green");
 	Color cheevoColor;
-	SDL_SetRenderDrawColor(renderer_, cheevoLockedColor.r, cheevoLockedColor.g, cheevoLockedColor.b, 0xFF);
-	const int lineX1 = (cheevosTextureWidth / 7) * 3;
-	const int lineX2 = lineX1 + ((cheevosTextureWidth / 7) * 1);
+	SDL_SetRenderDrawColor(Screen::get()->getRenderer(), CHEEVO_LOCKED_COLOR.r, CHEEVO_LOCKED_COLOR.g, CHEEVO_LOCKED_COLOR.b, 0xFF);
+	constexpr int LINE_X1 = (CHEEVOS_TEXTURE_WIDTH / 7) * 3;
+	constexpr int LINE_X2 = LINE_X1 + ((CHEEVOS_TEXTURE_WIDTH / 7) * 1);
 
-	for (auto cheevo : cheevosList)
+	for (const auto &cheevo : CHEEVOS_LIST)
 	{
-		cheevoColor = cheevo.completed ? cheevoUnlockedColor : cheevoLockedColor;
-		pos += cheevosPadding;
-		int half = cheevosPadding / 2;
-		SDL_RenderDrawLine(renderer_, lineX1, pos - half - 1, lineX2, pos - half - 1);
-		info_text_->writeDX(TEXT_CENTER | TEXT_COLOR, cheevosTextureWidth / 2, pos, cheevo.caption, 1, cheevoColor);
-		pos += info_text_->getCharacterSize() + 1;
-		info_text_->writeDX(TEXT_CENTER | TEXT_COLOR, cheevosTextureWidth / 2, pos, cheevo.description, 1, cheevoColor);
-		pos += info_text_->getCharacterSize();
+		cheevoColor = cheevo.completed ? CHEEVO_UNLOCKED_COLOR : CHEEVO_LOCKED_COLOR;
+		pos += CHEEVOS_PADDING;
+		constexpr int HALF = CHEEVOS_PADDING / 2;
+		SDL_RenderDrawLine(Screen::get()->getRenderer(), LINE_X1, pos - HALF - 1, LINE_X2, pos - HALF - 1);
+		TEXT->writeDX(TEXT_CENTER | TEXT_COLOR, CHEEVOS_TEXTURE_WIDTH / 2, pos, cheevo.caption, 1, cheevoColor);
+		pos += TEXT->getCharacterSize() + 1;
+		TEXT->writeDX(TEXT_CENTER | TEXT_COLOR, CHEEVOS_TEXTURE_WIDTH / 2, pos, cheevo.description, 1, cheevoColor);
+		pos += TEXT->getCharacterSize();
 	}
 
 	// Crea el sprite para el listado de logros
-	cheevos_sprite_ = std::make_shared<Sprite>(cheevos_texture_, (GAMECANVAS_WIDTH - cheevos_texture_->getWidth()) / 2, cheevosTexturePosY, cheevos_texture_->getWidth(), cheevos_texture_->getHeight());
-	cheevos_texture_view_ = {0, 0, cheevos_texture_->getWidth(), cheevosTextureViewHeight};
+	cheevos_sprite_ = std::make_shared<Sprite>(cheevos_texture_, (GAMECANVAS_WIDTH - cheevos_texture_->getWidth()) / 2, CHEEVOS_TEXTURE_POS_Y, cheevos_texture_->getWidth(), cheevos_texture_->getHeight());
+	cheevos_texture_view_ = {0, 0, cheevos_texture_->getWidth(), CHEEVOS_TEXTURE_VIEW_HEIGHT};
 	cheevos_sprite_->setClip(cheevos_texture_view_);
 }
 

source/title.h

@@ -17,43 +17,37 @@ class Texture;				 // lines 18-18
 class Title
 {
 private:
-	struct letter_t
+	struct TitleLetter
 	{
 		std::string letter; // Letra a escribir
 		int x;				// Posición en el eje x
 		bool enabled;		// Solo se escriben y mueven si estan habilitadas
 	};
 
-	enum states_e
+	enum class TitleState
 	{
-		show_loading_screen,
-		fade_loading_screen,
-		show_menu
+		SHOW_LOADING_SCREEN,
+		FADE_LOADING_SCREEN,
+		SHOW_MENU
 	};
 
 	// Objetos y punteros
-	Screen *screen_;						   // Objeto encargado de dibujar en pantalla
-	SDL_Renderer *renderer_;				   // El renderizador de la ventana
-	Resource *resource_;					   // Objeto con los recursos
-	Input *input_;							   // Objeto pata gestionar la entrada
 	std::shared_ptr<Texture> texture_;		   // Textura con los graficos
 	std::shared_ptr<Sprite> sprite_;		   // Sprite para manejar la textura
 	SDL_Texture *bg_texture_;				   // Textura para dibujar el fondo de la pantalla
-	std::shared_ptr<Text> text_;			   // Objeto para escribir texto en pantalla
-	std::shared_ptr<Text> info_text_;		   // Objeto para escribir texto en pantalla
 	std::shared_ptr<Texture> cheevos_texture_; // Textura con la lista de logros
 	std::shared_ptr<Sprite> cheevos_sprite_;   // Sprite para manejar la textura con la lista de logros
 
 	// Variables
-	int counter_ = 0;				// Contador
-	std::string long_text_;			// Texto que aparece en la parte inferior del titulo
-	Uint32 ticks_ = 0;				// Contador de ticks para ajustar la velocidad del programa
-	std::vector<letter_t> letters_; // Vector con las letras de la marquesina
-	int marquee_speed_ = 3;			// Velocidad de desplazamiento de la marquesina
-	bool show_cheevos_ = false;		// Indica si se muestra por pantalla el listado de logros
-	SDL_Rect cheevos_texture_view_; // Zona visible de la textura con el listado de logros
-	states_e state_;				// Estado en el que se encuentra el bucle principal
-	jSurface loading_screen_;	// Surface con los gráficos de la pantalla de carga
+	int counter_ = 0;				   // Contador
+	std::string long_text_;			   // Texto que aparece en la parte inferior del titulo
+	Uint32 ticks_ = 0;				   // Contador de ticks para ajustar la velocidad del programa
+	std::vector<TitleLetter> letters_; // Vector con las letras de la marquesina
+	int marquee_speed_ = 3;			   // Velocidad de desplazamiento de la marquesina
+	bool show_cheevos_ = false;		   // Indica si se muestra por pantalla el listado de logros
+	SDL_Rect cheevos_texture_view_;	   // Zona visible de la textura con el listado de logros
+	TitleState state_;				   // Estado en el que se encuentra el bucle principal
+	jSurface loading_screen_;		   // Surface con los gráficos de la pantalla de carga
 
 	// Actualiza las variables
 	void update();
@@ -76,15 +70,6 @@ private:
 	// Dibuja la marquesina
 	void renderMarquee();
 
-	// Dibuja la linea de información inferior
-	void renderInfo();
-
-	// Recarga las texturas
-	void reLoadTextures();
-
-	// Cambia la paleta
-	void switchPalette();
-
 	// Desplaza la lista de logros
 	void moveCheevosList(int direction);
 

source/utils.cpp

@@ -20,7 +20,7 @@ double distanceSquared(int x1, int y1, int x2, int y2)
 }
 
 // Detector de colisiones entre dos circulos
-bool checkCollision(Circle &a, Circle &b)
+bool checkCollision(const Circle &a, const Circle &b)
 {
     // Calcula el radio total al cuadrado
     int totalRadiusSquared = a.r + b.r;
@@ -38,7 +38,7 @@ bool checkCollision(Circle &a, Circle &b)
 }
 
 // Detector de colisiones entre un circulo y un rectangulo
-bool checkCollision(Circle &a, SDL_Rect &b)
+bool checkCollision(const Circle &a, const SDL_Rect &b)
 {
     // Closest point on collision box
     int cX, cY;
@@ -83,7 +83,7 @@ bool checkCollision(Circle &a, SDL_Rect &b)
 }
 
 // Detector de colisiones entre dos rectangulos
-bool checkCollision(SDL_Rect &a, SDL_Rect &b)
+bool checkCollision(const SDL_Rect &a, const SDL_Rect &b)
 {
     // Calcula las caras del rectangulo a
     const int leftA = a.x;
@@ -123,7 +123,7 @@ bool checkCollision(SDL_Rect &a, SDL_Rect &b)
 }
 
 // Detector de colisiones entre un punto y un rectangulo
-bool checkCollision(SDL_Point &p, SDL_Rect &r)
+bool checkCollision(const SDL_Point &p, const SDL_Rect &r)
 {
     // Comprueba si el punto está a la izquierda del rectangulo
     if (p.x < r.x)
@@ -154,7 +154,7 @@ bool checkCollision(SDL_Point &p, SDL_Rect &r)
 }
 
 // Detector de colisiones entre una linea horizontal y un rectangulo
-bool checkCollision(h_line_t &l, SDL_Rect &r)
+bool checkCollision(const h_line_t &l, const SDL_Rect &r)
 {
     // Comprueba si la linea esta por encima del rectangulo
     if (l.y < r.y)
@@ -185,7 +185,7 @@ bool checkCollision(h_line_t &l, SDL_Rect &r)
 }
 
 // Detector de colisiones entre una linea vertical y un rectangulo
-bool checkCollision(v_line_t &l, SDL_Rect &r)
+bool checkCollision(const v_line_t &l, const SDL_Rect &r)
 {
     // Comprueba si la linea esta por la izquierda del rectangulo
     if (l.x < r.x)
@@ -216,7 +216,7 @@ bool checkCollision(v_line_t &l, SDL_Rect &r)
 }
 
 // Detector de colisiones entre una linea horizontal y un punto
-bool checkCollision(h_line_t &l, SDL_Point &p)
+bool checkCollision(const h_line_t &l, const SDL_Point &p)
 {
     // Comprueba si el punto esta sobre la linea
     if (p.y > l.y)
@@ -247,7 +247,7 @@ bool checkCollision(h_line_t &l, SDL_Point &p)
 }
 
 // Detector de colisiones entre dos lineas
-SDL_Point checkCollision(line_t &l1, line_t &l2)
+SDL_Point checkCollision(const line_t &l1, const line_t &l2)
 {
     const float x1 = l1.x1;
     const float y1 = l1.y1;
@@ -276,7 +276,7 @@ SDL_Point checkCollision(line_t &l1, line_t &l2)
 }
 
 // Detector de colisiones entre dos lineas
-SDL_Point checkCollision(d_line_t &l1, v_line_t &l2)
+SDL_Point checkCollision(const d_line_t &l1, const v_line_t &l2)
 {
     const float x1 = l1.x1;
     const float y1 = l1.y1;
@@ -321,7 +321,7 @@ void normalizeLine(d_line_t &l)
 }
 
 // Detector de colisiones entre un punto y una linea diagonal
-bool checkCollision(SDL_Point &p, d_line_t &l)
+bool checkCollision(const SDL_Point &p, const d_line_t &l)
 {
     // Comprueba si el punto está en alineado con la linea
     if (abs(p.x - l.x1) != abs(p.y - l.y1))
@@ -464,36 +464,26 @@ bool colorAreEqual(Color color1, Color color2)
     return (r && g && b);
 }
 
-// Convierte una cadena a minusculas
+// Convierte una cadena a minúsculas
 std::string toLower(std::string str)
 {
-    const char *original = str.c_str();
-    char *lower = (char *)malloc(str.size() + 1);
-    for (int i = 0; i < (int)str.size(); ++i)
-    {
-        char c = original[i];
-        lower[i] = (c >= 65 && c <= 90) ? c + 32 : c;
+    for (char& c : str) {
+        if (c >= 'A' && c <= 'Z') {
+            c += 32; // Convierte a minúscula
+        }
     }
-    lower[str.size()] = 0;
-    std::string result(lower);
-    free(lower);
-    return result;
+    return str;
 }
 
 // Convierte una cadena a mayúsculas
 std::string toUpper(std::string str)
 {
-    const char *original = str.c_str();
-    char *upper = (char *)malloc(str.size() + 1);
-    for (int i = 0; i < (int)str.size(); ++i)
-    {
-        char c = original[i];
-        upper[i] = (c >= 97 && c <= 122) ? c - 32 : c;
+    for (char& c : str) {
+        if (c >= 'a' && c <= 'z') {
+            c -= 32; // Convierte a mayúscula
+        }
     }
-    upper[str.size()] = 0;
-    std::string result(upper);
-    free(upper);
-    return result;
+    return str;
 }
 
 // Obtiene el nombre de un fichero a partir de una ruta completa

source/utils.h

@@ -1,12 +1,11 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>    // for SDL_Rect, SDL_Point
-#include <SDL2/SDL_stdinc.h>  // for Uint8
-#include <string>             // for string
+#include <SDL2/SDL_rect.h>	 // for SDL_Rect, SDL_Point
+#include <SDL2/SDL_stdinc.h> // for Uint8
+#include <string>			 // for string
 #include <vector>
-#include <SDL2/SDL_render.h>  // for SDL_Renderer
-#include <SDL2/SDL.h> // for SDL_Texture
-
+#include <SDL2/SDL_render.h> // for SDL_Renderer
+#include <SDL2/SDL.h>		 // for SDL_Texture
 
 // Tipos de paleta
 enum class Palette : int
@@ -66,34 +65,34 @@ struct Color
 double distanceSquared(int x1, int y1, int x2, int y2);
 
 // Detector de colisiones entre dos circulos
-bool checkCollision(Circle &a, Circle &b);
+bool checkCollision(const Circle &a, const Circle &b);
 
 // Detector de colisiones entre un circulo y un rectangulo
-bool checkCollision(Circle &a, SDL_Rect &b);
+bool checkCollision(const Circle &a, const SDL_Rect &b);
 
 // Detector de colisiones entre un dos rectangulos
-bool checkCollision(SDL_Rect &a, SDL_Rect &b);
+bool checkCollision(const SDL_Rect &a, const SDL_Rect &b);
 
 // Detector de colisiones entre un punto y un rectangulo
-bool checkCollision(SDL_Point &p, SDL_Rect &r);
+bool checkCollision(const SDL_Point &p, const SDL_Rect &r);
 
 // Detector de colisiones entre una linea horizontal y un rectangulo
-bool checkCollision(h_line_t &l, SDL_Rect &r);
+bool checkCollision(const h_line_t &l, const SDL_Rect &r);
 
 // Detector de colisiones entre una linea vertical y un rectangulo
-bool checkCollision(v_line_t &l, SDL_Rect &r);
+bool checkCollision(const v_line_t &l, const SDL_Rect &r);
 
 // Detector de colisiones entre una linea horizontal y un punto
-bool checkCollision(h_line_t &l, SDL_Point &p);
+bool checkCollision(const h_line_t &l, const SDL_Point &p);
 
 // Detector de colisiones entre dos lineas
-SDL_Point checkCollision(line_t &l1, line_t &l2);
+SDL_Point checkCollision(const line_t &l1, const line_t &l2);
 
 // Detector de colisiones entre dos lineas
-SDL_Point checkCollision(d_line_t &l1, v_line_t &l2);
+SDL_Point checkCollision(const d_line_t &l1, const v_line_t &l2);
 
 // Detector de colisiones entre un punto y una linea diagonal
-bool checkCollision(SDL_Point &p, d_line_t &l);
+bool checkCollision(const SDL_Point &p, const d_line_t &l);
 
 // Normaliza una linea diagonal
 void normalizeLine(d_line_t &l);
@@ -135,4 +134,4 @@ bool stringInVector(const std::vector<std::string> &vec, const std::string &str)
 void playMusic(const std::string &music_path);
 
 // Rellena una textura de un color
-void fillTextureWithColor(SDL_Renderer* renderer, SDL_Texture* texture, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+void fillTextureWithColor(SDL_Renderer *renderer, SDL_Texture *texture, Uint8 r, Uint8 g, Uint8 b, Uint8 a);