Générer un escalier

avec une Boucle et des Clones

Apprendre à faire construire un escalier géant de 200 marches par le script lui-même ! Au lieu de placer les marches une par une à la main dans Roblox Studio (bon courage pour 200 marches ! :

Utiliser une Part modèle (template) qui sert de moule.
Cloner cette Part dans une boucle for (rappel du tutoriel de la pyramide !).
Positionner chaque marche avec un calcul basé sur le numéro de la marche (i).
Ranger proprement les marches dans un dossier créé par le script.

Ce tutoriel réunit des briques déjà connues : Clone(), Parent, Instance.new, les boucles for, les Vector3 et les paramètres en variables !

Introduction : Pourquoi générer un escalier par script ?

Imagine que tu veuilles construire un escalier de 200 marches dans Studio :

Chaque marche doit être positionnée un peu plus haut et un peu plus loin que la précédente.
À la main, c’est 200 manipulations… et si tu veux changer la hauteur des marches, il faut tout recommencer !

Avec un script :

Les 200 marches sont créées en moins d’une seconde.
Changer la hauteur, la largeur, le nombre de marches = changer 1 nombre et relancer !
Le niveau reste parfaitement régulier (aucune marche de travers !).

C’est toute la puissance de la programmation : l’ordinateur exécute les tâches répétitives à ta place.

Générer un escalier droit

Voici le script simple commenté en français :

-- Récupérer le dossier et la Part modèle (le "moule" des marches)
local stairsFolder = workspace:WaitForChild("Folder")
local template = stairsFolder:WaitForChild("Part")

-- Ancrer le modèle pour qu'il ne tombe pas pendant la construction
template.Anchored = true
template.Size = Vector3.new(8, 0.5, 4)

-- Boucle : créer les marches une par une
-- i va de 1 à 10 
for i = 1, 10 do
	-- 1) Cloner le modèle
	local step = template:Clone()

	-- 3) LE CŒUR DU SCRIPT : positionner la marche
	-- La marche n° i se trouve à :
	--   - X : interval * i  → chaque marche est décalée de "interval" studs vers l'avant
	--   - Y : (step.Size.Y + hauteur) * i → chaque marche est décalée vers le HAUT
	--   - Z : 0 → pas de décalage sur l'axe Z (escalier droit !)
	step.Position += Vector3.new(
		3 * i,                          -- décalage horizontal
		(step.Size.Y + 1) * i,               -- décalage vertical
		0                                      -- pas de décalage Z
	)

	-- 4) Attacher la marche au dossier et la nommer
	step.Parent = stairsFolder
	step.Name = "Step" .. i     -- "Step0", "Step1", "Step2"...
end

Et le script modifié pour le même résultat mais avec des constantes pour mieux modifier le code :

-- Récupérer le dossier et la Part modèle (le "moule" des marches)
local stairsFolder = workspace:WaitForChild("Folder")
local template = stairsFolder:WaitForChild("Part2")

-- ============================================================
-- PARAMÈTRES : c'est ICI que tout se règle ! Modifie-les !
-- ============================================================
local stepCount = 200          -- nombre de marches
local rise = 2                 -- hauteur gagnée par marche (studs)
local stepWidth = 4            -- largeur de la marche (axe X)
local stepDepth = 8            -- profondeur de la marche (axe Z) — espace pour poser le pied
local stepThickness = 0.5      -- épaisseur de la planche de la marche
local interval = 5            -- distance entre deux marches (axe X)

-- Ancrer le modèle pour qu'il ne tombe pas pendant la construction
template.Anchored = true
template.Size = Vector3.new(stepWidth, stepThickness, stepDepth)

-- Boucle : créer les marches une par une
-- i va de 0 à stepCount - 1 (donc 200 tours pour stepCount = 200)
for i = 1, stepCount do
	-- 1) Cloner le modèle
	local step = template:Clone()

	-- 3) LE CŒUR DU SCRIPT : positionner la marche
	-- La marche n° i se trouve à :
	--   - X : interval * i  → chaque marche est décalée de "interval" studs vers l'avant
	--   - Y : (step.Size.Y + rise) * i → chaque marche est décalée vers le HAUT
	--   - Z : 0 → pas de décalage sur l'axe Z (escalier droit !)
	step.Position += Vector3.new(
		interval * i,                          -- décalage horizontal
		(step.Size.Y + rise) * i,               -- décalage vertical
		0                                      -- pas de décalage Z
	)

	-- 4) Attacher la marche au dossier et la nommer
	step.Parent = stairsFolder
	step.Name = "Step" .. i     -- "Step0", "Step1", "Step2"...
