Boucles et fonctions

Dans la leçon précédente, ton code s’exécutait une seule fois, de haut en bas. Mais un jeu passe son temps à répéter des actions (faire tourner une pièce, compter un chrono…) et à réutiliser des morceaux de code. C’est le rôle des boucles et des fonctions. C’est aussi là qu’une IA peut produire les erreurs les plus graves : une boucle qui ne s’arrête jamais peut figer tout le jeu. Savoir lire une boucle (combien de tours ? est-ce qu’elle attend ?) est donc indispensable avant d’accepter un script. À la fin de cette leçon, les pièces de l’Obby des Nuages tourneront sur elles-mêmes.

La boucle for numérique

La boucle for répète un bloc un nombre de fois connu à l’avance. On lui donne une valeur de départ, une valeur d’arrivée et, si on veut, un pas (1 par défaut).

-- Compte de 1 à 5 (le pas vaut 1 par défaut)
for i = 1, 5 do
	print("Tour numéro", i)
end

-- Compte de 0 à 10 de 2 en 2 : 0, 2, 4, 6, 8, 10
for i = 0, 10, 2 do
	print(i)
end

-- Compte à rebours avec un pas négatif : 3, 2, 1
for i = 3, 1, -1 do
	print(i .. "...")
	task.wait(1) -- attend 1 seconde entre chaque nombre
end
print("Partez !")

La variable i (tu peux l’appeler comme tu veux) prend chaque valeur à tour de rôle. Elle n’existe qu’à l’intérieur de la boucle.

La boucle while

La boucle while (« tant que ») répète un bloc tant qu’une condition est vraie. Elle teste la condition avant chaque tour : si la condition est fausse dès le départ, le bloc ne s’exécute jamais.

-- Script dans ServerScriptService
local tempsRestant = 5

while tempsRestant > 0 do
	print(`Début de la manche dans {tempsRestant} s`)
	task.wait(1)
	tempsRestant -= 1
end

print("C'est parti !")

La boucle infinie et task.wait

while true do crée une boucle infinie : la condition est toujours vraie. C’est utile pour une action qui doit durer toute la partie (une pièce qui tourne, un événement toutes les minutes…). Mais attention : une boucle infinie doit toujours contenir une attente.

task.wait plutôt que wait

Tu verras souvent wait() dans de vieux tutoriels. La documentation Roblox la marque comme dépréciée : elle est remplacée par task.wait(), qui ne subit pas de ralentissement (throttling). Même chose pour spawn et delay, remplacées par task.spawn et task.delay (on les verra à la leçon 5).

• task.wait(2) attend au moins 2 secondes ;
• task.wait() sans argument attend le plus court possible : le prochain battement du moteur (l’événement Heartbeat, environ une image) ;
• task.wait renvoie le temps réellement écoulé, très pratique pour les animations, comme tu vas le voir.

La boucle repeat ... until

repeat ... until (« répète… jusqu’à ce que ») teste la condition après le bloc. Le bloc s’exécute donc au moins une fois. Attention au sens : la boucle s’arrête quand la condition devient vraie.

-- Script dans ServerScriptService : attendre qu'au moins un joueur soit connecté
local Players = game:GetService("Players")

repeat
	task.wait(1)
until #Players:GetPlayers() > 0

print("Un joueur est arrivé, on peut lancer la partie !")

Particularité de Luau : une variable local déclarée dans le bloc repeat est encore visible dans la condition until.

Contrôler une boucle : break et continue

• break arrête immédiatement la boucle ; le script continue après le end de la boucle.
• continue passe directement au tour suivant (pour un for, le compteur avance ; pour un while ou un repeat, la condition est testée à nouveau).

-- Afficher les étapes 1 à 10, en signalant les étapes « checkpoint bonus »
for etape = 1, 10 do
	if etape % 5 == 0 then
		print(`Étape {etape} : checkpoint bonus !`)
		continue -- on saute la fin du tour
	end
	print(`Étape {etape} : normale`)
end

-- Chercher la première étape dont le nombre de sauts dépasse 6
local sautsParEtape = 2
for etape = 1, 10 do
	sautsParEtape += 1
	if sautsParEtape > 6 then
		print("Première étape difficile :", etape)
		break -- inutile de continuer à chercher
	end
