Unlimited WordPress themes, graphics, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Game Development
  2. Pathfinding

A * Pathfinding Voor 2D op Grid-Gebaseerde Platformgames: een Bot Maken Volg Het Pad

by
Difficulty:IntermediateLength:LongLanguages:
This post is part of a series called How to Adapt A* Pathfinding to a 2D Grid-Based Platformer.
A* Pathfinding for 2D Grid-Based Platformers: Different Character Sizes
A* Pathfinding for 2D Grid-Based Platformers: Ledge Grabbing

Dutch (Nederlands) translation by Adjatay Bashroh Aldad (you can also view the original English article)

In deze zelfstudie gebruiken we het padbepalingsalgoritme van de platformer dat we hebben gebouwd om een ​​bot van stroom te voorzien die het pad zelfstandig kan volgen; klik gewoon op een locatie en deze zal rennen en springen om daar te komen. Dit is erg handig voor NPC's!

Demo

U kunt de Unity-demo of de WebGL versie (100 MB+) spelen om het uiteindelijke resultaat in actie te zien. Gebruik WASD om het personage te verplaatsen, klik met de linkermuisknop op een plek om een ​​pad te vinden dat je kunt volgen om daar te komen, klik met de rechtermuisknop op een cel om de grond op dat punt te wisselen, klik met de middelste muisknop om een ​​eenrichtingsplatform te plaatsen en klik - en sleep de schuifregelaars om hun waarden te wijzigen.

De Motor Updaten

Omgaan Met de Bot State

De bot heeft twee gedefinieerde toestanden: de eerste is om niets te doen, en de tweede is voor het hanteren van de beweging. In je game heb je waarschijnlijk veel meer nodig om het gedrag van de bot aan te passen aan de situatie.

De updatelus van de bot zal verschillende dingen doen afhankelijk van welke status momenteel is toegewezen aan mCurrentBotState:

De functie CharacterUpdate verwerkt alle ingangen en werkt de fysica voor de bot bij.

Om de status te wijzigen, gebruiken we een ChangeState functie die eenvoudig de nieuwe waarde toekent aan mCurrentBotState:

Het Beheersen van de Bot

We sturen de bot door invoer te simuleren, die we toewijzen aan een reeks Booleans:

Deze array wordt geïndexeerd door het KeyInput opsommingsteken:

Bijvoorbeeld, als we een druk op de linkerknop willen simuleren, we doen het als volgt:

De karakterlogica zal dan deze kunstmatige invoer op dezelfde manier verwerken als waarmee het echte invoer zou verwerken.

We hebben ook een extra hulpfunctie of een opzoektabel nodig om het aantal frames te krijgen dat we nodig hebben om op de springknop te drukken om een ​​bepaald aantal blokken te verspringen:

Merk op dat dit alleen consequent werkt als onze game wordt geüpdatet met een vaste frequentie en de startsprong van het personage hetzelfde is. Idealiter zouden we deze waarden voor elk karakter apart berekenen, afhankelijk van de springsnelheid van dat personage, maar het bovenstaande werkt in ons geval prima.

Voorbereiden en Verkrijgen van Het Pad om te Volgen

De Doellokatie Beperken

Voordat we de Pathfinder daadwerkelijk gebruiken, is het een goed idee om de doelbestemming op de grond te dwingen. Dit komt omdat de speler waarschijnlijk op een plek klikt die iets boven de grond is, in welk geval het pad van de bot eindigt met een ongemakkelijke sprong in de lucht. Door het eindpunt op het grondoppervlak te laten zakken, kunnen we dit eenvoudig vermijden.

Laten we eerst kijken naar de functie TappedOnTile. Deze functie wordt gebeld wanneer de speler ergens in het spel klikt; de parameter mapPos is de positie van de tegel waarop de speler heeft geklikt:

We moeten de positie van de aangeklikte tegel verlagen totdat deze op de grond ligt:

Eindelijk, als we eenmaal bij een grondtegel zijn aangekomen, weten we waar we het personage naartoe willen verplaatsen:

Bepaling van de Startlocatie

Voordat we de functie FindPath daadwerkelijk aanroepen, moeten we ervoor zorgen dat we de juiste startcel doorgeven.

Laten we eerst aannemen dat de starttegel de cel linksonder van een personage is:

