Étiquette : TweenService

Le défi des blocs

Auteur de l’article Par Patrick Gelinaud
Date de l’article 31 août 2026

Tu vas créer un petit jeu Roblox dans lequel plusieurs blocs sont placés dans un dossier.

Chaque bloc possède une couleur et peut réagir lorsque le joueur clique dessus.

Au fur et à mesure du tutoriel, tu vas apprendre à :

récupérer un objet dans Roblox ;
parcourir plusieurs objets ;
utiliser des variables ;
utiliser des conditions ;
réagir à un événement ;
modifier un objet ;
déplacer un objet ;
utiliser un Vector3 ;
créer une animation avec TweenService.

Le jeu commencera très simplement, puis tu vas progressivement le transformer.

La règle du jeu

Au départ, il y a trois blocs :

          PART01       PART02       PART03
           ROUGE        VERT         BLEU
             ↓            ↓            ↓
          [    ]       [    ]       [    ]

Le joueur doit cliquer sur les blocs pour les faire bouger.

Mais attention : c’est toi, le programmeur, qui vas décider de leurs règles !

Étape 1 : Comprendre le jeu avant de coder

But

Avant d’écrire une seule ligne de code, observe le jeu.

Tu dois identifier :

les objets ;
leurs noms ;
leurs propriétés ;
les actions que le joueur pourra effectuer.

Concepts clés

Objet
Propriété

Explications

Dans Roblox, presque tout ce que tu vois est un objet.

Une Part est un objet.

Elle possède des propriétés :

Nom
Couleur
Position
Taille
Anchored
...

On peut comparer un objet Roblox à une boîte qui contient des informations.

Par exemple :

Part01
 ├── Name = "Part01"
 ├── Color = rouge
 ├── Size = ...
 ├── Position = ...
 └── Anchored = true

Le programme pourra modifier ces informations.

À toi de jouer !

Ouvre Roblox Studio.

Dans Workspace, crée un dossier nommé :

FolderTest

À l’intérieur, crée trois Part :

FolderTest
│
├── Part01
├── Part02
└── Part03

Place-les à différents endroits dans la scène.

Test

Lance le jeu et vérifie que tu vois bien les trois blocs.

Questions

1. Une Part est-elle un objet Roblox ?

a) Oui
b) Non

2. Où se trouvent les trois Parts ?

a) Dans ServerStorage
b) Dans ReplicatedStorage
c) Dans Workspace

3. À quoi sert FolderTest ?

a) À ranger les Parts
b) À déplacer les Parts
c) À créer un joueur

Documentation Roblox

Roblox Creator Documentation – Instances

Roblox Creator Documentation – Folder

Roblox Creator Documentation – ClickDetector

Étape 3 : Lire un Folder

But

Tu vas apprendre à récupérer un objet et à utiliser ses propriétés.

Concepts clés

Variable
WaitForChild()

Explications

Une variable est comme une boîte portant une étiquette.

Nous allons créer une boîte appelée :

folderTest

et y ranger notre dossier Roblox.

Code Lua

Crée un Script dans ServerScriptService.

-- Récupère le dossier FolderKilyan dans Workspace
local folderTest = workspace:WaitForChild("FolderTest")

-- Affiche le nom et le type de l'objet
print("Folder test :", folderTest.Name, folderTest.ClassName)

Que fait le programme ?

Cette ligne :

local folderTest = workspace:WaitForChild("FolderTest")

signifie :

« Cherche FolderTest dans Workspace et place-le dans la variable folderTest. »

Puis :

folderTest.Name

récupère son nom.

Et :

folderTest.ClassName

récupère son type.

À toi de jouer !

Lance le jeu.

Regarde la fenêtre Output (Sortie)

Tu devrais voir quelque chose comme :

Folder test : FolderTest Folder

Modification

Remplace :

print("Folder test :", folderTest.Name, folderTest.ClassName)

par :

print("Mon dossier s'appelle :", folderTest.Name)

Observe le résultat.

Questions

1. Que contient la variable folderTest ?

a) Une Part
b) Un folder nommé FolderTest
c) Le joueur

2. À quoi sert local ?

a) À créer une variable
b) À créer une Part
c) À détecter un clic

Documentation Roblox

Roblox Creator Documentation – WaitForChild

Étape 4 : Lire toutes les Parts du Folder

But

Jusqu’à maintenant, nous savons récupérer un dossier (Folder).

Maintenant, nous voulons parcourir tous les objets qu’il contient.

Concepts clés

Boucle for
GetChildren()

Explications

Imagine que le programme ouvre la boîte FolderTest et regarde chaque objet l’un après l’autre.

FolderTest
     ↓
  Part01
     ↓
  Part02
     ↓
  Part03

C’est exactement le rôle de la boucle for.

Code Lua

local folderTest = workspace:WaitForChild("FolderTest")

-- Parcourt tous les objets directement contenus dans le Folder
for i, part in ipairs(folderTest:GetChildren()) do
	
	-- Affiche le nom et le type de chaque objet
	print("Part :", part.Name, part.ClassName)
	
end

Explication

Cette partie :

folderTest:GetChildren()

demande :

« Donne-moi tous les enfants de FolderTest. »

La boucle :

for i, part in ipairs(...)

prend ensuite chaque objet un par un.

part représente l’objet actuellement étudié.

À toi de jouer !

Lance le jeu.

Tu dois obtenir :

