Implementar toggle debug display y mejorar transparencia del texto

- Añadir tecla H para activar/desactivar debug display
- Debug display desactivado por defecto para interfaz limpia
- Implementar procesamiento bitmap monocromo a RGBA32 con transparencia
- Convertir fondo blanco original a pixels transparentes
- Convertir texto negro original a pixels blancos para color mod
- Configurar SDL_BLENDMODE_BLEND para transparencia correcta
- Actualizar README con documentacion de tecla H y debug display
- Conseguir texto flotante sin fondo negro para mejor legibilidad

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

README.md

@@ -16,6 +16,7 @@
 
 | Tecla | Accion |
 |-------|--------|
+| `H` | **Alternar debug display (FPS, V-Sync, valores fisica)** |
 | `V` | **Alternar V-Sync ON/OFF** |
 | `1-8` | Cambiar numero de pelotas (1, 10, 100, 500, 1K, 10K, 50K, 100K) |
 | `ESPACIO` | Impulsar todas las pelotas hacia arriba |
@@ -24,9 +25,15 @@
 
 ## 📊 Informacion en Pantalla
 
+- **Centro**: Numero de pelotas activas en **blanco** (temporal)
+
+### Debug Display (Tecla `H`)
+
+Cuando se activa el debug display con la tecla `H`:
+
 - **Esquina superior izquierda**: Estado V-Sync (VSYNC: ON/OFF) en **cian**
 - **Esquina superior derecha**: Contador FPS en tiempo real en **amarillo**
-- **Centro**: Numero de pelotas activas en **blanco** (temporal)
+- **Linea 3**: Valores fisica primera pelota (GRAV, VY, FLOOR) en **magenta**
 
 ## 🏗️ Estructura del Proyecto
 
@@ -103,50 +110,154 @@ make
 
 ### Configuracion Actual
 - **Resolucion**: 320x240 pixeles (escalado x3 = 960x720)
-- **FPS objetivo**: 60 FPS (16.67ms por frame)
+- **Sistema de timing**: Delta time independiente del framerate
 - **Fisica**: Gravedad constante (0.2f), rebotes con perdida de energia
 - **Tamaño de pelota**: 10x10 pixeles
 - **V-Sync**: Activado por defecto, controlable dinamicamente
 
 ### Arquitectura del Codigo
 
-1. **main.cpp**: Contiene el bucle principal con tres fases:
+1. **main.cpp**: Contiene el bucle principal con cuatro fases:
-   - `update()`: Actualiza la logica del juego + calculo FPS
+   - `calculateDeltaTime()`: Calcula tiempo transcurrido entre frames
+   - `update()`: Actualiza la logica del juego usando delta time + calculo FPS
    - `checkEvents()`: Procesa eventos de entrada
    - `render()`: Renderiza la escena + overlays informativos
 
-2. **Ball**: Maneja la fisica de cada pelota individual
+2. **Ball**: Maneja la fisica de cada pelota individual con timing basado en delta time
 3. **Sprite**: Sistema de renderizado de texturas con filtro nearest neighbor
 4. **Texture**: Gestion de carga y renderizado de imagenes con filtro pixel-perfect
 
-### Problema Actual: FPS Dependiente
+## ✅ Migracion a Delta Time (COMPLETADO)
 
-El sistema actual usa un **bucle acoplado** donde la logica y renderizado estan sincronizados a 60 FPS fijos:
+### Sistema Anterior (Frame-Based)
+
+El sistema original estaba **acoplado a 60 FPS** con logica dependiente del framerate:
 
 ```cpp
-// En update() - linea 236
+// Sistema ANTIGUO en update()
-if (SDL_GetTicks() - ticks > DEMO_SPEED) { // DEMO_SPEED = 1000/60
+if (SDL_GetTicks() - ticks > DEMO_SPEED) { // DEMO_SPEED = 1000/60 = 16.67ms
-    // Solo aqui se actualiza la fisica
+    // Solo aqui se actualizaba la fisica cada 16.67ms
+    for (auto &ball : balls) {
+        ball->update(); // Sin parametros de tiempo
+    }
+    ticks = SDL_GetTicks();
 }
 ```
 
-## 🚧 Mejoras Planificadas
+**Problemas del sistema anterior:**
+- Velocidad inconsistente entre diferentes refresh rates (60Hz vs 75Hz vs 144Hz)
+- Logica de fisica acoplada a framerate fijo
+- V-Sync ON/OFF cambiaba la velocidad del juego
+- Rendimiento inconsistente en diferentes hardware
 