Deze tegel is misschien niet degene die we als eerste knooppunt willen doorgeven aan het algoritme, omdat als ons personage op de rand van het platform staat, de starttile die op deze manier is berekend mogelijk geen grond heeft, zoals in de volgende situatie:

In dit geval willen we het startknooppunt instellen op de tegel aan de linkerkant van het karakter, niet in het midden ervan.

Laten we beginnen met het creëren van een functie die ons zal vertellen of het personage in een andere positie zal passen, en zo ja, of het op die plaats ter plaatse is:

Laten we eerst eens kijken of het personage precies past. Als dit niet het geval is, kunnen we onmiddellijk false retourneren:

Nu kunnen we zien of een van de tegels onder het personage gemalen tegels zijn:

Laten we teruggaan naar de MoveTo functie en kijken of we de starttegel moeten wijzigen. We moeten dat doen als het personage op de grond staat maar de starttegel niet:

We weten dat het personage in dit geval aan de linker- of rechterkant van het platform staat.

Laten we eerst de goede kant bekijken; als het personage daar past en de tegel op de grond ligt, dan moeten we de starttegel een spatie naar rechts verplaatsen. Als dat niet het geval is, moeten we het naar links verplaatsen.

Nu zouden we alle gegevens moeten hebben die we nodig hebben om de pathfinder te noemen:

Het eerste argument is de starttegel.

De tweede is de bestemming; we kunnen dit doorgeven zoals het is.

De derde en vierde argumenten zijn de breedte en de hoogte die moet worden benaderd door de tegelgrootte. Merk op dat we hier het plafond van de hoogte in tegels willen gebruiken? Dus als de werkelijke hoogte van het teken 2,3 tegels is, willen we dat het algoritme denkt dat het teken in werkelijkheid 3 tegels hoog is. (Het is beter als de werkelijke hoogte van het personage eigenlijk een beetje kleiner is dan de grootte in tegels, om iets meer ruimte te laten voor fouten vanaf het pad dat volgt op AI.)

Het vijfde argument ten slotte is de maximale spronghoogte van het personage.

Een Back Up van de Knooppuntenlijst Maken

Na het uitvoeren van het algoritme moeten we controleren of het resultaat goed is, dat wil zeggen, als er een pad is gevonden:

Als dat zo is, moeten we de knooppunten naar een afzonderlijke buffer kopiëren, want als een ander object nu de FindPath functie van de Pathfinder zou bellen, zou het oude resultaat worden overschreven. Het kopiëren van het resultaat naar een aparte lijst zal dit voorkomen.

Zoals u kunt zien, kopiëren we het resultaat in omgekeerde volgorde; dit komt omdat het resultaat zelf is omgekeerd. Als u dit doet, betekent dit dat de knooppunten in de mPath lijst de volgorde van de eerste keer zullen zijn.

Laten we nu het huidige doelknooppunt instellen. Omdat het eerste knooppunt in de lijst het startpunt is, kunnen we het feitelijk overslaan en verdergaan vanaf het tweede knooppunt:

Nadat het huidige doelknooppunt is ingesteld, stellen we de botstatus in op MoveTo, zodat een geschikte status wordt ingeschakeld.

Krijgen van de Context

Voordat we beginnen met het schrijven van de regels voor de AI-beweging, moeten we kunnen vinden in welke situatie het personage zich op een bepaald moment bevindt.

Wij moeten weten:

  • de posities van de vorige, huidige en volgende bestemmingen
  • of de huidige bestemming zich op de grond of in de lucht bevindt
  • of het karakter de huidige bestemming op de x-as heeft bereikt
  • of het karakter de huidige bestemming op de y-as heeft bereikt

Opmerking: de bestemmingen hier zijn niet noodzakelijk de uiteindelijke doelbestemming; ze zijn de knooppunten in de lijst uit het vorige gedeelte.

Deze informatie laat ons nauwkeurig bepalen wat de bot moet doen in elke situatie.

Laten we beginnen met het declareren van een functie om deze context te krijgen:

Wereldposities van Bestemmingsknooppunten Berekenen

Het eerste wat we moeten doen in de functie is het berekenen van de wereldpositie van de bestemmingsknooppunten.

Laten we beginnen met het berekenen van dit voor de vorige bestemming. Deze handeling hangt af van hoe uw spelwereld is opgezet; in mijn geval komen de kaartcoördinaten niet overeen met de wereldcoördinaten, dus moeten we ze vertalen.

