ROBLOX Faire bouger des objets

0 Partages

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 gauche
RoueAvantDroite = 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 à gauche
0 → tout droit
1 → 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 !!!!!!!!!!!!!

Partagez

0 Partages

PARTIE 01 : Lancer des balles

LinearVelocity

VectorForce

AssemblyLinearVelocity

Crée une balle à lancer

Programme un lancer avec linearVelocity :

🔹 Il sert à :

Programme un lancer avec vectorForce:

Programme un lancer avec AssemblyLinearVelocity

PARTIE 02 : Une barrière

Construction d’une barrière

Automatisation d’ouverture de la barrière

PARTIE 03 : ROULER EN VOITURE

Rappel : c’est quoi un HingeConstraint ?

Quand ActuatorType = Servo

🔩 3️⃣ Les propriétés importantes

📘 Le code

🧠 Maintenant, la partie importante :

1️⃣ seat:GetPropertyChangedSignal("Steer")

2️⃣ seat.Steer

3️⃣ steerAngle * seat.Steer

4️⃣ Application de l’angle

🧠 En résumé

🎯 Ce que fait le script

Qu’est-ce qu’un HingeConstraint ?

Quand ActuatorType = Motor

🧩 Étape 1 : on récupère les objets importants

🧩 Étape 2 : les réglages de base

🧩 Étape 3 : détecter quand le joueur accélère ou recule

🧩 Étape 4 : faire tourner les roues

🌀 Explication :

🧠 En résumé

🚗💨 En image (imagine) :

Rappel : c’est quoi un `HingeConstraint` ?

Quand `ActuatorType = Servo`

1️⃣ `seat:GetPropertyChangedSignal("Steer")`

2️⃣ `seat.Steer`

3️⃣ `steerAngle * seat.Steer`

Quand `ActuatorType` = Motor