Llevats un parell de warnings en pLoadSurface i pLoadPal

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

@@ -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

@@ -8,11 +8,9 @@
 #include <algorithm>             // for min
 #include <iostream>              // for basic_ostream, operator<<, cout, endl
 #include "animated_sprite.h"     // for AnimatedSprite
-#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 "options.h"             // for Options, options, OptionsVideo, Sect...
 #include "resource.h"            // for Resource
 #include "screen.h"              // for Screen
@@ -20,15 +18,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 +28,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 +42,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 +82,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 +167,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 +263,7 @@ void Credits::update()
 		// Actualiza el contador
 		updateCounter();
 
-		screen_->update();
+		Screen::get()->update();
 
 		// Actualiza el sprite con el brillo
 		if (counter_ > 770)
@@ -280,28 +277,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 +311,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,34 +1,23 @@
 #pragma once
 
-#include <SDL2/SDL_render.h>  // for SDL_Texture, SDL_Renderer
+#include <SDL2/SDL_render.h>  // for SDL_Texture
 #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 AnimatedSprite;  // lines 9-9
 
 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
@@ -38,7 +27,7 @@ private:
 	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
+	std::vector<Captions> texts_; // Vector con los textos
 
 	// Actualiza las variables
 	void update();
@@ -61,9 +50,6 @@ private:
 	// Escribe el texto en la textura
 	void fillTexture();
 
-	// Cambia la paleta
-	void switchPalette();
-
 public:
 	// Constructor
 	Credits();

source/debug.cpp

@@ -1,7 +1,7 @@
 #include "debug.h"
 #include <algorithm>   // for max
+#include <memory>      // for __shared_ptr_access, shared_ptr
 #include "resource.h"  // for Resource
-#include "screen.h"    // for Screen
 #include "text.h"      // for Text
 #include "utils.h"     // for Color
 
@@ -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,8 @@
 #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
 
 // Clase Debug
 class Debug
@@ -16,12 +11,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 +19,7 @@ private:
 	bool enabled_ = false;			// Indica si esta activo el modo debug
 
 	// Constructor
-	Debug();
+	Debug() = default;
 
 	// Destructor
 	~Debug() = default;
@@ -45,9 +34,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 +49,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

@@ -1,33 +1,26 @@
 #include "demo.h"
 #include <SDL2/SDL_events.h>  // for SDL_PollEvent, SDL_Event
 #include <SDL2/SDL_rect.h>    // for SDL_Rect
+#include <SDL2/SDL_render.h>  // for SDL_RenderFillRect, SDL_SetRenderDrawColor
 #include <SDL2/SDL_timer.h>   // for SDL_GetTicks
-#include <iostream>			 // for basic_ostream, operator<<, cout, endl
 #include "asset.h"            // for Asset
-#include "debug.h"			 // for Debug
 #include "defines.h"          // for BLOCK, PLAY_AREA_WIDTH, GAMECANVAS_CENT...
 #include "global_events.h"    // for check
 #include "global_inputs.h"    // for check
-#include "input.h"			 // for Input
 #include "item_tracker.h"     // for ItemTracker
 #include "options.h"          // for Options, options, OptionsVideo, Section...
 #include "resource.h"         // for Resource
 #include "room.h"             // for Room
+#include "scoreboard.h"       // for ScoreboardData, Scoreboard
 #include "screen.h"           // for Screen
-#include "text.h"			 // for Text, TEXT_CENTER, TEXT_COLOR
+#include "text.h"             // for TEXT_CENTER, TEXT_COLOR, Text
 #include "utils.h"            // for Color, stringToColor, colorAreEqual
 
 // 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 +37,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 +104,7 @@ void Demo::update()
 		scoreboard_->update();
 		checkRoomChange();
 
-		screen_->update();
+		Screen::get()->update();
 	}
 }
 
@@ -120,7 +112,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 +122,7 @@ void Demo::render()
 	scoreboard_->render();
 
 	// Actualiza la pantalla
-	screen_->render();
+	Screen::get()->render();
 }
 
 // Escribe el nombre de la pantalla
@@ -139,55 +131,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

@@ -1,32 +1,18 @@
 #pragma once
 
-#include <SDL2/SDL_render.h> // for SDL_Renderer
 #include <SDL2/SDL_stdinc.h>  // for Uint32
 #include <memory>             // for shared_ptr
 #include <string>             // for string
 #include <vector>             // for vector
-#include "scoreboard.h"		 // for board_t
-class Asset;				 // lines 11-11
-class Debug;				 // lines 12-12
-class Input;				 // lines 13-13
-class ItemTracker;			 // lines 14-14
-class Resource;				 // lines 15-15
-class Room;					 // lines 16-16
-class Screen;				 // lines 17-17
-class Text;					 // lines 18-18
+class Room;  // lines 14-14
+class Scoreboard;
+struct ScoreboardData;
 
 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 +39,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/director.h

@@ -3,7 +3,6 @@
 #include <SDL2/SDL_render.h>  // for SDL_Renderer
 #include <SDL2/SDL_video.h>   // for SDL_Window
 #include <string>             // for string
-struct JA_Music_t;  // lines 11-11
 
 class Director
 {

source/ending.cpp

@@ -7,11 +7,9 @@
 #include <SDL2/SDL_timer.h>      // for SDL_GetTicks
 #include <algorithm>             // for min
 #include <iostream>              // for basic_ostream, operator<<, cout, endl
-#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_SetVolume, JA_PlayMusic, JA_StopM...
 #include "options.h"             // for Options, options, OptionsVideo, Sect...
 #include "resource.h"            // for Resource
@@ -23,24 +21,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 +40,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 +88,7 @@ void Ending::update()
         // Actualiza el volumen de la musica
         updateMusicVolume();
 
-        screen_->update();
+        Screen::get()->update();
     }
 }
 
@@ -108,10 +96,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 +119,7 @@ void Ending::render()
     renderCoverTexture();
 
     // Vuelca el contenido del renderizador en pantalla
-    screen_->render();
+    Screen::get()->render();
 }
 
 // Comprueba el manejador de eventos
@@ -188,53 +176,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 +234,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 +266,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 +280,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 +408,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 +507,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 +540,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

@@ -1,18 +1,12 @@
 #pragma once
 
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_render.h>  // for SDL_Texture
 #include <SDL2/SDL_stdinc.h>  // for Uint32
 #include <memory>             // for shared_ptr
 #include <string>             // for string
 #include <vector>             // for vector
-class Asset;				 // lines 9-9
-class Input;				 // lines 10-10
-class Resource;				 // lines 11-11
-class Screen;				 // lines 12-12
-class Sprite;				 // lines 13-13
-class Text;					 // lines 14-14
-class Texture;				 // lines 15-15
-struct JA_Music_t;			 // lines 16-16
+class Sprite;  // lines 12-12
+class Texture;  // lines 14-14
 
 class Ending
 {
@@ -34,7 +28,7 @@ private:
 		int pos;			 // Posición
 	};
 
-	struct asdhk
+	struct TextIndex
 	{
 		int index;
 		int trigger;
@@ -42,18 +36,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 +53,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

@@ -2,14 +2,13 @@
 #include <SDL2/SDL_blendmode.h>  // for SDL_BLENDMODE_BLEND
 #include <SDL2/SDL_events.h>     // for SDL_PollEvent, SDL_Event
 #include <SDL2/SDL_rect.h>       // for SDL_Rect
+#include <SDL2/SDL_render.h>     // for SDL_RenderDrawPoint, SDL_SetRenderDr...
 #include <SDL2/SDL_timer.h>      // for SDL_GetTicks
 #include <algorithm>             // for max, min, replace
 #include "animated_sprite.h"     // for AnimatedSprite
-#include "asset.h"              // for Asset
 #include "defines.h"             // for GAMECANVAS_HEIGHT, GAMECANVAS_CENTER_X
 #include "global_events.h"       // for check
 #include "global_inputs.h"       // for check
-#include "input.h"              // for Input
 #include "jail_audio.h"          // for JA_SetVolume, JA_PlayMusic, JA_StopM...
 #include "moving_sprite.h"       // for MovingSprite
 #include "options.h"             // for Options, options, OptionsVideo, Sect...
@@ -21,37 +20,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 +88,8 @@ void Ending2::update()
         // Actualiza el volumen de la musica
         updateMusicVolume();
 
-        screen_->update();
+        // Actualiza el objeto
+        Screen::get()->update();
     }
 }
 
@@ -110,10 +97,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 +111,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(renderer_, 0, 0, 0, 0xFF);
+    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 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 +155,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 +279,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 +377,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 +401,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 +446,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 +482,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 +506,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

@@ -1,35 +1,27 @@
 #pragma once
 
-#include <SDL2/SDL_render.h> // for SDL_Renderer
 #include <SDL2/SDL_stdinc.h>  // for Uint32
 #include <memory>             // for shared_ptr
 #include <string>             // for string
 #include <vector>             // for vector
+#include "defines.h"          // for GAMECANVAS_WIDTH, GAMECANVAS_FIRST_QUAR...
 #include "utils.h"            // for Color
