feat(title): seqüència d'intro temporitzada amb slide-in del peu

source/game/scenes/logo_scene.hpp

@@ -16,7 +16,7 @@ class Surface;
 // es demana la mateixa pista que ja sona).
 //
 // Skip: qualsevol tecla no reservada salta directament a la transició
-// (sense fade-out) — el TitleScene té el seu propi `intro_fade_in_ms`,
+// (sense fade-out) — el TitleScene té el seu propi `intro.fade_in_ms`,
 // així que la transició queda visualment continua igualment.
 //
 // Si arriba amb `reset=true` (acció "Reiniciar" del menú de servei),

source/game/scenes/title_scene.cpp

@@ -25,6 +25,7 @@
 #include "game/scenes/scene_flow.hpp"
 #include "utils/defaults.hpp"
 #include "utils/defines.hpp"
+#include "utils/easing.hpp"
 
 namespace {
 
@@ -87,7 +88,7 @@ TitleScene::TitleScene(std::shared_ptr<Text> condensed_font, std::shared_ptr<Tex
     // Fade-in inicial: arrenquem en negre opac i ens esvaïm cap a la
     // imatge de fons. Sense lligar a cap fase — viu sempre al frame i
     // un cop finished, `render()` és no-op fins que la TitleScene mor.
-    intro_fade_.begin(UiConfig::get().titleIntroFadeInMs(), Transitions::FadeToBlack::Direction::FADE_IN);
+    intro_fade_.begin(UiConfig::get().titleIntro().fade_in_ms, Transitions::FadeToBlack::Direction::FADE_IN);
 
     // Música de fons en bucle. Es preloda al Director, així que la
     // primera crida és immediata. El fade-out arrenca en entrar a
@@ -121,6 +122,23 @@ void TitleScene::update(int delta_ms) {
     // `starting_blink_period_ms`.
     blink_elapsed_ms_ += delta_ms;
 
+    // Rellotge de la seqüència d'intro. Avança sempre — `enterStarting()`
+    // ja el força al final de la seqüència, així el seu valor a STARTING
+    // i ATTRACT_OUT és inofensiu (els consumidors clampen).
+    intro_elapsed_ms_ += delta_ms;
+    if (!press_start_armed_) {
+        const auto& intro = UiConfig::get().titleIntro();
+        if (intro_elapsed_ms_ >= intro.press_start_at_ms) {
+            // Resetegem el cicle del parpadeig a l'instant en què el
+            // PRESS START passa a ser visible per primera vegada, perquè
+            // el primer frame caigui en estat "on" (si no, el modulus
+            // amb el contador acumulat des de t=0 podria caure mig
+            // cicle i donar un primer "off" estrany).
+            press_start_armed_ = true;
+            blink_elapsed_ms_ = 0;
+        }
+    }
+
     const bool P1_START = pressedStart(0);
     const bool P2_START = pressedStart(1);
 
@@ -148,6 +166,24 @@ void TitleScene::enterStarting(DebugConfig::StartingPlayers players) {
     // STARTING comenci visible — sense això, el modulus amb el nou
     // període podria caure mig cicle i donar un primer "off" estrany.
     blink_elapsed_ms_ = 0;
+
+    // Shortcut: si l'usuari ha premut START durant la intro, saltem al
+    // final de la seqüència perquè el frame de STARTING comenci amb
+    // tot a la posició final i visible (sense salts ni elements en
+    // moviment a meitat). FadeToBlack::tick clampeja internament a
+    // duration_ms, així que un delta gegant l'avança a finished sense
+    // efectes secundaris.
+    const auto& intro = UiConfig::get().titleIntro();
+    const int INTRO_END_MS = std::max({
+        intro.game_logo_at_ms,
+        intro.mini_logo_at_ms + intro.mini_logo_slide_ms,
+        intro.copyright_at_ms + intro.copyright_slide_ms,
+        intro.press_start_at_ms,
+    });
+    intro_elapsed_ms_ = std::max(intro_elapsed_ms_, INTRO_END_MS);
+    press_start_armed_ = true;
+    intro_fade_.tick(INTRO_END_MS);
+
     // Fade-out de la música. Si l'altre jugador prem START i el timer
     // es reseteja, no rearranquem la música: es manté la fosa iniciada
     // ací (consistent amb el fade visual, que tampoc es reverteix).
@@ -237,9 +273,19 @@ void TitleScene::advanceToLogo() {
 }
 
 void TitleScene::render() {
-    const auto& ui_config = UiConfig::get();
-    const auto& palette = Resource::Cache::get().getPalette("ui");
+    const auto& intro = UiConfig::get().titleIntro();
 
+    renderBackground();
+    renderGameLogo(intro);
+    renderPressStart(intro);
+    renderFooter(intro);
+    Notifier::get().render();
+    renderTransitions();
+    RenderInfo::get().render();
+    Screen::get().present();
+}
+
+void TitleScene::renderBackground() {
     // Fons: la imatge si està disponible (cobreix tot el canvas amb la
     // seua paleta nadiua), opcionalment amb heat-haze; en cas contrari,
     // color pla de la paleta UI com a fallback defensiu.
@@ -249,79 +295,114 @@ void TitleScene::render() {
         } else {
             background_->render(0, 0);
         }
-    } else {
-        Screen::get().fillRect(0, 0, GameCanvas::WIDTH, GameCanvas::HEIGHT, palette[ui_config.titleBgColor()]);
+        return;
     }
+    const auto& ui_config = UiConfig::get();
+    const auto& palette = Resource::Cache::get().getPalette("ui");
+    Screen::get().fillRect(0, 0, GameCanvas::WIDTH, GameCanvas::HEIGHT, palette[ui_config.titleBgColor()]);
+}
+
+void TitleScene::renderGameLogo(const UiConfig::TitleIntro& intro) {
+    // Visibilitat binària gestionada per la seqüència d'intro: a IDLE
+    // només es pinta a partir de `game_logo_at_ms`; fora d'IDLE sempre.
+    // TODO: aplicar fade-in alpha quan Surface suporti renderWithAlpha.
+    const bool VISIBLE = phase_ != Phase::IDLE || intro_elapsed_ms_ >= intro.game_logo_at_ms;
+    if (!game_logo_ || !VISIBLE) { return; }
+    const auto& ui_config = UiConfig::get();
+    const int LOGO_Y = (GameCanvas::HEIGHT * ui_config.titleLogoYPercent()) / 100;
+    const int LOGO_X = GameCanvas::CENTER_X - (game_logo_->getWidth() / 2);
+    game_logo_->render(LOGO_X, LOGO_Y);
+}
+
+void TitleScene::renderPressStart(const UiConfig::TitleIntro& intro) {
+    // A IDLE només apareix a partir de `press_start_at_ms`; fora d'IDLE
+    // (STARTING o ATTRACT_OUT) sempre, com fins ara.
+    const bool VISIBLE = phase_ != Phase::IDLE || intro_elapsed_ms_ >= intro.press_start_at_ms;
+    if (!condensed_font_ || !VISIBLE) { return; }
+
+    // Cicle de parpadeig: a IDLE pren visible_ms+hidden_ms del yaml
+    // (asimètric, 80/20 per defecte); a STARTING commuta a 50/50 amb
+    // `starting_blink_period_ms` per donar feedback de "polsat".
+    // Si el cicle val 0 (configuració degenerada), cau a "sempre visible".
+    const auto& ui_config = UiConfig::get();
+    int cycle_ms = 0;
+    int visible_ms = 0;
+    if (phase_ == Phase::STARTING) {
+        cycle_ms = std::max(0, ui_config.titleStartingBlinkPeriodMs());
+        visible_ms = cycle_ms / 2;
+    } else {
+        visible_ms = std::max(0, ui_config.titleBlinkVisibleMs());
+        cycle_ms = visible_ms + std::max(0, ui_config.titleBlinkHiddenMs());
+    }
+    const bool BLINK_ON = (cycle_ms == 0) || ((blink_elapsed_ms_ % cycle_ms) < visible_ms);
+    if (!BLINK_ON) { return; }
 
-    const Uint8 TEXT_COLOR = ui_config.titleTextColor();
-    const Uint8 OUTLINE_COLOR = ui_config.titlePressStartOutlineColor();
     constexpr Uint8 OUTLINE_DIST = 1;
     constexpr Uint8 STROKE4 = Text::CENTER_FLAG | Text::COLOR_FLAG | Text::STROKE4_FLAG;
+    const int PROMPT_Y = (GameCanvas::HEIGHT * ui_config.titlePromptYPercent()) / 100;
+    condensed_font_->writeDX(STROKE4,
+        GameCanvas::CENTER_X,
+        PROMPT_Y,
+        Locale::get().text("title.press_start"),
+        condensed_font_->getDefaultKerning() - 1,
+        ui_config.titleTextColor(),
+        OUTLINE_DIST,
+        ui_config.titlePressStartOutlineColor());
+}
 
-    // Logotip del joc: GIF amb la seua paleta nadiua, centrat
-    // horitzontalment al canvas i ancorat al mateix Y on abans naixia
-    // la primera línia del text. Substitueix els dos `display_font_`
-    // que pintaven "Aventures en Egipte" + "A R C A D E".
-    if (game_logo_) {
-        const int LOGO_Y = (GameCanvas::HEIGHT * ui_config.titleLogoYPercent()) / 100;
-        const int LOGO_X = GameCanvas::CENTER_X - (game_logo_->getWidth() / 2);
-        game_logo_->render(LOGO_X, LOGO_Y);
-    }
-
-    if (condensed_font_) {
-        // Cicle de parpadeig: a IDLE pren visible_ms+hidden_ms del yaml
-        // (asimètric, 80/20 per defecte); a STARTING commuta a 50/50 amb
-        // `starting_blink_period_ms` per donar feedback de "polsat".
-        // Si el cicle val 0 (configuració degenerada), cau a "sempre visible".
-        int cycle_ms = 0;
-        int visible_ms = 0;
-        if (phase_ == Phase::STARTING) {
-            cycle_ms = std::max(0, ui_config.titleStartingBlinkPeriodMs());
-            visible_ms = cycle_ms / 2;
-        } else {
-            visible_ms = std::max(0, ui_config.titleBlinkVisibleMs());
-            cycle_ms = visible_ms + std::max(0, ui_config.titleBlinkHiddenMs());
-        }
-        const bool VISIBLE = (cycle_ms == 0) || ((blink_elapsed_ms_ % cycle_ms) < visible_ms);
-
-        if (VISIBLE) {
-            const int PROMPT_Y = (GameCanvas::HEIGHT * ui_config.titlePromptYPercent()) / 100;
-            condensed_font_->writeDX(STROKE4,
-                GameCanvas::CENTER_X,
-                PROMPT_Y,
-                Locale::get().text("title.press_start"),
-                condensed_font_->getDefaultKerning() - 1,
-                TEXT_COLOR,
-                OUTLINE_DIST,
-                OUTLINE_COLOR);
-        }
-    }
-
+void TitleScene::renderFooter(const UiConfig::TitleIntro& intro) {
     // Footer: minilogo centrat horitzontalment damunt del © de
     // copyright. El text va al `title.copyright_y_percent`, el logo just
     // damunt amb un petit gap (`title.mini_logo_gap_px`). El copyright fa
     // servir una font pixel-art pròpia (Tiny5-Regular size 8) — més neta
     // i petita que la del "press start" perquè la jerarquia tipogràfica
     // del peu quedi clara.
-    if (copyright_font_) {
-        const int COPY_Y = (GameCanvas::HEIGHT * ui_config.titleCopyrightYPercent()) / 100;
-        if (mini_logo_) {
-            const int LOGO_X = GameCanvas::CENTER_X - (mini_logo_->getWidth() / 2);
-            const int LOGO_Y = COPY_Y - mini_logo_->getHeight() - ui_config.titleMiniLogoGapPx();
-            mini_logo_->render(LOGO_X, LOGO_Y);
+    if (!copyright_font_) { return; }
+
+    const auto& ui_config = UiConfig::get();
+    const int COPY_Y = (GameCanvas::HEIGHT * ui_config.titleCopyrightYPercent()) / 100;
+    const bool IDLE = phase_ == Phase::IDLE;
+
+    // Mini-logo: slide-in vertical des del marge inferior amb la corba
+    // `slide_curve`. Fora d'IDLE (o un cop completat) la Y és la final.
+    if (mini_logo_ && (!IDLE || intro_elapsed_ms_ >= intro.mini_logo_at_ms)) {
+        const int FINAL_Y = COPY_Y - mini_logo_->getHeight() - ui_config.titleMiniLogoGapPx();
+        int y = FINAL_Y;
+        if (IDLE && intro.mini_logo_slide_ms > 0) {
+            const float T = std::clamp(
+                static_cast<float>(intro_elapsed_ms_ - intro.mini_logo_at_ms) / static_cast<float>(intro.mini_logo_slide_ms),
+                0.0F,
+                1.0F);
+            y = Easing::lerpInt(GameCanvas::HEIGHT, FINAL_Y, intro.slide_curve(T));
+        }
+        const int LOGO_X = GameCanvas::CENTER_X - (mini_logo_->getWidth() / 2);
+        mini_logo_->render(LOGO_X, y);
+    }
+
+    // Copyright: mateix patró amb el seu propi tempo. La diferència
+    // de temps entre `mini_logo_at_ms` i `copyright_at_ms` controla
+    // el decalatge entre les dues entrades (per defecte 200 ms).
+    if (!IDLE || intro_elapsed_ms_ >= intro.copyright_at_ms) {
+        int y = COPY_Y;
+        if (IDLE && intro.copyright_slide_ms > 0) {
+            const float T = std::clamp(
+                static_cast<float>(intro_elapsed_ms_ - intro.copyright_at_ms) / static_cast<float>(intro.copyright_slide_ms),
+                0.0F,
+                1.0F);
+            y = Easing::lerpInt(GameCanvas::HEIGHT, COPY_Y, intro.slide_curve(T));
         }
         copyright_font_->writeDX(Text::CENTER_FLAG | Text::COLOR_FLAG,
             GameCanvas::CENTER_X,
-            COPY_Y,
+            y,
             "© 2026 JailDesigner",
             copyright_font_->getDefaultKerning(),
             ui_config.titleCopyrightColor());
     }
+}
 
-    Notifier::get().render();
-
+void TitleScene::renderTransitions() {
     // Fade-in inicial: capa negra que s'esvaeix cap a l'escena durant
-    // els primers `title.intro_fade_in_ms` ms. `render()` és no-op un
+    // els primers `title.intro.fade_in_ms` ms. `render()` és no-op un
     // cop finished, així que es queda penjat aquí sense lògica
     // condicional. Va per damunt del Notifier — coherent amb la resta
     // de transicions — però per davall del RenderInfo de debug.
@@ -337,7 +418,4 @@ void TitleScene::render() {
     } else if (fade_out_ && (fade_out_->isActive() || fade_out_->isFinished())) {
         fade_out_->render();
     }
-
-    RenderInfo::get().render();
-    Screen::get().present();
 }

source/game/scenes/title_scene.hpp

@@ -8,6 +8,7 @@
 #include "core/rendering/transitions/fade_to_black.hpp"
 #include "core/rendering/transitions/mosaic.hpp"
 #include "core/scene/scene.hpp"
+#include "core/ui/ui_config.hpp"
 #include "game/debug_config.hpp"
 
 class Surface;
@@ -49,6 +50,14 @@ class TitleScene : public Scene {
     void advanceToIntro(DebugConfig::StartingPlayers players);
     void advanceToLogo();
 
+    // Helpers de `render()` extrets per evitar que la funció gran acumuli
+    // massa branques. Cadascun pinta un bloc independent del frame.
+    void renderBackground();
+    void renderGameLogo(const UiConfig::TitleIntro& intro);
+    void renderPressStart(const UiConfig::TitleIntro& intro);
+    void renderFooter(const UiConfig::TitleIntro& intro);
+    void renderTransitions();
+
     std::shared_ptr<Text> condensed_font_;
     std::shared_ptr<Text> copyright_font_;
     std::shared_ptr<Surface> background_;
@@ -56,6 +65,14 @@ class TitleScene : public Scene {
     std::shared_ptr<Surface> mini_logo_;
     int timer_ms_;
     int blink_elapsed_ms_{0};
+    // Rellotge de la seqüència d'intro (vegeu `title.intro` a ui.yaml).
+    // Avança sempre amb `delta_ms`. La visibilitat i el slide de cada
+    // element es deriven d'ell a `render()` — no cal cap altre estat.
+    int intro_elapsed_ms_{0};
+    // Detector de l'instant en què `intro_elapsed_ms_` creua per primera
+    // vegada `press_start_at_ms`: en aquell frame es reseteja
+    // `blink_elapsed_ms_` perquè el text aparegui en estat visible.
+    bool press_start_armed_{false};
     std::optional<Effects::HeatHaze> heat_haze_;
     Phase phase_{Phase::IDLE};
     int starting_timer_ms_{0};
@@ -63,7 +80,7 @@ class TitleScene : public Scene {
     std::optional<Transitions::Mosaic> fade_out_;
     std::optional<Transitions::FadeToBlack> attract_fade_;
     // Fade-in inicial: capa negra que s'esvaeix cap a la imatge de fons
-    // durant els primers `title.intro_fade_in_ms` ms. Sempre activa al
+    // durant els primers `title.intro.fade_in_ms` ms. Sempre activa al
     // ctor; un cop finished, `render()` pinta alpha=0 (no-op) la resta
     // del cicle de l'escena.
     Transitions::FadeToBlack intro_fade_;