From 2b57bfa4ddb1ba9d55ab0b64ec6e3c3db8293a8a Mon Sep 17 00:00:00 2001 From: Sergio Valor Date: Mon, 18 May 2026 22:46:41 +0200 Subject: [PATCH] time-based: migrada escena Intro (dual-API a MovingSprite/SmartSprite/Writer, constants a 60Hz) --- source/core/rendering/movingsprite.cpp | 21 +++++ source/core/rendering/movingsprite.h | 12 +-- source/core/rendering/smartsprite.cpp | 34 ++++++++ source/core/rendering/smartsprite.h | 41 +++++----- source/core/rendering/writer.cpp | 40 +++++++++ source/core/rendering/writer.h | 41 ++++++---- source/game/scenes/intro.cpp | 107 +++++++++++++++---------- source/game/scenes/intro.h | 12 ++- 8 files changed, 218 insertions(+), 90 deletions(-) diff --git a/source/core/rendering/movingsprite.cpp b/source/core/rendering/movingsprite.cpp index 8a6ea30..6325ef2 100644 --- a/source/core/rendering/movingsprite.cpp +++ b/source/core/rendering/movingsprite.cpp @@ -53,6 +53,21 @@ void MovingSprite::move() { } } +// Time-based: vx_/vy_ en px/s, ax_/ay_ en px/s^2. Integració d'Euler +// senzilla — suficient per a moviments sense col·lisions sensibles. +void MovingSprite::move(float dt_s) { + if (enabled_) { + x_prev_ = x_; + y_prev_ = y_; + + x_ += vx_ * dt_s; + y_ += vy_ * dt_s; + + vx_ += ax_ * dt_s; + vy_ += ay_ * dt_s; + } +} + // Muestra el sprite por pantalla void MovingSprite::render() { if (enabled_) { @@ -226,6 +241,12 @@ void MovingSprite::update() { } } +// Time-based: nomes move(dt). La rotacio time-based s'integrara quan +// migrem la escena que la requereix (Game/PowerBall). +void MovingSprite::update(float dt_s) { + move(dt_s); +} + // Cambia el sentido de la rotación void MovingSprite::switchRotate() { rotate_amount_ *= -1; diff --git a/source/core/rendering/movingsprite.h b/source/core/rendering/movingsprite.h index 5e3fdc8..08b96ef 100644 --- a/source/core/rendering/movingsprite.h +++ b/source/core/rendering/movingsprite.h @@ -10,11 +10,13 @@ class MovingSprite : public Sprite { public: explicit MovingSprite(float x = 0, float y = 0, int w = 0, int h = 0, float velx = 0, float vely = 0, float accelx = 0, float accely = 0, Texture *texture = nullptr, SDL_Renderer *renderer = nullptr); // Constructor - void move(); // Mueve el sprite - void rotate(); // Rota el sprite - virtual void update(); // Actualiza las variables internas del objeto - void clear(); // Reinicia todas las variables - void render() override; // Muestra el sprite por pantalla + void move(); // Mueve el sprite (frame-based, depreca) + void move(float dt_s); // Mueve el sprite (time-based: vx/vy/ax/ay en px/s i px/s^2) + void rotate(); // Rota el sprite (frame-based, depreca) + virtual void update(); // Actualiza las variables internas del objeto (frame-based) + virtual void update(float dt_s); // Actualiza les variables internes (time-based, només move; rotate per migrar al seu torn) + void clear(); // Reinicia todas las variables + void render() override; // Muestra el sprite por pantalla // cppcheck-suppress duplInheritedMember ; shadow intencional: Sprite::getPosX retorna int (sprites estàtics), MovingSprite::getPosX retorna float (sub-pixel). No s'accedeix via Sprite*: la jerarquia de joc treballa amb el tipus concret [[nodiscard]] auto getPosX() const -> float; // Obten el valor de la variable diff --git a/source/core/rendering/smartsprite.cpp b/source/core/rendering/smartsprite.cpp index e19e245..fb969b6 100644 --- a/source/core/rendering/smartsprite.cpp +++ b/source/core/rendering/smartsprite.cpp @@ -38,6 +38,18 @@ void SmartSprite::update() { } } +// Time-based: la velocitat i acceleració són en px/s i px/s^2; el temps de +// permanència després d'arribar al destí ve donat per setRemainingTime(). +void SmartSprite::update(float dt_s) { + if (enabled_) { + // NOLINTNEXTLINE(bugprone-parent-virtual-call): vegeu update() per al motiu del salt + MovingSprite::update(dt_s); + + checkMove(); + checkFinishedTimeBased(dt_s); + } +} + // Pinta el objeto en pantalla void SmartSprite::render() { if (enabled_) { @@ -56,6 +68,15 @@ void SmartSprite::setEnabledCounter(int value) { enabled_counter_ = value; } +// Time-based: temps de visibilitat post-arribada +void SmartSprite::setRemainingTime(float seconds) { + remaining_time_s_ = seconds; +} + +auto SmartSprite::getRemainingTime() const -> float { + return remaining_time_s_; +} + // Establece el valor de la variable void SmartSprite::setDestX(int x) { dest_x_ = x; @@ -143,6 +164,19 @@ void SmartSprite::checkFinished() { } } +// Time-based: decrementa el temps restant cada crida si està al destí +void SmartSprite::checkFinishedTimeBased(float dt_s) { + on_destination_ = getPosX() == dest_x_ && getPosY() == dest_y_; + + if (on_destination_) { + if (remaining_time_s_ <= 0.0F) { + finished_ = true; + } else { + remaining_time_s_ -= dt_s; + } + } +} + // Obtiene el valor de la variable auto SmartSprite::isOnDestination() const -> bool { return on_destination_; diff --git a/source/core/rendering/smartsprite.h b/source/core/rendering/smartsprite.h index ceec070..01286cd 100644 --- a/source/core/rendering/smartsprite.h +++ b/source/core/rendering/smartsprite.h @@ -10,27 +10,32 @@ class SmartSprite : public AnimatedSprite { public: SmartSprite(Texture *texture, SDL_Renderer *renderer); // Constructor - void init(); // Inicializa el objeto - void update() override; // Actualiza la posición y comprueba si ha llegado a su destino - void render() override; // Pinta el objeto en pantalla + void init(); // Inicializa el objeto + void update() override; // Actualiza la posicion (frame-based) + void update(float dt_s) override; // Actualiza la posicion (time-based) + void render() override; // Pinta el objeto en pantalla - [[nodiscard]] auto getEnabledCounter() const -> int; // Obtiene el valor de la variable - void setEnabledCounter(int value); // Establece el valor de la variable - void setDestX(int x); // Establece el valor de la variable - void setDestY(int y); // Establece el valor de la variable - [[nodiscard]] auto getDestX() const -> int; // Obtiene el valor de la variable - [[nodiscard]] auto getDestY() const -> int; // Obtiene el valor de la variable - [[nodiscard]] auto isOnDestination() const -> bool; // Obtiene el valor de la variable - [[nodiscard]] auto hasFinished() const -> bool; // Obtiene el valor de la variable + [[nodiscard]] auto getEnabledCounter() const -> int; // Obtiene el valor de la variable + void setEnabledCounter(int value); // Establece el valor de la variable + void setRemainingTime(float seconds); // Time-based: temps que es queda visible despres d'arribar al desti + [[nodiscard]] auto getRemainingTime() const -> float; // Time-based: temps restant + void setDestX(int x); // Establece el valor de la variable + void setDestY(int y); // Establece el valor de la variable + [[nodiscard]] auto getDestX() const -> int; // Obtiene el valor de la variable + [[nodiscard]] auto getDestY() const -> int; // Obtiene el valor de la variable + [[nodiscard]] auto isOnDestination() const -> bool; // Obtiene el valor de la variable + [[nodiscard]] auto hasFinished() const -> bool; // Obtiene el valor de la variable private: // Variables - bool on_destination_; // Indica si está en el destino - int dest_x_; // Posicion de destino en el eje X - int dest_y_; // Posicion de destino en el eje Y - int enabled_counter_; // Contador para deshabilitarlo - bool finished_; // Indica si ya ha terminado + bool on_destination_; // Indica si está en el destino + int dest_x_; // Posicion de destino en el eje X + int dest_y_; // Posicion de destino en el eje Y + int enabled_counter_; // Contador per a deshabilitar-lo (frame-based) + float remaining_time_s_{0.0F}; // Temps restant per a deshabilitar-lo (time-based) + bool finished_; // Indica si ya ha terminado - void checkMove(); // Comprueba el movimiento - void checkFinished(); // Comprueba si ha terminado + void checkMove(); // Comprueba el movimiento + void checkFinished(); // Comprueba si ha terminado (frame-based) + void checkFinishedTimeBased(float dt_s); // Comprueba si ha terminado (time-based) }; diff --git a/source/core/rendering/writer.cpp b/source/core/rendering/writer.cpp index 305fa3a..28fd2e7 100644 --- a/source/core/rendering/writer.cpp +++ b/source/core/rendering/writer.cpp @@ -35,6 +35,31 @@ void Writer::update() { } } +// Time-based: avanca un caracter cada `seconds_per_char_` i un cop completat +// es queda visible `remaining_time_s_` segons abans de finalitzar. +void Writer::update(float dt_s) { + if (!enabled_) { return; } + + if (!completed_) { + char_timer_s_ += dt_s; + while (char_timer_s_ >= seconds_per_char_ && index_ < length_) { + char_timer_s_ -= seconds_per_char_; + ++index_; + } + if (index_ >= length_) { + completed_ = true; + } + } + + if (completed_) { + if (remaining_time_s_ <= 0.0F) { + finished_ = true; + } else { + remaining_time_s_ -= dt_s; + } + } +} + // Dibuja el objeto en pantalla void Writer::render() { if (enabled_) { @@ -69,6 +94,12 @@ void Writer::setSpeed(int value) { writing_counter_ = value; } +// Time-based: segons per caracter. Quan s'usa, l'update(dt) avança index. +void Writer::setSecondsPerChar(float seconds) { + seconds_per_char_ = seconds; + char_timer_s_ = 0.0F; +} + // Establece el valor de la variable void Writer::setEnabled(bool value) { enabled_ = value; @@ -89,6 +120,15 @@ auto Writer::getEnabledCounter() const -> int { return enabled_counter_; } +// Time-based: temps que es mante visible despres de completar el text. +void Writer::setRemainingTime(float seconds) { + remaining_time_s_ = seconds; +} + +auto Writer::getRemainingTime() const -> float { + return remaining_time_s_; +} + // Centra la cadena de texto a un punto X void Writer::center(int x) { setPosX(x - (text_->lenght(caption_, kerning_) / 2)); diff --git a/source/core/rendering/writer.h b/source/core/rendering/writer.h index 2a01ff4..8da0400 100644 --- a/source/core/rendering/writer.h +++ b/source/core/rendering/writer.h @@ -8,19 +8,23 @@ class Writer { public: explicit Writer(Text *text); // Constructor - void update(); // Actualiza el objeto - void render(); // Dibuja el objeto en pantalla + void update(); // Actualiza el objeto (frame-based) + void update(float dt_s); // Actualiza el objeto (time-based) + void render(); // Dibuja el objeto en pantalla void setPosX(int value); // Establece el valor de la variable void setPosY(int value); // Establece el valor de la variable void setKerning(int value); // Establece el valor de la variable void setCaption(const std::string &text); // Establece el valor de la variable - void setSpeed(int value); // Establece el valor de la variable + void setSpeed(int value); // Establece el valor de la variable (frame-based: frames per caracter) + void setSecondsPerChar(float seconds); // Time-based: segons per caracter void setEnabled(bool value); // Establece el valor de la variable [[nodiscard]] auto isEnabled() const -> bool; // Obtiene el valor de la variable - void setEnabledCounter(int time); // Establece el valor de la variable - [[nodiscard]] auto getEnabledCounter() const -> int; // Obtiene el valor de la variable + void setEnabledCounter(int time); // Establece el valor de la variable (frame-based) + [[nodiscard]] auto getEnabledCounter() const -> int; // Obtiene el valor de la variable + void setRemainingTime(float seconds); // Time-based: temps despres de completar + [[nodiscard]] auto getRemainingTime() const -> float; // Time-based: temps restant void center(int x); // Centra la cadena de texto a un punto X [[nodiscard]] auto hasFinished() const -> bool; // Obtiene el valor de la variable @@ -30,16 +34,19 @@ class Writer { Text *text_; // Objeto encargado de escribir el texto // Variables - int pos_x_{0}; // Posicion en el eje X donde empezar a escribir el texto - int pos_y_{0}; // Posicion en el eje Y donde empezar a escribir el texto - int kerning_{0}; // Kerning del texto, es decir, espaciado entre caracteres - std::string caption_; // El texto para escribir - int speed_{0}; // Velocidad de escritura - int writing_counter_{0}; // Temporizador de escritura para cada caracter - int index_{0}; // Posición del texto que se está escribiendo - int length_{0}; // Longitud de la cadena a escribir - bool completed_{false}; // Indica si se ha escrito todo el texto - bool enabled_{false}; // Indica si el objeto está habilitado - int enabled_counter_{0}; // Temporizador para deshabilitar el objeto - bool finished_{false}; // Indica si ya ha terminado + int pos_x_{0}; // Posicion en el eje X donde empezar a escribir el texto + int pos_y_{0}; // Posicion en el eje Y donde empezar a escribir el texto + int kerning_{0}; // Kerning del texto, es decir, espaciado entre caracteres + std::string caption_; // El texto para escribir + int speed_{0}; // Velocidad d'escriptura (frame-based: frames per caracter) + int writing_counter_{0}; // Temporizador d'escriptura per cada caracter (frame-based) + float seconds_per_char_{0.0F}; // Time-based: segons per caracter + float char_timer_s_{0.0F}; // Time-based: acumulador d'avanç de caracter + int index_{0}; // Posición del texto que se está escribiendo + int length_{0}; // Longitud de la cadena a escribir + bool completed_{false}; // Indica si se ha escrito todo el texto + bool enabled_{false}; // Indica si el objeto está habilitado + int enabled_counter_{0}; // Temporizador per a deshabilitar el objecte (frame-based) + float remaining_time_s_{0.0F}; // Temps restant per a deshabilitar (time-based) + bool finished_{false}; // Indica si ya ha terminado }; diff --git a/source/game/scenes/intro.cpp b/source/game/scenes/intro.cpp index 4955887..605d567 100644 --- a/source/game/scenes/intro.cpp +++ b/source/game/scenes/intro.cpp @@ -12,9 +12,29 @@ #include "core/rendering/smartsprite.h" // for SmartSprite #include "core/rendering/writer.h" // for Writer #include "core/resources/resource.h" +#include "core/system/delta_time.hpp" #include "game/defaults.hpp" // for GAMECANVAS_CENTER_X, GAMECANVAS_FIRST_QU... #include "utils/utils.h" // for Section, Color +// =========================================================================== +// Time-based. Tots els valors precalculats: velocitats en px/s, acceleracions +// en px/s^2, durades en segons. La cadència real de la versió frame-based era +// empíricament ~60 Hz (el gate `> 15 ms` esperava al següent múltiple del +// refresh del SO, típicament 16.67 ms). Per això la conversió és: +// vel px/tick → vel * 60 = px/s +// acc px/tick² → acc * 3600 = px/s² +// counter frames → counter/60 = segons +// =========================================================================== + +namespace { + // Durades comunes (segons). Arrodonides amunt respecte a la conversió + // exacta des de frames per a tenir valors més "bonics" i una mica més + // de respir visual. + constexpr float BITMAP_REMAINING_TIME_S = 0.5F; // de 0.333 (20/60) ⇒ 0.5 + constexpr float BITMAP_FALLING_REMAINING_TIME_S = 5.0F; // de 4.167 (250/60) ⇒ 5.0 + constexpr float TEXT_REMAINING_TIME_S = 3.0F; // 180/60 ⇒ ja és exacte +} // namespace + // Constructor Intro::Intro(SDL_Renderer *renderer, Section *section) { // Copia los punteros @@ -30,8 +50,6 @@ Intro::Intro(SDL_Renderer *renderer, Section *section) { // Inicializa variables section->name = SECTION_PROG_INTRO; section->subsection = 0; - ticks_ = 0; - ticks_speed_ = 15; scene_ = 1; // Inicializa los bitmaps de la intro @@ -40,62 +58,69 @@ Intro::Intro(SDL_Renderer *renderer, Section *section) { auto *ss = new SmartSprite(texture_, renderer); ss->setWidth(128); ss->setHeight(96); - ss->setEnabledCounter(20); + ss->setRemainingTime(BITMAP_REMAINING_TIME_S); ss->setDestX(GAMECANVAS_CENTER_X - 64); ss->setDestY(GAMECANVAS_FIRST_QUARTER_Y - 24); bitmaps_.push_back(ss); } + // bitmap 0: entra des de l'esquerra, accelerant cap a la dreta bitmaps_[0]->setPosX(-128); bitmaps_[0]->setPosY(GAMECANVAS_FIRST_QUARTER_Y - 24); bitmaps_[0]->setVelX(0.0F); bitmaps_[0]->setVelY(0.0F); - bitmaps_[0]->setAccelX(0.6F); + bitmaps_[0]->setAccelX(2160.0F); // 0.6 px/tick² ⇒ 0.6 * 3600 px/s² bitmaps_[0]->setAccelY(0.0F); bitmaps_[0]->setSpriteClip(0, 0, 128, 96); + // bitmap 1: entra des de la dreta amb velocitat negativa i accelera més bitmaps_[1]->setPosX(GAMECANVAS_WIDTH); bitmaps_[1]->setPosY(GAMECANVAS_FIRST_QUARTER_Y - 24); - bitmaps_[1]->setVelX(-1.0F); + bitmaps_[1]->setVelX(-60.0F); // -1 px/tick ⇒ -60 px/s bitmaps_[1]->setVelY(0.0F); - bitmaps_[1]->setAccelX(-0.3F); + bitmaps_[1]->setAccelX(-1080.0F); // -0.3 px/tick² ⇒ -1080 px/s² bitmaps_[1]->setAccelY(0.0F); bitmaps_[1]->setSpriteClip(128, 0, 128, 96); + // bitmap 2: cau des de dalt; queda visible més temps (escena "GRITO") bitmaps_[2]->setPosX(GAMECANVAS_CENTER_X - 64); bitmaps_[2]->setPosY(-96); bitmaps_[2]->setVelX(0.0F); - bitmaps_[2]->setVelY(3.0F); - bitmaps_[2]->setAccelX(0.1F); - bitmaps_[2]->setAccelY(0.3F); + bitmaps_[2]->setVelY(180.0F); // 3 px/tick ⇒ 180 px/s + bitmaps_[2]->setAccelX(360.0F); // 0.1 px/tick² ⇒ 360 px/s² + bitmaps_[2]->setAccelY(1080.0F); // 0.3 px/tick² ⇒ 1080 px/s² bitmaps_[2]->setSpriteClip(0, 96, 128, 96); - bitmaps_[2]->setEnabledCounter(250); + bitmaps_[2]->setRemainingTime(BITMAP_FALLING_REMAINING_TIME_S); + // bitmap 3: puja lentament des de baix (reflexió) bitmaps_[3]->setPosX(GAMECANVAS_CENTER_X - 64); bitmaps_[3]->setPosY(GAMECANVAS_HEIGHT); bitmaps_[3]->setVelX(0.0F); - bitmaps_[3]->setVelY(-0.7F); + bitmaps_[3]->setVelY(-42.0F); // -0.7 px/tick ⇒ -42 px/s bitmaps_[3]->setAccelX(0.0F); bitmaps_[3]->setAccelY(0.0F); bitmaps_[3]->setSpriteClip(128, 96, 128, 96); + // bitmap 4: cau des de dalt (mateix que bitmap 2, sense temps allargat) bitmaps_[4]->setPosX(GAMECANVAS_CENTER_X - 64); bitmaps_[4]->setPosY(-96); bitmaps_[4]->setVelX(0.0F); - bitmaps_[4]->setVelY(3.0F); - bitmaps_[4]->setAccelX(0.1F); - bitmaps_[4]->setAccelY(0.3F); + bitmaps_[4]->setVelY(180.0F); + bitmaps_[4]->setAccelX(360.0F); + bitmaps_[4]->setAccelY(1080.0F); bitmaps_[4]->setSpriteClip(0, 192, 128, 96); + // bitmap 5: entra des de la dreta lentament bitmaps_[5]->setPosX(GAMECANVAS_WIDTH); bitmaps_[5]->setPosY(GAMECANVAS_FIRST_QUARTER_Y - 24); - bitmaps_[5]->setVelX(-0.7F); + bitmaps_[5]->setVelX(-42.0F); // -0.7 px/tick ⇒ -42 px/s bitmaps_[5]->setVelY(0.0F); bitmaps_[5]->setAccelX(0.0F); bitmaps_[5]->setAccelY(0.0F); bitmaps_[5]->setSpriteClip(128, 192, 128, 96); - // Inicializa los textos de la intro + // Inicializa los textos de la intro. Time-based: setSecondsPerChar. + // Conversió: frames_per_char / 60 = segons_per_char. const int TOTAL_TEXTS = 9; for (int i = 0; i < TOTAL_TEXTS; ++i) { auto *w = new Writer(text_); @@ -103,51 +128,53 @@ Intro::Intro(SDL_Renderer *renderer, Section *section) { w->setPosY(GAMECANVAS_HEIGHT - (BLOCK * 6)); w->setKerning(-1); w->setEnabled(false); - w->setEnabledCounter(180); + w->setRemainingTime(TEXT_REMAINING_TIME_S); texts_.push_back(w); } // Un dia qualsevol de l'any 2000 texts_[0]->setCaption(Lang::get()->getText(27)); - texts_[0]->setSpeed(8); + texts_[0]->setSecondsPerChar(0.15F); // de 0.1333 (8/60) ⇒ 0.15 // Tot esta tranquil a la UPV texts_[1]->setCaption(Lang::get()->getText(28)); - texts_[1]->setSpeed(8); + texts_[1]->setSecondsPerChar(0.15F); // Fins que un desaprensiu... texts_[2]->setCaption(Lang::get()->getText(29)); - texts_[2]->setSpeed(12); + texts_[2]->setSecondsPerChar(0.2F); // 12/60 ⇒ ja és 0.2 // HEY! ME ANE A FERME UN CORTAET... texts_[3]->setCaption(Lang::get()->getText(30)); - texts_[3]->setSpeed(8); + texts_[3]->setSecondsPerChar(0.15F); // UAAAAAAAAAAAAA!!! texts_[4]->setCaption(Lang::get()->getText(31)); - texts_[4]->setSpeed(1); + texts_[4]->setSecondsPerChar(0.02F); // de 0.0167 (1/60) ⇒ 0.02 // Espera un moment... texts_[5]->setCaption(Lang::get()->getText(32)); - texts_[5]->setSpeed(16); + texts_[5]->setSecondsPerChar(0.3F); // de 0.2667 (16/60) ⇒ 0.3 // Si resulta que no tinc solt! texts_[6]->setCaption(Lang::get()->getText(33)); - texts_[6]->setSpeed(2); + texts_[6]->setSecondsPerChar(0.05F); // de 0.0333 (2/60) ⇒ 0.05 // MERDA DE MAQUINA! texts_[7]->setCaption(Lang::get()->getText(34)); - texts_[7]->setSpeed(3); + texts_[7]->setSecondsPerChar(0.05F); // 3/60 ⇒ ja és 0.05 // Blop... blop... blop... texts_[8]->setCaption(Lang::get()->getText(35)); - texts_[8]->setSpeed(16); + texts_[8]->setSecondsPerChar(0.3F); for (auto *t : texts_) { t->center(GAMECANVAS_CENTER_X); } Audio::get()->playMusic(music_, 0); + + DeltaTime::reset(); } // Destructor @@ -332,26 +359,19 @@ void Intro::updateScene6() { } // Actualiza las variables del objeto -void Intro::update() { +void Intro::update(float dt_s) { Audio::update(); checkInput(); - if (SDL_GetTicks() - ticks_ > ticks_speed_) { - // Actualiza el contador de ticks - ticks_ = SDL_GetTicks(); - - // Actualiza los objetos - for (auto *bitmap : bitmaps_) { - bitmap->update(); - } - - for (auto *t : texts_) { - t->update(); - } - - // Actualiza las escenas de la intro - updateScenes(); + for (auto *bitmap : bitmaps_) { + bitmap->update(dt_s); } + + for (auto *t : texts_) { + t->update(dt_s); + } + + updateScenes(); } // Dibuja el objeto en pantalla @@ -386,7 +406,8 @@ void Intro::run() { // Ejecuta un frame void Intro::iterate() { - update(); + const float DELTA_TIME_S = DeltaTime::tick(); + update(DELTA_TIME_S); render(); } diff --git a/source/game/scenes/intro.h b/source/game/scenes/intro.h index 99ac45f..5f856ac 100644 --- a/source/game/scenes/intro.h +++ b/source/game/scenes/intro.h @@ -36,15 +36,13 @@ class Intro { Section *section_; // Estado del bucle principal para saber si continua o se sale // Variables - Uint32 ticks_; // Contador de ticks para ajustar la velocidad del programa - Uint8 ticks_speed_; // Velocidad a la que se repiten los bucles del programa Ja::Music *music_; // Musica para la intro - int scene_; // Indica que escena está activa + int scene_; // Indica que escena está activa - void update(); // Actualiza las variables del objeto - void render(); // Dibuja el objeto en pantalla - void checkInput(); // Comprueba las entradas - void updateScenes(); // Actualiza las escenas de la intro + void update(float dt_s); // Actualiza las variables del objeto (time-based) + void render(); // Dibuja el objeto en pantalla + void checkInput(); // Comprueba las entradas + void updateScenes(); // Actualiza las escenas de la intro // Helpers de updateScenes, uno por cada escena void updateScene1();