123Codage

Apprendre à afficher une bulle de chat au-dessus de la tête du joueur quand il touche une Part, avec un cooldown pour éviter le spam. Ce tutoriel explique :

1. Le service Chat et la fonction Chat:Chat().
2. Le tableau de cooldown (avec une nouveauté : ici la clé est le personnage, pas le joueur !).
3. La détection de collision avec Touched.
4. Au passage : corriger les noms de variables pour qu’ils soient en anglais (bonne pratique de programmeur !).

Introduction : À quoi sert ce script ?

Dans beaucoup de jeux, on veut féliciter le joueur quand il atteint une zone :

• « Bien joué ! » quand il touche la ligne d’arrivée.
• « Bravo ! » quand il trouve un secret.

Dans ce script, quand un joueur touche la Part (la ligne d’arrivée par exemple), une bulle verte s’affiche au-dessus de sa tête avec le message « bien jouer ».

Mais il y a un piège ! L’événement Touched se déclenche des dizaines de fois par seconde tant que le joueur touche la Part (une fois par partie du corps qui la touche : pied, jambe, bras…). Sans protection, on verrait des dizaines de bulles de chat en même temps ! C’est pour cela qu’on utilise un cooldown de 10 secondes.

Préparation dans Roblox Studio

1. Créer la Part :
   • Dans Workspace, ajoute une Part (ex: une ligne d’arrivée plate et large).
   • Positionne-la au sol dans ton niveau.
2. Ajouter le script DANS la Part (important !) :
   • Clic droit sur la Part → Insert Object → Script.
   • Le script devient enfant de la Part (c’est ce que script.Parent utilise).
3. Coller le code corrigé ci-dessus dans ce script.
4. Tester :
   • Lance le jeu et marche sur la Part :
     • Une bulle verte « Bien joué ! » apparaît au-dessus de ta tête.
   • Reste sur la Part ou re-touche-la : rien ne se passe pendant 10 secondes (le cooldown !).
   • Après 10 secondes, retouche-la : la bulle réapparaît !

Script commenté :

-- Récupérer la Part parente du script (la Part qui déclenche le message)
local wellDonePart = script.Parent

-- Récupérer le service Chat pour afficher des bulles de dialogue
local chatService = game:GetService("Chat")

-- Tableau de cooldown : [character] = true si le personnage est en cooldown
local cooldowns = {}

-- Détecter quand quelque chose touche la Part
wellDonePart.Touched:Connect(function(hit)
    -- Récupérer le personnage (Model) qui touche la Part
    local character = hit.Parent
    if not character then return end

    -- VÉRIFIER LE COOLDOWN : si ce personnage a déjà déclenché le message, on arrête
    if cooldowns[character] then return end

    -- Trouver la tête du personnage (là où la bulle de chat apparaît)
    local head = character:FindFirstChild("Head")
    if not head then return end

    -- Afficher une bulle de chat verte au-dessus de la tête avec le message
    chatService:Chat(head, "Bien joué !", Enum.ChatColor.Green)

    -- ACTIVER LE COOLDOWN pour ce personnage pendant 10 secondes
    cooldowns[character] = true
    task.wait(10)   -- Attendre 10 secondes
    cooldowns[character] = false  -- Réautoriser le message
end)

Explications Détaillées

1. script.Parent : le script est DANS la Part !

local wellDonePart = script.Parent

• Grande nouveauté par rapport aux tutoriels précédents : ici, le script est placé directement dans la Part (dans l’arborescence : Part > Script), pas dans ServerScriptService.
• script.Parent = l’objet parent du script, c’est-à-dire la Part elle-même !
• Avantage : le script fonctionne n’importe où où tu copies la Part. Tu peux dupliquer la Part, le script fonctionne tout seul dans chaque copie !

2. Le service Chat et la fonction Chat:Chat()

local chatService = game:GetService("Chat")
chatService:Chat(head, "Bien joué !", Enum.ChatColor.Green)

• game:GetService("Chat") : service Roblox qui gère les bulles de dialogue.
• chatService:Chat(...) : affiche une bulle de message au-dessus d’une partie du corps. Elle prend 3 paramètres :

Paramètre	Valeur ici	Rôle
1. La partie	head	Là où la bulle apparaît (au-dessus de la tête du personnage).
2. Le message	"Bien joué !"	Le texte affiché dans la bulle.
3. La couleur	Enum.ChatColor.Green	La bulle est verte (il existe aussi Blue, Red, White…).

• Différence avec le chat normal : Chat:Chat() ne fait qu’afficher une bulle au-dessus du personnage (comme quand un joueur parle dans le jeu). Ce n’est pas un message envoyé dans la fenêtre de chat.

3. Le tableau de cooldown… avec le PERSONNAGE comme clé !

local cooldowns = {}
if cooldowns[character] then return end
cooldowns[character] = true
task.wait(10)
cooldowns[character] = false

• Rappel des tutoriels précédents : un cooldown, c’est un temps d’attente pour éviter qu’une action se déclenche trop souvent.
• La nouveauté ici : la clé du tableau n’est ni player, ni userId, mais character (le Model du personnage) !
• Pourquoi character et pas player ?
  • On n’a pas besoin du joueur : on a déjà son personnage (hit.Parent), et c’est lui qu’on vérifie.
  • Ça économise une étape (pas besoin de Players:GetPlayerFromCharacter).
• ⚠️ Mais attention, il y a un piège avec ce choix ! Regarde la fin du cooldown :luaCopiercooldowns[character] = false -- Ici on met falseDans les tutoriels précédents, on mettait nil (on supprimait l’entrée). Ici on met false… mais la vérification if cooldowns[character] fonctionne quand même ! Pourquoi ? Parce que la condition vérifie simplement que la valeur n’est ni false ni nil. Les deux solutions marchent :
  • cooldowns[character] = nil → l’entrée n’existe plus (table plus propre).
  • cooldowns[character] = false → l’entrée existe mais vaut false (accepté par le if).
• Autre piège subtil : quand le joueur meurt et respawn, son personnage est détruit et un nouveau Model est créé. L’ancienne entrée cooldowns[ancienCharacter] reste dans le tableau avec false… mais elle ne gêne pas (elle ne sera plus jamais utilisée). Dans un vrai jeu, on nettoierait avec Players.PlayerRemoving comme dans les tutoriels précédents !

4. La détection de collision avec Touched

wellDonePart.Touched:Connect(function(hit)
    local character = hit.Parent
    if not character then return end

• hit : la partie du corps (ou objet) qui touche la Part.
• hit.Parent : le Model du personnage (si un pied touche la Part, hit = le pied, hit.Parent = le personnage entier).
• if not character then return end : si hit n’a pas de parent (impossible normalement), on arrête.
• ⚠️ Petit trou dans le filet : ce script vérifie seulement si hit.Parent existe. Une Part libre qui roule sur la ligne d’arrivée a aussi un Parent… mais elle n’a pas de Head, donc la vérification if not head then return end la rejette ! C’est la recherche de la Head qui filtre les vrais joueurs.

5. Pourquoi chercher la Head ?

local head = character:FindFirstChild("Head")
if not head then return end

• La bulle de chat apparaît au-dessus de la partie qu’on donne en paramètre.
• On donne la tête pour que la bulle apparaisse au-dessus de la tête du joueur (comme dans le tutoriel des messages cliquables !).
• Si le personnage n’a pas de tête (ex: un objet qui touche la Part), on arrête : pas de tête, pas de bulle !

---

QCM : Teste ta compréhension !

Sur le service Chat :

1. Que fait chatService:Chat(head, "Bien joué !", Enum.ChatColor.Green) ?
   • a) Affiche une bulle verte « Bien joué ! » au-dessus de la tête du personnage.
   • b) Envoie un message dans la fenêtre de chat globale.
   • c) Change la couleur du personnage en vert.

2. À quoi sert le paramètre Enum.ChatColor.Green ?
   • a) À définir la couleur de la bulle de chat.
   • b) À définir la couleur de la Part.
   • c) À définir la vitesse du personnage.

Sur script.Parent :

3. Que vaut script.Parent si le script est placé DANS une Part ?
   • a) La Part qui contient le script.
   • b) Le Workspace.
   • c) Le joueur.

4. Quel est l’avantage de placer le script dans la Part avec script.Parent ?
   • a) On peut dupliquer la Part, et chaque copie fonctionne toute seule.
   • b) Le script va plus vite.
   • c) Le message est plus long.

Sur le cooldown :

5. Pourquoi un cooldown est-il indispensable ici ?
   • a) L’événement Touched se déclenche des dizaines de fois par seconde, on aurait des dizaines de bulles.
   • b) Pour économiser la batterie.
   • c) Pour changer la couleur du message.

6. Quelle est la clé du tableau cooldowns dans ce script ?
   • a) Le personnage (character).
   • b) Le pseudo du joueur.
   • c) Le nom de la Part.

7. Que se passe-t-il pendant les 10 secondes de cooldown si le joueur re-touche la Part ?
   • a) La fonction s’arrête immédiatement à if cooldowns[character] then return end, aucune bulle ne s’affiche.
   • b) La bulle s’affiche quand même.
   • c) Le jeu plante.

8. Ce script remet le cooldown avec cooldowns[character] = false. Quelle autre écriture était aussi possible (comme dans les tutoriels précédents) ?
   • a) cooldowns[character] = nil (supprimer l’entrée du tableau).
   • b) cooldowns[character] = "stop".
   • c) cooldowns = {} (vider tout le tableau, ce qui supprimerait les cooldowns des AUTRES joueurs !).

