Variables, types et conditions

Dans la leçon précédente, tu as utilisé local plateforme = script.Parent sans trop savoir ce que c’était. Il est temps de comprendre les variables, les types de valeurs et les conditions. Avec ces trois briques, un script peut se souvenir de choses et prendre des décisions… et c’est aussi là que se cachent beaucoup d’erreurs dans le code, y compris celui d’une IA : une condition inversée, un nil oublié, un 0 considéré comme vrai. À la fin, tu liras et vérifieras la première vraie mécanique de l’Obby des Nuages : la kill brick, le bloc piégé qui élimine le joueur qui le touche.

Les variables

Une variable est une étiquette qui porte un nom et retient une valeur. On la crée avec le mot-clé local, suivi du nom, du signe = et de la valeur.

local nomDuJeu = "Obby des Nuages" -- un texte
local nombreEtapes = 10             -- un nombre
local partieLancee = true           -- un booléen (vrai / faux)

print(nomDuJeu, nombreEtapes, partieLancee)

-- On peut changer la valeur plus tard (sans remettre "local")
nombreEtapes = 12
print("Nouveau nombre d'étapes :", nombreEtapes)

Le signe = ne veut pas dire « est égal à » comme en maths : il veut dire « range cette valeur dans cette variable ».

Pourquoi toujours écrire local ?

Sans local, une variable est globale : elle est visible dans tout le script, ce qui provoque vite des collisions de noms. La documentation Roblox recommande de déclarer presque toujours les variables avec local : elles sont plus rapides d’accès pour Luau et libèrent leur mémoire quand on n’en a plus besoin. Dans cette formation, toutes nos variables seront locales.

Bien nommer ses variables

Les règles de Luau :

• un nom contient des lettres, des chiffres et des tirets bas _, et ne commence pas par un chiffre ;
• les noms sont sensibles à la casse : etape et Etape sont deux variables différentes ;
• certains mots sont réservés et ne peuvent pas servir de nom : and, break, do, else, elseif, end, false, for, function, if, in, local, nil, not, or, repeat, return, then, true, until, while.

Dans cette formation, on écrit les noms en camelCase (nombreEtapes, vitesseRotation), en français et sans accents (évite étape comme nom de variable). Les constantes, des valeurs qu’on ne change jamais, s’écrivent souvent en MAJUSCULES : VALEUR_PIECE.

Les types de base

Chaque valeur a un type. Voici les quatre types de base que tu manipuleras tout le temps :

Une variable déclarée sans valeur vaut nil : local checkpointActuel crée une variable qui ne contient rien pour l’instant.

typeof : connaître le type d’une valeur

La fonction typeof renvoie le nom du type sous forme de texte. Elle connaît aussi les types propres à Roblox, comme Vector3 (une position ou une taille en 3D), Color3 (une couleur) ou Instance (n’importe quel objet de l’Explorer).

print(typeof(42))                    --> number
print(typeof("Obby"))                --> string
print(typeof(true))                  --> boolean
print(typeof(nil))                   --> nil
print(typeof(Vector3.new(0, 10, 0))) --> Vector3
print(typeof(workspace))             --> Instance (workspace en minuscules : raccourci global vers le Workspace)

-- La fonction type() de Luau ne connaît pas les types Roblox :
print(type(Vector3.new(0, 10, 0)))   --> userdata (moins précis)

Retiens : sur Roblox, utilise typeof, plus précis que type.

Les nombres et les opérateurs arithmétiques

local a = 17
local b = 5

