treballant en la classe Player

BUGS_PLAYER_REWRITE.md

@@ -0,0 +1,141 @@
+# BUGS DETECTADOS - Reescritura Player
+
+**Fecha:** 2025-10-30
+**Commit funcional de referencia:** `7cd596a0b9876c75ff75efc13708a2ca00c8cfcd`
+**Estado:** La reescritura según PLAYER_MECHANICS.md ha introducido múltiples regresiones
+
+---
+
+## 🐛 BUGS CRÍTICOS DETECTADOS
+
+### 2. **Salto recto en rampa: atraviesa la rampa al caer**
+- **Descripción:** Si el jugador salta verticalmente (sin movimiento horizontal) estando en una rampa, al caer atraviesa la rampa
+- **Estado esperado:** Salto recto (vx_ == 0) debería pegarse a la rampa al descender
+- **Regla violada:** PLAYER_MECHANICS.md líneas 386-391 - "JUMPING con vx_ == 0 se PEGA a la rampa"
+- **Posible causa:** Lógica en `moveVerticalDown()` no detecta correctamente el caso vx_ == 0
+
+---
+
+### 4. **No suena al saltar**
+- **Descripción:** Los sonidos de salto no se reproducen
+- **Estado esperado:** Sonidos progresivos basados en distancia vertical
+- **Posible causa:**
+  - `y_prev_` no se inicializa correctamente
+  - Sistema de detección de cambio de índice no funciona
+  - `last_grounded_position_` no se actualiza en el momento correcto
+
+---
+
+### 5. **No suena al caer**
+- **Descripción:** Los sonidos de caída no se reproducen
+- **Estado esperado:** Sonidos progresivos basados en distancia vertical caída
+- **Posible causa:** Similar al bug #4, sistema distance-based no detecta cambios
+
+---
+
+### 6. **Caer desde precipicio con inercia sobre rampa: resbala en estado FALLING**
+- **Descripción:** Al caer con inercia horizontal sobre una rampa, el jugador resbala en lugar de pegarse
+- **Estado esperado:** FALLING siempre debe tener `vx_ = 0` y pegarse a rampas
+- **Regla violada:** PLAYER_MECHANICS.md línea 147 - "FALLING se PEGA a TODAS las rampas"
+- **Posible causa:** `vx_` no se establece a 0 correctamente en transición a FALLING, o se ejecuta después del movimiento horizontal
+
+---
+
+### 7. **No muere al caer desde gran altura**
+- **Descripción:** El jugador puede caer desde cualquier altura sin morir
+- **Estado esperado:** Caída > 32 píxeles (4 tiles) debería matar al jugador
+- **Regla violada:** PLAYER_MECHANICS.md líneas 158-178
+- **Posible causa:**
+  - La verificación de muerte en `moveVerticalDown()` no se ejecuta
+  - `previous_state_` no es FALLING cuando debería
+  - Cálculo de `FALL_DISTANCE` es incorrecto
+
+---
+
+### 8. **No muere al caer sobre conveyor belt desde altura**
+- **Descripción:** El jugador puede caer sobre una conveyor belt desde cualquier altura sin morir
+- **Estado esperado:** Caída > 32 píxeles sobre conveyor belt también debería matar
+- **Regla violada:** PLAYER_MECHANICS.md líneas 158-178
+- **Posible causa:**
+  - La verificación de muerte solo está en la rama de suelo normal (`checkTopSurfaces`)
+  - Posiblemente necesita estar también cuando aterriza en `checkAutoSurfaces`
+  - Podría ser un subcaso del bug #7
+
+---
+
+## 🔍 ANÁLISIS PRELIMINAR
+
+### Problema raíz principal: **Orden de ejecución**
+
+El orden actual es:
+```cpp
+move() {
+    y_prev_ = y_;
+    applyGravity();
+    updateStateAndVelocity();  // ← Cambia estado y DEBERÍA cambiar vx_
+    moveHorizontal();           // ← Aplica vx_ (que puede ser incorrecto)
+    moveVertical();
+    updateColliderGeometry();
+}
+```
+
+**Problema:** `updateStateAndVelocity()` puede cambiar el estado a FALLING y establecer `vx_ = 0`, pero esto ocurre DENTRO del switch que solo se ejecuta DESPUÉS de que `previous_state_` ya esté establecido. En el código actual, cuando se hace la transición STANDING → FALLING, `setState()` NO establece `vx_ = 0` (se supone que lo hace `updateStateAndVelocity()`), pero esto puede no ejecutarse hasta el siguiente frame.
+
+### Problema raíz secundario: **setState() incompleto**
+
+En el commit funcional (`7cd596a0b9876c75ff75efc13708a2ca00c8cfcd`), `setState()` probablemente establecía TODAS las variables necesarias inmediatamente. En la reescritura actual, se delegó parte de esta responsabilidad a `updateStateAndVelocity()`, creando una desincronización.
+
+---
+
+## 📋 PLAN DE SOLUCIÓN
+
+### Opción A: Volver al commit funcional y refactorizar con cuidado
+1. Hacer `git diff` entre commit funcional y actual
+2. Identificar QUÉ funcionaba en el original
+3. Aplicar solo los cambios necesarios (eliminar `jumping_time_`, unificar variables)
+4. Mantener la lógica de setState() completa
+
+### Opción B: Corregir bugs uno por uno en código actual
+1. Arreglar `setState()` para que establezca TODAS las variables inmediatamente
+2. Revisar orden de ejecución en `move()`
+3. Depurar sistema de sonidos
+4. Probar cada bug individualmente
+
+### Opción C: Híbrido
+1. Extraer lógica funcional del commit 7cd596a
+2. Aplicar solo las correcciones de PLAYER_MECHANICS.md que no rompen funcionalidad:
+   - Cambiar `jump_init_pos_` → `last_grounded_position_` (con cuidado)
+   - Eliminar `jumping_time_` (secundario, no crítico)
+   - Implementar sistema de sonidos distance-based (después de que todo funcione)
+
+---
+
+## 🎯 RECOMENDACIÓN
+
+**Opción C (Híbrido)** parece la más sensata:
+
+1. Revertir a un punto funcional
+2. Aplicar cambios incrementales uno por uno
+3. Testear después de cada cambio
+4. No hacer cambios arquitecturales grandes (mantener `updateState()` y `updateVelocity()` separados si funcionaba así)
+
+---
+
+## 📝 NOTAS ADICIONALES
+
+- El commit `7cd596a` funciona perfecto según el usuario, aunque el código sea "caótico"
+- **Lección aprendida:** Refactorizar código funcional sin tests automáticos es peligroso
+- La sincronización estado-velocidad es más sutil de lo que parecía
+- PLAYER_MECHANICS.md puede tener asunciones incorrectas sobre el orden de ejecución óptimo
+
+---
+
+## ✅ PRÓXIMOS PASOS
+
+1. Comparar código actual vs commit 7cd596a
+2. Identificar diferencias críticas en:
+   - `setState()`
+   - `move()`
+   - `updateState()`/`updateVelocity()`
+   - Transiciones de estado
+3. Decidir estrategia: revertir completo, revertir parcial, o corregir in-place

