afegits MES estats a la classe Game

source/game/scenes/game.cpp

@@ -138,6 +138,12 @@ void Game::update() {
         case State::PLAYING:
             updatePlaying(DELTA_TIME);
             break;
+        case State::BLACK_SCREEN:
+            updateBlackScreen(DELTA_TIME);
+            break;
+        case State::GAME_OVER:
+            updateGameOver(DELTA_TIME);
+            break;
         case State::FADE_TO_ENDING:
             updateFadeToEnding(DELTA_TIME);
             break;
@@ -165,7 +171,6 @@ void Game::updatePlaying(float delta_time) {
             checkPlayerAndItems();
             checkPlayerAndEnemies();
             checkIfPlayerIsAlive();
-            checkGameOver();
             checkEndGame();
             checkRestoringJail(delta_time);
             checkSomeCheevos();
@@ -177,7 +182,35 @@ void Game::updatePlaying(float delta_time) {
     }
     scoreboard_->update(delta_time);
     keepMusicPlaying();
-    updateBlackScreen(delta_time);
+}
+
+// Actualiza el juego en estado BLACK_SCREEN
+void Game::updateBlackScreen(float delta_time) {
+    state_time_ += delta_time;
+
+    // Si se acabaron las vidas Y pasó el threshold → GAME_OVER
+    if (board_->lives < 0 && state_time_ > GAME_OVER_THRESHOLD) {
+        transitionToState(State::GAME_OVER);
+        return;
+    }
+
+    // Si pasó la duración completa → volver a PLAYING
+    if (state_time_ > BLACK_SCREEN_DURATION) {
+        // Despausar al salir
+        player_->setPaused(false);
+        room_->setPaused(false);
+        Screen::get()->setBorderColor(room_->getBorderColor());
+        transitionToState(State::PLAYING);
+    }
+}
+
+// Actualiza el juego en estado GAME_OVER
+void Game::updateGameOver(float delta_time) {
+    // Pequeño delay antes de cambiar escena
+    state_time_ += delta_time;
+    if (state_time_ > 0.1F) {  // 100ms de delay mínimo
+        SceneManager::current = SceneManager::Scene::GAME_OVER;
+    }
 }
 
 // Actualiza el juego en estado FADE_TO_ENDING
@@ -216,6 +249,16 @@ void Game::updatePostFadeEnding(float delta_time) {
 
 // Cambia al estado especificado y resetea los timers
 void Game::transitionToState(State new_state) {
+    // Lógica de ENTRADA según el nuevo estado
+    if (new_state == State::BLACK_SCREEN) {
+        // Respawn room y player
+        room_ = std::make_shared<Room>(current_room_, board_);
+        initPlayer(spawn_data_, room_);
+        // Pausar ambos
+        room_->setPaused(true);
+        player_->setPaused(true);
+    }
+
     state_ = new_state;
     state_time_ = 0.0F;
     fade_accumulator_ = 0.0F;
@@ -228,6 +271,12 @@ void Game::render() {
         case State::PLAYING:
             renderPlaying();
             break;
+        case State::BLACK_SCREEN:
+            renderBlackScreen();
+            break;
+        case State::GAME_OVER:
+            renderGameOver();
+            break;
         case State::FADE_TO_ENDING:
             renderFadeToEnding();
             break;
@@ -251,7 +300,6 @@ void Game::renderPlaying() {
     }
     renderRoomName();
     scoreboard_->render();
-    renderBlackScreen();
 
 #ifdef _DEBUG
     // Debug info
@@ -262,6 +310,22 @@ void Game::renderPlaying() {
     Screen::get()->render();
 }
 
+// Renderiza el juego en estado BLACK_SCREEN (pantalla negra)
+void Game::renderBlackScreen() {
+    Screen::get()->start();
+    auto const COLOR = static_cast<Uint8>(PaletteColor::BLACK);
+    Screen::get()->clearSurface(COLOR);
+    Screen::get()->setBorderColor(COLOR);
+    Screen::get()->render();
+}
+
+// Renderiza el juego en estado GAME_OVER (pantalla negra)
+void Game::renderGameOver() {
+    Screen::get()->start();
+    Screen::get()->clearSurface(static_cast<Uint8>(PaletteColor::BLACK));
+    Screen::get()->render();
+}
+
 // Renderiza el juego en estado FADE_TO_ENDING (via backbuffer)
 void Game::renderFadeToEnding() {
     // 1. Guardar renderer actual
@@ -454,13 +518,6 @@ void Game::checkIfPlayerIsAlive() {
     }
 }
 
-// Comprueba si ha terminado la partida
-void Game::checkGameOver() {
-    if (board_->lives < 0 && black_screen_time_ > GAME_OVER_THRESHOLD) {
-        SceneManager::current = SceneManager::Scene::GAME_OVER;
-    }
-}
-
 // Mata al jugador
 void Game::killPlayer() {
     if (Options::cheats.invincible == Options::Cheat::State::ENABLED) {
@@ -481,46 +538,8 @@ void Game::killPlayer() {
     // Sonido
     Audio::get()->playSound("death.wav", Audio::Group::GAME);
 
-    // Pone la pantalla en negro un tiempo
+    // Transicionar al estado BLACK_SCREEN (el respawn ocurre en transitionToState)
-    setBlackScreen();
+    transitionToState(State::BLACK_SCREEN);
-
-    // Crea la nueva habitación y el nuevo jugador
-    room_ = std::make_shared<Room>(current_room_, board_);
-    initPlayer(spawn_data_, room_);
-
-    // Pone los objetos en pausa mientras esta la habitación en negro
-    room_->setPaused(true);
-    player_->setPaused(true);
-}
-
-// Establece la pantalla en negro
-void Game::setBlackScreen() {
-    black_screen_ = true;
-}
-
-// Actualiza las variables relativas a la pantalla en negro
-void Game::updateBlackScreen(float delta_time) {
-    if (black_screen_) {
-        black_screen_time_ += delta_time;
-        if (black_screen_time_ > BLACK_SCREEN_DURATION) {
-            black_screen_ = false;
-            black_screen_time_ = 0.0F;
-
-            player_->setPaused(false);
-            room_->setPaused(false);
-            Screen::get()->setBorderColor(room_->getBorderColor());
-        }
-    }
-}
-
-// Dibuja la pantalla negra
-void Game::renderBlackScreen() const {
-    if (black_screen_) {
-        auto const COLOR = static_cast<Uint8>(PaletteColor::BLACK);
-        Screen::get()->setRendererSurface();
-        Screen::get()->clearSurface(COLOR);
-        Screen::get()->setBorderColor(COLOR);
-    }
 }
 
 // Pone el color del marcador en función del color del borde de la habitación

source/game/scenes/game.hpp

@@ -25,6 +25,8 @@ class Game {
 
         enum class State {
             PLAYING,           // Normal gameplay
+            BLACK_SCREEN,      // Black screen after death (0.30s)
+            GAME_OVER,         // Intermediate state before changing scene
             FADE_TO_ENDING,    // Fade out transition
             POST_FADE_ENDING,  // Black screen delay before ending
         };
@@ -59,9 +61,13 @@ class Game {
         void renderRoomName();                                                              // Escribe el nombre de la pantalla
         void transitionToState(State new_state);                                            // Cambia al estado especificado y resetea los timers
         void updatePlaying(float delta_time);                                               // Actualiza el juego en estado PLAYING
+        void updateBlackScreen(float delta_time);                                           // Actualiza el juego en estado BLACK_SCREEN
+        void updateGameOver(float delta_time);                                              // Actualiza el juego en estado GAME_OVER
         void updateFadeToEnding(float delta_time);                                          // Actualiza el juego en estado FADE_TO_ENDING
         void updatePostFadeEnding(float delta_time);                                        // Actualiza el juego en estado POST_FADE_ENDING
         void renderPlaying();                                                               // Renderiza el juego en estado PLAYING (directo a pantalla)
+        void renderBlackScreen();                                                           // Renderiza el juego en estado BLACK_SCREEN (pantalla negra)
+        void renderGameOver();                                                              // Renderiza el juego en estado GAME_OVER (pantalla negra)
         void renderFadeToEnding();                                                          // Renderiza el juego en estado FADE_TO_ENDING (via backbuffer)
         void renderPostFadeEnding();                                                        // Renderiza el juego en estado POST_FADE_ENDING (pantalla negra)
         auto changeRoom(const std::string& room_path) -> bool;                              // Cambia de habitación
@@ -70,11 +76,7 @@ class Game {
         auto checkPlayerAndEnemies() -> bool;                                               // Comprueba las colisiones del jugador con los enemigos
         void checkPlayerAndItems();                                                         // Comprueba las colisiones del jugador con los objetos
         void checkIfPlayerIsAlive();                                                        // Comprueba si el jugador esta vivo
-        void checkGameOver();                                                               // Comprueba si ha terminado la partida
         void killPlayer();                                                                  // Mata al jugador
-        void setBlackScreen();                                                              // Establece la pantalla en negro
-        void updateBlackScreen(float delta_time);                                           // Actualiza las variables relativas a la pantalla en negro
-        void renderBlackScreen() const;                                                     // Dibuja la pantalla negra
         void setScoreBoardColor();                                                          // Pone el color del marcador en función del color del borde de la habitación
         auto checkEndGame() -> bool;                                                        // Comprueba si ha finalizado el juego
         static auto getTotalItems() -> int;                                                 // Obtiene la cantidad total de items que hay en el mapeado del juego
@@ -121,8 +123,6 @@ class Game {
         DemoData demo_;  // Variables para el modo demo
 
         // Variables de efectos visuales
-        bool black_screen_{false};       // Indica si la pantalla está en negro. Se utiliza para la muerte del jugador
-        float black_screen_time_{0.0F};  // Tiempo acumulado en pantalla negra en segundos
         SDL_FRect room_name_rect_;       // Rectangulo donde pintar la textura con el nombre de la habitación
         float jail_restore_time_{0.0F};  // Tiempo acumulado para restauración de vidas en la Jail
 };