revisat intro.cpp, path_sprite i writer.cpp

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

DELTATIME_MIGRATION_PLAN.md

@@ -0,0 +1,81 @@
+# Plan de Migración DeltaTime - Eliminación de frameFactor
+
+## Problema Identificado
+Se están usando `frameFactor` conversions en 7 archivos, lo que indica una migración incompleta a deltaTime.
+El patrón `float frameFactor = deltaTime / (1000.0f / 60.0f)` simula frames de 60fps en lugar de usar tiempo real.
+
+## Archivos Afectados y Estado
+1. **balloon.cpp** - 9 ocurrencias en métodos: moveX(), moveY(), updateState(), updateCreation()
+2. **balloon_manager.cpp** - 2 ocurrencias en updateBalloonDeployment()
+3. **bullet.cpp** - 3 ocurrencias en move()
+4. **item.cpp** - 6 ocurrencias en move()
+5. **moving_sprite.cpp** - 5 ocurrencias en move()
+6. **tabe.cpp** - 5 ocurrencias en update() y updateHitEffect()
+7. **credits.cpp** - 3 ocurrencias en update() y handleFadeOut()
+
+## Estrategia de Migración
+
+### Opción A: Velocidades ya en pixels/segundo
+Si las velocidades están definidas en pixels/segundo:
+```cpp
+// ANTES (incorrecto)
+float frameFactor = deltaTime / (1000.0f / 60.0f);
+pos_x_ += vel_x_ * frameFactor;
+
+// DESPUÉS (correcto)
+pos_x_ += vel_x_ * (deltaTime / 1000.0f);  // deltaTime en ms -> segundos
+```
+
+### Opción B: Velocidades en pixels/frame (legacy)
+Si las velocidades están en pixels/frame (sistema legacy):
+```cpp
+// ANTES (incorrecto con deltaTime)
+float frameFactor = deltaTime / (1000.0f / 60.0f);
+pos_x_ += vel_x_ * frameFactor;
+
+// OPCIÓN 1: Convertir velocidades a pixels/segundo
+static constexpr float VEL_X_PER_SECOND = VEL_X_PER_FRAME * 60.0f;
+pos_x_ += VEL_X_PER_SECOND * (deltaTime / 1000.0f);
+
+// OPCIÓN 2: Mantener frame-factor pero mejorar claridad
+pos_x_ += vel_x_ * (deltaTime / FRAME_TIME_MS);  // donde FRAME_TIME_MS = 16.67f
+```
+
+## Plan de Ejecución
+
+### Fase 1: Análisis de Velocidades
+- [ ] Revisar definiciones de velocidades en cada clase
+- [ ] Determinar si están en pixels/frame o pixels/segundo
+- [ ] Identificar constantes que necesitan conversión
+
+### Fase 2: Migración por Archivo
+- [x] **balloon.cpp**: Migrar velocidades x/y y contadores ✅
+- [x] **balloon_manager.cpp**: Migrar balloon_deploy_counter_ ✅
+- [x] **bullet.cpp**: Migrar velocidades de bala ✅ (VEL_Y: -3.0F→-0.18F, VEL_X: ±2.0F→±0.12F)
+- [x] **item.cpp**: Migrar física de ítems ✅ (vel_x: ±1.0F→±0.06F, vel_y: -4.0F→-0.24F, accel_y: 0.2F→0.012F)
+- [ ] **moving_sprite.cpp**: Migrar sistema base de movimiento
+- [ ] **tabe.cpp**: Migrar movimiento y efectos
+- [ ] **credits.cpp**: Migrar contadores de timing
+
+### Fase 3: Verificación
+- [ ] Compilar y probar cada archivo migrado
+- [ ] Verificar que el comportamiento se mantiene consistente
+- [ ] Eliminar todas las referencias a frameFactor
+- [ ] Actualizar comentarios para reflejar unidades correctas
+
+## Criterios de Éxito
+1. ✅ Cero ocurrencias de "frameFactor" en el código
+2. ✅ Todas las velocidades claramente documentadas (pixels/segundo vs pixels/frame)
+3. ✅ Comportamiento del juego idéntico al anterior
+4. ✅ Código más limpio y mantenible
+
+## Notas Importantes
+- El frameFactor actual simula 60fps: `deltaTime / 16.67ms`
+- Esto significa que las velocidades actuales están en "pixels per 16.67ms"
+- Para verdadero deltaTime, necesitamos convertir a "pixels per second" o usar factor de frame explícito
+- Mantener constantes claras para evitar números mágicos
+
+## Estado: En Progreso
+- Análisis iniciado
+- Plan documentado
+- Próximo paso: Análisis de velocidades en cada archivo

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

config/formations.txt

@@ -0,0 +1,277 @@
+# Coffee Crisis Arcade Edition - Archivo de configuración de formaciones de globos
+# Formato por línea: x, desp, y, vel_x, tipo, tamaño, retraso_tiempo_creacion
+# Variables disponibles:
+# X0_0, X0_50, X0_100, X1_0, X1_100, X2_0, X2_100, X3_0, X3_100
+# X3_25, X3_75, DEFAULT_POS_Y
+# SMALL, MEDIUM, LARGE, EXTRALARGE
+# RIGHT, LEFT
+
+formation: 0
+# Dos enemigos BALLOON3 uno a cada extremo
+X3_0,   0, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE, 0
+X3_100, 0, DEFAULT_POS_Y, LEFT,  BALLOON, EXTRALARGE, 0
+
+formation: 1
+# Dos enemigos BALLOON3 uno a cada cuarto. Ambos van hacia el centro
+X3_25, 0, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE, 0
+X3_75, 0, DEFAULT_POS_Y, LEFT,  BALLOON, EXTRALARGE, 0
+
+formation: 2
+# Cuatro enemigos BALLOON1 uno detrás del otro. A la izquierda y hacia el centro
+X1_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 500
+X1_0, 1, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 334
+X1_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 167
+X1_0, 3, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM,  0
+
+formation: 3
+# Cuatro enemigos BALLOON1 uno detrás del otro. A la derecha y hacia el centro
+X1_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 500
+X1_100, -1, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 334
+X1_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 167
+X1_100, -3, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM,  0
+
+formation: 4
+# Tres enemigos BALLOON2. 0, 417, 834. Hacia la derecha
+X2_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 334
+X2_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 167
+X2_0, 4, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE,  0
+
+formation: 5
+# Tres enemigos BALLOON2. 50, 75, 1667. Hacia la izquierda
+X2_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 334
+X2_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 167
+X2_100, -4, DEFAULT_POS_Y, LEFT, BALLOON, LARGE,  0
+
+formation: 6
+# Tres enemigos BALLOON2. 0, 0, 0. Hacia la derecha
+X2_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 334
+X2_0, 1, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 167
+X2_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE,  0
+
+formation: 7
+# Tres enemigos BALLOON2. 100, 1667, 1667. Hacia la izquierda
+X2_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 334
+X2_100, -1, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 167
+X2_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, LARGE,  0
+
+formation: 8
+# Seis enemigos BALLOON0. 0, 0, 0, 0, 0, 0. Hacia la derecha
+X0_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 834
+X0_0, 1, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 667
+X0_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 500
+X0_0, 3, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 334
+X0_0, 4, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 167
+X0_0, 5, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  0
+
+formation: 9
+# Seis enemigos BALLOON0. 100, 1667, 1667, 1667, 1667, 1667. Hacia la izquierda
+X0_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 834
+X0_100, -1, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 667
+X0_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 500
+X0_100, -3, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 334
+X0_100, -4, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 167
+X0_100, -5, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  0
+
+formation: 10
+# Tres enemigos BALLOON3 seguidos desde la izquierda. Hacia la derecha
+X3_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE, 500
+X3_0, 1, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE, 250
+X3_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE,  0
+
+formation: 11
+# Tres enemigos BALLOON3 seguidos desde la derecha. Hacia la izquierda
+X3_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, EXTRALARGE, 500
+X3_100, -1, DEFAULT_POS_Y, LEFT, BALLOON, EXTRALARGE, 250
+X3_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, EXTRALARGE,  0
+
+formation: 12
+# Seis enemigos BALLOON1 uno detrás del otro. A la izquierda y hacia el centro
+X1_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 834
+X1_0, 1, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 667
+X1_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 500
+X1_0, 3, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 334
+X1_0, 4, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 167
+X1_0, 5, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM,  0
+
+formation: 13
+# Seis enemigos BALLOON1 uno detrás del otro. A la derecha y hacia el centro
+X1_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 834
+X1_100, -1, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 667
+X1_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 500
+X1_100, -3, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 334
+X1_100, -4, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 167
+X1_100, -5, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM,  0
+
+formation: 14
+# Cinco enemigos BALLOON2. Hacia la derecha. Separados
+X2_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 667
+X2_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 500
+X2_0, 4, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 334
+X2_0, 6, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 167
+X2_0, 8, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE,  0
+
+formation: 15
+# Cinco enemigos BALLOON2. Hacia la izquierda. Separados
+X2_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 667
+X2_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 500
+X2_100, -4, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 334
+X2_100, -6, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 167
+X2_100, -8, DEFAULT_POS_Y, LEFT, BALLOON, LARGE,  0
+
+formation: 16
+# Cinco enemigos BALLOON2. Hacia la derecha. Juntos
+X2_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 667
+X2_0, 1, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 500
+X2_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 334
+X2_0, 3, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 167
+X2_0, 4, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE,  0
+
+formation: 17
+# Cinco enemigos BALLOON2. Hacia la izquierda. Juntos
+X2_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 667
+X2_100, -1, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 500
+X2_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 334
+X2_100, -3, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 167
+X2_100, -4, DEFAULT_POS_Y, LEFT, BALLOON, LARGE,  0
+
+formation: 18
+# Doce enemigos BALLOON0. Hacia la derecha. Juntos
+X0_0,  0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 1834
+X0_0,  1, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 1667
+X0_0,  2, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 25000
+X0_0, 50, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 1334
+X0_0,  4, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  70
+X0_0, 83, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 1000
+X0_0, 100, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 830
+X0_0,  7, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  40
+X0_0,  8, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 500
+X0_0, 150, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  20
+X0_0, 167, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  10
+X0_0, 11, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,   0
+
+formation: 19
+# Doce enemigos BALLOON0. Hacia la izquierda. Juntos
+X0_100,   0, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 1834
+X0_100,  -1, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 1667
+X0_100,  -2, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 25000
+X0_100,  -3, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 1334
+X0_100,  -4, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  70
+X0_100,  -5, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 1000
+X0_100,  -6, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 830
+X0_100,  -7, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  40
+X0_100,  -8, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 500
+X0_100,  -9, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  20
+X0_100, -10, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  10
+X0_100, -11, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,   0
+
+formation: 20
+# Cuatro enemigos BALLOON3 seguidos desde la izquierda/derecha. Simétricos
+X3_0,    0, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE, 0
+X3_0,    1, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE, 0
+X3_100,  0, DEFAULT_POS_Y, LEFT,  BALLOON, EXTRALARGE, 0
+X3_100, -1, DEFAULT_POS_Y, LEFT,  BALLOON, EXTRALARGE, 0
+
+formation: 21
+# Diez enemigos BALLOON1 uno detrás del otro. Izquierda/derecha. Simétricos
+X1_0,    0, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 200
+X1_0,    1, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 150
+X1_0,    2, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 100
+X1_0,    3, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 50
+X1_0,    4, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM,  0
+X1_100,  0, DEFAULT_POS_Y, LEFT,  BALLOON, MEDIUM, 200
+X1_100, -1, DEFAULT_POS_Y, LEFT,  BALLOON, MEDIUM, 150
+X1_100, -2, DEFAULT_POS_Y, LEFT,  BALLOON, MEDIUM, 100
+X1_100, -3, DEFAULT_POS_Y, LEFT,  BALLOON, MEDIUM, 50
+X1_100, -4, DEFAULT_POS_Y, LEFT,  BALLOON, MEDIUM,  0
+
+formation: 22
+# Diez enemigos BALLOON2. Hacia la derecha/izquierda. Separados. Simétricos
+X2_0,    0, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 667
+X2_0,    2, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 500
+X2_0,    4, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 334
+X2_0,    6, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 167
+X2_0,    8, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE,  0
+X2_100,  0, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 667
+X2_100, -2, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 500
+X2_100, -4, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 334
+X2_100, -6, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 167
+X2_100, -8, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE,  0
+
+formation: 23
+# Diez enemigos BALLOON2. Hacia la derecha. Juntos. Simétricos
+X2_0,    0, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 667
+X2_0,    1, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 500
+X2_0,    2, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 334
+X2_0,    3, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 167
+X2_0,    4, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE,  0
+X2_100,  0, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 667
+X2_100, -1, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 500
+X2_100, -2, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 334
+X2_100, -3, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 167
+X2_100, -4, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE,  0
+
+formation: 24
+# Treinta enemigos BALLOON0. Del centro hacia los extremos. Juntos. Simétricos
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  0
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 83
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 167
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 250
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 334
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 417
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 500
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 584
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 667
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 750
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 834
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 917
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 16700
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 16784
+X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 1167
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL,  0
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 83
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 167
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 250
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 334
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 417
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 500
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 584
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 667
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 750
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 834
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 917
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 16700
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 16784
+X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 1167
+
+formation: 25
+# Treinta enemigos BALLOON0. Del centro hacia adentro. Juntos. Simétricos
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 1167
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 16784
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 16700
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 917
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 834
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 750
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 667
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 584
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 500
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 417
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 334
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 250
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 167
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 83
+X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL,  0
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 1167
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 16784
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 16700
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 917
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 834
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 750
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 667
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 584
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 500
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 417
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 334
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 250
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 167
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 83
+X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  0

config/param_320x240.txt

@@ -10,8 +10,8 @@ game.play_area.rect.x                0   # Posición X de la zona jugable
 game.play_area.rect.y                0   # Posición Y de la zona jugable
 game.play_area.rect.w              320   # Ancho de la zona jugable
 game.play_area.rect.h              200   # Alto de la zona jugable
-game.name_entry_idle_time           10   # Segundos para introducir el nombre al finalizar la partida si no se pulsa nada
-game.name_entry_total_time          60   # Segundos totales para introducir el nombre al finalizar la partida
+game.name_entry_idle_time        10000   # Segundos para introducir el nombre al finalizar la partida si no se pulsa nada
+game.name_entry_total_time       60000   # Segundos totales para introducir el nombre al finalizar la partida
 game.hit_stop                    false   # Indica si debe haber un paro cuando el jugador es golpeado por un globo
 game.hit_stop_ms                   500   # Cantidad de milisegundos que dura el hit_stop
 
@@ -39,24 +39,24 @@ scoreboard.text_color2           FFFFFF   # Color secundario del texto del marca
 scoreboard.skip_countdown_value       8   # Valor para saltar la cuenta atrás (segundos)
 
 # --- TITLE ---
-title.press_start_position     180   # Posición Y del texto "Press Start"
-title.title_duration           800   # Duración de la pantalla de título (frames)
-title.arcade_edition_position  123   # Posición Y del subtítulo "Arcade Edition"
-title.title_c_c_position        80   # Posición Y del título principal
-title.bg_color              41526F   # Color de fondo en la sección titulo
+title.press_start_position        180   # Posición Y del texto "Press Start"
+title.title_duration            14000   # Duración de la pantalla de título (milisegundos)
+title.arcade_edition_position     123   # Posición Y del subtítulo "Arcade Edition"
+title.title_c_c_position           80   # Posición Y del título principal
+title.bg_color                 41526F   # Color de fondo en la sección titulo
 
 # --- BACKGROUND ---
 background.attenuate_color  FFFFFF00   # Color de atenuación del fondo (RGBA hexadecimal)
 
-# --- BALLOONS ---
-balloon.settings[0].vel   2.75f   # Velocidad inicial del globo 1
-balloon.settings[0].grav  0.09f   # Gravedad aplicada al globo 1
-balloon.settings[1].vel   3.70f   # Velocidad inicial del globo 2
-balloon.settings[1].grav  0.10f   # Gravedad aplicada al globo 2
-balloon.settings[2].vel   4.70f   # Velocidad inicial del globo 3
-balloon.settings[2].grav  0.10f   # Gravedad aplicada al globo 3
-balloon.settings[3].vel   5.45f   # Velocidad inicial del globo 4
-balloon.settings[3].grav  0.10f   # Gravedad aplicada al globo 4
+# --- BALLOONS --- (deltaTime puro: vel en pixels/ms, grav en pixels/ms²)
+balloon.settings[0].vel   0.165f    # Velocidad inicial del globo 1 (pixels/ms)
+balloon.settings[0].grav  0.00032f  # Gravedad aplicada al globo 1 (pixels/ms²)
+balloon.settings[1].vel   0.222f    # Velocidad inicial del globo 2 (pixels/ms)
+balloon.settings[1].grav  0.00036f  # Gravedad aplicada al globo 2 (pixels/ms²)
+balloon.settings[2].vel   0.282f    # Velocidad inicial del globo 3 (pixels/ms)
+balloon.settings[2].grav  0.00036f  # Gravedad aplicada al globo 3 (pixels/ms²)
+balloon.settings[3].vel   0.327f    # Velocidad inicial del globo 4 (pixels/ms)
+balloon.settings[3].grav  0.00036f  # Gravedad aplicada al globo 4 (pixels/ms²)
 
 balloon.color[0]  blue    # Color de creación del globo normal
 balloon.color[1]  orange  # Color del globo normal

config/param_320x256.txt

@@ -10,8 +10,8 @@ game.play_area.rect.x                0   # Posición X de la zona jugable
 game.play_area.rect.y                0   # Posición Y de la zona jugable
 game.play_area.rect.w              320   # Ancho de la zona jugable
 game.play_area.rect.h              216   # Alto de la zona jugable
-game.name_entry_idle_time           10   # Segundos para introducir el nombre al finalizar la partida si no se pulsa nada
-game.name_entry_total_time          60   # Segundos totales para introducir el nombre al finalizar la partida
+game.name_entry_idle_time        10000   # Segundos para introducir el nombre al finalizar la partida si no se pulsa nada
+game.name_entry_total_time       60000   # Segundos totales para introducir el nombre al finalizar la partida
 game.hit_stop                    false   # Indica si debe haber un paro cuando el jugador es golpeado por un globo
 game.hit_stop_ms                   500   # Cantidad de milisegundos que dura el hit_stop
 
@@ -39,24 +39,24 @@ scoreboard.text_color2           FFFFFF   # Color secundario del texto del marca
 scoreboard.skip_countdown_value       8   # Valor para saltar la cuenta atrás (segundos)
 
 # --- TITLE ---
-title.press_start_position     180   # Posición Y del texto "Press Start"
-title.title_duration           800   # Duración de la pantalla de título (frames)
-title.arcade_edition_position  123   # Posición Y del subtítulo "Arcade Edition"
-title.title_c_c_position        80   # Posición Y del título principal
-title.bg_color              41526F   # Color de fondo en la sección titulo
+title.press_start_position        180   # Posición Y del texto "Press Start"
+title.title_duration            14000   # Duración de la pantalla de título (milisegundos)
+title.arcade_edition_position     123   # Posición Y del subtítulo "Arcade Edition"
+title.title_c_c_position           80   # Posición Y del título principal
+title.bg_color                 41526F   # Color de fondo en la sección titulo
 
 # --- BACKGROUND ---
 background.attenuate_color  FFFFFF00   # Color de atenuación del fondo (RGBA hexadecimal)
 
-# --- BALLOONS ---
-balloon.settings[0].vel   2.75f   # Velocidad inicial del globo 1
-balloon.settings[0].grav  0.09f   # Gravedad aplicada al globo 1
-balloon.settings[1].vel   3.70f   # Velocidad inicial del globo 2
-balloon.settings[1].grav  0.10f   # Gravedad aplicada al globo 2
-balloon.settings[2].vel   4.70f   # Velocidad inicial del globo 3
-balloon.settings[2].grav  0.10f   # Gravedad aplicada al globo 3
-balloon.settings[3].vel   5.45f   # Velocidad inicial del globo 4
-balloon.settings[3].grav  0.10f   # Gravedad aplicada al globo 4
+# --- BALLOONS --- (deltaTime puro: vel en pixels/ms, grav en pixels/ms²)
+balloon.settings[0].vel   0.165f    # Velocidad inicial del globo 1 (pixels/ms)
+balloon.settings[0].grav  0.00032f  # Gravedad aplicada al globo 1 (pixels/ms²)
+balloon.settings[1].vel   0.222f    # Velocidad inicial del globo 2 (pixels/ms)
+balloon.settings[1].grav  0.00036f  # Gravedad aplicada al globo 2 (pixels/ms²)
+balloon.settings[2].vel   0.282f    # Velocidad inicial del globo 3 (pixels/ms)
+balloon.settings[2].grav  0.00036f  # Gravedad aplicada al globo 3 (pixels/ms²)
+balloon.settings[3].vel   0.327f    # Velocidad inicial del globo 4 (pixels/ms)
+balloon.settings[3].grav  0.00036f  # Gravedad aplicada al globo 4 (pixels/ms²)
 
 balloon.color[0]  blue    # Color de creación del globo normal
 balloon.color[1]  orange  # Color del globo normal

data/config/formations.txt

