123Codage

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 ! :

1. Utiliser une Part modèle (template) qui sert de moule.
2. Cloner cette Part dans une boucle for (rappel du tutoriel de la pyramide !).
3. Positionner chaque marche avec un calcul basé sur le numéro de la marche (i).
4. 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.

Préparation dans Roblox Studio

1. Dans Workspace, crée un dossier nommé Folder.
2. 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 !).
3. Crée un Script dans ServerScriptService et colle le code.
4. Lance le jeu :
   • L’escalier de 200 marches se construit instantanément !
   • Dans l’Explorer, un dossier EscalierDroit contient Step0, Step1, … Step199.
5. 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 !

Générer une échelle

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(
		0,                          -- 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

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(4, 0.5, 8)

-- 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("Part")

-- ============================================================
-- 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).

---

QCM : Teste ta compréhension !

Sur le moule (template) :

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

2. 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 :

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

4. 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 :

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

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

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

8. 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 :

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

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

11. 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(interval*i, hauteur*i, 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ère ton escalier par une fonction paramètrable

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

-- ============================================================
-- PARAMÈTRES : c'est ICI que tout se règle ! Modifie-les !
-- ============================================================

local function createStairs(base, stepCount, rise, interval, stepWidth, stepDepth, stepThickness)
	-- 2) Vérifier que le modèle a une base pour se coller

	if not base:IsA("BasePart") then
		warn("❌ Le modèle doit être une Part pour être cloné !")
		return
	end
	
	if not stepCount then stepCount = 12 end
	if not rise then rise = 2 end -- hauteur entre chaque marche
	if not interval then interval = 5 end -- décalage entre chaque marche
	if not stepWidth then stepWidth = base.Size.X end
	if not stepDepth then stepDepth = base.Size.Z end
	if not stepThickness then stepThickness = base.Size.Y end

	
	-- 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
end

createStairs(template)

Dans tous les sens :

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

-- ============================================================
-- PARAMÈTRES : c'est ICI que tout se règle ! Modifie-les !
-- ============================================================

local function createStairs(base, stepCount, rise, name, intervalX, intervalZ, stepWidth, stepDepth, stepThickness)
	-- 2) Vérifier que le modèle a une base pour se coller

	if not base:IsA("BasePart") then
		warn("❌ Le modèle doit être une Part pour être cloné !")
		return
	end
	
	if not stepCount then stepCount = 12 end
	if not name then name = "Step" end -- Par defaut "Step"
	if not rise then rise = 2 end -- hauteur entre chaque marche
	if not intervalX then intervalX = 5 end -- décalage entre chaque marche
	if not intervalZ then intervalZ = 0 end -- décalage entre chaque marche
	if not stepWidth then stepWidth = base.Size.X end
	if not stepDepth then stepDepth = base.Size.Z end
	if not stepThickness then stepThickness = base.Size.Y end

	
	-- 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(
			intervalX,                          -- décalage horizontal
			(step.Size.Y + rise),               -- décalage vertical
			intervalZ                                      -- pas de décalage Z
		) * i

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

createStairs(template, 20, 1 , "StairA", 5, 0)
createStairs(template, 20, 1 , "StairB", -5, 0)
createStairs(template, 20, 1 , "StairC", 0, -5)
createStairs(template, 20, 1 , "StairD", 0, 5)
createStairs(template, 20, 1 , "StairE", 5, 5)
createStairs(template, 20, 1 , "StairF", -5, 5)
createStairs(template, 20, 1 , "StairG", 5, -5)
createStairs(template, 20, 1 , "StairH", -5, -5)

---

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)

et les changements d’états

Découvrir la vie d’un joueur dans Roblox avec un script « d’observation » :

1. Quand un joueur se connecte (PlayerAdded).
2. Quand son personnage apparaît (CharacterAdded).
3. Quand son personnage change d’état (StateChanged : saut, chute, atterrissage…).

Ce script n’est pas un jeu : c’est un script espion ! Il ne fait qu’afficher dans la console (Output) tout ce qui arrive aux joueurs. C’est l’outil parfait pour comprendre ces trois événements avant de les utiliser dans de vrais jeux (comme la zone anti-gravité ou les checkpoints !).

Introduction : La vie d’un joueur Roblox

Quand tu joues à un jeu Roblox, voici ce qui se passe dans l’ordre :

1. Le JOUEUR se connecte au jeu        → événement PlayerAdded
2. Son PERSONNAGE apparaît dans le monde → événement CharacterAdded
3. Le personnage agit : court, saute, tombe, atterrit...
                                          → événements StateChanged (très fréquents !)
4. Le personnage meurt → il est détruit
5. Un NOUVEAU personnage apparaît        → de nouveau CharacterAdded !
6. Le joueur quitte le jeu               → événement PlayerRemoving

Les trois personnages-clés de ce tuto :

• player : le compte du joueur (son nom, son UserId…). Il ne meurt jamais.
• character : le bonhomme 3D dans le monde (le Model). Il est détruit à chaque mort et recréé à chaque respawn !
• humanoid : l’ordinateur de bord du personnage : il gère la santé, la marche, les sauts… et ses états.

Les états d’un Humanoid (Enum.HumanoidStateType)

État	Signification
Running	Le personnage court au sol.
Jumping	Il vient de sauter.
Freefall	Il tombe dans les airs.
Landed	Il vient d’atterrir.
Climbing	Il grimpe à une échelle.
Swimming	Il nage.
Seated	Il est assis (dans un siège).
Dead	Il est mort !
PlatformStanding / Physics	États spéciaux (plateformes, physique).

C’est la même liste que celle utilisée dans le tutoriel de la zone anti-gravité (Jumping, Freefall, Landed) !

Voici le script commenté en français :

-- Récupérer le service des joueurs
local Players = game:GetService("Players")

-- Fonction appelée à chaque changement d'état du Humanoid
-- Paramètres : le joueur, l'ancien état, le nouvel état
local function onStateChanged(player, oldState, newState)
    -- Affiche dans la console : nom du joueur, ancien état -> nouvel état
    print(player.Name, "État changé :", oldState, "->", newState)
end

-- Fonction appelée à chaque apparition du personnage
local function onCharacterAdded(player, character)
    -- Attendre que le Humanoid existe (le personnage se construit progressivement !)
    local humanoid = character:WaitForChild("Humanoid")

    -- Connecter le suivi des changements d'états de CE personnage
    humanoid.StateChanged:Connect(function(oldState, newState)
        onStateChanged(player, oldState, newState)
    end)
end

-- Fonction appelée à chaque connexion d'un joueur
local function onPlayerAdded(player)
    print(player.Name .. " est connecté")

    -- Cas 1 : le personnage existe DÉJÀ (joueur connecté avant le script)
    if player.Character then
        task.spawn(onCharacterAdded, player, player.Character)
    end

    -- Cas 2 : chaque apparition/réapparition FUTURE (mort, respawn...)
    player.CharacterAdded:Connect(function(character)
        onCharacterAdded(player, player.Character and character)
    end)
end

-- Nouveaux joueurs : événement pour chaque joueur qui se connecte
Players.PlayerAdded:Connect(onPlayerAdded)

-- Joueurs déjà connectés AVANT l'exécution du script
for _, player in ipairs(Players:GetPlayers()) do
    task.spawn(onPlayerAdded, player)
end

Explications Détaillées : les 4 fonctions du script

Le script est construit comme des poupées russes : chaque fonction appelle la suivante !

onPlayerAdded ──► onCharacterAdded ──► onStateChanged
     (1)                (2)                  (3)

1. onStateChanged : l’espion des états

local function onStateChanged(player, oldState, newState)
    print(player.Name, "État changé :", oldState, "->", newState)
