Share
Les comportements de pilotage visent à aider les personnages autonomes à se déplacer de manière réaliste, en utilisant des forces simples qui se combinent pour produire une navigation improvisée et réaliste. Dans ce tutoriel, je vais couvrir la errer comportement qui fait bouger le personnage au hasard.
Remarque: Bien que ce tutoriel ait été écrit avec AS3 et Flash, vous devriez pouvoir utiliser les mêmes techniques et concepts dans presque tous les environnements de développement de jeux. Vous devez avoir une compréhension de base des vecteurs mathématiques.
Souvent, les personnages d'un jeu doivent se déplacer de manière aléatoire dans leur environnement. Habituellement, ces personnages attendent simplement que quelque chose se passe (comme une bataille contre le joueur) ou qu'ils recherchent quelque chose. Lorsque le joueur est capable de voir ce comportement, la capacité de errance du personnage doit être visuellement agréable et suffisamment réaliste.
Si le joueur est capable d'identifier des lignes de chemin fortement définies ou un comportement de mouvement irréaliste, cela générera une frustration. Dans le pire des cas, le joueur trouvera comment anticiper les mouvements du personnage, ce qui se traduira par une expérience de jeu ennuyeuse..
le errer le comportement de la direction vise à produire un mouvement "occasionnel" réaliste, qui fera penser au joueur que le personnage est vraiment vivant et qu'il se promène.
Il existe plusieurs façons de mettre en œuvre le modèle de dérapage à l'aide de comportements de direction. Le plus simple utilise le comportement de recherche décrit précédemment. Lorsqu'un personnage effectue une recherche, il se dirigera vers une cible.
Si la position de cette cible change toutes les quelques secondes, le personnage ne pourra jamais atteindre la cible (et même si c'est le cas, la cible se déplacera à nouveau). En plaçant la cible au hasard dans la zone de jeu, le personnage finira par se déplacer dans tout l'environnement à la poursuite de la cible. La démo ci-dessous montre cette approche en action:
Le code pour cette implémentation serait:
// Calcule la fonction privée de force de dérapage wander (): Vector3D var maintenant: Number = (new Date ()). GetTime (); if (now> = nextDecision) // Choisit une position aléatoire pour "cible" // renvoie une force de direction qui pousse le caractère // vers la cible (le comportement de recherche). retour cherche (cible); // Dans la boucle du jeu, manipulez les forces et les mouvements // comme auparavant: fonction publique update (): void pilotage = wander () pilotage = tronqué (pilotage, max_force) pilotage = pilotage / vitesse de masse = tronqué (vitesse + direction, vitesse maximale) position = position + vitesse
Même s’il s’agit d’une approche simple et efficace, le résultat final n’est pas aussi convaincant. Parfois, le personnage inverse complètement son itinéraire car la cible est placée derrière lui. Le comportement du personnage semble beaucoup plus comme "Zut, j'ai oublié mes clés!" que "D'accord, je vais suivre cette direction maintenant".
Craig W. Reynolds a proposé une autre implémentation du comportement de dérapage lorsqu'il a inventé ces comportements. L'idée de base est de produire de petits déplacements aléatoires et de les appliquer au vecteur de direction actuel du personnage (la vélocité, dans notre cas) chaque cadre de jeu. Étant donné que le vecteur vélocité définit l’orientation du personnage et son déplacement de chaque image, toute interférence avec ce vecteur modifiera l’itinéraire actuel..
En utilisant de petits déplacements, chaque image empêche le personnage de changer brusquement de route. Si le personnage monte et tourne à droite, par exemple, dans le prochain cadre de jeu, il continuera à monter et à tourner à droite, mais sous un angle légèrement différent..
Cette approche peut également être mise en œuvre de différentes manières. L’un d’eux consiste à utiliser un cercle devant le personnage pour calculer toutes les forces en jeu:
le force de déplacement a son origine au centre du cercle et est contraint par le rayon du cercle. Plus le rayon et la distance entre le personnage et le cercle sont grands, plus le "push" reçu par le personnage recevra chaque cadre de jeu..
Cette force de déplacement sera utilisée pour interférer avec la route du personnage. Il est utilisé pour calculer le force errante.
La première composante requise pour calculer la force de dérapage est la position centrale du cercle. Puisque le cercle doit être placé devant le caractère, le vecteur de vitesse peut être utilisé comme guide:
// La constante CIRCLE_DISTANCE ci-dessous est // un nombre défini ailleurs. // Le code pour calculer le centre du cercle: var circleCenter: Vector3D; circleCenter = velocity.clone (); circleCenter.normalize (); circleCenter.scaleBy (CIRCLE_DISTANCE);
le circleCenter Le vecteur ci-dessus est un clone (copie) du vecteur vitesse, ce qui signifie qu'il pointe dans la même direction. Il est normalisé et multiplié par une valeur scalaire (CIRCLE_DISTANCE, dans ce cas) ce qui donnera le vecteur suivant:
Le composant suivant est la force de déplacement, responsable du virage à droite ou à gauche. Puisqu'il s'agit d'une force utilisée pour produire des perturbations, elle peut pointer n'importe où. Utilisons un vecteur aligné sur l’axe des Y:
déplacement var: Vector3D; déplacement = nouveau Vector3D (0, -1); déplacement.échellePar (CIRCLE_RADIUS); // // Change aléatoirement la direction du vecteur // en lui faisant changer son angle actuel setAngle (déplacement, wanderAngle); // // Change juste un peu wanderAngle, donc // il n'aura pas la même valeur dans le // prochain cadre de jeu. wanderAngle + = (Math.random () * ANGLE_CHANGE) - (ANGLE_CHANGE * .5);
La force de déplacement est créée et mise à l'échelle par le rayon du cercle. Comme décrit précédemment, plus le rayon est grand, plus la force de dérapage est forte. le errerAngle est une valeur scalaire qui définit la "inclinaison" de la force de déplacement; après son utilisation, une valeur aléatoire est ajoutée pour la rendre différente pour le prochain cadre de jeu. Il produit le caractère aléatoire requis dans le mouvement.
Par souci de compréhension, supposons que la force de déplacement calculée ci-dessus soit placée au centre du cercle. Puisqu'il a été mis à l'échelle par la valeur du rayon du cercle, cela ressemblerait à ceci:
Pointe: Rappelez-vous que les vecteurs mathématiques n'ont pas de position dans l'espace, ils ont une direction et une magnitude (longueur). En conséquence, ils peuvent être placés n'importe où. Après avoir calculé le centre du cercle et le vecteur de déplacement, ils doivent être combinés pour produire le force errante. Cette force est calculée en ajoutant ces deux vecteurs:
var wanderForce: Vector3D; wanderForce = circleCenter.add (déplacement);
Nous pouvons représenter visuellement ces forces de la manière suivante:
La force de dérapage peut être imaginée comme un vecteur allant du personnage à un point situé sur la circonférence du cercle. En fonction de la position de ce point, la force de dérapage poussera le personnage à gauche ou à droite, fortement ou faiblement:
Plus la force de dérapage est alignée sur le vecteur vitesse, moins le personnage changera son itinéraire actuel. La force de dérapage fonctionnera exactement comme les forces de recherche et de fuite: elle poussera le personnage dans une direction.
Semblable à rechercher et à fuir lorsque la direction de la force est calculée en fonction d'une cible, la direction de dérapage est calculée en fonction d'un point aléatoire de la circonférence du cercle. Le code final pour la force de dérapage est le suivant:
fonction privée wander (): Vector3D // Calculer le centre du cercle var circleCenter: Vector3D; circleCenter = velocity.clone (); circleCenter.normalize (); circleCenter.scaleBy (CIRCLE_DISTANCE); // // Calcule la force de déplacement var déplacement: Vector3D; déplacement = nouveau Vector3D (0, -1); déplacement.échellePar (CIRCLE_RADIUS); // // Change aléatoirement la direction du vecteur // en lui faisant changer son angle actuel setAngle (déplacement, wanderAngle); // // Change juste un peu wanderAngle, donc // il n'aura pas la même valeur dans le // prochain cadre de jeu. wanderAngle + = Math.random () * ANGLE_CHANGE - ANGLE_CHANGE * .5; // // Enfin calculer et renvoyer la force de dérapage var wanderForce: Vector3D; wanderForce = circleCenter.add (déplacement); retournez wanderForce; fonction publique setAngle (vector: Vector3D, valeur: Number): void var len: Number = vector.length; vector.x = Math.cos (valeur) * len; vector.y = Math.sin (valeur) * len;
Une fois que la force de dérapage a été calculée, elle doit être ajoutée à la vitesse du personnage afin qu’elle puisse affecter son mouvement. L'ajout de cette force est effectué de la même manière que précédemment:
braquage = dérapage () braquage = tronqué (braquage, force maximale) braquage = direction / vitesse de masse = tronqué (vitesse + direction, vitesse maximale) position = position + vélocité
La force d’errance affectera l’itinéraire du personnage de la même manière que les comportements décrits précédemment, à la différence qu’elle pousse le personnage dans une direction aléatoire pour chaque cadre de jeu:
La démo ci-dessus montre plusieurs personnages errant dans l'environnement. S'ils quittent l'écran, ils sont réapparus au centre.
Le comportement de dérapage est un excellent moyen de mettre en œuvre des mouvements aléatoires. Il est contrôlé par un cercle imaginaire placé devant le personnage, qui peut être modifié pour produire le modèle de mouvement souhaité..
Ce tutoriel décrit les comportements de direction, expliquant le comportement de dérapage. Dans le prochain article, nous en apprendrons davantage sur les comportements. Tenez-vous au courant en nous suivant sur Twitter, Facebook ou Google+.
Accentsconagua