Sur la détection de collision :

9. Que vaut hit quand un joueur touche la Part avec son pied ?
   • a) Le pied (la Part du corps qui touche).
   • b) Le personnage entier.
   • c) Le joueur.

10. Pourquoi la vérification if not head then return end est-elle utile, en plus de chercher la tête ?
    • a) Elle filtre les objets qui ne sont pas des personnages (une Part qui roule sur la ligne d’arrivée n’a pas de Head).
    • b) Elle accélère le script.
    • c) Elle change la couleur de la bulle.

---

Idées pour aller plus loin

1. Personnaliser le message avec un attribut (rappel du tutoriel des messages cliquables !)

• Objectif : Chaque copie de la Part affiche son propre message, sans modifier le script.
• Comment faire ?
  • Ajoute un attribut Message (type String) sur la Part, puis :luaCopierlocal message = wellDonePart:GetAttribute("Message") or "Bien joué !" chatService:Chat(head, message, Enum.ChatColor.Green)
  • Duplique la Part, change juste l’attribut : "Niveau 1 terminé !", "Zone secrète trouvée !"…

2. Créer un mini-jeu : une course avec score

• Objectif : La Part donne des points à chaque passage.
• Comment faire ?luaCopierlocal Players = game:GetService("Players") local player = Players:GetPlayerFromCharacter(character) if player then local leaderstats = player:FindFirstChild("leaderstats") if leaderstats then leaderstats.Score.Value += 1 end end

3. Ajouter un effet visuel et sonore (rappel du tutoriel des particules !)

• Comment faire ?luaCopierlocal emitter = wellDonePart:FindFirstChildOfClass("ParticleEmitter") local sound = wellDonePart:FindFirstChildOfClass("Sound") if emitter then emitter.Enabled = true end if sound then sound:Play() end task.delay(2, function() if emitter then emitter.Enabled = false end end)

4. Nettoyer le tableau quand le joueur quitte (bonne pratique !)

• Objectif : Éviter que le tableau cooldowns garde des entrées inutiles.
• Comment faire ? Comme dans le tutoriel flip/flop, utilise un cooldown basé sur le joueur (player.UserId comme clé, comme le tutoriel des checkpoints) + un nettoyage :luaCopierlocal Players = game:GetService("Players") local player = Players:GetPlayerFromCharacter(character) if not player then return end if cooldowns[player.UserId] then return end cooldowns[player.UserId] = true task.delay(10, function() cooldowns[player.UserId] = nil end) Players.PlayerRemoving:Connect(function(leavingPlayer) cooldowns[leavingPlayer.UserId] = nil end)
  • Bonus : avec task.delay au lieu de task.wait, la fonction Touched ne reste pas bloquée 10 secondes et peut traiter d’autres joueurs !

---

Résumé des concepts clés

Concept	Description	Exemple
script.Parent	L’objet qui contient le script (ici, la Part).	local wellDonePart = script.Parent
game:GetService("Chat")	Service pour afficher des bulles de dialogue.	chatService:Chat(head, message, color)
Chat:Chat()	Affiche une bulle au-dessus d’une partie, avec un message et une couleur.	Enum.ChatColor.Green
Touched	Événement déclenché à chaque contact avec la Part (très fréquent !).	wellDonePart.Touched:Connect(...)
hit.Parent	Le personnage (Model) qui touche la Part.	local character = hit.Parent
FindFirstChild("Head")	Cherche la tête (et filtre les non-personnages).	if not head then return end
Tableau de cooldown	[character] = true pendant 10 secondes pour bloquer le spam.	if cooldowns[character] then return end
task.wait(10)	Attend 10 secondes avant de réautoriser le message.	À la fin du cooldown

Voir le tutoriel : Déplacer une Part avec la Physique Roblox

Apprendre une version avancée de la fonction mouvement qui :

1. Calcule le déplacement restant frame par frame (comme Pythagore en 3D).
2. S’arrête exactement sur la cible (sans la dépasser).
3. Donne à la Part une vélocité physique réelle pendant le mouvement.
4. Utilise CustomPhysicalProperties pour contrôler la physique de la Part.

Introduction : Qu’est-ce qui change par rapport au tutoriel précédent ?

Dans le tutoriel précédent, la fonction mouvement fonctionnait ainsi :

• On calculait un déplacement fixe : direction * speed * deltaTime.
• On s’arrêtait quand la distance parcourue dépassait ou atteignait la cible.
• Problème : à la dernière frame, la Part pouvait dépasser légèrement la cible (elle ne s’arrêtait pas pile au bon endroit).

Dans ce nouveau script, on corrige ce problème et on ajoute des améliorations :

Aspect	Tutoriel précédent	Ce tutoriel
Cible	On mesure la distance depuis le départ.	On mesure la distance restante jusqu’à la cible.
Dernière frame	La Part peut dépasser la cible.	math.min permet de s’arrêter exactement sur la cible.
Position	Modifiée avec part.Position.	Modifiée avec part.CFrame = CFrame.new(newPosition).
Physique	Aucune vélocité.	On donne une vélocité réelle (AssemblyLinearVelocity) à la Part.
Direction	Normalisée dès le départ avec direction.Unit.	Calculée à chaque frame avec toTarget.Unit.
Arrêt	Vitesse « coupée » brutalement.	Vélocité remise à zéro proprement à l’arrêt.

Préparation dans Roblox Studio

1. Dans Workspace, crée un dossier Folder.
2. Ajoute une Part nommée Part dans ce dossier.
3. Crée un Script dans ServerScriptService et copie-y le code.
4. Lance le jeu :
   • Après 5 secondes, la Part monte (axe Y) à 30 studs/seconde.
   • Elle s’arrête exactement après 100 unités, sans dépasser.

Script Commenté :

-- Récupérer le service RunService pour utiliser Heartbeat
local RunService = game:GetService("RunService")

-- Récupérer le dossier "Folder" et la Part à déplacer
local folder = workspace:WaitForChild("Folder")
local part = folder:WaitForChild("Part")

-- Configurer les propriétés physiques personnalisées de la Part
part.CustomPhysicalProperties = PhysicalProperties.new(
    1,   -- Density (densité) : masse par unité de volume
    0.3, -- Friction (frottement) : glisse un peu sur les surfaces
    0,   -- Elasticity (rebond) : ne rebondit pas du tout
    1,   -- FrictionWeight : importance du frottement
    1    -- ElasticityWeight : importance du rebond
)

