treballant en la pantalla de càrrega de recursos

source/core/audio/audio.cpp

@@ -134,19 +134,19 @@ auto Audio::getRealMusicState() -> MusicState {
 }
 
 // Establece el volumen de los sonidos
-void Audio::setSoundVolume(int sound_volume, Group group) const {
+void Audio::setSoundVolume(float sound_volume, Group group) const {
     if (sound_enabled_) {
         sound_volume = std::clamp(sound_volume, MIN_VOLUME, MAX_VOLUME);
-        const float CONVERTED_VOLUME = (sound_volume / 100.0F) * (Options::audio.volume / 100.0F);
+        const float CONVERTED_VOLUME = sound_volume * Options::audio.volume;
         JA_SetSoundVolume(CONVERTED_VOLUME, static_cast<int>(group));
     }
 }
 
 // Establece el volumen de la música
-void Audio::setMusicVolume(int music_volume) const {
+void Audio::setMusicVolume(float music_volume) const {
     if (music_enabled_) {
         music_volume = std::clamp(music_volume, MIN_VOLUME, MAX_VOLUME);
-        const float CONVERTED_VOLUME = (music_volume / 100.0F) * (Options::audio.volume / 100.0F);
+        const float CONVERTED_VOLUME = music_volume * Options::audio.volume;
         JA_SetMusicVolume(CONVERTED_VOLUME);
     }
 }

source/core/audio/audio.hpp

@@ -20,9 +20,9 @@ class Audio {
         };
 
         // --- Constantes ---
-        static constexpr int MAX_VOLUME = 100;   // Volumen máximo
-        static constexpr int MIN_VOLUME = 0;     // Volumen mínimo
-        static constexpr int FREQUENCY = 48000;  // Frecuencia de audio
+        static constexpr float MAX_VOLUME = 1.0F;  // Volumen máximo
+        static constexpr float MIN_VOLUME = 0.0F;  // Volumen mínimo
+        static constexpr int FREQUENCY = 48000;    // Frecuencia de audio
 
         // --- Métodos de singleton ---
         static void init();                               // Inicializa el objeto Audio
@@ -42,9 +42,9 @@ class Audio {
         void fadeOutMusic(int milliseconds) const;               // Fundido de salida de la música
 
         // --- Control de Sonidos ---
-        void playSound(const std::string& name, Group group = Group::GAME) const;    // Reproducir sonido puntual por nombre
+        void playSound(const std::string& name, Group group = Group::GAME) const;   // Reproducir sonido puntual por nombre
         void playSound(struct JA_Sound_t* sound, Group group = Group::GAME) const;  // Reproducir sonido puntual por puntero
-        void stopAllSounds() const;                                                  // Detener todos los sonidos
+        void stopAllSounds() const;                                                 // Detener todos los sonidos
 
         // --- Configuración General ---
         void enable(bool value);                        // Establecer estado general
@@ -64,8 +64,8 @@ class Audio {
         void toggleMusic() { music_enabled_ = !music_enabled_; }  // Alternar estado de música
 
         // --- Control de Volumen ---
-        void setSoundVolume(int volume, Group group = Group::ALL) const;  // Ajustar volumen de efectos
-        void setMusicVolume(int volume) const;                            // Ajustar volumen de música
+        void setSoundVolume(float volume, Group group = Group::ALL) const;  // Ajustar volumen de efectos
+        void setMusicVolume(float volume) const;                            // Ajustar volumen de música
 
         // --- Getters para debug ---
         [[nodiscard]] auto isEnabled() const -> bool { return enabled_; }
@@ -78,14 +78,12 @@ class Audio {
     private:
         // --- Estructuras privadas ---
         struct Music {
-                MusicState state;  // Estado actual de la música (reproduciendo, detenido, en pausa)
-                std::string name;  // Última pista de música reproducida
-                bool loop;         // Indica si la última pista de música se debe reproducir en bucle
+                MusicState state{MusicState::STOPPED};  // Estado actual de la música (reproduciendo, detenido, en pausa)
+                std::string name;                       // Última pista de música reproducida
+                bool loop{false};                       // Indica si la última pista de música se debe reproducir en bucle
 
                 // Constructor para inicializar la música con valores predeterminados
-                Music()
-                    : state(MusicState::STOPPED),
-                      loop(false) {}
+                Music() = default;
 
                 // Constructor para inicializar con valores específicos
                 Music(MusicState init_state, std::string init_name, bool init_loop)

source/core/rendering/screen.cpp

@@ -90,6 +90,9 @@ Screen::Screen()
     // Establece la surface que actuará como renderer para recibir las llamadas a render()
     renderer_surface_ = std::make_shared<std::shared_ptr<Surface>>(game_surface_);
 
+    // Crea el objeto de texto para la pantalla de carga
+    createText();
+
     // Extrae el nombre de las paletas desde su ruta
     processPaletteList();
 
@@ -574,4 +577,13 @@ auto Screen::initSDLVideo() -> bool {
 
     std::cout << "** Video system initialized successfully\n";
     return true;
+}
+
+// Crea el objeto de texto
+void Screen::createText() {
+    // Carga la surface de la fuente directamente del archivo
+    auto surface = std::make_shared<Surface>(Asset::get()->get("aseprite.gif"));
+
+    // Crea el objeto de texto (el constructor de Text carga el archivo text_file internamente)
+    text_ = std::make_shared<Text>(surface, Asset::get()->get("aseprite.txt"));
 }

source/core/rendering/screen.hpp

@@ -9,6 +9,7 @@
 
 #include "utils/utils.hpp"  // Para Color
 class Surface;
+class Text;
 namespace Rendering {
 class ShaderBackend;
 }
@@ -70,6 +71,7 @@ class Screen {
         std::shared_ptr<Surface> border_surface_;                     // Surface para pintar el el borde de la pantalla
         std::shared_ptr<std::shared_ptr<Surface>> renderer_surface_;  // Puntero a la Surface que actua
         std::unique_ptr<Rendering::ShaderBackend> shader_backend_;    // Backend de shaders (OpenGL/Metal/Vulkan)
+        std::shared_ptr<Text> text_;                                  // Objeto para escribir texto en pantalla de carga
 
         // Variables
         int window_width_;                    // Ancho de la pantalla o ventana
@@ -120,6 +122,7 @@ class Screen {
         void renderInfo();            // Muestra información por pantalla
         void getDisplayInfo();        // Obtiene información sobre la pantalla
         auto initSDLVideo() -> bool;  // Arranca SDL VIDEO y crea la ventana
+        void createText();            // Crea el objeto de texto
 
         // Constructor
         Screen();
@@ -212,4 +215,5 @@ class Screen {
         auto getRenderer() -> SDL_Renderer*;
         auto getRendererSurface() -> std::shared_ptr<Surface>;
         auto getBorderSurface() -> std::shared_ptr<Surface>;
+        [[nodiscard]] auto getText() const -> std::shared_ptr<Text> { return text_; }
 };

source/core/resources/resource.cpp

@@ -15,7 +15,10 @@
 #include "external/jail_audio.h"          // Para JA_DeleteMusic, JA_DeleteSound, JA_Loa...
 #include "game/gameplay/room.hpp"         // Para RoomData, loadRoomFile, loadRoomTileFile
 #include "game/options.hpp"               // Para Options, OptionsGame, options
+#include "game/defaults.hpp"              // Para GameDefaults::VERSION
+#include "utils/defines.hpp"              // Para WINDOW_CAPTION
 #include "utils/utils.hpp"                // Para getFileName, printWithDots, PaletteColor
+#include "version.h"                      // Para Version::GIT_HASH
 struct JA_Music_t;                    // lines 17-17
 struct JA_Sound_t;                    // lines 18-18
 
@@ -32,7 +35,10 @@ void Resource::destroy() { delete Resource::resource; }
 auto Resource::get() -> Resource* { return Resource::resource; }
 
 // Constructor
-Resource::Resource() { load(); }
+Resource::Resource() {
+    loading_text_ = Screen::get()->getText();
+    load();
+}
 
 // Vacia todos los vectores de recursos
 void Resource::clear() {
@@ -341,7 +347,7 @@ void Resource::createText() {
     std::cout << "\n>> CREATING TEXT_OBJECTS" << '\n';
 
     std::vector<ResourceInfo> resources = {
-        {"debug", "debug.gif", "debug.txt"},
+        {"aseprite", "aseprite.gif", "aseprite.txt"},
         {"gauntlet", "gauntlet.gif", "gauntlet.txt"},
         {"smb2", "smb2.gif", "smb2.txt"},
         {"subatomic", "subatomic.gif", "subatomic.txt"},
@@ -408,13 +414,36 @@ void Resource::renderProgress() {
     Screen::get()->clearSurface(static_cast<Uint8>(PaletteColor::BLACK));
 
     auto surface = Screen::get()->getRendererSurface();
+    const Uint8 TEXT_COLOR = static_cast<Uint8>(PaletteColor::WHITE);
+    const int TEXT_HEIGHT = loading_text_->getCharacterSize();
+    const int CENTER_X = Options::game.width / 2;
+    const int CENTER_Y = Options::game.height / 2;
+
+    // Draw APP_NAME centered above center
+    const std::string APP_NAME = WINDOW_CAPTION;
+    loading_text_->writeColored(
+        CENTER_X - (loading_text_->lenght(APP_NAME) / 2),
+        CENTER_Y - TEXT_HEIGHT,
+        APP_NAME,
+        TEXT_COLOR);
+
+    // Draw VERSION centered below center
+    const std::string VERSION_TEXT = "(" + std::string(Version::GIT_HASH) + ")";
+    loading_text_->writeColored(
+        CENTER_X - (loading_text_->lenght(VERSION_TEXT) / 2),
+        CENTER_Y + TEXT_HEIGHT,
+        VERSION_TEXT,
+        TEXT_COLOR);
+
+    // Draw progress bar border
     const float WIRED_BAR_WIDTH = Options::game.width - (X_PADDING * 2);
     SDL_FRect rect_wired = {X_PADDING, BAR_POSITION, WIRED_BAR_WIDTH, X_PADDING};
-    surface->drawRectBorder(&rect_wired, static_cast<Uint8>(PaletteColor::WHITE));
+    surface->drawRectBorder(&rect_wired, TEXT_COLOR);
 
+    // Draw progress bar fill
     const float FULL_BAR_WIDTH = WIRED_BAR_WIDTH * count_.getPercentage();
     SDL_FRect rect_full = {X_PADDING, BAR_POSITION, FULL_BAR_WIDTH, X_PADDING};
-    surface->fillRect(&rect_full, static_cast<Uint8>(PaletteColor::WHITE));
+    surface->fillRect(&rect_full, TEXT_COLOR);
 
     Screen::get()->render();
 }

source/core/resources/resource.hpp

@@ -152,7 +152,8 @@ class Resource {
         std::vector<ResourceTileMap> tile_maps_;     // Vector con los mapas de tiles
         std::vector<ResourceRoom> rooms_;            // Vector con las habitaciones
 
-        ResourceCount count_;  // Contador de recursos
+        ResourceCount count_;              // Contador de recursos
+        std::shared_ptr<Text> loading_text_;  // Texto para la pantalla de carga
 
         // Carga los sonidos
         void loadSounds();

source/game/defaults.hpp

@@ -27,13 +27,13 @@ constexpr int WINDOW_ZOOM = 2;  // Zoom de la ventana por defecto
 // =============================================================================
 // VIDEO
 // =============================================================================
-constexpr bool VIDEO_MODE = false;                           // Modo de pantalla completa por defecto (false = ventana)
+constexpr bool VIDEO_MODE = false;                            // Modo de pantalla completa por defecto (false = ventana)
 constexpr ScreenFilter VIDEO_FILTER = ScreenFilter::NEAREST;  // Filtro por defecto
-constexpr bool VIDEO_VERTICAL_SYNC = true;                   // Vsync activado por defecto
-constexpr bool VIDEO_SHADERS = false;                        // Shaders desactivados por defecto
-constexpr bool VIDEO_INTEGER_SCALE = true;                   // Escalado entero activado por defecto
-constexpr bool VIDEO_KEEP_ASPECT = true;                     // Mantener aspecto activado por defecto
-constexpr const char* PALETTE_NAME = "zx-spectrum";          // Paleta por defecto
+constexpr bool VIDEO_VERTICAL_SYNC = true;                    // Vsync activado por defecto
+constexpr bool VIDEO_SHADERS = false;                         // Shaders desactivados por defecto
+constexpr bool VIDEO_INTEGER_SCALE = true;                    // Escalado entero activado por defecto
+constexpr bool VIDEO_KEEP_ASPECT = true;                      // Mantener aspecto activado por defecto
+constexpr const char* PALETTE_NAME = "zx-spectrum";           // Paleta por defecto
 
 // =============================================================================
 // BORDER
@@ -45,22 +45,22 @@ constexpr int BORDER_HEIGHT = 24;      // Alto del borde por defecto
 // =============================================================================
 // AUDIO
 // =============================================================================
-constexpr int AUDIO_VOLUME = 100;    // Volumen por defecto
+constexpr float AUDIO_VOLUME = 1.0F;  // Volumen por defecto
 constexpr bool AUDIO_ENABLED = true;  // Audio por defecto
 
 // MUSIC
-constexpr int MUSIC_VOLUME = 80;      // Volumen por defecto de la musica
+constexpr float MUSIC_VOLUME = 0.8F;  // Volumen por defecto de la musica
 constexpr bool MUSIC_ENABLED = true;  // Musica habilitada por defecto
 
 // SOUND
-constexpr int SOUND_VOLUME = 100;     // Volumen por defecto de los efectos de sonido
+constexpr float SOUND_VOLUME = 1.0F;  // Volumen por defecto de los efectos de sonido
 constexpr bool SOUND_ENABLED = true;  // Sonido habilitado por defecto
 
 // =============================================================================
 // NOTIFICATIONS
 // =============================================================================
-constexpr bool NOTIFICATION_SOUND = true;                                                                   // Sonido de las notificaciones por defecto
-const Uint8 NOTIFICATION_COLOR = static_cast<Uint8>(PaletteColor::BLUE);                                    // Color de las notificaciones por defecto
+constexpr bool NOTIFICATION_SOUND = true;                                 // Sonido de las notificaciones por defecto
+const Uint8 NOTIFICATION_COLOR = static_cast<Uint8>(PaletteColor::BLUE);  // Color de las notificaciones por defecto
 
 // =============================================================================
 // CONTROL
@@ -70,7 +70,7 @@ constexpr Options::ControlScheme CONTROL_SCHEME = Options::ControlScheme::CURSOR
 // =============================================================================
 // OTHER
 // =============================================================================
-constexpr bool CONSOLE = false;              // Consola desactivada por defecto
-constexpr const char* VERSION = "1.10";      // Versión por defecto
+constexpr bool CONSOLE = false;          // Consola desactivada por defecto
+constexpr const char* VERSION = "1.10";  // Versión por defecto
 
 }  // namespace GameDefaults

source/game/options.hpp

@@ -7,20 +7,11 @@
 #include <utility>
 
 #include "core/rendering/screen.hpp"  // Para ScreenFilter
+#include "utils/defines.hpp"          // Para WINDOW_CAPTION
 #include "utils/utils.hpp"            // Para Color, Palette
 
 // --- Namespace Options: gestión de configuración y opciones del juego ---
 namespace Options {
-
-// =============================================================================
-// VOLUME HELPERS - Conversión de volumen 0-100 a 0-128
-// =============================================================================
-namespace VolumeHelpers {
-constexpr auto convertVolume(int volume_percent) -> int {
-    return (volume_percent * 128) / 100;
-}
-}  // namespace VolumeHelpers
-
 // Tipos de control de teclado
 enum class ControlScheme {
     CURSOR,
@@ -97,25 +88,25 @@ struct Stats {
 
 // Estructura con opciones de la ventana
 struct Window {
-        std::string caption{"JailDoctor's Dilemma"};  // Texto que aparece en la barra de título de la ventana
-        int zoom{GameDefaults::WINDOW_ZOOM};          // Zoom de la ventana
-        int max_zoom{GameDefaults::WINDOW_ZOOM};      // Máximo tamaño de zoom para la ventana
+        std::string caption{WINDOW_CAPTION};     // Texto que aparece en la barra de título de la ventana
+        int zoom{GameDefaults::WINDOW_ZOOM};     // Zoom de la ventana
+        int max_zoom{GameDefaults::WINDOW_ZOOM}; // Máximo tamaño de zoom para la ventana
 
         // Constructor por defecto
         Window() = default;
 
         // Constructor
         Window(int window_zoom, int maximum_zoom)
-            : caption("JailDoctor's Dilemma"),
+            : caption(WINDOW_CAPTION),
               zoom(window_zoom),
               max_zoom(maximum_zoom) {}
 };
 
 // Estructura para gestionar el borde de la pantalla
 struct Border {
-        bool enabled{GameDefaults::BORDER_ENABLED};   // Indica si se ha de mostrar el borde
-        float width{GameDefaults::BORDER_WIDTH};      // Ancho del borde
-        float height{GameDefaults::BORDER_HEIGHT};    // Alto del borde
+        bool enabled{GameDefaults::BORDER_ENABLED};  // Indica si se ha de mostrar el borde
+        float width{GameDefaults::BORDER_WIDTH};     // Ancho del borde
+        float height{GameDefaults::BORDER_HEIGHT};   // Alto del borde
 
         // Constructor por defecto
         Border() = default;
@@ -129,15 +120,15 @@ struct Border {
 
 // Estructura para las opciones de video
 struct Video {
-        bool fullscreen{GameDefaults::VIDEO_MODE};               // Contiene el valor del modo de pantalla completa
-        ScreenFilter filter{GameDefaults::VIDEO_FILTER};         // Filtro usado para el escalado de la imagen
-        bool vertical_sync{GameDefaults::VIDEO_VERTICAL_SYNC};   // Indica si se quiere usar vsync o no
-        bool shaders{GameDefaults::VIDEO_SHADERS};               // Indica si se van a usar shaders o no
-        bool integer_scale{GameDefaults::VIDEO_INTEGER_SCALE};   // Indica si el escalado de la imagen ha de ser entero en el modo a pantalla completa
-        bool keep_aspect{GameDefaults::VIDEO_KEEP_ASPECT};       // Indica si se ha de mantener la relación de aspecto al poner el modo a pantalla completa
-        Border border;                                           // Borde de la pantalla
-        std::string palette{GameDefaults::PALETTE_NAME};         // Paleta de colores a usar en el juego
-        std::string info;                                        // Información sobre el modo de vídeo
+        bool fullscreen{GameDefaults::VIDEO_MODE};              // Contiene el valor del modo de pantalla completa
+        ScreenFilter filter{GameDefaults::VIDEO_FILTER};        // Filtro usado para el escalado de la imagen
+        bool vertical_sync{GameDefaults::VIDEO_VERTICAL_SYNC};  // Indica si se quiere usar vsync o no
+        bool shaders{GameDefaults::VIDEO_SHADERS};              // Indica si se van a usar shaders o no
+        bool integer_scale{GameDefaults::VIDEO_INTEGER_SCALE};  // Indica si el escalado de la imagen ha de ser entero en el modo a pantalla completa
+        bool keep_aspect{GameDefaults::VIDEO_KEEP_ASPECT};      // Indica si se ha de mantener la relación de aspecto al poner el modo a pantalla completa
+        Border border;                                          // Borde de la pantalla
+        std::string palette{GameDefaults::PALETTE_NAME};        // Paleta de colores a usar en el juego
+        std::string info;                                       // Información sobre el modo de vídeo
 
         // Constructor por defecto
         Video() = default;
@@ -156,60 +147,48 @@ struct Video {
 
 // Estructura para las opciones de musica
 struct Music {
-        bool enabled{GameDefaults::MUSIC_ENABLED};                               // Indica si la música suena o no
-        int volume{VolumeHelpers::convertVolume(GameDefaults::MUSIC_VOLUME)};    // Volumen al que suena la música (0 a 128 internamente)
+        bool enabled{GameDefaults::MUSIC_ENABLED};  // Indica si la música suena o no
+        float volume{GameDefaults::MUSIC_VOLUME};   // Volumen al que suena la música
 
         // Constructor por defecto
         Music() = default;
 
         // Constructor con parámetros
-        Music(bool is_enabled, int volume_percent)
+        Music(bool is_enabled, float volume_percent)
             : enabled(is_enabled),
-              volume(VolumeHelpers::convertVolume(volume_percent)) {}
-
-        // Método para establecer el volumen
-        void setVolume(int volume_percent) {
-            volume_percent = std::clamp(volume_percent, 0, 100);
-            volume = VolumeHelpers::convertVolume(volume_percent);
-        }
+              volume(volume_percent) {}
 };
 
 // Estructura para las opciones de sonido
 struct Sound {
-        bool enabled{GameDefaults::SOUND_ENABLED};                               // Indica si los sonidos suenan o no
-        int volume{VolumeHelpers::convertVolume(GameDefaults::SOUND_VOLUME)};    // Volumen al que suenan los sonidos (0 a 128 internamente)
+        bool enabled{GameDefaults::SOUND_ENABLED};  // Indica si los sonidos suenan o no
+        float volume{GameDefaults::SOUND_VOLUME};   // Volumen al que suenan los sonidos (0 a 128 internamente)
 
         // Constructor por defecto
         Sound() = default;
 
         // Constructor con parámetros
-        Sound(bool is_enabled, int volume_percent)
+        Sound(bool is_enabled, float volume_percent)
             : enabled(is_enabled),
-              volume(VolumeHelpers::convertVolume(volume_percent)) {}
-
-        // Método para establecer el volumen
-        void setVolume(int volume_percent) {
-            volume_percent = std::clamp(volume_percent, 0, 100);
-            volume = VolumeHelpers::convertVolume(volume_percent);
-        }
+              volume(volume_percent) {}
 };
 
 // Estructura para las opciones de audio
 struct Audio {
-        Music music;                                                            // Opciones para la música
-        Sound sound;                                                            // Opciones para los efectos de sonido
-        bool enabled{GameDefaults::AUDIO_ENABLED};                              // Indica si el audio está activo o no
-        int volume{VolumeHelpers::convertVolume(GameDefaults::AUDIO_VOLUME)};   // Volumen al que suenan el audio (0-128 internamente)
+        Music music;                                // Opciones para la música
+        Sound sound;                                // Opciones para los efectos de sonido
+        bool enabled{GameDefaults::AUDIO_ENABLED};  // Indica si el audio está activo o no
+        float volume{GameDefaults::AUDIO_VOLUME};   // Volumen al que suenan el audio (0-128 internamente)
 
         // Constructor por defecto
         Audio() = default;
 
         // Constructor
-        Audio(Music audio_music, Sound audio_sound, bool is_enabled, int volume_percent)
+        Audio(Music audio_music, Sound audio_sound, bool is_enabled, float volume_percent)
             : music(audio_music),
               sound(audio_sound),
               enabled(is_enabled),
-              volume(VolumeHelpers::convertVolume(volume_percent)) {}
+              volume(volume_percent) {}
 };
 
 // Estructura para las opciones de juego
@@ -239,7 +218,7 @@ inline Audio audio{};                                     // Opciones relativas
 inline ControlScheme keys{GameDefaults::CONTROL_SCHEME};  // Teclas usadas para jugar
 
 // --- Funciones ---
-void init();                                      // Crea e inicializa las opciones del programa
+void init();                                              // Crea e inicializa las opciones del programa
 auto loadFromFile(const std::string& file_path) -> bool;  // Carga las opciones desde un fichero
 auto saveToFile(const std::string& file_path) -> bool;    // Guarda las opciones a un fichero
 

source/utils/defines.hpp

@@ -9,7 +9,6 @@
 // Textos
 constexpr const char* WINDOW_CAPTION = "JailDoctor's Dilemma";
 constexpr const char* TEXT_COPYRIGHT = "@2022 JailDesigner";
-constexpr const char* VERSION = "1.10";
 
 // Velocidad del juego
 constexpr Uint32 GAME_SPEED = 15;