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,8 +20,8 @@ class Audio {
         };
 
         // --- Constantes ---
-        static constexpr int MAX_VOLUME = 100;   // Volumen máximo
-        static constexpr int MIN_VOLUME = 0;     // Volumen mínimo
+        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 ---
@@ -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)
+                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;         // Indica si la última pista de música se debe reproducir en bucle
+                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();
 
@@ -575,3 +578,12 @@ 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

@@ -153,6 +153,7 @@ class Resource {
         std::vector<ResourceRoom> rooms_;            // Vector con las habitaciones
 
         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

@@ -45,15 +45,15 @@ 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
 
 // =============================================================================

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,7 +88,7 @@ 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
+        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
 
@@ -106,7 +97,7 @@ struct Window {
 
         // Constructor
         Window(int window_zoom, int maximum_zoom)
-            : caption("JailDoctor's Dilemma"),
+            : caption(WINDOW_CAPTION),
               zoom(window_zoom),
               max_zoom(maximum_zoom) {}
 };
@@ -157,41 +148,29 @@ 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)
+        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)
+        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
@@ -199,17 +178,17 @@ 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)
+        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

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;