@@ -1,277 +0,0 @@
-# Coffee Crisis Arcade Edition - Archivo de configuración de formaciones de globos
-# Formato por línea: x, desp, y, vel_x, tipo, tamaño, retraso_tiempo_creacion
-# Variables disponibles:
-# X0_0, X0_50, X0_100, X1_0, X1_100, X2_0, X2_100, X3_0, X3_100
-# X3_25, X3_75, DEFAULT_POS_Y
-# SMALL, MEDIUM, LARGE, EXTRALARGE
-# RIGHT, LEFT
-
-formation: 0
-# Dos enemigos BALLOON3 uno a cada extremo
-X3_0,   0, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE, 0
-X3_100, 0, DEFAULT_POS_Y, LEFT,  BALLOON, EXTRALARGE, 0
-
-formation: 1
-# Dos enemigos BALLOON3 uno a cada cuarto. Ambos van hacia el centro
-X3_25, 0, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE, 0
-X3_75, 0, DEFAULT_POS_Y, LEFT,  BALLOON, EXTRALARGE, 0
-
-formation: 2
-# Cuatro enemigos BALLOON1 uno detrás del otro. A la izquierda y hacia el centro
-X1_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 30
-X1_0, 1, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 20
-X1_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 10
-X1_0, 3, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM,  0
-
-formation: 3
-# Cuatro enemigos BALLOON1 uno detrás del otro. A la derecha y hacia el centro
-X1_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 30
-X1_100, -1, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 20
-X1_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 10
-X1_100, -3, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM,  0
-
-formation: 4
-# Tres enemigos BALLOON2. 0, 25, 50. Hacia la derecha
-X2_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 20
-X2_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 10
-X2_0, 4, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE,  0
-
-formation: 5
-# Tres enemigos BALLOON2. 50, 75, 100. Hacia la izquierda
-X2_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 20
-X2_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 10
-X2_100, -4, DEFAULT_POS_Y, LEFT, BALLOON, LARGE,  0
-
-formation: 6
-# Tres enemigos BALLOON2. 0, 0, 0. Hacia la derecha
-X2_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 20
-X2_0, 1, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 10
-X2_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE,  0
-
-formation: 7
-# Tres enemigos BALLOON2. 100, 100, 100. Hacia la izquierda
-X2_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 20
-X2_100, -1, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 10
-X2_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, LARGE,  0
-
-formation: 8
-# Seis enemigos BALLOON0. 0, 0, 0, 0, 0, 0. Hacia la derecha
-X0_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 50
-X0_0, 1, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 40
-X0_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 30
-X0_0, 3, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 20
-X0_0, 4, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 10
-X0_0, 5, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  0
-
-formation: 9
-# Seis enemigos BALLOON0. 100, 100, 100, 100, 100, 100. Hacia la izquierda
-X0_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 50
-X0_100, -1, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 40
-X0_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 30
-X0_100, -3, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 20
-X0_100, -4, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 10
-X0_100, -5, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  0
-
-formation: 10
-# Tres enemigos BALLOON3 seguidos desde la izquierda. Hacia la derecha
-X3_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE, 30
-X3_0, 1, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE, 15
-X3_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE,  0
-
-formation: 11
-# Tres enemigos BALLOON3 seguidos desde la derecha. Hacia la izquierda
-X3_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, EXTRALARGE, 30
-X3_100, -1, DEFAULT_POS_Y, LEFT, BALLOON, EXTRALARGE, 15
-X3_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, EXTRALARGE,  0
-
-formation: 12
-# Seis enemigos BALLOON1 uno detrás del otro. A la izquierda y hacia el centro
-X1_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 50
-X1_0, 1, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 40
-X1_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 30
-X1_0, 3, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 20
-X1_0, 4, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 10
-X1_0, 5, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM,  0
-
-formation: 13
-# Seis enemigos BALLOON1 uno detrás del otro. A la derecha y hacia el centro
-X1_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 50
-X1_100, -1, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 40
-X1_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 30
-X1_100, -3, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 20
-X1_100, -4, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM, 10
-X1_100, -5, DEFAULT_POS_Y, LEFT, BALLOON, MEDIUM,  0
-
-formation: 14
-# Cinco enemigos BALLOON2. Hacia la derecha. Separados
-X2_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 40
-X2_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 30
-X2_0, 4, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 20
-X2_0, 6, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 10
-X2_0, 8, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE,  0
-
-formation: 15
-# Cinco enemigos BALLOON2. Hacia la izquierda. Separados
-X2_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 40
-X2_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 30
-X2_100, -4, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 20
-X2_100, -6, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 10
-X2_100, -8, DEFAULT_POS_Y, LEFT, BALLOON, LARGE,  0
-
-formation: 16
-# Cinco enemigos BALLOON2. Hacia la derecha. Juntos
-X2_0, 0, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 40
-X2_0, 1, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 30
-X2_0, 2, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 20
-X2_0, 3, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 10
-X2_0, 4, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE,  0
-
-formation: 17
-# Cinco enemigos BALLOON2. Hacia la izquierda. Juntos
-X2_100,  0, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 40
-X2_100, -1, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 30
-X2_100, -2, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 20
-X2_100, -3, DEFAULT_POS_Y, LEFT, BALLOON, LARGE, 10
-X2_100, -4, DEFAULT_POS_Y, LEFT, BALLOON, LARGE,  0
-
-formation: 18
-# Doce enemigos BALLOON0. Hacia la derecha. Juntos
-X0_0,  0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 110
-X0_0,  1, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 100
-X0_0,  2, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  90
-X0_0,  3, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  80
-X0_0,  4, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  70
-X0_0,  5, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  60
-X0_0,  6, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  50
-X0_0,  7, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  40
-X0_0,  8, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  30
-X0_0,  9, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  20
-X0_0, 10, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  10
-X0_0, 11, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,   0
-
-formation: 19
-# Doce enemigos BALLOON0. Hacia la izquierda. Juntos
-X0_100,   0, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 110
-X0_100,  -1, DEFAULT_POS_Y, LEFT, BALLOON, SMALL, 100
-X0_100,  -2, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  90
-X0_100,  -3, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  80
-X0_100,  -4, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  70
-X0_100,  -5, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  60
-X0_100,  -6, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  50
-X0_100,  -7, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  40
-X0_100,  -8, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  30
-X0_100,  -9, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  20
-X0_100, -10, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,  10
-X0_100, -11, DEFAULT_POS_Y, LEFT, BALLOON, SMALL,   0
-
-formation: 20
-# Cuatro enemigos BALLOON3 seguidos desde la izquierda/derecha. Simétricos
-X3_0,    0, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE, 0
-X3_0,    1, DEFAULT_POS_Y, RIGHT, BALLOON, EXTRALARGE, 0
-X3_100,  0, DEFAULT_POS_Y, LEFT,  BALLOON, EXTRALARGE, 0
-X3_100, -1, DEFAULT_POS_Y, LEFT,  BALLOON, EXTRALARGE, 0
-
-formation: 21
-# Diez enemigos BALLOON1 uno detrás del otro. Izquierda/derecha. Simétricos
-X1_0,    0, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM, 12
-X1_0,    1, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM,  9
-X1_0,    2, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM,  6
-X1_0,    3, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM,  3
-X1_0,    4, DEFAULT_POS_Y, RIGHT, BALLOON, MEDIUM,  0
-X1_100,  0, DEFAULT_POS_Y, LEFT,  BALLOON, MEDIUM, 12
-X1_100, -1, DEFAULT_POS_Y, LEFT,  BALLOON, MEDIUM,  9
-X1_100, -2, DEFAULT_POS_Y, LEFT,  BALLOON, MEDIUM,  6
-X1_100, -3, DEFAULT_POS_Y, LEFT,  BALLOON, MEDIUM,  3
-X1_100, -4, DEFAULT_POS_Y, LEFT,  BALLOON, MEDIUM,  0
-
-formation: 22
-# Diez enemigos BALLOON2. Hacia la derecha/izquierda. Separados. Simétricos
-X2_0,    0, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 40
-X2_0,    2, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 30
-X2_0,    4, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 20
-X2_0,    6, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 10
-X2_0,    8, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE,  0
-X2_100,  0, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 40
-X2_100, -2, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 30
-X2_100, -4, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 20
-X2_100, -6, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 10
-X2_100, -8, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE,  0
-
-formation: 23
-# Diez enemigos BALLOON2. Hacia la derecha. Juntos. Simétricos
-X2_0,    0, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 40
-X2_0,    1, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 30
-X2_0,    2, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 20
-X2_0,    3, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE, 10
-X2_0,    4, DEFAULT_POS_Y, RIGHT, BALLOON, LARGE,  0
-X2_100,  0, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 40
-X2_100, -1, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 30
-X2_100, -2, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 20
-X2_100, -3, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE, 10
-X2_100, -4, DEFAULT_POS_Y, LEFT,  BALLOON, LARGE,  0
-
-formation: 24
-# Treinta enemigos BALLOON0. Del centro hacia los extremos. Juntos. Simétricos
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  0
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  5
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 10
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 15
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 20
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 25
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 30
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 35
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 40
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 45
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 50
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 55
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 60
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 65
-X0_50, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 70
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL,  0
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL,  5
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 10
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 15
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 20
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 25
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 30
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 35
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 40
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 45
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 50
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 55
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 60
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 65
-X0_50, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 70
-
-formation: 25
-# Treinta enemigos BALLOON0. Del centro hacia adentro. Juntos. Simétricos
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 70
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 65
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 60
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 55
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 50
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 45
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 40
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 35
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 30
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 25
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 20
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 15
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL, 10
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL,  5
-X0_50 + 20, 0, DEFAULT_POS_Y, LEFT,  BALLOON, SMALL,  0
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 70
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 65
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 60
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 55
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 50
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 45
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 40
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 35
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 30
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 25
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 20
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 15
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL, 10
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  5
-X0_50 - 20, 0, DEFAULT_POS_Y, RIGHT, BALLOON, SMALL,  0

deltatime_cleanup_plan.md

