opcions per amagar la pantalla de carrega

source/core/resources/resource_cache.cpp

@@ -645,14 +645,20 @@ namespace Resource {
 
     // Muestra el progreso de carga
     void Cache::renderProgress() {
+        Screen::get()->start();
+        Screen::get()->clearSurface(static_cast<Uint8>(PaletteColor::BLACK));
+
+        // Si show=false: pantalla negra y salir
+        if (!Options::loading.show) {
+            Screen::get()->render();
+            return;
+        }
+
         constexpr float X_PADDING = 60.0F;
         constexpr float Y_PADDING = 10.0F;
         constexpr float BAR_HEIGHT = 5.0F;
 
         const float BAR_POSITION = Options::game.height - BAR_HEIGHT - Y_PADDING;
-        Screen::get()->start();
-        Screen::get()->clearSurface(static_cast<Uint8>(PaletteColor::BLACK));
-
         auto surface = Screen::get()->getRendererSurface();
         const auto LOADING_TEXT_COLOR = static_cast<Uint8>(PaletteColor::BRIGHT_WHITE);
         const auto BAR_COLOR = static_cast<Uint8>(PaletteColor::WHITE);
@@ -686,13 +692,15 @@ namespace Resource {
         SDL_FRect rect_full = {.x = X_PADDING, .y = BAR_POSITION, .w = FULL_BAR_WIDTH, .h = BAR_HEIGHT};
         surface->fillRect(&rect_full, BAR_COLOR);
 
-        // Mostra el nom del recurs que està a punt de carregar-se, centrat sobre la barra
+        // Mostra el nom del recurs (o missatge d'espera si ja ha acabat i wait_for_input=true)
-        if (!current_loading_name_.empty()) {
+        const bool WAITING_FOR_INPUT = isLoadDone() && Options::loading.wait_for_input;
+        const std::string OVER_BAR_TEXT = WAITING_FOR_INPUT ? "PRESS ANY KEY TO CONTINUE" : current_loading_name_;
+        if ((Options::loading.show_resource_name || WAITING_FOR_INPUT) && !OVER_BAR_TEXT.empty()) {
             const float TEXT_Y = BAR_POSITION - static_cast<float>(TEXT_HEIGHT) - 2.0F;
             loading_text_->writeColored(
-                CENTER_X - (loading_text_->length(current_loading_name_) / 2),
+                CENTER_X - (loading_text_->length(OVER_BAR_TEXT) / 2),
                 static_cast<int>(TEXT_Y),
-                current_loading_name_,
+                OVER_BAR_TEXT,
                 LOADING_TEXT_COLOR);
         }
 

source/core/system/director.cpp

@@ -438,7 +438,11 @@ auto Director::iterate() -> SDL_AppResult {
             // per veure la barra avançar suau i processar events del WM/ESC,
             // i evita el 50% d'ineficiència que provocaria un budget < vsync.
             if (Resource::Cache::get()->loadStep(50 /*ms*/)) {
-                finishBoot();
+                if (Options::loading.show && Options::loading.wait_for_input) {
+                    boot_waiting_for_input_ = true;  // Esperar tecla antes de continuar
+                } else {
+                    finishBoot();
+                }
                 boot_loading_ = false;
                 // finishBoot() ja ha fixat SceneManager::current a LOGO (o la que
                 // digui Debug). El canvi d'escena es fa just a sota.
@@ -472,6 +476,17 @@ auto Director::handleEvent(const SDL_Event& event) -> SDL_AppResult {
     }
 #endif
 
+    // Si estamos esperando input tras la carga: consumir tecla/botón y arrancar
+    if (boot_waiting_for_input_) {
+        const bool IS_KEY = event.type == SDL_EVENT_KEY_DOWN && !event.key.repeat;
+        const bool IS_BUTTON = event.type == SDL_EVENT_GAMEPAD_BUTTON_DOWN;
+        if (IS_KEY || IS_BUTTON) {
+            boot_waiting_for_input_ = false;
+            finishBoot();
+        }
+        return SDL_APP_CONTINUE;
+    }
+
     if (active_scene_) {
         active_scene_->handleEvent(event);
     }

source/core/system/director.hpp

@@ -24,7 +24,8 @@ class Director {
 
     std::unique_ptr<Scene> active_scene_;                                  // Escena activa
     SceneManager::Scene current_scene_{SceneManager::Scene::BOOT_LOADER};  // Tipus d'escena activa
-    bool boot_loading_{true};                                              // True mientras Cache::loadStep() no haya acabado
+    bool boot_loading_{true};                    // True mientras Cache::loadStep() no haya acabado
+    bool boot_waiting_for_input_{false};         // True si la carga acabó y Options::loading.wait_for_input está activo
 
     // --- Funciones ---
     void createSystemFolder(const std::string& folder);  // Crea la carpeta del sistema donde guardar datos

source/game/defaults.hpp

@@ -89,6 +89,12 @@ namespace Defaults::Localization {
     constexpr const char* LANGUAGE = "ca";  // Idioma por defecto (en = inglés, ca = catalán)
 }  // namespace Defaults::Localization
 
+namespace Defaults::Loading {
+    constexpr bool SHOW = false;               // No mostrar la pantalla de carga por defecto
+    constexpr bool SHOW_RESOURCE_NAME = true;  // Mostrar el nombre del recurso por defecto
+    constexpr bool WAIT_FOR_INPUT = false;     // No esperar tecla al terminar por defecto
+}  // namespace Defaults::Loading
+
 namespace Defaults::Game::Items {
     constexpr const float PERCENT_TO_OPEN_THE_JAIL = 0.9F;  // Porcentaje de items necesarios para abrir la jail
 }  // namespace Defaults::Game::Items

source/game/options.cpp

@@ -623,6 +623,21 @@ namespace Options {
         }
     }
 
+    // Carga opciones de la pantalla de carga desde YAML
+    void loadLoadingFromYaml(const fkyaml::node& yaml) {
+        if (!yaml.contains("loading")) { return; }
+        const auto& ld = yaml["loading"];
+        if (ld.contains("show")) {
+            try { loading.show = ld["show"].get_value<bool>(); } catch (...) { loading.show = Defaults::Loading::SHOW; }
+        }
+        if (ld.contains("show_resource_name")) {
+            try { loading.show_resource_name = ld["show_resource_name"].get_value<bool>(); } catch (...) { loading.show_resource_name = Defaults::Loading::SHOW_RESOURCE_NAME; }
+        }
+        if (ld.contains("wait_for_input")) {
+            try { loading.wait_for_input = ld["wait_for_input"].get_value<bool>(); } catch (...) { loading.wait_for_input = Defaults::Loading::WAIT_FOR_INPUT; }
+        }
+    }
+
     // Establece la ruta del fichero de configuración
     void setConfigFile(const std::string& path) {
         config_file_path = path;
@@ -673,6 +688,7 @@ namespace Options {
             loadPlayerConfigFromYaml(yaml);
             loadKioskConfigFromYaml(yaml);
             loadLocalizationFromYaml(yaml);
+            loadLoadingFromYaml(yaml);
 
             std::cout << "Config file loaded successfully\n\n";
 
@@ -810,6 +826,14 @@ namespace Options {
         file << "localization:\n";
         file << "  language: \"" << language << "\"\n";
 
+        // LOADING SCREEN
+        file << "\n";
+        file << "# LOADING SCREEN\n";
+        file << "loading:\n";
+        file << "  show: " << (loading.show ? "true" : "false") << "\n";
+        file << "  show_resource_name: " << (loading.show_resource_name ? "true" : "false") << "\n";
+        file << "  wait_for_input: " << (loading.wait_for_input ? "true" : "false") << " # solo si show=true\n";
+
         file.close();
 
         std::cout << "Config file saved successfully\n\n";

source/game/options.hpp

@@ -134,6 +134,13 @@ namespace Options {
         float volume{Defaults::Audio::VOLUME};   // Volumen al que suenan el audio (0-128 internamente)
     };
 
+    // Estructura para las opciones de la pantalla de carga
+    struct Loading {
+        bool show{Defaults::Loading::SHOW};                              // Muestra la pantalla de carga (si no, pantalla en negro)
+        bool show_resource_name{Defaults::Loading::SHOW_RESOURCE_NAME};  // Muestra el nombre del recurso sobre la barra de progreso
+        bool wait_for_input{Defaults::Loading::WAIT_FOR_INPUT};          // Al terminar la carga, espera tecla antes de continuar (solo si show=true)
+    };
+
     // Estructura para las opciones de juego
     struct Game {
         float width{Defaults::Canvas::WIDTH};                   // Ancho de la resolucion del juego
@@ -182,6 +189,7 @@ namespace Options {
     inline Stats stats{};                         // Datos con las estadisticas de juego
     inline Window window{};                       // Opciones relativas a la ventana
     inline Audio audio{};                         // Opciones relativas al audio
+    inline Loading loading{};                     // Opciones de la pantalla de carga
     inline KeyboardControls keyboard_controls{};  // Teclas usadas para jugar
     inline GamepadControls gamepad_controls{};    // Botones del gamepad usados para jugar
     inline Kiosk kiosk{};                         // Opciones del modo kiosko