Genres de jeux

Comment faire un obby sur Roblox Studio

Un obby est le jeu Roblox le plus facile à commencer, et l'un des plus durs pour garder les joueurs. Le scripting est léger : quelques scripts d'obstacles et un système de checkpoints. Le vrai travail, c'est le design des niveaux, parce que chaque joueur qui abandonne le fait à un niveau précis, et ton travail est de trouver ce niveau et de le corriger. Ce guide couvre le jeu entier : comment concevoir les niveaux, comment façonner la difficulté, les systèmes nécessaires, un plan de construction d'une baseplate vide jusqu'au lancement, et comment un obby gagne de l'argent sans gâcher le défi.

Mis à jour le 12 novembre 202613 min de lectureÉcrit par

En bref

Un obby est un parcours de niveaux numérotés (les stages), chacun un court défi de sauts qui se termine sur un checkpoint. Il te faut un script de checkpoints qui sauvegarde le niveau le plus haut, des parts mortelles qui renvoient les joueurs en arrière, quelques types d'obstacles réutilisables, et un moyen de voir où les joueurs abandonnent. Construis d'abord 10 niveaux en parts grises, teste-les sur de vrais joueurs, puis ajoute un thème, monétise avec un produit skip stage et des cosmétiques, et ajoute des niveaux dans des mises à jour régulières.

  • La difficulté doit monter par vagues, pas en ligne droite : un niveau dur, puis un ou deux plus faciles qui utilisent la même idée.
  • Apprends chaque nouvel obstacle sur un niveau où rater ne coûte presque rien, avant de le combiner avec autre chose.
  • Enregistre chaque niveau atteint comme une étape de funnel sur le serveur, pour que le Creator Hub te montre exactement où les joueurs s'arrêtent.
Sur cette page
  1. Ce qui marche
  2. Design des niveaux
  3. Systèmes
  4. Plan de construction
  5. Script d'obstacles
  6. Funnel des abandons
  7. Monétisation
  8. Rétention
  9. Avec RoCode
  10. Questions fréquentes
  11. Sources et lectures

Ce qui fait qu'un obby marche

La boucle en une ligne : sauter, rater, réapparaître tout près, réessayer, atteindre le checkpoint suivant. Tout dans un bon obby protège cette boucle. Un joueur doit être de retour au début du saut qu'il a raté en quelques secondes, et chaque checkpoint doit ressembler à une petite victoire.

  • Toutes les 10 secondes : un saut lisible. Le joueur voit où atterrir avant de sauter. Les obbys injustes cachent l'atterrissage ou utilisent la caméra contre le joueur. Les obbys justes sont durs parce que le saut est serré, pas parce qu'il faut deviner.
  • Toutes les minutes : un checkpoint. Des niveaux courts rendent l'échec peu coûteux. Un niveau qui prend trois minutes à rejouer après une seule glissade, c'est là que les joueurs partent, même quand le saut lui-même est facile.
  • Toutes les 5 minutes : quelque chose de nouveau. Un nouveau type d'obstacle, un nouveau thème de couleurs ou un nouveau monde. Vingt niveaux des mêmes sauts au-dessus de la lave paraissent plus longs que quarante niveaux qui changent sans arrêt.
  • À chaque session : un objectif visible. Le numéro de niveau dans la liste des joueurs, la fin du monde en cours, un badge au niveau 50. Les joueurs s'arrêtent quand ils ne voient pas le chemin qu'il leur reste.
  • Les autres : des joueurs sur le même parcours, un leaderboard des niveaux ou des temps, et des amis à battre à la course.

Ce qui sépare les obbys qu'on finit de ceux qu'on abandonne, c'est rarement les graphismes. C'est le rythme : les obbys abandonnés ont un pic de difficulté tôt, répètent le même obstacle, ou mettent un long niveau avant le premier checkpoint. Roblox classe Obby & platformer comme un genre à part avec trois sous-genres : Classic Obby, Runner (les joueurs avancent tout seuls) et Tower Obby (on grimpe vers le haut). Choisis tôt celui que tu fais, parce que Roblox ne te laisse changer le genre d'un jeu qu'une fois tous les trois mois.

