Plan A: frame loop al Director, interfaz Scene común

Cada escena ahora implementa una interfaz Scene { handleEvent, update,
draw, isFinished } y el Director es quien posee el bucle de frames.
Antes había tres bucles casi idénticos duplicados en logo/title/game
con ~30 LOC cada uno; ahora hay uno solo en Director::runFrameLoop.

Cambios:

- Nueva interfaz core/system/scene.hpp (pura virtual).
- Cada escena hereda final + override de handleEvent/update/draw/
  isFinished. Los métodos privados que ya existían (update, draw,
  processar_events) pasan a públicos como override; processar_events
  se renombra a handleEvent.
- Director::run gestiona la transición entre escenas vía
  buildScene(type) → runFrameLoop(scene), ambas estáticas.
- isFinished() = context_.nextScene() != mi_tipo, así que la única
  vía de transición es context_.setNextScene().
- TitleScene tenía un bug latente: llamaba a setNextScene(GAME)
  prematuramente al entrar en PLAYER_JOIN_PHASE, lo que con el nuevo
  modelo habría saltado las animaciones de salida. Movido el
  setNextScene al final de BLACK_SCREEN, que es donde la transición
  ocurría de verdad (vía la variable global SceneManager::actual).
- LogoScene::draw llamaba a clear() y present() dentro del draw, una
  anomalía. Sacados al Director para que la composición sea uniforme.
- Eliminadas todas las escrituras a SceneManager::actual desde las
  escenas. El Director es ahora la única fuente que actualiza la
  variable global (sigue ahí para lecturas externas, por compatibilidad).

Net: -60 LOC reales (las escenas pierden ~25 cada una de boilerplate),
y queda un único punto de inyección para los overlays globales que
vienen en el siguiente paso del roadmap.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

source/core/system/director.cpp

@@ -3,11 +3,15 @@
 #include <SDL3/SDL.h>
 #include <sys/stat.h>
 
+#include <algorithm>
 #include <cerrno>
 #include <cstdlib>
 #include <iostream>
+#include <memory>
 
+#include "scene.hpp"
 #include "scene_context.hpp"
+#include "global_events.hpp"
 #include "core/audio/audio.hpp"
 #include "core/audio/audio_adapter.hpp"
 #include "core/defaults.hpp"
@@ -251,38 +255,69 @@ auto Director::run() -> int {
     context.setNextScene(SceneType::LOGO);
 #endif
 
-    // Bucle principal de gestió de escenes
+    // Bucle principal: construir escena → frame loop → destruir → siguiente.
     while (context.nextScene() != SceneType::EXIT) {
-        // Sincronitzar SceneManager::actual con context
-        // (altres sistemes aún poden llegir SceneManager::actual)
         SceneManager::actual = context.nextScene();
-
-        switch (context.nextScene()) {
-            case SceneType::LOGO: {
-                LogoScene logo(sdl, context);
-                logo.run();
-                break;
-            }
-
-            case SceneType::TITLE: {
-                TitleScene titol(sdl, context);
-                titol.run();
-                break;
-            }
-
-            case SceneType::GAME: {
-                GameScene juego(sdl, context);
-                juego.run();
-                break;
-            }
-
-            default:
-                break;
+        std::unique_ptr<Scene> scene = buildScene(context.nextScene(), sdl, context);
+        if (!scene) {
+            break;
         }
+        runFrameLoop(*scene, sdl, context);
     }
 
-    // Sincronitzar final con SceneManager::actual
     SceneManager::actual = SceneType::EXIT;
-
     return 0;
 }
+
+auto Director::buildScene(SceneType type, SDLManager& sdl, SceneContext& context)
+    -> std::unique_ptr<Scene> {
+    switch (type) {
+        case SceneType::LOGO:
+            return std::make_unique<LogoScene>(sdl, context);
+        case SceneType::TITLE:
+            return std::make_unique<TitleScene>(sdl, context);
+        case SceneType::GAME:
+            return std::make_unique<GameScene>(sdl, context);
+        case SceneType::EXIT:
+        default:
+            return nullptr;
+    }
+}
+
+void Director::runFrameLoop(Scene& scene, SDLManager& sdl, SceneContext& context) {
+    SDL_Event event;
+    Uint64 last_time = SDL_GetTicks();
+
+    while (!scene.isFinished()) {
+        // Delta time real, capeado a 50ms para evitar grandes saltos.
+        const Uint64 NOW = SDL_GetTicks();
+        float delta_time = static_cast<float>(NOW - last_time) / 1000.0F;
+        last_time = NOW;
+        delta_time = std::min(delta_time, 0.05F);
+
+        sdl.updateFPS(delta_time);
+        Mouse::updateCursorVisibility();
+        Input::get()->update();
+
+        // Event loop: primero ventana, después globales, después escena.
+        while (SDL_PollEvent(&event)) {
+            if (sdl.handleWindowEvent(event)) {
+                continue;
+            }
+            if (GlobalEvents::handle(event, sdl, context)) {
+                continue;
+            }
+            scene.handleEvent(event);
+        }
+
+        scene.update(delta_time);
+        Audio::update();
+        sdl.updateColors(delta_time);  // no-op desde Fase 8c (oscilación en shader)
+
+        sdl.clear(0, 0, 0);
+        sdl.updateRenderingContext();
+        scene.draw();
+        // Hook futuro: overlays globales aquí (FPS+VSync, profilers...).
+        sdl.present();
+    }
+}