PARTIE 01 : Lancer des balles
LinearVelocity, VectorForce et AssemblyLinearVelocity — servent tous à faire bouger des objets dans Roblox,
mais ils ne fonctionnent pas du tout de la même manière.
LinearVelocity
Ce que ça fait :
➡️ Fait bouger un objet à une vitesse constante dans une direction.
➡️ Roblox s’occupe automatiquement de calculer la force nécessaire pour maintenir cette vitesse.
C’est parfait pour :
- Faire voler ou propulser un objet
- Tirer des projectiles
- Donner un mouvement stable et constant
VectorForce
Ce que ça fait :
➡️ Applique une force brute (comme une poussée de moteur ou la gravité).
➡️ La vitesse dépend de la masse de l’objet et des forces qui s’opposent.
L’objet est poussé mais ralentit ou accélère selon sa masse, sa friction, etc.
C’est parfait pour :
- Simuler une propulsion physique réaliste
- Faire un jetpack, un vent, une poussée de moteur
- Ajouter une force continue (comme la gravité personnalisée)
AssemblyLinearVelocity
Ce que ça fait :
➡️ Change directement la vitesse actuelle du corps rigide complet.
➡️ C’est comme “modifier” la vitesse sans appliquer de vraie force.
L’objet prend instantanément cette vitesse.
Pas de physique calculée, pas de force — juste une vitesse imposée.
📍 C’est parfait pour :
- Faire bouger instantanément un objet
- Lancer un objet d’un coup
- Remettre à zéro sa vitesse facilement
Crée une balle à lancer
Crée une balle à partir de l’onglet Modèle puis Pièce et Sphère :
Renomme le part en « Balle » :
Change les propriétés suivantes du part Balle :
Déplace le part Balle sous ServerStorage :
ServerStorage permet de stocker des objets secrets ou internes au serveur (comme des scripts, modèles ou outils que les joueurs ne doivent pas voir directement). Donc la conséquence immédiate du déplacement de la balle : celle-ci n’est plus visible dans ton jeu, ni dans ton workspace.
Programme un lancer avec linearVelocity :
VectorVelocity fait bouger ta balle à une vitesse constante dans la direction du regard du joueur.
La balle rouge bouge sans la contrainte de la physique du jeu, notamment de la gravité.
Crée un script sous ServerScriptService et lance les balles devant le joueur :
-- je récupère la balle dans le ServerStorage
local ss = game:GetService("ServerStorage")
local balle= ss:WaitForChild("Balle")
-- je récupère la liste des jueurs
local players = game:GetService("Players")
-- je lance la blle avec linearVelocity
local function linearVelocityBall(player)
-- je récupère le corps du joueur
local char = player.Character or
player.CharacterAdded:Wait()
local hrp = char:WaitForChild("HumanoidRootPart")
-- Je génère une copie de la balle dans le workspace
local ball = balle:Clone()
ball.BrickColor = BrickColor.Red()
ball.Parent = workspace
ball.CFrame = hrp.CFrame * CFrame.new(0, 2, -2)
-- J'applique à la balle une force constante
local lv = Instance.new("LinearVelocity")
lv.MaxForce = math.huge
lv.VelocityConstraintMode =
Enum.VelocityConstraintMode.Vector
lv.VectorVelocity = hrp.CFrame.LookVector * 5
lv.Parent = ball
-- J'attache cette force à la balle
local attchment = Instance.new("Attachment")
attchment.Parent = ball
lv.Attachment0 = attchment
-- Je détruis la balle au bout de 5 secondes
game.Debris:AddItem(ball, 5)
end
-- Le joueur se connecte
players.PlayerAdded:Connect(function(player)
player.CharacterAdded:Connect(function()
for i = 1, 5 do
task.wait(1)
linearVelocityBall(player)
end
end)
end)
VectorVelocity fait bouger ta balle à une vitesse constante dans la direction du regard du joueur.
L’objet bouge sans que tu aies besoin de gérer la physique.
Ton script instancie un Attachment. Un Attachment est un point de repère invisible dans une pièce (Part, MeshPart, etc.)
C’est comme une punaise virtuelle que tu peux placer n’importe où dans la pièce.
🔹 Il sert à :
- indiquer un point précis où appliquer une force, un effet, ou une jointure,
- ou relier deux objets ensemble (
LinearVelocity,VectorForce).
L’objet bouge sans que tu aies besoin de gérer la physique.
Programme un lancer avec vectorForce:
Applique une force brute (comme une poussée de moteur ).
La vitesse dépend de la masse de l’objet et des forces qui s’opposent. La belle bleue est poussée mais ralentit ou accélère selon sa masse, sa friction et subit la gravité.
Modifie ton script pour le lancer avec une balle bleue :
local function vectorForceBall(player)
-- je récupère le corps du joueur
local char = player.Character or
player.CharacterAdded:Wait()
local hrp = char:WaitForChild("HumanoidRootPart")
-- Je génère une copie de la balle dans le workspace
local ball = balle:Clone()
ball.BrickColor = BrickColor.Blue()
ball.Parent = workspace
ball.CFrame = hrp.CFrame * CFrame.new(0, 2, -2)
-- J'applique à la balle un VectorForce
local vf = Instance.new("VectorForce")
vf.RelativeTo = Enum.ActuatorRelativeTo.World
vf.ApplyAtCenterOfMass = true
vf.Force = hrp.CFrame.LookVector * ball:GetMass() * 5
vf.Parent = ball
-- J'attache cette force à la balle
local attchment = Instance.new("Attachment")
attchment.Parent = ball
vf.Attachment0 = attchment
-- Je détruis la balle au bout de 5 secondes
game.Debris:AddItem(ball, 5)
end
players.PlayerAdded:Connect(function(player)
player.CharacterAdded:Connect(function()
for i = 1, 5 do
task.wait(1)
linearVelocityBall(player)
task.wait(1)
vectorForceBall(player)
end
end)
end)
Programme un lancer avec AssemblyLinearVelocity
La balle verte prend instantanément la vitesse appliquée.
Pas de physique calculée, pas de force — juste une vitesse imposée
Modifie ton script :
local function assemblyLinearVelocityBall(player)
-- je récupère le corps du joueur
local char = player.Character or
player.CharacterAdded:Wait()
local hrp = char:WaitForChild("HumanoidRootPart")
-- Je génère une copie de la balle dans le workspace
local ball = balle:Clone()
ball.BrickColor = BrickColor.Green()
ball.Parent = workspace
ball.CFrame = hrp.CFrame * CFrame.new(0, 2, -2)
-- J'applique une vitesse à l'objet
ball.AssemblyLinearVelocity = hrp.CFrame.LookVector *
ball:GetMass() * 5
-- Je détruis la balle au bout de 5 secondes
game.Debris:AddItem(ball, 5)
end
players.PlayerAdded:Connect(function(player)
player.CharacterAdded:Connect(function()
task.wait(5)
for i = 1, 5 do
task.wait(1)
linearVelocityBall(player)
task.wait(1)
vectorForceBall(player)
task.wait(1)
assemblyLinearVelocityBall(player)
end
end)
end)PARTIE 02 : Une barrière
Avant de commencer à construire ta barrière, choisis ces options pour ton projet :
Construction d’une barrière
Puis commence à construire ta barrière en créant un bloc :
Renomme le part en Socle :
Modifie les propriétés suivantes :
Puis un deuxième part pour la barrière :
Renomme le part en Barriere :
Avec les propriétés suivantes :
Sous ton workspace crée un Model que tu renommes en Barriere puis range les deux parts précédent sous ce Model :
Installe une charnière pour le mécanisme d’ouverture de la porte :
Avec un premier point d’appui sur la barrière et un deuxième sur le socle :
Tu dois obtenir ce résultat dans explorer :
- deux points d’attachement un sur le socle et un autre sur la barrière,
- une charnière HingeConstraint sur la barrière.
Tu peux régler plus précisément le point d’attachement, en sélectionnant celui-ci dans explorer et en utilisant l’outil déplacer :
Modifie les propriétés du HingeConstraint :
Si tu lances ton jeu, tu obtiens ce résultat :
Si tu changes la propriété TargetAngle :
En lançant ton jeu, tu obtiens le résultat suivant :
Automatisation d’ouverture de la barrière
Rajoute une boîte de collision transparente autour de la barrière afin d’automatiser son ouverture :
N’oublie pas d’enlever le CanCollide de la boîte de collision.
Puis crée un script dans ton Model Barriere :
Puis saisie ce script pour ouvrir et fermer automatiquement ta barrière :
-- Récupération de la barrière
local barriere = script.Parent.Barriere
-- Récupération de la boîte de collision
local boiteCollision = script.Parent.BoiteCollision
-- Quand la boîte de collision touche un un personnage
boiteCollision.Touched:Connect(function(hit)
-- On récupère le modèle parent de la pièce touchée
local character = hit.Parent
-- On vérifie si ce modèle a un "Humanoid" (seuls les personnages en ont un)
local humanoid = character:FindFirstChild("Humanoid")
if humanoid then
-- Ouverture de la barrière
barriere.HingeConstraint.TargetAngle = 90
end
end)
-- Quand la boîte de collision ne touche plus de personnage
boiteCollision.TouchEnded:Connect(function(hit)
-- On récupère le modèle parent de la pièce touchée
local character = hit.Parent
-- On vérifie si ce modèle a un "Humanoid" (seuls les personnages en ont un)
local humanoid = character:FindFirstChild("Humanoid")
if humanoid then
-- Fermeture de la barrière
barriere.HingeConstraint.TargetAngle = 0
end
end)
-- Fermeture de la barrière au début
barriere.HingeConstraint.TargetAngle = 0
Lance ton jeu pour tester ta barrière automatique :
PARTIE 03 : ROULER EN VOITURE
Choisis ces paramètres pour la construction de ton véhicule :
- Joindre les surfaces
- 1 pour l’incrémentation pour dimensionner les objets
Choix d’un Bloc pour le châssis de la voiture
Redimensionne le châssis de ta voiture et renomme le part en « Chassis« :
Crée un nouveau bloc pour créer les moyeux des roues de la voiture :
Choisis sa demension :
Duplique en quatre blocs :
Colle les blocs sur le châssis :
Sur les quatre côtés du châssis :
Duplique deux nouveaux blocs pour la direction, modifie la couleur :
Décoche la propriété CanCollide pour ces blocs :
Sous worksapace crée cette structure et range tous les parts de ta voiture :
Par le clic droit de la souris, demande le menu suivant :
Insére l’objet VehicleSeat :
Installe cet objet sur le châssis, cet objet représente le siège du conducteur :
Déplace cet objet sous l’arborescence de ta voiture :
Lance le jeu pour venir t’assoir sur le siège de ton véhicule :
Insère des contraintes entre les pièces de ton véhicule pour transmettre la direction :
Vision de la transmission de direction à droite
Vision de la transmission de direction à gauche
Tu dois obtenir ce résultat dans ton explorer :
Sélectionne les HingeConstraint de tes deux roues de l’avant pour modifier les propriétés suivantes :
Rappel : c’est quoi un HingeConstraint ?
Un HingeConstraint = une charnière virtuelle.
Il permet à un objet de tourner autour d’un axe (comme une porte, une roue, ou un bras robotique).
Mais quand on ajoute un moteur dessus, il peut :
- tourner jusqu’à un certain angle →
Servo
Quand ActuatorType = Servo
Le Servo agit comme un moteur intelligent :
il regarde la position actuelle de la pièce, puis la fait tourner jusqu’à atteindre l’angle qu’on lui demande.
👉 On lui donne une cible (TargetAngle), et il s’arrête tout seul quand il y arrive.
🔩 3️⃣ Les propriétés importantes
| Propriété | Rôle |
|---|---|
TargetAngle | l’angle à atteindre (en degrés) |
ServoMaxTorque | la force que le moteur peut exercer pour y arriver |
AngularSpeed | vitesse à laquelle il tourne pour atteindre l’angle |
ActuatorType | doit être mis sur Enum.ActuatorType.Servo |
Tu dois obtenir la visualisation du mécanisme de la direction de tes deux roues :
Renomme les parts des roues avant droite et gauche ayant un HingeConstraint en « Direction » :
Rend invisible les deux parts des deux roues avant :
Rajoute un script sous le modèle de ta voiture :
local seat = script.Parent.VehicleSeat
local roueAvantGauche = script.Parent.RoueAvantGauche
local roueAvantDroite = script.Parent.RoueAvantDroite
local steerAngle = 30
seat:GetPropertyChangedSignal("Steer"):Connect(function()
print("Steer =", seat.Steer)
roueAvantGauche.Direction.HingeConstraint.TargetAngle =
steerAngle * seat.Steer
roueAvantDroite.Direction.HingeConstraint.TargetAngle =
steerAngle * seat.Steer
end)Ce script fait tourner les roues avant d’une voiture quand le joueur tourne à gauche ou à droite avec le clavier (A / D ou Q / D selon ton clavier).
📘 Le code
local seat = script.Parent.VehicleSeat
➡️ On récupère le siège de conduite de la voiture (VehicleSeat).
C’est lui qui détecte quand le joueur tourne à gauche ou à droite.
local roueAvantGauche = script.Parent.RoueAvantGauche
local roueAvantDroite = script.Parent.RoueAvantDroite
➡️ On récupère les deux roues avant du véhicule, pour pouvoir les faire pivoter.
RoueAvantGauche= la roue de gaucheRoueAvantDroite= la roue de droite
Ces roues ont chacune une charnière (HingeConstraint) qui permet de les faire tourner.
local steerAngle = 30
➡️ C’est l’angle maximum de rotation des roues (en degrés).
Ici : les roues peuvent tourner jusqu’à 30° vers la gauche ou la droite.
🧠 Maintenant, la partie importante :
seat:GetPropertyChangedSignal("Steer"):Connect(function()
print("Steer =", seat.Steer)
roueAvantGauche.Direction.HingeConstraint.TargetAngle = steerAngle * seat.Steer
roueavantDroite.Direction.HingeConstraint.TargetAngle = steerAngle * seat.Steer
end)
1️⃣ seat:GetPropertyChangedSignal("Steer")
➡️ écoute la propriété Steer du siège (objet noir que l’on a inséré au dessus du véhicule).
Cette valeur change quand le joueur appuie sur :
- Q → tourner à gauche
- D → tourner à droite
- Relâcher les touches → revenir droit
2️⃣ seat.Steer
Cette valeur peut être :
-1→ le joueur tourne à gauche0→ tout droit1→ le joueur tourne à droite
3️⃣ steerAngle * seat.Steer
➡️ C’est un calcul pour savoir de combien tourner les roues :
| Steer | Calcul | Résultat |
|---|---|---|
1 | 30 × 1 | roues tournées à +30° (droite) |
0 | 30 × 0 | roues droites |
-1 | 30 × -1 | roues tournées à -30° (gauche) |
4️⃣ Application de l’angle
roueAvantGauche.Direction.HingeConstraint.TargetAngle = steerAngle * seat.Steer
roueAvantDroite.Direction.HingeConstraint.TargetAngle = steerAngle * seat.Steer
➡️ Le script change l’angle cible (TargetAngle) de la charnière des roues avant.
👉 Résultat : quand le joueur tourne, les roues s’inclinent à gauche ou à droite comme une vraie voiture 🚘
🧠 En résumé
| Élément | Rôle |
|---|---|
VehicleSeat | détecte les touches du joueur |
Steer | indique la direction du volant (-1, 0, 1) |
HingeConstraint | permet de faire tourner les roues |
TargetAngle | angle que doit atteindre la roue |
steerAngle | limite maximale de rotation (ici 30°) |
🎯 Ce que fait le script
➡️ À chaque fois que le joueur tourne :
- Le siège envoie une valeur (
Steer) - Le script multiplie cette valeur par 30
- Les roues avant tournent de cet angle
💬 En bref :
Quand tu tournes le volant, les roues tournent dans la même direction, comme une vraie voiture
Lance ton jeu pour vérifier le bon fonctionnement de ta direction :
Maintenant nous allons installer les roues.
Crée une roue centrée sur la direction de ta voiture, surélève ton châssis de voiture :
Renomme le part en « roue » :
Duplique en 4 roues :
Place tes 4 roues bien centrées :
Range tes roues dans l’arborescence de ta voiture :
Pour chaque roue positionne une charnière à partir du centre de la roue sur le centre de la direction :
Sélectionne les quatre HingeConstraint des quatre roues et applique ces propriétés :
Qu’est-ce qu’un HingeConstraint ?
Un HingeConstraint (en français : contrainte de charnière) relie deux objets pour qu’ils puissent tourner autour d’un axe, comme une porte sur ses gonds ou une roue sur son axe.
Sans moteur, il laisse juste la pièce tourner librement.
Avec un Motor, il fait tourner activement la pièce tout seul.
Quand ActuatorType = Motor
Alors le HingeConstraint se comporte comme un moteur qui fait tourner la pièce en continu 🌀
Les propriétés les plus importantes sont :
| Propriété | Rôle |
|---|---|
| AngularVelocity | vitesse de rotation de la pièce (en radians/s) |
| MotorMaxTorque | force maximum du moteur (plus elle est grande, plus il peut pousser) |
| AngularResponsiveness | vitesse à laquelle le moteur s’adapte aux changements (réactivité) |
Vérifie le sens de rotation :
Tu remarques que le sens gauche est inverse de celui du sens droit.
Vérifie le bon fonctionnement de la direction :
Modifie ton script :
local seat = script.Parent.VehicleSeat
local roueAvantGauche = script.Parent.RoueAvantGauche
local roueAvantDroite = script.Parent.RoueAvantDroite
local roueArriereGauche = script.Parent.RoueArriereGauche
local roueArriereDroite = script.Parent.RoueArriereDroite
local steerAngle = 30
local speed = 60
seat:GetPropertyChangedSignal("Steer"):Connect(function()
print("Steer =", seat.Steer)
roueAvantGauche.Direction.HingeConstraint.TargetAngle =
steerAngle * seat.Steer
roueAvantDroite.Direction.HingeConstraint.TargetAngle =
steerAngle * seat.Steer
end)
seat:GetPropertyChangedSignal("Throttle"):Connect(function()
print("Throttle =", seat.Throttle)
roueAvantGauche.Roue.HingeConstraint.AngularVelocity =
speed * seat.Throttle
roueAvantDroite.Roue.HingeConstraint.AngularVelocity =
speed * -seat.Throttle
roueArriereGauche.Roue.HingeConstraint.AngularVelocity =
speed * seat.Throttle
roueArriereDroite.Roue.HingeConstraint.AngularVelocity =
speed * -seat.Throttle
end)
Ce script permet de faire tourner les roues d’une voiture quand le joueur accélère ou recule avec le clavier (les touches Z / S ou flèche haut / flèche bas).
🧩 Étape 1 : on récupère les objets importants
local seat = script.Parent.VehicleSeat
➡️ On récupère le siège de conduite de la voiture.
C’est lui qui détecte quand le joueur appuie pour avancer ou reculer.
local roueAvantGauche = script.Parent.RoueAvantGauche
local roueAvantDroite = script.Parent.RoueAvantDroite
local roueArriereGauche = script.Parent.RoueArriereGauche
local roueArriereDroite = script.Parent.RoueArriereDroite
➡️ On récupère les 4 roues du véhicule :
- 2 à l’avant
- 2 à l’arrière
Chaque roue contient un objet appelé HingeConstraint, une charnière qui permet à la roue de tourner sur elle-même.
🧩 Étape 2 : les réglages de base
local steerAngle = 30
local speed = 60
steerAngle: angle pour tourner (pas utilisé ici, mais utile si on veut tourner les roues plus tard).speed: vitesse de rotation des roues (plus la valeur est grande, plus la voiture va vite 🚀).
🧩 Étape 3 : détecter quand le joueur accélère ou recule
seat:GetPropertyChangedSignal("Throttle"):Connect(function()
➡️ Cette ligne écoute la propriété « Throttle » du siège.
Elle change quand le joueur appuie sur :
- Z / flèche haut →
Throttle = 1→ avancer 🏎️ - S / flèche bas →
Throttle = -1→ reculer 🚙 - Rien →
Throttle = 0→ arrêt ⛔
🧩 Étape 4 : faire tourner les roues
roueAvantGauche.Roue.HingeConstraint.AngularVelocity = speed * seat.Throttle
roueAvantDroite.Roue.HingeConstraint.AngularVelocity = speed * -seat.Throttle
🌀 Explication :
Chaque roue tourne grâce à sa vitesse angulaire (AngularVelocity), c’est-à-dire la vitesse à laquelle elle tourne autour de son axe.
Mais pourquoi une roue est multipliée par -seat.Throttle ❓
👉 Parce que les roues droite et gauche sont dans des sens opposés (comme une vraie voiture).
Si elles tournaient dans le même sens, la voiture glisserait sur place au lieu d’avancer 😅.
Donc :
- les roues de gauche tournent dans un sens,
- celles de droite tournent dans le sens inverse,
➡️ ce qui fait avancer la voiture dans la bonne direction 🚗💨
roueArriereGauche.Roue.HingeConstraint.AngularVelocity = speed * seat.Throttle
roueArriereDroite.Roue.HingeConstraint.AngularVelocity = speed * -seat.Throttle
Même principe pour les roues arrière : elles tournent aussi pour propulser la voiture.
🧠 En résumé
| Élément | Rôle |
|---|---|
VehicleSeat | détecte si le joueur accélère ou recule |
Throttle | -1 (reculer), 0 (ne bouge pas), 1 (avancer) |
HingeConstraint | fait tourner la roue |
AngularVelocity | vitesse de rotation de la roue |
speed | définit la vitesse du véhicule |
signe négatif - | pour que les roues tournent dans le bon sens |
🚗💨 En image (imagine) :
| Touche | Throttle | Effet |
|---|---|---|
| Z / ↑ | 1 | roues tournent, voiture avance |
| S / ↓ | -1 | roues tournent en sens inverse, voiture recule |
| (rien) | 0 | roues s’arrêtent |
Tu peux rouler avec ta voiture !!!!!!!!!!!!!
