Comprendre le système de coordonnées dans Unity

Dans Unity, la manipulation précise des objets nécessite une compréhension du système de coordonnées cartésien.

Sans cette connaissance, les objets peuvent être mal positionnés, rendant le jeu incohérent et frustrant pour les développeurs.

Cet article explore comment utiliser efficacement le système de coordonnées cartésien pour améliorer la fluidité et l’interactivité des jeux Unity.

Table de matière

Coordonnées Cartésiennes Unity Coordonnées 2D dans Unity Coordonnées 3D et Unity Utiliser transform.position Unity FAQ Conclusion

Formation Unity : Réaliser votre premier jeu 3D avec C# - De l'Idée à la Réalité

Créez votre premier jeu 3D en C# avec Unity, étape par étape.

Coordonnées Cartésiennes Unity

Il existe une grande variété de jeux vidéo qui se distinguent tant par le style, le genre que les mécaniques de gameplay. Mais ils se regroupent tous généralement dans 2 catégories à savoir : les jeux en deux dimensions (2D) et les jeux en trois dimensions (3D).

En programmation, nous conceptualisons cela en faisant appel au Système de coordonnées Cartésien pour mieux situer les objets que ce soit dans un plan (2D) ou dans l’espace (3D).

Question : Qu’est ce qu’un système de coordonnées cartésien ?
Comment pouvez vous l’utiliser pour manipuler la position des objets dans Unity ?

Coordonnées 2D dans Unity

Un système de coordonnées cartésien est un système mathématique qui permet de déterminer la position d’un point dans un espace en utilisant des coordonnées numériques : (x , y) pour un repère en 2D et (x , y, z) pour un repère en 3D .

Coordonnées 3D et Unity

Considérons le repère orthonormé suivant :

L’ axe horizontal X correspond à l’axe des abscisses tandis que l’ axe vertical Y correspond à l’axe des ordonnées .

En partant de l’origine du repère au coordonnée (0, 0) , on peut noter que :

– Sur l’axe X , les abscisses situées à droite ont une valeur positive , tandis que celles situées à gauche ont une valeur négative .

– sur l’axe Y , les valeurs positives sont vers le haut tandis que les valeurs négatives sont en dessous de l’origine.

Si vous avez bien compris le principe, essayez de visualiser sur le repère précédent, la position d’un Tank dont les coordonnées sont (X, Y) = (3, 2) .

Changez ensuite sa position à (X, Y) = (-3, -3)

Si vos estimations sont exactes vous aurez les résultats suivants :

Utiliser transform.position Unity

Dans un repère 3D, le principe reste le même à la différence qu’il faut à présent prendre en compte la côte ou l’axe Z encore appelé l’axe de la profondeur .

Voyons maintenant comment tout cela s’imbrique dans Unity.

Manipulation de la position des objets dans Unity

Commençons par rajouter sur la scène de Unity un cube en prenant soin de réinitialiser au besoin sa position à (0, 0, 0) afin qu’il soit bien au centre.

Puisque que nous sommes à présent dans un espace 3D, vous remarquerez que les axes X, Y et Z sont clairement indiqués sur la scène.

Ensuite créons un script « CubeMove » à attacher au cube.

Modifier la position d’un objet avec un script C#

Nous voulons à présent écrire une instruction dans la méthode Start() pour déplacer le cube d’une unité au lancement du jeu. Une première idée serait d’écrire l’inscription suivante :

				
					
usingUnityEngine;
publicclassCubeMove : MonoBehaviour {
  // Start is called before the first frame update
  voidStart() { transform.position = transform.position + 1; }
  // Update is called once per frame
  voidUpdate() {}
}

Comme vous pouvez le voir nous utilisons « transform.position » pour accéder à la position du gameObject auquel est attaché ce script. Ensuite nous ajoutons la valeur « 1 ». Cela génère l’erreur suivante :

Message d’erreur : Impossible d’appliquer l’opérateur « + » aux opérandes de type « Vector3 » et « int »

Comprenons déjà que « transform.position » renvoie une valeur de type Vector3 comportant les coordonnées x, y et z du cube. Alors, ce n’est pas possible d’additionner une valeur de type Vector3 et un nombre entier (int) .