Part : Part01 Part
Part : Part02 Part
Part : Part03 Part

Expérience

Ajoute une quatrième Part :

Part04

Sans modifier le script.

Relance le jeu.

Que se passe-t-il ?

Le programme doit automatiquement détecter Part04.

C’est la puissance des boucles !

Questions

1. Combien de fois la boucle s’exécute-t-elle avec 3 Parts ?

a) 1
b) 2
c) 3

2. Que contient la variable part pendant la boucle ?

a) Le joueur
b) L’objet actuellement parcouru
c) Le Folder

Documentation Roblox

Roblox Creator Documentation – GetChildren

Roblox Creator Documentation – Lua for loops

Étape 5 : Vérifier que l’objet est bien une Part

But

Tous les objets d’un Folder ne sont pas forcément des Parts.

Nous allons apprendre à vérifier le type d’un objet avant de le modifier.

Concept clé

Condition if

Code Lua

local folderTest = workspace:WaitForChild("FolderTest")

for _, part in ipairs(folderTest:GetChildren()) do
	
	-- Vérifie si l'objet est bien une pièce physique
	if part:IsA("BasePart") then
		
		print(part.Name, part.ClassName)
		
		-- Change la couleur de la Part en rouge
		part.Color = Color3.fromRGB(255, 0, 0)
		
	end
	
end

Explications

La condition :

if part:IsA("BasePart") then

signifie :

« Est-ce que cet objet est une Part physique ? »

Si la réponse est oui, le programme exécute le code entre :

then

end

À toi de jouer !

Ajoute un objet différent dans le Folder, par exemple un Model.

Lance le jeu.

Le programme ne devrait pas essayer de lui appliquer une couleur.

Modification

Change :

Color3.fromRGB(255, 0, 0)

par :

Color3.fromRGB(0, 255, 0)

Que se passe-t-il ?

Questions

1. À quoi sert if ?

a) À répéter
b) À poser une question au programme
c) À créer une variable

2. Que vérifie IsA() ?

a) Le nom
b) La couleur
c) Le type d’objet

Documentation Roblox

Roblox Creator Documentation – IsA

Étape 6 : Donner une couleur différente à chaque Part

But

Tu vas maintenant utiliser plusieurs conditions.

Concepts clés

if
elseif
else

Code Lua

local folderTest = workspace:WaitForChild("FolderTest")

for _, part in ipairs(folderTest:GetChildren()) do
	
	-- Vérifie que l'objet est bien une Part
	if part:IsA("BasePart") then
		
		-- Part01 devient rouge
		if part.Name == "Part01" then
			part.Color = Color3.fromRGB(255, 0, 0)
		
		-- Part02 devient verte
		elseif part.Name == "Part02" then
			part.Color = Color3.fromRGB(0, 255, 0)
		
		-- Toutes les autres Parts deviennent bleues
		else
			part.Color = Color3.fromRGB(0, 0, 255)
		end
		
	end
end

Explications

Le programme pose plusieurs questions :

Est-ce Part01 ?
     ↓
    oui → rouge

    non
     ↓
Est-ce Part02 ?
     ↓
    oui → vert

    non
     ↓
    bleu

Le else signifie :

« Si aucune des conditions précédentes n’est vraie. »

À toi de jouer !

Lance le jeu.

Tu dois obtenir :

Part01 → ROUGE

Part02 → VERT

Part03 → BLEU

Expérience

Ajoute :

Part04
Part05

Elles doivent automatiquement devenir bleues.

Puis crée une condition pour Part04.

Quelle couleur veux-tu lui donner ?

Questions

Si part.Name vaut "Part01", quelle condition est vraie ?

a) part.Name == "Part02"
b) part.Name == "Part01"
c) part.Name == "Part03"

Documentation Roblox

Roblox Creator Documentation – Conditional statements

Étape 7 : Réagir au clic du joueur

But

Jusqu’à maintenant, le programme s’exécute automatiquement.

Nous allons maintenant attendre une action du joueur.

Concepts clés

Événement
Fonction

Explications

Un événement signifie :

« Quelque chose vient de se produire. »

Par exemple :

Le joueur clique
       ↓
événement MouseClick
       ↓
le programme réagit

Nous allons utiliser le ClickDetector.

Rajoute un ClickDetector à chaque part

Code Lua

local folderTest = workspace:WaitForChild("FolderKTest")

for _, part in ipairs(folderTest:GetChildren()) do
	
	if part:IsA("BasePart") then
		
		-- Recherche le ClickDetector placé dans la Part
		local clickDetector = part:FindFirstChildOfClass("ClickDetector")
		
		if clickDetector then
			
			-- Attend que le joueur clique sur la Part
			clickDetector.MouseClick:Connect(function(player)
				
				-- Affiche le nom du joueur et de la Part
				print(player.Name .. " a cliqué sur " .. part.Name)
				
			end)
		end
	end
end

Explication de `function`

Cette partie :

function(player)

crée une petite fonction.

Elle sera exécutée plus tard, lorsque le joueur cliquera.

C’est comme dire :

« Quand le clic arrivera, fais ce qui se trouve dans cette fonction. »

À toi de jouer !

Lance le jeu.

Clique sur les Parts.

Dans Output, tu dois voir :

Patrick a cliqué sur Part01
Patrick a cliqué sur Part02

Le nom dépend évidemment du joueur.

Modification

Ajoute :

print("Bravo !")

dans la fonction.

Question

