segon commit

source/core/system/debug.cpp

@@ -0,0 +1,189 @@
+#include "core/system/debug.hpp"
+
+#ifdef _DEBUG
+
+#include <algorithm>  // Para max
+#include <fstream>    // Para ifstream, ofstream
+#include <memory>     // Para __shared_ptr_access, shared_ptr
+
+#include "core/rendering/text.hpp"            // Para Text
+#include "core/resources/resource_cache.hpp"  // Para Resource
+#include "external/fkyaml_node.hpp"           // Para fkyaml::node
+#include "game/defaults.hpp"                  // Para Defaults::Game::*
+#include "utils/defines.hpp"                  // Para Tile::SIZE
+#include "utils/utils.hpp"                    // Para Color, Flip::
+
+// [SINGLETON]
+Debug* Debug::debug = nullptr;
+
+// [SINGLETON] Crearemos el objeto con esta función estática
+void Debug::init() {
+    Debug::debug = new Debug();
+}
+
+// [SINGLETON] Destruiremos el objeto con esta función estática
+void Debug::destroy() {
+    delete Debug::debug;
+}
+
+// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
+auto Debug::get() -> Debug* {
+    return Debug::debug;
+}
+
+// Dibuja en pantalla
+void Debug::render() {  // NOLINT(readability-make-member-function-const)
+    auto text = Resource::Cache::get()->getText("aseprite");
+    int y = y_;
+    int w = 0;
+    constexpr int DESP_Y = 7;
+    const int CHAR_SIZE = text->getCharacterSize();
+
+    // Watch window: valores persistentes (key: value)
+    for (const auto& [key, value] : watches_) {
+        const std::string LINE = key + ": " + value;
+        text->write(x_, y, LINE);
+        w = std::max(w, text->length(LINE));
+        y += DESP_Y;
+        if (y > 192 - CHAR_SIZE) {
+            y = y_;
+            x_ += w + 2;
+            w = 0;
+        }
+    }
+
+    // Slot one-shot: mensajes de un solo frame
+    for (const auto& s : slot_) {
+        text->write(x_, y, s);
+        w = std::max(w, text->length(s));
+        y += DESP_Y;
+        if (y > 192 - CHAR_SIZE) {
+            y = y_;
+            x_ += w + 2;
+            w = 0;
+        }
+    }
+
+    y = 0;
+    for (const auto& l : log_) {
+        text->writeColored(x_ + 10, y, l, static_cast<Uint8>(PaletteColor::WHITE));
+        y += CHAR_SIZE + 1;
+    }
+}
+
+// Establece/actualiza un valor persistente en el watch window
+void Debug::set(const std::string& key, const std::string& value) {
+    watches_[key] = value;
+}
+
+// Elimina un valor del watch window
+void Debug::unset(const std::string& key) {
+    watches_.erase(key);
+}
+
+// Establece la posición donde se colocará la información de debug
+void Debug::setPos(SDL_FPoint p) {
+    x_ = p.x;
+    y_ = p.y;
+}
+
+// Establece la ruta del archivo debug.yaml
+void Debug::setDebugFile(const std::string& path) {
+    debug_file_path_ = path;
+}
+
+// Convierte string a SceneManager::Scene (para debug.yaml)
+static auto sceneFromString(const std::string& s) -> SceneManager::Scene {
+    if (s == "LOGO") { return SceneManager::Scene::LOGO; }
+    if (s == "LOADING") { return SceneManager::Scene::LOADING_SCREEN; }
+    if (s == "TITLE") { return SceneManager::Scene::TITLE; }
+    if (s == "CREDITS") { return SceneManager::Scene::CREDITS; }
+    if (s == "DEMO") { return SceneManager::Scene::DEMO; }
+    if (s == "ENDING") { return SceneManager::Scene::ENDING; }
+    if (s == "ENDING2") { return SceneManager::Scene::ENDING2; }
+    return SceneManager::Scene::GAME;  // Fallback seguro
+}
+
+// Convierte SceneManager::Scene a string (para debug.yaml)
+static auto sceneToString(SceneManager::Scene scene) -> std::string {
+    switch (scene) {
+        case SceneManager::Scene::LOGO:
+            return "LOGO";
+        case SceneManager::Scene::LOADING_SCREEN:
+            return "LOADING";
+        case SceneManager::Scene::TITLE:
+            return "TITLE";
+        case SceneManager::Scene::CREDITS:
+            return "CREDITS";
+        case SceneManager::Scene::DEMO:
+            return "DEMO";
+        case SceneManager::Scene::ENDING:
+            return "ENDING";
+        case SceneManager::Scene::ENDING2:
+            return "ENDING2";
+        default:
+            return "GAME";
+    }
+}
+
+// Carga la configuración de debug desde debug.yaml
+void Debug::loadFromFile() {
+    // Inicializar con valores de release por defecto
+    spawn_settings_.room = Defaults::Game::Room::INITIAL;
+    spawn_settings_.spawn_x = Defaults::Game::Player::SPAWN_X;
+    spawn_settings_.spawn_y = Defaults::Game::Player::SPAWN_Y;
+    spawn_settings_.flip = Defaults::Game::Player::SPAWN_FLIP;
+    initial_scene_ = SceneManager::Scene::GAME;
+
+    std::ifstream file(debug_file_path_);
+    if (!file.good()) {
+        saveToFile();  // No existe: crear con valores por defecto
+        return;
+    }
+
+    std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+    file.close();
+
+    try {
+        auto yaml = fkyaml::node::deserialize(content);
+        if (yaml.contains("room")) {
+            spawn_settings_.room = yaml["room"].get_value<std::string>();
+        }
+        if (yaml.contains("spawn_x")) {
+            spawn_settings_.spawn_x = yaml["spawn_x"].get_value<int>() * Tile::SIZE;
+        }
+        if (yaml.contains("spawn_y")) {
+            spawn_settings_.spawn_y = yaml["spawn_y"].get_value<int>() * Tile::SIZE;
+        }
+        if (yaml.contains("spawn_flip")) {
+            auto s = yaml["spawn_flip"].get_value<std::string>();
+            spawn_settings_.flip = (s == "right") ? Flip::RIGHT : Flip::LEFT;
+        }
+        if (yaml.contains("initial_scene")) {
+            initial_scene_ = sceneFromString(yaml["initial_scene"].get_value<std::string>());
+        }
+    } catch (...) {
+        // YAML inválido: resetear a defaults y sobreescribir
+        spawn_settings_.room = Defaults::Game::Room::INITIAL;
+        spawn_settings_.spawn_x = Defaults::Game::Player::SPAWN_X;
+        spawn_settings_.spawn_y = Defaults::Game::Player::SPAWN_Y;
+        spawn_settings_.flip = Defaults::Game::Player::SPAWN_FLIP;
+        initial_scene_ = SceneManager::Scene::GAME;
+        saveToFile();
+    }
+}
+
+// Guarda la configuración de debug en debug.yaml
+void Debug::saveToFile() const {
+    std::ofstream file(debug_file_path_);
+    if (!file.is_open()) { return; }
+    file << "# Projecte 2026 - Debug Configuration\n";
+    file << "# Edita para cambiar la habitacion y spawn del jugador en builds debug.\n\n";
+    file << "room: \"" << spawn_settings_.room << "\"\n";
+    file << "spawn_x: " << (spawn_settings_.spawn_x / Tile::SIZE) << "  # en tiles\n";
+    file << "spawn_y: " << (spawn_settings_.spawn_y / Tile::SIZE) << "  # en tiles\n";
+    file << "spawn_flip: " << ((spawn_settings_.flip == Flip::RIGHT) ? "right" : "left") << "\n";
+    file << "initial_scene: " << sceneToString(initial_scene_) << "\n";
+}
+
+#endif  // _DEBUG

