Création d'une IA C # simple dans Unity

Presque tous les jeux nécessitent une intelligence artificielle (IA) qui interagit avec l'utilisateur, le plus souvent sous la forme d'une force hostile au joueur. Dans certains cas, l'IA devrait aider le joueur, dans d'autres, elle devrait le combattre, mais tous les personnages contrôlés par l'ordinateur ont des similitudes. Selon les exigences du projet, l'IA peut utiliser des comportements simples ou complexes. Ces exigences peuvent être la diplomatie avec un autre joueur ou une simple errance dans les deux sens sur la plate-forme. Quoi qu'il en soit, il est nécessaire de s'assurer que l'IA fait son travail efficacement.

Dans ce projet, je vais démontrer une intelligence artificielle très simple. Supposons que nous créons un jeu dans lequel un joueur doit se faufiler près du quartier général ennemi. Lorsqu'un joueur est remarqué par une caméra de sécurité, des ennemis sont créés à proximité et pour une courte période, poursuivez le joueur. C'est ce que nous mettons en œuvre dans le projet au niveau le plus simple. À la fin du projet, vous recevrez un objet de joueur contrôlé, un cercle utilisé comme caméra d'un ennemi et un objet ennemi qui poursuivra le joueur lorsque l'objet de la caméra informe de sa présence.

La préparation

Nous devons d'abord créer un projet 3D. Cliquez sur le bouton Nouveau en haut de la fenêtre après avoir démarré Unity, comme illustré à la figure 1.


Figure 1: création d'un nouveau projet

Nommez votre projet AI et assurez-vous qu'il s'agit d'un projet 3D. Après avoir choisi un emplacement sur l'ordinateur pour stocker le projet, cliquez sur le bouton Créer un projet en bas, illustré à la figure 2.


Figure 2: écran de configuration du projet

Après avoir créé le projet, la première chose que nous devons faire est de configurer les dossiers dans la fenêtre Actifs pour organiser notre travail. Cliquez avec le bouton droit sur la fenêtre Actifs et sélectionnez Créer → Dossier pour créer un nouveau dossier. Nommez ce dossier Matériaux . Créez ensuite un deuxième dossier et nommez-le Scripts . La figure 3 montre à quoi cela devrait ressembler.


Figure 3: création d'un nouveau dossier

Après tout cela, la fenêtre Actifs devrait ressembler à celle illustrée à la figure 4.


Figure 4: fenêtre Actifs .

Ensuite, créez un sol sur lequel tous les objets se poseront. Dans la fenêtre Hiérarchie , sélectionnez Créer → Objet 3D → Plan pour créer un objet plan qui sera utilisé comme sol.


Figure 5: Création d'un objet plan.

Nommez cet objet Floor et changez sa valeur X Scale en 7, et la valeur Z Scale en 3. Après cela, la fenêtre Inspector avec l'objet Floor sélectionné devrait ressembler à la figure 6.


Figure 6: Définition des propriétés de l'objet Floor .

Maintenant, nous devons créer un nouveau matériau pour Floor afin de le distinguer du reste des objets qui seront placés dans la scène. Dans le dossier Matériaux de la fenêtre Actifs , créez un nouveau matériau en cliquant avec le bouton droit sur la fenêtre Actifs et en choisissant Créer → Matériau .


Figure 7: création d'un nouveau matériau

Une fois terminé, nommez le matériau Floor .


Figure 8: Matériau du sol .

En haut de la fenêtre Inspecteur avec Plancher sélectionné, sélectionnez un sélecteur de couleurs.


Figure 9: choix d'un sélecteur de couleurs.

Bien sûr, vous pouvez choisir n'importe quelle couleur pour le sol, mais dans cet exemple, j'ai choisi le rouge-brun, comme le montre la figure 10.


Figure 10: sélecteur de couleurs.

Sélectionnez l'objet Floor dans la fenêtre Hiérarchie et dans le composant Mesh Renderer , sélectionnez la petite flèche en regard de Matériaux .


Figure 11: Préparation d'un changement important.

Faites glisser le matériau Floor depuis la fenêtre Assets vers le champ Element 0 du composant Mesh Renderer dans la fenêtre Inspector .


Figure 12: Définition du matériau Floor comme matériau de l'objet Floor .

Après avoir terminé avec l'objet Floor , nous devons créer autour de la zone du mur afin que le joueur ne puisse pas tomber du bord. Revenez à Créer → Objet 3D → Plan pour créer un nouveau plan. Nous appelons ce plan de mur et le définissons aux mêmes dimensions que le sol , c'est-à-dire l' échelle X avec une valeur de 7 et l' échelle Z avec une valeur de 3. Ensuite, créez trois autres murs, sélectionnez un objet et appuyez trois fois sur Ctrl + D. Ensuite, placez les murs autour selon les données du tableau.

