JailDesignerandClaude Opus 4.7
c13b11c501
Habilita la regla 1 de la nova FSM de joc: durant PLAYING, qualsevol
slot DISABLED pot pulsar START per entrar a partida amb spawn aeri al
seu costat de la porta i vides reseteades. Quan un jugador esgota les
vides, `respawnFromDying` el deixa a DISABLED i publica `player_disabled`
al bus; GameScene i HUD reaccionen, deixant el slot disponible per a un
nou join. Afegeix prompts al HUD ("PULSA START / PER JUGAR" o
"ESPERA / PER JUGAR") segons l'estat de la RoomFsm.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
360 lines
17 KiB
C++
360 lines
17 KiB
C++
#pragma once
|
|
|
|
#include <array>
|
|
#include <cstdint>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "core/rendering/transitions/fade_to_black.hpp"
|
|
#include "core/scene/scene.hpp"
|
|
#include "core/ui/ui_config.hpp"
|
|
#include "game/debug_config.hpp"
|
|
#include "game/entities/entity_manager.hpp"
|
|
#include "game/map/paint_layer.hpp"
|
|
#include "game/map/tilemap.hpp"
|
|
#include "game/scenes/room_fsm.hpp"
|
|
|
|
#ifdef _DEBUG
|
|
#include "game/editor/editor.hpp"
|
|
#endif
|
|
|
|
class Hud;
|
|
class Player;
|
|
class Text;
|
|
|
|
class GameScene : public Scene {
|
|
public:
|
|
// Conjunt de rutes que defineixen una piràmide concreta (mapa + tilemap
|
|
// + sprites dels jugadors + música). Cada piràmide serà un Config distint;
|
|
// `defaultConfig()` retorna la primera (Defaults::Pyramid). `starting_players`
|
|
// controla quins jugadors instancia el ctor: només P1, només P2 o els dos.
|
|
struct Config {
|
|
std::string map_yaml;
|
|
std::string player_sprite;
|
|
std::string player_yaml;
|
|
std::string player2_sprite;
|
|
std::string player2_yaml;
|
|
std::string music_track;
|
|
DebugConfig::StartingPlayers starting_players{DebugConfig::StartingPlayers::BOTH};
|
|
};
|
|
|
|
[[nodiscard]] static auto defaultConfig() -> Config;
|
|
|
|
explicit GameScene(Config config = defaultConfig());
|
|
~GameScene() override;
|
|
|
|
void update(int delta_ms) override;
|
|
void render() override;
|
|
|
|
private:
|
|
// Punt centralitzat per canviar d'estat de sala. Imprimeix la
|
|
// transició i reinicialitza els acumuladors de la `RoomFsm::Transition`.
|
|
// Cap estat s'ha de canviar fora d'aquí.
|
|
void setState(RoomFsm::State new_state);
|
|
|
|
// Avança la transició activa via `RoomFsm::advance`. S'executa cada
|
|
// frame amb delta real (no escalat per la pausa) perquè la transició
|
|
// viu en temps de UI. Si l'estat retornat és diferent de l'actual,
|
|
// crida `setState` (que reseteja la `Transition`).
|
|
void updateRoomTransition(int delta_ms);
|
|
|
|
// Consumeix events d'aquest frame (F11 del KeyConfig "pause") per
|
|
// disparar les transicions de pausa. El mando ja no participa: el
|
|
// botó START és ara una acció remapeable per dispositiu i el menú
|
|
// de servei fa de pausa quan cal. 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);
|
|
|
|
// Spawna un Dust transitori centrat a (`feet_x_center`, `feet_y`).
|
|
// Cridat per la subscripció del bus a `player_jumped` /
|
|
// `player_landed` per pintar el polvet de despegue / aterratge.
|
|
// `is_landing` selecciona la variant de l'animació al `Dust`.
|
|
void spawnDust(float feet_x_center, float feet_y, bool is_landing);
|
|
|
|
// Spawna un `WhipAttack` a partir del payload publicat al bus quan
|
|
// un Player entra a `ATTACKING`. Llig la plantilla cacheada del YAML
|
|
// i delega la mida + surface al `WhipAttack::configure()` segons
|
|
// direcció.
|
|
void spawnWhip(const struct WhipSpawnPayload& payload);
|
|
|
|
Config config_;
|
|
Tilemap tilemap_;
|
|
|
|
// Gestor d'entitats del nivell (sarcòfags, porta, momia, antorxa,
|
|
// etc.). Viu aquí perquè la seua vida coincideix amb la de la escena;
|
|
// cada entitat del nivell es carrega al ctor via loadFromLevel.
|
|
EntityManager entity_manager_;
|
|
|
|
// Vector des del principi: AEE suportarà multijugador local; cada Player
|
|
// té els seus propis Controls i entra al vector amb una crida extra.
|
|
// Sempre conté **dos** entrades (P1 a [0], P2 a [1]) tant en mode BOTH
|
|
// com en single-player: l'slot inactiu es queda en estat DISABLED i
|
|
// pot entrar mid-partida via "join in progress" (`handleJoinInput`).
|
|
std::vector<std::unique_ptr<Player>> players_;
|
|
|
|
// Quins slots estan en partida ARA MATEIX (jugant o DYING). Mutable
|
|
// durant la sala: el ctor el sembra des de `config_.starting_players`,
|
|
// `joinPlayer` el posa a true quan un slot inactiu pulsa START, i la
|
|
// subscripció a `player_disabled` el torna a false quan un slot
|
|
// esgota vides. `loadRoom` recalcula `setExpectedPlayerCount` a
|
|
// partir d'aquesta vista — un slot DISABLED al final d'una sala no
|
|
// entra automàticament a la següent (el jugador ha de re-pulsar
|
|
// START si vol re-entrar).
|
|
std::array<bool, 2> players_active_{false, false};
|
|
|
|
// Cinemàtica de spawn d'un slot concret. Posa el slot indicat en
|
|
// AIRBORNE des d'una altura fora de pantalla. Cridat per
|
|
// `spawnDuePlayers` quan el timer post-callback supera el delay
|
|
// del slot. Idempotent (consulta `players_spawned_in_intro_`).
|
|
// També és el punt al qual es connectarà el respawn post-mort en
|
|
// el futur.
|
|
void triggerPlayerSpawn(std::size_t slot_index);
|
|
|
|
// Cos del callback de fi de música d'INTRO. Idempotent: si ja s'ha
|
|
// disparat aquest cicle (`intro_completed_`), no fa res. Marca el
|
|
// flag, reseteja el timer post-callback i intenta spawn dels slots
|
|
// actius amb delay <= 0 ara mateix; els altres cauen frame a frame
|
|
// dins `updateRoomTransition` quan el timer els assoleix. Finalment
|
|
// commuta a PLAYING — la música del joc arrenca amb el primer slot.
|
|
void completeIntro();
|
|
|
|
// Dispatch del cicle DYING al jugador identificat per `player_id`.
|
|
// Crida `Player::enterDying()` (idempotent — un segon impacte mentre
|
|
// ja és DYING és no-op). Subscriptor de l'event `player_killed`
|
|
// publicat pels hazards letals (mòmia amb `kills_outright`).
|
|
// Extret a un mètode per acotar la complexitat cognitiva del ctor.
|
|
void dispatchPlayerKilled(int player_id);
|
|
|
|
// Handler de l'event `player_disabled` (un slot acaba d'esgotar
|
|
// vides). Apaga `players_active_[id]` perquè el `loadRoom` següent
|
|
// no compti aquest slot i perquè el "join in progress" del frame
|
|
// següent torni a oferir-li `setJoinPrompt(CAN_JOIN)`. Extret a
|
|
// mètode per acotar la complexitat cognitiva del subscriber/ctor.
|
|
void onPlayerDisabled(int player_id);
|
|
|
|
// Itera els slots actius i, si el delay configurat ha expirat des
|
|
// del callback de fi de música d'INTRO, dispara `triggerPlayerSpawn`.
|
|
// Cridada cada frame durant la fase d'spawn escalonat (entre el
|
|
// callback i la caiguda de l'últim slot). No fa res si ja han
|
|
// caigut tots o si encara no estem dins la finestra (intro_completed_).
|
|
void spawnDuePlayers();
|
|
|
|
// Atén el "join in progress" (regla 1 de la FSM de joc): si un slot
|
|
// està DISABLED i el jugador corresponent pulsa START dins de PLAYING,
|
|
// dispara `joinPlayer`. La detecció de tecla/botó la fa
|
|
// `Input::detect::pressedStart`. Ignorat fora de PLAYING (durant
|
|
// INTRO/OUTRO el slot inactiu mostra "ESPERA / PARA JUGAR" al HUD).
|
|
void handleJoinInput();
|
|
|
|
// Materialitza l'entrada d'un slot inactiu: spawn aeri al costat
|
|
// corresponent de la porta (`computeSpawn().pX_x`), reset de vides
|
|
// al valor inicial via `Player::resetForJoin`, marcatge de
|
|
// `players_active_[i]=true` i activació del bloc del HUD. La
|
|
// cinemàtica reaprofita `spawnFromAir` (mateixa caiguda visual que
|
|
// l'INTRO de sala i el respawn post-mort).
|
|
void joinPlayer(std::size_t slot_index);
|
|
|
|
// Recompte de jugadors "en partida" (no DISABLED ni EXITED, o bé
|
|
// DYING — DYING encara compta com a jugant fins que es resol). Hook
|
|
// exposat per a la futura sub-FSM CONTINUE? + GAME OVER, que vigila
|
|
// la transició a 0 jugadors actius. No s'usa dins de la Fase 1.
|
|
[[nodiscard]] auto activePlayerCount() const -> int;
|
|
|
|
// Refresca el prompt mostrat al bloc HUD de cada slot inactiu. Es
|
|
// crida cada frame des d'`update()`. La decisió viu ací (que coneix
|
|
// `state_` de la RoomFsm); el HUD només pinta. Per a slots actius,
|
|
// posa el prompt a NONE per ser defensiu davant de canvis d'estat.
|
|
void refreshJoinPrompt();
|
|
|
|
// Sentinel que marca el moment "música d'INTRO acabada" dins del
|
|
// timeline. Ja no ve d'un callback d'àudio: el setja el GameScene
|
|
// quan la FSM ha consumit l'última fase d'INTRO (la `music_tail`,
|
|
// calculada perquè coincideixi amb el final del .ogg). Habilita el
|
|
// tick de `intro_spawn_elapsed_ms_` i el spawn aeri escalonat dels
|
|
// slots actius.
|
|
bool intro_completed_{false};
|
|
|
|
// Mil·lisegons acumulats des del callback de fi de música d'INTRO,
|
|
// per gatejar l'spawn aeri escalonat dels slots actius. P1 fa
|
|
// servir `player_spawn_delay_ms` (típicament 0); P2 en mode BOTH
|
|
// fa servir `player2_spawn_delay_ms` (offset respecte P1). Es
|
|
// reseteja a 0 dins `completeIntro` i no torna a córrer fins al
|
|
// següent cicle d'INTRO.
|
|
int intro_spawn_elapsed_ms_{0};
|
|
|
|
// Per slot: ja ha caigut aquest cicle d'INTRO? Garanteix
|
|
// idempotència de `triggerPlayerSpawn` davant múltiples ticks del
|
|
// timer mentre el delay no s'ha mogut. Es reseteja a `enterRoomIntro`
|
|
// i a `setState(ROOM_INTRO)` (camí defensiu no canònic).
|
|
std::array<bool, 2> players_spawned_in_intro_{false, false};
|
|
|
|
// Vista plana de punters crus — la fa servir Player com a llista
|
|
// d'obstacles mòbils a la callback de col·lisió. Es construeix un sol
|
|
// cop al ctor (els punters són estables perquè `players_` no es
|
|
// redimensiona dins de la vida de l'escena).
|
|
std::vector<Player*> players_view_;
|
|
|
|
// Factor multiplicatiu del push inter-jugador. Carregat de la clau
|
|
// `push_factor` del YAML del mapa; 0.30 per defecte (veure
|
|
// `Defaults::Player::PUSH_FACTOR`). Constant dins de la vida de
|
|
// l'escena — una piràmide, una física.
|
|
float push_factor_{0.30F};
|
|
|
|
// Capa de "pintat" del terra. Escolta `on_tile_entered` al bus,
|
|
// filtra pintabilitat (sòl transitable) i re-publica `tile_painted`
|
|
// per als sarcòfags. `unique_ptr` per controlar l'ordre de
|
|
// construcció/destrucció: es crea al ctor un cop `entity_manager_` i
|
|
// `tilemap_` estan llestos, i es destrueix abans que `entity_manager_`
|
|
// (on viu el bus al qual està subscrit). Declarat després d'aquests
|
|
// dos membres per garantir l'ordre invers a la destrucció.
|
|
std::unique_ptr<PaintLayer> paint_layer_;
|
|
|
|
// Marcador de la franja superior (24 px). `unique_ptr` per controlar
|
|
// l'ordre de construcció/destrucció igual que `paint_layer_`: es crea
|
|
// al ctor un cop `entity_manager_` ja té el bus, i es destrueix abans
|
|
// que `entity_manager_` (on viu el bus al qual està subscrit).
|
|
// Declarat després d'`entity_manager_` per garantir l'ordre invers a
|
|
// la destrucció.
|
|
std::unique_ptr<Hud> hud_;
|
|
|
|
// 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_;
|
|
|
|
// Font del rètol de transició de sala (ROOM_INTRO i ROOM_OUTRO).
|
|
// Distinta de `pause_font_` perquè el rètol de fase té estètica
|
|
// pròpia (CaesarDressing per defecte, configurable via
|
|
// `data/config/ui.yaml > fonts.room_text`). La pausa segueix amb la
|
|
// placeholder.
|
|
std::shared_ptr<Text> room_text_font_;
|
|
|
|
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_;
|
|
|
|
// Configuració de la FSM de sala (intro/outro). Carregada al ctor des
|
|
// de `data/scenes/game/game.yaml`; valors per defecte si manca el YAML.
|
|
RoomFsm::Config transition_config_{};
|
|
|
|
// Estat actual de la FSM de sala. S'inicialitza a ROOM_INTRO al ctor
|
|
// perquè cada vegada que entres al joc passes per la presentació de
|
|
// la sala. La transició a PLAYING l'orquestra `updateRoomTransition`.
|
|
RoomFsm::State state_{RoomFsm::State::ROOM_INTRO};
|
|
|
|
// Sub-fase i temps acumulat dins de l'estat actual. `setState` el
|
|
// reseteja a {0, 0}.
|
|
RoomFsm::Transition transition_{};
|
|
|
|
// Fade-in d'INTRO: alpha 255 → 0 durant `intro_fade_in_ms`. Es comença
|
|
// a `enterRoomIntro` i tica cada frame; un cop finished, `render()`
|
|
// pinta alpha=0 (no-op) durant la resta del cicle.
|
|
Transitions::FadeToBlack intro_fade_;
|
|
|
|
// Fade-out d'OUTRO: alpha 0 → 255 durant `outro_fade_out_ms`, només
|
|
// arrencat quan la FSM entra a la fase corresponent (detectada via
|
|
// `outro_fade_started_`). Un cop finished, `render()` segueix
|
|
// pintant alpha=255: això cobreix de manera natural la fase final
|
|
// de `black_hold` sense lògica especial.
|
|
Transitions::FadeToBlack outro_fade_;
|
|
bool outro_fade_started_{false};
|
|
|
|
// Píxels del fade negre i del text de la transició de sala.
|
|
// Cridats des de `render()` entre el bloc d'actors i el HUD —
|
|
// així marcador, notificacions i service menu queden per damunt.
|
|
void renderRoomFade();
|
|
void renderRoomText();
|
|
|
|
// Helpers de `renderRoomText`. Tots consulten `transition_` i
|
|
// `transition_config_` directament a través de `this` — així les
|
|
// signatures es queden netes i la funció pública s'orquestra amb
|
|
// poques línies. Tres tasques separades:
|
|
// - X animada d'una línia (entra per un costat, surt per l'altre).
|
|
// - Altura animada del panel translúcid (creix, manté, decreix).
|
|
// - Pintat efectiu del panel i d'una línia de text.
|
|
[[nodiscard]] auto computeRoomTextX(int width, int phase_enter, int phase_exit, int dur_enter, int dur_exit, bool from_right) const -> int;
|
|
[[nodiscard]] auto computeRoomTextPanelHeight(int phase_enter, int phase_hold, int phase_exit, int dur_enter, int dur_exit) const -> int;
|
|
void drawRoomTextPanel(int center_y, int panel_height) const;
|
|
void drawRoomTextLine(const std::string& text, int x, int y, std::uint8_t fill_color, std::uint8_t outline_color) const;
|
|
|
|
// Posició inicial dels jugadors derivada de `Map::door_col`. Tots
|
|
// els jugadors comparteixen Y (centre del corredor exterior superior);
|
|
// X depèn del nombre actiu: amb un jugador queda centrat sota la
|
|
// porta; amb dos, separats ±tile_size respecte al centre. Estructura
|
|
// exposada perquè els tests puguen verificar-la sense entrar al ctor
|
|
// sencer.
|
|
struct PlayerSpawn {
|
|
float p1_x{0.0F};
|
|
float p2_x{0.0F};
|
|
float y{0.0F};
|
|
};
|
|
[[nodiscard]] static auto computeSpawn() -> PlayerSpawn;
|
|
|
|
// Recarrega la sala apuntada per `yaml_path`: refresca Map (geometria,
|
|
// porta tancada), entitats (sarcs/porta/momies des de zero), neteja
|
|
// el PaintLayer i deixa els jugadors a DISABLED esperant la cinemàtica
|
|
// d'spawn aeri del nou cicle d'INTRO. També actualitza
|
|
// `config_.map_yaml` perquè futurs consumidors (l'Editor en guardar,
|
|
// logs, etc.) sàpiguen quina sala està viva.
|
|
void loadRoom(const std::string& yaml_path);
|
|
|
|
// Demana al LevelManager el següent nivell i el carrega via
|
|
// `loadRoom`, deixant la FSM al començament d'un nou cicle d'INTRO.
|
|
// Si ja era a l'última entrada, fa loop a la primera (política
|
|
// temporal mentre no hi haja pantalla de fi de joc). Cridat des de
|
|
// `updateRoomTransition` quan l'OUTRO arriba a la fase final.
|
|
void advanceToNextRoom();
|
|
|
|
// Inicia (o reinicia) el cicle d'entrada de sala: posa l'estat a
|
|
// ROOM_INTRO, reseteja `transition_` i `intro_completed_`, comença
|
|
// la pista `room_intro.ogg` i resol el `intro_music_tail_ms` perquè
|
|
// el timeline acabi just al final del .ogg. Sense callback de fi de
|
|
// música — la transició a PLAYING la dispara `updateRoomTransition`
|
|
// quan la FSM consumeix l'última fase. Si la música no arrenca, la
|
|
// cua queda a 0 i l'INTRO acaba al final del text. Idempotent quan
|
|
// ja s'estava a INTRO — útil per als salts debug.
|
|
void enterRoomIntro();
|
|
|
|
#ifdef _DEBUG
|
|
// Spawn instantani sense cinemàtica: usat al sortir del editor per
|
|
// fer un "fresh start" de la sala (jugadors al spawn, sense la
|
|
// cinemàtica `room_intro.ogg`). Posa l'estat directament a PLAYING.
|
|
void respawnPlayersInstant();
|
|
#endif
|
|
|
|
#ifdef _DEBUG
|
|
// 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
|
|
};
|