end

Explications Détaillées

1. La Part modèle (template) : le moule

local template = folder:WaitForChild("Part")

La Part nommée Part dans le dossier Folder ne sera jamais visible dans le jeu : elle sert uniquement de moule.
template:Clone() (rappel du tutoriel de la pyramide inversée !) crée une copie exacte à chaque tour de boucle.
À la fin, template:Destroy() supprime le moule : il a fait son travail ! (La ligne est facultative : sans elle, le moule resterait visible au sol.)

2. Les paramètres : le tableau de bord de l’escalier

local stepCount = 200
local rise = 2
local stepWidth = 4
local stepDepth = 8
local stepThickness = 0.5
local interval = 5

Toutes les dimensions sont des variables en haut du script : c’est le tableau de bord ! Expérimente :

Paramètre	Rôle	Que se passe-t-il si tu le changes ?
`stepCount`	Nombre de marches	`10` → un petit escalier de test ! `500` → une échelle vers le ciel !
`rise`	Hauteur gagnée par marche	`1` → escalier doux. `5` → escalier raide qu’on ne peut pas grimper !
`stepWidth`	Largeur (axe X)	`20` → autoroute géante !
`stepDepth`	Profondeur (axe Z)	`2` → marches minuscules, impossible de monter.
`stepThickness`	Épaisseur de la planche	`2` → marches massives.
`interval`	Distance entre marches (axe X)	`2` → marches serrées, plus facile à monter !

⚠️ Rappel important : pour qu’un joueur puisse monter l’escalier, la hauteur gagnée par marche (rise + stepThickness) doit rester inférieure à la hauteur de marche maximale que Roblox permet de franchir (environ 2.2 studs par défaut). Ici : stepThickness (0.5) + rise (2) = 2.5… c’est juste au-dessus ! Si ton joueur bloque sur une marche, réduis rise à 1.5 ! C’est le genre de chose qu’on découvre… en testant !

3. LA LIGNE MAGIQUE : le calcul de la position

step.Position += Vector3.new(interval * i, (step.Size.Y + rise) * i, 0)

C’est le cœur du tutoriel ! Décomposons-la :

**L’axe X : `interval * i`**

Marche n° 0 : décalage = 5 × 0 = 0 → position du moule.
Marche n° 1 : décalage = 5 × 1 = 5 studs.
Marche n° 2 : décalage = 5 × 2 = 10 studs.
Marche n° 199 : décalage = 5 × 199 = 995 studs !
Le numéro de la marche i pilote son décalage : plus i est grand, plus la marche est loin. C’est ça, une progression arithmétique (des maths de collège ! ).

**L’axe Y : `(step.Size.Y + rise) * i`**

Chaque marche est posée au-dessus de la précédente.
Pourquoi step.Size.Y + rise et pas juste rise ? L’épaisseur de la planche (stepThickness) doit être ajoutée : sans elle, chaque marche serait enfoncée dans la précédente au lieu d’être posée dessus. Le saut vertical entre deux marches = l’épaisseur de la planche + la hauteur gagnée.
Marche n° 199 : hauteur ≈ 2.5 × 199 = 497.5 studs… un escalier qui monte jusqu’au ciel !

L’axe Z : `0`

Aucun décalage : les marches s’alignent droit. C’est pour ça que le dossier s’appelle « EscalierDroit » !

La position de départ : `+=`

step.Position += ... : on part de la position du moule et on ajoute le décalage. Avantage : l’escalier se construit où que tu aies placé la Part modèle ! Déplace le moule dans Studio → tout l’escalier suit !

4. La boucle et le compteur `i`

for i = 0, stepCount - 1 do

Pourquoi commencer à 0 et finir à stepCount - 1 ? Avec i = 0, la première marche est positionnée exactement à l’emplacement du moule (décalage × 0 = aucun décalage). C’est plus intuitif pour placer l’escalier !
On pourrait aussi écrire for i = 1, stepCount — mais alors le calcul des positions devrait devenir (i - 1) partout. Choisir 0, c’est éviter les -1 partout !
step.Name = "Step" .. i (rappel : concaténation avec un nombre !) : chaque marche a un nom unique → on pourra la retrouver plus tard avec FindFirstChild("Step" .. i).