-### Implementacion de Delta Time
+### Sistema Actual (Delta Time)
 
-**Objetivo**: Separar el bucle de proceso del de renderizado usando delta time para conseguir:
+**Implementacion delta time** para simulacion independiente del framerate:
 
-- **Simulacion independiente del framerate**
+```cpp
-- **Mejor rendimiento** en escenarios de alta carga
+// Sistema NUEVO - Variables globales
-- **Consistencia** en diferentes dispositivos
+Uint64 last_frame_time = 0;
-- **Preparacion para optimizaciones futuras**
+float delta_time = 0.0f;
 
-### Cambios Previstos
+// Calculo de delta time
+void calculateDeltaTime() {
+    Uint64 current_time = SDL_GetTicks();
+    if (last_frame_time == 0) {
+        last_frame_time = current_time;
+        delta_time = 1.0f / 60.0f; // Primer frame a 60 FPS
+        return;
+    }
 
-1. **Sistema de timing basado en delta time**
+    delta_time = (current_time - last_frame_time) / 1000.0f; // Convertir a segundos
-2. **Bucle de juego desacoplado** (logica vs renderizado)
+    last_frame_time = current_time;
-3. **Interpolacion** para renderizado suave
+
-4. **Optimizaciones de rendimiento**
+    // Limitar delta time para evitar saltos grandes
+    if (delta_time > 0.05f) {
+        delta_time = 1.0f / 60.0f; // Fallback a 60 FPS
+    }
+}
+
+// Bucle principal actualizado
+while (!should_exit) {
+    calculateDeltaTime();  // 1. Calcular tiempo transcurrido
+    update();             // 2. Actualizar logica (usa delta_time)
+    checkEvents();        // 3. Procesar entrada
+    render();            // 4. Renderizar escena
+}
+```
+
+### Conversion de Fisica: Frame-Based → Time-Based
+
+#### 1. Conversion de Velocidades
+
+```cpp
+// En Ball::Ball() constructor
+// ANTES: velocidades en pixeles/frame
+vx_ = vx;
+vy_ = vy;
+
+// AHORA: convertir a pixeles/segundo (x60)
+vx_ = vx * 60.0f;
+vy_ = vy * 60.0f;
+```
+
+#### 2. Conversion de Gravedad (Aceleracion)
+
+```cpp
+// En Ball::Ball() constructor
+// ANTES: gravedad en pixeles/frame²
+gravity_force_ = GRAVITY_FORCE;
+
+// AHORA: convertir a pixeles/segundo² (x60²)
+gravity_force_ = GRAVITY_FORCE * 60.0f * 60.0f; // 3600x multiplicador
+```
+
+**¿Por que 60² para gravedad?**
+- Velocidad: `pixeles/frame * frame/segundo = pixeles/segundo` → **x60**
+- Aceleracion: `pixeles/frame² * frame²/segundo² = pixeles/segundo²` → **x60²**
+
+#### 3. Aplicacion de Delta Time en Fisica
+
+```cpp
+// En Ball::update(float deltaTime)
+// ANTES: incrementos fijos por frame
+vy_ += gravity_force_;
+pos_.x += vx_;
+pos_.y += vy_;
+
+// AHORA: incrementos proporcionales al tiempo transcurrido
+vy_ += gravity_force_ * deltaTime;  // Aceleracion * tiempo
+pos_.x += vx_ * deltaTime;         // Velocidad * tiempo
+pos_.y += vy_ * deltaTime;
+```
+
+### Valores de Debug: Antes vs Ahora
+
+| Parametro | Sistema Anterior | Sistema Delta Time | Razon |
+|-----------|------------------|-------------------|-------|
+| **Velocidad X/Y** | 1.0 - 3.0 pixeles/frame | 60.0 - 180.0 pixeles/segundo | x60 conversion |
+| **Gravedad** | 0.2 pixeles/frame² | 720.0 pixeles/segundo² | x3600 conversion |
+| **Debug Display** | No disponible | GRAV: 720.000000 VY: -140.5 FLOOR: NO | Valores en tiempo real |
+
+### Beneficios Conseguidos
+
+- ✅ **Velocidad consistente** entre 60Hz, 75Hz, 144Hz y otros refresh rates
+- ✅ **V-Sync independiente**: misma velocidad con V-Sync ON/OFF
+- ✅ **Fisica precisa**: gravedad y movimiento calculados correctamente
+- ✅ **Escalabilidad**: preparado para futuras optimizaciones
+- ✅ **Debug en tiempo real**: monitoreo de valores de fisica
+
+### Sistema de Debug Implementado
+
+```cpp
+// Debug display para primera pelota
+if (!balls.empty()) {
+    std::string debug_text = "GRAV: " + std::to_string(balls[0]->getGravityForce()) +
+                           " VY: " + std::to_string(balls[0]->getVelocityY()) +
+                           " FLOOR: " + (balls[0]->isOnFloor() ? "YES" : "NO");
+    dbg_print(8, 24, debug_text.c_str(), 255, 0, 255); // Magenta
+}
+```
 
 ## 🛠️ Desarrollo
 

