Box2DPlatformer Scena e Risorse

Box2DPlatformer: scena e risorse

Questa pagina segue il percorso dall'avvio alla prima immagine sullo schermo. Le classi Game, GameScene, View e UIScene provengono dal core; il progetto le specializza e compone un livello con body Box2D. Per la simulazione vera e propria passa a World, body e contatti.

Avvio e stack delle scene

main() crea e registra PlatformerGame, poi chiama init() e run(). Il costruttore di PlatformerGame inizializza SpriteFactory, Audio e, se abilitato, Fonts; il distruttore elimina prima le scene e poi i servizi. LevelLoader è una classe di utilità con metodi statici, non un singleton. PlatformerGame::init() inserisce nello stack, nell'ordine:

PlatformerGameScene("level0") -> HUD -> Menu iniziale

Il menu è una UIScene bloccante: intercetta input e aggiornamenti finché New Game ne richiede la rimozione con popSceneLater(). L'HUD resta separato dalla scena di gioco e usa una sua vista a rapporto d'aspetto fissato. Mostra punteggio, FPS e tempo; il tempo cala in HUD::update() quando l'HUD è attivo. Il menu di pausa viene aggiunto sopra le altre scene con Invio o Esc e chiuso da Resume.

Come nasce level0

LevelLoader::load("level0") legge levels/level0.json tramite LevelData e costruisce una PlatformerGameScene. Dimensioni 96 x 13, 32 x 32 pixel per unità, timestep 1/100 s e colore di sfondo sono argomenti del costruttore definiti nel loader C++. Dopo setJsonPath(path), loadJson(world, level) crea i contenuti:

1. Il codice C++ crea l'immagine fissa fg_ground e la registra con addBackgroundImage().
2. La polilinea di categoria Terrain produce un collider per ogni segmento valido, comprese le pendenze.
3. Le due regioni Gear creano gli ingranaggi cinematici.
4. La regione Player definisce lo spawn e il giocatore viene registrato con setPlayer().
5. Il loader crea esplicitamente gli OverlayScene per cielo, case, erba, pioggia e nebbia: parallasse e ripetizione sono argomenti dei costruttori nel C++.

Il livello incluso non contiene Box, Slime o Trigger; scatole e slime si possono creare col mouse, e le rispettive categorie sono già supportate dal loader. Le categorie riconosciute sono Renderable, Terrain, Gear, Player, Static, Box e Slime.

Grafica e collider del terreno sono dati distinti. L'immagine fg_ground copre il mondo ma non è una regione di objects: nell'editor resta visibile senza intercettare selezione e modifica dei segmenti. La polilinea Terrain conserva soltanto il profilo fisico. Non occorre un grande rettangolo di categoria Terrain.

Le regioni non richiedono name: il loader usa la categoria. Gear, Player, Box e Slime scelgono lo sprite nel proprio costruttore; Static e Renderable letti dal JSON sono trasparenti e senza sprite. La grafica è definita nel C++, separatamente dai collider; colori e layer non sono proprietà JSON. Schema e proprietà sono in LevelData e livelli JSON.

Coordinate, vista e camera

La scena costruisce un Box2D world con gravità {0, -24} e configura la View iniziale come rettangolo di 24 x 13 unità con yUp = true. Qui il verso positivo di Y va verso l'alto, diversamente dai pixel della finestra: salto e gravità seguono questa convenzione. View::mapToScene() converte le coordinate del mouse in quelle della scena prima di creare oggetti.

updateCamera() porta la camera verso destra quando il giocatore supera la zona intorno a X = 11 rispetto alla vista, ma non la riporta automaticamente a sinistra. Se è attiva la modalità camera manuale, la scena delega al comportamento della classe base. Gli OverlayScene sono layer visivi separati: alcuni usano fattori di parallax e ripetizione dell'immagine; non sono body Box2D.

Input e interfaccia

updatePhysicsControls() legge la tastiera prima di ogni passo Box2D: frecce sinistra/destra impostano la direzione, Z lo stato di corsa. event() gestisce pressioni singole: Spazio per saltare, D per il dash, F per sparare, Invio/Esc per il menu di pausa. Clic sinistro crea una Box, clic destro uno Slime, nel punto convertito dalla vista. I controlli generici della GameScene, come la visualizzazione dei collider, restano nel core.

La voce Options del menu comprende un interruttore VSYNC che legge e cambia l'impostazione del renderer SDL. Il passo fisico è indipendente dal refresh: le forze vengono riapplicate a ogni step, anche quando un frame ne contiene più di uno. Le altre voci dimostrative (Load, Select, alcune opzioni) stampano soltanto un messaggio: non caricano un salvataggio.

Da dove arrivano gli asset

SpriteFactory carica immagini da SDL_GetBasePath() + "sprites/...": il percorso è relativo alla cartella dell'eseguibile, non alla directory da cui avvii il programma. Costruisce sprite statici, sequenze animate e testo a tasselli dalla texture hud.png. Le animazioni di giocatore, nemici, pioggia e fuoco sono quindi presentazione, non geometria di collisione.

Il CMakeLists.txt collega SDL3, SDL3_image, SDL3_mixer, core e Box2D 3; dopo la build copia sprites/ accanto all'eseguibile e suoni/font in assets/. Se il programma parte senza immagini, controlla innanzitutto quella copia e il valore effettivo di SDL_GetBasePath().

Il progetto copia anche gli shader condivisi in assets/shaders/: i tasti 1-9 e 0 attivano o disattivano i dieci effetti GPU. La pioggia dell'effetto 1, con lampi pseudo-casuali, è distinta dall'overlay di pioggia della scena. Vedi Shader e post-processing.

Il target CMake copy_levels copia inoltre levels/ a ogni build. load(name) cerca levels/<name>.json; E apre quel file nell'editor. Dopo il salvataggio, riporta la copia accanto all'eseguibile nel sorgente del progetto prima della build successiva. Vedi Editor dei livelli.

V attiva/disattiva musica ed effetti anche nei menu e in pausa; M resta il comando per la camera manuale. Vedi Input ed eventi.

Sorgenti

• Box2DPlatformer/levels/level0.json
• main.cpp e PlatformerGame.cpp
• LevelLoader.cpp e PlatformerGameScene.cpp
• SpriteFactory.cpp, HUD.cpp e Menu.cpp
• CMakeLists.txt

Prosegui con World, body e contatti.