Share
I comportamenti di guida mirano ad aiutare i personaggi autonomi a muoversi in modo realistico, usando forze semplici che si combinano per produrre una navigazione improvvisa e realistica. In questo tutorial, tratterò il vagare comportamento, che fa muovere il personaggio in modo casuale.
Nota: Sebbene questo tutorial sia scritto usando AS3 e Flash, dovresti essere in grado di utilizzare le stesse tecniche e concetti in quasi tutti gli ambienti di sviluppo di giochi. Devi avere una conoscenza di base dei vettori di matematica.
Spesso i personaggi di un gioco devono spostarsi casualmente nel loro ambiente. Di solito quei personaggi stanno solo aspettando che qualcosa accada (come una battaglia contro il giocatore) o stanno cercando qualcosa. Quando il giocatore è in grado di vedere quel comportamento, l'abilità errante del personaggio deve essere visivamente piacevole e abbastanza realistica.
Se il giocatore è in grado di identificare linee di percorso fortemente definite o comportamenti di movimenti non realistici, genererà frustrazione. Nel peggiore dei casi il giocatore capirà come anticipare i movimenti del personaggio, il che si tradurrà in un'esperienza di gioco noioso.
Il vagare il comportamento dello sterzo mira a produrre un movimento "casuale" realistico, che farà pensare al giocatore che il personaggio è veramente vivo e in giro.
Esistono diversi modi per implementare il modello di wander usando i comportamenti di governo. Il più semplice sta usando il comportamento di ricerca precedentemente descritto. Quando un personaggio sta eseguendo la ricerca, si muoverà verso un bersaglio.
Se la posizione di quell'obiettivo cambia ogni pochi secondi, il personaggio non sarà mai in grado di raggiungere il bersaglio (e anche se lo farà, il bersaglio si sposterà di nuovo). Posizionando il bersaglio casualmente nell'area di gioco, il personaggio si muoverà infine intorno all'intero ambiente inseguendo il bersaglio. La demo qui sotto mostra questo approccio in azione:
Il codice per questa implementazione sarebbe:
// Calcola la funzione wander force wander (): Vector3D var now: Number = (new Date ()). GetTime (); if (now> = nextDecision) // Scegli una posizione casuale per "target" // restituisci una forza di guida che spinge il carattere // verso il bersaglio (il comportamento di ricerca) return seek (target); // Nel loop di gioco, gestisci le forze e il movimento appena // come prima: public function update (): void steering = wander () steering = truncate (steering, max_force) steering = sterzo / velocità di massa = truncate (velocity + steering, max_speed) position = position + velocity
Anche se questo è un approccio semplice e buono, il risultato finale non è così convincente. A volte il personaggio inverte completamente il suo percorso perché il bersaglio è posizionato dietro di esso. Il comportamento del personaggio sembra molto più simile "Accidenti, ho dimenticato le mie chiavi!" di "Ok, seguirò questa direzione ora".
Un'altra implementazione del comportamento errante fu proposta da Craig W. Reynolds quando inventò quei comportamenti. L'idea di base è di produrre piccoli spostamenti casuali e applicare al vettore di direzione corrente del personaggio (la velocità, nel nostro caso) ogni trama di gioco. Poiché il vettore della velocità definisce dove si sta dirigendo il personaggio e quanto si muove su ogni fotogramma, qualsiasi interferenza con quel vettore cambierà la rotta corrente.
Usando piccoli spostamenti ogni fotogramma impedisce al personaggio di cambiare bruscamente il suo percorso. Se il personaggio si muove verso l'alto e gira a destra, ad esempio, nel prossimo frame di gioco si muoverà ancora verso l'alto e girerà a destra, ma con un'angolazione leggermente diversa.
Questo approccio può anche essere implementato in diversi modi. Uno di questi è usare un cerchio di fronte al personaggio, usando quello per calcolare tutte le forze coinvolte:
Il forza di spostamento ha la sua origine al centro del cerchio ed è vincolato dal raggio del cerchio. Maggiore è il raggio e la distanza dal personaggio al cerchio, più forte è il "push" che il personaggio riceverà in ogni frame del gioco.
Questa forza di spostamento verrà utilizzata per interferire con il percorso del personaggio. È usato per calcolare il vagare forza.
Il primo componente richiesto per calcolare la forza vagante è la posizione centrale del cerchio. Poiché il cerchio deve essere posizionato di fronte al carattere, il vettore di velocità può essere utilizzato come guida:
// La costante CIRCLE_DISTANCE di seguito è // un numero definito da qualche altra parte. // Il codice per calcolare il centro del cerchio: var circleCenter: Vector3D; circleCenter = velocity.clone (); circleCenter.normalize (); circleCenter.scaleBy (CIRCLE_DISTANCE);
Il circleCenter il vettore sopra è un clone (copia) del vettore di velocità, il che significa che puntano nella stessa direzione. È normalizzato e moltiplicato per un valore scalare (CIRCLE_DISTANCE, in questo caso) che risulterà nel seguente vettore:
Il componente successivo è la forza di spostamento, che è responsabile della svolta a destra o a sinistra. Poiché questa è una forza usata per produrre disturbo, può puntare ovunque. Usiamo un vettore allineato con l'asse Y:
var spostamento: Vector3D; spostamento = nuovo Vector3D (0, -1); displacement.scaleBy (CIRCLE_RADIUS); // // Cambia in modo casuale la direzione del vettore // facendo in modo che cambi il suo angolo corrente setAngle (spostamento, wanderAngle); // // Cambia wanderAngle solo un po ', quindi // non avrà lo stesso valore nel // prossimo frame di gioco. wanderAngle + = (Math.random () * ANGLE_CHANGE) - (ANGLE_CHANGE * .5);
La forza di spostamento viene creata e ridimensionata dal raggio del cerchio. Come descritto in precedenza, maggiore è il raggio, maggiore è la forza di virata. Il wanderAngle è un valore scalare che definisce quanto deve essere "inclinata" la forza di spostamento; dopo che è stato usato, viene aggiunto un valore casuale per renderlo diverso per il prossimo frame di gioco. Produce la casualità richiesta nel movimento.
Per ragioni di comprensione, supponiamo che la forza di spostamento calcolata sopra sia posizionata al centro del cerchio. Poiché è stato ridimensionato in base al valore del raggio del cerchio, sarebbe qualcosa del genere:
Mancia: Ricorda che i vettori matematici non hanno una posizione nello spazio, hanno una direzione e una magnitudine (lunghezza). Di conseguenza possono essere posizionati ovunque. Dopo aver calcolato il centro del cerchio e il vettore di spostamento, devono essere combinati per produrre il vagare forza. Quella forza viene calcolata aggiungendo questi due vettori:
var wanderForce: Vector3D; wanderForce = circleCenter.add (spostamento);
Possiamo rappresentare visivamente queste forze in questo modo:
La forza vagabonda può essere immaginata come un vettore che va dal personaggio a un punto sulla circonferenza del cerchio. A seconda della posizione di quel punto, la forza vagabonda spinge il personaggio a sinistra o a destra, fortemente o debolmente:
Più la forza vagabonda è allineata con il vettore di velocità, meno il personaggio cambierà la rotta corrente. La forza vagabonda funzionerà esattamente come la ricerca e fugge le forze: spingerà il personaggio verso una direzione.
Simile a cercare e fuggire dove la direzione della forza è calcolata sulla base di un bersaglio, la direzione del vagabondaggio è calcolata sulla base di un punto casuale sulla circonferenza del cerchio. Il codice finale per la forza vagabonda è:
private function wander (): Vector3D // Calcola il centro del cerchio var circleCenter: Vector3D; circleCenter = velocity.clone (); circleCenter.normalize (); circleCenter.scaleBy (CIRCLE_DISTANCE); // // Calcola la forza di spostamento var di spostamento: Vector3D; spostamento = nuovo Vector3D (0, -1); displacement.scaleBy (CIRCLE_RADIUS); // // Cambia in modo casuale la direzione del vettore // facendo in modo che cambi il suo angolo corrente setAngle (spostamento, wanderAngle); // // Cambia wanderAngle solo un po ', quindi // non avrà lo stesso valore nel // prossimo frame di gioco. wanderAngle + = Math.random () * ANGLE_CHANGE - ANGLE_CHANGE * .5; // // Infine, calcola e restituisci la forza wander var wanderForce: Vector3D; wanderForce = circleCenter.add (spostamento); return wanderForce; public function setAngle (vector: Vector3D, value: Number): void var len: Number = vector.length; vector.x = Math.cos (valore) * len; vector.y = Math.sin (valore) * len;
Dopo che la forza del vagabondo è stata calcolata, deve essere aggiunta alla velocità del personaggio in modo che possa influenzarne il movimento. L'aggiunta di quella forza viene eseguita nello stesso modo di prima:
sterzo = virare () sterzo = troncare (sterzare, max_force) sterzare = sterzare / velocità di massa = troncare (velocità + sterzata, max_velocità) posizione = posizione + velocità
La forza vagabonda influenzerà la rotta del personaggio nello stesso modo in cui si sono comportati i comportamenti precedentemente descritti, con la differenza che spinge il personaggio in una direzione casuale per ogni trama del gioco:
La demo sopra mostra diversi personaggi che vagano nell'ambiente. Se lasciano lo schermo vengono rigenerati al centro.
Il comportamento di vagabondaggio è un modo eccellente per implementare movimenti casuali. È controllato da un cerchio immaginario posto di fronte al personaggio, che può essere modificato per produrre il modello di movimento desiderato.
Questo tutorial descrive i comportamenti di guida, spiegando il comportamento del vagabondaggio. Nel prossimo post, scopriremo ulteriori comportamenti. Tieniti aggiornato seguendoci su Twitter, Facebook o Google+.
Accentsconagua