Het vertalen ervan is heel eenvoudig: we hoeven alleen de positie van het knooppunt te vermenigvuldigen met de grootte van een tegel en de berekende vector vervolgens te verrekenen met de kaartpositie:

Merk op dat we beginnen met mCurrentNodeId gelijk aan 1, dus we hoeven ons geen zorgen te maken dat we per ongeluk toegang proberen te krijgen tot een knooppunt met een index van -1.

We zullen de positie van de huidige bestemming op dezelfde manier berekenen:

En nu voor de positie van de volgende bestemming. Hier moeten we controleren of er nog knopen zijn om te volgen nadat we ons huidige doel hebben bereikt, dus laten we eerst aannemen dat de volgende bestemming hetzelfde is als de huidige:

Nu, als er nog andere knooppunten zijn, berekenen we de volgende bestemming op dezelfde manier als de vorige twee:

Controleren of het Knooppunt Zich op de Grond Bevindt

De volgende stap is om te bepalen of de huidige bestemming op de grond ligt.

Vergeet niet dat het niet voldoende is om alleen de tegel direct onder het doel te controleren; we moeten rekening houden met de gevallen waarin het personage meer dan één blok breed is:

Laten we beginnen met aan te nemen dat de positie van de bestemming niet op de grond ligt:

Nu zullen we door de tegels onder de bestemming kijken om te zien of er solide blokken zijn. Als dat het geval is, kunnen we destOnGround op true zetten:

Controleren of het knooppunt op de X-as is bereikt

Voordat we kunnen zien of het personage het doel heeft bereikt, moeten we zijn positie op het pad weten. Deze positie is eigenlijk het centrum van de cel linksonder van ons karakter. Aangezien ons karakter is niet echt gebouwd van cellen, zijn we gewoon gaan gebruiken de bodem verlaten van de positie van het selectiekader van het personage plus de helft van een cel:

Dit is de positie die we moeten matchen met de doelknooppunten.

Hoe kunnen we bepalen of het personage het doel op de x-as heeft bereikt? Het is veilig om te veronderstellen dat, als het personage goed beweegt en een x-positie heeft die groter is dan of gelijk is aan die van de bestemming, het doel is bereikt.

Om te zien of het personage goed was, gebruiken we de vorige bestemming, die in dit geval links van de huidige moet zijn geweest:

Hetzelfde geldt voor de andere kant; als de vorige bestemming rechts van de huidige was en de x-positie van het karakter kleiner is dan of gelijk aan die van de doelpositie, dan kunnen we er zeker van zijn dat het karakter het doel op de x-as heeft bereikt:

Maak de Positie van het Personage Vast

Soms overschrijdt het vanwege de snelheid van het personage de bestemming, wat ertoe kan leiden dat het niet op het doelknooppunt terecht komt. Zie het volgende voorbeeld:

Om dit op te lossen, maken we de positie van het personage zodat het op het doelknooppunt terechtkomt.

De voorwaarden voor ons om het personage te klikken zijn:

  • Het doel is bereikt op de x-as.
  • De afstand tussen de positie van de bot en de huidige bestemming is groter dan cBotMaxPositionError.
  • De afstand tussen de positie van de bot en de huidige bestemming is niet erg ver, dus we klikken het personage niet van ver weg.
  • Het personage is in de vorige beurt niet links of rechts verplaatst, dus we knippen het personage alleen als het recht naar beneden valt.

cBotMaxPositionError in deze zelfstudie is gelijk aan 1 pixel; dit is hoe ver we het karakter laten zijn van de bestemming terwijl het nog steeds naar het volgende doel kan gaan.

Controleren of Het Knooppunt op de Y-As is Bereikt

Laten we uitzoeken wanneer we zeker weten dat het personage de Y positie van het doel heeft bereikt. Allereerst, als de vorige bestemming lager is dan de huidige, en ons karakter springt naar de hoogte van het huidige doel, dan kunnen we aannemen dat het doel is bereikt.

Evenzo, als de huidige bestemming lager is dan de vorige en het teken de y-positie van het huidige knooppunt heeft bereikt, kunnen we ook de bereikteY waarde instellen op waar.

Ongeacht of het personage moet springen of vallen om de y-positie van het bestemmingsknooppunt te bereiken, als het echt dichtbij is, dan moeten we bereikteY bereiken tot waar ook:

Als de bestemming op de grond ligt maar het karakter niet, dan kunnen we aannemen dat de Y positie van het huidige doel niet is bereikt:

Dat is het — dat zijn alle basisgegevens die we moeten weten om te bepalen wat voor soort beweging de AI moet doen.

Omgaan met de Beweging van de Bot

Het eerste dat u in onze update functie moet doen, is de context krijgen die we zojuist hebben geïmplementeerd:

Laten we nu de huidige positie van het personage langs het pad nemen. We berekenen dit op dezelfde manier als in de GetContext functie:

Aan het begin van het frame moeten we de nep-ingangen opnieuw instellen en deze alleen toewijzen als daarvoor een voorwaarde bestaat. We zullen slechts vier ingangen gebruiken: twee voor links en rechts bewegen, een voor springen en een voor het afzetten van een eenrichtingsplatform.

De allereerste voorwaarde voor beweging is deze: als de huidige bestemming lager is dan de positie van het personage en het personage op een eenrichtingsplatform staat, druk dan op de neerwaartse knop, wat ertoe zou moeten leiden dat het personage van het platform naar beneden springt :

Jumps Afhandelen

Laten we uitleggen hoe onze sprongen moeten werken. Ten eerste willen we de springknop niet ingedrukt houden als mFramesOfJumping 0 is.

De tweede voorwaarde om te controleren is dat het personage niet op de grond staat.

In deze implementatie van platformer-fysica mag het personage springen als het net van de rand van een platform is gestapt en niet meer op de grond staat. Dit is een populaire methode om de illusie te onderdrukken dat de speler op de springknop heeft gedrukt, maar het personage sprong niet, wat mogelijk het gevolg was van een invoervertraging of de speler die op de springknop drukte nadat het personage het platform had verlaten.

Deze voorwaarde werkt als het personage van een richel moet springen, omdat de frames van springen op een gepast bedrag worden ingesteld, het personage van nature van de richel af zal lopen en op dat moment ook de sprong start.

Dit zal niet werken als de sprong moet worden uitgevoerd vanaf de grond; om dit moeten we controleren van deze voorwaarden:

  • Het personage heeft de x-positie van het doelknooppunt bereikt, waar het gaat springen.
  • Het bestemmingsknooppunt bevindt zich niet op de grond; als we omhoog willen springen, moeten we eerst door een knooppunt gaan dat in de lucht is.

Het personage moet ook springen als het zich op de grond bevindt en de bestemming ook op de grond ligt. Dit gebeurt meestal als het personage één tegel omhoog en naar de zijkant moet springen om een ​​platform te bereiken dat slechts één blok hoger is.

Laten we nu de sprong activeren en de frames van het springen verlagen, zodat het personage de sprong naar het juiste aantal frames houdt:

Merk op dat we de mFramesOfJumping alleen verlagen als het personage niet op de grond staat. Dit is om per ongeluk de spronglengte te verminderen voordat de sprong begint.

Doorgaan Naar het Volgende Bestemmingsknooppunt

Laten we eens nadenken over wat er moet gebeuren als we het knooppunt bereiken - dat wil zeggen, als zowel bereiktX als bereiktY waar zijn.

Eerst verhogen we de huidige knooppunt ID:

Nu moeten we controleren of deze ID groter is dan het aantal knooppunten op ons pad. Als dat zo is, betekent dit dat het personage het doel heeft bereikt:

Het volgende dat we moeten doen is de sprong voor het volgende knooppunt berekenen. Omdat we dit op meerdere plaatsen moeten gebruiken, laten we er een functie voor maken:

We willen alleen springen als het nieuwe knooppunt hoger is dan het vorige en het personage op de grond staat:

Om erachter te komen hoeveel tegels we nodig hebben om te springen, gaan we door knopen heen herhalen zolang ze hoger en hoger gaan. Wanneer we bij een knooppunt komen dat zich op een lagere hoogte bevindt, of een knooppunt dat eronder is, kunnen we stoppen, omdat we weten dat het niet nodig is om hoger te gaan dan dat.

Laten we eerst de variabele die de waarde van de sprong vasthoudt declareren en instellen:

Laten we nu de knooppunten doorlopen, beginnend bij het huidige knooppunt:

Als het volgende knooppunt hoger is dan de jumpHeight en het niet op de grond staat, laten we dan de nieuwe springhoogte instellen:

Als de hoogte van het nieuwe knooppunt lager is dan het vorige niveau of op de grond ligt, geven we het aantal frames terug dat nodig is voor de gevonden hoogte. (En als er niet hoeft te springen, laten we gewoon 0 retourneren)

We moeten deze functie aanroept op twee plaatsen.

De eerste is in het geval dat het karakter de x- en y-posities van het knooppunt heeft bereikt:

Merk op dat we de sprongframes voor de hele sprong hebben ingesteld, dus wanneer we een in-air knooppunt bereiken, willen we niet het aantal springframes wijzigen dat werd bepaald voordat de sprong plaatsvond.

Nadat we het doel hebben bijgewerkt, moeten we alles opnieuw verwerken, zodat het volgende bewegingsframe onmiddellijk wordt berekend. Hiervoor gebruiken we een opdracht goto:

De tweede plaats waar we de sprong voor moeten berekenen is de MoveTo functie, omdat het kan gebeuren dat het eerste knooppunt van het pad een springknooppunt is:

Verplaatsing Afhandelen om de X Positie van Het Knooppunt te Bereiken

Laten we nu de beweging afhandelen voor het geval dat het karakter de x-positie van het doelknooppunt nog niet heeft bereikt.

Niets ingewikkeld hier; als de bestemming rechts is, moeten we de rechterknoppers simuleren. Als de bestemming links is, moeten we de linkerknoppers simuleren. We moeten alleen verplaatsen het teken als het verschil in positie meer dan de constante cBotMaxPositionError is:

Omgaan met beweging om de Y positie van het knooppunt te bereiken

Als het personage de doel-x-positie heeft bereikt, maar we doen het nog steeds om hoger te springen, kunnen we het karakter nog steeds naar links of rechts verplaatsen, afhankelijk van waar het volgende doel is. Dit betekent alleen dat het personage niet zo vast blijft plakken aan het gevonden pad. Dankzij dit is het veel gemakkelijker om naar de volgende bestemming te gaan, omdat in plaats van simpelweg te wachten om de doel-y-positie te bereiken, het personage op natuurlijke wijze naar de x-positie van het volgende knooppunt zal bewegen terwijl het dit doet.

We zullen het personage alleen naar de volgende bestemming verplaatsen als het al bestaat en niet op de grond ligt. (Als het op de grond ligt, kunnen we het niet overslaan omdat het een belangrijk ijkpunt is: het stelt de verticale snelheid van het personage opnieuw in en maakt het mogelijk om de sprong opnieuw te gebruiken.)

Maar voordat we echt naar het volgende doel toe gaan, moeten we controleren of we het pad niet zullen breken.

Voorkomen dat een Herfst Voortijdig Wordt Verbroken

Beschouw het volgende scenario:

Hier, zodra het personage van de rand liep waar het begon, bereikte het de x-positie van het tweede knooppunt en viel het om de y-positie te bereiken. Omdat het derde knooppunt zich rechts van het personage bevond, bewoog het naar rechts - en belandde in een tunnel boven die waar we wilden dat het ging.

Om dit te verhelpen, moeten we controleren of er obstakels tussen het teken en de volgende bestemming zijn; als dat niet het geval is, zijn we vrij om het personage ernaartoe te bewegen; als dat het geval is, moeten we wachten.

Laten we eerst eens kijken welke tegels we moeten controleren. Als het volgende doel rechts van het huidige is, moeten we de tegels aan de rechterkant controleren; als het aan de linkerkant is, moeten we de tegels links controleren. Als ze zich op dezelfde x-positie bevinden, is er geen reden om preventieve bewegingen te maken.

Zoals u kunt zien, hangt de x-coördinaat van het knooppunt rechts af van de breedte van het teken.

Nu kunnen we controleren of er tegels zijn tussen het teken en de positie van het volgende knooppunt op de y-as:

De AnySolidBlockInStripe functie controleert of er solide tegels zijn tussen twee gegeven punten op de kaart. De punten moeten dezelfde x-coördinaat hebben. De x-coördinaat die we controleren, is de tegel waar we het personage naartoe willen laten gaan, maar we weten niet zeker of we dit kunnen, zoals hierboven uitgelegd.

Dit is de implementatie van de functie.

Zoals u kunt zien, is de functie heel eenvoudig; het itereert alleen door de tegels in een kolom, te beginnen vanaf de onderste kolom.

Nu we weten dat we naar de volgende bestemming kunnen gaan, doen we het volgende:

Toestaan ​​Dat de Bot Overspringt