C’est comme l’eau et l’huile, il s’agit de deux types différents.

Il nous faudra alors remplacer la valeur « 1 » par une valeur plus explicite : new Vector3 (0, 0, 1) . Cette instruction devrait induire le déplacement du cube d’une (01) unité sur l’axe Z .

Bien sûr, nous pouvons améliorer la lisibilité du code en stockant cette valeur dans une variable de type Vector3 que nous nommerons : « forward » (ligne 5)

				
					
using UnityEngine;
public
class CubeMove : MonoBehaviour {
private
  Vector3 forward = new Vector3(0, 0, 1);
  // Start is called before the first frame update
  void Start() { transform.position = transform.position + forward; }
  // Update is called once per frame
  void Update() {}
}

Si vous êtes comme moi, un peu flémard, utilisez l’opérateur « += » pour incrémenter la position et raccourcir le code :

				
					
void Start() { transform.position += forward; }

Cette instruction signifie : « Ajouter à la valeur de transform.position la valeur de forward . »

Infos : Nous utilisons depuis, la propriété « transform » pour accéder à la position. Ne pas confondre avec « Transform » qui est justement le type de variable permettant de stocker des informations liées à la position, rotation et taille d’un gameObject.
Exemple : Transform cubeTransform ;

Revenons dans Unity pour lancer le jeu. Comme vous pouvez le remarquer le cube se déplace effectivement d’une unité en suivant l’axe Z.

Vous pouvez effectuer quelques tests en changeant la valeur des coordonnées (x, y, z) de la variable forward . La position du cube s’actualisera conformément aux nouvelles informations au lancement du jeu.

Remarquez à présent que si vous dupliquez le code présent comme suit ( ligne 10, 11 ) :

				
					
usingUnityEngine;
publicclassCubeMove : MonoBehaviour {
  privateVector3 forward = newVector3(0, 0, 1);
  // Start is called before the first frame update
  voidStart() {
    transform.position += forward;
    transform.position += forward;
  }
  // Update is called once per frame
  voidUpdate() {}
}

Vous observerez au lancement du jeu que la position du cube sur l’axe Z s’incrémente de 02 unités .

Question : Mais comment procédé pour faire bouger le cube de façon constante ?

C’est très simple !

Rappelez-vous de la méthode Update qui s’exécute à chaque frame . Nous pouvons juste lui demander de déplacer le cube d’ une unité à chaque frame . Cela se présente comme suit :

				
					
usingUnityEngine;
publicclassCubeMove : MonoBehaviour {
  privateVector3 forward = newVector3(0, 0, 1);
  // Start is called before the first frame update
  voidStart() {}
  // Update is called once per frame
  voidUpdate() { transform.position += forward; }
}

Ainsi, au lancement du moteur de jeu, vous remarquerez que le cube se déplace constamment vers l’avant.

Notre but initial était de déplacer le cube de façon constante . Cela semble atteint. Mais ce n’est pas réellement le cas.

Actuellement, le cube se déplace en fonction de la vitesse de calcul de votre machine . Si vous déployez ainsi un jeu, il sera plus rapide ou lent en fonction de la performance des machines utilisées par vos joueurs. Cela pose problème.

Pour éviter ce décalage, une bonne pratique consiste à utiliser l’instruction « Time.deltaTime ». Elle vous permettra gérer le déplacement à l’échelle du temps (en seconde) plutôt qu’en fonction des frames .

				
					
void Update() { transform.position += forward * Time.deltaTime; }

Vous pouvez à présent retester. Le cube se déplace plus lentement mais aura le mérite d’avoir une vitesse uniforme chez tous les utilisateurs.

En parlant justement de vitesse, nous pouvons rajouter une variable de type float qui nous permettra d’avoir un control uniforme sur la vitesse du cube .

Nommons cette variable : speed (ligne 8).

				
					
usingUnityEngine;
publicclassCubeMove : MonoBehaviour {
  privateVector3 forward = newVector3(0, 0, 1);
  [SerializeField] privatefloatspeed = 3f;
  // Update is called once per frame
  voidUpdate() { transform.position += forward * Time.deltaTime * speed; }
}

A la ligne 18 , nous multiplions la position du cube par la valeur de speed .

