Añadida mas información al marcador

source/game.cpp

@@ -4,12 +4,10 @@
 Game::Game(SDL_Renderer *renderer, Screen *screen, Asset *asset, Input *input, Debug *debug)
 {
 	// Inicia algunas variables
-	clock = SDL_GetTicks();
+	board.iniClock = SDL_GetTicks();
 	currentRoom = "01.room";
 	spawnPoint = {16, 96, 0, 0, 0, s_standing, SDL_FLIP_NONE};
 
-	currentRoom = "06.room";
-	spawnPoint = {240, 96, 0, 0, 0, s_standing, SDL_FLIP_HORIZONTAL};
 
 	// Copia los punteros
 	this->renderer = renderer;
@@ -17,12 +15,16 @@ Game::Game(SDL_Renderer *renderer, Screen *screen, Asset *asset, Input *input, D
 	this->screen = screen;
 	this->input = input;
 	this->debug = debug;
-	this->debug->setEnabled(true);
+	
+	//this->debug->setEnabled(true);
+	//currentRoom = "06.room";
+	//spawnPoint = {240, 96, 0, 0, 0, s_standing, SDL_FLIP_HORIZONTAL};
 
 	// Crea los objetos
-	scoreboard = new ScoreBoard(renderer, asset, &playerLives, &itemsPicked, &clock);
+	scoreboard = new ScoreBoard(renderer, asset, &board);
 	itemTracker = new ItemTracker();
-	room = new Room(asset->get(currentRoom), renderer, screen, asset, itemTracker, &itemsPicked, debug);
+	roomTracker = new RoomTracker();
+	room = new Room(asset->get(currentRoom), renderer, screen, asset, itemTracker, &board.items, debug);
 	player = new Player(spawnPoint, asset->get("player.png"), asset->get("player.ani"), renderer, asset, input, room, debug);
 	eventHandler = new SDL_Event();
 	text = new Text(asset->get("smb2.png"), asset->get("smb2.txt"), renderer);
@@ -33,11 +35,13 @@ Game::Game(SDL_Renderer *renderer, Screen *screen, Asset *asset, Input *input, D
 	// Inicializa el resto de variables
 	ticks = 0;
 	ticksSpeed = 15;
-	playerLives = 9;
-	itemsPicked = 0;
+	board.lives = 9;
+	board.items = 0;
+	board.rooms = 1;
+	roomTracker->addRoom(currentRoom);
 
 	player->setInvincible(debug->getEnabled());
-	musicEnabled = !debug->getEnabled();
+	board.music = !debug->getEnabled();
 
 	section.name = SECTION_PROG_GAME;
 	section.subsection = SUBSECTION_GAME_PLAY;
@@ -53,6 +57,7 @@ Game::~Game()
 	// Libera la memoria de los objetos
 	delete scoreboard;
 	delete itemTracker;
+	delete roomTracker;
 	delete room;
 	delete player;
 	delete eventHandler;
@@ -88,12 +93,13 @@ void Game::checkEventHandler()
 			case SDL_SCANCODE_D:
 				debug->switchEnabled();
 				player->setInvincible(debug->getEnabled());
-				musicEnabled = !debug->getEnabled();
-				musicEnabled ? JA_PlayMusic(music) : JA_StopMusic();
+				board.music = !debug->getEnabled();
+				board.music ? JA_ResumeMusic() : JA_PauseMusic();
 				break;
 
 			case SDL_SCANCODE_M:
-				(JA_GetMusicState() == JA_MUSIC_PLAYING) ? JA_PauseMusic() : JA_ResumeMusic();
+				board.music = !board.music;
+				board.music ? JA_ResumeMusic() : JA_PauseMusic();
 				break;
 
 			case SDL_SCANCODE_F:
@@ -131,9 +137,10 @@ void Game::checkEventHandler()
 // Bucle para el juego
 section_t Game::run()
 {
-	if (musicEnabled)
-	{
 	JA_PlayMusic(music);
+	if (!board.music)
+	{
+		JA_PauseMusic();
 	}
 
 	while (section.name == SECTION_PROG_GAME)
@@ -191,7 +198,7 @@ void Game::render()
 
 	// Debug info
 	renderDebugInfo();
-	//test->render();
+	// test->render();
 
 	// Actualiza la pantalla
 	screen->blit();
@@ -261,7 +268,13 @@ bool Game::changeRoom(std::string file)
 			room = nullptr;
 
 			// Crea un objeto habitación nuevo a partir del fichero
-			room = new Room(asset->get(file), renderer, screen, asset, itemTracker, &itemsPicked, debug);
+			room = new Room(asset->get(file), renderer, screen, asset, itemTracker, &board.items, debug);
+
+			// Actualiza el marcador
+			if (roomTracker->addRoom(file))
+			{
+				board.rooms++;
+			}
 
 			// Pasa la nueva habitación al jugador
 			player->setRoom(room);
@@ -312,7 +325,7 @@ void Game::killPlayer()
 		return;
 	}
 
-	playerLives--;
+	board.lives--;
 
 	// Destruye la habitacion y el jugador
 	delete room;
@@ -322,7 +335,7 @@ void Game::killPlayer()
 	JA_PlaySound(deathSound);
 
 	// Crea la nueva habitación y el nuevo jugador
-	room = new Room(asset->get(currentRoom), renderer, screen, asset, itemTracker, &itemsPicked, debug);
+	room = new Room(asset->get(currentRoom), renderer, screen, asset, itemTracker, &board.items, debug);
 	player = new Player(spawnPoint, asset->get("player.png"), asset->get("player.ani"), renderer, asset, input, room, debug);
 }
 

source/game.h

@@ -10,6 +10,7 @@
 #include "asset.h"
 #include "room.h"
 #include "item_tracker.h"
+#include "room_tracker.h"
 #include "player.h"
 #include "jail_audio.h"
 #include "scoreboard.h"
@@ -29,22 +30,21 @@ private:
 	Room *room;				  // Objeto encargado de gestionar cada habitación del juego
 	Player *player;			  // Objeto con el jugador
 	ItemTracker *itemTracker; // Lleva el control de los objetos recogidos
+	RoomTracker *roomTracker; // Lleva el control de las habitaciones visitadas
 	Asset *asset;			  // Objeto con la ruta a todos los ficheros de recursos
 	Input *input;			  // Objeto pata gestionar la entrada
 	Text *text;				  // Objeto para los textos del juego
 	ScoreBoard *scoreboard;	  // Objeto encargado de gestionar el marcador
 	JA_Music music;			  // Musica que suena durante el juego
 	Debug *debug;			  // Objeto para gestionar la información de debug
-	bool musicEnabled;		  // Indica si ha de sonar la musica durante el juego
 	int ticks;				  // Contador de ticks para ajustar la velocidad del programa
 	int ticksSpeed;			  // Velocidad a la que se repiten los bucles del programa
 	section_t section;		  // Seccion actual dentro del juego
 	std::string currentRoom;  // Fichero de la habitación actual
 	player_t spawnPoint;	  // Lugar de la habitación donde aparece el jugador
-	int playerLives;		  // Lleva la cuenta de ls vidas restantes del jugador
-	int itemsPicked;		  // Lleva la cuenta de los objetos recogidos
 	Uint32 clock;			  // Cuenta el tiempo que dura la partida
 	JA_Sound deathSound;	  // Sonido a reproducir cuando muere el jugador
+	board_t board;			  // Estructura con los datos del marcador
 	Test *test;
 
 	// Actualiza el juego, las variables, comprueba la entrada, etc.

source/room_tracker.cpp

@@ -0,0 +1,40 @@
+#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)
+{
+    for (auto l : list)
+    {
+        if (l == name)
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+// Añade la habitación a la lista
+bool RoomTracker::addRoom(std::string name)
+{
+    // Comprueba si la habitación ya ha sido visitada
+    if (!hasBeenVisited(name))
+    {
+        // En caso contrario añádela a la lista
+        list.push_back(name);
+        return true;
+    }
+
+    return false;
+}

source/room_tracker.h

@@ -0,0 +1,30 @@
+#pragma once
+#include <SDL2/SDL.h>
+#include "utils.h"
+#include <string>
+#include <vector>
+
+#ifndef ROOM_TRACKER_H
+#define ROOM_TRACKER_H
+
+// Clase RoomTracker
+class RoomTracker
+{
+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);
+
+public:
+	// Constructor
+	RoomTracker();
+
+	// Destructor
+	~RoomTracker();
+
+	// Añade la habitación a la lista
+	bool addRoom(std::string name);
+};
+
+#endif

source/scoreboard.cpp

@@ -3,18 +3,17 @@
 #include <sstream>
 
 // Constructor
-ScoreBoard::ScoreBoard(SDL_Renderer *renderer, Asset *asset, int *lives, int *items, Uint32 *clock)
+ScoreBoard::ScoreBoard(SDL_Renderer *renderer, Asset *asset, board_t *board)
 {
     // Obten punteros a objetos
     this->asset = asset;
     this->renderer = renderer;
-    this->lives = lives;
-    this->items = items;
-    this->clock = clock;
+    this->board = board;
 
     // Reserva memoria para los objetos
-    texture = new LTexture(renderer, asset->get("player.png"));
-    sprite = new AnimatedSprite(texture, renderer, asset->get("player.ani"));
+    playerTexture = new LTexture(renderer, asset->get("player.png"));
+    itemTexture = new LTexture(renderer, asset->get("items.png"));
+    sprite = new AnimatedSprite(playerTexture, renderer, asset->get("player.ani"));
     sprite->setCurrentAnimation("walk_menu");
     text = new Text(asset->get("smb2.png"), asset->get("smb2.txt"), renderer);
 
@@ -26,8 +25,8 @@ ScoreBoard::ScoreBoard(SDL_Renderer *renderer, Asset *asset, int *lives, int *it
     color_t c = stringToColor("blue");
     color.push_back(c);
 
-    c = stringToColor("red");
-    color.push_back(c);
+    //c = stringToColor("red");
+    //color.push_back(c);
 
     c = stringToColor("magenta");
     color.push_back(c);
@@ -47,8 +46,8 @@ ScoreBoard::ScoreBoard(SDL_Renderer *renderer, Asset *asset, int *lives, int *it
     c = stringToColor("bright_blue");
     color.push_back(c);
 
-    c = stringToColor("bright_red");
-    color.push_back(c);
+    //c = stringToColor("bright_red");
+    //color.push_back(c);
 
     c = stringToColor("bright_magenta");
     color.push_back(c);
@@ -69,7 +68,8 @@ ScoreBoard::ScoreBoard(SDL_Renderer *renderer, Asset *asset, int *lives, int *it
 // Destructor
 ScoreBoard::~ScoreBoard()
 {
-    delete texture;
+    delete playerTexture;
+    delete itemTexture;
     delete sprite;
     delete text;
 }
@@ -89,7 +89,7 @@ void ScoreBoard::render()
     const int frame = desp % 4;
     sprite->setCurrentFrame(frame);
 
-    for (int i = 0; i < *lives; i++)
+    for (int i = 0; i < board->lives; i++)
     {
         sprite->setPosX(8 + (16 * i) + desp);
         index = i % color.size();
@@ -97,18 +97,25 @@ void ScoreBoard::render()
         sprite->render();
     }
 
-    // Escribe los textos
-    const clock_t clock = getTime();
-    std::string itemsTxt = std::to_string(*items / 100) + std::to_string((*items % 100) / 10) + std::to_string(*items % 10);
-    std::string separator = " ";
-    if (clock.separator)
+    // Muestra si suena la música
+    if (board->music)
     {
-        separator = ":";
+        const color_t c = stringToColor("bright_blue");
+        SDL_Rect clip = {0, 8, 8, 8};
+        itemTexture->setColor(c.r, c.g, c.b);
+        itemTexture->render(renderer, 20 * BLOCK, 20 * BLOCK, &clip);
     }
-    std::string timeTxt = std::to_string((clock.minutes % 60) / 10) + std::to_string(clock.minutes % 10) + separator + std::to_string((clock.seconds % 60) / 10) + std::to_string(clock.seconds % 10);
-    std::string text = "Items collected " + itemsTxt + " Time " + timeTxt;
-    const color_t color = stringToColor("white");
-    this->text->writeColored(BLOCK, 22 * BLOCK, text, color);
+
+    // Escribe los textos
+    const std::string timeTxt = std::to_string((clock.minutes % 60) / 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(board->items / 100) + std::to_string((board->items % 100) / 10) + std::to_string(board->items % 10);
+    const std::string roomsTxt = std::to_string(board->rooms / 100) + std::to_string((board->rooms % 100) / 10) + std::to_string(board->rooms % 10);
+    this->text->writeColored(22 * BLOCK, 20 * BLOCK, "Rooms", stringToColor("yellow"));
+    this->text->writeColored(28 * BLOCK, 20 * BLOCK, roomsTxt, stringToColor("bright_blue"));
+    this->text->writeColored(BLOCK, 22 * BLOCK, "Items collected ", stringToColor("yellow"));
+    this->text->writeColored(17 * BLOCK, 22 * BLOCK, itemsTxt, stringToColor("bright_blue"));
+    this->text->writeColored(20 * BLOCK, 22 * BLOCK, " Time ", stringToColor("yellow"));
+    this->text->writeColored(26 * BLOCK, 22 * BLOCK, timeTxt, stringToColor("bright_blue"));
 }
 
 // Actualiza las variables del objeto
@@ -116,23 +123,27 @@ void ScoreBoard::update()
 {
     counter++;
     sprite->update();
+    clock = getTime();
 }
 
 // Obtiene el tiempo transcurrido de partida
 ScoreBoard::clock_t ScoreBoard::getTime()
 {
-    const Uint32 timeElapsed = SDL_GetTicks() - *clock;
+    const Uint32 timeElapsed = SDL_GetTicks() - board->iniClock;
+
     clock_t time;
     time.hours = timeElapsed / 3600000;
     time.minutes = timeElapsed / 60000;
     time.seconds = timeElapsed / 1000;
-    time.separator = (timeElapsed % 1000 <= 500);
+    time.separator = (timeElapsed % 1000 <= 500) ? ":" : " ";
+
     return time;
 }
 
 // Recarga la textura
 void ScoreBoard::reLoadTexture()
 {
-    texture->reLoad();
+    playerTexture->reLoad();
+    itemTexture->reLoad();
     text->reLoadTexture();
 }

source/scoreboard.h

@@ -11,6 +11,15 @@
 #ifndef SCOREBOARD_H
 #define SCOREBOARD_H
 
+struct board_t
+{
+	int items;	// Lleva la cuenta de los objetos recogidos
+	int lives;	// Lleva la cuenta de ls 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
+	Uint32 iniClock;
+};
+
 // Clase ScoreBoard
 class ScoreBoard
 {
@@ -20,10 +29,10 @@ private:
 		int hours;
 		int minutes;
 		int seconds;
-		bool separator;
+		std::string separator;
 	};
 
-	LTexture *texture;			// Textura con los graficos para las vidas
+	LTexture *playerTexture;	// Textura con los graficos para las vidas
 	AnimatedSprite *sprite;		// Sprite para mostrar las vidas en el marcador
 	SDL_Renderer *renderer;		// El renderizador de la ventana
 	Asset *asset;				// Objeto con la ruta a todos los ficheros de recursos
@@ -31,16 +40,16 @@ private:
 	std::vector<color_t> color; // Vector con los colores del objeto
 	int counter;				// Contador interno
 	int colorChangeSpeed;		// Cuanto mas alto, mas tarda en cambiar de color
-	int *lives;					// Número ara mostrar en el marcador de vidas
-	int *items;					// Número para mostrar en el marcador de items
-	Uint32 *clock;				// Contiene el tiempo de inicio de la partida
+	clock_t clock;				// Contiene las horas, minutos y segundos transcurridos desde el inicio de la partida
+	LTexture *itemTexture;		// Textura con los graficos para las vidas
+	board_t *board;				// Contiene las variables a mostrar en el marcador
 
 	// Obtiene el tiempo transcurrido de partida
 	clock_t getTime();
 
 public:
 	// Constructor
-	ScoreBoard(SDL_Renderer *renderer, Asset *asset, int *lives, int *items, Uint32 *clock);
+	ScoreBoard(SDL_Renderer *renderer, Asset *asset, board_t *board);
 
 	// Destructor
 	~ScoreBoard();