source/ball.cpp

@@ -9,35 +9,37 @@ Ball::Ball(float x, float vx, float vy, Color color, std::shared_ptr<Texture> te
     : sprite_(std::make_unique<Sprite>(texture)),
       pos_({x, 0.0f, BALL_SIZE, BALL_SIZE})
 {
-    vx_ = vx;
+    // Convertir velocidades de píxeles/frame a píxeles/segundo (multiplicar por 60)
-    vy_ = vy;
+    vx_ = vx * 60.0f;
+    vy_ = vy * 60.0f;
     sprite_->setPos({pos_.x, pos_.y});
     sprite_->setSize(BALL_SIZE, BALL_SIZE);
     sprite_->setClip({0, 0, BALL_SIZE, BALL_SIZE});
     color_ = color;
-    gravity_force_ = GRAVITY_FORCE;
+    // Convertir gravedad de píxeles/frame² a píxeles/segundo² (multiplicar por 60²)
+    gravity_force_ = GRAVITY_FORCE * 60.0f * 60.0f;
     on_floor_ = false;
     stopped_ = false;
     loss_ = ((rand() % 30) * 0.01f) + 0.6f;
 }
 
 // Actualiza la lógica de la clase
-void Ball::update()
+void Ball::update(float deltaTime)
 {
     if (stopped_)
     {
         return;
     }
 
-    // Aplica la gravedad a la velocidad
+    // Aplica la gravedad a la velocidad (píxeles/segundo²)
-    if (!on_floor_ && (pos_.y - SCREEN_HEIGHT) < BALL_SIZE * 2)
+    if (!on_floor_)
     {
-        vy_ += gravity_force_;
+        vy_ += gravity_force_ * deltaTime;
     }
 
-    // Actualiza la posición en función de la velocidad
+    // Actualiza la posición en función de la velocidad (píxeles/segundo)
-    pos_.x += vx_;
+    pos_.x += vx_ * deltaTime;
-    pos_.y += vy_;
+    pos_.y += vy_ * deltaTime;
 
     // Comprueba las colisiones con el lateral izquierdo
     if (pos_.x < 0)
@@ -94,20 +96,20 @@ void Ball::render()
     sprite_->render();
 }
 
-// Modifica la velocidad
+// Modifica la velocidad (convierte de frame-based a time-based)
 void Ball::modVel(float vx, float vy)
 {
     if (stopped_)
     {
-        vx_ = vx_ + vx;
+        vx_ = vx_ + (vx * 60.0f); // Convertir a píxeles/segundo
     }
-    vy_ = vy_ + vy;
+    vy_ = vy_ + (vy * 60.0f); // Convertir a píxeles/segundo
     on_floor_ = false;
     stopped_ = false;
 }
 
-// Cambia la gravedad
+// Cambia la gravedad (usa la versión convertida)
 void Ball::switchGravity()
 {
-    gravity_force_ = gravity_force_ == 0.0f ? GRAVITY_FORCE : 0.0f;
+    gravity_force_ = gravity_force_ == 0.0f ? (GRAVITY_FORCE * 60.0f * 60.0f) : 0.0f;
 }

source/ball.h

@@ -26,7 +26,7 @@ public:
     ~Ball() = default;
 
     // Actualiza la lógica de la clase
-    void update();
+    void update(float deltaTime);
 
     // Pinta la clase
     void render();
@@ -36,4 +36,9 @@ public:
 
     // Cambia la gravedad
     void switchGravity();
+
+    // Getters para debug
+    float getVelocityY() const { return vy_; }
+    float getGravityForce() const { return gravity_force_; }
+    bool isOnFloor() const { return on_floor_; }
 };

source/defines.h