Concevoir les niveaux et la courbe de difficulté

Pars du personnage. Un personnage Roblox par défaut marche à 16 studs par seconde et saute à 7,2 studs de haut (les valeurs par défaut de CharacterWalkSpeed et CharacterJumpHeight dans StarterPlayer). Construis une piste de test avec des plateformes de plus en plus éloignées et hautes avant de concevoir quoi que ce soit, et joue-la. Cette piste te dit quels écarts sont faciles, lesquels sont serrés et lesquels sont impossibles avec tes réglages. Si tu changes plus tard la hauteur de saut ou la vitesse de marche, chaque niveau change avec, donc décide tôt.

Une courbe de difficulté pour un premier monde de 20 niveaux
NiveauxObjectifCe qu'il faut y mettre
1 à 3Personne ne rateDes plateformes larges, des écarts courts, une part mortelle loin en dessous. Le joueur apprend que tomber ne coûte pas cher.
4 à 7Apprendre une idée chacunUne première plateforme mobile, une première plateforme qui disparaît, un premier obstacle qui tourne. Chacun seul, avec un sol sûr à côté.
8 à 10Premier vrai testCombine deux idées que le joueur a déjà vues. Termine sur un checkpoint qui paraît mérité.
11 à 12RespirationUn niveau facile et beau. Les joueurs qui viennent de galérer ont besoin d'une victoire.
13 à 18Monter et relâcherDur, plus facile, plus dur, plus facile. Jamais trois niveaux durs d'affilée si tôt.
19 à 20Final du mondeLe niveau le plus dur du monde, puis une récompense : un badge, une nouvelle zone, un cosmétique.

Des règles valables pour la plupart des obbys :

  • Une nouveauté à la fois. Quand un niveau présente les plateformes qui disparaissent, il ne doit pas être aussi le premier avec un obstacle qui tourne.
  • Rends le danger lisible. Les parts mortelles dans une seule couleur et un seul matériau dans tout le jeu (le neon rouge vif est la convention, et pour une bonne raison), et les parts sûres dans d'autres. Les joueurs ne doivent jamais mourir à cause de quelque chose qui avait l'air sûr.
  • Des niveaux courts, beaucoup de checkpoints. Si un niveau prend plus d'environ une minute à rejouer, coupe-le en deux.
  • Pas de saut à l'aveugle. Si l'atterrissage est hors de vue, ajoute un panneau, une flèche ou un point de vue plus bas.
  • Teste sur un téléphone. Les commandes tactiles rendent les sauts précis plus durs. Joue chaque niveau difficile sur un vrai téléphone avant le lancement.

Les systèmes dont un obby a besoin

Les systèmes, les éléments de Roblox qu'ils utilisent, et où apprendre chacun
SystèmeCe qu'il faitÉléments de RobloxGuide
Checkpoints et sauvegarde du niveauEnregistre le niveau le plus haut atteint, fait réapparaître là, le sauvegardeTouched, leaderstats, DataStoreServiceCheckpoints d'obby (en anglais)
Parts mortelles et laveFait réapparaître un joueur qui touche un dangerTouched, Humanoid.Health, tagsKill brick
Plateformes mobilesDes plateformes que les joueurs peuvent prendre sans glisserContraintes physiquesPlateforme mobile (en anglais)
Obstacles qui disparaissent et qui tournentDes types d'obstacles réutilisables par tagCollectionService, RunService.HeartbeatCette page
Pads de vitesse et de sautDes pads de lancement et de courts boostsHumanoid.WalkSpeed, AssemblyLinearVelocityPads de vitesse et de saut (en anglais)
Skip stageUn moyen payant de passer un niveauDeveloper product, ProcessReceiptProduit skip stage (en anglais)
Leaderboard des niveauxUn classement mondial des niveaux ou des tempsOrdered data storeLeaderboard
Suivi des abandonsMontre le niveau où les joueurs s'arrêtentÉvénements de funnel AnalyticsServiceCette page
Récompenses quotidiennesUne raison de revenir demainData stores, une interfaceRécompenses quotidiennes

