cleanup time-based: elimina Game update/sub-helpers frame-based i ticks_/ticks_speed_, deixant nomes les versions (dt_s)

source/game/game.cpp

@@ -150,9 +150,6 @@ Game::~Game() {
 
 // Inicializa las variables necesarias para la sección 'Game'
 void Game::init() {
-    ticks_ = 0;
-    ticks_speed_ = 15;
-
     // Elimina qualquier jugador que hubiese antes de crear los nuevos
     for (auto *player : players_) {
         delete player;
@@ -1442,28 +1439,6 @@ void Game::renderScoreBoard() {
 }
 
 // Actualiza las variables del jugador
-void Game::updatePlayers() {
-    for (auto *player : players_) {
-        player->update();
-
-        // Comprueba la colisión entre el jugador y los globos
-        if (checkPlayerBalloonCollision(player)) {
-            if (player->isAlive()) {
-                if (demo_.enabled) {
-                    section_->name = SECTION_PROG_TITLE;
-                    section_->subsection = SUBSECTION_TITLE_INSTRUCTIONS;
-                } else {
-                    killPlayer(player);
-                }
-            }
-        }
-
-        // Comprueba las colisiones entre el jugador y los items
-        checkPlayerItemCollision(player);
-    }
-}
-
-// Actualiza las variables del jugador (time-based)
 void Game::updatePlayers(float dt_s) {
     for (auto *player : players_) {
         player->update(dt_s);
@@ -1491,46 +1466,6 @@ void Game::renderPlayers() {
 }
 
 // Actualiza las variables de la fase
-void Game::updateStage() {
-    if (stage_[current_stage_].current_power >= stage_[current_stage_].power_to_complete) {
-        // Cambio de fase
-        current_stage_++;
-        last_stage_reached_ = current_stage_;
-        if (current_stage_ == 10) {                    // Ha llegado al final el juego
-            game_completed_ = true;                    // Marca el juego como completado
-            current_stage_ = 9;                        // Deja el valor dentro de los limites
-            stage_[current_stage_].current_power = 0;  // Deja el poder a cero para que no vuelva a entrar en esta condición
-            destroyAllBalloons();                      // Destruye a todos los enemigos
-            stage_[current_stage_].current_power = 0;  // Vuelve a dejar el poder a cero, por lo que hubiera podido subir al destruir todos lo globos
-            menace_current_ = 255;                     // Sube el nivel de amenaza para que no cree mas globos
-            for (auto *player : players_) {            // Añade un millon de puntos a los jugadores que queden vivos
-                if (player->isAlive()) {
-                    player->addScore(1000000);
-                }
-            }
-            updateHiScore();
-            Audio::get()->stopMusic();
-        }
-        Audio::get()->playSound(stage_change_sound_);
-        stage_bitmap_counter_ = 0;
-        enemy_speed_ = default_enemy_speed_;
-        setBalloonSpeed(enemy_speed_);
-        effect_.flash = true;
-        effect_.shake = true;
-    }
-
-    // Incrementa el contador del bitmap que aparece mostrando el cambio de fase
-    if (stage_bitmap_counter_ < STAGE_COUNTER) {
-        stage_bitmap_counter_++;
-    }
-
-    // Si el juego se ha completado, el bitmap se detiene en el centro de la pantalla
-    if (game_completed_) {
-        stage_bitmap_counter_ = std::min<int>(stage_bitmap_counter_, 100);
-    }
-}
-
-// Actualiza las variables de la fase (time-based)
 void Game::updateStage(float dt_s) {
     if (stage_[current_stage_].current_power >= stage_[current_stage_].power_to_complete) {
         current_stage_++;
@@ -1569,34 +1504,8 @@ void Game::updateStage(float dt_s) {
     }
 }
 
-// Actualiza el estado de muerte
+// Actualiza el estado de muerte. Detecta el creuament dels llindars 250/200/180/120/60
-void Game::updateDeath() {
+// (en frames) per a reproduir els bubbles als mateixos moments.
-    // Comprueba si todos los jugadores estan muertos
-    bool all_dead = true;
-    for (const auto *player : players_) {
-        all_dead &= (!player->isAlive());
-    }
-
-    if (all_dead) {
-        if (death_counter_ > 0) {
-            death_counter_--;
-
-            if ((death_counter_ == 250) || (death_counter_ == 200) || (death_counter_ == 180) || (death_counter_ == 120) || (death_counter_ == 60)) {
-                // Hace sonar aleatoriamente uno de los 4 sonidos de burbujas
-                if (!demo_.enabled) {
-                    const Uint8 INDEX = rand() % 4;
-                    Ja::Sound *sound[4] = {bubble1_sound_, bubble2_sound_, bubble3_sound_, bubble4_sound_};
-                    Audio::get()->playSound(sound[INDEX]);
-                }
-            }
-        } else {
-            section_->subsection = SUBSECTION_GAME_GAMEOVER;
-        }
-    }
-}
-
-// Actualiza el estado de muerte (time-based). Detecta el creuament dels llindars
-// 250/200/180/120/60 (en frames) per a reproduir els bubbles als mateixos moments.
 void Game::updateDeath(float dt_s) {
     bool all_dead = true;
     for (const auto *player : players_) {
@@ -1654,13 +1563,6 @@ void Game::renderDeathFade(int counter) {  // Counter debe ir de 0 a 150
 }
 
 // Actualiza los globos
-void Game::updateBalloons() {
-    for (auto *balloon : balloons_) {
-        balloon->update();
-    }
-}
-
-// Actualiza los globos (time-based)
 void Game::updateBalloons(float dt_s) {
     for (auto *balloon : balloons_) {
         balloon->update(dt_s);
@@ -2016,17 +1918,6 @@ void Game::resolveBulletBalloonHit(Bullet *bullet, Balloon *balloon) {
 }
 
 // Mueve las balas activas
-void Game::moveBullets() {
-    for (auto *bullet : bullets_) {
-        if (bullet->isEnabled()) {
-            if (bullet->move() == Bullet::MoveResult::OUT) {
-                players_[bullet->getOwner()]->decScoreMultiplier();
-            }
-        }
-    }
-}
-
-// Mueve las balas activas (time-based)
 void Game::moveBullets(float dt_s) {
     for (auto *bullet : bullets_) {
         if (bullet->isEnabled()) {
@@ -2065,19 +1956,6 @@ void Game::freeBullets() {
 }
 
 // Actualiza los items
-void Game::updateItems() {
-    for (auto *item : items_) {
-        if (item->isEnabled()) {
-            item->update();
-            if (item->isOnFloor()) {
-                Audio::get()->playSound(coffee_machine_sound_);
-                effect_.shake = true;
-            }
-        }
-    }
-}
-
-// Actualiza los items (time-based)
 void Game::updateItems(float dt_s) {
     for (auto *item : items_) {
         if (item->isEnabled()) {
@@ -2203,22 +2081,10 @@ void Game::renderFlashEffect() {
     }
 }
 
-// Actualiza el efecto de agitar la pantalla
+// Actualiza el efecto de agitar la pantalla. Decrementa `shake_counter` a
-void Game::updateShakeEffect() {
+// cadència fixa de 60Hz amb un acumulador de fase (independent del framerate)
-    if (effect_.shake) {
+// — el render de `updateBackground` segueix llegint la paritat del counter
-        if (effect_.shake_counter > 0) {
+// per fer vibrar els edificis.
-            effect_.shake_counter--;
-        } else {
-            effect_.shake = false;
-            effect_.shake_counter = SHAKE_COUNTER;
-        }
-    }
-}
-
-// Actualiza el efecto de agitar la pantalla (time-based). Decrementa
-// `shake_counter` a cadència fixa de 60Hz amb un acumulador de fase
-// (independent del framerate) — el render de `updateBackground` segueix
-// llegint la paritat del counter per fer vibrar els edificis.
 void Game::updateShakeEffect(float dt_s) {
     if (!effect_.shake) {
         shake_phase_s_ = 0.0F;
@@ -2265,13 +2131,6 @@ void Game::throwCoffee(int x, int y) {
 }
 
 // Actualiza los SmartSprites
-void Game::updateSmartSprites() {
-    for (auto *ss : smart_sprites_) {
-        ss->update();
-    }
-}
-
-// Actualiza los SmartSprites (time-based)
 void Game::updateSmartSprites(float dt_s) {
     for (auto *ss : smart_sprites_) {
         ss->update(dt_s);
@@ -2375,18 +2234,6 @@ void Game::incTimeStoppedCounter(Uint16 value) {
 }
 
 // Actualiza y comprueba el valor de la variable
-void Game::updateTimeStoppedCounter() {
-    if (isTimeStopped()) {
-        if (time_stopped_counter_ > 0) {
-            time_stopped_counter_--;
-            stopAllBalloons(TIME_STOPPED_COUNTER);
-        } else {
-            disableTimeStopItem();
-        }
-    }
-}
-
-// Actualiza y comprueba el valor de la variable (time-based)
 void Game::updateTimeStoppedCounter(float dt_s) {
     if (!isTimeStopped()) { return; }
     if (time_stopped_counter_s_ > 0.0F) {
@@ -2398,16 +2245,9 @@ void Game::updateTimeStoppedCounter(float dt_s) {
     }
 }
 
-// Actualiza la variable enemyDeployCounter
+// Actualiza la variable enemyDeployCounter. Decrementa a 60Hz fixe amb
-void Game::updateEnemyDeployCounter() {
+// acumulador de fase — és un comptador discret consultat per
-    if (enemy_deploy_counter_ > 0) {
+// `canPowerBallBeCreated()` i altres.
-        enemy_deploy_counter_--;
-    }
-}
-
-// Actualiza enemy_deploy_counter_ (time-based). El comptador es decrementa
-// a cadència fixa de 60Hz amb un acumulador de fase: és un comptador
-// discret consultat per `canPowerBallBeCreated()` i altres.
 void Game::updateEnemyDeployCounter(float dt_s) {
     if (enemy_deploy_counter_ <= 0) { return; }
     constexpr float STEP_S = 1.0F / 60.0F;
@@ -2418,87 +2258,10 @@ void Game::updateEnemyDeployCounter(float dt_s) {
     }
 }
 
-// Actualiza el juego
+// Actualiza el juego. La cadència la dicta dt_s, propagat des de iterate()
-void Game::update() {
+// via DeltaTime::tick(). El comptador global `counter_` queda derivat de
-    // Actualiza el audio
+// `elapsed_s_*60` perquè els lectors existents (render de l'herba, paths del
-    Audio::update();
+// get_ready, etc.) segueixin valuant.
-
-    // Actualiza los efectos basados en tiempo real (no en el throttle del juego)
-    updateDeathShake();
-    updateDeathSequence();
-
-    // Durante la secuencia de muerte, congela el resto del juego
-    if (death_sequence_.phase == DeathPhase::SHAKING || death_sequence_.phase == DeathPhase::WAITING) {
-        return;
-    }
-
-    // Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
-    if (SDL_GetTicks() - ticks_ > ticks_speed_) {
-        // Actualiza el contador de ticks
-        ticks_ = SDL_GetTicks();
-
-        // Actualiza el contador de juego
-        counter_++;
-
-        // Comprueba el teclado/mando
-        checkGameInput();
-
-        // Actualiza las variables del jugador
-        updatePlayers();
-
-        // Actualiza el fondo
-        updateBackground();
-
-        // Mueve los globos
-        updateBalloons();
-
-        // Mueve las balas
-        moveBullets();
-
-        // Actualiza los items
-        updateItems();
-
-        // Actualiza el valor de currentStage
-        updateStage();
-
-        // Actualiza el estado de muerte
-        updateDeath();
-
-        // Actualiza los SmartSprites
-        updateSmartSprites();
-
-        // Actualiza los contadores de estado y efectos
-        updateTimeStoppedCounter();
-        updateEnemyDeployCounter();
-        updateShakeEffect();
-
-        // Actualiza el ayudante
-        updateHelper();
-
-        // Comprueba las colisiones entre globos y balas
-        checkBulletBalloonCollision();
-
-        // Comprueba el nivel de amenaza para ver si se han de crear nuevos enemigos
-        updateMenace();
-
-        // Actualiza la velocidad de los enemigos
-        updateBalloonSpeed();
-
-        // Actualiza el tramo final de juego, una vez completado
-        updateGameCompleted();
-
-        // Vacia los vectores
-        freeBullets();
-        freeBalloons();
-        freeItems();
-        freeSmartSprites();
-    }
-}
-
-// Actualiza el juego (time-based). Sense el gate del SDL_GetTicks: la cadència
-// la dicta dt_s, propagat des de iterate() via DeltaTime::tick(). El comptador
-// global `counter_` queda derivat de `elapsed_s_*60` perquè els lectors
-// existents (render de l'herba, paths del get_ready, etc.) segueixin valuant.
 void Game::update(float dt_s) {
     Audio::update();
 
@@ -2537,68 +2300,7 @@ void Game::update(float dt_s) {
     freeSmartSprites();
 }
 
-// Actualiza el fondo
+// Actualiza el fondo. Velocitats dels núvols expressades com a px/s.
-void Game::updateBackground() {
-    if (!game_completed_) {  // Si el juego no esta completo, la velocidad de las nubes es igual a los globos explotados
-        clouds_speed_ = balloons_popped_;
-    } else {  // Si el juego está completado, se reduce la velocidad de las nubes
-        if (clouds_speed_ > 400) {
-            clouds_speed_ -= 25;
-        } else {
-            clouds_speed_ = 200;
-        }
-    }
-
-    // Calcula la velocidad en función de los globos explotados y el total de globos a explotar para acabar el juego
-    const float SPEED = (-0.2F) + (-3.00F * ((float)clouds_speed_ / (float)total_power_to_complete_game_));
-
-    // Aplica la velocidad calculada a las nubes (px/frame)
-    clouds1_a_->setVelX(SPEED);
-    clouds1_b_->setVelX(SPEED);
-    clouds2_a_->setVelX(SPEED / 2);
-    clouds2_b_->setVelX(SPEED / 2);
-
-    // Mueve las nubes (frame-based)
-    clouds1_a_->move();
-    clouds1_b_->move();
-    clouds2_a_->move();
-    clouds2_b_->move();
-
-    // Calcula el offset de las nubes
-    if (clouds1_a_->getPosX() < -clouds1_a_->getWidth()) {
-        clouds1_a_->setPosX(clouds1_a_->getWidth());
-    }
-
-    if (clouds1_b_->getPosX() < -clouds1_b_->getWidth()) {
-        clouds1_b_->setPosX(clouds1_b_->getWidth());
-    }
-
-    if (clouds2_a_->getPosX() < -clouds2_a_->getWidth()) {
-        clouds2_a_->setPosX(clouds2_a_->getWidth());
-    }
-
-    if (clouds2_b_->getPosX() < -clouds2_b_->getWidth()) {
-        clouds2_b_->setPosX(clouds2_b_->getWidth());
-    }
-
-    // Calcula el frame de la hierba
-    grass_sprite_->setSpriteClip(0, (6 * (counter_ / 20 % 2)), 256, 6);
-
-    // Mueve los edificios en funcion de si está activo el efecto de agitarlos
-    if (death_shake_.active) {
-        const int V[] = {-1, 1, -1, 1, -1, 1, -1, 0};
-        buildings_sprite_->setPosX(V[death_shake_.step]);
-    } else if (effect_.shake) {
-        buildings_sprite_->setPosX(((effect_.shake_counter % 2) * 2) - 1);
-    } else {
-        buildings_sprite_->setPosX(0);
-    }
-}
-
-// Actualiza el fondo (time-based). Velocitats dels núvols expressades com a
-// px/frame (la conversió a px/s la fa cloud->move(dt_s) multiplicant per 60
-// internament — perquè MovingSprite comparteix vx_ entre frame i time-based,
-// aquí passem la mateixa "velocitat per frame" * 60).
 void Game::updateBackground(float dt_s) {
     if (!game_completed_) {
         clouds_speed_ = balloons_popped_;
@@ -3057,24 +2759,7 @@ void Game::run() {
     }
 }
 
-// Actualiza las variables del menu de pausa del juego
+// Actualiza el menu de pausa
-void Game::updatePausedGame() {
-    if (SDL_GetTicks() - ticks_ <= ticks_speed_) {
-        return;
-    }
-    ticks_ = SDL_GetTicks();
-
-    // Atalls globals (zoom finestra, fullscreen, shaders, presets, ...)
-    GlobalInputs::handle();
-
-    if (leaving_pause_menu_) {
-        updateLeavingPauseMenu();
-    } else {
-        updatePauseMenuUI();
-    }
-}
-
-// Actualiza el menu de pausa (time-based)
 void Game::updatePausedGame(float dt_s) {
     GlobalInputs::handle();
 
@@ -3085,31 +2770,10 @@ void Game::updatePausedGame(float dt_s) {
     }
 }
 
-// Rama de updatePausedGame: cuenta atrás de salida y vuelta al juego
+// Rama de updatePausedGame: cuenta atrás de salida y vuelta al juego.
-void Game::updateLeavingPauseMenu() {
+// Decrementa pause_counter_ a 60Hz exactes amb un acumulador de fase per a
-    if (pause_counter_ > 0) {  // El contador está descendiendo
+// mantenir els sons de rellotge als llindars originals (90, 60, 30 frames =
-        const bool A = pause_counter_ == 90;
+// 1.5s, 1.0s, 0.5s restants).
-        const bool B = pause_counter_ == 60;
-        const bool C = pause_counter_ == 30;
-        if (A || B || C) {
-            Audio::get()->playSound(clock_sound_);
-        }
-        pause_counter_--;
-        return;
-    }
-
-    // Ha finalizado el contador
-    section_->name = SECTION_PROG_GAME;
-    section_->subsection = num_players_ == 1 ? SUBSECTION_GAME_PLAY_1P : SUBSECTION_GAME_PLAY_2P;
-
-    if (Audio::getRealMusicState() == Audio::MusicState::PAUSED) {
-        Audio::get()->resumeMusic();
-    }
-}
-
-// Cuenta atrás de salida (time-based). Decrementa pause_counter_ a 60Hz exactes
-// amb un acumulador de fase, per a mantenir els sons de rellotge als llindars
-// originals (90, 60, 30 frames = 1.5s, 1.0s, 0.5s restants).
 void Game::updateLeavingPauseMenu(float dt_s) {
     if (pause_counter_ <= 0) {
         section_->name = SECTION_PROG_GAME;
@@ -3169,46 +2833,6 @@ void Game::updatePauseMenuUI(float dt_s) {
     }
 }
 
-// Rama de updatePausedGame: lógica del menú de pausa (frame-based)
-void Game::updatePauseMenuUI() {
-    pause_menu_->update();
-    pause_menu_->checkInput();
-
-    // F12 (Action::PAUSE) també tanca el menú de pausa — mateix comportament
-    // que seleccionar "Continue" / cancel·lar amb BACKSPACE.
-    if (Input::get()->checkInput(Input::Action::PAUSE, Input::Repeat::OFF)) {
-        leaving_pause_menu_ = true;
-        if (!Options::gameplay.pause_countdown) {
-            pause_counter_ = 0;
-        }
-        return;
-    }
-
-    switch (pause_menu_->getItemSelected()) {
-        case 1:
-            leaving_pause_menu_ = true;
-            if (!Options::gameplay.pause_countdown) {
-                pause_counter_ = 0;  // salta el compte enrere de 3 segons
-            }
-            break;
-
-        case 2:
-            fade_->setFadeType(Fade::Type::CENTER);
-            fade_->activateFade();
-            break;
-
-        default:
-            break;
-    }
-
-    fade_->update();
-    if (fade_->hasEnded()) {
-        section_->name = SECTION_PROG_TITLE;
-        section_->subsection = SUBSECTION_TITLE_1;
-        Audio::get()->stopMusic();
-    }
-}
-
 // Dibuja el menu de pausa del juego
 void Game::renderPausedGame() {
     // Prepara para empezar a dibujar en la textura de juego
@@ -3269,65 +2893,6 @@ void Game::enterPausedGame() {
 }
 
 // Actualiza los elementos de la pantalla de game over
-void Game::updateGameOverScreen() {
-    // Calcula la lógica de los objetos
-    if (SDL_GetTicks() - ticks_ > ticks_speed_) {
-        // Actualiza el contador de ticks
-        ticks_ = SDL_GetTicks();
-
-        // Atalls globals (zoom finestra, fullscreen, shaders, presets, ...)
-        GlobalInputs::handle();
-
-        // Actualiza la lógica del menu
-        game_over_menu_->update();
-
-        // Actualiza el fade
-        fade_->update();
-
-        // Si ha terminado el fade, actua segun se haya operado
-        if (fade_->hasEnded()) {
-            switch (game_over_post_fade_) {
-                case 0:  // YES
-                    section_->name = SECTION_PROG_GAME;
-                    deleteAllVectorObjects();
-                    init();
-                    section_->subsection = num_players_ == 1 ? SUBSECTION_GAME_PLAY_1P : SUBSECTION_GAME_PLAY_2P;
-                    break;
-
-                case 1:  // NO
-                    section_->name = SECTION_PROG_TITLE;
-                    section_->subsection = SUBSECTION_TITLE_1;
-                    break;
-
-                default:
-                    break;
-            }
-        }
-
-        // Comprueba las entradas para el menu solo si no esta el juego completo
-        if (!game_completed_) {
-            game_over_menu_->checkInput();
-
-            // Comprueba si se ha seleccionado algún item del menú
-            switch (game_over_menu_->getItemSelected()) {
-                case 0:  // YES
-                    game_over_post_fade_ = 0;
-                    fade_->activateFade();
-                    break;
-
-                case 1:  // NO
-                    game_over_post_fade_ = 1;
-                    fade_->activateFade();
-                    break;
-
-                default:
-                    break;
-            }
-        }
-    }
-}
-
-// Actualiza los elementos de la pantalla de game over (time-based)
 void Game::updateGameOverScreen(float dt_s) {
     GlobalInputs::handle();
 
@@ -3505,17 +3070,6 @@ void Game::initPaths() {
 }
 
 // Actualiza el tramo final de juego, una vez completado
-void Game::updateGameCompleted() {
-    if (game_completed_) {
-        game_completed_counter_++;
-    }
-
-    if (game_completed_counter_ == GAME_COMPLETED_END) {
-        section_->subsection = SUBSECTION_GAME_GAMEOVER;
-    }
-}
-
-// Actualiza el tramo final de juego (time-based)
 void Game::updateGameCompleted(float dt_s) {
     if (!game_completed_) { return; }
 
@@ -3528,23 +3082,8 @@ void Game::updateGameCompleted(float dt_s) {
     }
 }
 
-// Actualiza las variables de ayuda
+// Actualiza las variables de ayuda. De moment cap timer real dins helper_;
-void Game::updateHelper() {
+// el dt_s queda reservat per a futurs comptadors d'helper.
-    // Solo ofrece ayuda cuando la amenaza es elevada
-    if (menace_current_ > 15) {
-        for (const auto *player : players_) {
-            helper_.need_coffee = player->getCoffees() == 0;
-
-            helper_.need_coffee_machine = !player->isPowerUp();
-        }
-    } else {
-        helper_.need_coffee = false;
-        helper_.need_coffee_machine = false;
-    }
-}
-
-// Actualiza las variables de ayuda (time-based). De moment cap timer real
-// dins helper_; clonem la lògica per consistència d'API.
 void Game::updateHelper([[maybe_unused]] float dt_s) {
     if (menace_current_ > 15) {
         for (const auto *player : players_) {

source/game/game.h

@@ -146,8 +146,7 @@ class Game {
         DemoKeys data_file[TOTAL_DEMO_DATA];  // Datos del fichero con los movimientos para la demo
     };
 
-    void update();            // Actualiza el juego (frame-based)
+    void update(float dt_s);  // Actualiza el juego
-    void update(float dt_s);  // Actualiza el juego (time-based)
     void render();            // Dibuja el juego
     void init();              // Inicializa las variables necesarias para la sección 'Game'
     void loadMedia();         // Carga los recursos necesarios para la sección 'Game'
@@ -173,18 +172,14 @@ class Game {
     static auto updateScoreText(Uint32 num) -> std::string;  // Transforma un valor numérico en una cadena de 6 cifras
     void renderScoreBoard();                                 // Pinta el marcador en pantalla usando un objeto texto
 
-    void updatePlayers();            // Actualiza las variables del jugador (frame-based)
+    void updatePlayers(float dt_s);  // Actualiza las variables del jugador
-    void updatePlayers(float dt_s);  // Actualiza las variables del jugador (time-based)
     void renderPlayers();            // Dibuja a los jugadores
 
-    void updateStage();                 // Actualiza las variables de la fase (frame-based)
+    void updateStage(float dt_s);       // Actualiza las variables de la fase
-    void updateStage(float dt_s);       // Actualiza las variables de la fase (time-based)
+    void updateDeath(float dt_s);       // Actualiza el estado de muerte
-    void updateDeath();                 // Actualiza el estado de muerte (frame-based)
-    void updateDeath(float dt_s);       // Actualiza el estado de muerte (time-based)
     void renderDeathFade(int counter);  // Renderiza el fade final cuando se acaba la partida
 
-    void updateBalloons();                                                                                     // Actualiza los globos (frame-based)
+    void updateBalloons(float dt_s);                                                                           // Actualiza los globos
-    void updateBalloons(float dt_s);                                                                           // Actualiza los globos (time-based)
     void renderBalloons();                                                                                     // Pinta en pantalla todos los globos activos
     auto createBalloon(float x, float y, Uint8 kind, float velx, float speed, Uint16 creationtimer) -> Uint8;  // Crea un globo nuevo en el vector de globos
     void createPowerBall();                                                                                    // Crea una PowerBall
@@ -203,14 +198,12 @@ class Game {
     void checkBulletBalloonCollision();                              // Comprueba la colisión entre las balas y los globos
     void resolveBulletBalloonHit(Bullet *bullet, Balloon *balloon);  // Resuelve un impacto bala-globo (helper de checkBulletBalloonCollision)
 
-    void moveBullets();                                                              // Mueve las balas activas (frame-based)
+    void moveBullets(float dt_s);                                                    // Mueve las balas activas
-    void moveBullets(float dt_s);                                                    // Mueve las balas activas (time-based)
     void renderBullets();                                                            // Pinta las balas activas
     void createBullet(int x, int y, Bullet::Kind kind, bool powered_up, int owner);  // Crea un objeto bala
     void freeBullets();                                                              // Vacia el vector de balas
 
-    void updateItems();                                // Actualiza los items (frame-based)
+    void updateItems(float dt_s);                      // Actualiza los items
-    void updateItems(float dt_s);                      // Actualiza los items (time-based)
     void renderItems();                                // Pinta los items activos
     auto dropItem() -> Item::Id;                       // Devuelve un item en función del azar
     void createItem(Item::Id kind, float x, float y);  // Crea un objeto item
@@ -220,11 +213,9 @@ class Game {
     void freeSmartSprites();                                              // Vacia el vector de smartsprites
 
     void renderFlashEffect();             // Dibuja el efecto de flash
-    void updateShakeEffect();             // Actualiza el efecto de agitar la pantalla (frame-based)
+    void updateShakeEffect(float dt_s);   // Actualiza el efecto de agitar la pantalla
-    void updateShakeEffect(float dt_s);   // Actualiza el efecto de agitar la pantalla (time-based)
     void throwCoffee(int x, int y);       // Crea un SmartSprite para arrojar el item café al recibir un impacto
-    void updateSmartSprites();            // Actualiza los SmartSprites (frame-based)
+    void updateSmartSprites(float dt_s);  // Actualiza los SmartSprites
-    void updateSmartSprites(float dt_s);  // Actualiza los SmartSprites (time-based)
     void renderSmartSprites();            // Pinta los SmartSprites activos
 
     void killPlayer(Player *player);                // Acciones a realizar cuando el jugador muere
@@ -236,13 +227,10 @@ class Game {
     void setTimeStoppedCounter(Uint16 value);          // Establece el valor de la variable
     void incTimeStoppedCounter(Uint16 value);          // Incrementa el valor de la variable
 
-    void updateEnemyDeployCounter();            // Actualiza la variable EnemyDeployCounter (frame-based)
+    void updateEnemyDeployCounter(float dt_s);  // Actualiza la variable EnemyDeployCounter
-    void updateEnemyDeployCounter(float dt_s);  // Actualiza la variable EnemyDeployCounter (time-based)
+    void updateTimeStoppedCounter(float dt_s);  // Actualiza y comprueba el valor de la variable
-    void updateTimeStoppedCounter();            // Actualiza y comprueba el valor de la variable (frame-based)
-    void updateTimeStoppedCounter(float dt_s);  // Actualiza y comprueba el valor de la variable (time-based)
     void updateMenace();                        // Gestiona el nivel de amenaza
-    void updateBackground();                    // Actualiza el fondo (frame-based)
+    void updateBackground(float dt_s);          // Actualiza el fondo
-    void updateBackground(float dt_s);          // Actualiza el fondo (time-based)
     void renderBackground();                    // Dibuja el fondo
 
     void checkGameInput();                               // Gestiona la entrada durante el juego
@@ -258,27 +246,21 @@ class Game {
     [[nodiscard]] auto isDeathShaking() const -> bool;  // Indica si el efecto de agitación intensa está activo
     void updateDeathSequence();                         // Actualiza la secuencia de muerte del jugador
 
-    void updatePausedGame();                  // Actualiza el menu de pausa (frame-based)
+    void updatePausedGame(float dt_s);        // Actualiza el menu de pausa
-    void updatePausedGame(float dt_s);        // Actualiza el menu de pausa (time-based)
+    void updateLeavingPauseMenu(float dt_s);  // Helper
-    void updateLeavingPauseMenu();            // Helper (frame-based)
+    void updatePauseMenuUI(float dt_s);       // Helper
-    void updateLeavingPauseMenu(float dt_s);  // Helper (time-based)
-    void updatePauseMenuUI();                 // Helper (frame-based)
-    void updatePauseMenuUI(float dt_s);       // Helper (time-based)
     void renderPausedGame();                  // Dibuja el menu de pausa del juego
     void enterPausedGame();                   // Inicializa el estado de pausa del juego
 
-    void updateGameOverScreen();            // Actualiza game over (frame-based)
+    void updateGameOverScreen(float dt_s);  // Actualiza game over
-    void updateGameOverScreen(float dt_s);  // Actualiza game over (time-based)
     void renderGameOverScreen();            // Dibuja los elementos de la pantalla de game over
     void enterGameOverScreen();             // Inicializa el estado de game over
 
     auto canPowerBallBeCreated() -> bool;  // Indica si se puede crear una powerball
     auto calculateScreenPower() -> int;    // Calcula el poder actual de los globos en pantalla
     void initPaths();                      // Inicializa las variables que contienen puntos de ruta para mover objetos
-    void updateGameCompleted();            // Actualiza el tramo final de juego (frame-based)
+    void updateGameCompleted(float dt_s);  // Actualiza el tramo final de juego
-    void updateGameCompleted(float dt_s);  // Actualiza el tramo final de juego (time-based)
+    void updateHelper(float dt_s);         // Actualiza las variables de ayuda
-    void updateHelper();                   // Actualiza las variables de ayuda (frame-based)
-    void updateHelper(float dt_s);         // Actualiza las variables de ayuda (time-based)
     auto allPlayersAreDead() -> bool;      // Comprueba si todos los jugadores han muerto
     void deleteAllVectorObjects();         // Elimina todos los objetos contenidos en vectores
     void setHiScore();                     // Establece la máxima puntuación desde fichero o desde las puntuaciones online
@@ -360,9 +342,7 @@ class Game {
 
     // Variables
     int num_players_;                                             // Numero de jugadores
-    Uint32 ticks_;                                                // Contador de ticks para ajustar la velocidad del programa (frame-based)
+    float elapsed_s_{0.0F};                                       // Acumulador global de temps de joc
-    Uint8 ticks_speed_;                                           // Velocidad a la que se repiten los bucles del programa (frame-based)
-    float elapsed_s_{0.0F};                                       // Acumulador global de temps de joc (time-based)
     Uint32 hi_score_;                                             // Puntuación máxima
     bool hi_score_achieved_;                                      // Indica si se ha superado la puntuación máxima
     std::string hi_score_name_;                                   // Nombre del jugador que ostenta la máxima puntuación