Jusqu'à maintenant, vous avez appris à déclencher des méthodes uniquement avec des boutons qui ne renvoient aucune valeur. Cette fois-ci, nous allons apprendre à utiliser les inputs qui renvoient des valeurs de type Vector2.
Contexte
Actuellement, si vous souhaitez déplacer un personnage, vous devez créer quatre méthodes distinctes : une pour avancer, une pour reculer, et deux autres pour se déplacer à droite et à gauche. Bref, ce n'est pas idéal et cela alourdit considérablement votre code.
Cette fois, nous allons apprendre à associer des touches à des valeurs. Ces valeurs seront ensuite envoyées à une même action. Par exemple, vous allez configurer les touches fléchées de votre clavier pour envoyer les nombres -1 ou 1, afin de déterminer si vous souhaitez avancer ou reculer.
Préparation
Pour cette page, nous allons utiliser le même fichier InputSystem que pour les pages précédentes. Nous allons seulement effacer ce que nous avons fait dans le script Controleur et conserver uniquement l'objet InputSystem, comme ceci :
using UnityEngine;
using UnityEngine.InputSystem;
public class Controleur : MonoBehaviour
{
private Rigidbody rb;
private InputSystem inputSystem;
private void Awake()
{
rb = GetComponent<Rigidbody>();
inputSystem = new InputSystem();
}
}
Éditeur d'Input
Maintenant, nous allons créer une nouvelle action dans la map "Joueur" dans l'éditeur d'input, et la nommer "Mouvement". Sélectionnez cette action et changez l'option "Action Type" par "Value". Cela signifie que notre action pourra envoyer une valeur à notre script, comme un int, un Vector2, un bool, etc.
Comme nous allons déplacer notre personnage sur deux axes, changez le "Control Type" en Vector2. Cela limitera les options proposées par Unity, et vous proposera uniquement celles qui renvoient des valeurs de type Vector2. Vous auriez pu laisser Any pour accepter tous les types, mais cela vous aurait obligé à trier manuellement les options proposées par Unity pour vos bindings.
Ensuite, supprimez la ligne "<No Binding>" et créez le bindings pour les touches "up", "down", etc.
Cela générera quatre lignes "<No Binding>". À ce stade, tout fonctionne comme d'habitude : cliquez sur l'un des bindings et associez-y une touche du clavier. Faites bien attention de lier chaque touche à la direction appropriée. Par exemple, associez la flèche du haut à "Up" et la flèche du bas à "Down".
Pour comprendre, ce type de binding, vous venez d'associée un bouton à une coordonnée cartésienne en 2 dimensions (Vector2), qui correspondra aux valeurs des axes X et Y .
Ces valeurs seront ensuite utilisées pour déterminer la direction du déplacement. Par exemple, la touche que vous avez associée au binding Down va envoyer X = 0 et Y =-1.
N'oubliez pas de sauvegarder après avoir effectué vos modifications.
Remarque: La sauvegarde peut être plus longue que d'habitude, car Unity doit lire et modifier le fichier C# pour refléter vos changements. Il est donc conseillé de désactiver l'auto-sauvegarde pendant ces changements pour éviter les ralentissements entre chaque modification.
À ce stade, vous devriez avoir quelque chose de semblable à ceci.
Lire les valeurs
Maintenant, lorsque vous appuyez sur l'une des touches configurée précédement, Unity va pouvoir recevoir un Vector2 (X, Y). Mais que faire avec cette valeur ? Nous allons simplement la lire et l'utiliser dans une méthode comme AddForce pour déplacer notre sphère.
Il existe plusieurs façons de coder cela, mais pour éviter de complexifier le cours, je vais tout intégrer dans la méthode FixedUpdate.
Voici comment nous allons lire les valeurs :
using UnityEngine;
using UnityEngine.InputSystem;
public class Controleur : MonoBehaviour
{
private Rigidbody rb;
private InputSystem inputSystem;
public Vector2 direction
private void Awake()
{
rb = GetComponent<Rigidbody>();
inputSystem = new InputSystem();
inputSystem.Joueur.Enable();
}
private void FixedUpdate()
{
direction = inputSystem.Joueur.Mouvement.ReadValue<Vector2>();
}
}
La ligne suivante :
direction = inputSystem.Joueur.Mouvement.ReadValue<Vector2>();
permet de lire les valeurs de l'action "Mouvement" de la map "Joueur". Nous utilisons la méthode ReadValue<Type de variable attendu>() pour obtenir notre valeur, qui sera ensuite stocké dans la variable direction.
J'ai choisi de rendre cette variable publique afin que vous puissiez voir en temps réel la valeur du Vector2 dans l'Inspector. Lorsque vous appuyez sur les flèches, vous devriez voir la variable direction changer de valeur.
Sur l'image ci-dessus, j'ai appuyé sur la flèche de droite de mon clavier, ce qui a donné la valeur 1 à l'axe des X.
Pour ce type de variable venant d'un input, il est généralement préférable d'utiliser une variable temporaire, comme ceci :
Vector2 direction = inputSystem.Joueur.Mouvement.ReadValue<Vector2>();
Cela permet surtout d'éviter d'alourdir le nombre de propriétés de notre objet.
Information sur les symboles <> en C#
Cette section est purement informative pour mieux comprendre ce que vous voyez. Nous aborderons ce sujet plus en détail dans un autre chapitre, donc ne vous inquiétez pas si vous ne saisissez pas tout immédiatement.
Actuellement, vous avez probablement l'habitude d'appeler des méthodes que vous avez créées comme ceci : Méthode(); et non comme cela : Méthode<>();.
Lorsque vous utilisez les symboles "<>", cela signifie que vous demandez à la méthode de vous retourner une valeur du type que vous avez écrit entre les chevrons.
Par exemple, si vous créez une méthode qui retourne un int comme ceci :
public int exemple()
{
return 2;
}
En appelant cette méthode, vous vous attendez à obtenir un int valant 2. Mais parfois, vous voulez que cette méthode soit plus flexible et renvoie un autre type de valeur, comme une chaîne de caractères ("2").
C'est à ce moment que vous utilisez une méthode générique comme ci-dessous.
Vous pouvez remplacer le mot "typeVariable" par ce que vous voulez, normalement, nous utilisons simplement la lettre "T" pour signifier que c'est une méthode avec un retour générique.
ReadValue, n'est pas la première méthode générique que vous utilisé. Chaque fois que vous utilisez GetComponent<t>(), vous faites en fait appel à une méthode générique. Peu importe le type d'objet que vous recherchez (comme un Rigidbody ou autre), Unity vous retournera l'objet du type spécifié, malgré que la méthode utilisé reste la même.
En résumé, si vous voyez des symboles "<>", cela signifie que vous utilisez une méthode qui renvoie une valeur du type que vous avez spécifié. Dans notre cas, la ligne
ReadValue<Vector2>();
va nous retourner un Vector2.
Identifier les axes
Votre variable direction possède deux axes, X et Y, alors que votre environnement 3D en possède trois. De plus, l'axe des Y correspond à l'axe de hauteur. Lorsque vous appuyez sur la touche flèche haut, vous souhaitez faire avancer la sphère, pas la faire monter dans les airs. Nous allons donc associer les axes correctement et utiliser notre Vector2 pour ajuster les axes X et Z du monde 3D.
Regardez votre scène du point de vue de la caméra pour bien identifier les axes. Vous pouvez activer l'option correspondante en bas à gauche lorsque la caméra est sélectionnée.
Sur l'image ci-dessus, on voit que droite/gauche correspond à l'axe X, et pour avancer/reculer, vous devez utiliser l'axe Z. Donc, pour avancer, nous devons utiliser la valeur Y de notre variable direction pour modifier la position en Z.
Remarque : La direction des flèches indique l'axe positif, donc c'est dans cette direction que vous allez si vous utilisez un nombre supérieur à 0.
Déplacer la sphère
Pour plus de clarté, nous allons créer des variables temporaires qui extrairont les valeurs de notre Vector2, et nous leur donnerons des noms correspondant à l'axe que nous souhaitons modifier dans notre monde 3D.
Voici le code :
private void FixedUpdate()
{
direction = inputSystem.Joueur.Mouvement.ReadValue<Vector2>();
float axeX = direction.x;
float axeZ = direction.y;
Vector3 directionForce = new Vector3(axeX, 0 , axeZ);
}
Nous utilisons des variables de type float pour extraire les axes du Vector2, car les positions contenues dans le Vector2 peuvent être des nombres décimaux (par exemple, 1.0).
Ensuite, comme nous l'avons vu plus haut, nous devons associer l'axe Y de direction à l'axe Z de notre monde, d'où cette ligne :
float axeZ = direction.y;
Pour terminé, la ligne
Vector3 directionForce = new Vector3(axeX, 0 , axeZ);
va placer nos valeurs dans un vector3. Nous devons faire cela, car il n'est pas possible d'addition un vector2 avec un vector3. Puisque nous voulons déplacer notre personnage, nous allons addition notre vector à ça position initiale, qui lui est un Vector3.
Nous laissons l'Axe Y de notre variable à 0, car nous ne souhaintons pas nous deplacer vers le haut.
Pour déplacer la sphère, nous allons maintenant utiliser la méthode AddForce du Rigidbody avec notre variable directionForce :
private void FixedUpdate()
{
direction = inputSystem.Joueur.Mouvement.ReadValue();
float axeX = direction.x;
float axeZ = direction.y;
Vector3 directionForce = new Vector3(axeX, 0 , axeZ);
rb.AddForce(directionForce);
}
Vous pouvez maintenant essayer votre jeu ! Et là, magie, rien ne se passe !
La vitesse
En réalité, votre code fonctionne, mais la sphère ne se déplace pas, car les valeurs de -1 et 1 ne sont pas suffisantes pour déplacer l'objet de manière visible. Il est donc nécessaire de multiplier cette force.
Ajoutez simplement une variable vitesse pour multiplier la force comme ceci :
public class Controleur : MonoBehaviour
{
private Rigidbody rb;
private InputSystem inputSystem;
public Vector2 direction;
public float vitesse;
private void Awake()
{
rb = GetComponent();
inputSystem = new InputSystem();
inputSystem.Joueur.Enable();
}
private void FixedUpdate()
{
direction = inputSystem.Joueur.Mouvement.ReadValue();
float axeX = direction.x;
float axeZ = direction.y;
Vector3 directionForce = new Vector3(axeX, 0 , axeZ);
rb.AddForce(directionForce * vitesse);
}
}
Ajustez la vitesse dans l'Inspector et testez !
Maintenant, tout fonctionne. Votre sphère se déplace ! Bien sûr, si vous n'aimez pas ce genre de déplacement, vous pouvez toujours utiliser ce que vous venez de voir avec d'autres méthodes du Rigidbody ou utiliser la valeur de Transform pour vos déplacements comme ceci.
private void FixedUpdate()
{
direction = inputSystem.Joueur.Mouvement.ReadValue();
float axeX = direction.x;
float axeZ = direction.y;
Vector3 directionForce = new Vector3(axeX, 0 , axeZ);
transform.position += directionForce * vitesse; // tester avec vitesse = 0.2
}
Petits ajustements à faire
Si vous avez testé votre jeu, vous avez probablement remarqué un léger problème : lorsque vous arrêtez d'appuyer sur une flèche de votre clavier, votre sphère continue de glisser, même si vous utilisez transform. La cause principale de ce phénomène est le composant Rigidbody, qui tente de maintenir l'inertie de l'objet.
Pour résoudre ce problème, plusieurs solutions sont possibles. Vous pouvez, par exemple, supprimer le composant Rigidbody si vous n'utilisez que transform. Vous pouvez aussi supprimer la vitesse de l'objet lorsque la variable direction vaut zéro sur tous ses axes.
Voyons comment mettre en œuvre cette dernière solution.
Pour vérifier si un Vector2 vaut zéro sur tous ses axes, on utilise cette ligne de code :
if(direction == Vector2.zero)
{ }
Ici, Vector2.zero est un Vector2 dont les valeurs des axes X et Y sont toutes deux égales à zéro.
C'est seulement un raccourcis, cela nous évite d'écrire une ligne comme ceci.
if(direction == New Vector2(0,0))
En comparant direction avec Vector2.zero, nous pouvons vérifier si aucune touche fléchée n'est enfoncée, car les deux vecteurs seront égaux.
Pour votre culture, il est possible de lire la structure d'une classe créée par Unity en effectuant un clique droit sur son nom et en sélectionnant « Atteindre la définition ».
Vous arriverez alors sur ceci.
C'est surtout pour le plaisir de connaître les détails des propriétés d'un objet. Comme vous le voyez sur l'image, vous pouvez retrouver la propriété zero. Cependant, à ce stade, votre niveau en C# n'est probablement pas suffisant pour comprendre comment ce type d'objet est structuré. Il est donc préférable d'utiliser la documentation d'Unity, ce qui est plus rapide, même pour les programmeurs avec un bon niveau en C#.
Bref revenons à notre cours. Nous allons maintenant modifier une propriété de notre Rigidbody, à savoir le linearVelocity, qui est un Vector3 utilisé pour calculer la vitesse actuelle de l'objet.
Voici la ligne de code à utiliser :
rb.linearVelocity = new Vector3(0, 0, 0);
Cette ligne mettra à zéro la vitesse de l'objet sur tous ses axes. Ainsi, la vitesse devient nulle lorsque vous arrêtez d'appuyer sur une touche fléchée, donc votre sphère s'arrêtera de se déplacer.
Voici donc le code complet de notre sphère :
using UnityEngine;
using UnityEngine.InputSystem;
public class Controleur : MonoBehaviour
{
private Rigidbody rb;
private InputSystem inputSystem;
public Vector2 direction;
public float vitesse;
private void Awake()
{
rb = GetComponent();
inputSystem = new InputSystem();
inputSystem.Joueur.Enable();
}
private void FixedUpdate()
{
if(direction == Vector2.zero)
{
rb.linearVelocity = new Vector3(0, 0, 0);
}
direction = inputSystem.Joueur.Mouvement.ReadValue();
float axeX = direction.x;
float axeZ = direction.y;
Vector3 directionForce = new Vector3(axeX, 0 , axeZ);
rb.AddForce(directionForce * vitesse);
}
}
Comme vous pouvez le constater, le code n'est pas si compliqué une fois qu'on comprend comment fonctionnent les inputs. Le plus difficile, c'est de ne pas se perdre avec les axes de notre monde 3D.
Remarque : jusqu'à maintenant, nous avons déplacé uniquement nos personnages lorsque la caméra restait fixe. Mais imaginons que votre caméra tourne autour de votre personnage. Dans ce cas, la droite et la gauche de votre caméra ne correspondront pas toujours aux mêmes axes de votre monde 3D. Déplacer votre personnage avec une telle caméra nécessite donc des étapes supplémentaires que nous aborderons plus loin, dans un autre chapitre. Pour l'instant, essayez d'utiliser une caméra qui se déplace sans effectuer de rotation.
Conclusion
Vous savez maintenant comment déplacer un personnage à l'aide des touches de votre clavier. Dans ce cours, vous avez appris qu'il était possible de convertir des touches en valeurs.
Vous en savez maintenant assez pour passer à la pratique. Dans le prochain chapitre d'exercice, je vous inviterai à créer un jeu de plateforme. Vous devrez donc utiliser tout ce que vous avez appris sur les inputs pour créer votre jeu. Bien sûr, nous aborderons également de nouvelles notions, telles que le changement de scène et le déplacement à l'aide d'un Joystick.
À la prochaine
Cette page ne contient pas de Fichier à Télécharger.
Les cours vous ont aidé et vous souhaitez à votre tour nous aider ?
- - - Vous pouvez partager le site avec vos connaissances, ainsi que le Discord. - - -
- - - Participer à la vie active du site et du Discord. - - -