end

• oldState : l’état avant le changement (ex: Enum.HumanoidStateType.Freefall).
• newState : le nouvel état (ex: Enum.HumanoidStateType.Landed).
• Rappel des tutoriels précédents : print(...) avec plusieurs valeurs séparées par des virgules affiche tout sur une ligne (pas besoin de concaténer avec .. !).

2. onCharacterAdded : l’espion des personnages

local function onCharacterAdded(player, character)
    local humanoid = character:WaitForChild("Humanoid")
    humanoid.StateChanged:Connect(function(oldState, newState)
        onStateChanged(player, oldState, newState)
    end)
end

• WaitForChild("Humanoid") : quand le personnage apparaît, il se construit pièce par pièce (jambes, torse, tête, Humanoid…). Si on cherche le Humanoid trop tôt, il n’existe pas encore → erreur ! WaitForChild attend qu’il soit prêt. (Rappel : c’est pareil que WaitForChild("HumanoidRootPart") dans le tutoriel des checkpoints !)
• On connecte StateChanged pour ce personnage précis. Quand il mourra, ce personnage sera détruit — et sa connexion avec lui ! C’est pour ça qu’il faut reconnecter StateChanged à chaque nouveau personnage (d’où la fonction !).

3. onPlayerAdded : l’espion des joueurs (avec ses DEUX pièges !)

local function onPlayerAdded(player)
    print(player.Name .. " est connecté")

    -- Cas 1 : le personnage existe DÉJÀ
    if player.Character then
        task.spawn(onCharacterAdded, player, player.Character)
    end

    -- Cas 2 : apparitions futures
    player.CharacterAdded:Connect(function(character)
        onCharacterAdded(player, character)
    end)
end

Piège n°1 : le joueur est arrivé AVANT le script !

• Le problème : PlayerAdded ne se déclenche que pour les joueurs qui arrivent après la connexion de l’événement. Si tu es déjà dans le jeu quand le script démarre (par exemple au lancement d’un test Studio), l’événement t’a raté !
• La solution en deux temps :
  • Cas 1 : if player.Character then → le personnage existe déjà → on appelle directement onCharacterAdded.
  • Cas 2 : player.CharacterAdded:Connect(...) → on guette toutes les apparitions futures (respawn après mort !).

Piège n°2 : CharacterAdded ne se déclenche pas à la connexion… mais un peu après !

• Quand un joueur se connecte, PlayerAdded se déclenche, puis Roblox crée son personnage (quelques millisecondes plus tard) → c’est ensuite que CharacterAdded se déclenche. C’est pour ça que le Cas 2 attrape aussi la toute première apparition !

Pourquoi task.spawn ?

• task.spawn(fonction, arguments...) lance la fonction dans un thread séparé : le script n’attend pas qu’elle soit finie pour continuer.
• Indispensable ici : onCharacterAdded commence par un WaitForChild… qui peut bloquer quelques instants. Sans task.spawn, un joueur « lent à charger » bloquerait le traitement des autres joueurs !

4. La boucle finale : rattraper tout le monde

Players.PlayerAdded:Connect(onPlayerAdded)

for _, player in ipairs(Players:GetPlayers()) do
    task.spawn(onPlayerAdded, player)
end

• Players.PlayerAdded:Connect(onPlayerAdded) : tous les joueurs qui arriveront à partir de maintenant.
• Players:GetPlayers() : la liste des joueurs déjà présents (rappel : c’est une liste numérotée, donc on utilise ipairs, comme pour les checkpoints et les blocs de la pyramide !).
• La boucle appelle onPlayerAdded pour chacun : personne n’est oublié, même si le script a démarré en retard !

Le schéma complet :

---

Préparation et Test dans Roblox Studio

1. Crée un Script dans ServerScriptService et colle le code corrigé.
2. Ouvre la fenêtre Output (onglet View → Output) : c’est là que les print s’affichent.
3. Lance le jeu en mode multi-joueurs (onglet Test → 2 Players) pour observer plusieurs joueurs !
4. Expérimente et observe la console :

Action	Ce que tu dois voir dans l’Output
Le jeu démarre	patrick est connecté (et celui du 2ème joueur !)
Tu marches	Rien (rester en Running ne change pas l’état !)
Tu sautes	Jumping puis Freefall
Tu atterris	Landed puis Running
Tu montes une échelle	Climbing
Tu tombes dans l’eau	Swimming
Tu t’assois sur un siège	Seated
Tu te reset (menu Echap → Reset)	Dead… puis re-connexion automatique de CharacterAdded !

Contrôle important : après ta mort, observe bien : onCharacterAdded est rappelé automatiquement pour ton nouveau personnage (le script continue d’afficher tes états, sans rien refaire !). C’est la preuve que le Cas 2 de onPlayerAdded fonctionne.

---

QCM : Teste ta compréhension !

Sur la vie du joueur :

1. Dans quel ordre se passent les événements quand un joueur rejoint le jeu ?
   • a) PlayerAdded → CharacterAdded → puis les StateChanged.
   • b) CharacterAdded → PlayerAdded → StateChanged.
   • c) Tout en même temps.

2. Quelle est la différence entre player et character ?
   • a) player est le compte (ne meurt jamais) ; character est le bonhomme 3D, détruit à chaque mort et recréé à chaque respawn.
   • b) Ce sont deux noms pour la même chose.
   • c) character est le compte du joueur.

3. Que se passe-t-il pour la connexion StateChanged quand le personnage meurt et respawn ?
   • a) Elle est détruite avec l’ancien personnage ; onCharacterAdded reconnecte StateChanged sur le NOUVEAU Humanoid.
   • b) Elle reste active sur l’ancien personnage.
   • c) Roblox la reconnecte automatiquement tout seul.

Sur les états du Humanoid :

4. Dans quel ordre les états s’enchaînent-ils quand tu sautes d’une plateforme ?
   • a) Jumping → Freefall → Landed → Running.
   • b) Running → Landed → Jumping.
   • c) Freefall → Jumping → Running.

5. Pourquoi ne voit-on rien s’afficher quand on marche normalement pendant longtemps ?
   • a) Parce qu’on reste dans l’état Running : sans changement d’état, StateChanged ne se déclenche pas.
   • b) Parce que print est cassé.
   • c) Parce que la marche est trop rapide.

6. Quels sont les paramètres reçus par la fonction connectée à StateChanged ?
   • a) L’ancien état et le nouvel état (oldState, newState).
   • b) Le joueur et le personnage.
   • c) Rien.

Sur les deux pièges :

7. Pourquoi le script a-t-il besoin de la boucle for ... ipairs(Players:GetPlayers()) à la fin ?
   • a) Pour rattraper les joueurs déjà connectés AVANT le démarrage du script (l’événement PlayerAdded ne se déclenche pas pour eux).
   • b) Pour déconnecter les joueurs.
   • c) Pour afficher la liste des règles du jeu.

8. Pourquoi utilise-t-on task.spawn(onCharacterAdded, player, player.Character) ?
   • a) Pour lancer la fonction dans un thread séparé et ne pas bloquer le script, car elle contient un WaitForChild qui peut attendre.
   • b) Pour aller plus vite que WaitForChild.
   • c) Parce que onCharacterAdded est interdite ailleurs.

9. Pourquoi onCharacterAdded utilise-t-elle WaitForChild("Humanoid") ?
   • a) Parce que le personnage se construit pièce par pièce : au moment de l’événement, le Humanoid n’existe peut-être pas encore.
   • b) Pour faire joli.
   • c) Parce que le Humanoid n’existe jamais.