-#include "defines.h"		 // for GAMECANVAS_FIRST_QUARTER_X, GAMECANVAS_THIRD_QUARTER_X, GAMECANVAS_WIDTH
-class AnimatedSprite;		 // lines 9-9
-class Asset;				 // lines 10-10
-class Input;				 // lines 11-11
-class MovingSprite;			 // lines 12-12
-class Resource;				 // lines 13-13
-class Screen;				 // lines 14-14
-class Text;					 // lines 15-15
-struct JA_Music_t;			 // lines 16-16
+class AnimatedSprite;  // lines 10-10
+class MovingSprite;  // lines 13-13
 
 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 +32,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

@@ -8,103 +8,54 @@
 #include <vector>                // for vector
 #include "asset.h"               // for Asset
 #include "cheevos.h"             // for Cheevos
-#include "defines.h"			// for PLAY_AREA_HEIGHT, GAMECANVAS_WIDTH
 #include "debug.h"               // for Debug
-#include "input.h"				// for Input, REPEAT_FALSE, inputs_e
+#include "defines.h"             // for BLOCK, PLAY_AREA_HEIGHT, GAMECANVAS_...
+#include "global_events.h"       // for check
+#include "global_inputs.h"       // for check
+#include "input.h"               // for Input, InputAction, REPEAT_FALSE
 #include "item_tracker.h"        // for ItemTracker
 #include "jail_audio.h"          // for JA_PauseMusic, JA_PlaySound, JA_Resu...
-#include "resource.h"			// for Resource, res_room_t
-#include "room.h"				// for Room, room_t
+#include "notifier.h"            // for Notifier, NotificationText
+#include "options.h"             // for Options, options, Cheat, OptionsVideo
+#include "resource.h"            // for ResourceRoom, Resource
+#include "room.h"                // for Room, RoomData
 #include "room_tracker.h"        // for RoomTracker
+#include "scoreboard.h"          // for ScoreboardData, Scoreboard
 #include "screen.h"              // for Screen
 #include "stats.h"               // for Stats
-#include "text.h"				// for Text, TXT_CENTER, TXT_COLOR
-#include "utils.h"				// for options_t, cheat_t, stringToColor
-#include "options.h"
-#include "notifier.h"
-#include "global_inputs.h"
-#include "global_events.h"
-//#include "surface.h"
+#include "text.h"                // for Text, TEXT_CENTER, TEXT_COLOR
+#include "utils.h"               // for Color, stringToColor, colorAreEqual
 
 // 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

@@ -1,60 +1,37 @@
 #pragma once
 
-#include <SDL2/SDL_events.h> // Para SDL_Event
-#include <SDL2/SDL_rect.h>	 // Para SDL_Rect
-#include <SDL2/SDL_render.h> // Para SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h> // Para Uint32
-#include <string>			 // Para string, basic_string
-#include "player.h"			 // Para playerSpawn_t
-#include "scoreboard.h"		 // Para board_t
-#include "room.h"
-//#include "surface.h"
-class Asset;
-class Cheevos;
-class Debug;
-class Input;
-class ItemTracker;
-class Resource;
-class Room;
-class RoomTracker;
-class Screen;
-class Stats;
-class Text;
-struct JA_Music_t;
-struct JA_Sound_t;
-struct Options;
-struct SectionState;
+#include <SDL2/SDL_events.h>  // for SDL_Event
+#include <SDL2/SDL_rect.h>    // for SDL_Rect
+#include <SDL2/SDL_render.h>  // for SDL_Texture
+#include <SDL2/SDL_stdinc.h>  // for Uint32
+#include <memory>             // for shared_ptr
+#include <string>             // for string
+#include "player.h"           // for PlayerSpawn
+class Room;  // lines 17-17
+class RoomTracker;  // lines 18-18
+class Scoreboard;
+class Stats;  // lines 20-20
+struct ScoreboardData;
 
 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
+	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
-	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
+	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
 
@@ -73,13 +50,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 +82,6 @@ private:
 	// Mata al jugador
 	void killPlayer();
 
-	// Recarga todas las texturas
-	void reLoadTextures();
-
 	// Establece la pantalla en negro
 	void setBlackScreen();
 
@@ -123,11 +100,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 +118,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

@@ -4,11 +4,9 @@
 #include <algorithm>          // for min, max
 #include <string>             // for basic_string, operator+, to_string, cha...
 #include "animated_sprite.h"  // for AnimatedSprite
-#include "asset.h"           // for Asset
-#include "defines.h"         // for GAMECANVAS_CENTER_X
+#include "defines.h"          // for GAMECANVAS_CENTER_X, GAME_SPEED
 #include "global_events.h"    // for check
 #include "global_inputs.h"    // for check
-#include "input.h"           // for Input
 #include "jail_audio.h"       // for JA_PlayMusic
 #include "options.h"          // for Options, options, OptionsStats, Section...
 #include "resource.h"         // for Resource
@@ -18,34 +16,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 +61,7 @@ void GameOver::update()
         player_sprite_->update();
         tv_sprite_->update();
 
-        screen_->update();
+        Screen::get()->update();
     }
 }
 
@@ -81,11 +70,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 +86,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 +169,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

@@ -1,17 +1,10 @@
 #pragma once
 
-#include <SDL2/SDL_render.h> // for SDL_Renderer
 #include <SDL2/SDL_stdinc.h>  // for Uint32
 #include <memory>             // for shared_ptr
 #include <vector>             // for vector
 #include "utils.h"            // for Color
-class AnimatedSprite;		 // lines 9-9
-class Asset;				 // lines 10-10
-class Input;				 // lines 11-11
-class Resource;				 // lines 12-12
-class Screen;				 // lines 13-13
-class Text;					 // lines 14-14
-struct JA_Music_t;			 // lines 15-15
+class AnimatedSprite;  // lines 8-8
 
 class GameOver
 {
@@ -22,12 +15,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 +24,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/gif.cpp

@@ -1,8 +1,6 @@
 #include "gif.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <fcntl.h>
+#include <stdio.h>   // for NULL, fprintf, stderr
+#include <stdlib.h>  // for malloc, realloc, exit, calloc, free
 
 void uncompress( int code_length,
                const unsigned char *input,

source/gif.h

@@ -1,6 +1,7 @@
 #pragma once
 
-#include <stdint.h>
+#include <stdint.h>  // for uint32_t
+#include <string.h>  // for memcpy
 
 #define EXTENSION_INTRODUCER   0x21
 #define IMAGE_DESCRIPTOR       0x2C

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

@@ -32,40 +32,31 @@ Input::Input(const std::string &game_controller_db_path)
 	: db_path_(game_controller_db_path)
 {
 	// Inicializa las variables
-	keyBindings_t kb;
+	KeyBindings 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;
+	GameControllerBindings 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
@@ -55,13 +48,13 @@ private:
 	// [SINGLETON] Objeto privado
 	static Input *input_;
 
-	struct keyBindings_t
+	struct KeyBindings
 	{
 		Uint8 scancode; // Scancode asociado
 		bool active;	// Indica si está activo
 	};
 
-	struct GameControllerBindings_t
+	struct GameControllerBindings
 	{
 		SDL_GameControllerButton button; // GameControllerButton asociado
 		bool active;					 // Indica si está activo
@@ -71,13 +64,12 @@ private:
 	std::vector<SDL_GameController *> connected_controllers_; // Vector con todos los mandos conectados
 
 	// Variables
-	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<KeyBindings> key_bindings_;						   // Vector con las teclas asociadas a los inputs predefinidos
+	std::vector<GameControllerBindings> 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

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <SDL2/SDL_rect.h>  // for SDL_Rect, SDL_Point
-#include <SDL2/SDL_render.h> // for SDL_Renderer
 #include <memory>           // for shared_ptr, __shared_ptr_access
 #include <string>           // for string
 #include <vector>           // for vector
@@ -26,6 +25,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 +39,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,12 +1,13 @@
 #include "loading_screen.h"
+#include <SDL2/SDL_error.h>   // for SDL_GetError
 #include <SDL2/SDL_events.h>  // for SDL_PollEvent, SDL_Event
+#include <SDL2/SDL_pixels.h>  // for SDL_PIXELFORMAT_RGBA8888
 #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 <iostream>           // for char_traits, basic_ostream, operator<<
+#include "defines.h"          // for GAME_SPEED
 #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
@@ -14,34 +15,25 @@
 #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);
+	texture_ = SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, options.game.width, options.game.height);
 	if (texture_ == nullptr)
 	{
 		if (options.console)
@@ -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"));
 	}
 }
 
@@ -171,26 +161,28 @@ 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_);
+    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);
+    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;
-	int rowSize = 1;
-	while (row < height)
+    while (row < HEIGHT)
     {
-		rowSize = (rand() % 4) + 3;
+        const int ROW_HEIGHT = (rand() % 4) + 3;
         if (drawEnabled)
-			for (int i = row; i < row + rowSize; ++i)
         {
-				SDL_RenderDrawLine(renderer_, 0, i, width, i);
+            for (int i = row; i < row + ROW_HEIGHT; ++i)
+            {
+                SDL_RenderDrawLine(Screen::get()->getRenderer(), 0, i, WIDTH, i);
             }
-		row += rowSize;
+        }
+        row += ROW_HEIGHT;
         drawEnabled = !drawEnabled;
     }
 }
@@ -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

@@ -1,26 +1,16 @@
 #pragma once
 
 #include <SDL2/SDL_rect.h>    // for SDL_Rect