Le titre	Position X	Position Y	Position z	Rotation x	Rotation z
Mur	-35	21	0	0	-90
Mur (1)	-1	11	-15	90	0
Mur (2)	-1	11	13,5	-90	0
Mur (3)	34	21	0	0	90

Tableau 1: Positions et rotations de tous les objets Mur .

Après avoir terminé tout cela, vous devez changer la position de la caméra afin qu'elle regarde le sol par le haut. Sélectionnez l'objet Caméra principale et définissez Position Y sur 30, Position Z sur 0 et Rotation X sur 80.


Figure 13: configuration de l'objet caméra.

La scène est préparée, il est donc temps de créer le personnage du joueur. Dans la fenêtre Hiérarchie , cliquez sur Créer → Objet 3D → Sphère pour créer un objet sphère. Nommez cet objet Player , puis cliquez sur le bouton Ajouter un composant en bas de la fenêtre Inspecteur .


Figure 14: ajout d'un nouveau composant.

Maintenant, trouvez le Rigidbody . Après cela, sélectionnez le composant Rigidbody dans la liste et ajoutez le Rigidbody à l'objet Player .


Figure 15: ajout d'un composant Rigidbody .

Ensuite, vous devez attribuer au joueur un tag, qui nous sera plus tard utile dans le code. Cliquez sur le menu déroulant Tag dans le coin supérieur gauche de la fenêtre Inspecteur et sélectionnez la balise Player .


Figure 16: Définition d'une nouvelle balise.

Nous devons définir la position du joueur afin qu'il ne se trouve pas sous l'objet Floor . Dans l'exemple, j'ai placé le joueur dans le coin supérieur gauche avec une position X égale à 26, une position Y égale à 1 et une position Z égale à -9.


Figure 17: placement du joueur.

Pour que notre futur code fonctionne correctement, nous devons, bien sûr, l'attacher à l'objet. Revenez à la fenêtre Hiérarchie et sélectionnez cette fois Créer → Objet 3D → Cube . Appelez ce cube Guard , ajoutez-y le composant Rigidbody et le composant NavMesh Agent à l'aide du bouton Ajouter un composant dans la fenêtre Inspecteur . Ensuite, placez-le quelque part dans le coin supérieur gauche de la scène. Après cela, la fenêtre Inspecteur de l'objet Guard ressemblera à ceci:


Figure 18: Objet de garde dans la fenêtre Inspecteur .

Et cet objet doit être situé comme ceci:


Figure 19: Placement de l'objet Guard .

Enfin, nous avons besoin d'un objet utilisé comme «œil» de l'objet Guard , qui informera le Guard que le joueur le touche. Pour la dernière fois, allez dans la fenêtre Hiérarchie et sélectionnez Créer → Objet 3D → Sphère pour créer un autre objet sphère. Nommez cet objet Looker . Cette fois, nous n'avons pas besoin d'y ajouter d'autres composants. Cependant, nous allons redimensionner l'objet. Après avoir choisi Looker , modifiez les variables de composant Transform suivantes dans la fenêtre Inspector .

• Échelle X à 9.
• Échelle Y à 0,5.
• Échelle Z à 9.

Après cela, positionnez le Looker de manière à ce qu'il soit situé dans la partie supérieure centrale du sol, comme illustré à la figure 20.


Figure 20: Emplacement du Looker.

C'est le bon moment pour donner à Looker un matériau unique afin que vous puissiez voir qu'il vaut la peine d'être évité. Dans le dossier Matériaux de la fenêtre Actifs , cliquez avec le bouton droit et créez un nouveau matériau. Nommez-le Looker et donnez-lui une couleur rouge vif. Après cela, désignez ce matériau comme le matériau de l'objet Looker pour changer sa couleur. Après cela, la scène devrait ressembler à ceci:


Figure 21: objet Looker avec un nouveau matériau.

Il ne nous reste plus qu'à créer un maillage de navigation pour la Garde , sur lequel il pourra se déplacer. Il y a un menu Fenêtre en haut de l'éditeur Unity. Choisissez Fenêtre → Navigation pour ouvrir la fenêtre de navigation illustrée à la figure 22.


Figure 22: Fenêtre de navigation .

Sélectionnez l'objet Floor dans la hiérarchie , puis dans la fenêtre Navigation , cochez la case Navigation Static .


Figure 23: Navigation statique .

Ensuite, sélectionnez l'option Bake en haut de la fenêtre.


Figure 24: Basculez vers le menu Bake .

Le menu Bake s'ouvre, dans lequel vous pouvez modifier les propriétés du maillage de navigation que nous allons créer. Dans notre exemple, rien ne doit être changé. Cliquez simplement sur le bouton Bake en bas à droite.


Figure 25: création d'un nouveau maillage de navigation.