10. Dans onPlayerAdded, à quoi sert le if player.Character then ?
    • a) À vérifier si le personnage existe DÉJÀ (le joueur était là avant le script) pour ne pas rater son suivi.
    • b) À créer un personnage.
    • c) À détruire le personnage.

---

Résumé des concepts clés

Concept	Description	Exemple
PlayerAdded	Un joueur se connecte au jeu.	Players.PlayerAdded:Connect(onPlayerAdded)
CharacterAdded	Un personnage apparaît (1ère fois OU respawn !).	player.CharacterAdded:Connect(...)
StateChanged	Le Humanoid change d’état (saut, chute, atterrissage…).	humanoid.StateChanged:Connect(...)
Enum.HumanoidStateType	La liste des états possibles.	Landed, Jumping, Freefall, Dead…
GetPlayers()	Liste des joueurs déjà présents (rattrapage !).	for _, player in ipairs(...) do
task.spawn	Lance une fonction sans bloquer le script.	task.spawn(onPlayerAdded, player)
WaitForChild("Humanoid")	Attend que le personnage soit prêt.	Anti-erreur !
GetState()	Lit l’état ACTUEL (sans attendre un changement).	Utilisé dans la zone anti-gravité

Astuce : Garde ce script espion dans un coin de tes projets : dès qu’un comportement te semble mystérieux (pourquoi mon joueur ne saute plus ?), les print des états te diront exactement ce qui se passe dans la tête du Humanoid ! C’est l’outil de débogage parfait

Construire en trois phases une zone magique où le joueur flotte comme dans l’espace :

1. Phase 1 : donner au joueur une force vers le haut pour annuler la gravité quand il touche une Part.
2. Phase 2 : supprimer cette force quand le joueur sort de la Part (et qu’il est retombé au sol).
3. Phase 3 : supprimer cette force quand le joueur touche le sol (atterrissage).

Ce tutoriel introduit des concepts physiques réels (masse, gravité, poids) et des outils Roblox puissants : VectorForce, Attachment, les états de l’Humanoid (StateChanged) et GetTouchingParts().

Introduction : La physique de la gravité dans Roblox

Pourquoi le joueur tombe-t-il ?

Dans Roblox (comme dans la vraie vie !), chaque objet subit son poids : une force qui le tire vers le bas.

Poids = Masse × Gravité

• La gravité de Roblox vaut par défaut 196.2 studs/seconde² (accessible via workspace.Gravity).
• La masse du personnage est accessible via rootPart.AssemblyMass.
• Donc le poids d’un personnage = 196.2 × masse, dirigé vers le bas (Vector3.new(0, -poids, 0)).

L’astuce du script : annuler le poids !

Si on applique sur le joueur une force exactement égale à son poids, mais vers le HAUT, les deux forces s’annulent :

Gravité (vers le bas) + Notre force (vers le haut) = 0  → le joueur FLOTE !

C’est exactement ce que ressentent les astronautes en orbite : ils sont en apesanteur !

L’outil : VectorForce

Un VectorForce est un objet qui applique une force en continue sur une Part. Il a besoin :

• d’un Attachment (un point d’ancrage invisible sur la Part),
• d’une direction relative au monde (Enum.ActuatorRelativeTo.World),
• d’une force exprimée en Vector3.

Préparation dans Roblox Studio

1. Dans Workspace, crée un dossier GravityFolder.
2. Ajoute une Part nommée Part : c’est la zone d’apesanteur.
   • Forme libre : une grande zone transparente (Transparency = 0.8, Anchored = true, CanCollide = false) donne le meilleur effet « champ de force » !
   • Important : laisse CanTouch = true (sinon Touched, TouchEnded et GetTouchingParts ne fonctionnent pas !).
3. Crée un Script dans ServerScriptService et colle le code complet (utilitaires + Phase 1 + Phase 2 + Phase 3).

Le script complet, corrigé et commenté en français

Voici le script commenté en français :

-- Récupérer le service des joueurs
local Players = game:GetService("Players")

-- Récupérer la zone anti-gravité
local folder = workspace:WaitForChild("GravityFolder")
local antiGravityPart = folder:WaitForChild("Part")

-- Constantes du script
local GRAVITY = workspace.Gravity * 0.99   -- 99% de la gravité (petite marge de confort)
local DEFAULT_JUMP_HEIGHT = 7.2            -- Hauteur de saut normale de Roblox

-- Fonction utilitaire : retrouve le personnage, son rootPart et son humanoid
-- à partir de l'objet qui a touché la zone (hit)
local function getCharacterFromHit(hit)
    local character = hit:FindFirstAncestorOfClass("Model")
    if not character then return nil end

    local rootPart = character:FindFirstChild("HumanoidRootPart")
    if not rootPart then return nil end

    local humanoid = character:FindFirstChildOfClass("Humanoid")
    if not humanoid then return nil end

    return character, rootPart, humanoid   -- On retourne les trois !
end

-- Fonction utilitaire : crée (ou retrouve) la force anti-gravité du joueur
local function getOrCreateAntiGravityForce(rootPart)
    -- Chercher une force déjà existante (pour ne pas en créer deux !)
    local force = rootPart:FindFirstChildOfClass("VectorForce")
    if not force then
        -- Créer le point d'ancrage invisible sur le joueur
        local attachment = Instance.new("Attachment")
        attachment.Parent = rootPart

        -- Créer la force vectorielle
        force = Instance.new("VectorForce")
        force.Attachment0 = attachment                          -- où la force s'applique
        force.RelativeTo = Enum.ActuatorRelativeTo.World        -- relative au MONDE
        force.ApplyAtCenterOfMass = true                         -- au centre de masse
        force.Parent = rootPart
    end
    return force
end

-- Fonction utilitaire : supprime la force anti-gravité du joueur
local function removeAntiGravityForce(rootPart, humanoid)
    local force = rootPart:FindFirstChildOfClass("VectorForce")
    if force then
        force.Attachment0:Destroy()   -- supprimer le point d'ancrage
        force:Destroy()               -- supprimer la force
        humanoid.JumpHeight = DEFAULT_JUMP_HEIGHT  -- restaurer le saut normal
    end

end

-- Fonction utilitaire : vérifie si le personnage touche encore la zone
local function isStillTouching(character)
    for _, touchingPart in pairs(antiGravityPart:GetTouchingParts()) do
        if touchingPart.Parent == character then
            return true    -- une partie du corps touche encore la zone !
        end
    end
    return false           -- plus aucun contact
end

PHASE 1 : Donner une force vers le haut quand le joueur touche la Part

But : dès que le joueur entre dans la zone, il flotte.

Explication :

• L’événement Touched se déclenche à chaque contact (rappel : des dizaines de fois par seconde !).
• On cherche si une VectorForce existe déjà sur le joueur (sinon on en crée une). C’est notre réflexe « cooldown » des tutoriels précédents : ne jamais créer deux fois le même objet !
• On applique la formule physique : Force = Masse × Gravité, vers le haut.
• On réduit JumpHeight à 1 : en apesanteur, un grand saut propulserait le joueur au plafond !

-- PHASE 1 : le joueur touche la zone → il flotte
antiGravityPart.Touched:Connect(function(hit)
    -- Retrouver personnage, rootPart et humanoid (fonction utilitaire)
    local character, rootPart, humanoid = getCharacterFromHit(hit)
    if not character then return end   -- pas un joueur : on ignore

    -- Créer la force (ou retrouver celle qui existe déjà)
    local force = getOrCreateAntiGravityForce(rootPart)

    -- LA PHYSIQUE : force qui annule exactement le poids, vers le haut
    -- Force = gravité × masse, dirigée vers +Y
    force.Force = Vector3.new(0, GRAVITY * rootPart.AssemblyMass, 0)

    -- En apesanteur, on limite le saut pour ne pas partir dans le décor !
    humanoid.JumpHeight = 1
end)