print(a + b)  --> 22   addition
print(a - b)  --> 12   soustraction
print(a * b)  --> 85   multiplication
print(a / b)  --> 3.4  division
print(a // b) --> 3    division entière (arrondie vers le bas)
print(a % b)  --> 2    reste de la division (modulo)
print(2 ^ 3)  --> 8    puissance

Comme en maths, la multiplication passe avant l’addition : 2 + 3 * 4 vaut 14. Utilise des parenthèses pour changer l’ordre : (2 + 3) * 4 vaut 20.

Les affectations composées

Pour modifier une variable à partir de sa propre valeur, Luau propose des raccourcis :

local pieces = 10
pieces += 5  -- équivaut à : pieces = pieces + 5   (15)
pieces -= 3  -- équivaut à : pieces = pieces - 3   (12)
pieces *= 2  -- équivaut à : pieces = pieces * 2   (24)
print(pieces) --> 24

Les textes (strings)

Coller des textes avec ..

Pour concaténer (coller) des textes, on utilise deux points .., jamais +. Les nombres sont convertis automatiquement en texte.

local pseudo = "Lea"
local etape = 3

print("Bravo " .. pseudo .. " !")                 --> Bravo Lea !
print(pseudo .. " est à l'étape " .. etape)       --> Lea est à l'étape 3
print("Longueur du pseudo : " .. #pseudo)         --> Longueur du pseudo : 3
print("Étape suivante : " .. tostring(etape + 1)) --> Étape suivante : 4

.. n’ajoute pas d’espace : pense à les mettre dans tes textes. Le # devant un texte donne sa longueur en octets : c’est le nombre de caractères tant que le texte n’a pas d’accents (#"Lea" vaut 3), mais une lettre accentuée compte pour 2 (#"Étape" vaut 6). tostring convertit une valeur en texte, et tonumber fait l’inverse (il renvoie nil si le texte n’est pas un nombre) : tonumber("12") vaut 12.

L’interpolation avec les accents graves

Luau propose une écriture plus lisible : l’interpolation de chaînes. On entoure le texte d’accents graves (le caractère ` ; sur un clavier AZERTY français : AltGr + 7, puis Espace) et on place les valeurs entre accolades.

local pseudo = "Lea"
local etape = 3

print(`{pseudo} est à l'étape {etape}`)         --> Lea est à l'étape 3
print(`Prochaine étape : {etape + 1} sur 10`)   --> Prochaine étape : 4 sur 10

Tu peux mettre n’importe quel calcul entre les accolades. Deux contraintes : pour passer un texte à accents graves à une fonction, garde toujours les parenthèses, comme ci-dessus ; et pour afficher une vraie accolade, échappe-la avec une barre oblique inverse (\{).

Comparer des valeurs

Les opérateurs de comparaison renvoient toujours un booléen (true ou false) :

Les opérateurs logiques : and, or, not

• a and b est vrai si les deux sont vrais ;
• a or b est vrai si au moins un des deux est vrai ;
• not a inverse : not true vaut false.

local aUnePiece = true
local etape = 4

print(aUnePiece and etape >= 3)   --> true  (les deux conditions sont vraies)
print(etape > 10 or aUnePiece)    --> true  (une seule suffit)
print(not aUnePiece)              --> false

Vrai, faux… et tout le reste (truthy / falsy)

Règle capitale en Luau : seuls nil et false sont considérés comme faux. Tout le reste est considéré comme vrai, y compris 0 et le texte vide "". On dit que nil et false sont « falsy », et tout le reste « truthy ».

Cette règle permet une astuce très utilisée : or pour donner une valeur par défaut. En effet, or renvoie la première valeur si elle est vraie, sinon la seconde.

local recordPerso = nil
local record = recordPerso or 0 -- recordPerso vaut nil, donc on prend 0
print(record) --> 0

Prendre des décisions avec if

La structure if exécute un bloc de code seulement si une condition est vraie. Elle se termine toujours par end.

local etape = 7

if etape == 10 then
	print("Tu as terminé l'Obby des Nuages !")
elseif etape >= 5 then
	print("Tu as passé la moitié du parcours.")
else
	print("Courage, tu débutes !")
end

Luau teste les conditions dans l’ordre et n’exécute que le premier bloc dont la condition est vraie. Ici, etape vaut 7 : la première condition est fausse, la deuxième vraie, donc seul « Tu as passé la moitié du parcours. » s’affiche. Le else final, facultatif, attrape tous les autres cas.

Fil rouge : la kill brick de l’Obby des Nuages

Une kill brick est une Part qui élimine le joueur qui la touche ; il réapparaît alors à son point de départ (on gérera le retour au checkpoint à la leçon 5). Pour éliminer un personnage, il suffit de mettre la santé (Health) de son Humanoid à 0. Le Humanoid est l’objet qui gère la vie, la marche et le saut d’un personnage.

Préparer la scène

1. Dans le Workspace, crée un Folder nommé KillBricks (respecte bien ce nom, on le réutilisera).
2. Crée une Part rouge en matériau Neon, ancrée (Anchored coché), placée sous ou entre deux plateformes, et range-la dans KillBricks.
3. Insère un Script à l’intérieur de cette Part.

Le code

Voici le code. Tape-le toi-même (c’est encore un excellent exercice à ce stade) ou demande-le à Claude Code avec le prompt de l’encadré plus bas. Dans les deux cas, l’objectif est le même : pouvoir expliquer chaque ligne.

-- Script placé DANS une Part du dossier Workspace.KillBricks
local killBrick = script.Parent

-- Cette fonction est appelée chaque fois que quelque chose touche la Part.
-- autrePart = la partie qui a touché (une jambe, un bras, un objet...)
local function surContact(autrePart)
	local personnage = autrePart.Parent -- le Model qui contient cette partie
	local humanoid = personnage:FindFirstChildOfClass("Humanoid")

	-- On vérifie que c'est bien un personnage (il a un Humanoid)
	-- ET qu'il est encore vivant (inutile de le tuer deux fois)
	if humanoid and humanoid.Health > 0 then
		humanoid.Health = 0
	end
end

-- On relie la fonction à l'événement Touched de la Part (détaillé à la leçon 5)
killBrick.Touched:Connect(surContact)

Lance le jeu et saute sur la Part : ton personnage s’effondre puis réapparaît sur la SpawnLocation.

Ce qui compte ici, c’est la condition :

• FindFirstChildOfClass("Humanoid") cherche un enfant de classe Humanoid et renvoie nil s’il n’en trouve pas (par exemple si c’est une balle ou une autre Part qui touche) ;
• if humanoid and ... protège donc le code : sans ce test, humanoid.Health provoquerait l’erreur attempt to index nil with 'Health' dès qu’un objet non-personnage touche la brique ;
• humanoid.Health > 0 évite de « retuer » un personnage déjà mort.

La syntaxe local function et :Connect seront expliquées en détail aux leçons 3 et 5. Pour l’instant, retiens que surContact s’exécute à chaque contact.

Lire ce code comme un relecteur

Exercice 1 : que va afficher l’Output ?

local pieces = 0
local pseudo = nil
local nom = pseudo or "Invité"

if pieces then
	print(nom .. " a des pièces")
else
	print(nom .. " n'a rien")
end

print(`{nom} : {pieces + 5} pièces`)

Exercice 2 : quelle ligne est dangereuse, laquelle est inutile ?

Une IA a proposé cette kill brick. Elle semble marcher quand tu sautes dessus… (Les numéros de ligne de la réponse sont ceux affichés à gauche de l’extrait.)

-- Script placé DANS une Part de Workspace.KillBricks (proposé par une IA)
local killBrick = script.Parent
local degats = 100

local function surContact(autrePart)
	local humanoid = autrePart.Parent.Humanoid
	if humanoid.Health > 0 then
		humanoid.Health = 0
	end
end

killBrick.Touched:Connect(surContact)

📌 Ce qu’il faut retenir

• On déclare les variables avec local ; les noms sont sensibles à la casse et ne commencent pas par un chiffre.
• Types de base : nil, boolean, number, string ; typeof donne le type, y compris les types Roblox.
• Opérateurs : + - * / // % ^, comparaisons == ~= < > <= >=, textes collés avec .. ou interpolés avec les accents graves.
• Seuls nil et false sont faux ; 0 et "" sont vrais. or sert à donner une valeur par défaut.
• if / elseif / else / end exécute le premier bloc dont la condition est vraie.
• Une kill brick met Health à 0 après avoir vérifié qu’un Humanoid a bien été trouvé : c’est ce test que tu dois retrouver dans tout code produit par l’IA.

📚 Sources et pour aller plus loin

• Variables (mots réservés, local, const) — documentation Luau de Roblox
• Scope (variables locales plus rapides, libérées en fin de bloc) — documentation Luau de Roblox
• Operators — documentation Luau de Roblox
• Strings — documentation Luau de Roblox
• Syntaxe de Luau (interpolation, expressions if, affectations composées, const) — luau.org
• typeof — Roblox globals, référence API
• Humanoid (Health, TakeDamage) — référence API
• Tutoriel officiel « Deadly lava »