feat(game): pausa graduada amb easing i separador al HUD

source/game/scenes/game_scene.hpp

@@ -1,10 +1,12 @@
 #pragma once
 
+#include <cstdint>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "core/scene/scene.hpp"
+#include "core/ui/ui_config.hpp"
 #include "game/entities/entity_manager.hpp"
 #include "game/map/paint_layer.hpp"
 #include "game/map/tilemap.hpp"
@@ -39,10 +41,16 @@ class GameScene : public Scene {
 
    private:
     // Consumeix events d'aquest frame (F11 del KeyConfig "pause" o botó
-    // START del gamepad primari) per alternar l'estat de pausa. Quan
-    // s'activa, pausa la música; en reprendre, la reprén.
+    // START del gamepad primari) per disparar les transicions de pausa.
+    // No alterna un flag binari: inicia (o inverteix mid-flight) un
+    // "dial" de temps que frena el món amb easing.
     void handlePauseInput();
 
+    // Avança la transició activa, recalcula `pause_.scale` i aplica el
+    // fade de volum de música. S'executa cada frame amb el delta real
+    // (no escalat) perquè la transició viu en temps real.
+    void updatePauseTransition(int delta_ms);
+
     Config config_;
     Tilemap tilemap_;
 
@@ -72,19 +80,40 @@ class GameScene : public Scene {
     // la destrucció.
     std::unique_ptr<Hud> hud_;
 
-    // Pausa de gameplay. Quan `paused_` és true, l'update de jugadors i
-    // entitats es salta (el món es congela); l'input d'UI (GlobalInputs,
-    // Notifier, RenderInfo) continua per no perdre hotkeys ni l'overlay de
-    // debug. La font s'instancia des del Surface ja cachejat al Director
-    // (cap altra escena l'allibera, així que l'accés és segur).
+    // Pausa de gameplay com a "dial" de temps. En lloc d'un interruptor,
+    // `pause_.scale` va de 1 (món corrent) a 0 (món congelat) amb una
+    // corba d'easing durant ENTERING, i al revés durant EXITING. El
+    // `delta_ms` del món (players + EntityManager) es multiplica per
+    // aquesta escala; HUD, Notifier i GlobalInputs reben sempre el
+    // delta real. Les inversions mid-flight capturen la `scale` actual
+    // com a `from_scale` i escalen la durada a la distància restant per
+    // mantenir la sensació de velocitat. La font és la mateixa que
+    // abans — ja cachejada al Director.
     std::shared_ptr<Text> pause_font_;
-    bool paused_{false};
+
+    enum class PauseState : std::uint8_t {
+        IDLE,      // Joc corrent; cap transició en marxa. scale == 1.
+        ENTERING,  // Frenant cap a la pausa. scale decreix a 0.
+        PAUSED,    // Món congelat. scale == 0.
+        EXITING,   // Accelerant de tornada. scale creix a 1.
+    };
+
+    struct PauseTransition {
+        PauseState state{PauseState::IDLE};
+        float scale{1.0F};                 // 0 = parat, 1 = corrent.
+        float from_scale{1.0F};            // Valor de `scale` al començar la transició.
+        float to_scale{1.0F};              // Valor objectiu (0.0 o 1.0).
+        int elapsed_ms{0};                 // Temps transcorregut dins la transició.
+        int duration_ms{0};                // Durada total (escalada a la distància).
+        UiConfig::CurveFn curve{nullptr};  // Corba activa.
+    } pause_;
 
 #ifdef _DEBUG
-    // Editor modal del tilemap. Mútuament excloent amb la pausa: si `paused_`
-    // la tecla de toggle de l'editor s'ignora, i viceversa. Quan
-    // `editor_.active()` és true, saltem entitats i jugador (update i
-    // render) i deixem el tilemap visible perquè es pugui editar.
+    // Editor modal del tilemap. Mútuament excloent amb la pausa: si la
+    // pausa no està IDLE la tecla de toggle de l'editor s'ignora, i
+    // viceversa. Quan `editor_.active()` és true, saltem entitats i
+    // jugador (update i render) i deixem el tilemap visible perquè es
+    // pugui editar.
     Editor editor_;
 #endif
 };