el modo demo ya funciona con las tres combinaciones de jugadores y con diferentes ficheros de demo

data/config/param.txt

@@ -1,6 +1,7 @@
 #GAME
 gameWidth 320
 gameHeight 240
+itemSize 20
 
 #FADE
 numSquaresWidth 160

data/gfx/item_coffee_machine.ani

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

source/common/utils.h

@@ -171,6 +171,7 @@ struct param_t
 {
 	int gameWidth;	// Ancho de la resolucion nativa del juego
 	int gameHeight; // Alto de la resolucion nativa del juego
+	int itemSize; // Tamañoi de los items del juego
 
 	SDL_Rect scoreboard; // Posición y tamaño del marcador
 

source/director.cpp

@@ -16,7 +16,12 @@ Director::Director(int argc, char *argv[])
 {
 	// Inicializa variables
 	section = new section_t();
+#ifdef RECORDING
+	section->name = SECTION_PROG_GAME;
+	section->subsection = SUBSECTION_GAME_PLAY_1P;
+#else
 	section->name = SECTION_PROG_LOGO;
+#endif
 
 	// Comprueba los parametros del programa
 	checkProgramArguments(argc, argv);
@@ -279,7 +284,8 @@ bool Director::setFileList()
 	asset->add(systemFolder + "/config.txt", t_data, false, true);
 	asset->add(systemFolder + "/score.bin", t_data, false, true);
 	asset->add(prefix + "/data/config/param.txt", t_data);
-	asset->add(prefix + "/data/config/demo.bin", t_data);
+	asset->add(prefix + "/data/config/demo1.bin", t_data);
+	asset->add(prefix + "/data/config/demo2.bin", t_data);
 	asset->add(prefix + "/data/config/gamecontrollerdb.txt", t_data);
 
 	// Notificaciones
@@ -419,7 +425,11 @@ void Director::initOptions()
 	// Pone unos valores por defecto para las opciones
 
 	// Opciones varias
+#ifdef VERBOSE
+	options->console = true;
+#else
 	options->console = false;
+#endif
 
 	// Opciones de video
 	options->video.mode = 0;
@@ -818,7 +828,8 @@ void Director::runInstructions()
 // Ejecuta el juego en modo demo
 void Director::runDemoGame()
 {
-	demoGame = new Game(1, 0, renderer, screen, asset, lang, input, true, param, options, section, nullptr);
+	const int playerID = (rand() % 2) + 1;
+	demoGame = new Game(playerID, 0, renderer, screen, asset, lang, input, true, param, options, section, nullptr);
 	demoGame->run();
 	delete demoGame;
 }

source/game.cpp

@@ -31,8 +31,15 @@ Game::Game(int playerID, int currentStage, SDL_Renderer *renderer, Screen *scree
 	// Carga los recursos
 	loadMedia();
 
-	// Carga ficheros
+	// Inicializa los vectores con los datos para la demo
-	loadDemoFile();
+	if (demo)
+	{
+		// Aleatoriza la asignación del fichero
+		const int index1 = rand() % 2;
+		const int index2 = (index1 + 1) % 2;
+		loadDemoFile(asset->get("demo1.bin"), &this->demo.dataFile[index1]);
+		loadDemoFile(asset->get("demo2.bin"), &this->demo.dataFile[index2]);
+	}
 
 	// Establece la máxima puntuación desde fichero o desde las puntuaciones online
 	setHiScore();
@@ -171,14 +178,14 @@ void Game::init(int playerID)
 	};
 	players.clear();
 
-	// Crea los jugadores
+	// Crea los dos jugadores
 	Player *player1 = new Player((PLAY_AREA_CENTER_FIRST_QUARTER_X * ((0 * 2) + 1)) - 11, PLAY_AREA_BOTTOM - 24, renderer, playerTextures[0], playerAnimations);
 	players.push_back(player1);
 
 	Player *player2 = new Player((PLAY_AREA_CENTER_FIRST_QUARTER_X * ((1 * 2) + 1)) - 11, PLAY_AREA_BOTTOM - 24, renderer, playerTextures[1], playerAnimations);
 	players.push_back(player2);
 
-	// playerID es player 1 o player 2
+	// Habilita el jugador seleccionado. playerID es player 1 o player 2
 	players[playerID - 1]->enable(true);
 
 	// Variables relacionadas con la dificultad
@@ -243,6 +250,7 @@ void Game::init(int playerID)
 	powerBallCounter = 0;
 	coffeeMachineEnabled = false;
 
+	// Inicializa las variables para el modo demo
 	if (demo.enabled)
 	{
 		// Selecciona una pantalla al azar
@@ -258,6 +266,13 @@ void Game::init(int playerID)
 			currentStage = 6;
 		}
 
+		// Activa o no al otro jugador
+		if (rand() % 3 == 0)
+		{
+			const int otherPlayer = playerID == 1 ? 2 : 1;
+			players[otherPlayer - 1]->enable(true);
+		}
+
 		// Añade 0, 1 o 2 cafes al jugador
 		for (int i = 0; i < rand() % 3; ++i)
 		{
@@ -286,7 +301,7 @@ void Game::init(int playerID)
 		totalPowerToCompleteGame += stage[i].powerToComplete;
 	}
 
-	// Modo demo
+	// Modo grabar demo
 #ifdef RECORDING
 	demo.recording = true;
 #else
@@ -603,13 +618,12 @@ bool Game::loadScoreFile()
 }
 
 // Carga el fichero de datos para la demo
-bool Game::loadDemoFile()
+bool Game::loadDemoFile(std::string f, demoKeys_t (*dataFile)[TOTAL_DEMO_DATA])
 {
 	// Indicador de éxito en la carga
 	bool success = true;
-	const std::string p = asset->get("demo.bin");
+	const std::string filename = f.substr(f.find_last_of("\\/") + 1);
-	const std::string filename = p.substr(p.find_last_of("\\/") + 1);
+	SDL_RWops *file = SDL_RWFromFile(f.c_str(), "r+b");
-	SDL_RWops *file = SDL_RWFromFile(p.c_str(), "r+b");
 
 	// El fichero no existe
 	if (file == nullptr)
@@ -620,7 +634,9 @@ bool Game::loadDemoFile()
 		}
 
 		// Creamos el fichero para escritura
-		file = SDL_RWFromFile(p.c_str(), "w+b");
+		file = SDL_RWFromFile(f.c_str(), "w+b");
+
+		// Si no existe el fichero
 		if (file != nullptr)
 		{
 			if (options->console)
@@ -628,24 +644,25 @@ bool Game::loadDemoFile()
 				std::cout << "New file (" << filename.c_str() << ") created!" << std::endl;
 			}
 
-			// Inicializamos los datos
+			// Inicializas los datos y los guarda en el fichero
 			for (int i = 0; i < TOTAL_DEMO_DATA; ++i)
 			{
-				demo.keys.left = 0;
+				demoKeys_t tmp;
-				demo.keys.right = 0;
+				tmp.left = 0;
-				demo.keys.noInput = 0;
+				tmp.right = 0;
-				demo.keys.fire = 0;
+				tmp.noInput = 0;
-				demo.keys.fireLeft = 0;
+				tmp.fire = 0;
-				demo.keys.fireRight = 0;
+				tmp.fireLeft = 0;
-				demo.dataFile[i] = demo.keys;
+				tmp.fireRight = 0;
-				SDL_RWwrite(file, &demo.dataFile[i], sizeof(demoKeys_t), 1);
+				(*dataFile)[i] = tmp;
+				SDL_RWwrite(file, &tmp, sizeof(demoKeys_t), 1);
 			}
 
 			// Cerramos el fichero
 			SDL_RWclose(file);
 		}
 		else