À ce stade, Unity vous demandera de sauvegarder la scène. Enregistrez-le, après quoi un maillage de navigation sera créé. Maintenant, la scène ressemblera à ceci:


Figure 26: La scène actuelle avec le maillage de navigation ajouté.

Maintenant, tout dans Unity est configuré, il est donc temps de créer les scripts nécessaires au fonctionnement du projet. Dans la fenêtre Actifs , cliquez avec le bouton droit et sélectionnez Créer → Script C # . Nommez ce script Player . Répétez cette opération deux fois de plus, en créant des scripts avec les noms Guard et Looker .


Figure 27: création d'un nouveau script.

Après cela, le dossier Scripts dans la fenêtre Actifs ressemblera à ceci:


Figure 28: dossier Scripts .

Tout d'abord, nous allons commencer à écrire le code du script Player . Double-cliquez sur le script Player dans la fenêtre Actifs pour ouvrir Visual Studio et commencer à créer le code.

Code

Le script Player est assez simple, il ne fait que déplacer l’objet balle. Sous la déclaration de classe, nous devons obtenir un lien vers le composant Rigidbody que nous avons précédemment créé dans le projet.

private Rigidbody rb; 

Juste après cela, dans la fonction Démarrer , nous commandons à Unity de définir le composant Rigidbody actuel de l'objet Player sur rb .

 rb = GetComponent<Rigidbody>(); 

Après cela, le script Player ressemblera à ceci:


Figure 29: Script du joueur pour le moment.

Maintenant que la valeur rb est affectée, nous devons laisser bouger l'objet Player lorsque nous appuyons sur les touches fléchées. Pour déplacer l'objet, nous utiliserons la physique, en appliquant une force à l'objet lorsque l'utilisateur appuie sur les touches fléchées. Pour ce faire, ajoutez simplement le code suivant à la fonction de mise à jour :

 if (Input.GetKey(KeyCode.UpArrow)) rb.AddForce(Vector3.forward * 20); if (Input.GetKey(KeyCode.DownArrow)) rb.AddForce(Vector3.back * 20); if (Input.GetKey(KeyCode.LeftArrow)) rb.AddForce(Vector3.left * 20); if (Input.GetKey(KeyCode.RightArrow)) rb.AddForce(Vector3.right * 20); 

Avec cela, nous avons terminé le script Player . Le script terminé ressemblera à ceci:


Figure 30: le script Player terminé.

Enregistrez votre travail et revenez à Unity. Cette fois, sélectionnez le script Guard dans la fenêtre Actifs . Pour que le code Guard fonctionne, vous devez ajouter la construction using en haut du script.

 using UnityEngine.AI; 

Ensuite, déclarez les variables suivantes immédiatement après la déclaration de classe.

 public GameObject player; private NavMeshAgent navmesh; 

L'objet Player est utilisé comme valeur de la variable player de l'objet Guard . Cela vous sera utile plus tard lorsque nous ordonnerons à l'objet Garde de poursuivre le joueur. Ensuite, la variable navmesh est déclarée pour recevoir le composant NavMeshAgent de l'objet. Nous l'utiliserons plus tard lorsque le garde commencera à chasser le joueur après avoir appris que le joueur touche l'objet Looker . Dans la fonction Démarrer , nous devons définir la valeur de la variable navmesh sur le composant NavMesh Agent de l' objet:

 navmesh = GetComponent<NavMeshAgent>(); 

Ensuite, dans la fonction Update , nous ajoutons une seule ligne de code:

 navmesh.destination = player.transform.position; 

Cette ligne définit la destination de l'objet Guard . Dans notre cas, il prendra la position actuelle de l'objet Player et se déplacera jusqu'à ce point. Après l'opération, l'objet poursuivra constamment le joueur. La question est de savoir comment se déroule le processus de réponse? Il ne sera pas encodé dans le script Guard , mais dans le script Looker . Avant de passer au script Looker, consultez la figure 31 pour vérifier le code de votre script Guard .


Figure 31: le script Guard terminé.

Dans Looker, nous devons à nouveau déclarer les variables suivantes:

 public GameObject guard; private float reset = 5; private bool movingDown; 

Après cela, nous commentons la fonction Démarrer , dont nous n'avons pas besoin dans ce script. Passons à la fonction de mise à jour et ajoutons le code suivant:

 if (movingDown == false) transform.position -= new Vector3(0, 0, 0.1f); else transform.position += new Vector3(0, 0, 0.1f); if (transform.position.z > 10) movingDown = false; else if (transform.position.z < -10) movingDown = true; reset -= Time.deltaTime; if (reset < 0) { guard.GetComponent<Guard>().enabled = false; GetComponent<SphereCollider>().enabled = true; } 