Le système de checkpoints est la seule partie qui doit être juste avant tout le reste. Il possède le numéro de niveau, donc le skip stage, les leaderboards et le funnel le lisent tous. Le guide des checkpoints garde le niveau dans une IntValue nommée Stage dans leaderstats, et les scripts de cette page lisent cette même valeur.

Plan de construction : d'une baseplate au lancement

  1. Piste de test du mouvement. Sur une Baseplate, pose des plateformes dont les écarts grandissent de 2 studs et les hauteurs de 1 stud. Joue-la, note le plus grand écart que tu passes à chaque fois et le plus grand que tu passes une fois sur deux. Ces deux nombres sont ton « facile » et ton « dur ».
  2. Checkpoints. Suis le guide des checkpoints (en anglais) : un dossier Checkpoints avec des parts nommées 1, 2, 3, et son script serveur. Vérifie que mourir te fait réapparaître sur le bon checkpoint et que tu ne peux pas sauter en avant en touchant le checkpoint 5 depuis le niveau 2.
  3. Sol mortel. Une grande part mortelle sous tout le parcours, plus le script de kill brick pour chaque danger.
  4. 10 niveaux en greybox. De simples parts grises, sans décoration. Suis la courbe ci-dessus. Ajoute le script d'obstacles ci-dessous pour que les parts qui disparaissent et qui tournent marchent par tag.
  5. Premier test avec d'autres personnes. Publie le jeu en privé ou partage-le avec des amis, et regarde-les jouer sans les aider. Note chaque niveau où quelqu'un est mort plus de cinq fois.
  6. Corrige et passe à 20 ou 30 niveaux. Rééquilibre les niveaux à partir de tes notes. Puis donne-leur un thème : couleurs, matériaux, éclairage par monde.
  7. Ajoute le script de funnel, et publie. Les événements de funnel ne partent que d'un jeu publié, donc c'est à ce moment que les données d'abandon commencent.
  8. Fonctions du lancement. Un compteur de niveau à l'écran, un produit skip stage, un ou deux passes, une boutique de traînées, des récompenses quotidiennes et des badges à la fin des mondes. Puis prévois ta première mise à jour avant le jour du lancement, parce que la fin de ton parcours, c'est là qu'arrive chaque joueur motivé.

Des obstacles par tag : un seul script pour tout le parcours

Un obby de 100 niveaux avec un script dans chaque obstacle est pénible à modifier. Utilise plutôt des tags : donne à une part le tag Fade ou Spin dans la fenêtre Properties (la partie Tags), et un seul script serveur les trouve toutes avec CollectionService. Pour changer la durée de toutes les plateformes qui disparaissent, tu modifies un seul nombre.

Script dans ServerScriptService nommé ObbyObstacles
-- Script dans ServerScriptService nommé ObbyObstacles.
-- Un seul script pour chaque obstacle : tague une part "Fade" ou "Spin" et elle marche.
local CollectionService = game:GetService("CollectionService")
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local FADE_DELAY = 0.6 -- secondes que tient une plateforme Fade après le premier contact
local FADE_GONE = 2 -- secondes pendant lesquelles elle reste partie avant de revenir
local SPIN_SPEED = 90 -- degrés par seconde, sauf si la part a un attribut SpinSpeed

local function setupFade(part: BasePart)
	local busy = false
	part.Touched:Connect(function(hit)
		local character = hit.Parent
		if busy or not (character and character:IsA("Model")) or not Players:GetPlayerFromCharacter(character) then
			return
		end
		busy = true
		local start = part.Transparency
		part.Transparency = 0.5 -- prévient le joueur
		task.wait(FADE_DELAY)
		part.Transparency = 1
		part.CanCollide = false
		task.wait(FADE_GONE)
		part.Transparency = start
		part.CanCollide = true
		busy = false
	end)
end

local spinners: { [BasePart]: CFrame } = {}

local function setupSpin(part: BasePart)
	part.Anchored = true
	spinners[part] = part.CFrame
