Progression, difficulté et récompenses

Ton joueur a passé ses premières secondes avec plaisir. Et maintenant ? Pour qu’il continue, il lui faut un défi à sa mesure, des récompenses qui donnent envie et des objectifs qui l’attirent plus loin. C’est le rôle de la progression, le troisième pilier de la core loop. Cette leçon t’apprend à la doser dans l’Obby des Nuages.

La courbe de difficulté

La difficulté d’un jeu évolue au fil de la partie : c’est sa courbe de difficulté. La page de Roblox sur la rétention résume l’enjeu en deux phrases :

• si les joueurs progressent trop vite, ils risquent de manquer de contenu à explorer ;
• s’ils progressent trop lentement, ils peuvent s’ennuyer, se frustrer et perdre la motivation de rester.

Elle conseille aussi d’équilibrer le défi de la core loop pour éviter à la fois la frustration et l’ennui. L’objectif n’est donc pas un jeu « facile » ou « dur », mais un jeu dont la difficulté suit les progrès du joueur.

Découper le parcours en paliers

Pour un obby, une méthode simple (c’est le choix de cette formation) consiste à regrouper les étapes en paliers, chacun avec son thème et son niveau de difficulté. Bonne nouvelle : tu les as déjà ! Au module 3 (leçon 6), tu as rangé dans Config.Niveaux les trois niveaux de l’Obby des Nuages. On va maintenant leur donner une difficulté croissante :

Quand tu ajouteras des étapes, il suffira de modifier etapeFin (ou d’ajouter un niveau) dans Config. À l’intérieur de chaque niveau, beaucoup de concepteurs de niveaux alternent les passages difficiles et les moments plus calmes, plutôt que de monter la difficulté sans répit : on parle souvent de courbe « en dents de scie ». Ce n’est pas une règle officielle de Roblox, mais une approche courante à vérifier avec tes playtests (leçon 5).

Introduire un obstacle à la fois

Quand tu présentes un nouvel obstacle (une plateforme qui bouge, par exemple), propose-le d’abord seul et sans danger, puis dans une version plus exigeante, puis combiné à d’autres. C’est une pratique courante de level design, pas une règle Roblox, et elle prolonge le principe du tutoriel contextuel de la leçon précédente : on apprend en jouant, un élément à la fois.

Choisir des récompenses motivantes

Récompenses fixes et récompenses variables

• Une récompense fixe est toujours la même : 2 pièces par checkpoint, un bonus en fin de niveau. Le joueur sait ce qu’il va gagner, ce qui lui permet de planifier (« encore 3 étapes et je peux m’acheter la Traînée Nuage »).
• Une récompense variable change d’une fois à l’autre : une pièce rare qui apparaît parfois, un coffre au contenu aléatoire. Elle crée de la surprise.

Quand ce hasard est payant, Roblox l’encadre strictement. Ses Community Standards fixent des règles pour les objets aléatoires payants : les probabilités doivent être affichées de façon exacte et chiffrée avant l’achat, et chaque résultat possible doit apporter un bénéfice au joueur. Le créateur doit en outre en réserver l’accès aux utilisateurs éligibles (attribut ArePaidRandomItemsRestricted). On étudiera ces règles au module 7 (Fixer ses prix et monétiser éthiquement).

Pour l’Obby des Nuages, on reste simple : des récompenses fixes et lisibles, et éventuellement un peu de surprise gratuite (une pièce dorée cachée qui vaut plus que les autres).

Faire grandir la récompense avec l’effort

La documentation Roblox sur les quêtes donne un principe clair : en général, plus une tâche est difficile, plus la récompense doit avoir de valeur. Sa page sur l’onboarding conseille aussi de garder les premiers paliers de progression bas, pour que le joueur sente tout de suite qu’il avance. Un niveau facile rapporte donc peu par étape, un niveau difficile beaucoup plus, avec un bonus quand on en termine un.

Coder une récompense par palier

Ces réglages ont leur place dans le ModuleScript Config que tu as créé au module 3 (leçon 6), dans ReplicatedStorage › Modules. Tu n’as rien à recréer : ouvre-le, fais deux ajouts (repérés par -- NOUVEAU ci-dessous) et vérifie l’ordre du fichier :

1. Dans Config.Niveaux, ajoute à chaque niveau un champ piecesParEtape.
2. Sous la fonction Config.obtenirNiveau (déjà présente), ajoute Config.BONUS_FIN_DE_NIVEAU et la fonction Config.recompensePourEtape. Elle réutilise obtenirNiveau pour trouver le niveau de l’étape.
3. Garde return Config tout à la fin (on ne touche pas au reste du fichier). Si tu as ajouté table.freeze(Config) (astuce du module 3), laisse-le juste avant return Config, après tes ajouts : une fois gelée, la table refuse tout nouveau champ.