Points clés :

1. rootPart.AssemblyMass : la masse totale du personnage (corps, habits, accessoires…). C’est pour ça qu’on utilise AssemblyMass et pas Mass (qui ne donnerait que la masse d’une seule Part !).
2. GRAVITY = workspace.Gravity * 0.99 : pourquoi 99 % et pas 100 % ? Avec exactement 100 %, le joueur resterait figé en l’air comme une statue. Avec 99 %, il descend très lentement : il peut quitter la zone en marchant, c’est plus jouable ! (Tu peux essayer 1.0 pour voir la différence.)
3. force.Force = Vector3.new(0, GRAVITY * rootPart.AssemblyMass, 0) : la force est recalculée à chaque Touched, donc si le joueur met un chapeau (masse change), la force s’adapte !

Teste ! Place une Part dans un dossier GravityFolder, lance le jeu et marche dedans.
Contrôle :

• Ton personnage ** monte lentement / flotte ** dans la zone.
• Dans l’Explorer, tu vois apparaître un VectorForce et un Attachment dans le HumanoidRootPart.
• Si tu sautes, tu ne montes presque plus (JumpHeight = 1).

QCM :

1. Que vaut la force appliquée au joueur ?
   • a) La masse du personnage multipliée par la gravité, dirigée vers le haut.
   • b) Toujours 100, vers le bas.
   • c) La taille du personnage.

2. Pourquoi utilise-t-on rootPart.AssemblyMass plutôt que rootPart.Mass ?
   • a) Pour avoir la masse totale du personnage entier, pas seulement celle du HumanoidRootPart.
   • b) C’est plus rapide.
   • c) Mass n’existe pas.

3. Que se passe-t-il si on ne vérifie pas si la force existe déjà (if not force then)?
   • a) Des dizaines de VectorForce seraient créées (un par contact Touched !) et le joueur partirait en fusée.
   • b) Rien.
   • c) Le jeu plante immédiatement.

4. Pourquoi mettre humanoid.JumpHeight = 1 ?
   • a) Pour empêcher le joueur de sauter très haut dans la zone et s’échapper au plafond.
   • b) Pour l’empêcher de marcher.
   • c) Pour changer sa couleur.

---

PHASE 2 : Supprimer la force quand le joueur SORT de la Part

But : quand le joueur n’a plus aucun contact avec la zone, il retrouve une gravité normale.

Explication — le problème est plus subtil qu’il n’y paraît :

• L’événement TouchEnded se déclenche quand une Part précise (ex: le pied gauche) quitte le contact. Mais le joueur a encore peut-être un autre contact (le pied droit !).
• Il faut donc vérifier avec GetTouchingParts() : la liste de toutes les Parts qui touchent actuellement la zone. Si une seule appartient au personnage → il est encore dedans → on ne fait rien !
• Autre piège : si le joueur saute ou est en chute libre au moment du TouchEnded, il est en l’air et va retoucher la zone dans un instant. On regarde donc son état avec humanoid:GetState() :
  • Enum.HumanoidStateType.Jumping : il saute → on attend.
  • Enum.HumanoidStateType.Freefall : il tombe → on attend.
• Dernier piège : GetTouchingParts() est appelé après un task.wait(1) pour laisser le temps au moteur physique de « réaliser » le nouveau contact (ex: le joueur qui retombe dans la zone juste après le saut).

-- PHASE 2 : le joueur sort de la zone → on enlève la force
antiGravityPart.TouchEnded:Connect(function(hit)
    -- Retrouver le personnage
    local character, rootPart, humanoid = getCharacterFromHit(hit)
    if not character then return end

    -- S'il saute ou tombe, il va peut-être retoucher la zone : on ne fait rien !
    local state = humanoid:GetState()
    if state == Enum.HumanoidStateType.Jumping then return end
    if state == Enum.HumanoidStateType.Freefall then return end

    -- Attendre 1 seconde que le contact se stabilise
    task.wait(1)

    -- Le joueur touche-t-il ENCORE la zone (avec une autre partie du corps) ?
    if isStillTouching(character) then return end   -- oui : il est toujours dedans !

    -- Non : il est bien sorti → supprimer la force
    removeAntiGravityForce(rootPart, humanoid)
end)

Teste ! Entre dans la zone, flotte, puis sors complètement.
Contrôle :

• Tant qu’une seule partie de ton corps touche la zone, tu continues de flotter (demande à un camarade de regarder depuis l’extérieur !).
• Dès que tu es totalement sorti, tu retombes : gravité normale, saut restauré (JumpHeight = 7.2).
• Le VectorForce et l’Attachment ont disparu de l’Explorer.

QCM :

1. Pourquoi vérifier isStillTouching(character) avant de supprimer la force ?
   • a) Parce que TouchEnded se déclenche pour UNE Part (ex: un pied), mais le joueur peut encore toucher la zone avec une autre (ex: l’autre pied).
   • b) Pour faire durer le jeu.
   • c) Parce que TouchEnded ne fonctionne pas.

2. Que retourne part:GetTouchingParts() ?
   • a) La liste de toutes les Parts actuellement en contact avec la zone.
   • b) Le nom de la zone.
   • c) La liste des joueurs du serveur.

3. Pourquoi ignorer l’événement si l’état du joueur est Jumping ou Freefall ?
   • a) Parce qu’en sautant ou en tombant, il va probablement retoucher la zone juste après : ce serait bête de couper la force pour rien.
   • b) Parce que les sauts sont interdits.
   • c) Parce que l’état Jumping détruit la force tout seul.

4. Que fait removeAntiGravityForce(rootPart, humanoid) ?
   • a) Détruit l’Attachment et le VectorForce, et restaure JumpHeight à 7.2.
   • b) Détruit le personnage.
   • c) Téléporte le joueur.

---

PHASE 3 : Supprimer la force quand le joueur TOUCCHE LE SOL

But : si le joueur saute hors de la zone et atterrit au sol (sans jamais déclencher le TouchEnded complet de la Phase 2), il faut quand même couper la force — sinon il flotterait en permanence !

Explication — un nouvel outil puissant : StateChanged !

• Un Humanoid passe par des états : Running (il court), Jumping (il saute), Freefall (il tombe), Landed (il vient d’atterrir !)…
• L’événement humanoid.StateChanged se déclenche à chaque changement d’état, avec l’ancien et le nouvel état en paramètres.
• Notre règle : si le nouvel état est Landed ET que le joueur ne touche plus la zone → on supprime la force.

Le problème du respawn : le VectorForce est attaché au personnage. Si on connectait StateChanged n’importe quand, on raterait les joueurs déjà connectés ou ceux qui respawnent. Solution en 3 étages (déjà vue dans le tutoriel des checkpoints !) :

1. Players.PlayerAdded → nouveau joueur.
2. player.CharacterAdded → chaque apparition/réapparition du personnage.
3. humanoid.StateChanged → chaque changement d’état.

-- PHASE 3 : le joueur atterrit au sol → on enlève la force

-- Fonction appelée à chaque changement d'état du Humanoid
local function onStateChanged(character, humanoid, oldState, newState)
    -- On ne s'intéresse qu'à l'atterrissage
    if newState ~= Enum.HumanoidStateType.Landed then return end

    local rootPart = character:FindFirstChild("HumanoidRootPart")
    if not rootPart then return end

    -- S'il touche encore la zone, il est dedans : on garde la force !
    if isStillTouching(character) then return end

    -- Il a atterri ailleurs : supprimer la force
    removeAntiGravityForce(rootPart, humanoid)
end