Quand la fonction est-elle exécutée ?

a) Au lancement du jeu
b) Quand le joueur clique
c) Quand le joueur quitte

Documentation Roblox

Roblox Creator Documentation – Events

Roblox Creator Documentation – ClickDetector.MouseClick

Étape 8 : Faire bouger une Part avec un vecteur

But

Tu vas maintenant faire agir la Part lorsqu’elle est cliquée.

C’est ici que nous faisons le lien avec les mathématiques.

Concepts clés

Vector3
Vitesse

Explications

Un Vector3 contient trois valeurs :

X
Y
Z

Par exemple :

Vector3.new(50, 0, 0)

signifie :

X = 50
Y = 0
Z = 0

On demande donc à la Part de se déplacer selon l’axe X.

Code Lua

local folderTest = workspace:WaitForChild("FolderTest")

for _, part in ipairs(folderTest:GetChildren()) do
	
	if part:IsA("BasePart") then
		
		-- Recherche le ClickDetector
		local clickDetector = part:FindFirstChildOfClass("ClickDetector")
		
		if clickDetector then
			
			-- Action réalisée lorsque le joueur clique
			clickDetector.MouseClick:Connect(function(player)
				
				print(player.Name .. " a cliqué sur " .. part.Name)
				
				-- Autorise la Part à être déplacée par la physique
				part.Anchored = false
				
				-- Crée un vecteur de vitesse
				local velocityVector = Vector3.new(50, 0, 0)
				
				-- Applique le vecteur à la Part
				part.AssemblyLinearVelocity = velocityVector
				
			end)
		end
	end
end

Que représente le vecteur ?

Vector3.new(50, 0, 0)

On peut le représenter mathématiquement : $\vec{v}=(50;0;0)$

La Part part dans la direction positive de X.

À toi de jouer !

Clique sur une Part.

Elle doit partir vers la droite.

Expériences

Essaie successivement :

Vector3.new(-50, 0, 0)

Puis :

Vector3.new(0, 50, 0)

Puis :

Vector3.new(0, 0, 50)

Observe les directions.

Puis essaie :

Vector3.new(30, 0, 40)

Que se passe-t-il ?

Tu viens de créer un déplacement oblique.

Question

Que signifie :

Vector3.new(0, 50, 0)

a) Aller vers X
b) Aller vers Y
c) Aller vers Z

Pour aller plus loin

Demande-toi :

Pourquoi Vector3 est-il intéressant pour représenter un vecteur mathématique ?

Tu peux maintenant commencer à introduire :

Vecteur mathématique
        ↓
Direction
Sens
Longueur

        ↓

Vector3 Roblox
(X, Y, Z)

Documentation Roblox

Roblox Creator Documentation – Vector3

Roblox Creator Documentation – AssemblyLinearVelocity

Étape 9 : Faire monter la Part avec TweenService

But

Jusqu’à maintenant, la Part était lancée avec une vitesse.

Maintenant, nous allons créer une animation contrôlée.

Concepts clés

Service
Tween

Explications

TweenService permet de modifier progressivement une propriété.

Par exemple :

Position initiale
       ↓
       ↓
       ↓
Position finale

Au lieu de déplacer brutalement la Part, Roblox crée une animation.

Code Lua

local folderTest = workspace:WaitForChild("FolderKilyan")

-- Récupère le service qui permet de créer des animations
local tweenService = game:GetService("TweenService")

-- Définit la durée et le type de l'animation
local tweenInfo = TweenInfo.new(
	1,
	Enum.EasingStyle.Linear,
	Enum.EasingDirection.Out,
	0,
	false,
	0
)

for _, part in ipairs(folderTest:GetChildren()) do
	
	if part:IsA("BasePart") then
		
		-- Recherche le ClickDetector
		local clickDetector = part:FindFirstChildOfClass("ClickDetector")
		
		if clickDetector then
			
			clickDetector.MouseClick:Connect(function(player)
				
				print(player.Name .. " a cliqué sur " .. part.Name)
				
				-- Vecteur de déplacement
				local moveVector = CFrame.new(0, 10, 0)
				
				-- Création de l'animation
				local tween = tweenService:Create(
					part,
					tweenInfo,
					{
						CFrame = part.CFrame * moveVector
					}
				)
				
				-- Lance l'animation
				tween:Play()
				
			end)
		end
	end
end

Que signifie le déplacement ?

CFrame.new(0, 10, 0)

correspond à :

X = 0
Y = 10
Z = 0

La Part monte donc de 10 studs.

À toi de jouer !

Clique sur une Part.

Elle doit monter progressivement.

Modification 1

Essaie :

CFrame.new(10, 0, 0)

La Part se déplace horizontalement.

Modification 2

Essaie :

CFrame.new(10, 10, 0)

La Part se déplace à la fois :

sur X ;
sur Y.

Tu viens de construire un déplacement composé de deux directions.

Question

Quelle instruction démarre réellement l’animation ?

a) tweenInfo
b) tween:Play()
c) CFrame.new()

Documentation Roblox

Roblox Creator Documentation – TweenService

Roblox Creator Documentation – TweenInfo

Étape 10 : Construire la règle du jeu

Nous avons maintenant suffisamment de programmation pour créer une vraie règle.

But

Tu vas combiner plusieurs concepts.

Règle proposée

Chaque couleur correspond à une action :

ROUGE → se déplace à droite

VERT → monte

BLEU → se déplace en diagonale

