delta-time: game.cpp (funciona pero va un poc massa ràpid)

delta-time: balloon_manager.cpp
delta-time: credits.cpp

.clang-format

@@ -14,6 +14,8 @@ ContinuationIndentWidth: 4
 ConstructorInitializerIndentWidth: 4
 IndentWrappedFunctionNames: false
 Cpp11BracedListStyle: true
-BreakConstructorInitializers: BeforeComma
+BreakConstructorInitializers: BeforeColon
+AllowAllConstructorInitializersOnNextLine: false
+PackConstructorInitializers: Never
 AllowAllArgumentsOnNextLine: false
 AllowAllParametersOfDeclarationOnNextLine: false

.gitignore

@@ -1,4 +1,5 @@
 .vscode
+.claude
 build/
 data/config/config.txt
 *.DS_Store

CMakeLists.txt

@@ -28,6 +28,9 @@ set(APP_SOURCES
     source/main.cpp
     source/param.cpp
     source/resource.cpp
+    source/resource_helper.cpp
+    source/resource_loader.cpp
+    source/resource_pack.cpp
     source/screen.cpp
     source/text.cpp
     source/writer.cpp

LICENSE

@@ -1 +1,21 @@
-GNU General Public License v3.0 only
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License
+
+Copyright (c) 2025 Coffee Crisis Arcade Edition
+
+This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
+
+You are free to:
+- Share — copy and redistribute the material in any medium or format
+- Adapt — remix, transform, and build upon the material
+
+Under the following terms:
+- Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
+- NonCommercial — You may not use the material for commercial purposes.
+- ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.
+
+No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.
+
+To view a copy of this license, visit:
+https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Makefile

@@ -71,6 +71,9 @@ APP_SOURCES := \
     source/path_sprite.cpp \
     source/player.cpp \
     source/resource.cpp \
+    source/resource_helper.cpp \
+    source/resource_loader.cpp \
+    source/resource_pack.cpp \
     source/scoreboard.cpp \
     source/screen.cpp \
     source/sections/credits.cpp \
@@ -104,7 +107,7 @@ INCLUDES := -Isource -Isource/external
 # Variables según el sistema operativo
 ifeq ($(OS),Windows_NT)
     FixPath         = $(subst /,\\,$1)
-    CXXFLAGS        := -std=c++20 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows -DWINDOWS_BUILD
+    CXXFLAGS        := -std=c++20 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -static-libgcc -Wl,-Bstatic -lpthread -Wl,-Bdynamic -Wl,-subsystem,windows -DWINDOWS_BUILD
     CXXFLAGS_DEBUG  := -std=c++20 -Wall -g -D_DEBUG -DWINDOWS_BUILD
     LDFLAGS         := -lmingw32 -lws2_32 -lSDL3 -lopengl32
     RM              := del /Q
@@ -158,8 +161,9 @@ windows_release:
 	powershell if (Test-Path "$(RELEASE_FOLDER)") {Remove-Item "$(RELEASE_FOLDER)" -Recurse -Force}
 	powershell if (-not (Test-Path "$(RELEASE_FOLDER)")) {New-Item "$(RELEASE_FOLDER)" -ItemType Directory}
 
-# Copia la carpeta 'data'
-	powershell Copy-Item -Path "data" -Destination "$(RELEASE_FOLDER)" -recurse -Force
+# Copia la carpeta 'config' y el archivo 'resources.pack'
+	powershell Copy-Item -Path "config" -Destination "$(RELEASE_FOLDER)" -recurse -Force
+	powershell Copy-Item -Path "resources.pack" -Destination "$(RELEASE_FOLDER)"
 
 # Copia los ficheros que estan en la raíz del proyecto
 	powershell Copy-Item "LICENSE" -Destination "$(RELEASE_FOLDER)"
@@ -203,7 +207,8 @@ macos_release:
 	$(MKDIR) Frameworks
 
 # Copia carpetas y ficheros
-	cp -R data "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
+	cp -R config "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
+	cp resources.pack "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
 	cp -R release/frameworks/SDL3.xcframework "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks"
 	cp -R release/frameworks/SDL3.xcframework Frameworks
 	cp release/*.icns "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
@@ -262,7 +267,8 @@ linux_release:
 	$(MKDIR) "$(RELEASE_FOLDER)"
 
 # Copia ficheros
-	cp -R data "$(RELEASE_FOLDER)"
+	cp -R config "$(RELEASE_FOLDER)"
+	cp resources.pack "$(RELEASE_FOLDER)"
 	cp LICENSE "$(RELEASE_FOLDER)"
 	cp README.md "$(RELEASE_FOLDER)"
 
@@ -291,7 +297,8 @@ linux_release_desktop:
 	$(MKDIR) "$(RELEASE_FOLDER)/$(TARGET_NAME)/share/$(TARGET_NAME)"
 
 # Copia ficheros del juego
-	cp -R data "$(RELEASE_FOLDER)/$(TARGET_NAME)/share/$(TARGET_NAME)/"
+	cp -R config "$(RELEASE_FOLDER)/$(TARGET_NAME)/share/$(TARGET_NAME)/"
+	cp resources.pack "$(RELEASE_FOLDER)/$(TARGET_NAME)/share/$(TARGET_NAME)/"
 	cp LICENSE "$(RELEASE_FOLDER)/$(TARGET_NAME)/"
 	cp README.md "$(RELEASE_FOLDER)/$(TARGET_NAME)/"
 
@@ -391,7 +398,8 @@ raspi_release:
 	$(MKDIR) "$(RELEASE_FOLDER)"
 
 # Copia ficheros
-	cp -R data "$(RELEASE_FOLDER)"
+	cp -R config "$(RELEASE_FOLDER)"
+	cp resources.pack "$(RELEASE_FOLDER)"
 	cp LICENSE "$(RELEASE_FOLDER)"
 	cp README.md "$(RELEASE_FOLDER)"
 
@@ -416,7 +424,8 @@ anbernic:
 	$(MKDIR) "$(RELEASE_FOLDER)"_anbernic
 
 # Copia ficheros
-	cp -R data "$(RELEASE_FOLDER)"_anbernic
+	cp -R config "$(RELEASE_FOLDER)"_anbernic
+	cp resources.pack "$(RELEASE_FOLDER)"_anbernic
 
 # Compila
 	$(CXX) $(APP_SOURCES) $(INCLUDES) -DANBERNIC -DNO_SHADERS -DARCADE -DVERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(RELEASE_FOLDER)_anbernic/$(TARGET_NAME)

config/assets.txt

@@ -9,15 +9,17 @@ DATA|${SYSTEM_FOLDER}/controllers.json|optional,absolute
 DATA|${SYSTEM_FOLDER}/score.bin|optional,absolute
 
 # Archivos de configuración del juego
-DATA|${PREFIX}/data/config/formations.txt
-DATA|${PREFIX}/data/config/gamecontrollerdb.txt
-DATA|${PREFIX}/data/config/param_320x240.txt
-DATA|${PREFIX}/data/config/param_320x256.txt
-DATA|${PREFIX}/data/config/param_red.txt
-DATA|${PREFIX}/data/config/pools.txt
-DATA|${PREFIX}/data/config/stages.txt
-DEMODATA|${PREFIX}/data/config/demo1.bin
-DEMODATA|${PREFIX}/data/config/demo2.bin
+DATA|${PREFIX}/config/formations.txt
+DATA|${PREFIX}/config/gamecontrollerdb.txt
+DATA|${PREFIX}/config/param_320x240.txt
+DATA|${PREFIX}/config/param_320x256.txt
+DATA|${PREFIX}/config/param_red.txt
+DATA|${PREFIX}/config/pools.txt
+DATA|${PREFIX}/config/stages.txt
+
+# Archivos con los datos de la demo
+DEMODATA|${PREFIX}/data/demo/demo1.bin
+DEMODATA|${PREFIX}/data/demo/demo2.bin
 
 # Música
 MUSIC|${PREFIX}/data/music/credits.ogg
@@ -50,6 +52,7 @@ SOUND|${PREFIX}/data/sound/notify.wav
 SOUND|${PREFIX}/data/sound/player_collision.wav
 SOUND|${PREFIX}/data/sound/power_ball_explosion.wav
 SOUND|${PREFIX}/data/sound/service_menu_adjust.wav
+SOUND|${PREFIX}/data/sound/service_menu_back.wav
 SOUND|${PREFIX}/data/sound/service_menu_move.wav
 SOUND|${PREFIX}/data/sound/service_menu_select.wav
 SOUND|${PREFIX}/data/sound/stage_change.wav
@@ -172,6 +175,7 @@ BITMAP|${PREFIX}/data/gfx/player/hit.png
 
 # Fuentes de texto
 BITMAP|${PREFIX}/data/font/04b_25_2x.png
+BITMAP|${PREFIX}/data/font/04b_25_2x_white.png
 BITMAP|${PREFIX}/data/font/04b_25_flat_2x.png
 BITMAP|${PREFIX}/data/font/04b_25_flat.png
 BITMAP|${PREFIX}/data/font/04b_25_grey.png

source/animated_sprite.cpp

@@ -9,22 +9,44 @@
 #include <stdexcept>  // Para runtime_error
 #include <utility>    // Para pair
 
-#include "texture.h"  // Para Texture
-#include "utils.h"    // Para printWithDots
+#include "resource_helper.h"  // Para ResourceHelper
+#include "texture.h"          // Para Texture
+#include "utils.h"            // Para printWithDots
 
 // Carga las animaciones en un vector(Animations) desde un fichero
 auto loadAnimationsFromFile(const std::string& file_path) -> AnimationsFileBuffer {
-    std::ifstream file(file_path);
-    if (!file) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", file_path.c_str());
-        throw std::runtime_error("Fichero no encontrado: " + file_path);
+    // Intentar cargar desde ResourceHelper primero
+    auto resource_data = ResourceHelper::loadFile(file_path);
+    std::istringstream stream;
+    bool using_resource_data = false;
+
+    if (!resource_data.empty()) {
+        std::string content(resource_data.begin(), resource_data.end());
+        stream.str(content);
+        using_resource_data = true;
     }
 
+    // Fallback a archivo directo
+    std::ifstream file;
+    if (!using_resource_data) {
+        file.open(file_path);
+        if (!file) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", file_path.c_str());
+            throw std::runtime_error("Fichero no encontrado: " + file_path);
+        }
+    }
+
+    std::istream& input_stream = using_resource_data ? stream : static_cast<std::istream&>(file);
+
     printWithDots("Animation : ", file_path.substr(file_path.find_last_of("\\/") + 1), "[ LOADED ]");
 
     std::vector<std::string> buffer;
     std::string line;
-    while (std::getline(file, line)) {
+    while (std::getline(input_stream, line)) {
+        // Eliminar caracteres de retorno de carro (\r) al final de la línea
+        if (!line.empty() && line.back() == '\r') {
+            line.pop_back();
+        }
         if (!line.empty()) {
             buffer.push_back(line);
         }
@@ -64,7 +86,7 @@ auto AnimatedSprite::getAnimationIndex(const std::string& name) -> int {
     return -1;
 }
 
-// Calcula el frame correspondiente a la animación
+// Calcula el frame correspondiente a la animación (frame-based)
 void AnimatedSprite::animate() {
     if (animations_[current_animation_].speed == 0 || animations_[current_animation_].paused) {
         return;
@@ -94,6 +116,39 @@ void AnimatedSprite::animate() {
     }
 }
 
+// Calcula el frame correspondiente a la animación (time-based)
+void AnimatedSprite::animate(float deltaTime) {
+    if (animations_[current_animation_].speed == 0 || animations_[current_animation_].paused) {
+        return;
+    }
+
+    // Convertir speed (frames) a tiempo: speed frames = speed * (1000ms/60fps) milisegundos
+    float frameTime = static_cast<float>(animations_[current_animation_].speed) * (1000.0f / 60.0f);
+    
+    // Acumular tiempo transcurrido
+    animations_[current_animation_].time_accumulator += deltaTime;
+    
+    // Verificar si es momento de cambiar frame
+    if (animations_[current_animation_].time_accumulator >= frameTime) {
+        animations_[current_animation_].time_accumulator -= frameTime;
+        animations_[current_animation_].current_frame++;
+        
+        // Si alcanza el final de la animación
+        if (animations_[current_animation_].current_frame >= animations_[current_animation_].frames.size()) {
+            if (animations_[current_animation_].loop == -1) {  // Si no hay loop, deja el último frame
+                animations_[current_animation_].current_frame = animations_[current_animation_].frames.size() - 1;
+                animations_[current_animation_].completed = true;
+            } else {  // Si hay loop, vuelve al frame indicado
+                animations_[current_animation_].time_accumulator = 0.0f;
+                animations_[current_animation_].current_frame = animations_[current_animation_].loop;
+            }
+        }
+        
+        // Actualizar el sprite clip
+        updateSpriteClip();
+    }
+}
+
 // Comprueba si ha terminado la animación
 auto AnimatedSprite::animationIsCompleted() -> bool {
     return animations_[current_animation_].completed;
@@ -108,10 +163,12 @@ void AnimatedSprite::setCurrentAnimation(const std::string& name, bool reset) {
         if (reset) {
             animations_[current_animation_].current_frame = 0;
             animations_[current_animation_].counter = 0;
+            animations_[current_animation_].time_accumulator = 0.0f;
             animations_[current_animation_].completed = false;
         } else {
             animations_[current_animation_].current_frame = std::min(animations_[OLD_ANIMATION].current_frame, animations_[current_animation_].frames.size() - 1);
             animations_[current_animation_].counter = animations_[OLD_ANIMATION].counter;
+            animations_[current_animation_].time_accumulator = animations_[OLD_ANIMATION].time_accumulator;
             animations_[current_animation_].completed = animations_[OLD_ANIMATION].completed;
         }
         updateSpriteClip();
@@ -127,26 +184,35 @@ void AnimatedSprite::setCurrentAnimation(int index, bool reset) {
         if (reset) {
             animations_[current_animation_].current_frame = 0;
             animations_[current_animation_].counter = 0;
+            animations_[current_animation_].time_accumulator = 0.0f;
             animations_[current_animation_].completed = false;
         } else {
             animations_[current_animation_].current_frame = std::min(animations_[OLD_ANIMATION].current_frame, animations_[current_animation_].frames.size());
             animations_[current_animation_].counter = animations_[OLD_ANIMATION].counter;
+            animations_[current_animation_].time_accumulator = animations_[OLD_ANIMATION].time_accumulator;
             animations_[current_animation_].completed = animations_[OLD_ANIMATION].completed;
         }
         updateSpriteClip();
     }
 }
 
-// Actualiza las variables del objeto
+// Actualiza las variables del objeto (frame-based)
 void AnimatedSprite::update() {
     animate();
     MovingSprite::update();
 }
 
+// Actualiza las variables del objeto (time-based)
+void AnimatedSprite::update(float deltaTime) {
+    animate(deltaTime);
+    MovingSprite::update(deltaTime);
+}
+
 // Reinicia la animación
 void AnimatedSprite::resetAnimation() {
     animations_[current_animation_].current_frame = 0;
     animations_[current_animation_].counter = 0;
+    animations_[current_animation_].time_accumulator = 0.0f;
     animations_[current_animation_].completed = false;
     animations_[current_animation_].paused = false;
     updateSpriteClip();

source/animated_sprite.h

@@ -21,11 +21,12 @@ struct Animation {
 
         std::string name;               // Nombre de la animación
         std::vector<SDL_FRect> frames;  // Frames que componen la animación
-        int speed{DEFAULT_SPEED};       // Velocidad de reproducción
+        int speed{DEFAULT_SPEED};       // Velocidad de reproducción (frame-based)
         int loop{0};                    // Frame de vuelta al terminar (-1 para no repetir)
         bool completed{false};          // Indica si la animación ha finalizado
         size_t current_frame{0};        // Frame actual en reproducción
-        int counter{0};                 // Contador para la animación
+        int counter{0};                 // Contador para la animación (frame-based)
+        float time_accumulator{0.0f};   // Acumulador de tiempo para animaciones time-based
         bool paused{false};             // La animación no avanza
 
         Animation() = default;
@@ -50,11 +51,13 @@ class AnimatedSprite : public MovingSprite {
         // --- Constructores y destructor ---
         AnimatedSprite(std::shared_ptr<Texture> texture, const std::string& file_path);
         AnimatedSprite(std::shared_ptr<Texture> texture, const AnimationsFileBuffer& animations);
-        explicit AnimatedSprite(std::shared_ptr<Texture> texture) : MovingSprite(std::move(texture)) {}
+        explicit AnimatedSprite(std::shared_ptr<Texture> texture)
+            : MovingSprite(std::move(texture)) {}
         ~AnimatedSprite() override = default;
 
         // --- Métodos principales ---
-        void update() override;  // Actualiza la animación
+        void update() override;              // Actualiza la animación (frame-based)
+        void update(float deltaTime);        // Actualiza la animación (time-based)
 
         // --- Control de animaciones ---
         void setCurrentAnimation(const std::string& name = "default", bool reset = true);                          // Establece la animación por nombre
@@ -77,7 +80,8 @@ class AnimatedSprite : public MovingSprite {
         int current_animation_ = 0;                               // Índice de la animación activa
 
         // --- Métodos internos ---
-        void animate();                                                                                                               // Calcula el frame correspondiente a la animación
+        void animate();                                                                                                               // Calcula el frame correspondiente a la animación (frame-based)
+        void animate(float deltaTime);                                                                                                // Calcula el frame correspondiente a la animación (time-based)
         void loadFromAnimationsFileBuffer(const AnimationsFileBuffer& source);                                                        // Carga la animación desde un vector de cadenas
         void processConfigLine(const std::string& line, AnimationConfig& config);                                                     // Procesa una línea de configuración
         void updateFrameCalculations(AnimationConfig& config);                                                                        // Actualiza los cálculos basados en las dimensiones del frame

source/asset.cpp

@@ -8,7 +8,8 @@
 #include <sstream>    // Para basic_istringstream
 #include <stdexcept>  // Para runtime_error
 
-#include "utils.h"  // Para getFileName
+#include "resource_helper.h"  // Para ResourceHelper
+#include "utils.h"            // Para getFileName
 
 // Singleton
 Asset *Asset::instance = nullptr;
@@ -139,6 +140,17 @@ auto Asset::get(const std::string &filename) const -> std::string {
     return "";
 }
 
+// Carga datos del archivo usando ResourceHelper
+auto Asset::loadData(const std::string &filename) const -> std::vector<uint8_t> {
+    auto it = file_list_.find(filename);
+    if (it != file_list_.end()) {
+        return ResourceHelper::loadFile(it->second.file);
+    }
+
+    SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Warning: file %s not found for data loading", filename.c_str());
+    return {};
+}
+
 // Verifica si un recurso existe
 auto Asset::exists(const std::string &filename) const -> bool {
     return file_list_.find(filename) != file_list_.end();
@@ -194,9 +206,16 @@ auto Asset::check() const -> bool {
 
 // Comprueba que existe un fichero
 auto Asset::checkFile(const std::string &path) -> bool {
-    std::ifstream file(path);
-    bool success = file.good();
-    file.close();
+    // Intentar primero con ResourceHelper
+    auto data = ResourceHelper::loadFile(path);
+    bool success = !data.empty();
+
+    // Si no se encuentra en el pack, intentar con filesystem directo
+    if (!success) {
+        std::ifstream file(path);
+        success = file.good();
+        file.close();
+    }
 
     if (!success) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

source/asset.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>        // Para uint8_t
 #include <string>         // Para string
 #include <unordered_map>  // Para unordered_map
 #include <utility>        // Para move
@@ -33,6 +34,7 @@ class Asset {
         void add(const std::string &file_path, Type type, bool required = true, bool absolute = false);
         void loadFromFile(const std::string &config_file_path, const std::string &prefix = "", const std::string &system_folder = "");  // Con soporte para variables
         [[nodiscard]] auto get(const std::string &filename) const -> std::string;                                                       // Mantener nombre original
+        [[nodiscard]] auto loadData(const std::string &filename) const -> std::vector<uint8_t>;                                         // Carga datos del archivo
         [[nodiscard]] auto check() const -> bool;
         [[nodiscard]] auto getListByType(Type type) const -> std::vector<std::string>;
         [[nodiscard]] auto exists(const std::string &filename) const -> bool;  // Nueva función para verificar existencia
@@ -45,7 +47,9 @@ class Asset {
                 bool required;     // Indica si el archivo es obligatorio
 
                 Item(std::string path, Type asset_type, bool is_required)
-                    : file(std::move(path)), type(asset_type), required(is_required) {}
+                    : file(std::move(path)),
+                      type(asset_type),
+                      required(is_required) {}
         };
 
         // --- Variables internas ---

source/asset_integrated.cpp

@@ -0,0 +1,106 @@
+#include "asset_integrated.h"
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+
+bool AssetIntegrated::resource_pack_enabled_ = false;
+
+void AssetIntegrated::initWithResourcePack(const std::string &executable_path,
+    const std::string &resource_pack_path) {
+    // Inicializar Asset normal
+    Asset::init(executable_path);
+
+    // Inicializar ResourceLoader
+    auto &loader = ResourceLoader::getInstance();
+    if (loader.initialize(resource_pack_path, true)) {
+        resource_pack_enabled_ = true;
+        std::cout << "Asset system initialized with resource pack: " << resource_pack_path << std::endl;
+    } else {
+        resource_pack_enabled_ = false;
+        std::cout << "Asset system initialized in fallback mode (filesystem)" << std::endl;
+    }
+}
+
+std::vector<uint8_t> AssetIntegrated::loadFile(const std::string &filename) {
+    if (shouldUseResourcePack(filename) && resource_pack_enabled_) {
+        // Intentar cargar del pack de recursos
+        auto &loader = ResourceLoader::getInstance();
+
+        // Convertir ruta completa a ruta relativa para el pack
+        std::string relativePath = filename;
+
+        // Si la ruta contiene "data/", extraer la parte relativa
+        size_t dataPos = filename.find("data/");
+        if (dataPos != std::string::npos) {
+            relativePath = filename.substr(dataPos + 5);  // +5 para saltar "data/"
+        }
+
+        auto data = loader.loadResource(relativePath);
+        if (!data.empty()) {
+            return data;
+        }
+    }
+
+    // Fallback: cargar del filesystem
+    std::ifstream file(filename, std::ios::binary | std::ios::ate);
+    if (!file) {
+        std::cerr << "Error: Could not open file: " << filename << std::endl;
+        return {};
+    }
+
+    std::streamsize fileSize = file.tellg();
+    file.seekg(0, std::ios::beg);
+
+    std::vector<uint8_t> data(fileSize);
+    if (!file.read(reinterpret_cast<char *>(data.data()), fileSize)) {
+        std::cerr << "Error: Could not read file: " << filename << std::endl;
+        return {};
+    }
+
+    return data;
+}
+
+bool AssetIntegrated::fileExists(const std::string &filename) const {
+    if (shouldUseResourcePack(filename) && resource_pack_enabled_) {
+        auto &loader = ResourceLoader::getInstance();
+
+        // Convertir ruta completa a ruta relativa para el pack
+        std::string relativePath = filename;
+        size_t dataPos = filename.find("data/");
+        if (dataPos != std::string::npos) {
+            relativePath = filename.substr(dataPos + 5);
+        }
+
+        if (loader.resourceExists(relativePath)) {
+            return true;
+        }
+    }
+
+    // Verificar en filesystem
+    return std::filesystem::exists(filename);
+}
+
+std::string AssetIntegrated::getSystemPath(const std::string &filename) const {
+    // Los archivos de sistema/config siempre van al filesystem
+    return filename;
+}
+
+bool AssetIntegrated::shouldUseResourcePack(const std::string &filepath) const {
+    // Los archivos que NO van al pack:
+    // - Archivos de config/ (ahora están fuera de data/)
+    // - Archivos con absolute=true en assets.txt
+    // - Archivos de sistema (${SYSTEM_FOLDER})
+
+    if (filepath.find("/config/") != std::string::npos ||
+        filepath.find("config/") == 0) {
+        return false;
+    }
+
+    if (filepath.find("/data/") != std::string::npos ||
+        filepath.find("data/") == 0) {
+        return true;
+    }
+
+    return false;
+}

source/asset_integrated.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <memory>
+
+#include "asset.h"
+#include "resource_loader.h"
+
+// Extensión de Asset que integra ResourceLoader
+class AssetIntegrated : public Asset {
+    public:
+        // Inicializa Asset con ResourceLoader
+        static void initWithResourcePack(const std::string &executable_path,
+            const std::string &resource_pack_path = "resources.pack");
+
+        // Carga un archivo usando ResourceLoader como primera opción
+        std::vector<uint8_t> loadFile(const std::string &filename);
+
+        // Verifica si un archivo existe (pack o filesystem)
+        bool fileExists(const std::string &filename) const;
+
+        // Obtiene la ruta completa para archivos del sistema/config
+        std::string getSystemPath(const std::string &filename) const;
+
+    private:
+        static bool resource_pack_enabled_;
+
+        // Determina si un archivo debe cargarse del pack o del filesystem
+        bool shouldUseResourcePack(const std::string &filepath) const;
+};

source/audio.cpp

@@ -100,7 +100,7 @@ void Audio::stopAllSounds() const {
 
 // Realiza un fundido de salida de la música
 void Audio::fadeOutMusic(int milliseconds) const {
-    if (music_enabled_) {
+    if (music_enabled_ && music_.state == MusicState::PLAYING) {
 #ifndef NO_AUDIO
         JA_FadeOutMusic(milliseconds);
 #endif

source/audio.h

@@ -75,11 +75,15 @@ class Audio {
                 bool loop;         // 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()
+                    : state(MusicState::STOPPED),
+                      loop(false) {}
 
                 // Constructor para inicializar con valores específicos
                 Music(MusicState init_state, std::string init_name, bool init_loop)
-                    : state(init_state), name(std::move(init_name)), loop(init_loop) {}
+                    : state(init_state),
+                      name(std::move(init_name)),
+                      loop(init_loop) {}
         };
 
         // --- Variables de estado ---

source/background.cpp

@@ -126,7 +126,14 @@ void Background::initializeTextures() {
 }
 
 // Actualiza la lógica del objeto
+// Actualiza la lógica del objeto (compatibilidad)
 void Background::update() {
+    constexpr float FRAME_TIME_MS = 1000.0f / 60.0f;  // 16.67ms por frame a 60 FPS
+    update(FRAME_TIME_MS);
+}
+
+// Actualiza la lógica del objeto
+void Background::update(float delta_time) {
     // Actualiza la progresión y calcula transiciones
     if (!manual_mode_) {
         updateProgression();

source/background.h

@@ -31,7 +31,8 @@ class Background {
         ~Background();                                           // Destructor
 
         // --- Métodos principales ---
-        void update();  // Actualiza la lógica del objeto
+        void update();                    // Actualiza la lógica del objeto (compatibilidad)
+        void update(float delta_time);    // Actualiza la lógica del objeto
         void render();  // Dibuja el objeto
         void reset();   // Reinicia la progresión
 

source/balloon.cpp

@@ -11,20 +11,21 @@
 #include "texture.h"          // Para Texture
 
 // Constructor
-Balloon::Balloon(float x, float y, Type type, Size size, float vel_x, float speed, Uint16 creation_timer, SDL_FRect play_area, const std::shared_ptr<Texture> &texture, const std::vector<std::string> &animation)
-    : sprite_(std::make_unique<AnimatedSprite>(texture, animation)),
-      x_(x),
-      y_(y),
-      vx_(vel_x),
-      being_created_(creation_timer > 0),
-      invulnerable_(creation_timer > 0),
-      stopped_(creation_timer > 0),
-      creation_counter_(creation_timer),
-      creation_counter_ini_(creation_timer),
-      type_(type),
-      size_(size),
-      speed_(speed),
-      play_area_(play_area) {
+Balloon::Balloon(const Config& config)
+    : sprite_(std::make_unique<AnimatedSprite>(config.texture, config.animation)),
+      x_(config.x),
+      y_(config.y),
+      vx_(config.vel_x),
+      being_created_(config.creation_counter > 0),
+      invulnerable_(config.creation_counter > 0),
+      stopped_(config.creation_counter > 0),
+      creation_counter_(config.creation_counter),
+      creation_counter_ini_(config.creation_counter),
+      type_(config.type),
+      size_(config.size),
+      speed_(config.speed),
+      play_area_(config.play_area),
+      sound_(config.sound) {
     switch (type_) {
         case Type::BALLOON: {
             vy_ = 0;
@@ -37,9 +38,8 @@ Balloon::Balloon(float x, float y, Type type, Size size, float vel_x, float spee
             power_ = POWER.at(INDEX);
             menace_ = MENACE.at(INDEX);
             score_ = SCORE.at(INDEX);
-            bouncing_sound_ = BOUNCING_SOUND.at(INDEX);
-            popping_sound_ = POPPING_SOUND.at(INDEX);
-
+            sound_.bouncing_file = BOUNCING_SOUND.at(INDEX);
+            sound_.popping_file = POPPING_SOUND.at(INDEX);
             break;
         }
 
@@ -52,17 +52,16 @@ Balloon::Balloon(float x, float y, Type type, Size size, float vel_x, float spee
             power_ = POWER.at(INDEX);
             menace_ = MENACE.at(INDEX);
             score_ = SCORE.at(INDEX);
-            bouncing_sound_ = BOUNCING_SOUND.at(INDEX);
-            popping_sound_ = POPPING_SOUND.at(INDEX);
-
+            sound_.bouncing_file = BOUNCING_SOUND.at(INDEX);
+            sound_.popping_file = POPPING_SOUND.at(INDEX);
             break;
         }
 
         case Type::POWERBALL: {
             constexpr int INDEX = 3;
             h_ = w_ = WIDTH.at(4);
-            bouncing_sound_ = BOUNCING_SOUND.at(3);
-            popping_sound_ = "power_ball_explosion.wav";
+            sound_.bouncing_file = BOUNCING_SOUND.at(3);
+            sound_.popping_file = "power_ball_explosion.wav";
             power_ = score_ = menace_ = 0;
 
             vy_ = 0;
@@ -70,9 +69,8 @@ Balloon::Balloon(float x, float y, Type type, Size size, float vel_x, float spee
             gravity_ = param.balloon.settings.at(INDEX).grav;
             default_vy_ = param.balloon.settings.at(INDEX).vel;
 
-            sprite_->setRotate(creation_timer <= 0);
+            sprite_->setRotate(config.creation_counter <= 0);
             sprite_->setRotateAmount(vx_ > 0.0F ? 2.0 : -2.0);
-
             break;
         }
 
@@ -137,7 +135,7 @@ void Balloon::render() {
     }
 }
 
-// Actualiza la posición y estados del globo
+// Actualiza la posición y estados del globo (frame-based)
 void Balloon::move() {
     if (isStopped()) {
         return;
@@ -148,6 +146,17 @@ void Balloon::move() {
     applyGravity();
 }
 
+// Actualiza la posición y estados del globo (time-based)
+void Balloon::move(float deltaTime) {
+    if (isStopped()) {
+        return;
+    }
+
+    handleHorizontalMovement(deltaTime);
+    handleVerticalMovement(deltaTime);
+    applyGravity(deltaTime);
+}
+
 void Balloon::handleHorizontalMovement() {
     x_ += vx_ * speed_;
 
@@ -160,6 +169,20 @@ void Balloon::handleHorizontalMovement() {
     }
 }
 
+void Balloon::handleHorizontalMovement(float deltaTime) {
+    // Convertir deltaTime (milisegundos) a factor de frame (asumiendo 60fps)
+    float frameFactor = deltaTime / (1000.0f / 60.0f);
+    x_ += vx_ * speed_ * frameFactor;
+
+    const int CLIP = 2;
+    const float MIN_X = play_area_.x - CLIP;
+    const float MAX_X = play_area_.x + play_area_.w - w_ + CLIP;
+
+    if (isOutOfHorizontalBounds(MIN_X, MAX_X)) {
+        handleHorizontalBounce(MIN_X, MAX_X);
+    }
+}
+
 void Balloon::handleVerticalMovement() {
     y_ += vy_ * speed_;
 
@@ -170,6 +193,18 @@ void Balloon::handleVerticalMovement() {
     handleBottomCollision();
 }
 
+void Balloon::handleVerticalMovement(float deltaTime) {
+    // Convertir deltaTime (milisegundos) a factor de frame (asumiendo 60fps)
+    float frameFactor = deltaTime / (1000.0f / 60.0f);
+    y_ += vy_ * speed_ * frameFactor;
+
+    if (shouldCheckTopCollision()) {
+        handleTopCollision();
+    }
+
+    handleBottomCollision();
+}
+
 auto Balloon::isOutOfHorizontalBounds(float min_x, float max_x) const -> bool {
     return x_ < min_x || x_ > max_x;
 }
@@ -232,13 +267,31 @@ void Balloon::applyGravity() {
     }
 }
 
-void Balloon::playBouncingSound() {
-    if (bouncing_sound_enabled_) {
-        playSound(bouncing_sound_);
+void Balloon::applyGravity(float deltaTime) {
+    // Convertir deltaTime (milisegundos) a factor de frame (asumiendo 60fps)
+    float frameFactor = deltaTime / (1000.0f / 60.0f);
+
+    travel_y_ += speed_ * frameFactor;
+
+    if (travel_y_ >= 1.0F) {
+        travel_y_ -= 1.0F;
+        vy_ += gravity_;
     }
 }
 
-// Actualiza al globo a su posicion, animación y controla los contadores
+void Balloon::playBouncingSound() {
+    if (sound_.enabled && sound_.bouncing_enabled) {
+        Audio::get()->playSound(sound_.bouncing_file);
+    }
+}
+
+void Balloon::playPoppingSound() {
+    if (sound_.enabled && sound_.poping_enabled) {
+        Audio::get()->playSound(sound_.popping_file);
+    }
+}
+
+// Actualiza al globo a su posicion, animación y controla los contadores (frame-based)
 void Balloon::update() {
     move();
     updateState();
@@ -249,7 +302,20 @@ void Balloon::update() {
     ++counter_;
 }
 
-// Actualiza los estados del globo
+// Actualiza al globo a su posicion, animación y controla los contadores (time-based)
+void Balloon::update(float deltaTime) {
+    move(deltaTime);
+    updateState(deltaTime);
+    updateBounceEffect();
+    shiftSprite();
+    shiftColliders();
+    sprite_->update(deltaTime);
+    // Convertir deltaTime (milisegundos) a factor de frame (asumiendo 60fps)
+    float frameFactor = deltaTime / (1000.0f / 60.0f);
+    counter_ += frameFactor;
+}
+
+// Actualiza los estados del globo (frame-based)
 void Balloon::updateState() {
     // Si se está creando
     if (isBeingCreated()) {
@@ -259,7 +325,7 @@ void Balloon::updateState() {
 
         if (creation_counter_ > 0) {
             // Desplaza lentamente el globo hacia abajo y hacia un lado
-            if (creation_counter_ % 10 == 0) {
+            if (static_cast<int>(creation_counter_) % 10 == 0) {
                 y_++;
                 x_ += vx_;
 
@@ -286,6 +352,51 @@ void Balloon::updateState() {
     }
 }
 
+// Actualiza los estados del globo (time-based)
+void Balloon::updateState(float deltaTime) {
+    // Si se está creando
+    if (isBeingCreated()) {
+        // Actualiza el valor de las variables
+        stop();
+        setInvulnerable(true);
+
+        if (creation_counter_ > 0) {
+            // Convertir deltaTime (milisegundos) a factor de frame (asumiendo 60fps)
+            float frameFactor = deltaTime / (1000.0f / 60.0f);
+
+            // Desplaza lentamente el globo hacia abajo y hacia un lado
+            // Cada 10 frames (aproximadamente cada 166ms a 60fps)
+            movement_accumulator_ += frameFactor;
+
+            if (movement_accumulator_ >= 10.0f) {
+                movement_accumulator_ -= 10.0f;
+                y_++;
+                x_ += vx_;
+
+                // Comprueba no se salga por los laterales
+                const int MIN_X = play_area_.x;
+                const int MAX_X = play_area_.w - w_;
+
+                if (x_ < MIN_X || x_ > MAX_X) {
+                    // Corrige y cambia el sentido de la velocidad
+                    x_ -= vx_;
+                    vx_ = -vx_;
+                }
+            }
+            creation_counter_ -= frameFactor;
+            if (creation_counter_ < 0) creation_counter_ = 0;
+        }
+
+        else {
+            // El contador ha llegado a cero
+            being_created_ = false;
+            start();
+            setInvulnerable(false);
+            setAnimation();
+        }
+    }
+}
+
 // Establece la animación correspondiente al estado
 void Balloon::setAnimation() {
     std::string creating_animation;
@@ -368,23 +479,8 @@ void Balloon::useNormalColor() {
     setAnimation();
 }
 
-// Reproduce sonido
-void Balloon::playSound(const std::string &name) const {
-    if (!sound_enabled_) {
-        return;
-    }
-
-    static auto *audio_ = Audio::get();
-    audio_->playSound(name);
-}
-
 // Explota el globo
 void Balloon::pop(bool should_sound) {
-    if (should_sound) {
-        if (poping_sound_enabled_) {
-            playSound(popping_sound_);
-        }
-    }
-
+    if (should_sound) { playPoppingSound(); }
     enabled_ = false;
 }

source/balloon.h

@@ -25,10 +25,16 @@ class Balloon {
         static constexpr std::array<int, 5> WIDTH = {10, 16, 26, 48, 49};
 
         static constexpr std::array<std::string_view, 4> BOUNCING_SOUND = {
-            "balloon_bounce0.wav", "balloon_bounce1.wav", "balloon_bounce2.wav", "balloon_bounce3.wav"};
+            "balloon_bounce0.wav",
+            "balloon_bounce1.wav",
+            "balloon_bounce2.wav",
+            "balloon_bounce3.wav"};
 
         static constexpr std::array<std::string_view, 4> POPPING_SOUND = {
-            "balloon_pop0.wav", "balloon_pop1.wav", "balloon_pop2.wav", "balloon_pop3.wav"};
+            "balloon_pop0.wav",
+            "balloon_pop1.wav",
+            "balloon_pop2.wav",
+            "balloon_pop3.wav"};
 
         static constexpr float VELX_POSITIVE = 0.7F;
         static constexpr float VELX_NEGATIVE = -0.7F;
@@ -52,26 +58,42 @@ class Balloon {
             POWERBALL = 2,  // Globo de poder
         };
 
+        // --- Estructura para manejo de sonido ---
+        struct Sound {
+                std::string bouncing_file;      // Archivo de sonido al rebotar
+                std::string popping_file;       // Archivo de sonido al explotar
+                bool bouncing_enabled = false;  // Si debe sonar el globo al rebotar
+                bool poping_enabled = true;     // Si debe sonar el globo al explotar
+                bool enabled = true;            // Indica si los globos deben hacer algun sonido
+        };
+
+        // --- Estructura de configuración para inicialización ---
+        struct Config {
+                float x = 0.0F;
+                float y = 0.0F;
+                Type type = Type::BALLOON;
+                Size size = Size::EXTRALARGE;
+                float vel_x = VELX_POSITIVE;
+                float speed = SPEED.at(0);
+                Uint16 creation_counter = 0;
+                SDL_FRect play_area = {.x = 0.0F, .y = 0.0F, .w = 0.0F, .h = 0.0F};
+                std::shared_ptr<Texture> texture = nullptr;
+                std::vector<std::string> animation;
+                Sound sound;
+        };
+
         // --- Constructores y destructor ---
-        Balloon(
-            float x,
-            float y,
-            Type type,
-            Size size,
-            float vel_x,
-            float speed,
-            Uint16 creation_timer,
-            SDL_FRect play_area,
-            const std::shared_ptr<Texture>& texture,
-            const std::vector<std::string>& animation);
+        Balloon(const Config& config);
         ~Balloon() = default;
 
         // --- Métodos principales ---
-        void alignTo(int x);                  // Centra el globo en la posición X
-        void render();                        // Pinta el globo en la pantalla
-        void move();                          // Actualiza la posición y estados del globo
-        void update();                        // Actualiza el globo (posición, animación, contadores)
-        void stop();                          // Detiene el globo
+        void alignTo(int x);                       // Centra el globo en la posición X
+        void render();                             // Pinta el globo en la pantalla
+        void move();                               // Actualiza la posición y estados del globo (frame-based)
+        void move(float deltaTime);                // Actualiza la posición y estados del globo (time-based)
+        void update();                             // Actualiza el globo (posición, animación, contadores) (frame-based)
+        void update(float deltaTime);              // Actualiza el globo (posición, animación, contadores) (time-based)
+        void stop();                               // Detiene el globo
         void start();                         // Pone el globo en movimiento
         void pop(bool should_sound = false);  // Explota el globo
 
@@ -102,9 +124,9 @@ class Balloon {
         void setVelY(float vel_y) { vy_ = vel_y; }
         void setSpeed(float speed) { speed_ = speed; }
         void setInvulnerable(bool value) { invulnerable_ = value; }
-        void setBouncingSound(bool value) { bouncing_sound_enabled_ = value; }
-        void setPoppingSound(bool value) { poping_sound_enabled_ = value; }
-        void setSound(bool value) { sound_enabled_ = value; }
+        void setBouncingSound(bool value) { sound_.bouncing_enabled = value; }
+        void setPoppingSound(bool value) { sound_.poping_enabled = value; }
+        void setSound(bool value) { sound_.enabled = value; }
 
     private:
         // --- Estructura para el efecto de rebote ---
@@ -114,10 +136,28 @@ class Balloon {
 
                 // Tablas de valores predefinidos para el efecto de rebote
                 static constexpr std::array<float, BOUNCE_FRAMES> HORIZONTAL_ZOOM_VALUES = {
-                    1.10F, 1.05F, 1.00F, 0.95F, 0.90F, 0.95F, 1.00F, 1.02F, 1.05F, 1.02F};
+                    1.10F,
+                    1.05F,
+                    1.00F,
+                    0.95F,
+                    0.90F,
+                    0.95F,
+                    1.00F,
+                    1.02F,
+                    1.05F,
+                    1.02F};
 
                 static constexpr std::array<float, BOUNCE_FRAMES> VERTICAL_ZOOM_VALUES = {
-                    0.90F, 0.95F, 1.00F, 1.05F, 1.10F, 1.05F, 1.00F, 0.98F, 0.95F, 0.98F};
+                    0.90F,
+                    0.95F,
+                    1.00F,
+                    1.05F,
+                    1.10F,
+                    1.05F,
+                    1.00F,
+                    0.98F,
+                    0.95F,
+                    0.98F};
 
                 // Estado del efecto
                 bool enabled_ = false;  // Si el efecto está activo
@@ -203,52 +243,52 @@ class Balloon {
         std::unique_ptr<AnimatedSprite> sprite_;  // Sprite del objeto globo
 
         // --- Variables de estado y físicas ---
-        float x_;                              // Posición X
-        float y_;                              // Posición Y
-        float w_;                              // Ancho
-        float h_;                              // Alto
-        float vx_;                             // Velocidad X
-        float vy_;                             // Velocidad Y
-        float gravity_;                        // Aceleración en Y
-        float default_vy_;                     // Velocidad inicial al rebotar
-        float max_vy_;                         // Máxima velocidad en Y
-        bool being_created_;                   // Si el globo se está creando
-        bool enabled_ = true;                  // Si el globo está activo
-        bool invulnerable_;                    // Si el globo es invulnerable
-        bool stopped_;                         // Si el globo está parado
-        bool use_reversed_colors_ = false;     // Si se usa el color alternativo
-        Circle collider_;                      // Círculo de colisión
-        Uint16 creation_counter_;              // Temporizador de creación
-        Uint16 creation_counter_ini_;          // Valor inicial del temporizador de creación
-        Uint16 score_;                         // Puntos al destruir el globo
-        Type type_;                            // Tipo de globo
-        Size size_;                            // Tamaño de globo
-        Uint8 menace_;                         // Amenaza que genera el globo
-        Uint32 counter_ = 0;                   // Contador interno
-        float travel_y_ = 1.0F;                // Distancia a recorrer en Y antes de aplicar gravedad
-        float speed_;                          // Velocidad del globo
-        Uint8 power_;                          // Poder que alberga el globo
-        SDL_FRect play_area_;                  // Zona de movimiento del globo
-        std::string bouncing_sound_;           // Archivo de sonido al rebotar
-        std::string popping_sound_;            // Archivo de sonido al explotar
-        bool bouncing_sound_enabled_ = false;  // Si debe sonar el globo al rebotar
-        bool poping_sound_enabled_ = true;     // Si debe sonar el globo al explotar
-        bool sound_enabled_ = true;            // Indica si los globos deben hacer algun sonido
-        BounceEffect bounce_effect_;           // Efecto de rebote
+        float x_;                           // Posición X
+        float y_;                           // Posición Y
+        float w_;                           // Ancho
+        float h_;                           // Alto
+        float vx_;                          // Velocidad X
+        float vy_;                          // Velocidad Y
+        float gravity_;                     // Aceleración en Y
+        float default_vy_;                  // Velocidad inicial al rebotar
+        float max_vy_;                      // Máxima velocidad en Y
+        bool being_created_;                // Si el globo se está creando
+        bool enabled_ = true;               // Si el globo está activo
+        bool invulnerable_;                 // Si el globo es invulnerable
+        bool stopped_;                      // Si el globo está parado
+        bool use_reversed_colors_ = false;  // Si se usa el color alternativo
+        Circle collider_;                   // Círculo de colisión
+        float creation_counter_;            // Temporizador de creación
+        float creation_counter_ini_;        // Valor inicial del temporizador de creación
+        Uint16 score_;                      // Puntos al destruir el globo
+        Type type_;                         // Tipo de globo
+        Size size_;                         // Tamaño de globo
+        Uint8 menace_;                      // Amenaza que genera el globo
+        Uint32 counter_ = 0;                // Contador interno
+        float travel_y_ = 1.0F;             // Distancia a recorrer en Y antes de aplicar gravedad
+        float speed_;                       // Velocidad del globo
+        float movement_accumulator_ = 0.0f; // Acumulador para movimiento durante creación (deltaTime)
+        Uint8 power_;                       // Poder que alberga el globo
+        SDL_FRect play_area_;               // Zona de movimiento del globo
+        Sound sound_;                       // Configuración de sonido del globo
+        BounceEffect bounce_effect_;        // Efecto de rebote
 
         // --- Posicionamiento y transformación ---
         void shiftColliders();  // Alinea el círculo de colisión con el sprite
         void shiftSprite();     // Alinea el sprite en pantalla
 
         // --- Animación y sonido ---
-        void setAnimation();                            // Establece la animación correspondiente
-        void playSound(const std::string& name) const;  // Reproduce un sonido por nombre
-        void playBouncingSound();                       // Reproduce el sonido de rebote
+        void setAnimation();       // Establece la animación correspondiente
+        void playBouncingSound();  // Reproduce el sonido de rebote
+        void playPoppingSound();   // Reproduce el sonido de reventar
 
         // --- Movimiento y física ---
-        void handleHorizontalMovement();  // Maneja el movimiento horizontal
-        void handleVerticalMovement();    // Maneja el movimiento vertical
-        void applyGravity();              // Aplica la gravedad al objeto
+        void handleHorizontalMovement();                // Maneja el movimiento horizontal (frame-based)
+        void handleHorizontalMovement(float deltaTime); // Maneja el movimiento horizontal (time-based)
+        void handleVerticalMovement();                  // Maneja el movimiento vertical (frame-based)
+        void handleVerticalMovement(float deltaTime);   // Maneja el movimiento vertical (time-based)
+        void applyGravity();                            // Aplica la gravedad al objeto (frame-based)
+        void applyGravity(float deltaTime);             // Aplica la gravedad al objeto (time-based)
 
         // --- Rebote ---
         void enableBounceEffect();                              // Activa el efecto de rebote
@@ -263,5 +303,6 @@ class Balloon {
         void handleBottomCollision();                                                        // Maneja la colisión inferior
 
         // --- Lógica de estado ---
-        void updateState();  // Actualiza los estados del globo
+        void updateState();                   // Actualiza los estados del globo (frame-based)
+        void updateState(float deltaTime);    // Actualiza los estados del globo (time-based)
 };

source/balloon_formations.h

@@ -15,19 +15,24 @@ class BalloonFormations {
     public:
         // --- Estructuras ---
         struct SpawnParams {
-                int x = 0;                                    // Posición en el eje X donde crear el globo
-                int y = 0;                                    // Posición en el eje Y donde crear el globo
+                float x = 0;                                  // Posición en el eje X donde crear el globo
+                float y = 0;                                  // Posición en el eje Y donde crear el globo
                 float vel_x = 0.0F;                           // Velocidad inicial en el eje X
                 Balloon::Type type = Balloon::Type::BALLOON;  // Tipo de globo
                 Balloon::Size size = Balloon::Size::SMALL;    // Tamaño de globo
-                int creation_counter = 0;                     // Temporizador para la creación del globo
+                Uint16 creation_counter = 0;                  // Temporizador para la creación del globo
 
                 // Constructor por defecto
                 SpawnParams() = default;
 
                 // Constructor con parámetros
-                SpawnParams(int x, int y, float vel_x, Balloon::Type type, Balloon::Size size, int creation_counter)
-                    : x(x), y(y), vel_x(vel_x), type(type), size(size), creation_counter(creation_counter) {}
+                SpawnParams(float x, float y, float vel_x, Balloon::Type type, Balloon::Size size, Uint16 creation_counter)
+                    : x(x),
+                      y(y),
+                      vel_x(vel_x),
+                      type(type),
+                      size(size),
+                      creation_counter(creation_counter) {}
         };
 
         struct Formation {

source/balloon_manager.cpp

@@ -17,7 +17,9 @@
 
 // Constructor
 BalloonManager::BalloonManager(IStageInfo *stage_info)
-    : explosions_(std::make_unique<Explosions>()), balloon_formations_(std::make_unique<BalloonFormations>()), stage_info_(stage_info) { init(); }
+    : explosions_(std::make_unique<Explosions>()),
+      balloon_formations_(std::make_unique<BalloonFormations>()),
+      stage_info_(stage_info) { init(); }
 
 // Inicializa
 void BalloonManager::init() {
@@ -60,7 +62,7 @@ void BalloonManager::init() {
     explosions_->addTexture(3, explosions_textures_.at(3), explosions_animations_.at(3));
 }
 
-// Actualiza
+// Actualiza (frame-based)
 void BalloonManager::update() {
     for (const auto &balloon : balloons_) {
         balloon->update();
@@ -69,6 +71,15 @@ void BalloonManager::update() {
     explosions_->update();
 }
 
+// Actualiza (time-based)
+void BalloonManager::update(float deltaTime) {
+    for (const auto &balloon : balloons_) {
+        balloon->update(deltaTime);
+    }
+    updateBalloonDeployCounter(deltaTime);
+    explosions_->update(deltaTime);
+}
+
 // Renderiza los objetos
 void BalloonManager::render() {
     for (auto &balloon : balloons_) {
@@ -105,7 +116,15 @@ void BalloonManager::deployRandomFormation(int stage) {
             // Crea los globos de la formación
             const auto BALLOONS = balloon_formations_->getFormationFromPool(stage, formation_id).balloons;
             for (auto balloon : BALLOONS) {
-                createBalloon(balloon.x, balloon.y, balloon.type, balloon.size, balloon.vel_x, balloon_speed_, (creation_time_enabled_) ? balloon.creation_counter : 0);
+                Balloon::Config config = {
+                    .x = balloon.x,
+                    .y = balloon.y,
+                    .type = balloon.type,
+                    .size = balloon.size,
+                    .vel_x = balloon.vel_x,
+                    .speed = balloon_speed_,
+                    .creation_counter = static_cast<Uint16>(creation_time_enabled_ ? balloon.creation_counter : 0)};
+                createBalloon(config);
             }
 
             // Reinicia el contador para el próximo despliegue
@@ -118,15 +137,31 @@ void BalloonManager::deployRandomFormation(int stage) {
 void BalloonManager::deployFormation(int formation_id) {
     const auto BALLOONS = balloon_formations_->getFormation(formation_id).balloons;
     for (auto balloon : BALLOONS) {
-        createBalloon(balloon.x, balloon.y, balloon.type, balloon.size, balloon.vel_x, balloon_speed_, balloon.creation_counter);
+        Balloon::Config config = {
+            .x = balloon.x,
+            .y = balloon.y,
+            .type = balloon.type,
+            .size = balloon.size,
+            .vel_x = balloon.vel_x,
+            .speed = balloon_speed_,
+            .creation_counter = balloon.creation_counter};
+        createBalloon(config);
     }
 }
 
 // Crea una formación de globos específica a una altura determinada
-void BalloonManager::deployFormation(int formation_id, int y) {
+void BalloonManager::deployFormation(int formation_id, float y) {
     const auto BALLOONS = balloon_formations_->getFormation(formation_id).balloons;
     for (auto balloon : BALLOONS) {
-        createBalloon(balloon.x, y, balloon.type, balloon.size, balloon.vel_x, balloon_speed_, balloon.creation_counter);
+        Balloon::Config config = {
+            .x = balloon.x,
+            .y = y,
+            .type = balloon.type,
+            .size = balloon.size,
+            .vel_x = balloon.vel_x,
+            .speed = balloon_speed_,
+            .creation_counter = balloon.creation_counter};
+        createBalloon(config);
     }
 }
 
@@ -136,13 +171,23 @@ void BalloonManager::freeBalloons() {
     balloons_.erase(result.begin(), balloons_.end());
 }
 
-// Actualiza la variable enemyDeployCounter
+// Actualiza la variable enemyDeployCounter (frame-based)
 void BalloonManager::updateBalloonDeployCounter() {
     if (balloon_deploy_counter_ > 0) {
         --balloon_deploy_counter_;
     }
 }
 
+// Actualiza la variable enemyDeployCounter (time-based)
+void BalloonManager::updateBalloonDeployCounter(float deltaTime) {
+    if (balloon_deploy_counter_ > 0) {
+        // Convertir deltaTime (milisegundos) a factor de frame (asumiendo 60fps)
+        float frameFactor = deltaTime / (1000.0f / 60.0f);
+        balloon_deploy_counter_ -= frameFactor;
+        if (balloon_deploy_counter_ < 0) balloon_deploy_counter_ = 0;
+    }
+}
+
 // Indica si se puede crear una powerball
 auto BalloonManager::canPowerBallBeCreated() -> bool { return (!power_ball_enabled_) && (calculateScreenPower() > Balloon::POWERBALL_SCREENPOWER_MINIMUM) && (power_ball_counter_ == 0); }
 
@@ -152,13 +197,16 @@ auto BalloonManager::calculateScreenPower() -> int {
 }
 
 // Crea un globo nuevo en el vector de globos
-auto BalloonManager::createBalloon(float x, int y, Balloon::Type type, Balloon::Size size, float velx, float speed, int creation_timer) -> std::shared_ptr<Balloon> {
+auto BalloonManager::createBalloon(Balloon::Config config) -> std::shared_ptr<Balloon> {
     if (can_deploy_balloons_) {
-        const int INDEX = static_cast<int>(size);
-        balloons_.emplace_back(std::make_shared<Balloon>(x, y, type, size, velx, speed, creation_timer, play_area_, balloon_textures_.at(INDEX), balloon_animations_.at(INDEX)));
-        balloons_.back()->setSound(sound_enabled_);
-        balloons_.back()->setBouncingSound(bouncing_sound_enabled_);
-        balloons_.back()->setPoppingSound(poping_sound_enabled_);
+        const int INDEX = static_cast<int>(config.size);
+        config.play_area = play_area_;
+        config.texture = balloon_textures_.at(INDEX);
+        config.animation = balloon_animations_.at(INDEX);
+        config.sound.enabled = sound_enabled_;
+        config.sound.bouncing_enabled = bouncing_sound_enabled_;
+        config.sound.poping_enabled = poping_sound_enabled_;
+        balloons_.emplace_back(std::make_shared<Balloon>(config));
         return balloons_.back();
     }
 
@@ -169,19 +217,24 @@ auto BalloonManager::createBalloon(float x, int y, Balloon::Type type, Balloon::
 void BalloonManager::createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction) {
     if (can_deploy_balloons_) {
         // Calcula parametros
-        const float VX = direction == "LEFT" ? Balloon::VELX_NEGATIVE : Balloon::VELX_POSITIVE;
-        const auto SIZE = static_cast<Balloon::Size>(static_cast<int>(balloon->getSize()) - 1);
         const int PARENT_HEIGHT = balloon->getHeight();
         const int CHILD_HEIGHT = Balloon::WIDTH.at(static_cast<int>(balloon->getSize()) - 1);
         const int CHILD_WIDTH = CHILD_HEIGHT;
-        const float Y = balloon->getPosY() + ((PARENT_HEIGHT - CHILD_HEIGHT) / 2);
-        float x = direction == "LEFT" ? balloon->getPosX() + (balloon->getWidth() / 3) : balloon->getPosX() + (2 * (balloon->getWidth() / 3));
+
+        const float X = direction == "LEFT" ? balloon->getPosX() + (balloon->getWidth() / 3) : balloon->getPosX() + (2 * (balloon->getWidth() / 3));
         const float MIN_X = play_area_.x;
         const float MAX_X = play_area_.w - CHILD_WIDTH;
-        x = std::clamp(x - (CHILD_WIDTH / 2), MIN_X, MAX_X);
+
+        Balloon::Config config = {
+            .x = std::clamp(X - (CHILD_WIDTH / 2), MIN_X, MAX_X),
+            .y = balloon->getPosY() + ((PARENT_HEIGHT - CHILD_HEIGHT) / 2),
+            .size = static_cast<Balloon::Size>(static_cast<int>(balloon->getSize()) - 1),
+            .vel_x = direction == "LEFT" ? Balloon::VELX_NEGATIVE : Balloon::VELX_POSITIVE,
+            .speed = balloon_speed_,
+            .creation_counter = 0};
 
         // Crea el globo
-        auto b = createBalloon(x, Y, balloon->getType(), SIZE, VX, balloon_speed_, 0);
+        auto b = createBalloon(config);
 
         // Establece parametros
         b->setVelY(b->getType() == Balloon::Type::BALLOON ? -2.50F : Balloon::VELX_NEGATIVE * 2.0F);
@@ -196,18 +249,32 @@ void BalloonManager::createChildBalloon(const std::shared_ptr<Balloon> &balloon,
 void BalloonManager::createPowerBall() {
     if (can_deploy_balloons_) {
         constexpr int VALUES = 6;
-        constexpr float POS_Y = -Balloon::WIDTH.at(4);
-        constexpr int CREATION_TIME = 0;
+        const int LUCK = rand() % VALUES;
 
         const float LEFT = param.game.play_area.rect.x;
         const float CENTER = param.game.play_area.center_x - (Balloon::WIDTH.at(4) / 2);
         const float RIGHT = param.game.play_area.rect.w - Balloon::WIDTH.at(4);
 
-        const int LUCK = rand() % VALUES;
         const std::array<float, VALUES> POS_X = {LEFT, LEFT, CENTER, CENTER, RIGHT, RIGHT};
         const std::array<float, VALUES> VEL_X = {Balloon::VELX_POSITIVE, Balloon::VELX_POSITIVE, Balloon::VELX_POSITIVE, Balloon::VELX_NEGATIVE, Balloon::VELX_NEGATIVE, Balloon::VELX_NEGATIVE};
 
-        balloons_.emplace_back(std::make_unique<Balloon>(POS_X[LUCK], POS_Y, Balloon::Type::POWERBALL, Balloon::Size::EXTRALARGE, VEL_X[LUCK], balloon_speed_, CREATION_TIME, play_area_, balloon_textures_[4], balloon_animations_[4]));
+        Balloon::Config config = {
+            .x = POS_X.at(LUCK),
+            .y = -Balloon::WIDTH.at(4),
+            .type = Balloon::Type::POWERBALL,
+            .size = Balloon::Size::EXTRALARGE,
+            .vel_x = VEL_X.at(LUCK),
+            .speed = balloon_speed_,
+            .creation_counter = 0,
+            .play_area = play_area_,
+            .texture = balloon_textures_.at(4),
+            .animation = balloon_animations_.at(4),
+            .sound = {
+                .bouncing_enabled = bouncing_sound_enabled_,
+                .poping_enabled = poping_sound_enabled_,
+                .enabled = sound_enabled_}};
+
+        balloons_.emplace_back(std::make_unique<Balloon>(config));
         balloons_.back()->setInvulnerable(true);
 
         power_ball_enabled_ = true;
@@ -332,19 +399,6 @@ void BalloonManager::createTwoBigBalloons() {
     deployFormation(1);
 }
 
-// Crea una disposición de globos aleatoria
-void BalloonManager::createRandomBalloons() {
-    const int NUM_BALLOONS = 2 + (rand() % 4);
-    for (int i = 0; i < NUM_BALLOONS; ++i) {
-        const float X = param.game.game_area.rect.x + (rand() % static_cast<int>(param.game.game_area.rect.w)) - Balloon::WIDTH.at(3);
-        const int Y = param.game.game_area.rect.y + (rand() % 50);
-        const auto SIZE = static_cast<Balloon::Size>(rand() % 4);
-        const float VEL_X = (rand() % 2 == 0) ? Balloon::VELX_POSITIVE : Balloon::VELX_NEGATIVE;
-        const int CREATION_COUNTER = 0;
-        createBalloon(X, Y, Balloon::Type::BALLOON, SIZE, VEL_X, balloon_speed_, CREATION_COUNTER);
-    }
-}
-
 // Obtiene el nivel de ameza actual generado por los globos
 auto BalloonManager::getMenace() -> int {
     return std::accumulate(balloons_.begin(), balloons_.end(), 0, [](int sum, const auto &balloon) { return sum + (balloon->isEnabled() ? balloon->getMenace() : 0); });

source/balloon_manager.h

@@ -28,8 +28,9 @@ class BalloonManager {
         ~BalloonManager() = default;
 
         // --- Métodos principales ---
-        void update();  // Actualiza el estado de los globos
-        void render();  // Renderiza los globos en pantalla
+        void update();                   // Actualiza el estado de los globos (frame-based)
+        void update(float deltaTime);    // Actualiza el estado de los globos (time-based)
+        void render();                   // Renderiza los globos en pantalla
 
         // --- Gestión de globos ---
         void freeBalloons();  // Libera globos que ya no sirven
@@ -37,20 +38,20 @@ class BalloonManager {
         // --- Creación de formaciones enemigas ---
         void deployRandomFormation(int stage);          // Crea una formación de globos aleatoria
         void deployFormation(int formation_id);         // Crea una formación específica
-        void deployFormation(int formation_id, int y);  // Crea una formación específica con coordenadas
+        void deployFormation(int formation_id, float y);  // Crea una formación específica con coordenadas
 
         // --- Creación de globos ---
-        auto createBalloon(float x, int y, Balloon::Type type, Balloon::Size size, float velx, float speed, int creation_timer) -> std::shared_ptr<Balloon>;  // Crea un nuevo globo
+        auto createBalloon(Balloon::Config config) -> std::shared_ptr<Balloon>;  // Crea un nuevo globo
         void createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction);                                                       // Crea un globo a partir de otro
         void createPowerBall();                                                                                                                               // Crea una PowerBall
         void createTwoBigBalloons();                                                                                                                          // Crea dos globos grandes
-        void createRandomBalloons();                                                                                                                          // Crea una disposición aleatoria de globos
 
         // --- Control de velocidad y despliegue ---
         void setBalloonSpeed(float speed);                                             // Ajusta la velocidad de los globos
         void setDefaultBalloonSpeed(float speed) { default_balloon_speed_ = speed; };  // Establece la velocidad base
         void resetBalloonSpeed() { setBalloonSpeed(default_balloon_speed_); };         // Restablece la velocidad de los globos
-        void updateBalloonDeployCounter();                                             // Actualiza el contador de despliegue
+        void updateBalloonDeployCounter();                                             // Actualiza el contador de despliegue (frame-based)
+        void updateBalloonDeployCounter(float deltaTime);                          // Actualiza el contador de despliegue (time-based)
         auto canPowerBallBeCreated() -> bool;                                          // Indica si se puede crear una PowerBall
         auto calculateScreenPower() -> int;                                            // Calcula el poder de los globos en pantalla
 
@@ -99,7 +100,7 @@ class BalloonManager {
         SDL_FRect play_area_ = param.game.play_area.rect;
         float balloon_speed_ = Balloon::SPEED.at(0);
         float default_balloon_speed_ = Balloon::SPEED.at(0);
-        int balloon_deploy_counter_ = 0;
+        float balloon_deploy_counter_ = 0;
         int power_ball_counter_ = 0;
         int last_balloon_deploy_ = 0;
         bool power_ball_enabled_ = false;

source/bullet.cpp

@@ -60,13 +60,19 @@ void Bullet::render() {
     }
 }
 
-// Actualiza el estado del objeto
+// Actualiza el estado del objeto (frame-based)
 auto Bullet::update() -> BulletMoveStatus {
     sprite_->update();
     return move();
 }
 
-// Implementación del movimiento usando BulletMoveStatus
+// Actualiza el estado del objeto (time-based)
+auto Bullet::update(float deltaTime) -> BulletMoveStatus {
+    sprite_->update(deltaTime);
+    return move(deltaTime);
+}
+
+// Implementación del movimiento usando BulletMoveStatus (frame-based)
 auto Bullet::move() -> BulletMoveStatus {
     pos_x_ += vel_x_;
     if (pos_x_ < param.game.play_area.rect.x - WIDTH || pos_x_ > param.game.play_area.rect.w) {
@@ -86,6 +92,29 @@ auto Bullet::move() -> BulletMoveStatus {
     return BulletMoveStatus::OK;
 }
 
+// Implementación del movimiento usando BulletMoveStatus (time-based)
+auto Bullet::move(float deltaTime) -> BulletMoveStatus {
+    // Convertir deltaTime (milisegundos) a factor de frame (asumiendo 60fps)
+    float frameFactor = deltaTime / (1000.0f / 60.0f);
+    
+    pos_x_ += vel_x_ * frameFactor;
+    if (pos_x_ < param.game.play_area.rect.x - WIDTH || pos_x_ > param.game.play_area.rect.w) {
+        disable();
+        return BulletMoveStatus::OUT;
+    }
+
+    pos_y_ += VEL_Y * frameFactor;
+    if (pos_y_ < param.game.play_area.rect.y - HEIGHT) {
+        disable();
+        return BulletMoveStatus::OUT;
+    }
+
+    shiftSprite();
+    shiftColliders();
+
+    return BulletMoveStatus::OK;
+}
+
 auto Bullet::isEnabled() const -> bool {
     return bullet_type_ != BulletType::NONE;
 }

source/bullet.h

@@ -34,9 +34,10 @@ class Bullet {
         ~Bullet() = default;                                                               // Destructor
 
         // --- Métodos principales ---
-        void render();                      // Dibuja la bala en pantalla
-        auto update() -> BulletMoveStatus;  // Actualiza el estado del objeto
-        void disable();                     // Desactiva la bala
+        void render();                                   // Dibuja la bala en pantalla
+        auto update() -> BulletMoveStatus;               // Actualiza el estado del objeto (frame-based)
+        auto update(float deltaTime) -> BulletMoveStatus; // Actualiza el estado del objeto (time-based)
+        void disable();                                  // Desactiva la bala
 
         // --- Getters ---
         [[nodiscard]] auto isEnabled() const -> bool;       // Comprueba si está activa
@@ -64,7 +65,8 @@ class Bullet {
         // --- Métodos internos ---
         void shiftColliders();                                                                  // Ajusta el círculo de colisión
         void shiftSprite();                                                                     // Ajusta el sprite
-        auto move() -> BulletMoveStatus;                                                        // Mueve la bala y devuelve su estado
+        auto move() -> BulletMoveStatus;                                                        // Mueve la bala y devuelve su estado (frame-based)
+        auto move(float deltaTime) -> BulletMoveStatus;                                         // Mueve la bala y devuelve su estado (time-based)
         static auto calculateVelocity(BulletType bullet_type) -> float;                         // Calcula la velocidad horizontal de la bala
         static auto buildAnimationString(BulletType bullet_type, bool powered) -> std::string;  // Construye el string de animación
 };

source/color.cpp

@@ -116,71 +116,71 @@ constexpr auto Color::hsvToRgb(HSV hsv) -> Color {
 
 // Implementaciones del namespace Colors
 namespace Colors {
-    // Obtiene un color del vector de colores imitando al Coche Fantástico
-    auto getColorLikeKnightRider(const std::vector<Color> &colors, int counter) -> Color {
-        int cycle_length = (colors.size() * 2) - 2;
-        size_t n = counter % cycle_length;
+// Obtiene un color del vector de colores imitando al Coche Fantástico
+auto getColorLikeKnightRider(const std::vector<Color> &colors, int counter) -> Color {
+    int cycle_length = (colors.size() * 2) - 2;
+    size_t n = counter % cycle_length;
 
-        size_t index;
-        if (n < colors.size()) {
-            index = n;  // Avanza: 0,1,2,3
-        } else {
-            index = 2 * (colors.size() - 1) - n;  // Retrocede: 2,1
-        }
-
-        return colors[index];
+    size_t index;
+    if (n < colors.size()) {
+        index = n;  // Avanza: 0,1,2,3
+    } else {
+        index = 2 * (colors.size() - 1) - n;  // Retrocede: 2,1
     }
 
-    auto generateMirroredCycle(Color base, ColorCycleStyle style) -> Cycle {
-        Cycle result{};
-        HSV base_hsv = Color::rgbToHsv(base);
+    return colors[index];
+}
 
-        for (size_t i = 0; i < CYCLE_SIZE; ++i) {
-            float t = static_cast<float>(i) / (CYCLE_SIZE - 1);  // 0 → 1
-            float hue_shift = 0.0F;
-            float sat_shift = 0.0F;
-            float val_shift = 0.0F;
+auto generateMirroredCycle(Color base, ColorCycleStyle style) -> Cycle {
+    Cycle result{};
+    HSV base_hsv = Color::rgbToHsv(base);
 
-            switch (style) {
-                case ColorCycleStyle::SUBTLE_PULSE:
-                    // Solo brillo suave
-                    val_shift = 0.07F * sinf(t * M_PI);
-                    break;
+    for (size_t i = 0; i < CYCLE_SIZE; ++i) {
+        float t = static_cast<float>(i) / (CYCLE_SIZE - 1);  // 0 → 1
+        float hue_shift = 0.0F;
+        float sat_shift = 0.0F;
+        float val_shift = 0.0F;
 
-                case ColorCycleStyle::HUE_WAVE:
-                    // Oscilación leve de tono
-                    hue_shift = 15.0F * (t - 0.5F) * 2.0F;
-                    val_shift = 0.05F * sinf(t * M_PI);
-                    break;
+        switch (style) {
+            case ColorCycleStyle::SUBTLE_PULSE:
+                // Solo brillo suave
+                val_shift = 0.07F * sinf(t * M_PI);
+                break;
 
-                case ColorCycleStyle::VIBRANT:
-                    // Cambios fuertes en tono y brillo
-                    hue_shift = 35.0F * sinf(t * M_PI);
-                    val_shift = 0.2F * sinf(t * M_PI);
-                    sat_shift = -0.2F * sinf(t * M_PI);
-                    break;
+            case ColorCycleStyle::HUE_WAVE:
+                // Oscilación leve de tono
+                hue_shift = 15.0F * (t - 0.5F) * 2.0F;
+                val_shift = 0.05F * sinf(t * M_PI);
+                break;
 
-                case ColorCycleStyle::DARKEN_GLOW:
-                    // Se oscurece al centro
-                    val_shift = -0.15F * sinf(t * M_PI);
-                    break;
+            case ColorCycleStyle::VIBRANT:
+                // Cambios fuertes en tono y brillo
+                hue_shift = 35.0F * sinf(t * M_PI);
+                val_shift = 0.2F * sinf(t * M_PI);
+                sat_shift = -0.2F * sinf(t * M_PI);
+                break;
 
-                case ColorCycleStyle::LIGHT_FLASH:
-                    // Se ilumina al centro
-                    val_shift = 0.25F * sinf(t * M_PI);
-                    break;
-            }
+            case ColorCycleStyle::DARKEN_GLOW:
+                // Se oscurece al centro
+                val_shift = -0.15F * sinf(t * M_PI);
+                break;
 
-            HSV adjusted = {
-                .h = fmodf(base_hsv.h + hue_shift + 360.0F, 360.0F),
-                .s = fminf(1.0F, fmaxf(0.0F, base_hsv.s + sat_shift)),
-                .v = fminf(1.0F, fmaxf(0.0F, base_hsv.v + val_shift))};
-
-            Color c = Color::hsvToRgb(adjusted);
-            result[i] = c;
-            result[(2 * CYCLE_SIZE) - 1 - i] = c;  // espejo
+            case ColorCycleStyle::LIGHT_FLASH:
+                // Se ilumina al centro
+                val_shift = 0.25F * sinf(t * M_PI);
+                break;
         }
 
-        return result;
+        HSV adjusted = {
+            .h = fmodf(base_hsv.h + hue_shift + 360.0F, 360.0F),
+            .s = fminf(1.0F, fmaxf(0.0F, base_hsv.s + sat_shift)),
+            .v = fminf(1.0F, fmaxf(0.0F, base_hsv.v + val_shift))};
+
+        Color c = Color::hsvToRgb(adjusted);
+        result[i] = c;
+        result[(2 * CYCLE_SIZE) - 1 - i] = c;  // espejo
     }
-}
+
+    return result;
+}
+}  // namespace Colors

source/color.h

@@ -36,10 +36,17 @@ struct Color {
 
         Uint8 r, g, b, a;
 
-        constexpr Color() : r(MIN_COLOR_VALUE), g(MIN_COLOR_VALUE), b(MIN_COLOR_VALUE), a(DEFAULT_ALPHA) {}
+        constexpr Color()
+            : r(MIN_COLOR_VALUE),
+              g(MIN_COLOR_VALUE),
+              b(MIN_COLOR_VALUE),
+              a(DEFAULT_ALPHA) {}
 
         explicit constexpr Color(Uint8 red, Uint8 green, Uint8 blue, Uint8 alpha = DEFAULT_ALPHA)
-            : r(red), g(green), b(blue), a(alpha) {}
+            : r(red),
+              g(green),
+              b(blue),
+              a(alpha) {}
 
         [[nodiscard]] constexpr auto INVERSE() const -> Color {
             return Color(MAX_COLOR_VALUE - r, MAX_COLOR_VALUE - g, MAX_COLOR_VALUE - b, a);
@@ -108,25 +115,25 @@ enum class ColorCycleStyle {
 
 // --- Namespace Colors: constantes y utilidades de color ---
 namespace Colors {
-    // --- Constantes ---
-    constexpr size_t CYCLE_SIZE = 6;  // Mitad del ciclo espejado
+// --- Constantes ---
+constexpr size_t CYCLE_SIZE = 6;  // Mitad del ciclo espejado
 
-    // --- Alias ---
-    using Cycle = std::array<Color, 2 * CYCLE_SIZE>;
+// --- Alias ---
+using Cycle = std::array<Color, 2 * CYCLE_SIZE>;
 
-    // --- Colores predefinidos ---
-    constexpr Color NO_COLOR_MOD = Color(0XFF, 0XFF, 0XFF);
-    constexpr Color SHADOW_TEXT = Color(0X43, 0X43, 0X4F);
-    constexpr Color TITLE_SHADOW_TEXT = Color(0x14, 0x87, 0xc4);
-    constexpr Color ORANGE_TEXT = Color(0XFF, 0X7A, 0X00);
+// --- Colores predefinidos ---
+constexpr Color NO_COLOR_MOD = Color(0XFF, 0XFF, 0XFF);
+constexpr Color SHADOW_TEXT = Color(0X43, 0X43, 0X4F);
+constexpr Color TITLE_SHADOW_TEXT = Color(0x14, 0x87, 0xc4);
+constexpr Color ORANGE_TEXT = Color(0XFF, 0X7A, 0X00);
 
-    constexpr Color FLASH = Color(0XFF, 0XFF, 0XFF);
+constexpr Color FLASH = Color(0XFF, 0XFF, 0XFF);
 
-    constexpr Color BLUE_SKY = Color(0X02, 0X88, 0XD1);
-    constexpr Color PINK_SKY = Color(0XFF, 0X6B, 0X97);
-    constexpr Color GREEN_SKY = Color(0X00, 0X79, 0X6B);
+constexpr Color BLUE_SKY = Color(0X02, 0X88, 0XD1);
+constexpr Color PINK_SKY = Color(0XFF, 0X6B, 0X97);
+constexpr Color GREEN_SKY = Color(0X00, 0X79, 0X6B);
 
-    // --- Funciones ---
-    auto getColorLikeKnightRider(const std::vector<Color> &colors, int counter) -> Color;
-    auto generateMirroredCycle(Color base, ColorCycleStyle style = ColorCycleStyle::SUBTLE_PULSE) -> Cycle;
-}
+// --- Funciones ---
+auto getColorLikeKnightRider(const std::vector<Color> &colors, int counter) -> Color;
+auto generateMirroredCycle(Color base, ColorCycleStyle style = ColorCycleStyle::SUBTLE_PULSE) -> Cycle;
+}  // namespace Colors

source/defaults.h

@@ -76,7 +76,8 @@ struct BalloonSettings {
         float vel;
         float grav;
         constexpr BalloonSettings(float v, float g)
-            : vel(v), grav(g) {}
+            : vel(v),
+              grav(g) {}
 };
 
 constexpr std::array<BalloonSettings, 4> SETTINGS = {{

source/define_buttons.h

@@ -25,7 +25,9 @@ class DefineButtons {
                 int button;
 
                 Button(std::string label, Input::Action action, int button)
-                    : label(std::move(label)), action(action), button(button) {}
+                    : label(std::move(label)),
+                      action(action),
+                      button(button) {}
         };
 
         // --- Constructor y destructor ---

source/director.cpp

@@ -20,6 +20,7 @@
 #include "param.h"                   // Para loadParamsFromFile
 #include "player.h"                  // Para Player
 #include "resource.h"                // Para Resource
+#include "resource_helper.h"         // Para ResourceHelper
 #include "screen.h"                  // Para Screen
 #include "section.hpp"               // Para Name, Options, name, options, AttractMode, attract_mode
 #include "sections/credits.h"        // Para Credits
@@ -76,7 +77,13 @@ Director::~Director() {
 // Inicializa todo
 void Director::init() {
     // Configuración inicial de parametros
-    Asset::init(executable_path_);                                                                  // Inicializa el sistema de gestión de archivos
+    Asset::init(executable_path_);  // Inicializa el sistema de gestión de archivos
+
+#ifdef MACOS_BUNDLE
+    ResourceHelper::initializeResourceSystem(executable_path_ + "/../Resources/resources.pack");
+#else
+    ResourceHelper::initializeResourceSystem("resources.pack");
+#endif
     loadAssets();                                                                                   // Crea el índice de archivos
     Input::init(Asset::get()->get("gamecontrollerdb.txt"), Asset::get()->get("controllers.json"));  // Carga configuración de controles
     Options::setConfigFile(Asset::get()->get("config.txt"));                                        // Establece el fichero de configuración
@@ -154,7 +161,7 @@ void Director::loadAssets() {
 #endif
 
     // Cargar la configuración de assets (también aplicar el prefijo al archivo de configuración)
-    std::string config_path = executable_path_ + PREFIX + "/data/config/assets.txt";
+    std::string config_path = executable_path_ + PREFIX + "/config/assets.txt";
     Asset::get()->loadFromFile(config_path, PREFIX, system_folder_);
 
     SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Assets configuration loaded successfully");

source/enter_name.cpp

@@ -45,7 +45,10 @@ void EnterName::incPosition() {
     } else if (position_ > 0)       // No es necesario verificar position_ < MAX_NAME_LENGTH
     {
         // Copiamos el índice del carácter anterior si es posible.
-        character_index_[position_] = character_index_[position_ - 1];
+        // character_index_[position_] = character_index_[position_ - 1];
+
+        // Ponemos el caracter "espacio"
+        character_index_[position_] = 0;
     } else {
         // Si position_ es 0, inicializamos el carácter actual.
         character_index_[position_] = 0;
@@ -144,12 +147,19 @@ auto EnterName::findIndex(char character) const -> int {
 // Devuelve un nombre al azar
 auto EnterName::getRandomName() -> std::string {
     static constexpr std::array<std::string_view, 8> NAMES = {
-        "BAL1", "TABE", "DOC", "MON", "SAM1", "JORDI", "JDES", "PEPE"};
+        "BAL1",
+        "TABE",
+        "DOC",
+        "MON",
+        "SAM1",
+        "JORDI",
+        "JDES",
+        "PEPE"};
     return std::string(NAMES[rand() % NAMES.size()]);
 }
 // Obtiene el nombre final introducido
 auto EnterName::getFinalName() -> std::string {
-    auto name = trim(name_.substr(0, position_));
+    auto name = trim(name_.substr(0, position_ + 1));  // Devuelve el texto intruducido incluyendo el del selector
     if (name.empty()) {
         name = getRandomName();
     }

source/explosions.cpp

@@ -6,7 +6,7 @@
 
 class Texture;  // lines 4-4
 
-// Actualiza la lógica de la clase
+// Actualiza la lógica de la clase (frame-based)
 void Explosions::update() {
     for (auto &explosion : explosions_) {
         explosion->update();
@@ -16,6 +16,16 @@ void Explosions::update() {
     freeExplosions();
 }
 
+// Actualiza la lógica de la clase (time-based)
+void Explosions::update(float deltaTime) {
+    for (auto &explosion : explosions_) {
+        explosion->update(deltaTime);
+    }
+
+    // Vacia el vector de elementos finalizados
+    freeExplosions();
+}
+
 // Dibuja el objeto en pantalla
 void Explosions::render() {
     for (auto &explosion : explosions_) {

source/explosions.h

@@ -16,7 +16,9 @@ struct ExplosionTexture {
         std::vector<std::string> animation;  // Animación para la textura
 
         ExplosionTexture(int sz, std::shared_ptr<Texture> tex, const std::vector<std::string> &anim)
-            : size(sz), texture(std::move(tex)), animation(anim) {}
+            : size(sz),
+              texture(std::move(tex)),
+              animation(anim) {}
 };
 
 // --- Clase Explosions: gestor de explosiones ---
@@ -27,8 +29,9 @@ class Explosions {
         ~Explosions() = default;  // Destructor por defecto
 
         // --- Métodos principales ---
-        void update();  // Actualiza la lógica de la clase
-        void render();  // Dibuja el objeto en pantalla
+        void update();                    // Actualiza la lógica de la clase (frame-based)
+        void update(float deltaTime);     // Actualiza la lógica de la clase (time-based)
+        void render();                    // Dibuja el objeto en pantalla
 
         // --- Configuración ---
         void addTexture(int size, const std::shared_ptr<Texture> &texture, const std::vector<std::string> &animation);  // Añade texturas al objeto

source/fade.cpp

@@ -41,7 +41,7 @@ void Fade::init() {
     num_squares_width_ = param.fade.num_squares_width;
     num_squares_height_ = param.fade.num_squares_height;
     random_squares_duration_ = param.fade.random_squares_duration_ms;  // Usar como duración en ms
-    square_transition_duration_ = random_squares_duration_ / 4;  // 25% del tiempo total para la transición individual
+    square_transition_duration_ = random_squares_duration_ / 4;        // 25% del tiempo total para la transición individual
     random_squares_start_time_ = 0;
 }
 
@@ -60,7 +60,7 @@ void Fade::render() {
         if (state_ == State::FINISHED && mode_ == Mode::IN) {
             return;
         }
-        
+
         SDL_RenderTexture(renderer_, backbuffer_, nullptr, nullptr);
     }
 }
@@ -82,10 +82,15 @@ void Fade::update() {
     }
 }
 
+// Compatibilidad delta-time (ignora el parámetro ya que usa SDL_GetTicks)
+void Fade::update(float delta_time) {
+    update();  // Llama al método original
+}
+
 void Fade::updatePreState() {
     // Sistema basado en tiempo únicamente
     Uint32 elapsed_time = SDL_GetTicks() - pre_start_time_;
-    
+
     if (elapsed_time >= static_cast<Uint32>(pre_duration_)) {
         state_ = State::FADING;
         // CRÍTICO: Reinicializar tiempo de inicio para tipos que usan random_squares_start_time_
@@ -129,17 +134,17 @@ void Fade::changeToPostState() {
 void Fade::updatePostState() {
     // Sistema basado en tiempo únicamente
     Uint32 elapsed_time = SDL_GetTicks() - post_start_time_;
-    
+
     if (elapsed_time >= static_cast<Uint32>(post_duration_)) {
         state_ = State::FINISHED;
     }
-    
+
     // Mantener el alpha final correcto para cada tipo de fade
     Uint8 post_alpha = a_;
     if (type_ == Type::RANDOM_SQUARE2 || type_ == Type::DIAGONAL) {
         post_alpha = (mode_ == Mode::OUT) ? 255 : 0;
     }
-    
+
     cleanBackbuffer(r_, g_, b_, post_alpha);
 }
 
@@ -204,16 +209,16 @@ void Fade::updateRandomSquareFade() {
 
 void Fade::updateRandomSquare2Fade() {
     Uint32 elapsed_time = SDL_GetTicks() - random_squares_start_time_;
-    
+
     int total_squares = num_squares_width_ * num_squares_height_;
-    
+
     // Calcula el tiempo de activación: total - tiempo que necesitan los últimos cuadrados
     int activation_time = random_squares_duration_ - square_transition_duration_;
     activation_time = std::max(activation_time, square_transition_duration_);  // Mínimo igual a la duración de transición
-    
+
     // Lógica diferente según el modo
     int squares_to_activate = 0;
-    
+
     if (mode_ == Mode::OUT) {
         // OUT: Activa cuadrados gradualmente
         if (elapsed_time < static_cast<Uint32>(activation_time)) {
@@ -222,7 +227,7 @@ void Fade::updateRandomSquare2Fade() {
         } else {
             squares_to_activate = total_squares;  // Activar todos
         }
-        
+
         // Activa nuevos cuadrados y guarda su tiempo de activación
         for (int i = 0; i < squares_to_activate && i < total_squares; ++i) {
             if (square_age_[i] == -1) {
@@ -232,22 +237,22 @@ void Fade::updateRandomSquare2Fade() {
     } else {
         // IN: Todos los cuadrados empiezan activos desde el inicio
         squares_to_activate = total_squares;
-        
+
         // Activa cuadrados gradualmente con tiempo de inicio escalonado
         float activation_progress = static_cast<float>(elapsed_time) / activation_time;
         int squares_starting_transition = static_cast<int>(activation_progress * total_squares);
-        
+
         // Asegurar que al menos 1 cuadrado se active desde el primer frame
         squares_starting_transition = std::max(squares_starting_transition, 1);
         squares_starting_transition = std::min(squares_starting_transition, total_squares);
-        
+
         for (int i = 0; i < squares_starting_transition; ++i) {
             if (square_age_[i] == -1) {
                 square_age_[i] = elapsed_time;  // Empieza la transición a transparente
             }
         }
     }
-    
+
     drawRandomSquares2();
 
     value_ = calculateValue(0, total_squares, squares_to_activate);
@@ -265,7 +270,7 @@ void Fade::updateRandomSquare2Fade() {
                 }
             }
         }
-        
+
         if (all_completed) {
             // Pintar textura final: OUT opaca, IN transparente
             Uint8 final_alpha = (mode_ == Mode::OUT) ? 255 : 0;
@@ -277,17 +282,17 @@ void Fade::updateRandomSquare2Fade() {
 
 void Fade::updateDiagonalFade() {
     Uint32 elapsed_time = SDL_GetTicks() - random_squares_start_time_;
-    
+
     int total_squares = num_squares_width_ * num_squares_height_;
-    
+
     // Calcula el tiempo de activación: total - tiempo que necesitan los últimos cuadrados
     int activation_time = random_squares_duration_ - square_transition_duration_;
     activation_time = std::max(activation_time, square_transition_duration_);
-    
+
     // Calcula cuántas diagonales deberían estar activas
     int max_diagonal = num_squares_width_ + num_squares_height_ - 1;  // Número total de diagonales
     int active_diagonals = 0;
-    
+
     if (mode_ == Mode::OUT) {
         // OUT: Activa diagonales gradualmente desde esquina superior izquierda
         if (elapsed_time < static_cast<Uint32>(activation_time)) {
@@ -296,7 +301,7 @@ void Fade::updateDiagonalFade() {
         } else {
             active_diagonals = max_diagonal;  // Activar todas
         }
-        
+
         // Activa cuadrados por diagonales
         for (int diagonal = 0; diagonal < active_diagonals; ++diagonal) {
             activateDiagonal(diagonal, elapsed_time);
@@ -304,12 +309,12 @@ void Fade::updateDiagonalFade() {
     } else {
         // IN: Todas las diagonales empiezan activas, van desapareciendo
         active_diagonals = max_diagonal;
-        
+
         // Activa diagonales gradualmente para transición
         if (elapsed_time < static_cast<Uint32>(activation_time)) {
             float activation_progress = static_cast<float>(elapsed_time) / activation_time;
             int diagonals_starting_transition = static_cast<int>(activation_progress * max_diagonal);
-            
+
             for (int diagonal = 0; diagonal < diagonals_starting_transition; ++diagonal) {
                 activateDiagonal(diagonal, elapsed_time);
             }
@@ -320,7 +325,7 @@ void Fade::updateDiagonalFade() {
             }
         }
     }
-    
+
     drawDiagonal();
 
     value_ = calculateValue(0, total_squares, active_diagonals * (total_squares / max_diagonal));
@@ -338,7 +343,7 @@ void Fade::updateDiagonalFade() {
                 }
             }
         }
-        
+
         if (all_completed) {
             // Pintar textura final: OUT opaca, IN transparente
             Uint8 final_alpha = (mode_ == Mode::OUT) ? 255 : 0;
@@ -354,15 +359,15 @@ void Fade::activateDiagonal(int diagonal_index, Uint32 current_time) {
     // Diagonal 1: (1,0), (0,1)
     // Diagonal 2: (2,0), (1,1), (0,2)
     // etc.
-    
+
     for (int x = 0; x < num_squares_width_; ++x) {
         int y = diagonal_index - x;
-        
+
         // Verificar que y está dentro de los límites
         if (y >= 0 && y < num_squares_height_) {
             // Convertir coordenadas (x,y) a índice en el vector
             int index = y * num_squares_width_ + x;
-            
+
             if (index >= 0 && index < static_cast<int>(square_age_.size())) {
                 if (square_age_[index] == -1) {
                     square_age_[index] = current_time;  // Guarda el tiempo de activación
@@ -385,30 +390,30 @@ void Fade::drawDiagonal() {
     SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);  // Usar BLEND para alpha
 
     Uint32 current_time = SDL_GetTicks() - random_squares_start_time_;
-    
+
     // Lógica unificada: sobre textura transparente, pintar cuadrados según su estado
     for (size_t i = 0; i < square_.size(); ++i) {
         Uint8 current_alpha = 0;
-        
+
         if (square_age_[i] == -1) {
             // Cuadrado no activado
             if (mode_ == Mode::OUT) {
                 current_alpha = 0;  // OUT: transparente si no activado
             } else {
-                current_alpha = a_;  // IN: opaco si no activado  
+                current_alpha = a_;  // IN: opaco si no activado
             }
         } else {
             // Cuadrado activado - calculamos progreso
             Uint32 square_elapsed = current_time - square_age_[i];
             float progress = std::min(static_cast<float>(square_elapsed) / square_transition_duration_, 1.0f);
-            
+
             if (mode_ == Mode::OUT) {
                 current_alpha = static_cast<Uint8>(progress * a_);  // 0 → 255
             } else {
                 current_alpha = static_cast<Uint8>((1.0f - progress) * a_);  // 255 → 0
             }
         }
-        
+
         if (current_alpha > 0) {
             SDL_SetRenderDrawColor(renderer_, r_, g_, b_, current_alpha);
             SDL_RenderFillRect(renderer_, &square_[i]);
@@ -450,30 +455,30 @@ void Fade::drawRandomSquares2() {
     SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);  // Usar BLEND para alpha
 
     Uint32 current_time = SDL_GetTicks() - random_squares_start_time_;
-    
+
     // Lógica unificada: sobre textura transparente, pintar cuadrados según su estado
     for (size_t i = 0; i < square_.size(); ++i) {
         Uint8 current_alpha = 0;
-        
+
         if (square_age_[i] == -1) {
             // Cuadrado no activado
             if (mode_ == Mode::OUT) {
                 current_alpha = 0;  // OUT: transparente si no activado
             } else {
-                current_alpha = a_;  // IN: opaco si no activado  
+                current_alpha = a_;  // IN: opaco si no activado
             }
         } else {
             // Cuadrado activado - calculamos progreso
             Uint32 square_elapsed = current_time - square_age_[i];
             float progress = std::min(static_cast<float>(square_elapsed) / square_transition_duration_, 1.0f);
-            
+
             if (mode_ == Mode::OUT) {
                 current_alpha = static_cast<Uint8>(progress * a_);  // 0 → 255
             } else {
                 current_alpha = static_cast<Uint8>((1.0f - progress) * a_);  // 255 → 0
             }
         }
-        
+
         if (current_alpha > 0) {
             SDL_SetRenderDrawColor(renderer_, r_, g_, b_, current_alpha);
             SDL_RenderFillRect(renderer_, &square_[i]);

source/fade.h

@@ -11,12 +11,12 @@ class Fade {
     public:
         // --- Enums ---
         enum class Type : Uint8 {
-            FULLSCREEN = 0,     // Fundido de pantalla completa
-            CENTER = 1,         // Fundido desde el centro
-            RANDOM_SQUARE = 2,  // Fundido con cuadrados aleatorios
-            RANDOM_SQUARE2 = 3, // Fundido con cuadrados aleatorios (variante 2)
-            DIAGONAL = 4,       // Fundido diagonal desde esquina superior izquierda
-            VENETIAN = 5,       // Fundido tipo persiana veneciana
+            FULLSCREEN = 0,      // Fundido de pantalla completa
+            CENTER = 1,          // Fundido desde el centro
+            RANDOM_SQUARE = 2,   // Fundido con cuadrados aleatorios
+            RANDOM_SQUARE2 = 3,  // Fundido con cuadrados aleatorios (variante 2)
+            DIAGONAL = 4,        // Fundido diagonal desde esquina superior izquierda
+            VENETIAN = 5,        // Fundido tipo persiana veneciana
         };
 
         enum class Mode : Uint8 {
@@ -37,10 +37,11 @@ class Fade {
         ~Fade();
 
         // --- Métodos principales ---
-        void reset();     // Resetea variables para reutilizar el fade
-        void render();    // Dibuja la transición en pantalla
-        void update();    // Actualiza el estado interno
-        void activate();  // Activa el fade
+        void reset();                  // Resetea variables para reutilizar el fade
+        void render();                 // Dibuja la transición en pantalla
+        void update();                 // Actualiza el estado interno (ya usa tiempo real)
+        void update(float delta_time); // Compatibilidad delta-time (ignora el parámetro)
+        void activate();               // Activa el fade
 
         // --- Configuración ---
         void setColor(Uint8 r, Uint8 g, Uint8 b);                    // Establece el color RGB del fade
@@ -104,10 +105,10 @@ class Fade {
         void calculateVenetianProgress();  // Calcula el progreso del efecto veneciano
 
         // --- Dibujo de efectos visuales ---
-        void drawCenterFadeRectangles();  // Dibuja los rectángulos del fundido central
-        void drawRandomSquares(int active_count = -1);  // Dibuja los cuadrados aleatorios del fundido
-        void drawRandomSquares2();        // Dibuja los cuadrados con transición de color (RANDOM_SQUARE2)
-        void drawDiagonal();              // Dibuja los cuadrados con patrón diagonal
+        void drawCenterFadeRectangles();                                 // Dibuja los rectángulos del fundido central
+        void drawRandomSquares(int active_count = -1);                   // Dibuja los cuadrados aleatorios del fundido
+        void drawRandomSquares2();                                       // Dibuja los cuadrados con transición de color (RANDOM_SQUARE2)
+        void drawDiagonal();                                             // Dibuja los cuadrados con patrón diagonal
         void activateDiagonal(int diagonal_index, Uint32 current_time);  // Activa una diagonal específica
-        void drawVenetianBlinds();        // Dibuja las persianas venecianas del fundido
+        void drawVenetianBlinds();                                       // Dibuja las persianas venecianas del fundido
 };

source/game_logo.cpp

@@ -45,6 +45,7 @@ void GameLogo::init() {
     arcade_edition_status_ = Status::DISABLED;
     shake_.init(1, 2, 8, XP);
     zoom_ = 3.0F * ZOOM_FACTOR;
+    post_finished_time_accumulator_ = 0.0f;
 
     // Inicializa el bitmap de 'Coffee'
     coffee_sprite_->setPosX(XP);
@@ -112,13 +113,20 @@ void GameLogo::render() {
     }
 }
 
-// Actualiza la lógica de la clase
+// Actualiza la lógica de la clase (frame-based)
 void GameLogo::update() {
     updateCoffeeCrisis();
     updateArcadeEdition();
     updatePostFinishedCounter();
 }
 
+// Actualiza la lógica de la clase (time-based)
+void GameLogo::update(float deltaTime) {
+    updateCoffeeCrisis(deltaTime);
+    updateArcadeEdition(deltaTime);
+    updatePostFinishedCounter(deltaTime);
+}
+
 void GameLogo::updateCoffeeCrisis() {
     switch (coffee_crisis_status_) {
         case Status::MOVING:
@@ -135,6 +143,22 @@ void GameLogo::updateCoffeeCrisis() {
     }
 }
 
+void GameLogo::updateCoffeeCrisis(float deltaTime) {
+    switch (coffee_crisis_status_) {
+        case Status::MOVING:
+            handleCoffeeCrisisMoving(deltaTime);
+            break;
+        case Status::SHAKING:
+            handleCoffeeCrisisShaking(deltaTime);
+            break;
+        case Status::FINISHED:
+            handleCoffeeCrisisFinished(deltaTime);
+            break;
+        default:
+            break;
+    }
+}
+
 void GameLogo::updateArcadeEdition() {
     switch (arcade_edition_status_) {
         case Status::MOVING:
@@ -148,6 +172,19 @@ void GameLogo::updateArcadeEdition() {
     }
 }
 
+void GameLogo::updateArcadeEdition(float deltaTime) {
+    switch (arcade_edition_status_) {
+        case Status::MOVING:
+            handleArcadeEditionMoving(deltaTime);
+            break;
+        case Status::SHAKING:
+            handleArcadeEditionShaking(deltaTime);
+            break;
+        default:
+            break;
+    }
+}
+
 void GameLogo::handleCoffeeCrisisMoving() {
     coffee_sprite_->update();
     crisis_sprite_->update();
@@ -158,6 +195,16 @@ void GameLogo::handleCoffeeCrisisMoving() {
     }
 }
 
+void GameLogo::handleCoffeeCrisisMoving(float deltaTime) {
+    coffee_sprite_->update(deltaTime);
+    crisis_sprite_->update(deltaTime);
+
+    if (coffee_sprite_->hasFinished() && crisis_sprite_->hasFinished()) {
+        coffee_crisis_status_ = Status::SHAKING;
+        playTitleEffects();
+    }
+}
+
 void GameLogo::handleCoffeeCrisisShaking() {
     if (shake_.remaining > 0) {
         processShakeEffect(coffee_sprite_.get(), crisis_sprite_.get());
@@ -168,10 +215,24 @@ void GameLogo::handleCoffeeCrisisShaking() {
     updateDustSprites();
 }
 
+void GameLogo::handleCoffeeCrisisShaking(float deltaTime) {
+    if (shake_.remaining > 0) {
+        processShakeEffect(coffee_sprite_.get(), crisis_sprite_.get(), deltaTime);
+    } else {
+        finishCoffeeCrisisShaking();
+    }
+
+    updateDustSprites(deltaTime);
+}
+
 void GameLogo::handleCoffeeCrisisFinished() {
     updateDustSprites();
 }
 
+void GameLogo::handleCoffeeCrisisFinished(float deltaTime) {
+    updateDustSprites(deltaTime);
+}
+
 void GameLogo::handleArcadeEditionMoving() {
     zoom_ -= 0.1F * ZOOM_FACTOR;
     arcade_edition_sprite_->setZoom(zoom_);
@@ -181,6 +242,16 @@ void GameLogo::handleArcadeEditionMoving() {
     }
 }
 
+void GameLogo::handleArcadeEditionMoving(float deltaTime) {
+    // Convertir 0.1F * ZOOM_FACTOR por frame a por milisegundo (asumiendo 60fps)
+    zoom_ -= (0.1F * ZOOM_FACTOR) * deltaTime / (1000.0F / 60.0F);
+    arcade_edition_sprite_->setZoom(zoom_);
+
+    if (zoom_ <= 1.0F) {
+        finishArcadeEditionMoving();
+    }
+}
+
 void GameLogo::handleArcadeEditionShaking() {
     if (shake_.remaining > 0) {
         processArcadeEditionShake();
@@ -190,6 +261,15 @@ void GameLogo::handleArcadeEditionShaking() {
     }
 }
 
+void GameLogo::handleArcadeEditionShaking(float deltaTime) {
+    if (shake_.remaining > 0) {
+        processArcadeEditionShake(deltaTime);
+    } else {
+        arcade_edition_sprite_->setX(shake_.origin);
+        arcade_edition_status_ = Status::FINISHED;
+    }
+}
+
 void GameLogo::processShakeEffect(SmartSprite* primary_sprite, SmartSprite* secondary_sprite) {
     if (shake_.counter > 0) {
         shake_.counter--;
@@ -204,6 +284,23 @@ void GameLogo::processShakeEffect(SmartSprite* primary_sprite, SmartSprite* seco
     }
 }
 
+void GameLogo::processShakeEffect(SmartSprite* primary_sprite, SmartSprite* secondary_sprite, float deltaTime) {
+    // Convertir delay (frames) a tiempo: delay frames = delay * (1000ms/60fps)
+    float delayTime = static_cast<float>(shake_.delay) * (1000.0f / 60.0f);
+    
+    shake_.time_accumulator += deltaTime;
+    
+    if (shake_.time_accumulator >= delayTime) {
+        shake_.time_accumulator -= delayTime;
+        const auto DISPLACEMENT = calculateShakeDisplacement();
+        primary_sprite->setPosX(shake_.origin + DISPLACEMENT);
+        if (secondary_sprite != nullptr) {
+            secondary_sprite->setPosX(shake_.origin + DISPLACEMENT + 15);
+        }
+        shake_.remaining--;
+    }
+}
+
 void GameLogo::processArcadeEditionShake() {
     if (shake_.counter > 0) {
         shake_.counter--;
@@ -215,6 +312,20 @@ void GameLogo::processArcadeEditionShake() {
     }
 }
 
+void GameLogo::processArcadeEditionShake(float deltaTime) {
+    // Convertir delay (frames) a tiempo: delay frames = delay * (1000ms/60fps)
+    float delayTime = static_cast<float>(shake_.delay) * (1000.0f / 60.0f);
+    
+    shake_.time_accumulator += deltaTime;
+    
+    if (shake_.time_accumulator >= delayTime) {
+        shake_.time_accumulator -= delayTime;
+        const auto DISPLACEMENT = calculateShakeDisplacement();
+        arcade_edition_sprite_->setX(shake_.origin + DISPLACEMENT);
+        shake_.remaining--;
+    }
+}
+
 auto GameLogo::calculateShakeDisplacement() const -> int {
     return shake_.remaining % 2 == 0 ? shake_.desp * (-1) : shake_.desp;
 }
@@ -245,6 +356,11 @@ void GameLogo::updateDustSprites() {
     dust_left_sprite_->update();
 }
 
+void GameLogo::updateDustSprites(float deltaTime) {
+    dust_right_sprite_->update(deltaTime);
+    dust_left_sprite_->update(deltaTime);
+}
+
 void GameLogo::updatePostFinishedCounter() {
     if (coffee_crisis_status_ == Status::FINISHED &&
         arcade_edition_status_ == Status::FINISHED &&
@@ -253,6 +369,23 @@ void GameLogo::updatePostFinishedCounter() {
     }
 }
 
+void GameLogo::updatePostFinishedCounter(float deltaTime) {
+    if (coffee_crisis_status_ == Status::FINISHED &&
+        arcade_edition_status_ == Status::FINISHED &&
+        post_finished_counter_ > 0) {
+        
+        // Convertir 1 frame a tiempo: 1 frame = 1000ms/60fps = 16.67ms
+        float frameTime = 1000.0f / 60.0f;
+        
+        post_finished_time_accumulator_ += deltaTime;
+        
+        if (post_finished_time_accumulator_ >= frameTime) {
+            post_finished_time_accumulator_ -= frameTime;
+            --post_finished_counter_;
+        }
+    }
+}
+
 // Activa la clase
 void GameLogo::enable() {
     init();

source/game_logo.h

@@ -16,9 +16,10 @@ class GameLogo {
         ~GameLogo() = default;
 
         // --- Métodos principales ---
-        void render();  // Pinta la clase en pantalla
-        void update();  // Actualiza la lógica de la clase
-        void enable();  // Activa la clase
+        void render();             // Pinta la clase en pantalla
+        void update();             // Actualiza la lógica de la clase (frame-based)
+        void update(float deltaTime);  // Actualiza la lógica de la clase (time-based)
+        void enable();             // Activa la clase
 
         // --- Getters ---
         [[nodiscard]] auto hasFinished() const -> bool;  // Indica si ha terminado la animación
@@ -34,16 +35,22 @@ class GameLogo {
 
         // --- Estructuras privadas ---
         struct Shake {
-                int desp = 1;            // Pixels de desplazamiento para agitar la pantalla en el eje x
-                int delay = 2;           // Retraso entre cada desplazamiento de la pantalla al agitarse
-                int length = 8;          // Cantidad de desplazamientos a realizar
-                int remaining = length;  // Cantidad de desplazamientos pendientes a realizar
-                int counter = delay;     // Contador para el retraso
-                int origin = 0;          // Valor inicial de la pantalla para dejarla igual tras el desplazamiento
+                int desp = 1;              // Pixels de desplazamiento para agitar la pantalla en el eje x
+                int delay = 2;             // Retraso entre cada desplazamiento de la pantalla al agitarse (frame-based)
+                int length = 8;            // Cantidad de desplazamientos a realizar
+                int remaining = length;    // Cantidad de desplazamientos pendientes a realizar
+                int counter = delay;       // Contador para el retraso (frame-based)
+                float time_accumulator = 0.0f;  // Acumulador de tiempo para deltaTime
+                int origin = 0;            // Valor inicial de la pantalla para dejarla igual tras el desplazamiento
 
                 Shake() = default;
                 Shake(int d, int de, int l, int o)
-                    : desp(d), delay(de), length(l), remaining(l), counter(de), origin(o) {}
+                    : desp(d),
+                      delay(de),
+                      length(l),
+                      remaining(l),
+                      counter(de),
+                      origin(o) {}
 
                 void init(int d, int de, int l, int o) {
                     desp = d;
@@ -51,6 +58,7 @@ class GameLogo {
                     length = l;
                     remaining = l;
                     counter = de;
+                    time_accumulator = 0.0f;
                     origin = o;
                 }
         };
@@ -74,32 +82,44 @@ class GameLogo {
         float x_;                                          // Posición X del logo
         float y_;                                          // Posición Y del logo
         float zoom_ = 1.0F;                                // Zoom aplicado al texto "ARCADE EDITION"
-        int post_finished_counter_ = 1;                    // Contador final tras animaciones
+        int post_finished_counter_ = 1;                    // Contador final tras animaciones (frame-based)
+        float post_finished_time_accumulator_ = 0.0f;     // Acumulador de tiempo para post_finished_counter
 
         // --- Inicialización ---
         void init();                                               // Inicializa las variables
         [[nodiscard]] auto getInitialVerticalDesp() const -> int;  // Calcula el desplazamiento vertical inicial
 
         // --- Actualización de estados específicos ---
-        void updateCoffeeCrisis();         // Actualiza el estado de "Coffee Crisis"
-        void updateArcadeEdition();        // Actualiza el estado de "Arcade Edition"
-        void updatePostFinishedCounter();  // Actualiza el contador tras finalizar una animación
+        void updateCoffeeCrisis();                    // Actualiza el estado de "Coffee Crisis" (frame-based)
+        void updateCoffeeCrisis(float deltaTime);     // Actualiza el estado de "Coffee Crisis" (time-based)
+        void updateArcadeEdition();                   // Actualiza el estado de "Arcade Edition" (frame-based)
+        void updateArcadeEdition(float deltaTime);    // Actualiza el estado de "Arcade Edition" (time-based)
+        void updatePostFinishedCounter();             // Actualiza el contador tras finalizar una animación (frame-based)
+        void updatePostFinishedCounter(float deltaTime); // Actualiza el contador tras finalizar una animación (time-based)
 
         // --- Efectos visuales: movimiento y sacudidas ---
-        void handleCoffeeCrisisMoving();                                                                // Maneja el movimiento de "Coffee Crisis"
-        void handleCoffeeCrisisShaking();                                                               // Maneja la sacudida de "Coffee Crisis"
-        void handleArcadeEditionMoving();                                                               // Maneja el movimiento de "Arcade Edition"
-        void handleArcadeEditionShaking();                                                              // Maneja la sacudida de "Arcade Edition"
-        void processShakeEffect(SmartSprite* primary_sprite, SmartSprite* secondary_sprite = nullptr);  // Procesa el efecto de sacudida en sprites
-        void processArcadeEditionShake();                                                               // Procesa la sacudida específica de "Arcade Edition"
-        [[nodiscard]] auto calculateShakeDisplacement() const -> int;                                   // Calcula el desplazamiento de la sacudida
+        void handleCoffeeCrisisMoving();                    // Maneja el movimiento de "Coffee Crisis" (frame-based)
+        void handleCoffeeCrisisMoving(float deltaTime);     // Maneja el movimiento de "Coffee Crisis" (time-based)
+        void handleCoffeeCrisisShaking();                   // Maneja la sacudida de "Coffee Crisis" (frame-based)
+        void handleCoffeeCrisisShaking(float deltaTime);    // Maneja la sacudida de "Coffee Crisis" (time-based)
+        void handleArcadeEditionMoving();                   // Maneja el movimiento de "Arcade Edition" (frame-based)
+        void handleArcadeEditionMoving(float deltaTime);    // Maneja el movimiento de "Arcade Edition" (time-based)
+        void handleArcadeEditionShaking();                  // Maneja la sacudida de "Arcade Edition" (frame-based)
+        void handleArcadeEditionShaking(float deltaTime); // Maneja la sacudida de "Arcade Edition" (time-based)
+        void processShakeEffect(SmartSprite* primary_sprite, SmartSprite* secondary_sprite = nullptr); // Procesa el efecto de sacudida en sprites (frame-based)
+        void processShakeEffect(SmartSprite* primary_sprite, SmartSprite* secondary_sprite, float deltaTime); // Procesa el efecto de sacudida en sprites (time-based)
+        void processArcadeEditionShake();                                                              // Procesa la sacudida específica de "Arcade Edition" (frame-based)
+        void processArcadeEditionShake(float deltaTime);                                               // Procesa la sacudida específica de "Arcade Edition" (time-based)
+        [[nodiscard]] auto calculateShakeDisplacement() const -> int;                                  // Calcula el desplazamiento de la sacudida
 
         // --- Gestión de finalización de efectos ---
-        void handleCoffeeCrisisFinished();  // Maneja el final de la animación "Coffee Crisis"
-        void finishCoffeeCrisisShaking();   // Finaliza la sacudida de "Coffee Crisis"
-        void finishArcadeEditionMoving();   // Finaliza el movimiento de "Arcade Edition"
+        void handleCoffeeCrisisFinished();                // Maneja el final de la animación "Coffee Crisis" (frame-based)
+        void handleCoffeeCrisisFinished(float deltaTime); // Maneja el final de la animación "Coffee Crisis" (time-based)
+        void finishCoffeeCrisisShaking();                 // Finaliza la sacudida de "Coffee Crisis"
+        void finishArcadeEditionMoving();                 // Finaliza el movimiento de "Arcade Edition"
 
         // --- Utilidades ---
-        static void playTitleEffects();  // Reproduce efectos visuales/sonoros del título
-        void updateDustSprites();        // Actualiza los sprites de polvo
+        static void playTitleEffects();         // Reproduce efectos visuales/sonoros del título
+        void updateDustSprites();               // Actualiza los sprites de polvo (frame-based)
+        void updateDustSprites(float deltaTime);  // Actualiza los sprites de polvo (time-based)
 };

source/input.h

@@ -32,7 +32,9 @@ class Input {
                 bool just_pressed;  // Se acaba de pulsar en este fotograma
 
                 KeyState(Uint8 scancode = 0, bool is_held = false, bool just_pressed = false)
-                    : scancode(scancode), is_held(is_held), just_pressed(just_pressed) {}
+                    : scancode(scancode),
+                      is_held(is_held),
+                      just_pressed(just_pressed) {}
         };
 
         struct ButtonState {
@@ -43,7 +45,10 @@ class Input {
                 bool trigger_active{false};  // Estado del trigger como botón digital
 
                 ButtonState(int btn = static_cast<int>(SDL_GAMEPAD_BUTTON_INVALID), bool is_held = false, bool just_pressed = false, bool axis_act = false)
-                    : button(btn), is_held(is_held), just_pressed(just_pressed), axis_active(axis_act) {}
+                    : button(btn),
+                      is_held(is_held),
+                      just_pressed(just_pressed),
+                      axis_active(axis_act) {}
         };
 
         struct Keyboard {

source/item.cpp

@@ -9,7 +9,9 @@
 class Texture;  // lines 6-6
 
 Item::Item(ItemType type, float x, float y, SDL_FRect &play_area, const std::shared_ptr<Texture> &texture, const std::vector<std::string> &animation)
-    : sprite_(std::make_unique<AnimatedSprite>(texture, animation)), play_area_(play_area), type_(type) {
+    : sprite_(std::make_unique<AnimatedSprite>(texture, animation)),
+      play_area_(play_area),
+      type_(type) {
     switch (type) {
         case ItemType::COFFEE_MACHINE: {
             width_ = COFFEE_MACHINE_WIDTH;
@@ -90,7 +92,7 @@ void Item::move() {
 
     // Si toca el borde lateral
     if (pos_x_ == MIN_X || pos_x_ == MAX_X) {
-        vel_x_ = -vel_x_;                                 // Invierte la velocidad horizontal
+        vel_x_ = -vel_x_;  // Invierte la velocidad horizontal
     }
 
     // Si colisiona por arriba, rebota (excepto la máquina de café)

source/lang.cpp

@@ -11,6 +11,7 @@
 #include "difficulty.h"       // Para Difficulty
 #include "external/json.hpp"  // Para basic_json, iteration_proxy_value, oper...
 #include "options.h"          // Para SettingsOpt...
+#include "resource_helper.h"  // Para ResourceHelper
 
 using json = nlohmann::json;
 
@@ -27,14 +28,24 @@ std::vector<Language> languages = {
 auto loadFromFile(const std::string &file_path) -> bool {
     texts.clear();
 
-    std::ifstream rfile(file_path);
-    if (!rfile.is_open()) {
-        return false;
-    }
+    // Intentar cargar desde ResourceHelper primero
+    auto resource_data = ResourceHelper::loadFile(file_path);
 
     try {
         json j;
-        rfile >> j;
+
+        if (!resource_data.empty()) {
+            // Cargar desde datos del pack
+            std::string content(resource_data.begin(), resource_data.end());
+            j = json::parse(content);
+        } else {
+            // Fallback a filesystem directo
+            std::ifstream rfile(file_path);
+            if (!rfile.is_open()) {
+                return false;
+            }
+            rfile >> j;
+        }
 
         for (const auto &el : j.items()) {
             texts[el.key()] = el.value();

source/lang.h

@@ -19,7 +19,9 @@ struct Language {
         std::string file_name;  // Nombre del fichero con los textos
 
         Language(Code c, std::string n, std::string fn)
-            : code(c), name(std::move(n)), file_name(std::move(fn)) {}
+            : code(c),
+              name(std::move(n)),
+              file_name(std::move(fn)) {}
 };
 
 // --- Funciones ---

source/manage_hiscore_table.h

@@ -10,8 +10,10 @@ struct HiScoreEntry {
         bool one_credit_complete;  // Indica si se ha conseguido 1CC
 
         // Constructor
-        explicit HiScoreEntry(const std::string &n = "", int s = 0, bool occ = false)
-            : name(n.substr(0, 6)), score(s), one_credit_complete(occ) {}
+        explicit HiScoreEntry(const std::string &name = "", int score = 0, bool one_credit_complete = false)
+            : name(name.substr(0, 6)),
+              score(score),
+              one_credit_complete(one_credit_complete) {}
 };
 
 // --- Tipos ---

source/moving_sprite.cpp

@@ -53,7 +53,7 @@ void MovingSprite::stop() {
     flip_ = SDL_FLIP_NONE;  // Establece como se ha de voltear el sprite
 }
 
-// Mueve el sprite
+// Mueve el sprite (frame-based)
 void MovingSprite::move() {
     x_ += vx_;
     y_ += vy_;
@@ -65,16 +65,37 @@ void MovingSprite::move() {
     pos_.y = static_cast<int>(y_);
 }
 
-// Actualiza las variables internas del objeto
+// Mueve el sprite (time-based)
+void MovingSprite::move(float deltaTime) {
+    // Convertir deltaTime (milisegundos) a factor de frame (asumiendo 60fps)
+    float frameFactor = deltaTime / (1000.0f / 60.0f);
+    
+    x_ += vx_ * frameFactor;
+    y_ += vy_ * frameFactor;
+
+    vx_ += ax_ * frameFactor;
+    vy_ += ay_ * frameFactor;
+
+    pos_.x = static_cast<int>(x_);
+    pos_.y = static_cast<int>(y_);
+}
+
+// Actualiza las variables internas del objeto (frame-based)
 void MovingSprite::update() {
     move();
     rotate();
 }
 
+// Actualiza las variables internas del objeto (time-based)
+void MovingSprite::update(float deltaTime) {
+    move(deltaTime);
+    rotate(deltaTime);
+}
+
 // Muestra el sprite por pantalla
 void MovingSprite::render() { getTexture()->render(pos_.x, pos_.y, &sprite_clip_, horizontal_zoom_, vertical_zoom_, rotate_.angle, &rotate_.center, flip_); }
 
-// Establece la rotacion
+// Establece la rotacion (frame-based)
 void MovingSprite::rotate() {
     if (rotate_.enabled) {
         ++rotate_.counter;
@@ -85,6 +106,15 @@ void MovingSprite::rotate() {
     }
 }
 
+// Establece la rotacion (time-based)
+void MovingSprite::rotate(float deltaTime) {
+    if (rotate_.enabled) {
+        // Convertir speed (frames) a tiempo: speed frames = speed * (1000ms/60fps) milisegundos
+        float rotationFrameTime = static_cast<float>(rotate_.speed) * (1000.0f / 60.0f);
+        rotate_.angle += rotate_.amount * (deltaTime / rotationFrameTime);
+    }
+}
+
 // Activa o desactiva el efecto de rotación
 void MovingSprite::setRotate(bool enable) {
     rotate_.enabled = enable;

source/moving_sprite.h

@@ -29,10 +29,11 @@ class MovingSprite : public Sprite {
         ~MovingSprite() override = default;
 
         // --- Métodos principales ---
-        virtual void update();   // Actualiza las variables internas del objeto
-        void clear() override;   // Reinicia todas las variables a cero
-        void stop();             // Elimina el movimiento del sprite
-        void render() override;  // Muestra el sprite por pantalla
+        virtual void update();                    // Actualiza las variables internas del objeto (frame-based)
+        virtual void update(float deltaTime);     // Actualiza las variables internas del objeto (time-based)
+        void clear() override;                    // Reinicia todas las variables a cero
+        void stop();                              // Elimina el movimiento del sprite
+        void render() override;                   // Muestra el sprite por pantalla
 
         // --- Configuración ---
         void setPos(SDL_FRect rect);                                                                   // Establece la posición y el tamaño del objeto
@@ -79,6 +80,8 @@ class MovingSprite : public Sprite {
 
         // --- Métodos internos ---
         void updateAngle() { rotate_.angle += rotate_.amount; }  // Incrementa el valor del ángulo
-        void move();                                             // Mueve el sprite según velocidad y aceleración
-        void rotate();                                           // Rota el sprite según los parámetros de rotación
+        void move();                                             // Mueve el sprite según velocidad y aceleración (frame-based)
+        void move(float deltaTime);                              // Mueve el sprite según velocidad y aceleración (time-based)
+        void rotate();                                           // Rota el sprite según los parámetros de rotación (frame-based)
+        void rotate(float deltaTime);                            // Rota el sprite según los parámetros de rotación (time-based)
 };

source/param.cpp

@@ -196,46 +196,48 @@ auto setParams(const std::string& var, const std::string& value) -> bool {
 
     // Colores válidos para globos
     static const std::unordered_map<std::string, bool> VALID_BALLOON_COLORS = {
-        {"blue", true}, {"orange", true}, {"red", true}, {"green", true}
-    };
-    
+        {"blue", true},
+        {"orange", true},
+        {"red", true},
+        {"green", true}};
+
     auto validateBalloonColor = [](const std::string& color) -> bool {
         return VALID_BALLOON_COLORS.find(color) != VALID_BALLOON_COLORS.end();
     };
 
     static const std::unordered_map<std::string, std::function<void(const std::string&)>> STRING_PARAMS = {
-        {"balloon.color[0]", [validateBalloonColor](const std::string& v) { 
-            if (!validateBalloonColor(v)) {
-                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Color de globo inválido '%s'. Usando 'blue' por defecto.", v.c_str());
-                param.balloon.color.at(0) = "blue";
-            } else {
-                param.balloon.color.at(0) = v; 
-            }
-        }},
-        {"balloon.color[1]", [validateBalloonColor](const std::string& v) { 
-            if (!validateBalloonColor(v)) {
-                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Color de globo inválido '%s'. Usando 'orange' por defecto.", v.c_str());
-                param.balloon.color.at(1) = "orange";
-            } else {
-                param.balloon.color.at(1) = v; 
-            }
-        }},
-        {"balloon.color[2]", [validateBalloonColor](const std::string& v) { 
-            if (!validateBalloonColor(v)) {
-                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Color de globo inválido '%s'. Usando 'red' por defecto.", v.c_str());
-                param.balloon.color.at(2) = "red";
-            } else {
-                param.balloon.color.at(2) = v; 
-            }
-        }},
-        {"balloon.color[3]", [validateBalloonColor](const std::string& v) { 
-            if (!validateBalloonColor(v)) {
-                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Color de globo inválido '%s'. Usando 'green' por defecto.", v.c_str());
-                param.balloon.color.at(3) = "green";
-            } else {
-                param.balloon.color.at(3) = v; 
-            }
-        }}};
+        {"balloon.color[0]", [validateBalloonColor](const std::string& v) {
+             if (!validateBalloonColor(v)) {
+                 SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Color de globo inválido '%s'. Usando 'blue' por defecto.", v.c_str());
+                 param.balloon.color.at(0) = "blue";
+             } else {
+                 param.balloon.color.at(0) = v;
+             }
+         }},
+        {"balloon.color[1]", [validateBalloonColor](const std::string& v) {
+             if (!validateBalloonColor(v)) {
+                 SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Color de globo inválido '%s'. Usando 'orange' por defecto.", v.c_str());
+                 param.balloon.color.at(1) = "orange";
+             } else {
+                 param.balloon.color.at(1) = v;
+             }
+         }},
+        {"balloon.color[2]", [validateBalloonColor](const std::string& v) {
+             if (!validateBalloonColor(v)) {
+                 SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Color de globo inválido '%s'. Usando 'red' por defecto.", v.c_str());
+                 param.balloon.color.at(2) = "red";
+             } else {
+                 param.balloon.color.at(2) = v;
+             }
+         }},
+        {"balloon.color[3]", [validateBalloonColor](const std::string& v) {
+             if (!validateBalloonColor(v)) {
+                 SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Color de globo inválido '%s'. Usando 'green' por defecto.", v.c_str());
+                 param.balloon.color.at(3) = "green";
+             } else {
+                 param.balloon.color.at(3) = v;
+             }
+         }}};
 
     // Lambda para intentar cada mapa de parámetros
     auto try_map = [&](const auto& param_map) -> bool {

source/param.h

@@ -57,7 +57,8 @@ struct ParamBalloon {
 
                 // Constructor por defecto
                 constexpr Settings(float grav_val = 0.0F, float vel_val = 0.0F)
-                    : grav(grav_val), vel(vel_val) {}
+                    : grav(grav_val),
+                      vel(vel_val) {}
         };
 
         // Inicialización con los valores por defecto desde GameDefaults
@@ -164,7 +165,10 @@ struct ParamPlayer {
 
                 // Constructor con tonalidades específicas
                 Shirt(const Color& darkest_tone, const Color& dark_tone, const Color& base_tone, const Color& light_tone)
-                    : darkest(darkest_tone), dark(dark_tone), base(base_tone), light(light_tone) {}
+                    : darkest(darkest_tone),
+                      dark(dark_tone),
+                      base(base_tone),
+                      light(light_tone) {}
         };
 
         // Inicialización con valores por defecto

source/path_sprite.cpp

@@ -4,6 +4,13 @@
 #include <functional>  // Para function
 #include <utility>     // Para move
 
+// Constructor para paths por puntos (compatibilidad)
+Path::Path(const std::vector<SDL_FPoint> &spots_init, int waiting_counter_init)
+    : spots(spots_init), is_point_path(true) {
+    constexpr float FRAME_TIME_MS = 1000.0f / 60.0f;
+    waiting_time_ms = static_cast<float>(waiting_counter_init) * FRAME_TIME_MS;
+}
+
 // Devuelve un vector con los puntos que conforman la ruta
 auto createPath(float start, float end, PathType type, float fixed_pos, int steps, const std::function<double(double)> &easing_function) -> std::vector<SDL_FPoint> {
     std::vector<SDL_FPoint> v;
@@ -32,10 +39,16 @@ auto createPath(float start, float end, PathType type, float fixed_pos, int step
     return v;
 }
 
-// Actualiza la posición y comprueba si ha llegado a su destino
+// Actualiza la posición y comprueba si ha llegado a su destino (compatibilidad)
 void PathSprite::update() {
+    constexpr float FRAME_TIME_MS = 1000.0f / 60.0f;  // 16.67ms por frame a 60 FPS
+    update(FRAME_TIME_MS);
+}
+
+// Actualiza la posición y comprueba si ha llegado a su destino
+void PathSprite::update(float delta_time) {
     if (enabled_ && !has_finished_) {
-        moveThroughCurrentPath();
+        moveThroughCurrentPath(delta_time);
         goToNextPathOrDie();
     }
 }
@@ -79,7 +92,13 @@ void PathSprite::addPath(Path path, bool centered) {
 
 // Añade un recorrido
 void PathSprite::addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easing_function, int waiting_counter) {
-    paths_.emplace_back(createPath(start, end, type, fixed_pos, steps, easing_function), waiting_counter);
+    // Convertir frames a milisegundos
+    constexpr float FRAME_TIME_MS = 1000.0f / 60.0f;
+    float duration_ms = static_cast<float>(steps) * FRAME_TIME_MS;
+    float waiting_ms = static_cast<float>(waiting_counter) * FRAME_TIME_MS;
+
+    paths_.emplace_back(static_cast<float>(start), static_cast<float>(end), type, static_cast<float>(fixed_pos),
+                       duration_ms, waiting_ms, easing_function);
 }
 
 // Añade un recorrido
@@ -95,35 +114,78 @@ void PathSprite::enable() {
 
     enabled_ = true;
 
-    // Establece la posición
+    // Establece la posición inicial
     auto &path = paths_.at(current_path_);
-    const auto &p = path.spots.at(path.counter);
-    setPosition(p);
+    if (path.is_point_path) {
+        const auto &p = path.spots.at(path.counter);
+        setPosition(p);
+    } else {
+        // Para paths generados, establecer posición inicial
+        SDL_FPoint initial_pos;
+        if (path.type == PathType::HORIZONTAL) {
+            initial_pos = {path.start_pos, path.fixed_pos};
+        } else {
+            initial_pos = {path.fixed_pos, path.start_pos};
+        }
+        setPosition(initial_pos);
+    }
 }
 
 // Coloca el sprite en los diferentes puntos del recorrido
-void PathSprite::moveThroughCurrentPath() {
+void PathSprite::moveThroughCurrentPath(float delta_time) {
     auto &path = paths_.at(current_path_);
 
-    // Establece la posición
-    const auto &p = path.spots.at(path.counter);
-    setPosition(p);
+    if (path.is_point_path) {
+        // Lógica para paths por puntos (compatibilidad)
+        const auto &p = path.spots.at(path.counter);
+        setPosition(p);
 
-    // Comprobar si ha terminado el recorrido
-    if (!path.on_destination) {
-        ++path.counter;
-        if (path.counter >= static_cast<int>(path.spots.size())) {
-            path.on_destination = true;
-            path.counter = static_cast<int>(path.spots.size()) - 1;
+        if (!path.on_destination) {
+            ++path.counter;
+            if (path.counter >= static_cast<int>(path.spots.size())) {
+                path.on_destination = true;
+                path.counter = static_cast<int>(path.spots.size()) - 1;
+            }
         }
-    }
 
-    // Comprobar si ha terminado la espera
-    if (path.on_destination) {
-        if (path.waiting_counter == 0) {
-            path.finished = true;
+        if (path.on_destination) {
+            path.waiting_elapsed += delta_time;
+            if (path.waiting_elapsed >= path.waiting_time_ms) {
+                path.finished = true;
+            }
+        }
+    } else {
+        // Lógica para paths generados en tiempo real
+        if (!path.on_destination) {
+            path.elapsed_time += delta_time;
+
+            // Calcular progreso (0.0 a 1.0)
+            float progress = path.elapsed_time / path.duration_ms;
+            if (progress >= 1.0f) {
+                progress = 1.0f;
+                path.on_destination = true;
+            }
+
+            // Aplicar función de easing
+            double eased_progress = path.easing_function(progress);
+
+            // Calcular posición actual
+            float current_pos = path.start_pos + (path.end_pos - path.start_pos) * static_cast<float>(eased_progress);
+
+            // Establecer posición según el tipo
+            SDL_FPoint position;
+            if (path.type == PathType::HORIZONTAL) {
+                position = {current_pos, path.fixed_pos};
+            } else {
+                position = {path.fixed_pos, current_pos};
+            }
+            setPosition(position);
         } else {
-            --path.waiting_counter;
+            // Esperar en destino
+            path.waiting_elapsed += delta_time;
+            if (path.waiting_elapsed >= path.waiting_time_ms) {
+                path.finished = true;
+            }
         }
     }
 }

source/path_sprite.h

@@ -24,16 +24,31 @@ enum class PathCentered {  // Centrado del recorrido
 };
 
 // --- Estructuras ---
-struct Path {                           // Define un recorrido para el sprite
-        std::vector<SDL_FPoint> spots;  // Puntos por los que se desplazará el sprite
-        int waiting_counter;            // Tiempo de espera una vez en el destino
-        bool on_destination = false;    // Indica si ha llegado al destino
-        bool finished = false;          // Indica si ha terminado de esperarse
-        int counter = 0;                // Contador interno
+struct Path {                                                    // Define un recorrido para el sprite
+        float start_pos;                                         // Posición inicial
+        float end_pos;                                           // Posición final
+        PathType type;                                           // Tipo de movimiento (horizontal/vertical)
+        float fixed_pos;                                         // Posición fija en el eje contrario
+        float duration_ms;                                       // Duración de la animación en milisegundos
+        float waiting_time_ms;                                   // Tiempo de espera una vez en el destino
+        std::function<double(double)> easing_function;           // Función de easing
+        float elapsed_time = 0.0f;                               // Tiempo transcurrido
+        float waiting_elapsed = 0.0f;                            // Tiempo de espera transcurrido
+        bool on_destination = false;                             // Indica si ha llegado al destino
+        bool finished = false;                                   // Indica si ha terminado de esperarse
 
-        // Constructor
-        Path(const std::vector<SDL_FPoint> &spots_init, int waiting_counter_init)
-            : spots(spots_init), waiting_counter(waiting_counter_init) {}
+        // Constructor para paths generados
+        Path(float start, float end, PathType path_type, float fixed, float duration, float waiting, std::function<double(double)> easing)
+            : start_pos(start), end_pos(end), type(path_type), fixed_pos(fixed),
+              duration_ms(duration), waiting_time_ms(waiting), easing_function(std::move(easing)) {}
+
+        // Constructor para paths por puntos (mantenemos compatibilidad)
+        Path(const std::vector<SDL_FPoint> &spots_init, int waiting_counter_init);
+
+        // Variables para paths por puntos
+        std::vector<SDL_FPoint> spots;  // Solo para paths por puntos
+        int counter = 0;                // Solo para paths por puntos
+        bool is_point_path = false;     // Indica si es un path por puntos
 };
 
 // --- Funciones ---
@@ -48,7 +63,8 @@ class PathSprite : public Sprite {
         ~PathSprite() override = default;
 
         // --- Métodos principales ---
-        void update();           // Actualiza la posición del sprite según el recorrido
+        void update();                           // Actualiza la posición del sprite según el recorrido (compatibilidad)
+        void update(float delta_time);           // Actualiza la posición del sprite según el recorrido
         void render() override;  // Muestra el sprite por pantalla
 
         // --- Gestión de recorridos ---
@@ -71,6 +87,6 @@ class PathSprite : public Sprite {
         std::vector<Path> paths_;    // Caminos a recorrer por el sprite
 
         // --- Métodos internos ---
-        void moveThroughCurrentPath();  // Coloca el sprite en los diferentes puntos del recorrido
+        void moveThroughCurrentPath(float delta_time);  // Coloca el sprite en los diferentes puntos del recorrido
         void goToNextPathOrDie();       // Cambia de recorrido o finaliza
 };

source/player.cpp

@@ -3,6 +3,7 @@
 #include <SDL3/SDL.h>  // Para SDL_GetTicks, SDL_FlipMode
 
 #include <algorithm>  // Para clamp, max, min
+#include <cmath>      // Para fmod
 #include <cstdlib>    // Para rand
 
 #include "animated_sprite.h"       // Para AnimatedSprite
@@ -22,7 +23,17 @@
 
 // Constructor
 Player::Player(const Config &config)
-    : player_sprite_(std::make_unique<AnimatedSprite>(config.texture.at(0), config.animations.at(0))), power_sprite_(std::make_unique<AnimatedSprite>(config.texture.at(4), config.animations.at(1))), enter_name_(std::make_unique<EnterName>()), hi_score_table_(config.hi_score_table), glowing_entry_(config.glowing_entry), stage_info_(config.stage_info), play_area_(*config.play_area), id_(config.id), default_pos_x_(config.x), default_pos_y_(config.y), demo_(config.demo) {
+    : player_sprite_(std::make_unique<AnimatedSprite>(config.texture.at(0), config.animations.at(0))),
+      power_sprite_(std::make_unique<AnimatedSprite>(config.texture.at(4), config.animations.at(1))),
+      enter_name_(std::make_unique<EnterName>()),
+      hi_score_table_(config.hi_score_table),
+      glowing_entry_(config.glowing_entry),
+      stage_info_(config.stage_info),
+      play_area_(*config.play_area),
+      id_(config.id),
+      default_pos_x_(config.x),
+      default_pos_y_(config.y),
+      demo_(config.demo) {
     // Configura objetos
     player_sprite_->addTexture(config.texture.at(1));
     player_sprite_->addTexture(config.texture.at(2));
@@ -176,6 +187,41 @@ void Player::move() {
     }
 }
 
+// Fase 1: Sistema de movimiento time-based
+void Player::move(float deltaTime) {
+    switch (playing_state_) {
+        case State::PLAYING:
+            handlePlayingMovement(deltaTime);
+            break;
+        case State::ROLLING:
+            handleRollingMovement();  // Usa MovingSprite que ya soporta deltaTime
+            break;
+        case State::TITLE_ANIMATION:
+            handleTitleAnimation();   // Sin cambios - usa solo animaciones
+            break;
+        case State::CONTINUE_TIME_OUT:
+            handleContinueTimeOut();  // Sin cambios - usa MovingSprite que ya soporta deltaTime
+            break;
+        case State::LEAVING_SCREEN:
+            handleLeavingScreen();    // Sin cambios - usa MovingSprite que ya soporta deltaTime
+            break;
+        case State::ENTERING_SCREEN:
+            handleEnteringScreen();   // Sin cambios - usa MovingSprite que ya soporta deltaTime
+            break;
+        case State::CREDITS:
+            handleCreditsMovement(deltaTime);  // Fase 4: Sistema de créditos time-based
+            break;
+        case State::WAITING:
+            handleWaitingMovement(deltaTime);  // Fase 4: Sistema de waiting time-based
+            break;
+        case State::RECOVER:
+            handleRecoverMovement();  // Sin cambios - usa AnimatedSprite que ya soporta deltaTime
+            break;
+        default:
+            break;
+    }
+}
+
 void Player::handlePlayingMovement() {
     // Mueve el jugador a derecha o izquierda
     pos_x_ += vel_x_;
@@ -188,6 +234,19 @@ void Player::handlePlayingMovement() {
     shiftSprite();
 }
 
+// Fase 1: Movimiento time-based durante el juego
+void Player::handlePlayingMovement(float deltaTime) {
+    // Mueve el jugador a derecha o izquierda (time-based)
+    pos_x_ += vel_x_ * deltaTime / (1000.0f / 60.0f);
+
+    // Si el jugador abandona el area de juego por los laterales, restaura su posición
+    const float MIN_X = play_area_.x - 5;
+    const float MAX_X = play_area_.w + 5 - WIDTH;
+    pos_x_ = std::clamp(pos_x_, MIN_X, MAX_X);
+
+    shiftSprite();
+}
+
 void Player::handleRecoverMovement() {
     if (player_sprite_->getCurrentAnimationFrame() == 10) { playSound("voice_recover.wav"); }
     if (player_sprite_->animationIsCompleted()) { setPlayingState(State::RESPAWNING); }
@@ -327,6 +386,20 @@ void Player::handleCreditsMovement() {
     shiftSprite();
 }
 
+// Fase 4: Movimiento general en la pantalla de créditos (time-based)
+void Player::handleCreditsMovement(float deltaTime) {
+    pos_x_ += (vel_x_ / 2.0F) * deltaTime / (1000.0f / 60.0f); // Convert frame-based movement to time-based
+
+    if (vel_x_ > 0) {
+        handleCreditsRightMovement();
+    } else {
+        handleCreditsLeftMovement();
+    }
+
+    updateWalkingStateForCredits();
+    shiftSprite();
+}
+
 void Player::handleCreditsRightMovement() {
     if (pos_x_ > param.game.game_area.rect.w - WIDTH) {
         pos_x_ = param.game.game_area.rect.w - WIDTH;
@@ -349,6 +422,16 @@ void Player::handleWaitingMovement() {
     }
 }
 
+// Fase 4: Controla la animación del jugador saludando (time-based)
+void Player::handleWaitingMovement(float deltaTime) {
+    waiting_time_accumulator_ += deltaTime;
+    float waiting_duration = static_cast<float>(WAITING_COUNTER) * (1000.0f / 60.0f); // Convert frames to milliseconds
+    if (waiting_time_accumulator_ >= waiting_duration) {
+        waiting_time_accumulator_ = 0.0f;
+        player_sprite_->resetAnimation();
+    }
+}
+
 void Player::updateWalkingStateForCredits() {
     if (pos_x_ > param.game.game_area.center_x - WIDTH / 2) {
         setWalkingState(State::WALKING_LEFT);
@@ -377,6 +460,16 @@ void Player::updateStepCounter() {
     }
 }
 
+// Fase 4: Incrementa o ajusta el contador de pasos (time-based)
+void Player::updateStepCounter(float deltaTime) {
+    step_time_accumulator_ += deltaTime;
+    float step_interval = 10.0f / 60.0f; // 10 frames converted to seconds
+    if (step_time_accumulator_ >= step_interval) {
+        step_time_accumulator_ = 0.0f;
+        playSound("walk.wav");
+    }
+}
+
 // Pinta el jugador en pantalla
 void Player::render() {
     if (power_up_ && isPlaying()) {
@@ -444,7 +537,7 @@ auto Player::computeAnimation() const -> std::pair<std::string, SDL_FlipMode> {
     return {anim_name, flip_mode};
 }
 
-// Establece la animación correspondiente al estado
+// Establece la animación correspondiente al estado (frame-based)
 void Player::setAnimation() {
     switch (playing_state_) {
         case State::PLAYING:
@@ -485,7 +578,49 @@ void Player::setAnimation() {
     power_sprite_->update();
 }
 
-// Actualiza el valor de la variable
+// Fase 1: Establece la animación correspondiente al estado (time-based)
+void Player::setAnimation(float deltaTime) {
+    switch (playing_state_) {
+        case State::PLAYING:
+        case State::ENTERING_NAME_GAME_COMPLETED:
+        case State::ENTERING_SCREEN:
+        case State::LEAVING_SCREEN:
+        case State::TITLE_ANIMATION:
+        case State::CREDITS: {
+            auto [animName, flipMode] = computeAnimation();
+            player_sprite_->setCurrentAnimation(animName, false);
+            player_sprite_->setFlip(flipMode);
+            break;
+        }
+        case State::RECOVER:
+            player_sprite_->setCurrentAnimation("recover");
+            break;
+        case State::WAITING:
+        case State::GAME_OVER:
+            player_sprite_->setCurrentAnimation("hello");
+            break;
+        case State::ROLLING:
+        case State::CONTINUE_TIME_OUT:
+            player_sprite_->setCurrentAnimation("rolling");
+            break;
+        case State::LYING_ON_THE_FLOOR_FOREVER:
+        case State::ENTERING_NAME:
+        case State::CONTINUE:
+            player_sprite_->setCurrentAnimation("dizzy");
+            break;
+        case State::CELEBRATING:
+            player_sprite_->setCurrentAnimation("celebration");
+            break;
+        default:
+            break;
+    }
+
+    // La diferencia clave: usa deltaTime para las animaciones
+    player_sprite_->update(deltaTime);
+    power_sprite_->update(deltaTime);
+}
+
+// Actualiza el valor de la variable (frame-based)
 void Player::updateCooldown() {
     if (playing_state_ != State::PLAYING) {
         return;
@@ -498,6 +633,19 @@ void Player::updateCooldown() {
     }
 }
 
+// Fase 2: Actualiza el cooldown de disparo (time-based)
+void Player::updateCooldown(float deltaTime) {
+    if (playing_state_ != State::PLAYING) {
+        return;
+    }
+
+    if (cant_fire_time_accumulator_ > 0) {
+        handleFiringCooldown(deltaTime);
+    } else {
+        handleRecoilAndCooling(deltaTime);
+    }
+}
+
 void Player::handleFiringCooldown() {
     cooling_state_counter_ = COOLING_DURATION;
 
@@ -512,6 +660,28 @@ void Player::handleFiringCooldown() {
     }
 }
 
+// Fase 2: Manejo de cooldown de disparo (time-based)
+void Player::handleFiringCooldown(float deltaTime) {
+    cooling_time_accumulator_ = static_cast<float>(COOLING_DURATION) / 60.0f;
+
+    // Convertir frames a tiempo: 1 frame = 1/60 segundos
+    float frameTime = 1.0f / 60.0f;
+    float halfwayTime = static_cast<float>(recoiling_state_duration_) / 2.0f / 60.0f;
+    
+    // Reducir tiempo acumulado
+    cant_fire_time_accumulator_ -= deltaTime;
+    
+    // Transition to recoiling state at halfway point
+    if (cant_fire_time_accumulator_ <= halfwayTime && cant_fire_time_accumulator_ > halfwayTime - frameTime) {
+        transitionToRecoiling();
+    }
+
+    if (cant_fire_time_accumulator_ <= 0) {
+        cant_fire_time_accumulator_ = 0;
+        recoiling_time_accumulator_ = static_cast<float>(recoiling_state_duration_) / 60.0f;
+    }
+}
+
 void Player::handleRecoilAndCooling() {
     if (recoiling_state_counter_ > 0) {
         --recoiling_state_counter_;
@@ -521,6 +691,16 @@ void Player::handleRecoilAndCooling() {
     handleCoolingState();
 }
 
+// Fase 2: Manejo de retroceso y enfriamiento (time-based)
+void Player::handleRecoilAndCooling(float deltaTime) {
+    if (recoiling_time_accumulator_ > 0) {
+        recoiling_time_accumulator_ -= deltaTime;
+        return;
+    }
+
+    handleCoolingState(deltaTime);
+}
+
 void Player::handleCoolingState() {
     if (cooling_state_counter_ > COOLING_COMPLETE) {
         if (cooling_state_counter_ == COOLING_DURATION) {
@@ -534,6 +714,26 @@ void Player::handleCoolingState() {
     }
 }
 
+// Fase 2: Manejo del estado de enfriamiento (time-based)
+void Player::handleCoolingState(float deltaTime) {
+    float coolingCompleteTime = static_cast<float>(COOLING_COMPLETE) / 60.0f;
+    float coolingDurationTime = static_cast<float>(COOLING_DURATION) / 60.0f;
+    float frameTime = 1.0f / 60.0f;
+    
+    if (cooling_time_accumulator_ > coolingCompleteTime) {
+        // Transición a cooling cuando empezamos (equivalente a == COOLING_DURATION)
+        if (cooling_time_accumulator_ <= coolingDurationTime && cooling_time_accumulator_ > coolingDurationTime - frameTime) {
+            transitionToCooling();
+        }
+        cooling_time_accumulator_ -= deltaTime;
+    }
+
+    if (cooling_time_accumulator_ <= coolingCompleteTime) {
+        cooling_time_accumulator_ = coolingCompleteTime;
+        completeCooling();
+    }
+}
+
 void Player::transitionToRecoiling() {
     switch (firing_state_) {
         case State::FIRING_LEFT:
@@ -585,6 +785,28 @@ void Player::update() {
     updateShowingName();
 }
 
+// Fase 1-4: Método deltaTime completo
+void Player::update(float deltaTime) {
+    move(deltaTime);                        // Sistema de movimiento time-based
+    setAnimation(deltaTime);                // Animaciones time-based  
+    shiftColliders();                       // Sin cambios (posicional)
+    updateCooldown(deltaTime);              // Fase 2: Sistema de disparo time-based
+    updatePowerUp(deltaTime);               // Fase 3: Sistema de power-up time-based
+    updateInvulnerable(deltaTime);          // Fase 3: Sistema de invulnerabilidad time-based
+    updateScoreboard();                     // Sin cambios (no temporal)
+    updateContinueCounter(deltaTime);       // Fase 4: Sistema de continue time-based
+    updateEnterNameCounter(deltaTime);      // Fase 4: Sistema de name entry time-based
+    updateShowingName();                    // Sin cambios (no temporal)
+}
+
+void Player::passShowingName() {
+    if (game_completed_) {
+        setPlayingState(State::LEAVING_SCREEN);
+    } else {
+        setPlayingState(State::CONTINUE);
+    }
+}
+
 // Incrementa la puntuación del jugador
 void Player::addScore(int score, int lowest_hi_score_entry) {
     if (isPlaying()) {
@@ -624,6 +846,9 @@ void Player::setPlayingState(State state) {
 
     switch (playing_state_) {
         case State::RECOVER: {
+            score_ = 0;  // Pon los puntos a cero para que no se vea en el marcador
+            score_multiplier_ = 1.0F;
+            setScoreboardMode(Scoreboard::Mode::SCORE);
             break;
         }
         case State::RESPAWNING: {
@@ -643,6 +868,7 @@ void Player::setPlayingState(State state) {
             // Inicializa el contador de continuar
             continue_ticks_ = SDL_GetTicks();
             continue_counter_ = 9;
+            continue_time_accumulator_ = 0.0f; // Initialize time accumulator
             playSound("continue_clock.wav");
             setScoreboardMode(Scoreboard::Mode::CONTINUE);
             break;
@@ -661,6 +887,7 @@ void Player::setPlayingState(State state) {
             }
             pos_y_ = default_pos_y_;
             waiting_counter_ = 0;
+            waiting_time_accumulator_ = 0.0f; // Initialize time accumulator
             shiftSprite();
             player_sprite_->setCurrentAnimation("hello");
             player_sprite_->animtionPause();
@@ -728,12 +955,14 @@ void Player::setPlayingState(State state) {
         }
         case State::LEAVING_SCREEN: {
             step_counter_ = 0;
+            step_time_accumulator_ = 0.0f; // Initialize time accumulator
             setScoreboardMode(Scoreboard::Mode::GAME_COMPLETED);
             break;
         }
         case State::ENTERING_SCREEN: {
             init();
             step_counter_ = 0;
+            step_time_accumulator_ = 0.0f; // Initialize time accumulator
             setScoreboardMode(Scoreboard::Mode::SCORE);
             switch (id_) {
                 case Id::PLAYER1:
@@ -774,26 +1003,27 @@ void Player::decScoreMultiplier() {
 void Player::setInvulnerable(bool value) {
     invulnerable_ = value;
     invulnerable_counter_ = invulnerable_ ? INVULNERABLE_COUNTER : 0;
+    invulnerable_time_accumulator_ = invulnerable_ ? static_cast<float>(INVULNERABLE_COUNTER) / 60.0f : 0.0f; // Initialize time accumulator
 }
 
-// Monitoriza el estado
+// Monitoriza el estado (frame-based)
 void Player::updateInvulnerable() {
     if (playing_state_ == State::PLAYING && invulnerable_) {
         if (invulnerable_counter_ > 0) {
             --invulnerable_counter_;
-            
+
             // Frecuencia fija de parpadeo (como el original)
             constexpr int blink_speed = 8;
-            
+
             // Calcula proporción decreciente: menos textura blanca hacia el final
             // Al inicio: 50-50, hacia el final: 70-30 (menos blanco)
             float progress = 1.0f - (static_cast<float>(invulnerable_counter_) / INVULNERABLE_COUNTER);
-            int white_frames = static_cast<int>((0.5f - progress * 0.2f) * blink_speed);  
-            
+            int white_frames = static_cast<int>((0.5f - progress * 0.2f) * blink_speed);
+
             // Alterna entre texturas con proporción variable
             bool should_show_invulnerable = (invulnerable_counter_ % blink_speed) < white_frames;
             size_t target_texture = should_show_invulnerable ? INVULNERABLE_TEXTURE : coffees_;
-            
+
             // Solo cambia textura si es diferente (optimización)
             if (player_sprite_->getActiveTexture() != target_texture) {
                 player_sprite_->setActiveTexture(target_texture);
@@ -806,13 +1036,46 @@ void Player::updateInvulnerable() {
     }
 }
 
+// Fase 3: Monitoriza el estado (time-based)
+void Player::updateInvulnerable(float deltaTime) {
+    if (playing_state_ == State::PLAYING && invulnerable_) {
+        if (invulnerable_time_accumulator_ > 0) {
+            invulnerable_time_accumulator_ -= deltaTime;
+
+            // Frecuencia fija de parpadeo adaptada a deltaTime
+            constexpr float blink_period = 8.0f / 60.0f; // 8 frames convertidos a segundos
+
+            // Calcula proporción decreciente basada en tiempo restante
+            float total_invulnerable_time = static_cast<float>(INVULNERABLE_COUNTER) / 60.0f;
+            float progress = 1.0f - (invulnerable_time_accumulator_ / total_invulnerable_time);
+            float white_proportion = 0.5f - progress * 0.2f; // Menos blanco hacia el final
+
+            // Calcula si debe mostrar textura de invulnerabilidad basado en el ciclo temporal
+            float cycle_position = fmod(invulnerable_time_accumulator_, blink_period) / blink_period;
+            bool should_show_invulnerable = cycle_position < white_proportion;
+            size_t target_texture = should_show_invulnerable ? INVULNERABLE_TEXTURE : coffees_;
+
+            // Solo cambia textura si es diferente (optimización)
+            if (player_sprite_->getActiveTexture() != target_texture) {
+                player_sprite_->setActiveTexture(target_texture);
+            }
+        } else {
+            // Fin de invulnerabilidad
+            invulnerable_time_accumulator_ = 0;
+            setInvulnerable(false);
+            player_sprite_->setActiveTexture(coffees_);
+        }
+    }
+}
+
 // Establece el valor de la variable
 void Player::setPowerUp() {
     power_up_ = true;
     power_up_counter_ = POWERUP_COUNTER;
+    power_up_time_accumulator_ = static_cast<float>(POWERUP_COUNTER) / 60.0f; // Initialize time accumulator
 }
 
-// Actualiza el valor de la variable
+// Actualiza el valor de la variable (frame-based)
 void Player::updatePowerUp() {
     if (playing_state_ == State::PLAYING) {
         if (power_up_) {
@@ -822,6 +1085,19 @@ void Player::updatePowerUp() {
     }
 }
 
+// Fase 3: Actualiza el valor de la variable (time-based)
+void Player::updatePowerUp(float deltaTime) {
+    if (playing_state_ == State::PLAYING) {
+        if (power_up_) {
+            power_up_time_accumulator_ -= deltaTime;
+            power_up_ = power_up_time_accumulator_ > 0;
+            if (!power_up_) {
+                power_up_time_accumulator_ = 0;
+            }
+        }
+    }
+}
+
 // Concede un toque extra al jugador
 void Player::giveExtraHit() {
     extra_hit_ = true;
@@ -854,7 +1130,7 @@ void Player::setPlayerTextures(const std::vector<std::shared_ptr<Texture>> &text
     power_sprite_->setTexture(texture[1]);
 }
 
-// Actualiza el contador de continue
+// Actualiza el contador de continue (frame-based)
 void Player::updateContinueCounter() {
     if (playing_state_ == State::CONTINUE) {
         constexpr int TICKS_SPEED = 1000;
@@ -864,7 +1140,19 @@ void Player::updateContinueCounter() {
     }
 }
 
-// Actualiza el contador de entrar nombre
+// Fase 4: Actualiza el contador de continue (time-based)
+void Player::updateContinueCounter(float deltaTime) {
+    if (playing_state_ == State::CONTINUE) {
+        continue_time_accumulator_ += deltaTime;
+        constexpr float CONTINUE_INTERVAL = 1.0f; // 1 segundo
+        if (continue_time_accumulator_ >= CONTINUE_INTERVAL) {
+            continue_time_accumulator_ -= CONTINUE_INTERVAL;
+            decContinueCounter();
+        }
+    }
+}
+
+// Actualiza el contador de entrar nombre (frame-based)
 void Player::updateEnterNameCounter() {
     if (playing_state_ == State::ENTERING_NAME || playing_state_ == State::ENTERING_NAME_GAME_COMPLETED) {
         constexpr int TICKS_SPEED = 1000;
@@ -874,6 +1162,18 @@ void Player::updateEnterNameCounter() {
     }
 }
 
+// Fase 4: Actualiza el contador de entrar nombre (time-based)
+void Player::updateEnterNameCounter(float deltaTime) {
+    if (playing_state_ == State::ENTERING_NAME || playing_state_ == State::ENTERING_NAME_GAME_COMPLETED) {
+        name_entry_time_accumulator_ += deltaTime;
+        constexpr float NAME_ENTRY_INTERVAL = 1.0f; // 1 segundo
+        if (name_entry_time_accumulator_ >= NAME_ENTRY_INTERVAL) {
+            name_entry_time_accumulator_ -= NAME_ENTRY_INTERVAL;
+            decNameEntryCounter();
+        }
+    }
+}
+
 // Actualiza el estado de SHOWING_NAME
 void Player::updateShowingName() {
     if (playing_state_ == State::SHOWING_NAME) {
@@ -898,6 +1198,7 @@ void Player::decContinueCounter() {
 // Decrementa el contador de entrar nombre
 void Player::decNameEntryCounter() {
     name_entry_ticks_ = SDL_GetTicks();
+    name_entry_time_accumulator_ = 0.0f; // Reset time accumulator
 
     // Actualiza contadores
     ++name_entry_idle_counter_;

source/player.h

@@ -94,9 +94,10 @@ class Player {
         ~Player() = default;
 
         // --- Inicialización y ciclo de vida ---
-        void init();    // Inicializa el jugador
-        void update();  // Actualiza estado, animación y contadores
-        void render();  // Dibuja el jugador en pantalla
+        void init();                    // Inicializa el jugador
+        void update();                  // Actualiza estado, animación y contadores (frame-based)
+        void update(float deltaTime);   // Actualiza estado, animación y contadores (time-based)
+        void render();                  // Dibuja el jugador en pantalla
 
         // --- Entrada y control ---
         void setInput(Input::Action action);              // Procesa entrada general
@@ -104,14 +105,17 @@ class Player {
         void setInputEnteringName(Input::Action action);  // Procesa entrada al introducir nombre
 
         // --- Movimiento y animación ---
-        void move();          // Mueve el jugador
-        void setAnimation();  // Establece la animación según el estado
+        void move();                        // Mueve el jugador (frame-based)
+        void move(float deltaTime);         // Mueve el jugador (time-based)
+        void setAnimation();                // Establece la animación según el estado (frame-based)
+        void setAnimation(float deltaTime); // Establece la animación según el estado (time-based)
 
         // --- Texturas y animaciones ---
         void setPlayerTextures(const std::vector<std::shared_ptr<Texture>> &texture);  // Cambia las texturas del jugador
 
         // --- Estados y contadores ---
-        void updateCooldown();  // Actualiza el cooldown de disparo
+        void updateCooldown();                   // Actualiza el cooldown de disparo (frame-based)
+        void updateCooldown(float deltaTime);    // Actualiza el cooldown de disparo (time-based)
 
         // --- Puntuación y marcador ---
         void addScore(int score, int lowest_hi_score_entry);  // Añade puntos
@@ -122,7 +126,8 @@ class Player {
         void setPlayingState(State state);  // Cambia el estado de juego
         void setInvulnerable(bool value);   // Establece el valor del estado de invulnerabilidad
         void setPowerUp();                  // Activa el modo PowerUp
-        void updatePowerUp();               // Actualiza el valor de PowerUp
+        void updatePowerUp();               // Actualiza el valor de PowerUp (frame-based)
+        void updatePowerUp(float deltaTime); // Actualiza el valor de PowerUp (time-based)
         void giveExtraHit();                // Concede un toque extra al jugador
         void removeExtraHit();              // Quita el toque extra al jugador
         void decContinueCounter();          // Decrementa el contador de continuar
@@ -170,7 +175,7 @@ class Player {
         [[nodiscard]] static auto getWidth() -> int { return WIDTH; }
         [[nodiscard]] auto getPlayingState() const -> State { return playing_state_; }
         [[nodiscard]] auto getName() const -> const std::string & { return name_; }
-        [[nodiscard]] auto get1CC() const -> bool { return game_completed_ && credits_used_ == 1; }
+        [[nodiscard]] auto get1CC() const -> bool { return game_completed_ && credits_used_ <= 1; }
         [[nodiscard]] auto getEnterNamePositionOverflow() const -> bool { return enter_name_ ? enter_name_->getPositionOverflow() : false; }
 
         // Setters inline
@@ -186,6 +191,7 @@ class Player {
         void setWalkingState(State state) { walking_state_ = state; }
 
         void addCredit();
+        void passShowingName();
         void setGamepad(std::shared_ptr<Input::Gamepad> gamepad) { gamepad_ = std::move(gamepad); }
         [[nodiscard]] auto getGamepad() const -> std::shared_ptr<Input::Gamepad> { return gamepad_; }
         void setUsesKeyboard(bool value) { uses_keyboard_ = value; }
@@ -231,10 +237,19 @@ class Player {
         int pos_y_ = 0;                                    // Posición en el eje Y
         int default_pos_y_;                                // Posición inicial para el jugador
         int vel_y_ = 0;                                    // Cantidad de píxeles a desplazarse en el eje Y
-        int cant_fire_counter_ = 0;                        // Contador durante el cual no puede disparar
-        int recoiling_state_counter_ = 0;                  // Contador para la animación del estado de retroceso
+        int cant_fire_counter_ = 0;                        // Contador durante el cual no puede disparar (frame-based)
+        int recoiling_state_counter_ = 0;                  // Contador para la animación del estado de retroceso (frame-based)
         int recoiling_state_duration_ = 0;                 // Número de frames que dura el estado de retroceso
-        int cooling_state_counter_ = 0;                    // Contador para la animación del estado cooling
+        int cooling_state_counter_ = 0;                    // Contador para la animación del estado cooling (frame-based)
+        float cant_fire_time_accumulator_ = 0.0f;          // Acumulador de tiempo para cooldown de disparo (time-based)
+        float recoiling_time_accumulator_ = 0.0f;          // Acumulador de tiempo para retroceso (time-based)
+        float cooling_time_accumulator_ = 0.0f;            // Acumulador de tiempo para enfriamiento (time-based)
+        float invulnerable_time_accumulator_ = 0.0f;       // Acumulador de tiempo para invulnerabilidad (time-based)
+        float power_up_time_accumulator_ = 0.0f;           // Acumulador de tiempo para power-up (time-based)
+        float continue_time_accumulator_ = 0.0f;           // Acumulador de tiempo para continue counter (time-based)
+        float name_entry_time_accumulator_ = 0.0f;         // Acumulador de tiempo para name entry counter (time-based)
+        float waiting_time_accumulator_ = 0.0f;            // Acumulador de tiempo para waiting movement (time-based)
+        float step_time_accumulator_ = 0.0f;               // Acumulador de tiempo para step counter (time-based)
         int invulnerable_counter_ = INVULNERABLE_COUNTER;  // Contador para la invulnerabilidad
         int score_ = 0;                                    // Puntos del jugador
         int coffees_ = 0;                                  // Indica cuántos cafés lleva acumulados
@@ -258,9 +273,12 @@ class Player {
         // --- Métodos internos ---
         void shiftColliders();                                                                // Actualiza el círculo de colisión a la posición del jugador
         void shiftSprite();                                                                   // Recoloca el sprite
-        void updateInvulnerable();                                                            // Monitoriza el estado de invulnerabilidad
-        void updateContinueCounter();                                                         // Actualiza el contador de continue
-        void updateEnterNameCounter();                                                        // Actualiza el contador de entrar nombre
+        void updateInvulnerable();                                                            // Monitoriza el estado de invulnerabilidad (frame-based)
+        void updateInvulnerable(float deltaTime);                                         // Monitoriza el estado de invulnerabilidad (time-based)
+        void updateContinueCounter();                                                         // Actualiza el contador de continue (frame-based)
+        void updateContinueCounter(float deltaTime);                                      // Actualiza el contador de continue (time-based)
+        void updateEnterNameCounter();                                                        // Actualiza el contador de entrar nombre (frame-based)
+        void updateEnterNameCounter(float deltaTime);                                     // Actualiza el contador de entrar nombre (time-based)
         void updateShowingName();                                                             // Actualiza el estado SHOWING_NAME
         void decNameEntryCounter();                                                           // Decrementa el contador de entrar nombre
         void updateScoreboard();                                                              // Actualiza el panel del marcador
@@ -268,13 +286,17 @@ class Player {
         void playSound(const std::string &name) const;                                        // Hace sonar un sonido
         [[nodiscard]] auto isRenderable() const -> bool;                                      // Indica si se puede dibujar el objeto
         void addScoreToScoreBoard() const;                                                    // Añade una puntuación a la tabla de records
-        void handleFiringCooldown();                                                          // Gestiona el tiempo de espera después de disparar antes de permitir otro disparo
-        void handleRecoilAndCooling();                                                        // Procesa simultáneamente el retroceso del arma y la transición al estado de enfriamiento si aplica
-        void handleCoolingState();                                                            // Actualiza la lógica interna mientras el sistema está en estado de enfriamiento
+        void handleFiringCooldown();                                                          // Gestiona el tiempo de espera después de disparar antes de permitir otro disparo (frame-based)
+        void handleFiringCooldown(float deltaTime);                                           // Gestiona el tiempo de espera después de disparar antes de permitir otro disparo (time-based)
+        void handleRecoilAndCooling();                                                        // Procesa simultáneamente el retroceso del arma y la transición al estado de enfriamiento si aplica (frame-based)
+        void handleRecoilAndCooling(float deltaTime);                                         // Procesa simultáneamente el retroceso del arma y la transición al estado de enfriamiento si aplica (time-based)
+        void handleCoolingState();                                                            // Actualiza la lógica interna mientras el sistema está en estado de enfriamiento (frame-based)
+        void handleCoolingState(float deltaTime);                                             // Actualiza la lógica interna mientras el sistema está en estado de enfriamiento (time-based)
         void transitionToRecoiling();                                                         // Cambia el estado actual al de retroceso después de disparar
         void transitionToCooling();                                                           // Cambia el estado actual al de enfriamiento (por ejemplo, tras una ráfaga o sobrecalentamiento)
         void completeCooling();                                                               // Finaliza el proceso de enfriamiento y restablece el estado listo para disparar
-        void handlePlayingMovement();                                                         // Gestiona el movimiento del personaje u objeto durante el estado de juego activo
+        void handlePlayingMovement();                                                         // Gestiona el movimiento del personaje u objeto durante el estado de juego activo (frame-based)
+        void handlePlayingMovement(float deltaTime);                                      // Gestiona el movimiento del personaje u objeto durante el estado de juego activo (time-based)
         void handleRecoverMovement();                                                         // Comprueba si ha acabado la animación
         void handleRollingMovement();                                                         // Actualiza la lógica de movimiento de "rodar" (posiblemente tras impacto o acción especial)
         void handleRollingBoundaryCollision();                                                // Detecta y maneja colisiones del objeto rodante con los límites de la pantalla
@@ -287,12 +309,15 @@ class Player {
         void handleEnteringScreen();                                                          // Lógica para entrar en una nueva pantalla, posiblemente con animación o retraso
         void handlePlayer1Entering();                                                         // Controla la animación o posición de entrada del Jugador 1 en pantalla
         void handlePlayer2Entering();                                                         // Controla la animación o posición de entrada del Jugador 2 en pantalla
-        void handleCreditsMovement();                                                         // Movimiento general en la pantalla de créditos (desplazamiento vertical u horizontal)
+        void handleCreditsMovement();                                                         // Movimiento general en la pantalla de créditos (frame-based)
+        void handleCreditsMovement(float deltaTime);                                      // Movimiento general en la pantalla de créditos (time-based)
         void handleCreditsRightMovement();                                                    // Lógica específica para mover los créditos hacia la derecha
         void handleCreditsLeftMovement();                                                     // Lógica específica para mover los créditos hacia la izquierda
-        void handleWaitingMovement();                                                         // Controla la animación del jugador saludando
+        void handleWaitingMovement();                                                         // Controla la animación del jugador saludando (frame-based)
+        void handleWaitingMovement(float deltaTime);                                      // Controla la animación del jugador saludando (time-based)
         void updateWalkingStateForCredits();                                                  // Actualiza el estado de caminata de algún personaje u elemento animado en los créditos
         void setInputBasedOnPlayerId();                                                       // Asocia las entradas de control en función del identificador del jugador (teclas, mando, etc.)
-        void updateStepCounter();                                                             // Incrementa o ajusta el contador de pasos para animaciones o mecánicas relacionadas con movimiento
+        void updateStepCounter();                                                             // Incrementa o ajusta el contador de pasos (frame-based)
+        void updateStepCounter(float deltaTime);                                          // Incrementa o ajusta el contador de pasos (time-based)
         [[nodiscard]] auto computeAnimation() const -> std::pair<std::string, SDL_FlipMode>;  // Calcula la animacion de moverse y disparar del jugador
 };

source/resource.cpp

@@ -2,25 +2,58 @@
 
 #include <SDL3/SDL.h>  // Para SDL_LogInfo, SDL_LogCategory, SDL_LogError, SDL_SetRenderDrawColor, SDL_EventType, SDL_PollEvent, SDL_RenderFillRect, SDL_RenderRect, SDLK_ESCAPE, SDL_Event
 
-#include <algorithm>  // Para find_if, max, find
-#include <array>      // Para array
-#include <cstdlib>    // Para exit
-#include <stdexcept>  // Para runtime_error
-#include <utility>    // Para move
+#include <algorithm>   // Para find_if, max, find
+#include <array>       // Para array
+#include <cstdlib>     // Para exit, getenv
+#include <filesystem>  // Para filesystem::remove, filesystem::exists
+#include <fstream>     // Para ofstream
+#include <stdexcept>   // Para runtime_error
+#include <utility>     // Para move
 
 #include "asset.h"  // Para Asset
 #include "color.h"  // Para Color
 #ifndef NO_AUDIO
 #include "external/jail_audio.h"  // Para JA_LoadMusic, JA_LoadSound, JA_DeleteMusic, JA_DeleteSound
 #endif
-#include "lang.h"    // Para getText
-#include "param.h"   // Para Param, param, ParamResource, ParamGame
-#include "screen.h"  // Para Screen
-#include "text.h"    // Para Text
+#include "lang.h"             // Para getText
+#include "param.h"            // Para Param, param, ParamResource, ParamGame
+#include "resource_helper.h"  // Para ResourceHelper
+#include "screen.h"           // Para Screen
+#include "text.h"             // Para Text
 
 struct JA_Music_t;  // lines 11-11
 struct JA_Sound_t;  // lines 12-12
 
+// Helper para cargar archivos de audio desde pack o filesystem
+namespace {
+std::string createTempAudioFile(const std::string &file_path, std::vector<std::string> &temp_files_tracker) {
+    auto resource_data = ResourceHelper::loadFile(file_path);
+    if (!resource_data.empty()) {
+        // Crear archivo temporal
+        std::string temp_dir;
+#ifdef _WIN32
+        temp_dir = std::getenv("TEMP") ? std::getenv("TEMP") : "C:\\temp";
+#else
+        temp_dir = "/tmp";
+#endif
+        std::string temp_path = temp_dir + "/ccae_audio_" + std::to_string(std::hash<std::string>{}(file_path));
+        std::ofstream temp_file(temp_path, std::ios::binary);
+        if (!temp_file) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Cannot create temp file %s", temp_path.c_str());
+            return file_path;
+        }
+        temp_file.write(reinterpret_cast<const char *>(resource_data.data()), resource_data.size());
+        temp_file.close();
+
+        // Agregar a la lista de archivos temporales para limpieza posterior
+        temp_files_tracker.push_back(temp_path);
+
+        return temp_path;
+    }
+    return file_path;  // Usar ruta original si no está en pack
+}
+}  // namespace
+
 // Declaraciones de funciones que necesitas implementar en otros archivos
 
 // Singleton
@@ -42,7 +75,8 @@ auto Resource::get() -> Resource * { return Resource::instance; }
 
 // Constructor con modo de carga
 Resource::Resource(LoadingMode mode)
-    : loading_mode_(mode), loading_text_(nullptr) {
+    : loading_mode_(mode),
+      loading_text_(nullptr) {
     if (loading_mode_ == LoadingMode::PRELOAD) {
         loading_text_ = Screen::get()->getText();
         load();
@@ -55,6 +89,7 @@ Resource::Resource(LoadingMode mode)
 
 // Destructor
 Resource::~Resource() {
+    cleanupTempAudioFiles();
     clear();
 }
 
@@ -293,7 +328,8 @@ auto Resource::loadSoundLazy(const std::string &name) -> JA_Sound_t * {
     auto sound_list = Asset::get()->getListByType(Asset::Type::SOUND);
     for (const auto &file : sound_list) {
         if (getFileName(file) == name) {
-            return JA_LoadSound(file.c_str());
+            std::string audio_path = createTempAudioFile(file, Resource::get()->temp_audio_files_);
+            return JA_LoadSound(audio_path.c_str());
         }
     }
 #endif
@@ -306,7 +342,8 @@ auto Resource::loadMusicLazy(const std::string &name) -> JA_Music_t * {
     auto music_list = Asset::get()->getListByType(Asset::Type::MUSIC);
     for (const auto &file : music_list) {
         if (getFileName(file) == name) {
-            return JA_LoadMusic(file.c_str());
+            std::string audio_path = createTempAudioFile(file, Resource::get()->temp_audio_files_);
+            return JA_LoadMusic(audio_path.c_str());
         }
     }
 #endif
@@ -448,7 +485,8 @@ void Resource::loadSounds() {
         auto name = getFileName(l);
         updateLoadingProgress(name);
 #ifndef NO_AUDIO
-        sounds_.emplace_back(name, JA_LoadSound(l.c_str()));
+        std::string audio_path = createTempAudioFile(l, temp_audio_files_);
+        sounds_.emplace_back(name, JA_LoadSound(audio_path.c_str()));
 #else
         sounds_.emplace_back(name, nullptr);
 #endif
@@ -466,7 +504,8 @@ void Resource::loadMusics() {
         auto name = getFileName(l);
         updateLoadingProgress(name);
 #ifndef NO_AUDIO
-        musics_.emplace_back(name, JA_LoadMusic(l.c_str()));
+        std::string audio_path = createTempAudioFile(l, temp_audio_files_);
+        musics_.emplace_back(name, JA_LoadMusic(audio_path.c_str()));
 #else
         musics_.emplace_back(name, nullptr);
 #endif
@@ -567,7 +606,7 @@ void Resource::createPlayerTextures() {
                 texture->setPaletteColor(0, 19, param.player.default_shirt[player_idx].light.TO_UINT32());
                 texture->setPaletteColor(0, 56, param.player.outline_color[player_idx].TO_UINT32());
             } else {
-                // Crear textura nueva desde archivo
+                // Crear textura nueva desde archivo usando ResourceHelper
                 texture = std::make_shared<Texture>(Screen::get()->getRenderer(), texture_file_path);
 
                 // Añadir todas las paletas
@@ -611,7 +650,8 @@ void Resource::createTextTextures() {
             std::string text;
 
             NameAndText(std::string name_init, std::string text_init)
-                : name(std::move(name_init)), text(std::move(text_init)) {}
+                : name(std::move(name_init)),
+                  text(std::move(text_init)) {}
     };
 
     SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "\n>> CREATING TEXTURES");
@@ -623,7 +663,8 @@ void Resource::createTextTextures() {
         {"game_text_5000_points", "5.000"},
         {"game_text_powerup", Lang::getText("[GAME_TEXT] 4")},
         {"game_text_one_hit", Lang::getText("[GAME_TEXT] 5")},
-        {"game_text_stop", Lang::getText("[GAME_TEXT] 6")}};
+        {"game_text_stop", Lang::getText("[GAME_TEXT] 6")},
+        {"game_text_1000000_points", Lang::getText("[GAME_TEXT] 8")}};
 
     auto text1 = getText("04b_25_enhanced");
     for (const auto &s : strings1) {
@@ -631,27 +672,17 @@ void Resource::createTextTextures() {
         printWithDots("Texture : ", s.name, "[  DONE  ]");
     }
 
-    // Texturas de tamaño normal
-    std::vector<NameAndText> strings2 = {
-        {"game_text_1000000_points", Lang::getText("[GAME_TEXT] 8")}};
-
-    auto text2 = getText("04b_25");
-    for (const auto &s : strings2) {
-        textures_.emplace_back(s.name, text2->writeDXToTexture(Text::STROKE, s.text, -2, Colors::NO_COLOR_MOD, 1, param.game.item_text_outline_color));
-        printWithDots("Texture : ", s.name, "[  DONE  ]");
-    }
-
     // Texturas de tamaño doble
-    std::vector<NameAndText> strings3 = {
+    std::vector<NameAndText> strings2 = {
         {"game_text_100000_points", "100.000"},
         {"game_text_get_ready", Lang::getText("[GAME_TEXT] 7")},
         {"game_text_last_stage", Lang::getText("[GAME_TEXT] 3")},
         {"game_text_congratulations", Lang::getText("[GAME_TEXT] 1")},
         {"game_text_game_over", "Game Over"}};
 
-    auto text3 = getText("04b_25_2x");
-    for (const auto &s : strings3) {
-        textures_.emplace_back(s.name, text3->writeToTexture(s.text, 1, -4));
+    auto text2 = getText("04b_25_2x_enhanced");
+    for (const auto &s : strings2) {
+        textures_.emplace_back(s.name, text2->writeDXToTexture(Text::STROKE, s.text, -4, Colors::NO_COLOR_MOD, 1, param.game.item_text_outline_color));
         printWithDots("Texture : ", s.name, "[  DONE  ]");
     }
 }
@@ -665,7 +696,10 @@ void Resource::createText() {
             std::string white_texture_file;  // Textura blanca opcional
 
             ResourceInfo(std::string k, std::string t_file, std::string txt_file, std::string w_file = "")
-                : key(std::move(k)), texture_file(std::move(t_file)), text_file(std::move(txt_file)), white_texture_file(std::move(w_file)) {}
+                : key(std::move(k)),
+                  texture_file(std::move(t_file)),
+                  text_file(std::move(txt_file)),
+                  white_texture_file(std::move(w_file)) {}
     };
 
     SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "\n>> CREATING TEXT OBJECTS");
@@ -675,6 +709,7 @@ void Resource::createText() {
         {"04b_25_enhanced", "04b_25.png", "04b_25.txt", "04b_25_white.png"},  // Nueva fuente con textura blanca
         {"04b_25_white", "04b_25_white.png", "04b_25.txt"},
         {"04b_25_2x", "04b_25_2x.png", "04b_25_2x.txt"},
+        {"04b_25_2x_enhanced", "04b_25_2x.png", "04b_25_2x.txt", "04b_25_2x_white.png"},  // Nueva fuente con textura blanca
         {"04b_25_metal", "04b_25_metal.png", "04b_25.txt"},
         {"04b_25_grey", "04b_25_grey.png", "04b_25.txt"},
         {"04b_25_flat", "04b_25_flat.png", "04b_25.txt"},
@@ -833,3 +868,18 @@ void Resource::updateLoadingProgress(std::string name) {
 void Resource::updateProgressBar() {
     loading_full_rect_.w = loading_wired_rect_.w * loading_count_.getPercentage();
 }
+
+// Limpia archivos temporales de audio
+void Resource::cleanupTempAudioFiles() {
+    for (const auto &temp_path : temp_audio_files_) {
+        try {
+            if (std::filesystem::exists(temp_path)) {
+                std::filesystem::remove(temp_path);
+                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Removed temp audio file: %s", temp_path.c_str());
+            }
+        } catch (const std::exception &e) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to remove temp audio file %s: %s", temp_path.c_str(), e.what());
+        }
+    }
+    temp_audio_files_.clear();
+}

source/resource.h

@@ -52,7 +52,8 @@ class Resource {
                 JA_Sound_t *sound;  // Objeto con el sonido
 
                 ResourceSound(std::string name, JA_Sound_t *sound = nullptr)
-                    : name(std::move(name)), sound(sound) {}
+                    : name(std::move(name)),
+                      sound(sound) {}
         };
 
         struct ResourceMusic {
@@ -60,7 +61,8 @@ class Resource {
                 JA_Music_t *music;  // Objeto con la música
 
                 ResourceMusic(std::string name, JA_Music_t *music = nullptr)
-                    : name(std::move(name)), music(music) {}
+                    : name(std::move(name)),
+                      music(music) {}
         };
 
         struct ResourceTexture {
@@ -68,7 +70,8 @@ class Resource {
                 std::shared_ptr<Texture> texture;  // Objeto con la textura
 
                 ResourceTexture(std::string name, std::shared_ptr<Texture> texture = nullptr)
-                    : name(std::move(name)), texture(std::move(texture)) {}
+                    : name(std::move(name)),
+                      texture(std::move(texture)) {}
         };
 
         struct ResourceTextFile {
@@ -76,7 +79,8 @@ class Resource {
                 std::shared_ptr<Text::File> text_file;  // Objeto con los descriptores de la fuente de texto
 
                 ResourceTextFile(std::string name, std::shared_ptr<Text::File> text_file = nullptr)
-                    : name(std::move(name)), text_file(std::move(text_file)) {}
+                    : name(std::move(name)),
+                      text_file(std::move(text_file)) {}
         };
 
         struct ResourceText {
@@ -84,7 +88,8 @@ class Resource {
                 std::shared_ptr<Text> text;  // Objeto de texto
 
                 ResourceText(std::string name, std::shared_ptr<Text> text = nullptr)
-                    : name(std::move(name)), text(std::move(text)) {}
+                    : name(std::move(name)),
+                      text(std::move(text)) {}
         };
 
         struct ResourceAnimation {
@@ -92,7 +97,8 @@ class Resource {
                 AnimationsFileBuffer animation;  // Objeto con las animaciones
 
                 ResourceAnimation(std::string name, AnimationsFileBuffer animation = {})
-                    : name(std::move(name)), animation(std::move(animation)) {}
+                    : name(std::move(name)),
+                      animation(std::move(animation)) {}
         };
 
         // --- Estructura para el progreso de carga ---
@@ -100,8 +106,12 @@ class Resource {
                 size_t total;   // Número total de recursos
                 size_t loaded;  // Número de recursos cargados
 
-                ResourceCount() : total(0), loaded(0) {}
-                ResourceCount(size_t total) : total(total), loaded(0) {}
+                ResourceCount()
+                    : total(0),
+                      loaded(0) {}
+                ResourceCount(size_t total)
+                    : total(total),
+                      loaded(0) {}
 
                 void add(size_t amount) { loaded += amount; }
                 void increase() { loaded++; }
@@ -129,6 +139,9 @@ class Resource {
         SDL_FRect loading_wired_rect_;
         SDL_FRect loading_full_rect_;
 
+        // --- Archivos temporales ---
+        std::vector<std::string> temp_audio_files_;  // Rutas de archivos temporales de audio para limpieza
+
         // --- Métodos internos de carga y gestión ---
         void loadSounds();              // Carga los sonidos
         void loadMusics();              // Carga las músicas
@@ -147,6 +160,7 @@ class Resource {
         void load();                    // Carga todos los recursos
         void clearSounds();             // Vacía el vector de sonidos
         void clearMusics();             // Vacía el vector de músicas
+        void cleanupTempAudioFiles();   // Limpia archivos temporales de audio
 
         // --- Métodos para carga perezosa ---
         void initResourceLists();                                                              // Inicializa las listas de recursos sin cargar el contenido

source/resource_helper.cpp

@@ -0,0 +1,96 @@
+#include "resource_helper.h"
+
+#include <algorithm>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+
+namespace ResourceHelper {
+static bool resource_system_initialized = false;
+
+bool initializeResourceSystem(const std::string& pack_file) {
+    auto& loader = ResourceLoader::getInstance();
+    resource_system_initialized = loader.initialize(pack_file, true);
+
+    if (resource_system_initialized) {
+        std::cout << "Resource system initialized with pack: " << pack_file << std::endl;
+    } else {
+        std::cout << "Resource system using fallback mode (filesystem only)" << std::endl;
+    }
+
+    return true;  // Always return true as fallback is acceptable
+}
+
+void shutdownResourceSystem() {
+    if (resource_system_initialized) {
+        ResourceLoader::getInstance().shutdown();
+        resource_system_initialized = false;
+    }
+}
+
+std::vector<uint8_t> loadFile(const std::string& filepath) {
+    if (resource_system_initialized && shouldUseResourcePack(filepath)) {
+        auto& loader = ResourceLoader::getInstance();
+        std::string pack_path = getPackPath(filepath);
+
+        auto data = loader.loadResource(pack_path);
+        if (!data.empty()) {
+            return data;
+        }
+    }
+
+    // Fallback a filesystem
+    std::ifstream file(filepath, std::ios::binary | std::ios::ate);
+    if (!file) {
+        return {};
+    }
+
+    std::streamsize fileSize = file.tellg();
+    file.seekg(0, std::ios::beg);
+
+    std::vector<uint8_t> data(fileSize);
+    if (!file.read(reinterpret_cast<char*>(data.data()), fileSize)) {
+        return {};
+    }
+
+    return data;
+}
+
+bool shouldUseResourcePack(const std::string& filepath) {
+    // Archivos que NO van al pack:
+    // - config/ (ahora está fuera de data/)
+    // - archivos absolutos del sistema
+
+    if (filepath.find("config/") != std::string::npos) {
+        return false;
+    }
+
+    // Si contiene "data/" es candidato para el pack
+    if (filepath.find("data/") != std::string::npos) {
+        return true;
+    }
+
+    return false;
+}
+
+std::string getPackPath(const std::string& asset_path) {
+    std::string pack_path = asset_path;
+
+    // Normalizar separadores de path a '/'
+    std::replace(pack_path.begin(), pack_path.end(), '\\', '/');
+
+    // Remover prefijo "data/" si existe
+    size_t data_pos = pack_path.find("data/");
+    if (data_pos != std::string::npos) {
+        pack_path = pack_path.substr(data_pos + 5);  // +5 para saltar "data/"
+    }
+
+    // Remover cualquier prefijo de path absoluto
+    size_t last_data = pack_path.rfind("data/");
+    if (last_data != std::string::npos) {
+        pack_path = pack_path.substr(last_data + 5);
+    }
+
+    return pack_path;
+}
+}  // namespace ResourceHelper

source/resource_helper.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <filesystem>
+#include <fstream>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "resource_loader.h"
+
+// Helper functions para integrar ResourceLoader con el sistema existente
+namespace ResourceHelper {
+// Inicializa ResourceLoader (llamar al inicio del programa)
+bool initializeResourceSystem(const std::string& pack_file = "resources.pack");
+
+// Cierra ResourceLoader
+void shutdownResourceSystem();
+
+// Carga un archivo usando ResourceLoader o fallback a filesystem
+std::vector<uint8_t> loadFile(const std::string& filepath);
+
+// Verifica si un archivo debería cargarse del pack vs filesystem
+bool shouldUseResourcePack(const std::string& filepath);
+
+// Convierte ruta Asset a ruta relativa para ResourceLoader
+std::string getPackPath(const std::string& asset_path);
+
+// Wrappea la carga de archivos para mantener compatibilidad
+template <typename T>
+T* loadResourceFile(const std::string& asset_path, T* (*loader_func)(const char*)) {
+    auto data = loadFile(asset_path);
+    if (data.empty()) {
+        return loader_func(asset_path.c_str());
+    }
+
+    // Crear archivo temporal para funciones que esperan path
+    std::string temp_path = "/tmp/ccae_" + std::to_string(std::hash<std::string>{}(asset_path));
+    std::ofstream temp_file(temp_path, std::ios::binary);
+    temp_file.write(reinterpret_cast<const char*>(data.data()), data.size());
+    temp_file.close();
+
+    T* result = loader_func(temp_path.c_str());
+    std::filesystem::remove(temp_path);
+
+    return result;
+}
+}  // namespace ResourceHelper

source/resource_loader.cpp

@@ -0,0 +1,135 @@
+#include "resource_loader.h"
+
+#include <algorithm>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+
+std::unique_ptr<ResourceLoader> ResourceLoader::instance = nullptr;
+
+ResourceLoader::ResourceLoader()
+    : resourcePack(nullptr),
+      fallbackToFiles(true) {}
+
+ResourceLoader& ResourceLoader::getInstance() {
+    if (!instance) {
+        instance = std::unique_ptr<ResourceLoader>(new ResourceLoader());
+    }
+    return *instance;
+}
+
+ResourceLoader::~ResourceLoader() {
+    shutdown();
+}
+
+bool ResourceLoader::initialize(const std::string& packFile, bool enableFallback) {
+    shutdown();
+
+    fallbackToFiles = enableFallback;
+    packPath = packFile;
+
+    if (std::filesystem::exists(packFile)) {
+        resourcePack = new ResourcePack();
+        if (resourcePack->loadPack(packFile)) {
+            std::cout << "Resource pack loaded successfully: " << packFile << std::endl;
+            std::cout << "Resources available: " << resourcePack->getResourceCount() << std::endl;
+            return true;
+        } else {
+            delete resourcePack;
+            resourcePack = nullptr;
+            std::cerr << "Failed to load resource pack: " << packFile << std::endl;
+        }
+    }
+
+    if (fallbackToFiles) {
+        std::cout << "Using fallback mode: loading resources from data/ directory" << std::endl;
+        return true;
+    }
+
+    std::cerr << "Resource pack not found and fallback disabled: " << packFile << std::endl;
+    return false;
+}
+
+void ResourceLoader::shutdown() {
+    if (resourcePack) {
+        delete resourcePack;
+        resourcePack = nullptr;
+    }
+}
+
+std::vector<uint8_t> ResourceLoader::loadResource(const std::string& filename) {
+    if (resourcePack && resourcePack->hasResource(filename)) {
+        return resourcePack->getResource(filename);
+    }
+
+    if (fallbackToFiles) {
+        return loadFromFile(filename);
+    }
+
+    std::cerr << "Resource not found: " << filename << std::endl;
+    return {};
+}
+
+bool ResourceLoader::resourceExists(const std::string& filename) {
+    if (resourcePack && resourcePack->hasResource(filename)) {
+        return true;
+    }
+
+    if (fallbackToFiles) {
+        std::string fullPath = getDataPath(filename);
+        return std::filesystem::exists(fullPath);
+    }
+
+    return false;
+}
+
+std::vector<uint8_t> ResourceLoader::loadFromFile(const std::string& filename) {
+    std::string fullPath = getDataPath(filename);
+
+    std::ifstream file(fullPath, std::ios::binary | std::ios::ate);
+    if (!file) {
+        std::cerr << "Error: Could not open file: " << fullPath << std::endl;
+        return {};
+    }
+
+    std::streamsize fileSize = file.tellg();
+    file.seekg(0, std::ios::beg);
+
+    std::vector<uint8_t> data(fileSize);
+    if (!file.read(reinterpret_cast<char*>(data.data()), fileSize)) {
+        std::cerr << "Error: Could not read file: " << fullPath << std::endl;
+        return {};
+    }
+
+    return data;
+}
+
+std::string ResourceLoader::getDataPath(const std::string& filename) {
+    return "data/" + filename;
+}
+
+size_t ResourceLoader::getLoadedResourceCount() const {
+    if (resourcePack) {
+        return resourcePack->getResourceCount();
+    }
+    return 0;
+}
+
+std::vector<std::string> ResourceLoader::getAvailableResources() const {
+    if (resourcePack) {
+        return resourcePack->getResourceList();
+    }
+
+    std::vector<std::string> result;
+    if (fallbackToFiles && std::filesystem::exists("data")) {
+        for (const auto& entry : std::filesystem::recursive_directory_iterator("data")) {
+            if (entry.is_regular_file()) {
+                std::string filename = std::filesystem::relative(entry.path(), "data").string();
+                std::replace(filename.begin(), filename.end(), '\\', '/');
+                result.push_back(filename);
+            }
+        }
+    }
+
+    return result;
+}

source/resource_loader.h

@@ -0,0 +1,38 @@
+#ifndef RESOURCE_LOADER_H
+#define RESOURCE_LOADER_H
+
+#include <memory>
+
+#include "resource_pack.h"
+
+class ResourceLoader {
+    private:
+        static std::unique_ptr<ResourceLoader> instance;
+        ResourcePack* resourcePack;
+        std::string packPath;
+        bool fallbackToFiles;
+
+        ResourceLoader();
+
+    public:
+        static ResourceLoader& getInstance();
+        ~ResourceLoader();
+
+        bool initialize(const std::string& packFile, bool enableFallback = true);
+        void shutdown();
+
+        std::vector<uint8_t> loadResource(const std::string& filename);
+        bool resourceExists(const std::string& filename);
+
+        void setFallbackToFiles(bool enable) { fallbackToFiles = enable; }
+        bool getFallbackToFiles() const { return fallbackToFiles; }
+
+        size_t getLoadedResourceCount() const;
+        std::vector<std::string> getAvailableResources() const;
+
+    private:
+        std::vector<uint8_t> loadFromFile(const std::string& filename);
+        std::string getDataPath(const std::string& filename);
+};
+
+#endif

source/resource_pack.cpp

@@ -0,0 +1,224 @@
+#include "resource_pack.h"
+
+#include <algorithm>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+
+const std::string ResourcePack::DEFAULT_ENCRYPT_KEY = "CCAE_RESOURCES_2024";
+
+ResourcePack::ResourcePack()
+    : loaded(false) {}
+
+ResourcePack::~ResourcePack() {
+    clear();
+}
+
+uint32_t ResourcePack::calculateChecksum(const std::vector<uint8_t>& data) {
+    uint32_t checksum = 0x12345678;
+    for (size_t i = 0; i < data.size(); ++i) {
+        checksum = ((checksum << 5) + checksum) + data[i];
+    }
+    return checksum;
+}
+
+void ResourcePack::encryptData(std::vector<uint8_t>& data, const std::string& key) {
+    if (key.empty()) return;
+
+    for (size_t i = 0; i < data.size(); ++i) {
+        data[i] ^= key[i % key.length()];
+    }
+}
+
+void ResourcePack::decryptData(std::vector<uint8_t>& data, const std::string& key) {
+    encryptData(data, key);
+}
+
+bool ResourcePack::loadPack(const std::string& packFile) {
+    std::ifstream file(packFile, std::ios::binary);
+    if (!file) {
+        std::cerr << "Error: Could not open pack file: " << packFile << std::endl;
+        return false;
+    }
+
+    char header[4];
+    file.read(header, 4);
+    if (std::string(header, 4) != "CCAE") {
+        std::cerr << "Error: Invalid pack file format" << std::endl;
+        return false;
+    }
+
+    uint32_t version;
+    file.read(reinterpret_cast<char*>(&version), sizeof(version));
+    if (version != 1) {
+        std::cerr << "Error: Unsupported pack version: " << version << std::endl;
+        return false;
+    }
+
+    uint32_t resourceCount;
+    file.read(reinterpret_cast<char*>(&resourceCount), sizeof(resourceCount));
+
+    resources.clear();
+    resources.reserve(resourceCount);
+
+    for (uint32_t i = 0; i < resourceCount; ++i) {
+        uint32_t filenameLength;
+        file.read(reinterpret_cast<char*>(&filenameLength), sizeof(filenameLength));
+
+        std::string filename(filenameLength, '\0');
+        file.read(&filename[0], filenameLength);
+
+        ResourceEntry entry;
+        entry.filename = filename;
+        file.read(reinterpret_cast<char*>(&entry.offset), sizeof(entry.offset));
+        file.read(reinterpret_cast<char*>(&entry.size), sizeof(entry.size));
+        file.read(reinterpret_cast<char*>(&entry.checksum), sizeof(entry.checksum));
+
+        resources[filename] = entry;
+    }
+
+    uint64_t dataSize;
+    file.read(reinterpret_cast<char*>(&dataSize), sizeof(dataSize));
+
+    data.resize(dataSize);
+    file.read(reinterpret_cast<char*>(data.data()), dataSize);
+
+    decryptData(data, DEFAULT_ENCRYPT_KEY);
+
+    loaded = true;
+    return true;
+}
+
+bool ResourcePack::savePack(const std::string& packFile) {
+    std::ofstream file(packFile, std::ios::binary);
+    if (!file) {
+        std::cerr << "Error: Could not create pack file: " << packFile << std::endl;
+        return false;
+    }
+
+    file.write("CCAE", 4);
+
+    uint32_t version = 1;
+    file.write(reinterpret_cast<const char*>(&version), sizeof(version));
+
+    uint32_t resourceCount = static_cast<uint32_t>(resources.size());
+    file.write(reinterpret_cast<const char*>(&resourceCount), sizeof(resourceCount));
+
+    for (const auto& [filename, entry] : resources) {
+        uint32_t filenameLength = static_cast<uint32_t>(filename.length());
+        file.write(reinterpret_cast<const char*>(&filenameLength), sizeof(filenameLength));
+        file.write(filename.c_str(), filenameLength);
+
+        file.write(reinterpret_cast<const char*>(&entry.offset), sizeof(entry.offset));
+        file.write(reinterpret_cast<const char*>(&entry.size), sizeof(entry.size));
+        file.write(reinterpret_cast<const char*>(&entry.checksum), sizeof(entry.checksum));
+    }
+
+    std::vector<uint8_t> encryptedData = data;
+    encryptData(encryptedData, DEFAULT_ENCRYPT_KEY);
+
+    uint64_t dataSize = encryptedData.size();
+    file.write(reinterpret_cast<const char*>(&dataSize), sizeof(dataSize));
+    file.write(reinterpret_cast<const char*>(encryptedData.data()), dataSize);
+
+    return true;
+}
+
+bool ResourcePack::addFile(const std::string& filename, const std::string& filepath) {
+    std::ifstream file(filepath, std::ios::binary | std::ios::ate);
+    if (!file) {
+        std::cerr << "Error: Could not open file: " << filepath << std::endl;
+        return false;
+    }
+
+    std::streamsize fileSize = file.tellg();
+    file.seekg(0, std::ios::beg);
+
+    std::vector<uint8_t> fileData(fileSize);
+    if (!file.read(reinterpret_cast<char*>(fileData.data()), fileSize)) {
+        std::cerr << "Error: Could not read file: " << filepath << std::endl;
+        return false;
+    }
+
+    ResourceEntry entry;
+    entry.filename = filename;
+    entry.offset = data.size();
+    entry.size = fileData.size();
+    entry.checksum = calculateChecksum(fileData);
+
+    data.insert(data.end(), fileData.begin(), fileData.end());
+    resources[filename] = entry;
+
+    return true;
+}
+
+bool ResourcePack::addDirectory(const std::string& directory) {
+    if (!std::filesystem::exists(directory)) {
+        std::cerr << "Error: Directory does not exist: " << directory << std::endl;
+        return false;
+    }
+
+    for (const auto& entry : std::filesystem::recursive_directory_iterator(directory)) {
+        if (entry.is_regular_file()) {
+            std::string filepath = entry.path().string();
+            std::string filename = std::filesystem::relative(entry.path(), directory).string();
+
+            std::replace(filename.begin(), filename.end(), '\\', '/');
+
+            if (!addFile(filename, filepath)) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+std::vector<uint8_t> ResourcePack::getResource(const std::string& filename) {
+    auto it = resources.find(filename);
+    if (it == resources.end()) {
+        std::cerr << "Error: Resource not found: " << filename << std::endl;
+        return {};
+    }
+
+    const ResourceEntry& entry = it->second;
+    if (entry.offset + entry.size > data.size()) {
+        std::cerr << "Error: Invalid resource data: " << filename << std::endl;
+        return {};
+    }
+
+    std::vector<uint8_t> result(data.begin() + entry.offset,
+        data.begin() + entry.offset + entry.size);
+
+    uint32_t checksum = calculateChecksum(result);
+    if (checksum != entry.checksum) {
+        std::cerr << "Warning: Checksum mismatch for resource: " << filename << std::endl;
+    }
+
+    return result;
+}
+
+bool ResourcePack::hasResource(const std::string& filename) const {
+    return resources.find(filename) != resources.end();
+}
+
+void ResourcePack::clear() {
+    resources.clear();
+    data.clear();
+    loaded = false;
+}
+
+size_t ResourcePack::getResourceCount() const {
+    return resources.size();
+}
+
+std::vector<std::string> ResourcePack::getResourceList() const {
+    std::vector<std::string> result;
+    result.reserve(resources.size());
+
+    for (const auto& [filename, entry] : resources) {
+        result.push_back(filename);
+    }
+
+    return result;
+}

source/resource_pack.h

@@ -0,0 +1,46 @@
+#ifndef RESOURCE_PACK_H
+#define RESOURCE_PACK_H
+
+#include <cstdint>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+struct ResourceEntry {
+        std::string filename;
+        uint64_t offset;
+        uint64_t size;
+        uint32_t checksum;
+};
+
+class ResourcePack {
+    private:
+        std::unordered_map<std::string, ResourceEntry> resources;
+        std::vector<uint8_t> data;
+        bool loaded;
+
+        uint32_t calculateChecksum(const std::vector<uint8_t>& data);
+        void encryptData(std::vector<uint8_t>& data, const std::string& key);
+        void decryptData(std::vector<uint8_t>& data, const std::string& key);
+
+    public:
+        ResourcePack();
+        ~ResourcePack();
+
+        bool loadPack(const std::string& packFile);
+        bool savePack(const std::string& packFile);
+
+        bool addFile(const std::string& filename, const std::string& filepath);
+        bool addDirectory(const std::string& directory);
+
+        std::vector<uint8_t> getResource(const std::string& filename);
+        bool hasResource(const std::string& filename) const;
+
+        void clear();
+        size_t getResourceCount() const;
+        std::vector<std::string> getResourceList() const;
+
+        static const std::string DEFAULT_ENCRYPT_KEY;
+};
+
+#endif

source/scoreboard.cpp

@@ -40,7 +40,8 @@ Scoreboard::Scoreboard()
     : renderer_(Screen::get()->getRenderer()),
       game_power_meter_texture_(Resource::get()->getTexture("game_power_meter.png")),
       power_meter_sprite_(std::make_unique<Sprite>(game_power_meter_texture_)),
-      text_scoreboard_(Resource::get()->getText("8bithud")) {
+      text_(Resource::get()->getText("8bithud")),
+      enter_name_text_(Resource::get()->getText("smb2")) {
     // Inicializa variables
     for (size_t i = 0; i < static_cast<size_t>(Id::SIZE); ++i) {
         name_.at(i).clear();
@@ -198,50 +199,50 @@ void Scoreboard::renderPanelContent(size_t panel_index) {
 
 void Scoreboard::renderScoreMode(size_t panel_index) {
     // SCORE
-    text_scoreboard_->writeDX(Text::COLOR | Text::CENTER, slot4_1_.x, slot4_1_.y, name_.at(panel_index), 1, text_color1_);
-    text_scoreboard_->writeDX(Text::COLOR | Text::CENTER, slot4_2_.x, slot4_2_.y, updateScoreText(score_.at(panel_index)), 1, text_color2_);
+    text_->writeDX(Text::COLOR | Text::CENTER, slot4_1_.x, slot4_1_.y, name_.at(panel_index), 1, text_color1_);
+    text_->writeDX(Text::COLOR | Text::CENTER, slot4_2_.x, slot4_2_.y, updateScoreText(score_.at(panel_index)), 1, text_color2_);
 
     // MULT
-    text_scoreboard_->writeDX(Text::COLOR | Text::CENTER, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 3"), 1, text_color1_);
-    text_scoreboard_->writeDX(Text::COLOR | Text::CENTER, slot4_4_.x, slot4_4_.y, "x" + std::to_string(mult_.at(panel_index)).substr(0, 3), 1, text_color2_);
+    text_->writeDX(Text::COLOR | Text::CENTER, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 3"), 1, text_color1_);
+    text_->writeDX(Text::COLOR | Text::CENTER, slot4_4_.x, slot4_4_.y, "x" + std::to_string(mult_.at(panel_index)).substr(0, 3), 1, text_color2_);
 }
 
 void Scoreboard::renderDemoMode() {
     // DEMO MODE
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y + 4, Lang::getText("[SCOREBOARD] 6"), 1, text_color1_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y + 4, Lang::getText("[SCOREBOARD] 6"), 1, text_color1_);
 
     // PRESS START TO PLAY
     if (time_counter_ % 10 < 8) {
-        text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y - 2, Lang::getText("[SCOREBOARD] 8"), 1, text_color1_);
-        text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y - 2, Lang::getText("[SCOREBOARD] 9"), 1, text_color1_);
+        text_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y - 2, Lang::getText("[SCOREBOARD] 8"), 1, text_color1_);
+        text_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y - 2, Lang::getText("[SCOREBOARD] 9"), 1, text_color1_);
     }
 }
 
 void Scoreboard::renderWaitingMode() {
     // GAME OVER
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y + 4, Lang::getText("[SCOREBOARD] 7"), 1, text_color1_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y + 4, Lang::getText("[SCOREBOARD] 7"), 1, text_color1_);
 
     // PRESS START TO PLAY
     if (time_counter_ % 10 < 8) {
-        text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y - 2, Lang::getText("[SCOREBOARD] 8"), 1, text_color1_);
-        text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y - 2, Lang::getText("[SCOREBOARD] 9"), 1, text_color1_);
+        text_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y - 2, Lang::getText("[SCOREBOARD] 8"), 1, text_color1_);
+        text_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y - 2, Lang::getText("[SCOREBOARD] 9"), 1, text_color1_);
     }
 }
 
 void Scoreboard::renderGameOverMode() {
     // GAME OVER
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y + 4, Lang::getText("[SCOREBOARD] 7"), 1, text_color1_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y + 4, Lang::getText("[SCOREBOARD] 7"), 1, text_color1_);
 
     // PLEASE WAIT
     if (time_counter_ % 10 < 8) {
-        text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y - 2, Lang::getText("[SCOREBOARD] 12"), 1, text_color1_);
-        text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y - 2, Lang::getText("[SCOREBOARD] 13"), 1, text_color1_);
+        text_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y - 2, Lang::getText("[SCOREBOARD] 12"), 1, text_color1_);
+        text_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y - 2, Lang::getText("[SCOREBOARD] 13"), 1, text_color1_);
     }
 }
 
 void Scoreboard::renderStageInfoMode() {
     // STAGE
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y, Lang::getText("[SCOREBOARD] 5") + " " + std::to_string(stage_), 1, text_color1_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y, Lang::getText("[SCOREBOARD] 5") + " " + std::to_string(stage_), 1, text_color1_);
 
     // POWERMETER
     power_meter_sprite_->setSpriteClip(0, 0, 40, 7);
@@ -250,76 +251,75 @@ void Scoreboard::renderStageInfoMode() {
     power_meter_sprite_->render();
 
     // HI-SCORE
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 4"), 1, text_color1_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 4"), 1, text_color1_);
     const std::string NAME = hi_score_name_.empty() ? "" : hi_score_name_ + " - ";
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y, NAME + updateScoreText(hi_score_), 1, text_color2_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y, NAME + updateScoreText(hi_score_), 1, text_color2_);
 }
 
 void Scoreboard::renderContinueMode(size_t panel_index) {
     // SCORE
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y, name_.at(panel_index), 1, text_color1_);
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_2_.x, slot4_2_.y, updateScoreText(score_.at(panel_index)), 1, text_color2_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y, name_.at(panel_index), 1, text_color1_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_2_.x, slot4_2_.y, updateScoreText(score_.at(panel_index)), 1, text_color2_);
 
     // CONTINUE
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 10"), 1, text_color1_);
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y, std::to_string(continue_counter_.at(panel_index)), 1, text_color2_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 10"), 1, text_color1_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y, std::to_string(continue_counter_.at(panel_index)), 1, text_color2_);
 }
 
 void Scoreboard::renderEnterNameMode(size_t panel_index) {
     // SCORE
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y, name_.at(panel_index), 1, text_color1_);
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_2_.x, slot4_2_.y, updateScoreText(score_.at(panel_index)), 1, text_color2_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y, name_.at(panel_index), 1, text_color1_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_2_.x, slot4_2_.y, updateScoreText(score_.at(panel_index)), 1, text_color2_);
 
     // ENTER NAME
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 11"), 1, text_color1_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 11"), 1, text_color1_);
 
     renderNameInputField(panel_index);
 }
 
 void Scoreboard::renderNameInputField(size_t panel_index) {
-    SDL_FRect rect = {enter_name_pos_.x, enter_name_pos_.y, 5.0F, 7.0F};
+    SDL_FRect rect = {
+        .x = enter_name_pos_.x,
+        .y = enter_name_pos_.y,
+        .w = static_cast<float>(enter_name_text_->getCharacterSize() - 2),
+        .h = static_cast<float>(enter_name_text_->getCharacterSize())};
 
     // Recorre todos los slots de letras del nombre
     for (size_t j = 0; j < NAME_SIZE; ++j) {
-        // Selecciona el color
-        const Color COLOR = j < selector_pos_.at(panel_index) ? text_color2_ : text_color1_;
-
-        if (j != selector_pos_.at(panel_index) || time_counter_ % 3 == 0) {
-            // Dibuja la linea
-            if (j >= selector_pos_.at(panel_index)) {
-                SDL_SetRenderDrawColor(renderer_, COLOR.r, COLOR.g, COLOR.b, 255);
-                SDL_RenderLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
-            }
-
-            // Dibuja la letra
-            if (j < record_name_.at(panel_index).size()) {
-                text_scoreboard_->writeColored(rect.x, rect.y, record_name_.at(panel_index).substr(j, 1), COLOR);
-            }
+        // Dibuja la linea. Si coincide con el selector solo se dibuja 2 de cada 4 veces
+        if (j != selector_pos_.at(panel_index) || time_counter_ % 4 >= 2) {
+            SDL_SetRenderDrawColor(renderer_, text_color1_.r, text_color1_.g, text_color1_.b, 255);
+            SDL_RenderLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
         }
-        rect.x += 7;
+
+        // Dibuja la letra
+        if (j < record_name_.at(panel_index).size()) {
+            enter_name_text_->writeColored(rect.x, rect.y, record_name_.at(panel_index).substr(j, 1), text_color2_);
+        }
+        rect.x += enter_name_text_->getCharacterSize();
     }
 }
 
 void Scoreboard::renderShowNameMode(size_t panel_index) {
     // SCORE
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y, name_.at(panel_index), 1, text_color1_);
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_2_.x, slot4_2_.y, updateScoreText(score_.at(panel_index)), 1, text_color2_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y, name_.at(panel_index), 1, text_color1_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_2_.x, slot4_2_.y, updateScoreText(score_.at(panel_index)), 1, text_color2_);
 
     // NAME
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 11"), 1, text_color1_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 11"), 1, text_color1_);
 
-    /* TEXTO CENTRADO */
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y, record_name_.at(panel_index), 1, Colors::getColorLikeKnightRider(name_colors_, loop_counter_ / 5));
+    // NOMBRE INTRODUCIDO
+    enter_name_text_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y, record_name_.at(panel_index), 1, Colors::getColorLikeKnightRider(name_colors_, loop_counter_ / 5));
 }
 
 void Scoreboard::renderGameCompletedMode(size_t panel_index) {
     // GAME OVER
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y + 4, Lang::getText("[SCOREBOARD] 7"), 1, text_color1_);
+    text_->writeDX(Text::CENTER | Text::COLOR, slot4_1_.x, slot4_1_.y + 4, Lang::getText("[SCOREBOARD] 7"), 1, text_color1_);
 
     // SCORE
     if (time_counter_ % 10 < 8) {
-        text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y - 2, Lang::getText("[SCOREBOARD] 14"), 1, text_color1_);
-        text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y - 2, updateScoreText(score_.at(panel_index)), 1, text_color2_);
+        text_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y - 2, Lang::getText("[SCOREBOARD] 14"), 1, text_color1_);
+        text_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y - 2, updateScoreText(score_.at(panel_index)), 1, text_color2_);
     }
 }
 