-- Fonction appelée à chaque apparition du personnage
local function onCharacterAdded(player, character)
    -- Attendre que le Humanoid existe
    local humanoid = character:WaitForChild("Humanoid")

    -- Connecter le suivi des changements d'état
    humanoid.StateChanged:Connect(function(oldState, newState)
        onStateChanged(character, humanoid, oldState, newState)
    end)
end

-- Fonction appelée à chaque connexion d'un joueur
local function onPlayerAdded(player)
    -- Cas 1 : le personnage existe DÉJÀ (joueur connecté avant le script)
    if player.Character then
        task.spawn(onCharacterAdded, player, player.Character)
    end

    -- Cas 2 : chaque apparition/réapparition future (mort, respawn...)
    player.CharacterAdded:Connect(function(character)
        onCharacterAdded(player, character)
    end)
end

-- Nouveaux joueurs
Players.PlayerAdded:Connect(onPlayerAdded)

-- Joueurs déjà connectés AVANT l'exécution du script
for _, player in ipairs(Players:GetPlayers()) do
    task.spawn(onPlayerAdded, player)
end

Points clés :

1. newState ~= Enum.HumanoidStateType.Landed : on filtre tout ce qui n’est pas un atterrissage (courir, sauter, nager…). Seul Landed nous intéresse.
2. Le duo PlayerAdded + boucle sur GetPlayers() : rappelle-toi le tutoriel des checkpoints ! Si le script démarre après qu’un joueur soit déjà là, PlayerAdded ne se déclenchera pas pour lui → la boucle finale rattrape tout le monde.
3. task.spawn(...) : lance la fonction dans un thread séparé pour ne pas bloquer le script pendant les WaitForChild.

Teste ! Entre dans la zone, saute au-dessus des bords et atterris loin de la zone.
Contrôle :

• À l’atterrissage hors zone, tu retombes immédiatement sous la gravité normale : le VectorForce a été détruit par la Phase 3 (et non la Phase 2 !).
• Tue ton personnage (Reset Character dans le menu) : il respawn… sans force résiduelle (le VectorForce était attaché à l’ancien personnage, détruit avec lui — et le nouveau personnage est suivi par CharacterAdded !).

QCM :

1. À quoi sert humanoid.StateChanged ?
   • a) À exécuter une fonction à chaque changement d’état du personnage (saut, chute, atterrissage…).
   • b) À détecter les collisions.
   • c) À changer la couleur du personnage.

2. Quel état nous intéresse dans la Phase 3 ?
   • a) Enum.HumanoidStateType.Landed (le joueur vient d’atterrir).
   • b) Enum.HumanoidStateType.Running.
   • c) Enum.HumanoidStateType.Dead.

3. Pourquoi le script se connecte-t-il aussi à player.CharacterAdded ?
   • a) Pour suivre chaque nouveau personnage (mort, respawn) et reconnecter StateChanged à chaque fois.
   • b) Pour créer un nouveau joueur.
   • c) Pour rien.

4. Pourquoi une boucle for sur Players:GetPlayers() à la fin du script ?
   • a) Pour rattraper les joueurs déjà connectés avant le démarrage du script (le PlayerAdded ne se déclenche pas pour eux).
   • b) Pour les déconnecter.
   • c) Pour afficher leurs noms.

5. Pourquoi vérifier isStillTouching(character) même dans la Phase 3 ?
   • a) Parce qu’un joueur peut atterrir SUR la zone elle-même (ou juste à côté, en la touchant encore) : il doit continuer à flotter !
   • b) Pour compter les joueurs.
   • c) C’est inutile.

---

Résumé des concepts clés

Concept	Description	Exemple
Poids = masse × gravité	La formule physique pour annuler la gravité.	GRAVITY * rootPart.AssemblyMass
VectorForce	Applique une force continue sur une Part.	force.Force = Vector3.new(0, p, 0)
Attachment	Point d’ancrage invisible pour la force.	force.Attachment0 = attachment
AssemblyMass	Masse totale du personnage.	rootPart.AssemblyMass
TouchEnded	Déclenché quand UN contact se termine (attention aux autres contacts !).	Phase 2
GetTouchingParts()	Liste toutes les Parts en contact actuel.	isStillTouching(character)
humanoid:GetState()	État actuel du personnage (Jumping, Freefall, Landed…).	Phase 2
StateChanged	Événement à chaque changement d’état.	Phase 3
PlayerAdded / CharacterAdded	Suivre les joueurs et leurs respawns.	Phase 3
Factorisation	Des fonctions utilitaires au lieu de dupliquer le code.	removeAntiGravityForce(...)

---

Idées pour aller plus loin

1. Une zone qui donne une force supérieure au poids

• Objectif : le joueur monte lentement comme dans un ascenseur de geysers.
• Comment faire ? Multiplie la force par un coefficient : Vector3.new(0, GRAVITY * rootPart.AssemblyMass * 1.5, 0) — le joueur s’élève à 50 % de la gravité nette !

2. Zone de lune (gravité réduite)

• Objectif : le joueur fait des bonds géants comme sur la Lune.
• Comment faire ? Force à 50 % du poids : Vector3.new(0, GRAVITY * rootPart.AssemblyMass * 0.5, 0) et augmente JumpHeight à 25 !

3. Ajouter des particules de lévitation

• Objectif : rendre la zone visuellement magique.
• Comment faire ? Ajoute un ParticleEmitter à la zone (rappel du tutoriel des particules !) avec EmissionDirection = Enum.NormalId.Top.

4. Un effet de rotation pendant l’apesanteur

• Objectif : le joueur tourne lentement sur lui-même comme un astronaute.
• Comment faire ? Ajoute un BodyAngularVelocity ou applique rootPart.AssemblyAngularVelocity = Vector3.new(0, 2, 0) à l’entrée dans la zone.

---

Défi final :

Crée un niveau spatial complet :

1. Trois zones : une d’apesanteur (le script du jour), une « lune » (gravité à 50 %), une « geyser » (force à 150 %).
2. Des plateformes flottantes entre les zones (réutilise le tutoriel TweenService !).
3. Un checkpoint au sommet (réutilise le tutoriel des checkpoints !) avec une bulle de chat « Bien joué ! » verte à l’arrivée.

Objectif : Découvrir pas à pas les bases de la programmation Lua avec Roblox :

• Les variables (texte et nombres)
• Les propriétés d’objets (écran, texte, Part)
• Les boucles (for et while)
• Les tableaux (simples et doubles)
• Le clonage et la destruction d’objets

Le fil du jeu : tu possèdes un écran géant (TableauPart) qui affiche des messages, et un cube magique (Part) qui va grandir, changer de couleur, devenir invisible… et même se multiplier en pyramide inversée !

Règle du jeu : à chaque étape, essaye d’écrire le code, teste, contrôle ce qui est affiché, puis réponds au QCM avant de passer à la suite !

Étape 0 : Préparer le terrain dans Roblox Studio

Avant de coder, construis la scène :

1. Dans Workspace, crée un dossier nommé Folder.
2. Dans ce dossier :
   • Une Part nommée TableauPart : aplatie comme un écran (ex: Size = Vector3.new(12, 8, 0.5)), avec Anchored = true.
   • Une Part nommée Part : un cube visible (Size = Vector3.new(4, 4, 4)), avec Anchored = true.
3. Sur TableauPart, ajoute (clic droit → Insert Object) :
   • Un SurfaceGui (nomme-le SurfaceGui).
   • Dans le SurfaceGui, un TextBox (nomme-le TextBox) : étire-le sur tout l’écran avec Size = {1,0},{1,0}.
4. Crée un Script dans ServerScriptService : c’est là que tu colleras le code, étape par étape.