-#include <SDL2/SDL_render.h> // for SDL_Renderer
+#include <SDL2/SDL_render.h>  // for SDL_Texture
 #include <SDL2/SDL_stdinc.h>  // for Uint32
 #include <memory>             // for shared_ptr
-class Asset;				 // lines 8-8
-class Input;				 // lines 9-9
-class Resource;				 // lines 10-10
-class Screen;				 // lines 11-11
-class Sprite;				 // lines 12-12
-class Texture;				 // lines 13-13
-struct JA_Music_t;			 // lines 14-14
+class Sprite;  // lines 11-11
+class Texture;  // lines 12-12
 
 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 +22,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 +50,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

@@ -2,10 +2,9 @@
 #include <SDL2/SDL_events.h>  // for SDL_PollEvent, SDL_Event
 #include <SDL2/SDL_timer.h>   // for SDL_GetTicks
 #include <string>             // for basic_string, string
-#include "asset.h"			 // for Asset
+#include "defines.h"          // for GAME_SPEED
 #include "global_events.h"    // for check
 #include "global_inputs.h"    // for check
-#include "input.h"			 // for Input
 #include "jail_audio.h"       // for JA_StopMusic
 #include "options.h"          // for Options, options, SectionState, Section
 #include "resource.h"         // for Resource
@@ -13,20 +12,13 @@
 #include "sprite.h"           // for Sprite
 #include "texture.h"          // for Texture
 #include "utils.h"            // for Color, stringToColor
-#include "defines.h"
 
 // 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 +27,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 +68,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 +96,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 +203,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,20 +217,20 @@ 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_)
+	for (const auto &s : jailgames_sprite_)
 	{
 		s->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

@@ -1,14 +1,9 @@
 #pragma once
 
-#include <SDL2/SDL_render.h> // for SDL_Renderer
 #include <SDL2/SDL_stdinc.h>  // for Uint32
 #include <memory>             // for shared_ptr
 #include <vector>             // for vector
 #include "utils.h"            // for Color
-class Asset;				 // lines 8-8
-class Input;				 // lines 9-9
-class Resource;				 // lines 10-10
-class Screen;				 // lines 11-11
 class Sprite;  // lines 12-12
 class Texture;  // lines 13-13
 
@@ -21,11 +16,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

@@ -1,16 +1,17 @@
 #include "notifier.h"
-#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888
-#include <string>               // Para string
-#include <algorithm>
-#include <vector>
-#include "jail_audio.h" // Para JA_DeleteSound, JA_LoadSound, JA_Pla...
-#include "screen.h"     // Para Screen
-#include "sprite.h"     // Para Sprite
-#include "text.h"       // Para Text
-#include "texture.h"    // Para Texture
-#include "resource.h"
-#include "options.h"
+#include <SDL2/SDL_blendmode.h>  // for SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_pixels.h>     // for SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_render.h>     // for SDL_RenderFillRect, SDL_RenderClear
+#include <algorithm>             // for remove_if
+#include <string>                // for string, basic_string
+#include <vector>                // for vector
+#include "jail_audio.h"          // for JA_PlaySound
+#include "options.h"             // for Options, options, OptionsNotification
+#include "resource.h"            // for Resource
+#include "screen.h"              // for Screen
+#include "sprite.h"              // for Sprite
+#include "text.h"                // for Text, TEXT_CENTER, TEXT_COLOR
+#include "texture.h"             // for Texture
 
 // [SINGLETON]
 Notifier *Notifier::notifier_ = nullptr;
@@ -35,8 +36,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 +84,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 +117,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 +234,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 +290,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

@@ -1,11 +1,10 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>	 // Para SDL_Rect
-#include <SDL2/SDL_render.h> // Para SDL_Renderer
-#include <memory>			 // Para shared_ptr
-#include <string>			 // Para string, basic_string
-#include <vector>			 // Para vector
-#include "utils.h"			 // Para Color
+#include <SDL2/SDL_rect.h>  // for SDL_Rect
+#include <memory>           // for shared_ptr
+#include <string>           // for string, basic_string
+#include <vector>           // for vector
+#include "utils.h"          // for Color
 class Sprite;  // lines 9-9
 class Text;  // lines 10-10
 class Texture;  // lines 11-11
@@ -62,9 +61,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

@@ -1,13 +1,14 @@
 #include "options.h"
-#include <SDL2/SDL_video.h> // for SDL_WINDOW_FULLSCREEN, SDL_WINDOW_FULLSC...
+#include <SDL2/SDL_video.h>  // for SDL_WINDOW_FULLSCREEN_DESKTOP
+#include <algorithm>         // for find_if
+#include <cctype>            // for isspace
 #include <fstream>           // for basic_ostream, operator<<, basic_ofstream
 #include <functional>        // for function
 #include <iostream>          // for cout, cerr
+#include <sstream>           // for basic_istringstream
+#include <string>            // for char_traits, string, operator<<, hash
 #include <unordered_map>     // for unordered_map, operator==, _Node_const_i...
 #include <utility>           // for pair
-#include <sstream>
-#include <string>
-#include <algorithm>
 
 // Variables
 Options options;
@@ -39,7 +40,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 +50,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

@@ -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/paleta.cpp

@@ -82,21 +82,44 @@ jSurface pLoadSurface(const char *filename)
     fseek(f, 0, SEEK_END);
     long size = ftell(f);
     fseek(f, 0, SEEK_SET);
+
     Uint8 *buffer = (Uint8 *)malloc(size);
-    fread(buffer, size, 1, f);
+    if (!buffer) // Verificar que la memoria se asignó correctamente
+    {
+        fclose(f);
+        return NULL;
+    }
+
+    // Verificar el retorno de fread
+    if (fread(buffer, size, 1, f) != 1)
+    {
+        free(buffer); // Liberar memoria si falla la lectura
+        fclose(f);
+        return NULL;
+    }
+
     fclose(f);
 
     Uint16 w, h;
     Uint8 *pixels = LoadGif(buffer, &w, &h);
+    free(buffer); // Liberar memoria después de usar el buffer
+
     if (pixels == NULL)
     {
         return NULL;
     }
+
     jSurface surf = (jSurface)malloc(sizeof(jSurface_s));
+    if (!surf) // Verificar que la memoria se asignó correctamente
+    {
+        free(pixels); // Liberar los píxeles si falla
+        return NULL;
+    }
+
     surf->w = w;
     surf->h = h;
     surf->data = pixels;
-    free(buffer);
+
     return surf;
 }
 
@@ -110,15 +133,30 @@ void pLoadPal(const char *filename)
     long size = ftell(f);
     fseek(f, 0, SEEK_SET);
     Uint8 *buffer = (Uint8 *)malloc(size);
-    fread(buffer, size, 1, f);
+    if (!buffer) // Verificar que la asignación de memoria fue exitosa
+    {
+        fclose(f);
+        return;
+    }
+
+    // Verificar el resultado de fread
+    if (fread(buffer, size, 1, f) != 1)
+    {
+        free(buffer); // Liberar memoria si falla la lectura
+        fclose(f);
+        return;
+    }
+
     fclose(f);
 
     Uint32 *pal = LoadPalette(buffer);
+    free(buffer); // Liberar memoria después de usar el buffer
+
     if (pal == NULL)
     {
         return;
     }