-- Fonction pour déplacer une Part jusqu'à une cible, à vitesse contrôlée
-- Paramètres :
--   part : la Part à déplacer
--   targetDistance : distance totale à parcourir
--   direction : direction du mouvement (Vector3)
--   speed : vitesse en studs par seconde
local function mouvement(part, targetDistance, direction, speed)
    -- Ancrer la Part pour la contrôler manuellement (pas de gravité pendant le mouvement)
    part.Anchored = true

    -- Stocker la position de départ
    local startPosition = part.Position

    -- Calculer la position de la cible (point d'arrivée)
    local target = startPosition + (direction * targetDistance)

    -- Variable pour stocker la connexion à Heartbeat
    local connection
    connection = RunService.Heartbeat:Connect(function(deltaTime)
        -- Position actuelle de la Part
        local currentPosition = part.Position

        -- Vecteur restant jusqu'à la cible
        local toTarget = target - currentPosition

        -- Distance restante : longueur du vecteur toTarget
        -- C'est le théorème de Pythagore en 3D :
        -- distance = racine(x^2 + y^2 + z^2)
        local remainingDistance = toTarget.Magnitude

        -- Distance qu'on peut réellement parcourir cette frame :
        -- on prend la PLUS PETITE valeur entre (speed * deltaTime) et (remainingDistance)
        -- --> évite de dépasser la cible à la dernière frame !
        local step = math.min(speed * deltaTime, remainingDistance)

        -- Direction unitaire (longueur 1) vers la cible
        local moveDirection = toTarget.Unit

        -- Nouvelle position : position actuelle + direction * step
        local newPosition = currentPosition + moveDirection * step

        -- Appliquer la nouvelle position via CFrame
        part.CFrame = CFrame.new(newPosition)

        -- Donner à la Part une vélocité réelle correspondant au déplacement effectué
        -- velocity = déplacement / temps
        -- Cela rend le mouvement "visible" pour la physique de Roblox
        part.AssemblyLinearVelocity = (newPosition - currentPosition) / deltaTime

        -- Si la distance restante est plus petite que le pas, on est arrivé !
        if remainingDistance <= step then
            -- Remettre la vélocité à zéro (arrêt propre)
            part.AssemblyLinearVelocity = Vector3.new(0, 0, 0)
            -- Déconnecter Heartbeat pour arrêter le mouvement
            connection:Disconnect()
        end
    end)
end

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

-- Paramètres du mouvement
local speed1 = 30                     -- 30 studs par seconde
local direction1 = Vector3.new(0, 1, 0) -- Direction : vers le haut (axe Y)
local targetDistance1 = 100           -- 100 unités à parcourir

-- Lancer le mouvement
mouvement(part, targetDistance1, direction1, speed1)

Explications Détaillées

1. Les propriétés physiques personnalisées

part.CustomPhysicalProperties = PhysicalProperties.new(1, 0.3, 0, 1, 1)

• PhysicalProperties.new permet de contrôler exactement le comportement physique de la Part :

Paramètre	Valeur	Signification
Density (densité)	1	Poids de la Part par unité de volume.
Friction (frottement)	0.3	Elle glisse un peu sur les surfaces (0 = glisse parfaitement, 1 = accroche).
Elasticity (rebond)	0	Elle ne rebondit pas du tout (0 = pas de rebond).
FrictionWeight	1	Importance de notre frottement face aux autres surfaces.
ElasticityWeight	1	Importance de notre rebond face aux autres surfaces.

• Pourquoi c’est utile ici ?
  • Comme on donne une vélocité à la Part, on veut contrôler comment elle réagirait en cas de collision (pas de rebond, frottement connu).

2. Calculer la distance restante (Pythagore en 3D)

local toTarget = target - currentPosition
local remainingDistance = toTarget.Magnitude

• target - currentPosition :
  • Vecteur qui pointe de la position actuelle vers la cible.
• .Magnitude :
  • Longueur de ce vecteur = distance restante.
  • C’est le théorème de Pythagore en 3D :
    distance = √(x² + y² + z²)
• Différence avec le tutoriel précédent :
  • Avant : on mesurait la distance depuis le départ (distance parcourue).
  • Maintenant : on mesure la distance restant jusqu’à la cible.
  • C’est plus précis : même si la Part était déplacée par autre chose, le calcul resterait juste !

3. math.min : le secret de l’arrêt exact

local step = math.min(speed * deltaTime, remainingDistance)

• math.min(a, b) retourne la plus petite des deux valeurs.
• Deux cas possibles :

Cas	Comparaison	Résultat
Milieu du mouvement	speed * deltaTime < remainingDistance	On avance normalement de speed * deltaTime.
Dernière frame	speed * deltaTime > remainingDistance	On avance exactement de remainingDistance → on tombe pile sur la cible !

• Exemple concret :
  • Il reste 0.4 studs à parcourir, mais speed * deltaTime = 0.5.
  • Ancienne méthode : on avancerait de 0.5 → la Part dépasse la cible de 0.1 !
  • Nouvelle méthode : math.min(0.5, 0.4) = 0.4 → la Part s’arrête exactement sur la cible.

4. Déplacer avec CFrame

part.CFrame = CFrame.new(newPosition)

• CFrame.new(position) crée un CFrame (position + rotation) à la position donnée.
• Différence avec part.Position = newPosition :
  • Position ne déplace que la position géométrique de la Part.
  • CFrame déplace toute la Part de manière complète (utile pour les Model et les assemblies).
• Les deux fonctionnent ici, mais CFrame est la méthode recommandée pour déplacer des objets dans Roblox.

5. La vélocité réelle

part.AssemblyLinearVelocity = (newPosition - currentPosition) / deltaTime

• Pourquoi faire ça alors que la Part est ancrée ?
  • La formule de la vitesse : vitesse = distance / temps.
  • Ici : déplacement de la frame ÷ durée de la frame = vélocité exacte en studs/seconde.
  • Cela informe le moteur physique de Roblox sur le mouvement réel de la Part.
  • Avantage : si un joueur touche la Part pendant son déplacement, les collisions et les effets seront cohérents avec le mouvement réel.

6. L’arrêt propre

if remainingDistance <= step then
    part.AssemblyLinearVelocity = Vector3.new(0, 0, 0)
    connection:Disconnect()
end

• Condition : si la distance restante est plus petite que (ou égale à) le pas, c’est qu’on est arrivé.
• On remet la vélocité à zéro (Vector3.new(0, 0, 0)) pour un arrêt propre, puis on déconnecte Heartbeat.

---

QCM : Teste ta compréhension !

Sur les différences avec le tutoriel précédent :

1. Quelle est la principale amélioration de ce script par rapport au précédent ?
   • a) La Part s’arrête exactement sur la cible grâce à math.min.
   • b) La Part va plus vite.
   • c) La Part change de couleur.

2. Dans le tutoriel précédent, quel problème pouvait survenir à la dernière frame ?
   • a) La Part pouvait dépasser légèrement la cible.
   • b) La Part ne bougeait pas.
   • c) La Part disparaissait.

3. Comment mesure-t-on la distance dans ce script ?
   • a) La distance restante jusqu’à la cible (toTarget.Magnitude).
   • b) La distance parcourue depuis le départ.
   • c) On ne mesure pas la distance.

Sur math.min :

4. Que fait math.min(0.5, 0.4) ?
   • a) Retourne 0.4 (la plus petite valeur).
   • b) Retourne 0.5 (la plus grande valeur).
   • c) Retourne 0.9 (la somme).

5. Pourquoi math.min est-il essentiel ici ?
   • a) Pour éviter que la Part dépasse la cible à la dernière frame.
   • b) Pour accélérer la Part.
   • c) Pour changer la couleur de la Part.

Sur la physique :

6. Que fait part.CustomPhysicalProperties = PhysicalProperties.new(1, 0.3, 0, 1, 1) ?
   • a) Définit la densité, le frottement et le rebond de la Part.
   • b) Définit la couleur de la Part.
   • c) Déplace la Part.

7. Que signifie Elasticity = 0 dans les propriétés physiques ?
   • a) La Part ne rebondit pas du tout.
   • b) La Part rebondit parfaitement.
   • c) La Part est invisible.

8. Pourquoi calcule-t-on AssemblyLinearVelocity = (newPosition - currentPosition) / deltaTime ?
   • a) Pour donner à la Part une vitesse physique réelle (distance / temps).
   • b) Pour téléporter la Part.
   • c) Pour changer la couleur de la Part.

9. Pourquoi remet-on AssemblyLinearVelocity à Vector3.new(0, 0, 0) à l’arrêt ?
   • a) Pour un arrêt propre de la Part.
   • b) Pour redémarrer le mouvement.
   • c) Pour supprimer la Part.

10. Quel est l’avantage de mesurer la distance restante plutôt que la distance parcourue ?
    • a) Le calcul reste correct même si la Part est déplacée par autre chose en cours de route.
    • b) Le script est plus court.
    • c) La Part va plus vite

Apprendre à créer des ascenseurs sans boucle Heartbeat, grâce au service TweenService ! Ce tutoriel est progressif :

1. Script 1 : animer un seul ascenseur avec un Tween.
2. Script 2 : généraliser avec une fonction createElevator pour gérer plusieurs ascenseurs différents avec le même code.

Tu vas découvrir que parfois, Roblox propose un mécanisme intégré qui remplace des dizaines de lignes de code écrites à la main !

Introduction : C’est quoi un Tween ?

Un Tween, c’est une animation automatique : tu dis à Roblox :

• où aller (la position cible),
• en combien de temps (la durée),
• comment (le style : fluide, rebondissant, linéaire…),

…et Roblox fait tout le travail, frame par frame, à ta place !

Comparaison avec le tutoriel précédent :

Technique	Tutoriel précédent (Heartbeat)	Ce tutoriel (TweenService)
Qui déplace la Part ?	Ton code, à chaque frame.	Roblox, automatiquement.
Lignes de code	Beaucoup (calculs, direction, elapsed…).	Très peu !
Vitesse fluide / accélération	À coder soi-même.	Intégrée (EasingStyle) !
Transport du joueur	Oui (avec AssemblyLinearVelocity).	Oui (Roblox gère la vélocité du Tween).

SCRIPT 1 : Animer un seul ascenseur

Préparation dans Roblox Studio

1. Dans Workspace, crée un dossier MovementsFolder.
2. Ajoute deux Part nommées Part et Part02 (plates et larges : Size = Vector3.new(20, 1, 20)).
3. Crée un Script dans ServerScriptService et colle le Script 1. Teste :
   • L’ascenseur 1 monte en 15 s, redescend, remonte… à l’infini, en douceur.
   • Monte dessus : tu es transporté (TweenService gère la physique pour toi !).
4. Remplace par le Script 2. Teste :
   • L’ascenseur 1 monte (10 s), l’ascenseur 2 recule de 200 studs sur l’axe X.
   • Les deux animations tournent en même temps, chacune dans son sens.

Voici le premier script :

-- Récupérer le dossier et les deux ascenseurs
local folder = workspace:WaitForChild("MovementsFolder")
local elevator01 = folder:WaitForChild("Part")
local elevator02 = folder:WaitForChild("Part02")

-- Récupérer le service d'animations TweenService
local tweenService = game:GetService("TweenService")

-- Décrire les règles de l'animation avec TweenInfo
local tweenInfo = TweenInfo.new(
    15,                          -- Durée : 15 secondes pour monter
    Enum.EasingStyle.Sine,       -- Style : démarre doucement, accélère, ralentit (comme un vrai ascenseur !)
    Enum.EasingDirection.InOut,  -- Direction : fluide au début ET à la fin
    -1,                          -- Répétition : -1 = INFINIE (jamais arrêtée)
    true                         -- Reverser : à l'arrivée, l'animation REPART EN ARRIÈRE (descente !)
)

-- Créer le Tween : on anime elevator01 vers une position 100 studs plus haut
local tween = tweenService:Create(
    elevator01,                   -- Objet à animer
    tweenInfo,                    -- Les règles de l'animation
    {                             -- Propriétés à modifier (la destination) :
        Position = Vector3.new(  -- La nouvelle Position = position actuelle + 100 en Y
            elevator01.Position.X,      -- X : inchangé
            elevator01.Position.Y + 100, -- Y : +100 studs (on monte !)
            elevator01.Position.Z       -- Z : inchangé
        )
    }
)