source/core/system/debug.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#ifdef _DEBUG
+
+#include <SDL3/SDL.h>
+
+#include <map>     // Para map
+#include <string>  // Para string
+#include <vector>  // Para vector
+
+#include "game/scene_manager.hpp"  // Para SceneManager::Scene
+
+// Clase Debug
+class Debug {
+   public:
+    struct SpawnSettings {
+        std::string room;
+        int spawn_x = 0;
+        int spawn_y = 0;
+        SDL_FlipMode flip = SDL_FLIP_NONE;
+    };
+
+    static void init();           // [SINGLETON] Crearemos el objeto con esta función estática
+    static void destroy();        // [SINGLETON] Destruiremos el objeto con esta función estática
+    static auto get() -> Debug*;  // [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
+
+    void render();  // Dibuja en pantalla
+
+    void setPos(SDL_FPoint p);  // Establece la posición donde se colocará la información de debug
+
+    [[nodiscard]] auto isEnabled() const -> bool { return enabled_; }  // Obtiene si el debug está activo
+
+    void add(const std::string& text) { slot_.push_back(text); }      // Añade texto one-shot al slot (se limpia cada frame)
+    void clear() { slot_.clear(); }                                   // Limpia el slot one-shot (no afecta a watches)
+    void addToLog(const std::string& text) { log_.push_back(text); }  // Añade texto al log
+    void clearLog() { log_.clear(); }                                 // Limpia el log
+    void set(const std::string& key, const std::string& value);       // Establece/actualiza un valor persistente en el watch window
+    void unset(const std::string& key);                               // Elimina un valor del watch window
+    void clearWatches() { watches_.clear(); }                         // Limpia todos los watches
+    void setEnabled(bool value) { enabled_ = value; }                 // Establece si el debug está activo
+    void toggleEnabled() { enabled_ = !enabled_; }                    // Alterna el estado del debug
+
+    void setDebugFile(const std::string& path);                                                      // Establece la ruta del archivo debug.yaml
+    void loadFromFile();                                                                             // Carga la configuración de debug desde debug.yaml
+    void saveToFile() const;                                                                         // Guarda la configuración de debug en debug.yaml
+    [[nodiscard]] auto getSpawnSettings() const -> const SpawnSettings& { return spawn_settings_; }  // Obtiene los valores de spawn
+    void setSpawnSettings(const SpawnSettings& s) { spawn_settings_ = s; }                           // Establece los valores de spawn
+    [[nodiscard]] auto getInitialScene() const -> SceneManager::Scene { return initial_scene_; }     // Obtiene la escena inicial de debug
+    void setInitialScene(SceneManager::Scene s) { initial_scene_ = s; }                              // Establece la escena inicial de debug
+
+   private:
+    static Debug* debug;  // [SINGLETON] Objeto privado
+
+    Debug() = default;   // Constructor
+    ~Debug() = default;  // Destructor
+
+    // Variables
+    std::map<std::string, std::string> watches_;                     // Watch window: valores persistentes (key→value)
+    std::vector<std::string> slot_;                                  // One-shot: textos que se limpian cada frame
+    std::vector<std::string> log_;                                   // Log persistente
+    int x_ = 0;                                                      // Posicion donde escribir el texto de debug
+    int y_ = 0;                                                      // Posición donde escribir el texto de debug
+    bool enabled_ = false;                                           // Indica si esta activo el modo debug
+    std::string debug_file_path_;                                    // Ruta del archivo debug.yaml
+    SpawnSettings spawn_settings_;                                   // Configuración de spawn para debug
+    SceneManager::Scene initial_scene_ = SceneManager::Scene::GAME;  // Escena inicial en debug
+};
+
+#endif  // _DEBUG