-    free(buffer);
+
     for (int i = 0; i < 256; ++i)
     {
         paleta[i] = pal[i];

source/player.cpp

@@ -1,27 +1,22 @@
 // IWYU pragma: no_include <bits/std_abs.h>
 #include "player.h"
-#include <stdlib.h>          // Para rand
-#include <algorithm>         // Para max, min
-#include <cmath>             // Para ceil, abs
-#include "animated_sprite.h" // Para AnimatedSprite
-#include "asset.h"           // Para Asset
-#include "defines.h"         // Para BORDER_TOP, BLOCK, BORDER_BOTTOM, BORDER...
-#include "debug.h"           // Para Debug
-#include "input.h"           // Para Input, inputs_e
-#include "jail_audio.h"      // Para JA_LoadSound, JA_Sound_t, JA_PlaySound
-#include "resource.h"        // Para Resource
-#include "room.h"            // Para Room, tile_e
-#include "texture.h"         // Para Texture
-#include "options.h"
-#include "screen.h"
+#include <stdlib.h>           // for rand
+#include <algorithm>          // for max, min
+#include <cmath>              // for ceil, abs
+#include "animated_sprite.h"  // for AnimatedSprite
+#include "debug.h"            // for Debug
+#include "defines.h"          // for BORDER_BOTTOM, BORDER_LEFT, BORDER_RIGHT
+#include "input.h"            // for Input, InputAction
+#include "jail_audio.h"       // for JA_PlaySound
+#include "options.h"          // for Options, options, Cheat, OptionsVideo
+#include "resource.h"         // for Resource
+#include "room.h"             // for Room, JA_Sound_t, TileType
+#include "screen.h"           // for Screen
+#include "texture.h"          // for Texture
 
 // 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 +77,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 +114,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
@@ -293,7 +288,7 @@ void Player::move()
         // Si ha tocado alguna rampa mientras camina (sin saltar), asciende
         if (state_ != PlayerState::JUMPING)
         {
-            v_line_t leftSide = {static_cast<int>(x_), static_cast<int>(y_) + HEIGHT_ - 2, static_cast<int>(y_) + HEIGHT_ - 1}; // Comprueba solo los dos pixels de abajo
+            LineVertical leftSide = {static_cast<int>(x_), static_cast<int>(y_) + HEIGHT_ - 2, static_cast<int>(y_) + HEIGHT_ - 1}; // Comprueba solo los dos pixels de abajo
             const int ly = room_->checkLeftSlopes(&leftSide);
             if (ly > -1)
             {
@@ -340,7 +335,7 @@ void Player::move()
         // Si ha tocado alguna rampa mientras camina (sin saltar), asciende
         if (state_ != PlayerState::JUMPING)
         {
-            v_line_t rightSide = {static_cast<int>(x_) + WIDTH_ - 1, static_cast<int>(y_) + HEIGHT_ - 2, static_cast<int>(y_) + HEIGHT_ - 1}; // Comprueba solo los dos pixels de abajo
+            LineVertical rightSide = {static_cast<int>(x_) + WIDTH_ - 1, static_cast<int>(y_) + HEIGHT_ - 2, static_cast<int>(y_) + HEIGHT_ - 1}; // Comprueba solo los dos pixels de abajo
             const int ry = room_->checkRightSlopes(&rightSide);
             if (ry > -1)
             {
@@ -432,8 +427,8 @@ void Player::move()
             // Si no hay colisión con los muros, comprueba la colisión con las rampas
             if (state_ != PlayerState::JUMPING)
             { // Las rampas no se miran si se está saltando
-                v_line_t leftSide = {proj.x, proj.y, proj.y + proj.h - 1};
-                v_line_t rightSide = {proj.x + proj.w - 1, proj.y, proj.y + proj.h - 1};
+                LineVertical leftSide = {proj.x, proj.y, proj.y + proj.h - 1};
+                LineVertical rightSide = {proj.x + proj.w - 1, proj.y, proj.y + proj.h - 1};
                 const int p = std::max(room_->checkRightSlopes(&rightSide), room_->checkLeftSlopes(&leftSide));
                 if (p > -1)
                 {
@@ -469,8 +464,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 +505,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 +518,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 +545,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 +578,7 @@ bool Player::isOnAutoSurface()
 #ifdef DEBUG
     if (onAutoSurface)
     {
-        debug_->add("ON_AUTO_SURFACE");
+        Debug::get()->add("ON_AUTO_SURFACE");
     }
 #endif
 
@@ -609,7 +604,7 @@ bool Player::isOnDownSlope()
 #ifdef DEBUG
     if (onSlope)
     {
-        debug_->add("ON_DOWN_SLOPE");
+        Debug::get()->add("ON_DOWN_SLOPE");
     }
 #endif
 
@@ -622,21 +617,17 @@ bool Player::checkKillingTiles()
     // Actualiza los puntos de colisión
     updateColliderPoints();
 
-    // Comprueba si hay contacto
-    bool check = false;
-
-    for (auto c : collider_points_)
+    // Comprueba si hay contacto y retorna en cuanto se encuentra colisión
+    for (const auto &c : collider_points_)
     {
-        check |= (room_->getTile(c) == t_kill);
+        if (room_->getTile(c) == TileType::KILL)
+        {
+            is_alive_ = false; // Mata al jugador inmediatamente
+            return true;       // Retorna en cuanto se detecta una colisión
+        }
     }
 
-    // Mata al jugador si hay colisión
-    if (check)
-    {
-        is_alive_ = false;
-    }
-
-    return check;
+    return false; // No se encontró ninguna colisión
 }
 
 // Establece el color del jugador
@@ -709,13 +700,6 @@ void Player::initSounds()
     }
 }
 
-// Coloca el sprite en la posición del jugador
-void Player::placeSprite()
-{
-    sprite_->setPosX(x_);
-    sprite_->setPosY(y_);
-}
-
 // Aplica los valores de spawn al jugador
 void Player::applySpawnValues(const PlayerSpawn &spawn)
 {
@@ -744,34 +728,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

@@ -1,20 +1,16 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>	 // Para SDL_Rect, SDL_Point
-#include <SDL2/SDL_render.h> // Para SDL_Renderer
-#include <string>			 // Para basic_string, string
-#include <vector>			 // Para vector
-#include <memory>			 // Para shared_ptr
-#include "utils.h"			 // Para color_t
-#include "defines.h"		 // Para BLOCK
-#include "room.h"
-#include "animated_sprite.h"
-class Asset;
-class Debug;
-class Input;
-class Resource;
-class Room;
-struct JA_Sound_t;
+#include <SDL2/SDL_rect.h>    // for SDL_Rect, SDL_Point
+#include <SDL2/SDL_render.h>  // for SDL_RendererFlip, SDL_FLIP_NONE
+#include <memory>             // for shared_ptr, __shared_ptr_access
+#include <string>             // for string
+#include <vector>             // for vector
+#include "animated_sprite.h"  // for AnimatedSprite
+#include "defines.h"          // for BORDER_TOP, BLOCK
+#include "texture.h"          // for Texture
+#include "utils.h"            // for Color
+class Room;  // lines 16-16
+struct JA_Sound_t;  // lines 17-17
 
 enum class PlayerState
 {
@@ -63,10 +59,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
 
@@ -153,7 +145,7 @@ public:
 	void initSounds();
 
 	// Coloca el sprite en la posición del jugador
-	void placeSprite();
+	void placeSprite() { sprite_->setPos(x_, y_); }
 
 	// Aplica los valores de spawn al jugador
 	void applySpawnValues(const PlayerSpawn &spawn);
@@ -168,7 +160,7 @@ public:
 
 public:
 	// Constructor
-	Player(PlayerData player);
+	explicit Player(const PlayerData &player);
 
 	// Destructor
 	~Player() = default;
@@ -210,8 +202,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/resource.cpp

@@ -1,16 +1,20 @@
 #include "resource.h"
+#include <SDL2/SDL_events.h>   // for SDL_PollEvent, SDL_Event, SDL_KEYDOWN
+#include <SDL2/SDL_keycode.h>  // for SDLK_ESCAPE
+#include <SDL2/SDL_rect.h>     // for SDL_Rect
+#include <SDL2/SDL_render.h>   // for SDL_RenderDrawRect, SDL_RenderFillRect
+#include <stdlib.h>            // for exit, size_t
 #include <algorithm>           // for find_if
-#include <iostream>          // for basic_ostream, operator<<, endl, cout, cerr
+#include <iostream>            // for basic_ostream, operator<<, endl, cout
 #include <stdexcept>           // for runtime_error
-#include "asset.h"           // for Asset, AssetType
-#include "jail_audio.h"      // for JA_DeleteMusic, JA_DeleteSound, JA_LoadMusic
+#include "asset.h"             // for AssetType, Asset
+#include "jail_audio.h"        // for JA_DeleteMusic, JA_DeleteSound, JA_Loa...
+#include "options.h"           // for Options, OptionsGame, options
 #include "screen.h"            // for Screen
 #include "text.h"              // for Text, loadTextFile
-#include "utils.h"           // for getFileName, printWithDots
-#include "options.h"         // for getFileName, printWithDots
-#include <SDL2/SDL_events.h> // for SDL_PollEvent
-struct JA_Music_t;           // lines 10-10
-struct JA_Sound_t;           // lines 11-11
+#include "utils.h"             // for getFileName, printWithDots, Color
+struct JA_Music_t;  // lines 12-12
+struct JA_Sound_t;  // lines 13-13
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Resource *Resource::resource_ = nullptr;

source/room.cpp

@@ -1,34 +1,35 @@
 #include "room.h"
-#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_error.h>     // Para SDL_GetError
-#include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888
-#include <stdlib.h>             // Para rand
-#include <fstream>              // Para basic_ostream, operator<<, basic_ist...
-#include <iostream>             // Para cout
-#include <sstream>              // Para basic_stringstream
-#include "asset.h"              // Para Asset
-#include "defines.h"            // Para BLOCK, PLAY_AREA_HEIGHT, PLAY_AREA_W...
-#include "debug.h"              // Para Debug
-#include "item_tracker.h"       // Para ItemTracker
-#include "jail_audio.h"         // Para JA_DeleteSound, JA_LoadSound, JA_Pla...
-#include "screen.h"             // Para Screen
-#include "sprite.h"             // Para Sprite
-#include "texture.h"            // Para Texture
-#include "options.h"
-#include "utils.h" // Para stringToBool, stringToColor
-#include "resource.h"
+#include <SDL2/SDL_blendmode.h>  // for SDL_BLENDMODE_BLEND
+#include <SDL2/SDL_error.h>      // for SDL_GetError
+#include <SDL2/SDL_pixels.h>     // for SDL_PIXELFORMAT_RGBA8888
+#include <stdlib.h>              // for rand
+#include <exception>             // for exception
+#include <fstream>               // for basic_ostream, operator<<, basic_ist...
+#include <iostream>              // for cout, cerr
+#include <sstream>               // for basic_stringstream
+#include "debug.h"               // for Debug
+#include "defines.h"             // for BLOCK, PLAY_AREA_HEIGHT, PLAY_AREA_W...
+#include "item_tracker.h"        // for ItemTracker
+#include "jail_audio.h"          // for JA_PlaySound
+#include "options.h"             // for Options, options, OptionsVideo, Opti...
+#include "resource.h"            // for Resource
+#include "scoreboard.h"          // for ScoreboardData
+#include "screen.h"              // for Screen
+#include "sprite.h"              // for Sprite
+#include "texture.h"             // for Texture
+#include "utils.h"               // for LineHorizontal, LineDiagonal, LineVe...
 
 // Carga las variables y texturas desde un fichero de mapa de tiles
 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 +82,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,76 +399,23 @@ 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)
 {
-    number_ = room->number;
-    name_ = room->name;
-    bg_color_ = room->bg_color;
-    border_color_ = room->border_color;
-    item_color1_ = room->item_color1 == "" ? "yellow" : room->item_color1;
-    item_color2_ = room->item_color2 == "" ? "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_ = (options.video.palette == Palette::ZXSPECTRUM) ? Resource::get()->getTexture(room->tile_set_file) : Resource::get()->getTexture(room->tile_set_file);
+    auto room = Resource::get()->getRoom(room_path);
+    initializeRoom(*room);
 
-    // Inicializa variables
-    tile_set_width_ = texture_->getWidth() / TILE_SIZE_;
-    paused_ = false;
-    counter_ = 0;
-
-    // Crea los enemigos
-    for (auto &enemy_data : room->enemies)
-    {
-        enemies_.emplace_back(std::make_shared<Enemy>(enemy_data));
-    }
-
-    // Crea 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));
-        }
-    }
-
-    // Carga los sonidos
-    item_sound_ = Resource::get()->getSound("item.wav");
-
-    // Abre la jail para poder entrar
-    if (data_->jail_is_open)
-    {
+    // Abre la Jail si se da el caso
     openTheJail();
-    }
 
-    // Calcula las superficies
-    setBottomSurfaces();
-    setTopSurfaces();
-    setLeftSurfaces();
-    setRightSurfaces();
-    setLeftSlopes();
-    setRightSlopes();
-    setAutoSurfaces();
+    // Inicializa las superficies de colision
+    initRoomSurfaces();
 
     // Busca los tiles animados
     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,41 +429,65 @@ 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, border_color_));
 }
 
 // Destructor
-Room::~Room()
-{
-    // Reclama la memoria utilizada por los objetos
-    SDL_DestroyTexture(map_texture_);
-}
+Room::~Room() { SDL_DestroyTexture(map_texture_); }
 
-// Devuelve el nombre de la habitación
-std::string Room::getName()
+void Room::initializeRoom(const RoomData &room)
 {
-    return name_;
-}
+    // 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;
 
-// Devuelve el color de la habitación
-Color Room::getBGColor()
-{
-    return stringToColor(options.video.palette, bg_color_);
-}
+    // Crear los enemigos
+    for (auto &enemy_data : room.enemies)
+    {
+        enemies_.emplace_back(std::make_shared<Enemy>(enemy_data));
+    }
 
-// Devuelve el color del borde
-Color Room::getBorderColor()
-{
-    return stringToColor(options.video.palette, border_color_);
+    // Crear los items
+    for (const auto &item : room.items)
+    {
+        const SDL_Point itemPos = {item.x, item.y};
+
+        if (!ItemTracker::get()->hasBeenPicked(room.name, itemPos))
+        {
+            // Crear una copia local de los datos del item
+            ItemData itemCopy = item;
+            itemCopy.color1 = stringToColor(options.video.palette, item_color1_);
+            itemCopy.color2 = stringToColor(options.video.palette, item_color2_);
+
+            // Crear el objeto Item usando la copia modificada
+            items_.emplace_back(std::make_shared<Item>(itemCopy));
+        }
+    }
 }
 
 // Crea la textura con el mapeado de la habitación
 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 +509,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 +524,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 +542,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 +553,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 +564,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 +575,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 +586,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 +597,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 +612,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();
     }