-- Lancer l'animation !
tween:Play()

Explications du Script 1

1. TweenInfo.new : les règles du jeu

TweenInfo.new accepte 5 paramètres (dans cet ordre, attention !) :

Paramètre	Valeur ici	Signification
1. Durée	15	Le trajet dure 15 secondes.
2. Style	Enum.EasingStyle.Sine	L’ascenseur démarre doucement et freine à l’arrivée (pas de secousse !).
3. Direction	Enum.EasingDirection.InOut	L’effet de style s’applique au début ET à la fin.
4. Répétitions	‘-1	‘-1 = répétition à l’infini. (0 = une fois, 2 = trois allers…)
5. Reverser	true	Après chaque montée, l’animation rejoue en sens inverse : c’est la descente automatique !

2. Les styles d’animation (EasingStyle) — à expérimenter !

Style	Effet
Linear	Vitesse constante, comme un tapis roulant.
Sine	Doux au départ et à l’arrivée — parfait pour un ascenseur.
Quad, Cubic	Accélération de plus en plus marquée.
Bounce	Rebondit à l’arrivée comme un ballon !
Elastic	Élastique, dépasse la cible puis revient.
Back	Part légèrement en arrière avant d’avancer.

3. La cible : une table de propriétés

{Position = Vector3.new(...)}

• Le 3ème argument de Create est une table qui contient les propriétés à animer et leur valeur finale.
• Ici, on anime seulement la Position, mais on peut animer Color, Transparency, Size… tout à la fois !
• Astuce : la cible est calculée à partir de la position actuelle (elevator01.Position.Y + 100) : le script fonctionne où que soit placée la Part dans ton niveau !

4. La magie Reverser = true

• Montée (15 s) → descente (15 s) → montée → descente… à l’infini, sans aucune boucle while ni variable direction !
• Compare avec le tutoriel précédent : des dizaines de lignes remplacées par -1 et true !

5. N’oublie pas Anchored = true !

• Dans le Script 1, la Part doit être ancrée dans Studio (case Anchored cochée), sinon elle tombe avant même que le Tween commence ! (Le Script 2 corrige cela dans le code.)

SCRIPT 2 : Gérer plusieurs ascenseurs différents

Problème du Script 1 : il n’anime que elevator01, et il faut copier-coller tout le code pour un 2ème ascenseur. Mauvaise pratique !

Solution (rappel des tutoriels précédents) : une fonction createElevator paramétrable + un tableau de fiches + une boucle pairs !

Voici le script commenté :

-- Récupérer le dossier et les deux ascenseurs
local folder = workspace:WaitForChild("MovementsFolder")
local elevator01 = folder:WaitForChild("Part")
local elevator02 = folder:WaitForChild("Part02")

-- Récupérer le service d'animations TweenService
local tweenService = game:GetService("TweenService")

-- Tableau des ascenseurs (une fiche de paramètres par ascenseur)
local elevators = {}

-- Fonction pour créer un ascenseur avec SES paramètres propres
-- Paramètres :
--   part : la Part à animer
--   movement : le déplacement à effectuer (Vector3)
--   duration : la durée de l'animation (secondes)
--   style : le style d'animation (EasingStyle)
--   direction : le sens de l'animation (EasingDirection)
--   repeatCount : le nombre de répétitions (-1 = infini)
--   reverser : retour à l'origine à la fin (true/false)
local function createElevator(part, movement, duration, style, direction, repeatCount, reverser)
    part.Anchored = true    -- Mouvement contrôlé, pas de gravité
    part.CanCollide = true  -- Le joueur peut monter dessus

    elevators[part] = {
        movement = movement or Vector3.new(0, 100, 0),      -- Déplacement par défaut : +100 en Y
        duration = duration or 10,                          -- Durée par défaut : 10 s
        style = style or Enum.EasingStyle.Sine,             -- Style par défaut : Sine
        direction = direction or Enum.EasingDirection.InOut,-- Direction par défaut : InOut
        repeatCount = repeatCount or -1,                    -- Répétition par défaut : infinie
        reverser = reverser or true,                        -- Descente automatique par défaut
    }
end

-- Ascenseur 1 : monte de 100 studs (tous les autres paramètres par défaut)
createElevator(elevator01, Vector3.new(0, 100, 0))

-- Ascenseur 2 : recule de 200 studs sur l'axe X (un pont mobile horizontal !)
createElevator(elevator02, Vector3.new(-200, 0, 0))

-- Parcourir le tableau et créer + lancer UN TWEEN PAR ASCENSEUR
for part, properties in pairs(elevators) do
    -- Construire les règles de l'animation avec les paramètres de CET ascenseur
    local tweenInfo = TweenInfo.new(
        properties.duration,
        properties.style,
        properties.direction,
        properties.repeatCount,
        properties.reverser
    )

    -- Créer le Tween : cible = position actuelle + le déplacement demandé
    local tween = tweenService:Create(
        part,
        tweenInfo,
        {Position = part.Position + properties.movement}
    )

    -- Lancer l'animation
    tween:Play()
end

Explications du Script 2

1. La fonction createElevator : une fiche par ascenseur

• Même architecture que le tutoriel précédent (les tableaux de cooldowns, de checkpoints…) :
  • Clé = la Part.
  • Valeur = une fiche de paramètres (table).
• Rappel : movement or Vector3.new(0, 100, 0) = si le paramètre n’est pas fourni, on prend la valeur par défaut.

2. Deux ascenseurs, deux comportements, UN code

createElevator(elevator01, Vector3.new(0, 100, 0))    -- Monte de 100 studs
createElevator(elevator02, Vector3.new(-200, 0, 0))   -- Recule de 200 studs

• Ascenseur 1 : vertical (comme un vrai ascenseur).
• Ascenseur 2 : horizontal (comme un pont mobile ou un tapis géant).
• La cible est calculée dans la boucle : part.Position + properties.movement → fonctionne pour n’importe quelle Part, n’importe où !

3. La boucle pairs : créer et lancer tous les Tweens

for part, properties in pairs(elevators) do
    local tweenInfo = TweenInfo.new(...)
    local tween = tweenService:Create(part, tweenInfo, {Position = ...})
    tween:Play()
end

• On parcourt toutes les fiches, et pour chacune on construit son TweenInfo personnalisé.
• Chaque Tween tourne indépendamment : l’ascenseur 1 mettra 10 s pour monter, l’ascenseur 2 aussi mais dans l’autre sens, chacun son rythme, sans se gêner !
• Ajouter un 3ème ascenseur = 1 seule ligne :luaCopierlocal elevator03 = folder:WaitForChild("Part03") createElevator(elevator03, Vector3.new(0, 0, 150), 20, Enum.EasingStyle.Bounce) -- Va-et-vient avec rebonds !

---

QCM : Teste ta compréhension !

Sur TweenService et TweenInfo :

1. À quoi sert TweenService ?
   • a) À créer des animations automatiques de propriétés (position, couleur, transparence…).
   • b) À détecter les collisions.
   • c) À afficher des messages dans le chat.

2. Que signifie -1 en 4ème paramètre de TweenInfo.new ?
   • a) L’animation se répète à l’infini.
   • b) L’animation dure -1 seconde.
   • c) L’animation est supprimée.

3. Que fait le paramètre Reverser = true ?
   • a) Après l’aller, l’animation rejoue en sens inverse : descente automatique !
   • b) La Part tourne sur elle-même.
   • c) La Part devient invisible.

4. Quel EasingStyle donne un mouvement doux au départ et à l’arrivée, comme un vrai ascenseur ?
   • a) Enum.EasingStyle.Sine
   • b) Enum.EasingStyle.Bounce
   • c) Enum.EasingStyle.Linear

5. Quel EasingStyle fait rebondir la Part à l’arrivée ?
   • a) Enum.EasingStyle.Bounce
   • b) Enum.EasingStyle.Sine
   • c) Enum.EasingStyle.InOut

Sur la création du Tween :

6. Que contient le 3ème argument de tweenService:Create ?
   • a) Une table avec les propriétés à animer et leur valeur finale (la cible).
   • b) La durée de l’animation.
   • c) Le nom du joueur.

7. Pourquoi calcule-t-on la cible avec part.Position + properties.movement ?
   • a) Pour que le script fonctionne où que soit placée la Part dans le niveau.
   • b) Pour aller plus vite.
   • c) Pour changer la couleur de la Part.

8. Que faut-il penser à faire pour que la Part animée ne tombe pas à cause de la gravité ?
   • a) L’ancrer (part.Anchored = true, comme dans createElevator).
   • b) La peindre en rouge.
   • c) La rendre transparente.

Sur le Script 2 :

9. Quel est l’avantage de la fonction createElevator par rapport au Script 1 ?
   • a) On peut créer autant d’ascenseurs différents qu’on veut sans dupliquer le code (1 ligne par ascenseur).
   • b) Les animations vont plus vite.
   • c) Il n’y a aucun avantage.

10. Que fait movement = movement or Vector3.new(0, 100, 0) ?
    • a) Si aucun mouvement n’est fourni, on utilise le déplacement par défaut (+100 en Y).
    • b) On additionne les deux vecteurs.
    • c) On supprime le mouvement.

