Déplacer une Part avec la Physique Roblox

Apprendre à déplacer une Part en utilisant la physique de Roblox avec les propriétés AssemblyLinearVelocity et AssemblyAngularVelocity. Contrairement au tutoriel précédent où on modifiait directement la Position et l’Orientation, ici on utilise les vitesse linéaire et angulaire pour un mouvement plus réaliste et dynamique.

Introduction : Pourquoi utiliser la physique ?

Dans Roblox, les objets peuvent bouger naturellement grâce à la physique (gravité, collisions, etc.). En utilisant AssemblyLinearVelocity et AssemblyAngularVelocity, on peut :

• Simuler des mouvements réalistes (ex: une balle qui roule, un objet qui glisse).
• Créer des effets dynamiques (ex: une voiture qui accélère, un objet qui tourne).
• Contrôler la vitesse et la rotation de manière fluide.

Dans ce tutoriel, on va lancer une Part dans différentes directions et la faire tourner en utilisant la physique.

Préparation dans Roblox Studio

Pour tester ce script, suis ces étapes :

1. Créer un dossier pour les mouvements :
   • Dans Workspace, crée un dossier nommé Folder.
2. Ajouter une Part :
   • Ajoute une Part dans Folder.
   • Nomme-la Part (ou modifie le nom dans le script).
3. Configurer la Part :
   • Assure-toi que la Part a une taille visible (ex: Size = Vector3.new(4, 4, 4)).
   • Place-la à une position centrale (ex: Position = Vector3.new(0, 10, 0)).
4. Ajouter le script :
   • Crée un Script dans ServerScriptService et copie-y le code fourni.
5. Lancer le jeu :
   • Observe la Part :
     • Après 5 secondes, elle commence à se déplacer vers l’avant (Z).
     • Elle recule, tourne, monte, et se déplace en diagonale.

Voici le script commenté :

-- Récupérer le dossier "Folder" dans le Workspace
local folder = workspace:WaitForChild("Folder")

-- Récupérer la Part à déplacer dans le dossier
local movingPart = folder:WaitForChild("Part")

-- Désactiver l'ancrage pour permettre à la Part de bouger avec la physique
movingPart.Anchored = false

-- Attendre 5 secondes avant de commencer les mouvements
task.wait(5)

-- Appliquer une vitesse linéaire de 100 unités/seconde vers l'avant (axe Z)
movingPart.AssemblyLinearVelocity = Vector3.new(0, 0, 100)
task.wait(1)  -- Attendre 1 seconde

-- Appliquer une vitesse linéaire de -100 unités/seconde vers l'arrière (axe Z)
movingPart.AssemblyLinearVelocity = Vector3.new(0, 0, -100)
task.wait(1)

-- Appliquer une vitesse angulaire de 10 degrés/seconde autour de l'axe Y (rotation droite/gauche)
movingPart.AssemblyAngularVelocity = Vector3.new(0, 10, 0)
task.wait(1)

-- Appliquer une vitesse angulaire de -10 degrés/seconde autour de l'axe Y (rotation gauche/droite)
movingPart.AssemblyAngularVelocity = Vector3.new(0, -10, 0)
task.wait(1)

-- Appliquer une vitesse linéaire de 100 unités/seconde vers le haut (axe Y)
movingPart.AssemblyLinearVelocity = Vector3.new(0, 100, 0)
task.wait(1)

-- Appliquer une vitesse linéaire de 100 unités/seconde en diagonale (axe Y et Z)
movingPart.AssemblyLinearVelocity = Vector3.new(0, 100, 100)
task.wait(1)

-- Appliquer une vitesse angulaire de 10 degrés/seconde autour de l'axe Y (rotation)
movingPart.AssemblyAngularVelocity = Vector3.new(0, 10, 0)

Explications Détaillées

1. Désactiver l’ancrage (Anchored = false)

movingPart.Anchored = false

• Anchored = false :
  • Permet à la Part de bouger librement sous l’effet de la physique (gravité, collisions, vitesses appliquées).
  • Sans cela, la Part resterait fixe et les vitesses n’auraient aucun effet.
• Pourquoi est-ce important ?
  • Si Anchored = true, la Part ne pourrait pas bouger, même avec AssemblyLinearVelocity ou AssemblyAngularVelocity.

2. Déplacer une Part avec AssemblyLinearVelocity

movingPart.AssemblyLinearVelocity = Vector3.new(0, 0, 100)

• AssemblyLinearVelocity :
  • Définit la vitesse linéaire de la Part (en unités par seconde).
  • La Part se déplace en ligne droite dans la direction spécifiée.
• Vector3.new(X, Y, Z) :
  • Définit la vitesse selon les axes X, Y et Z.
  • Exemple : Vector3.new(0, 0, 100) signifie 100 unités/seconde vers l’avant (axe Z).
• Effet de la physique :
  • La Part accélère dans la direction donnée jusqu’à ce qu’une autre force (ex: collision, gravité) ne l’arrête.
  • Si tu veux un mouvement constant, il faut réappliquer la vitesse régulièrement.

Exemples de vitesses linéaires :

