Avanzate

PaperZD

Crea animazioni 2D per i personaggi in PaperZD semplicemente chiedendolo: flipbook da uno sprite sheet, animation source, Animation Blueprint, state machine, personaggi giocabili e una verifica in gioco.

PaperZD di Critical Failure Studio è il sistema di animazione usato dalla maggior parte dei giochi Paper2D: grafi di animazione e state machine per personaggi a flipbook. È gratuito su Fab e su GitHub.

Con l’estensione PaperZD, Ultimate Engine CoPilot costruisce queste configurazioni al posto tuo, da uno sprite sheet fino a un personaggio che cammina e attacca durante il gioco.

È stata testata con PaperZD 2.2.4 su Unreal Engine 5.7.

Cosa ti serve

PaperZD, installato e attivo nel tuo progetto. Usa il plugin Paper2D di Unreal, che PaperZD attiva insieme a sé.
Uno sprite sheet per il tuo personaggio, oppure dei flipbook già esistenti.

In più, Ultimate Engine CoPilot con l’estensione PaperZD attiva.

Senza PaperZD l’estensione non fa nulla di dannoso. Ogni strumento PaperZD risponde con un unico messaggio che dice se il plugin è installato, attivo e caricato, e cosa fare dopo.

Configurazione

Installa PaperZD da Fab o da GitHub e attivalo nel tuo progetto. Riavvia l’editor se Unreal lo chiede.
Nel CoPilot, apri Impostazioni > Estensioni e attiva PaperZD. Di base è disattivata.
Chiedi all’AI di controllare lo stato di PaperZD. Ti dice se PaperZD è stato trovato e, in caso contrario, cosa manca.

Cosa puoi chiedere

“Ecco il mio sprite sheet del cavaliere, 6 colonne per 13 righe. Crea i flipbook per idle, walk e attack in quattro direzioni e configura PaperZD per usarli.”
“Aggiungi una state machine con Idle, Walk e Attack. Walk quando il personaggio si muove, di nuovo Idle quando si ferma, e Attack parte una volta e poi torna a Idle.”
“Fai in modo che le animazioni guardino nella direzione in cui si muove il personaggio.”
“Crea un personaggio giocabile con WASD per muoversi e Space per attaccare, con una camera dietro di lui e un game mode che lo faccia comparire.”
“Aggiungi un suono di passi all’animazione di walk.”
“Cambia il personaggio con la palette rossa mentre il gioco è in esecuzione.”

Dietro queste richieste, l’AI può:

Ritagliare uno sprite sheet in animazioni. Una sola chiamata trasforma uno sheet in sprite, flipbook, animation sequence, un’animation source e un Animation Blueprint. Le animazioni con più direzioni diventano un’unica sequence multidirezionale.
Costruire il grafo di animazione. Nodi play sequence, state machine, direction, override slot, selezione per bool, numero o enum, random player e cached animation, e collegarli.
Costruire state machine. Stati, conduit e jump, con transizioni che scattano su una variabile, quando l’animazione corrente finisce, sempre o mai, con una priorità e una sequence di transizione opzionale.
Aggiungere notify. Eventi personalizzati, suoni ed effetti Niagara o particellari su una timeline, con i notify personalizzati che diventano funzioni che puoi riempire.
Aggiungere skin. Flipbook sostitutivi per ogni animazione, per costumi o cambi di palette, applicati mentre il gioco è in esecuzione.
Creare personaggi. Un nuovo personaggio PaperZD guidato dall’Animation Blueprint, oppure collegare un actor esistente. Può anche aggiungere una traccia PaperZD a una Level Sequence.
Verificarlo in gioco. Leggere quale sequence è in riproduzione, a che punto è e i valori delle variabili di animazione, e riprodurre, fermare o saltare a un’animazione per testare a mano una transizione.

Errori che evita

PaperZD ha alcune trappole che compilano senza errori ma non fanno comunque nulla. L’AI le conosce:

La regola di una nuova transizione è “never” finché non viene impostata, quindi il personaggio non uscirebbe mai da Idle.
Una variabile letta da una regola deve essere scritta da qualche parte, di solito nel tick dell’Animation Blueprint. Una compilazione pulita non prova che la regola cambi mai, quindi l’AI verifica in gioco.
Una sequence viene riprodotta solo in un Animation Blueprint della propria animation source, quindi tiene insieme gli asset di ogni personaggio.
Stati e transizioni vengono compilati in un unico batch alla fine di un gruppo di modifiche, non dopo ognuna.
La griglia dello sprite sheet si legge da sinistra a destra partendo dall’alto, quindi l’AI conta le celle come le conta PaperZD.

Consigli e trucchi

Vengono dalla costruzione di un piccolo villaggio giocabile con PaperZD e il CoPilot: un eroe, un abitante, nemici scheletro e lupi che vagano. È stato testato con PaperZD 2.2.4 su Unreal Engine 5.7.

I tre che contano di più:

Di’ all’AI l’esatta disposizione delle righe del tuo sheet. Numera le righe da 0, di’ quali righe sono animazioni e quale riga è qualcos’altro, e apri il primo frame di ogni flipbook per controllare.
Non ruotare mai l’actor. Un flipbook è una carta piatta, quindi la direzione deve venire da quale animazione viene riprodotta, non dalla rotazione dell’actor.
Non fidarti di una compilazione pulita. Chiedi un test in gioco che riporti l’animazione corrente e le sue variabili.

Descrivi lo sheet con precisione

L’AI non può vedere quale riga del tuo sheet contiene quale animazione. Devi dirglielo tu.

Uno sheet esportato da PixelLab ha 6 colonne e 13 righe di celle da 92 pixel, con quattro direzioni in ogni animazione nell’ordine sud, ovest, est, nord. La riga 0 è una riga di pose di rotazione, non un’animazione.
L’esportazione include un file di layout che elenca quale riga contiene quale animazione. Usalo. L’ordine cambia da personaggio a personaggio: nel villaggio l’eroe e il mago avevano walk per primo, lo scheletro attack per primo e il lupo idle per primo.
Conta da 0 e nomina la riga di rotazione. In una sessione il prompt diceva “le righe da 1 a 4 sono il walk”. L’AI ha contato da 1, quindi ogni animazione era sfasata di una riga e l’eroe guardava dalla parte sbagliata.

Scrivi le righe così:

Ogni sheet è di 6 colonne per 13 righe di celle da 92 pixel. Numera le righe da 0. La riga 0 è la riga di rotazione, saltala. Le righe da 1 a 4 sono il walk (sud, ovest, est, nord, 6 frame), le righe da 5 a 8 l’attack, le righe da 9 a 12 l’idle (4 frame).

Impostazioni che contano

Pixel art attiva. Le texture usano il filtro nearest e nessun mip, così i pixel restano nitidi.
Pivot in basso al centro. I piedi restano nello stesso punto in ogni frame.
Frame al secondo. Chiedi le velocità che vuoi. L’AI ha usato 15 per tutto, e questo faceva ripetere un idle da 4 frame in circa un quarto di secondo. Idle 6, walk 12 e attack 14 sembravano giusti.
Ordine delle direzioni. Una sequence multidirezionale procede in senso orario partendo dall’alto: nord, est, sud, ovest.
I valori su un actor piazzato vincono. Un cooldown o una velocità impostati su un actor nel livello prevalgono sul valore predefinito del Blueprint, quindi controlla le copie piazzate quando una modifica sembra non fare nulla.

Mantieni lo sprite rivolto verso la camera

Questa è la configurazione che ha impedito allo sprite di girare, inclinarsi o mostrarsi di taglio:

Disattiva la rotazione dell’actor. Controller yaw disattivato, orient rotation to movement disattivato, controller desired rotation disattivato. Se restano attivi, la carta ruota con l’actor e può mostrarsi di taglio.
Fai comparire l’actor con yaw 0. Un yaw di comparsa di 180 fa inclinare la carta lontano da una camera fissa nel mondo.
Fissa lo spring arm al mondo. Pawn control rotation disattivato, inherit di pitch, yaw e roll disattivato, collision test disattivato. Un pitch di -40 e uno yaw di -90 hanno funzionato.
Inclina la carta una sola volta. Con la camera che guarda in basso di 40 gradi, dai allo sprite un roll di -40 e sollevalo in modo che i piedi tocchino il pavimento.
Muoviti negli assi del mondo, non lungo il vettore forward o right dell’actor.
Mostra la direzione con Set Directionality. Dagli una variabile Vector2D chiamata Facing. Scrivi Facing a ogni tick dalla velocità e mantieni l’ultimo valore quando il personaggio si ferma.