@@ -379,7 +379,7 @@ void Scoreboard::recalculateAnchors() {
     slot4_4_ = {.x = COL, .y = ROW4};
 
     // Primer cuadrado para poner el nombre de record
-    const int ENTER_NAME_LENGTH = text_scoreboard_->length(std::string(NAME_SIZE, 'A'));
+    const int ENTER_NAME_LENGTH = enter_name_text_->length(std::string(NAME_SIZE, 'A'));
     enter_name_pos_.x = COL - (ENTER_NAME_LENGTH / 2);
     enter_name_pos_.y = ROW4;
 

source/scoreboard.h

@@ -73,7 +73,8 @@ class Scoreboard {
         SDL_Renderer *renderer_;                             // El renderizador de la ventana
         std::shared_ptr<Texture> game_power_meter_texture_;  // Textura con el marcador de poder de la fase
         std::unique_ptr<Sprite> power_meter_sprite_;         // Sprite para el medidor de poder de la fase
-        std::shared_ptr<Text> text_scoreboard_;              // Fuente para el marcador del juego
+        std::shared_ptr<Text> text_;                         // Fuente para el marcador del juego
+        std::shared_ptr<Text> enter_name_text_;              // Fuente para la introducción de nombre del jugador
         SDL_Texture *background_ = nullptr;                  // Textura para dibujar el marcador
         std::vector<SDL_Texture *> panel_texture_;           // Texturas para dibujar cada panel
 

source/screen.cpp

@@ -224,8 +224,10 @@ void Screen::renderInfo() {
 void Screen::loadShaders() {
     if (shader_source_.empty()) {
         const std::string GLSL_FILE = param.game.game_area.rect.h == 256 ? "crtpi_256.glsl" : "crtpi_240.glsl";
-        std::ifstream f(Asset::get()->get(GLSL_FILE).c_str());
-        shader_source_ = std::string((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
+        auto data = Asset::get()->loadData(GLSL_FILE);
+        if (!data.empty()) {
+            shader_source_ = std::string(data.begin(), data.end());
+        }
     }
 }
 

source/screen.h

@@ -91,7 +91,11 @@ class Screen {
                 Color color;   // Color del flash
 
                 explicit FlashEffect(bool enabled = false, int length = 0, int delay = 0, Color color = Color(0xFF, 0xFF, 0xFF))
-                    : enabled(enabled), length(length), delay(delay), counter(length), color(color) {}
+                    : enabled(enabled),
+                      length(length),
+                      delay(delay),
+                      counter(length),
+                      color(color) {}
 
                 void update() { (enabled && counter > 0) ? counter-- : static_cast<int>(enabled = false); }
                 [[nodiscard]] auto isRendarable() const -> bool { return enabled && counter < length - delay; }
@@ -109,7 +113,14 @@ class Screen {
                 bool enabled;        // Indica si el efecto está activo
 
                 explicit ShakeEffect(bool en = false, int dp = 2, int dl = 3, int cnt = 0, int len = 8, int rem = 0, int orig_pos = 0, int orig_width = 800)
-                    : desp(dp), delay(dl), counter(cnt), length(len), remaining(rem), original_pos(orig_pos), original_width(orig_width), enabled(en) {}
+                    : desp(dp),
+                      delay(dl),
+                      counter(cnt),
+                      length(len),
+                      remaining(rem),
+                      original_pos(orig_pos),
+                      original_width(orig_width),
+                      enabled(en) {}
 
                 // Activa el efecto de sacudida y guarda la posición y tamaño originales
                 void enable(SDL_FRect &src_rect, SDL_FRect &dst_rect, int new_desp = -1, int new_delay = -1, int new_length = -1) {

source/sections/credits.cpp

@@ -35,7 +35,12 @@ constexpr std::string_view TEXT_COPYRIGHT = "@2020,2025 JailDesigner";
 
 // Constructor
 Credits::Credits()
-    : balloon_manager_(std::make_unique<BalloonManager>(nullptr)), tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::DIAGONAL)), fade_in_(std::make_unique<Fade>()), fade_out_(std::make_unique<Fade>()), text_texture_(SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, static_cast<int>(param.game.width), static_cast<int>(param.game.height))), canvas_(SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, static_cast<int>(param.game.width), static_cast<int>(param.game.height))) {
+    : balloon_manager_(std::make_unique<BalloonManager>(nullptr)),
+      tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::DIAGONAL)),
+      fade_in_(std::make_unique<Fade>()),
+      fade_out_(std::make_unique<Fade>()),
+      text_texture_(SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, static_cast<int>(param.game.width), static_cast<int>(param.game.height))),
+      canvas_(SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, static_cast<int>(param.game.width), static_cast<int>(param.game.height))) {
     if (text_texture_ == nullptr) {
         throw std::runtime_error("Failed to create SDL texture for text.");
     }
@@ -73,20 +78,31 @@ Credits::~Credits() {
     Options::gamepad_manager.clearPlayers();
 }
 
+// Calcula el deltatime
+auto Credits::calculateDeltaTime() -> float {
+    const Uint64 current_time = SDL_GetTicks();
+    const float delta_time = static_cast<float>(current_time - last_time_);
+    last_time_ = current_time;
+    return delta_time;
+}
+
 // Bucle principal
 void Credits::run() {
+    last_time_ = SDL_GetTicks();
+
     while (Section::name == Section::Name::CREDITS) {
         checkInput();
-        update();
+        const float delta_time = calculateDeltaTime();
+        update(delta_time);
         checkEvents();  // Tiene que ir antes del render
         render();
     }
 }
 
-// Actualiza las variables
+// Actualiza las variables (frame-based)
 void Credits::update() {
-    if (SDL_GetTicks() - ticks_ > param.game.speed) {
-        ticks_ = SDL_GetTicks();
+    if (SDL_GetTicks() - last_time_ > param.game.speed) {
+        last_time_ = SDL_GetTicks();
         const int REPEAT = want_to_pass_ ? 4 : 1;
         for (int i = 0; i < REPEAT; ++i) {
             tiled_bg_->update();
@@ -106,6 +122,28 @@ void Credits::update() {
     Audio::update();
 }
 
+// Actualiza las variables (time-based)
+void Credits::update(float deltaTime) {
+    const float multiplier = want_to_pass_ ? 4.0f : 1.0f;
+    const float adjusted_delta_time = deltaTime * multiplier;
+
+    tiled_bg_->update(adjusted_delta_time);
+    cycleColors();
+    balloon_manager_->update(adjusted_delta_time);
+    updateTextureDstRects(adjusted_delta_time);
+    throwBalloons(adjusted_delta_time);
+    updatePlayers(adjusted_delta_time);
+    updateAllFades(adjusted_delta_time);
+
+    // Convertir deltaTime a factor de frame (asumiendo 60fps)
+    const float frameFactor = adjusted_delta_time / (1000.0f / 60.0f);
+    counter_ += frameFactor;
+
+    Screen::get()->update();
+    fillCanvas();
+    Audio::update();
+}
+
 // Dibuja Credits::en patalla
 void Credits::render() {
     static auto *const SCREEN = Screen::get();
@@ -272,9 +310,9 @@ void Credits::fillCanvas() {
     SDL_SetRenderTarget(Screen::get()->getRenderer(), temp);
 }
 
-// Actualiza el destino de los rectangulos de las texturas
+// Actualiza el destino de los rectangulos de las texturas (frame-based)
 void Credits::updateTextureDstRects() {
-    if (counter_ % 10 == 0) {
+    if (static_cast<int>(counter_) % 10 == 0) {
         // Comprueba la posición de la textura con los titulos de credito
         if (credits_rect_dst_.y + credits_rect_dst_.h > play_area_.y) {
             --credits_rect_dst_.y;
@@ -301,7 +339,42 @@ void Credits::updateTextureDstRects() {
     }
 }
 
-// Tira globos al escenario
+// Actualiza el destino de los rectangulos de las texturas (time-based)
+void Credits::updateTextureDstRects(float deltaTime) {
+    constexpr float TEXTURE_UPDATE_INTERVAL = 10 * (1000.0f / 60.0f); // 166.67ms (cada 10 frames)
+    static float texture_accumulator = 0.0f;
+    texture_accumulator += deltaTime;
+
+    if (texture_accumulator >= TEXTURE_UPDATE_INTERVAL) {
+        texture_accumulator -= TEXTURE_UPDATE_INTERVAL;
+
+        // Comprueba la posición de la textura con los titulos de credito
+        if (credits_rect_dst_.y + credits_rect_dst_.h > play_area_.y) {
+            --credits_rect_dst_.y;
+        }
+
+        // Comprueba la posición de la textura con el mini_logo
+        if (mini_logo_rect_dst_.y == mini_logo_final_pos_) {
+            mini_logo_on_position_ = true;
+
+            // Si el jugador quiere pasar los titulos de credito, el fade se inicia solo
+            if (want_to_pass_) {
+                fading_ = true;
+            }
+
+            // Se activa el contador para evitar que la sección sea infinita
+            if (counter_prevent_endless_ == 1000) {
+                fading_ = true;
+            } else {
+                ++counter_prevent_endless_;
+            }
+        } else {
+            --mini_logo_rect_dst_.y;
+        }
+    }
+}
+
+// Tira globos al escenario (frame-based)
 void Credits::throwBalloons() {
     constexpr int SPEED = 200;
     const std::vector<int> SETS = {0, 63, 25, 67, 17, 75, 13, 50};
@@ -310,12 +383,41 @@ void Credits::throwBalloons() {
         return;
     }
 
-    if (counter_ % SPEED == 0) {
-        const int INDEX = (counter_ / SPEED) % SETS.size();
+    if (static_cast<int>(counter_) % SPEED == 0) {
+        const int INDEX = (static_cast<int>(counter_) / SPEED) % SETS.size();
         balloon_manager_->deployFormation(SETS.at(INDEX), -60);
     }
 
-    if (counter_ % (SPEED * 4) == 0 && counter_ > 0) {
+    if (static_cast<int>(counter_) % (SPEED * 4) == 0 && counter_ > 0) {
+        balloon_manager_->createPowerBall();
+    }
+}
+
+// Tira globos al escenario (time-based)
+void Credits::throwBalloons(float deltaTime) {
+    constexpr int SPEED = 200;
+    const std::vector<int> SETS = {0, 63, 25, 67, 17, 75, 13, 50};
+    constexpr float BALLOON_INTERVAL = SPEED * (1000.0f / 60.0f); // 3333.33ms (cada 200 frames)
+    constexpr float POWERBALL_INTERVAL = (SPEED * 4) * (1000.0f / 60.0f); // 13333.33ms (cada 800 frames)
+
+    if (counter_ > ((SETS.size() - 1) * SPEED) * 3) {
+        return;
+    }
+
+    static float balloon_accumulator = 0.0f;
+    static float powerball_accumulator = 0.0f;
+
+    balloon_accumulator += deltaTime;
+    powerball_accumulator += deltaTime;
+
+    if (balloon_accumulator >= BALLOON_INTERVAL) {
+        balloon_accumulator -= BALLOON_INTERVAL;
+        const int INDEX = (static_cast<int>(counter_ / SPEED)) % SETS.size();
+        balloon_manager_->deployFormation(SETS.at(INDEX), -60);
+    }
+
+    if (powerball_accumulator >= POWERBALL_INTERVAL && counter_ > 0) {
+        powerball_accumulator -= POWERBALL_INTERVAL;
         balloon_manager_->createPowerBall();
     }
 }
@@ -387,12 +489,12 @@ void Credits::initPlayers() {
     }
 }
 
-// Actualiza los rectangulos negros
+// Actualiza los rectangulos negros (frame-based)
 void Credits::updateBlackRects() {
     static int current_step_ = steps_;
     if (top_black_rect_.h != param.game.game_area.center_y - 1 && bottom_black_rect_.y != param.game.game_area.center_y + 1) {
         // Si los rectangulos superior e inferior no han llegado al centro
-        if (counter_ % 4 == 0) {
+        if (static_cast<int>(counter_) % 4 == 0) {
             // Incrementa la altura del rectangulo superior
             top_black_rect_.h = std::min(top_black_rect_.h + 1, param.game.game_area.center_y - 1);
 
@@ -430,6 +532,57 @@ void Credits::updateBlackRects() {
     }
 }
 
+// Actualiza los rectangulos negros (time-based)
+void Credits::updateBlackRects(float deltaTime) {
+    static float current_step_ = static_cast<float>(steps_);
+    constexpr float BLACK_RECT_INTERVAL = 4 * (1000.0f / 60.0f); // 66.67ms (cada 4 frames)
+    static float black_rect_accumulator = 0.0f;
+
+    if (top_black_rect_.h != param.game.game_area.center_y - 1 && bottom_black_rect_.y != param.game.game_area.center_y + 1) {
+        // Si los rectangulos superior e inferior no han llegado al centro
+        black_rect_accumulator += deltaTime;
+        if (black_rect_accumulator >= BLACK_RECT_INTERVAL) {
+            black_rect_accumulator -= BLACK_RECT_INTERVAL;
+
+            // Incrementa la altura del rectangulo superior
+            top_black_rect_.h = std::min(top_black_rect_.h + 1, param.game.game_area.center_y - 1);
+
+            // Incrementa la altura y modifica la posición del rectangulo inferior
+            ++bottom_black_rect_.h;
+            bottom_black_rect_.y = std::max(bottom_black_rect_.y - 1, param.game.game_area.center_y + 1);
+
+            --current_step_;
+            setVolume(static_cast<int>(initial_volume_ * current_step_ / steps_));
+        }
+    } else {
+        // Si los rectangulos superior e inferior han llegado al centro
+        if (left_black_rect_.w != param.game.game_area.center_x && right_black_rect_.x != param.game.game_area.center_x) {
+            constexpr int SPEED = 2;
+            // Si los rectangulos izquierdo y derecho no han llegado al centro
+            // Incrementa la anchura del rectangulo situado a la izquierda
+            left_black_rect_.w = std::min(left_black_rect_.w + SPEED, param.game.game_area.center_x);
+
+            // Incrementa la anchura y modifica la posición del rectangulo situado a la derecha
+            right_black_rect_.w += SPEED;
+            right_black_rect_.x = std::max(right_black_rect_.x - SPEED, param.game.game_area.center_x);
+
+            --current_step_;
+            setVolume(static_cast<int>(initial_volume_ * current_step_ / steps_));
+        } else {
+            // Si los rectangulos izquierdo y derecho han llegado al centro
+            setVolume(0);
+            Audio::get()->stopMusic();
+            if (counter_pre_fade_ == 400) {
+                fade_out_->activate();
+            } else {
+                // Convertir deltaTime a factor de frame
+                const float frameFactor = deltaTime / (1000.0f / 60.0f);
+                counter_pre_fade_ += frameFactor;
+            }
+        }
+    }
+}
+
 // Actualiza el rectangulo rojo
 void Credits::updateRedRect() {
     border_rect_.x = left_black_rect_.x + left_black_rect_.w;
@@ -438,7 +591,7 @@ void Credits::updateRedRect() {
     border_rect_.h = bottom_black_rect_.y - border_rect_.y + 1;
 }
 
-// Actualiza el estado de fade
+// Actualiza el estado de fade (frame-based)
 void Credits::updateAllFades() {
     if (fading_) {
         updateBlackRects();
@@ -456,6 +609,24 @@ void Credits::updateAllFades() {
     }
 }
 
+// Actualiza el estado de fade (time-based)
+void Credits::updateAllFades(float deltaTime) {
+    if (fading_) {
+        updateBlackRects(deltaTime);
+        updateRedRect();
+    }
+
+    fade_in_->update(); // Fade ya usa tiempo interno
+    if (fade_in_->hasEnded()) {
+        Audio::get()->playMusic("credits.ogg");
+    }
+
+    fade_out_->update(); // Fade ya usa tiempo interno
+    if (fade_out_->hasEnded()) {
+        Section::name = Section::Name::HI_SCORE_TABLE;
+    }
+}
+
 // Establece el nivel de volumen
 void Credits::setVolume(int amount) {
     Options::audio.music.volume = std::clamp(amount, 0, 100);
@@ -503,13 +674,20 @@ void Credits::cycleColors() {
     tiled_bg_->setColor(color_);
 }
 
-// Actualza los jugadores
+// Actualza los jugadores (frame-based)
 void Credits::updatePlayers() {
     for (auto &player : players_) {
         player->update();
     }
 }
 
+// Actualza los jugadores (time-based)
+void Credits::updatePlayers(float deltaTime) {
+    for (auto &player : players_) {
+        player->update(deltaTime);
+    }
+}
+
 // Renderiza los jugadores
 void Credits::renderPlayers() {
     for (auto const &player : players_) {

source/sections/credits.h

@@ -25,6 +25,12 @@ class Credits {
         // --- Bucle principal ---
         void run();
 
+    private:
+        // --- Métodos del bucle principal ---
+        void update();                   // Actualización principal de la lógica (frame-based)
+        void update(float deltaTime);    // Actualización principal de la lógica (time-based)
+        auto calculateDeltaTime() -> float;  // Calcula el deltatime
+
     private:
         // --- Constantes de clase ---
         static constexpr int PLAY_AREA_HEIGHT = 200;
@@ -41,10 +47,10 @@ class Credits {
         SDL_Texture *canvas_;        // Textura donde se dibuja todo
 
         // --- Temporización y contadores ---
-        Uint64 ticks_ = 0;                    // Control de velocidad del programa
-        Uint32 counter_ = 0;                  // Contador principal de lógica
-        Uint32 counter_pre_fade_ = 0;         // Activación del fundido final
-        Uint32 counter_prevent_endless_ = 0;  // Prevención de bucle infinito
+        Uint64 last_time_ = 0;                // Último tiempo registrado para deltaTime
+        float counter_ = 0;                   // Contador principal de lógica
+        float counter_pre_fade_ = 0;          // Activación del fundido final
+        float counter_prevent_endless_ = 0;   // Prevención de bucle infinito
 
         // --- Variables de estado ---
         bool fading_ = false;                 // Estado del fade final
@@ -101,8 +107,6 @@ class Credits {
         // Borde para la ventana
         SDL_FRect border_rect_ = play_area_;  // Delimitador de ventana
 
-        // --- Métodos del bucle principal ---
-        void update();              // Actualización principal de la lógica
         void render();              // Renderizado de la escena
         static void checkEvents();  // Manejo de eventos
         void checkInput();          // Procesamiento de entrada
@@ -110,19 +114,24 @@ class Credits {
         // --- Métodos de renderizado ---
         void fillTextTexture();        // Crear textura de texto de créditos
         void fillCanvas();             // Renderizar todos los sprites y fondos
-        void updateTextureDstRects();  // Actualizar destinos de texturas
         void renderPlayers();          // Renderiza los jugadores
 
         // --- Métodos de lógica del juego ---
-        void throwBalloons();   // Lanzar globos al escenario
-        void initPlayers();     // Inicializar jugadores
-        void updateAllFades();  // Actualizar estados de fade
-        void cycleColors();     // Cambiar colores de fondo
-        void updatePlayers();   // Actualza los jugadores
+        void throwBalloons();                    // Lanzar globos al escenario (frame-based)
+        void throwBalloons(float deltaTime);     // Lanzar globos al escenario (time-based)
+        void initPlayers();                      // Inicializar jugadores
+        void updateAllFades();                   // Actualizar estados de fade (frame-based)
+        void updateAllFades(float deltaTime);    // Actualizar estados de fade (time-based)
+        void cycleColors();                      // Cambiar colores de fondo
+        void updatePlayers();                    // Actualza los jugadores (frame-based)
+        void updatePlayers(float deltaTime);     // Actualza los jugadores (time-based)
 
         // --- Métodos de interfaz ---
-        void updateBlackRects();  // Actualizar rectángulos negros (letterbox)
-        void updateRedRect();     // Actualizar rectángulo rojo (borde)
+        void updateBlackRects();                     // Actualizar rectángulos negros (letterbox) (frame-based)
+        void updateBlackRects(float deltaTime);      // Actualizar rectángulos negros (letterbox) (time-based)
+        void updateRedRect();                        // Actualizar rectángulo rojo (borde)
+        void updateTextureDstRects();                // Actualizar destinos de texturas (frame-based)
+        void updateTextureDstRects(float deltaTime); // Actualizar destinos de texturas (time-based)
 
         // --- Métodos de audio ---
         static void setVolume(int amount);  // Establecer volumen

source/sections/game.cpp

@@ -49,7 +49,18 @@
 
 // Constructor
 Game::Game(Player::Id player_id, int current_stage, bool demo)
-    : renderer_(Screen::get()->getRenderer()), screen_(Screen::get()), input_(Input::get()), canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.play_area.rect.w, param.game.play_area.rect.h)), pause_manager_(std::make_unique<PauseManager>([this](bool is_paused) { onPauseStateChanged(is_paused); })), stage_manager_(std::make_unique<StageManager>()), balloon_manager_(std::make_unique<BalloonManager>(stage_manager_.get())), background_(std::make_unique<Background>(stage_manager_->getPowerNeededToReachStage(stage_manager_->getTotalStages() - 1))), fade_in_(std::make_unique<Fade>()), fade_out_(std::make_unique<Fade>()), tabe_(std::make_unique<Tabe>()), hit_(Hit(Resource::get()->getTexture("hit.png"))) {
+    : renderer_(Screen::get()->getRenderer()),
+      screen_(Screen::get()),
+      input_(Input::get()),
+      canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.play_area.rect.w, param.game.play_area.rect.h)),
+      pause_manager_(std::make_unique<PauseManager>([this](bool is_paused) { onPauseStateChanged(is_paused); })),
+      stage_manager_(std::make_unique<StageManager>()),
+      balloon_manager_(std::make_unique<BalloonManager>(stage_manager_.get())),
+      background_(std::make_unique<Background>(stage_manager_->getPowerNeededToReachStage(stage_manager_->getTotalStages() - 1))),
+      fade_in_(std::make_unique<Fade>()),
+      fade_out_(std::make_unique<Fade>()),
+      tabe_(std::make_unique<Tabe>()),
+      hit_(Hit(Resource::get()->getTexture("hit.png"))) {
     // Pasa variables
     demo_.enabled = demo;
 
@@ -199,7 +210,7 @@ void Game::updateHiScore() {
     }
 }
 
-// Actualiza las variables del jugador
+// Actualiza las variables del jugador (frame-based)
 void Game::updatePlayers() {
     for (auto &player : players_) {
         player->update();
@@ -235,6 +246,42 @@ void Game::updatePlayers() {
     sortPlayersByZOrder();
 }
 
+// Actualiza las variables del jugador (time-based)
+void Game::updatePlayers(float deltaTime) {
+    for (auto &player : players_) {
+        player->update(deltaTime);
+
+        if (player->isPlaying()) {
+            // Comprueba la colisión entre el jugador y los globos
+            auto balloon = checkPlayerBalloonCollision(player);
+
+            // Si hay colisión
+            if (balloon) {
+                // Si el globo está parado y el temporizador activo, lo explota
+                if (balloon->isStopped() && time_stopped_counter_ > 0) {
+                    balloon_manager_->popBalloon(balloon);
+                }
+                // En caso contrario, el jugador ha sido golpeado por un globo activo
+                else {
+                    handlePlayerCollision(player, balloon);
+
+                    if (demo_.enabled && allPlayersAreNotPlaying()) {
+                        fade_out_->setType(Fade::Type::RANDOM_SQUARE2);
+                        fade_out_->setPostDuration(500);
+                        fade_out_->activate();
+                    }
+                }
+            }
+
+            // Comprueba las colisiones entre el jugador y los items
+            checkPlayerItemCollision(player);
+        }
+    }
+
+    // Organiza la lista de jugadores
+    sortPlayersByZOrder();
+}
+
 // Dibuja a los jugadores
 void Game::renderPlayers() {
     for (auto &player : players_) {
@@ -285,11 +332,11 @@ void Game::updateStage() {
         if (current_stage_index == total_stages - 1) {  // Penúltima fase (será la última)
             createMessage(paths, Resource::get()->getTexture("game_text_last_stage"));
         } else {
-            auto text = Resource::get()->getText("04b_25_2x");
+            auto text = Resource::get()->getText("04b_25_2x_enhanced");
             const std::string CAPTION = Lang::getText("[GAME_TEXT] 2") +
                 std::to_string(total_stages - current_stage_index) +
                 Lang::getText("[GAME_TEXT] 2A");
-            createMessage(paths, text->writeToTexture(CAPTION, 1, -4));
+            createMessage(paths, text->writeDXToTexture(Text::STROKE, CAPTION, -4, Colors::NO_COLOR_MOD, 1, param.game.item_text_outline_color));
         }
     }
 
@@ -367,15 +414,6 @@ void Game::updateGameStateCompleted() {
     updatePathSprites();
     cleanVectors();
 
-    // Para la música y elimina todos los globos e items
-    if (game_completed_counter_ == 0) {
-        stopMusic();                             // Detiene la música
-        balloon_manager_->destroyAllBalloons();  // Destruye a todos los globos
-        playSound("power_ball_explosion.wav");   // Sonido de destruir todos los globos
-        destroyAllItems();                       // Destruye todos los items
-        background_->setAlpha(0);                // Elimina el tono rojo de las últimas pantallas
-    }
-
     // Comienza las celebraciones
     // Muestra el mensaje de felicitación y da los puntos a los jugadores
     if (game_completed_counter_ == START_CELEBRATIONS) {
@@ -606,6 +644,7 @@ void Game::handleItemDrop(const std::shared_ptr<Balloon> &balloon, const std::sh
 
     if (DROPPED_ITEM != ItemType::COFFEE_MACHINE) {
         createItem(DROPPED_ITEM, balloon->getPosX(), balloon->getPosY());
+        playSound("item_drop.wav");
     } else {
         createItem(DROPPED_ITEM, player->getPosX(), param.game.game_area.rect.y - Item::COFFEE_MACHINE_HEIGHT);
         coffee_machine_enabled_ = true;
@@ -733,7 +772,6 @@ auto Game::dropItem() -> ItemType {
 // Crea un objeto item
 void Game::createItem(ItemType type, float x, float y) {
     items_.emplace_back(std::make_unique<Item>(type, x, y, param.game.play_area.rect, item_textures_[static_cast<int>(type) - 1], item_animations_[static_cast<int>(type) - 1]));
-    playSound("item_drop.wav");
 }
 
 // Vacia el vector de items
@@ -890,14 +928,14 @@ void Game::updateTimeStopped() {
     if (time_stopped_counter_ > 0) {
         time_stopped_counter_--;
         if (time_stopped_counter_ > 120) {
-            if (time_stopped_counter_ % 30 == 0) {
+            if (static_cast<int>(time_stopped_counter_) % 30 == 0) {
                 playSound("clock.wav");
             }
         } else {
-            if (time_stopped_counter_ % 30 == 0) {
+            if (static_cast<int>(time_stopped_counter_) % 30 == 0) {
                 balloon_manager_->normalColorsToAllBalloons();
                 playSound("clock.wav");
-            } else if (time_stopped_counter_ % 30 == 15) {
+            } else if (static_cast<int>(time_stopped_counter_) % 30 == 15) {
                 balloon_manager_->reverseColorsToAllBalloons();
                 playSound("clock.wav");
             }
@@ -907,9 +945,10 @@ void Game::updateTimeStopped() {
     }
 }
 
+// Actualiza toda la lógica del juego (frame-based)
 void Game::update() {
-    if (SDL_GetTicks() - ticks_ > param.game.speed) {
-        ticks_ = SDL_GetTicks();
+    if (SDL_GetTicks() - last_time_ > param.game.speed) {
+        last_time_ = SDL_GetTicks();
         screen_->update();
 
         updateDemo();
@@ -923,6 +962,20 @@ void Game::update() {
     Audio::update();
 }
 
+// Actualiza toda la lógica del juego (time-based)
+void Game::update(float deltaTime) {
+    screen_->update();
+
+    updateDemo();
+#ifdef RECORDING
+    updateRecording();
+#endif
+    updateGameStates();
+    fillCanvas();
+
+    Audio::update();
+}
+
 // Dibuja el juego
 void Game::render() {
     screen_->start();  // Prepara para empezar a dibujar en la textura de juego
@@ -1004,13 +1057,24 @@ void Game::disableTimeStopItem() {
     balloon_manager_->normalColorsToAllBalloons();
 }
 
+// Calcula el deltatime
+auto Game::calculateDeltaTime() -> float {
+    const Uint64 current_time = SDL_GetTicks();
+    const float delta_time = static_cast<float>(current_time - last_time_);
+    last_time_ = current_time;
+    return delta_time;
+}
+
 // Bucle para el juego
 void Game::run() {
+    last_time_ = SDL_GetTicks();
+
     while (Section::name == Section::Name::GAME) {
 #ifndef RECORDING
         checkInput();
 #endif
-        update();
+        const float delta_time = calculateDeltaTime();
+        update(delta_time);
         handleEvents();  // Tiene que ir antes del render
         render();
     }
@@ -1371,17 +1435,27 @@ void Game::handleNormalPlayerInput(const std::shared_ptr<Player> &player) {
 
 // Procesa las entradas de disparo del jugador, permitiendo disparos automáticos si está habilitado.
 void Game::handleFireInputs(const std::shared_ptr<Player> &player, bool autofire) {
+    if (!player) {
+        return;
+    }
+
     if (input_->checkAction(Input::Action::FIRE_CENTER, autofire, player->getUsesKeyboard(), player->getGamepad())) {
         handleFireInput(player, BulletType::UP);
 #ifdef RECORDING
         demo_.keys.fire = 1;
 #endif
-    } else if (input_->checkAction(Input::Action::FIRE_LEFT, autofire, player->getUsesKeyboard(), player->getGamepad())) {
+        return;
+    }
+
+    if (input_->checkAction(Input::Action::FIRE_LEFT, autofire, player->getUsesKeyboard(), player->getGamepad())) {
         handleFireInput(player, BulletType::LEFT);
 #ifdef RECORDING
         demo_.keys.fire_left = 1;
 #endif
-    } else if (input_->checkAction(Input::Action::FIRE_RIGHT, autofire, player->getUsesKeyboard(), player->getGamepad())) {
+        return;
+    }
+
+    if (input_->checkAction(Input::Action::FIRE_RIGHT, autofire, player->getUsesKeyboard(), player->getGamepad())) {
         handleFireInput(player, BulletType::RIGHT);
 #ifdef RECORDING
         demo_.keys.fire_right = 1;
@@ -1395,6 +1469,7 @@ void Game::handlePlayerContinueInput(const std::shared_ptr<Player> &player) {
         player->setPlayingState(Player::State::RECOVER);
         player->addCredit();
         sendPlayerToTheFront(player);
+        return;
     }
 
     // Disminuye el contador de continuación si se presiona cualquier botón de disparo.
@@ -1420,33 +1495,53 @@ void Game::handlePlayerWaitingInput(const std::shared_ptr<Player> &player) {
 void Game::handleNameInput(const std::shared_ptr<Player> &player) {
     if (input_->checkAction(Input::Action::FIRE_LEFT, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad())) {
         if (player->isShowingName()) {
-            player->setPlayingState(Player::State::CONTINUE);
-        } else if (player->getEnterNamePositionOverflow()) {
+            player->passShowingName();
+            return;
+        }
+        if (player->getEnterNamePositionOverflow()) {
             player->setInput(Input::Action::START);
             player->setPlayingState(Player::State::SHOWING_NAME);
+            playSound("service_menu_select.wav");
             updateHiScoreName();
-        } else {
-            player->setInput(Input::Action::RIGHT);
+            return;
         }
-    } else if (input_->checkAction(Input::Action::FIRE_CENTER, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad()) ||
+        player->setInput(Input::Action::RIGHT);
+        playSound("service_menu_select.wav");
+        return;
+    }
+
+    if (input_->checkAction(Input::Action::FIRE_CENTER, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad()) ||
         input_->checkAction(Input::Action::FIRE_RIGHT, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad())) {
         if (player->isShowingName()) {
-            player->setPlayingState(Player::State::CONTINUE);
-        } else {
-            player->setInput(Input::Action::LEFT);
+            player->passShowingName();
+            return;
         }
-    } else if (input_->checkAction(Input::Action::UP, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad())) {
+        player->setInput(Input::Action::LEFT);
+        playSound("service_menu_back.wav");
+        return;
+    }
+
+    if (input_->checkAction(Input::Action::UP, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad())) {
         player->setInput(Input::Action::UP);
-    } else if (input_->checkAction(Input::Action::DOWN, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad())) {
+        playSound("service_menu_move.wav");
+        return;
+    }
+
+    if (input_->checkAction(Input::Action::DOWN, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad())) {
         player->setInput(Input::Action::DOWN);
-    } else if (input_->checkAction(Input::Action::START, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad())) {
+        playSound("service_menu_move.wav");
+        return;
+    }
+
+    if (input_->checkAction(Input::Action::START, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad())) {
         if (player->isShowingName()) {
-            player->setPlayingState(Player::State::CONTINUE);
-        } else {
-            player->setInput(Input::Action::START);
-            player->setPlayingState(Player::State::SHOWING_NAME);
-            updateHiScoreName();
+            player->passShowingName();
+            return;
         }
+        player->setInput(Input::Action::START);
+        player->setPlayingState(Player::State::SHOWING_NAME);
+        playSound("service_menu_select.wav");
+        updateHiScoreName();
     }
 }
 
@@ -1457,20 +1552,16 @@ void Game::initDemo(Player::Id player_id) {
         setState(State::PLAYING);
 
         // Aleatoriza la asignación del fichero con los datos del modo demostracion
-        {
-            const auto DEMO1 = rand() % 2;
-            const auto DEMO2 = (DEMO1 == 0) ? 1 : 0;
-            demo_.data.emplace_back(Resource::get()->getDemoData(DEMO1));
-            demo_.data.emplace_back(Resource::get()->getDemoData(DEMO2));
-        }
+        const auto DEMO1 = rand() % 2;
+        const auto DEMO2 = (DEMO1 == 0) ? 1 : 0;
+        demo_.data.emplace_back(Resource::get()->getDemoData(DEMO1));
+        demo_.data.emplace_back(Resource::get()->getDemoData(DEMO2));
 
         // Selecciona una pantalla al azar
-        {
-            constexpr auto NUM_DEMOS = 3;
-            const auto DEMO = rand() % NUM_DEMOS;
-            constexpr std::array<int, NUM_DEMOS> STAGES = {0, 3, 5};
-            stage_manager_->jumpToStage(STAGES.at(DEMO));
-        }
+        constexpr auto NUM_DEMOS = 3;
+        const auto DEMO = rand() % NUM_DEMOS;
+        constexpr std::array<int, NUM_DEMOS> STAGES = {0, 3, 5};
+        stage_manager_->jumpToStage(STAGES.at(DEMO));
 
         // Activa o no al otro jugador
         if (rand() % 3 != 0) {
@@ -1554,60 +1645,51 @@ void Game::initDifficultyVars() {
 // Inicializa los jugadores
 void Game::initPlayers(Player::Id player_id) {
     const int Y = param.game.play_area.rect.h - Player::HEIGHT + 1;  // Se hunde un pixel para esconder el outline de los pies
+    const Player::State STATE = demo_.enabled ? Player::State::PLAYING : Player::State::ENTERING_SCREEN;
 
     // Crea al jugador uno y lo pone en modo espera
-    Player::Config config_player1;
-    config_player1.id = Player::Id::PLAYER1;
-    config_player1.x = param.game.play_area.first_quarter_x - (Player::WIDTH / 2);
-    config_player1.y = Y;
-    config_player1.demo = demo_.enabled;
-    config_player1.play_area = &param.game.play_area.rect;
-    config_player1.texture = player_textures_.at(0);
-    config_player1.animations = player_animations_;
-    config_player1.hi_score_table = &Options::settings.hi_score_table;
-    config_player1.glowing_entry = &Options::settings.glowing_entries.at(static_cast<int>(Player::Id::PLAYER1) - 1);
-    config_player1.stage_info = stage_manager_.get();
+    Player::Config config_player1{
+        .id = Player::Id::PLAYER1,
+        .x = param.game.play_area.first_quarter_x - (Player::WIDTH / 2),
+        .y = Y,
+        .demo = demo_.enabled,
+        .play_area = &param.game.play_area.rect,
+        .texture = player_textures_.at(0),
+        .animations = player_animations_,
+        .hi_score_table = &Options::settings.hi_score_table,
+        .glowing_entry = &Options::settings.glowing_entries.at(static_cast<int>(Player::Id::PLAYER1) - 1),
+        .stage_info = stage_manager_.get()};
 
     auto player1 = std::make_unique<Player>(config_player1);
     player1->setScoreBoardPanel(Scoreboard::Id::LEFT);
     player1->setName(Lang::getText("[SCOREBOARD] 1"));
     player1->setGamepad(Options::gamepad_manager.getGamepad(Player::Id::PLAYER1).instance);
     player1->setUsesKeyboard(Player::Id::PLAYER1 == Options::keyboard.player_id);
-    player1->setPlayingState(Player::State::WAITING);
-    players_.push_back(std::move(player1));
+    player1->setPlayingState((player_id == Player::Id::BOTH_PLAYERS || player_id == Player::Id::PLAYER1) ? STATE : Player::State::WAITING);
 
     // Crea al jugador dos y lo pone en modo espera
-    Player::Config config_player2;
-    config_player2.id = Player::Id::PLAYER2;
-    config_player2.x = param.game.play_area.third_quarter_x - (Player::WIDTH / 2);
-    config_player2.y = Y;
-    config_player2.demo = demo_.enabled;
-    config_player2.play_area = &param.game.play_area.rect;
-    config_player2.texture = player_textures_.at(1);
-    config_player2.animations = player_animations_;
-    config_player2.hi_score_table = &Options::settings.hi_score_table;
-    config_player2.glowing_entry = &Options::settings.glowing_entries.at(static_cast<int>(Player::Id::PLAYER2) - 1);
-    config_player2.stage_info = stage_manager_.get();
+    Player::Config config_player2{
+        .id = Player::Id::PLAYER2,
+        .x = param.game.play_area.third_quarter_x - (Player::WIDTH / 2),
+        .y = Y,
+        .demo = demo_.enabled,
+        .play_area = &param.game.play_area.rect,
+        .texture = player_textures_.at(1),
+        .animations = player_animations_,
+        .hi_score_table = &Options::settings.hi_score_table,
+        .glowing_entry = &Options::settings.glowing_entries.at(static_cast<int>(Player::Id::PLAYER2) - 1),
+        .stage_info = stage_manager_.get()};
 
     auto player2 = std::make_unique<Player>(config_player2);
     player2->setScoreBoardPanel(Scoreboard::Id::RIGHT);
     player2->setName(Lang::getText("[SCOREBOARD] 2"));
     player2->setGamepad(Options::gamepad_manager.getGamepad(Player::Id::PLAYER2).instance);
     player2->setUsesKeyboard(Player::Id::PLAYER2 == Options::keyboard.player_id);
-    player2->setPlayingState(Player::State::WAITING);
-    players_.push_back(std::move(player2));
+    player2->setPlayingState((player_id == Player::Id::BOTH_PLAYERS || player_id == Player::Id::PLAYER2) ? STATE : Player::State::WAITING);
 
-    // Activa el jugador que coincide con el "player_id" o ambos si es "0"
-    if (player_id == Player::Id::BOTH_PLAYERS) {
-        // Activa ambos jugadores
-        getPlayer(Player::Id::PLAYER1)->setPlayingState(demo_.enabled ? Player::State::PLAYING : Player::State::ENTERING_SCREEN);
-        getPlayer(Player::Id::PLAYER2)->setPlayingState(demo_.enabled ? Player::State::PLAYING : Player::State::ENTERING_SCREEN);
-    } else {
-        // Activa el jugador elegido
-        auto player = getPlayer(player_id);
-        player->setPlayingState(demo_.enabled ? Player::State::PLAYING : Player::State::ENTERING_SCREEN);
-        sendPlayerToTheFront(player);
-    }
+    // Añade los jugadores al vector de forma que el jugador 1 se pinte por delante del jugador 2
+    players_.push_back(std::move(player2));
+    players_.push_back(std::move(player1));
 
     // Registra los jugadores en Options
     for (const auto &player : players_) {
@@ -1812,6 +1894,19 @@ void Game::checkAndUpdateBalloonSpeed() {
 void Game::setState(State state) {
     state_ = state;
     counter_ = 0;
+
+    switch (state) {
+        case State::COMPLETED:                       // Para la música y elimina todos los globos e items
+            stopMusic();                             // Detiene la música
+            balloon_manager_->destroyAllBalloons();  // Destruye a todos los globos
+            playSound("power_ball_explosion.wav");   // Sonido de destruir todos los globos
+            destroyAllItems();                       // Destruye todos los items
+            background_->setAlpha(0);                // Elimina el tono rojo de las últimas pantallas
+            tabe_->disableSpawning();                // Deshabilita la creacion de Tabes
+            break;
+        default:
+            break;
+    }
 }
 
 void Game::playSound(const std::string &name) const {
@@ -1873,20 +1968,17 @@ void Game::handleDebugEvents(const SDL_Event &event) {
     static int formation_id_ = 0;
     if (event.type == SDL_EVENT_KEY_DOWN && static_cast<int>(event.key.repeat) == 0) {
         switch (event.key.key) {
-            case SDLK_1:  // Crea una powerball
-            {
+            case SDLK_1: {  // Crea una powerball
                 balloon_manager_->createPowerBall();
                 break;
             }
-            case SDLK_2:  // Activa o desactiva la aparición de globos
-            {
+            case SDLK_2: {  // Activa o desactiva la aparición de globos
                 static bool deploy_balloons_ = true;
                 deploy_balloons_ = !deploy_balloons_;
                 balloon_manager_->enableBalloonDeployment(deploy_balloons_);
                 break;
             }
-            case SDLK_3:  // Activa el modo para pasar el juego automaticamente
-            {
+            case SDLK_3: {  // Activa el modo para pasar el juego automaticamente
                 auto_pop_balloons_ = !auto_pop_balloons_;
                 Notifier::get()->show({"auto advance: " + boolToString(auto_pop_balloons_)});
                 if (auto_pop_balloons_) {
@@ -1896,24 +1988,20 @@ void Game::handleDebugEvents(const SDL_Event &event) {
                 balloon_manager_->enableBalloonDeployment(!auto_pop_balloons_);
                 break;
             }
-            case SDLK_4:  // Suelta un item
-            {
+            case SDLK_4: {  // Suelta un item
                 createItem(ItemType::CLOCK, players_.at(0)->getPosX(), players_.at(0)->getPosY() - 40);
                 break;
             }
-            case SDLK_5:  // 5.000
-            {
+            case SDLK_5: {  // 5.000
                 const int X = players_.at(0)->getPosX() + ((Player::WIDTH - game_text_textures_[3]->getWidth()) / 2);
                 createItemText(X, game_text_textures_.at(2));
                 break;
             }
-            case SDLK_6:  // Crea un mensaje
-            {
+            case SDLK_6: {  // Crea un mensaje
                 createMessage({paths_.at(0), paths_.at(1)}, Resource::get()->getTexture("game_text_get_ready"));
                 break;
             }
-            case SDLK_7:  // 100.000
-            {
+            case SDLK_7: {  // 100.000
                 const int X = players_.at(0)->getPosX() + ((Player::WIDTH - game_text_textures_[3]->getWidth()) / 2);
                 createItemText(X, game_text_textures_.at(6));
                 break;

source/sections/game.h

@@ -77,7 +77,7 @@ class Game {
                 bool need_coffee{false};          // Indica si se necesitan cafes
                 bool need_coffee_machine{false};  // Indica si se necesita PowerUp
                 bool need_power_ball{false};      // Indica si se necesita una PowerBall
-                int counter;                      // Contador para no dar ayudas consecutivas
+                float counter;                    // Contador para no dar ayudas consecutivas
                 int item_disk_odds;               // Probabilidad de aparición del objeto
                 int item_gavina_odds;             // Probabilidad de aparición del objeto
                 int item_pacmar_odds;             // Probabilidad de aparición del objeto
@@ -134,14 +134,14 @@ class Game {
         Demo demo_;                                                   // Variable con todas las variables relacionadas con el modo demo
         Difficulty::Code difficulty_ = Options::settings.difficulty;  // Dificultad del juego
         Helper helper_;                                               // Variable para gestionar las ayudas
-        Uint64 ticks_ = 0;                                            // Contador de ticks para ajustar la velocidad del programa
+        Uint64 last_time_ = 0;                                        // Último tiempo registrado para deltaTime
         bool coffee_machine_enabled_ = false;                         // Indica si hay una máquina de café en el terreno de juego
         bool hi_score_achieved_ = false;                              // Indica si se ha superado la puntuación máxima
         float difficulty_score_multiplier_;                           // Multiplicador de puntos en función de la dificultad
-        int counter_ = 0;                                             // Contador para el juego
-        int game_completed_counter_ = 0;                              // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más globos
-        int game_over_counter_ = GAME_OVER_COUNTER;                   // Contador para el estado de fin de partida
-        int time_stopped_counter_ = 0;                                // Temporizador para llevar la cuenta del tiempo detenido
+        float counter_ = 0;                                           // Contador para el juego
+        float game_completed_counter_ = 0;                            // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más globos
+        float game_over_counter_ = GAME_OVER_COUNTER;                 // Contador para el estado de fin de partida
+        float time_stopped_counter_ = 0;                              // Temporizador para llevar la cuenta del tiempo detenido
         int menace_ = 0;                                              // Nivel de amenaza actual
         int menace_threshold_ = 0;                                    // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
         State state_ = State::FADE_IN;                                // Estado
@@ -154,25 +154,28 @@ class Game {
 #endif
 
         // --- Ciclo principal del juego ---
-        void update();               // Actualiza la lógica principal del juego
-        void render();               // Renderiza todos los elementos del juego
+        void update();                      // Actualiza la lógica principal del juego (frame-based)
+        void update(float deltaTime);       // Actualiza la lógica principal del juego (time-based)
+        auto calculateDeltaTime() -> float; // Calcula el deltatime
+        void render();                      // Renderiza todos los elementos del juego
         void handleEvents();         // Procesa los eventos del sistema en cola
         void checkState();           // Verifica y actualiza el estado actual del juego
         void setState(State state);  // Cambia el estado del juego
         void cleanVectors();         // Limpia vectores de elementos deshabilitados
 
         // --- Gestión de estados del juego ---
-        void updateGameStates();                       // Actualiza todos los estados del juego
-        void updateGameStateFadeIn();                  // Gestiona el estado de transición de entrada
-        void updateGameStateEnteringPlayer();          // Gestiona el estado de entrada de jugador
-        void updateGameStateShowingGetReadyMessage();  // Gestiona el estado de mensaje "preparado"
-        void updateGameStatePlaying();                 // Gestiona el estado de juego activo
-        void updateGameStateCompleted();               // Gestiona el estado de juego completado
-        void updateGameStateGameOver();                // Gestiona el estado de fin de partida
+        void updateGameStates();                           // Actualiza todos los estados del juego (usa deltaTime interno)
+        void updateGameStateFadeIn();                      // Gestiona el estado de transición de entrada
+        void updateGameStateEnteringPlayer();              // Gestiona el estado de entrada de jugador
+        void updateGameStateShowingGetReadyMessage();      // Gestiona el estado de mensaje "preparado"
+        void updateGameStatePlaying();                     // Gestiona el estado de juego activo
+        void updateGameStateCompleted();                   // Gestiona el estado de juego completado
+        void updateGameStateGameOver();                    // Gestiona el estado de fin de partida
 
         // --- Gestión de jugadores ---
         void initPlayers(Player::Id player_id);                    // Inicializa los datos de los jugadores
-        void updatePlayers();                                      // Actualiza las variables y estados de los jugadores
+        void updatePlayers();                                      // Actualiza las variables y estados de los jugadores (frame-based)
+        void updatePlayers(float deltaTime);                       // Actualiza las variables y estados de los jugadores (time-based)
         void renderPlayers();                                      // Renderiza todos los jugadores en pantalla
         void sortPlayersByZOrder();                                // Reorganiza el orden de dibujado de jugadores
         auto getPlayer(Player::Id id) -> std::shared_ptr<Player>;  // Obtiene un jugador por su identificador
@@ -229,9 +232,10 @@ class Game {
         void destroyAllItems();                            // Elimina todos los ítems activos de la pantalla
 
         // --- ítems especiales ---
-        void enableTimeStopItem();       // Activa el efecto de detener el tiempo
-        void disableTimeStopItem();      // Desactiva el efecto de detener el tiempo
-        void updateTimeStopped();        // Actualiza el estado del tiempo detenido
+        void enableTimeStopItem();                   // Activa el efecto de detener el tiempo
+        void disableTimeStopItem();                  // Desactiva el efecto de detener el tiempo
+        void updateTimeStopped();                    // Actualiza el estado del tiempo detenido (frame-based)
+        void updateTimeStopped(float deltaTime);     // Actualiza el estado del tiempo detenido (time-based)
         void throwCoffee(int x, int y);  // Crea efecto de café arrojado al ser golpeado
 
         // --- Gestión de caída de ítems ---
@@ -254,8 +258,8 @@ class Game {
 
         // --- Sistema de globos y enemigos ---
         void handleBalloonDestruction(std::shared_ptr<Balloon> balloon, const std::shared_ptr<Player> &player);  // Procesa destrucción de globo
-        void handleTabeHitEffects();                                                                                    // Gestiona efectos al golpear a Tabe
-        void checkAndUpdateBalloonSpeed();                                                                              // Ajusta velocidad de globos según progreso
+        void handleTabeHitEffects();                                                                             // Gestiona efectos al golpear a Tabe
+        void checkAndUpdateBalloonSpeed();                                                                       // Ajusta velocidad de globos según progreso
 
         // --- Gestión de fases y progresión ---
         void updateStage();         // Verifica y actualiza cambio de fase

source/sections/hiscore_table.cpp

@@ -29,7 +29,14 @@
 
 // Constructor
 HiScoreTable::HiScoreTable()
-    : renderer_(Screen::get()->getRenderer()), backbuffer_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)), fade_(std::make_unique<Fade>()), background_(std::make_unique<Background>()), ticks_(0), view_area_(SDL_FRect{0, 0, param.game.width, param.game.height}), fade_mode_(Fade::Mode::IN), background_fade_color_(Color(0, 0, 0)) {
+    : renderer_(Screen::get()->getRenderer()),
+      backbuffer_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
+      fade_(std::make_unique<Fade>()),
+      background_(std::make_unique<Background>()),
+      last_time_(0),
+      view_area_(SDL_FRect{0, 0, param.game.width, param.game.height}),
+      fade_mode_(Fade::Mode::IN),
+      background_fade_color_(Color(0, 0, 0)) {
     // Inicializa el resto
     Section::name = Section::Name::HI_SCORE_TABLE;
     SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
@@ -46,17 +53,14 @@ HiScoreTable::~HiScoreTable() {
 }
 
 // Actualiza las variables
-void HiScoreTable::update() {
-    if (SDL_GetTicks() - ticks_ > param.game.speed) {
-        ticks_ = SDL_GetTicks();  // Actualiza el contador de ticks
-        Screen::get()->update();  // Actualiza el objeto screen
+void HiScoreTable::update(float delta_time) {
+    Screen::get()->update();  // Actualiza el objeto screen
 
-        updateSprites();        // Actualiza las posiciones de los sprites de texto
-        background_->update();  // Actualiza el fondo
-        updateFade();           // Gestiona el fade
-        updateCounter();        // Gestiona el contador y sus eventos
-        fillTexture();          // Dibuja los sprites en la textura
-    }
+    updateSprites(delta_time);        // Actualiza las posiciones de los sprites de texto
+    background_->update(delta_time);  // Actualiza el fondo
+    updateFade(delta_time);           // Gestiona el fade
+    updateCounter();                  // Gestiona el contador y sus eventos
+    fillTexture();                    // Dibuja los sprites en la textura
 
     Audio::update();
 }
@@ -110,20 +114,32 @@ void HiScoreTable::checkInput() {
     GlobalInputs::check();
 }
 
+// Calcula el tiempo transcurrido desde el último frame
+float HiScoreTable::calculateDeltaTime() {
+    const Uint64 current_time = SDL_GetTicks();
+    const float delta_time = static_cast<float>(current_time - last_time_);
+    last_time_ = current_time;
+    return delta_time;
+}
+
 // Bucle para la pantalla de instrucciones
 void HiScoreTable::run() {
+    last_time_ = SDL_GetTicks();
     Audio::get()->playMusic("title.ogg");
+
     while (Section::name == Section::Name::HI_SCORE_TABLE) {
+        const float delta_time = calculateDeltaTime();
+
         checkInput();
-        update();
+        update(delta_time);
         checkEvents();  // Tiene que ir antes del render
         render();
     }
 }
 
 // Gestiona el fade
-void HiScoreTable::updateFade() {
-    fade_->update();
+void HiScoreTable::updateFade(float delta_time) {
+    fade_->update(delta_time);
 
     if (fade_->hasEnded() && fade_mode_ == Fade::Mode::IN) {
         fade_->reset();
@@ -242,7 +258,7 @@ void HiScoreTable::createSprites() {
 }
 
 // Actualiza las posiciones de los sprites de texto
-void HiScoreTable::updateSprites() {
+void HiScoreTable::updateSprites(float delta_time) {
     constexpr int INIT_COUNTER = 190;
     const int COUNTER_BETWEEN_ENTRIES = 16;
     if (counter_ >= INIT_COUNTER) {
@@ -255,7 +271,7 @@ void HiScoreTable::updateSprites() {
         }
     }
     for (auto const &entry : entry_names_) {
-        entry->update();
+        entry->update(delta_time);
     }
 
     glowEntryNames();

source/sections/hiscore_table.h

@@ -45,26 +45,27 @@ class HiScoreTable {
 
         // --- Variables ---
         Uint16 counter_ = 0;               // Contador
-        Uint64 ticks_;                     // Contador de ticks para ajustar la velocidad del programa
+        Uint64 last_time_ = 0;             // Último timestamp para calcular delta-time
         SDL_FRect view_area_;              // Parte de la textura que se muestra en pantalla
         Fade::Mode fade_mode_;             // Modo de fade a utilizar
         Color background_fade_color_;      // Color de atenuación del fondo
         std::vector<Color> entry_colors_;  // Colores para destacar las entradas en la tabla
 
         // --- Métodos internos ---
-        void update();                                  // Actualiza las variables
+        void update(float delta_time);                  // Actualiza las variables
         void render();                                  // Pinta en pantalla
         static void checkEvents();                      // Comprueba los eventos
         static void checkInput();                       // Comprueba las entradas
         static auto format(int number) -> std::string;  // Convierte un entero a un string con separadores de miles
         void fillTexture();                             // Dibuja los sprites en la textura
-        void updateFade();                              // Gestiona el fade
+        void updateFade(float delta_time);              // Gestiona el fade
         void createSprites();                           // Crea los sprites con los textos
-        void updateSprites();                           // Actualiza las posiciones de los sprites de texto
+        void updateSprites(float delta_time);           // Actualiza las posiciones de los sprites de texto
         void initFade();                                // Inicializa el fade
         void initBackground();                          // Inicializa el fondo
         auto getEntryColor(int counter) -> Color;       // Obtiene un color del vector de colores de entradas
         void iniEntryColors();                          // Inicializa los colores de las entradas
         void glowEntryNames();                          // Hace brillar los nombres de la tabla de records
         void updateCounter();                           // Gestiona el contador
+        float calculateDeltaTime();                     // Calcula el tiempo transcurrido desde el último frame
 };

source/sections/instructions.cpp

@@ -26,7 +26,12 @@
 
 // Constructor
 Instructions::Instructions()
-    : renderer_(Screen::get()->getRenderer()), texture_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)), backbuffer_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)), text_(Resource::get()->getText("smb2")), tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::STATIC)), fade_(std::make_unique<Fade>()) {
+    : renderer_(Screen::get()->getRenderer()),
+      texture_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
+      backbuffer_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
+      text_(Resource::get()->getText("smb2")),
+      tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::STATIC)),
+      fade_(std::make_unique<Fade>()) {
     // Configura las texturas
     SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
     SDL_SetTextureBlendMode(texture_, SDL_BLENDMODE_BLEND);
@@ -199,18 +204,15 @@ void Instructions::fillBackbuffer() {
 }
 
 // Actualiza las variables
-void Instructions::update() {
-    if (SDL_GetTicks() - ticks_ > param.game.speed) {
-        ticks_ = SDL_GetTicks();  // Actualiza el contador de ticks
-        Screen::get()->update();  // Actualiza el objeto screen
+void Instructions::update(float delta_time) {
+    Screen::get()->update();  // Actualiza el objeto screen
 
-        counter_++;           // Incrementa el contador
-        updateSprites();      // Actualiza los sprites
-        updateBackbuffer();   // Gestiona la textura con los graficos
-        tiled_bg_->update();  // Actualiza el mosaico de fondo
-        fade_->update();      // Actualiza el objeto "fade"
-        fillBackbuffer();     // Rellena el backbuffer
-    }
+    counter_++;                      // Incrementa el contador
+    updateSprites();                 // Actualiza los sprites
+    updateBackbuffer();              // Gestiona la textura con los graficos
+    tiled_bg_->update(delta_time);   // Actualiza el mosaico de fondo
+    fade_->update(delta_time);       // Actualiza el objeto "fade"
+    fillBackbuffer();                // Rellena el backbuffer
 
     Audio::update();
 }
@@ -250,12 +252,24 @@ void Instructions::checkInput() {
     GlobalInputs::check();
 }
 
+// Calcula el tiempo transcurrido desde el último frame
+float Instructions::calculateDeltaTime() {
+    const Uint64 current_time = SDL_GetTicks();
+    const float delta_time = static_cast<float>(current_time - last_time_);
+    last_time_ = current_time;
+    return delta_time;
+}
+
 // Bucle para la pantalla de instrucciones
 void Instructions::run() {
+    last_time_ = SDL_GetTicks();
     Audio::get()->playMusic("title.ogg");
+
     while (Section::name == Section::Name::INSTRUCTIONS) {
+        const float delta_time = calculateDeltaTime();
+
         checkInput();
-        update();
+        update(delta_time);
         checkEvents();  // Tiene que ir antes del render
         render();
     }

source/sections/instructions.h

@@ -34,7 +34,9 @@ struct Line {                  // Almacena información de línea animada
 
         // Constructor de Line
         Line(int y, float x, int direction)
-            : y(y), x(x), direction(direction) {}
+            : y(y),
+              x(x),
+              direction(direction) {}
 };
 
 // Clase Instructions
@@ -61,7 +63,7 @@ class Instructions {
 
         // --- Variables ---
         int counter_ = 0;                     // Contador para manejar el progreso en la pantalla de instrucciones
-        Uint64 ticks_ = 0;                    // Contador de ticks para ajustar la velocidad del programa
+        Uint64 last_time_ = 0;                // Último timestamp para calcular delta-time
         SDL_FRect view_;                      // Vista del backbuffer que se va a mostrar por pantalla
         SDL_FPoint sprite_pos_ = {0, 0};      // Posición del primer sprite en la lista
         float item_space_ = 2.0;              // Espacio entre los items en pantalla
@@ -71,7 +73,7 @@ class Instructions {
         bool start_delay_triggered_ = false;  // Bandera para determinar si el retraso ha comenzado
 
         // --- Métodos internos ---
-        void update();                                                                                           // Actualiza las variables
+        void update(float delta_time);                                                                           // Actualiza las variables
         void render();                                                                                           // Pinta en pantalla
         static void checkEvents();                                                                               // Comprueba los eventos
         static void checkInput();                                                                                // Comprueba las entradas
@@ -80,7 +82,8 @@ class Instructions {
         void iniSprites();                                                                                       // Inicializa los sprites de los items
         void updateSprites();                                                                                    // Actualiza los sprites
         static auto initializeLines(int height) -> std::vector<Line>;                                            // Inicializa las líneas animadas
-        static auto moveLines(std::vector<Line> &lines, int width, float duration, Uint32 start_delay) -> bool;  // Mueve las líneas
+        static auto moveLines(std::vector<Line> &lines, int width, float duration, Uint32 start_delay) -> bool;  // Mueve las líneas (ya usa tiempo real)
         static void renderLines(SDL_Renderer *renderer, SDL_Texture *texture, const std::vector<Line> &lines);   // Renderiza las líneas
         void updateBackbuffer();                                                                                 // Gestiona la textura con los gráficos
+        float calculateDeltaTime();                                                                              // Calcula el tiempo transcurrido desde el último frame
 };

source/sections/intro.cpp

@@ -207,24 +207,21 @@ void Intro::switchText(int from_index, int to_index) {
 }
 
 // Actualiza las variables del objeto
-void Intro::update() {
-    if (SDL_GetTicks() - ticks_ > param.game.speed) {
-        ticks_ = SDL_GetTicks();  // Actualiza el contador de ticks
-        Screen::get()->update();  // Actualiza el objeto screen
+void Intro::update(float delta_time) {
+    Screen::get()->update();  // Actualiza el objeto screen
 
-        tiled_bg_->update();  // Actualiza el fondo
+    tiled_bg_->update(delta_time);  // Actualiza el fondo
 
-        switch (state_) {
-            case State::SCENES:
-                updateSprites();
-                updateTexts();
-                updateScenes();
-                break;
+    switch (state_) {
+        case State::SCENES:
+            updateSprites(delta_time);
+            updateTexts(delta_time);
+            updateScenes();
+            break;
 
-            case State::POST:
-                updatePostState();
-                break;
-        }
+        case State::POST:
+            updatePostState();
+            break;
     }
 
     Audio::update();
@@ -253,12 +250,24 @@ void Intro::render() {
     SCREEN->render();  // Vuelca el contenido del renderizador en pantalla
 }
 
+// Calcula el tiempo transcurrido desde el último frame
+float Intro::calculateDeltaTime() {
+    const Uint64 current_time = SDL_GetTicks();
+    const float delta_time = static_cast<float>(current_time - last_time_);
+    last_time_ = current_time;
+    return delta_time;
+}
+
 // Bucle principal
 void Intro::run() {
+    last_time_ = SDL_GetTicks();
     Audio::get()->playMusic("intro.ogg", 0);
+
     while (Section::name == Section::Name::INTRO) {
+        const float delta_time = calculateDeltaTime();
+
         checkInput();
-        update();
+        update(delta_time);
         checkEvents();  // Tiene que ir antes del render
         render();
     }
@@ -444,20 +453,20 @@ void Intro::initTexts() {
 }
 
 // Actualiza los sprites
-void Intro::updateSprites() {
+void Intro::updateSprites(float delta_time) {
     for (auto &sprite : card_sprites_) {
-        sprite->update();
+        sprite->update(delta_time);
     }
 
     for (auto &sprite : shadow_sprites_) {
-        sprite->update();
+        sprite->update(delta_time);
     }
 }
 
 // Actualiza los textos
-void Intro::updateTexts() {
+void Intro::updateTexts(float delta_time) {
     for (auto &text : texts_) {
-        text->update();
+        text->update(delta_time);
     }
 }
 

source/sections/intro.h

@@ -42,7 +42,7 @@ class Intro {
         std::unique_ptr<TiledBG> tiled_bg_;                        // Fondo en mosaico
 
         // --- Variables ---
-        Uint64 ticks_ = 0;                           // Contador de ticks para ajustar la velocidad del programa
+        Uint64 last_time_ = 0;                       // Último timestamp para calcular delta-time
         int scene_ = 0;                              // Indica qué escena está activa
         State state_ = State::SCENES;                // Estado principal de la intro
         PostState post_state_ = PostState::STOP_BG;  // Estado POST
@@ -50,19 +50,20 @@ class Intro {
         Color bg_color_ = param.intro.bg_color;      // Color de fondo
 
         // --- Métodos internos ---
-        void update();                 // Actualiza las variables del objeto
+        void update(float delta_time);                 // Actualiza las variables del objeto
         void render();                 // Dibuja el objeto en pantalla
         static void checkInput();      // Comprueba las entradas
         static void checkEvents();     // Comprueba los eventos
         void updateScenes();           // Actualiza las escenas de la intro
         void initSprites();            // Inicializa las imágenes
         void initTexts();              // Inicializa los textos
-        void updateSprites();          // Actualiza los sprites
-        void updateTexts();            // Actualiza los textos
+        void updateSprites(float delta_time);          // Actualiza los sprites
+        void updateTexts(float delta_time);            // Actualiza los textos
         void renderSprites();          // Dibuja los sprites
         void renderTexts();            // Dibuja los textos
         static void renderTextRect();  // Dibuja el rectangulo de fondo del texto;
         void updatePostState();        // Actualiza el estado POST
+        float calculateDeltaTime();    // Calcula el tiempo transcurrido desde el último frame
 
         // --- Métodos para manejar cada escena individualmente ---
         void updateScene0();

source/sections/logo.cpp

@@ -79,21 +79,23 @@ void Logo::checkInput() {
 }
 
 // Gestiona el logo de JAILGAMES
-void Logo::updateJAILGAMES() {
+void Logo::updateJAILGAMES(float delta_time) {
     if (counter_ == 30) {
         Audio::get()->playSound("logo.wav");
     }
 
     if (counter_ > 30) {
+        const float pixels_to_move = SPEED * delta_time;
+
         for (int i = 0; i < (int)jail_sprite_.size(); ++i) {
             if (jail_sprite_[i]->getX() != dest_.x) {
                 if (i % 2 == 0) {
-                    jail_sprite_[i]->incX(-SPEED);
+                    jail_sprite_[i]->incX(-pixels_to_move);
                     if (jail_sprite_[i]->getX() < dest_.x) {
                         jail_sprite_[i]->setX(dest_.x);
                     }
                 } else {
-                    jail_sprite_[i]->incX(SPEED);
+                    jail_sprite_[i]->incX(pixels_to_move);
                     if (jail_sprite_[i]->getX() > dest_.x) {
                         jail_sprite_[i]->setX(dest_.x);
                     }
@@ -129,16 +131,21 @@ void Logo::updateTextureColors() {
 }
 
 // Actualiza las variables
-void Logo::update() {
-    if (SDL_GetTicks() - ticks_ > param.game.speed) {
-        ticks_ = SDL_GetTicks();  // Actualiza el contador de ticks
-        Screen::get()->update();  // Actualiza el objeto screen
+void Logo::update(float delta_time) {
+    static float logic_accumulator = 0.0f;
+    logic_accumulator += delta_time;
 
-        updateJAILGAMES();      // Actualiza el logo de JAILGAMES
+    // Ejecutar lógica a 60 FPS (cada 16.67ms) para mantener consistencia en counter_ y colores
+    constexpr float LOGIC_FRAME_TIME = 1000.0f / 60.0f;
+
+    if (logic_accumulator >= LOGIC_FRAME_TIME) {
+        Screen::get()->update();  // Actualiza el objeto screen
         updateTextureColors();  // Actualiza los colores de las texturas
         ++counter_;             // Gestiona el contador
+        logic_accumulator -= LOGIC_FRAME_TIME;
     }
 
+    updateJAILGAMES(delta_time);      // Actualiza el logo de JAILGAMES con delta-time real
     Audio::update();
 }
 
@@ -154,11 +161,23 @@ void Logo::render() {
     SCREEN->render();
 }
 
+// Calcula el tiempo transcurrido desde el último frame
+float Logo::calculateDeltaTime() {
+    const Uint64 current_time = SDL_GetTicks();
+    const float delta_time = static_cast<float>(current_time - last_time_);
+    last_time_ = current_time;
+    return delta_time;
+}
+
 // Bucle para el logo del juego
 void Logo::run() {
+    last_time_ = SDL_GetTicks();
+
     while (Section::name == Section::Name::LOGO) {
+        const float delta_time = calculateDeltaTime();
+
         checkInput();
-        update();
+        update(delta_time);
         checkEvents();  // Tiene que ir antes del render
         render();
     }

source/sections/logo.h

@@ -31,7 +31,7 @@ class Logo {
         static constexpr int INIT_FADE_COUNTER_MARK = 300;         // Tiempo del contador cuando inicia el fade a negro
         static constexpr int END_LOGO_COUNTER_MARK = 400;          // Tiempo del contador para terminar el logo
         static constexpr int POST_LOGO_DURATION = 20;              // Tiempo que dura el logo con el fade al máximo
-        static constexpr int SPEED = 8;                            // Velocidad de desplazamiento de cada línea
+        static constexpr float SPEED = 8.0f / 15.0f;              // Velocidad de desplazamiento de cada línea (píxeles por ms)
 
         // --- Objetos y punteros ---
         std::shared_ptr<Texture> since_texture_;            // Textura con los gráficos "Since 1998"
@@ -42,15 +42,16 @@ class Logo {
         // --- Variables ---
         std::vector<Color> color_;  // Vector con los colores para el fade
         int counter_ = 0;           // Contador
-        Uint64 ticks_ = 0;          // Contador de ticks para ajustar la velocidad del programa
+        Uint64 last_time_ = 0;      // Último timestamp para calcular delta-time
         SDL_FPoint dest_;           // Posición donde dibujar el logo
 
         // --- Métodos internos ---
-        void update();               // Actualiza las variables
+        void update(float delta_time);               // Actualiza las variables
         void render();               // Dibuja en pantalla
         static void checkEvents();   // Comprueba el manejador de eventos
         static void checkInput();    // Comprueba las entradas
-        void updateJAILGAMES();      // Gestiona el logo de JAILGAMES
+        void updateJAILGAMES(float delta_time);      // Gestiona el logo de JAILGAMES
         void renderJAILGAMES();      // Renderiza el logo de JAILGAMES
         void updateTextureColors();  // Gestiona el color de las texturas
+        float calculateDeltaTime();  // Calcula el tiempo transcurrido desde el último frame
 };

source/sections/title.cpp

@@ -37,7 +37,13 @@ class Texture;
 
 // Constructor
 Title::Title()
-    : text_(Resource::get()->getText("smb2_grad")), fade_(std::make_unique<Fade>()), tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::RANDOM)), game_logo_(std::make_unique<GameLogo>(param.game.game_area.center_x, param.title.title_c_c_position)), mini_logo_sprite_(std::make_unique<Sprite>(Resource::get()->getTexture("logo_jailgames_mini.png"))), state_(TitleState::LOGO_ANIMATING), num_controllers_(Input::get()->getNumGamepads()) {
+    : text_(Resource::get()->getText("smb2_grad")),
+      fade_(std::make_unique<Fade>()),
+      tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::RANDOM)),
+      game_logo_(std::make_unique<GameLogo>(param.game.game_area.center_x, param.title.title_c_c_position)),
+      mini_logo_sprite_(std::make_unique<Sprite>(Resource::get()->getTexture("logo_jailgames_mini.png"))),
+      state_(TitleState::LOGO_ANIMATING),
+      num_controllers_(Input::get()->getNumGamepads()) {
     // Configura objetos
     tiled_bg_->setColor(param.title.bg_color);
     game_logo_->enable();
@@ -71,10 +77,10 @@ Title::~Title() {
     Options::gamepad_manager.clearPlayers();
 }
 
-// Actualiza las variables del objeto
+// Actualiza las variables del objeto (frame-based)
 void Title::update() {
-    if (SDL_GetTicks() - ticks_ > param.game.speed) {
-        ticks_ = SDL_GetTicks();
+    if (SDL_GetTicks() - last_time_ > param.game.speed) {
+        last_time_ = SDL_GetTicks();
         Screen::get()->update();
 
         updateFade();
@@ -86,6 +92,28 @@ void Title::update() {
     Audio::update();
 }
 
+// Actualiza las variables del objeto (time-based)  
+void Title::update(float deltaTime) {
+    Screen::get()->update();
+    updateFade();
+    updateState(deltaTime);
+    updateStartPrompt();
+    
+    for (auto& player : players_) {
+        player->update(deltaTime);  // deltaTime ya está en segundos
+    }
+    
+    Audio::update();
+}
+
+// Calcula el tiempo transcurrido desde el último frame
+float Title::calculateDeltaTime() {
+    const Uint64 current_time = SDL_GetTicks();
+    const float delta_time = static_cast<float>(current_time - last_time_);
+    last_time_ = current_time;
+    return delta_time;
+}
+
 // Dibuja el objeto en pantalla
 void Title::render() {
     static auto* const SCREEN = Screen::get();
@@ -130,7 +158,7 @@ void Title::handleDebugColorKeys(SDL_Keycode key) {
 
     adjustColorComponent(key, color_);
 
-    counter_ = 0;
+    counter_time_ = 0.0f;
     tiled_bg_->setColor(color_);
     printColorValue(color_);
 }
@@ -284,21 +312,25 @@ void Title::processPlayer2Start() {
 void Title::activatePlayerAndSetState(Player::Id player_id) {
     getPlayer(player_id)->setPlayingState(Player::State::TITLE_ANIMATION);
     setState(TitleState::START_HAS_BEEN_PRESSED);
-    counter_ = 0;
+    counter_time_ = 0.0f;
 }
 
 // Bucle para el titulo del juego
 void Title::run() {
+    last_time_ = SDL_GetTicks();
+
     while (Section::name == Section::Name::TITLE) {
+        const float delta_time = calculateDeltaTime();
+
         checkInput();
-        update();
+        update(delta_time);
         checkEvents();  // Tiene que ir antes del render
         render();
     }
 }
 
 // Reinicia el contador interno
-void Title::resetCounter() { counter_ = 0; }
+void Title::resetCounter() { counter_time_ = 0.0f; }
 
 // Intercambia la asignación de mandos a los jugadores
 void Title::swapControllers() {
@@ -364,18 +396,55 @@ void Title::updateState() {
     // Establece la lógica según el estado
     switch (state_) {
         case TitleState::LOGO_ANIMATING: {
-            game_logo_->update();
+            game_logo_->update();  // Mantener frame-based para consistencia del estado
             if (game_logo_->hasFinished()) {
                 setState(TitleState::LOGO_FINISHED);
             }
             break;
         }
         case TitleState::LOGO_FINISHED: {
-            ++counter_;            // Incrementa el contador
-            game_logo_->update();  // Actualiza el logo con el título del juego
-            tiled_bg_->update();   // Actualiza el mosaico de fondo
+            // Ya no se usa counter_ aquí, se usa updateState(deltaTime)
+            game_logo_->update();  
+            tiled_bg_->update();   
 
-            if (counter_ == param.title.title_duration) {
+            // Esta lógica se movió a updateState(deltaTime)
+            break;
+        }
+        case TitleState::START_HAS_BEEN_PRESSED: {
+            // Ya no se usa counter_ aquí, se usa updateState(deltaTime)
+            game_logo_->update();  
+            tiled_bg_->update();   
+
+            // Esta lógica se movió a updateState(deltaTime)
+            break;
+        }
+
+        default:
+            break;
+    }
+}
+
+// Actualiza el estado (time-based)
+void Title::updateState(float deltaTime) {
+    // deltaTime ya está en segundos desde calculateDeltaTime()
+    game_logo_->update(deltaTime);
+    tiled_bg_->update(deltaTime);
+
+    // Establece la lógica según el estado
+    switch (state_) {
+        case TitleState::LOGO_ANIMATING: {
+            if (game_logo_->hasFinished()) {
+                setState(TitleState::LOGO_FINISHED);
+            }
+            break;
+        }
+        case TitleState::LOGO_FINISHED: {
+            counter_time_ += deltaTime;  // deltaTime está en milisegundos
+            
+            // param.title.title_duration está en frames (60fps), convertir a ms: frames * (1000ms/60fps)
+            float duration_ms = static_cast<float>(param.title.title_duration) * (1000.0f / 60.0f);
+            
+            if (counter_time_ >= duration_ms) {
                 // El menu ha hecho time out
                 fade_->setPostDuration(0);
                 fade_->activate();
@@ -384,11 +453,10 @@ void Title::updateState() {
             break;
         }
         case TitleState::START_HAS_BEEN_PRESSED: {
-            ++counter_;            // Incrementa el contador
-            game_logo_->update();  // Actualiza el logo con el título del juego
-            tiled_bg_->update();   // Actualiza el mosaico de fondo
-
-            if (counter_ == 100) {
+            counter_time_ += deltaTime;  // deltaTime está en milisegundos
+            
+            // 100 frames a 60fps convertir a ms: 100 * (1000/60) = 1666.67 ms
+            if (counter_time_ >= (100.0f * 1000.0f / 60.0f)) {
                 fade_->activate();
             }
             break;
@@ -538,7 +606,7 @@ void Title::initPlayers() {
     }
 }
 
-// Actualza los jugadores
+// Actualiza los jugadores
 void Title::updatePlayers() {
     for (auto& player : players_) {
         player->update();

source/sections/title.h

@@ -60,16 +60,19 @@ class Title {
         Section::Name next_section_;                                     // Siguiente sección a cargar
         Section::Options selection_ = Section::Options::TITLE_TIME_OUT;  // Opción elegida en el título
         TitleState state_;                                               // Estado actual de la sección
-        Uint64 ticks_ = 0;                                               // Contador de ticks para ajustar la velocidad
-        int counter_ = 0;                                                // Temporizador para la pantalla de título
+        Uint64 last_time_ = 0;                                           // Último timestamp para calcular delta-time
+        float counter_time_ = 0.0f;                                      // Temporizador para la pantalla de título (en milisegundos)
         int num_controllers_;                                            // Número de mandos conectados
         bool should_render_start_prompt_ = false;                        // Indica si se muestra el texto de PRESS START BUTTON TO PLAY
         bool player1_start_pressed_ = false;                             // Indica si se ha pulsado el botón de empezar para el jugador 1
         bool player2_start_pressed_ = false;                             // Indica si se ha pulsado el botón de empezar para el jugador 2
 
         // --- Ciclo de vida del título ---
-        void update();                    // Actualiza las variables del objeto
-        void updateState();               // Actualiza el estado actual del título
+        void update();                    // Actualiza las variables del objeto (frame-based)
+        void update(float deltaTime);     // Actualiza las variables del objeto (time-based)
+        float calculateDeltaTime();       // Calcula el tiempo transcurrido desde el último frame
+        void updateState();               // Actualiza el estado actual del título (frame-based)
+        void updateState(float deltaTime); // Actualiza el estado actual del título (time-based)
         void setState(TitleState state);  // Cambia el estado del título
         void resetCounter();              // Reinicia el contador interno
 

source/smart_sprite.cpp

@@ -2,7 +2,7 @@
 
 #include "moving_sprite.h"  // Para MovingSprite
 
-// Actualiza la posición y comprueba si ha llegado a su destino
+// Actualiza la posición y comprueba si ha llegado a su destino (frame-based)
 void SmartSprite::update() {
     if (enabled_) {
         MovingSprite::update();
@@ -11,6 +11,15 @@ void SmartSprite::update() {
     }
 }
 
+// Actualiza la posición y comprueba si ha llegado a su destino (time-based)
+void SmartSprite::update(float deltaTime) {
+    if (enabled_) {
+        MovingSprite::update(deltaTime);
+        checkMove();
+        checkFinished();
+    }
+}
+
 // Dibuja el sprite
 void SmartSprite::render() {
     if (enabled_) {

source/smart_sprite.h

@@ -16,8 +16,9 @@ class SmartSprite : public AnimatedSprite {
         ~SmartSprite() override = default;
 
         // --- Métodos principales ---
-        void update() override;  // Actualiza la posición y comprueba si ha llegado a su destino
-        void render() override;  // Dibuja el sprite
+        void update() override;              // Actualiza la posición y comprueba si ha llegado a su destino (frame-based)
+        void update(float deltaTime) override;  // Actualiza la posición y comprueba si ha llegado a su destino (time-based)
+        void render() override;              // Dibuja el sprite
 
         // --- Getters ---
         auto getDestX() const -> int { return dest_x_; }                  // Obtiene la posición de destino en X

source/sprite.h

@@ -55,9 +55,9 @@ class Sprite {
         [[nodiscard]] auto getTexture() const -> std::shared_ptr<Texture> { return textures_.at(texture_index_); }
         void setTexture(std::shared_ptr<Texture> texture) { textures_.at(texture_index_) = std::move(texture); }
         void addTexture(const std::shared_ptr<Texture>& texture) { textures_.push_back(texture); }
-        auto setActiveTexture(size_t index) -> bool;                                           // Cambia la textura activa por índice
-        [[nodiscard]] auto getActiveTexture() const -> size_t { return texture_index_; }       // Alias para getActiveTextureIndex
-        [[nodiscard]] auto getTextureCount() const -> size_t { return textures_.size(); }      // Obtiene el número total de texturas
+        auto setActiveTexture(size_t index) -> bool;                                       // Cambia la textura activa por índice
+        [[nodiscard]] auto getActiveTexture() const -> size_t { return texture_index_; }   // Alias para getActiveTextureIndex
+        [[nodiscard]] auto getTextureCount() const -> size_t { return textures_.size(); }  // Obtiene el número total de texturas
 
     protected:
         // --- Métodos internos ---

source/tabe.cpp

@@ -17,7 +17,7 @@ Tabe::Tabe()
     : sprite_(std::make_unique<AnimatedSprite>(Resource::get()->getTexture("tabe.png"), Resource::get()->getAnimation("tabe.ani"))),
       timer_(Timer(param.tabe.min_spawn_time, param.tabe.max_spawn_time)) {}
 
-// Actualiza la lógica
+// Actualiza la lógica (frame-based)
 void Tabe::update() {
     if (enabled_ && !timer_.is_paused) {
         sprite_->update();
@@ -31,6 +31,20 @@ void Tabe::update() {
     }
 }
 
+// Actualiza la lógica (time-based)
+void Tabe::update(float deltaTime) {
+    if (enabled_ && !timer_.is_paused) {
+        sprite_->update(deltaTime);
+        move(deltaTime);
+        updateState(deltaTime);
+    }
+
+    timer_.update();
+    if (timer_.shouldSpawn()) {
+        enable();
+    }
+}
+
 // Dibuja el objeto
 void Tabe::render() {
     if (enabled_) {
@@ -38,7 +52,7 @@ void Tabe::render() {
     }
 }
 
-// Mueve el objeto
+// Mueve el objeto (frame-based)
 void Tabe::move() {
     const int X = static_cast<int>(x_);
     speed_ += accel_;
@@ -103,6 +117,75 @@ void Tabe::move() {
     shiftSprite();
 }
 
+// Mueve el objeto (time-based)
+void Tabe::move(float deltaTime) {
+    // Convertir deltaTime (milisegundos) a factor de frame (asumiendo 60fps)
+    float frameFactor = deltaTime / (1000.0f / 60.0f);
+    
+    const int X = static_cast<int>(x_);
+    speed_ += accel_ * frameFactor;
+    x_ += speed_ * frameFactor;
+    fly_distance_ -= std::abs(X - static_cast<int>(x_));
+
+    // Comprueba si sale por los bordes
+    const float MIN_X = param.game.game_area.rect.x - WIDTH;
+    const float MAX_X = param.game.game_area.rect.x + param.game.game_area.rect.w;
+    switch (destiny_) {
+        case Direction::TO_THE_LEFT: {
+            if (x_ < MIN_X) {
+                disable();
+            }
+            if (x_ > param.game.game_area.rect.x + param.game.game_area.rect.w - WIDTH && direction_ == Direction::TO_THE_RIGHT) {
+                setRandomFlyPath(Direction::TO_THE_LEFT, 80);
+                x_ = param.game.game_area.rect.x + param.game.game_area.rect.w - WIDTH;
+            }
+            break;
+        }
+
+        case Direction::TO_THE_RIGHT: {
+            if (x_ > MAX_X) {
+                disable();
+            }
+            if (x_ < param.game.game_area.rect.x && direction_ == Direction::TO_THE_LEFT) {
+                setRandomFlyPath(Direction::TO_THE_RIGHT, 80);
+                x_ = param.game.game_area.rect.x;
+            }
+            break;
+        }
+        default:
+            break;
+    }
+
+    if (fly_distance_ <= 0) {
+        if (waiting_counter_ > 0) {
+            accel_ = speed_ = 0.0F;
+            waiting_counter_ -= frameFactor;
+            if (waiting_counter_ < 0) waiting_counter_ = 0;
+        } else {
+            constexpr int CHOICES = 4;
+            const std::array<Direction, CHOICES> LEFT = {
+                Direction::TO_THE_LEFT,
+                Direction::TO_THE_LEFT,
+                Direction::TO_THE_LEFT,
+                Direction::TO_THE_RIGHT};
+
+            const std::array<Direction, CHOICES> RIGHT = {
+                Direction::TO_THE_LEFT,
+                Direction::TO_THE_RIGHT,
+                Direction::TO_THE_RIGHT,
+                Direction::TO_THE_RIGHT};
+
+            const Direction DIRECTION = destiny_ == Direction::TO_THE_LEFT
+                ? LEFT[rand() % CHOICES]
+                : RIGHT[rand() % CHOICES];
+
+            setRandomFlyPath(DIRECTION, 20 + (rand() % 40));
+        }
+    }
+
+    shiftSprite();
+}
+
 // Habilita el objeto
 void Tabe::enable() {
     if (!enabled_) {
@@ -175,11 +258,23 @@ void Tabe::setState(State state) {
     }
 }
 
-// Actualiza el estado
+// Actualiza el estado (frame-based)
 void Tabe::updateState() {
     if (state_ == State::HIT) {
         --hit_counter_;
-        if (hit_counter_ == 0) {
+        if (hit_counter_ <= 0) {
+            setState(State::FLY);
+        }
+    }
+}
+
+// Actualiza el estado (time-based)
+void Tabe::updateState(float deltaTime) {
+    if (state_ == State::HIT) {
+        // Convertir deltaTime (milisegundos) a factor de frame (asumiendo 60fps)
+        float frameFactor = deltaTime / (1000.0f / 60.0f);
+        hit_counter_ -= frameFactor;
+        if (hit_counter_ <= 0) {
             setState(State::FLY);
         }
     }
@@ -210,4 +305,14 @@ void Tabe::disable() {
 // Detiene/activa el timer
 void Tabe::pauseTimer(bool value) {
     timer_.setPaused(value);
+}
+
+// Deshabilita el spawning permanentemente
+void Tabe::disableSpawning() {
+    timer_.setSpawnDisabled(true);
+}
+
+// Habilita el spawning nuevamente
+void Tabe::enableSpawning() {
+    timer_.setSpawnDisabled(false);
 }

source/tabe.h

@@ -26,12 +26,15 @@ class Tabe {
         ~Tabe() = default;
 
         // --- Métodos principales ---
-        void update();                 // Actualiza la lógica
-        void render();                 // Dibuja el objeto
+        void update();                      // Actualiza la lógica (frame-based)
+        void update(float deltaTime);       // Actualiza la lógica (time-based)
+        void render();                      // Dibuja el objeto
         void enable();                 // Habilita el objeto
         void setState(State state);    // Establece el estado
         auto tryToGetBonus() -> bool;  // Intenta obtener el bonus
         void pauseTimer(bool value);   // Detiene/activa el timer
+        void disableSpawning();        // Deshabilita el spawning permanentemente
+        void enableSpawning();         // Habilita el spawning nuevamente
 
         // --- Getters ---
         auto getCollider() -> SDL_FRect& { return sprite_->getRect(); }    // Obtiene el área de colisión
@@ -54,7 +57,8 @@ class Tabe {
                 Uint32 current_time;           // Tiempo actual
                 Uint32 delta_time;             // Diferencia de tiempo desde la última actualización
                 Uint32 last_time;              // Tiempo de la última actualización
-                bool is_paused{false};         // Indica si el temporizador está pausado
+                bool is_paused{false};         // Indica si el temporizador está pausado (por pausa de juego)
+                bool spawn_disabled{false};    // Indica si el spawning está deshabilitado permanentemente
 
                 // Constructor - los parámetros min_time y max_time están en mintos
                 Timer(float min_time, float max_time)
@@ -75,8 +79,8 @@ class Tabe {
                 void update() {
                     current_time = SDL_GetTicks();
 
-                    // Solo actualizar si no está pausado
-                    if (!is_paused) {
+                    // Solo actualizar si no está pausado (ni por juego ni por spawn deshabilitado)
+                    if (!is_paused && !spawn_disabled) {
                         delta_time = current_time - last_time;
 
                         if (time_until_next_spawn > delta_time) {
@@ -101,9 +105,20 @@ class Tabe {
                     }
                 }
 
+                // Pausa o reanuda el spawning
+                void setSpawnDisabled(bool disabled) {
+                    if (spawn_disabled != disabled) {
+                        spawn_disabled = disabled;
+                        // Al reactivar, actualizar last_time para evitar saltos
+                        if (!disabled) {
+                            last_time = SDL_GetTicks();
+                        }
+                    }
+                }
+
                 // Indica si el temporizador ha finalizado
                 [[nodiscard]] auto shouldSpawn() const -> bool {
-                    return time_until_next_spawn == 0 && !is_paused;
+                    return time_until_next_spawn == 0 && !is_paused && !spawn_disabled;
                 }
         };
 
@@ -116,21 +131,23 @@ class Tabe {
         float speed_ = 0.0F;                            // Velocidad de movimiento
         float accel_ = 0.0F;                            // Aceleración
         int fly_distance_ = 0;                          // Distancia de vuelo
-        int waiting_counter_ = 0;                       // Tiempo que pasa quieto
+        float waiting_counter_ = 0;                     // Tiempo que pasa quieto
         bool enabled_ = false;                          // Indica si el objeto está activo
         Direction direction_ = Direction::TO_THE_LEFT;  // Dirección actual
         Direction destiny_ = Direction::TO_THE_LEFT;    // Destino
         State state_ = State::FLY;                      // Estado actual
-        int hit_counter_ = 0;                           // Contador para el estado HIT
+        float hit_counter_ = 0;                         // Contador para el estado HIT
         int number_of_hits_ = 0;                        // Cantidad de disparos recibidos
         bool has_bonus_ = true;                         // Indica si aún tiene el bonus para soltar
         Timer timer_;                                   // Temporizador para gestionar la aparición
 
         // --- Métodos internos ---
-        void move();                                             // Mueve el objeto
+        void move();                                             // Mueve el objeto (frame-based)
+        void move(float deltaTime);                              // Mueve el objeto (time-based)
         void shiftSprite() { sprite_->setPos(x_, y_); }          // Actualiza la posición del sprite
         void setRandomFlyPath(Direction direction, int length);  // Establece un vuelo aleatorio
-        void updateState();                                      // Actualiza el estado
+        void updateState();                                      // Actualiza el estado (frame-based)
+        void updateState(float deltaTime);                       // Actualiza el estado (time-based)
         void updateTimer();                                      // Actualiza el temporizador
         void disable();                                          // Deshabilita el objeto
 };

source/text.cpp

@@ -4,14 +4,16 @@
 
 #include <fstream>      // Para basic_ifstream, basic_istream, basic_ostream, operator<<, endl, ifstream
 #include <iostream>     // Para cerr
+#include <sstream>      // Para istringstream
 #include <stdexcept>    // Para runtime_error
 #include <string_view>  // Para string_view
 
-#include "color.h"    // Para Color
-#include "screen.h"   // Para Screen
-#include "sprite.h"   // Para Sprite
-#include "texture.h"  // Para Texture
-#include "utils.h"    // Para getFileName, printWithDots
+#include "color.h"            // Para Color
+#include "resource_helper.h"  // Para ResourceHelper
+#include "screen.h"           // Para Screen
+#include "sprite.h"           // Para Sprite
+#include "texture.h"          // Para Texture
+#include "utils.h"            // Para getFileName, printWithDots
 
 // Constructor
 Text::Text(const std::shared_ptr<Texture> &texture, const std::string &text_file) {
@@ -155,7 +157,7 @@ auto Text::writeToTexture(const std::string &text, int zoom, int kerning, int le
 auto Text::writeDXToTexture(Uint8 flags, const std::string &text, int kerning, Color text_color, Uint8 shadow_distance, Color shadow_color, int length) -> std::shared_ptr<Texture> {
     auto *renderer = Screen::get()->getRenderer();
     auto texture = std::make_shared<Texture>(renderer);
-    
+
     // Calcula las dimensiones considerando los efectos
     auto base_width = Text::length(text, kerning);
     auto base_height = box_height_;
@@ -163,10 +165,10 @@ auto Text::writeDXToTexture(Uint8 flags, const std::string &text, int kerning, C
     auto height = base_height;
     auto offset_x = 0;
     auto offset_y = 0;
-    
+
     const auto STROKED = ((flags & Text::STROKE) == Text::STROKE);
     const auto SHADOWED = ((flags & Text::SHADOW) == Text::SHADOW);
-    
+
     if (STROKED) {
         // Para stroke, el texto se expande en todas las direcciones por shadow_distance
         width = base_width + (shadow_distance * 2);
@@ -178,7 +180,7 @@ auto Text::writeDXToTexture(Uint8 flags, const std::string &text, int kerning, C
         width = base_width + shadow_distance;
         height = base_height + shadow_distance;
     }
-    
+
     auto *temp = SDL_GetRenderTarget(renderer);
 
     texture->createBlank(width, height, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
@@ -198,18 +200,18 @@ void Text::writeColored(int x, int y, const std::string &text, Color color, int
 }
 
 // Escribe el texto con colores usando un sprite específico
-void Text::writeColoredWithSprite(Sprite* sprite, int x, int y, const std::string &text, Color color, int kerning, int length) {
+void Text::writeColoredWithSprite(Sprite *sprite, int x, int y, const std::string &text, Color color, int kerning, int length) {
     int shift = 0;
     const std::string_view VISIBLE_TEXT = (length == -1) ? std::string_view(text) : std::string_view(text).substr(0, length);
 
     auto *texture = sprite->getTexture().get();
-    
+
     // Guarda el alpha original y aplica el nuevo
     Uint8 original_alpha;
     SDL_GetTextureAlphaMod(texture->getSDLTexture(), &original_alpha);
     texture->setAlpha(color.a);
     texture->setColor(color.r, color.g, color.b);
-    
+
     sprite->setY(y);
     for (const auto CH : VISIBLE_TEXT) {
         const auto INDEX = static_cast<unsigned char>(CH);
@@ -221,7 +223,7 @@ void Text::writeColoredWithSprite(Sprite* sprite, int x, int y, const std::strin
             shift += offset_[INDEX].w + kerning;
         }
     }
-    
+
     // Restaura los valores originales
     texture->setColor(255, 255, 255);
     texture->setAlpha(255);
@@ -231,26 +233,26 @@ void Text::writeColoredWithSprite(Sprite* sprite, int x, int y, const std::strin
 void Text::writeStrokeWithAlpha(int x, int y, const std::string &text, int kerning, Color stroke_color, Uint8 shadow_distance, int length) {
     auto *renderer = Screen::get()->getRenderer();
     auto *original_target = SDL_GetRenderTarget(renderer);
-    
+
     // Calcula dimensiones de la textura temporal
     auto text_width = Text::length(text, kerning);
     auto text_height = box_height_;
     auto temp_width = text_width + (shadow_distance * 2);
     auto temp_height = text_height + (shadow_distance * 2);
-    
+
     // Crea textura temporal
     auto temp_texture = std::make_shared<Texture>(renderer);
     temp_texture->createBlank(temp_width, temp_height, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
     temp_texture->setBlendMode(SDL_BLENDMODE_BLEND);
-    
+
     // Renderiza el stroke en la textura temporal
     temp_texture->setAsRenderTarget(renderer);
     SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
     SDL_RenderClear(renderer);
-    
+
     // Selecciona el sprite apropiado para el stroke
     auto *stroke_sprite = white_sprite_ ? white_sprite_.get() : sprite_.get();
-    
+
     // Renderiza stroke sin alpha (sólido) en textura temporal
     Color solid_color = Color(stroke_color.r, stroke_color.g, stroke_color.b, 255);
     for (int dist = 1; dist <= shadow_distance; ++dist) {
@@ -260,10 +262,10 @@ void Text::writeStrokeWithAlpha(int x, int y, const std::string &text, int kerni
             }
         }
     }
-    
+
     // Restaura render target original
     SDL_SetRenderTarget(renderer, original_target);
-    
+
     // Renderiza la textura temporal con el alpha deseado
     temp_texture->setAlpha(stroke_color.a);
     temp_texture->render(x - shadow_distance, y - shadow_distance);
@@ -372,25 +374,41 @@ auto Text::loadFile(const std::string &file_path) -> std::shared_ptr<Text::File>
         tf->box_height = 0;
     }
 
-    // Abre el fichero para leer los valores
-    std::ifstream file(file_path);
+    // Intenta cargar desde ResourceHelper primero
+    auto resource_data = ResourceHelper::loadFile(file_path);
+    std::istringstream stream;
+    bool using_resource_data = false;
 
-    if (file.is_open() && file.good()) {
+    if (!resource_data.empty()) {
+        std::string content(resource_data.begin(), resource_data.end());
+        stream.str(content);
+        using_resource_data = true;
+    }
+
+    // Fallback a archivo directo
+    std::ifstream file;
+    if (!using_resource_data) {
+        file.open(file_path);
+    }
+
+    std::istream &input_stream = using_resource_data ? stream : static_cast<std::istream &>(file);
+
+    if ((using_resource_data && stream.good()) || (!using_resource_data && file.is_open() && file.good())) {
         std::string buffer;
 
         // Lee los dos primeros valores del fichero
-        std::getline(file, buffer);
-        std::getline(file, buffer);
+        std::getline(input_stream, buffer);
+        std::getline(input_stream, buffer);
         tf->box_width = std::stoi(buffer);
 
-        std::getline(file, buffer);
-        std::getline(file, buffer);
+        std::getline(input_stream, buffer);
+        std::getline(input_stream, buffer);
         tf->box_height = std::stoi(buffer);
 
         // lee el resto de datos del fichero
         auto index = 32;
         auto line_read = 0;
-        while (std::getline(file, buffer)) {
+        while (std::getline(input_stream, buffer)) {
             // Almacena solo las lineas impares
             if (line_read % 2 == 1) {
                 tf->offset[index++].w = std::stoi(buffer);
@@ -401,9 +419,11 @@ auto Text::loadFile(const std::string &file_path) -> std::shared_ptr<Text::File>
             line_read++;
         };
 
-        // Cierra el fichero
+        // Cierra el fichero si se usó
         printWithDots("Text File : ", getFileName(file_path), "[ LOADED ]");
-        file.close();
+        if (!using_resource_data && file.is_open()) {
+            file.close();
+        }
     }
 
     // El fichero no se puede abrir