Code	Mouvement
Vector3.new(100, 0, 0)	Déplacement vers la droite (axe X).
Vector3.new(-100, 0, 0)	Déplacement vers la gauche (axe X).
Vector3.new(0, 100, 0)	Déplacement vers le haut (axe Y).
Vector3.new(0, -100, 0)	Déplacement vers le bas (axe Y).
Vector3.new(0, 0, 100)	Déplacement vers l’avant (axe Z).
Vector3.new(0, 0, -100)	Déplacement vers l’arrière (axe Z).
Vector3.new(100, 100, 0)	Déplacement en diagonale (X et Y).

3. Faire tourner une Part avec AssemblyAngularVelocity

movingPart.AssemblyAngularVelocity = Vector3.new(0, 10, 0)

• AssemblyAngularVelocity :
  • Définit la vitesse de rotation de la Part (en degrés par seconde).
  • La Part tourne autour des axes spécifiés.
• Vector3.new(X, Y, Z) :
  • Définit la rotation autour des axes X, Y et Z (en degrés par seconde).
  • Exemple : Vector3.new(0, 10, 0) signifie 10 degrés/seconde autour de l’axe Y (rotation droite/gauche).

Exemples de vitesses angulaires :

Code	Rotation
Vector3.new(10, 0, 0)	Rotation vers l’avant (axe X).
Vector3.new(-10, 0, 0)	Rotation vers l’arrière (axe X).
Vector3.new(0, 10, 0)	Rotation vers la droite (axe Y).
Vector3.new(0, -10, 0)	Rotation vers la gauche (axe Y).
Vector3.new(0, 0, 10)	Rotation dans le sens horaire (axe Z).
Vector3.new(0, 0, -10)	Rotation dans le sens anti-horaire (axe Z).

4. Combiner vitesse linéaire et angulaire

Dans le script, on utilise AssemblyLinearVelocity et AssemblyAngularVelocity pour :

• Déplacer la Part dans une direction.
• La faire tourner en même temps.

Exemple :

luaCopier

-- Déplacement en diagonale + rotation
movingPart.AssemblyLinearVelocity = Vector3.new(0, 100, 100)  -- Diagonale (Y et Z)
movingPart.AssemblyAngularVelocity = Vector3.new(0, 10, 0)   -- Rotation autour de Y

• La Part monte et avance tout en tournant sur elle-même.

QCM : Teste ta compréhension !

Sur la physique et l’ancrage :

1. Pourquoi utilise-t-on Anchored = false ?
   • a) Pour permettre à la Part de bouger avec la physique.
   • b) Pour empêcher la Part de bouger.
   • c) Pour rendre la Part invisible.

2. Que se passe-t-il si on oublie de mettre Anchored = false ?
   • a) La Part ne bougera pas, même avec AssemblyLinearVelocity.
   • b) La Part disparaîtra.
   • c) La Part changera de couleur.

Sur AssemblyLinearVelocity :

3. Que fait movingPart.AssemblyLinearVelocity = Vector3.new(0, 0, 100) ?
   • a) Déplace la Part de 100 unités/seconde vers l’avant (axe Z).
   • b) Déplace la Part de 100 unités/seconde vers le haut (axe Y).
   • c) Fait tourner la Part de 100 degrés/seconde.

4. Que fait Vector3.new(0, 100, 100) pour AssemblyLinearVelocity ?
   • a) Déplace la Part de 100 unités/seconde vers le haut et l’avant (axes Y et Z).
   • b) Déplace la Part de 100 unités/seconde vers la droite (axe X).
   • c) Fait tourner la Part.

Sur AssemblyAngularVelocity :

5. Que fait movingPart.AssemblyAngularVelocity = Vector3.new(0, 10, 0) ?
   • a) Fait tourner la Part de 10 degrés/seconde autour de l’axe Y (droite/gauche).
   • b) Fait tourner la Part de 10 degrés/seconde autour de l’axe X (avant/arrière).
   • c) Fait tourner la Part de 10 degrés/seconde autour de l’axe Z.

6. Que fait Vector3.new(0, 0, 10) pour AssemblyAngularVelocity ?
   • a) Fait tourner la Part de 10 degrés/seconde autour de l’axe Z (sens horaire).
   • b) Fait tourner la Part de 10 degrés/seconde autour de l’axe X.
   • c) Déplace la Part vers l’avant.

Sur les délais :

7. À quoi sert task.wait(1) dans ce script ?
   • a) Attendre 1 seconde pour laisser le temps à la physique de s’appliquer.
   • b) Accélérer le script.
   • c) Supprimer la Part.

8. Que se passe-t-il si on supprime tous les task.wait() ?
   • a) Les mouvements seront trop rapides et la Part aura un comportement imprévisible.
   • b) La Part ne bougera pas.
   • c) La Part changera de couleur.

Comparaison avec le Tuto : https://123codage.com/deplacer-une-part/

Méthode	Position / Orientation	AssemblyLinearVelocity / AssemblyAngularVelocity
Type de mouvement	Déplacement instantané (téléportation).	Déplacement progressif et réaliste (physique).
Effet sur la Part	La Part se téléporte directement à la nouvelle position.	La Part accélère et se déplace avec la physique.
Anchored	Doit être true (sinon la Part tombe).	Doit être false (pour permettre le mouvement physique).
Utilisation typique	Pour des mouvements précis et contrôlés (ex: téléportation).	Pour des mouvements naturels et dynamiques (ex: une balle qui roule).
Exemple	part.Position = Vector3.new(10, 0, 0)	part.AssemblyLinearVelocity = Vector3.new(10, 0, 0)