Dat is het bijna—maar er is nog steeds één zaak die moet worden opgelost. Hier is een voorbeeld:

Zoals je kunt zien, voordat het personage de y-positie van het tweede knooppunt bereikte, botste het zijn kop op de zwevende tegel, omdat we het naar de volgende bestemming aan de rechterkant hebben verplaatst. Als gevolg daarvan eindigt het personage nooit de y-positie van het tweede knooppunt; in plaats daarvan ging het rechtstreeks naar het derde knooppunt. Omdat bereiktY in dit geval false, kan het niet verdergaan met het pad.

Om dergelijke gevallen te voorkomen, controleren we eenvoudig of het personage het volgende doel heeft bereikt voordat het de huidige bereikt.

De eerste stap hierin is het scheiden van onze eerdere berekeningen van bereikteX en bereiktY in hun eigen functies:

Vervang vervolgens de berekeningen door de functieaanroep in de GetContext functie:

Nu kunnen we controleren of de volgende bestemming is bereikt. Als dit het geval is, kunnen we eenvoudig mCurrentNode verhogen en de statusupdate onmiddellijk opnieuw uitvoeren. Hierdoor wordt de volgende bestemming de huidige en aangezien het personage deze al heeft bereikt, kunnen we verder gaan:

Dat is alles voor karakterbeweging!

Omgaan met Herstartcondities

Het is goed om een ​​back-upplan te hebben voor een situatie waarin de bot niet op de juiste manier door het pad beweegt. Dit kan gebeuren als de kaart bijvoorbeeld wordt gewijzigd; een obstakel toevoegen aan een reeds berekend pad kan ertoe leiden dat het pad ongeldig wordt. Wat we zullen doen is het pad opnieuw instellen als het personage langer vastzit dan een bepaald aantal frames.

Laten we daarom de variabelen declareren die tellen hoeveel frames het personage heeft geplakt en hoeveel frames er hoogstens aan vastzitten:

We moeten dit opnieuw instellen als we de MoveTo functie bellen:

En tot slot, aan het einde van de BotState.MoveTo, laten we controleren of het personage vastzit. Hier moeten we gewoon controleren of de huidige positie gelijk is aan de oude; als dat zo is, dan moeten we ook de mStuckFrames verhogen en controleren of het personage vastzit voor meer frames dan cMaxStuckFrames - en als dat het geval was, dan moeten we de MoveTo functie met het laatste knooppunt van het huidige pad als parameter aanroepen. Natuurlijk, als de positie anders is, dan moeten we de mStuckFrames naar 0 resetten:

Nu moet het personage een alternatief pad vinden als het de eerste niet kan afmaken.

Conclusie

Dat is het geheel van de tutorial! Het is veel werk geweest, maar ik hoop dat je deze methode nuttig zult vinden. Het is zeker geen perfecte oplossing voor het vinden van platformers; de benadering van de sprongcurve voor het karakter dat het algoritme moet maken is vaak vrij lastig om te doen en kan leiden tot onjuist gedrag. Het algoritme kan nog steeds worden uitgebreid - het is niet zo moeilijk om richelgrijpers en andere soorten flexibiliteit voor bewegingsvrijheid toe te voegen - maar we hebben de elementaire platformmachinemonteurs behandeld. Het is ook mogelijk om de code te optimaliseren om deze sneller te maken en minder geheugen te gebruiken; deze iteratie van het algoritme is helemaal niet perfect als het om die aspecten gaat. Het lijdt ook aan een tamelijk slechte benadering van de curve wanneer deze met grote snelheden valt.

Het algoritme kan op vele manieren worden gebruikt, met name om de vijandelijke AI of AI-metgezellen te verbeteren. Het kan ook worden gebruikt als een controleschema voor aanraakapparaten - dit zou in principe hetzelfde werken als in de zelfstudiedemo, waarbij de speler tikt waarheen hij het personage wil laten bewegen. Hiermee wordt de uitvoeringsuitdaging weggenomen waarop veel platformspelers zijn gebouwd, dus het spel zou anders moeten worden ontworpen, veel meer om je personage op de juiste plek te plaatsen in plaats van te leren het personage nauwkeurig te besturen.

Bedankt voor het lezen! Vergeet niet om wat feedback over de methode achter te laten en laat me ook weten of je er verbeteringen in hebt aangebracht!

Advertisement
Advertisement
Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.