En haut du script, ces lignes (elles ne changent plus jamais) :

-- Récupérer les objets de la scène
local folder = workspace:WaitForChild("Folder")
local tableauPart = folder:WaitForChild("TableauPart")
local surfaceGui = tableauPart:WaitForChild("SurfaceGui")
local screen = surfaceGui:WaitForChild("TextBox")  -- notre écran d'affichage
local part = folder:WaitForChild("Part")           -- notre cube magique

Convention : comme dans tous nos tutoriels, les noms de variables sont en anglais (screen, firstName…) et les commentaires en français.

Étape 1 : Afficher un message (les propriétés d’un objet)

But : écrire « Bonjour » sur l’écran géant.

Explication : un objet Roblox (comme notre TextBox) possède des propriétés : sa couleur, sa taille… et son texte (Text). Pour changer une propriété, on écrit objet.propriete = valeur.

-- ÉTAPE 1 : Affiche un Bonjour à l'écran
screen.Text = "Bonjour"

Teste ! Lance le jeu.
Contrôle : tu dois voir « Bonjour » s’afficher sur l’écran géant. Sinon, vérifie que ton TextBox s’appelle bien TextBox et que le script pointe vers le bon objet.

QCM :

1. Comment change-t-on le texte affiché dans le TextBox ?
   • a) screen.Bonjour = Text
   • b) print("Bonjour")
   • c) screen.Text = "Bonjour"
2. Text est… ?
   • a) Une propriété du TextBox.
   • b) Une boucle.
   • c) Un joueur.

Étape 2 : Les variables texte et la concaténation

But : afficher « Bonjour patrick ! » (avec ton prénom !).

Explication : une variable, c’est une boîte avec une étiquette qui contient une valeur. Pour assembler des morceaux de texte, on utilise .. (deux points) : c’est la concaténation.

-- ÉTAPE 2 : Renseigne une variable pour afficher ton prénom
task.wait(2)                       -- petite pause de 2 secondes
local firstName = "patrick"        -- remplace par TON prénom !
screen.Text = "Bonjour " .. firstName .. " !"

Teste ! Contrôle : l’écran affiche d’abord « Bonjour » (2 secondes), puis « Bonjour tonprénom ! ». Attention : il y a un espace dans "Bonjour "; essaie sans espace pour voir la différence !

QCM :

1. Que fait "Bonjour " .. firstName ?
   • a) Il colle les deux textes bout à bout (concaténation).
   • b) Il les additionne comme des nombres.
   • c) Il supprime le premier texte.
2. Que fait task.wait(2) ?
   • a) Il supprime 2 objets.
   • b) Il met le script en pause pendant 2 secondes.
   • c) Il écrit 2 fois le texte.

Étape 3 : Modifier les propriétés de l’écran et du texte

But : rendre l’écran coloré et le texte stylé.

Explication : on peut modifier plein de propriétés d’un objet : couleur de fond (BackgroundColor3), couleur du texte (TextColor3), bordure, taille du texte… Color3.fromRGB(rouge, vert, bleu) fabrique une couleur avec 3 nombres de 0 à 255.

-- ÉTAPE 3 : Modifie les propriétés de l'écran et du texte
screen.BackgroundColor3 = Color3.fromRGB(85, 255, 255)   -- fond cyan
sreen.TextColor3 = Color3.fromRGB(50, 50, 100)           -- gris bleu
screen.BorderMode = Enum.BorderMode.Inset               -- style de bordure
screen.BorderColor3 = Color3.fromRGB(255, 0, 0)         -- bordure rouge
screen.BorderSizePixel = 20                              -- épaisseur de la bordure
screen.TextScaled = true                                 -- texte agrandi automatiquement
screen.TextWrapped = true                               -- texte qui passe à la ligne
screen.TextXAlignment = Enum.TextXAlignment.Center      -- texte centré

Teste ! Contrôle : fond cyan, texte jaune, bordure rouge épaisse, texte centré et plus grand. Amuse-toi : change les 3 nombres de fromRGB et observe ! Que donne Color3.fromRGB(255, 0, 0) ? Et Color3.fromRGB(0, 0, 255) ?

QCM :

1. Que représente les 3 nombres de Color3.fromRGB(...) ?
   • a) Les quantités de rouge, de vert et de bleu (de 0 à 255).
   • b) La taille de l’écran.
   • c) L’heure.
2. Que fait screen.TextScaled = true ?
   • a) L’écran disparaît.
   • b) Le texte s’agrandit automatiquement pour remplir l’espace.
   • c) Le texte devient bleu.

Étape 4 : Les variables nombre

But : afficher ton âge à l’écran.

Explication : une variable peut contenir du texte ("patrick") ou un nombre (12). Attention au piège : pour coller un nombre à du texte, on utilise quand même .. !

-- ÉTAPE 4 : Renseigne ton âge dans une variable et affiche-le
task.wait(2)
local age = 12                          -- remplace par TON âge !
screen.Text = screen.Text .. "\nJ'ai " .. age .. " ans"

Nouveauté : \n = un saut de ligne dans le texte (le message s’écrit en dessous du précédent).

Teste ! Contrôle : le message « J’ai X ans » apparaît en dessous du message précédent. Si tout s’affiche sur une seule ligne, vérifie ton \n.

QCM :

1. Que fait "\n" dans un texte ?
   • a) Il affiche un « n ».
   • b) Il efface le texte.
   • c) Il saute à la ligne suivante.
     Réponse : a)
2. Peut-on coller un nombre à du texte avec .. ?
   • a) Oui, .. " ans" fonctionne avec une variable nombre.
   • b) Non, jamais.
   • c) Seulement le lundi.

Étape 5 : À toi de jouer — une variable de ton choix

But : afficher une information de ton choix (ex: « Fille » ou « Garçon », ou ta classe).

Explication : c’est le même principe qu’avant. À toi d’écrire le code sans copier ! Indice : crée une variable texte, puis concatène-la avec \n à la suite.

-- ÉTAPE 5 : Renseigne une information et affiche-la
task.wait(2)
local gender = "Garçon"                -- ou "Fille"... ou invente ta variable !
screen.Text = screen.Text .. "\n" .. gender

Teste ! Contrôle : ta nouvelle ligne s’affiche sous les précédentes, sans effacer le reste.

QCM :

1. Que se passe-t-il si tu écris screen.Text = gender (sans concaténation) ?
   • a) Tout le texte précédent est remplacé par ta variable.
   • b) Ta variable s’ajoute à la fin.
   • c) Rien ne s’affiche.

Étape 6 : Les nombres et l’addition (ton inventaire)

But : imagine que tu récupères une épée, un laser et une lampe, et calcule le total des points de ton inventaire.

Explication : avec des variables nombre, on peut calculer : +, -, * (multiplié), / (divisé).

-- ÉTAPE 6 : Calcule le total des points de l'inventaire
task.wait(2)
local sword = 10        -- points de l'épée
local laser = 50        -- points du laser
local lamp = 2          -- points de la lampe
local total = sword + laser + lamp   -- le calcul !
screen.Text = screen.Text .. "\nTotal inventaire : " .. total

Teste ! Contrôle : l’écran affiche « Total inventaire : 62 ». Vérifie le calcul de tête : 10 + 50 + 2 = 62 ?

QCM :

1. Que vaut total si sword = 10, laser = 50, lamp = 2 ?
   • a) 62
   • b) 10502
   • c) 60
2. Que fait local total = sword + laser + lamp ?
   • a) Il colle les trois textes.
   • b) Il additionne les trois variables et range le résultat dans total.
   • c) Il supprime les variables.

Étape 7 : Un vrai calcul (le voyage en vaisseau)