Voici le module complet après modification :

-- ModuleScript « Config » dans ReplicatedStorage > Modules (créé au module 3, leçon 6)
-- Tous les réglages de l'Obby des Nuages, au même endroit.
local Config = {}

-- Pièces
Config.VITESSE_ROTATION_PIECES = 90 -- degrés par seconde
Config.VALEUR_PIECE = 1             -- pièces gagnées par ramassage

-- Checkpoints
Config.HAUTEUR_REAPPARITION = Vector3.new(0, 4, 0)

-- Niveaux : chaque niveau regroupe des étapes de difficulté proche
-- NOUVEAU : le champ piecesParEtape (pièces gagnées par étape de ce niveau)
Config.Niveaux = {
	{nom = "Les premiers nuages", etapeDebut = 1, etapeFin = 5, piecesParEtape = 2},
	{nom = "La tempête", etapeDebut = 6, etapeFin = 10, piecesParEtape = 3},
	{nom = "Le sommet", etapeDebut = 11, etapeFin = 12, piecesParEtape = 5},
}

-- Renvoie le niveau qui contient l'étape donnée (ou nil)
function Config.obtenirNiveau(etape)
	for _, niveau in Config.Niveaux do
		if etape >= niveau.etapeDebut and etape <= niveau.etapeFin then
			return niveau
		end
	end
	return nil
end

-- NOUVEAU : bonus versé en terminant un niveau (le « moment de joie » de fin de palier)
Config.BONUS_FIN_DE_NIVEAU = 10

-- NOUVEAU : pièces gagnées en atteignant une étape pour la première fois
function Config.recompensePourEtape(etape: number): number
	local niveau = Config.obtenirNiveau(etape)
	if niveau == nil then
		return 0 -- étape hors des niveaux : aucune récompense
	end
	local gain = niveau.piecesParEtape
	if etape == niveau.etapeFin then
		gain += Config.BONUS_FIN_DE_NIVEAU -- dernière étape du niveau : bonus
	end
	return gain
end

return Config -- OBLIGATOIRE, toujours en dernier

Côté serveur, la récompense doit être versée là où le checkpoint est validé (modules 4 et 5), et seulement pour une étape jamais atteinte. Sinon, un joueur pourrait toucher le même checkpoint en boucle pour accumuler des pièces. Le petit module ci-dessous fait les deux d’un coup. Crée-le comme un ModuleScript dans ServerScriptService (efface le code de départ avant de coller le tien, comme pour DonneesJoueurs au module 5). On l’appelle RecompensesEtapes, et pas Recompenses, pour ne pas le confondre avec le Script d’exemple « Recompenses » du module 4 (leçon 3) : deux objets du même nom dans ServerScriptService, et WaitForChild risque de renvoyer le mauvais.

-- ModuleScript « RecompensesEtapes » dans ServerScriptService
-- À appeler depuis le script qui valide les checkpoints (modules 4 et 5), côté serveur uniquement.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Config = require(ReplicatedStorage:WaitForChild("Modules"):WaitForChild("Config"))

local RecompensesEtapes = {}

-- Fait passer le joueur à l'étape suivante et lui verse la récompense correspondante.
-- Renvoie true si l'étape a été acceptée.
function RecompensesEtapes.valider(player: Player, nouvelleEtape: number): boolean
	local stats = player:FindFirstChild("leaderstats")
	if not stats then
		return false
	end
	local etape = stats:FindFirstChild("Etape") :: IntValue?
	local pieces = stats:FindFirstChild("Pieces") :: IntValue?
	if not (etape and pieces) then
		return false
	end

	-- Seule l'étape qui suit immédiatement est acceptée : pas de saut d'étape, pas de « farm »
	if nouvelleEtape ~= etape.Value + 1 then
		return false
	end

	etape.Value = nouvelleEtape
	pieces.Value += Config.recompensePourEtape(nouvelleEtape)
	return true
end

return RecompensesEtapes

Il reste à le brancher dans ton Script serveur de checkpoints, « Progression » (créé au module 4, adapté au module 5) :

1. en haut du script, charge le module (ajoute aussi la ligne ServerScriptService si ton script ne l’a pas déjà) :