Comme résultat, la vitesse du cube varie en fonction de la valeur affectée à « speed ». Par exemple en affectant la valeur 10 à la variable speed dans l’inspecteur, vous pourrez noter que le déplacement sera nettement plus rapide. Vous pouvez vous amusez à changer les valeurs pour observer le résultat.

Peut-être que votre curiosité vous poussera à vous poser la question suivante :

Question : Que se passe-t-il si j’affecte à speed une valeur négative ?

Alors, si vous attribuez une vitesse négative, comme par exemple « -10 », cette valeur multipliera – à chaque frame – chacune des coordonnées du vecteur forward (x, y, z).

Il s’en suit que la valeur de la cote sur l’axe Z sera négative et le cube se déplacera en sens contraire.

En somme, nous venons de découvrir ce qu’est le système de coordonnées cartésien et son usage dans Unity . En usant du type Vector3 et de la propriété transform , nous avons vu comment gérer le mouvement des objets ainsi que les bonnes pratiques avec Time.deltaTime .

Ces principes peuvent être appliqués pour gérer le mouvement de n’importe quel objet , dans n’importe quel sens dans Unity. C’est d’ailleurs ce à quoi nous allons bientôt nous appliquer dans l’article suivant.

Formez-vous gratuitement avec Alphorm !

Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui.

FAQ

Qu'est-ce qu'un système de coordonnées cartésien?

Un système de coordonnées cartésien est un outil mathématique qui permet de localiser un point dans l’espace grâce à des coordonnées numériques. En 2D, ces coordonnées sont (x, y), et en 3D, elles deviennent (x, y, z). Ce système est essentiel pour positionner des objets dans un espace de jeu, permettant ainsi de définir précisément leur emplacement et d’interagir avec d’autres éléments. Dans Unity, comprendre ce système est fondamental pour créer des environnements de jeu cohérents et interactifs.

Comment utiliser les coordonnées cartésiennes dans Unity?

Dans Unity, les coordonnées cartésiennes sont utilisées pour définir la position des objets dans les scènes 2D et 3D. En utilisant le composant transform, vous pouvez accéder et modifier la position d’un gameObject via transform.position. Par exemple, pour déplacer un objet, vous pouvez utiliser un script C# pour ajuster ses coordonnées x, y et z, facilitant ainsi le contrôle du déplacement et de l’interaction des objets au sein de la scène Unity.

Comment manipuler la position d'un objet dans Unity avec un script?

Pour manipuler la position d’un objet dans Unity à l’aide d’un script, vous pouvez utiliser un script C# attaché au gameObject. Par exemple, en définissant une variable Vector3 pour la direction et en modifiant transform.position dans la méthode Update(), vous pouvez déplacer l’objet de manière continue. L’utilisation de Time.deltaTime permet de réguler la vitesse de déplacement indépendamment des performances de l’ordinateur, garantissant un mouvement fluide et uniforme.

Pourquoi utiliser Time.deltaTime dans Unity?

Time.deltaTime est crucial dans Unity pour assurer que les animations et mouvements des objets soient indépendants de la vitesse de traitement de la machine. En multipliant le déplacement par Time.deltaTime, vous garantissez que les objets bougent à une vitesse constante par seconde, plutôt qu’une vitesse qui varie selon le nombre de frames par seconde. Cette approche assure que le jeu fonctionne uniformément sur toutes les machines, offrant une expérience de jeu cohérente.

Comment ajuster la vitesse de déplacement d'un objet dans Unity?

Pour ajuster la vitesse de déplacement d’un objet dans Unity, utilisez une variable de type float pour définir la vitesse souhaitée. Intégrez cette variable dans le calcul de la position dans la méthode Update() en multipliant le vecteur de direction par le temps écoulé (Time.deltaTime) et par la vitesse. Cela permet de contrôler précisément la vitesse de déplacement, que vous pouvez modifier à tout moment via l’inspecteur, rendant le jeu adaptable et dynamique.

Conclusion

En maîtrisant le système de coordonnées cartésien dans Unity, vous pouvez créer des environnements de jeu interactifs et dynamiques. Comment allez-vous appliquer ces concepts dans votre prochain projet Unity?