Préparation dans Roblox Studio

Dans Workspace, crée un dossier nommé Folder.
Ajoute une Part nommée Part dans ce dossier : c’est le moule.
- Place-la à l’endroit où l’escalier doit commencer.
- Sa taille n’a pas grande importance (le script la règle à chaque clone !), mais tu peux lui donner une couleur sympa : toutes les marches hériteront de cette couleur (et du matériau !).
Crée un Script dans ServerScriptService et colle le code corrigé.
Lance le jeu :
- L’escalier de 200 marches se construit instantanément !
- Dans l’Explorer, un dossier EscalierDroit contient Step0, Step1, … Step199.
- Le moule a disparu (Destroy).
Teste la montée : ton joueur peut-il grimper ? Si les marches sont trop hautes, réduis rise !

⚠️ Conseil de test : mets stepCount = 10 pendant tes essais (escalier court, facile à inspecter), et seulement à la fin remets 200 !

QCM : Teste ta compréhension !

Sur le moule (template) :

À quoi sert la Part nommée Part dans le dossier ?
- a) C’est la première marche de l’escalier.
- b) Elle sert à décorer le niveau.
- c) C’est un moule : le script la clone pour créer chaque marche, puis la détruit.

Pourquoi appelle-t-on template:Destroy() à la fin ?
- a) Le moule a servi et n’a plus d’utilité : on nettoie le niveau.
- b) Pour supprimer tout l’escalier.
- c) C’est obligatoire sinon le jeu plante.

Sur les paramètres :

Que se passe-t-il si on change stepCount = 200 en stepCount = 50 ?
- a) Les marches sont 4 fois plus petites.
- b) L’escalier ne fait plus que 50 marches (il est 4 fois plus court).
- c) Rien ne change.

Pourquoi les dimensions sont-elles mises en variables en haut du script ?
- a) Parce que Lua oblige.
- b) Pour décorer le script.
- c) Pour pouvoir ajuster l’escalier facilement en changeant un seul nombre, sans toucher au reste du code.

Sur le calcul de position :

Pour la marche n° 3 (i = 3), quel est son décalage horizontal (axe X) avec interval = 5 ?
- a) 15 studs (interval * i = 5 × 3).
- b) 5 studs.
- c) 3 studs.

Pourquoi ajoute-t-on step.Size.Y dans le calcul vertical (step.Size.Y + rise) * i ?
- a) Pour changer la couleur des marches.
- b) Pour compenser l’épaisseur de la planche : sinon chaque marche serait enfoncée dans la précédente au lieu d’être posée dessus.
- c) Pour aller plus vite.

Pourquoi le décalage Z est-il à 0 ?
- a) Parce que l’escalier est DROIT : les marches avancent sur un seul axe, sans tourner.
- b) Parce que l’axe Z n’existe pas.
- c) Parce que les marches sont invisibles.

Que signifie step.Position += Vector3.new(...) ?
- a) On remplace la position par celle du moule.
- b) On AJOUTE le décalage à la position actuelle du clone (celle du moule) — l’escalier se construit là où est placé le moule.
- c) On supprime la position.
  Réponse : a)

Sur la boucle :

Pourquoi la boucle va-t-elle de 0 à stepCount - 1 ?
- a) Pour que la première marche (i = 0) soit positionnée exactement à l’emplacement du moule, sans décalage.
- b) Parce que Lua interdit de commencer à 1.
- c) Pour économiser une marche.

Pourquoi chaque marche reçoit-elle un nom "Step" .. i ?
- a) Pour avoir un nom unique et pouvoir retrouver chaque marche plus tard (FindFirstChild).
- b) Pour la détruire immédiatement.
- c) Pour changer sa couleur.

Pourquoi range-t-on toutes les marches dans le dossier EscalierDroit ?
- a) Pour garder l’Explorer propre et pouvoir manipuler tout l’escalier d’un seul coup.
- b) Parce que les Parts ne peuvent pas être ailleurs.
- c) Pour rien.

Idées pour aller plus loin

1. Un escalier aux couleurs dégradées

Objectif : dégradé du bleu au rouge du bas en haut (rappel des boucles de couleurs du tutoriel de découverte !).
Comment faire ? Calcule la couleur avec i :

