Geavanceerd

PaperZD

Bouw 2D-karakteranimatie in PaperZD door erom te vragen: flipbooks uit een spritesheet, animatiebronnen, Animation Blueprints, state machines, speelbare karakters en een speelcontrole.

PaperZD van Critical Failure Studio is het animatiesysteem dat de meeste Paper2D-games gebruiken: animatiegrafen en state machines voor flipbook-karakters. Het is gratis op Fab en op GitHub.

Met de uitbreiding PaperZD bouwt Ultimate Engine CoPilot die opzetten voor je, van een spritesheet tot een karakter dat in het spel loopt en aanvalt.

Het is getest met PaperZD 2.2.4 op Unreal Engine 5.7.

Wat je nodig hebt

PaperZD, geïnstalleerd en ingeschakeld in je project. Het gebruikt de eigen plugin Paper2D van Unreal, die PaperZD er meteen bij aanzet.
Een spritesheet voor je karakter, of bestaande flipbooks.

Plus Ultimate Engine CoPilot met de uitbreiding PaperZD aangezet.

Zonder PaperZD doet de uitbreiding niets schadelijks. Elke PaperZD-tool antwoordt met één bericht dat zegt of de plugin is geïnstalleerd, ingeschakeld en geladen, en wat je daarna moet doen.

Instellen

Installeer PaperZD via Fab of GitHub en schakel het in je project in. Herstart de editor als Unreal erom vraagt.
Open in de CoPilot Instellingen > Uitbreidingen en zet PaperZD aan. Standaard staat hij uit.
Vraag de AI om de status van PaperZD te controleren. Hij meldt of PaperZD is gevonden en, zo niet, wat er ontbreekt.

Waar je om kunt vragen

“Dit is mijn spritesheet van een ridder, 6 kolommen bij 13 rijen. Maak flipbooks voor idle, walk en attack in vier richtingen en zet PaperZD ervoor op.”
“Voeg een state machine toe met Idle, Walk en Attack. Walk als het karakter beweegt, terug naar Idle als het stopt, en Attack speelt één keer af en gaat dan terug naar Idle.”
“Laat de animaties kijken in de richting waarin het karakter beweegt.”
“Maak een speelbaar karakter met WASD om te bewegen en Space om aan te vallen, met een camera erachter en een game mode die het spawnt.”
“Voeg een voetstapgeluid toe aan de walk-animatie.”
“Zet het karakter op het rode palet terwijl het spel draait.”

Achter die verzoeken kan de AI:

Een spritesheet in animaties knippen. Eén aanroep verandert een sheet in sprites, flipbooks, animatiesequenties, een animatiebron en een Animation Blueprint. Animaties met meerdere richtingen worden één multidirectionele sequentie.
De animatiegraaf bouwen. Nodes voor sequentie afspelen, state machine, richting, override-slot, selecteren op bool, getal of enum, willekeurige speler en gecachete animatie, en ze verbinden.
State machines bouwen. States, conduits en sprongen, met transities die afgaan op een variabele, wanneer de huidige animatie klaar is, altijd of nooit, met een prioriteit en een optionele overgangssequentie.
Notifies toevoegen. Eigen events, geluiden en Niagara- of deeltjeseffecten op een tijdlijn, waarbij eigen notifies functies worden die je kunt invullen.
Skins toevoegen. Vervangende flipbooks per animatie, voor outfits of paletwissels, toegepast terwijl het spel draait.
Karakters maken. Een nieuw PaperZD-karakter dat door de Animation Blueprint wordt aangestuurd, of een bestaande actor erop aansluiten. Hij kan ook een PaperZD-track aan een Level Sequence toevoegen.
Het in het spel controleren. Uitlezen welke sequentie speelt, hoe ver die is en wat de waarden van de animatievariabelen zijn, en een animatie afspelen, stoppen of ernaartoe springen om een transitie met de hand te testen.

Fouten die hij vermijdt

PaperZD heeft een paar valkuilen die schoon compileren en toch niets doen. De AI kent ze:

De regel van een nieuwe transitie is “never” tot je hem instelt, dus het karakter zou Idle nooit verlaten.
Een variabele die een regel leest, moet ergens geschreven worden, meestal in de tick van de Animation Blueprint. Een schone compilatie bewijst niet dat de regel ooit verandert, dus de AI controleert het in het spel.
Een sequentie speelt alleen af in een Animation Blueprint van haar eigen animatiebron, dus hij houdt de assets van elk karakter bij elkaar.
States en transities worden in één keer gecompileerd aan het eind van een groep wijzigingen, niet na elke afzonderlijke.
Het raster van de spritesheet wordt van links naar rechts gelezen, vanaf de bovenkant, dus de AI telt cellen op dezelfde manier als PaperZD.

Tips en trucs

Deze komen uit het bouwen van een klein speelbaar dorp met PaperZD en de CoPilot: een held, een dorpeling, skeletvijanden en ronddwalende wolven. Het is getest met PaperZD 2.2.4 op Unreal Engine 5.7.

De drie die het meest tellen:

Vertel de AI de echte rij-indeling van je sheet. Nummer de rijen vanaf 0, zeg welke rijen animaties zijn en welke rij iets anders is, en open het eerste frame van elke flipbook om het te controleren.
Draai de actor nooit. Een flipbook is een platte kaart, dus de richting moet komen van welke animatie speelt, niet van het draaien van de actor.
Vertrouw niet op een schone compilatie. Vraag om een speeltest die de huidige animatie en de variabelen ervan meldt.

Beschrijf de sheet exact

De AI kan niet zien welke rij van je sheet welke animatie bevat. Dat moet je hem vertellen.

Een sheet die uit PixelLab is geëxporteerd, heeft 6 kolommen en 13 rijen van cellen van 92 pixels, met in elke animatie vier richtingen in de volgorde zuid, west, oost, noord. Rij 0 is een rij met rotatiehoudingen, geen animatie.
De export komt met een layoutbestand dat laat zien welke rij welke animatie bevat. Gebruik het. De volgorde verschilt per karakter: in het dorp hadden de held en de magiër walk eerst, het skelet attack eerst en de wolf idle eerst.
Tel vanaf 0 en noem de rotatierij. In één sessie stond in de prompt “rijen 1 tot en met 4 zijn de walk”. De AI telde vanaf 1, dus elke animatie zat één rij ernaast en de held keek de verkeerde kant op.

Schrijf de rijen zo op:

Elke sheet is 6 kolommen bij 13 rijen van cellen van 92 pixels. Nummer de rijen vanaf 0. Rij 0 is de rotatierij, sla die over. Rijen 1 tot en met 4 zijn de walk (zuid, west, oost, noord, 6 frames), rijen 5 tot en met 8 de attack, rijen 9 tot en met 12 de idle (4 frames).

Instellingen die ertoe doen

Pixelart aan. De texturen gebruiken nearest-filtering en geen mips, zodat de pixels scherp blijven.
Pivot onderin het midden. De voeten blijven in elk frame op dezelfde plek.
Frames per seconde. Vraag om de snelheden die je wilt. De AI gebruikte 15 voor alles, waardoor een idle van 4 frames in ongeveer een kwart seconde liep. Idle 6, walk 12 en attack 14 zagen er goed uit.
Richtingsvolgorde. Een multidirectionele sequentie loopt met de klok mee vanaf boven: noord, oost, zuid, west.
Waarden op een geplaatste actor winnen. Een cooldown of snelheid die op een actor in het level is ingesteld, gaat voor de standaardwaarde van de Blueprint, dus controleer de geplaatste exemplaren als een wijziging niets lijkt te doen.

Houd de sprite naar de camera gericht

Met deze opzet draaide, kantelde of stond de sprite niet meer op zijn kant:

Zet de rotatie van de actor uit. Controller yaw uit, orient rotation to movement uit, controller desired rotation uit. Staat dat aan, dan draait de kaart mee met de actor en kan hij op zijn kant komen te staan.
Spawn met yaw 0. Een spawn-yaw van 180 laat de kaart van een camera af leunen die vast in de wereld staat.
Zet de spring arm vast aan de wereld. Pawn control rotation uit, pitch, yaw en roll overnemen uit, collision test uit. Een pitch van -40 en een yaw van -90 werkten.
Kantel de kaart één keer. Geef de sprite bij een camera die 40 graden omlaag kijkt een roll van -40, en til hem op zodat de voeten de vloer raken.
Beweeg langs wereldassen, niet langs de forward- of right-vector van de actor.
Toon de richting met Set Directionality. Voer er een Vector2D-variabele Facing aan. Schrijf Facing elke tick vanuit de snelheid en bewaar de laatste waarde als het karakter stopt.