end

Les fonctions

Une fonction est un morceau de code qui porte un nom et qu’on peut exécuter (on dit appeler) autant de fois qu’on veut. Elle évite de copier-coller le même code partout.

Déclarer et appeler une fonction

-- Déclaration
local function direBonjour()
	print("Bienvenue dans l'Obby des Nuages !")
end

-- Appels : les parenthèses déclenchent l'exécution
direBonjour()
direBonjour()

Les paramètres

Les paramètres sont des variables que la fonction reçoit au moment de l’appel. Les valeurs qu’on passe s’appellent les arguments.

local function feliciter(pseudo, etape)
	print(`Bravo {pseudo}, tu as atteint l'étape {etape} !`)
end

feliciter("Lea", 3)   --> Bravo Lea, tu as atteint l'étape 3 !
feliciter("Noah", 7)  --> Bravo Noah, tu as atteint l'étape 7 !

Si tu passes moins d’arguments que de paramètres, les paramètres manquants valent nil. Si tu en passes plus, les arguments en trop sont ignorés.

Les valeurs de retour

Avec return, une fonction renvoie un résultat à celui qui l’a appelée. Une fonction Luau peut même renvoyer plusieurs valeurs d’un coup.

-- Calcule la récompense en pièces pour une étape donnée
local function calculerRecompense(etape)
	local base = 5
	return base + etape * 2
end

local gain = calculerRecompense(4)
print("Récompense :", gain) --> Récompense : 13

-- Renvoie deux valeurs : le nombre de minutes et de secondes
local function convertirTemps(totalSecondes)
	local minutes = totalSecondes // 60
	local secondes = totalSecondes % 60
	return minutes, secondes
end

local min, sec = convertirTemps(135)
print(`Temps : {min} min {sec} s`) --> Temps : 2 min 15 s

return termine immédiatement la fonction : la suite de la fonction n’est pas exécutée. Luau exige d’ailleurs que return soit la dernière instruction de son bloc (écrire du code entre return et end provoque une erreur). C’est pratique pour sortir tôt quand une condition n’est pas remplie (if not humanoid then return end).

Les fonctions anonymes

Une fonction peut aussi être créée sans nom et passée directement à une autre fonction. C’est très courant avec les événements :

-- Une fonction anonyme passée à task.delay : elle s'exécutera dans 3 secondes
task.delay(3, function()
	print("3 secondes se sont écoulées")
end)

Tu en verras partout à partir de la leçon 5.

La portée des variables

La portée (scope) d’une variable, c’est la zone du code où elle existe. Une variable local n’existe que dans le bloc où elle est déclarée : une fonction, une boucle, un if… Un bloc peut lire les variables de ses blocs parents, mais pas celles de ses blocs enfants.

local total = 0 -- visible dans tout le script (déclarée au niveau principal)

for i = 1, 3 do
	local double = i * 2 -- n'existe que pendant ce tour de boucle
	total += double      -- on peut lire et modifier "total", déclarée plus haut
end

print(total) --> 12
-- Ici, "double" et "i" n'existent plus : les utiliser donnerait nil
-- (et Studio les soulignerait comme des noms inconnus).

Deux conséquences importantes :

• Une fonction locale doit être déclarée avant d’être utilisée. Luau lit ton script de haut en bas : si tu appelles calculerRecompense() à la ligne 3 alors qu’elle est déclarée à la ligne 10, elle n’existe pas encore.
• Redéclarer une variable avec local crée une nouvelle variable qui cache l’ancienne dans ce bloc (on parle de shadowing). L’ancienne n’est pas modifiée. Évite de réutiliser les mêmes noms pour ne pas te perdre.

Fil rouge : une pièce qui tourne

Les pièces à collecter de l’Obby des Nuages doivent attirer l’œil : on va les faire tourner sur elles-mêmes.

Préparer la pièce

