Déplacer des Ascenseurs avec TweenService

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

Script 1 : animer un seul ascenseur avec un Tween.
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

Dans Workspace, crée un dossier MovementsFolder.
Ajoute deux Part nommées Part et Part02 (plates et larges : Size = Vector3.new(20, 1, 20)).
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 !).
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 :

À 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.

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.

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.

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

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 :

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.

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.

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 :

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.

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.

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.

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, ...)`