@@ -8,7 +8,7 @@ constexpr int WINDOW_SIZE = 3;
 constexpr int BALL_SIZE = 10;
 constexpr float GRAVITY_FORCE = 0.2f;
 
-constexpr Uint64 DEMO_SPEED = 1000 / 60;
+// DEMO_SPEED eliminado - ya no se usa con delta time
 constexpr Uint64 TEXT_DURATION = 2000;
 
 struct Color

source/external/dbgtxt.h

@@ -10,12 +10,56 @@ void dbg_init(SDL_Renderer *renderer)
 {
     dbg_ren = renderer;
     Uint8 font[448] = {0x42, 0x4D, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x18, 0xF3, 0x83, 0x83, 0xCF, 0x83, 0x87, 0x00, 0x00, 0xF3, 0x39, 0x39, 0xCF, 0x79, 0xF3, 0x00, 0x00, 0x01, 0xF9, 0x39, 0xCF, 0x61, 0xF9, 0x00, 0x00, 0x33, 0xF9, 0x03, 0xE7, 0x87, 0x81, 0x00, 0x00, 0x93, 0x03, 0x3F, 0xF3, 0x1B, 0x39, 0x00, 0x00, 0xC3, 0x3F, 0x9F, 0x39, 0x3B, 0x39, 0x00, 0x41, 0xE3, 0x03, 0xC3, 0x01, 0x87, 0x83, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xE7, 0x01, 0xC7, 0x81, 0x01, 0x83, 0x00, 0x00, 0xE7, 0x1F, 0x9B, 0xE7, 0x1F, 0x39, 0x00, 0x00, 0xE7, 0x8F, 0x39, 0xE7, 0x87, 0xF9, 0x00, 0x00, 0xC3, 0xC7, 0x39, 0xE7, 0xC3, 0xC3, 0x00, 0x00, 0x99, 0xE3, 0x39, 0xE7, 0xF1, 0xE7, 0x00, 0x00, 0x99, 0xF1, 0xB3, 0xC7, 0x39, 0xF3, 0x00, 0x00, 0x99, 0x01, 0xC7, 0xE7, 0x83, 0x81, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x83, 0xE7, 0x83, 0xEF, 0x39, 0x39, 0x00, 0x00, 0x39, 0xE7, 0x39, 0xC7, 0x11, 0x11, 0x00, 0x00, 0xF9, 0xE7, 0x39, 0x83, 0x01, 0x83, 0x00, 0x00, 0x83, 0xE7, 0x39, 0x11, 0x01, 0xC7, 0x00, 0x00, 0x3F, 0xE7, 0x39, 0x39, 0x29, 0x83, 0x00, 0x00, 0x33, 0xE7, 0x39, 0x39, 0x39, 0x11, 0x00, 0x00, 0x87, 0x81, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x39, 0x39, 0x83, 0x3F, 0x85, 0x31, 0x00, 0x00, 0x39, 0x31, 0x39, 0x3F, 0x33, 0x23, 0x00, 0x00, 0x29, 0x21, 0x39, 0x03, 0x21, 0x07, 0x00, 0x00, 0x01, 0x01, 0x39, 0x39, 0x39, 0x31, 0x00, 0x00, 0x01, 0x09, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0x11, 0x19, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0x39, 0x39, 0x83, 0x03, 0x83, 0x03, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xC1, 0x39, 0x81, 0x83, 0x31, 0x01, 0x00, 0x00, 0x99, 0x39, 0xE7, 0x39, 0x23, 0x3F, 0x00, 0x00, 0x39, 0x39, 0xE7, 0xF9, 0x07, 0x3F, 0x00, 0x00, 0x31, 0x01, 0xE7, 0xF9, 0x0F, 0x3F, 0x00, 0x00, 0x3F, 0x39, 0xE7, 0xF9, 0x27, 0x3F, 0x00, 0x00, 0x9F, 0x39, 0xE7, 0xF9, 0x33, 0x3F, 0x00, 0x00, 0xC1, 0x39, 0x81, 0xF9, 0x39, 0x3F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x39, 0x03, 0xC3, 0x07, 0x01, 0x3F, 0x00, 0x00, 0x39, 0x39, 0x99, 0x33, 0x3F, 0x3F, 0x00, 0x00, 0x01, 0x39, 0x3F, 0x39, 0x3F, 0x3F, 0x00, 0x00, 0x39, 0x03, 0x3F, 0x39, 0x03, 0x03, 0x00, 0x00, 0x39, 0x39, 0x3F, 0x39, 0x3F, 0x3F, 0x00, 0x00, 0x93, 0x39, 0x99, 0x33, 0x3F, 0x3F, 0x00, 0x00, 0xC7, 0x03, 0xC3, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00};
-    dbg_tex = SDL_CreateTextureFromSurface(dbg_ren, SDL_LoadBMP_IO(SDL_IOFromMem(font, 448), 1));
+
+    // Cargar surface del bitmap font
+    SDL_Surface* font_surface = SDL_LoadBMP_IO(SDL_IOFromMem(font, 448), 1);
+    if (font_surface != nullptr)
+    {
+        // Crear una nueva surface de 32 bits con canal alpha
+        SDL_Surface* rgba_surface = SDL_CreateSurface(font_surface->w, font_surface->h, SDL_PIXELFORMAT_RGBA8888);
+        if (rgba_surface != nullptr)
+        {
+            // Obtener píxeles de ambas surfaces
+            Uint8* src_pixels = (Uint8*)font_surface->pixels;
+            Uint32* dst_pixels = (Uint32*)rgba_surface->pixels;
+
+            int width = font_surface->w;
+            int height = font_surface->h;
+
+            // Procesar cada píxel
+            for (int y = 0; y < height; y++)
+            {
+                for (int x = 0; x < width; x++)
+                {
+                    int byte_index = y * font_surface->pitch + (x / 8);
+                    int bit_index = 7 - (x % 8);
+
+                    // Extraer bit del bitmap monocromo
+                    bool is_white = (src_pixels[byte_index] >> bit_index) & 1;
+
+                    if (is_white) // Fondo blanco original -> transparente
+                    {
+                        dst_pixels[y * width + x] = 0x00000000; // Transparente
+                    }
+                    else // Texto negro original -> blanco opaco
+                    {
+                        dst_pixels[y * width + x] = 0xFFFFFFFF; // Blanco opaco
+                    }
+                }
+            }
+
+            dbg_tex = SDL_CreateTextureFromSurface(dbg_ren, rgba_surface);
+            SDL_DestroySurface(rgba_surface);
+        }
+        SDL_DestroySurface(font_surface);
+    }
 
     // Configurar filtro nearest neighbor para píxel perfect del texto
     if (dbg_tex != nullptr)
     {
         SDL_SetTextureScaleMode(dbg_tex, SDL_SCALEMODE_NEAREST);
+        // Configurar blend mode para transparencia normal
+        SDL_SetTextureBlendMode(dbg_tex, SDL_BLENDMODE_BLEND);
     }
 }
 