@@ -656,7 +628,7 @@ void Room::renderMap()
 // Dibuja los enemigos en pantalla
 void Room::renderEnemies()
 {
-    for (auto enemy : enemies_)
+    for (const auto &enemy : enemies_)
     {
         enemy->render();
     }
@@ -665,7 +637,7 @@ void Room::renderEnemies()
 // Dibuja los objetos en pantalla
 void Room::renderItems()
 {
-    for (auto item : items_)
+    for (const auto &item : items_)
     {
         item->render();
     }
@@ -674,8 +646,9 @@ void Room::renderItems()
 // Actualiza las variables y objetos de la habitación
 void Room::update()
 {
-    if (paused_)
-    { // Si está en modo pausa no se actualiza nada
+    if (is_paused_)
+    {
+        // Si está en modo pausa no se actualiza nada
         return;
     }
 
@@ -686,12 +659,14 @@ void Room::update()
     updateAnimatedTiles();
 
     for (auto enemy : enemies_)
-    { // Actualiza los enemigos
+    {
+        // Actualiza los enemigos
         enemy->update();
     }
 
     for (auto item : items_)
-    { // Actualiza los items
+    {
+        // Actualiza los items
         item->update();
     }
 }
@@ -724,14 +699,14 @@ std::string Room::getRoom(int border)
 }
 
 // Devuelve el tipo de tile que hay en ese pixel
-tile_e Room::getTile(SDL_Point point)
+TileType Room::getTile(SDL_Point point)
 {
     const int pos = ((point.y / TILE_SIZE_) * MAP_WIDTH_) + (point.x / TILE_SIZE_);
     return getTile(pos);
 }
 
 // Devuelve el tipo de tile que hay en ese indice
-tile_e Room::getTile(int index)
+TileType Room::getTile(int index)
 {
     // const bool onRange = (index > -1) && (index < mapWidth * mapHeight);
     const bool onRange = (index > -1) && (index < (int)tile_map_.size());
@@ -741,66 +716,66 @@ tile_e Room::getTile(int index)
         // Las filas 0-8 son de tiles t_wall
         if ((tile_map_[index] >= 0) && (tile_map_[index] < 9 * tile_set_width_))
         {
-            return t_wall;
+            return TileType::WALL;
         }
 
         // Las filas 9-17 son de tiles t_passable
         else if ((tile_map_[index] >= 9 * tile_set_width_) && (tile_map_[index] < 18 * tile_set_width_))
         {
-            return t_passable;
+            return TileType::PASSABLE;
         }
 
         // Las filas 18-20 es de tiles t_animated
         else if ((tile_map_[index] >= 18 * tile_set_width_) && (tile_map_[index] < 21 * tile_set_width_))
         {
-            return t_animated;
+            return TileType::ANIMATED;
         }
 
         // La fila 21 es de tiles t_slope_r
         else if ((tile_map_[index] >= 21 * tile_set_width_) && (tile_map_[index] < 22 * tile_set_width_))
         {
-            return t_slope_r;
+            return TileType::SLOPE_R;
         }
 
         // La fila 22 es de tiles t_slope_l
         else if ((tile_map_[index] >= 22 * tile_set_width_) && (tile_map_[index] < 23 * tile_set_width_))
         {
-            return t_slope_l;
+            return TileType::SLOPE_L;
         }
 
         // La fila 23 es de tiles t_kill
         else if ((tile_map_[index] >= 23 * tile_set_width_) && (tile_map_[index] < 24 * tile_set_width_))
         {
-            return t_kill;
+            return TileType::KILL;
         }
     }
 
-    return t_empty;
+    return TileType::EMPTY;
 }
 
 // Indica si hay colision con un enemigo a partir de un rectangulo
 bool Room::enemyCollision(SDL_Rect &rect)
 {
-    bool collision = false;
-
-    for (auto enemy : enemies_)
+    for (const auto &enemy : enemies_)
     {
-        collision |= checkCollision(rect, enemy->getCollider());
+        if (checkCollision(rect, enemy->getCollider()))
+        {
+            return true;
         }
-
-    return collision;
+    }
+    return false;
 }
 
 // Indica si hay colision con un objeto a partir de un rectangulo
 bool Room::itemCollision(SDL_Rect &rect)
 {
-    for (int i = 0; i < (int)items_.size(); ++i)
+    for (int i = 0; i < static_cast<int>(items_.size()); ++i)
     {
-        if (checkCollision(rect, items_[i]->getCollider()))
+        if (checkCollision(rect, items_.at(i)->getCollider()))
         {
-            ItemTracker::get()->addItem(name_, items_[i]->getPos());
+            ItemTracker::get()->addItem(name_, items_.at(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,88 +785,34 @@ 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)
+int Room::getSlopeHeight(SDL_Point p, TileType 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
-    if (slope == t_slope_r)
+    if (slope == TileType::SLOPE_R)
     {
         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
     }
 
@@ -907,7 +828,7 @@ void Room::setBottomSurfaces()
     // Hay que recorrer la habitación por filas (excepto los de la última fila)
     for (int i = 0; i < (int)tile_map_.size() - MAP_WIDTH_; ++i)
     {
-        if (getTile(i) == t_wall && getTile(i + MAP_WIDTH_) != t_wall)
+        if (getTile(i) == TileType::WALL && getTile(i + MAP_WIDTH_) != TileType::WALL)
         {
             tile.push_back(i);
 
@@ -926,20 +847,19 @@ void Room::setBottomSurfaces()
     if ((int)tile.size() > 1)
     {
         int i = 0;
-        int lastOne = 0;
         do
         {
-            h_line_t line;
+            LineHorizontal 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 +868,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)
             {
@@ -970,7 +890,7 @@ void Room::setTopSurfaces()
     // Hay que recorrer la habitación por filas (excepto los de la primera fila)
     for (int i = MAP_WIDTH_; i < (int)tile_map_.size(); ++i)
     {
-        if ((getTile(i) == t_wall || getTile(i) == t_passable) && getTile(i - MAP_WIDTH_) != t_wall)
+        if ((getTile(i) == TileType::WALL || getTile(i) == TileType::PASSABLE) && getTile(i - MAP_WIDTH_) != TileType::WALL)
         {
             tile.push_back(i);
 
@@ -989,20 +909,19 @@ void Room::setTopSurfaces()
     if ((int)tile.size() > 1)
     {
         int i = 0;
-        int lastOne = 0;
         do
         {
-            h_line_t line;
+            LineHorizontal 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 +930,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)
             {
@@ -1036,7 +955,7 @@ void Room::setLeftSurfaces()
         for (int j = 0; j < MAP_HEIGHT_; ++j)
         {
             const int pos = (j * MAP_WIDTH_ + i);
-            if (getTile(pos) == t_wall && getTile(pos - 1) != t_wall)
+            if (getTile(pos) == TileType::WALL && getTile(pos - 1) != TileType::WALL)
             {
                 tile.push_back(pos);
             }
@@ -1054,7 +973,7 @@ void Room::setLeftSurfaces()
         int i = 0;
         do
         {
-            v_line_t line;
+            LineVertical line;
             line.x = (tile[i] % MAP_WIDTH_) * TILE_SIZE_;
             line.y1 = ((tile[i] / MAP_WIDTH_) * TILE_SIZE_);
             while (tile[i] + MAP_WIDTH_ == tile[i + 1])
@@ -1084,7 +1003,7 @@ void Room::setRightSurfaces()
         for (int j = 0; j < MAP_HEIGHT_; ++j)
         {
             const int pos = (j * MAP_WIDTH_ + i);
-            if (getTile(pos) == t_wall && getTile(pos + 1) != t_wall)
+            if (getTile(pos) == TileType::WALL && getTile(pos + 1) != TileType::WALL)
             {
                 tile.push_back(pos);
             }
@@ -1102,7 +1021,7 @@ void Room::setRightSurfaces()
         int i = 0;
         do
         {
-            v_line_t line;
+            LineVertical line;
             line.x = ((tile[i] % MAP_WIDTH_) * TILE_SIZE_) + TILE_SIZE_ - 1;
             line.y1 = ((tile[i] / MAP_WIDTH_) * TILE_SIZE_);
             while (tile[i] + MAP_WIDTH_ == tile[i + 1])
@@ -1127,7 +1046,7 @@ void Room::setLeftSlopes()
     std::vector<int> found;
     for (int i = 0; i < (int)tile_map_.size(); ++i)
     {
-        if (getTile(i) == t_slope_l)
+        if (getTile(i) == TileType::SLOPE_L)
         {
             found.push_back(i);
         }
@@ -1139,7 +1058,7 @@ void Room::setLeftSlopes()
 
     while (found.size() > 0)
     {
-        d_line_t line;
+        LineDiagonal line;
         line.x1 = (found[0] % MAP_WIDTH_) * TILE_SIZE_;
         line.y1 = (found[0] / MAP_WIDTH_) * TILE_SIZE_;
         int lookingFor = found[0] + MAP_WIDTH_ + 1;
@@ -1168,7 +1087,7 @@ void Room::setRightSlopes()
     std::vector<int> found;
     for (int i = 0; i < (int)tile_map_.size(); ++i)
     {
-        if (getTile(i) == t_slope_r)
+        if (getTile(i) == TileType::SLOPE_R)
         {
             found.push_back(i);
         }
@@ -1180,7 +1099,7 @@ void Room::setRightSlopes()
 
     while (found.size() > 0)
     {
-        d_line_t line;
+        LineDiagonal line;
         line.x1 = ((found[0] % MAP_WIDTH_) * TILE_SIZE_) + TILE_SIZE_ - 1;
         line.y1 = (found[0] / MAP_WIDTH_) * TILE_SIZE_;
         int lookingFor = found[0] + MAP_WIDTH_ - 1;
@@ -1211,7 +1130,7 @@ void Room::setAutoSurfaces()
     // Hay que recorrer la habitación por filas (excepto los de la primera fila)
     for (int i = MAP_WIDTH_; i < (int)tile_map_.size(); ++i)
     {
-        if (getTile(i) == t_animated)
+        if (getTile(i) == TileType::ANIMATED)
         {
             tile.push_back(i);
 
@@ -1224,23 +1143,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;
+            LineHorizontal 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 +1167,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)
             {
@@ -1268,7 +1186,7 @@ void Room::setAnimatedTiles()
     // Recorre la habitación entera por filas buscando tiles de tipo t_animated
     for (int i = 0; i < (int)tile_map_.size(); ++i)
     {
-        if (getTile(i) == t_animated)
+        if (getTile(i) == TileType::ANIMATED)
         {
             // La i es la ubicación
             const int x = (i % MAP_WIDTH_) * TILE_SIZE_;
@@ -1278,7 +1196,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;
@@ -1312,7 +1230,7 @@ void Room::updateAnimatedTiles()
 // Pinta los tiles animados en pantalla
 void Room::renderAnimatedTiles()
 {
-    for (auto a : animated_tiles_)
+    for (const auto &a : animated_tiles_)
     {
         a.sprite->render();
     }
@@ -1321,7 +1239,7 @@ void Room::renderAnimatedTiles()
 // Comprueba las colisiones
 int Room::checkRightSurfaces(SDL_Rect *rect)
 {
-    for (auto s : right_surfaces_)
+    for (const auto &s : right_surfaces_)
     {
         if (checkCollision(s, *rect))
         {
@@ -1335,7 +1253,7 @@ int Room::checkRightSurfaces(SDL_Rect *rect)
 // Comprueba las colisiones
 int Room::checkLeftSurfaces(SDL_Rect *rect)
 {
-    for (auto s : left_surfaces_)
+    for (const auto &s : left_surfaces_)
     {
         if (checkCollision(s, *rect))
         {
@@ -1349,7 +1267,7 @@ int Room::checkLeftSurfaces(SDL_Rect *rect)
 // Comprueba las colisiones
 int Room::checkTopSurfaces(SDL_Rect *rect)
 {
-    for (auto s : top_surfaces_)
+    for (const auto &s : top_surfaces_)
     {
         if (checkCollision(s, *rect))
         {
@@ -1363,7 +1281,7 @@ int Room::checkTopSurfaces(SDL_Rect *rect)
 // Comprueba las colisiones
 int Room::checkBottomSurfaces(SDL_Rect *rect)
 {
-    for (auto s : bottom_surfaces_)
+    for (const auto &s : bottom_surfaces_)
     {
         if (checkCollision(s, *rect))
         {
@@ -1377,7 +1295,7 @@ int Room::checkBottomSurfaces(SDL_Rect *rect)
 // Comprueba las colisiones
 int Room::checkAutoSurfaces(SDL_Rect *rect)
 {
-    for (auto s : auto_surfaces_)
+    for (const auto &s : auto_surfaces_)
     {
         if (checkCollision(s, *rect))
         {
@@ -1391,7 +1309,7 @@ int Room::checkAutoSurfaces(SDL_Rect *rect)
 // Comprueba las colisiones
 bool Room::checkTopSurfaces(SDL_Point *p)
 {
-    for (auto s : top_surfaces_)
+    for (const auto &s : top_surfaces_)
     {
         if (checkCollision(s, *p))
         {
@@ -1405,7 +1323,7 @@ bool Room::checkTopSurfaces(SDL_Point *p)
 // Comprueba las colisiones
 bool Room::checkAutoSurfaces(SDL_Point *p)
 {
-    for (auto s : auto_surfaces_)
+    for (const auto &s : auto_surfaces_)
     {
         if (checkCollision(s, *p))
         {
@@ -1417,11 +1335,11 @@ bool Room::checkAutoSurfaces(SDL_Point *p)
 }
 
 // Comprueba las colisiones
-int Room::checkLeftSlopes(v_line_t *line)
+int Room::checkLeftSlopes(const LineVertical *line)
 {
-    for (auto s : left_slopes_)
+    for (const 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 +1352,9 @@ int Room::checkLeftSlopes(v_line_t *line)
 // Comprueba las colisiones
 bool Room::checkLeftSlopes(SDL_Point *p)
 {
-    for (auto s : left_slopes_)
+    for (const auto &slope : left_slopes_)
     {
-        if (checkCollision(*p, s))
+        if (checkCollision(*p, slope))
         {
             return true;
         }
@@ -1446,11 +1364,11 @@ bool Room::checkLeftSlopes(SDL_Point *p)
 }
 
 // Comprueba las colisiones
-int Room::checkRightSlopes(v_line_t *line)
+int Room::checkRightSlopes(const LineVertical *line)
 {
-    for (auto s : right_slopes_)
+    for (const 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 +1381,9 @@ int Room::checkRightSlopes(v_line_t *line)
 // Comprueba las colisiones
 bool Room::checkRightSlopes(SDL_Point *p)
 {
-    for (auto s : right_slopes_)
+    for (const auto &slope : right_slopes_)
     {
-        if (checkCollision(*p, s))
+        if (checkCollision(*p, slope))
         {
             return true;
         }
@@ -1474,36 +1392,39 @@ 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()
-{
-    return auto_surface_direction_;
-}
-
-// Abre la jail para poder entrar
+// Abre la Jail si se da el caso
 void Room::openTheJail()
 {
-    if (name_ == "THE JAIL")
+    if (data_->jail_is_open && name_ == "THE JAIL")
+    {
+        // Elimina el último enemigo (Bry debe ser el último enemigo definido en el fichero)
+        if (!enemies_.empty())
         {
-        // Elimina el último enemigo (Bry debe ser el ultimo enemigo definido en el fichero)
             enemies_.pop_back();
+        }
 
         // Abre las puertas
-        const int tileA = 16 + (13 * 32);
-        const int tileB = 16 + (14 * 32);
-        tile_map_[tileA] = -1;
-        tile_map_[tileB] = -1;
+        constexpr int TILE_A = 16 + (13 * 32);
+        constexpr int TILE_B = 16 + (14 * 32);
+        if (TILE_A < tile_map_.size())
+        {
+            tile_map_[TILE_A] = -1;
+        }
+        if (TILE_B < tile_map_.size())
+        {
+            tile_map_[TILE_B] = -1;
+        }
     }
 }
+
+// Inicializa las superficies de colision
+void Room::initRoomSurfaces()
+{
+    setBottomSurfaces();
+    setTopSurfaces();
+    setLeftSurfaces();
+    setRightSurfaces();
+    setLeftSlopes();
+    setRightSlopes();
+    setAutoSurfaces();
+}

source/room.h

@@ -1,34 +1,33 @@
 #pragma once
 
 #include <SDL2/SDL_rect.h>    // for SDL_Rect, SDL_Point
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_render.h>  // for SDL_Texture
 #include <memory>             // for shared_ptr
 #include <string>             // for string
 #include <vector>             // for vector
 #include "enemy.h"            // for EnemyData
-#include "item.h"			 // for item_t
-#include "utils.h"			 // for Color
-#include "scoreboard.h"
-class Asset; // lines 12-12
-class Debug; // lines 13-13
-class ItemTracker;
-class Screen;	   // lines 14-14
-class Sprite;	   // lines 15-15
-class Texture;	   // lines 16-16
-struct JA_Sound_t; // lines 17-17
+#include "item.h"             // for ItemData
+#include "options.h"          // for Options, OptionsVideo, options
+#include "utils.h"            // for stringToColor, Color
+class Sprite;  // lines 17-17
+class Texture;  // lines 18-18
+struct JA_Sound_t;  // lines 19-19
+struct ScoreboardData;  // lines 20-20
 
-enum tile_e
+
+
+enum class TileType
 {
-	t_empty,
-	t_wall,
-	t_passable,
-	t_slope_l,
-	t_slope_r,
-	t_kill,
-	t_animated
+	EMPTY,
+	WALL,
+	PASSABLE,
+	SLOPE_L,
+	SLOPE_R,
+	KILL,
+	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 +47,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 +77,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
@@ -104,18 +99,20 @@ private:
 	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
+	std::vector<LineHorizontal> bottom_surfaces_; // Lista con las superficies inferiores de la habitación
+	std::vector<LineHorizontal> top_surfaces_;	  // Lista con las superficies superiores de la habitación
+	std::vector<LineVertical> left_surfaces_;	  // Lista con las superficies laterales de la parte izquierda de la habitación
+	std::vector<LineVertical> right_surfaces_;	  // Lista con las superficies laterales de la parte derecha de la habitación
+	std::vector<LineDiagonal> left_slopes_;		  // Lista con todas las rampas que suben hacia la izquierda
+	std::vector<LineDiagonal> 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
+	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<LineHorizontal> 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();
 
@@ -150,26 +147,29 @@ private:
 	void renderAnimatedTiles();
 
 	// Devuelve el tipo de tile que hay en ese indice
-	tile_e getTile(int index);
+	TileType getTile(int index);
 
 	// Abre la jail para poder entrar
 	void openTheJail();
 
+	// Inicializa las superficies de colision
+	void initRoomSurfaces();
+
 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();
 
 	// Devuelve el nombre de la habitación
-	std::string getName();
+	std::string getName() const { return name_; }
 
 	// Devuelve el color de la habitación
-	Color getBGColor();
+	Color getBGColor() const { return stringToColor(options.video.palette, bg_color_); }
 
 	// Devuelve el color del borde
-	Color getBorderColor();
+	Color getBorderColor() const { return stringToColor(options.video.palette, border_color_); }
 
 	// Dibuja el mapa en pantalla
 	void renderMap();
@@ -187,7 +187,7 @@ public:
 	std::string getRoom(int border);
 
 	// Devuelve el tipo de tile que hay en ese pixel
-	tile_e getTile(SDL_Point point);
+	TileType getTile(SDL_Point point);
 
 	// Indica si hay colision con un enemigo a partir de un rectangulo
 	bool enemyCollision(SDL_Rect &rect);
@@ -195,17 +195,11 @@ 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);
+	int getSlopeHeight(SDL_Point p, TileType slope);
 
 	// Comprueba las colisiones
 	int checkRightSurfaces(SDL_Rect *rect);
@@ -229,23 +223,20 @@ public:
 	bool checkAutoSurfaces(SDL_Point *p);
 
 	// Comprueba las colisiones
-	int checkLeftSlopes(v_line_t *line);
+	int checkLeftSlopes(const LineVertical *line);
 
 	// Comprueba las colisiones
 	bool checkLeftSlopes(SDL_Point *p);
 
 	// Comprueba las colisiones
-	int checkRightSlopes(v_line_t *line);
+	int checkRightSlopes(const LineVertical *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();
+	int getAutoSurfaceDirection() const { return auto_surface_direction_; }
 };

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

@@ -1,35 +1,33 @@
 #include "scoreboard.h"
+#include <SDL2/SDL_error.h>   // for SDL_GetError
+#include <SDL2/SDL_pixels.h>  // for SDL_PIXELFORMAT_RGBA8888
 #include <SDL2/SDL_rect.h>    // for SDL_Rect
 #include <SDL2/SDL_timer.h>   // for SDL_GetTicks
+#include <iostream>           // for basic_ostream, operator<<, cout, endl
 #include "animated_sprite.h"  // for AnimatedSprite
-#include "asset.h"           // for Asset
-#include "defines.h"         // for BLOCK, GAMECANVAS_HEIGHT, PLAY_AREA_HEIGHT
+#include "defines.h"          // for BLOCK
 #include "options.h"          // for Options, options, OptionsVideo, Cheat
 #include "resource.h"         // for Resource
 #include "screen.h"           // for Screen
 #include "text.h"             // for Text
 #include "texture.h"          // for Texture
-#include <iostream>
 
 // 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 +46,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 +62,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 +98,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;
+    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 +149,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 +183,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

@@ -1,30 +1,32 @@
 #pragma once
 
-#include <SDL2/SDL_render.h> // Para SDL_Renderer
-#include <SDL2/SDL_stdinc.h> // Para Uint32
-#include <string>			 // Para basic_string, string
-#include <vector>			 // Para vector
-#include "utils.h"			 // Para color_t
-#include <memory>			 // Para shared_ptr
-class AnimatedSprite;
-class Asset;
-class Resource;
-class Text;
-class Texture;
+#include <SDL2/SDL_rect.h>    // for SDL_Rect
+#include <SDL2/SDL_render.h>  // for SDL_Texture
+#include <SDL2/SDL_stdinc.h>  // for Uint32
+#include <memory>             // for shared_ptr
+#include <string>             // for string, basic_string
+#include <vector>             // for vector
+#include "utils.h"            // for Color
+class AnimatedSprite;  // lines 9-9
+class Texture;  // lines 13-13
 
 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 +38,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 +76,7 @@ private:
 
 public:
 	// Constructor
-	Scoreboard(std::shared_ptr<ScoreboardData> data);
+	explicit Scoreboard(std::shared_ptr<ScoreboardData> data);
 
 	// Destructor
 	~Scoreboard();
@@ -81,17 +87,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

@@ -2,13 +2,10 @@
 
 #include <SDL2/SDL_blendmode.h>  // for SDL_BlendMode
 #include <SDL2/SDL_rect.h>       // for SDL_Rect
-#include <SDL2/SDL_render.h>	// for SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_render.h>     // for SDL_Texture, SDL_Renderer
 #include <SDL2/SDL_stdinc.h>     // for Uint32
 #include <SDL2/SDL_video.h>      // for SDL_Window
-#include <vector>				// for vector
-#include <memory>				// for shared_ptr
 #include "utils.h"               // for Color
-//#include "surface.h"
 
 // Tipos de filtro
 enum class ScreenFilter : Uint32
@@ -58,9 +55,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

@@ -4,14 +4,9 @@
 #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

@@ -6,50 +6,44 @@
 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

@@ -1,26 +1,24 @@
 #include "surface.h"
-#include <SDL2/SDL_pixels.h> // Para SDL_PIXELFORMAT_ARGB8888
-#include <SDL2/SDL_rect.h>   // Para SDL_Rect
-#include <fstream>           // Para std::ifstream
-#include <iostream>          // Para std::cerr
-#include <vector>            // Para std::vector
-#include <stdexcept>         // For exceptions
-#include "gif.h"             // Para LoadGif, LoadPalette
-#include <memory>            // Para std::shared_ptr
-#include <algorithm>         // Para std::copy
-#include "asset.h"
+#include <SDL2/SDL_error.h>  // for SDL_GetError
+#include <stddef.h>          // for size_t
+#include <algorithm>         // for min, copy, fill
+#include <fstream>           // for basic_ostream, basic_ifstream, basic_ios
+#include <iostream>          // for cerr, cout
+#include <memory>            // for shared_ptr, __shared_ptr_access, unique_ptr
+#include <stdexcept>         // for runtime_error
+#include <vector>            // for vector
+#include "asset.h"           // for Asset
+#include "gif.h"             // for LoadGif, LoadPalette
 
 Surface::Surface(std::shared_ptr<SurfaceData> surface_dest, int w, int h)
     : surface_dest_(surface_dest),
       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/texture.cpp

@@ -1,14 +1,12 @@
 
 #include "texture.h"
-#include <SDL2/SDL_error.h>	  // Para SDL_GetError
-#include <SDL2/SDL_surface.h> // Para SDL_CreateRGBSurfaceWithFormatFrom
-#include <fstream>			  // Para basic_ostream, operator<<, basic_ifstream
-#include <iostream>			  // Para cerr, cout
-#include <stdexcept>		  // Para runtime_error
-#include <string>			  // Para char_traits, operator<<, operator+
-#include <vector>			  // Para vector
-#include "stb_image.h"		  // Para stbi_image_free, stbi_load, STBI_rgb_a...
-#include "utils.h"			  // Para getFileName, printWithDots
+#include <SDL2/SDL_error.h>    // for SDL_GetError
+#include <SDL2/SDL_surface.h>  // for SDL_CreateRGBSurfaceWithFormatFrom
+#include <iostream>            // for basic_ostream, operator<<, endl, cout
+#include <stdexcept>           // for runtime_error
+#include <string>              // for char_traits, operator<<, string, opera...
+#include <vector>              // for vector
+#include "utils.h"             // for getFileName, Color, printWithDots
 
 #define STB_IMAGE_IMPLEMENTATION
 #include "stb_image.h" // para stbi_failure_reason, stbi_image_free

source/texture.h

@@ -1,14 +1,13 @@
 #pragma once
 
-#include <SDL2/SDL_blendmode.h> // Para SDL_BlendMode
-#include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888, SDL_PixelF...
-#include <SDL2/SDL_rect.h>      // Para SDL_Point, SDL_Rect
-#include <SDL2/SDL_render.h>    // Para SDL_Renderer, SDL_FLIP_NONE, SDL_TEX...
-#include <SDL2/SDL_stdinc.h>    // Para Uint8, Uint16, Uint32
-#include <memory>               // Para shared_ptr
-#include <string>               // Para string
-#include <vector>               // Para vector
-struct Color;
+#include <SDL2/SDL_blendmode.h>  // for SDL_BlendMode
+#include <SDL2/SDL_pixels.h>     // for SDL_PIXELFORMAT_RGBA8888, SDL_PixelF...
+#include <SDL2/SDL_rect.h>       // for SDL_Point, SDL_Rect
+#include <SDL2/SDL_render.h>     // for SDL_Renderer, SDL_FLIP_NONE, SDL_TEX...
+#include <SDL2/SDL_stdinc.h>     // for Uint8, Uint32
+#include <string>                // for string
+#include <vector>                // for vector
+struct Color;  // lines 11-11
 
 // Definiciones de tipos
 /*struct 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

@@ -1,46 +1,36 @@
 #pragma once
 
 #include <SDL2/SDL_rect.h>    // for SDL_Rect
-#include <SDL2/SDL_render.h> // for SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_render.h>  // for SDL_Texture
 #include <SDL2/SDL_stdinc.h>  // for Uint32
 #include <memory>             // for shared_ptr
 #include <string>             // for string
 #include <vector>             // for vector
 #include "paleta.h"           // for jSurface
-class Input;				 // lines 13-13
-class Resource;				 // lines 14-14
-class Screen;				 // lines 15-15
-class Sprite;				 // lines 16-16
-class Text;					 // lines 17-17
-class Texture;				 // lines 18-18
+class Sprite;  // lines 13-13
+class Texture;  // lines 15-15
 
 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
 
@@ -48,11 +38,11 @@ private:
 	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
+	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
-	states_e state_;				// Estado en el que se encuentra el bucle principal
+	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
@@ -76,15 +66,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

@@ -1,15 +1,16 @@
 #include "utils.h"
-#include <stdlib.h>      // for free, malloc, abs
-#include <algorithm>     // for transform
+#include <stdlib.h>       // for abs
+#include <algorithm>      // for find, transform
 #include <cctype>         // for tolower
 #include <cmath>          // for round, abs
 #include <exception>      // for exception
 #include <filesystem>     // for path
 #include <iostream>       // for basic_ostream, cout, basic_ios, ios, endl
-#include <unordered_map> // for unordered_map
-#include <string>        // for string
-#include "jail_audio.h"
-#include "resource.h"
+#include <string>         // for basic_string, string, char_traits, allocator
+#include <unordered_map>  // for unordered_map, operator==, _Node_const_iter...
+#include <utility>        // for pair
+#include "jail_audio.h"   // for JA_GetMusicState, JA_Music_state, JA_PlayMusic
+#include "resource.h"     // for Resource
 
 // Calcula el cuadrado de la distancia entre dos puntos
 double distanceSquared(int x1, int y1, int x2, int y2)
@@ -20,7 +21,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 +39,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 +84,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 +124,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 +155,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 LineHorizontal &l, const SDL_Rect &r)
 {
     // Comprueba si la linea esta por encima del rectangulo
     if (l.y < r.y)
@@ -185,7 +186,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 LineVertical &l, const SDL_Rect &r)
 {
     // Comprueba si la linea esta por la izquierda del rectangulo
     if (l.x < r.x)
@@ -216,7 +217,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 LineHorizontal &l, const SDL_Point &p)
 {
     // Comprueba si el punto esta sobre la linea
     if (p.y > l.y)
@@ -247,7 +248,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 &l1, const Line &l2)
 {
     const float x1 = l1.x1;
     const float y1 = l1.y1;
@@ -276,7 +277,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 LineDiagonal &l1, const LineVertical &l2)
 {
     const float x1 = l1.x1;
     const float y1 = l1.y1;
@@ -305,7 +306,7 @@ SDL_Point checkCollision(d_line_t &l1, v_line_t &l2)
 }
 
 // Normaliza una linea diagonal
-void normalizeLine(d_line_t &l)
+void normalizeLine(LineDiagonal &l)
 {
     // Las lineas diagonales van de izquierda a derecha
     // x2 mayor que x1
@@ -321,7 +322,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 LineDiagonal &l)
 {
     // Comprueba si el punto está en alineado con la linea
     if (abs(p.x - l.x1) != abs(p.y - l.y1))
@@ -464,36 +465,30 @@ 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)
+    for (char &c : str)
     {
-        char c = original[i];
-        lower[i] = (c >= 65 && c <= 90) ? c + 32 : c;
+        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)
+    for (char &c : str)
     {
-        char c = original[i];
-        upper[i] = (c >= 97 && c <= 122) ? c - 32 : c;
+        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
@@ -539,10 +534,10 @@ 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)
 {
     // Guardar el render target actual
-    SDL_Texture* previous_target = SDL_GetRenderTarget(renderer);
+    SDL_Texture *previous_target = SDL_GetRenderTarget(renderer);
 
     // Establecer la textura como el render target
     SDL_SetRenderTarget(renderer, texture);

source/utils.h

@@ -1,12 +1,10 @@
 #pragma once
 
 #include <SDL2/SDL_rect.h>    // for SDL_Rect, SDL_Point
+#include <SDL2/SDL_render.h>  // for SDL_Renderer, SDL_Texture
 #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 <vector>             // for vector
 
 // Tipos de paleta
 enum class Palette : int
@@ -24,25 +22,25 @@ struct Circle
 };
 
 // Estructura para definir una linea horizontal
-struct h_line_t
+struct LineHorizontal
 {
 	int x1, x2, y;
 };
 
 // Estructura para definir una linea vertical
-struct v_line_t
+struct LineVertical
 {
 	int x, y1, y2;
 };
 
 // Estructura para definir una linea diagonal
-struct d_line_t
+struct LineDiagonal
 {
 	int x1, y1, x2, y2;
 };
 
 // Estructura para definir una linea
-struct line_t
+struct Line
 {
 	int x1, y1, x2, y2;
 };
@@ -66,37 +64,37 @@ 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 LineHorizontal &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 LineVertical &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 LineHorizontal &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 &l1, const Line &l2);
 
 // Detector de colisiones entre dos lineas
-SDL_Point checkCollision(d_line_t &l1, v_line_t &l2);
+SDL_Point checkCollision(const LineDiagonal &l1, const LineVertical &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 LineDiagonal &l);
 
 // Normaliza una linea diagonal
-void normalizeLine(d_line_t &l);
+void normalizeLine(LineDiagonal &l);
 
 // Devuelve un Color a partir de un string
 Color stringToColor(Palette pal, const std::string &str);
@@ -135,4 +133,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);