jaildoctors_dilemma/source/game/scenes/game.hpp

#pragma once

#include <SDL3/SDL.h>

#include <initializer_list>  // Para initializer_list
#include <memory>            // Para shared_ptr
#include <string>            // Para string
#include <vector>            // Para vector

#include "game/entities/player.hpp"  // Para PlayerSpawn
class Room;                          // lines 12-12
class RoomTracker;                   // lines 13-13
class Scoreboard;                    // lines 14-14
class Stats;                         // lines 15-15
class Surface;
struct ScoreboardData;  // lines 16-16

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_FRect 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
        static void renderDebugInfo();

        // Comprueba los eventos
        void checkDebugEvents(const SDL_Event& event);
#endif

        // Escribe el nombre de la pantalla
        void renderRoomName();

        // Cambia de habitación
        auto changeRoom(const std::string& room_path) -> bool;

        // Comprueba el teclado
        void checkInput();

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

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

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

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

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

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

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

        // Hace sonar la música
        void keepMusicPlaying();

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

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

    public:
        // Constructor
        explicit Game(GameMode mode);

        // Destructor
        ~Game();

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