end

for _, part in CollectionService:GetTagged("Fade") do
	if part:IsA("BasePart") then
		setupFade(part)
	end
end
for _, part in CollectionService:GetTagged("Spin") do
	if part:IsA("BasePart") then
		setupSpin(part)
	end
end

-- Fait tourner chaque obstacle depuis son CFrame de départ, pour qu'ils ne se décalent jamais
RunService.Heartbeat:Connect(function()
	local now = workspace:GetServerTimeNow()
	for part, origin in spinners do
		if not part.Parent then
			spinners[part] = nil
			continue
		end
		local speed = part:GetAttribute("SpinSpeed")
		local degrees = (if typeof(speed) == "number" then speed else SPIN_SPEED) * now
		part.CFrame = origin * CFrame.Angles(0, math.rad(degrees % 360), 0)
	end
end)
  • Les parts Fade deviennent à moitié transparentes quand un joueur atterrit dessus, disparaissent après 0,6 seconde et reviennent 2 secondes plus tard. L'étape à moitié transparente est l'avertissement qui les rend justes.
  • Les parts Spin sont ancrées et tournent autour de leur axe vertical, pratique pour des barres qui balayent le sol et par-dessus lesquelles on saute. Donne à l'une d'elles un attribut SpinSpeed pour changer sa vitesse. Les obstacles tournent selon l'heure partagée du serveur, donc deux obstacles de même vitesse restent synchronisés.
  • Les parts ancrées déplacées de cette façon ne transportent pas les joueurs. Pour une plateforme sur laquelle les joueurs restent debout pendant qu'elle bouge, utilise le guide de la plateforme mobile (en anglais), qui la déplace avec la physique.
  • Le script lit les tags une fois, au démarrage du serveur. Ça convient à un parcours construit dans Studio. Si tu crées des obstacles pendant que le jeu tourne, connecte aussi CollectionService:GetInstanceAddedSignal.

Trouver le niveau où les joueurs abandonnent

Les analytics de Roblox ont des événements de funnel : tu enregistres des étapes numérotées depuis le serveur, et la page Funnel du Creator Hub montre combien de joueurs ont atteint chacune. Pour un obby, chaque niveau est une étape. Le niveau où la barre chute brutalement, c'est ton niveau à problème.

Script dans ServerScriptService nommé StageFunnel
-- Script dans ServerScriptService nommé StageFunnel.
-- Enregistre chaque niveau qu'un joueur atteint comme une étape de funnel, pour que la page
-- Funnel des analytics du Creator Hub montre le niveau où les joueurs s'arrêtent.
local AnalyticsService = game:GetService("AnalyticsService")
local Players = game:GetService("Players")

local FUNNEL_NAME = "ObbyStages"
local MAX_STEP = 100 -- les funnels acceptent les étapes 1 à 100

local function watch(player: Player)
	local leaderstats = player:WaitForChild("leaderstats", 30)
	local stage = leaderstats and leaderstats:WaitForChild("Stage", 30)
	if not (stage and stage:IsA("IntValue")) then
		return
	end
	local function log()
		local step = math.clamp(stage.Value, 1, MAX_STEP)
		-- Le funnel ignore une étape répétée, donc un joueur qui revient ne pose pas de problème
		AnalyticsService:LogFunnelStepEvent(player, FUNNEL_NAME, nil, step, "Stage " .. step)
	end
	log()
	stage.Changed:Connect(log)
end

Players.PlayerAdded:Connect(watch)
for _, player in Players:GetPlayers() do
	task.spawn(watch, player)
end

Ce que dit la documentation sur ces événements, et ce que ça veut dire ici :

  • Les événements ne partent que du serveur et seulement dans les jeux publiés, jamais depuis le client ni Studio. Teste le script dans Studio pour les erreurs, puis lis les données après la publication.
  • Un funnel prend les étapes 1 à 100, et un jeu peut avoir jusqu'à 10 funnels. Un long obby peut utiliser un funnel par monde, comme World1 pour les niveaux 1 à 100 et World2 pour les 100 suivants, avec le numéro d'étape compté depuis le début de ce monde.
  • Une étape répétée est ignorée, donc un joueur qui revient au niveau 12 ne compte pas deux fois. Si des étapes sont sautées, les étapes intermédiaires comptent comme terminées. Un joueur qui achète trois skips a donc l'air d'avoir passé ces niveaux, ce qu'il vaut mieux garder en tête en lisant le graphique.