11. Dans le Script 2, comment s’appellent les deux paramètres corrigés par rapport à l’original ?
    • a) movement (au lieu de mouvment) et repeatCount (au lieu de nbrRepeat).
    • b) vitesse et duree.
    • c) up et down.

12. Comment ajouter un 3ème ascenseur qui avance sur l’axe Z en 20 secondes ?
    • a) createElevator(elevator03, Vector3.new(0, 0, 150), 20) — une seule ligne suffit !
    • b) Il faut recopier tout le script.
    • c) C’est impossible.

Comparaison : Heartbeat (tutoriel précédent) vs TweenService

Critère	Boucle Heartbeat	TweenService
Quantité de code	Beaucoup (direction, elapsed, conditions…).	Très peu.
Pause entre les trajets	✅ Facile (task.delay + direction = 0).	❌ Pas prévu par TweenInfo (à gérer soi-même avec tween.Completed).
Chaque ascenseur différent	✅ Fiches de paramètres.	✅ Fiches de paramètres aussi !
Styles d’animation (rebond, élastique…)	❌ À coder entièrement à la main.	✅ Intégrés (EasingStyle) !
Annuler / reprendre	Compliqué (déconnecter, recalculer).	✅ tween:Cancel(), tween:Pause() !
Conclusion	Puissant et flexible (pauses, conditions). Permet le déplacement du joueur sur la part dans un déplacement sur X ou Z	Simple et rapide pour des allers-retours classiques.

La leçon du programmeur : avant de coder un mouvement à la main, demande-toi si Roblox n’a pas déjà un outil intégré ! Pour des animations simples, TweenService gagne. Pour des comportements complexes (pauses, étages, conditions), la boucle Heartbeat reste reine.

---

Idées pour aller plus loin

1. Animer d’autres propriétés que la Position

• Objectif : Faire clignoter ou changer la couleur des ascenseurs.
• Comment faire ?luaCopiertweenService:Create(part, TweenInfo.new(2, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut, -1, true), {Color = Color3.fromRGB(255, 0, 0)}):Play()On peut animer plusieurs propriétés en même temps : {Position = ..., Color = ..., Transparency = 0.5} !

2. Ajouter une pause entre les trajets

