JailDesigner
5e82dc880f
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>
95 lines
4.1 KiB
C++
95 lines
4.1 KiB
C++
// logo_scene.hpp - Pantalla de start del juego
|
|
// Muestra logo JAILGAMES animat con zoom i salta al juego
|
|
// © 2025 Port a C++20
|
|
|
|
#pragma once
|
|
|
|
#include <SDL3/SDL.h>
|
|
|
|
#include <array>
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
#include "core/defaults.hpp"
|
|
#include "core/graphics/shape.hpp"
|
|
#include "core/input/input_types.hpp"
|
|
#include "core/rendering/sdl_manager.hpp"
|
|
#include "core/system/scene.hpp"
|
|
#include "core/system/scene_context.hpp"
|
|
#include "core/types.hpp"
|
|
#include "game/effects/debris_manager.hpp"
|
|
|
|
class LogoScene final : public Scene {
|
|
public:
|
|
explicit LogoScene(SDLManager& sdl, SceneManager::SceneContext& context);
|
|
~LogoScene() override; // Destructor per aturar sons
|
|
|
|
// Scene interface
|
|
void handleEvent(const SDL_Event& event) override;
|
|
void update(float delta_time) override;
|
|
void draw() override;
|
|
[[nodiscard]] auto isFinished() const -> bool override;
|
|
|
|
private:
|
|
// Màquina de estats per l'animación
|
|
enum class AnimationState {
|
|
PRE_ANIMATION, // Pantalla negra inicial
|
|
ANIMATION, // Animación de zoom de lletres
|
|
POST_ANIMATION, // Logo complet visible
|
|
EXPLOSION, // Explosión seqüencial de lletres
|
|
POST_EXPLOSION // Espera después de l'última explosión
|
|
};
|
|
|
|
SDLManager& sdl_;
|
|
SceneManager::SceneContext& context_;
|
|
AnimationState estat_actual_; // Estat actual de la màquina
|
|
float
|
|
temps_estat_actual_; // Temps en l'state actual (reset en cada transición)
|
|
|
|
// Gestor de fragments de explosions
|
|
std::unique_ptr<Effects::DebrisManager> debris_manager_;
|
|
|
|
// Seguiment de explosions seqüencials
|
|
size_t lletra_explosio_index_; // Índex de la següent lletra a explode
|
|
float temps_des_ultima_explosio_; // Temps desde l'última explosión
|
|
std::vector<size_t> ordre_explosio_; // Ordre aleatori de índexs de lletres
|
|
|
|
// Estructura para cada lletra del logo
|
|
struct LetraLogo {
|
|
std::shared_ptr<Graphics::Shape> shape;
|
|
Vec2 position; // Posición final en pantalla
|
|
float ancho; // Ancho del bounding box
|
|
float offset_centre; // Distancia de min_x a shape_centre.x
|
|
};
|
|
|
|
std::vector<LetraLogo> lletres_; // 9 lletres: J-A-I-L-G-A-M-E-S
|
|
|
|
// Seguiment de sons de lletres (evitar reproduccions repetides)
|
|
std::array<bool, 9> so_reproduit_; // Track si cada lletra ya ha reproduit el so
|
|
|
|
// Constants de animación
|
|
static constexpr float DURACIO_PRE = 1.5F; // Duració PRE_ANIMATION (pantalla negra)
|
|
static constexpr float DURACIO_ZOOM = 4.0F; // Duració del zoom (segons)
|
|
static constexpr float DURACIO_POST_ANIMATION = 3.0F; // Duració POST_ANIMATION (logo complet)
|
|
static constexpr float DURACIO_POST_EXPLOSION = 3.0F; // Duració POST_EXPLOSION (espera final)
|
|
static constexpr float DELAY_ENTRE_EXPLOSIONS = 0.1F; // Temps entre explosions de lletres
|
|
static constexpr float VELOCITAT_EXPLOSIO = 240.0F; // Velocidad base fragments (px/s)
|
|
static constexpr float ESCALA_INICIAL = 0.1F; // Escala inicial (10%)
|
|
static constexpr float ESCALA_FINAL = 0.8F; // Escala final (80%)
|
|
static constexpr float ESPAI_ENTRE_LLETRES = 10.0F; // Espaiat entre lletres
|
|
|
|
// Constants de animación seqüencial
|
|
static constexpr float THRESHOLD_LETRA = 0.6F; // Umbral per activar següent lletra (0.0-1.0)
|
|
static constexpr float ORIGEN_ZOOM_X = Defaults::Game::WIDTH * 0.5F; // Vec2 inicial X del zoom
|
|
static constexpr float ORIGEN_ZOOM_Y = Defaults::Game::HEIGHT * 0.4F; // Vec2 inicial Y del zoom
|
|
|
|
// Métodos privats
|
|
void inicialitzar_lletres();
|
|
void actualitzar_explosions(float delta_time);
|
|
auto checkSkipButtonPressed() -> bool;
|
|
|
|
// Métodos de gestió de estats
|
|
void canviar_estat(AnimationState nou_estat);
|
|
[[nodiscard]] bool totes_lletres_completes() const;
|
|
};
|