La boucle de jeu (core loop)

Pourquoi certains jeux te donnent envie de « faire encore une partie » alors que d’autres te lassent en deux minutes ? Une grande partie de la réponse tient dans leur boucle de jeu, en anglais core loop. C’est le premier outil du game designer, et c’est par lui que commence ce module. Tu as maintenant un Obby des Nuages qui fonctionne (modules 1 à 5) : il est temps de le rendre amusant à rejouer.

Qu’est-ce qu’une core loop ?

La documentation officielle de Roblox définit la core loop comme le gameplay central autour duquel tout le jeu est construit. Elle la découpe en trois parties :

1. L’interaction minute par minute : ce que le joueur fait en permanence. Dans un obby, c’est courir et sauter.
2. L’ensemble d’actions le plus répété : la mécanique qui définit le jeu. Dans un obby, c’est franchir un obstacle.
3. Le moteur de progression : le système qui fait avancer le joueur. Selon la documentation, sans lui, un jeu devient « répétitif, ennuyeux et superficiel ».

L’exemple donné par Roblox est celui d’un jeu de rôle d’action : le joueur explore le monde, combat des ennemis, puis améliore son personnage grâce à un arbre de compétences. Ces améliorations rendent l’exploration et les combats suivants plus intéressants. On obtient un cycle : explorer → combattre → s’améliorer → explorer…

Une formule simple à retenir

Pour un débutant, on peut résumer la boucle en trois mots : action → récompense → progression. C’est une simplification proposée par cette formation, pas le vocabulaire officiel de Roblox, mais elle recoupe ses trois parties.

• Action : le joueur fait quelque chose (sauter, récolter, combattre).
• Récompense : le jeu répond tout de suite (une pièce, un son, un message, un effet visuel).
• Progression : la récompense change quelque chose de durable (une nouvelle zone, un objet, un niveau).

La page de Roblox sur la rétention le dit avec ses mots : identifie les étapes de ta boucle et rends-les claires et amusantes, équilibre le défi pour éviter à la fois la frustration et l’ennui, et récompense le joueur qui termine la boucle avec du feedback, de la monnaie, des objets ou des succès.

Boucles courtes et boucles longues

Un jeu ne contient pas une seule boucle, mais plusieurs boucles imbriquées, de durées différentes. Cette façon de décrire un jeu est très répandue chez les game designers, même si la page « Core loops » de Roblox ne détaille que la boucle principale.

La boucle méta (de « méta-jeu », le jeu autour du jeu) donne une raison de revenir demain. On l’approfondira dans les leçons 3 et 4 de ce module.

Analyser la boucle de jeux existants

Analyser des jeux populaires est un excellent exercice, à condition de décrire ce que tu observes, sans copier. Voici des boucles typiques par genre. Ce sont des descriptions générales, pas des recettes garanties : chaque jeu les adapte à sa façon.

L’obby

• Action : sauter d’obstacle en obstacle.
• Récompense : atteindre un checkpoint (on ne recommence plus depuis le début).
• Progression : le numéro d’étape monte, de nouvelles zones apparaissent.

Le simulateur

• Action : cliquer ou récolter une ressource.
• Récompense : de la monnaie.
• Progression : acheter un meilleur outil, qui permet de récolter plus vite, puis de débloquer une nouvelle zone.

Le tycoon

• Action : construire une machine ou un bâtiment.
• Récompense : un revenu qui arrive automatiquement.
• Progression : acheter des bâtiments plus chers qui rapportent plus.

Le jeu de rôle (roleplay)

• Action : choisir un rôle, discuter, jouer une scène avec d’autres joueurs.
• Récompense : surtout sociale (une histoire partagée, des amis).
• Progression : souvent cosmétique (maison, véhicule, tenue).

Le tutoriel officiel « Core curriculum » de Roblox fait construire un petit jeu de plateforme où les joueurs collectent des pièces pour les échanger contre de la puissance de saut, ce qui leur permet d’atteindre des plateformes de plus en plus hautes. C’est une boucle complète en une phrase : les pièces (récompense) achètent du saut (progression), qui ouvre de nouveaux sauts (action).

La boucle de l’Obby des Nuages

Appliquons tout ça à notre fil rouge :

1. Action : le joueur saute de nuage en nuage, en évitant les kill bricks.
2. Récompense immédiate : il ramasse des pièces sur le chemin et atteint un checkpoint.
3. Progression : son étape (Etape) augmente et ses pièces (Pieces) s’accumulent.
4. Retour à l’action : avec ses pièces, il achète une traînée dans la boutique, qu’il montre fièrement en continuant le parcours… et il repart vers l’étape suivante.

Il manque souvent une chose dans les premiers obbys : le retour visible (feedback). Dans l’Obby des Nuages, la valeur Pieces change bien dans les leaderstats, mais rien ne le signale vraiment au joueur. Or la documentation Roblox sur les techniques d’onboarding est claire : chaque fois qu’un joueur fait une action, il est impératif de lui donner un retour clair.

Rendre la récompense visible

Le script ci-dessous affiche un message bref en haut et au centre de l’écran quand le joueur gagne des pièces ou atteint une nouvelle étape. Crée-le comme un LocalScript nommé MessagesProgression dans StarterPlayer › StarterPlayerScripts : il fabrique lui-même sa petite interface, rien à construire à la main. Il ne modifie rien : il se contente de regarder les valeurs que le serveur met à jour (module 5) et de les mettre en scène. Dans ton projet Rojo (module 2), ce LocalScript est le fichier src/StarterPlayer/StarterPlayerScripts/MessagesProgression.client.luau : tu peux le demander à Claude Code avec le prompt de l’encadré « Avec Claude Code » plus bas, puis le relire à l’aide des explications de cette leçon.