@@ -0,0 +1,79 @@
+# Plan de Limpieza Post-Migración DeltaTime
+
+## Estado Actual
+✅ Migración básica completada: bullet.cpp, item.cpp, moving_sprite.cpp, game_logo.cpp
+✅ Magic numbers convertidos a constantes en game_logo.cpp
+
+## Tareas Pendientes
+
+### 1. Eliminar Contadores Frame-Based
+- [ ] Buscar todos los contadores que usen lógica frame-based
+- [ ] Convertir a timers basados en deltaTime
+- [ ] Eliminar variables como `counter_`, `frame_counter_`, etc.
+- [ ] Patrón: `if (counter-- <= 0)` → `if (timer >= DURATION_MS)`
+- [ ] **IMPORTANTE**: Todos los contadores han de ser crecientes, de cero hasta llegar a la constante que define su tope
+
+### 2. Revisar Inicializaciones de Aceleraciones MovingSprite
+- [ ] Buscar todas las llamadas a `setAccelX()`, `setAccelY()`
+- [ ] Buscar asignaciones directas a `ax_`, `ay_`
+- [ ] Convertir de `pixels/frame²` a `pixels/ms²`
+- [ ] Factor de conversión: `valor_original / (16.67)²`
+
+### 3. Problema Detectado: Demo - Creación Incorrecta de Globos
+- [ ] Investigar cómo se crean los globos en modo demo
+- [ ] Verificar si usan timing frame-based obsoleto
+- [ ] Corregir la lógica de creación para deltaTime
+
+### 4. Búsqueda de Patrones Problemáticos
+- [ ] Buscar `frameFactor` residual
+- [ ] Buscar `1000.0f / 60.0f` hardcodeado
+- [ ] Buscar `16.67f` hardcodeado
+- [ ] Buscar comentarios con "frame" o "60fps"
+- [ ] Localizar magic numbers y convertirlos a constantes con nombres descriptivos
+- [ ] **IMPORTANTE**: Modificar speed en ficheros .ani - está en frames, hay que pasarlo a milisegundos (multiplicar speed por 1000/60 = 16.67)
+- [ ] **SmartSprite**: Revisar inicialización de SmartSprites en el código - cambiar setFinishedCounter() a setFinishedDelay() y convertir valores de frames a milisegundos
+
+### 5. Cambio de Unidades de Tiempo en sections/*
+- [ ] Cambiar el cálculo de deltatime en source/sections/* para que devuelva segundos (float) en lugar de milisegundos
+- [ ] Cambiar velocidades de pixeles/ms a pixeles/segundos para evitar valores absurdamente pequeños
+- [ ] Cambiar aceleraciones de pixeles/ms² a pixeles/segundos²
+- [ ] Actualizar todas las constantes de tiempo en archivos de sections
+
+### 6. Archivos Prioritarios a Revisar
+- [ ] **player.cpp** - puede tener aceleraciones
+- [ ] **balloon.cpp** - contadores de estado
+- [ ] **stage.cpp** - timers de nivel
+- [ ] **credits.cpp** - efectos de texto
+- [ ] **tabe.cpp** - movimiento del protagonista
+- [ ] **sections/*.cpp** - transiciones y efectos
+
+### 7. Validación Final
+- [ ] Compilar sin warnings
+- [ ] Probar gameplay normal
+- [ ] Probar modo demo
+- [ ] Verificar que no hay saltos de velocidad
+- [ ] Confirmar que el timing es consistente en diferentes framerates
+
+## Comandos Útiles de Búsqueda
+```bash
+# Buscar contadores frame-based
+rg "counter.*--|\+\+.*counter|counter.*\+\+|--.*counter"
+
+# Buscar inicializaciones de aceleración
+rg "setAccel|\.ax.*=|\.ay.*="
+
+# Buscar hardcoded framerates
+rg "60\.0|16\.67|1000\.0.*60"
+```
+
+## DECISIÓN IMPORTANTE: TODO EL CÓDIGO USA SEGUNDOS
+- **CAMBIO DE PLAN**: Todo el código del juego debe usar deltaTime en segundos (float)
+- **NO** debe haber soporte para frames, milisegundos y segundos simultáneamente
+- **SOLO SEGUNDOS** en todo el codebase
+- Velocidades en `pixels/segundos`, aceleraciones en `pixels/segundos²`
+- Todos los contadores deben ser crecientes (0 → constante_tope)
+- Eliminar todos los métodos duales (updateS, setSpeedS, etc.) - solo una versión
+- Convertir completamente: path_sprite.cpp, writer.cpp, tiled_bg.cpp, etc.
+- Documentar las conversiones en comentarios
+- Crear constantes para valores repetidos
+- Evitar números mágicos

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,33 +86,33 @@ auto AnimatedSprite::getAnimationIndex(const std::string& name) -> int {
     return -1;
 }
 
-// Calcula el frame correspondiente a la animación
-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;
     }
 
-    // Calcula el frame actual a partir del contador
-    animations_[current_animation_].current_frame = animations_[current_animation_].counter / animations_[current_animation_].speed;
-
-    // Si alcanza el final de la animación, reinicia el contador de la animación
-    // en función de la variable loop y coloca el nuevo frame
-    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();
-            animations_[current_animation_].completed = true;
-        } else {  // Si hay loop, vuelve al frame indicado
-            animations_[current_animation_].counter = 0;
-            animations_[current_animation_].current_frame = animations_[current_animation_].loop;
+    // Acumular tiempo transcurrido
+    animations_[current_animation_].time_accumulator += deltaTime;
+    
+    // Verificar si es momento de cambiar frame
+    if (animations_[current_animation_].time_accumulator >= animations_[current_animation_].speed) {
+        animations_[current_animation_].time_accumulator -= animations_[current_animation_].speed;
+        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;
+            }
         }
-    }
-    // En caso contrario
-    else {
-        // Escoge el frame correspondiente de la animación
+        
+        // Actualizar el sprite clip
         updateSpriteClip();
-
-        // Incrementa el contador de la animacion
-        animations_[current_animation_].counter++;
     }
 }
 
@@ -107,11 +129,11 @@ void AnimatedSprite::setCurrentAnimation(const std::string& name, bool reset) {
         current_animation_ = NEW_ANIMATION;
         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();
@@ -126,27 +148,27 @@ void AnimatedSprite::setCurrentAnimation(int index, bool reset) {
         current_animation_ = NEW_ANIMATION;
         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
-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();
@@ -172,6 +194,12 @@ void AnimatedSprite::loadFromAnimationsFileBuffer(const AnimationsFileBuffer& so
     // Pone un valor por defecto
     setWidth(config.frame_width);
     setHeight(config.frame_height);
+
+    // Establece el primer frame inmediatamente si hay animaciones
+    if (!animations_.empty()) {
+        current_animation_ = 0;
+        updateSpriteClip();
+    }
 }
 
 // Procesa una línea de configuración

source/animated_sprite.h

@@ -17,15 +17,15 @@ class Texture;
 
 // --- Estructuras ---
 struct Animation {
-        static constexpr int DEFAULT_SPEED = 5;
+        static constexpr float DEFAULT_SPEED = 80.0F;
 
         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
+        float speed{DEFAULT_SPEED};     // Velocidad de reproducción (ms entre frames)
         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
+        float time_accumulator{0.0f};   // Acumulador de tiempo para animaciones time-based
         bool paused{false};             // La animación no avanza
 
         Animation() = default;
@@ -50,11 +50,12 @@ 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(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 +78,7 @@ 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(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,7 @@ void Background::initializeTextures() {
 }
 
 // Actualiza la lógica del objeto
-void Background::update() {
+void Background::update(float delta_time) {
     // Actualiza la progresión y calcula transiciones
     if (!manual_mode_) {
         updateProgression();
@@ -136,10 +136,14 @@ void Background::update() {
     updateAlphaColorTexture();
 
     // Actualiza las nubes
-    updateClouds();
+    updateClouds(delta_time);
 
-    // Calcula el frame de la hierba
-    grass_sprite_->setSpriteClip(0, (10 * (counter_ / 20 % 2)), 320, 10);
+    // Actualiza timer de hierba
+    grass_timer_ += delta_time;
+
+    // Calcula el frame de la hierba (alterna cada GRASS_FRAME_DURATION ms)
+    int grass_frame = static_cast<int>(grass_timer_ / GRASS_FRAME_DURATION) % 2;
+    grass_sprite_->setSpriteClip(0, (10 * grass_frame), 320, 10);
 
     // Calcula el valor de alpha
     alpha_ = std::max((255 - (int)(255 * transition_)), 0);
@@ -148,9 +152,6 @@ void Background::update() {
     sun_sprite_->setPosition(sun_path_.at(sun_index_));
     moon_sprite_->setPosition(moon_path_.at(moon_index_));
 
-    // Incrementa el contador
-    ++counter_;
-
     // Compone todos los elementos del fondo en la textura
     fillCanvas();
 }
@@ -314,12 +315,12 @@ void Background::updateCloudsSpeed() {
 }
 
 // Actualiza las nubes
-void Background::updateClouds() {
+void Background::updateClouds(float deltaTime) {
     // Mueve las nubes
-    top_clouds_sprite_a_->update();
-    top_clouds_sprite_b_->update();
-    bottom_clouds_sprite_a_->update();
-    bottom_clouds_sprite_b_->update();
+    top_clouds_sprite_a_->update(deltaTime);
+    top_clouds_sprite_b_->update(deltaTime);
+    bottom_clouds_sprite_a_->update(deltaTime);
+    bottom_clouds_sprite_b_->update(deltaTime);
 
     // Calcula el offset de las nubes
     if (top_clouds_sprite_a_->getPosX() < -top_clouds_sprite_a_->getWidth()) {

source/background.h

@@ -31,7 +31,7 @@ class Background {
         ~Background();                                           // Destructor
 
         // --- Métodos principales ---
-        void update();  // Actualiza la lógica del objeto
+        void update(float delta_time);    // Actualiza la lógica del objeto
         void render();  // Dibuja el objeto
         void reset();   // Reinicia la progresión
 
@@ -107,7 +107,8 @@ class Background {
         float clouds_speed_ = 0;                       // Velocidad de las nubes
         float transition_ = 0;                         // Porcentaje de transición
         size_t gradient_number_ = 0;                   // Índice de fondo degradado
-        size_t counter_ = 0;                           // Contador interno
+        float grass_timer_ = 0.0f;                     // Timer para animación de hierba (ms)
+        static constexpr float GRASS_FRAME_DURATION = 333.34f;  // Duración por frame de hierba (20 frames * 16.67ms)
         size_t alpha_color_texture_ = 0;               // Transparencia de atenuación
         size_t previous_alpha_color_texture_ = 0;      // Transparencia anterior
         size_t sun_index_ = 0;                         // Índice del recorrido del sol
@@ -129,7 +130,7 @@ class Background {
         void renderBottomClouds();          // Dibuja las nubes inferiores
         void fillCanvas();                  // Compone todos los elementos en la textura
         void updateAlphaColorTexture();     // Actualiza el alpha de la textura de atenuación
-        void updateClouds();                // Actualiza el movimiento de las nubes
+        void updateClouds(float deltaTime);  // Actualiza el movimiento de las nubes (time-based)
         void createSunPath();               // Precalcula el recorrido del sol
         void createMoonPath();              // Precalcula el recorrido de la luna
 };

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),
+      game_tempo_(config.game_tempo),
+      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;
         }
 
@@ -91,6 +89,12 @@ Balloon::Balloon(float x, float y, Type type, Size size, float vel_x, float spee
 
     // Establece la animación a usar
     setAnimation();
+
+    // Si no se está creando (creation_counter = 0), asegurar estado activo
+    if (!being_created_) {
+        start();
+        setInvulnerable(false);
+    }
 }
 
 // Centra el globo en la posición X
@@ -137,19 +141,20 @@ void Balloon::render() {
     }
 }
 
-// Actualiza la posición y estados del globo
-void Balloon::move() {
+// Actualiza la posición y estados del globo (time-based)
+void Balloon::move(float deltaTime) {
     if (isStopped()) {
         return;
     }
 
-    handleHorizontalMovement();
-    handleVerticalMovement();
-    applyGravity();
+    handleHorizontalMovement(deltaTime);
+    handleVerticalMovement(deltaTime);
+    applyGravity(deltaTime);
 }
 
-void Balloon::handleHorizontalMovement() {
-    x_ += vx_ * speed_;
+void Balloon::handleHorizontalMovement(float deltaTime) {
+    // DeltaTime puro: velocidad (pixels/ms) * tempo * tiempo (ms)
+    x_ += vx_ * game_tempo_ * deltaTime;
 
     const int CLIP = 2;
     const float MIN_X = play_area_.x - CLIP;
@@ -160,8 +165,9 @@ void Balloon::handleHorizontalMovement() {
     }
 }
 
-void Balloon::handleVerticalMovement() {
-    y_ += vy_ * speed_;
+void Balloon::handleVerticalMovement(float deltaTime) {
+    // DeltaTime puro: velocidad (pixels/ms) * tempo * tiempo (ms)
+    y_ += vy_ * game_tempo_ * deltaTime;
 
     if (shouldCheckTopCollision()) {
         handleTopCollision();
@@ -216,41 +222,37 @@ void Balloon::handleBottomCollision() {
     }
 }
 
-void Balloon::applyGravity() {
-    /*
-    Para aplicar la gravedad, el diseño original la aplicaba en cada iteración del bucle
-    Al añadir el modificador de velocidad se reduce la distancia que recorre el objeto y por
-    tanto recibe mas gravedad. Para solucionarlo se va a aplicar la gravedad cuando se haya
-    recorrido una distancia igual a la velocidad en Y, que era el cálculo inicial
-    */
-
-    travel_y_ += speed_;
-
-    if (travel_y_ >= 1.0F) {
-        travel_y_ -= 1.0F;
-        vy_ += gravity_;
-    }
+void Balloon::applyGravity(float deltaTime) {
+    // DeltaTime puro: aceleración (pixels/ms²) * tempo * tiempo (ms)
+    vy_ += gravity_ * game_tempo_ * deltaTime;
 }
 
 void Balloon::playBouncingSound() {
-    if (bouncing_sound_enabled_) {
-        playSound(bouncing_sound_);
+    if (sound_.enabled && sound_.bouncing_enabled) {
+        Audio::get()->playSound(sound_.bouncing_file);
     }
 }
 
-// Actualiza al globo a su posicion, animación y controla los contadores
-void Balloon::update() {
-    move();
-    updateState();
+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 (time-based)
+void Balloon::update(float deltaTime) {
+    move(deltaTime);
+    updateState(deltaTime);
     updateBounceEffect();
     shiftSprite();
     shiftColliders();
-    sprite_->update();
-    ++counter_;
+    sprite_->update(deltaTime);
+    // Contador interno con deltaTime puro
+    counter_ += deltaTime;
 }
 
-// Actualiza los estados del globo
-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
@@ -259,9 +261,13 @@ void Balloon::updateState() {
 
         if (creation_counter_ > 0) {
             // Desplaza lentamente el globo hacia abajo y hacia un lado
-            if (creation_counter_ % 10 == 0) {
+            // Cada 166ms (equivalente a 10 frames a 60fps)
+            movement_accumulator_ += deltaTime;
+
+            if (movement_accumulator_ >= 166.0f) {
+                movement_accumulator_ -= 166.0f;
                 y_++;
-                x_ += vx_;
+                x_ += vx_ * 10.0f;  // Movimiento equivalente a 10 frames de velocidad horizontal
 
                 // Comprueba no se salga por los laterales
                 const int MIN_X = play_area_.x;
@@ -269,11 +275,12 @@ void Balloon::updateState() {
 
                 if (x_ < MIN_X || x_ > MAX_X) {
                     // Corrige y cambia el sentido de la velocidad
-                    x_ -= vx_;
+                    x_ -= vx_ * 10.0f;
                     vx_ = -vx_;
                 }
             }
-            --creation_counter_;
+            creation_counter_ -= deltaTime;
+            if (creation_counter_ < 0) creation_counter_ = 0;
         }
 
         else {
@@ -307,11 +314,14 @@ void Balloon::setAnimation() {
     }
 
     // Establece el frame de animación
+    std::string chosen_animation;
     if (use_reversed_colors_) {
-        sprite_->setCurrentAnimation(creating_animation);
+        chosen_animation = creating_animation;
     } else {
-        sprite_->setCurrentAnimation(isBeingCreated() ? creating_animation : normal_animation);
+        chosen_animation = isBeingCreated() ? creating_animation : normal_animation;
     }
+
+    sprite_->setCurrentAnimation(chosen_animation);
 }
 
 // Detiene el globo
@@ -368,23 +378,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,15 +25,23 @@ 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;
+        // Velocidades horizontales en pixels/ms (convertidas desde 0.7 pixels/frame a 60fps)
+        static constexpr float VELX_POSITIVE = 0.7F / (1000.0F / 60.0F);  // ~0.042 pixels/ms
+        static constexpr float VELX_NEGATIVE = -0.7F / (1000.0F / 60.0F); // ~-0.042 pixels/ms
 
-        static constexpr std::array<float, 5> SPEED = {0.60F, 0.70F, 0.80F, 0.90F, 1.00F};
+        // Multiplicadores de tempo del juego (sin cambios, son puros multiplicadores)
+        static constexpr std::array<float, 5> GAME_TEMPO = {0.60F, 0.70F, 0.80F, 0.90F, 1.00F};
 
         static constexpr int POWERBALL_SCREENPOWER_MINIMUM = 10;
         static constexpr int POWERBALL_COUNTER = 8;
@@ -52,26 +60,40 @@ 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 game_tempo = GAME_TEMPO.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(float deltaTime);                // Actualiza la posición y estados del globo (time-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
 
@@ -100,11 +122,11 @@ class Balloon {
 
         // --- Setters ---
         void setVelY(float vel_y) { vy_ = vel_y; }
-        void setSpeed(float speed) { speed_ = speed; }
+        void setGameTempo(float tempo) { game_tempo_ = tempo; }
         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,48 @@ 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 game_tempo_;                  // Multiplicador de tempo del juego
+        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(float deltaTime); // Maneja el movimiento horizontal (time-based)
+        void handleVerticalMovement(float deltaTime);   // Maneja el movimiento vertical (time-based)
+        void applyGravity(float deltaTime);             // Aplica la gravedad al objeto (time-based)
 
         // --- Rebote ---
         void enableBounceEffect();                              // Activa el efecto de rebote
@@ -263,5 +299,5 @@ class Balloon {
         void handleBottomCollision();                                                        // Maneja la colisión inferior
 
         // --- Lógica de estado ---
-        void updateState();  // Actualiza los estados del globo
+        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 {
@@ -77,7 +82,7 @@ class BalloonFormations {
     private:
         // --- Constantes ---
         static constexpr int BALLOON_SPAWN_HEIGHT = 208;   // Altura desde el suelo en la que aparecen los globos
-        static constexpr int DEFAULT_CREATION_TIME = 200;  // Tiempo base de creación de los globos para las formaciones
+        static constexpr int DEFAULT_CREATION_TIME = 3334;  // Tiempo base de creación de los globos en ms (200 frames × 16.67ms)
 
         // --- Variables ---
         std::vector<Formation> formations_;  // Vector con todas las formaciones disponibles

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,13 +62,13 @@ void BalloonManager::init() {
     explosions_->addTexture(3, explosions_textures_.at(3), explosions_animations_.at(3));
 }
 
-// Actualiza
-void BalloonManager::update() {
+// Actualiza (time-based)
+void BalloonManager::update(float deltaTime) {
     for (const auto &balloon : balloons_) {
-        balloon->update();
+        balloon->update(deltaTime);
     }
-    updateBalloonDeployCounter();
-    explosions_->update();
+    updateBalloonDeployCounter(deltaTime);
+    explosions_->update(deltaTime);
 }
 
 // Renderiza los objetos
@@ -80,11 +82,11 @@ void BalloonManager::render() {
 // Crea una formación de globos
 void BalloonManager::deployRandomFormation(int stage) {
     // Solo despliega una formación enemiga si ha pasado cierto tiempo desde la última
-    if (balloon_deploy_counter_ == 0) {
+    if (balloon_deploy_counter_ >= DEFAULT_BALLOON_DEPLOY_COUNTER) {
         // En este punto se decide entre crear una powerball o una formación enemiga
         if ((rand() % 100 < 15) && (canPowerBallBeCreated())) {
             createPowerBall();             // Crea una powerball
-            balloon_deploy_counter_ = 10;  // Da un poco de margen para que se creen mas globos
+            balloon_deploy_counter_ = -167;  // Resetea con pequeño retraso (10 frames = 167ms negativos)
         } else {
             // Decrementa el contador de despliegues de globos necesarios para la siguiente PowerBall
             if (power_ball_counter_ > 0) {
@@ -105,11 +107,19 @@ 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,
+                    .game_tempo = balloon_speed_,
+                    .creation_counter = static_cast<Uint16>(creation_time_enabled_ ? balloon.creation_counter : 0)};
+                createBalloon(config);
             }
 
             // Reinicia el contador para el próximo despliegue
-            balloon_deploy_counter_ = DEFAULT_BALLOON_DEPLOY_COUNTER;
+            balloon_deploy_counter_ = 0;
         }
     }
 }
@@ -118,15 +128,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,
+            .game_tempo = 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,
+            .game_tempo = balloon_speed_,
+            .creation_counter = balloon.creation_counter};
+        createBalloon(config);
     }
 }
 
@@ -136,11 +162,10 @@ void BalloonManager::freeBalloons() {
     balloons_.erase(result.begin(), balloons_.end());
 }
 
-// Actualiza la variable enemyDeployCounter
-void BalloonManager::updateBalloonDeployCounter() {
-    if (balloon_deploy_counter_ > 0) {
-        --balloon_deploy_counter_;
-    }
+// Actualiza la variable enemyDeployCounter (time-based)
+void BalloonManager::updateBalloonDeployCounter(float deltaTime) {
+    // DeltaTime puro - contador incrementa hasta llegar al umbral
+    balloon_deploy_counter_ += deltaTime;
 }
 
 // Indica si se puede crear una powerball
@@ -152,13 +177,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,22 +197,28 @@ 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,
+            .game_tempo = 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);
+        // Establece parametros (deltaTime puro - valores ya en pixels/ms)
+        constexpr float VEL_Y_BALLOON_PER_MS = -0.15F;  // -2.50F convertido a pixels/ms
+        b->setVelY(b->getType() == Balloon::Type::BALLOON ? VEL_Y_BALLOON_PER_MS : Balloon::VELX_NEGATIVE * 2.0F);
 
         // Herencia de estados
         if (balloon->isStopped()) { b->stop(); }
@@ -196,18 +230,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),
+            .game_tempo = 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;
@@ -219,7 +267,7 @@ void BalloonManager::createPowerBall() {
 void BalloonManager::setBalloonSpeed(float speed) {
     balloon_speed_ = speed;
     for (auto &balloon : balloons_) {
-        balloon->setSpeed(speed);
+        balloon->setGameTempo(speed);
     }
 }
 
@@ -232,7 +280,7 @@ auto BalloonManager::popBalloon(const std::shared_ptr<Balloon> &balloon) -> int
         balloon->pop(true);
         score = destroyAllBalloons();
         power_ball_enabled_ = false;
-        balloon_deploy_counter_ = 20;
+        balloon_deploy_counter_ = -334;  // Resetea con retraso (20 frames = 334ms negativos)
     } else {
         score = balloon->getScore();
         if (balloon->getSize() != Balloon::Size::SMALL) {
@@ -288,7 +336,7 @@ auto BalloonManager::destroyAllBalloons() -> int {
         score += destroyBalloon(balloon);
     }
 
-    balloon_deploy_counter_ = 300;
+    balloon_deploy_counter_ = -5000;  // Resetea con retraso grande (300 frames = 5000ms negativos)
     Screen::get()->flash(Colors::FLASH, 3);
     Screen::get()->shake();
 
@@ -298,7 +346,9 @@ auto BalloonManager::destroyAllBalloons() -> int {
 // Detiene todos los globos
 void BalloonManager::stopAllBalloons() {
     for (auto &balloon : balloons_) {
-        balloon->stop();
+        if (!balloon->isBeingCreated()) {
+            balloon->stop();
+        }
     }
 }
 
@@ -332,19 +382,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,8 @@ class BalloonManager {
         ~BalloonManager() = default;
 
         // --- Métodos principales ---
-        void update();  // Actualiza el estado de los globos
-        void render();  // Renderiza los globos en pantalla
+        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 +37,19 @@ 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(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
 
@@ -83,7 +82,7 @@ class BalloonManager {
 
     private:
         // --- Constantes ---
-        static const int DEFAULT_BALLOON_DEPLOY_COUNTER = 300;
+        static const int DEFAULT_BALLOON_DEPLOY_COUNTER = 5000;  // 300 frames × 16.67ms = 5000ms
 
         // --- Objetos y punteros ---
         Balloons balloons_;                                            // Vector con los globos activos
@@ -97,9 +96,9 @@ class BalloonManager {
 
         // --- Variables de estado ---
         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_speed_ = Balloon::GAME_TEMPO.at(0);
+        float default_balloon_speed_ = Balloon::GAME_TEMPO.at(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,21 +60,22 @@ void Bullet::render() {
     }
 }
 
-// Actualiza el estado del objeto
-auto Bullet::update() -> BulletMoveStatus {
-    sprite_->update();
-    return move();
+// 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
-auto Bullet::move() -> BulletMoveStatus {
-    pos_x_ += vel_x_;
+// Implementación del movimiento usando BulletMoveStatus (time-based)
+auto Bullet::move(float deltaTime) -> BulletMoveStatus {
+    // DeltaTime puro: velocidad (pixels/ms) * tiempo (ms)
+    pos_x_ += vel_x_ * deltaTime;
     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;
+    pos_y_ += VEL_Y * deltaTime;
     if (pos_y_ < param.game.play_area.rect.y - HEIGHT) {
         disable();
         return BulletMoveStatus::OUT;

source/bullet.h

@@ -34,9 +34,9 @@ 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(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
@@ -45,9 +45,9 @@ class Bullet {
 
     private:
         // --- Constantes ---
-        static constexpr float VEL_Y = -3.0F;        // Velocidad vertical
-        static constexpr float VEL_X_LEFT = -2.0F;   // Velocidad izquierda
-        static constexpr float VEL_X_RIGHT = 2.0F;   // Velocidad derecha
+        static constexpr float VEL_Y = -0.18F;        // Velocidad vertical (pixels/ms)
+        static constexpr float VEL_X_LEFT = -0.12F;   // Velocidad izquierda (pixels/ms)
+        static constexpr float VEL_X_RIGHT = 0.12F;   // Velocidad derecha (pixels/ms)
         static constexpr float VEL_X_CENTER = 0.0F;  // Velocidad central
 
         // --- Objetos y punteros ---
@@ -64,7 +64,7 @@ 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(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

@@ -15,8 +15,8 @@ namespace Game {
 constexpr float WIDTH = 320.0F;
 constexpr float HEIGHT = 256.0F;
 constexpr float ITEM_SIZE = 20.0F;
-constexpr int NAME_ENTRY_IDLE_TIME = 10;
-constexpr int NAME_ENTRY_TOTAL_TIME = 60;
+constexpr int NAME_ENTRY_IDLE_TIME = 10000;   // 10 segundos en milisegundos
+constexpr int NAME_ENTRY_TOTAL_TIME = 60000;  // 60 segundos en milisegundos
 constexpr bool HIT_STOP = false;
 constexpr int HIT_STOP_MS = 500;
 constexpr const char* ITEM_TEXT_OUTLINE_COLOR = "FFFFFF00";  // 255, 255, 255, 0
@@ -58,7 +58,7 @@ constexpr int SKIP_COUNTDOWN_VALUE = 8;
 // --- TITLE ---
 namespace Title {
 constexpr int PRESS_START_POSITION = 180;
-constexpr int DURATION = 800;
+constexpr float DURATION = 14000;
 constexpr int ARCADE_EDITION_POSITION = 123;
 constexpr int TITLE_C_C_POSITION = 80;
 constexpr const char* BG_COLOR = "41526F";
@@ -76,14 +76,16 @@ struct BalloonSettings {
         float vel;
         float grav;
         constexpr BalloonSettings(float v, float g)
-            : vel(v), grav(g) {}
+            : vel(v),
+              grav(g) {}
 };
 
+// Valores para deltaTime puro: vel en pixels/ms, grav en pixels/ms² (aceleración)
 constexpr std::array<BalloonSettings, 4> SETTINGS = {{
-    BalloonSettings(2.75F, 0.09F),  // Globo 0
-    BalloonSettings(3.70F, 0.10F),  // Globo 1
-    BalloonSettings(4.70F, 0.10F),  // Globo 2
-    BalloonSettings(5.45F, 0.10F)   // Globo 3
+    BalloonSettings(2.75F / 16.67F, 0.09F / (16.67F * 16.67F)),   // Globo 0: vel=0.165 pixels/ms, grav=0.00032 pixels/ms²
+    BalloonSettings(3.70F / 16.67F, 0.10F / (16.67F * 16.67F)),   // Globo 1: vel=0.222 pixels/ms, grav=0.00036 pixels/ms²
+    BalloonSettings(4.70F / 16.67F, 0.10F / (16.67F * 16.67F)),   // Globo 2: vel=0.282 pixels/ms, grav=0.00036 pixels/ms²
+    BalloonSettings(5.45F / 16.67F, 0.10F / (16.67F * 16.67F))    // Globo 3: vel=0.327 pixels/ms, grav=0.00036 pixels/ms²
 }};
 
 constexpr std::array<const char*, 4> COLORS = {

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
@@ -41,7 +42,7 @@ Director::Director(int argc, std::span<char *> argv) {
     Section::name = Section::Name::GAME;
     Section::options = Section::Options::GAME_PLAY_1P;
 #elif _DEBUG
-    Section::name = Section::Name::GAME;
+    Section::name = Section::Name::INTRO;
     Section::options = Section::Options::GAME_PLAY_1P;
 #else  // NORMAL GAME
     Section::name = Section::Name::LOGO;
@@ -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,10 +6,10 @@
 
 class Texture;  // lines 4-4
 
-// Actualiza la lógica de la clase
-void Explosions::update() {
+// Actualiza la lógica de la clase (time-based)
+void Explosions::update(float deltaTime) {
     for (auto &explosion : explosions_) {
-        explosion->update();
+        explosion->update(deltaTime);
     }
 
     // Vacia el vector de elementos finalizados

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,8 @@ 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(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_timer_ = 0.0f;
 
     // Inicializa el bitmap de 'Coffee'
     coffee_sprite_->setPosX(XP);
@@ -52,44 +53,44 @@ void GameLogo::init() {
     coffee_sprite_->setWidth(coffee_texture_->getWidth());
     coffee_sprite_->setHeight(coffee_texture_->getHeight());
     coffee_sprite_->setVelX(0.0F);
-    coffee_sprite_->setVelY(2.5F);
+    coffee_sprite_->setVelY(COFFEE_VEL_Y);
     coffee_sprite_->setAccelX(0.0F);
-    coffee_sprite_->setAccelY(0.1F);
+    coffee_sprite_->setAccelY(COFFEE_ACCEL_Y);
     coffee_sprite_->setSpriteClip(0, 0, coffee_texture_->getWidth(), coffee_texture_->getHeight());
     coffee_sprite_->setEnabled(true);
-    coffee_sprite_->setFinishedCounter(0);
+    coffee_sprite_->setFinishedDelay(0.0f);
     coffee_sprite_->setDestX(XP);
     coffee_sprite_->setDestY(y_ - coffee_texture_->getHeight());
 
     // Inicializa el bitmap de 'Crisis'
-    crisis_sprite_->setPosX(XP + 15);
+    crisis_sprite_->setPosX(XP + CRISIS_OFFSET_X);
     crisis_sprite_->setPosY(y_ + DESP);
     crisis_sprite_->setWidth(crisis_texture_->getWidth());
     crisis_sprite_->setHeight(crisis_texture_->getHeight());
     crisis_sprite_->setVelX(0.0F);
-    crisis_sprite_->setVelY(-2.5F);
+    crisis_sprite_->setVelY(CRISIS_VEL_Y);
     crisis_sprite_->setAccelX(0.0F);
-    crisis_sprite_->setAccelY(-0.1F);
+    crisis_sprite_->setAccelY(CRISIS_ACCEL_Y);
     crisis_sprite_->setSpriteClip(0, 0, crisis_texture_->getWidth(), crisis_texture_->getHeight());
     crisis_sprite_->setEnabled(true);
-    crisis_sprite_->setFinishedCounter(0);
-    crisis_sprite_->setDestX(XP + 15);
+    crisis_sprite_->setFinishedDelay(0.0f);
+    crisis_sprite_->setDestX(XP + CRISIS_OFFSET_X);
     crisis_sprite_->setDestY(y_);
 
     // Inicializa el bitmap de 'DustRight'
     dust_right_sprite_->resetAnimation();
     dust_right_sprite_->setPosX(coffee_sprite_->getPosX() + coffee_sprite_->getWidth());
     dust_right_sprite_->setPosY(y_);
-    dust_right_sprite_->setWidth(16);
-    dust_right_sprite_->setHeight(16);
+    dust_right_sprite_->setWidth(DUST_SIZE);
+    dust_right_sprite_->setHeight(DUST_SIZE);
     dust_right_sprite_->setFlip(SDL_FLIP_HORIZONTAL);
 
     // Inicializa el bitmap de 'DustLeft'
     dust_left_sprite_->resetAnimation();
-    dust_left_sprite_->setPosX(coffee_sprite_->getPosX() - 16);
+    dust_left_sprite_->setPosX(coffee_sprite_->getPosX() - DUST_SIZE);
     dust_left_sprite_->setPosY(y_);
-    dust_left_sprite_->setWidth(16);
-    dust_left_sprite_->setHeight(16);
+    dust_left_sprite_->setWidth(DUST_SIZE);
+    dust_left_sprite_->setHeight(DUST_SIZE);
 
     // Inicializa el bitmap de 'Arcade Edition'
     arcade_edition_sprite_->setZoom(zoom_);
@@ -112,45 +113,45 @@ void GameLogo::render() {
     }
 }
 
-// Actualiza la lógica de la clase
-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() {
+void GameLogo::updateCoffeeCrisis(float deltaTime) {
     switch (coffee_crisis_status_) {
         case Status::MOVING:
-            handleCoffeeCrisisMoving();
+            handleCoffeeCrisisMoving(deltaTime);
             break;
         case Status::SHAKING:
-            handleCoffeeCrisisShaking();
+            handleCoffeeCrisisShaking(deltaTime);
             break;
         case Status::FINISHED:
-            handleCoffeeCrisisFinished();
+            handleCoffeeCrisisFinished(deltaTime);
             break;
         default:
             break;
     }
 }
 
-void GameLogo::updateArcadeEdition() {
+void GameLogo::updateArcadeEdition(float deltaTime) {
     switch (arcade_edition_status_) {
         case Status::MOVING:
-            handleArcadeEditionMoving();
+            handleArcadeEditionMoving(deltaTime);
             break;
         case Status::SHAKING:
-            handleArcadeEditionShaking();
+            handleArcadeEditionShaking(deltaTime);
             break;
         default:
             break;
     }
 }
 
-void GameLogo::handleCoffeeCrisisMoving() {
-    coffee_sprite_->update();
-    crisis_sprite_->update();
+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;
@@ -158,22 +159,23 @@ void GameLogo::handleCoffeeCrisisMoving() {
     }
 }
 
-void GameLogo::handleCoffeeCrisisShaking() {
+void GameLogo::handleCoffeeCrisisShaking(float deltaTime) {
     if (shake_.remaining > 0) {
-        processShakeEffect(coffee_sprite_.get(), crisis_sprite_.get());
+        processShakeEffect(coffee_sprite_.get(), crisis_sprite_.get(), deltaTime);
     } else {
         finishCoffeeCrisisShaking();
     }
 
-    updateDustSprites();
+    updateDustSprites(deltaTime);
 }
 
-void GameLogo::handleCoffeeCrisisFinished() {
-    updateDustSprites();
+void GameLogo::handleCoffeeCrisisFinished(float deltaTime) {
+    updateDustSprites(deltaTime);
 }
 
-void GameLogo::handleArcadeEditionMoving() {
-    zoom_ -= 0.1F * ZOOM_FACTOR;
+void GameLogo::handleArcadeEditionMoving(float deltaTime) {
+    // DeltaTime puro: decremento por milisegundo
+    zoom_ -= (ZOOM_DECREMENT_PER_MS * ZOOM_FACTOR) * deltaTime;
     arcade_edition_sprite_->setZoom(zoom_);
 
     if (zoom_ <= 1.0F) {
@@ -181,34 +183,38 @@ void GameLogo::handleArcadeEditionMoving() {
     }
 }
 
-void GameLogo::handleArcadeEditionShaking() {
+void GameLogo::handleArcadeEditionShaking(float deltaTime) {
     if (shake_.remaining > 0) {
-        processArcadeEditionShake();
+        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--;
-    } else {
-        shake_.counter = shake_.delay;
+
+void GameLogo::processShakeEffect(SmartSprite* primary_sprite, SmartSprite* secondary_sprite, float deltaTime) {
+    shake_.time_accumulator += deltaTime;
+    
+    if (shake_.time_accumulator >= SHAKE_DELAY_MS) {
+        shake_.time_accumulator -= SHAKE_DELAY_MS;
         const auto DISPLACEMENT = calculateShakeDisplacement();
         primary_sprite->setPosX(shake_.origin + DISPLACEMENT);
         if (secondary_sprite != nullptr) {
-            secondary_sprite->setPosX(shake_.origin + DISPLACEMENT + 15);
+            secondary_sprite->setPosX(shake_.origin + DISPLACEMENT + CRISIS_OFFSET_X);
         }
         shake_.remaining--;
     }
 }
 
-void GameLogo::processArcadeEditionShake() {
-    if (shake_.counter > 0) {
-        shake_.counter--;
-    } else {
-        shake_.counter = shake_.delay;
+void GameLogo::processArcadeEditionShake(float deltaTime) {
+    // Delay fijo en milisegundos (shake_.delay era frames, ahora usamos constante)
+    float delayTime = SHAKE_DELAY_MS;
+    
+    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--;
@@ -221,7 +227,7 @@ auto GameLogo::calculateShakeDisplacement() const -> int {
 
 void GameLogo::finishCoffeeCrisisShaking() {
     coffee_sprite_->setPosX(shake_.origin);
-    crisis_sprite_->setPosX(shake_.origin + 15);
+    crisis_sprite_->setPosX(shake_.origin + CRISIS_OFFSET_X);
     coffee_crisis_status_ = Status::FINISHED;
     arcade_edition_status_ = Status::MOVING;
 }
@@ -240,16 +246,16 @@ void GameLogo::playTitleEffects() {
     Screen::get()->shake();
 }
 
-void GameLogo::updateDustSprites() {
-    dust_right_sprite_->update();
-    dust_left_sprite_->update();
+void GameLogo::updateDustSprites(float deltaTime) {
+    dust_right_sprite_->update(deltaTime);
+    dust_left_sprite_->update(deltaTime);
 }
 
-void GameLogo::updatePostFinishedCounter() {
+void GameLogo::updatePostFinishedCounter(float deltaTime) {
     if (coffee_crisis_status_ == Status::FINISHED &&
-        arcade_edition_status_ == Status::FINISHED &&
-        post_finished_counter_ > 0) {
-        --post_finished_counter_;
+        arcade_edition_status_ == Status::FINISHED) {
+
+        post_finished_timer_ += deltaTime;
     }
 }
 
@@ -261,7 +267,7 @@ void GameLogo::enable() {
 
 // Indica si ha terminado la animación
 auto GameLogo::hasFinished() const -> bool {
-    return post_finished_counter_ == 0;
+    return post_finished_timer_ >= post_finished_delay_ms_;
 }
 
 // Calcula el desplazamiento vertical inicial

source/game_logo.h

@@ -11,14 +11,25 @@ class Texture;
 // --- Clase GameLogo: gestor del logo del juego ---
 class GameLogo {
     public:
+        // --- Constantes ---
+        static constexpr float COFFEE_VEL_Y = 0.15F;         // Velocidad Y de coffee sprite (pixels/ms) - 2.5F/16.67
+        static constexpr float COFFEE_ACCEL_Y = 0.00036F;    // Aceleración Y de coffee sprite (pixels/ms²) - 0.1F/(16.67)²
+        static constexpr float CRISIS_VEL_Y = -0.15F;        // Velocidad Y de crisis sprite (pixels/ms) - -2.5F/16.67
+        static constexpr float CRISIS_ACCEL_Y = -0.00036F;   // Aceleración Y de crisis sprite (pixels/ms²) - -0.1F/(16.67)²
+        static constexpr int CRISIS_OFFSET_X = 15;           // Desplazamiento X de crisis sprite
+        static constexpr int DUST_SIZE = 16;                 // Tamaño de dust sprites
+        static constexpr float ZOOM_DECREMENT_PER_MS = 0.006F; // Decremento de zoom por milisegundo (0.1F/16.67ms)
+        static constexpr float SHAKE_DELAY_MS = 33.34F;        // Delay de shake en milisegundos (2 frames * 16.67ms)
+        static constexpr float POST_FINISHED_FRAME_TIME = 16.67F; // Tiempo entre decrementos del counter (1 frame)
+
         // --- Constructores y destructor ---
         GameLogo(int x, int y);
         ~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(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 +45,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 +68,7 @@ class GameLogo {
                     length = l;
                     remaining = l;
                     counter = de;
+                    time_accumulator = 0.0f;
                     origin = o;
                 }
         };
@@ -74,32 +92,34 @@ 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
+        float post_finished_delay_ms_ = POST_FINISHED_FRAME_TIME;  // Retraso final tras animaciones (ms)
+        float post_finished_timer_ = 0.0f;                     // Timer acumulado para retraso final (ms)
 
         // --- 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(float deltaTime);     // Actualiza el estado de "Coffee Crisis" (time-based)
+        void updateArcadeEdition(float deltaTime);    // Actualiza el estado de "Arcade Edition" (time-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(float deltaTime);     // Maneja el movimiento de "Coffee Crisis" (time-based)
+        void handleCoffeeCrisisShaking(float deltaTime);    // Maneja la sacudida de "Coffee Crisis" (time-based)
+        void handleArcadeEditionMoving(float deltaTime);    // Maneja el movimiento de "Arcade Edition" (time-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(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(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(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

@@ -1,6 +1,7 @@
 #include "item.h"
 
 #include <algorithm>  // Para clamp
+#include <cmath>      // Para fmod
 #include <cstdlib>    // Para rand
 
 #include "animated_sprite.h"  // Para AnimatedSprite
@@ -9,16 +10,18 @@
 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;
             height_ = COFFEE_MACHINE_HEIGHT;
             pos_x_ = getCoffeeMachineSpawn(x, width_, play_area_.w);
             pos_y_ = y;
-            vel_x_ = ((rand() % 3) - 1) * 0.5F;
-            vel_y_ = -0.1F;
-            accel_y_ = 0.1F;
+            vel_x_ = ((rand() % 3) - 1) * COFFEE_MACHINE_VEL_X_FACTOR;
+            vel_y_ = COFFEE_MACHINE_VEL_Y;
+            accel_y_ = COFFEE_MACHINE_ACCEL_Y;
             collider_.r = 10;
             break;
         }
@@ -31,13 +34,13 @@ Item::Item(ItemType type, float x, float y, SDL_FRect &play_area, const std::sha
             const int direction = rand() % 6;
             if (direction < 3) {
                 // Velocidades negativas: -1.0, -0.66, -0.33
-                vel_x_ = -1.0F + (direction * 0.33F);
+                vel_x_ = -ITEM_VEL_X_BASE + (direction * ITEM_VEL_X_STEP);
             } else {
                 // Velocidades positivas: 0.33, 0.66, 1.0
-                vel_x_ = 0.33F + ((direction - 3) * 0.33F);
+                vel_x_ = ITEM_VEL_X_STEP + ((direction - 3) * ITEM_VEL_X_STEP);
             }
-            vel_y_ = -4.0F;
-            accel_y_ = 0.2F;
+            vel_y_ = ITEM_VEL_Y;
+            accel_y_ = ITEM_ACCEL_Y;
             collider_.r = width_ / 2;
             break;
         }
@@ -64,24 +67,34 @@ void Item::alignTo(int x) {
 
 void Item::render() {
     if (enabled_) {
-        if (time_to_live_ > 200) {
-            sprite_->render();
-        } else if (time_to_live_ % 20 > 10) {
+        // Muestra normalmente hasta los últimos ~3.3 segundos (200 frames)
+        constexpr float BLINK_START_MS = LIFETIME_DURATION_MS - (200.0f * (1000.0f / 60.0f));
+
+        if (lifetime_timer_ < BLINK_START_MS) {
             sprite_->render();
+        } else {
+            // Efecto de parpadeo en los últimos segundos (cada ~333ms o 20 frames)
+            constexpr float BLINK_INTERVAL_MS = 20.0f * (1000.0f / 60.0f);
+            const float phase = fmod(lifetime_timer_, BLINK_INTERVAL_MS);
+            const float half_interval = BLINK_INTERVAL_MS / 2.0f;
+
+            if (phase < half_interval) {
+                sprite_->render();
+            }
         }
     }
 }
 
-void Item::move() {
+void Item::move(float deltaTime) {
     floor_collision_ = false;
 
-    // Calcula la nueva posición
-    pos_x_ += vel_x_;
-    pos_y_ += vel_y_;
+    // Calcula la nueva posición usando deltaTime puro (velocidad en pixels/ms)
+    pos_x_ += vel_x_ * deltaTime;
+    pos_y_ += vel_y_ * deltaTime;
 
-    // Aplica las aceleraciones a la velocidad
-    vel_x_ += accel_x_;
-    vel_y_ += accel_y_;
+    // Aplica las aceleraciones a la velocidad usando deltaTime puro (aceleración en pixels/ms²)
+    vel_x_ += accel_x_ * deltaTime;
+    vel_y_ += accel_y_ * deltaTime;
 
     // Comprueba los laterales de la zona de juego
     const float MIN_X = param.game.play_area.rect.x;
@@ -90,7 +103,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é)
@@ -111,24 +124,24 @@ void Item::move() {
             case ItemType::COFFEE_MACHINE:
                 // La máquina de café es mas pesada y tiene una fisica diferente, ademas hace ruido
                 floor_collision_ = true;
-                if (vel_y_ < 1.0F) {
+                if (std::abs(vel_y_) < BOUNCE_VEL_THRESHOLD) {
                     // Si la velocidad vertical es baja, detiene el objeto
                     vel_y_ = vel_x_ = accel_x_ = accel_y_ = 0;
                 } else {
                     // Si la velocidad vertical es alta, el objeto rebota y pierde velocidad
-                    vel_y_ *= -0.20F;
-                    vel_x_ *= 0.75F;
+                    vel_y_ *= COFFEE_BOUNCE_DAMPING;
+                    vel_x_ *= HORIZONTAL_DAMPING;
                 }
                 break;
             default:
                 // Si no es una máquina de café
-                if (vel_y_ < 1.0F) {
+                if (std::abs(vel_y_) < BOUNCE_VEL_THRESHOLD) {
                     // Si la velocidad vertical es baja, detiene el objeto
                     vel_y_ = vel_x_ = accel_x_ = accel_y_ = 0;
                 } else {
                     // Si la velocidad vertical es alta, el objeto rebota y pierde velocidad
-                    vel_y_ *= -0.5F;
-                    vel_x_ *= 0.75F;
+                    vel_y_ *= ITEM_BOUNCE_DAMPING;
+                    vel_x_ *= HORIZONTAL_DAMPING;
                 }
                 break;
         }
@@ -141,16 +154,15 @@ void Item::move() {
 
 void Item::disable() { enabled_ = false; }
 
-void Item::update() {
-    move();
-    sprite_->update();
-    updateTimeToLive();
+void Item::update(float deltaTime) {
+    move(deltaTime);
+    sprite_->update(deltaTime);
+    updateTimeToLive(deltaTime);
 }
 
-void Item::updateTimeToLive() {
-    if (time_to_live_ > 0) {
-        time_to_live_--;
-    } else {
+void Item::updateTimeToLive(float deltaTime) {
+    lifetime_timer_ += deltaTime;
+    if (lifetime_timer_ >= LIFETIME_DURATION_MS) {
         disable();
     }
 }

source/item.h

@@ -29,16 +29,34 @@ class Item {
         // --- Constantes ---
         static constexpr int COFFEE_MACHINE_WIDTH = 30;   // Anchura de la máquina de café
         static constexpr int COFFEE_MACHINE_HEIGHT = 39;  // Altura de la máquina de café
+        static constexpr float LIFETIME_DURATION_MS = 10000.0f;  // Duración de vida del ítem (600 frames a 60fps)
+
+        // Velocidades base (pixels/ms) - Coffee Machine
+        static constexpr float COFFEE_MACHINE_VEL_X_FACTOR = 0.03F;  // Factor para velocidad X de máquina de café
+        static constexpr float COFFEE_MACHINE_VEL_Y = -0.006F;       // Velocidad Y inicial de máquina de café
+        static constexpr float COFFEE_MACHINE_ACCEL_Y = 0.00036F;    // Aceleración Y de máquina de café (pixels/ms²)
+
+        // Velocidades base (pixels/ms) - Items normales (del plan: vel_x: ±1.0F→±0.06F, vel_y: -4.0F→-0.24F, accel_y: 0.2F→0.012F)
+        static constexpr float ITEM_VEL_X_BASE = 0.06F;     // Velocidad X base para items (1.0F/16.67)
+        static constexpr float ITEM_VEL_X_STEP = 0.02F;     // Incremento de velocidad X (0.33F/16.67)
+        static constexpr float ITEM_VEL_Y = -0.24F;         // Velocidad Y inicial de items (-4.0F/16.67)
+        static constexpr float ITEM_ACCEL_Y = 0.00072F;     // Aceleración Y de items (pixels/ms²) - 0.2F * (60/1000)²
+
+        // Constantes de física de rebote
+        static constexpr float BOUNCE_VEL_THRESHOLD = 0.06F;    // Umbral de velocidad para parar (1.0F/16.67)
+        static constexpr float COFFEE_BOUNCE_DAMPING = -0.20F;  // Factor de rebote Y para máquina de café
+        static constexpr float ITEM_BOUNCE_DAMPING = -0.5F;     // Factor de rebote Y para items normales
+        static constexpr float HORIZONTAL_DAMPING = 0.75F;      // Factor de amortiguación horizontal
 
         // --- Constructor y destructor ---
         Item(ItemType type, float x, float y, SDL_FRect &play_area, const std::shared_ptr<Texture> &texture, const std::vector<std::string> &animation);  // Constructor principal
         ~Item() = default;                                                                                                                                // Destructor
 
         // --- Métodos principales ---
-        void alignTo(int x);  // Centra el objeto en la posición X indicada
-        void render();        // Renderiza el objeto en pantalla
-        void disable();       // Desactiva el objeto
-        void update();        // Actualiza la posición, animación y contadores
+        void alignTo(int x);            // Centra el objeto en la posición X indicada
+        void render();                  // Renderiza el objeto en pantalla
+        void disable();                 // Desactiva el objeto
+        void update(float deltaTime);   // Actualiza la posición, animación y contadores (time-based)
 
         // --- Getters ---
         [[nodiscard]] auto getPosX() const -> float { return pos_x_; }             // Obtiene la posición X
@@ -66,14 +84,14 @@ class Item {
         float accel_y_;                 // Aceleración en el eje Y
         int width_;                     // Ancho del objeto
         int height_;                    // Alto del objeto
-        Uint16 time_to_live_ = 600;     // Tiempo que el objeto está presente
+        float lifetime_timer_ = 0.0f;     // Acumulador de tiempo de vida del ítem (milisegundos)
         bool floor_collision_ = false;  // Indica si el objeto colisiona con el suelo
         bool enabled_ = true;           // Indica si el objeto está habilitado
 
         // --- Métodos internos ---
         void shiftColliders();                                                                                   // Alinea el círculo de colisión con la posición del objeto
         void shiftSprite();                                                                                      // Coloca el sprite en la posición del objeto
-        void move();                                                                                             // Actualiza la posición y estados del objeto
-        void updateTimeToLive();                                                                                 // Actualiza el contador de tiempo de vida
+        void move(float deltaTime);                                                                              // Actualiza la posición y estados del objeto (time-based)
+        void updateTimeToLive(float deltaTime);                                                                 // Actualiza el contador de tiempo de vida (time-based)
         static auto getCoffeeMachineSpawn(int player_x, int item_width, int area_width, int margin = 2) -> int;  // Calcula la zona de aparición de 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,42 +53,41 @@ void MovingSprite::stop() {
     flip_ = SDL_FLIP_NONE;  // Establece como se ha de voltear el sprite
 }
 
-// Mueve el sprite
-void MovingSprite::move() {
-    x_ += vx_;
-    y_ += vy_;
+// Mueve el sprite (time-based)
+void MovingSprite::move(float deltaTime) {
+    // DeltaTime puro: velocidad (pixels/ms) * tiempo (ms)
+    x_ += vx_ * deltaTime;
+    y_ += vy_ * deltaTime;
 
-    vx_ += ax_;
-    vy_ += ay_;
+    // Aceleración (pixels/ms²) * tiempo (ms)
+    vx_ += ax_ * deltaTime;
+    vy_ += ay_ * deltaTime;
 
     pos_.x = static_cast<int>(x_);
     pos_.y = static_cast<int>(y_);
 }
 
-// Actualiza las variables internas del objeto
-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_); }
+void MovingSprite::render() { 
+    getTexture()->render(pos_.x, pos_.y, &sprite_clip_, horizontal_zoom_, vertical_zoom_, rotate_.angle, &rotate_.center, flip_);
+}
 
-// Establece la rotacion
-void MovingSprite::rotate() {
+// Establece la rotacion (time-based)
+void MovingSprite::rotate(float deltaTime) {
     if (rotate_.enabled) {
-        ++rotate_.counter;
-        if (rotate_.counter % rotate_.speed == 0) {
-            updateAngle();
-            rotate_.counter = 0;
-        }
+        rotate_.angle += rotate_.amount * deltaTime;
     }
 }
 
 // Activa o desactiva el efecto de rotación
 void MovingSprite::setRotate(bool enable) {
     rotate_.enabled = enable;
-    rotate_.counter = 0;
 }
 
 // Establece la posición y_ el tamaño del objeto

source/moving_sprite.h

@@ -15,7 +15,6 @@ class MovingSprite : public Sprite {
         // --- Estructuras ---
         struct Rotate {
                 bool enabled{false};                      // Indica si ha de rotar
-                int counter{0};                           // Contador
                 int speed{1};                             // Velocidad de giro
                 double angle{0.0};                        // Ángulo para dibujarlo
                 float amount{0.0F};                       // Cantidad de grados a girar en cada iteración
@@ -29,10 +28,10 @@ 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(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 +78,6 @@ 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(float deltaTime);                              // Mueve el sprite según velocidad y aceleración (time-based)
+        void rotate(float deltaTime);                            // Rota el sprite según los parámetros de rotación (time-based)
 };

source/param.cpp

@@ -106,7 +106,6 @@ auto setParams(const std::string& var, const std::string& value) -> bool {
         {"scoreboard.rect.h", [](const std::string& v) { param.scoreboard.rect.h = std::stoi(v); }},
         {"scoreboard.skip_countdown_value", [](const std::string& v) { param.scoreboard.skip_countdown_value = std::stoi(v); }},
         {"title.press_start_position", [](const std::string& v) { param.title.press_start_position = std::stoi(v); }},
-        {"title.title_duration", [](const std::string& v) { param.title.title_duration = std::stoi(v); }},
         {"title.arcade_edition_position", [](const std::string& v) { param.title.arcade_edition_position = std::stoi(v); }},
         {"title.title_c_c_position", [](const std::string& v) { param.title.title_c_c_position = std::stoi(v); }},
         {"intro.text_distance_from_bottom", [](const std::string& v) { param.intro.text_distance_from_bottom = std::stoi(v); }}};
@@ -182,6 +181,7 @@ auto setParams(const std::string& var, const std::string& value) -> bool {
         {"balloon.settings[3].grav", [](const std::string& v) { param.balloon.settings.at(3).grav = std::stof(v); }},
         {"tabe.min_spawn_time", [](const std::string& v) { param.tabe.min_spawn_time = std::stof(v); }},
         {"tabe.max_spawn_time", [](const std::string& v) { param.tabe.max_spawn_time = std::stof(v); }},
+        {"title.title_duration", [](const std::string& v) { param.title.title_duration = std::stof(v); }},
         {"service_menu.window_message.padding", [](const std::string& v) { param.service_menu.window_message.padding = std::stof(v); }},
         {"service_menu.window_message.line_spacing", [](const std::string& v) { param.service_menu.window_message.line_spacing = std::stof(v); }},
         {"service_menu.window_message.title_separator_spacing", [](const std::string& v) { param.service_menu.window_message.title_separator_spacing = std::stof(v); }},
@@ -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

@@ -38,7 +38,7 @@ struct ParamFade {
 // --- Parámetros de la pantalla de título ---
 struct ParamTitle {
         int press_start_position = GameDefaults::Title::PRESS_START_POSITION;
-        int title_duration = GameDefaults::Title::DURATION;
+        float title_duration = GameDefaults::Title::DURATION;
         int arcade_edition_position = GameDefaults::Title::ARCADE_EDITION_POSITION;
         int title_c_c_position = GameDefaults::Title::TITLE_C_C_POSITION;
         Color bg_color = Color::fromHex(GameDefaults::Title::BG_COLOR);
@@ -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,12 @@
 #include <functional>  // Para function
 #include <utility>     // Para move
 
+// Constructor para paths por puntos (convertido a segundos)
+Path::Path(const std::vector<SDL_FPoint> &spots_init, float waiting_time_s_init)
+    : spots(spots_init), is_point_path(true) {
+    waiting_time_s = waiting_time_s_init;
+}
+
 // 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;
@@ -33,9 +39,9 @@ auto createPath(float start, float end, PathType type, float fixed_pos, int step
 }
 
 // Actualiza la posición y comprueba si ha llegado a su destino
-void PathSprite::update() {
+void PathSprite::update(float delta_time) {
     if (enabled_ && !has_finished_) {
-        moveThroughCurrentPath();
+        moveThroughCurrentPath(delta_time);
         goToNextPathOrDie();
     }
 }
@@ -77,14 +83,14 @@ 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);
+// Añade un recorrido generado (en segundos)
+void PathSprite::addPath(float start, float end, PathType type, float fixed_pos, float duration_s, const std::function<double(double)> &easing_function, float waiting_time_s) {
+    paths_.emplace_back(start, end, type, fixed_pos, duration_s, waiting_time_s, easing_function);
 }
 
-// Añade un recorrido
-void PathSprite::addPath(const std::vector<SDL_FPoint> &spots, int waiting_counter) {
-    paths_.emplace_back(spots, waiting_counter);
+// Añade un recorrido por puntos (en segundos)
+void PathSprite::addPath(const std::vector<SDL_FPoint> &spots, float waiting_time_s) {
+    paths_.emplace_back(spots, waiting_time_s);
 }
 
 // Habilita el objeto
@@ -95,35 +101,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_s) {
+                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_s;
+            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_s) {
+                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_s;                                        // Duración de la animación en segundos
+        float waiting_time_s;                                    // 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_s(duration), waiting_time_s(waiting), easing_function(std::move(easing)) {}
+
+        // Constructor para paths por puntos (convertido a segundos)
+        Path(const std::vector<SDL_FPoint> &spots_init, float waiting_time_s_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,13 +63,13 @@ class PathSprite : public Sprite {
         ~PathSprite() override = default;
 
         // --- Métodos principales ---
-        void update();           // Actualiza la posición del sprite según el recorrido
+        void update(float delta_time);           // Actualiza la posición del sprite según el recorrido (delta_time en segundos)
         void render() override;  // Muestra el sprite por pantalla
 
         // --- Gestión de recorridos ---
         void addPath(Path path, bool centered = false);                                                                                                            // Añade un recorrido (Path)
-        void addPath(const std::vector<SDL_FPoint> &spots, int waiting_counter = 0);                                                                               // Añade un recorrido a partir de puntos
-        void addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easing_function, int waiting_counter = 0);  // Añade un recorrido generado
+        void addPath(const std::vector<SDL_FPoint> &spots, float waiting_time_s = 0.0f);                                                                        // Añade un recorrido a partir de puntos
+        void addPath(float start, float end, PathType type, float fixed_pos, float duration_s, const std::function<double(double)> &easing_function, float waiting_time_s = 0.0f);  // Añade un recorrido generado
 
         // --- Estado y control ---
         void enable();                                   // Habilita el objeto
@@ -71,6 +86,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));
@@ -49,17 +60,14 @@ void Player::init() {
     power_up_counter_ = POWERUP_COUNTER;
     extra_hit_ = false;
     coffees_ = 0;
-    continue_ticks_ = 0;
     continue_counter_ = 10;
-    name_entry_ticks_ = 0;
-    name_entry_idle_counter_ = 0;
-    name_entry_total_counter_ = 0;
+    name_entry_idle_time_accumulator_ = 0.0f;
+    name_entry_total_time_accumulator_ = 0.0f;
     shiftColliders();
     vel_x_ = 0;
     vel_y_ = 0;
     score_ = 0;
     score_multiplier_ = 1.0F;
-    cant_fire_counter_ = 10;
     enter_name_->init(last_enter_name_);
 
     // Establece la posición del sprite
@@ -138,38 +146,38 @@ void Player::setInputEnteringName(Input::Action action) {
         default:
             break;
     }
-    name_entry_idle_counter_ = 0;
+    name_entry_idle_time_accumulator_ = 0.0f;
 }
 
-// Mueve el jugador a la posición y animación que le corresponde
-void Player::move() {
+// Fase 1: Sistema de movimiento time-based
+void Player::move(float deltaTime) {
     switch (playing_state_) {
         case State::PLAYING:
-            handlePlayingMovement();
+            handlePlayingMovement(deltaTime);
             break;
         case State::ROLLING:
-            handleRollingMovement();
+            handleRollingMovement();  
             break;
         case State::TITLE_ANIMATION:
-            handleTitleAnimation();
+            handleTitleAnimation();   
             break;
         case State::CONTINUE_TIME_OUT:
-            handleContinueTimeOut();
+            handleContinueTimeOut();  
             break;
         case State::LEAVING_SCREEN:
-            handleLeavingScreen();
+            handleLeavingScreen();    
             break;
         case State::ENTERING_SCREEN:
-            handleEnteringScreen();
+            handleEnteringScreen();   
             break;
         case State::CREDITS:
-            handleCreditsMovement();
+            handleCreditsMovement(deltaTime);  
             break;
         case State::WAITING:
-            handleWaitingMovement();
+            handleWaitingMovement(deltaTime);  
             break;
         case State::RECOVER:
-            handleRecoverMovement();
+            handleRecoverMovement();  
             break;
         default:
             break;
@@ -188,6 +196,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 +348,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 +384,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,11 +422,35 @@ 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()) {
-        if (power_up_counter_ > (POWERUP_COUNTER / 4) || power_up_counter_ % 20 > 4) {
+        // Convertir lógica de parpadeo a deltaTime
+        float total_powerup_time_ms = static_cast<float>(POWERUP_COUNTER) / 60.0f * 1000.0f; // Total time in ms
+        float quarter_time_ms = total_powerup_time_ms / 4.0f; // 25% del tiempo total
+
+        if (power_up_time_accumulator_ > quarter_time_ms) {
+            // En los primeros 75% del tiempo, siempre visible
             power_sprite_->render();
+        } else {
+            // En el último 25%, parpadea cada 20 frames (333ms aprox)
+            constexpr float blink_period_ms = 20.0f / 60.0f * 1000.0f; // 20 frames in ms
+            constexpr float visible_proportion = 4.0f / 20.0f; // 4 frames visible de 20 total
+
+            float cycle_position = fmod(power_up_time_accumulator_, blink_period_ms) / blink_period_ms;
+            if (cycle_position >= visible_proportion) {
+                power_sprite_->render();
+            }
         }
     }
 
@@ -444,8 +513,8 @@ auto Player::computeAnimation() const -> std::pair<std::string, SDL_FlipMode> {
     return {anim_name, flip_mode};
 }
 
-// Establece la animación correspondiente al estado
-void Player::setAnimation() {
+// 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:
@@ -481,110 +550,33 @@ void Player::setAnimation() {
             break;
     }
 
-    player_sprite_->update();
-    power_sprite_->update();
+    // La diferencia clave: usa deltaTime para las animaciones
+    player_sprite_->update(deltaTime);
+    power_sprite_->update(deltaTime);
 }
 
-// Actualiza el valor de la variable
-void Player::updateCooldown() {
-    if (playing_state_ != State::PLAYING) {
-        return;
-    }
+// Actualiza al jugador con deltaTime (time-based)
+void Player::update(float deltaTime) {
+    move(deltaTime);                        // Sistema de movimiento time-based
+    setAnimation(deltaTime);                // Animaciones time-based
+    shiftColliders();                       // Sin cambios (posicional)
+    updateFireSystem(deltaTime);            // Sistema de disparo de dos líneas
+    updatePowerUp(deltaTime);               // Sistema de power-up time-based
+    updateInvulnerable(deltaTime);          // Sistema de invulnerabilidad time-based
+    updateScoreboard();                     // Sin cambios (no temporal)
+    updateContinueCounter(deltaTime);       // Sistema de continue time-based
+    updateEnterNameCounter(deltaTime);      // Sistema de name entry time-based
+    updateShowingName(deltaTime);           // Sistema de showing name time-based
+}
 
-    if (cant_fire_counter_ > 0) {
-        handleFiringCooldown();
+void Player::passShowingName() {
+    if (game_completed_) {
+        setPlayingState(State::LEAVING_SCREEN);
     } else {
-        handleRecoilAndCooling();
+        setPlayingState(State::CONTINUE);
     }
 }
 
-void Player::handleFiringCooldown() {
-    cooling_state_counter_ = COOLING_DURATION;
-
-    // Transition to recoiling state at halfway point
-    if (cant_fire_counter_ == recoiling_state_duration_ / 2) {
-        transitionToRecoiling();
-    }
-
-    --cant_fire_counter_;
-    if (cant_fire_counter_ == 0) {
-        recoiling_state_counter_ = recoiling_state_duration_;
-    }
-}
-
-void Player::handleRecoilAndCooling() {
-    if (recoiling_state_counter_ > 0) {
-        --recoiling_state_counter_;
-        return;
-    }
-
-    handleCoolingState();
-}
-
-void Player::handleCoolingState() {
-    if (cooling_state_counter_ > COOLING_COMPLETE) {
-        if (cooling_state_counter_ == COOLING_DURATION) {
-            transitionToCooling();
-        }
-        --cooling_state_counter_;
-    }
-
-    if (cooling_state_counter_ == COOLING_COMPLETE) {
-        completeCooling();
-    }
-}
-
-void Player::transitionToRecoiling() {
-    switch (firing_state_) {
-        case State::FIRING_LEFT:
-            setFiringState(State::RECOILING_LEFT);
-            break;
-        case State::FIRING_RIGHT:
-            setFiringState(State::RECOILING_RIGHT);
-            break;
-        case State::FIRING_UP:
-            setFiringState(State::RECOILING_UP);
-            break;
-        default:
-            break;
-    }
-}
-
-void Player::transitionToCooling() {
-    switch (firing_state_) {
-        case State::RECOILING_LEFT:
-            setFiringState(State::COOLING_LEFT);
-            break;
-        case State::RECOILING_RIGHT:
-            setFiringState(State::COOLING_RIGHT);
-            break;
-        case State::RECOILING_UP:
-            setFiringState(State::COOLING_UP);
-            break;
-        default:
-            break;
-    }
-}
-
-void Player::completeCooling() {
-    setFiringState(State::FIRING_NONE);
-    cooling_state_counter_ = -1;
-}
-
-// Actualiza al jugador a su posicion, animación y controla los contadores
-void Player::update() {
-    move();
-    setAnimation();
-    shiftColliders();
-    updateCooldown();
-    updatePowerUp();
-    updateInvulnerable();
-    updateScoreboard();
-    updateContinueCounter();
-    updateEnterNameCounter();
-    updateShowingName();
-}
-
 // Incrementa la puntuación del jugador
 void Player::addScore(int score, int lowest_hi_score_entry) {
     if (isPlaying()) {
@@ -624,6 +616,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: {
@@ -641,8 +636,8 @@ void Player::setPlayingState(State state) {
         }
         case State::CONTINUE: {
             // 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 +656,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();
@@ -672,7 +668,7 @@ void Player::setPlayingState(State state) {
             break;
         }
         case State::SHOWING_NAME: {
-            showing_name_ticks_ = SDL_GetTicks();
+            showing_name_time_accumulator_ = 0.0f;  // Inicializar acumulador time-based
             setScoreboardMode(Scoreboard::Mode::SHOW_NAME);
             Scoreboard::get()->setRecordName(scoreboard_panel_, last_enter_name_);
             addScoreToScoreBoard();
@@ -728,12 +724,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,32 +772,35 @@ 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 * 1000.0f : 0.0f; // Convert frames to milliseconds
 }
 
-// Monitoriza el estado
-void Player::updateInvulnerable() {
+// Monitoriza el estado (time-based)
+void Player::updateInvulnerable(float deltaTime) {
     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);  
-            
-            // Alterna entre texturas con proporción variable
-            bool should_show_invulnerable = (invulnerable_counter_ % blink_speed) < white_frames;
+        if (invulnerable_time_accumulator_ > 0) {
+            invulnerable_time_accumulator_ -= deltaTime;
+
+            // Frecuencia fija de parpadeo adaptada a deltaTime (en milisegundos)
+            constexpr float blink_period_ms = 8.0f / 60.0f * 1000.0f; // 8 frames convertidos a ms
+
+            // Calcula proporción decreciente basada en tiempo restante
+            float total_invulnerable_time_ms = static_cast<float>(INVULNERABLE_COUNTER) / 60.0f * 1000.0f;
+            float progress = 1.0f - (invulnerable_time_accumulator_ / total_invulnerable_time_ms);
+            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_ms) / blink_period_ms;
+            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_);
         }
@@ -810,14 +811,18 @@ void Player::updateInvulnerable() {
 void Player::setPowerUp() {
     power_up_ = true;
     power_up_counter_ = POWERUP_COUNTER;
+    power_up_time_accumulator_ = static_cast<float>(POWERUP_COUNTER) / 60.0f * 1000.0f; // Convert frames to milliseconds
 }
 
-// Actualiza el valor de la variable
-void Player::updatePowerUp() {
+// Actualiza el valor de la variable (time-based)
+void Player::updatePowerUp(float deltaTime) {
     if (playing_state_ == State::PLAYING) {
         if (power_up_) {
-            --power_up_counter_;
-            power_up_ = power_up_counter_ > 0;
+            power_up_time_accumulator_ -= deltaTime;
+            power_up_ = power_up_time_accumulator_ > 0;
+            if (!power_up_) {
+                power_up_time_accumulator_ = 0;
+            }
         }
     }
 }
@@ -854,31 +859,36 @@ void Player::setPlayerTextures(const std::vector<std::shared_ptr<Texture>> &text
     power_sprite_->setTexture(texture[1]);
 }
 
-// Actualiza el contador de continue
-void Player::updateContinueCounter() {
+// Actualiza el contador de continue (time-based)
+void Player::updateContinueCounter(float deltaTime) {
     if (playing_state_ == State::CONTINUE) {
-        constexpr int TICKS_SPEED = 1000;
-        if (SDL_GetTicks() - continue_ticks_ > TICKS_SPEED) {
+        continue_time_accumulator_ += deltaTime;
+        constexpr float CONTINUE_INTERVAL = 1000.0f; // 1 segundo en milisegundos
+        if (continue_time_accumulator_ >= CONTINUE_INTERVAL) {
+            continue_time_accumulator_ -= CONTINUE_INTERVAL;
             decContinueCounter();
         }
     }
 }
 
-// Actualiza el contador de entrar nombre
-void Player::updateEnterNameCounter() {
+// 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) {
-        constexpr int TICKS_SPEED = 1000;
-        if (SDL_GetTicks() - name_entry_ticks_ > TICKS_SPEED) {
+        name_entry_time_accumulator_ += deltaTime;
+        constexpr float NAME_ENTRY_INTERVAL = 1000.0f; // 1 segundo en milisegundos
+        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() {
+// Actualiza el estado de SHOWING_NAME (time-based)
+void Player::updateShowingName(float deltaTime) {
     if (playing_state_ == State::SHOWING_NAME) {
-        constexpr int TICKS_SPEED = 5000;
-        if (SDL_GetTicks() - name_entry_ticks_ > TICKS_SPEED) {
+        showing_name_time_accumulator_ += deltaTime;
+        constexpr float SHOWING_NAME_DURATION = 5000.0f; // 5 segundos en milisegundos
+        if (showing_name_time_accumulator_ >= SHOWING_NAME_DURATION) {
             game_completed_ ? setPlayingState(State::LEAVING_SCREEN) : setPlayingState(State::CONTINUE);
         }
     }
@@ -886,7 +896,7 @@ void Player::updateShowingName() {
 
 // Decrementa el contador de continuar
 void Player::decContinueCounter() {
-    continue_ticks_ = SDL_GetTicks();
+    continue_time_accumulator_ = 0.0f; // Reset time accumulator
     --continue_counter_;
     if (continue_counter_ < 0) {
         setPlayingState(State::CONTINUE_TIME_OUT);
@@ -897,17 +907,17 @@ 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_;
-    ++name_entry_total_counter_;
+    // Incrementa acumuladores de tiempo (1 segundo = 1000ms)
+    name_entry_idle_time_accumulator_ += 1000.0f;
+    name_entry_total_time_accumulator_ += 1000.0f;
 
-    // Comprueba los contadores
-    if ((name_entry_total_counter_ >= param.game.name_entry_total_time) ||
-        (name_entry_idle_counter_ >= param.game.name_entry_idle_time)) {
-        name_entry_total_counter_ = 0;
-        name_entry_idle_counter_ = 0;
+    // Comprueba los acumuladores directamente contra los límites en milisegundos
+    if ((name_entry_total_time_accumulator_ >= param.game.name_entry_total_time) ||
+        (name_entry_idle_time_accumulator_ >= param.game.name_entry_idle_time)) {
+        name_entry_total_time_accumulator_ = 0.0f;
+        name_entry_idle_time_accumulator_ = 0.0f;
         if (playing_state_ == State::ENTERING_NAME) {
             last_enter_name_ = getRecordName();
             setPlayingState(State::SHOWING_NAME);
@@ -967,4 +977,145 @@ void Player::addScoreToScoreBoard() const {
 void Player::addCredit() {
     ++credits_used_;
     playSound("credit.wav");
+}
+
+// ========================================
+// SISTEMA DE DISPARO DE DOS LÍNEAS
+// ========================================
+
+// Método principal del sistema de disparo
+void Player::updateFireSystem(float deltaTime) {
+    updateFunctionalLine(deltaTime);  // Línea 1: CanFire
+    updateVisualLine(deltaTime);      // Línea 2: Animaciones
+}
+
+// LÍNEA 1: Sistema Funcional (CanFire)
+void Player::updateFunctionalLine(float deltaTime) {
+    if (fire_cooldown_timer_ > 0) {
+        fire_cooldown_timer_ -= deltaTime;
+        can_fire_new_system_ = false;
+    } else {
+        fire_cooldown_timer_ = 0;  // Evitar valores negativos
+        can_fire_new_system_ = true;
+    }
+}
+
+// LÍNEA 2: Sistema Visual (Animaciones)
+void Player::updateVisualLine(float deltaTime) {
+    if (visual_fire_state_ == VisualFireState::NORMAL) {
+        return;  // No hay temporizador activo en estado NORMAL
+    }
+
+    visual_state_timer_ -= deltaTime;
+
+    switch (visual_fire_state_) {
+        case VisualFireState::AIMING:
+            if (visual_state_timer_ <= 0) {
+                transitionToRecoilingNew();
+            }
+            break;
+
+        case VisualFireState::RECOILING:
+            if (visual_state_timer_ <= 0) {
+                transitionToThreatPose();
+            }
+            break;
+
+        case VisualFireState::THREAT_POSE:
+            if (visual_state_timer_ <= 0) {
+                transitionToNormalNew();
+            }
+            break;
+
+        case VisualFireState::NORMAL:
+            // Ya manejado arriba
+            break;
+    }
+}
+
+// Inicia un disparo en ambas líneas
+void Player::startFiringSystem(int cooldown_frames) {
+    // LÍNEA 1: Inicia cooldown funcional
+    fire_cooldown_timer_ = static_cast<float>(cooldown_frames) / 60.0f * 1000.0f;  // Convertir frames a ms
+    can_fire_new_system_ = false;
+
+    // LÍNEA 2: Resetea completamente el estado visual
+    aiming_duration_ = fire_cooldown_timer_ * AIMING_DURATION_FACTOR;        // 50% del cooldown
+    recoiling_duration_ = aiming_duration_ * RECOILING_DURATION_MULTIPLIER;  // 4 veces la duración de aiming
+
+    visual_fire_state_ = VisualFireState::AIMING;
+    visual_state_timer_ = aiming_duration_;
+
+    updateFiringStateFromVisual(); // Sincroniza firing_state_ para animaciones
+}
+
+// Sincroniza firing_state_ con visual_fire_state_
+void Player::updateFiringStateFromVisual() {
+    // Mantener la dirección actual del disparo
+    State base_state = State::FIRING_NONE;
+
+    if (firing_state_ == State::FIRING_LEFT || firing_state_ == State::RECOILING_LEFT || firing_state_ == State::COOLING_LEFT) {
+        base_state = State::FIRING_LEFT;
+    } else if (firing_state_ == State::FIRING_RIGHT || firing_state_ == State::RECOILING_RIGHT || firing_state_ == State::COOLING_RIGHT) {
+        base_state = State::FIRING_RIGHT;
+    } else if (firing_state_ == State::FIRING_UP || firing_state_ == State::RECOILING_UP || firing_state_ == State::COOLING_UP) {
+        base_state = State::FIRING_UP;
+    }
+
+    switch (visual_fire_state_) {
+        case VisualFireState::NORMAL:
+            firing_state_ = State::FIRING_NONE;
+            break;
+
+        case VisualFireState::AIMING:
+            firing_state_ = base_state;  // FIRING_LEFT/RIGHT/UP
+            break;
+
+        case VisualFireState::RECOILING:
+            switch (base_state) {
+                case State::FIRING_LEFT: firing_state_ = State::RECOILING_LEFT; break;
+                case State::FIRING_RIGHT: firing_state_ = State::RECOILING_RIGHT; break;
+                case State::FIRING_UP: firing_state_ = State::RECOILING_UP; break;
+                default: firing_state_ = State::RECOILING_UP; break;
+            }
+            break;
+
+        case VisualFireState::THREAT_POSE:
+            switch (base_state) {
+                case State::FIRING_LEFT: firing_state_ = State::COOLING_LEFT; break;
+                case State::FIRING_RIGHT: firing_state_ = State::COOLING_RIGHT; break;
+                case State::FIRING_UP: firing_state_ = State::COOLING_UP; break;
+                default: firing_state_ = State::COOLING_UP; break;
+            }
+            break;
+    }
+}
+
+// Transiciones del sistema visual
+void Player::transitionToRecoilingNew() {
+    visual_fire_state_ = VisualFireState::RECOILING;
+    visual_state_timer_ = recoiling_duration_;
+    updateFiringStateFromVisual();
+}
+
+void Player::transitionToThreatPose() {
+    visual_fire_state_ = VisualFireState::THREAT_POSE;
+
+    // Calcular threat_pose_duration ajustada:
+    // Duración original (833ms) menos el tiempo extra que ahora dura recoiling
+    float original_recoiling_duration = fire_cooldown_timer_;                           // Era 100% del cooldown
+    float new_recoiling_duration = aiming_duration_ * RECOILING_DURATION_MULTIPLIER;    // Ahora es más del cooldown
+    float extra_recoiling_time = new_recoiling_duration - original_recoiling_duration;
+    float adjusted_threat_duration = THREAT_POSE_DURATION - extra_recoiling_time;
+
+    // Asegurar que no sea negativo
+    visual_state_timer_ = std::max(adjusted_threat_duration, MIN_THREAT_POSE_DURATION);
+
+    updateFiringStateFromVisual();
+}
+
+void Player::transitionToNormalNew() {
+    visual_fire_state_ = VisualFireState::NORMAL;
+    visual_state_timer_ = 0;
+    updateFiringStateFromVisual();
 }

source/player.h

@@ -17,7 +17,21 @@
 
 class Texture;
 
-// --- Clase Player ---
+// --- Clase Player: jugador principal del juego ---
+//
+// Esta clase gestiona todos los aspectos de un jugador durante el juego,
+// incluyendo movimiento, disparos, animaciones y estados especiales.
+//
+// Funcionalidades principales:
+// • Sistema de disparo de dos líneas: funcional (cooldown) + visual (animaciones)
+// • Estados de animación: normal → aiming → recoiling → threat_pose → normal
+// • Movimiento time-based: compatibilidad con deltaTime para fluidez variable
+// • Power-ups e invulnerabilidad: coffee machine, extra hits, parpadeos
+// • Sistema de puntuación: multipliers, high scores, entrada de nombres
+// • Estados de juego: playing, rolling, continue, entering_name, etc.
+//
+// El sistema de disparo utiliza duraciones configurables mediante constantes
+// para facilitar el ajuste del gameplay y la sensación de disparo.
 class Player {
     public:
         // --- Constantes ---
@@ -94,9 +108,9 @@ 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(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 +118,13 @@ 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(float deltaTime);         // Mueve el jugador (time-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
 
         // --- Puntuación y marcador ---
         void addScore(int score, int lowest_hi_score_entry);  // Añade puntos
@@ -122,7 +135,7 @@ 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(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
@@ -145,7 +158,7 @@ class Player {
         [[nodiscard]] auto isTitleHidden() const -> bool { return playing_state_ == State::TITLE_HIDDEN; }
 
         // Getters
-        [[nodiscard]] auto canFire() const -> bool { return cant_fire_counter_ <= 0; }
+        [[nodiscard]] auto canFire() const -> bool { return can_fire_new_system_; }  // Usa nuevo sistema
         [[nodiscard]] auto hasExtraHit() const -> bool { return extra_hit_; }
         [[nodiscard]] auto isCooling() const -> bool { return firing_state_ == State::COOLING_LEFT || firing_state_ == State::COOLING_UP || firing_state_ == State::COOLING_RIGHT; }
         [[nodiscard]] auto isRecoiling() const -> bool { return firing_state_ == State::RECOILING_LEFT || firing_state_ == State::RECOILING_UP || firing_state_ == State::RECOILING_RIGHT; }
@@ -170,12 +183,12 @@ 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
         void setController(int index) { controller_index_ = index; }
-        void setCantFireCounter(int counter) { recoiling_state_duration_ = cant_fire_counter_ = counter; }
+        void startFiringSystem(int cooldown_frames);     // Método público para iniciar disparo
         void setFiringState(State state) { firing_state_ = state; }
         void setInvulnerableCounter(int value) { invulnerable_counter_ = value; }
         void setName(const std::string &name) { name_ = name; }
@@ -186,21 +199,34 @@ 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; }
         [[nodiscard]] auto getUsesKeyboard() const -> bool { return uses_keyboard_; }
 
     private:
-        // --- Constantes ---
-        static constexpr int POWERUP_COUNTER = 1500;       // Duración del estado PowerUp
-        static constexpr int INVULNERABLE_COUNTER = 200;   // Duración del estado invulnerable
-        static constexpr size_t INVULNERABLE_TEXTURE = 3;  // Textura usada durante invulnerabilidad
+        // --- Constantes de física y movimiento ---
         static constexpr float BASE_SPEED = 1.5F;          // Velocidad base del jugador
+
+        // --- Constantes de power-ups y estados especiales ---
+        static constexpr int POWERUP_COUNTER = 1500;       // Duración del estado PowerUp (frames)
+        static constexpr int INVULNERABLE_COUNTER = 200;   // Duración del estado invulnerable (frames)
+        static constexpr size_t INVULNERABLE_TEXTURE = 3;  // Textura usada durante invulnerabilidad
+
+        // --- Constantes del sistema de disparo (obsoletas - usar nuevo sistema) ---
         static constexpr int COOLING_DURATION = 50;        // Duración del enfriamiento tras disparar
         static constexpr int COOLING_COMPLETE = 0;         // Valor que indica enfriamiento completado
+
+        // --- Constantes de estados de espera ---
         static constexpr int WAITING_COUNTER = 1000;       // Tiempo de espera en estado de espera
 
+        // --- Constantes del nuevo sistema de disparo de dos líneas ---
+        static constexpr float AIMING_DURATION_FACTOR = 0.5f;      // 50% del cooldown funcional
+        static constexpr float RECOILING_DURATION_MULTIPLIER = 4.0f; // 4 veces la duración de aiming
+        static constexpr float THREAT_POSE_DURATION = 833.33f;     // 50 frames = ~833ms (duración base)
+        static constexpr float MIN_THREAT_POSE_DURATION = 100.0f;  // Duración mínima para threat pose
+
         // --- Objetos y punteros ---
         std::unique_ptr<AnimatedSprite> player_sprite_;      // Sprite para dibujar el jugador
         std::unique_ptr<AnimatedSprite> power_sprite_;       // Sprite para dibujar el aura del jugador con el poder a tope
@@ -221,9 +247,6 @@ class Player {
         State firing_state_ = State::FIRING_NONE;                 // Estado del jugador al disparar
         State playing_state_ = State::WAITING;                    // Estado del jugador en el juego
 
-        Uint32 continue_ticks_ = 0;                        // Variable para poder cambiar el contador de continue en función del tiempo
-        Uint32 name_entry_ticks_ = 0;                      // Variable para poder cambiar el contador de poner nombre en función del tiempo
-        Uint32 showing_name_ticks_ = 0;                    // Tiempo en el que se entra al estado SHOWING_NAME
         float pos_x_ = 0.0F;                               // Posición en el eje X
         float default_pos_x_;                              // Posición inicial para el jugador
         float vel_x_ = 0.0F;                               // Cantidad de píxeles a desplazarse en el eje X
@@ -231,10 +254,36 @@ 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 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
+        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 showing_name_time_accumulator_ = 0.0f;       // Acumulador de tiempo para showing name (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)
+
+        // ========================================
+        // NUEVO SISTEMA DE DISPARO DE DOS LÍNEAS
+        // ========================================
+
+        // LÍNEA 1: SISTEMA FUNCIONAL (CanFire)
+        float fire_cooldown_timer_ = 0.0f;                 // Tiempo restante hasta poder disparar otra vez
+        bool can_fire_new_system_ = true;                  // true si puede disparar ahora mismo
+
+        // LÍNEA 2: SISTEMA VISUAL (Animaciones)
+        enum class VisualFireState {
+            NORMAL,           // Brazo en posición neutral
+            AIMING,           // Brazo alzado (disparando)
+            RECOILING,        // Brazo en retroceso
+            THREAT_POSE       // Posición amenazante
+        };
+
+        VisualFireState visual_fire_state_ = VisualFireState::NORMAL;
+        float visual_state_timer_ = 0.0f;                  // Tiempo en el estado visual actual
+        float aiming_duration_ = 0.0f;                     // Duración del estado AIMING
+        float recoiling_duration_ = 0.0f;                  // Duración del estado RECOILING
+
+
         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
@@ -242,8 +291,8 @@ class Player {
         int power_up_x_offset_ = 0;                        // Desplazamiento del sprite de PowerUp respecto al sprite del jugador
         int continue_counter_ = 10;                        // Contador para poder continuar
         int controller_index_ = 0;                         // Índice del array de mandos que utilizará para moverse
-        int name_entry_idle_counter_ = 0;                  // Contador para poner nombre
-        int name_entry_total_counter_ = 0;                 // Segundos totales que lleva acumulados poniendo nombre
+        float name_entry_idle_time_accumulator_ = 0.0f;    // Tiempo idle acumulado para poner nombre (milisegundos)
+        float name_entry_total_time_accumulator_ = 0.0f;   // Tiempo total acumulado poniendo nombre (milisegundos)
         int step_counter_ = 0;                             // Cuenta los pasos para los estados en los que camina automáticamente
         int credits_used_ = 0;                             // Indica el número de veces que ha continuado
         int waiting_counter_ = 0;                          // Contador para el estado de espera
@@ -258,23 +307,39 @@ 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 updateShowingName();                                                             // Actualiza el estado SHOWING_NAME
+        void updateInvulnerable(float deltaTime);                                         // Monitoriza el estado de invulnerabilidad (time-based)
+        void updateContinueCounter(float deltaTime);                                      // Actualiza el contador de continue (time-based)
+        void updateEnterNameCounter(float deltaTime);                                     // Actualiza el contador de entrar nombre (time-based)
+        void updateShowingName(float deltaTime);                                          // Actualiza el estado SHOWING_NAME (time-based)
         void decNameEntryCounter();                                                           // Decrementa el contador de entrar nombre
         void updateScoreboard();                                                              // Actualiza el panel del marcador
         void setScoreboardMode(Scoreboard::Mode mode) const;                                  // Cambia el modo del marcador
         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 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
+
+        // --- Métodos del sistema de disparo de dos líneas ---
+        void updateFireSystem(float deltaTime);                                               // Método principal del nuevo sistema de disparo
+        void updateFunctionalLine(float deltaTime);                                           // Actualiza la línea funcional (CanFire)
+        void updateVisualLine(float deltaTime);                                               // Actualiza la línea visual (Animaciones)
+        void startFiring(int cooldown_frames);                                                // Inicia un nuevo disparo en ambas líneas
+        void updateFiringStateFromVisual();                                                   // Sincroniza firing_state_ con visual_fire_state_
+        void transitionToRecoilingNew();                                                      // Transición AIMING → RECOILING
+        void transitionToThreatPose();                                                        // Transición RECOILING → THREAT_POSE
+        void transitionToNormalNew();                                                         // Transición THREAT_POSE → NORMAL
+
+        // --- Métodos del sistema de disparo obsoleto ---
+        void handleFiringCooldown();                                                          // Gestiona el tiempo de espera después de disparar (frame-based)
+        void handleFiringCooldown(float deltaTime);                                           // Gestiona el tiempo de espera después de disparar (time-based)
+        void handleRecoilAndCooling();                                                        // Procesa retroceso y enfriamiento (frame-based)
+        void handleRecoilAndCooling(float deltaTime);                                         // Procesa retroceso y enfriamiento (time-based)
+        void handleCoolingState();                                                            // Actualiza estado de enfriamiento (frame-based)
+        void handleCoolingState(float deltaTime);                                             // Actualiza estado de enfriamiento (time-based)
+        void transitionToRecoiling();                                                         // Transición a retroceso (sistema obsoleto)
+        void transitionToCooling();                                                           // Transición a enfriamiento (sistema obsoleto)
+        void completeCooling();                                                               // Finaliza enfriamiento (sistema obsoleto)
+        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 +352,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,36 +78,46 @@ 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
-void Credits::update() {
-    if (SDL_GetTicks() - ticks_ > param.game.speed) {
-        ticks_ = SDL_GetTicks();
-        const int REPEAT = want_to_pass_ ? 4 : 1;
-        for (int i = 0; i < REPEAT; ++i) {
-            tiled_bg_->update();
-            cycleColors();
-            balloon_manager_->update();
-            updateTextureDstRects();
-            throwBalloons();
-            updatePlayers();
-            updateAllFades();
-            ++counter_;
-        }
+// 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;
 
-        Screen::get()->update();
+    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);
 
-        fillCanvas();
-    }
+    // 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();
 }
 
@@ -272,9 +287,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 +316,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 +360,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 +466,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 +509,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 +568,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 +586,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,10 +651,10 @@ void Credits::cycleColors() {
     tiled_bg_->setColor(color_);
 }
 
-// Actualza los jugadores
-void Credits::updatePlayers() {
+// Actualza los jugadores (time-based)
+void Credits::updatePlayers(float deltaTime) {
     for (auto &player : players_) {
-        player->update();
+        player->update(deltaTime);
     }
 }
 

source/sections/credits.h

@@ -25,6 +25,11 @@ class Credits {
         // --- Bucle principal ---
         void run();
 
+    private:
+        // --- Métodos del bucle principal ---
+        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 +46,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 +106,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 +113,23 @@ 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(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;
 
@@ -68,7 +79,7 @@ Game::Game(Player::Id player_id, int current_stage, bool demo)
     scoreboard_ = Scoreboard::get();
 
     fade_in_->setColor(param.fade.color);
-    fade_in_->setPreDuration(demo_.enabled ? 500 : 0);
+    fade_in_->setPreDuration(demo_.enabled ? DEMO_FADE_PRE_DURATION_MS : 0);
     fade_in_->setPostDuration(0);
     fade_in_->setType(Fade::Type::RANDOM_SQUARE2);
     fade_in_->setMode(Fade::Mode::IN);
@@ -200,9 +211,9 @@ void Game::updateHiScore() {
 }
 
 // Actualiza las variables del jugador
-void Game::updatePlayers() {
+void Game::updatePlayers(float deltaTime) {
     for (auto &player : players_) {
-        player->update();
+        player->update(deltaTime);
 
         if (player->isPlaying()) {
             // Comprueba la colisión entre el jugador y los globos
@@ -211,7 +222,7 @@ void Game::updatePlayers() {
             // Si hay colisión
             if (balloon) {
                 // Si el globo está parado y el temporizador activo, lo explota
-                if (balloon->isStopped() && time_stopped_counter_ > 0) {
+                if (balloon->isStopped() && time_stopped_timer_ > 0) {
                     balloon_manager_->popBalloon(balloon);
                 }
                 // En caso contrario, el jugador ha sido golpeado por un globo activo
@@ -285,11 +296,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));
         }
     }
 
@@ -301,31 +312,28 @@ void Game::updateStage() {
 }
 
 // Actualiza el estado de fin de la partida
-void Game::updateGameStateGameOver() {
+void Game::updateGameStateGameOver(float deltaTime) {
     fade_out_->update();
-    updatePlayers();
+    updatePlayers(deltaTime);
     updateScoreboard();
-    updateBackground();
-    balloon_manager_->update();
-    tabe_->update();
-    updateBullets();
-    updateItems();
-    updateSmartSprites();
-    updatePathSprites();
-    updateTimeStopped();
+    updateBackground(deltaTime);
+    balloon_manager_->update(deltaTime);
+    tabe_->update(deltaTime);
+    updateBullets(deltaTime);
+    updateItems(deltaTime);
+    updateSmartSprites(deltaTime);
+    updatePathSprites(deltaTime);
+    updateTimeStopped(deltaTime);
     checkBulletCollision();
     cleanVectors();
 
-    if (game_over_counter_ > 0) {
-        if (game_over_counter_ == GAME_OVER_COUNTER) {
-            createMessage({paths_.at(2), paths_.at(3)}, Resource::get()->getTexture("game_text_game_over"));
-            Audio::get()->fadeOutMusic(1000);
-            balloon_manager_->setBouncingSounds(true);
-        }
+    if (game_over_timer_ < GAME_OVER_DURATION_MS) {
+        handleGameOverEvents();  // Maneja eventos al inicio
 
-        game_over_counter_--;
+        game_over_timer_ += deltaTime;  // Incremento time-based
 
-        if (game_over_counter_ == 150) {
+        constexpr float FADE_TRIGGER_MS = GAME_OVER_DURATION_MS - (150.0f * (1000.0f / 60.0f));  // 2500ms antes del final
+        if (game_over_timer_ >= FADE_TRIGGER_MS && !fade_out_->isEnabled()) {
             fade_out_->activate();
         }
     }
@@ -338,7 +346,7 @@ void Game::updateGameStateGameOver() {
     }
 
     if (fade_out_->hasEnded()) {
-        if (game_completed_counter_ > 0) {
+        if (game_completed_timer_ > 0) {
             Section::name = Section::Name::CREDITS;  // Los jugadores han completado el juego
         } else {
             Section::name = Section::Name::HI_SCORE_TABLE;  // La partida ha terminado con la derrota de los jugadores
@@ -352,64 +360,28 @@ void Game::updateGameStateGameOver() {
 }
 
 // Gestiona eventos para el estado del final del juego
-void Game::updateGameStateCompleted() {
-    constexpr int START_CELEBRATIONS = 400;
-    constexpr int END_CELEBRATIONS = START_CELEBRATIONS + 300;
-
-    updatePlayers();
+void Game::updateGameStateCompleted(float deltaTime) {
+    updatePlayers(deltaTime);
     updateScoreboard();
-    updateBackground();
-    balloon_manager_->update();
-    tabe_->update();
-    updateBullets();
-    updateItems();
-    updateSmartSprites();
-    updatePathSprites();
+    updateBackground(deltaTime);
+    balloon_manager_->update(deltaTime);
+    tabe_->update(deltaTime);
+    updateBullets(deltaTime);
+    updateItems(deltaTime);
+    updateSmartSprites(deltaTime);
+    updatePathSprites(deltaTime);
     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) {
-        createMessage({paths_.at(4), paths_.at(5)}, Resource::get()->getTexture("game_text_congratulations"));
-        createMessage({paths_.at(6), paths_.at(7)}, Resource::get()->getTexture("game_text_1000000_points"));
-
-        for (auto &player : players_) {
-            if (player->isPlaying()) {
-                player->addScore(1000000, Options::settings.hi_score_table.back().score);
-                player->setPlayingState(Player::State::CELEBRATING);
-            } else {
-                player->setPlayingState(Player::State::GAME_OVER);
-            }
-        }
-
-        updateHiScore();
-    }
-
-    // Termina las celebraciones
-    if (game_completed_counter_ == END_CELEBRATIONS) {
-        for (auto &player : players_) {
-            if (player->isCelebrating()) {
-                player->setPlayingState(player->qualifiesForHighScore() ? Player::State::ENTERING_NAME_GAME_COMPLETED : Player::State::LEAVING_SCREEN);
-            }
-        }
-    }
+    // Maneja eventos del juego completado
+    handleGameCompletedEvents();
 
     // Si los jugadores ya no estan y no quedan mensajes en pantalla
     if (allPlayersAreGameOver() && path_sprites_.empty()) {
         setState(State::GAME_OVER);
     }
 
-    // Incrementa el contador al final
-    ++game_completed_counter_;
+    // Incrementa el acumulador al final
+    game_completed_timer_ += deltaTime;
 }
 
 // Comprueba el estado del juego
@@ -606,6 +578,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;
@@ -624,9 +597,9 @@ void Game::handleBalloonDestruction(std::shared_ptr<Balloon> balloon, const std:
 }
 
 // Mueve las balas activas
-void Game::updateBullets() {
+void Game::updateBullets(float deltaTime) {
     for (auto &bullet : bullets_) {
-        if (bullet->update() == BulletMoveStatus::OUT) {
+        if (bullet->update(deltaTime) == BulletMoveStatus::OUT) {
             getPlayer(bullet->getOwner())->decScoreMultiplier();
         }
     }
@@ -656,10 +629,10 @@ void Game::freeBullets() {
 }
 
 // Actualiza los items
-void Game::updateItems() {
+void Game::updateItems(float deltaTime) {
     for (auto &item : items_) {
         if (item->isEnabled()) {
-            item->update();
+            item->update(deltaTime);
             if (item->isOnFloor()) {
                 playSound("title.wav");
                 screen_->shake(1, 2, 4);
@@ -733,7 +706,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
@@ -818,7 +790,7 @@ void Game::throwCoffee(int x, int y) {
     smart_sprites_.back()->setDestX(x + (smart_sprites_.back()->getVelX() * 50));
     smart_sprites_.back()->setDestY(param.game.height + 1);
     smart_sprites_.back()->setEnabled(true);
-    smart_sprites_.back()->setFinishedCounter(1);
+    smart_sprites_.back()->setFinishedDelay(0.0F);
     smart_sprites_.back()->setSpriteClip(0, param.game.item_size, param.game.item_size, param.game.item_size);
     smart_sprites_.back()->setRotatingCenter({param.game.item_size / 2, param.game.item_size / 2});
     smart_sprites_.back()->setRotate(true);
@@ -827,9 +799,9 @@ void Game::throwCoffee(int x, int y) {
 }
 
 // Actualiza los SmartSprites
-void Game::updateSmartSprites() {
+void Game::updateSmartSprites(float deltaTime) {
     for (auto &sprite : smart_sprites_) {
-        sprite->update();
+        sprite->update(deltaTime);
     }
 }
 
@@ -841,9 +813,9 @@ void Game::renderSmartSprites() {
 }
 
 // Actualiza los PathSprites
-void Game::updatePathSprites() {
+void Game::updatePathSprites(float deltaTime) {
     for (auto &sprite : path_sprites_) {
-        sprite->update();
+        sprite->update(deltaTime);
     }
 }
 
@@ -885,21 +857,35 @@ void Game::handlePlayerCollision(std::shared_ptr<Player> &player, std::shared_pt
     }
 }
 
-// Actualiza y comprueba el valor de la variable
-void Game::updateTimeStopped() {
-    if (time_stopped_counter_ > 0) {
-        time_stopped_counter_--;
-        if (time_stopped_counter_ > 120) {
-            if (time_stopped_counter_ % 30 == 0) {
+// Actualiza el estado del tiempo detenido
+void Game::updateTimeStopped(float deltaTime) {
+    static constexpr float WARNING_THRESHOLD_MS = 2000.0f;    // 120 frames a 60fps
+    static constexpr float CLOCK_SOUND_INTERVAL_MS = 500.0f;  // 30 frames a 60fps
+    static constexpr float COLOR_FLASH_INTERVAL_MS = 250.0f;  // 15 frames a 60fps
+
+    if (time_stopped_timer_ > 0) {
+        time_stopped_timer_ -= deltaTime;
+
+        // Fase de advertencia (últimos 2 segundos)
+        if (time_stopped_timer_ <= WARNING_THRESHOLD_MS) {
+            static float last_sound_time = 0.0f;
+            last_sound_time += deltaTime;
+
+            if (last_sound_time >= CLOCK_SOUND_INTERVAL_MS) {
+                balloon_manager_->normalColorsToAllBalloons();
+                playSound("clock.wav");
+                last_sound_time = 0.0f;
+            } else if (last_sound_time >= COLOR_FLASH_INTERVAL_MS) {
+                balloon_manager_->reverseColorsToAllBalloons();
                 playSound("clock.wav");
             }
         } else {
-            if (time_stopped_counter_ % 30 == 0) {
-                balloon_manager_->normalColorsToAllBalloons();
-                playSound("clock.wav");
-            } else if (time_stopped_counter_ % 30 == 15) {
-                balloon_manager_->reverseColorsToAllBalloons();
+            // Fase normal - solo sonido ocasional
+            static float sound_timer = 0.0f;
+            sound_timer += deltaTime;
+            if (sound_timer >= CLOCK_SOUND_INTERVAL_MS) {
                 playSound("clock.wav");
+                sound_timer = 0.0f;
             }
         }
     } else {
@@ -907,18 +893,16 @@ void Game::updateTimeStopped() {
     }
 }
 
-void Game::update() {
-    if (SDL_GetTicks() - ticks_ > param.game.speed) {
-        ticks_ = SDL_GetTicks();
-        screen_->update();
+// Actualiza toda la lógica del juego
+void Game::update(float deltaTime) {
+    screen_->update();
 
-        updateDemo();
+    updateDemo();
 #ifdef RECORDING
-        updateRecording();
+    updateRecording();
 #endif
-        updateGameStates();
-        fillCanvas();
-    }
+    updateGameStates(deltaTime);
+    fillCanvas();
 
     Audio::update();
 }
@@ -936,26 +920,26 @@ void Game::render() {
 }
 
 // Actualiza los estados del juego
-void Game::updateGameStates() {
+void Game::updateGameStates(float deltaTime) {
     if (!pause_manager_->isPaused()) {
         switch (state_) {
             case State::FADE_IN:
-                updateGameStateFadeIn();
+                updateGameStateFadeIn(deltaTime);
                 break;
             case State::ENTERING_PLAYER:
-                updateGameStateEnteringPlayer();
+                updateGameStateEnteringPlayer(deltaTime);
                 break;
             case State::SHOWING_GET_READY_MESSAGE:
-                updateGameStateShowingGetReadyMessage();
+                updateGameStateShowingGetReadyMessage(deltaTime);
                 break;
             case State::PLAYING:
-                updateGameStatePlaying();
+                updateGameStatePlaying(deltaTime);
                 break;
             case State::COMPLETED:
-                updateGameStateCompleted();
+                updateGameStateCompleted(deltaTime);
                 break;
             case State::GAME_OVER:
-                updateGameStateGameOver();
+                updateGameStateGameOver(deltaTime);
                 break;
             default:
                 break;
@@ -964,8 +948,8 @@ void Game::updateGameStates() {
 }
 
 // Actualiza el fondo
-void Game::updateBackground() {
-    background_->update();
+void Game::updateBackground(float deltaTime) {
+    background_->update(deltaTime);
 }
 
 // Dibuja los elementos de la zona de juego en su textura
@@ -994,23 +978,34 @@ void Game::fillCanvas() {
 void Game::enableTimeStopItem() {
     balloon_manager_->stopAllBalloons();
     balloon_manager_->reverseColorsToAllBalloons();
-    time_stopped_counter_ = TIME_STOPPED_COUNTER;
+    time_stopped_timer_ = TIME_STOPPED_DURATION_MS;
 }
 
 // Deshabilita el efecto del item de detener el tiempo
 void Game::disableTimeStopItem() {
-    time_stopped_counter_ = 0;
+    time_stopped_timer_ = 0;
     balloon_manager_->startAllBalloons();
     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();
     }
@@ -1327,7 +1322,7 @@ void Game::handleFireInput(const std::shared_ptr<Player> &player, BulletType bul
             cant_fire_counter = NORMAL_COOLDOWN;
         }
 
-        player->setCantFireCounter(cant_fire_counter);
+        player->startFiringSystem(cant_fire_counter);  // Sistema de disparo de dos líneas
     }
 }
 
@@ -1371,17 +1366,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 +1400,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 +1426,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 +1483,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) {
@@ -1524,21 +1546,21 @@ void Game::initDifficultyVars() {
     // Variables relacionadas con la dificultad
     switch (difficulty_) {
         case Difficulty::Code::EASY: {
-            balloon_manager_->setDefaultBalloonSpeed(Balloon::SPEED.at(0));
+            balloon_manager_->setDefaultBalloonSpeed(Balloon::GAME_TEMPO.at(0));
             difficulty_score_multiplier_ = 0.5F;
             scoreboard_->setColor(param.scoreboard.easy_color);
             break;
         }
 
         case Difficulty::Code::NORMAL: {
-            balloon_manager_->setDefaultBalloonSpeed(Balloon::SPEED.at(0));
+            balloon_manager_->setDefaultBalloonSpeed(Balloon::GAME_TEMPO.at(0));
             difficulty_score_multiplier_ = 1.0F;
             scoreboard_->setColor(param.scoreboard.normal_color);
             break;
         }
 
         case Difficulty::Code::HARD: {
-            balloon_manager_->setDefaultBalloonSpeed(Balloon::SPEED.at(4));
+            balloon_manager_->setDefaultBalloonSpeed(Balloon::GAME_TEMPO.at(4));
             difficulty_score_multiplier_ = 1.5F;
             scoreboard_->setColor(param.scoreboard.hard_color);
             break;
@@ -1554,60 +1576,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_) {
@@ -1686,10 +1699,10 @@ void Game::updateRecording() {
 #endif
 
 // Actualiza las variables durante dicho estado
-void Game::updateGameStateFadeIn() {
+void Game::updateGameStateFadeIn(float deltaTime) {
     fade_in_->update();
     updateScoreboard();
-    updateBackground();
+    updateBackground(deltaTime);
     if (fade_in_->hasEnded()) {
         setState(State::ENTERING_PLAYER);
         balloon_manager_->createTwoBigBalloons();
@@ -1698,11 +1711,11 @@ void Game::updateGameStateFadeIn() {
 }
 
 // Actualiza las variables durante dicho estado
-void Game::updateGameStateEnteringPlayer() {
-    balloon_manager_->update();
-    updatePlayers();
+void Game::updateGameStateEnteringPlayer(float deltaTime) {
+    balloon_manager_->update(deltaTime);
+    updatePlayers(deltaTime);
     updateScoreboard();
-    updateBackground();
+    updateBackground(deltaTime);
     for (const auto &player : players_) {
         if (player->isPlaying()) {
             setState(State::SHOWING_GET_READY_MESSAGE);
@@ -1713,8 +1726,8 @@ void Game::updateGameStateEnteringPlayer() {
 }
 
 // Actualiza las variables durante dicho estado
-void Game::updateGameStateShowingGetReadyMessage() {
-    updateGameStatePlaying();
+void Game::updateGameStateShowingGetReadyMessage(float deltaTime) {
+    updateGameStatePlaying(deltaTime);
     if (path_sprites_.empty()) {
         setState(State::PLAYING);
     }
@@ -1725,24 +1738,24 @@ void Game::updateGameStateShowingGetReadyMessage() {
 }
 
 // Actualiza las variables durante el transcurso normal del juego
-void Game::updateGameStatePlaying() {
+void Game::updateGameStatePlaying(float deltaTime) {
 #ifdef _DEBUG
     if (auto_pop_balloons_) {
-        stage_manager_->addPower(5);
+        stage_manager_->addPower(1);
     }
 #endif
-    updatePlayers();
+    updatePlayers(deltaTime);
     checkPlayersStatusPlaying();
     updateScoreboard();
-    updateBackground();
-    balloon_manager_->update();
-    tabe_->update();
-    updateBullets();
-    updateItems();
+    updateBackground(deltaTime);
+    balloon_manager_->update(deltaTime);
+    tabe_->update(deltaTime);
+    updateBullets(deltaTime);
+    updateItems(deltaTime);
     updateStage();
-    updateSmartSprites();
-    updatePathSprites();
-    updateTimeStopped();
+    updateSmartSprites(deltaTime);
+    updatePathSprites(deltaTime);
+    updateTimeStopped(deltaTime);
     updateHelper();
     checkBulletCollision();
     updateMenace();
@@ -1800,9 +1813,9 @@ void Game::checkAndUpdateBalloonSpeed() {
 
     for (size_t i = 0; i < std::size(THRESHOLDS); ++i) {
         // Si la velocidad actual del globo es la correspondiente al umbral "i" y el porcentaje de progreso ha superado ese umbral
-        if (balloon_manager_->getBalloonSpeed() == Balloon::SPEED.at(i) && PERCENT > THRESHOLDS.at(i)) {
+        if (balloon_manager_->getBalloonSpeed() == Balloon::GAME_TEMPO.at(i) && PERCENT > THRESHOLDS.at(i)) {
             // Sube la velocidad al siguiente nivel (i + 1)
-            balloon_manager_->setBalloonSpeed(Balloon::SPEED.at(i + 1));
+            balloon_manager_->setBalloonSpeed(Balloon::GAME_TEMPO.at(i + 1));
             return;
         }
     }
@@ -1812,6 +1825,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 {
@@ -1867,26 +1893,72 @@ void Game::onPauseStateChanged(bool is_paused) {
     tabe_->pauseTimer(is_paused);
 }
 
+// Maneja eventos del juego completado usando flags para triggers únicos
+void Game::handleGameCompletedEvents() {
+    constexpr float START_CELEBRATIONS_MS = 6667.0f;  // 400 frames a 60fps
+    constexpr float END_CELEBRATIONS_MS = 11667.0f;   // 700 frames a 60fps
+
+    // Inicio de celebraciones
+    static bool start_celebrations_triggered = false;
+    if (!start_celebrations_triggered && game_completed_timer_ >= START_CELEBRATIONS_MS) {
+        createMessage({paths_.at(4), paths_.at(5)}, Resource::get()->getTexture("game_text_congratulations"));
+        createMessage({paths_.at(6), paths_.at(7)}, Resource::get()->getTexture("game_text_1000000_points"));
+
+        for (auto &player : players_) {
+            if (player->isPlaying()) {
+                player->addScore(1000000, Options::settings.hi_score_table.back().score);
+                player->setPlayingState(Player::State::CELEBRATING);
+            } else {
+                player->setPlayingState(Player::State::GAME_OVER);
+            }
+        }
+
+        updateHiScore();
+        start_celebrations_triggered = true;
+    }
+
+    // Fin de celebraciones
+    static bool end_celebrations_triggered = false;
+    if (!end_celebrations_triggered && game_completed_timer_ >= END_CELEBRATIONS_MS) {
+        for (auto &player : players_) {
+            if (player->isCelebrating()) {
+                player->setPlayingState(player->qualifiesForHighScore() ? Player::State::ENTERING_NAME_GAME_COMPLETED : Player::State::LEAVING_SCREEN);
+            }
+        }
+
+        fade_out_->activate();
+        end_celebrations_triggered = true;
+    }
+}
+
+// Maneja eventos de game over usando flag para trigger único
+void Game::handleGameOverEvents() {
+    static bool game_over_triggered = false;
+    if (!game_over_triggered && game_over_timer_ == 0.0f) {
+        createMessage({paths_.at(2), paths_.at(3)}, Resource::get()->getTexture("game_text_game_over"));
+        Audio::get()->fadeOutMusic(1000);
+        balloon_manager_->setBouncingSounds(true);
+        game_over_triggered = true;
+    }
+}
+
 #ifdef _DEBUG
 // Comprueba los eventos en el modo DEBUG
 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 +1968,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

@@ -33,7 +33,22 @@ namespace Difficulty {
 enum class Code;
 }  // namespace Difficulty
 
-// --- Clase Game: gestor principal del juego ---
+// --- Clase Game: núcleo principal del gameplay ---
+//
+// Esta clase gestiona toda la lógica del juego durante las partidas activas,
+// incluyendo mecánicas de juego, estados, objetos y sistemas de puntuación.
+//
+// Funcionalidades principales:
+// • Gestión de jugadores: soporte para 1 o 2 jugadores simultáneos
+// • Sistema de estados: fade-in, entrada, jugando, completado, game-over
+// • Mecánicas de juego: globos, balas, ítems, power-ups y efectos especiales
+// • Sistema de puntuación: scoreboard y tabla de récords
+// • Efectos temporales: tiempo detenido, ayudas automáticas
+// • Modo demo: reproducción automática para attract mode
+// • Gestión de fases: progresión entre niveles y dificultad
+//
+// Utiliza un sistema de tiempo basado en milisegundos para garantizar
+// comportamiento consistente independientemente del framerate.
 class Game {
     public:
         // --- Constantes ---
@@ -58,12 +73,13 @@ class Game {
             GAME_OVER,                  // Fin del juego
         };
 
-        // --- Constantes internas ---
-        static constexpr int HELP_COUNTER = 1000;
-        static constexpr int GAME_COMPLETED_START_FADE = 500;
-        static constexpr int GAME_COMPLETED_END = 700;
-        static constexpr int GAME_OVER_COUNTER = 350;
-        static constexpr int TIME_STOPPED_COUNTER = 360;
+        // --- Constantes de tiempo (en milisegundos) ---
+        static constexpr float HELP_COUNTER_MS = 16667.0f;              // Contador de ayuda (1000 frames a 60fps)
+        static constexpr float GAME_COMPLETED_START_FADE_MS = 8333.0f;  // Inicio del fade al completar (500 frames)
+        static constexpr float GAME_COMPLETED_END_MS = 11667.0f;        // Fin del juego completado (700 frames)
+        static constexpr float GAME_OVER_DURATION_MS = 5833.0f;         // Duración game over (350 frames)
+        static constexpr float TIME_STOPPED_DURATION_MS = 6000.0f;      // Duración del tiempo detenido (360 frames)
+        static constexpr int DEMO_FADE_PRE_DURATION_MS = 500;           // Pre-duración del fade en modo demo
         static constexpr int ITEM_POINTS_1_DISK_ODDS = 10;
         static constexpr int ITEM_POINTS_2_GAVINA_ODDS = 6;
         static constexpr int ITEM_POINTS_3_PACMAR_ODDS = 3;
@@ -77,7 +93,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
@@ -86,7 +102,7 @@ class Game {
                 int item_coffee_machine_odds;     // Probabilidad de aparición del objeto
 
                 Helper()
-                    : counter(HELP_COUNTER),
+                    : counter(HELP_COUNTER_MS),
                       item_disk_odds(ITEM_POINTS_1_DISK_ODDS),
                       item_gavina_odds(ITEM_POINTS_2_GAVINA_ODDS),
                       item_pacmar_odds(ITEM_POINTS_3_PACMAR_ODDS),
@@ -134,14 +150,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 difficulty_score_multiplier_ = 1.0f;                    // Multiplicador de puntos en función de la dificultad
+        float counter_ = 0.0f;                                        // Contador para el juego
+        float game_completed_timer_ = 0.0f;                           // Acumulador de tiempo para el tramo final (milisegundos)
+        float game_over_timer_ = 0.0f;                                // Timer para el estado de fin de partida (milisegundos)
+        float time_stopped_timer_ = 0.0f;                             // 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 +170,26 @@ 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 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
+        void update(float deltaTime);        // Actualiza la lógica principal del juego
+        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(float deltaTime);                       // Actualiza todos los estados del juego
+        void updateGameStateFadeIn(float deltaTime);                  // Gestiona el estado de transición de entrada (time-based)
+        void updateGameStateEnteringPlayer(float deltaTime);          // Gestiona el estado de entrada de jugador
+        void updateGameStateShowingGetReadyMessage(float deltaTime);  // Gestiona el estado de mensaje "preparado"
+        void updateGameStatePlaying(float deltaTime);                 // Gestiona el estado de juego activo
+        void updateGameStateCompleted(float deltaTime);               // Gestiona el estado de juego completado
+        void updateGameStateGameOver(float deltaTime);                // 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(float deltaTime);                       // Actualiza las variables y estados de los jugadores
         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
@@ -209,7 +226,7 @@ class Game {
         void demoHandlePlayerInput(const std::shared_ptr<Player> &player, int index);  // Procesa entrada de jugador en demo
 
         // --- Sistema de balas y proyectiles ---
-        void updateBullets();                                                                 // Actualiza posición y estado de todas las balas
+        void updateBullets(float deltaTime);                                              // Actualiza posición y estado de todas las balas (time-based)
         void renderBullets();                                                                 // Renderiza todas las balas activas
         void createBullet(int x, int y, BulletType kind, bool powered_up, Player::Id owner);  // Crea una nueva bala
         void checkBulletCollision();                                                          // Verifica colisiones de todas las balas
@@ -221,7 +238,7 @@ class Game {
         void processBalloonHit(const std::shared_ptr<Bullet> &bullet, const std::shared_ptr<Balloon> &balloon);  // Procesa impacto en globo
 
         // --- Sistema de ítems y power-ups ---
-        void updateItems();                                // Actualiza posición y estado de todos los ítems
+        void updateItems(float deltaTime);                // Actualiza posición y estado de todos los ítems
         void renderItems();                                // Renderiza todos los ítems activos
         auto dropItem() -> ItemType;                       // Determina aleatoriamente qué ítem soltar
         void createItem(ItemType type, float x, float y);  // Crea un nuevo ítem en posición específica
@@ -229,21 +246,23 @@ 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 throwCoffee(int x, int y);  // Crea efecto de café arrojado al ser golpeado
+        void enableTimeStopItem();                // Activa el efecto de detener el tiempo
+        void disableTimeStopItem();               // Desactiva el efecto de detener el tiempo
+        void updateTimeStopped(float deltaTime);  // Actualiza el estado del tiempo detenido
+        void handleGameCompletedEvents();         // Maneja eventos del juego completado
+        void handleGameOverEvents();              // Maneja eventos de game over
+        void throwCoffee(int x, int y);           // Crea efecto de café arrojado al ser golpeado
 
         // --- Gestión de caída de ítems ---
         void handleItemDrop(const std::shared_ptr<Balloon> &balloon, const std::shared_ptr<Player> &player);  // Gestiona caída de ítem desde globo
 
         // --- Sprites inteligentes (smartsprites) ---
-        void updateSmartSprites();  // Actualiza todos los sprites con lógica propia
+        void updateSmartSprites(float deltaTime);  // Actualiza todos los sprites con lógica propia (time-based)
         void renderSmartSprites();  // Renderiza todos los sprites inteligentes
         void freeSmartSprites();    // Libera memoria de sprites inteligentes
 
         // --- Sprites por ruta (pathsprites) ---
-        void updatePathSprites();  // Actualiza sprites que siguen rutas predefinidas
+        void updatePathSprites(float deltaTime);  // Actualiza sprites que siguen rutas predefinidas
         void renderPathSprites();  // Renderiza sprites animados por ruta
         void freePathSprites();    // Libera memoria de sprites por ruta
         void initPaths();          // Inicializa rutas predefinidas para animaciones
@@ -254,8 +273,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
@@ -277,7 +296,7 @@ class Game {
 
         // --- Recursos y renderizado ---
         void setResources();      // Asigna texturas y animaciones a los objetos
-        void updateBackground();  // Actualiza elementos del fondo
+        void updateBackground(float deltaTime);  // Actualiza elementos del fondo (time-based)
         void fillCanvas();        // Renderiza elementos del área de juego en su textura
         void updateHelper();      // Actualiza variables auxiliares de renderizado
 

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

@@ -39,7 +39,7 @@ Intro::Intro()
     initTexts();
 
     // Configura el fondo
-    tiled_bg_->setSpeed(0.3F);
+    tiled_bg_->setSpeed(TILED_BG_SPEED);
     tiled_bg_->setColor(bg_color_);
 }
 
@@ -191,7 +191,7 @@ void Intro::updateScene5() {
     // Acaba la ultima imagen
     if (card_sprites_.at(5)->hasFinished() && texts_.at(8)->hasFinished()) {
         state_ = State::POST;
-        state_start_time_ = SDL_GetTicks();
+        state_start_time_ = SDL_GetTicks() / 1000.0f;
     }
 }
 
@@ -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_) / 1000.0f;  // Convertir ms a segundos
+    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();
     }
@@ -277,7 +286,7 @@ void Intro::initSprites() {
 
     // Constantes
     constexpr int TOTAL_SPRITES = TEXTURE_LIST.size();
-    const float BORDER = 2.0F;
+    const float BORDER = CARD_BORDER_SIZE;
 
     auto texture = Resource::get()->getTexture(TEXTURE_LIST.front());
     const float CARD_WIDTH = texture->getWidth() + (BORDER * 2);
@@ -329,16 +338,16 @@ void Intro::initSprites() {
     const float X_DEST = param.game.game_area.center_x - (CARD_WIDTH / 2);
     const float Y_DEST = param.game.game_area.first_quarter_y - (CARD_HEIGHT / 4);
 
-    card_sprites_.at(0)->addPath(-CARD_WIDTH - 10, X_DEST, PathType::HORIZONTAL, Y_DEST, 100, easeInOutExpo, 0);
-    card_sprites_.at(1)->addPath(param.game.width, X_DEST, PathType::HORIZONTAL, Y_DEST, 100, easeOutBounce, 0);
-    card_sprites_.at(2)->addPath(-CARD_HEIGHT, Y_DEST, PathType::VERTICAL, X_DEST, 40, easeOutQuint, 0);
-    card_sprites_.at(3)->addPath(param.game.height, Y_DEST, PathType::VERTICAL, X_DEST, 300, easeInOutExpo, 0);
-    card_sprites_.at(4)->addPath(-CARD_HEIGHT, Y_DEST, PathType::VERTICAL, X_DEST, 70, easeOutElastic, 0);
-    card_sprites_.at(5)->addPath(-CARD_HEIGHT, Y_DEST, PathType::VERTICAL, X_DEST, 250, easeOutQuad, 450);
-    card_sprites_.at(5)->addPath(X_DEST, -CARD_WIDTH, PathType::HORIZONTAL, Y_DEST, 80, easeInElastic, 0);
+    card_sprites_.at(0)->addPath(-CARD_WIDTH - CARD_OFFSET_MARGIN, X_DEST, PathType::HORIZONTAL, Y_DEST, CARD_ANIM_DURATION_NORMAL, easeInOutExpo, 0.0f);
+    card_sprites_.at(1)->addPath(param.game.width, X_DEST, PathType::HORIZONTAL, Y_DEST, CARD_ANIM_DURATION_NORMAL, easeOutBounce, 0.0f);
+    card_sprites_.at(2)->addPath(-CARD_HEIGHT, Y_DEST, PathType::VERTICAL, X_DEST, CARD_ANIM_DURATION_FAST, easeOutQuint, 0.0f);
+    card_sprites_.at(3)->addPath(param.game.height, Y_DEST, PathType::VERTICAL, X_DEST, CARD_ANIM_DURATION_VERY_SLOW, easeInOutExpo, 0.0f);
+    card_sprites_.at(4)->addPath(-CARD_HEIGHT, Y_DEST, PathType::VERTICAL, X_DEST, CARD_ANIM_DURATION_MEDIUM, easeOutElastic, 0.0f);
+    card_sprites_.at(5)->addPath(-CARD_HEIGHT, Y_DEST, PathType::VERTICAL, X_DEST, CARD_ANIM_DURATION_SLOW, easeOutQuad, CARD_ANIM_DELAY_LONG);
+    card_sprites_.at(5)->addPath(X_DEST, -CARD_WIDTH, PathType::HORIZONTAL, Y_DEST, CARD_ANIM_DURATION_SHORT, easeInElastic, 0.0f);
 
     // Constantes
-    const float DESP = 8;
+    const float DESP = SHADOW_OFFSET;
     const float SHADOW_SPRITE_WIDTH = CARD_WIDTH;
     const float SHADOW_SPRITE_HEIGHT = CARD_HEIGHT;
 
@@ -380,13 +389,13 @@ void Intro::initSprites() {
     const float S_X_DEST = X_DEST + DESP;
     const float S_Y_DEST = Y_DEST + DESP;
 
-    shadow_sprites_.at(0)->addPath(param.game.height + 10, S_Y_DEST, PathType::VERTICAL, S_X_DEST, 100, easeInOutExpo, 0);
-    shadow_sprites_.at(1)->addPath(-SHADOW_SPRITE_HEIGHT, S_Y_DEST, PathType::VERTICAL, S_X_DEST, 100, easeOutBounce, 0);
-    shadow_sprites_.at(2)->addPath(-SHADOW_SPRITE_WIDTH, S_X_DEST, PathType::HORIZONTAL, S_Y_DEST, 40, easeOutQuint, 0);
-    shadow_sprites_.at(3)->addPath(-SHADOW_SPRITE_HEIGHT, S_Y_DEST, PathType::VERTICAL, S_X_DEST, 300, easeInOutExpo, 0);
-    shadow_sprites_.at(4)->addPath(param.game.height, S_Y_DEST, PathType::VERTICAL, S_X_DEST, 70, easeOutElastic, 0);
-    shadow_sprites_.at(5)->addPath(param.game.width, S_X_DEST, PathType::HORIZONTAL, S_Y_DEST, 250, easeOutQuad, 450);
-    shadow_sprites_.at(5)->addPath(S_X_DEST, param.game.width, PathType::HORIZONTAL, S_Y_DEST, 80, easeInElastic, 0);
+    shadow_sprites_.at(0)->addPath(param.game.height + CARD_OFFSET_MARGIN, S_Y_DEST, PathType::VERTICAL, S_X_DEST, CARD_ANIM_DURATION_NORMAL, easeInOutExpo, 0.0f);
+    shadow_sprites_.at(1)->addPath(-SHADOW_SPRITE_HEIGHT, S_Y_DEST, PathType::VERTICAL, S_X_DEST, CARD_ANIM_DURATION_NORMAL, easeOutBounce, 0.0f);
+    shadow_sprites_.at(2)->addPath(-SHADOW_SPRITE_WIDTH, S_X_DEST, PathType::HORIZONTAL, S_Y_DEST, CARD_ANIM_DURATION_FAST, easeOutQuint, 0.0f);
+    shadow_sprites_.at(3)->addPath(-SHADOW_SPRITE_HEIGHT, S_Y_DEST, PathType::VERTICAL, S_X_DEST, CARD_ANIM_DURATION_VERY_SLOW, easeInOutExpo, 0.0f);
+    shadow_sprites_.at(4)->addPath(param.game.height, S_Y_DEST, PathType::VERTICAL, S_X_DEST, CARD_ANIM_DURATION_MEDIUM, easeOutElastic, 0.0f);
+    shadow_sprites_.at(5)->addPath(param.game.width, S_X_DEST, PathType::HORIZONTAL, S_Y_DEST, CARD_ANIM_DURATION_SLOW, easeOutQuad, CARD_ANIM_DELAY_LONG);
+    shadow_sprites_.at(5)->addPath(S_X_DEST, param.game.width, PathType::HORIZONTAL, S_Y_DEST, CARD_ANIM_DURATION_SHORT, easeInElastic, 0.0f);
 }
 
 // Inicializa los textos
@@ -396,47 +405,47 @@ void Intro::initTexts() {
         auto writer = std::make_unique<Writer>(Resource::get()->getText("04b_25_metal"));
         writer->setPosX(0);
         writer->setPosY(param.game.height - param.intro.text_distance_from_bottom);
-        writer->setKerning(-2);
+        writer->setKerning(TEXT_KERNING);
         writer->setEnabled(false);
-        writer->setFinishedCounter(180);
+        writer->setFinishedTimerS(TEXT_DISPLAY_DURATION_S);
         texts_.push_back(std::move(writer));
     }
 
     // Un dia qualsevol de l'any 2000
     texts_.at(0)->setCaption(Lang::getText("[INTRO] 1"));
-    texts_.at(0)->setSpeed(8);
+    texts_.at(0)->setSpeedS(TEXT_SPEED_NORMAL);
 
     // Tot esta tranquil a la UPV
     texts_.at(1)->setCaption(Lang::getText("[INTRO] 2"));
-    texts_.at(1)->setSpeed(8);
+    texts_.at(1)->setSpeedS(TEXT_SPEED_NORMAL);
 
     // Fins que un desaprensiu...
     texts_.at(2)->setCaption(Lang::getText("[INTRO] 3"));
-    texts_.at(2)->setSpeed(12);
+    texts_.at(2)->setSpeedS(TEXT_SPEED_FAST);
 
     // HEY! ME ANE A FERME UN CORTAET...
     texts_.at(3)->setCaption(Lang::getText("[INTRO] 4"));
-    texts_.at(3)->setSpeed(8);
+    texts_.at(3)->setSpeedS(TEXT_SPEED_NORMAL);
 
     // UAAAAAAAAAAAAA!!!
     texts_.at(4)->setCaption(Lang::getText("[INTRO] 5"));
-    texts_.at(4)->setSpeed(1);
+    texts_.at(4)->setSpeedS(TEXT_SPEED_VERY_SLOW);
 
     // Espera un moment...
     texts_.at(5)->setCaption(Lang::getText("[INTRO] 6"));
-    texts_.at(5)->setSpeed(16);
+    texts_.at(5)->setSpeedS(TEXT_SPEED_VERY_FAST);
 
     // Si resulta que no tinc solt!
     texts_.at(6)->setCaption(Lang::getText("[INTRO] 7"));
-    texts_.at(6)->setSpeed(2);
+    texts_.at(6)->setSpeedS(TEXT_SPEED_SLOW);
 
     // MERDA DE MAQUINA!
     texts_.at(7)->setCaption(Lang::getText("[INTRO] 8"));
-    texts_.at(7)->setSpeed(3);
+    texts_.at(7)->setSpeedS(TEXT_SPEED_MEDIUM_SLOW);
 
     // Blop... blop... blop...
     texts_.at(8)->setCaption(Lang::getText("[INTRO] 9"));
-    texts_.at(8)->setSpeed(20);
+    texts_.at(8)->setSpeedS(TEXT_SPEED_ULTRA_FAST);
 
     for (auto &text : texts_) {
         text->center(param.game.game_area.center_x);
@@ -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->updateS(delta_time);  // Usar updateS para delta_time en segundos
     }
 }
 
@@ -476,12 +485,12 @@ void Intro::renderTexts() {
 
 // Actualiza el estado POST
 void Intro::updatePostState() {
-    const Uint32 ELAPSED_TIME = SDL_GetTicks() - state_start_time_;
+    const float ELAPSED_TIME = (SDL_GetTicks() / 1000.0f) - state_start_time_;
 
     switch (post_state_) {
         case PostState::STOP_BG:
-            // EVENTO: Detiene el fondo después de 1 segundo
-            if (ELAPSED_TIME >= 1000) {
+            // EVENTO: Detiene el fondo después del tiempo especificado
+            if (ELAPSED_TIME >= POST_BG_STOP_DELAY_S) {
                 tiled_bg_->stopGracefully();
 
                 if (!bg_color_.IS_EQUAL_TO(param.title.bg_color)) {
@@ -494,13 +503,13 @@ void Intro::updatePostState() {
             // Cambia de estado si el fondo se ha detenido y recuperado el color
             if (tiled_bg_->isStopped() && bg_color_.IS_EQUAL_TO(param.title.bg_color)) {
                 post_state_ = PostState::END;
-                state_start_time_ = SDL_GetTicks();
+                state_start_time_ = SDL_GetTicks() / 1000.0f;
             }
             break;
 
         case PostState::END:
-            // Finaliza la intro después de 1 segundo
-            if (ELAPSED_TIME >= 1000) {
+            // Finaliza la intro después del tiempo especificado
+            if (ELAPSED_TIME >= POST_END_DELAY_S) {
                 Audio::get()->stopMusic();
                 Section::name = Section::Name::TITLE;
                 Section::options = Section::Options::TITLE_1;

source/sections/intro.h

@@ -11,9 +11,22 @@
 #include "tiled_bg.h"     // Para TiledBG
 #include "writer.h"       // Para Writer
 
-// --- Clase Intro: muestra la secuencia de introducción ---
-// Esta clase gestiona un estado del programa. Se encarga de mostrar la secuencia
-// de introducción.
+// --- Clase Intro: secuencia cinemática de introducción del juego ---
+//
+// Esta clase gestiona la secuencia de introducción narrativa del juego, mostrando
+// una serie de escenas con imágenes, texto y efectos visuales sincronizados.
+//
+// Funcionalidades principales:
+// • Sistema de escenas secuencial: 6 escenas con transiciones automáticas
+// • Animaciones de tarjetas: efectos de entrada con diferentes tipos de easing
+// • Texto narrativo: velocidades de escritura configurables por escena
+// • Efectos visuales: sombras, bordes y transiciones de color
+// • Audio sincronizado: música de fondo durante toda la secuencia
+// • Estado POST: transición suave hacia el menú principal
+//
+// Todas las duraciones y velocidades están configuradas mediante constantes
+// para facilitar el ajuste fino de la experiencia cinematográfica.
+
 class Intro {
     public:
         // --- Constructor y destructor ---
@@ -24,6 +37,37 @@ class Intro {
         void run();
 
     private:
+        // --- Constantes de tiempo (en segundos) ---
+        static constexpr float TEXT_DISPLAY_DURATION_S = 3.0f;  // Duración de visualización de texto (180 frames a 60fps)
+        static constexpr float POST_BG_STOP_DELAY_S = 1.0f;     // Retraso antes de detener el fondo
+        static constexpr float POST_END_DELAY_S = 1.0f;         // Retraso antes de finalizar intro
+
+        // --- Constantes de layout ---
+        static constexpr float CARD_BORDER_SIZE = 2.0f;  // Tamaño del borde de tarjetas
+        static constexpr float SHADOW_OFFSET = 8.0f;     // Desplazamiento de sombra
+        static constexpr float TILED_BG_SPEED = 18.0f;   // Velocidad del fondo mosaico (pixels/segundo)
+        static constexpr int TEXT_KERNING = -2;          // Espaciado entre caracteres
+
+        // --- Constantes de velocidades de texto (segundos entre caracteres) ---
+        static constexpr float TEXT_SPEED_NORMAL = 0.133f;      // Velocidad normal (8 frames * 16.67ms = 133ms)
+        static constexpr float TEXT_SPEED_FAST = 0.2f;          // Velocidad rápida (12 frames * 16.67ms = 200ms)
+        static constexpr float TEXT_SPEED_VERY_SLOW = 0.0167f;  // Velocidad muy lenta (1 frame * 16.67ms = 16.7ms)
+        static constexpr float TEXT_SPEED_VERY_FAST = 0.267f;   // Velocidad muy rápida (16 frames * 16.67ms = 267ms)
+        static constexpr float TEXT_SPEED_SLOW = 0.033f;        // Velocidad lenta (2 frames * 16.67ms = 33ms)
+        static constexpr float TEXT_SPEED_MEDIUM_SLOW = 0.05f;  // Velocidad medio-lenta (3 frames * 16.67ms = 50ms)
+        static constexpr float TEXT_SPEED_ULTRA_FAST = 0.333f;  // Velocidad ultra rápida (20 frames * 16.67ms = 333ms)
+
+        // --- Constantes de animaciones de tarjetas (duraciones en segundos) ---
+        static constexpr float CARD_ANIM_DURATION_NORMAL = 100.0f / 60.0f;     // ≈ 1.6667 s
+        static constexpr float CARD_ANIM_DURATION_FAST = 40.0f / 60.0f;        // ≈ 0.6667 s
+        static constexpr float CARD_ANIM_DURATION_MEDIUM = 70.0f / 60.0f;      // ≈ 1.1667 s
+        static constexpr float CARD_ANIM_DURATION_SHORT = 80.0f / 60.0f;       // ≈ 1.3333 s
+        static constexpr float CARD_ANIM_DURATION_SLOW = 250.0f / 60.0f;       // ≈ 4.1667 s
+        static constexpr float CARD_ANIM_DURATION_VERY_SLOW = 300.0f / 60.0f;  // ≈ 5.0000 s
+
+        static constexpr float CARD_ANIM_DELAY_LONG = 0.45f;  // Retraso largo antes de animación
+        static constexpr float CARD_OFFSET_MARGIN = 10.0f;    // Margen fuera de pantalla
+
         // --- Estados internos ---
         enum class State {
             SCENES,
@@ -42,27 +86,28 @@ 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
-        Uint32 state_start_time_;                    // Tiempo de inicio del estado actual
+        float state_start_time_;                     // Tiempo de inicio del estado actual (segundos)
         Color bg_color_ = param.intro.bg_color;      // Color de fondo
 
         // --- Métodos internos ---
-        void update();                 // 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 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
+        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(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

@@ -28,38 +28,38 @@ Logo::Logo()
     dest_.y = param.game.game_area.center_y - jail_texture_->getHeight() / 2;
     since_sprite_->setPosition(SDL_FRect{
         static_cast<float>((param.game.width - since_texture_->getWidth()) / 2),
-        static_cast<float>(83 + jail_texture_->getHeight() + 5),
+        static_cast<float>(SINCE_SPRITE_Y_OFFSET + jail_texture_->getHeight() + LOGO_SPACING),
         static_cast<float>(since_texture_->getWidth()),
         static_cast<float>(since_texture_->getHeight())});
-    since_sprite_->setY(dest_.y + jail_texture_->getHeight() + 5);
+    since_sprite_->setY(dest_.y + jail_texture_->getHeight() + LOGO_SPACING);
     since_sprite_->setSpriteClip(0, 0, since_texture_->getWidth(), since_texture_->getHeight());
-    since_texture_->setColor(0x00, 0x00, 0x00);
+    since_texture_->setColor(SPECTRUM_BLACK.r, SPECTRUM_BLACK.g, SPECTRUM_BLACK.b);
 
     // Crea los sprites de cada linea
     for (int i = 0; i < jail_texture_->getHeight(); ++i) {
-        auto temp = std::make_unique<Sprite>(jail_texture_, 0, i, jail_texture_->getWidth(), 1);
-        temp->setSpriteClip(0, i, jail_texture_->getWidth(), 1);
-        const int POS_X = (i % 2 == 0) ? param.game.width + (i * 3) : -jail_texture_->getWidth() - (i * 3);
+        auto temp = std::make_unique<Sprite>(jail_texture_, 0, i, jail_texture_->getWidth(), SPRITE_LINE_HEIGHT);
+        temp->setSpriteClip(0, i, jail_texture_->getWidth(), SPRITE_LINE_HEIGHT);
+        const int POS_X = (i % 2 == 0) ? param.game.width + (i * LINE_OFFSET_FACTOR) : -jail_texture_->getWidth() - (i * LINE_OFFSET_FACTOR);
         temp->setX(POS_X);
         temp->setY(dest_.y + i);
         jail_sprite_.push_back(std::move(temp));
     }
 
-    // Inicializa el vector de colores
-    color_.emplace_back(0x00, 0x00, 0x00);  // Black
-    color_.emplace_back(0x00, 0x00, 0xd8);  // Blue
-    color_.emplace_back(0xd8, 0x00, 0x00);  // Red
-    color_.emplace_back(0xd8, 0x00, 0xd8);  // Magenta
-    color_.emplace_back(0x00, 0xd8, 0x00);  // Green
-    color_.emplace_back(0x00, 0xd8, 0xd8);  // Cyan
-    color_.emplace_back(0xd8, 0xd8, 0x00);  // Yellow
-    color_.emplace_back(0xFF, 0xFF, 0xFF);  // Bright white
+    // Inicializa el vector de colores con la paleta ZX Spectrum
+    color_.emplace_back(SPECTRUM_BLACK);
+    color_.emplace_back(SPECTRUM_BLUE);
+    color_.emplace_back(SPECTRUM_RED);
+    color_.emplace_back(SPECTRUM_MAGENTA);
+    color_.emplace_back(SPECTRUM_GREEN);
+    color_.emplace_back(SPECTRUM_CYAN);
+    color_.emplace_back(SPECTRUM_YELLOW);
+    color_.emplace_back(SPECTRUM_WHITE);
 }
 
 // Destructor
 Logo::~Logo() {
-    jail_texture_->setColor(255, 255, 255);
-    since_texture_->setColor(255, 255, 255);
+    jail_texture_->setColor(RESET_COLOR.r, RESET_COLOR.g, RESET_COLOR.b);
+    since_texture_->setColor(RESET_COLOR.r, RESET_COLOR.g, RESET_COLOR.b);
     Audio::get()->stopAllSounds();
     Audio::get()->stopMusic();
 }
@@ -78,22 +78,30 @@ void Logo::checkInput() {
     GlobalInputs::check();
 }
 
-// Gestiona el logo de JAILGAMES
-void Logo::updateJAILGAMES() {
-    if (counter_ == 30) {
-        Audio::get()->playSound("logo.wav");
-    }
+// Maneja la reproducción del sonido del logo
+void Logo::handleSound() {
+    static bool sound_triggered = false;
 
-    if (counter_ > 30) {
-        for (int i = 0; i < (int)jail_sprite_.size(); ++i) {
+    if (!sound_triggered && elapsed_time_s_ >= SOUND_TRIGGER_TIME_S) {
+        Audio::get()->playSound("logo.wav");
+        sound_triggered = true;
+    }
+}
+
+// Gestiona el logo de JAILGAMES
+void Logo::updateJAILGAMES(float delta_time) {
+    if (elapsed_time_s_ > SOUND_TRIGGER_TIME_S) {
+        const float PIXELS_TO_MOVE = LOGO_SPEED_PX_PER_S * delta_time;
+
+        for (size_t i = 0; i < 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);
                     }
@@ -103,43 +111,41 @@ void Logo::updateJAILGAMES() {
     }
 
     // Comprueba si ha terminado el logo
-    if (counter_ == END_LOGO_COUNTER_MARK + POST_LOGO_DURATION) {
+    if (elapsed_time_s_ >= END_LOGO_TIME_S + POST_LOGO_DURATION_S) {
         Section::name = Section::Name::INTRO;
     }
 }
 
 // Gestiona el color de las texturas
-void Logo::updateTextureColors() {
-    constexpr int INC = 4;
-
+void Logo::updateTextureColors(float delta_time) {
     // Manejo de 'sinceTexture'
-    for (int i = 0; i <= 7; ++i) {
-        if (counter_ == SHOW_SINCE_SPRITE_COUNTER_MARK + INC * i) {
+    for (int i = 0; i <= MAX_SINCE_COLOR_INDEX; ++i) {
+        const float target_time = SHOW_SINCE_SPRITE_TIME_S + COLOR_CHANGE_INTERVAL_S * i;
+        if (elapsed_time_s_ >= target_time && elapsed_time_s_ - delta_time < target_time) {
             since_texture_->setColor(color_[i].r, color_[i].g, color_[i].b);
         }
     }
 
     // Manejo de 'jailTexture' y 'sinceTexture' en el fade
-    for (int i = 0; i <= 6; ++i) {
-        if (counter_ == INIT_FADE_COUNTER_MARK + INC * i) {
-            jail_texture_->setColor(color_[6 - i].r, color_[6 - i].g, color_[6 - i].b);
-            since_texture_->setColor(color_[6 - i].r, color_[6 - i].g, color_[6 - i].b);
+    for (int i = 0; i <= MAX_FADE_COLOR_INDEX; ++i) {
+        const float target_time = INIT_FADE_TIME_S + COLOR_CHANGE_INTERVAL_S * i;
+        if (elapsed_time_s_ >= target_time && elapsed_time_s_ - delta_time < target_time) {
+            jail_texture_->setColor(color_[MAX_FADE_COLOR_INDEX - i].r, color_[MAX_FADE_COLOR_INDEX - i].g, color_[MAX_FADE_COLOR_INDEX - i].b);
+            since_texture_->setColor(color_[MAX_FADE_COLOR_INDEX - i].r, color_[MAX_FADE_COLOR_INDEX - i].g, color_[MAX_FADE_COLOR_INDEX - i].b);
         }
     }
 }
 
 // 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) {
+    elapsed_time_s_ += delta_time;   // Acumula el tiempo transcurrido
 
-        updateJAILGAMES();      // Actualiza el logo de JAILGAMES
-        updateTextureColors();  // Actualiza los colores de las texturas
-        ++counter_;             // Gestiona el contador
-    }
+    Screen::get()->update();          // Actualiza el objeto screen
+    Audio::update();                  // Actualiza el objeto audio
 
-    Audio::update();
+    handleSound();                    // Maneja la reproducción del sonido
+    updateTextureColors(delta_time);  // Actualiza los colores de las texturas
+    updateJAILGAMES(delta_time);      // Actualiza el logo de JAILGAMES
 }
 
 // Dibuja en pantalla
@@ -154,11 +160,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_) / 1000.0f;  // Convertir ms a segundos
+    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();
     }
@@ -171,7 +189,7 @@ void Logo::renderJAILGAMES() {
         sprite->render();
     }
 
-    if (counter_ >= SHOW_SINCE_SPRITE_COUNTER_MARK) {
+    if (elapsed_time_s_ >= SHOW_SINCE_SPRITE_TIME_S) {
         since_sprite_->render();
     }
 }

source/sections/logo.h

@@ -10,12 +10,21 @@
 
 class Texture;
 
-// --- Clase Logo: dibuja el logo de JAILGAMES con efectos visuales ---
-// Esta clase gestiona un estado del programa. Se encarga de dibujar por pantalla el
-// logo de "JAILGAMES" utilizando un sencillo efecto consistente en generar un sprite por
-// cada línea del bitmap que forma la palabra "JAILGAMES". Posteriormente realiza una
-// modulación de color sobre la textura para simular un fade to black al estilo
-// ZX Spectrum.
+// --- Clase Logo: pantalla de presentación de JAILGAMES con efectos retro ---
+//
+// Esta clase gestiona el estado inicial del programa, mostrando el logo corporativo
+// de JAILGAMES con efectos visuales inspirados en el ZX Spectrum.
+//
+// Funcionalidades principales:
+// • Animación de convergencia: cada línea del logo entra desde los laterales
+// • Efectos de color: transiciones automáticas usando la paleta ZX Spectrum
+// • Audio sincronizado: reproduce sonido del logo en momento específico
+// • Transición temporal: duración controlada con paso automático al siguiente estado
+// • Sistema delta-time: animaciones suaves independientes del framerate
+//
+// La clase utiliza un sistema de tiempo basado en segundos para garantizar
+// consistencia visual en diferentes velocidades de procesamiento.
+
 class Logo {
     public:
         // --- Constructor y destructor ---
@@ -26,12 +35,35 @@ class Logo {
         void run();
 
     private:
-        // --- Constantes ---
-        static constexpr int SHOW_SINCE_SPRITE_COUNTER_MARK = 70;  // Tiempo del contador en el que empieza a verse el sprite de "SINCE 1998"
-        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
+        // --- Constantes de tiempo (en segundos) ---
+        static constexpr float SOUND_TRIGGER_TIME_S = 0.5f;         // Tiempo para activar el sonido del logo
+        static constexpr float SHOW_SINCE_SPRITE_TIME_S = 1.167f;   // Tiempo para mostrar el sprite "SINCE 1998"
+        static constexpr float INIT_FADE_TIME_S = 5.0f;             // Tiempo de inicio del fade a negro
+        static constexpr float END_LOGO_TIME_S = 6.668f;            // Tiempo de finalización del logo
+        static constexpr float POST_LOGO_DURATION_S = 0.333f;       // Duración adicional después del fade
+        static constexpr float LOGO_SPEED_PX_PER_S = 480.0f;        // Velocidad de desplazamiento (píxeles por segundo) - 8.0f/16.67f*1000
+        static constexpr float COLOR_CHANGE_INTERVAL_S = 0.0667f;   // Intervalo entre cambios de color (~4 frames a 60fps)
+
+        // --- Constantes de layout ---
+        static constexpr int SINCE_SPRITE_Y_OFFSET = 83;  // Posición Y base del sprite "Since 1998"
+        static constexpr int LOGO_SPACING = 5;            // Espaciado entre elementos del logo
+        static constexpr int LINE_OFFSET_FACTOR = 3;      // Factor de desplazamiento inicial por línea
+        static constexpr int SPRITE_LINE_HEIGHT = 1;      // Altura de cada línea sprite
+
+        // --- Constantes de colores ---
+        static constexpr int MAX_SINCE_COLOR_INDEX = 7;  // Índice máximo para colores del sprite "Since"
+        static constexpr int MAX_FADE_COLOR_INDEX = 6;   // Índice máximo para colores del fade
+
+        // --- Paleta ZX Spectrum para efectos de logo ---
+        static constexpr Color SPECTRUM_BLACK = Color(0x00, 0x00, 0x00);    // Negro
+        static constexpr Color SPECTRUM_BLUE = Color(0x00, 0x00, 0xd8);     // Azul
+        static constexpr Color SPECTRUM_RED = Color(0xd8, 0x00, 0x00);      // Rojo
+        static constexpr Color SPECTRUM_MAGENTA = Color(0xd8, 0x00, 0xd8);  // Magenta
+        static constexpr Color SPECTRUM_GREEN = Color(0x00, 0xd8, 0x00);    // Verde
+        static constexpr Color SPECTRUM_CYAN = Color(0x00, 0xd8, 0xd8);     // Cian
+        static constexpr Color SPECTRUM_YELLOW = Color(0xd8, 0xd8, 0x00);   // Amarillo
+        static constexpr Color SPECTRUM_WHITE = Color(0xFF, 0xFF, 0xFF);    // Blanco brillante
+        static constexpr Color RESET_COLOR = Color(255, 255, 255);          // Color de reset
 
         // --- Objetos y punteros ---
         std::shared_ptr<Texture> since_texture_;            // Textura con los gráficos "Since 1998"
@@ -40,17 +72,19 @@ class Logo {
         std::vector<std::unique_ptr<Sprite>> jail_sprite_;  // Vector con los sprites de cada línea que forman el bitmap JAILGAMES
 
         // --- 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
-        SDL_FPoint dest_;           // Posición donde dibujar el logo
+        std::vector<Color> color_;      // Vector con los colores para el fade
+        float elapsed_time_s_ = 0.0f;   // Tiempo transcurrido en segundos
+        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 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 renderJAILGAMES();      // Renderiza el logo de JAILGAMES
-        void updateTextureColors();  // Gestiona el color de las texturas
+        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(float delta_time);      // Gestiona el logo de JAILGAMES
+        void renderJAILGAMES();                      // Renderiza el logo de JAILGAMES
+        void updateTextureColors(float delta_time);  // Gestiona el color de las texturas
+        void handleSound();                          // Maneja la reproducción del sonido del logo
+        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_(State::LOGO_ANIMATING),
+      num_controllers_(Input::get()->getNumGamepads()) {
     // Configura objetos
     tiled_bg_->setColor(param.title.bg_color);
     game_logo_->enable();
@@ -54,16 +60,16 @@ Title::Title()
     Section::attract_mode = IS_TITLE_TO_DEMO ? Section::AttractMode::TITLE_TO_LOGO : Section::AttractMode::TITLE_TO_DEMO;
 
     // Define los anclajes de los elementos
-    anchor_.mini_logo = (param.game.height / 5 * 4) + BLOCK;
+    anchor_.mini_logo = (param.game.height / MINI_LOGO_Y_DIVISOR * MINI_LOGO_Y_FACTOR) + BLOCK;
     mini_logo_sprite_->setY(anchor_.mini_logo);
-    anchor_.copyright_text = anchor_.mini_logo + mini_logo_sprite_->getHeight() + 3;
+    anchor_.copyright_text = anchor_.mini_logo + mini_logo_sprite_->getHeight() + COPYRIGHT_TEXT_SPACING;
 }
 
 // Destructor
 Title::~Title() {
     Audio::get()->stopAllSounds();
     if (Section::name == Section::Name::LOGO) {
-        Audio::get()->fadeOutMusic(300);
+        Audio::get()->fadeOutMusic(MUSIC_FADE_OUT_SHORT_MS);
     }
 
     // Desregistra los jugadores de Options
@@ -72,20 +78,27 @@ Title::~Title() {
 }
 
 // Actualiza las variables del objeto
-void Title::update() {
-    if (SDL_GetTicks() - ticks_ > param.game.speed) {
-        ticks_ = SDL_GetTicks();
-        Screen::get()->update();
+void Title::update(float deltaTime) {
+    Screen::get()->update();
+    updateFade();
+    updateState(deltaTime);
+    updateStartPrompt();
 
-        updateFade();
-        updateState();
-        updateStartPrompt();
-        updatePlayers();
+    for (auto& player : players_) {
+        player->update(deltaTime);
     }
 
     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 +143,7 @@ void Title::handleDebugColorKeys(SDL_Keycode key) {
 
     adjustColorComponent(key, color_);
 
-    counter_ = 0;
+    counter_time_ = 0.0f;
     tiled_bg_->setColor(color_);
     printColorValue(color_);
 }
@@ -264,7 +277,7 @@ void Title::handleStartButtonPress(const Options::Gamepad* controller) {
 }
 
 auto Title::canProcessStartButton() const -> bool {
-    return (state_ != TitleState::LOGO_ANIMATING || ALLOW_TITLE_ANIMATION_SKIP);
+    return (state_ != State::LOGO_ANIMATING || ALLOW_TITLE_ANIMATION_SKIP);
 }
 
 void Title::processPlayer1Start() {
@@ -283,22 +296,26 @@ 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;
+    setState(State::START_HAS_BEEN_PRESSED);
+    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() {
@@ -360,22 +377,22 @@ void Title::updateFade() {
 }
 
 // Actualiza el estado
-void Title::updateState() {
+void Title::updateState(float deltaTime) {
+    game_logo_->update(deltaTime);
+    tiled_bg_->update(deltaTime);
+
     // Establece la lógica según el estado
     switch (state_) {
-        case TitleState::LOGO_ANIMATING: {
-            game_logo_->update();
+        case State::LOGO_ANIMATING: {
             if (game_logo_->hasFinished()) {
-                setState(TitleState::LOGO_FINISHED);
+                setState(State::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
+        case State::LOGO_FINISHED: {
+            counter_time_ += deltaTime;
 
-            if (counter_ == param.title.title_duration) {
+            if (counter_time_ >= param.title.title_duration) {
                 // El menu ha hecho time out
                 fade_->setPostDuration(0);
                 fade_->activate();
@@ -383,12 +400,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
+        case State::START_HAS_BEEN_PRESSED: {
+            counter_time_ += deltaTime;
 
-            if (counter_ == 100) {
+            if (counter_time_ >= START_PRESSED_DELAY_MS) {
                 fade_->activate();
             }
             break;
@@ -400,22 +415,16 @@ void Title::updateState() {
 }
 
 void Title::updateStartPrompt() {
-    constexpr Uint32 LOGO_BLINK_PERIOD = 833;   // milisegundos
-    constexpr Uint32 LOGO_BLINK_ON_TIME = 583;  // 833 - 250
-
-    constexpr Uint32 START_BLINK_PERIOD = 167;
-    constexpr Uint32 START_BLINK_ON_TIME = 83;  // 167 - 83
-
     Uint32 time_ms = SDL_GetTicks();
     bool condition_met = false;
 
     switch (state_) {
-        case TitleState::LOGO_FINISHED:
-            condition_met = (time_ms % LOGO_BLINK_PERIOD) >= (LOGO_BLINK_PERIOD - LOGO_BLINK_ON_TIME);
+        case State::LOGO_FINISHED:
+            condition_met = (time_ms % LOGO_BLINK_PERIOD_MS) >= (LOGO_BLINK_PERIOD_MS - LOGO_BLINK_ON_TIME_MS);
             break;
 
-        case TitleState::START_HAS_BEEN_PRESSED:
-            condition_met = (time_ms % START_BLINK_PERIOD) >= (START_BLINK_PERIOD - START_BLINK_ON_TIME);
+        case State::START_HAS_BEEN_PRESSED:
+            condition_met = (time_ms % START_BLINK_PERIOD_MS) >= (START_BLINK_PERIOD_MS - START_BLINK_ON_TIME_MS);
             break;
 
         default:
@@ -439,7 +448,7 @@ void Title::renderStartPrompt() {
 }
 
 void Title::renderCopyright() {
-    if (state_ != TitleState::LOGO_ANIMATING) {
+    if (state_ != State::LOGO_ANIMATING) {
         // Mini logo
         mini_logo_sprite_->render();
 
@@ -456,20 +465,20 @@ void Title::renderCopyright() {
 }
 
 // Cambia el estado
-void Title::setState(TitleState state) {
+void Title::setState(State state) {
     if (state_ == state) {
         return;
     }
 
     state_ = state;
     switch (state_) {
-        case TitleState::LOGO_ANIMATING:
+        case State::LOGO_ANIMATING:
             break;
-        case TitleState::LOGO_FINISHED:
+        case State::LOGO_FINISHED:
             Audio::get()->playMusic("title.ogg");
             break;
-        case TitleState::START_HAS_BEEN_PRESSED:
-            Audio::get()->fadeOutMusic(1500);
+        case State::START_HAS_BEEN_PRESSED:
+            Audio::get()->fadeOutMusic(MUSIC_FADE_OUT_LONG_MS);
             break;
     }
 }
@@ -538,13 +547,6 @@ void Title::initPlayers() {
     }
 }
 
-// Actualza los jugadores
-void Title::updatePlayers() {
-    for (auto& player : players_) {
-        player->update();
-    }
-}
-
 // Renderiza los jugadores
 void Title::renderPlayers() {
     for (auto const& player : players_) {

source/sections/title.h

@@ -19,11 +19,22 @@ namespace Options {
 struct Gamepad;
 }  // namespace Options
 
-// --- Constantes ---
-constexpr std::string_view TEXT_COPYRIGHT = "@2020,2025 JailDesigner";  // Texto de copyright
-constexpr bool ALLOW_TITLE_ANIMATION_SKIP = false;                      // Permite saltar la animación del título
-
-// --- Clase Title: gestiona el estado de título/menú principal del juego ---
+// --- Clase Title: pantalla de título y menú principal del juego ---
+//
+// Esta clase gestiona la pantalla de título del juego, incluyendo el menú principal
+// y la transición entre diferentes modos de juego.
+//
+// Funcionalidades principales:
+// • Logo animado: muestra y anima el logotipo principal del juego
+// • Selección de jugadores: permite iniciar partidas de 1 o 2 jugadores
+// • Modo attract: cicla automáticamente entre título y demo
+// • Efectos visuales: parpadeos, transiciones y efectos de fondo
+// • Gestión de controles: soporte para teclado y múltiples gamepads
+// • Timeouts automáticos: transición automática si no hay interacción
+// • Debug de colores: herramientas de depuración para ajustes visuales
+//
+// La clase utiliza un sistema de tiempo basado en milisegundos para garantizar
+// comportamiento consistente independientemente del framerate.
 class Title {
     public:
         // --- Constructor y destructor ---
@@ -34,8 +45,28 @@ class Title {
         void run();
 
     private:
+        // --- Constantes de tiempo (en milisegundos) ---
+        static constexpr float START_PRESSED_DELAY_MS = 1666.67f;  // Tiempo antes de fade tras pulsar start (100 frames a 60fps)
+        static constexpr int MUSIC_FADE_OUT_LONG_MS = 1500;        // Fade out largo de música
+        static constexpr int MUSIC_FADE_OUT_SHORT_MS = 300;        // Fade out corto de música
+
+        // --- Constantes de parpadeo ---
+        static constexpr Uint32 LOGO_BLINK_PERIOD_MS = 833;   // Período de parpadeo del logo
+        static constexpr Uint32 LOGO_BLINK_ON_TIME_MS = 583;  // Tiempo encendido del logo (833-250)
+        static constexpr Uint32 START_BLINK_PERIOD_MS = 167;  // Período de parpadeo del start
+        static constexpr Uint32 START_BLINK_ON_TIME_MS = 83;  // Tiempo encendido del start (167-83)
+
+        // --- Constantes de layout ---
+        static constexpr int MINI_LOGO_Y_DIVISOR = 5;     // Divisor para posición Y del mini logo
+        static constexpr int MINI_LOGO_Y_FACTOR = 4;      // Factor para posición Y del mini logo
+        static constexpr int COPYRIGHT_TEXT_SPACING = 3;  // Espaciado del texto de copyright
+
+        // --- Constantes de texto y configuración ---
+        static constexpr std::string_view TEXT_COPYRIGHT = "@2020,2025 JailDesigner";  // Texto de copyright
+        static constexpr bool ALLOW_TITLE_ANIMATION_SKIP = false;                      // Permite saltar la animación del título
+
         // --- Enums ---
-        enum class TitleState {
+        enum class State {
             LOGO_ANIMATING,          // El logo está animándose
             LOGO_FINISHED,           // El logo ha terminado de animarse
             START_HAS_BEEN_PRESSED,  // Se ha pulsado el botón de start
@@ -59,19 +90,20 @@ class Title {
         Anchor anchor_;                                                  // Anclas para definir la posición de los elementos del título
         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
+        State state_;                                                    // Estado actual de la sección
+        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 setState(TitleState state);  // Cambia el estado del título
-        void resetCounter();              // Reinicia el contador interno
+        void update(float deltaTime);       // Actualiza las variables del objeto
+        float calculateDeltaTime();         // Calcula el tiempo transcurrido desde el último frame
+        void updateState(float deltaTime);  // Actualiza el estado actual del título
+        void setState(State state);         // Cambia el estado del título
+        void resetCounter();                // Reinicia el contador interno
 
         // --- Entrada de usuario ---
         void checkEvents();                                                                          // Comprueba los eventos

source/smart_sprite.cpp

@@ -2,12 +2,12 @@
 
 #include "moving_sprite.h"  // Para MovingSprite
 
-// Actualiza la posición y comprueba si ha llegado a su destino
-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();
+        MovingSprite::update(deltaTime);
         checkMove();
-        checkFinished();
+        checkFinished(deltaTime);
     }
 }
 
@@ -71,16 +71,19 @@ void SmartSprite::checkMove() {
     }
 }
 
-// Comprueba si ha terminado
-void SmartSprite::checkFinished() {
+// Comprueba si ha terminado (time-based)
+void SmartSprite::checkFinished(float deltaTime) {
     // Comprueba si ha llegado a su destino
     on_destination_ = (getPosX() == dest_x_ && getPosY() == dest_y_);
 
     if (on_destination_) {
-        if (finished_counter_ == 0) {
+        if (finished_delay_ms_ == 0.0f) {
             finished_ = true;
         } else {
-            --finished_counter_;
+            finished_timer_ += deltaTime;
+            if (finished_timer_ >= finished_delay_ms_) {
+                finished_ = true;
+            }
         }
     }
 }

source/smart_sprite.h

@@ -16,8 +16,8 @@ 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(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
@@ -26,21 +26,22 @@ class SmartSprite : public AnimatedSprite {
         auto hasFinished() const -> bool { return finished_; }            // Indica si ya ha terminado
 
         // --- Setters ---
-        void setFinishedCounter(int value) { finished_counter_ = value; }  // Establece el contador para deshabilitarlo
-        void setDestX(int x) { dest_x_ = x; }                              // Establece la posición de destino en X
-        void setDestY(int y) { dest_y_ = y; }                              // Establece la posición de destino en Y
-        void setEnabled(bool value) { enabled_ = value; }                  // Habilita o deshabilita el objeto
+        void setFinishedDelay(float value) { finished_delay_ms_ = value; }  // Establece el retraso para deshabilitarlo (ms)
+        void setDestX(int x) { dest_x_ = x; }                               // Establece la posición de destino en X
+        void setDestY(int y) { dest_y_ = y; }                               // Establece la posición de destino en Y
+        void setEnabled(bool value) { enabled_ = value; }                   // Habilita o deshabilita el objeto
 
     private:
         // --- Variables de estado ---
-        int dest_x_ = 0;               // Posición de destino en el eje X
-        int dest_y_ = 0;               // Posición de destino en el eje Y
-        int finished_counter_ = 0;     // Contador para deshabilitarlo
+        int dest_x_ = 0;                   // Posición de destino en el eje X
+        int dest_y_ = 0;                   // Posición de destino en el eje Y
+        float finished_delay_ms_ = 0.0f;   // Retraso para deshabilitarlo (ms)
+        float finished_timer_ = 0.0f;      // Timer acumulado (ms)
         bool on_destination_ = false;  // Indica si está en el destino
         bool finished_ = false;        // Indica si ya ha terminado
         bool enabled_ = false;         // Indica si el objeto está habilitado
 
         // --- Métodos internos ---
-        void checkFinished();  // Comprueba si ha terminado
-        void checkMove();      // Comprueba el movimiento
+        void checkFinished(float deltaTime);  // Comprueba si ha terminado (time-based)
+        void checkMove();                      // Comprueba el movimiento
 };