Code

local folderTest = workspace:WaitForChild("FolderKilyan")

for _, part in ipairs(folderTest:GetChildren()) do
	
	if part:IsA("BasePart") then
		
		-- Détermine la couleur de la Part
		if part.Name == "Part01" then
			part.Color = Color3.fromRGB(255, 0, 0)
			
		elseif part.Name == "Part02" then
			part.Color = Color3.fromRGB(0, 255, 0)
			
		else
			part.Color = Color3.fromRGB(0, 0, 255)
		end
		
		-- Recherche le ClickDetector
		local clickDetector = part:FindFirstChildOfClass("ClickDetector")
		
		if clickDetector then
			
			clickDetector.MouseClick:Connect(function(player)
				
				print(player.Name .. " a cliqué sur " .. part.Name)
				
				-- Part rouge
				if part.Name == "Part01" then
					
					part.Anchored = false
					part.AssemblyLinearVelocity = Vector3.new(50, 0, 0)
				
				-- Part verte
				elseif part.Name == "Part02" then
					
					part.Anchored = false
					part.AssemblyLinearVelocity = Vector3.new(0, 50, 0)
				
				-- Part bleue
				else
					
					part.Anchored = false
					part.AssemblyLinearVelocity = Vector3.new(30, 0, 40)
					
				end
				
			end)
		end
	end
end

Le jeu possède maintenant une règle

                JOUEUR
                   |
                 clique
                   ↓
              Quelle Part ?
              /     |     \
          ROUGE    VERT    BLEU
            ↓        ↓       ↓
          → X       ↑ Y    ↗ X+Z

Étape 11 : Défi mathématique — prédire le déplacement

Maintenant, c’est à ton tour de réfléchir avant d’exécuter le programme.

Le code indique :

local moveVector = Vector3.new(20, 0, 30)

Demande-toi :

Dans quelle direction la Part va-t-elle partir ?

Dessine le vecteur sur une feuille.

Puis teste dans Roblox.

Défi 1

Quel vecteur faut-il utiliser pour aller :

10 à droite et 20 vers l’avant ?

Réponse :

Vector3.new(10, 0, 20)

Défi 2

Quel vecteur faut-il utiliser pour aller :

20 à gauche ?

Vector3.new(-20, 0, 0)

Défi 3

Quel vecteur permet de monter de 15 studs ?

Vector3.new(0, 15, 0)

Défi 4

Construis un déplacement :

X = -20
Y = 10
Z = 30

Solution :

Vector3.new(-20, 10, 30)

Tu viens de manipuler un vecteur dans l’espace.

Ce que tu as appris

À la fin du tutoriel, tu as utilisé de nombreuses notions fondamentales :

Notion	Exemple dans le jeu
Variable	`folderTest`
Objet	`part`
Propriété	`part.Color`
Condition	`if part.Name == ...`
`else`	autre Part
Boucle	`for _, part`
Fonction	`function(player)`
Événement	`MouseClick`
Service	`GetService()`
`Vector3`	`Vector3.new(50,0,0)`
Physique	`AssemblyLinearVelocity`
Animation	`TweenService`
Organisation	`Folder`

Et surtout, tu as découvert une idée importante :

PROGRAMME

        ↓

OBSERVER
        ↓
DÉCIDER
        ↓
AGIR

C’est cette structure qui permet de transformer progressivement quelques lignes de Lua en un véritable jeu.

Pour aller beaucoup plus loin

Maintenant, mets-toi à la place du joueur.

Au début, tu ne connais pas le jeu :

« Je clique sur une Part. Que va-t-il se passer ? »

Puis tu deviens joueur expérimenté :

« La Part rouge part dans la direction X. »

Puis programmeur :

« Si je remplace Vector3.new(50,0,0) par Vector3.new(20,0,40), je change la direction du déplacement. »

Puis concepteur de jeu :

« Je vais créer une zone d’arrivée et donner des points lorsque la Part atteint sa cible. »

Tu peux alors faire évoluer le projet avec :

un score ;
des vies ;
plusieurs niveaux ;
des obstacles ;
des zones interdites ;
des portes ;
des téléporteurs ;
des vecteurs à calculer ;
des angles à déterminer ;
un véritable défi de géométrie dans l’espace.

Cela permettrait de faire évoluer le même projet de la sixième à la troisième, en introduisant progressivement programmation, coordonnées, déplacements, vecteurs, angles, distances et géométrie 3D.

Étiquettes Boucle For, ClickDetector, GetChilDren, if, ipair, TweenService, vector3, WaitForChild

Jeu vidéo ROBLOX

Apprendre Lua sur Roblox – 10 scénarios OBBY

Auteur de l’article Par Patrick Gelinaud
Date de l’article 6 juin 2026

Ateliers de 3h · Multijoueur · Progression pédagogique

Défi 01 : La Course aux Portes

Défi 02 : Le Labyrinthe Fantôme

défi 03 : Roi de la Plateforme

défi 04 : La Bombe Logique

défi 05 : Ascenseur Infernal

Défi 06 : Sauve-qui-peut !

Défi 07 : Le Voleur de Flag

Défi 08 : Puzzle Coopératif

Défi : 09 Arène des pièges

Défi 10 : Le Grand OBBY Final

Défi 01 : La Course aux Portes