But : ton vaisseau part avec un réservoir vide, tu achètes 100 litres, puis tu visites 3 villes qui consomment chacune 30 litres. Combien reste-t-il ?

Explication : on peut combiner plusieurs opérations, et même réutiliser une variable avec =. Les parenthèses ( ) forcent le calcul à se faire en priorité.

-- ÉTAPE 7 : Calcule le carburant restant
task.wait(2)
local fuelTank = 0                          -- réservoir vide au départ
local fuelBought = 100                      -- litres achetés
local trips = 3                             -- nombre de déplacements
local fuelPerTrip = 30                      -- litres consommés par déplacement

fuelTank = fuelTank + fuelBought - (trips * fuelPerTrip)   -- le calcul !

screen.Text = screen.Text .. "\nReste dans mon réservoir : " .. fuelTank

Teste ! Contrôle : l’écran affiche 10 (100 – 90 = 10). Enlève les parenthèses autour de trips * fuelPerTrip : le résultat est-il le même ? Pourquoi ? (Indice : sans parenthèses, le calcul se fait de gauche à droite !)

QCM :

1. Pourquoi met-on des parenthèses autour de trips * fuelPerTrip ?
   • a) Pour que la multiplication se fasse avant la soustraction.
   • b) Pour décorer le code.
   • c) Pour afficher le texte.

Étape 8 : La boucle for (compteur et décompte)

But : afficher un compteur de 1 à 10, puis un décompte de 10 à 1.

Explication : une boucle for répète un bloc de code. for i = 1, 10 do signifie : « pour i allant de 1 à 10 ». La variable i change à chaque tour ! Et for i = 10, 1, -1 compte à l’envers grâce au pas de -1.

-- ÉTAPE 8a : Compteur de 1 à 10
task.wait(2)
local baseText = screen.Text .. "\n"
for i = 1, 10 do
    screen.Text = baseText .. "Attente : " .. i .. " seconde(s)"
    task.wait(0.3)
end

-- ÉTAPE 8b : Décompte de 10 à 1
for i = 10, 1, -1 do                       -- pas de -1 : on compte à l'envers !
    screen.Text = baseText .. "Attente : " .. i .. " seconde(s)"
    task.wait(0.3)
end

Teste ! Contrôle : le chiffre affiché monte 1, 2, 3… 10 puis redescend 10, 9… 1. Remarque : on a préparé baseText avant la boucle pour ne pas coller 10 fois la phrase !

QCM :

1. Combien de fois le code dans for i = 1, 10 do s’exécute-t-il ?
   • a) 10 fois.
   • b) 1 fois.
   • c) 11 fois.
2. Que fait le -1 dans for i = 10, 1, -1 do ?
   • a) Il fait diminuer i de 1 à chaque tour (décompte).
   • b) Il répète la boucle à l’infini.
   • c) Il affiche -1 à l’écran.

Étape 9 : Les tableaux (ton inventaire en liste)

But : ranger les valeurs de l’inventaire dans un tableau et les afficher une par une.

Explication : un tableau ({ }) range plusieurs valeurs dans une seule variable. pairs parcourt le tableau et donne l’index (i, la position) et la valeur (item).

-- ÉTAPE 9 : Affiche l'inventaire avec une boucle
task.wait(2)
screen.Text = baseText .. "\n"
local inventory = {sword, laser, lamp}      -- tableau avec les 3 valeurs

for i, item in pairs(inventory) do
    screen.Text = screen.Text .. "Objet " .. i .. " : " .. item .. "\n"
end

Teste ! Contrôle : l’écran affiche 3 lignes : « Objet 1 : 10 », « Objet 2 : 50 », « Objet 3 : 2 ».

QCM :

1. Que vaut inventory[1] ?
   • a) Le nombre de cases.
   • b) La première valeur du tableau (10, la valeur de sword).
   • c) Une erreur.
2. Dans for i, item in pairs(inventory) do, que vaut item ?
   • a) La valeur de la case courante du tableau.
   • b) Le nom du tableau.
   • c) Toujours 1.

Étape 10 : Le tableau double (objet ET valeur)

But : afficher le nom de chaque objet et sa valeur. Un tableau dans un tableau !

Explication : chaque case d’un tableau peut contenir… un autre tableau ! {{"sword", 10}, {"laser", 50}}. Pour lire la case 1 d’un sous-tableau : item[1].

-- ÉTAPE 10 : Affiche les noms et les valeurs de l'inventaire
task.wait(2)
screen.Text = baseText .. "\n"
inventory = {{"sword", sword}, {"laser", laser}, {"lamp", lamp}}   -- tableau double

for i, item in pairs(inventory) do
    screen.Text = screen.Text .. i .. ") " .. item[1] .. " : " .. item[2] .. "\n"
end
baseText = screen.Text     -- on mémorise pour la suite

Teste ! Contrôle : l’écran affiche : « 1) sword : 10 », « 2) laser : 50 », « 3) lamp : 2 ». Le nom ET la valeur !

QCM :

1. Que vaut item[2] dans la boucle ?
   • a) Le nom de l’objet.
   • b) La position dans le tableau.
   • c) La valeur (le nombre de points) de l’objet courant.
2. Comment s’appelle un tableau qui contient d’autres tableaux ?
   • a) Un tableau double (imbriqué).
   • b) Une boucle.
   • c) Une propriété.

Étape 11 : La boucle while (la jauge d’énergie)

But : faire monter une jauge d’énergie jusqu’à 100, barre par barre.

Explication : la boucle while (« tant que ») répète un code tant qu’une condition est vraie. Ici : tant que l’énergie est inférieure au maximum, on ajoute 10.

-- ÉTAPE 11 : Charge la jauge d'énergie
task.wait(2)
local energy = 10                 -- énergie de départ
local maxEnergy = 100             -- énergie maximale
screen.Text = screen.Text .. "Energie : "
while energy < maxEnergy do       -- TANT QUE energy < 100
    energy = energy + 10          -- ajouter 10
    screen.Text = screen.Text .. "▄"    -- une barre de plus (Alt+220)
    task.wait(0.3)
end

Teste ! Contrôle : les barres « ▄ » s’ajoutent une par une, puis s’arrêtent d’elles-mêmes quand l’énergie atteint 100. La boucle s’est toute seule arrêtée : c’est la condition qui l’a décidée !

QCM :

1. Quand la boucle while s’arrête-t-elle ?
   • a) Quand la condition devient fausse (ici, quand energy atteint 100).
   • b) Après 10 secondes.
   • c) Jamais.
2. Quelle est la différence avec la boucle for ?
   • a) Aucune.
   • b) for répète un nombre de fois connu ; while répète jusqu’à une condition.
   • c) while ne marche que sur les écrans.

Étape 12 : Transformer le cube (taille et couleur)

But : faire grandir, rétrécir, changer la couleur du cube magique… en boucle !

Explication : la Size d’une Part est un Vector3 (largeur, hauteur, profondeur) : on peut l’additionner ou la soustraire avec += et -=. La couleur est faite avec Color3.fromRGB : si les 3 nombres sont égaux, on obtient un gris (0 = noir, 255 = blanc) !

-- ÉTAPE 12a : Fais grandir le cube, puis rétrécir
task.wait(2)
for i = 1, 10 do
    part.Size += Vector3.new(i, i, i)    -- le cube grossit de plus en plus fort !
    task.wait(0.3)
end
for i = 1, 10 do
    part.Size -= Vector3.new(i, i, i)   -- et il rétrécit
    task.wait(0.3)
end

-- ÉTAPE 12b : Du noir au blanc (le gris)
for i = 0, 255 do
    part.Color = Color3.fromRGB(i, i, i)    -- gris qui s'éclaircit
    task.wait(0.01)