source/core/system/director.cpp

@@ -0,0 +1,428 @@
+#include "core/system/director.hpp"
+
+#include <SDL3/SDL.h>
+#include <sys/stat.h>  // Para mkdir, stat, S_IRWXU
+#include <unistd.h>    // Para getuid
+
+#include <cerrno>    // Para errno, EEXIST, EACCES, ENAMETOO...
+#include <cstdio>    // Para printf, perror
+#include <cstdlib>   // Para exit, EXIT_FAILURE, srand
+#include <iostream>  // Para basic_ostream, operator<<, cout
+#include <memory>    // Para make_unique, unique_ptr
+#include <string>    // Para operator+, allocator, char_traits
+
+#include "core/audio/audio.hpp"                // Para Audio
+#include "core/input/input.hpp"                // Para Input, InputAction
+#include "core/locale/locale.hpp"              // Para Locale
+#include "core/rendering/render_info.hpp"      // Para RenderInfo
+#include "core/rendering/screen.hpp"           // Para Screen
+#include "core/resources/resource_cache.hpp"   // Para Resource
+#include "core/resources/resource_helper.hpp"  // Para ResourceHelper
+#include "core/resources/resource_list.hpp"    // Para Asset, AssetType
+#include "core/resources/resource_loader.hpp"  // Para ResourceLoader
+#include "game/gameplay/cheevos.hpp"           // Para Cheevos
+#include "game/options.hpp"                    // Para Options, options, OptionsVideo
+#include "game/scene_manager.hpp"              // Para SceneManager
+#include "game/scenes/credits.hpp"             // Para Credits
+#include "game/scenes/ending.hpp"              // Para Ending
+#include "game/scenes/ending2.hpp"             // Para Ending2
+#include "game/scenes/game.hpp"                // Para Game, GameMode
+#include "game/scenes/game_over.hpp"           // Para GameOver
+#include "game/scenes/loading_screen.hpp"      // Para LoadingScreen
+#include "game/scenes/logo.hpp"                // Para Logo
+#include "game/scenes/title.hpp"               // Para Title
+#include "game/ui/console.hpp"                 // Para Console
+#include "game/ui/notifier.hpp"                // Para Notifier
+#include "utils/defines.hpp"                   // Para WINDOW_CAPTION
+
+#ifdef _DEBUG
+#include "core/system/debug.hpp"       // Para Debug
+#include "game/editor/map_editor.hpp"  // Para MapEditor
+#endif
+
+#ifndef _WIN32
+#include <pwd.h>
+#endif
+
+// Constructor
+Director::Director() {
+    std::cout << "Game start" << '\n';
+
+    // Obtiene la ruta del ejecutable
+    std::string base = SDL_GetBasePath();
+    if (!base.empty() && base.back() == '/') {
+        base.pop_back();
+    }
+    executable_path_ = base;
+
+    // Crea la carpeta del sistema donde guardar datos
+    createSystemFolder("jailgames");
+    createSystemFolder("jailgames/projecte_2026");
+
+    // Crea el subdirectorio shaders/ dentro de system_folder_ sin modificar system_folder_
+    {
+        std::string shaders_dir = system_folder_ + "/shaders";
+        struct stat st = {.st_dev = 0};
+        if (stat(shaders_dir.c_str(), &st) == -1) {
+            errno = 0;
+#ifdef _WIN32
+            mkdir(shaders_dir.c_str());
+#else
+            mkdir(shaders_dir.c_str(), S_IRWXU);
+#endif
+        }
+    }
+
+    // Determinar el prefijo de ruta según la plataforma
+#ifdef MACOS_BUNDLE
+    const std::string PREFIX = "/../Resources";
+#else
+    const std::string PREFIX;
+#endif
+
+    // Preparar ruta al pack (en macOS bundle está en Contents/Resources/)
+    std::string pack_path = executable_path_ + PREFIX + "/resources.pack";
+
+#ifdef RELEASE_BUILD
+    // ============================================================
+    // RELEASE BUILD: Pack-first architecture
+    // ============================================================
+    std::cout << "\n** RELEASE MODE: Pack-first initialization\n";
+
+    // 1. Initialize resource pack system (required, no fallback)
+    std::cout << "Initializing resource pack: " << pack_path << '\n';
+    if (!Resource::Helper::initializeResourceSystem(pack_path, false)) {
+        std::cerr << "ERROR: Failed to load resources.pack (required in release builds)\n";
+        exit(EXIT_FAILURE);
+    }
+
+    // 2. Validate pack integrity
+    std::cout << "Validating pack integrity..." << '\n';
+    if (!Resource::Loader::get().validatePack()) {
+        std::cerr << "ERROR: Pack validation failed\n";
+        exit(EXIT_FAILURE);
+    }
+
+    // 3. Load assets.yaml from pack
+    std::cout << "Loading assets configuration from pack..." << '\n';
+    std::string assets_config = Resource::Loader::get().loadAssetsConfig();
+    if (assets_config.empty()) {
+        std::cerr << "ERROR: Failed to load assets.yaml from pack\n";
+        exit(EXIT_FAILURE);
+    }
+
+    // 4. Initialize Asset system with config from pack
+    // NOTE: In release, don't use executable_path or PREFIX - paths in pack are relative
+    // Pass empty string to avoid issues when running from different directories
+    Resource::List::init("");                                                  // Empty executable_path in release
+    Resource::List::get()->loadFromString(assets_config, "", system_folder_);  // Empty PREFIX for pack
+    std::cout << "Asset system initialized from pack\n";
+
+#else
+    // ============================================================
+    // DEVELOPMENT BUILD: Filesystem-first architecture
+    // ============================================================
+    std::cout << "\n** DEVELOPMENT MODE: Filesystem-first initialization\n";
+
+    // 1. Initialize Asset system from filesystem
+    Resource::List::init(executable_path_);
+
+    // 2. Load asset configuration from disk
+    // Note: Asset verification happens during Resource::Cache::load()
+    setFileList();
+
+    // 3. Initialize resource pack system (optional, with fallback)
+    std::cout << "Initializing resource pack (development mode): " << pack_path << '\n';
+    Resource::Helper::initializeResourceSystem(pack_path, true);
+
+#endif
+
+    // Configura la ruta y carga las opciones desde un fichero
+    Options::setConfigFile(Resource::List::get()->get("config.yaml"));  // NOLINT(readability-static-accessed-through-instance)
+    Options::loadFromFile();
+
+    // Configura la ruta y carga los presets de PostFX
+    Options::setPostFXFile(Resource::List::get()->get("postfx.yaml"));  // NOLINT(readability-static-accessed-through-instance)
+    Options::loadPostFXFromFile();
+
+    // Configura la ruta y carga los presets del shader CrtPi
+    Options::setCrtPiFile(Resource::List::get()->get("crtpi.yaml"));  // NOLINT(readability-static-accessed-through-instance)
+    Options::loadCrtPiFromFile();
+
+    // En mode quiosc, forçar pantalla completa independentment de la configuració
+    if (Options::kiosk.enabled) {
+        Options::video.fullscreen = true;
+    }
+
+    // Inicializa JailAudio
+    Audio::init();
+
+    // Crea los objetos
+    Screen::init();
+
+    // Initialize resources (works for both release and development)
+    Resource::Cache::init();
+    Notifier::init("", "8bithud");
+    RenderInfo::init();
+    Console::init("8bithud");
+    Screen::get()->setNotificationsEnabled(true);
+
+    // Special handling for gamecontrollerdb.txt - SDL needs filesystem path
+#ifdef RELEASE_BUILD
+    // In release, construct the path manually (not from Asset which has empty executable_path)
+    std::string gamecontroller_db = executable_path_ + PREFIX + "/gamecontrollerdb.txt";
+    Input::init(gamecontroller_db);
+#else
+    // In development, use Asset as normal
+    Input::init(Resource::List::get()->get("gamecontrollerdb.txt"));  // NOLINT(readability-static-accessed-through-instance) Carga configuración de controles
+#endif
+
+    // Aplica las teclas y botones del gamepad configurados desde Options
+    Input::get()->applyKeyboardBindingsFromOptions();
+    Input::get()->applyGamepadBindingsFromOptions();
+
+#ifdef _DEBUG
+    Debug::init();
+    Debug::get()->setDebugFile(Resource::List::get()->get("debug.yaml"));
+    Debug::get()->loadFromFile();
+    SceneManager::current = Debug::get()->getInitialScene();
+    MapEditor::init();
+#endif
+
+    std::cout << "\n";  // Fin de inicialización de sistemas
+
+    // Inicializa el sistema de localización (antes de Cheevos que usa textos traducidos)
+#ifdef RELEASE_BUILD
+    {
+        // En release el locale está en el pack, no en el filesystem
+        std::string locale_key = Resource::List::get()->get(Options::language + ".yaml");  // NOLINT(readability-static-accessed-through-instance)
+        auto locale_bytes = Resource::Helper::loadFile(locale_key);
+        std::string locale_content(locale_bytes.begin(), locale_bytes.end());
+        Locale::initFromContent(locale_content);
+    }
+#else
+    Locale::init(Resource::List::get()->get(Options::language + ".yaml"));  // NOLINT(readability-static-accessed-through-instance)
+#endif
+
+    // Special handling for cheevos.bin - also needs filesystem path
+#ifdef RELEASE_BUILD
+    std::string cheevos_path = system_folder_ + "/cheevos.bin";
+    Cheevos::init(cheevos_path);
+#else
+    Cheevos::init(Resource::List::get()->get("cheevos.bin"));
+#endif
+}
+
+Director::~Director() {
+    // Guarda las opciones a un fichero
+    Options::saveToFile();
+
+    // Destruye los singletones
+    Cheevos::destroy();
+    Locale::destroy();
+#ifdef _DEBUG
+    MapEditor::destroy();
+    Debug::destroy();
+#endif
+    Input::destroy();
+    Console::destroy();
+    RenderInfo::destroy();
+    Notifier::destroy();
+    Resource::Cache::destroy();
+    Resource::Helper::shutdownResourceSystem();  // Shutdown resource pack system
+    Audio::destroy();
+    Screen::destroy();
+    Resource::List::destroy();
+
+    SDL_Quit();
+
+    std::cout << "\nBye!" << '\n';
+}
+
+// Crea la carpeta del sistema donde guardar datos
+void Director::createSystemFolder(const std::string& folder) {  // NOLINT(readability-convert-member-functions-to-static)
+#ifdef _WIN32
+    system_folder_ = std::string(getenv("APPDATA")) + "/" + folder;
+#elif __APPLE__
+    struct passwd* pw = getpwuid(getuid());
+    const char* homedir = pw->pw_dir;
+    system_folder_ = std::string(homedir) + "/Library/Application Support" + "/" + folder;
+#elif __linux__
+    struct passwd* pw = getpwuid(getuid());
+    const char* homedir = pw->pw_dir;
+    system_folder_ = std::string(homedir) + "/.config/" + folder;
+
+    {
+        // Intenta crear ".config", per si no existeix
+        std::string config_base_folder = std::string(homedir) + "/.config";
+        int ret = mkdir(config_base_folder.c_str(), S_IRWXU);
+        if (ret == -1 && errno != EEXIST) {
+            printf("ERROR CREATING CONFIG BASE FOLDER.");
+            exit(EXIT_FAILURE);
+        }
+    }
+#endif
+
+    struct stat st = {.st_dev = 0};
+    if (stat(system_folder_.c_str(), &st) == -1) {
+        errno = 0;
+#ifdef _WIN32
+        int ret = mkdir(system_folder_.c_str());
+#else
+        int ret = mkdir(system_folder_.c_str(), S_IRWXU);
+#endif
+
+        if (ret == -1) {
+            switch (errno) {
+                case EACCES:
+                    printf("the parent directory does not allow write");
+                    exit(EXIT_FAILURE);
+
+                case EEXIST:
+                    printf("pathname already exists");
+                    exit(EXIT_FAILURE);
+
+                case ENAMETOOLONG:
+                    printf("pathname is too long");
+                    exit(EXIT_FAILURE);
+
+                default:
+                    perror("mkdir");
+                    exit(EXIT_FAILURE);
+            }
+        }
+    }
+}
+
+// Carga la configuración de assets desde assets.yaml
+void Director::setFileList() {  // NOLINT(readability-convert-member-functions-to-static)
+    // Determinar el prefijo de ruta según la plataforma
+#ifdef MACOS_BUNDLE
+    const std::string PREFIX = "/../Resources";
+#else
+    const std::string PREFIX;
+#endif
+
+    // Construir ruta al archivo de configuración de assets
+    std::string config_path = executable_path_ + PREFIX + "/config/assets.yaml";
+
+    // Cargar todos los assets desde el archivo de configuración
+    // La verificación de existencia de archivos se realiza durante Resource::Cache::load()
+    Resource::List::get()->loadFromFile(config_path, PREFIX, system_folder_);
+}
+
+// Ejecuta la seccion de juego con el logo
+void Director::runLogo() {
+    auto logo = std::make_unique<Logo>();
+    logo->run();
+}
+
+// Ejecuta la seccion de juego de la pantalla de carga
+void Director::runLoadingScreen() {
+    auto loading_screen = std::make_unique<LoadingScreen>();
+    loading_screen->run();
+}
+
+// Ejecuta la seccion de juego con el titulo y los menus
+void Director::runTitle() {
+    auto title = std::make_unique<Title>();
+    title->run();
+}
+
+// Ejecuta la seccion de los creditos del juego
+void Director::runCredits() {
+    auto credits = std::make_unique<Credits>();
+    credits->run();
+}
+
+// Ejecuta la seccion de la demo, donde se ven pantallas del juego
+void Director::runDemo() {
+    auto game = std::make_unique<Game>(Game::Mode::DEMO);
+    game->run();
+}
+
+// Ejecuta la seccion del final del juego
+void Director::runEnding() {
+    auto ending = std::make_unique<Ending>();
+    ending->run();
+}
+
+// Ejecuta la seccion del final del juego
+void Director::runEnding2() {
+    auto ending2 = std::make_unique<Ending2>();
+    ending2->run();
+}
+
+// Ejecuta la seccion del final de la partida
+void Director::runGameOver() {
+    auto game_over = std::make_unique<GameOver>();
+    game_over->run();
+}
+
+// Ejecuta la seccion de juego donde se juega
+void Director::runGame() {
+    Audio::get()->stopMusic();
+    auto game = std::make_unique<Game>(Game::Mode::GAME);
+    game->run();
+}
+
+auto Director::run() -> int {
+    // Bucle principal
+    while (SceneManager::current != SceneManager::Scene::QUIT) {
+        const SceneManager::Scene ACTIVE = SceneManager::current;
+
+        switch (SceneManager::current) {
+            case SceneManager::Scene::LOGO:
+                runLogo();
+                break;
+
+            case SceneManager::Scene::LOADING_SCREEN:
+                runLoadingScreen();
+                break;
+
+            case SceneManager::Scene::TITLE:
+                runTitle();
+                break;
+
+            case SceneManager::Scene::CREDITS:
+                runCredits();
+                break;
+
+            case SceneManager::Scene::DEMO:
+                runDemo();
+                break;
+
+            case SceneManager::Scene::GAME:
+                runGame();
+                break;
+
+            case SceneManager::Scene::GAME_OVER:
+                runGameOver();
+                break;
+
+            case SceneManager::Scene::ENDING:
+                runEnding();
+                break;
+
+            case SceneManager::Scene::ENDING2:
+                runEnding2();
+                break;
+
+            case SceneManager::Scene::RESTART_CURRENT:
+                // La escena salió por RESTART_CURRENT → relanzar la escena guardada
+                SceneManager::current = SceneManager::scene_before_restart;
+                break;
+
+            default:
+                break;
+        }
+
+        // Si la escena que acaba de correr dejó RESTART_CURRENT pendiente,
+        // restaurar la escena que estaba activa para relanzarla en la próxima iteración
+        if (SceneManager::current == SceneManager::Scene::RESTART_CURRENT) {
+            SceneManager::current = ACTIVE;
+        }
+    }
+
+    return 0;
+}