C'est là que se déroulent les principales actions du projet, analysons donc le code. Premièrement, selon la valeur de la variable booléenne movingDown , l'objet auquel ce script est attaché se déplacera vers le haut ou vers le bas. Dès qu'il atteint un certain point, il change de direction. Ensuite, Looker réduira la valeur de réinitialisation en fonction du temps réel. Dès que le chronomètre devient inférieur à zéro, il prendra le script Guard de l'objet Guard et le désactivera, après quoi l'objet Guard commencera à se déplacer vers la dernière position connue du joueur jusqu'à ce moment, puis s'arrêtera. Looker rallume également son collisionneur pour que l'ensemble du processus puisse recommencer. Maintenant, notre script ressemble à ceci:


Figure 32: script Looker .

En parlant de collisionneurs: il est temps de créer un code de conflit qui réinitialise le minuteur Looker et inclut le script Guard . Dans la fonction de mise à jour , créez le code suivant:

 private void OnCollisionEnter(Collision collision) { if (collision.gameObject.tag == "Player") { guard.GetComponent<Guard>().enabled = true; reset = 5; GetComponent<SphereCollider>().enabled = false; } } 

OnCollisionEnter Unity le reconnaît automatiquement comme un code de collision et l'exécute donc lorsqu'une collision se produit avec un autre objet. Dans notre cas, il vérifie d'abord si l'objet entrant en collision a une balise Player . Sinon, il ignore le reste du code. Sinon, il active le script Guard , définit le délai de réinitialisation sur 5 (c'est-à-dire cinq secondes) et désactive son collisionneur afin que le joueur puisse toujours se déplacer dans l'objet et ne pas se coincer accidentellement dans l'objet Looker . La fonction est illustrée à la figure 33.


Figure 33: Code de collision pour Looker.

C'est tout le code du projet est prêt! Vous pouvez faire quelques autres choses avant de terminer le projet. Enregistrez tout le travail et revenez à Unity.

Achèvement du projet

Pour terminer le projet, nous avons juste besoin d'attacher des scripts aux objets correspondants et de définir plusieurs variables. Tout d'abord, passez de la fenêtre Navigation à la fenêtre Inspecteur :


Figure 34: transition vers la fenêtre Inspecteur.

Après cela, commençons par l'objet Player . Sélectionnez-le dans la fenêtre Hiérarchie , puis en bas de la fenêtre Inspecteur , cliquez sur le bouton Ajouter un composant et ajoutez le script Player . Ceci termine l'objet Player .


Figure 35: Composant de script du lecteur .

Ensuite, sélectionnez l'objet Guard . Comme précédemment, attachez le script Guard à l'objet. Cette fois, nous devons dire au garde qui est le joueur. Pour ce faire, faites glisser l'objet Player de la hiérarchie vers le champ Player du composant de script Guard , comme illustré à la figure 36.


Figure 36: Faire de l'objet Player la valeur du champ Player .

Nous devons également désactiver le script Guard . Dans notre projet, Guard poursuivra le joueur après avoir activé son script. Ce script de garde ne doit être inclus qu'après que le joueur a touché l' objet Looker . Il vous suffit de décocher la case à côté du texte Guard (Script) dans le composant:


Figure 37: Désactivation du script Guard .

Enfin, passons à l'objet Looker et y attachons le script Looker . Cette fois, l'objet Looker aura besoin d'un objet Guard comme valeur de sa variable Guard . Tout comme nous avons affecté l'objet Player à la variable Player du script Guard , nous ferons de même avec l'objet Guard et le script Looker . Faites glisser la Garde de la Hiérarchie dans le champ Garde du script Looker . Et le projet est terminé! Cliquez sur le bouton Lecture en haut de l'éditeur Unity pour tester votre projet.


Figure 38: Test d'un projet.

Essayez de déplacer l'objet Player vers l'objet Looker (rappelez-vous que le déplacement se fait avec des flèches!). Notez qu'après cela, l'objet Guard commencera à chasser le joueur. Il poursuivra la poursuite pendant environ 5 secondes, après quoi il abandonnera.


Figure 39: Un projet entièrement achevé en action.

Conclusion

Cette IA est très simple, mais elle peut facilement être étendue. Supposons que si nous imaginons que l'objet Looker est une caméra et que le garde regarde à travers lui pour vous trouver, il sera logique de donner à l'objet Guard sa propre paire d'yeux. Le joueur peut s'approcher des caméras, mais elles doivent tenir compte des yeux du gardien. Vous pouvez également combiner ce projet avec le concept de trouver le chemin : donner au gardien le chemin qu'il suivra, créant ainsi un environnement plus intéressant pour le joueur.

Une IA aussi simple peut être développée de différentes manières. Vous ne voudrez peut-être rien faire de ce qui précède et décider de faire quelque chose de votre choix. Je vous conseille d'expérimenter, peut-être aurez-vous l'idée d'un projet intéressant, qui mérite d'être mené à terme.