-		{
+		{ // Si no puede crear el fichero
 			if (options->console)
 			{
 				std::cout << "Error: Unable to create file " << filename.c_str() << std::endl;
@@ -656,13 +673,19 @@ bool Game::loadDemoFile()
 	// El fichero existe
 	else
 	{
-		// Cargamos los datos
+		// Mensaje de proceder a la carga de los datos
 		if (options->console)
 		{
 			std::cout << "Reading file " << filename.c_str() << std::endl;
 		}
+
+		// Lee todos los datos del fichero y los deja en el destino
 		for (int i = 0; i < TOTAL_DEMO_DATA; ++i)
-			SDL_RWread(file, &demo.dataFile[i], sizeof(demoKeys_t), 1);
+		{
+			demoKeys_t tmp;
+			SDL_RWread(file, &tmp, sizeof(demoKeys_t), 1);
+			(*dataFile)[i] = tmp;
+		}
 
 		// Cierra el fichero
 		SDL_RWclose(file);
@@ -709,17 +732,16 @@ bool Game::saveScoreFile()
 bool Game::saveDemoFile()
 {
 	bool success = true;
-	const std::string p = asset->get("demo.bin");
+	const std::string p = asset->get("demo1.bin");
 	const std::string filename = p.substr(p.find_last_of("\\/") + 1);
-	if (demo.recording)
+
-	{
 	SDL_RWops *file = SDL_RWFromFile(p.c_str(), "w+b");
 	if (file != nullptr)
 	{
 		// Guardamos los datos
 		for (int i = 0; i < TOTAL_DEMO_DATA; ++i)
 		{
-				SDL_RWwrite(file, &demo.dataFile[i], sizeof(demoKeys_t), 1);
+			SDL_RWwrite(file, &demo.dataFile[0][i], sizeof(demoKeys_t), 1);
 		}
 
 		if (options->console)
@@ -737,7 +759,7 @@ bool Game::saveDemoFile()
 			std::cout << "Error: Unable to save " << filename.c_str() << " file! " << SDL_GetError() << std::endl;
 		}
 	}
-	}
+
 	return success;
 }
 #endif
@@ -1551,7 +1573,7 @@ void Game::updatePlayers()
 				{
 					killPlayer(player);
 
-					if (demo.enabled && !player->isAlive())
+					if (demo.enabled && allPlayersAreDead())
 					{
 						fade->setType(FADE_RANDOM_SQUARE);
 						fade->activate();
@@ -1631,13 +1653,7 @@ void Game::updateStage()
 void Game::updateDeath()
 {
 	// Comprueba si todos los jugadores estan muertos
-	bool allPlayersAreDead = true;
+	if (allPlayersAreDead())
-	for (auto player : players)
-	{
-		allPlayersAreDead &= (!player->isAlive() || !player->isEnabled());
-	}
-
-	if (allPlayersAreDead)
 	{
 		if (deathCounter > 0)
 		{
@@ -2376,8 +2392,8 @@ void Game::throwCoffee(int x, int y)
 
 	ss->setPosX(x - 8);
 	ss->setPosY(y - 8);
-	ss->setWidth(16);
+	ss->setWidth(param->itemSize);
-	ss->setHeight(16);
+	ss->setHeight(param->itemSize);
 	ss->setVelX(-1.0f + ((rand() % 5) * 0.5f));
 	ss->setVelY(-4.0f);
 	ss->setAccelX(0.0f);
@@ -2386,7 +2402,7 @@ void Game::throwCoffee(int x, int y)
 	ss->setDestY(param->gameHeight + 1);
 	ss->setEnabled(true);
 	ss->setEnabledCounter(1);
-	ss->setSpriteClip(0, 0, 16, 16);
+	ss->setSpriteClip(0, param->itemSize, param->itemSize, param->itemSize);
 	ss->setRotate(true);
 	ss->setRotateSpeed(10);
 	ss->setRotateAmount(90.0);
@@ -2533,24 +2549,22 @@ void Game::update()
 		// Actualiza el contador de juego
 		counter++;
 
-		// Incrementa el contador de la demo
 		if (demo.enabled)
 		{
+			// Incrementa el contador de la demo
 			if (demo.counter < TOTAL_DEMO_DATA)
 			{
 				demo.counter++;
+			}
+
+			// Activa el fundido antes de acabar con los datos de la demo
 			if (demo.counter == TOTAL_DEMO_DATA - 200)
 			{
 				fade->setType(FADE_RANDOM_SQUARE);
 				fade->activate();
 			}
-			}
-			else
-			{
-				section->name = SECTION_PROG_HI_SCORE_TABLE;
-				return;
-			}
 
+			// Si ha terminado el fundido, cambia de sección
 			if (fade->hasEnded())
 			{
 				section->name = SECTION_PROG_HI_SCORE_TABLE;
@@ -2559,16 +2573,21 @@ void Game::update()
 		}
 
 #ifdef RECORDING
+		// Solo mira y guarda el input en cada update
 		checkInput();
 
-		if (demo.recording)
+		// Incrementa el contador de la demo
+		if (demo.counter < TOTAL_DEMO_DATA)
 		{
-			if (demo.counter >= TOTAL_DEMO_DATA)
+			demo.counter++;
+		}
+
+		// Si se ha llenado el vector con datos, sale del programa
+		else
 		{
 			section->name = SECTION_PROG_QUIT;
 			return;
 		}
-		}
 #endif
 
 		// Comprueba si la música ha de estar sonando
@@ -2760,51 +2779,55 @@ void Game::checkInput()
 	// Modo Demo activo
 	if (demo.enabled)
 	{
-		const int index = 0;
+		int i = 0;
+		for (auto player : players)
+		{
+			if (player->isAlive() && player->isEnabled())
+			{
 				// Comprueba direcciones
-		if (demo.dataFile[demo.counter].left == 1)
+				if (demo.dataFile[i][demo.counter].left == 1)
 				{
-			players[index]->setInput(input_left);
+					player->setInput(input_left);
 				}
 
-		else if (demo.dataFile[demo.counter].right == 1)
+				else if (demo.dataFile[i][demo.counter].right == 1)
 				{
-			players[index]->setInput(input_right);
+					player->setInput(input_right);
 				}
 
-		else if (demo.dataFile[demo.counter].noInput == 1)
+				else if (demo.dataFile[i][demo.counter].noInput == 1)
 				{
-			players[index]->setInput(input_null);
+					player->setInput(input_null);
 				}
 
 				// Comprueba botones
-		if (demo.dataFile[demo.counter].fire == 1)
+				if (demo.dataFile[i][demo.counter].fire == 1)
 				{
-			if (players[index]->canFire())
+					if (player->canFire())
 					{
-				players[index]->setInput(input_fire_center);
+						player->setInput(input_fire_center);
-				createBullet(players[index]->getPosX() + (players[index]->getWidth() / 2) - 4, players[index]->getPosY() + (players[index]->getHeight() / 2), BULLET_UP, players[index]->isPowerUp(), index);
+						createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BULLET_UP, player->isPowerUp(), i);
-				players[index]->setFireCooldown(10);
+						player->setFireCooldown(10);
 					}
 				}
 
-		else if (demo.dataFile[demo.counter].fireLeft == 1)
+				else if (demo.dataFile[i][demo.counter].fireLeft == 1)
 				{
-			if (players[index]->canFire())
+					if (player->canFire())
 					{
-				players[index]->setInput(input_fire_left);
+						player->setInput(input_fire_left);
-				createBullet(players[index]->getPosX() + (players[index]->getWidth() / 2) - 4, players[index]->getPosY() + (players[index]->getHeight() / 2), BULLET_LEFT, players[index]->isPowerUp(), index);
+						createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BULLET_LEFT, player->isPowerUp(), i);
-				players[index]->setFireCooldown(10);
+						player->setFireCooldown(10);
 					}
 				}
 
-		else if (demo.dataFile[demo.counter].fireRight == 1)
+				else if (demo.dataFile[i][demo.counter].fireRight == 1)
 				{
-			if (players[index]->canFire())
+					if (player->canFire())
 					{
-				players[index]->setInput(input_fire_right);
+						player->setInput(input_fire_right);
-				createBullet(players[index]->getPosX() + (players[index]->getWidth() / 2) - 4, players[index]->getPosY() + (players[index]->getHeight() / 2), BULLET_RIGHT, players[index]->isPowerUp(), index);
+						createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BULLET_RIGHT, player->isPowerUp(), i);
-				players[index]->setFireCooldown(10);
+						player->setFireCooldown(10);
 					}
 				}
 
@@ -2815,6 +2838,10 @@ void Game::checkInput()
 					return;
 				}
 			}
+
+			i++;
+		}
+	}
 	// Modo Demo no activo
 	else
 	{
@@ -2914,7 +2941,7 @@ void Game::checkInput()
 				{
 					if (demo.counter < TOTAL_DEMO_DATA)
 					{
-						demo.dataFile[demo.counter] = demo.keys;
+						demo.dataFile[0][demo.counter] = demo.keys;
 					}
 				}
 #endif
@@ -3220,7 +3247,7 @@ bool Game::allPlayersAreDead()
 	bool success = true;
 	for (auto player : players)
 	{
-		success &= (!player->isAlive());
+		success &= (!player->isAlive() || !player->isEnabled());
 	}
 
 	return success;
@@ -3355,10 +3382,15 @@ void Game::setHiScore()
 // Actualiza el marcador
 void Game::updateScoreboard()
 {
+	// Jugador 1
 	scoreboard->setScore1(players[0]->getScore());
 	scoreboard->setMult1(players[0]->getScoreMultiplier());
-	scoreboard->setScore2(players[0]->getScore());
+
-	scoreboard->setMult2(players[0]->getScoreMultiplier());
+	// Jugador 2
+	scoreboard->setScore2(players[1]->getScore());
+	scoreboard->setMult2(players[1]->getScoreMultiplier());
+
+	// Resto de marcador
 	scoreboard->setStage(stage[currentStage].number);
 	scoreboard->setPower((float)stage[currentStage].currentPower / (float)stage[currentStage].powerToComplete);
 	scoreboard->setHiScore(hiScore);

source/game.h

@@ -102,9 +102,9 @@ private:
 	{
 		bool enabled;							 // Indica si está activo el modo demo
 		bool recording;							 // Indica si está activado el modo para grabar la demo
-		Uint16 counter;						  // Contador para el modo demo
+		int counter;							 // Contador para el modo demo
 		demoKeys_t keys;						 // Variable con las pulsaciones de teclas del modo demo
-		demoKeys_t dataFile[TOTAL_DEMO_DATA]; // Datos del fichero con los movimientos para la demo
+		demoKeys_t dataFile[2][TOTAL_DEMO_DATA]; // Vector con diferentes sets de datos con los movimientos para la demo
 	};
 
 	// Objetos y punteros
@@ -232,7 +232,7 @@ private:
 	bool loadScoreFile();
 
 	// Carga el fichero de datos para la demo
-	bool loadDemoFile();
+	bool loadDemoFile(std::string fileName, demoKeys_t (*dataFile)[TOTAL_DEMO_DATA]);
 
 	// Guarda el fichero de puntos
 	bool saveScoreFile();

source/instructions.cpp

@@ -35,7 +35,7 @@ Instructions::Instructions(SDL_Renderer *renderer, Screen *screen, Asset *asset,
 	counterEnd = 700;
 	view = {0, 0, param->gameWidth, param->gameHeight};
 	spritePos = {0, 0};
-	itemSize = 20;
+	itemSpace = 2;
 
 	// Inicializa objetos
 	fade->setColor(fadeColor.r, fadeColor.g, fadeColor.b);
@@ -96,12 +96,10 @@ void Instructions::iniSprites()
 	itemTextures.push_back(item5);
 
 	// Inicializa los sprites
-	const int desp = spritePos.y - 4;
-
 	for (int i = 0; i < (int)itemTextures.size(); ++i)
 	{
-		Sprite *sprite = new Sprite(0, 0, itemSize, itemSize, itemTextures[i], renderer);
+		Sprite *sprite = new Sprite(0, 0, param->itemSize, param->itemSize, itemTextures[i], renderer);
-		sprite->setPos({spritePos.x, desp + ((itemSize + 2) * i), itemSize, itemSize});
+		sprite->setPos({spritePos.x, spritePos.y + ((param->itemSize + itemSpace) * i), param->itemSize, param->itemSize});
 		sprites.push_back(sprite);
 	}
 }
@@ -109,34 +107,33 @@ void Instructions::iniSprites()
 // Actualiza los sprites
 void Instructions::updateSprites()
 {
-	SDL_Rect srcRect = {0, 0, itemSize, itemSize};
+	SDL_Rect srcRect = {0, 0, param->itemSize, param->itemSize};
 
 	// Disquito
-	srcRect.y = itemSize * (((counter + 12) / 36) % 2);
+	srcRect.y = param->itemSize * (((counter + 12) / 36) % 2);
 	sprites[0]->setSpriteClip(srcRect);
 
 	// Gavineixon
-	srcRect.y = itemSize * (((counter + 9) / 36) % 2);
+	srcRect.y = param->itemSize * (((counter + 9) / 36) % 2);
 	sprites[1]->setSpriteClip(srcRect);
 
 	// Pacmar
-	srcRect.y = itemSize * (((counter + 6) / 36) % 2);
+	srcRect.y = param->itemSize * (((counter + 6) / 36) % 2);
 	sprites[2]->setSpriteClip(srcRect);
 
 	// Time Stopper
-	srcRect.y = itemSize * (((counter + 3) / 36) % 2);
+	srcRect.y = param->itemSize * (((counter + 3) / 36) % 2);
 	sprites[3]->setSpriteClip(srcRect);
 
 	// Coffee
-	srcRect.y = itemSize * (((counter + 0) / 36) % 2);
+	srcRect.y = param->itemSize * (((counter + 0) / 36) % 2);
 	sprites[4]->setSpriteClip(srcRect);
 }
 
 // Rellena la textura de texto
 void Instructions::fillTexture()
 {
-	const int despX = itemSize + 8;
+	const int despX = param->itemSize + 8;
-	const int despY = (itemSize - text->getCharacterSize() / 2);
 
 	// Modifica el renderizador para pintar en la textura
 	SDL_Texture *temp = SDL_GetRenderTarget(renderer);
@@ -155,7 +152,7 @@ void Instructions::fillTexture()
 	const int spacePostHeader = 20;
 	const int spacePreHeader = 28;
 	const int spaceBetweenLines = text->getCharacterSize() * 1.5f;
-	const int spaceBetweenItemLines = itemSize + 2;
+	const int spaceBetweenItemLines = param->itemSize + itemSpace;
 	const int spaceNewParagraph = spaceBetweenLines * 0.5f;
 
 	const int size = (numLines * spaceBetweenLines) + (numItemLines * spaceBetweenItemLines) + (numPostHeaders * spacePostHeader) + (numPreHeaders * spacePreHeader) + (spaceNewParagraph);
@@ -184,18 +181,19 @@ void Instructions::fillTexture()
 	text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, GAMECANVAS_CENTER_X, anchor2, lang->getText(16), 1, orangeColor, 1, shdwTxtColor);
 
 	const int anchor3 = anchor2 + spacePostHeader;
-	text->writeShadowed(anchorItem + despX, despY + anchor3 + spaceBetweenItemLines * 0, lang->getText(17), shdwTxtColor);
+	//const int anchor4 = anchor3 + ((param->itemSize + text->getCharacterSize()) / 2);
-	text->writeShadowed(anchorItem + despX, despY + anchor3 + spaceBetweenItemLines * 1, lang->getText(18), shdwTxtColor);
+	text->writeShadowed(anchorItem + despX, anchor3 + spaceBetweenItemLines * 0, lang->getText(17), shdwTxtColor);
-	text->writeShadowed(anchorItem + despX, despY + anchor3 + spaceBetweenItemLines * 2, lang->getText(19), shdwTxtColor);
+	text->writeShadowed(anchorItem + despX, anchor3 + spaceBetweenItemLines * 1, lang->getText(18), shdwTxtColor);
-	text->writeShadowed(anchorItem + despX, despY + anchor3 + spaceBetweenItemLines * 3, lang->getText(20), shdwTxtColor);
+	text->writeShadowed(anchorItem + despX, anchor3 + spaceBetweenItemLines * 2, lang->getText(19), shdwTxtColor);
-	text->writeShadowed(anchorItem + despX, despY + anchor3 + spaceBetweenItemLines * 4, lang->getText(21), shdwTxtColor);
+	text->writeShadowed(anchorItem + despX, anchor3 + spaceBetweenItemLines * 3, lang->getText(20), shdwTxtColor);
+	text->writeShadowed(anchorItem + despX, anchor3 + spaceBetweenItemLines * 4, lang->getText(21), shdwTxtColor);
 
 	// Deja el renderizador como estaba
 	SDL_SetRenderTarget(renderer, temp);
 
 	// Da valor a la variable
 	spritePos.x = anchorItem;
-	spritePos.y = anchor3;
+	spritePos.y = anchor3 - ((param->itemSize - text->getCharacterSize()) / 2);
 }
 
 // Rellena el backbuffer

source/instructions.h

@@ -44,7 +44,7 @@ private:
 	Uint32 ticksSpeed;	 // Velocidad a la que se repiten los bucles del programa
 	SDL_Rect view;		 // Vista del backbuffer que se va amostrar por pantalla
 	SDL_Point spritePos; // Posición del primer sprite
-	int itemSize;		 // Tamaño de los items
+	int itemSpace;		 // Espacio entre los items
 
 	// Actualiza las variables
 	void update();

source/item.cpp

@@ -14,8 +14,8 @@ Item::Item(Uint8 kind, float x, float y, Texture *texture, std::vector<std::stri
 
 	if (kind == ITEM_COFFEE_MACHINE)
 	{
-		width = 30;
+		width = 28;
-		height = 39;
+		height = 37;
 		posX = (((int)x + (PLAY_AREA_WIDTH / 2)) % (PLAY_AREA_WIDTH - width - 5)) + 2;
 		posY = PLAY_AREA_TOP - height;
 		velX = 0.0f;

source/load_param.cpp

@@ -11,6 +11,7 @@ void initParam(param_t *param)
 	// Tamaño original del juego
 	param->gameWidth = 320;
 	param->gameHeight = 240;
+	param->itemSize = 20;
 
 	// Tamaño para el marcador
 	param->scoreboard = {0, 208, 320, 32};
@@ -131,6 +132,11 @@ bool setOptions(param_t *param, std::string var, std::string value)
 		param->gameHeight = std::stoi(value);
 	}
 
+	else if (var == "itemSize")
+	{
+		param->itemSize = std::stoi(value);
+	}
+
 	else if (var == "numSquaresWidth")
 	{
 		param->numSquaresWidth = std::stoi(value);

source/scoreboard.cpp

@@ -95,52 +95,62 @@ void Scoreboard::render()
 	SDL_RenderCopy(renderer, background, nullptr, &rect);
 }
 
+// Establece el valor de la variable
 void Scoreboard::setScore1(int score)
 {
 	score1 = score;
 }
 
+// Establece el valor de la variable
 void Scoreboard::setScore2(int score)
 {
 	score2 = score;
 }
 
+// Establece el valor de la variable
 void Scoreboard::setMult1(float mult)
 {
 	mult1 = mult;
 }
 
+// Establece el valor de la variable
 void Scoreboard::setMult2(float mult)
 {
 	mult2 = mult;
 }
 
+// Establece el valor de la variable
 void Scoreboard::setStage(int stage)
 {
 	this->stage = stage;
 }
 
+// Establece el valor de la variable
 void Scoreboard::setHiScore(int hiScore)
 {
 	this->hiScore = hiScore;
 }
 
+// Establece el valor de la variable
 void Scoreboard::setPower(float power)
 {
 	this->power = power;
 }
 
+// Establece el valor de la variable
 void Scoreboard::setHiScoreName(std::string name)
 {
 	hiScoreName = name;
 }
 
+// Establece el valor de la variable
 void Scoreboard::setColor(color_t color)
 {
 	this->color = color;
 	fillBackgroundTexture();
 }
 
+// Establece el valor de la variable
 void Scoreboard::setPos(SDL_Rect rect)
 {
 	this->rect = rect;

source/scoreboard.h

@@ -74,15 +74,34 @@ public:
 	// Pinta el marcador
 	void render();
 
+	// Establece el valor de la variable
 	void setScore1(int score);
+
+	// Establece el valor de la variable
 	void setScore2(int score);
+	
+	// Establece el valor de la variable
 	void setMult1(float mult);
+	
+	// Establece el valor de la variable
 	void setMult2(float mult);
+	
+	// Establece el valor de la variable
 	void setStage(int stage);
+	
+	// Establece el valor de la variable
 	void setHiScore(int hiScore);
+	
+	// Establece el valor de la variable
 	void setPower(float power);
+	
+	// Establece el valor de la variable
 	void setHiScoreName(std::string name);
+	
+	// Establece el valor de la variable
 	void setColor(color_t color);
+	
+	// Establece el valor de la variable
 	void setPos(SDL_Rect rect);
 };