Met die camera zijn de toetsen zo toegewezen:

D beweegt langs +X, Facing (1, 0).
W beweegt langs -Y, Facing (0, 1).
A beweegt langs -X, Facing (-1, 0).
S beweegt langs +Y, Facing (0, -1).

Als links en rechts of boven en onder verwisseld blijken, draai dan het teken van dat deel van Facing om. Draai de actor niet om het te compenseren.

Test het in het spel

Een transitie doet niets tot zijn regel kan veranderen. Een nieuwe regel is “never”, en een regel die een variabele leest, heeft iets nodig dat die variabele schrijft, meestal de tick van de Animation Blueprint. Vraag om een speeltest die de huidige animatie meldt.
Geef Facing een beginwaarde. Hij wordt alleen geschreven terwijl het karakter beweegt, dus een aanval vóór de eerste stap leest nul. Een standaardwaarde van zuid lost dat op.
Laat de held naar het doel kijken. Als de aanval iets aan één kant moet raken, vraag de AI dan om Facing naar de dichtstbijzijnde vijand te zetten vóór de zwaai.

Een echte sessie

De collab-clip is gebouwd in vier prompts in de CoPilot-chat, met de Claude Code-agent. De AI voerde zijn eigen speeltests uit en herstelde wat hij vond. De tijden komen van één machine.

Twee karakters geïmporteerd, met state machines voor idle, walk en attack: ongeveer 2,5 minuten.
Een speelbare held (WASD om te bewegen, Space om aan te vallen), een spring-arm-camera, een game mode en een dorpeling die tussen drie punten loopt: ongeveer 7 minuten.
Een skeletvijand die achtervolgt en aanvalt, levenspunten en een gezondheidsteller op het scherm: ongeveer 7 minuten.
Ronddwalende wolven, verzamelbare kruiden en een kruidenteller: ongeveer 7 minuten.

De look is een apart karwei

De AI bouwt de animatie en de gameplay. De look van de clip is in het level ingesteld, niet door de AI:

Warm zonlicht en lantaarnlicht.
Bloom, een vignet en een geringe scherptediepte voor een tilt-shiftgevoel.
Een unlit emissief materiaal op de karakters.

Begin met het unlit materiaal en een vaste belichting. De belichting op het oog bijstellen in veel rondes kostte meer tijd dan het opleverde.

Beperkingen

De AI weet niet welke animatie elke rij van je sheet bevat. Dat moet je hem vertellen.
Vijanden lopen recht op de held af, zonder pathfinding om objecten heen.
Bij een exacte hoek van 45 graden staan twee assen gelijk en kiest de animatie oost.
Gezondheid stopt bij 0. Er gebeurt niets anders tot je om een dood vraagt.
Hij kon geen animatiestatus uitlezen midden in een ingedrukte toets, en dat zei hij ook in plaats van te gokken.

Rechten

Lezen is vrij: een asset, een graaf of een draaiende animatie bekijken vraagt nooit om toestemming. Wijzigingen volgen je instelling Vraag het even voordat je iets bewerkt of Automatisch bewerken, net als elke andere tool.

Hoe het werkt

Geen koppeling tussen de plugins. De uitbreiding bereikt PaperZD alleen via reflectie, dus Ultimate Engine CoPilot bouwt en draait hetzelfde met of zonder geïnstalleerd PaperZD, en de uitbreiding blijft werken met PaperZD-versies van hetzelfde ontwerp. Als een update iets hernoemt, noemt de tool het ontbrekende veld in plaats van te gokken.
Overal tegelijk. De tools werken in de chat van de CoPilot, in externe MCP-clients zoals Claude Code en Cursor, en in coding agents. Zie MCP-integratie.
39 tools. Tools voor het maken, inspecteren en tijdens het spelen, voor bronnen, sequenties, notifies, skins, Animation Blueprints, grafen, state machines, karakters en Sequencer.

Zie Uitbreidingen voor hoe uitbreidingen werken, en Speltests voor hoe de AI een draaiend spel controleert.