Con quella camera i tasti si mappano così:

D muove lungo +X, Facing (1, 0).
W muove lungo -Y, Facing (0, 1).
A muove lungo -X, Facing (-1, 0).
S muove lungo +Y, Facing (0, -1).

Se sinistra e destra o su e giù risultano scambiati, inverti il segno di quella parte di Facing. Non ruotare l’actor per compensare.

Provalo in gioco

Una transizione non fa nulla finché la sua regola non può cambiare. Una nuova regola è “never”, e una regola che legge una variabile ha bisogno di qualcosa che scriva quella variabile, di solito il tick dell’Animation Blueprint. Chiedi un test in gioco che riporti l’animazione corrente.
Dai a Facing un valore iniziale. Viene scritto solo mentre il personaggio si muove, quindi un attack prima del primo passo legge zero. Un valore predefinito di sud lo risolve.
Fai guardare l’eroe verso il bersaglio. Se l’attack deve colpire qualcosa di lato, chiedi all’AI di impostare Facing verso il nemico più vicino prima del colpo.

Una sessione reale

La clip della collaborazione è stata costruita in quattro prompt nella chat del CoPilot, con l’agente Claude Code. L’AI ha eseguito i propri test in gioco e ha riparato ciò che ha trovato. I tempi sono di una sola macchina.

Due personaggi importati, con state machine di idle, walk e attack: circa 2,5 minuti.
Un eroe giocabile (WASD per muoversi, Space per attaccare), una camera con spring arm, un game mode e un abitante che cammina tra tre punti: circa 7 minuti.
Un nemico scheletro che insegue e attacca, punti ferita e un contatore di salute sullo schermo: circa 7 minuti.
Lupi che vagano, erbe da raccogliere e un contatore di erbe: circa 7 minuti.

L’aspetto è un lavoro a parte

L’AI costruisce l’animazione e il gameplay. L’aspetto della clip è stato impostato nel livello, non dall’AI:

Luce calda del sole e delle lanterne.
Bloom, una vignettatura e una profondità di campo ridotta per un effetto tilt-shift.
Un materiale emissive unlit sui personaggi.

Parti dal materiale unlit e da un’esposizione fissa. Regolare l’esposizione a occhio per molti giri è costato più tempo di quanto ne abbia fatto risparmiare.

Limiti

L’AI non sa quale animazione contiene ogni riga del tuo sheet. Devi dirglielo tu.
I nemici camminano dritti verso l’eroe, senza pathfinding intorno agli oggetti.
A un angolo esatto di 45 gradi due assi sono in parità e l’animazione sceglie est.
La salute si ferma a 0. Non succede nient’altro finché non chiedi una morte.
Non è riuscita a leggere uno stato di animazione a metà della pressione prolungata di un tasto, e lo ha detto invece di tirare a indovinare.

Permessi

Leggere è libero: ispezionare un asset, un grafo o un’animazione in esecuzione non chiede mai. Le modifiche seguono la tua impostazione Ask Before Edit o Auto Edit, come ogni altro strumento.

Come funziona

Nessun legame tra i plugin. L’estensione raggiunge PaperZD solo tramite reflection, quindi Ultimate Engine CoPilot compila e funziona allo stesso modo con o senza PaperZD installato, e l’estensione continua a funzionare tra le versioni di PaperZD con lo stesso design. Se un aggiornamento rinomina qualcosa, lo strumento indica il campo mancante invece di tirare a indovinare.
Ovunque allo stesso tempo. Gli strumenti funzionano nella chat del CoPilot, nei client MCP esterni come Claude Code e Cursor, e negli agenti di programmazione. Vedi Integrazione MCP.
39 strumenti. Strumenti di authoring, ispezione e di tempo di gioco per source, sequence, notify, skin, Animation Blueprint, grafi, state machine, personaggi e Sequencer.

Vedi Estensioni per come funzionano le estensioni, e Test di gioco per come l’AI verifica un gioco in esecuzione.