-- Dans la boucle : 
local ratio = i / stepCount -- de 0 à 1 
step.Color = Color3.fromRGB(255 * ratio, 0, 255 * (1 - ratio))

2. Une marche sur deux avec un effet spécial

Objectif : les marches paires sont normales, les marches impaires personnalisées !
Comment faire ? Utilise l’opérateur modulo (i % 2) qui donne le reste de la division :

if i % 2 == 1 then -- marches impaires           step.Color = Color3.fromRGB(0, 255, 0) 
        step.BrickColor = BrickColor.new("Lime green") 
end

3. Un escalier construit marche par marche (effet visuel)

Objectif : voir l’escalier se construire sous tes yeux.
Comment faire ? Ajoute task.wait(0.05) à la fin de la boucle : chaque marche apparaît l’une après l’autre ! Pour 200 marches, ça donne un bel effet de construction.

4. Démontage progressif de l’escalier

Objectif : comme pour la pyramide, détruire les marches une par une (mode « escalier qui s’effondre » !).
Comment faire ? (rappel du tutoriel de découverte !)
task.wait(3) for i = stepCount - 1, 0, -1 do stairsFolder:FindFirstChild("Step" .. i):Destroy() task.wait(0.1) end

for i = stepCount - 1, 0, -1 do 
  stairsFolder:FindFirstChild("Step" .. i):Destroy()
  task.wait(0.1)
 
end

Résumé des concepts clés

Concept	Description	Exemple
Part modèle (template)	Un moule cloné autant de fois que nécessaire, puis détruit.	`template:Clone()`
Paramètres en variables	Toutes les dimensions réglables en haut du script.	`stepCount`, `rise`, `interval`
Boucle `for` génératrice	Le compteur `i` pilote à la fois le nombre ET la position.	`for i = 0, stepCount - 1 do`
Progression arithmétique	Décalage = valeur × numéro de la marche.	`interval * i`
`Vector3.new` de position	Décalage X (avant), Y (haut), Z (côté).	‘`+= Vector3.new(intervali, hauteuri, 0)`
`Instance.new("Folder")`	Créer un dossier par le script pour ranger les clones.	`.Parent = workspace`
Noms uniques	Retrouver chaque clone plus tard.	`"Step" .. i`
Ne pas masquer les variables	Deux variables du même nom = confusion !	`folder` vs `stairsFolder`

Astuce : teste toujours avec stepCount = 10 avant de passer à 200 — un escalier court, c’est plus rapide à inspecter, et tu gagneras un temps fou pendant tes réglages

Générer un escalier hélicoïdal ou en colimaçon

local folder = workspace:WaitForChild("Folder")
local template = folder:WaitForChild("Part")

-- Paramètres
local stepCount = 400        -- nombre de marches
local angleStep = 15        -- degrés entre deux marches (360 / 15 = 24 marches par tour)
local rise = 1              -- hauteur gagnée par marche (studs)
local radius = 12           -- distance entre l'axe de l'escalier et le centre d'une marche
local stepWidth = 8         -- largeur radiale de la marche
local stepThickness = 0.5   -- épaisseur de la marche
local center = template.Position

-- Profondeur de la marche : corde de l'arc extérieur, pour éviter les trous entre deux marches
local outerRadius = radius + stepWidth / 2
local stepDepth = 2 * outerRadius * math.sin(math.rad(angleStep) / 2)

template.Anchored = true
local stairsFolder = Instance.new("Folder")
stairsFolder.Name = "EscalierHelicoidal"
stairsFolder.Parent = workspace


for i = 0, stepCount - 1 do
	local step = template:Clone()
	
	step.Size = Vector3.new(stepWidth, stepThickness, stepDepth)
	step.Anchored = true
	
	local ratio = i / stepCount -- de 0 à 1 
	step.Color = Color3.fromRGB(255 * ratio, 0, 255 * (1 - ratio))	
	
	-- 1) on se place à la bonne hauteur, 2) on tourne autour de l'axe Y,
	-- 3) on s'écarte du centre : la marche est ainsi orientée radialement
	step.CFrame = CFrame.new(center + Vector3.new(0, i * rise, 0))
		* CFrame.Angles(0, math.rad(i * angleStep), 0)
		* CFrame.new(radius, 0, 0)

	step.Parent = stairsFolder
end

template:Destroy() -- retire la part modèle (facultatif)