Nous avons vu précédemment qu'il était possible de déplacer un objet en modifiant sa position via le composant Transform. Cette fois-ci, nous allons utiliser les propriétés du moteur physique pour déplacer un objet.
Le principe
Nous allons utiliser le composant Rigidbody pour déplacer notre objet. Lorsque vous obtenez une référence à ce composant, vous accédez à de nombreuses méthodes qui y sont liées. Vous pouvez déplacer votre objet de manière classique, mais aussi appliquer des impulsions, un peu comme si vous frappiez une balle de billard avec un bâton.
Avantages de Rigidbody par rapport à Transform
L'avantage de déplacer un objet avec Rigidbody est d'obtenir des résultats plus réalistes, notamment un meilleur calcul des collisions. Par exemple, lorsque nous modifions directement la position d'un objet via le composant Transform, cela revient à "téléporter" l'objet, ce qui peut entraîner des chevauchements avec d'autres objets. De plus, si vous souhaitez que l'objet rebondisse après une collision, comme une balle frappant un mur, cela ne sera pas possible en modifiant directement la position avec Transform. En revanche, cela devient possible avec Rigidbody.
Rigidbody est également plus pratique pour gérer des mouvements comme les sauts. En effet, avec un Rigidbody, vous pouvez appliquer une impulsion pour propulser l'objet dans les airs, contrairement à l'utilisation de Transform où vous seriez obligé de créer une méthode complexe pour calculés la positions du joueur pendant un saut.
Préparation
Pour utiliser le moteur physique, vous devez vous assurer que votre sphère possède le composant Rigidbody ainsi qu'un composant de collision.
Enfin, nous coderons principalement dans la méthode FixedUpdate, car nous devons être synchronisée avec le moteur physique.
Obtenir une référence vers le composant
Pour commencer, nous devons obtenir une référence au composant Rigidbody afin de pouvoir utiliser ses méthodes. Voici un exemple de code :
using UnityEngine;
public class Move : MonoBehaviour
{
private Rigidbody rb;
void Start()
{
rb = GetComponent<Rigidbody>();
}
void FixedUpdate()
{
}
}
Notez la ligne suivante :
rb = GetComponent<Rigidbody>();
Cette ligne signifie que nous souhaitons obtenir le composant Rigidbody de l'objet auquel ce script est attaché. Cela équivaut à utiliser la ligne suivante :
rb = gameObject.GetComponent<Rigidbody>();
Il s'agit simplement d'un raccourci. Les deux approches sont identiques, et c'est surtout une question de préférence. Dans les chapitres précédents, j'ai utilisé gameObject.GetComponent... principalement parce que certains développeurs préfèrent cette forme explicite, surtout lorsqu'ils travaillent en équipe, car cela clarifie à quel objet appartient le composant. Mais vous êtes libre de choisir la forme qui vous convient. Pour le reste de ce cours, j'utiliserai la forme courte.
La méthode MovePosition
Nous allons créer une variable de type Vector3 pour déterminer la direction vers laquelle l'objet se déplacera. Déplacer un objet avec cette méthode est légèrement plus complexe que de modifier la propriété transform.position. Voici un exemple de code :
using UnityEngine;
public class Move : MonoBehaviour
{
private Rigidbody rb;
public Vector3 direction;
void Start()
{
rb = GetComponent();
}
void FixedUpdate()
{
rb.MovePosition(transform.position + direction);
}
}
La méthode MovePosition déplace le GameObject vers les coordonnées que vous lui spécifiez. Dans ce cas, nous ajoutons la valeur de notre Vector3 direction à la position actuelle de l'objet (obtenue via transform.position).
C'est très similaire à ce que nous faisons avec Transform. Cependant, cette fois, nous utilisons une méthode au lieu de modifier directement la propriété position. Cette méthode respecte la physique de notre objet tout en le dirigeant vers la nouvelle position.
Quand utiliser Rigidbody plutôt que Transform.position ?
Le choix d'utiliser Rigidbody ou Transform dépend de vos besoins spécifique. Toutefois, il est conseillé d'utiliser Rigidbody lorsque l'objet interagit avec le moteur physique, par exemple lors de collisions ou de l'application de la gravité lors d'un saut.
Une utilisation classique pourrait consister à utiliser Transform pour la caméra, et Rigidbody pour les personnages. Bien entendu, cela dépendra du type de projet sur lequel vous travaillez.
AddForce et autres méthodes
La méthode MovePosition n'est pas la seule disponible avec Rigidbody. Vous trouverez une liste complète des méthodes dans la documentation officielle. Dans ce chapitre, nous allons nous intéresser à la méthode AddForce.
Cette méthode applique une force à votre objet. Contrairement à MovePosition, elle ne déplace pas directement l'objet, mais modifie sa vitesse en fonction de la force appliquée.
Dans la vie réelle, cela pourrait être comparé à souffler sur une bille. Votre souffle applique une force à la bille, la déplaçant. Si la bille est déjà en mouvement, la direction de votre souffle déterminera si elle accélère. Cela est couramment utilisé dans les jeux de course pour simuler des accélérations et des effets d'inertie.
Si vous avez une base en mathématiques et en physique, ce concept ne devrait pas vous poser de problème, car c'est tout simplement la deuxième loi de Newton qui s'applique, soit la formule F = ma.
Exemple de saut avec AddForce
Voici un exemple de code pour faire "sauter" une sphère :
using UnityEngine;
public class Move : MonoBehaviour
{
private Rigidbody rb;
void Start()
{
rb = GetComponent();
rb.AddForce(new Vector3(0,1000,0));
}
}
Ici, la méthode AddForce applique une force sur l'axe Y pour propulser la sphère vers le haut. Nous avons choisi une valeur de 1000 pour la force, car elle sera appliquée uniquement sur une frame, donc une valeur plus élevée est nécessaire pour obtenir un résultat visible. Si vous souhaitez que l'objet se déplace plus lentement ou plus rapidement, vous devrez ajuster cette valeur en fonction du comportement souhaité.
Quelle force appliquer ?
Il n'y a pas de valeur magique pour faire un saut parfait. La force à appliquer dépend de plusieurs facteurs, comme la masse de l'objet dans le composant Rigidbody. Plus l'objet est lourd, plus la force nécessaire pour le déplacer sera élevée. Vous devrez donc expérimenter pour trouver la bonne valeur.
Utiliser le paramètre ForceMode avec AddForce
Lorsque vous appliquez une force avec AddForce, vous pouvez spécifier le mode dans lequel la force sera appliquée, grâce au paramètre ForceMode. Voici un exemple de code avec ForceMode.Impulse :
using UnityEngine;
public class Move : MonoBehaviour
{
private Rigidbody rb;
void Start()
{
rb = GetComponent();
rb.AddForce(new Vector3(0,10,0), ForceMode.Impulse);
}
}
Le paramètre ForceMode.Impulse signifie que la force sera appliquée instantanément, comme un coup de poing. Par défaut, AddForce utilise le mode Force, qui applique une force continue, proportionnelle à la masse de l'objet.
Résumé des différents modes de ForceMode :
- Force : Applique une force continue, proportionnelle à la masse de l'objet (mode par défaut).
- Acceleration : Applique une force continue, indépendante de la masse.
- Impulse : Applique une force instantanée.
- VelocityChange : Modifie instantanément la vitesse de l'objet sans tenir compte de sa masse.
Nous ne sommes pas dans un cours de physique, donc je ne vais pas vous expliquer la différence entre la vitesse et l'accélération.
Mais en général, on utilise Impulse pour des sauts, Force ou Acceleration pour des déplacements avec des vitesses qui varient au fil du temps, et VelocityChange pour des changements de direction rapides ou des mouvements immédiats.
Déplacer la sphère avec les touches du clavier
Avec ce que vous avez appris de ce chapitre, il vous est possible de déplacer la sphère en détectant les touches du clavier. Voici un exemple de code pour déplacer l'objet avec les touches W, A, S, et D:
using UnityEngine;
public class Move : MonoBehaviour
{
private Rigidbody rb;
void Start()
{
rb = GetComponent<RigidBoby>();
}
private void FixedUpdate()
{
if (Input.GetKey(KeyCode.W))
{
rb.AddForce(new Vector3(0,0,5));
}
if (Input.GetKey(KeyCode.S))
{
rb.AddForce(new Vector3(0,0,-5));
}
if (Input.GetKey(KeyCode.A))
{
rb.AddForce(new Vector3(-5,0,0));
}
if (Input.GetKey(KeyCode.D))
{
rb.AddForce(new Vector3(5,0,0));
}
}
}
Ce code permet de déplacer votre sphère en appuyant sur les touches W, A, S, et D.
Si vous avez des difficultés à comprendre les directions des axes, consultez le gizmo des axes dans la fenêtre "Scène" de Unity pour identifier les axes X, Y, et Z. Cela devrait vous aidez à déterminer qu'elle valeur ajouter à vos Vector3
Conclusion
Dans cette section, nous avons appris à déplacer un objet en utilisant les méthodes du composant Rigidbody. La prochaine étape de ce chapitre portera sur l'utilisation du nouveau système d'input. Rendez-vous donc à la prochaine page pour la suite du cours !
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. - - -
