Lors de la création de l'intelligence artificielle pour les jeux vidéo, l'un des aspects les plus importants est sa localisation. La position du personnage de l'IA peut changer complètement ses types de comportement et ses décisions futures. Dans ce tutoriel, nous allons comprendre comment l'environnement de jeu peut affecter l'IA et comment l'utiliser correctement.Cet article est tiré du livre Practical Game AI Programming , écrit par Michael Dagrack et publié par Packt Publishing. Ce livre vous permet d'apprendre à créer une IA de jeu et à partir de zéro mettre en œuvre les algorithmes d'IA les plus avancés.Les interactions visuelles sont basiques, elles n'affectent pas directement le gameplay, mais vous permettent d'améliorer le jeu vidéo et ses personnages en les intégrant à l'environnement que nous créons, ce qui affecte grandement l'immersion du joueur dans le jeu. Cela nous prouve l'importance de l'environnement faisant partie du jeu, et pas seulement d'aider à remplir l'espace sur l'écran. Des interactions similaires se retrouvent de plus en plus dans les jeux, et les joueurs s'attendent à les voir. S'il y a un objet dans le jeu, il doit remplir une fonction, mais pas la plus importante.L'un des premiers exemples d'interaction avec les environnements se trouve dans le premier Castlevania, sorti en 1986 pour la Nintendo Entertainment System. Dès le début, le joueur peut utiliser le fouet pour détruire les bougies et les incendies, qui faisaient à l'origine partie de l'arrière-plan.Ce jeu et certains jeux de cette époque ont ouvert de nombreuses portes et opportunités en termes de perception moderne des arrière-plans et des environnements des personnages du jeu. De toute évidence, en raison des limites matérielles de cette génération de consoles, il était beaucoup plus difficile de créer des choses simples qui sont généralement acceptées par les normes actuelles. Mais chaque génération de consoles a apporté de nouvelles fonctionnalités et les développeurs les ont utilisées pour créer des jeux incroyables.Ainsi, notre premier exemple d'interaction visuelle est un objet en arrière-plan qui peut être détruit sans affecter directement le gameplay. Ce type d'interaction se retrouve dans de nombreux jeux. Son implémentation est simple, il suffit d'animer l'objet lorsqu'il est attaqué. Après cela, nous pouvons décider si des points ou des objets doivent être retirés de l'objet qui récompensent le joueur pour avoir exploré le jeu.Nous pouvons maintenant passer à l'exemple suivant - les objets du jeu qui sont animés ou se déplacent lorsque les personnages les traversent. Le principe ici est le même que pour les objets destructibles, mais cette fois l'interaction est plus subtile - elle nécessite que le personnage se déplace jusqu'au point où se trouve l'objet. Cela peut être appliqué à divers éléments du jeu, du mouvement de l'herbe, de la poussière ou de l'eau aux oiseaux volants ou aux personnes faisant des gestes amusants; les possibilités sont infinies.Lors de l'analyse de ces interactions, nous pouvons facilement déterminer qu'elles n'utilisent pas nécessairement l'IA, et dans la plupart des cas, c'est juste une fonction booléenne qui est activée en fonction d'une action donnée. Mais ils font partie de l'environnement et doivent donc être pris en compte lors de la mise en œuvre d'une interaction de haute qualité entre l'environnement et l'IA.Créez des interactions simples avec l'environnement
Comme nous l'avons déjà vu, l'environnement est devenu une fois une partie du gameplay, ce qui a donné naissance à de nombreux nouveaux concepts et idées pour les futurs jeux. L'étape suivante a été l'intégration de ces petits changements dans le gameplay et leur utilisation pour changer le comportement du joueur dans le jeu. Cela a certainement affecté positivement l'histoire des jeux vidéo, car tous les éléments de la scène ont progressivement pris vie et le joueur a commencé à réaliser à quel point l'environnement était riche. L'utilisation d'environnements pour atteindre les objectifs du jeu fait désormais partie du gameplay.
if(cube.transform.position == mark.transform.position)
{
openDoor = true;
}
Imaginez maintenant un instant que Lara Croft ait un personnage allié dont la tâche principale est de l'aider à remettre cette boîte à sa place. Et dans ce chapitre, nous ne considérerons que ce type d'interaction: le personnage de l'IA comprend comment l'environnement fonctionne et comment l'utiliser.Environnement en mouvement dans Tomb Raider
Allons directement à ce scénario et essayons de recréer une situation dans laquelle il y a un personnage IA qui peut aider le joueur à atteindre son objectif. Dans cet exemple, nous imaginerons qu'un joueur est piégé dont il ne peut pas accéder à un objet interactif qui peut le libérer. Le personnage que nous créons doit pouvoir trouver le cube et le pousser dans la bonne direction.Alors maintenant, nous avons tous les personnages et objets. Planifions le comportement du personnage de l'IA dans cette situation. Tout d'abord, il doit voir que le joueur est proche, afin qu'il puisse commencer à rechercher et déplacer le cube à la position souhaitée. Supposons que si le cube est à la marque, alors un nouveau bloc apparaît du sable, permettant au joueur d'avancer plus loin en niveau. Un personnage IA peut pousser un cube dans quatre directions: gauche, droite, avant et arrière, de sorte qu'il s'adapte parfaitement au repère de position.Le personnage AI doit vérifier et valider chaque action indiquée dans cet arbre de comportement. La première chose et la plus importante pour continuer la tâche est que le personnage doit être sûr que le joueur se trouve sur sa marque.Si le joueur n'y est pas encore arrivé, alors notre personnage doit attendre et rester en place. Si le joueur est déjà arrivé à la marque, alors le personnage AI continue l'exécution et se demande à quelle distance il est de l'objet cube. Sinon, le personnage devrait se diriger vers le cube, et une fois cette action confirmée, il devrait poser la même question. Lorsque la réponse devient positive et que le personnage est à côté du cube, il doit déterminer de quelle manière vous devez d'abord pousser le cube.Puis il commence à pousser le cube le long de l'axe Y ou X jusqu'à ce qu'il corresponde à la position de marquage et que la tâche soit terminée.public GameObject playerMesh;
public Transform playerMark;
public Transform cubeMark;
public Transform currentPlayerPosition;
public Transform currentCubePosition;
public float proximityValueX;
public float proximityValueY;
public float nearValue;
private bool playerOnMark;
void Start () {
}
void Update () {
currentPlayerPosition.transform.position = playerMesh.transform.position;
proximityValueX = playerMark.transform.position.x - currentPlayerPosition.transform.position.x;
proximityValueYplayerMark.transform.position.y - currentPlayerPosition.transform.position.y;
if((proximityValueX + proximityValueY) < nearValue)
{
playerOnMark = true;
}
}
Nous commençons à ajouter des informations au code qui permettent au personnage de vérifier si le joueur est à côté de sa position marquée. Pour ce faire, nous créons toutes les variables nécessaires pour calculer les distances entre le joueur et la position dans laquelle il devrait se trouver. playerMeshfait référence au modèle 3D du joueur, à partir duquel nous extrayons sa position et l'utiliser comme currentPlayerPosition.Pour savoir s'il est proche de la marque, nous avons besoin d'une variable représentant la position de la marque, et dans notre exemple, nous avons créé une variable playerMarkdans laquelle nous pouvons écrire la position dans laquelle le joueur devrait être. Ensuite, nous avons ajouté trois variables qui nous permettent de savoir si le joueur est à proximité. proximityValueXcalcule la distance entre le joueur et la marque de l'axe X. proximityValueYcalcule la distance entre le joueur et la marque de l'axe Y.Ensuite, nous avons nearValue, dans lequel nous pouvons déterminer à quelle distance le joueur peut être de la position de la marque, quand le personnage de l'IA peut commencer à travailler pour atteindre l'objectif. Dès que le joueur est proche de la marque, la variable booléenne playerOnMarkchange la valeur en true.Pour calculer la distance entre le joueur et la marque, nous avons utilisé ce qui suit: la distance entre le joueur et sa marque, similaire (mark.position - player.position).Maintenant, pour déterminer si le caractère AI est proche du cube, nous calculons la même équation en calculant la distance entre l'IA et le cube. De plus, nous avons complété le code avec des positions sur les deux marques (joueur et cube):public GameObject playerMesh;
public Transform playerMark;
public Transform cubeMark;
public Transform currentPlayerPosition;
public Transform currentCubePosition;
public float proximityValueX;
public float proximityValueY;
public float nearValue;
public float cubeProximityX;
public float cubeProximityY;
public float nearCube;
private bool playerOnMark;
private bool cubeIsNear;
void Start () {
Vector3 playerMark = new Vector3(81.2f, 32.6f, -31.3f);
Vector3 cubeMark = new Vector3(81.9f, -8.3f, -2.94f);
nearValue = 0.5f;
nearCube = 0.5f;
}
void Update () {
currentPlayerPosition.transform.position = playerMesh.transform.position;
proximityValueX = playerMark.transform.position.x - currentPlayerPosition.transform.position.x;
proximityValueY = playerMark.transform.position.y - currentPlayerPosition.transform.position.y;
if((proximityValueX + proximityValueY) < nearValue)
{
playerOnMark = true;
}
cubeProximityX = currentCubePosition.transform.position.x - this.transform.position.x;
cubeProximityY = currentCubePosition.transform.position.y - this.transform.position.y;
if((cubeProximityX + cubeProximityY) < nearCube)
{
cubeIsNear = true;
}
else
{
cubeIsNear = false;
}
}
Maintenant que notre personnage IA sait s'il est à côté du cube, cela nous permet de répondre à la question et de déterminer s'il peut passer à la branche suivante que nous avons planifiée. Mais que se passe-t-il lorsque le personnage n'est pas à côté du cube? Il devra s'approcher du cube. Par conséquent, nous ajouterons ceci au code:public GameObject playerMesh;
public Transform playerMark;
public Transform cubeMark;
public Transform cubeMesh;
public Transform currentPlayerPosition;
public Transform currentCubePosition;
public float proximityValueX;
public float proximityValueY;
public float nearValue;
public float cubeProximityX;
public float cubeProximityY;
public float nearCube;
private bool playerOnMark;
private bool cubeIsNear;
public float speed;
public bool Finding;
void Start () {
Vector3 playerMark = new Vector3(81.2f, 32.6f, -31.3f);
Vector3 cubeMark = new Vector3(81.9f, -8.3f, -2.94f);
nearValue = 0.5f;
nearCube = 0.5f;
speed = 1.3f;
}
void Update () {
currentPlayerPosition.transform.position = playerMesh.transform.position;
proximityValueX = playerMark.transform.position.x - currentPlayerPosition.transform.position.x;
proximityValueY = playerMark.transform.position.y - currentPlayerPosition.transform.position.y;
if((proximityValueX + proximityValueY) < nearValue)
{
playerOnMark = true;
}
cubeProximityX = currentCubePosition.transform.position.x - this.transform.position.x;
cubeProximityY = currentCubePosition.transform.position.y - this.transform.position.y;
if((cubeProximityX + cubeProximityY) < nearCube)
{
cubeIsNear = true;
}
else
{
cubeIsNear = false;
}
if(playerOnMark == true && cubeIsNear == false && Finding == false)
{
PositionChanging();
}
if(playerOnMark == true && cubeIsNear == true)
{
Finding = false;
}
}
void PositionChanging () {
Finding = true;
Vector3 positionA = this.transform.position;
Vector3 positionB = cubeMesh.transform.position;
this.transform.position = Vector3.Lerp(positionA, positionB, Time.deltaTime * speed);
}
Jusqu'à présent, notre personnage AI est capable de calculer la distance entre lui et le cube; s'ils sont trop éloignés, alors il ira au cube. Après avoir terminé cette tâche, il peut passer à la phase suivante et commencer à pousser le cube. La dernière chose dont il a besoin pour calculer est la distance entre le cube et la position de la marque, après quoi il décide de quelle direction pousser, en tenant compte de quel côté du cube la marque est la plus proche.Le cube ne peut être poussé que le long des axes X et Z, et sa rotation n'est pas encore importante pour nous, car le bouton est activé lorsque le cube est installé dessus. Compte tenu de tout cela, le personnage AI doit calculer la distance entre le cube et la position de la marque en X et la position de la marque en Z.Ensuite, il compare les deux valeurs sur deux axes et sélectionne celle qui est la plus éloignée de la position souhaitée, puis commence à pousser le long de cette axe. Le personnage continuera à pousser dans cette direction jusqu'à ce que le cube soit aligné avec la position de la marque, puis passe de l'autre côté, et le poussera jusqu'à ce qu'il soit complètement au-dessus de la position de la marque:public GameObject playerMesh;
public Transform playerMark;
public Transform cubeMark;
public Transform cubeMesh;
public Transform currentPlayerPosition;
public Transform currentCubePosition;
public float proximityValueX;
public float proximityValueY;
public float nearValue;
public float cubeProximityX;
public float cubeProximityY;
public float nearCube;
public float cubeMarkProximityX;
public float cubeMarkProximityZ;
private bool playerOnMark;
private bool cubeIsNear;
public float speed;
public bool Finding;
void Start () {
Vector3 playerMark = new Vector3(81.2f, 32.6f, -31.3f);
Vector3 cubeMark = new Vector3(81.9f, -8.3f, -2.94f);
nearValue = 0.5f;
nearCube = 0.5f;
speed = 1.3f;
}
void Update () {
currentPlayerPosition.transform.position = playerMesh.transform.position;
proximityValueX = playerMark.transform.position.x - currentPlayerPosition.transform.position.x;
proximityValueY = playerMark.transform.position.y - currentPlayerPosition.transform.position.y;
if((proximityValueX + proximityValueY) < nearValue)
{
playerOnMark = true;
}
cubeProximityX = currentCubePosition.transform.position.x - this.transform.position.x;
cubeProximityY = currentCubePosition.transform.position.y - this.transform.position.y;
if((cubeProximityX + cubeProximityY) < nearCube)
{
cubeIsNear = true;
}
else
{
cubeIsNear = false;
}
if(playerOnMark == true && cubeIsNear == false && Finding == false)
{
PositionChanging();
}
if(playerOnMark == true && cubeIsNear == true)
{
Finding = false;
}
cubeMarkProximityX = cubeMark.transform.position.x - currentCubePosition.transform.position.x;
cubeMarkProximityZ = cubeMark.transform.position.z - currentCubePosition.transform.position.z;
if(cubeMarkProximityX > cubeMarkProximityZ)
{
PushX();
}
if(cubeMarkProximityX < cubeMarkProximityZ)
{
PushZ();
}
}
void PositionChanging () {
Finding = true;
Vector3 positionA = this.transform.position;
Vector3 positionB = cubeMesh.transform.position;
this.transform.position = Vector3.Lerp(positionA, positionB, Time.deltaTime * speed);
}
Après avoir ajouté les dernières actions au code, le personnage doit apprendre à déterminer son objectif, trouver et pousser le cube à la position souhaitée afin que le joueur puisse passer et terminer le niveau. Dans cet exemple, nous nous sommes concentrés sur la façon de calculer les distances entre les objets de scène et les personnages. Cela nous aidera à créer des types d'interactions similaires dans lesquels nous devons placer l'objet de jeu dans une certaine position.L'exemple montre un personnage IA amical qui aide le joueur, mais les mêmes principes peuvent être appliqués si nous avons besoin de l'effet inverse (si le personnage est un ennemi), dans lequel le personnage doit trouver le cube le plus tôt possible pour arrêter le joueur.Obstacles dans des environnements utilisant l'exemple d'Age of Empires
Comme nous l'avons vu précédemment, vous pouvez utiliser ou déplacer des objets dans le jeu pour atteindre des objectifs, mais que se passe-t-il si un objet obstrue le chemin du personnage? L'objet peut être placé par le joueur ou simplement localisé par le concepteur à cette position de la carte. Dans tous les cas, le personnage IA devrait être capable de déterminer ce qui doit être fait dans cette situation.Nous pouvons observer ce comportement, par exemple, dans une stratégie appelée Age of Empires II développée par Ensemble Studios. Chaque fois qu'un personnage de jeu ne peut pas atteindre le territoire ennemi en raison du fait qu'il est entouré de murs fortifiés, l'IA passe à la destruction d'une partie du mur pour continuer.Ce type d'interaction est également très intelligent et important, car sinon les personnages se promèneraient le long du mur à la recherche d'une entrée, et cela ne ressemblerait pas à un comportement raisonnable. Puisque le mur renforcé est créé par le joueur, il peut être placé n'importe où et avoir n'importe quelle forme. Par conséquent, vous devez y penser lorsque vous développez une IA ennemie.Cet exemple se rapporte également au sujet de notre article, car au stade de la planification, lorsque nous créons des arbres de comportement, nous devons réfléchir à ce qui se passera si quelque chose gêne le personnage et qu'il ne peut pas atteindre ses objectifs. Nous examinerons cet aspect en détail dans les chapitres suivants du livre, mais pour l'instant nous simplifions la situation et analysons comment le personnage de l'IA devrait se comporter si l'objet d'environnement l'empêche d'atteindre son objectif.Dans notre exemple, le personnage de l'IA doit entrer dans la maison, mais lorsqu'il s'approche, il se rend compte qu'il est entouré d'une clôture en bois, à travers laquelle vous ne pouvez pas passer. Nous voulons que le personnage choisisse une cible à ce stade et commence à attaquer jusqu'à ce que cette partie de la clôture soit détruite et qu'il puisse entrer dans la maison.Dans cet exemple, nous devons calculer quelle clôture le personnage doit attaquer, compte tenu de la distance et de l'état de santé actuel de la clôture. Une clôture avec des HP bas devrait avoir une priorité d'attaque plus élevée qu'une clôture avec des HP complets, donc nous en tiendrons compte dans nos calculs.Nous voulons définir le voisinage autour du personnage, dans lequel les clôtures les plus proches transmettent leurs informations à l'intelligence artificielle afin qu'elle puisse décider laquelle est plus facile à détruire. Cela peut être mis en œuvre de différentes manières, soit en utilisant la reconnaissance des collisions de clôtures avec le joueur, soit en les forçant à calculer la distance entre les clôtures / objets et le joueur; nous définissons la valeur de la distance à laquelle le joueur commence à percevoir l'état de la clôture. Dans notre exemple, nous allons calculer la distance et l'utiliser pour informer le personnage des clôtures HP.Commençons par créer le code qui sera appliqué à l'objet fence; tous auront le même script:public float HP;
public float distanceValue;
private Transform characterPosition;
private GameObject characterMesh;
private float proximityValueX;
private float proximityValueY;
private float nearValue;
void Start () {
HP = 100f;
distanceValue = 1.5f;
characterMesh = GameObject.Find("AICharacter");
}
void Update () {
characterPosition = characterMesh.transform;
proximityValueX = characterPosition.transform.position.x - this.transform.position.x;
proximityValueY = characterPosition.transform.position.y - this.transform.position.y;
nearValue = proximityValueX + proximityValueY;
}
Dans ce script, nous avons ajouté des informations de base sur les HP et les distances, qui seront utilisées pour se connecter avec le personnage AI. Cette fois, nous ajoutons le script de calcul de distance non pas au personnage, mais aux objets d'environnement; cela donne à l'objet plus de dynamisme et nous permet de créer plus d'opportunités.Par exemple, si les personnages du jeu participent également à la création de clôtures, ils auront alors des états différents, par exemple, «en construction», «terminé» ou «endommagé»; le personnage pourra alors recevoir ces informations et les utiliser à ses propres fins.Définissons le personnage interagissant avec l'objet environnement. Son objectif principal sera d'accéder à la maison, mais lorsqu'il s'en approche, il se rend compte qu'il ne peut pas entrer à l'intérieur du fait qu'il est entouré de clôtures en bois. Nous voulons qu'après avoir analysé la situation, notre personnage détruise la clôture pour atteindre son objectif et entrer dans la maison.Dans le script de caractère, nous ajouterons une fonction statique à l'entrée dont les clôtures pourront transmettre des informations sur leur «santé» actuelle; cela aidera le personnage à choisir la clôture la plus appropriée pour la destruction.public static float fenceHP;
public static float lowerFenceHP;
public static float fencesAnalyzed;
public static GameObject bestFence;
private Transform House;
private float timeWasted;
public float speed;
void Start () {
fenceHP = 100f;
lowerFenceHP = fenceHP;
fencesAnalyzed = 0;
speed = 0.8;
Vector3 House = new Vector3(300.2f, 83.3f, -13.3f);
}
void Update () {
timeWasted += Time.deltaTime;
if(fenceHP > lowerFenceHP)
{
lowerFenceHP = fenceHP;
}
if(timeWasted > 30f)
{
GoToFence();
}
}
void GoToFence() {
Vector3 positionA = this.transform.position;
Vector3 positionB = bestFence.transform.position;
this.transform.position = Vector3.Lerp(positionA, positionB, Time.deltaTime * speed);
}
Nous avons déjà ajouté les informations les plus élémentaires au personnage. fenceHPsera une variable statique dans laquelle chaque clôture qui se situe dans le rayon du voisinage du personnage enregistrera des informations sur le HP actuel. Ensuite, le personnage de l'IA analyse les informations reçues et les compare avec la clôture avec le moins de HP présenté lowerFenceHP.Le personnage a une variable timeWastedreprésentant le nombre de secondes qu'il a déjà passé à chercher une clôture appropriée à détruire. fencesAnalyzedsera utilisé pour savoir s'il y a déjà une clôture dans le code, et sinon, la première clôture trouvée par le personnage est ajoutée; si les clôtures ont la même valeur de PV, le personnage les attaque en premier. Ajoutons maintenant le code des clôtures afin qu'elles puissent accéder au script du personnage et entrer des informations utiles.public float HP;
public float distanceValue;
private Transform characterPosition;
private GameObject characterMesh;
private float proximityValueX;
private float proximityValueY;
private float nearValue;
void Start () {
HP = 100f;
distanceValue = 1.5f;
characterMesh = GameObject.Find("AICharacter");
}
void Update () {
characterPosition = characterMesh.transform;
proximityValueX = characterPosition.transform.position.x - this.transform.position.x;
proximityValueY = characterPosition.transform.position.y - this.transform.position.y;
nearValue = proximityValueX + proximityValueY;
if(nearValue <= distanceValue){
if(AICharacter.fencesAnalyzed == 0){
AICharacter.fencesAnalyzed = 1;
AICharacter.bestFence = this.gameObject;
}
AICharacter.fenceHP = HP;
if(HP < AICharacter.lowerFenceHP){
AICharacter.bestFence = this.gameObject;
}
}
}
Nous avons finalement terminé cet exemple. Maintenant, la clôture compare ses HP actuels avec les données du personnage ( lowerFenceHP), et si ses HP sont inférieurs à la valeur la plus basse du personnage, alors cette clôture sera considérée bestFence.Cet exemple montre comment adapter un personnage IA à divers objets dynamiques du jeu; le même principe peut être étendu et utilisé pour interagir avec presque n'importe quel objet. Il est également applicable et utile lors de l'utilisation d'objets pour interagir avec un personnage, en reliant des informations entre eux.Dans cet article, nous avons exploré différentes façons d'interagir avec l'environnement. Les techniques présentées dans ce chapitre peuvent être étendues à de nombreux genres de jeux différents et utilisées pour effectuer des interactions simples et complexes entre les personnages de l'IA et l'environnement.