source/main.cpp

@@ -26,7 +26,7 @@ std::vector<std::unique_ptr<Ball>> balls;
 std::array<int, 8> test = {1, 10, 100, 500, 1000, 10000, 50000, 100000};
 
 bool should_exit = false;  // Controla si la aplicación debe cerrarse
-Uint64 ticks = 0;		   // Tiempo en milisegundos para controlar la actualización
+// ticks eliminado - reemplazado por delta time system
 int scenario = 0;		   // Escenario actual basado en el número de bolas
 std::string text;		   // Texto a mostrar en pantalla
 int text_pos = 0;		   // Posición del texto en la pantalla
@@ -43,6 +43,13 @@ std::string fps_text = "FPS: 0"; // Texto del contador de FPS
 bool vsync_enabled = true; // Estado inicial del V-Sync (activado por defecto)
 std::string vsync_text = "VSYNC: ON"; // Texto del estado V-Sync
 
+// Variables para Delta Time
+Uint64 last_frame_time = 0; // Tiempo del último frame en milisegundos
+float delta_time = 0.0f;    // Tiempo transcurrido desde el último frame en segundos
+
+// Variables para Debug Display
+bool show_debug = false; // Debug display desactivado por defecto
+
 // Establece el texto en pantalla mostrando el número de bolas actuales
 void setText()
 {
@@ -101,6 +108,30 @@ void toggleVSync()
 	SDL_SetRenderVSync(renderer, vsync_enabled ? 1 : 0);
 }
 