Une monétisation adaptée à un obby

Les joueurs d'obby paient pour gagner du temps, pour avoir du style et pour jouer avec des amis. Ils n'aiment pas payer pour gagner quelque chose qu'ils voulaient mériter, donc l'astuce est de vendre des raccourcis sans rendre le parcours inutile pour ceux qui ne paient pas.

Ce qui se vend dans les obbys, et le piège de chaque option
ObjetFonction RobloxAccepté ?Attention à
Skip stageDeveloper product (peut être racheté)Oui, c'est le standard du genreDonne-le dans ProcessReceipt une fois le nouveau niveau sauvegardé. Le guide des checkpoints le couvre.
Traînées, couleurs, aurasPass ou developer productOuiRien : les cosmétiques ne changent pas le défi.
Boost de vitesse ou de sautPassPartagéUn plus grand saut contourne ton design de niveaux et rend injustes les leaderboards de niveaux et de temps. Garde les parties boostées hors des classements de temps, ou ne le vends que dans un obby détente.
Vol, noclip, objets de gravitéPassRisquéIls retirent le défi, qui est le jeu, pour l'acheteur.
Serveur privéServeurs privés (frais mensuels en Robux)OuiPopulaire pour jouer avec des amis. Les abonnés Roblox Plus ont les serveurs privés payants sans frais, et tu gagnes quand même de l'argent sur leur temps de jeu.
Regarder une pub pour un skipRewarded video adsSeulement si éligibleLa récompense doit être un developer product et ne peut pas être aléatoire. Roblox fixe des règles d'éligibilité pour le créateur et pour le jeu.

N'interromps pas un saut avec une demande d'achat : mets un petit bouton Skip là où le joueur le voit et peut le choisir quand il est prêt. Pour vérifier qu'un joueur possède un pass sur le serveur, vois le guide des game passes (en anglais).

Ce qui fait revenir les joueurs d'obby

  • La progression sauvegardée. Rien ne fait revenir un joueur comme voir « Stage 47 » dans la liste des joueurs. Sans sauvegarde, un long obby se joue en une seule session.
  • Des mondes et des mises à jour. Les joueurs qui finissent ton parcours n'ont plus rien à faire. Sors de nouveaux niveaux à un rythme régulier, et dis dans la description du jeu quand arrive le prochain monde.
  • Des badges aux étapes importantes. Un badge à la fin de chaque monde donne un objectif et s'affiche sur le profil du joueur. Tu peux créer jusqu'à 5 badges gratuitement par période de 24 heures pour chaque jeu.
  • Des leaderboards. Le niveau le plus haut, le temps le plus rapide sur un monde, le nombre total de parcours terminés. Un leaderboard des temps transforme un obby fini en speedrun.
  • Des récompenses quotidiennes. Une série qui paie en couleurs de traînées ou en skips. Vois le guide des récompenses quotidiennes.
  • Les amis. Un serveur privé réservé aux amis et des niveaux faits pour deux joueurs (l'un tient un bouton pendant que l'autre traverse) donnent aux groupes une raison de revenir ensemble.
Capture d'un test dans Roblox Studio : un écran de récompenses quotidiennes au thème blocky, avec une rangée de jours à réclamer.
Capture Studio. L'écran de récompenses quotidiennes des kits d'interface de RoCode (thème blocky), dans un test Studio. C'est un écran de kit que RoCode peut ajouter, pas une partie d'un obby construit dans ce guide.

Le construire avec RoCode

