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
#include "utils/delta_timer.hpp"     // Para DeltaTimer
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:
        // Constantes de tiempo
        static constexpr float BLACK_SCREEN_DURATION = 0.30F;  // Duración de la pantalla negra en segundos (20 frames a 66.67fps)
        static constexpr float GAME_OVER_THRESHOLD = 0.255F;   // Tiempo antes del game over en segundos (17 frames a 66.67fps)
        static constexpr float DEMO_ROOM_DURATION = 6.0F;      // Duración de cada habitación en modo demo en segundos (400 frames)
        static constexpr float JAIL_RESTORE_INTERVAL = 1.5F;   // Intervalo de restauración de vidas en la Jail en segundos (100 frames)

        // Estructuras
        struct DemoData {
                float time_accumulator;          // Acumulador de tiempo para el modo demo
                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()
                    : time_accumulator(0.0F),
                      room_index(0),
                      rooms({}) {}

                // Constructor parametrizado
                DemoData(float time_accumulator, int room_index, const std::vector<std::string>& rooms)
                    : time_accumulator(time_accumulator),
                      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
        DeltaTimer delta_timer_;          // Timer para calcular delta time
        std::string current_room_;        // Fichero de la habitación actual
        Player::SpawnData spawn_data_;    // 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
        float black_screen_time_ = 0.0F;  // Tiempo acumulado en pantalla negra en segundos
        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
        float jail_restore_time_ = 0.0F;  // Tiempo acumulado para restauración de vidas en la Jail

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

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

        // 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 Player::SpawnData& 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(float delta_time);

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

        // Destructor
        ~Game();

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