corregit: flags estatics en game.cpp

source/sections/game.cpp

@@ -319,7 +319,7 @@ void Game::updateStage() {
     }
 }
 
-// Actualiza el estado de fin de la partida
+// Actualiza las variables y sistemas durante el estado de fin de partida
 void Game::updateGameStateGameOver(float deltaTime) {
     fade_out_->update();
     updatePlayers(deltaTime);
@@ -336,14 +336,8 @@ void Game::updateGameStateGameOver(float deltaTime) {
     cleanVectors();
 
     if (game_over_timer_ < GAME_OVER_DURATION_S) {
-        handleGameOverEvents();  // Maneja eventos al inicio
+        game_over_timer_ += deltaTime;  // Incremento time-based primero
-
+        handleGameOverEvents();         // Maneja eventos después del incremento
-        game_over_timer_ += deltaTime;  // Incremento time-based
-
-        constexpr float FADE_TRIGGER_S = GAME_OVER_DURATION_S - 2.5f;  // 2.5 segundos antes del final
-        if (game_over_timer_ >= FADE_TRIGGER_S && !fade_out_->isEnabled()) {
-            fade_out_->activate();
-        }
     }
 
     if (Options::audio.enabled) {
@@ -872,13 +866,11 @@ void Game::updateTimeStopped(float deltaTime) {
         // Fase de advertencia (últimos 2 segundos)
         if (time_stopped_timer_ <= WARNING_THRESHOLD_S) {
             static float last_sound_time = 0.0f;
-            static bool color_flash_sound_played = false;
-            static bool warning_phase_started = false;
 
             // CLAC al entrar en fase de advertencia
-            if (!warning_phase_started) {
+            if (!time_stopped_flags_.warning_phase_started) {
                 playSound("clock.wav");
-                warning_phase_started = true;
+                time_stopped_flags_.warning_phase_started = true;
                 last_sound_time = 0.0f;  // Reset para empezar el ciclo rápido
             }
 
@@ -888,11 +880,11 @@ void Game::updateTimeStopped(float deltaTime) {
                 balloon_manager_->normalColorsToAllBalloons();
                 playSound("clock.wav");
                 last_sound_time = 0.0f;
-                color_flash_sound_played = false;  // Reset flag para el próximo intervalo
+                time_stopped_flags_.color_flash_sound_played = false;  // Reset flag para el próximo intervalo
-            } else if (last_sound_time >= COLOR_FLASH_INTERVAL_S && !color_flash_sound_played) {
+            } else if (last_sound_time >= COLOR_FLASH_INTERVAL_S && !time_stopped_flags_.color_flash_sound_played) {
                 balloon_manager_->reverseColorsToAllBalloons();
                 playSound("clock.wav");
-                color_flash_sound_played = true;  // Evita que suene múltiples veces
+                time_stopped_flags_.color_flash_sound_played = true;  // Evita que suene múltiples veces
             }
         } else {
             // Fase normal - solo sonido ocasional
@@ -997,6 +989,7 @@ void Game::enableTimeStopItem() {
     balloon_manager_->stopAllBalloons();
     balloon_manager_->reverseColorsToAllBalloons();
     time_stopped_timer_ = TIME_STOPPED_DURATION_S;
+    time_stopped_flags_.reset();  // Resetea flags al activar el item
 }
 
 // Deshabilita el efecto del item de detener el tiempo
@@ -1890,6 +1883,10 @@ void Game::setState(State state) {
             destroyAllItems();                       // Destruye todos los items
             background_->setAlpha(0);                // Elimina el tono rojo de las últimas pantallas
             tabe_->disableSpawning();                // Deshabilita la creacion de Tabes
+            game_completed_flags_.reset();           // Resetea flags de juego completado
+            break;
+        case State::GAME_OVER:
+            game_over_flags_.reset();                // Resetea flags de game over
             break;
         default:
             break;
@@ -1951,20 +1948,11 @@ void Game::onPauseStateChanged(bool is_paused) {
 
 // Maneja eventos del juego completado usando flags para triggers únicos
 void Game::handleGameCompletedEvents() {
-    static bool start_celebrations_triggered = false;
-    static bool end_celebrations_triggered = false;
-
-    // Resetear
-    if (game_completed_timer_ == 0.0f) {
-        start_celebrations_triggered = false;
-        end_celebrations_triggered = false;
-    }
-
     constexpr float START_CELEBRATIONS_S = 6.0f;
     constexpr float END_CELEBRATIONS_S = 14.0f;
 
     // Inicio de celebraciones
-    if (!start_celebrations_triggered && game_completed_timer_ >= START_CELEBRATIONS_S) {
+    if (!game_completed_flags_.start_celebrations_triggered && game_completed_timer_ >= START_CELEBRATIONS_S) {
         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"));
 
@@ -1979,43 +1967,44 @@ void Game::handleGameCompletedEvents() {
 
         updateHiScore();
         playMusic("congratulations.ogg", 1);
-        start_celebrations_triggered = true;
+        game_completed_flags_.start_celebrations_triggered = true;
     }
 
     // Fin de celebraciones
-    if (!end_celebrations_triggered && game_completed_timer_ >= END_CELEBRATIONS_S) {
+    if (!game_completed_flags_.end_celebrations_triggered && game_completed_timer_ >= END_CELEBRATIONS_S) {
         for (auto &player : players_) {
             if (player->isCelebrating()) {
                 player->setPlayingState(player->qualifiesForHighScore() ? Player::State::ENTERING_NAME_GAME_COMPLETED : Player::State::LEAVING_SCREEN);
             }
         }
-        end_celebrations_triggered = true;
+        game_completed_flags_.end_celebrations_triggered = true;
     }
 }
 
-// Maneja eventos de game over usando flag para trigger único
+// Maneja eventos discretos basados en tiempo durante el estado game over
 void Game::handleGameOverEvents() {
-    static bool game_over_trigger1 = false;
+    constexpr float MESSAGE_TRIGGER_S = 1.5f;
-    static bool game_over_trigger2 = false;
+    constexpr float FADE_TRIGGER_S = GAME_OVER_DURATION_S - 2.5f;
 
-    // Resetear
+    // Trigger inicial: fade out de música y sonidos de globos
-    if (game_over_timer_ == 0.0f) {
+    if (!game_over_flags_.music_fade_triggered) {
-        game_over_trigger1 = false;
-        game_over_trigger2 = false;
-    }
-
-    if (!game_over_trigger1 && game_over_timer_ == 0.0f) {
         Audio::get()->fadeOutMusic(1000);
         balloon_manager_->setBouncingSounds(true);
-        game_over_trigger1 = true;
+        game_over_flags_.music_fade_triggered = true;
-    }
-    
-    if (!game_over_trigger2 && game_over_timer_ >= 1.5f) {
-        createMessage({paths_.at(10), paths_.at(11)}, Resource::get()->getTexture("game_text_game_over"));
-        playSound("voice_game_over.wav");
-        game_over_trigger2 = true;
     }
 
+    // Trigger del mensaje "Game Over"
+    if (!game_over_flags_.message_triggered && game_over_timer_ >= MESSAGE_TRIGGER_S) {
+        createMessage({paths_.at(10), paths_.at(11)}, Resource::get()->getTexture("game_text_game_over"));
+        playSound("voice_game_over.wav");
+        game_over_flags_.message_triggered = true;
+    }
+
+    // Trigger del fade out
+    if (!game_over_flags_.fade_out_triggered && game_over_timer_ >= FADE_TRIGGER_S && !fade_out_->isEnabled()) {
+        fade_out_->activate();
+        game_over_flags_.fade_out_triggered = true;
+    }
 }
 
 #ifdef _DEBUG

source/sections/game.h

@@ -165,6 +165,39 @@ class Game {
         std::vector<std::shared_ptr<Player>> players_to_put_at_front_;
         Hit hit_;  // Para representar colisiones en pantalla
 
+        // Estructuras para gestionar flags de eventos basados en tiempo
+        struct GameOverFlags {
+            bool music_fade_triggered = false;
+            bool message_triggered = false;
+            bool fade_out_triggered = false;
+
+            void reset() {
+                music_fade_triggered = false;
+                message_triggered = false;
+                fade_out_triggered = false;
+            }
+        } game_over_flags_;
+
+        struct GameCompletedFlags {
+            bool start_celebrations_triggered = false;
+            bool end_celebrations_triggered = false;
+
+            void reset() {
+                start_celebrations_triggered = false;
+                end_celebrations_triggered = false;
+            }
+        } game_completed_flags_;
+
+        struct TimeStoppedFlags {
+            bool color_flash_sound_played = false;
+            bool warning_phase_started = false;
+
+            void reset() {
+                color_flash_sound_played = false;
+                warning_phase_started = false;
+            }
+        } time_stopped_flags_;
+
 #ifdef _DEBUG
         bool auto_pop_balloons_ = false;  // Si es true, incrementa automaticamente los globos explotados
 #endif
@@ -185,7 +218,7 @@ class Game {
         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
+        void updateGameStateGameOver(float deltaTime);                // Gestiona las actualizaciones continuas del estado de fin de partida
 
         // --- Gestión de jugadores ---
         void initPlayers(Player::Id player_id);                    // Inicializa los datos de los jugadores
@@ -250,7 +283,7 @@ class Game {
         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 handleGameOverEvents();              // Maneja eventos discretos basados en tiempo durante game over
         void throwCoffee(int x, int y);           // Crea efecto de café arrojado al ser golpeado
 
         // --- Gestión de caída de ítems ---