• Objectif : Combiner TweenService avec la pause du tutoriel précédent.
• Comment faire ? Utiliser l’événement tween.Completed (attention : avec Reverser, il ne se déclenche qu’à la toute fin) :luaCopierlocal info = TweenInfo.new(10, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut, 0, true) -- 0 répétition local tween = tweenService:Create(part, info, {Position = part.Position + properties.movement}) tween.Completed:Connect(function() task.wait(3) -- Pause de 3 secondes à l'arrivée tween:Play() -- Et on repart ! end) tween:Play()

3. Contrôler le Tween en direct

• Objectif : Arrêter ou mettre en pause l’ascenseur (ex: bouton d’arrêt d’urgence !).
• Comment faire ?tween:Pause() -- Met en pause (l'animation reprendra où elle s'est arrêtée) tween:Play() -- Reprend tween:Cancel() -- Annule et remet la Part à sa position d'origine

4. Un son d’ascenseur à chaque départ

• Comment faire ?luaCopierlocal sound = part:FindFirstChildOfClass("Sound") if sound then sound:Play() endAssocie-le à un ClickDetector (rappel du tutoriel des messages) pour un bouton « Appeler l’ascenseur » !

---

Résumé des concepts clés

Concept	Description	Exemple
TweenService	Service qui anime automatiquement les propriétés.	game:GetService("TweenService")
TweenInfo.new	Les règles : durée, style, direction, répétitions, reverser.	TweenInfo.new(15, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut, -1, true)
EasingStyle	Le « caractère » du mouvement (Sine, Bounce, Elastic…).	Enum.EasingStyle.Bounce
‘-1 répétitions + true reverser	Le combo magique : aller-retour infini en 2 paramètres !
tweenService:Create(objet, infos, cible)	Prépare l’animation.	{Position = part.Position + movement}
tween:Play()	Lance l’animation.
Fiche de paramètres + pairs	Un Tween personnalisé par ascenseur, ajoutable en 1 ligne.	createElevator(part, ...)

• avec déplacement fluide de la part avec RunService.Heartbeat
• avec déplacement du joueur sur la part avec AssemblyLinearVelocity

En utilisant les concepts appris dans les deux tutoriels précédents, tu vas apprendre à déplacer de manière fluide les parts avec RunService.Heartbeat tout en proposer un déplacement du joueur sur la part sur les axes X et Z avec AssemblyLinearVelocity. On va garder la Part ancrée pour un mouvement 100% contrôlé et précis, mais on informe le moteur physique de la vitesse réelle du déplacement

Rappel des deux tutoriels précédents :

Technique	Comment ça marche	Le joueur est transporté ?
Tutoriel 1 : part.Position avec Anchored = true	On téléporte la Part	Non ! Le joueur traverse la part
Tutoriel 2 : AssemblyLinearVelocity avec Anchored = false	On confie le déplacement au moteur physique.	Oui… mais la plateforme subit la gravité et pivote sous le poids du joueur

L’astuce de ce tutoriel : le meilleur des deux mondes !

On garde la Part ancrée (Anchored = true) pour un mouvement 100% contrôlé et précis, mais on informe le moteur physique de la vitesse réelle du déplacement avec :

part.AssemblyLinearVelocity = speed * direction

• Pourquoi ça marche ?
  • Roblox utilise la vélocité d’une surface pour savoir comment déplacer les personnages debout dessus.
  • En donnant la bonne vélocité (même à une Part ancrée), Roblox « sait » que le sol bouge, et entraîne le joueur avec lui !
  • C’est exactement la formule de la physique : vitesse = distance / temps.

Aspect	Tutoriel 1 (Position seule)	Tutoriel 2 (Vélocité + non ancré)	Ce tutoriel (hybride)
Précision du mouvement	✅ Parfaite	❌ La physique peut dévier	✅ Parfaite
Transport du joueur	❌ Non	✅ Oui	✅ Oui
Gravité / collisions parasites	✅ Aucune (ancrée)	❌ Oui (non ancrée)	✅ Aucune (ancrée)

Apprendre à créer une fonction paramétrable pour déplacer une Part de manière fluide en utilisant RunService.Heartbeat. Ce tutoriel explique :

1. Comment utiliser RunService.Heartbeat pour des mouvements fluides.
2. Comment créer une fonction paramétrable pour contrôler le déplacement.
3. Comment calculer la distance parcourue avec Magnitude.

Préparation dans Roblox Studio

Pour tester ce script, suis ces étapes :

1. Créer un dossier :
   • Dans Workspace, crée un dossier nommé MovementsFolder.
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.

Script pour faire monter :

local folder = workspace:WaitForChild("MovementsFolder")
local ascenseur = folder:WaitForChild("Part")

task.wait(3)
ascenseur.Position += Vector3.new(0, 10, 0)

Pourquoi utiliser RunService.Heartbeat ?

Dans Roblox, RunService.Heartbeat est un événement qui se déclenche à chaque frame (environ 60 fois par seconde). Cela permet de :

• Créer des mouvements fluides (ex: une animation progressive).
• Contrôler précisément le déplacement d’un objet.
• Arrêter le mouvement quand une condition est remplie (ex: une distance parcourue).

Dans ce tutoriel, on va déplacer une Part sur l’axe Y jusqu’à ce qu’elle ait parcouru une distance donnée.

Faire montrer progressivement la part :

local RunService = game:GetService("RunService")

local folder = workspace:WaitForChild("MovementsFolder")
local ascenseur = folder:WaitForChild("Part")

ascenseur.Anchored = true
task.wait(5)


local connection
connection = RunService.Heartbeat:Connect(function(deltaTime)

	ascenseur.Position += Vector3.new(0, +10,0)

end)

Faire monter la parte en contrôlant sa vitesse de montée :

• speed : vitesse du déplacement en stud
• direction : direction du déplacement 1 monter -1 descendre

local runService = game:GetService("RunService")

local folder = workspace:WaitForChild("MovementsFolder")
local ascenseur = folder:WaitForChild("Part")

ascenseur.Anchored = true
task.wait(5)

local speed = 10
local direction = 1 -- 1 monter -1 descendre


local connection
connection = runService.Heartbeat:Connect(function(deltatime)
	ascenseur.Position += Vector3.new(0, (direction * speed * deltatime) , 0)
end)

Faire monter puis descendre la part en contrôlant la vitesse et la hauteur :

• starty : point de départ sur l’axe Y
• targety : point d’arrivée sur l’axe Y

local runService = game:GetService("RunService")

local folder = workspace:WaitForChild("MovementsFolder")
local ascenseur = folder:WaitForChild("Part")

ascenseur.Anchored = true
task.wait(5)

local speed = 10
local direction = 1 -- 1 monter -1 descendre

local startY = ascenseur.Position.Y
local targetY = startY + 50

local connection
connection = runService.Heartbeat:Connect(function(deltatime)
	ascenseur.Position += Vector3.new(0, (direction * speed * deltatime) , 0)
	
	if ascenseur.Position.Y >= targetY then
		direction = -1
	elseif ascenseur.Position.Y <= startY then
		direction = 1
	end
end)

Monter et descendre avec un arrêt :

• pause_duration = temps de l’arrêt en seconde

local runService = game:GetService("RunService")

local folder = workspace:WaitForChild("MovementsFolder")
local ascenseur = folder:WaitForChild("Part")

ascenseur.Anchored = true
task.wait(5)

local speed = 10
local direction = 1 -- 1 monter -1 descendre

local startY = ascenseur.Position.Y
local targetY = startY + 50

local pause_duration = 5

local connection
connection = runService.Heartbeat:Connect(function(deltatime)
	ascenseur.Position += Vector3.new(0, (direction * speed * deltatime) , 0)
	
	if direction ~= 0 and ascenseur.Position.Y >= targetY then
		direction = 0
		task.delay(pause_duration, function()
			direction = -1
		end)
	
	elseif direction ~= 0 and ascenseur.Position.Y <= startY then
		direction = 0
		task.delay(pause_duration, function()
			direction = 1
		end)
	end
end)

Parcourir sur une certaine distance en transportant le joueur :

On garde la Part ancrée (Anchored = true) pour un mouvement 100% contrôlé et précis, mais on informe le moteur physique de la vitesse réelle du déplacement avec :

ascenseur.AssemblyLinearVelocity = Vector3.new(speed * direction, 5, 0)

• Pourquoi ça marche ?
  • Roblox utilise la vélocité d’une surface pour savoir comment déplacer les personnages debout dessus.
  • En donnant la bonne vélocité (même à une Part ancrée), Roblox « sait » que le sol bouge, et entraîne le joueur avec lui !
• .Magnitude : distance totale parcourue depuis le départ (Pythagore 3D : √(x² + y² + z²)).

local runService = game:GetService("RunService")

local folder = workspace:WaitForChild("MovementsFolder")
local ascenseur = folder:WaitForChild("Part")

local speed = 20
local direction = 1 -- 1 monter -1 descendre

local start = ascenseur.Position
local distance = 200

local pause_duration = 5

ascenseur.Anchored = true
task.wait(5)

local connection
connection = runService.Heartbeat:Connect(function(deltatime)
	ascenseur.Position += Vector3.new((direction * speed * deltatime),
		                           0 , 
		                           0)
	if direction == 0 then
		ascenseur.AssemblyLinearVelocity = Vector3.new(0, 0, 0)		
	else	
		ascenseur.AssemblyLinearVelocity = Vector3.new(speed * direction,
			                                       5, 
			                                       0)		
	end
	if direction ~= 0 and  and (ascenseur.Position - start).Magnitude > distance then
		direction = 0
		task.delay(pause_duration, function()
			direction = -1
		end)

	elseif direction ~= 0 and  and (ascenseur.Position - start).Magnitude < 1 then
		direction = 0
		task.delay(pause_duration, function()
			direction = 1
		end)
	end
end)

Parcourir sur une certaine distance dans toutes les directions :

local runService = game:GetService("RunService")

local folder = workspace:WaitForChild("MovementsFolder")
local ascenseur = folder:WaitForChild("Part")

local speed = Vector3.new(20, 20, 20)
local direction = 1 -- 1 monter -1 descendre

local start = ascenseur.Position
local distance = 200

local pause_duration = 5

ascenseur.Anchored = true
task.wait(5)

local connection
connection = runService.Heartbeat:Connect(function(deltatime)
	ascenseur.Position += speed * direction * deltatime

	if direction == 0 then
		ascenseur.AssemblyLinearVelocity = Vector3.new(0, 0, 0)		
	else	
		ascenseur.AssemblyLinearVelocity = Vector3.new(speed.X * direction,
			                                           5 , 
			                                           speed.Z * direction)		
	end
	if direction ~= 0 and  and (ascenseur.Position - start).Magnitude > distance then
		direction = 0
		task.delay(pause_duration, function()
			direction = -1
		end)

	elseif direction ~= 0 and  and (ascenseur.Position - start).Magnitude < 1 then
		direction = 0
		task.delay(pause_duration, function()
			direction = 1
		end)
	end
end)

Parcourir pendant un certain temps dans toutes les directions :

local runService = game:GetService("RunService")

local folder = workspace:WaitForChild("MovementsFolder")
local ascenseur = folder:WaitForChild("Part")

local speed = Vector3.new(20, 20, 20)
local direction = 1 -- 1 monter -1 descendre

local elapsed = 0
local duration = 10

local pause_duration = 5

ascenseur.Anchored = true
task.wait(5)

local connection
connection = runService.Heartbeat:Connect(function(deltatime)
	ascenseur.Position += speed * direction * deltatime

	if direction == 0 then
		ascenseur.AssemblyLinearVelocity = Vector3.new(0, 0, 0)		
	else	
		ascenseur.AssemblyLinearVelocity = Vector3.new(speed.X*direction,
                                                               5 , 
			                                       speed.Z*direction)		
	end
	
	elapsed += deltatime * direction
	if direction ~= 0 and elapsed >= duration then
		direction = 0
		task.delay(pause_duration, function()
			direction = -1
		end)

	elseif direction ~= 0 and elapsed <= 0 then
		direction = 0
		task.delay(pause_duration, function()
			direction = 1
		end)
	end
end)

Créer des Ascenseurs Automatiques en Aller-Retour avec Pause.

Apprendre à créer plusieurs ascenseurs qui montent, marquent une pause, redescendent, repartent… en boucle infinie ! Ce tutoriel explique :

1. Comment stocker les paramètres de chaque ascenseur dans un tableau (une fiche d’identité par ascenseur !).
2. La boucle for ... in pairs() pour gérer plusieurs ascenseurs en même temps avec un seul Heartbeat.
3. La variable elapsed (temps écoulé) pour savoir où en est l’ascenseur.
4. La direction (1, 0, -1) pour piloter montée, pause et descente.
5. La protection contre la double connexion au Heartbeat.

Ce script réunit des briques vues dans les tutoriels précédents : Heartbeat, deltaTime, AssemblyLinearVelocity pour transporter les joueurs, et task.delay pour les pauses !

Comment fonctionne un ascenseur ?

Un vrai ascenseur fait un cycle :

1. Montée (direction = 1)
2. Pause à l’étage (direction = 0) — les portes s’ouvrent !
3. Descente (direction = -1)
4. Pause en bas (direction = 0)
5. Et on recommence !

Le défi du jour : gérer deux ascenseurs avec des vitesses différentes (l’un monte en diagonale, l’autre avance sur l’axe X), mais avec une seule boucle Heartbeat pour tout le monde — c’est plus efficace que de créer une boucle par ascenseur !

-- Récupérer le service RunService pour utiliser Heartbeat
local RunService = game:GetService("RunService")

-- Récupérer le dossier et les deux ascenseurs
local folder = workspace:WaitForChild("MovementsFolder")
local elevator01 = folder:WaitForChild("Part")
local elevator02 = folder:WaitForChild("Part02")

-- Variable pour stocker la connexion à Heartbeat (UNE SEULE pour tous les ascenseurs)
local connection

-- Fonction qui démarre la boucle de mouvement pour TOUS les ascenseurs
-- Paramètre : elevators = le tableau contenant tous les ascenseurs et leurs paramètres
local function startMovement(elevators)
	-- PROTECTION : si une connexion existe déjà, on ne fait rien
	-- (évite de connecter DEUX fois Heartbeat, ce qui doublerait la vitesse !)
	if connection then return end

	connection = RunService.Heartbeat:Connect(function(deltaTime)
		-- Parcourir le tableau des ascenseurs avec pairs()
		-- Pour chaque ascenseur (part) et sa fiche de paramètres (properties) :
		for part, properties in pairs(elevators) do

			-- Ignorer si l'objet n'est pas une BasePart (sécurité)
			if not part:IsA("BasePart") then continue end
			
			if properties.direction ~= 0 then

				-- Déplacer l'ascenseur : position += vitesse * direction * temps
				-- direction = 1 (monte) : avance normalement
				-- direction = -1 (descend) : avance à l'envers (vitesse négative)
				-- direction = 0 (pause) : ne bouge plus (vitesse * 0 = 0)
				part.Position += properties.speed * properties.direction * deltaTime

				-- Donner la vélocité réelle pour TRANSPORTER LES JOUEURS
				-- (technique du tutoriel précédent : vitesse = déplacement / temps)
				if properties.direction == 0 then
					part.AssemblyLinearVelocity = Vector3.new(0, 0, 0)  -- Arrêt propre
				else
					part.AssemblyLinearVelocity = properties.speed *
                                                                                    properties.direction
				end

				-- Mise à jour du temps écoulé :
				-- si direction = 1 : elapsed augmente (montée)
				-- si direction = -1 : elapsed DIMINUE (descente)
				-- si direction = 0 : elapsed ne change plus (pause)
				properties.elapsed += deltaTime * properties.direction
			end
			-- ARRIVÉE EN HAUT : elapsed atteint la durée du trajet
			if properties.direction ~= 0 and properties.elapsed >= properties.duration then
				properties.direction = 0  -- Stop : pause en haut !
				task.delay(properties.pause_duration, function()
					properties.direction = -1  -- Après la pause : descente
				end)

				-- ARRIVÉE EN BAS : elapsed revient à 0
			elseif properties.direction ~= 0 and properties.elapsed <= 0 then
				properties.direction = 0  -- Stop : pause en bas !
				task.delay(properties.pause_duration, function()
					properties.direction = 1  -- Après la pause : montée
				end)
			end
		end
	end)
end

-- Attendre 5 secondes avant de démarrer
task.wait(5)

-- Tableau qui contiendra tous les ascenseurs et leurs paramètres
local elevators = {}

-- Fonction pour créer un ascenseur et l'enregistrer dans le tableau
-- Chaque ascenseur reçoit SA fiche de paramètres (sa "fiche d'identité")
local function createElevator(part, speed, duration, pauseDuration)
	part.Anchored = true    -- Mouvement 100% contrôlé par le script
	part.CanCollide = true  -- Le joueur peut monter dessus

	elevators[part] = {
		connection = nil,
		speed = speed or Vector3.new(20, 20, 20),  -- Vitesse par défaut si non fournie
		duration = duration or 10,                  -- Durée du trajet par défaut : 10 s
		pause_duration = pauseDuration or 3,        -- Durée de la pause par défaut : 3 s
		direction = 1,   -- Direction de départ : 1 = monte
		elapsed = 0,     -- Temps écoulé : on part du bas (0)
	}
end

-- Créer les deux ascenseurs :
-- Ascenseur 1 : vitesse par défaut (diagonale 20,20,20), durée et pause par défaut
createElevator(elevator01)

-- Ascenseur 2 : avance sur l'axe X seulement (Vector3.new(20, 0, 0))
createElevator(elevator02, Vector3.new(20, 0, 0))

-- Démarrer le mouvement de tous les ascenseurs
startMovement(elevators)

Explications Détaillées

1. La fiche d’identité : un tableau DANS un tableau !

elevators[part] = {
    speed = Vector3.new(20, 20, 20),
    duration = 10,
    pause_duration = 3,
    direction = 1,
    elapsed = 0,
}

• elevators est un tableau associatif dont la clé est la Part :luaCopierelevators = { [Part] = { speed = ..., direction = ..., ... }, [Part02] = { speed = ..., direction = ..., ... } }
• Chaque ascenseur a sa propre fiche avec ses paramètres. C’est la même technique que les tableaux cooldowns des tutoriels précédents : une clé unique par objet, une valeur dédiée.
• L’astuce valeur or défaut :luaCopierspeed = speed or Vector3.new(20, 20, 20),
  • Si on donne une vitesse → on l’utilise.
  • Si on n’en donne pas (comme createElevator(elevator01)) → speed vaut nil, et nil or Vector3.new(20, 20, 20) prend la valeur par défaut.
  • C’est comme un jeu vidéo : si tu ne choisis pas la difficulté, le mode Normal s’active tout seul !

2. La boucle for ... in pairs() : gérer tous les ascenseurs d’un coup

for part, properties in pairs(elevators) do
    ...
end

• Jusqu’ici, tu connaissais ipairs pour les listes numérotées (1, 2, 3…).
• pairs parcourt un tableau associatif : il donne successivement chaque clé (part) et chaque valeur (properties).
• Avantage énorme : un seul Heartbeat met à jour tous les ascenseurs à chaque frame. Si tu ajoutes un 3ème, 4ème… 10ème ascenseur, aucune ligne de la boucle ne change !

3. La direction : le chef d’orchestre (1, 0, -1)

La variable properties.direction peut valoir trois états :

direction	Signification	Effet sur le mouvement	Effet sur elapsed
1	Montée	Avance à pleine vitesse	Augmente
0	Pause	Immobile (vitesse × 0 = 0)	Ne bouge plus
‘-1	Descente	Avance « à l’envers »	Diminue

• La magie des signes : speed * direction * deltaTime :
  • direction = 1 → +speed (monte)
  • direction = -1 → -speed (descend !)
  • direction = 0 → rien (pause)
• Un seul calcul gère les trois comportements !

4. elapsed : le chronomètre du trajet

properties.elapsed += deltaTime * properties.direction

• elapsed compte le temps écoulé depuis le bas :
  • Pendant la montée : elapsed augmente (0 → 1 → 2 → … → duration).
  • Pendant la descente : elapsed diminue (duration → … → 2 → 1 → 0).
  • Pendant la pause : elapsed ne change pas (car direction = 0).
• Deux conditions de retournement :luaCopierif properties.elapsed >= properties.duration then -- En HAUT elseif properties.elapsed <= 0 then -- En BAS
• Pourquoi un chronomètre plutôt qu’une distance ? Avec des vitesses en Vector3 (diagonales possibles), mesurer un temps est plus simple et plus fiable que mesurer une distance 3D à chaque frame !

5. La pause avec task.delay

properties.direction = 0   -- Stop immédiat
task.delay(properties.pause_duration, function()
    properties.direction = -1  -- Dans 3 secondes : descente
end)

• On coupe d’abord la direction (0), puis on programme la suite avec task.delay.
• Pourquoi pas task.wait ? On est dans une boucle Heartbeat ! Un task.wait(3) bloquerait toute la boucle pendant 3 secondes… et tous les autres ascenseurs seraient figés aussi ! task.delay programme l’action sans rien bloquer.

6. La protection contre la double connexion

if connection then return end

• Le danger : si on appelle startMovement(elevators) deux fois (erreur de copier-coller par exemple), on aurait deux boucles Heartbeat actives en même temps.
• Résultat catastrophique : chaque frame déplacerait les ascenseurs deux fois → vitesse doublée, elapsed doublé, chaos total !
• La protection : si connection existe déjà (pas nil), la fonction s’arrête immédiatement. Un seul Heartbeat possible, garanti. C’est une variante du principe du cooldown !

7. La vélocité pour transporter les joueurs (rappel !)

part.AssemblyLinearVelocity = properties.speed * properties.direction

• Technique du script précédent : même si la Part est ancrée, Roblox lit sa vélocité pour entraîner les joueurs debout dessus.
• En pause, on remet la vélocité à zéro (Vector3.new(0, 0, 0)) : arrêt propre, personne ne glisse.
• Détail important : ici la vitesse est un Vector3 (ex: Vector3.new(20, 20, 20)), donc l’ascenseur 1 monte en diagonale et le 2 avance horizontalement — la même fonction gère les deux cas !

---

QCM : Teste ta compréhension !

Sur le tableau des ascenseurs :

1. Que stocke elevators[part] ?
   • a) Une fiche de paramètres (vitesse, durée, pause, direction, temps écoulé) propre à chaque ascenseur.
   • b) Le nom du joueur.
   • c) La couleur de la Part.