source/core/system/director.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <string>  // Para string
+
+class Director {
+   public:
+    Director();                // Constructor
+    ~Director();               // Destructor
+    static auto run() -> int;  // Bucle principal
+
+   private:
+    // --- Variables ---
+    std::string executable_path_;  // Path del ejecutable
+    std::string system_folder_;    // Carpeta del sistema donde guardar datos
+
+    // --- Funciones ---
+    void createSystemFolder(const std::string& folder);  // Crea la carpeta del sistema donde guardar datos
+    void setFileList();                                  // Carga la configuración de assets desde assets.yaml
+    static void runLogo();                               // Ejecuta la seccion de juego con el logo
+    static void runLoadingScreen();                      // Ejecuta la seccion de juego de la pantalla de carga
+    static void runTitle();                              // Ejecuta la seccion de juego con el titulo y los menus
+    static void runCredits();                            // Ejecuta la seccion de los creditos del juego
+    static void runDemo();                               // Ejecuta la seccion de la demo, donde se ven pantallas del juego
+    static void runEnding();                             // Ejecuta la seccion del final del juego
+    static void runEnding2();                            // Ejecuta la seccion del final del juego
+    static void runGameOver();                           // Ejecuta la seccion del final de la partida
+    static void runGame();                               // Ejecuta la seccion de juego donde se juega
+};

