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();
+    }
+}

source/core/system/director.hpp

@@ -1,8 +1,14 @@
 #pragma once
 
+#include <memory>
 #include <string>
 #include <vector>
 
+#include "scene_context.hpp"
+
+class Scene;
+class SDLManager;
+
 class Director {
     public:
         explicit Director(std::vector<std::string> const& args);
@@ -17,4 +23,16 @@ class Director {
         static auto checkProgramArguments(std::vector<std::string> const& args)
             -> std::string;
         void createSystemFolder(const std::string& folder);
+
+        // Construye la escena correspondiente al tipo solicitado. Retorna
+        // nullptr para EXIT u otros valores no constructibles.
+        static auto buildScene(SceneManager::SceneContext::SceneType type,
+                               SDLManager& sdl,
+                               SceneManager::SceneContext& context)
+            -> std::unique_ptr<Scene>;
+
+        // Ejecuta el bucle de frames de UNA escena hasta que scene.isFinished()
+        // sea true. Maneja delta_time, eventos (globales + escena), update y draw.
+        static void runFrameLoop(Scene& scene, SDLManager& sdl,
+                                 SceneManager::SceneContext& context);
 };

source/core/system/scene.hpp

@@ -0,0 +1,41 @@
+// scene.hpp - Interfaz base para escenas del juego
+// © 2025 Orni Attack
+//
+// El frame loop vive en Director, no en cada escena. Cada escena implementa
+// estos cuatro métodos y el Director los llama en orden por frame:
+//   handleEvent(ev)   por cada evento SDL (tras los eventos globales)
+//   update(dt)        lógica
+//   draw()            pintado (entre clear y present del Director)
+//   isFinished()      consultar transición pendiente
+//
+// Cuando una escena pide transición (vía context_.setNextScene(...)),
+// isFinished() debe pasar a true y el Director destruye la escena para
+// construir la siguiente.
+
+#pragma once
+
+#include <SDL3/SDL.h>
+
+class Scene {
+    public:
+        Scene() = default;
+        virtual ~Scene() = default;
+
+        Scene(const Scene&) = delete;
+        auto operator=(const Scene&) -> Scene& = delete;
+        Scene(Scene&&) = delete;
+        auto operator=(Scene&&) -> Scene& = delete;
+
+        // Eventos específicos de la escena. Los globales (window resize,
+        // F1-F4, ESC, QUIT) los procesa GlobalEvents::handle antes.
+        virtual void handleEvent(const SDL_Event& event) = 0;
+
+        // Lógica de la escena. delta_time en segundos, ya capeado por el Director.
+        virtual void update(float delta_time) = 0;
+
+        // Pintar la escena (entre clear y present del Director).
+        virtual void draw() = 0;
+
+        // True cuando la escena ha pedido transición.
+        [[nodiscard]] virtual auto isFinished() const -> bool = 0;
+};