2. Que fait speed = speed or Vector3.new(20, 20, 20) ?
   • a) Si aucune vitesse n’est fournie, on utilise la vitesse par défaut Vector3.new(20, 20, 20).
   • b) On additionne les deux vitesses.
   • c) On supprime la vitesse.

3. Quel est l’avantage de stocker tous les ascenseurs dans le tableau elevators ?
   • a) Une seule boucle Heartbeat gère tous les ascenseurs, même si on en ajoute 10 de plus.
   • b) Le jeu va plus vite.
   • c) Les ascenseurs sont plus colorés.

Sur la boucle pairs :

4. Que fait for part, properties in pairs(elevators) do ?
   • a) Parcourt le tableau associatif et donne chaque clé (part) et sa valeur (properties).
   • b) Parcourt uniquement les nombres de 1 à 10.
   • c) Supprime le tableau.

5. Quelle est la différence entre ipairs et pairs ?
   • a) ipairs parcourt les listes numérotées (1, 2, 3…), pairs parcourt les tableaux avec n’importe quelle clé (comme des Parts).
   • b) ipairs est plus rapide.
   • c) pairs ne fonctionne qu’avec des joueurs.

Sur la direction :

6. Que se passe-t-il quand properties.direction = -1 ?
   • a) L’ascenseur descend (vitesse multipliée par -1) et elapsed diminue.
   • b) L’ascenseur s’arrête.
   • c) L’ascenseur double de vitesse.

7. Pourquoi un seul calcul speed * direction * deltaTime gère-t-il montée, descente ET pause ?
   • a) Car multiplier par 1 donne la vitesse, par -1 l’inverse, et par 0 rien du tout.
   • b) Car Lua devine automatiquement quoi faire.
   • c) Car les ascenseurs sont intelligents.

Sur le chronomètre elapsed :

8. À quoi sert la variable elapsed ?
   • a) À compter le temps écoulé depuis le bas, pour savoir quand faire demi-tour.
   • b) À compter les joueurs sur l’ascenseur.
   • c) À afficher l’heure.

9. Que se passe-t-il quand elapsed >= duration ?
   • a) L’ascenseur est en haut : il se met en pause, puis repartira en descente.
   • b) Le jeu s’arrête.
   • c) L’ascenseur est détruit.

Sur les pauses et la protection :

10. Pourquoi utilise-t-on task.delay plutôt que task.wait pour la pause ?
    • a) task.wait bloquerait la boucle Heartbeat et figerait TOUS les ascenseurs ; task.delay programme la suite sans rien bloquer.
    • b) task.delay est plus court à écrire.
    • c) task.wait n’existe plus.

11. Que risque-t-on si on supprime la ligne if connection then return end et qu’on appelle startMovement deux fois ?
    • a) Deux boucles Heartbeat déplaceraient chaque ascenseur deux fois par frame : vitesse doublée et chaos.
    • b) Rien, c’est juste une décoration.
    • c) Le jeu planterait immédiatement.

12. Pourquoi met-on AssemblyLinearVelocity à zéro quand direction = 0 ?
    • a) Pour un arrêt propre : le joueur ne glisse pas pendant la pause de l’ascenseur.
    • b) Pour refroidir les moteurs.
    • c) Pour changer la couleur de l’ascenseur.

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)