+// Calcula el delta time entre frames
+void calculateDeltaTime()
+{
+	Uint64 current_time = SDL_GetTicks();
+
+	// En el primer frame, inicializar el tiempo anterior
+	if (last_frame_time == 0)
+	{
+		last_frame_time = current_time;
+		delta_time = 1.0f / 60.0f; // Asumir 60 FPS para el primer frame
+		return;
+	}
+
+	// Calcular delta time en segundos
+	delta_time = (current_time - last_frame_time) / 1000.0f;
+	last_frame_time = current_time;
+
+	// Limitar delta time para evitar saltos grandes (pausa larga, depuración, etc.)
+	if (delta_time > 0.05f) // Máximo 50ms (20 FPS mínimo)
+	{
+		delta_time = 1.0f / 60.0f; // Usar 60 FPS como fallback
+	}
+}
+
 // Inicializa SDL y configura los componentes principales
 bool init()
 {
@@ -146,7 +177,7 @@ bool init()
 
 	// Inicializar otros componentes
 	texture = std::make_shared<Texture>(renderer, "resources/ball.png");
-	ticks = SDL_GetTicks();
+	// ticks eliminado - delta time system se inicializa automáticamente
 	srand(static_cast<unsigned>(time(nullptr)));
 	dbg_init(renderer);
 	initBalls(scenario);
@@ -196,6 +227,10 @@ void checkEvents()
 				toggleVSync();
 				break;
 
+			case SDLK_H:
+				show_debug = !show_debug;
+				break;
+
 			case SDLK_1:
 				scenario = 0;
 				initBalls(scenario);
@@ -254,19 +289,16 @@ void update()
 		fps_text = "FPS: " + std::to_string(fps_current);
 	}
 
-	if (SDL_GetTicks() - ticks > DEMO_SPEED)
+	// ¡DELTA TIME! Actualizar física siempre, usando tiempo transcurrido
+	for (auto &ball : balls)
 	{
-		ticks = SDL_GetTicks();
+		ball->update(delta_time); // Pasar delta time a cada pelota
+	}
 
-		for (auto &ball : balls)
+	// Actualizar texto (sin cambios en la lógica)
-		{
+	if (show_text)
-			ball->update();
+	{
-		}
+		show_text = !(SDL_GetTicks() - text_init_time > TEXT_DURATION);
-
-		if (show_text)
-		{
-			show_text = !(SDL_GetTicks() - text_init_time > TEXT_DURATION);
-		}
 	}
 }
 
@@ -286,13 +318,26 @@ void render()
 		dbg_print(text_pos, 8, text.c_str(), 255, 255, 255);
 	}
 
-	// Mostrar contador de FPS en esquina superior derecha
+	// Debug display (solo si está activado con tecla H)
-	int fps_text_width = static_cast<int>(fps_text.length() * 8); // 8 píxeles por carácter
+	if (show_debug)
-	int fps_x = SCREEN_WIDTH - fps_text_width - 8; // 8 píxeles de margen
+	{
-	dbg_print(fps_x, 8, fps_text.c_str(), 255, 255, 0); // Amarillo para distinguir
+		// Mostrar contador de FPS en esquina superior derecha
+		int fps_text_width = static_cast<int>(fps_text.length() * 8); // 8 píxeles por carácter
+		int fps_x = SCREEN_WIDTH - fps_text_width - 8; // 8 píxeles de margen
+		dbg_print(fps_x, 8, fps_text.c_str(), 255, 255, 0); // Amarillo para distinguir
 
-	// Mostrar estado V-Sync en esquina superior izquierda
+		// Mostrar estado V-Sync en esquina superior izquierda
-	dbg_print(8, 8, vsync_text.c_str(), 0, 255, 255); // Cian para distinguir
+		dbg_print(8, 8, vsync_text.c_str(), 0, 255, 255); // Cian para distinguir
+
+		// Debug: Mostrar valores de la primera pelota (si existe)
+		if (!balls.empty())
+		{
+			std::string debug_text = "GRAV: " + std::to_string(balls[0]->getGravityForce()) +
+									 " VY: " + std::to_string(balls[0]->getVelocityY()) +
+									 " FLOOR: " + (balls[0]->isOnFloor() ? "YES" : "NO");
+			dbg_print(8, 24, debug_text.c_str(), 255, 0, 255); // Magenta para debug
+		}
+	}
 
 	SDL_RenderPresent(renderer);
 }
@@ -308,8 +353,16 @@ int main(int argc, char *args[])
 
 	while (!should_exit)
 	{
+		// 1. Calcular delta time antes de actualizar la lógica
+		calculateDeltaTime();
+
+		// 2. Actualizar lógica del juego con delta time
 		update();
+
+		// 3. Procesar eventos de entrada
 		checkEvents();
+
+		// 4. Renderizar la escena
 		render();
 	}