source/core/system/global_events.cpp

@@ -0,0 +1,31 @@
+#include "core/system/global_events.hpp"
+
+#include "core/input/mouse.hpp"
+#include "game/options.hpp"        // Para Options, options, OptionsGame, OptionsAudio
+#include "game/scene_manager.hpp"  // Para SceneManager
+#include "game/ui/console.hpp"     // Para Console
+
+namespace GlobalEvents {
+    // Comprueba los eventos que se pueden producir en cualquier sección del juego
+    void handle(const SDL_Event& event) {
+        // Evento de salida de la aplicación
+        if (event.type == SDL_EVENT_QUIT) {
+            SceneManager::current = SceneManager::Scene::QUIT;
+            return;
+        }
+
+        if (event.type == SDL_EVENT_RENDER_DEVICE_RESET || event.type == SDL_EVENT_RENDER_TARGETS_RESET) {
+            // reLoadTextures();
+        }
+
+        // Enrutar eventos de texto a la consola cuando está activa
+        if (Console::get() != nullptr && Console::get()->isActive()) {
+            if (event.type == SDL_EVENT_TEXT_INPUT || event.type == SDL_EVENT_KEY_DOWN) {
+                Console::get()->handleEvent(event);
+                return;
+            }
+        }
+
+        Mouse::handleEvent(event);
+    }
+}  // namespace GlobalEvents

source/core/system/global_events.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+namespace GlobalEvents {
+    // Comprueba los eventos que se pueden producir en cualquier sección del juego
+    void handle(const SDL_Event& event);
+}  // namespace GlobalEvents