Añadiendo la clase asset

2022-09-26 10:17:54 +02:00
parent 25616e1e6c
commit 9e089e9092
18 changed files with 1190 additions and 622 deletions
--- a/source/asset.cpp
+++ b/source/asset.cpp
@@ -0,0 +1,160 @@
+#include "asset.h"
+
+// Constructor
+Asset::Asset(std::string path)
+{
+    executablePath = path;
+    longest_name = 0;
+}
+
+// Destructor
+Asset::~Asset()
+{
+}
+
+// Añade un elemento a la lista
+void Asset::add(std::string file, enum assetType type, bool required)
+{
+    item_t temp;
+    temp.file = executablePath + file;
+    temp.type = type;
+    temp.required = required;
+    fileList.push_back(temp);
+
+    const std::string filename = file.substr(file.find_last_of("\\/") + 1);
+    longest_name = SDL_max(longest_name, filename.size());
+}
+
+// Devuelve el fichero de un elemento de la lista a partir de una cadena
+std::string Asset::get(std::string text)
+{
+    for (auto f : fileList)
+    {
+        if (f.file.find(text) != std::string::npos)
+        {
+            return f.file;
+        }
+    }
+
+    printf("Warning: file %s not found\n", text.c_str());
+    return "";
+}
+
+// Comprueba que existen todos los elementos
+bool Asset::check()
+{
+    bool success = true;
+
+    printf("\n** Checking files.\n");
+
+    // Comprueba la lista de ficheros clasificandolos por tipo
+    for (int type = 0; type < maxAssetType; ++type)
+    {
+        // Comprueba si hay ficheros de ese tipo
+        bool any = false;
+
+        for (auto f : fileList)
+        {
+            if ((f.required) && (f.type == type))
+            {
+                any = true;
+            }
+        }
+
+        // Si hay ficheros de ese tipo, comprueba si existen
+        if (any)
+        {
+            printf("\n>> %s FILES\n", getTypeName(type).c_str());
+
+            for (auto f : fileList)
+            {
+                if ((f.required) && (f.type == type))
+                {
+                    success &= checkFile(f.file);
+                }
+            }
+        }
+    }
+
+    // Resultado
+    if (success)
+    {
+        printf("\n** All files OK.\n\n");
+    }
+    else
+    {
+        printf("\n** A file is missing. Exiting.\n\n");
+    }
+
+    return success;
+}
+
+// Comprueba que existe un fichero
+bool Asset::checkFile(std::string path)
+{
+    bool success = false;
+    std::string result = "ERROR";
+
+    // Comprueba si existe el fichero
+    const std::string filename = path.substr(path.find_last_of("\\/") + 1);
+    SDL_RWops *file = SDL_RWFromFile(path.c_str(), "r+b");
+
+    if (file != nullptr)
+    {
+        result = "OK";
+        success = true;
+        SDL_RWclose(file);
+    }
+
+    const std::string s = "Checking file %-" + std::to_string(longest_name) + "s [" + result + "]\n";
+    printf(s.c_str(), filename.c_str());
+
+    return success;
+}
+
+// Devuelve el nombre del tipo de recurso
+std::string Asset::getTypeName(int type)
+{
+    switch (type)
+    {
+    case bitmap:
+        return "BITMAP";
+        break;
+
+    case music:
+        return "MUSIC";
+        break;
+
+    case sound:
+        return "SOUND";
+        break;
+
+    case font:
+        return "FONT";
+        break;
+
+    case lang:
+        return "LANG";
+        break;
+
+    case data:
+        return "DATA";
+        break;
+
+    case room:
+        return "ROOM";
+        break;
+
+    case enemy:
+        return "ENEMY";
+        break;
+
+    case item:
+        return "ITEM";
+        break;
+
+    default:
+        return "ERROR";
+        break;
+    }
+}
--- a/source/asset.h
+++ b/source/asset.h
@@ -0,0 +1,64 @@
+#pragma once
+
+#include <SDL2/SDL.h>
+#include <string>
+#include <vector>
+
+#ifndef ASSET_H
+#define ASSET_H
+
+enum assetType
+{
+	bitmap,
+	music,
+	sound,
+	font,
+	lang,
+	data,
+	room,
+	enemy,
+	item,
+	maxAssetType
+};
+
+// Clase Asset
+class Asset
+{
+private:
+	// Estructura para definir un item
+	struct item_t
+	{
+		std::string file;	 // Ruta del fichero desde la raiz del directorio
+		enum assetType type; // Indica el tipo de recurso
+		bool required;		 // Indica si es un fichero que debe de existir
+	};
+
+	int longest_name; // Contiene la longitud del nombre de fichero mas largo
+
+	std::vector<item_t> fileList;
+	std::string executablePath;
+
+	// Comprueba que existe un fichero
+	bool checkFile(std::string path);
+
+	// Devuelve el nombre del tipo de recurso
+	std::string getTypeName(int type);
+
+public:
+	// Constructor
+	Asset(std::string path);
+
+	// Destructor
+	~Asset();
+
+	// Añade un elemento a la lista
+	void add(std::string file, enum assetType type, bool required = true);
+
+	// Devuelve un elemento de la lista a partir de una cadena
+	std::string get(std::string text);
+
+	// Comprueba que existen todos los elementos
+	bool check();
+};
+
+#endif
--- a/source/director.cpp
+++ b/source/director.cpp
@@ -7,26 +7,26 @@
 // Constructor
 Director::Director(std::string path)
 {
-	// Inicializa la ruta
-	setExecutablePath(path);

+	// Crea el objeto que controla los ficheros de recursos
+	mAsset = new Asset(path.substr(0, path.find_last_of("\\/")) + "../");
+	
 	// Establece la lista de ficheros
-	setFileList();
-
-	// Si falta algún fichero no inicies el programa
 	Uint8 section = PROG_SECTION_LOGO;
-	if (!checkFileList())
+	if (!setFileList())
+	{// Si falta algún fichero no inicies el programa
 		section = PROG_SECTION_QUIT;
+	}

 	// Crea el objeto de idioma
-	mLang = new Lang(mFileList);
+	mLang = new Lang(mAsset);

 	// Crea el puntero a la estructura y carga el fichero de configuración
 	mOptions = new options_t;
 	loadConfigFile();

 	// Crea los objetos
-	mInput = new Input(mFileList[53]);
+	mInput = new Input(mAsset->get("controllerdb.txt"));

 	// Inicializa SDL
 	initSDL();
@@ -48,6 +48,9 @@ Director::~Director()
 {
 	saveConfigFile();

+	delete mAsset;
+	mAsset = nullptr;
+
 	delete mInput;
 	mInput = nullptr;

@@ -172,10 +175,82 @@ bool Director::initSDL()
 }

 // Crea el indice de ficheros
-void Director::setFileList()
+bool Director::setFileList()
 {
+	// Ficheros binarios
+	mAsset->add("data/score.bin", data, false);
+	mAsset->add("data/demo.bin", data);
+	mAsset->add("data/config.bin", data, false);
+
+	// Musicas
+	mAsset->add("media/music/intro.ogg", music);
+	mAsset->add("media/music/playing.ogg", music);
+	mAsset->add("media/music/title.ogg", music);
+
+	// Sonidos
+	mAsset->add("media/sound/balloon.wav", sound);
+	mAsset->add("media/sound/bubble1.wav", sound);
+	mAsset->add("media/sound/bubble2.wav", sound);
+	mAsset->add("media/sound/bubble3.wav", sound);
+	mAsset->add("media/sound/bubble4.wav", sound);
+	mAsset->add("media/sound/bullet.wav", sound);
+	mAsset->add("media/sound/coffeeout.wav", sound);
+	mAsset->add("media/sound/hiscore.wav", sound);
+	mAsset->add("media/sound/itemdrop.wav", sound);
+	mAsset->add("media/sound/itempickup.wav", sound);
+	mAsset->add("media/sound/menu_cancel.wav", sound);
+	mAsset->add("media/sound/menu_move.wav", sound);
+	mAsset->add("media/sound/menu_select.wav", sound);
+	mAsset->add("media/sound/player_collision.wav", sound);
+	mAsset->add("media/sound/stage_change.wav", sound);
+	mAsset->add("media/sound/title.wav", sound);
+	mAsset->add("media/sound/clock.wav", sound);
+	mAsset->add("media/sound/powerball.wav", sound);
+
+	// Texturas
+	mAsset->add("media/gfx/balloon.png", bitmap);
+	mAsset->add("media/gfx/bullet.png", bitmap);
+	mAsset->add("media/gfx/game_bg.png", bitmap);
+	mAsset->add("media/gfx/game_text.png", bitmap);
+	mAsset->add("media/gfx/intro.png", bitmap);
+	mAsset->add("media/gfx/items.png", bitmap);
+	mAsset->add("media/gfx/logo.png", bitmap);
+	mAsset->add("media/gfx/player1_body.png", bitmap);
+	mAsset->add("media/gfx/player1_death.png", bitmap);
+	mAsset->add("media/gfx/player1_legs.png", bitmap);
+	mAsset->add("media/gfx/title.png", bitmap);
+	mAsset->add("media/gfx/player1_head.png", bitmap);
+	mAsset->add("media/gfx/player2_body.png", bitmap);
+	mAsset->add("media/gfx/player2_death.png", bitmap);
+	mAsset->add("media/gfx/player2_legs.png", bitmap);
+	mAsset->add("media/gfx/player2_head.png", bitmap);
+
+	// Fuentes
+	mAsset->add("media/font/8bithud.png", font);
+	mAsset->add("media/font/8bithud.txt", font);
+	mAsset->add("media/font/nokia.png", font);
+	mAsset->add("media/font/nokia_big2.png", font);
+	mAsset->add("media/font/nokia.txt", font);
+	mAsset->add("media/font/nokia2.png", font);
+	mAsset->add("media/font/nokia2.txt", font);
+	mAsset->add("media/font/nokia_big2.txt", font);
+	mAsset->add("media/font/smb2_big.png", font);
+	mAsset->add("media/font/smb2_big.txt", font);
+	mAsset->add("media/font/smb2.png", font);
+	mAsset->add("media/font/smb2.txt", font);
+
+	// Textos
+	mAsset->add("media/lang/es_ES.txt", lang);
+	mAsset->add("media/lang/en_UK.txt", lang);
+	mAsset->add("media/lang/ba_BA.txt", lang);
+
+	// DATA
+	mAsset->add("data/gamecontrollerdb.txt", data);
+
+	return mAsset->check();
+
 	// Inicializa el vector
-	for (int i = 0; i < MAX_FILE_LIST; i++)
+	/*for (int i = 0; i < MAX_FILE_LIST; i++)
 		mFileList[i] = "";

 	// Ficheros binarios
@@ -247,69 +322,7 @@ void Director::setFileList()

 	// DATA
 	mFileList[53] = mExecutablePath + "/" + "../data/gamecontrollerdb.txt";
-}
-
-// Comprueba los ficheros del vector de ficheros que coinciden con una ruta dada
-bool Director::checkFolder(std::string name, std::string path)
-{
-	bool success = true;
-	std::string p;
-	std::string filename;
-	SDL_RWops *file;
-
-	// Comprueba los ficheros de la carpeta
-	printf("\n>> %s FILES\n", name.c_str());
-	for (int i = 3; i < MAX_FILE_LIST; i++)
-	{
-		if (mFileList[i].find(path.c_str()) != std::string::npos)
-		{
-			p = mFileList[i].c_str();
-			filename = p.substr(p.find_last_of("\\/") + 1);
-			file = SDL_RWFromFile(p.c_str(), "r+b");
-			if (file != nullptr)
-			{
-				printf("Checking file %-20s [OK]\n", filename.c_str());
-			}
-			else
-			{
-				printf("Checking file %-20s [ERROR]\n", filename.c_str());
-				success = false;
-				break;
-			}
-			SDL_RWclose(file);
-		}
-	}
-	return success;
-}
-
-// Comprueba que todos los ficheros existen
-bool Director::checkFileList()
-{
-	bool success = true;
-	printf("Checking files...\n");
-
-	if (success)
-		success &= checkFolder("MUSIC", "/media/music/");
-
-	if (success)
-		success &= checkFolder("SOUND", "/media/sound/");
-
-	if (success)
-		success &= checkFolder("BITMAP", "/media/gfx/");
-
-	if (success)
-		success &= checkFolder("FONT", "/media/font/");
-
-	if (success)
-		success &= checkFolder("LANG", "/media/lang/");
-
-	// Resultado
-	if (success)
-		printf("\n** All files OK.\n\n");
-	else
-		printf("\n** A file is missing. Exiting.\n\n");
-
-	return success;
+	*/
 }

 // Carga el fichero de configuración
@@ -332,7 +345,7 @@ bool Director::loadConfigFile()
 	// Indicador de éxito en la carga
 	bool success = true;

-	const std::string p = mFileList[2];
+	const std::string p = mAsset->get("config.bin");
 	std::string filename = p.substr(p.find_last_of("\\/") + 1);
 	SDL_RWops *file = SDL_RWFromFile(p.c_str(), "r+b");

@@ -409,7 +422,7 @@ bool Director::loadConfigFile()
 bool Director::saveConfigFile()
 {
 	bool success = true;
-	const std::string p = mFileList[2];
+	const std::string p = mAsset->get("config.bin");
 	std::string filename = p.substr(p.find_last_of("\\/") + 1);
 	SDL_RWops *file = SDL_RWFromFile(p.c_str(), "w+b");
 	if (file != nullptr)
@@ -440,12 +453,6 @@ bool Director::saveConfigFile()
 	return success;
 }

-// Establece el valor de la variable
-void Director::setExecutablePath(std::string path)
-{
-	mExecutablePath = path.substr(0, path.find_last_of("\\/"));
-}
-
 // Obtiene el valor de la variable
 Uint8 Director::getSubsection()
 {
@@ -466,21 +473,21 @@ void Director::setSection(section_t section)

 void Director::runLogo()
 {
-	mLogo = new Logo(mRenderer, mScreen, mFileList);
+	mLogo = new Logo(mRenderer, mScreen, mAsset);
 	setSection(mLogo->run());
 	delete mLogo;
 }

 void Director::runIntro()
 {
-	mIntro = new Intro(mRenderer, mScreen, mFileList, mLang);
+	mIntro = new Intro(mRenderer, mScreen, mAsset, mLang);
 	setSection(mIntro->run());
 	delete mIntro;
 }

 void Director::runTitle()
 {
-	mTitle = new Title(mWindow, mRenderer, mScreen, mInput, mFileList, mOptions, mLang);
+	mTitle = new Title(mWindow, mRenderer, mScreen, mInput, mAsset, mOptions, mLang);
 	setSection(mTitle->run(mSection.subsection));
 	delete mTitle;
 }
@@ -489,14 +496,14 @@ void Director::runGame()
 {
 	if (mSection.subsection == GAME_SECTION_PLAY_1P)
 	{
-		mGame = new Game(1, 8, mRenderer, mScreen, mFileList, mLang, mInput, false, mOptions);
+		mGame = new Game(1, 0, mRenderer, mScreen, mAsset, mLang, mInput, false, mOptions);
 	}
-	
+
 	else if (mSection.subsection == GAME_SECTION_PLAY_2P)
 	{
-		mGame = new Game(2, 0, mRenderer, mScreen, mFileList, mLang, mInput, false, mOptions);
+		mGame = new Game(2, 0, mRenderer, mScreen, mAsset, mLang, mInput, false, mOptions);
 	}
-	
+
 	setSection(mGame->run());
 	delete mGame;
 }
--- a/source/director.h
+++ b/source/director.h
@@ -1,27 +1,28 @@
 #pragma once

 #include <SDL2/SDL.h>
-#include "sprite.h"
-#include "movingsprite.h"
-#include "smartsprite.h"
-#include "player.h"
+#include "asset.h"
 #include "balloon.h"
 #include "bullet.h"
 #include "coffeedrop.h"
-#include "item.h"
-#include "text.h"
-#include "writer.h"
-#include "menu.h"
 #include "const.h"
-#include "jail_audio.h"
-#include "utils.h"
-#include "logo.h"
-#include "intro.h"
-#include "title.h"
+#include "fade.h"
 #include "game.h"
 #include "input.h"
+#include "intro.h"
+#include "item.h"
+#include "jail_audio.h"
+#include "logo.h"
+#include "menu.h"
+#include "movingsprite.h"
+#include "player.h"
 #include "screen.h"
-#include "fade.h"
+#include "smartsprite.h"
+#include "sprite.h"
+#include "text.h"
+#include "title.h"
+#include "utils.h"
+#include "writer.h"

 #ifndef DIRECTOR_H
 #define DIRECTOR_H
@@ -29,26 +30,23 @@
 // Textos
 #define WINDOW_CAPTION "Coffee Crisis"

-// Cantidad máxima de elementos para el vector con las rutas de los ficheros de recursos
-#define MAX_FILE_LIST 100
-
 // Clase Director
 class Director
 {
 private:
-	SDL_Window *mWindow;				  // La ventana donde dibujamos
-	SDL_Renderer *mRenderer;			  // El renderizador de la ventana
-	Screen *mScreen;					  // Objeto encargado de dibujar en pantalla
-	Logo *mLogo;						  // Objeto para la sección del logo
-	Intro *mIntro;						  // Objeto para la sección de la intro
-	Title *mTitle;						  // Objeto para la sección del titulo y el menu de opciones
-	Game *mGame;						  // Objeto para la sección del juego
-	Input *mInput;						  // Objeto Input para gestionar las entradas
-	Lang *mLang;						  // Objeto para gestionar los textos en diferentes idiomas
-	std::string mFileList[MAX_FILE_LIST]; // Vector con las rutas a los ficheros de recursos
-	struct options_t *mOptions;			  // Variable con todas las opciones del programa
-	std::string mExecutablePath;		  // Path del ejecutable
-	section_t mSection;					  // Sección y subsección actual del programa;
+	SDL_Window *mWindow;		 // La ventana donde dibujamos
+	SDL_Renderer *mRenderer;	 // El renderizador de la ventana
+	Screen *mScreen;			 // Objeto encargado de dibujar en pantalla
+	Logo *mLogo;				 // Objeto para la sección del logo
+	Intro *mIntro;				 // Objeto para la sección de la intro
+	Title *mTitle;				 // Objeto para la sección del titulo y el menu de opciones
+	Game *mGame;				 // Objeto para la sección del juego
+	Input *mInput;				 // Objeto Input para gestionar las entradas
+	Lang *mLang;				 // Objeto para gestionar los textos en diferentes idiomas
+	Asset *mAsset;				 // Objeto que gestiona todos los ficheros de recursos
+	struct options_t *mOptions;	 // Variable con todas las opciones del programa
+	std::string mExecutablePath; // Path del ejecutable
+	section_t mSection;			 // Sección y subsección actual del programa;

 	// Inicializa jail_audio
 	void initJailAudio();
@@ -57,10 +55,7 @@ private:
 	bool initSDL();

 	// Crea el indice de ficheros
-	void setFileList();
-
-	// Comprueba que todos los ficheros existen
-	bool checkFileList();
+	bool setFileList();

 	// Carga el fichero de configuración
 	bool loadConfigFile();
@@ -68,9 +63,6 @@ private:
 	// Guarda el fichero de configuración
 	bool saveConfigFile();

-	// Establece el valor de la variable
-	void setExecutablePath(std::string path);
-
 	// Obtiene el valor de la variable
 	Uint8 getSubsection();

@@ -92,9 +84,6 @@ private:
 	// Ejecuta la seccion de juego donde se juega
 	void runGame();

-	// Comprueba los ficheros del vector de ficheros que coinciden con una ruta dada
-	bool checkFolder(std::string name, std::string path);
-
 public:
 	// Constructor
 	Director(std::string path);
--- a/source/game.cpp
+++ b/source/game.cpp
@@ -1,12 +1,12 @@
 #include "game.h"

 // Constructor
-Game::Game(int numPlayers, int currentStage, SDL_Renderer *renderer, Screen *screen, std::string *filelist, Lang *lang, Input *input, bool demo, options_t *options)
+Game::Game(int numPlayers, int currentStage, SDL_Renderer *renderer, Screen *screen, Asset *mAsset, Lang *lang, Input *input, bool demo, options_t *options)
 {
 	// Copia los punteros
 	mRenderer = renderer;
 	mScreen = screen;
-	mFileList = filelist;
+	this->mAsset = mAsset;
 	mLang = lang;
 	mInput = input;
 	mOptions = options;
@@ -68,14 +68,14 @@ Game::Game(int numPlayers, int currentStage, SDL_Renderer *renderer, Screen *scr
 	mTextureTextNokia2 = new LTexture(mRenderer);
 	mTextureTextNokiaBig2 = new LTexture(mRenderer);

-	mText = new Text(mFileList[48], mTextureText, mRenderer);
-	mTextScoreBoard = new Text(mFileList[46], mTextureTextScoreBoard, mRenderer);
-	mTextBig = new Text(mFileList[47], mTextureTextBig, mRenderer);
-	mTextNokia2 = new Text(mFileList[57], mTextureTextNokia2, mRenderer);
-	mTextNokiaBig2 = new Text(mFileList[55], mTextureTextNokiaBig2, mRenderer);
+	mText = new Text(mAsset->get("smb2.txt"), mTextureText, mRenderer);
+	mTextScoreBoard = new Text(mAsset->get("8bithud.txt"), mTextureTextScoreBoard, mRenderer);
+	mTextBig = new Text(mAsset->get("smb2_big.txt"), mTextureTextBig, mRenderer);
+	mTextNokia2 = new Text(mAsset->get("nokia2.txt"), mTextureTextNokia2, mRenderer);
+	mTextNokiaBig2 = new Text(mAsset->get("nokia_big2.txt"), mTextureTextNokiaBig2, mRenderer);

-	mMenuGameOver = new Menu(mRenderer, mText, mInput, mFileList);
-	mMenuPause = new Menu(mRenderer, mText, mInput, mFileList);
+	mMenuGameOver = new Menu(mRenderer, mText, mInput, mAsset);
+	mMenuPause = new Menu(mRenderer, mText, mInput, mAsset);

 	mFade = new Fade(mRenderer);
 	mEventHandler = new SDL_Event();
@@ -104,7 +104,7 @@ Game::~Game()

 	mRenderer = nullptr;
 	mScreen = nullptr;
-	mFileList = nullptr;
+	mAsset = nullptr;
 	mLang = nullptr;
 	mInput = nullptr;

@@ -549,47 +549,47 @@ bool Game::loadMedia()
 	bool success = true;

 	// Texturas
-	success &= loadTextureFromFile(mTextureText, mFileList[30], mRenderer);
-	success &= loadTextureFromFile(mTextureTextScoreBoard, mFileList[27], mRenderer);
-	success &= loadTextureFromFile(mTextureTextBig, mFileList[29], mRenderer);
-	success &= loadTextureFromFile(mTextureTextNokia2, mFileList[56], mRenderer);
-	success &= loadTextureFromFile(mTextureTextNokiaBig2, mFileList[54], mRenderer);
+	success &= loadTextureFromFile(mTextureText, mAsset->get("smb2.png"), mRenderer);
+	success &= loadTextureFromFile(mTextureTextScoreBoard, mAsset->get("8bithud.png"), mRenderer);
+	success &= loadTextureFromFile(mTextureTextBig, mAsset->get("smb2_big.png"), mRenderer);
+	success &= loadTextureFromFile(mTextureTextNokia2, mAsset->get("nokia2.png"), mRenderer);
+	success &= loadTextureFromFile(mTextureTextNokiaBig2, mAsset->get("nokia_big2.png"), mRenderer);

-	success &= loadTextureFromFile(mTexturePlayer1Legs, mFileList[39], mRenderer);
-	success &= loadTextureFromFile(mTexturePlayer1Head, mFileList[41], mRenderer);
-	success &= loadTextureFromFile(mTexturePlayer1Body, mFileList[37], mRenderer);
-	success &= loadTextureFromFile(mTexturePlayer1Death, mFileList[38], mRenderer);
+	success &= loadTextureFromFile(mTexturePlayer1Legs, mAsset->get("player1_legs.png"), mRenderer);
+	success &= loadTextureFromFile(mTexturePlayer1Head, mAsset->get("player1_head.png"), mRenderer);
+	success &= loadTextureFromFile(mTexturePlayer1Body, mAsset->get("player1_body.png"), mRenderer);
+	success &= loadTextureFromFile(mTexturePlayer1Death, mAsset->get("player1_death.png"), mRenderer);

-	success &= loadTextureFromFile(mTexturePlayer2Legs, mFileList[44], mRenderer);
-	success &= loadTextureFromFile(mTexturePlayer2Head, mFileList[45], mRenderer);
-	success &= loadTextureFromFile(mTexturePlayer2Body, mFileList[42], mRenderer);
-	success &= loadTextureFromFile(mTexturePlayer2Death, mFileList[43], mRenderer);
+	success &= loadTextureFromFile(mTexturePlayer2Legs, mAsset->get("player2_legs.png"), mRenderer);
+	success &= loadTextureFromFile(mTexturePlayer2Head, mAsset->get("player2_head.png"), mRenderer);
+	success &= loadTextureFromFile(mTexturePlayer2Body, mAsset->get("player2_body.png"), mRenderer);
+	success &= loadTextureFromFile(mTexturePlayer2Death, mAsset->get("player2_death.png"), mRenderer);

-	success &= loadTextureFromFile(mTextureBalloon, mFileList[24], mRenderer);
-	success &= loadTextureFromFile(mTextureBullet, mFileList[25], mRenderer);
-	success &= loadTextureFromFile(mTextureGameBG, mFileList[31], mRenderer);
-	success &= loadTextureFromFile(mTextureItems, mFileList[34], mRenderer);
-	success &= loadTextureFromFile(mTextureGameText, mFileList[32], mRenderer);
+	success &= loadTextureFromFile(mTextureBalloon, mAsset->get("balloon.png"), mRenderer);
+	success &= loadTextureFromFile(mTextureBullet, mAsset->get("bullet.png"), mRenderer);
+	success &= loadTextureFromFile(mTextureGameBG, mAsset->get("game_bg.png"), mRenderer);
+	success &= loadTextureFromFile(mTextureItems, mAsset->get("items.png"), mRenderer);
+	success &= loadTextureFromFile(mTextureGameText, mAsset->get("game_text.png"), mRenderer);

 	// Sonidos
-	mSoundBalloon = JA_LoadSound(mFileList[6].c_str());
-	mSoundBubble1 = JA_LoadSound(mFileList[7].c_str());
-	mSoundBubble2 = JA_LoadSound(mFileList[8].c_str());
-	mSoundBubble3 = JA_LoadSound(mFileList[9].c_str());
-	mSoundBubble4 = JA_LoadSound(mFileList[10].c_str());
-	mSoundBullet = JA_LoadSound(mFileList[11].c_str());
-	mSoundClock = JA_LoadSound(mFileList[22].c_str());
-	mSoundCoffeeOut = JA_LoadSound(mFileList[12].c_str());
-	mSoundHiScore = JA_LoadSound(mFileList[13].c_str());
-	mSoundItemDrop = JA_LoadSound(mFileList[14].c_str());
-	mSoundItemPickup = JA_LoadSound(mFileList[15].c_str());
-	mSoundPlayerCollision = JA_LoadSound(mFileList[19].c_str());
-	mSoundPowerBall = JA_LoadSound(mFileList[23].c_str());
-	mSoundStageChange = JA_LoadSound(mFileList[20].c_str());
-	mSoundCollision = JA_LoadSound(mFileList[21].c_str());
+	mSoundBalloon = JA_LoadSound(mAsset->get("balloon.wav").c_str());
+	mSoundBubble1 = JA_LoadSound(mAsset->get("bubble1.wav").c_str());
+	mSoundBubble2 = JA_LoadSound(mAsset->get("bubble2.wav").c_str());
+	mSoundBubble3 = JA_LoadSound(mAsset->get("bubble3.wav").c_str());
+	mSoundBubble4 = JA_LoadSound(mAsset->get("bubble4.wav").c_str());
+	mSoundBullet = JA_LoadSound(mAsset->get("bullet.wav").c_str());
+	mSoundClock = JA_LoadSound(mAsset->get("clock.wav").c_str());
+	mSoundCoffeeOut = JA_LoadSound(mAsset->get("coffeeout.wav").c_str());
+	mSoundHiScore = JA_LoadSound(mAsset->get("hiscore.wav").c_str());
+	mSoundItemDrop = JA_LoadSound(mAsset->get("itemdrop.wav").c_str());
+	mSoundItemPickup = JA_LoadSound(mAsset->get("itempickup.wav").c_str());
+	mSoundPlayerCollision = JA_LoadSound(mAsset->get("player_collision.wav").c_str());
+	mSoundPowerBall = JA_LoadSound(mAsset->get("powerball.wav").c_str());
+	mSoundStageChange = JA_LoadSound(mAsset->get("stage_change.wav").c_str());
+	mSoundCollision = JA_LoadSound(mAsset->get("title.wav").c_str());

 	// Musicas
-	mMusicPlaying = JA_LoadMusic(mFileList[4].c_str());
+	mMusicPlaying = JA_LoadMusic(mAsset->get("playing.ogg").c_str());

 	return success;
 }
@@ -599,7 +599,7 @@ bool Game::loadScoreFile()
 {
 	// Indicador de éxito en la carga
 	bool success = true;
-	const std::string p = mFileList[0];
+	const std::string p = mAsset->get("score.bin");
 	const std::string filename = p.substr(p.find_last_of("\\/") + 1);
 	SDL_RWops *file = SDL_RWFromFile(p.c_str(), "r+b");

@@ -644,12 +644,12 @@ bool Game::loadScoreFile()

 	// Establece el valor de la máxima puntuación a partir del vector con los datos
 	if (mScoreDataFile[0] == 0)
-		mHiScore = 10000;
+		{mHiScore = 10000;}
 	// Comprueba el checksum para ver si se ha modificado el fichero
 	else if (mScoreDataFile[0] % 43 == mScoreDataFile[1])
-		mHiScore = mScoreDataFile[0];
+		{mHiScore = mScoreDataFile[0];}
 	else
-		mHiScore = 10000;
+		{mHiScore = 10000;}

 	return success;
 }
@@ -659,7 +659,7 @@ bool Game::loadDemoFile()
 {
 	// Indicador de éxito en la carga
 	bool success = true;
-	const std::string p = mFileList[1];
+	const std::string p = mAsset->get("demo.bin");
 	const std::string filename = p.substr(p.find_last_of("\\/") + 1);
 	SDL_RWops *file = SDL_RWFromFile(p.c_str(), "r+b");

@@ -715,7 +715,7 @@ bool Game::loadDemoFile()
 bool Game::saveScoreFile()
 {
 	bool success = true;
-	const std::string p = mFileList[0];
+	const std::string p = mAsset->get("score.bin");
 	const std::string filename = p.substr(p.find_last_of("\\/") + 1);
 	SDL_RWops *file = SDL_RWFromFile(p.c_str(), "w+b");
 	if (file != nullptr)
@@ -742,7 +742,7 @@ bool Game::saveScoreFile()
 bool Game::saveDemoFile()
 {
 	bool success = true;
-	const std::string p = mFileList[1];
+	const std::string p = mAsset->get("demo.bin");
 	const std::string filename = p.substr(p.find_last_of("\\/") + 1);
 	if (mDemo.recording)
 	{
--- a/source/game.h
+++ b/source/game.h
@@ -1,6 +1,7 @@
 #pragma once

 #include <SDL2/SDL.h>
+#include "asset.h"
 #include "balloon.h"
 #include "bullet.h"
 #include "const.h"
@@ -129,7 +130,7 @@ private:

 	SDL_Renderer *mRenderer; // El renderizador de la ventana
 	Screen *mScreen;		 // Objeto encargado de dibujar en pantalla
-	std::string *mFileList;	 // Lista de ficheros con los recursos
+	Asset *mAsset;			 // Objeto que gestiona todos los ficheros de recursos
 	Lang *mLang;			 // Objeto para gestionar los textos en diferentes idiomas

 	int mNumPlayers;	// Numero de jugadores
@@ -518,7 +519,7 @@ private:

 public:
 	// Constructor
-	Game(int numPlayers, int currentStage, SDL_Renderer *renderer, Screen *screen, std::string *filelist, Lang *lang, Input *input, bool demo, options_t *options);
+	Game(int numPlayers, int currentStage, SDL_Renderer *renderer, Screen *screen, Asset *mAsset, Lang *lang, Input *input, bool demo, options_t *options);

 	// Destructor
 	~Game();
--- a/source/instructions.cpp
+++ b/source/instructions.cpp
@@ -3,12 +3,12 @@
 const Uint8 SELF = 0;

 // Constructor
-Instructions::Instructions(SDL_Renderer *renderer, Screen *screen, std::string *fileList, Lang *lang)
+Instructions::Instructions(SDL_Renderer *renderer, Screen *screen, Asset *mAsset, Lang *lang)
 {
 	// Copia los punteros
 	mRenderer = renderer;
 	mScreen = screen;
-	mFileList = fileList;
+	this->mAsset = mAsset;
 	mLang = lang;

 	// Reserva memoria para los punteros
@@ -16,12 +16,14 @@ Instructions::Instructions(SDL_Renderer *renderer, Screen *screen, std::string *
 	mItemTexture = new LTexture(mRenderer);
 	mTextTexture = new LTexture(mRenderer);
 	mSprite = new Sprite();
-	mText = new Text(mFileList[48], mTextTexture, mRenderer);
+	mText = new Text(mAsset->get("smb2.txt"), mTextTexture, mRenderer);

 	// Crea un backbuffer para el renderizador
 	mBackbuffer = SDL_CreateTexture(mRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, SCREEN_WIDTH, SCREEN_HEIGHT);
 	if (mBackbuffer == nullptr)
+	{
 		printf("Backbuffer could not be created!\nSDL Error: %s\n", SDL_GetError());
+	}
 }

 // Destructor
@@ -29,7 +31,7 @@ Instructions::~Instructions()
 {
 	mRenderer = nullptr;
 	mScreen = nullptr;
-	mFileList = nullptr;
+	mAsset = nullptr;
 	mLang = nullptr;

 	mItemTexture->unload();
@@ -58,8 +60,8 @@ bool Instructions::loadMedia()
 {
 	bool success = true;

-	success &= loadTextureFromFile(mItemTexture, mFileList[34], mRenderer);
-	success &= loadTextureFromFile(mTextTexture, mFileList[30], mRenderer);
+	success &= loadTextureFromFile(mItemTexture, mAsset->get("items.png"), mRenderer);
+	success &= loadTextureFromFile(mTextTexture, mAsset->get("smb2.png"), mRenderer);

 	return success;
 }
--- a/source/instructions.h
+++ b/source/instructions.h
@@ -1,6 +1,7 @@
 #pragma once

 #include <SDL2/SDL.h>
+#include "asset.h"
 #include "const.h"
 #include "jail_audio.h"
 #include "screen.h"
@@ -29,7 +30,7 @@ private:
 	SDL_Event *mEventHandler; // Manejador de eventos
 	SDL_Texture *mBackbuffer; // Textura para usar como backbuffer
 	Sprite *mSprite;		  // Sprite con la textura de las instrucciones
-	std::string *mFileList;	  // Lista de ficheros
+	Asset *mAsset;			  // Objeto que gestiona todos los ficheros de recursos
 	Lang *mLang;			  // Objeto para gestionar los textos en diferentes idiomas
 	Text *mText;			  // Objeto para escribir texto
 	Uint16 mCounter;		  // Contador
@@ -52,7 +53,7 @@ private:

 public:
 	// Constructor
-	Instructions(SDL_Renderer *renderer, Screen *screen, std::string *fileList, Lang *lang);
+	Instructions(SDL_Renderer *renderer, Screen *screen, Asset *mAsset, Lang *lang);

 	// Destructor
 	~Instructions();
--- a/source/intro.cpp
+++ b/source/intro.cpp
@@ -1,25 +1,29 @@
 #include "intro.h"

 // Constructor
-Intro::Intro(SDL_Renderer *renderer, Screen *screen, std::string *fileList, Lang *lang)
+Intro::Intro(SDL_Renderer *renderer, Screen *screen, Asset *mAsset, Lang *lang)
 {
 	// Copia los punteros
 	mRenderer = renderer;
 	mScreen = screen;
-	mFileList = fileList;
 	mLang = lang;
+	this->mAsset = mAsset;

 	// Reserva memoria para los punteros
 	mEventHandler = new SDL_Event();
 	mBitmapTexture = new LTexture(mRenderer);
 	mTextTexture = new LTexture(mRenderer);
-	mText = new Text(mFileList[52], mTextTexture, mRenderer);
+	mText = new Text(mAsset->get("nokia.txt"), mTextTexture, mRenderer);

 	for (int i = 0; i < INTRO_TOTAL_BITMAPS; i++)
+	{
 		mBitmap[i] = new SmartSprite();
+	}

 	for (int i = 0; i < INTRO_TOTAL_TEXTS; i++)
+	{
 		mWriter[i] = new Writer(mText);
+	}
 }

 // Destructor
@@ -27,7 +31,7 @@ Intro::~Intro()
 {
 	mRenderer = nullptr;
 	mScreen = nullptr;
-	mFileList = nullptr;
+	mAsset = nullptr;
 	mLang = nullptr;

 	delete mEventHandler;
@@ -192,11 +196,11 @@ bool Intro::loadMedia()
 	bool success = true;

 	// Texturas
-	success &= loadTextureFromFile(mBitmapTexture, mFileList[33], mRenderer);
-	success &= loadTextureFromFile(mTextTexture, mFileList[28], mRenderer);
+	success &= loadTextureFromFile(mBitmapTexture, mAsset->get("intro.png"), mRenderer);
+	success &= loadTextureFromFile(mTextTexture, mAsset->get("nokia.png"), mRenderer);

 	// Musicas
-	mMusic = JA_LoadMusic(mFileList[3].c_str());
+	mMusic = JA_LoadMusic(mAsset->get("intro.ogg").c_str());

 	return success;
 }
@@ -208,7 +212,9 @@ section_t Intro::run()

 	// Si la música no está sonando la hace sonar
 	if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
+	{
 		JA_PlayMusic(mMusic, 0);
+	}

 	while (mSection.name == PROG_SECTION_INTRO)
 	{
@@ -237,9 +243,13 @@ section_t Intro::run()

 			// Actualiza los objetos
 			for (int i = 0; i < INTRO_TOTAL_BITMAPS; i++)
+			{
 				mBitmap[i]->update();
+			}
 			for (int i = 0; i < INTRO_TOTAL_TEXTS; i++)
+			{
 				mWriter[i]->update();
+			}

 			// Guión de eventos
 			// Primera imagen - UPV
@@ -361,10 +371,14 @@ section_t Intro::run()
 		mScreen->clean(bgColor);

 		// Dibuja los objetos
-		for (int i = 0; i < INTRO_TOTAL_BITMAPS; i++)
+		for (int i = 0; i < INTRO_TOTAL_BITMAPS; ++i)
+		{
 			mBitmap[i]->render();
-		for (int i = 0; i < INTRO_TOTAL_TEXTS; i++)
+		}
+		for (int i = 0; i < INTRO_TOTAL_TEXTS; ++i)
+		{
 			mWriter[i]->render();
+		}

 		// Vuelca el contenido del renderizador en pantalla
 		mScreen->blit();
--- a/source/intro.h
+++ b/source/intro.h
@@ -1,12 +1,13 @@
 #pragma once

 #include <SDL2/SDL.h>
+#include "asset.h"
 #include "const.h"
-#include "utils.h"
+#include "jail_audio.h"
 #include "screen.h"
 #include "smartsprite.h"
+#include "utils.h"
 #include "writer.h"
-#include "jail_audio.h"

 #ifndef INTRO_H
 #define INTRO_H
@@ -42,7 +43,7 @@ private:
 	LTexture *mBitmapTexture;				   // Textura con los graficos
 	LTexture *mTextTexture;					   // Textura con los caracteres de texto
 	SDL_Event *mEventHandler;				   // Manejador de eventos
-	std::string *mFileList;					   // Lista de ficheros
+	Asset *mAsset;							   // Objeto que gestiona todos los ficheros de recursos
 	Lang *mLang;							   // Objeto para gestionar los textos en diferentes idiomas
 	section_t mSection;						   // Estado del bucle principal para saber si continua o se sale
 	Uint32 mTicks;							   // Contador de ticks para ajustar la velocidad del programa
@@ -58,7 +59,7 @@ private:

 public:
 	// Constructor
-	Intro(SDL_Renderer *renderer, Screen *screen, std::string *fileList, Lang *lang);
+	Intro(SDL_Renderer *renderer, Screen *screen, Asset *mAsset, Lang *lang);

 	// Destructor
 	~Intro();
--- a/source/lang.cpp
+++ b/source/lang.cpp
@@ -3,9 +3,9 @@
 #include <fstream>

 // Constructor
-Lang::Lang(std::string *fileList)
+Lang::Lang(Asset *mAsset)
 {
-    mFileList = fileList;
+    this->mAsset = mAsset;
 }

 // Destructor
@@ -21,19 +21,19 @@ bool Lang::setLang(Uint8 lang)
    switch (lang)
    {
    case es_ES:
-        file = mFileList[49];
+        file = mAsset->get("es_ES.txt");
        break;

    case en_UK:
-        file = mFileList[50];
+        file = mAsset->get("en_UK.txt");
        break;

    case ba_BA:
-        file = mFileList[51];
+        file = mAsset->get("ba_BA.txt");
        break;

    default:
-        file = mFileList[50];
+        file = mAsset->get("en_UK.txt");
        break;
    }

--- a/source/lang.h
+++ b/source/lang.h
@@ -1,6 +1,7 @@
 #pragma once

 #include <SDL2/SDL.h>
+#include "asset.h"
 #include <string>

 #ifndef LANG_H
@@ -19,12 +20,12 @@
 class Lang
 {
 private:
-    std::string *mFileList;                     // Lista de ficheros con los recursos
+	Asset *mAsset;				 // Objeto que gestiona todos los ficheros de recursos
    std::string mTextStrings[MAX_TEXT_STRINGS]; // Vector con los textos

 public:
    // Constructor
-    Lang(std::string *fileList);
+    Lang(Asset *mAsset);

    // Destructor
    ~Lang();
--- a/source/logo.cpp
+++ b/source/logo.cpp
@@ -4,12 +4,12 @@
 #define END_LOGO 200

 // Constructor
-Logo::Logo(SDL_Renderer *renderer, Screen *screen, std::string *fileList)
+Logo::Logo(SDL_Renderer *renderer, Screen *screen, Asset *mAsset)
 {
 	// Copia la dirección de los objetos
 	mRenderer = renderer;
 	mScreen = screen;
-	mFileList = fileList;
+	this->mAsset = mAsset;

 	// Reserva memoria para los punteros
 	mEventHandler = new SDL_Event();
@@ -19,7 +19,9 @@ Logo::Logo(SDL_Renderer *renderer, Screen *screen, std::string *fileList)
 	// Crea un backbuffer para el renderizador
 	mBackbuffer = SDL_CreateTexture(mRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, SCREEN_WIDTH, SCREEN_HEIGHT);
 	if (mBackbuffer == nullptr)
+	{
 		printf("Backbuffer could not be created!\nSDL Error: %s\n", SDL_GetError());
+	}
 }

 // Destructor
@@ -27,7 +29,7 @@ Logo::~Logo()
 {
 	mRenderer = nullptr;
 	mScreen = nullptr;
-	mFileList = nullptr;
+	mAsset = nullptr;

 	mTexture->unload();
 	delete mTexture;
@@ -63,7 +65,7 @@ bool Logo::loadMedia()
 {
 	bool success = true;

-	success &= loadTextureFromFile(mTexture, mFileList[35], mRenderer);
+	success &= loadTextureFromFile(mTexture, mAsset->get("logo.png"), mRenderer);

 	return success;
 }
--- a/source/logo.h
+++ b/source/logo.h
@@ -1,11 +1,12 @@
 #pragma once

 #include <SDL2/SDL.h>
+#include "asset.h"
 #include "const.h"
-#include "utils.h"
-#include "sprite.h"
-#include "screen.h"
 #include "jail_audio.h"
+#include "screen.h"
+#include "sprite.h"
+#include "utils.h"

 #ifndef LOGO_H
 #define LOGO_H
@@ -16,7 +17,7 @@ class Logo
 private:
 	SDL_Renderer *mRenderer;  // El renderizador de la ventana
 	Screen *mScreen;		  // Objeto encargado de dibujar en pantalla
-	std::string *mFileList;	  // Lista de ficheros
+	Asset *mAsset;			  // Objeto que gestiona todos los ficheros de recursos
 	LTexture *mTexture;		  // Textura con los graficos
 	SDL_Event *mEventHandler; // Manejador de eventos
 	SDL_Texture *mBackbuffer; // Textura para usar como backbuffer
@@ -28,7 +29,7 @@ private:

 public:
 	// Constructor
-	Logo(SDL_Renderer *renderer, Screen *screen, std::string *fileList);
+	Logo(SDL_Renderer *renderer, Screen *screen, Asset *mAsset);

 	// Destructor
 	~Logo();
--- a/source/menu.cpp
+++ b/source/menu.cpp
--- a/source/menu.h
+++ b/source/menu.h
@@ -1,21 +1,28 @@
 #pragma once

 #include <SDL2/SDL.h>
+#include <vector>
 #include "sprite.h"
 #include "text.h"
+#include "asset.h"
 #include "input.h"
+#include "utils.h"
 #include "jail_audio.h"
+#include <sstream>
+#include <fstream>

 #ifndef MENU_H
 #define MENU_H

-// Cantidad máxima de items en el menu
-#define MENU_MAX_ITEMS 50
-
 // Tipos de fondos para el menu
 #define MENU_BACKGROUND_TRANSPARENT 0
 #define MENU_BACKGROUND_SOLID 1

+// Tipos de archivos de audio
+#define SOUND_ACCEPT 0
+#define SOUND_MOVE 1
+#define SOUND_CANCEL 2
+
 // Opciones de menu
 #define MENU_NO_OPTION -1

@@ -23,82 +30,83 @@
 class Menu
 {
 private:
-	std::string mName;				// Nombre del menu
-	int mPosX;						// Posición en el eje X de la primera letra del primer elemento
-	int mPosY;						// Posición en el eje Y de la primera letra del primer elemento
-	Uint16 mHeight;					// Altura del menu
-	Uint16 mWidth;					// Anchura del menu
-	Uint8 mTotalItems;				// Numero total de items del menu
-	int mItemSelected;				// Índice del item del menu que ha sido seleccionado
-	Uint8 mDefaultActionWhenCancel; // Indice del item del menu que se selecciona cuando se cancela el menu
-	Uint8 mBackgroundType;			// Tipo de fondo para el menu
-	bool mIsCenteredOnX;			// Variable para saber si el menu debe estar centrado respecto a un punto en el eje X
-	bool mIsCenteredOnY;			// Variable para saber si el menu debe estar centrado respecto a un punto en el eje Y
-	int mCenterX;					// Centro del menu en el eje X
-	int mCenterY;					// Centro del menu en el eje Y
-	bool mAreElementsCenteredOnX;	// Variable para saber si los elementos van centrados en el eje X
-	Uint16 mWidestItem;				// Anchura del elemento más ancho
-	JA_Sound mSoundAccept;			// Sonido al aceptar o elegir una opción del menu
-	JA_Sound mSoundCancel;			// Sonido al cancelar el menu
-	JA_Sound mSoundMove;			// Sonido al mover el selector
-	SDL_Renderer *mRenderer;		// Puntero al renderizador de la ventana
-	std::string *mFileList;			// Lista de ficheros
-	Text *mText;					// Texto para poder escribir los items del menu
-	Input *mInput;					// Gestor de eventos de entrada de teclado o gamepad
-	color_t mColorGreyed;			// Color para los elementos agrisados
-
-	struct rectangle
+	struct rectangle_t
 	{
 		SDL_Rect rect; // Rectangulo
-		Uint8 r;	   // Rojo
-		Uint8 g;	   // Verde
-		Uint8 b;	   // Azul
-		Uint8 a;	   // Transparencia
+		color_t color; // Color
+		int a;		   // Transparencia
 	};
-	rectangle mRectBG; // Rectangulo de fondo del menu

-	struct item
+	struct item_t
 	{
-		std::string label;	// Texto
-		SDL_Rect rect;	// Rectangulo que delimita el elemento
-		Uint8 hPaddingDown; // Espaciado bajo el elemento
-		bool selectable;	// Indica si se puede seleccionar
-		bool greyed;		// Indica si ha de aparecer con otro color mas oscuro
-		bool linkedDown;	// Indica si el elemento actual y el siguiente se tratan como uno solo. Afecta al selector
-		bool linkedUp;		// Indica si el elemento actual y el anterior se tratan como uno solo. Afecta al selector
+		std::string label; // Texto
+		SDL_Rect rect;	   // Rectangulo que delimita el elemento
+		int hPaddingDown;  // Espaciado bajo el elemento
+		bool selectable;   // Indica si se puede seleccionar
+		bool greyed;	   // Indica si ha de aparecer con otro color mas oscuro
+		bool linkedDown;   // Indica si el elemento actual y el siguiente se tratan como uno solo. Afecta al selector
+		bool linkedUp;	   // Indica si el elemento actual y el anterior se tratan como uno solo. Afecta al selector
 	};
-	item mItem[MENU_MAX_ITEMS]; // Estructura para cada elemento del menu

-	struct selector
+	struct selector_t
 	{
-		float originY;	// Coordenada de origen
-		float targetY;	// Coordenada de destino
-		float despY;	// Cantidad de pixeles que se desplaza el selector en cada salto: (target - origin) / numJumps
-		bool moving;	// Indica si el selector está avanzando hacia el destino
-		float originH;	// Altura de origen
-		float targetH;	// Altura de destino
-		float incH;		// Cantidad de pixels que debe incrementar o decrementar el selector en cada salto
-		bool resizing;	// Indica si el selector está cambiando de tamaño
-		float y;		// Coordenada actual, usado para el desplazamiento
-		float h;		// Altura actual, usado para el cambio de tamaño
-		Uint8 numJumps; // Numero de pasos preestablecido para llegar al destino
-		Uint8 index;	// Elemento del menu que tiene el foco
-		SDL_Rect rect;	// Rectangulo del selector
-		Uint8 r;		// Cantidad de color rojo para el rectangulo del selector
-		Uint8 g;		// Cantidad de color verde para el rectangulo del selector
-		Uint8 b;		// Cantidad de color azul para el rectangulo del selector
-		Uint8 a;		// Cantidad de transparencia para el rectangulo del selector
-		Uint8 itemR;	// Cantidad de color rojo para el texto del elemento seleccionado
-		Uint8 itemG;	// Cantidad de color verde para el texto del elemento seleccionado
-		Uint8 itemB;	// Cantidad de color azul para el texto del elemento seleccionado
+		float originY;	   // Coordenada de origen
+		float targetY;	   // Coordenada de destino
+		float despY;	   // Cantidad de pixeles que se desplaza el selector en cada salto: (target - origin) / numJumps
+		bool moving;	   // Indica si el selector está avanzando hacia el destino
+		float originH;	   // Altura de origen
+		float targetH;	   // Altura de destino
+		float incH;		   // Cantidad de pixels que debe incrementar o decrementar el selector en cada salto
+		bool resizing;	   // Indica si el selector está cambiando de tamaño
+		float y;		   // Coordenada actual, usado para el desplazamiento
+		float h;		   // Altura actual, usado para el cambio de tamaño
+		int numJumps;	   // Numero de pasos preestablecido para llegar al destino
+		int index;		   // Elemento del menu que tiene el foco
+		SDL_Rect rect;	   // Rectangulo del selector
+		color_t color;	   // Color del selector
+		color_t itemColor; // Color del item
+		int a;			   // Cantidad de transparencia para el rectangulo del selector
 	};
-	selector mSelector; // Variables para pintar el selector del menu

-	// Carga los recursos necesarios para la sección 'Title'
-	bool loadMedia();
+	std::string name;			 // Nombre del menu
+	int x;						 // Posición en el eje X de la primera letra del primer elemento
+	int y;						 // Posición en el eje Y de la primera letra del primer elemento
+	int h;						 // Altura del menu
+	int w;						 // Anchura del menu
+	int itemSelected;			 // Índice del item del menu que ha sido seleccionado
+	int defaultActionWhenCancel; // Indice del item del menu que se selecciona cuando se cancela el menu
+	int backgroundType;			 // Tipo de fondo para el menu
+	int centerX;				 // Centro del menu en el eje X
+	int centerY;				 // Centro del menu en el eje Y
+	bool isCenteredOnX;			 // Variable para saber si el menu debe estar centrado respecto a un punto en el eje X
+	bool isCenteredOnY;			 // Variable para saber si el menu debe estar centrado respecto a un punto en el eje Y
+	bool areElementsCenteredOnX; // Variable para saber si los elementos van centrados en el eje X
+	int widestItem;				 // Anchura del elemento más ancho
+	JA_Sound soundAccept;		 // Sonido al aceptar o elegir una opción del menu
+	JA_Sound soundCancel;		 // Sonido al cancelar el menu
+	JA_Sound soundMove;			 // Sonido al mover el selector
+	SDL_Renderer *renderer;		 // Puntero al renderizador de la ventana
+	Text *text;					 // Texto para poder escribir los items del menu
+	Input *input;				 // Gestor de eventos de entrada de teclado o gamepad
+	Asset *asset;				 // Objeto para gestionar los ficheros de recursos
+	color_t colorGreyed;		 // Color para los elementos agrisados
+	rectangle_t rectBG;			 // Rectangulo de fondo del menu
+	std::vector<item_t> item;	 // Estructura para cada elemento del menu
+	selector_t selector;		 // Variables para pintar el selector del menu
+	std::string font_png;
+	std::string font_txt;

-	// Establece el valor de la variable
-	void setTotalItems(int num);
+	// Carga la configuración del menu desde un archivo de texto
+	bool load(std::string file_path);
+
+	// Asigna variables a partir de dos cadenas
+	bool setVars(std::string var, std::string value);
+
+	// Asigna variables a partir de dos cadenas
+	bool setItem(item_t *item, std::string var, std::string value);
+
+	// Inicializa las variables
+	void init();

 	// Establece el rectangulo de fondo del menu
 	void setRectSize();
@@ -116,16 +124,16 @@ private:
 	void updateSelector();

 	// Obtiene la anchura del elemento más ancho del menu
-	Uint16 getWidestItem();
+	int getWidestItem();

 	// Gestiona la entrada de teclado y mando durante el menu
 	void checkMenuInput(Menu *menu);

 	// Calcula el ancho del menu
-	Uint16 findWidth();
+	int findWidth();

 	// Calcula el alto del menu
-	Uint16 findHeight();
+	int findHeight();

 	// Recoloca los elementos del menu en el eje Y
 	void replaceElementsOnY();
@@ -135,19 +143,19 @@ private:

 public:
 	// Constructor
-	Menu(SDL_Renderer *renderer, Text *text, Input *input, std::string *fileList);
+	Menu(SDL_Renderer *renderer, Asset *asset, Input *input, std::string file="");

 	// Destructor
 	~Menu();

-	// Inicializador
-	void init(std::string name, int x, int y, int backgroundType);
+	// Carga los ficheros de audio
+	void loadAudioFile(std::string file, int sound);

 	// Obtiene el nombre del menu
 	std::string getName();

 	// Obtiene el valor de la variable
-	Uint8 getItemSelected();
+	int getItemSelected();

 	// Deja el menu apuntando al primer elemento
 	void reset();
@@ -162,13 +170,13 @@ public:
 	void render();

 	// Establece el color del rectangulo de fondo
-	void setBackgroundColor(int r, int g, int b, int alpha);
+	void setBackgroundColor(color_t color, int alpha);

 	// Establece el color del rectangulo del selector
-	void setSelectorColor(int r, int g, int b, int alpha);
+	void setSelectorColor(color_t color, int alpha);

 	// Establece el color del texto del selector
-	void setSelectorTextColor(int r, int g, int b);
+	void setSelectorTextColor(color_t color);

 	// Centra el menu respecto a un punto en el eje X
 	void centerMenuOnX(int value);
@@ -180,25 +188,27 @@ public:
 	void centerMenuElementsOnX();

 	// Añade un item al menu
-	void addItem(std::string text, Uint8 hPaddingDown = 1, bool selectable = true, bool greyed = false, bool linkedDown = false);
+	void addItem(std::string text, int hPaddingDown = 1, bool selectable = true, bool greyed = false, bool linkedDown = false);

 	// Cambia el texto de un item
-	void setItemCaption(Uint8 index, std::string text);
+	void setItemCaption(int index, std::string text);

 	// Establece el indice del item que se usará por defecto al cancelar el menu
-	void setDefaultActionWhenCancel(Uint8 item);
+	void setDefaultActionWhenCancel(int item);

 	// Coloca el selector en una posición específica
-	void setSelectorPos(Uint8 index);
+	void setSelectorPos(int index);

 	// Establece el estado seleccionable de un item
-	void setSelectable(Uint8 index, bool value);
+	void setSelectable(int index, bool value);

 	// Establece el estado agrisado de un item
-	void setGreyed(Uint8 index, bool value);
+	void setGreyed(int index, bool value);

 	// Establece el estado de enlace de un item
-	void setLinkedDown(Uint8 index, bool value);
+	void setLinkedDown(int index, bool value);
+
+	// hacer procedimientos para establecer el titulo, la x, la y, la tipografia y el tipo de fondo
 };

 #endif
--- a/source/title.cpp
+++ b/source/title.cpp
@@ -1,14 +1,14 @@
 #include "title.h"

 // Constructor
-Title::Title(SDL_Window *window, SDL_Renderer *renderer, Screen *screen, Input *input, std::string *fileList, options_t *options, Lang *lang)
+Title::Title(SDL_Window *window, SDL_Renderer *renderer, Screen *screen, Input *input, Asset *mAsset, options_t *options, Lang *lang)
 {
 	// Copia las direcciones de los punteros
 	mWindow = window;
 	mRenderer = renderer;
 	mScreen = screen;
 	mInput = input;
-	mFileList = fileList;
+	this->mAsset = mAsset;
 	mOptions = options;
 	mLang = lang;

@@ -25,10 +25,10 @@ Title::Title(SDL_Window *window, SDL_Renderer *renderer, Screen *screen, Input *
 	mDustBitmapR = new AnimatedSprite();
 	mTile = new Sprite();
 	mGradient = new Sprite();
-	mText = new Text(mFileList[48], mTextTexture, mRenderer);
-	mText2 = new Text(mFileList[46], mTextTexture2, mRenderer);
-	mMenu.title = new Menu(mRenderer, mText, mInput, mFileList);
-	mMenu.options = new Menu(mRenderer, mText, mInput, mFileList);
+	mText = new Text(mAsset->get("smb2.txt"), mTextTexture, mRenderer);
+	mText2 = new Text(mAsset->get("8bithud.txt"), mTextTexture2, mRenderer);
+	mMenu.title = new Menu(mRenderer, mText, mInput, mAsset);
+	mMenu.options = new Menu(mRenderer, mText, mInput, mAsset);

 	// Crea la textura para el mosaico de fondo
 	mBackground = SDL_CreateTexture(mRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, SCREEN_WIDTH * 2, SCREEN_HEIGHT * 2);
@@ -45,7 +45,7 @@ Title::~Title()
 	mRenderer = nullptr;
 	mScreen = nullptr;
 	mInput = nullptr;
-	mFileList = nullptr;
+	mAsset = nullptr;
 	mOptions = nullptr;
 	mLang = nullptr;

@@ -108,12 +108,6 @@ Title::~Title()

 	SDL_DestroyTexture(mBackground);
 	mBackground = nullptr;
-
-	mWindow = nullptr;
-	mRenderer = nullptr;
-	mInput = nullptr;
-	mFileList = nullptr;
-	mOptions = nullptr;
 }

 // Inicializa las variables necesarias para la sección 'Title'
@@ -302,16 +296,16 @@ bool Title::loadMedia()
 	bool success = true;

 	// Texturas
-	success &= loadTextureFromFile(mTitleTexture, mFileList[40], mRenderer);
-	success &= loadTextureFromFile(mItemsTexture, mFileList[34], mRenderer);
-	success &= loadTextureFromFile(mTextTexture, mFileList[30], mRenderer);
-	success &= loadTextureFromFile(mTextTexture2, mFileList[27], mRenderer);
+	success &= loadTextureFromFile(mTitleTexture, mAsset->get("title.png"), mRenderer);
+	success &= loadTextureFromFile(mItemsTexture, mAsset->get("items.png"), mRenderer);
+	success &= loadTextureFromFile(mTextTexture, mAsset->get("smb2.png"), mRenderer);
+	success &= loadTextureFromFile(mTextTexture2, mAsset->get("8bithud.png"), mRenderer);

 	// Sonidos
-	mSound = JA_LoadSound(mFileList[21].c_str());
+	mSound = JA_LoadSound(mAsset->get("title.wav").c_str());

 	// Musicas
-	mMusic = JA_LoadMusic(mFileList[5].c_str());
+	mMusic = JA_LoadMusic(mAsset->get("title.ogg").c_str());

 	return success;
 }
@@ -920,7 +914,7 @@ section_t Title::run(Uint8 subsection)
 // Ejecuta la parte donde se muestran las instrucciones
 void Title::runInstructions(Uint8 mode)
 {
-	mInstructions = new Instructions(mRenderer, mScreen, mFileList, mLang);
+	mInstructions = new Instructions(mRenderer, mScreen, mAsset, mLang);
 	mInstructions->run(mode);
 	delete mInstructions;
 }
@@ -928,7 +922,7 @@ void Title::runInstructions(Uint8 mode)
 // Ejecuta el juego en modo demo
 void Title::runDemoGame()
 {
-	mDemoGame = new Game(1, 0, mRenderer, mScreen, mFileList, mLang, mInput, true, mOptions);
+	mDemoGame = new Game(1, 0, mRenderer, mScreen, mAsset, mLang, mInput, true, mOptions);
 	mDemoGame->run();
 	delete mDemoGame;
 }
--- a/source/title.h
+++ b/source/title.h
@@ -1,20 +1,21 @@
 #pragma once

 #include <SDL2/SDL.h>
+#include "asset.h"
 #include "const.h"
-#include "utils.h"
-#include "sprite.h"
-#include "movingsprite.h"
-#include "smartsprite.h"
-#include "item.h"
-#include "text.h"
-#include "menu.h"
 #include "fade.h"
+#include "game.h"
 #include "input.h"
 #include "instructions.h"
-#include "game.h"
-#include "screen.h"
+#include "item.h"
 #include "jail_audio.h"
+#include "menu.h"
+#include "movingsprite.h"
+#include "screen.h"
+#include "smartsprite.h"
+#include "sprite.h"
+#include "text.h"
+#include "utils.h"

 #ifndef TITLE_H
 #define TITLE_H
@@ -52,7 +53,7 @@ private:
 	SmartSprite *mCrisisBitmap;		   // Sprite con la palabra CRISIS para la pantalla de titulo
 	Sprite *mTile;					   // Sprite para dibujar el fondo de pantalla del título
 	Sprite *mGradient;				   // Sprite para dibujar el degradado del titulo
-	std::string *mFileList;			   // Lista de ficheros
+	Asset *mAsset;					   // Objeto que gestiona todos los ficheros de recursos
 	Lang *mLang;					   // Objeto para gestionar los textos en diferentes idiomas
 	Uint16 mBackgroundCounter;		   // Temporizador para el fondo de tiles de la pantalla de titulo
 	Uint16 mCounter;				   // Temporizador para la pantalla de titulo
@@ -114,7 +115,7 @@ private:

 public:
 	// Constructor
-	Title(SDL_Window *window, SDL_Renderer *renderer, Screen *screen, Input *input, std::string *fileList, options_t *options, Lang *lang);
+	Title(SDL_Window *window, SDL_Renderer *renderer, Screen *screen, Input *input, Asset *mAsset, options_t *options, Lang *lang);

 	// Destructor
 	~Title();