local ServerScriptService = game:GetService("ServerScriptService")
local RecompensesEtapes = require(ServerScriptService:WaitForChild("RecompensesEtapes"))

2. remplace la ligne etape.Value = numero par RecompensesEtapes.valider(player, numero). Garde avant elle toutes les vérifications déjà en place (étape suivante, distance…).

Grâce au script de feedback de la leçon 1, le joueur verra « +13 pièces » en terminant « La tempête » : le bonus est perçu, pas seulement versé.

Équilibrer l’économie : sources et puits

Dès qu’une monnaie existe, ton jeu a une économie. La documentation Roblox la décrit avec deux notions :

• les sources : tout ce qui crée de la monnaie (pièces ramassées, bonus d’étape, objectifs quotidiens de la leçon suivante) ;
• les puits (sinks) : les systèmes qui retirent la monnaie de la circulation (achats en boutique, objets à durée limitée).

Si les sources produisent beaucoup plus que ce que les puits absorbent, les joueurs accumulent des réserves énormes. C’est ce qu’on appelle couramment l’inflation (terme général d’économie ; la page Roblox parle de « surplus ») : la monnaie ne vaut plus grand-chose, plus rien n’est désirable, et la boucle méta s’arrête. Roblox décrit exactement ce scénario dans son exemple : un événement mal estimé crée un surplus de monnaie ; les joueurs qui en ont beaucoup dépensent sans compter et n’ont plus guère de raison d’en acheter davantage.

Roblox insiste : quand on conçoit une nouvelle source de monnaie, il est impératif d’avoir prévu les puits qui absorberont l’excédent, donc de les planifier avant de lancer la source. Pour un événement temporaire, la solution que sa documentation juge la plus sûre est une monnaie d’événement séparée, dépensable uniquement dans une boutique d’événement : l’économie principale reste intacte.

Faire le calcul pour l’Obby des Nuages

La documentation Roblox utilise un calcul d’espérance (la valeur moyenne gagnée par tentative) pour estimer ce que produit une source. Faisons la version simple pour notre obby :

• Bonus d’étapes, une seule fois par joueur : niveau 1 = 5 × 2 + 10 = 20 ; niveau 2 = 5 × 3 + 10 = 25 ; niveau 3 = 2 × 5 + 10 = 20. Total : 65 pièces.
• Pièces ramassées : disons 40 pièces réparties sur le parcours. Comme elles réapparaissent (module 4), un joueur gagne environ 40 pièces par parcours rejoué, mais plus aucun bonus d’étape.

Compare maintenant avec les prix de ta boutique (le module Catalogue du module 5) :

Tu obtiens des objectifs à court, moyen et long terme, exactement ce que Roblox conseille d’afficher dès l’onboarding. Ces chiffres sont des points de départ : seuls tes playtests et, plus tard, tes statistiques (module 9) te diront s’ils sont justes. Et si tu ajoutes des étapes, refais le calcul : les bonus augmentent, et les prix devront peut-être suivre.

Éviter la frustration

Quelques garde-fous :

• Un échec ne doit jamais coûter trop cher : checkpoints fréquents avant les passages durs, aucune perte de pièces à la mort. C’est un choix de la formation pour l’Obby des Nuages, au service du conseil Roblox d’éviter la frustration.
• Les objectifs doivent rester atteignables : la page sur les season passes note que si les joueurs échouent régulièrement à leurs missions, leur intérêt s’éteint.
• La récompense doit être visible : le feedback de la leçon 1 transforme un chiffre qui change en moment de satisfaction.

📌 Ce qu’il faut retenir

• Une bonne courbe de difficulté évite les deux écueils cités par Roblox : progresser trop vite (plus de contenu) ou trop lentement (frustration).
• Découpe le parcours en paliers (les niveaux de Config), introduis un obstacle à la fois et place un checkpoint avant chaque passage difficile.
• Préfère des récompenses fixes et lisibles ; les objets aléatoires payants sont strictement encadrés par Roblox.
• Une économie saine équilibre sources et puits ; planifie les puits avant d’ajouter des sources.
• Calcule ce que gagne un joueur pour fixer des prix à court, moyen et long terme, puis vérifie avec des playtests.

📚 Sources et pour aller plus loin

• Retention — équilibrer la progression (Roblox)
• Balance virtual economies — sources, puits et espérance (Roblox)
• Quest design — difficulté et valeur des récompenses (Roblox)
• Onboarding — premiers paliers bas et objectifs visibles (Roblox)
• Season pass design — missions atteignables (Roblox)
• Roblox Community Standards — objets aléatoires payants