Dans un couloir géant, des portes colorées s’ouvrent ou se ferment en fonction d’une condition secrète à définir au lancement de la partie (nombre pair, tous les x, couleur, niveau de transparence, type de matériaux de la porte …). La mauvaise porte téléporte en début de partie.

Règles du jeu

2 à 6 joueurs simultanés sur le même serveur
Chaque manche dure 90 secondes — le premier à passer 5 portes gagne
Une mauvaise porte = retour en début de partie
Si possible les indices changent aléatoirement à chaque manche et l’accès aux bonnes portes
Un tableau de score (Leaderboard) est visible de tous et montre le nombre de bonnes portes ouvertes et le nombre de parties gagnées

Techniques Lua abordées

Variables locales/globales : Stocker la couleur de la porte et le score du joueur
Instruction if/elseif/else : Tester la condition de la bonne porte
Gérer dynamiquement et aléatoirement les propriétés des Parts
RemoteEvents : Communiquer entre le serveur et les clients
Leaderboard (Leaderstats) : Afficher les scores de tous les joueurs
ClickDetector pour l’ouverture des portes
Gérer les ressources du workspace (script.Parent, :GetChildren(), if part:IsA(« BasePart »)
Boucle

for _, enfant in ipairs(dossier:GetChildren()) do
    print(enfant.Name)
end

Compétences acquises

Déclarer et utiliser des variables
Écrire des conditions simples et imbriquées
Comprendre la différence Server/Client
Créer un système de score multijoueur

QCM de validation — 4 questions

1. En Lua, quelle instruction permet de tester une condition ?

A. check
B. if
C. test
D. when

2. Comment déclare-t-on une variable locale en Lua ?

A. var score = 0
B. let score = 0
C. local score = 0
D. int score = 0

3. Quel objet Roblox permet d’afficher le score de tous les joueurs ?

A. ScoreBoard
B. Leaderstats
C. PlayerGUI
D. DataStore

4. Que se passe-t-il si la condition d’un if est fausse et qu’il y a un else ?

A. Le script s’arrête
B. La condition est retestée
C. Le bloc else est exécuté
D. Une erreur apparaît

Défi 02 : Le Labyrinthe Fantôme

Des murs du labyrinthe, ou un chemin de plateformes apparaissent et disparaissent par cycles réguliers, comme des fantômes. Les joueurs doivent mémoriser et anticiper. Un joueur « Fantôme » (désigné aléatoirement) voit tous les murs en transparence et peut guider les autres via un chat.

Règles du jeu

1 Fantôme (voit tout) + 1 à 5 Chasseurs (voient un brouillard)
Les murs disparaissent ou réapparaissent toutes les 3 secondes
Le Fantôme doit guider les Chasseurs jusqu’à la sortie en 2 minutes
Si un Chasseur touche un mur plein, il revient au départ
Bonus si toute l’équipe sort ensemble

Techniques Lua abordées

Boucle while true do : Faire clignoter les murs indéfiniment
task.wait(n) : Contrôler la durée entre chaque clignotement
Propriété Transparency : Rendre les murs visibles/invisibles
CanCollide : Activer/désactiver la collision des murs
Lire tous les joueurs local Players = game:GetService(« Players ») Players.PlayerAdded:Connect(function(player)

Compétences acquises

Comprendre le fonctionnement client/serveur
Gérer les RemoteEvent
Créer des boucles infinies contrôlées
Manipuler les propriétés des Parts Roblox
Concevoir un mécanisme de jeu temporisé
Comprendre CanCollide et Transparency

QCM de validation — 4 questions

1. Quelle boucle Lua tourne indéfiniment jusqu’à ce qu’on l’arrête ?

A. for i=1,10
B. repeat until
C. while true do
D. loop forever

2. Que fait wait(3) dans un script Roblox ?

A. Attend l’appui d’une touche
B. Pause l’exécution 3 secondes
C. Répète une action 3 fois
D. Crée un délai de 0,3 s

3. Quelle propriété rend un objet traversable sans le rendre invisible ?

A. Transparency = 1
B. CanCollide = false
C. Anchored = true
D. Locked = true

4. Comment accède-t-on à la propriété d’un objet Roblox en Lua ?

A. objet->propriete
B. objet.propriete
C. objet[propriete]
D. get(objet, propriete)

Défi 03 : Roi de la Plateforme

Une grande plateforme centrale se rétrécit progressivement grâce au TweenService. Des blocs se déplacent ou tournent sur cette plateforme et poussent les joueurs. Ceux qui tombent sont éliminés. Le dernier joueur debout devient le Roi et gagne des points. Les joueurs éliminés doivent attendre en spectateur, qu’il ne reste plus qu’un seul joueur présent sur la plateforme, pour recommencer une nouvelle partie.

La difficulté augmente : les blocs se déplacent de plus en plus vite.

Règles du jeu

2 à 8 joueurs par partie
La plateforme perd 10% de sa taille toutes les 15 secondes
Un joueur éliminé peut regarder la partie en spectateur
Victoire = survivre jusqu’à la fin et être le dernier avec le plus de points
3 manches par session, le total des Points compte pour la victoire finale

Techniques Lua abordées

Fonctions nommées : Organiser le code en blocs réutilisables
TweenService : Animer la réduction de la plateforme
Touched event : Détecter quand un joueur tombe dans le vide
Boucle for numérique : Compter les manches et les cycles de rétrécissement

Compétences acquises

Déclarer et appeler des fonctions
Utiliser TweenService pour des animations
Connecter des événements (Touched)
Structurer un jeu en manches avec boucle for

QCM de validation — 4 questions

1. Comment appelle-t-on une fonction nommée ‘demarrer’ en Lua ?

A. call demarrer()
B. run:demarrer()
C. demarrer()
D. execute(demarrer)

2. Quel service Roblox permet de créer des animations fluides ?

A. AnimationService
B. TweenService
C. SmoothService
D. TransitionService

3. Comment s’écrit une boucle for qui compte de 1 à 5 en Lua ?

A. for(i=0; i<5; i++)
B. for i in range(5)
C. for i = 1, 5 do
D. repeat 5 times

4. Quel événement détecte qu’un objet touche une Part Roblox ?

A. .OnTouch
B. .Touched:Connect
C. .Hit:Bind
D. Contact:Link

Défi 04 : La Bombe Logique

Une bombe virtuelle affiche un chrono avant son explosion. Elle raccordée par une séquence de fils de couleurs tirée au hasard. Les joueurs doivent couper les fils dans la bonne séquence. Chaque joueur reçoit une partie du code sur son écran (GUI), et doit communiquer avec les autres pour coordonner la séquence exacte de câbles à couper avant que le chrono n’atteigne zéro.

Règles du jeu

3 à 5 joueurs requis (chaque joueur voit 1/3 du code)
La bombe explose si le mauvais câble est coupé
30 secondes maximum pour désamorcer
Code différent à chaque partie (aléatoire)

Techniques Lua abordées

Tables (tableaux) : Stocker la séquence de couleurs de la bombe
math.random() : Générer la séquence aléatoire à chaque partie
ScreenGui / Frame : Afficher les indices à chaque joueur
ipairs / pairs : Parcourir la table des couleurs

Compétences acquises

Créer et manipuler des tables Lua
Utiliser math.random pour l’aléatoire
Créer une interface joueur (GUI)
Itérer avec ipairs sur une liste

QCM de validation — 4 questions

1. Comment crée-t-on une table vide en Lua ?

A. table = []
B. table = new Table()
C. table = {}
D. table = list()

2. Quelle fonction ajoute un élément à la fin d’une table ?

A. table.push()
B. table.add()
C. table.append()
D. table.insert()

3. Que retourne math.random(1, 6) ?

A. Toujours 1
B. Un nombre décimal entre 1 et 6
C. Un entier aléatoire entre 1 et 6
D. La somme 1+6

4. Quelle boucle est faite pour parcourir une table indexée en Lua ?

A. while
B. for k,v in pairs
C. for i,v in ipairs
D. foreach

Défi 05 : Ascenseur Infernal

Les joueurs fabriquent, dans un espace dédié, un ascenseur fonctionnel qui monte et descend entre différents étages. Chaque étage contient des obstacles différents. Le joueur programme lui-même la vitesse, les arrêts et les comportements des obstacles à chaque palier et un objet à trouver. Un mini concours final compare les ascenseurs de tous les participants.

Règles du jeu

Travail individuel avec présentation finale en groupe
L’ascenseur doit desservir au minimum 3 étages
Chaque étage doit avoir un obstacle scripté différent
Le joueur doit pouvoir appuyer sur un bouton pour appeler l’ascenseur
Bonus : ajouter une porte qui s’ouvre à l’arrivée

Compétences acquises

Manipuler CFrame et Vector3 pour le déplacement
Utiliser les Welds pour solidariser des objets
Créer des interactions ProximityPrompt
Organiser des données dans une table d’étages

QCM de validation — 4 questions

1. Qu’est-ce que CFrame représente dans Roblox ?

A. La couleur d’un objet
B. La position ET l’orientation d’un objet
C. La taille d’une Part
D. Le nom d’un script

2. À quoi sert un WeldConstraint entre deux Parts ?

A. Les rendre invisibles
B. Les coller ensemble pour qu’elles bougent solidairement
C. Les faire tomber en même temps
D. Les fusionner en une seule Part

3. Comment crée-t-on un point 3D à X=5, Y=10, Z=0 en Lua Roblox ?

A. Point(5,10,0)
B. Vector3.new(5,10,0)
C. CFrame.new(5,10,0)
D. Pos3D(5,10,0)

4. Quel objet Roblox crée une interaction ‘Appuyer sur E’ dans le monde ?

A. ButtonPart
B. ClickDetector
C. ProximityPrompt
D. TouchButton

Défi 06 : Sauve-qui-peut !

Un joueur est désigné « Monstre » avec une vitesse boostée. Les autres doivent traverser un OBBY classique tout en étant poursuivis. Des zones de ralentissement, de vitesse boost, et de gravité réduite sont scriptées dans l’arène. Si le Monstre te touche, tu deviens Monstre à ton tour ! Le jeu s’arrête lorsque les joueurs sont tous des monstres ou au bout d’un certain temps.

Règles du jeu

Monstre pour commencer, désigné aléatoirement
Les survivants gagnent 1 point par checkpoint franchi
Un survivant tagué devient immédiatement Monstre
Le dernier survivant gagne un bonus x3
Partie de 3 minutes max

Techniques Lua abordées

Humanoid.WalkSpeed : Modifier la vitesse du Monstre et des joueurs
Humanoid.JumpPower : Ajuster la hauteur de saut dans les zones spéciales
workspace.Gravity : Créer des zones de gravité réduite
GetPlayers() : Récupérer tous les joueurs pour désigner le Monstre

Compétences acquises

Modifier les propriétés du Humanoid
Sélectionner un joueur aléatoire depuis GetPlayers()
Créer des zones d’effet avec Touched
Comprendre la physique Roblox (vitesse, gravité)

QCM de validation — 4 questions

1. Quelle propriété du Humanoid contrôle la vitesse de marche ?

A. Humanoid.Speed
B. Humanoid.WalkSpeed
C. Character.Velocity
D. Player.RunSpeed

2. Que retourne Players:GetPlayers() ?

A. Le nombre de joueurs
B. Le premier joueur connecté
C. Une table de tous les joueurs connectés
D. Le joueur local

3. Comment accède-t-on au personnage d’un joueur ?

A. player.Model
B. player.Character
C. player.Avatar
D. player.Body

4. Qu’est-ce que workspace.Gravity contrôle ?

A. La couleur du ciel
B. La force de gravité sur tous les objets
C. La vitesse du vent
D. La taille des joueurs

Défi 07 : Le Voleur de Flag

Deux équipes (Rouge et Bleue) s’affrontent dans un OBBY en miroir. Chaque équipe doit traverser l’OBBY adverse, voler le flag ennemi et le ramener à sa base. Des pièges scriptés bloquent les chemins selon l’équipe du joueur. Le flag est un objet physique que le personnage « porte » grâce à un Weld. Le jeu se termine quand une équipe ramène le flag à un endroit déterminé.

Règles du jeu

2 équipes de 2 à 4 joueurs chacune
Pour marquer, le joueur doit ramener le flag sans mourir
Les pièges changent d’état toutes les 10 secondes

Techniques Lua abordées

Teams Service :; Créer et assigner des équipes Rouge/Bleue
ObjectValue / BoolValue : Savoir qui porte le flag (valeur partagée)
RemoteEvent (FireAllClients) : Annoncer une capture à tous les joueurs
Weld dynamique : Attacher le flag au personnage qui le ramasse

Compétences acquises

Configurer le système Teams de Roblox
Partager des données entre Server et Clients
Créer des Welds dynamiques par script
Utiliser FireAllClients pour des annonces globales

QCM de validation — 4 questions

1. Comment vérifier l’équipe d’un joueur en Lua Roblox ?

A. player.Color
B. player.Group.Name
C. player.Team.Name
D. player.Side

2. Quelle valeur Roblox permet de stocker une référence à un objet ?

A. StringValue
B. ObjectValue
C. NumberValue
D. ReferenceValue

3. Que fait RemoteEvent:FireAllClients() ?

A. Envoie un signal au serveur
B. Envoie un signal à un seul joueur
C. Envoie un signal à tous les joueurs connectés
D. Crée un nouvel événement

4. Comment créer un nouvel objet Roblox par script ?

A. new Instance(‘WeldConstraint’)
B. Instance.new(‘WeldConstraint’)
C. create(‘WeldConstraint’)
D. Roblox.new(‘WeldConstraint’)

Défi 08 : Puzzle Coopératif

Un OBBY avec des portes géantes qui ne s’ouvrent que si PLUSIEURS joueurs appuient simultanément sur des boutons répartis dans des zones différentes. Le niveau est impossible à finir seul. Des scripts de détection comptent les joueurs sur chaque bouton et déclenchent l’ouverture seulement quand le bon nombre est atteint.

Règles du jeu

3 à 5 joueurs requis (portes à 2, 3 joueurs simultanés)
Les boutons restent actifs 5 secondes maximum
Si un joueur lâche son bouton, tout le monde doit recommencer
Des checkpoints communs sauvegardent la progression collective
Fin = tous les joueurs arrivent ensemble à la salle finale

Techniques Lua abordées

BindableEvent : Communiquer entre scripts locaux du serveur
Compteur de joueurs : Détecter combien de joueurs sont sur un bouton
Fonctions modulaires : Organiser le code en modules réutilisables
BoolValue partagée : Synchroniser l’état ouvert/fermé des portes

Compétences acquises

Utiliser des compteurs et variables d’état
Coordonner plusieurs scripts avec BindableEvent
Concevoir une logique coopérative
Structurer du code modulaire et réutilisable

QCM de validation — 4 questions

1. Quelle est la différence entre BindableEvent et RemoteEvent ?

A. Aucune différence
B. BindableEvent = serveur→serveur, RemoteEvent = serveur↔client
C. BindableEvent = client→client uniquement
D. RemoteEvent ne fonctionne qu’en studio

2. Comment incrémenter un compteur de 1 en Lua ?

A. compteur++
B. compteur += 1
C. compteur = compteur + 1
D. increment(compteur)

3. Que retourne hit.Parent:FindFirstChild(‘Humanoid’) si absent ?

A. Une erreur
B. false
C. nil
D. 0

4. Pour qu’une porte détecte l’événement d’un autre script, on utilise ?

A. .OnServerEvent
B. .Event:Connect
C. .Listen()
D. .Subscribe()

Défi : 09 Arène des pièges

Chaque joueur crée un piège dans l’arène (lame rotative, boule de feu, zone électrique) puis tous jouent ensemble sur la carte collective. Le créateur du piège qui élimine le plus d’adversaires gagne. Les pièges doivent utiliser des patterns de mouvement différents (oscillation, rotation, trajectoire). Chaque joueur crée une zone bonus protégée par les pièges pour permettre la sortie de l’arène.

Règles du jeu

Phase 1 (45 min) : chaque joueur code son piège dans sa zone
Phase 2 : les pièges sont assemblés dans une arène commune
Chaque élimination rapporte 2 points au créateur du piège
Atteindre une une zone de bonus 10 points
Obtenir plus de 30 points permet de sortir de l’arène

Techniques Lua abordées

TakeDamage() : Infliger des dégâts au Humanoid au contact
CFrame rotation : Faire tourner un piège sur lui-même
math.sin() oscillation : Créer un mouvement de va-et-vient fluide
Respawn personnalisé : Réapparaître à un spawn aléatoire

Compétences acquises

Infliger et gérer les points de vie (TakeDamage)
Animer avec RunService.Heartbeat
Créer des mouvements avec math.sin et CFrame
Concevoir et partager ses propres mécaniques

QCM de validation — 4 questions

1. Quelle méthode inflige des dégâts à un Humanoid ?

A. Humanoid.Health -= 10
B. Humanoid:Hurt(10)
C. Humanoid:TakeDamage(10)
D. Humanoid.DealDamage(10)

2. Que fait RunService.Heartbeat:Connect(function(dt) … end) ?

A. Lance le jeu au démarrage
B. Exécute la fonction à chaque frame
C. Attend 1 seconde puis exécute
D. Connecte deux serveurs

3. math.sin(t) retourne des valeurs entre :

A. 0 et 1
B. -1 et 1
C. -180 et 180
D. 0 et 360

4. CFrame.Angles(0, math.pi, 0) représente une rotation de :

A. 90° sur l’axe Y
B. 360° sur l’axe X
C. 180° sur l’axe Y
D. 45° sur tous les axe

Défi 10 : Le Grand OBBY Final

Projet final d’atelier : les joueurs assemblent tous les mécanismes appris dans un OBBY. Chaque stage reprend une technique (portes, labyrinthes, plateformes, pièges). Les progrès sont sauvegardés dans un DataStore pour qu’un joueur puisse reprendre où il s’est arrêté. Un leaderboard global classe tous les participants de la session.

Règles du jeu

OBBY solo mais visible par tous les autres joueurs en temps réel
Reprise de tous les 9 scénarios + un boss final
Chaque stage complété est sauvegardé en DataStore
Timer global affiché pour tout le serveur
Cérémonie de fin : podium animé avec les 3 meilleurs temps

Techniques Lua abordées

DataStoreService : Sauvegarder la progression du joueur entre sessions
Checkpoint system : Respawn au dernier stage sauvegardé
ModuleScript : Centraliser le code réutilisé dans des modules
Intégration complète : Combiner toutes les techniques précédentes

Compétences acquises

Utiliser DataStoreService pour la persistance
Architecturer un projet Roblox complet
Utiliser des ModuleScripts pour organiser le code
Combiner toutes les compétences Lua acquises

QCM de validation — 4 questions

1. À quoi sert le DataStoreService ?

A. Sauvegarder des données entre les sessions de jeu
B. Stocker les scripts du jeu
C. Gérer les animations des personnages
D. Envoyer des données au client

2. Quelle est la clé utilisée pour identifier un joueur de façon unique ?

A. player.Name
B. player.DisplayName
C. player.UserId
D. player.AccountId

3. Qu’est-ce qu’un ModuleScript dans Roblox ?

A. Un script qui se lance automatiquement
B. Un script qui retourne des fonctions réutilisables
C. Un script réservé aux admins
D. Un script qui gère les animations

4. Que fait store:SetAsync(cle, valeur) ?

A. Lit une valeur dans le DataStore
B. Efface une valeur du DataStore
C. Sauvegarde une valeur dans le DataStore
D. Vérifie si une clé existe

Étiquettes atelier 3h, Boucle For, Boucles while, CFrame, conditions, events, fonction, For, multi joueurs, Timer, Tranparency, TweenService, variables, wait, Weld

La règle du jeu

Étape 1 : Comprendre le jeu avant de coder

But

Concepts clés

Explications

À toi de jouer !

Test

Questions

Documentation Roblox

Étape 3 : Lire un Folder

But

Concepts clés

Explications

Code Lua

Que fait le programme ?

À toi de jouer !

Modification

Questions

Documentation Roblox

Étape 4 : Lire toutes les Parts du Folder

But

Concepts clés

Explications

Code Lua

Explication

À toi de jouer !

Expérience

Questions

Documentation Roblox

Étape 5 : Vérifier que l’objet est bien une Part

But

Concept clé

Code Lua

Explications

À toi de jouer !

Modification

Questions

Documentation Roblox

Étape 6 : Donner une couleur différente à chaque Part

But

Concepts clés

Code Lua

Explications

À toi de jouer !

Expérience

Questions

Documentation Roblox

Étape 7 : Réagir au clic du joueur

But

Concepts clés

Explications

Code Lua

Explication de function

À toi de jouer !

Modification

Question

Documentation Roblox

Étape 8 : Faire bouger une Part avec un vecteur

But

Concepts clés

Explications

Code Lua

Que représente le vecteur ?

À toi de jouer !

Expériences

Question

Pour aller plus loin

Documentation Roblox

Étape 9 : Faire monter la Part avec TweenService

But

Concepts clés

Explications

Code Lua

Que signifie le déplacement ?

À toi de jouer !

Modification 1

Modification 2

Question

Documentation Roblox

Étape 10 : Construire la règle du jeu

Explication de `function`