-- LocalScript « MessagesProgression » à placer dans StarterPlayer > StarterPlayerScripts
-- Affiche un message quand le joueur gagne des pièces ou atteint une nouvelle étape.
-- Le serveur reste le seul à modifier les valeurs : ici, on ne fait que les afficher.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local TweenService = game:GetService("TweenService")

local joueur = Players.LocalPlayer
local leaderstats = joueur:WaitForChild("leaderstats")
local pieces = leaderstats:WaitForChild("Pieces") :: IntValue
-- RemoteEvent du module 4 : le Script « Progression » l'utilise après chaque étape validée
local notification = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notification") :: RemoteEvent

-- Petite interface créée par le script
local ecran = Instance.new("ScreenGui")
ecran.Name = "RetourBoucle"
ecran.ResetOnSpawn = false -- l'interface survit à la réapparition du personnage
ecran.Parent = joueur:WaitForChild("PlayerGui")

local message = Instance.new("TextLabel")
message.AnchorPoint = Vector2.new(0.5, 0)
message.Position = UDim2.fromScale(0.5, 0.15)
message.Size = UDim2.fromScale(0.5, 0.08)
message.BackgroundTransparency = 1
message.TextScaled = true
message.TextColor3 = Color3.fromRGB(255, 220, 80)
message.TextTransparency = 1 -- invisible au départ
message.TextStrokeTransparency = 1
message.Parent = ecran

local infoFondu = TweenInfo.new(1.5, Enum.EasingStyle.Quad, Enum.EasingDirection.In)

-- Affiche un texte puis le fait disparaître en fondu
local function afficher(texte: string)
	message.Text = texte
	message.TextTransparency = 0
	message.TextStrokeTransparency = 0.5
	local fondu = TweenService:Create(message, infoFondu, {
		TextTransparency = 1,
		TextStrokeTransparency = 1,
	})
	fondu:Play()
end

-- Sécurité : le script de sauvegarde du module 5 crée les leaderstats directement avec
-- les valeurs chargées. Mais si ton propre script les met à jour APRÈS les avoir créées
-- (ex. de 0 à 120 pièces), on ne veut pas célébrer ce saut : on attend un peu.
local pret = false
task.delay(3, function()
	pret = true
end)

local anciennesPieces = pieces.Value
pieces.Changed:Connect(function(nouvelleValeur: number)
	local gain = nouvelleValeur - anciennesPieces
	anciennesPieces = nouvelleValeur
	if pret and gain > 0 then
		afficher("+" .. gain .. " pièce" .. (if gain > 1 then "s" else ""))
	end
end)

-- Les étapes : le SERVEUR envoie déjà « Étape N atteinte ! » (Script « Progression »,
-- module 4) une fois le checkpoint validé. Il suffit d'écouter et d'afficher.
notification.OnClientEvent:Connect(function(texte: string)
	afficher(texte)
end)

Quelques points à remarquer :

• C’est un LocalScript : l’affichage ne concerne que le joueur concerné. Les valeurs, elles, restent modifiées par le serveur, comme on l’a vu au module 4.
• On mémorise l’ancienne valeur pour calculer le gain et pour ne célébrer que les progrès (pas une baisse de pièces après un achat).
• Pour les étapes, pas besoin de surveiller Etape : depuis le module 4, ton Script « Progression » envoie « Étape N atteinte ! » par le RemoteEvent Notification, juste après avoir validé le checkpoint. Le LocalScript l’écoute avec OnClientEvent et l’affiche.
• Le texte apparaît puis disparaît en fondu grâce à TweenService (module 5) : le feedback doit être bref, pas envahissant.

Ce qu’une bonne boucle n’est pas

Une boucle efficace n’est pas une boucle interminable. Le but n’est pas de garder le joueur le plus longtemps possible par tous les moyens, mais de lui donner une activité amusante avec des objectifs clairs. On verra dans la leçon 4 comment Roblox encadre les mécaniques de rétention, et pourquoi les « dark patterns » (manipulations) sont à proscrire.

📌 Ce qu’il faut retenir

• La core loop est le gameplay central d’un jeu. Roblox la découpe en trois parties : interaction minute par minute, actions les plus répétées, moteur de progression.
• Formule simple : action → récompense → progression, et la progression doit ramener à l’action.
• Un jeu combine des boucles courtes (secondes), une boucle principale (minutes) et des boucles longues (sessions).
• Toute nouvelle fonctionnalité doit servir la boucle principale.
• Le feedback (message, son, effet) rend la récompense perceptible : sans lui, la boucle perd sa force.

📚 Sources et pour aller plus loin

• Core loops — documentation Roblox
• Design games on Roblox — vue d’ensemble du game design (Roblox)
• Retention — conseils pour la core loop et la rétention D1 (Roblox)
• Onboarding techniques — importance du feedback (Roblox)
• LiveOps essentials — relier les nouveautés à la core loop (Roblox)
• Core curriculum — tutoriel officiel de jeu de plateforme (Roblox)
• Prototyping — examiner la core loop dès le prototype (Roblox)