Apprendre à déplacer une Part dans Roblox en utilisant les propriétés Position et Orientation. Ce tutoriel explique :

1. Comment accéder à une Part dans le Workspace.
2. Comment déplacer une Part en modifiant sa Position.
3. Comment faire tourner une Part en modifiant son Orientation.
4. Comment utiliser task.wait() pour créer des délais entre les mouvements.

Introduction : Pourquoi déplacer une Part ?

Dans Roblox, les Part sont les éléments de base pour construire des objets. Savoir les déplacer et les faire tourner permet de :

• Créer des animations (ex: une porte qui s’ouvre, un ascenseur qui monte).
• Simuler des mouvements (ex: un objet qui se déplace automatiquement).
• Contrôler des éléments du jeu (ex: une plateforme qui bouge).

Dans ce tutoriel, on va déplacer une Part dans différentes directions et la faire tourner autour des axes X, Y et Z.

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é MovementsFolder.
2. Ajouter une Part :
   • Ajoute une Part dans MovementsFolder.
   • Nomme-la Part (ou modifie le nom dans le script).
3. Ajouter le script :
   • Crée un Script dans ServerScriptService et copie-y le code fourni.
4. Lancer le jeu :
   • Observe la Part :
     • Après 5 secondes, elle commence à se déplacer.
     • Elle se déplace sur les axes X, Y et Z, puis tourne autour des axes X, Y et Z.

Voici le script commenté sous ServerScriptService :

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

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

-- Empêcher la Part de bouger à cause des collisions ou de la gravité
movingPart.Anchored = true

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

-- Déplacer la Part de +50 unités sur l'axe X (droite)
movingPart.Position += Vector3.new(50, 0, 0)
task.wait(1)  -- Attendre 1 seconde

-- Déplacer la Part de -50 unités sur l'axe X (gauche, retourne à la position initiale)
movingPart.Position += Vector3.new(-50, 0, 0)
task.wait(1)

-- Déplacer la Part de +50 unités sur l'axe Z (avant)
movingPart.Position += Vector3.new(0, 0, 50)
task.wait(1)

-- Déplacer la Part de -50 unités sur l'axe Z (arrière, retourne à la position initiale)
movingPart.Position += Vector3.new(0, 0, -50)
task.wait(1)

-- Déplacer la Part de +50 unités sur l'axe Y (haut)
movingPart.Position += Vector3.new(0, 50, 0)
task.wait(1)

-- Déplacer la Part de -50 unités sur l'axe Y (bas, retourne à la position initiale)
movingPart.Position += Vector3.new(0, -50, 0)
task.wait(1)

-- Faire tourner la Part de +10 degrés autour de l'axe Y (rotation vers la droite)
movingPart.Orientation += Vector3.new(0, 10, 0)
task.wait(1)

-- Faire tourner la Part de -10 degrés autour de l'axe Y (rotation vers la gauche, retourne à l'orientation initiale)
movingPart.Orientation += Vector3.new(0, -10, 0)
task.wait(1)

-- Faire tourner la Part de +10 degrés autour de l'axe Z (rotation vers le haut)
movingPart.Orientation += Vector3.new(0, 0, 10)
task.wait(1)

-- Faire tourner la Part de -10 degrés autour de l'axe Z (rotation vers le bas, retourne à l'orientation initiale)
movingPart.Orientation += Vector3.new(0, 0, -10)
task.wait(1)

-- Faire tourner la Part de +10 degrés autour de l'axe X (rotation vers l'avant)
movingPart.Orientation += Vector3.new(10, 0, 0)
task.wait(1)

-- Faire tourner la Part de -10 degrés autour de l'axe X (rotation vers l'arrière, retourne à l'orientation initiale)
movingPart.Orientation += Vector3.new(-10, 0, 0)

Explications Détaillées

1. Accéder à une Part dans le Workspace

local movementsFolder = workspace:WaitForChild("MovementsFolder")
local movingPart = movementsFolder:WaitForChild("Part")

• workspace:WaitForChild("MovementsFolder") :
  • Attend que le dossier MovementsFolder existe dans le Workspace.
  • Si le dossier n’existe pas encore, le script attend qu’il soit créé.
• movementsFolder:WaitForChild("Part") :
  • Attend que la Part existe dans le dossier MovementsFolder.
  • Si la Part n’existe pas encore, le script attend qu’elle soit créée.
• Pourquoi utiliser WaitForChild ?
  • Cela évite les erreurs si le dossier ou la Part ne sont pas encore chargés quand le script s’exécute.

2. Empêcher la Part de bouger (Anchored)

movingPart.Anchored = true

• Anchored = true :
  • Empêche la Part de bouger à cause de la gravité ou des collisions.
  • Sans cela, la Part tomberait ou serait poussée par d’autres objets.
• Pourquoi est-ce important ?
  • Si Anchored = false, la Part serait soumise à la physique (gravité, collisions), ce qui rendrait les mouvements imprévisibles.

3. Déplacer une Part avec Position

movingPart.Position += Vector3.new(50, 0, 0)

• Position :
  • Propriété qui stocke la position de la Part dans l’espace 3D (coordonnées X, Y, Z).
  • Exemple : Vector3.new(50, 0, 0) signifie 50 unités sur l’axe X, 0 sur Y, 0 sur Z.
• += :
  • Ajoute un Vector3 à la position actuelle.
  • Exemple : Si movingPart.Position = Vector3.new(0, 0, 0), alors après += Vector3.new(50, 0, 0), la nouvelle position sera Vector3.new(50, 0, 0).
• Axes dans Roblox : Axe Direction Exemple de mouvement X Gauche/Droite Vector3.new(50, 0, 0) → Déplacement vers la droite Y Haut/Bas Vector3.new(0, 50, 0) → Déplacement vers le haut Z Avant/Arrière Vector3.new(0, 0, 50) → Déplacement vers l’avant

4. Faire tourner une Part avec Orientation

movingPart.Orientation += Vector3.new(0, 10, 0)

• Orientation :
  • Propriété qui stocke la rotation de la Part autour des axes X, Y et Z (en degrés).
  • Exemple : Vector3.new(0, 10, 0) signifie 10 degrés autour de l’axe Y.
• += :
  • Ajoute une rotation à l’orientation actuelle.
  • Exemple : Si movingPart.Orientation = Vector3.new(0, 0, 0), alors après += Vector3.new(0, 10, 0), la nouvelle orientation sera Vector3.new(0, 10, 0).
• Axes de rotation : Axe Rotation Exemple X Inclinaison avant/arrière Vector3.new(10, 0, 0) → Rotation vers l’avant Y Rotation gauche/droite Vector3.new(0, 10, 0) → Rotation vers la droite Z Rotation autour de l’axe vertical Vector3.new(0, 0, 10) → Rotation dans le sens horaire

5. Créer des délais avec task.wait()

task.wait(5)  -- Attendre 5 secondes

• task.wait(durée) :
  • Pause l’exécution du script pendant durée secondes.
  • Exemple : task.wait(1) attend 1 seconde avant de continuer.
• Pourquoi utiliser task.wait() ?
  • Pour espacer les mouvements et les rendre visibles.
  • Sans délai, les mouvements seraient trop rapides pour être vus.

---

QCM : Teste ta compréhension !

Sur l’accès aux objets :

1. Que fait workspace:WaitForChild("MovementsFolder") ?
   • a) Attend que le dossier MovementsFolder existe dans le Workspace.
   • b) Crée un nouveau dossier.
   • c) Supprime le dossier.

2. Pourquoi utilise-t-on WaitForChild ?
   • a) Pour éviter les erreurs si l’objet n’existe pas encore.
   • b) Pour accélérer le script.
   • c) Pour changer la couleur de la Part.

Sur le déplacement :

3. Que fait movingPart.Position += Vector3.new(50, 0, 0) ?
   • a) Déplace la Part de 50 unités vers la droite (axe X).
   • b) Déplace la Part de 50 unités vers le haut (axe Y).
   • c) Déplace la Part de 50 unités vers l’avant (axe Z).

4. Que fait Vector3.new(0, 50, 0) ?
   • a) Crée un vecteur pour déplacer la Part de 50 unités vers le haut.
   • b) Crée un vecteur pour faire tourner la Part.
   • c) Crée un vecteur pour changer la couleur de la Part.

5. Pourquoi utilise-t-on Anchored = true ?
   • a) Pour empêcher la Part de bouger à cause de la gravité ou des collisions.
   • b) Pour rendre la Part invisible.
   • c) Pour supprimer la Part.

Sur la rotation :

6. Que fait movingPart.Orientation += Vector3.new(0, 10, 0) ?
   • a) Fait tourner la Part de 10 degrés autour de l’axe Y (droite/gauche).
   • b) Fait tourner la Part de 10 degrés autour de l’axe X (avant/arrière).
   • c) Fait tourner la Part de 10 degrés autour de l’axe Z (sens horaire/anti-horaire).

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

Sur les délais :

8. À quoi sert task.wait(5) ?
   • a) Attendre 5 secondes avant de continuer le script.
   • b) Accélérer le script.
   • c) Supprimer la Part.

9. Pourquoi utilise-t-on task.wait(1) entre chaque mouvement ?
   • a) Pour espacer les mouvements et les rendre visibles.
   • b) Pour économiser de la mémoire.
   • c) Pour changer la couleur de la Part.