jaildesigner-jailgames/coffee-crisis
1
0
Fork 1
Code Issues Pull Requests Projects Releases 14 Wiki Activity

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

Browse Source
This commit is contained in:
Sergio Valor
2026-05-19 18:10:15 +02:00
parent 4f7333ba46
commit 2a69eaf041
2 changed files with 40 additions and 521 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/game/game.cpp
+21 -482
View File
@@ -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
void Game::updateDeath() {
// 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.
// Actualiza el estado de muerte. 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
void Game::updateShakeEffect() {
if (effect_.shake) {
if (effect_.shake_counter > 0) {
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.
// Actualiza el efecto de agitar la pantalla. 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
void Game::updateEnemyDeployCounter() {
if (enemy_deploy_counter_ > 0) {
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.
// Actualiza la variable enemyDeployCounter. Decrementa a 60Hz fixe amb
// 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
void Game::update() {
// Actualiza el audio
Audio::update();
// 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.
// Actualiza el juego. 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
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).
// Actualiza el fondo. Velocitats dels núvols expressades com a px/s.
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
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)
// Actualiza el menu de pausa
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
void Game::updateLeavingPauseMenu() {
if (pause_counter_ > 0) { // El contador está descendiendo
const bool A = pause_counter_ == 90;
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).
// Rama de updatePausedGame: cuenta atrás de salida y vuelta al juego.
// 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
void Game::updateHelper() {
// 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.
// Actualiza las variables de ayuda. De moment cap timer real dins helper_;
// el dt_s queda reservat per a futurs comptadors d'helper.
void Game::updateHelper([[maybe_unused]] float dt_s) {
if (menace_current_ > 15) {
for (const auto *player : players_) {
source/game/game.h
+19 -39
View File
@@ -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 (time-based)
void update(float dt_s); // Actualiza el juego
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 (time-based)
void updatePlayers(float dt_s); // Actualiza las variables del jugador
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 (time-based)
void updateDeath(); // Actualiza el estado de muerte (frame-based)
void updateDeath(float dt_s); // Actualiza el estado de muerte (time-based)
void updateStage(float dt_s); // Actualiza las variables de la fase
void updateDeath(float dt_s); // Actualiza el estado de muerte
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 (time-based)
void updateBalloons(float dt_s); // Actualiza los globos
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 (time-based)
void moveBullets(float dt_s); // Mueve las balas activas
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 (time-based)
void updateItems(float dt_s); // Actualiza los items
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 (time-based)
void updateShakeEffect(float dt_s); // Actualiza el efecto de agitar la pantalla
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 (time-based)
void updateSmartSprites(float dt_s); // Actualiza los SmartSprites
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 (time-based)
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 updateEnemyDeployCounter(float dt_s); // Actualiza la variable EnemyDeployCounter
void updateTimeStoppedCounter(float dt_s); // Actualiza y comprueba el valor de la variable
void updateMenace(); // Gestiona el nivel de amenaza
void updateBackground(); // Actualiza el fondo (frame-based)
void updateBackground(float dt_s); // Actualiza el fondo (time-based)
void updateBackground(float dt_s); // Actualiza el fondo
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 (time-based)
void updateLeavingPauseMenu(); // Helper (frame-based)
void updateLeavingPauseMenu(float dt_s); // Helper (time-based)
void updatePauseMenuUI(); // Helper (frame-based)
void updatePauseMenuUI(float dt_s); // Helper (time-based)
void updatePausedGame(float dt_s); // Actualiza el menu de pausa
void updateLeavingPauseMenu(float dt_s); // Helper
void updatePauseMenuUI(float dt_s); // Helper
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 (time-based)
void updateGameOverScreen(float dt_s); // Actualiza game over
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 (time-based)
void updateHelper(); // Actualiza las variables de ayuda (frame-based)
void updateHelper(float dt_s); // Actualiza las variables de ayuda (time-based)
void updateGameCompleted(float dt_s); // Actualiza el tramo final de juego
void updateHelper(float dt_s); // Actualiza las variables de ayuda
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)
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)
float elapsed_s_{0.0F}; // Acumulador global de temps de joc
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