1. Dans le Workspace, crée un Folder nommé Pieces.
2. Crée une Part, nomme-la Piece, donne-lui une forme de pièce et une couleur dorée. Par exemple : propriété Shape sur Cylinder et Size à 0.4, 3, 3. Un cylindre Roblox est couché le long de l’axe X : avec ces dimensions, la pièce se tient debout « sur la tranche », et elle tournera comme une pièce de monnaie qu’on fait tourner sur une table.
3. Coche Anchored (la pièce ne doit pas tomber) et décoche CanCollide (le joueur doit pouvoir la traverser).
4. Range-la dans Pieces et insère un Script dedans (directement dans Studio : dans notre projet, Rojo ne synchronise pas le Workspace).

Le code

Voici le code, que tu peux taper ou demander à Claude Code (prompt dans l’encadré plus bas). Avant de le lancer, repère la boucle et vérifie qu’elle contient bien une attente.

-- Script placé DANS une Part « Piece » du dossier Workspace.Pieces
local piece = script.Parent
local VITESSE_ROTATION = 90 -- en degrés par seconde

-- Fait tourner la pièce d'un certain angle autour de l'axe vertical (Y)
local function tourner(angleEnDegres)
	-- CFrame.Angles attend des radians : math.rad convertit les degrés en radians
	piece.CFrame = piece.CFrame * CFrame.Angles(0, math.rad(angleEnDegres), 0)
end

while true do
	-- task.wait() attend environ une image et renvoie le temps réellement écoulé
	local ecoule = task.wait()
	-- On tourne proportionnellement au temps écoulé :
	-- la vitesse reste la même, que le jeu tourne vite ou lentement
	tourner(VITESSE_ROTATION * ecoule)
end

Quelques explications :

• Le CFrame d’une Part combine sa position et son orientation. Multiplier le CFrame par CFrame.Angles(0, angle, 0) fait tourner la Part autour de son propre axe vertical, sans la déplacer.
• math.rad convertit des degrés en radians, l’unité qu’attend CFrame.Angles. Le radian est une autre façon de mesurer un angle : un tour complet (360°) vaut environ 6,28 radians.
• Multiplier la vitesse par le temps écoulé donne une rotation régulière : si une image dure plus longtemps, la pièce tourne d’un angle plus grand. C’est une bonne habitude pour toute animation dans une boucle.

Lire ce code comme un relecteur

Exercice 1 : que va afficher l’Output ?

local total = 0

for i = 1, 6 do
	if i % 2 == 0 then
		continue
	end
	if i > 4 then
		break
	end
	total += i
end

print(total)

Exercice 2 : que se passe-t-il vraiment ?

Une IA a proposé ce script pour faire clignoter une plateforme :

-- Script placé DANS une Part (proposé par une IA pour la faire clignoter)
local plateforme = script.Parent

local function clignoter()
	while true do
		plateforme.Transparency = 0.5
		wait(0.5)
		plateforme.Transparency = 0
	end
end

clignoter()
print("Clignotement lancé")

1. Le jeu se fige-t-il ?
2. La plateforme clignote-t-elle vraiment ?
3. Le message « Clignotement lancé » s’affiche-t-il ?

📌 Ce qu’il faut retenir

• for i = debut, fin, pas do répète un bloc un nombre connu de fois (pas de 1 par défaut, négatif pour compter à rebours).
• while condition do teste avant chaque tour ; repeat ... until condition teste après (au moins un tour).
• break sort de la boucle, continue passe au tour suivant ; toute boucle infinie contient un task.wait().
• task.wait remplace wait (dépréciée) et renvoie le temps réellement écoulé ; un wait dans du code généré est un signal d’alerte.
• Pour relire une boucle, déroule-la à la main sur quelques tours : combien de tours, et où attend-elle ?
• Une fonction reçoit des paramètres et peut renvoyer plusieurs valeurs avec return.
• Une variable local n’existe que dans son bloc ; déclare tes fonctions avant de les appeler.

📚 Sources et pour aller plus loin

• Control structures (for, while, repeat, break, continue) — documentation Luau de Roblox
• Functions — documentation Luau de Roblox
• Scope — documentation Luau de Roblox
• Bibliothèque task (task.wait, task.delay…) — référence API
• Syntaxe de Luau (continue, affectations composées) — luau.org
• PartType (Cylinder orienté selon l’axe X) — référence API
• Fil DevForum (retours de développeurs) sur l’erreur « Script timeout: exhausted allowed execution time »