source/game/defaults.hpp

@@ -46,7 +46,7 @@ constexpr int BORDER_HEIGHT = 24;      // Alto del borde por defecto
 // AUDIO
 // =============================================================================
 constexpr int AUDIO_VOLUME = 100;    // Volumen por defecto
-constexpr bool AUDIO_ENABLED = false;  // Audio por defecto
+constexpr bool AUDIO_ENABLED = true;  // Audio por defecto
 
 // MUSIC
 constexpr int MUSIC_VOLUME = 80;      // Volumen por defecto de la musica

source/game/entities/player.cpp

@@ -35,42 +35,66 @@ void Player::render() {
 // Actualiza las variables del objeto
 void Player::update(float delta_time) {
     if (!is_paused_) {
-        // 1. Procesamiento de entrada: captura las intenciones del jugador
+        checkInput(delta_time);  // Comprueba las entradas y modifica variables
-        checkInput();
+        move(delta_time);        // Recalcula la posición del jugador
-
+        animate(delta_time);     // Establece la animación del jugador
-        // 2. Física: aplica gravedad y actualiza velocidades
+        checkBorders();          // Comprueba si está situado en alguno de los cuatro bordes de la habitación
-        applyGravity(delta_time);
+        checkJumpEnd();          // Comprueba si ha finalizado el salto al alcanzar la altura de inicio
-        updateVelocity();
+        checkKillingTiles();     // Comprueba que el jugador no toque ningun tile de los que matan
-
+        setColor();              // Establece el color del jugador
-        // 3. Movimiento: ejecuta movimiento, actualiza estado durante movimiento, resuelve colisiones
-        move(delta_time);
-
-        // 4. Finalización: animación, comprobaciones y efectos
-        animate(delta_time);
-        checkBorders();
-        checkJumpEnd();
-        checkKillingTiles();
-        setColor();
     }
 }
 
-// Comprueba las entradas y establece las banderas de intención
+// Comprueba las entradas y modifica variables
-void Player::checkInput() {
+void Player::checkInput(float delta_time) {
-    // Resetea las banderas de intención
+    (void)delta_time;  // No usado en este método, pero mantenido para consistencia
-    want_to_jump_ = false;
-    want_to_move_left_ = false;
-    want_to_move_right_ = false;
 
-    // Captura las intenciones de movimiento
+    // Solo comprueba las entradas de dirección cuando está sobre una superficie
-    if (Input::get()->checkInput(InputAction::LEFT)) {
+    if (state_ != State::STANDING) {
-        want_to_move_left_ = true;
+        return;
-    } else if (Input::get()->checkInput(InputAction::RIGHT)) {
+    }
-        want_to_move_right_ = true;
+
+    if (!auto_movement_) {
+        // Comprueba las entradas de desplazamiento lateral solo en el caso de no estar enganchado a una superficie automatica
+        if (Input::get()->checkInput(InputAction::LEFT)) {
+            vx_ = -HORIZONTAL_VELOCITY;
+            sprite_->setFlip(SDL_FLIP_HORIZONTAL);
+        }
+
+        else if (Input::get()->checkInput(InputAction::RIGHT)) {
+            vx_ = HORIZONTAL_VELOCITY;
+            sprite_->setFlip(SDL_FLIP_NONE);
+        }
+
+        else {
+            // No se pulsa ninguna dirección
+            vx_ = 0.0F;
+            if (isOnAutoSurface()) {
+                // Si deja de moverse sobre una superficie se engancha
+                auto_movement_ = true;
+            }
+        }
+    } else {  // El movimiento lo proporciona la superficie
+        vx_ = HORIZONTAL_VELOCITY * room_->getAutoSurfaceDirection();
+
+        if (vx_ > 0.0F) {
+            sprite_->setFlip(SDL_FLIP_NONE);
+        } else {
+            sprite_->setFlip(SDL_FLIP_HORIZONTAL);
+        }
     }
 
-    // Captura la intención de salto
     if (Input::get()->checkInput(InputAction::JUMP)) {
-        want_to_jump_ = true;
+        // Solo puede saltar si ademas de estar (state == STANDING)
+        // Esta sobre el suelo, rampa o suelo que se mueve
+        // Esto es para evitar el salto desde el vacio al cambiar de pantalla verticalmente
+        // Ya que se coloca el estado STANDING al cambiar de pantalla
+
+        if (isOnFloor() || isOnAutoSurface()) {
+            setState(State::JUMPING);
+            vy_ = JUMP_VELOCITY;
+            last_grounded_position_ = static_cast<int>(y_);
+        }
     }
 }
 
@@ -101,125 +125,24 @@ void Player::checkBorders() {
     }
 }
 
-// Actualiza el estado del jugador basado en física e intenciones
+// Comprueba el estado del jugador
-void Player::updateState(float delta_time) {
+void Player::checkState(float delta_time) {
-    // Guarda el estado anterior para detectar transiciones
+    (void)delta_time;  // No usado actualmente
-    previous_state_ = state_;
 
-    // Máquina de estados: determina transiciones basándose en PLAYER_RULES.md
+    // Reproduce sonidos según el estado
-    switch (state_) {
+    if (state_ == State::FALLING) {
-        case State::STANDING: {
-            // Comprueba muerte por caída desde altura
-            if (previous_state_ == State::FALLING) {
-                const int FALLING_DISTANCE = static_cast<int>(y_) - last_grounded_position_;
-                if (FALLING_DISTANCE > MAX_FALLING_HEIGHT) {
-                    is_alive_ = false;
-                }
-            }
-
-            // Actualiza la posición de tierra
-            last_grounded_position_ = static_cast<int>(y_);
-            jumping_time_ = 0.0F;
-
-            // Regla: Si no tiene suelo debajo y no está JUMPING -> FALLING
-            if (shouldFall()) {
-                setState(State::FALLING);
-                return;
-            }
-
-            // Regla: Puede saltar si está sobre suelo o superficie automática
-            if (want_to_jump_ && canJump()) {
-                setState(State::JUMPING);
-                return;
-            }
-
-            // Nota: auto_movement_ se gestiona en updateVelocity() basado en el input
-            break;
-        }
-
-        case State::JUMPING: {
-            // Actualiza el tiempo de salto
-            jumping_time_ += delta_time;
-            playJumpSound();
-
-            // Regla: Si durante el salto Y > jump_init_pos -> FALLING
-            if (static_cast<int>(y_) >= jump_init_pos_ && vy_ > 0.0F) {
-                setState(State::FALLING);
-                return;
-            }
-            break;
-        }
-
-        case State::FALLING: {
-            // Reproduce sonido de caída
         playFallSound();
-            break;
     }
-
+    else if (state_ == State::STANDING) {
-        default:
+        // Si no tiene suelo debajo y no está en rampa descendente -> FALLING
-            break;
+        if (!isOnFloor() && !isOnAutoSurface() && !isOnDownSlope()) {
-    }
+            last_grounded_position_ = static_cast<int>(y_);  // Guarda Y actual al SALIR de STANDING
-}
+            setState(State::FALLING);  // setState() establece vx_=0, vy_=MAX_VY
-
+            playFallSound();
-// Comprueba si el jugador puede saltar
-auto Player::canJump() -> bool {
-    // Solo puede saltar si está STANDING y sobre suelo o superficie automática
-    return state_ == State::STANDING && (isOnFloor() || isOnAutoSurface());
-}
-
-// Comprueba si el jugador debe caer
-auto Player::shouldFall() -> bool {
-    // Cae si no tiene suelo, no está en superficie automática, y no está en rampa descendente
-    return !isOnFloor() && !isOnAutoSurface() && !isOnDownSlope();
-}
-
-// Actualiza velocidad basada en estado e intenciones
-void Player::updateVelocity() {
-    switch (state_) {
-        case State::STANDING: {
-            // Regla: Si está STANDING -> vy_ = 0
-            vy_ = 0.0F;
-
-            if (!auto_movement_) {
-                // Movimiento normal: el jugador controla la dirección
-                if (want_to_move_left_) {
-                    vx_ = -HORIZONTAL_VELOCITY;
-                    sprite_->setFlip(SDL_FLIP_HORIZONTAL);
-                } else if (want_to_move_right_) {
-                    vx_ = HORIZONTAL_VELOCITY;
-                    sprite_->setFlip(SDL_FLIP_NONE);
-                } else {
-                    // No se pulsa ninguna dirección
-                    vx_ = 0.0F;
-                    // Regla conveyor belt: cuando el jugador deja de pulsar, se acopla al movimiento
-                    if (isOnAutoSurface()) {
-                        auto_movement_ = true;
         }
     }
-            } else {
+    else if (state_ == State::JUMPING) {
-                // Movimiento automático: conveyor belt controla la dirección
+        playJumpSound();
-                // Regla conveyor belt: el jugador no puede cambiar de dirección
-                vx_ = HORIZONTAL_VELOCITY * room_->getAutoSurfaceDirection();
-                sprite_->setFlip(vx_ > 0.0F ? SDL_FLIP_NONE : SDL_FLIP_HORIZONTAL);
-            }
-            break;
-        }
-
-        case State::JUMPING: {
-            // Durante el salto, mantiene la velocidad horizontal
-            // La velocidad vertical la controla applyGravity()
-            break;
-        }
-
-        case State::FALLING: {
-            // Regla: Si está FALLING -> vx_ = 0 (no puede cambiar dirección en el aire)
-            vx_ = 0.0F;
-            // La velocidad vertical es MAX_VY (ya configurada por setState)
-            break;
-        }
-
-        default:
-            break;
     }
 }
 
@@ -248,6 +171,8 @@ void Player::switchBorders() {
             break;
     }
 
+    // CRÍTICO: Resetear last_grounded_position_ para evitar muerte falsa por diferencia de Y entre pantallas
+    last_grounded_position_ = static_cast<int>(y_);
     is_on_border_ = false;
     placeSprite();
 }
@@ -378,27 +303,47 @@ void Player::moveVerticalDown(float delta_time) {
     if (POS > -1) {
         // Si hay colisión lo mueve hasta donde no colisiona y pasa a estar sobre la superficie
         y_ = POS - HEIGHT;
+
+        // VERIFICAR MUERTE ANTES de cambiar de estado (PLAYER_MECHANICS.md línea 1268-1274)
+        const int FALL_DISTANCE = static_cast<int>(y_) - last_grounded_position_;
+        if (previous_state_ == State::FALLING && FALL_DISTANCE > MAX_FALLING_HEIGHT) {
+            is_alive_ = false;  // Muere si cae más de 32 píxeles
+        }
+
         setState(State::STANDING);
-        auto_movement_ = false;  // Desactiva conveyor belt al aterrizar
+        last_grounded_position_ = static_cast<int>(y_);  // Actualizar AL ENTRAR en STANDING
+        // Deja de estar enganchado a la superficie automatica
+        auto_movement_ = false;
     } else {
         // Si no hay colisión con los muros, comprueba la colisión con las rampas
-        // Regla: La unica forma de atravesar una Slope es en estado JUMPING y con vx_ != 0
+        // CORRECCIÓN: FALLING siempre se pega a rampas, JUMPING se pega solo si vx_ == 0
-        if (state_ != State::JUMPING || vx_ == 0.0F) {
+        if (state_ == State::FALLING || (state_ == State::JUMPING && vx_ == 0.0F)) {
-            // No está saltando o salta recto: se pega a las rampas
+            // No está saltando O salta recto: se pega a las rampas
             auto rect = toSDLRect(proj);
             const LineVertical LEFT_SIDE = {.x = rect.x, .y1 = rect.y, .y2 = rect.y + rect.h - 1};
             const LineVertical RIGHT_SIDE = {.x = rect.x + rect.w - 1, .y1 = rect.y, .y2 = rect.y + rect.h - 1};
             const float POINT = std::max(room_->checkRightSlopes(&RIGHT_SIDE), room_->checkLeftSlopes(&LEFT_SIDE));
             if (POINT > -1) {
-                // Hay colisión con una rampa: se pega a ella
+                // No está saltando y hay colisión con una rampa
+                // Calcula la nueva posición
                 y_ = POINT - HEIGHT;
+
+                // VERIFICAR MUERTE ANTES de cambiar de estado (PLAYER_MECHANICS.md línea 1268-1274)
+                const int FALL_DISTANCE = static_cast<int>(y_) - last_grounded_position_;
+                if (previous_state_ == State::FALLING && FALL_DISTANCE > MAX_FALLING_HEIGHT) {
+                    is_alive_ = false;  // Muere si cae más de 32 píxeles
+                }
+
                 setState(State::STANDING);
+                last_grounded_position_ = static_cast<int>(y_);  // Actualizar AL ENTRAR en STANDING
             } else {
-                // No hay colisión con rampa: continúa cayendo
+                // No está saltando y no hay colisón con una rampa
+                // Calcula la nueva posición
                 y_ += DISPLACEMENT;
             }
         } else {
-            // Está saltando con movimiento horizontal: atraviesa las rampas
+            // Esta saltando con movimiento horizontal y no hay colisión con los muros
+            // Calcula la nueva posición (atraviesa rampas)
             y_ += DISPLACEMENT;
         }
     }
@@ -406,6 +351,9 @@ void Player::moveVerticalDown(float delta_time) {
 
 // Orquesta el movimiento del jugador
 void Player::move(float delta_time) {
+    applyGravity(delta_time);   // Aplica gravedad al jugador
+    checkState(delta_time);     // Comprueba el estado del jugador
+
     // Movimiento horizontal
     if (vx_ < 0.0F) {
         moveHorizontal(delta_time, -1);  // Izquierda
@@ -413,9 +361,16 @@ void Player::move(float delta_time) {
         moveHorizontal(delta_time, 1);   // Derecha
     }
 
-    // Actualización de estado DURANTE el movimiento (después de horizontal, antes de vertical)
+    // Si ha salido del suelo, el jugador cae
-    // Esto asegura que el estado se actualice con la posición correcta
+    if (state_ == State::STANDING && !isOnFloor()) {
-    updateState(delta_time);
+        setState(State::FALLING);
+        auto_movement_ = false;
+    }
+
+    // Si ha salido de una superficie automatica, detiene el movimiento automatico
+    if (state_ == State::STANDING && isOnFloor() && !isOnAutoSurface()) {
+        auto_movement_ = false;
+    }
 
     // Movimiento vertical
     if (vy_ < 0.0F) {
@@ -424,6 +379,8 @@ void Player::move(float delta_time) {
         moveVerticalDown(delta_time);
     }
 
+    y_prev_ = y_;  // Guarda Y DESPUÉS de todo el movimiento (para detectar hitos en sonidos)
+
     // Actualiza la geometría del collider y sprite
     updateColliderGeometry();
 }
@@ -437,40 +394,44 @@ void Player::animate(float delta_time) {
 
 // Comprueba si ha finalizado el salto al alcanzar la altura de inicio
 void Player::checkJumpEnd() {
-    if (state_ == State::JUMPING && vy_ > 0.0F && static_cast<int>(y_) >= jump_init_pos_) {
+    // CORRECCIÓN: Usar > (mayor) en lugar de >= (mayor o igual)
-        // Si alcanza la altura de salto inicial, pasa al estado de caída
+    // Si el jugador vuelve EXACTAMENTE a la altura inicial, debe CONTINUAR en JUMPING
+    // Solo cuando la SUPERA (desciende más allá) cambia a FALLING
+    if (state_ == State::JUMPING && vy_ > 0.0F && static_cast<int>(y_) > last_grounded_position_) {
         setState(State::FALLING);
     }
 }
 
-// Calcula y reproduce el sonido de salto
+// Calcula y reproduce el sonido de salto basado en distancia vertical recorrida
 void Player::playJumpSound() {
-    const int SOUND_INDEX = static_cast<int>(jumping_time_ / SOUND_INTERVAL);
+    // Sistema basado en distancia vertical, no en tiempo (PLAYER_MECHANICS.md línea 107-120)
-    const int PREVIOUS_INDEX = static_cast<int>((jumping_time_ - SOUND_INTERVAL) / SOUND_INTERVAL);
+    const float DISTANCE_FROM_START = std::abs(y_ - static_cast<float>(last_grounded_position_));
+    const int SOUND_INDEX = static_cast<int>(DISTANCE_FROM_START / SOUND_DISTANCE_INTERVAL);
 
-    // Solo reproduce el sonido cuando cambia de índice
+    // Calcular índice previo (frame anterior)
+    const float PREV_DISTANCE = std::abs(y_prev_ - static_cast<float>(last_grounded_position_));
+    const int PREVIOUS_INDEX = static_cast<int>(PREV_DISTANCE / SOUND_DISTANCE_INTERVAL);
+
+    // Solo reproduce cuando cambia de índice (nuevo hito alcanzado)
     if (SOUND_INDEX != PREVIOUS_INDEX && SOUND_INDEX < static_cast<int>(jumping_sound_.size())) {
         JA_PlaySound(jumping_sound_[SOUND_INDEX]);
     }
 }
 
-// Calcula y reproduce el sonido de caer
+// Calcula y reproduce el sonido de caída basado en distancia vertical recorrida
 void Player::playFallSound() {
-    return;
+    // Sistema basado en distancia vertical, no en tiempo (PLAYER_MECHANICS.md línea 193-206)
+    const float DISTANCE_FALLEN = y_ - static_cast<float>(last_grounded_position_);
+    const int SOUND_INDEX = static_cast<int>(DISTANCE_FALLEN / SOUND_DISTANCE_INTERVAL);
 
-    /*
+    // Calcular índice previo (frame anterior)
-    const int SOUND_INDEX = static_cast<int>(falling_time_ / SOUND_INTERVAL);
+    const float PREV_DISTANCE = y_prev_ - static_cast<float>(last_grounded_position_);
-    const int PREVIOUS_INDEX = static_cast<int>((falling_time_ - SOUND_INTERVAL) / SOUND_INTERVAL);
+    const int PREVIOUS_INDEX = static_cast<int>(PREV_DISTANCE / SOUND_DISTANCE_INTERVAL);
 
-    // Solo reproduce el sonido cuando cambia de índice
+    // Solo reproduce cuando cambia de índice (nuevo hito alcanzado)
-    if (SOUND_INDEX != PREVIOUS_INDEX) {
+    if (SOUND_INDEX != PREVIOUS_INDEX && SOUND_INDEX < static_cast<int>(falling_sound_.size())) {
-        const int CLAMPED_INDEX = std::min(SOUND_INDEX, static_cast<int>(falling_sound_.size()) - 1);
+        JA_PlaySound(falling_sound_[SOUND_INDEX]);
-        JA_PlaySound(falling_sound_[CLAMPED_INDEX]);
-#ifdef _DEBUG
-        Debug::get()->add("FALL: " + std::to_string(CLAMPED_INDEX));
-#endif
     }
-    */
 }
 
 // Comprueba si el jugador tiene suelo debajo de los pies
@@ -597,32 +558,25 @@ void Player::updateFeet() {
 
 // Cambia el estado del jugador
 void Player::setState(State value) {
-    // Solo actualiza el estado y configura las variables iniciales
-    // NO llama a updateState() para evitar recursión circular
     previous_state_ = state_;
     state_ = value;
 
+    // Establecer velocidades INMEDIATAMENTE al cambiar de estado
     switch (state_) {
         case State::STANDING:
-            // Se establecerá vy_ = 0 en updateVelocity()
+            vx_ = 0.0F;
+            vy_ = 0.0F;
             break;
 
         case State::JUMPING:
-            // Configura el salto
+            // vx_ mantiene su valor actual (heredado de STANDING)
             vy_ = JUMP_VELOCITY;
-            jump_init_pos_ = y_;
-            jumping_time_ = 0.0F;
             break;
 
         case State::FALLING:
-            // Configura la caída
+            vx_ = 0.0F;  // CRÍTICO para pegarse a rampas
             vy_ = MAX_VY;
-            // vx_ = 0 se establecerá en updateVelocity()
-            if (previous_state_ == State::STANDING) {
-                last_grounded_position_ = static_cast<int>(y_);
-            }
             auto_movement_ = false;
-            jumping_time_ = 0.0F;
             break;
 
         default:
@@ -649,9 +603,10 @@ void Player::initSounds() {
 void Player::applySpawnValues(const SpawnData& spawn) {
     x_ = spawn.x;
     y_ = spawn.y;
+    y_prev_ = spawn.y;  // Inicializar y_prev_ igual a y_ para evitar saltos en primer frame
     vx_ = spawn.vx;
     vy_ = spawn.vy;
-    jump_init_pos_ = spawn.jump_init_pos;
+    last_grounded_position_ = spawn.last_grounded_position;
     state_ = spawn.state;
     sprite_->setFlip(spawn.flip);
 }

source/game/entities/player.hpp

@@ -28,7 +28,7 @@ class Player {
                 float y = 0;
                 float vx = 0;
                 float vy = 0;
-                int jump_init_pos = 0;
+                int last_grounded_position = 0;
                 State state = State::STANDING;
                 SDL_FlipMode flip = SDL_FLIP_NONE;
 
@@ -36,12 +36,12 @@ class Player {
                 SpawnData() = default;
 
                 // Constructor con parámetros
-                SpawnData(float x, float y, float vx, float vy, int jump_init_pos, State state, SDL_FlipMode flip)
+                SpawnData(float x, float y, float vx, float vy, int last_grounded_position, State state, SDL_FlipMode flip)
                     : x(x),
                       y(y),
                       vx(vx),
                       vy(vy),
-                      jump_init_pos(jump_init_pos),
+                      last_grounded_position(last_grounded_position),
                       state(state),
                       flip(flip) {}
         };
@@ -73,7 +73,7 @@ class Player {
         void switchBorders();                                                                                          // Cambia al jugador de un borde al opuesto. Util para el cambio de pantalla
         auto getRect() -> SDL_FRect { return {x_, y_, WIDTH, HEIGHT}; }                                                // Obtiene el rectangulo que delimita al jugador
         auto getCollider() -> SDL_FRect& { return collider_box_; }                                                     // Obtiene el rectangulo de colision del jugador
-        auto getSpawnParams() -> SpawnData { return {x_, y_, vx_, vy_, jump_init_pos_, state_, sprite_->getFlip()}; }  // Obtiene el estado de reaparición del jugador
+        auto getSpawnParams() -> SpawnData { return {x_, y_, vx_, vy_, last_grounded_position_, state_, sprite_->getFlip()}; }  // Obtiene el estado de reaparición del jugador
         void setColor();                                                                                               // Establece el color del jugador
         void setRoom(std::shared_ptr<Room> room) { room_ = std::move(room); }                                          // Establece la habitación en la que se encuentra el jugador
         [[nodiscard]] auto isAlive() const -> bool { return is_alive_; }                                               // Comprueba si el jugador esta vivo
@@ -92,7 +92,7 @@ class Player {
         static constexpr float GRAVITY_FORCE = 155.6F;       // Fuerza de gravedad en pixels/segundo² (0.035 * 66.67²)
 
         // --- Constantes de sonido ---
-        static constexpr float SOUND_INTERVAL = 0.06F;  // Intervalo entre sonidos de salto/caída en segundos (4 frames a 66.67fps)
+        static constexpr float SOUND_DISTANCE_INTERVAL = 3.0F;  // Distancia en píxeles entre cada sonido de salto/caída
 
         // --- --- Objetos y punteros --- ---
         std::shared_ptr<Room> room_;                     // Objeto encargado de gestionar cada habitación del juego
@@ -101,6 +101,7 @@ class Player {
         // --- Variables de posición y física ---
         float x_ = 0.0F;                               // Posición del jugador en el eje X
         float y_ = 0.0F;                               // Posición del jugador en el eje Y
+        float y_prev_ = 0.0F;                          // Posición Y del frame anterior (para detectar hitos de distancia en sonidos)
         float vx_ = 0.0F;                              // Velocidad/desplazamiento del jugador en el eje X
         float vy_ = 0.0F;                              // Velocidad/desplazamiento del jugador en el eje Y
 
@@ -108,11 +109,6 @@ class Player {
         State state_ = State::STANDING;                // Estado en el que se encuentra el jugador. Util apara saber si está saltando o cayendo
         State previous_state_ = State::STANDING;       // Estado previo en el que se encontraba el jugador
 
-        // --- Variables de entrada (input intent) ---
-        bool want_to_jump_ = false;                    // Indica si el jugador quiere saltar
-        bool want_to_move_left_ = false;               // Indica si el jugador quiere moverse a la izquierda
-        bool want_to_move_right_ = false;              // Indica si el jugador quiere moverse a la derecha
-
         // --- Variables de colisión ---
         SDL_FRect collider_box_;                       // Caja de colisión con los enemigos u objetos
         std::array<SDL_FPoint, 8> collider_points_{};  // Puntos de colisión con el mapa
@@ -125,14 +121,12 @@ class Player {
         bool is_paused_ = false;                       // Indica si el jugador esta en modo pausa
         bool auto_movement_ = false;                   // Indica si esta siendo arrastrado por una superficie automatica
         Room::Border border_ = Room::Border::TOP;      // Indica en cual de los cuatro bordes se encuentra
-        int jump_init_pos_ = 0;                        // Valor del eje Y en el que se inicia el salto
+        int last_grounded_position_ = 0;               // Ultima posición en Y en la que se estaba en contacto con el suelo (hace doble función: tracking de caída + altura inicial del salto)
-        int last_grounded_position_ = 0;               // Ultima posición en Y en la que se estaba en contacto con el suelo
 
         // --- Variables de renderizado y sonido ---
         Uint8 color_ = 0;                              // Color del jugador
         std::vector<JA_Sound_t*> jumping_sound_;       // Vecor con todos los sonidos del salto
         std::vector<JA_Sound_t*> falling_sound_;       // Vecor con todos los sonidos de la caída
-        float jumping_time_ = 0.0F;                    // Tiempo acumulado de salto en segundos
 
         // --- Funciones de inicialización ---
         void initSprite(const std::string& animations_path);  // Inicializa el sprite del jugador
@@ -140,17 +134,14 @@ class Player {
         void applySpawnValues(const SpawnData& spawn);        // Aplica los valores de spawn al jugador
 
         // --- Funciones de procesamiento de entrada ---
-        void checkInput();                                    // Comprueba las entradas y establece las banderas de intención
+        void checkInput(float delta_time);                    // Comprueba las entradas y modifica variables
 
         // --- Funciones de gestión de estado ---
-        void updateState(float delta_time);                   // Actualiza el estado del jugador basado en física e intenciones
+        void checkState(float delta_time);                    // Comprueba el estado del jugador y actualiza variables
         void setState(State value);                           // Cambia el estado del jugador
-        auto canJump() -> bool;                               // Comprueba si el jugador puede saltar
-        auto shouldFall() -> bool;                            // Comprueba si el jugador debe caer
 
         // --- Funciones de física ---
         void applyGravity(float delta_time);                  // Aplica gravedad al jugador
-        void updateVelocity();                                // Actualiza velocidad basada en estado e intenciones
 
         // --- Funciones de movimiento y colisión ---
         void move(float delta_time);                          // Orquesta el movimiento del jugador