RoCode est un agent IA indépendant pour Roblox Studio, qui n'est pas fait par Roblox. Tu décris ce que tu veux dans un chat web, et son plugin pour Studio écrit le Luau et crée les parts, les scripts et l'interface dans le jeu que tu as ouvert. Pour un obby, il peut construire le système de checkpoints, les scripts d'obstacles et les niveaux quelques-uns à la fois, et ajouter des écrans prêts à l'emploi comme un HUD de niveau ou une boutique. Il ne peut pas te dire si un niveau est amusant ou trop dur : ça demande toujours de vrais joueurs.

Tu écris

Fais la première version jouable d'un obby dans mon jeu : 10 niveaux courts qui deviennent plus durs par vagues, un dossier Checkpoints avec des parts nommées 1 à 10, un script de checkpoints qui sauvegarde le niveau le plus haut dans leaderstats, un sol mortel rouge sous le parcours, et des obstacles qui disparaissent et qui tournent, gérés par les tags Fade et Spin depuis un seul script serveur.

RoCode fait
  • Écrit les scripts de checkpoints, de parts mortelles et d'obstacles, et construit des niveaux en greybox dans ton jeu
  • Construit un obby plus grand par étapes : quelques niveaux qui marchent à la fois, pour que tu puisses jouer chaque lot
  • Peut ajouter des écrans de ses kits d'interface comme un HUD, une boutique, des récompenses quotidiennes ou un leaderboard
  • Peut lancer un robot de test qui marche et saute à travers les niveaux et rapporte PASS ou FAIL, et prend des captures en mode édition pour vérifier l'apparence d'un niveau

Le construire dans Studio

RoCode ne publie pas ton jeu, ne crée pas le produit skip stage dans le Creator Hub et ne dépense pas de Robux. Le plan gratuit donne des crédits gratuits chaque jour, sans carte. Comment RoCode construit un jeu.

Questions fréquentes

Comment faire un obby sur Roblox sans scripter ?

Tu peux construire les niveaux uniquement avec des parts, mais des checkpoints qui sauvegardent, des parts mortelles et des obstacles qui bougent demandent des scripts. Tu peux coller les scripts du guide des checkpoints (en anglais) et de cette page sans en écrire toi-même, ou décrire l'obby à RoCode et le laisser les ajouter.

Combien de niveaux doit avoir mon obby au lancement ?

Assez pour une première session satisfaisante avec une fin claire, ce qui pour beaucoup d'obbys veut dire un monde complet. Plus important que le nombre : les dix premiers niveaux doivent être soignés et testés, parce que c'est là que la plupart des joueurs décident de rester.

Pourquoi les joueurs abandonnent mon obby à un niveau précis ?

En général, un pic de difficulté, un long niveau sans checkpoint, ou un saut dont l'atterrissage se voit mal. Enregistre les événements de funnel des niveaux comme montré plus haut, trouve le niveau avec la plus grosse chute, puis raccourcis-le, ajoute un checkpoint ou déplace-le plus loin dans le parcours.

Un pass de vitesse ou de saut, c'est du pay to win dans un obby ?

Il permet aux acheteurs de contourner ton design de niveaux et de battre les autres dans les leaderboards de niveaux ou de temps. Beaucoup d'obbys détente en vendent quand même un. Si ton jeu a des leaderboards compétitifs, garde les joueurs boostés en dehors, ou vends plutôt des cosmétiques.

Combien de temps faut-il pour faire un obby ?

Une greybox de 10 niveaux avec des checkpoints peut se faire en un week-end. Tester, thématiser et équilibrer un monde complet, plus la monétisation, prend beaucoup plus longtemps, et la plus grande partie de ce temps, ce sont des tests.

Sources et lectures

Comment le code a été vérifié : chaque script de cette page passe le vérificateur de types strict de Luau avec les définitions de l'API Roblox (luau-lsp, 12 novembre 2026). Une vérification de types repère les API mal écrites et les mauvais types, pas la logique du jeu : teste dans Studio avant de publier.

Essaie RoCode sur ton propre jeu.

Des crédits gratuits chaque jour, sans carte. Installe le plugin, décris la fonctionnalité et vérifie ce qui arrive dans Studio.