@@ -0,0 +1,474 @@
# Arquitectura de **Aventures en Egipte (AEE)**
> Guía de orientación para un desarrollador nuevo en el proyecto.
>
> Cada afirmación está anclada a código real: se cita el fichero (y, cuando
> ayuda, la función o el número de línea) que la respalda. Donde no he
> encontrado algo, lo digo explícitamente en lugar de inventarlo.
>
> **Aventures en Egipte** es un juego de aventura/plataformas retro (el
> protagonista "Sam" explora pirámides esquivando momias y recogiendo
> tesoros), escrito en C++ + SDL3. Resolución de juego **320×
> que más condiciona el código es que está **en plena migración** desde un
> motor legacy propio ("Jail") hacia C++ moderno (ver
> [§3](#3-el-motor-legacy-jail)). Los comentarios del código están en
> valenciano/español; este documento está en castellano.
>
> Existe además un `docs/scenes-migration-plan.md` (histórico) sobre la
> migración del sistema de escenas; aquí se documenta el **estado actual** del
> código, no el plan.
---
## Índice
1. [Visión general ](#1-visión-general )
2. [Punto de entrada y bucle principal ](#2-punto-de-entrada-y-bucle-principal )
3. [El motor legacy "Jail" ](#3-el-motor-legacy-jail )
4. [Escenas y máquina de estados ](#4-escenas-y-máquina-de-estados )
5. [Renderizado: de la lógica al píxel ](#5-renderizado-de-la-lógica-al-píxel )
6. [Entrada ](#6-entrada )
7. [Gameplay: `ModuleGame` y entidades ](#7-gameplay-modulegame-y-entidades )
8. [Sistema de escenas cinemáticas ](#8-sistema-de-escenas-cinemáticas )
9. [Recursos ](#9-recursos )
10. [Audio y localización ](#10-audio-y-localización )
11. [Configuración y persistencia ](#11-configuración-y-persistencia )
12. [Modo demo / IA ](#12-modo-demo--ia )
13. [Convenciones y patrones recurrentes ](#13-convenciones-y-patrones-recurrentes )
14. [Guía de navegación: "si quieres tocar X, mira Y" ](#14-guía-de-navegación-si-quieres-tocar-x-mira-y )
---
## 1. Visión general
El árbol `source/` separa **motor ** y **juego ** , pero con una particularidad:
el motor tiene **dos generaciones ** conviviendo (legacy "Jail" + capas nuevas).
- **`source/core/jail/` ** — el **motor legacy "Jail" ** (APIs C planas): `Jg`
(jgame), `Jd8` (jdraw8), `Ji` (jinput), `Jf` (jfile). En modernización (§3).
- **`source/core/` ** (resto) — capas **nuevas ** : `rendering` (`Screen` ,
`Overlay` , `Text` , `Menu` , `sdl3gpu` ), `input` , `system` (`Director` ),
`resources` , `audio` , `locale` .
- **`source/game/` ** — el juego: gameplay legacy en la raíz (`modulegame` ,
`prota` , `momia` , `engendro` , `bola` , `mapa` , `marcador` , `info` , `sprite` ) y
el sistema de **escenas ** nuevo en `scenes/` .
- **`source/utils/` ** — `easing` , `utils` .
- **`source/external/` ** — vendorizado (stb, fkyaml).
~117 ficheros C++, ~40.000 líneas.
**El `CLAUDE.md` define una frontera explícita "Original vs New Code" ** (§79):
`core/jail/` y `game/*.cpp` son * legacy en modernización * (modificar con
cuidado, preservando comportamiento); `core/rendering` , `core/input` ,
`utils/` , `options/defines/defaults` son * código nuevo * . Interiorizar esa
frontera es lo primero para no romper invariantes del juego original.
**Ideas-fuerza: **
1. Un solo hilo, **tick-based ** , vía callbacks de SDL3 (§2).
2. El render es **software paletizado 8-bit ** (`Jd8` , 320×
convierte a ARGB y pasa por shaders GPU (§5).
3. El flujo de pantallas es una **máquina de estados ** apoyada en
`Info::ctx.num_piramide` , con un `SceneRegistry` que va sustituyendo
cinemáticas legacy por escenas nuevas (§4).
``` mermaid
graph TD
SDL[SDL3 callbacks · main.cpp] --> DIR[Director]
DIR -->|game_state_ + Info::ctx| DISP{createNextScene}
DISP -->|==0| MG["ModuleGame (gameplay)"]
DISP -->|==1| REG["SceneRegistry::tryCreate(num_piramide)"]
REG --> CINE["intro / banner / slides / mort / secreta / credits…"]
MG --> MAPA[Mapa] & PROTA[Prota] & MOMIA[Momia] & BOLA[Bola] & MARC[Marcador]
DIR --> INP["KeyConfig / GlobalInputs / Gamepad / KeyRemap / Mouse"]
MG -->|dibuja índices| JD8["Jd8 (8-bit 320×
CINE --> JD8
JD8 -->|JD8_Flip → ARGB| SCREEN[Screen]
OVL[Overlay] --> SCREEN
SCREEN --> GPU["sdl3gpu PostFX / CrtPi / upscale"] --> WIN[Ventana]
RES["Resource::Cache / List"] -.-> MG & CINE
```
---
## 2. Punto de entrada y bucle principal
### 2.1. SDL conduce el bucle (callbacks)
`source/main.cpp` define `SDL_MAIN_USE_CALLBACKS` . No hay `while` propio (clave
para el port a Emscripten). `SDL_AppInit` monta todo y `SDL_AppIterate` llama a
`Director::iterate()` .
El arranque en `SDL_AppInit` inicializa, en orden: carpeta de config (`Jf` ),
sistema de recursos (`resources.pack` + fallback en Debug/WASM), `Options` ,
`KeyConfig` , `Locale` , presets de shaders, y luego el **motor ** : `Jg::init` ,
`Screen::init` , `Jd8::init` , `Audio::init` , `Overlay::init` , `Menu::init` ,
`Resource::List` /`Cache` (con `beginLoad()` ), y `Director::init` + `setup()` .
### 2.2. El `Director`
`source/core/system/director.{hpp,cpp}` . Es el **orquestador singleton, único
hilo del runtime** (sin fibers, mutex ni condition variables; el comentario de
`director.hpp:11` lo subraya). Posee el estado de escena como miembros:
`current_scene_` (`std::unique_ptr<Scenes::Scene>` ), `game_state_` ,
`last_tick_ms_` , y dos buffers de frame `[320*200]` (`game_frame_` ,
`presentation_buffer_` ).
Cada `iterate()` (modelo documentado en `CLAUDE.md:161` ):
```
Gamepad/KeyRemap/GlobalInputs/Mouse::update
JA_Update() ← bombeo de audio
if (!paused_) {
if (scene && (scene->done() || JG_Quitting())) game_state_ = scene->nextState(); scene.reset();
if (!scene) scene = createNextScene(); scene->onEnter(); ← ModuleGame o SceneRegistry
JI_Update()
scene->tick(now - last_tick_ms_)
JD8_Flip() ← índices → ARGB
memcpy → game_frame
}
memcpy game_frame → presentation_buffer
Overlay::render(presentation_buffer)
Screen::present(presentation_buffer)
SDL_Delay(frame_target - elapsed) ← cap de FPS
```
### 2.3. Tiempo, pausa y salida
Las escenas reciben `delta_ms` real (time-based). El gameplay (`ModuleGame` )
gatea su `Update()` a 10 ms fijos vía `Jg::shouldUpdate()` (ticker del motor
legacy, ya sin * yield * ). La **pausa ** (F11) simplemente salta el bloque de
`tick()` : el overlay y el present siguen, re-presentando el último frame
congelado. La **salida ** se solicita con `requestQuit()` (doble ESC o
`SDL_QUIT` ) y `requestRestart()` hace un reinicio suave (para audio, resetea
`Info::ctx` , vuelve a la intro).
---
## 3. El motor legacy "Jail"
`source/core/jail/` es el sustrato heredado, **APIs C planas con prefijo por
subsistema** (sin clases), que se está convirtiendo progresivamente a C++
idiomático manteniendo los nombres externos estables para no romper los
* call sites * (`CLAUDE.md:92` ). Es el rasgo más distintivo del proyecto.
| Subsistema | Fichero | Qué hace |
|---|---|---|
| * * `Jg` ** (jgame) | `jail/jgame.*` | * Timing * : init/finalize, fixed-timestep (`Jg::shouldUpdate()` a 10 ms), flag de salida (`JG_Quitting` ). |
| * * `Jd8` ** (jdraw8) | `jail/jdraw8.*` | **Renderer software 8-bit paletizado ** , buffer de pantalla 320× `Jd8::Surface = Uint8*` ), blits con * color key * , fades no bloqueantes (máquina de estados), `flip()` (paleta→ARGB) → `Screen::present` . |
| * * `Ji` ** (jinput) | `jail/jinput.*` | Sondeo de teclado, * debounce * , códigos * cheat * . Filtra las teclas de GUI del juego y llama a `GlobalInputs` /`Mouse` cada update. |
| * * `Jf` ** (jfile) | `jail/jfile.*` | I/O de ficheros: carpeta `data/` o pack; carpeta de config en `~/.config/jailgames/aee/` . |
### `Jd8` en detalle (el corazón del render)
`jail/jdraw8.hpp` . API representativa:
- `using Surface = Uint8*` (búfer de índices de paleta), `using Palette = Color*` .
- `loadSurface` /`newSurface` /`freeSurface` , `loadPalette` /`setScreenPalette` .
- Blits: `blit` , `blitCK` (con * color key * /transparencia), `blitCKCut` ,
`blitCKScroll` , `blitToSurface` /`blitCKToSurface` (blit entre surfaces).
- `fillRect` /`fillSquare` /`putPixel` /`getPixel` .
- **Fade no bloqueante** (`fadeStart*` + `fadeTickStep` que devuelve `true` al
acabar): sustituye los `JD8_FadeOut` bloqueantes del código original.
- `flip()` convierte el buffer indexado + paleta a ARGB y delega en
`Screen::present` ; `getFramebuffer()` devuelve el `Uint32*` resultante.
> Mentalidad clave: **todo el dibujo del juego ocurre sobre índices de 8 bits**
> en un buffer 320×
---
## 4. Escenas y máquina de estados
### 4.1. La base `Scene`
`source/game/scenes/scene.hpp` (`namespace Scenes` ):
``` cpp
class Scene {
public :
virtual void onEnter ( ) { } // una vez, antes del primer tick
virtual void tick ( int delta_ms ) = 0 ; // no bloquea, NO llama a Jd8::flip
virtual auto done ( ) const - > bool = 0 ;
virtual auto nextState ( ) const - > int { return 1 ; } // 1=siguiente, 0=gameplay, -1=salir
} ;
```
El `Director` hace avanzar la escena hasta que `done()` es cierto, consulta
`nextState()` y construye la siguiente.
### 4.2. El despachador: `game_state_` + `Info::ctx`
`Director::createNextScene()` decide la siguiente escena:
- `game_state_ == 0` → `new ModuleGame` (gameplay puro, §7).
- `game_state_ == 1` → `SceneRegistry::tryCreate(Info::ctx.num_piramide)`
(`game/scenes/scene_registry.hpp` ): un mapa `int → factory` que devuelve la
escena registrada para ese estado, o `nullptr` para caer al **path legacy ** .
Replica el viejo `ModuleSequence::Go` , incluido el * redirect * heredado
`num_piramide == 6 && diners < 200 → 7` (`CLAUDE.md:104` ).
- `game_state_ == -1` → salir.
### 4.3. `Info::ctx`: el estado del juego
`source/game/info.hpp` — `Info::GameContext ctx` (singleton inline) es la fuente
de verdad del estado:
``` cpp
struct GameContext {
int num_piramide , num_habitacio , diners , diamants , vida , momies , engendros ;
bool nou_personatge , pepe_activat ;
void reset ( ) ;
} ;
```
`num_piramide` es la pieza central: hace de **selector tanto de cinemáticas como
de nivel jugable**. El `SceneRegistry` va migrando cada estado de cinemática a
una `Scene` nueva; lo que no esté registrado cae a legacy. Por eso el registro
"crece" a medida que avanza la modernización.
``` mermaid
graph LR
SC[Scene activa] -->|done()| NS{nextState}
NS -->|0| MG[ModuleGame]
NS -->|1| REG["SceneRegistry(num_piramide)"]
NS -->|-1| QUIT[salir]
MG -->|muta Info::ctx| REG
REG --> SC
```
---
## 5. Renderizado: de la lógica al píxel
El pipeline tiene dos mitades: **software paletizado ** (`Jd8` ) y **GPU **
(`Screen` + shaders).
### 5.1. Software: dibujar índices
Escenas y `ModuleGame` dibujan sobre el buffer `screen` de `Jd8` (índices 8-bit,
320× * color key * . `JD8_Flip()` aplica la paleta y produce un
buffer ARGB (formato **ABGR8888 ** : `0xFF000000 + R + (G<<8) + (B<<16)` ;
`CLAUDE.md:220` ).
### 5.2. `Overlay`: sobre el buffer ARGB
`source/core/rendering/overlay.*` pinta **directamente sobre el buffer ARGB **
antes de presentar: notificaciones (slide-in), info de render animada (4
segmentos), indicador de **PAUSA ** y la lógica de **doble-ESC para salir ** .
### 5.3. `Screen`: a la ventana (GPU o fallback)
`source/core/rendering/screen.*` (singleton). Doble camino
(`Screen::present` , `CLAUDE.md:204` ):
- **GPU con shaders** (primario, `sdl3gpu/` ): sube los píxeles a una textura
de escena 320× * upscale * /**supersampling** (3× × ×
* downscale * Lanczos) y **estiramiento 4:3 ** fusionado en el * upscale * ; luego
el shader **PostFX ** o **CRT-Pi ** (con presets) a la * swapchain * con
* letterboxing * .
- **GPU sin shaders**: subida limpia a la * swapchain * .
- **Fallback**: `SDL_UpdateTexture` + `SDL_RenderPresent` (`SDL_Renderer` ).
`Screen` gestiona ventana, fullscreen, zoom, 4:3, * integer scaling * , VSync, FPS.
Apoyos de UI: `Text` (fuentes bitmap `.fnt` +`.gif` sobre el buffer ARGB, con
* clipping * 2D) y `Menu` (menú flotante de opciones con navegación por páginas,
animaciones y captura de teclas para * remapping * ).
---
## 6. Entrada
Toda la entrada de UI/sistema converge en * * `KeyConfig` ** como fuente única de
verdad de las teclas (`source/core/input/key_config.*` ): carga
`data/input/keys.yaml` (F1–
* overrides * del usuario; expone `scancode("id")` , `isGuiKey(sc)` (para que el
`Director` no propague teclas de UI al juego), y persiste solo lo que difiere
del default.
- **`GlobalInputs` ** (`global_inputs.*` ) — mapea las F-keys a acciones de
presentación (zoom, fullscreen, shaders, 4:3, supersampling, filtro, render
info, pausa, menú). Tabla completa en `CLAUDE.md:139` .
- **`Gamepad` ** (`gamepad.*` ) — primer mando con * hot-plug * y notificación;
D-pad/stick → flechas virtuales; botones frontales → Enter sintético;
SELECT → menú, START → pausa. Carga `gamecontrollerdb.txt` .
- **`KeyRemap` ** (`key_remap.*` ) — cada frame copia `Options::keys_game.*` al
estado virtual de scancodes estándar (UP/DOWN/LEFT/RIGHT). Permite remapear el
movimiento **sin tocar el código legacy ** de `prota.cpp` /`mapa.cpp` .
- **`Mouse` ** (`mouse.*` ) — auto-oculta el cursor tras 3 s de inactividad.
> Reparto deliberado: las teclas de **UI/sistema** viven en `KeyConfig`
> (`keys.yaml`); las de **movimiento del jugador** en `Options::keys_game`
> (`config.yaml`, sección `controls:`).
---
## 7. Gameplay: `ModuleGame` y entidades
`source/game/modulegame.{hpp,cpp}` es la **escena de gameplay puro **
(`game_state_ == 0` ). Hereda de `Scenes::Scene` y sustituye el viejo `Go()`
bloqueante por un `tick()` . Tres fases internas (`Phase` ):
`FADING_IN → PLAYING → FADING_OUT → DONE` (`modulegame.hpp:46` ), con un
`PaletteFade` para los fundidos no bloqueantes.
Coordina las entidades del nivel, todas con una `Jd8::Surface gfx_` compartida:
- **`Mapa` ** (`game/mapa.*` ) — la sala/pirámide: tiles con contenido
(`CONTE_RES` /`CONTE_TRESOR` /`CONTE_FARAO` …), colisión y dibujo del escenario.
- **`Prota` ** (`game/prota.*` ) — el protagonista "Sam" (hereda de `Sprite` ),
movimiento y colisión.
- **`Momia` ** (`game/momia.*` ) — enemigo que persigue al `Prota` (recibe
`Prota*` ); variante `dimoni` (demonio).
- **`Bola` ** (`game/bola.*` ) — bola/roca que interactúa con el `Prota` .
- **`Engendro` ** (`game/engendro.*` ) — entidad generada (su `update()` devuelve
`bool` ); `Info::ctx.engendros` lleva la cuenta.
- **`Marcador` ** (`game/marcador.*` ) — el marcador (vidas, dinero, diamantes),
lee del `Prota` /`Info::ctx` .
`ModuleGame::tick()` hace `draw()` (a `screen` , sin `flip` — lo hace el
`Director` ) y `update()` (gateado por `Jg::shouldUpdate` ). Cuando la partida
acaba (`final_ != 0` : muerte o cambio de sala), `applyFinalTransitions()` muta
`Info::ctx` y `nextState()` devuelve el estado siguiente.
Todas las entidades de gameplay derivan de * * `Sprite` ** (`game/sprite.*` ),
clase base con `draw()` /`update()` sobre `Jd8` .
---
## 8. Sistema de escenas cinemáticas
Las pantallas no jugables (`game_state_ == 1` ) son `Scene` s registradas en el
`SceneRegistry` . Las concretas viven en `source/game/scenes/` : `boot_loader`
(carga incremental, §9), `banner` , `intro` , `intro_new_logo` , `intro_sprites` ,
`slides` , `menu` (`menu_scene` ), `mort` (secuencia de muerte), `secreta`
(pantalla secreta) y `credits` .
Sobre ellas hay un **conjunto de utilidades de animación ** reutilizables —el
andamiaje "cinematográfico" del juego—:
- **`Timeline` ** (`scenes/timeline.*` ) — secuenciación temporal de eventos.
- **`FrameAnimator` ** (`scenes/frame_animator.*` ) — animación por fotogramas.
- **`SpriteMover` ** (`scenes/sprite_mover.*` ) — movimiento interpolado de
sprites (con `easing` ).
- **`PaletteFade` ** (`scenes/palette_fade.*` ) — fundidos por paleta no
bloqueantes (también usado por `ModuleGame` ).
- **`SurfaceHandle` ** (`scenes/surface_handle.*` ) — propiedad RAII de una
`Jd8::Surface` (las escenas poseen sus assets y los liberan en el destructor).
- **`scene_utils` ** — helpers compartidos.
---
## 9. Recursos
- **`Resource::List` ** (`core/resources/resource_list.*` ) — registro de rutas de
asset desde * * `data/config/assets.yaml` **, con consulta O(1).
- **`Resource::Cache` ** (`core/resources/resource_cache.*` ) — caché de assets con
**carga incremental ** : `beginLoad()` (en `SDL_AppInit` ) + la escena
`BootLoaderScene` que el `Director` arranca automáticamente mientras
`Resource::Cache::isLoadDone()` sea falso (una barra de progreso con la
ventana viva).
- **Pack y fallback**: `resource_pack.*` + `resource_helper.*` sirven desde
* * `resources.pack` ** (formato propio "AEE1", `CLAUDE.md:237` ); en release
nativo es estricto (solo pack), en Debug/WASM hay * fallback * a `data/` .
- **Formatos**: GIF/paletas para gráficos (vía `Jd8` ), fuentes `.fnt` +`.gif` ,
OGG/WAV para audio, GLSL para shaders.
---
## 10. Audio y localización
- **Audio**: `core/audio/audio.*` (singleton, aplica `Options::audio` ) sobre
* * `jail_audio` ** (`Ja` , `jail/jail_audio.hpp` / `core/audio/jail_audio.hpp` ),
mezcla propia con streams SDL3 (OGG vía `stb_vorbis` , WAV). `JA_Update()` se
bombea cada frame desde el `Director` ; pausa/resume con F11.
- **Localización**: `core/locale/locale.*` — mapa plano clave→cadena cargado de
YAML (`data/locale/ca.yaml` , valenciano por defecto). Claves con notación de
puntos (`menu.items.zoom` ); si falta una clave, devuelve la propia clave
(fallback visible para depurar).
---
## 11. Configuración y persistencia
- **`Options` ** (`source/game/options.*` ) — namespace con globals `inline` y
carga/guardado YAML. Structs: `KeysGame` (movimiento), `Video` , `RenderInfo` ,
`Audio` , `Window` , `Game` , `PostFXPreset` , `CrtPiPreset` .
- **`defines.hpp` ** — constantes del juego: `Texts::WINDOW_TITLE` /`VERSION` ,
`GameScreen::WIDTH=320` /`HEIGHT=200` /`BUFFER_SIZE=64000` .
- **`defaults.hpp` ** — valores por defecto (`Defaults::KeysGame` , `Video` ,
`Audio` , `Window` , `Game` ).
- **`KeyConfig` ** — teclas de UI (§6).
Ficheros persistentes en `~/.config/jailgames/aee/` (`CLAUDE.md:224` ):
`config.yaml` (vídeo/audio/ventana/render_info/controles), `keys.yaml`
(overrides de UI), `postfx.yaml` (6 presets), `crtpi.yaml` (4 presets), y en
Debug `debug.yaml` (estado inicial de gameplay para pruebas).
**Builds condicionales ** : `NDEBUG` (release: pack estricto, sin `debug.yaml` ),
`__EMSCRIPTEN__` (WASM: fuerza ventana/zoom/4:3, mantiene fallback de assets,
sin persistencia MEMFS).
---
## 12. Modo demo / IA
**No he encontrado un modo demo, * attract mode * ni IA de demostración en este
proyecto.** Lo he buscado explícitamente: la única aparición de "replay" es un
comentario en `jail_audio.hpp` sobre re-reproducción de pistas de audio, sin
relación con un modo demo.
A diferencia de los proyectos hermanos `coffee_crisis` (playback de input
grabado) o `jaildoctors_dilemma` (tour de habitaciones), aquí el flujo de
atracción —si lo hubiera— se construiría sobre el `SceneRegistry` y las escenas
cinemáticas (§8), pero **hoy no existe ** tal cosa implementada.
---
## 13. Convenciones y patrones recurrentes
- **Frontera legacy/nuevo** (`CLAUDE.md:79` ): lo más importante. `core/jail/` y
`game/*.cpp` son legacy en modernización (preservar comportamiento); el resto
es código nuevo. Los assets de `data/gfx` /`data/music` son **intocables ** .
- **Namespaces legacy abreviados** `Jg` /`Jd8` /`Ji` /`Jf` /`Ja` (APIs C planas),
con nombres externos estables durante la transición.
- **Single-thread, tick-based**: sin fibers/mutex; las escenas no bloquean ni
llaman a `Jd8::flip` (lo hace el `Director` ).
- **Render paletizado 8-bit** sobre buffer 320×
final (`JD8_Flip` → `Screen` ).
- **Singletons con `init()` /`destroy()` /`get()` ** (`Screen` , `Audio` ,
`Director` , `Menu` , `Overlay` , `Resource::*` , `Jd8` /`Jg` como módulos),
creados/destruidos en orden explícito en `SDL_AppInit` /`SDL_AppQuit` .
- **Máquina de estados por `Info::ctx.num_piramide` ** + `SceneRegistry` que
migra cinemáticas legacy a `Scene` s nuevas de forma incremental.
- **Fades y timing no bloqueantes**: lo que antes eran bucles bloqueantes
(`JD8_FadeOut` ) ahora son máquinas de estados que avanzan un paso por tick.
- **Comentarios** en valenciano/español; muchos `#include` con comentario de
justificación (estilo IWYU).
---
## 14. Guía de navegación: "si quieres tocar X, mira Y"
| Quiero… | Empieza por… |
|---|---|
| Entender el arranque | `source/main.cpp` (`SDL_AppInit` ) + `core/system/director.cpp` |
| El bucle / orden del frame | `Director::iterate()` (`director.cpp` ) |
| Tocar el motor de dibujo | `core/jail/jdraw8.*` (`Jd8` ) |
| Timing / fixed-timestep | `core/jail/jgame.*` (`Jg::shouldUpdate` ) |
| Añadir/editar una pantalla | `game/scenes/` (hereda de `Scenes::Scene` ) + `SceneRegistry::registerScene` |
| Cómo se decide la siguiente pantalla | `Director::createNextScene` + `Info::ctx.num_piramide` + `scene_registry.*` |
| El estado del juego | `game/info.hpp` (`Info::ctx` ) |
| **Gameplay ** | `game/modulegame.*` (fases) + entidades `prota/momia/bola/engendro/mapa/marcador` |
| Animaciones de cinemáticas | `game/scenes/{timeline,frame_animator,sprite_mover,palette_fade,surface_handle}.*` |
| Composición final / shaders | `core/rendering/screen.*` + `sdl3gpu/` + presets `postfx.yaml` /`crtpi.yaml` |
| Overlays (notificaciones/PAUSA/info) | `core/rendering/overlay.*` |
| Texto / menú | `core/rendering/text.*` , `core/rendering/menu.*` |
| Teclas de UI / F1– `core/input/key_config.*` + `global_inputs.*` + `data/input/keys.yaml` |
| Remapear movimiento | `core/input/key_remap.*` + `Options::keys_game` |
| Mando | `core/input/gamepad.*` |
| Cargar recursos / barra de carga | `core/resources/resource_cache.*` + `resource_list.*` + `scenes/boot_loader_scene.*` |
| Audio | `core/audio/audio.*` + `jail_audio.hpp` (`Ja` ) |
| Idiomas | `core/locale/locale.*` + `data/locale/` |
| Opciones / constantes | `game/options.*` , `game/defines.hpp` , `game/defaults.hpp` |
| Carpetas y pack | `core/jail/jfile.*` (`Jf` ) + `core/resources/resource_pack.*` |
---
*Documento generado a partir de la lectura directa del código en el commit
actual de la rama `main` . Si algo aquí no cuadra con el código, el código
manda: actualiza este documento.*
JailDesigner