Share
Tot nu toe hebben we gekeken naar het gedrag van zoeken, vluchten, aankomen en afdwalen. In deze tutorial behandel ik de achtervolging en de ontwijken gedrag, waardoor uw personages het doelwit volgen of ontwijken.
Notitie: Hoewel deze tutorial geschreven is met behulp van AS3 en Flash, zou je in bijna elke game-ontwikkelomgeving dezelfde technieken en concepten moeten kunnen gebruiken. Je moet een basiskennis hebben van wiskundige vectoren.
Een achtervolging is het proces van het volgen van een doelwit vang het. Het is belangrijk op te merken dat het woord "vangen" hier het verschil maakt. Als iets gewoon een doelwit volgt, hoeft het alleen maar de bewegingen van het doel te herhalen en als gevolg daarvan zal het op zijn spoor zijn.
Bij het nastreven van iets moet de achtervolger het doelwit volgen, maar het moet ook anticiperen waar het doel in de nabije toekomst zal zijn. Als u kunt voorspellen (of schatten) waar het doel binnen de komende paar seconden zal zijn, is het mogelijk om het huidige traject aan te passen om onnodige routes te vermijden:
Zoals beschreven in de eerste tutorials, wordt de beweging berekend met behulp van Euler-integratie:
positie = positie + snelheid
Als een direct gevolg, als de positie en snelheid van het huidige personage bekend zijn, is het mogelijk om te voorspellen waar het zich in de volgende bevindt T game-updates. Ervan uitgaande dat het personage in een rechte lijn beweegt en de positie die we willen voorspellen drie updates voor ons is (T = 3), de toekomstige positie van het personage zal zijn:
positie = positie + snelheid * T
De sleutel voor een goede voorspelling is de juiste waarde voor T. Als de waarde te hoog is, betekent dit dat de achtervolger uiteindelijk een geest achtervolgt. Als T is te dicht bij nul, het betekent dat de achtervolger niet echt het doel nastreeft, maar het is gewoon het volgen (geen voorspelling).
Als de voorspelling voor elk gameframe wordt berekend, werkt het ook als het doel voortdurend van richting verandert. Bij elke update wordt een nieuwe "toekomstige positie" gegenereerd op basis van de huidige snelheidsvector (die ook de bewegingsrichting aangeeft).
Het achtervolgingsgedrag werkt vrijwel hetzelfde als zoeken doet, het enige verschil is dat de achtervolger het doelwit zelf niet zal zoeken, maar zijn positie in de nabije toekomst.
Ervan uitgaande dat elk personage in het spel wordt vertegenwoordigd door een klasse met de naam Boid, de volgende pseudo-code implementeert het basisidee achter het achtervolgingsgedrag:
openbare functie achtervolging (t: Boid): Vector3D T: int = 3; futurePosition: Vector3D = t.position + t.velocity * T; return seek (futurePosition);
Na de berekening van de achtervolgingskracht moet deze net als alle voorgaande stuurkrachten worden toegevoegd aan de snelheidsvector:
update van openbare functie (): void steering = pursuit (target) steering = truncate (steering, max_force) steering = steering / mass velocity = truncate (velocity + steering, max_speed) position = position + velocity
De onderstaande figuur illustreert het proces:
De achtervolger (het personage onderaan) zoekt de toekomstige positie van het doelwit, volgens een traject dat wordt beschreven door de oranje curve. Het eindresultaat zal zijn:
Het achtervolgingsgedrag met behulp van T = 30. Klik op de demo om krachtvectoren te tonen. Het doelwit zoekt de muis.
Er is een probleem wanneer de waarde van T is constant: de nauwkeurigheid van het streven is meestal slecht wanneer het doelwit dichtbij is. Dit is omdat wanneer het doelwit dichtbij is, de achtervolger zal blijven zoeken naar de voorspelling van de positie van het doel, dat wil zeggen T frames "weg".
Dat gedrag zou nooit gebeuren in een echte achtervolging omdat de achtervolger zou weten dat het dicht genoeg bij het doelwit ligt en zou moeten stoppen met het voorspellen van zijn positie.
Er is een eenvoudige truc die kan worden geïmplementeerd om dat te voorkomen en de nauwkeurigheid van het streven drastisch te verbeteren. Het idee is heel eenvoudig; in plaats van een constante waarde voor T, een dynamische wordt gebruikt:
T = distanceBetweenTargetAndPuer / MAX_VELOCITY
De nieuwe T wordt berekend op basis van de afstand tussen de twee karakters en de maximumsnelheid die het doelwit kan bereiken. In eenvoudige woorden het nieuwe T middelen "hoeveel updates moet het doel verplaatsen van zijn huidige positie naar de positie van de purser".
Hoe langer de afstand, hoe hoger T zal zijn, dus de achtervolger zal een punt zoeken dat ver voor het doel ligt. Hoe korter de afstand, hoe lager T zal zijn, wat betekent dat het een punt zoekt dat heel dicht bij het doel ligt. De nieuwe code voor die implementatie is:
publieke functie achtervolging (t: Boid): Vector3D var distance: Vector3D = t.position - position; var T: int = distance.length / MAX_VELOCITY; futurePosition: Vector3D = t.position + t.velocity * T; return seek (futurePosition);
Het eindresultaat is:
Het achtervolgingsgedrag met behulp van een dynamiek T. Klik op de demo om krachtvectoren te tonen. Het doelwit zoekt de muis.
Het ontwijkgedrag is het tegenovergestelde van het achtervolgingsgedrag. In plaats van de toekomstige positie van het doelwit te zoeken, zal het personage in het ontwijkgedrag voor die positie vluchten:
De code om te ontwijken is bijna identiek, alleen de laatste regel is gewijzigd:
publieke functie ontwijken (t: Boid): Vector3D var distance: Vector3D = t.position - position; var-updatesAhead: int = distance.length / MAX_VELOCITY; futurePosition: Vector3D = t.position + t.velocity * updatesAhead; terugkeer vlucht (futurePosition);
Het uiteindelijke resultaat is de volgende:
Deze tutorial beschreef de achtervolging en het ontwijkgedrag, die geweldig zijn om een verscheidenheid aan patronen te simuleren, zoals een groep dieren die probeert te ontsnappen aan een jager.
Ik hoop dat je tot nu toe van deze tips hebt genoten en al dat gedrag kunt gebruiken, door ze te combineren om nog betere patronen te maken! Blijf op de hoogte door ons te volgen op Twitter, Facebook of Google+.
Accentsconagua