end

-- ÉTAPE 12c : Une couleur vivante (du noir au rouge)
for i = 0, 255 do
    part.Color = Color3.fromRGB(i, 160, 160)   -- rouge qui monte, vert/bleu fixes
    task.wait(0.01)
end

Teste ! Contrôle : le cube grossit de plus en plus vite (car i augmente à chaque tour !), rétrécit, passe du noir au gris clair, puis prend une teinte rouge. Modifie le 160 : que se passe-t-il avec Color3.fromRGB(i, 0, 0) ?

QCM :

1. Pourquoi le cube grandit-il de plus en plus vite dans la première boucle ?
   • a) Parce que task.wait raccourcit.
   • b) Parce que i augmente à chaque tour, et on ajoute Vector3.new(i, i, i).
   • c) Parce qu’il est magique.
2. Que donne Color3.fromRGB(100, 100, 100) ?
   • a) Un gris moyen.
   • b) Du rouge pur.
   • c) Du blanc pur.

Étape 13 : Invisible puis visible (la transparence)

But : faire disparaître le cube puis le faire réapparaître.

Explication : la propriété Transparency va de 0 (opaque) à 1 (invisible). Deux boucles while parfaites pour ça !

-- ÉTAPE 13a : Rend le cube transparent (disparition)
while part.Transparency < 1 do
    part.Transparency += 0.1    -- un peu plus transparent...
    task.wait(0.1)
end

-- ÉTAPE 13b : Rend-le opaque (réapparition)
task.wait(2)
while part.Transparency > 0 do
    part.Transparency -= 0.1    -- un peu plus opaque...
    task.wait(0.1)
end

Teste ! Contrôle : le cube s’efface progressivement puis réapparaît tout doucement, comme un fantôme !

QCM :

1. Quand une Part est-elle complètement invisible ?
   • a) Quand Transparency = 0.
   • b) Quand Transparency = 1.
   • c) Quand Transparency = 255.
2. Que fait part.Transparency += 0.1 ?
   • a) Il ajoute 0.1 à la transparence actuelle (avec +=).
   • b) Il remplace la transparence par 0.1.
   • c) Il change la taille.

Étape 14 : Le clonage : construis une pyramide inversée !

But : cloner le cube 10 fois pour construire une pyramide inversée : chaque nouvel étage est plus large que le précédent, posé au-dessus.

Explication : part:Clone() crée une copie exacte de la Part. On la modifie ensuite (position, taille) puis on l’attache au dossier avec .Parent. Sans .Parent, l’objet reste invisible ! Attention aussi : chaque copie doit avoir un nom différent (« Part1 », « Part2″…) pour pouvoir la retrouver ensuite.

-- ÉTAPE 14 : Construis la pyramide inversée
task.wait(3)
screen.Text = baseText                     -- on nettoie l'écran
for i = 1, 10 do
    local newPart = part:Clone()           -- une copie du cube
    newPart.Position += Vector3.new(0, newPart.Size.Y * i, 0)   -- posée plus haut à chaque fois
    newPart.Size += Vector3.new(i * 3, 0, i * 3)                -- de plus en plus large !
    newPart.Parent = folder               -- ATTACHE la copie au monde
    newPart.Name = "Part" .. i             -- nom unique : "Part1", "Part2"...
    task.wait(1)
end

Teste ! Contrôle : un nouveau bloc apparaît chaque seconde, posé au-dessus du précédent, et de plus en plus large : la pyramide pointe vers le bas ! Regarde dans l’Explorer : les Part1 à Part10 sont bien dans Folder.

QCM :

1. Que fait part:Clone() ?
   • a) Il crée une copie identique de la Part.
   • b) Il supprime la Part.
   • c) Il change la couleur.
2. Que se passe-t-il si on oublie newPart.Parent = folder ?
   • a) Le jeu plante.
   • b) La copie existe en mémoire mais n’apparaît pas dans le jeu.
   • c) Rien, c’est la même chose.
3. Pourquoi newPart.Name = "Part" .. i ?
   • a) Pour donner un nom unique à chaque copie et la retrouver plus tard.
   • b) Pour la détruire.
   • c) Pour changer sa couleur.

Étape 15 : La destruction : démolis la pyramide à l’envers !

But : détruire les blocs du haut vers le bas (ordre inverse).

Explication : :Destroy() supprime définitivement un objet. Pour retrouver chaque bloc par son nom, on utilise FindFirstChild : "Part" .. i fabrique le nom à chercher !

-- ÉTAPE 15 : Détruis les blocs dans l'ordre inverse
task.wait(3)
for i = 10, 1, -1 do                                   -- du dernier au premier !
    local block = folder:FindFirstChild("Part" .. i)   -- retrouve le bloc par son nom
    if block then
        block:Destroy()                                -- ... et détruis-le !
    end
    task.wait(1)
end
task.wait(3)

Teste ! Contrôle : les blocs disparaissent un par un, du haut vers le bas. À la fin, l’Explorer ne contient plus que TableauPart et Part !

1. Que fait folder:FindFirstChild("Part" .. i) ?
   • a) Il détruit la Part.
   • b) Il cherche dans le dossier l’objet nommé « Part1 », « Part2″… selon la valeur de i.
   • c) Il crée une Part.
2. Pourquoi la boucle va de 10 à 1 avec un pas de -1 ?
   • a) Pour aller plus vite.
   • b) Par hasard.
   • c) Pour détruire les blocs dans l’ordre inverse de leur création (du haut vers le bas).
3. Pourquoi vérifie-t-on if block then avant de détruire ?
   • a) Pour éviter une erreur si le bloc n’existe pas (il retourne nil).
   • b) Pour changer sa couleur.
   • c) Ce n’est pas utile.

Résumé des concepts découverts

Concept	Description	Exemple
Propriétés	Les réglages d’un objet.	screen.Text, part.Color
Variable texte / nombre	Une boîte étiquetée contenant une valeur.	local firstName = "patrick"
Concaténation ..	Coller des textes (et nombres) ensemble.	"J'ai " .. age
\n	Saut de ligne dans un texte.	screen.Text .. "\n"
Color3.fromRGB	Fabriquer une couleur (rouge, vert, bleu : 0-255).	Color3.fromRGB(85, 255, 255)
Calculs	‘+, -, *, / et les parenthèses.	fuelTank + fuelBought - (trips * fuelPerTrip)
Boucle for	Répéter un nombre de fois connu (avec pas négatif pour décompter).	for i = 10, 1, -1 do
Boucle while	Répéter tant qu’une condition est vraie.	while energy < maxEnergy do
Tableau	Une liste de valeurs.	{sword, laser, lamp}
Tableau double	Un tableau de tableaux (nom + valeur).	{{"sword", 10}}
pairs	Parcourir un tableau (index + valeur).	for i, item in pairs(inventory) do
‘+= et -=	Ajouter / retirer à une valeur.	part.Size += Vector3.new(i, i, i)
Clone()	Copier un objet.	part:Clone()
Destroy()	Supprimer un objet.	block:Destroy()
FindFirstChild	Retrouver un objet par son nom.	folder:FindFirstChild("Part" .. i)

Défi final :

1. Personnalise l’écran : affiche ton prénom, ton âge, ton inventaire imaginé (5 objets dans un tableau double !).
2. Crée un escalier : au lieu d’une pyramide inversée, fais des marches qui montent en décalant aussi sur l’axe X (Vector3.new(i * 5, i * 2, 0)).

Félicitations ! Tu viens de découvrir presque toutes les bases de la programmation Lua : variables, conditions, boucles, tableaux, objets et propriétés. Tous les grands jeux Roblox sont construits avec ces mêmes briques !