jaildoctors_dilemma/source/game.h

#pragma once

#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 <vector>			 // for vector
#include "player.h"			 // for PlayerSpawn
#include "surface.h"
class Room;			   // lines 10-10
class RoomTracker;	   // lines 11-11
class Scoreboard;	   // lines 12-12
class Stats;		   // lines 13-13
struct ScoreboardData; // lines 14-14

enum class GameMode
{
	DEMO,
	GAME
};

class Game
{
private:
	// Estructuras
	struct DemoData
	{
		int counter;					// Contador para el modo demo
		int room_time;					// Tiempo que se muestra cada habitación
		int room_index;					// Índice para el vector de habitaciones
		std::vector<std::string> rooms; // Listado con los mapas de la demo

		// Constructor por defecto
		DemoData()
			: counter(0), room_time(0), room_index(0), rooms({}) {}

		// Constructor parametrizado
		DemoData(int counter, int room_time, int room_index, const std::vector<std::string> &rooms)
			: counter(counter), room_time(room_time), room_index(room_index), rooms(rooms) {}
	};

	// Objetos y punteros
	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<Stats> stats_;				 // Objeto encargado de gestionar las estadísticas
	std::shared_ptr<Surface> room_name_surface_; // Textura para escribir el nombre de la habitación

	// Variables
	GameMode mode_;				   // Modo del juego
	DemoData demo_;				   // Variables para el modo demo
	Uint32 ticks_ = 0;			   // Contador de ticks para ajustar la velocidad del programa
	std::string current_room_;	   // Fichero de la habitación actual
	PlayerSpawn spawn_point_;	   // Lugar de la habitación donde aparece el jugador
	bool paused_ = false;		   // Indica si el juego se encuentra en pausa
	bool black_screen_ = false;	   // Indica si la pantalla está en negro. Se utiliza para la muerte del jugador
	int black_screen_counter_ = 0; // Contador para temporizar la pantalla en negro
	int total_items_;			   // Cantidad total de items que hay en el mapeado del juego
	SDL_Rect room_name_rect_;	   // Rectangulo donde pintar la textura con el nombre de la habitación

	// Actualiza el juego, las variables, comprueba la entrada, etc.
	void update();

	// Pinta los objetos en pantalla
	void render();

	// Comprueba los eventos de la cola
	void checkEvents();

#ifdef DEBUG
	// Pone la información de debug en pantalla
	void updateDebugInfo();

	// 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(const std::string &file);

	// Comprueba el teclado
	void checkInput();

	// Comprueba si el jugador esta en el borde de la pantalla y actua
	void checkPlayerOnBorder();

	// Comprueba las colisiones del jugador con los enemigos
	bool checkPlayerAndEnemies();

	// Comprueba las colisiones del jugador con los objetos
	void checkPlayerAndItems();

	// Comprueba si el jugador esta vivo
	void checkIfPlayerIsAlive();

	// Comprueba si ha terminado la partida
	void checkGameOver();

	// Mata al jugador
	void killPlayer();

	// Establece la pantalla en negro
	void setBlackScreen();

	// Actualiza las variables relativas a la pantalla en negro
	void updateBlackScreen();

	// Dibuja la pantalla negra
	void renderBlackScreen();

	// Pone el color del marcador en función del color del borde de la habitación
	void setScoreBoardColor();

	// Comprueba si ha finalizado el juego
	bool checkEndGame();

	// Obtiene la cantidad total de items que hay en el mapeado del juego
	int getTotalItems();

	// Pone el juego en pausa
	void togglePause();

	// Da vidas al jugador cuando está en la Jail
	void checkRestoringJail();

	// Inicializa el diccionario de las estadísticas
	void initStats();

	// Pone el nombre de la habitación en la textura
	void fillRoomNameTexture();

	// Comprueba algunos logros
	void checkSomeCheevos();

	// 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();

	// DEMO MODE: Inicializa las variables para el modo demo
	void DEMO_init();

	// DEMO MODE: Comprueba si se ha de cambiar de habitación
	void DEMO_checkRoomChange();

public:
	// Constructor
	Game(GameMode mode);

	// Destructor
	~Game();

	// Bucle para el juego
	void run();
};