Comment faire un jeu sur Roblox Studio, étape par étape

Ce que tu vas construire

Le jeu est un court parcours. Les joueurs partent de la SpawnLocation, sautent entre des plateformes au-dessus d'un sol de lave, ramassent des pièces et touchent un pad vert d'arrivée. Le Finish ne donne une victoire qu'à un joueur qui a ramassé au moins 3 pièces depuis sa dernière apparition ou sa dernière arrivée, puis le renvoie au départ. Coins et Wins s'affichent dans la liste des joueurs, et chaque règle tourne sur le serveur.

Workspace
  Baseplate Part
  SpawnLocation SpawnLocation
  Course Folder new
    Platform Part new
    Lava Folder new
      Lava Part new
    Coins Folder new
      Coin Part new
    Finish Part new
ServerScriptService
  PlayerStats Script new
  CourseService Script new

Tu construis tout dans Workspace à la main à l'étape 2. Les deux scripts vont dans ServerScriptService. Roblox n'envoie jamais aux joueurs les scripts de ce conteneur, donc personne ne peut les lire ni les modifier depuis son propre appareil.

Étape 1 : installer Studio et ouvrir une Baseplate

1. Télécharge Roblox Studio depuis le Creator Hub de Roblox et lance l'installateur (RobloxStudio.exe sur Windows, RobloxStudio.dmg sur Mac). Studio est une application gratuite pour Windows et Mac.
2. Quand il s'ouvre, connecte-toi avec ton compte Roblox. Si tu n'en as pas, crée-en un d'abord sur roblox.com.
3. Dans la section Open a Template, choisis Baseplate. Il commence avec seulement deux objets : une SpawnLocation, où les personnages apparaissent et réapparaissent, et la Baseplate, un sol avec une texture en grille de 4 sur 4 alignée sur les studs, l'unité de longueur de Roblox.
4. Ouvre trois fenêtres que tu vas utiliser tout le temps. Explorer liste chaque objet de ton jeu, et Properties modifie l'objet sélectionné ; les deux s'ouvrent depuis le menu Window ou l'onglet Home. Output montre les erreurs de tes scripts, et s'ouvre depuis le menu Window ou l'onglet Script.

Étape 2 : construire le parcours

1. Dans l'Explorer, survole Workspace, clique sur le bouton + (ou appuie sur Ctrl+I, Cmd+I sur Mac) et insère un Folder. Renomme-le Course.
2. Survole Course, clique sur +, et insère deux autres Folders dedans. Nomme-les Lava et Coins.
3. Construis le sol de lave. Clique sur Part dans l'onglet Home ou Model pour insérer un bloc, puis utilise l'outil Scale pour l'étirer en une grande dalle plate qui passera sous tout le parcours, avec beaucoup de marge de chaque côté. Dans Properties, règle sa Color sur rouge et son Material sur Neon, coche Anchored, et glisse-la dans le dossier Lava. Maintenant, un joueur qui tombe n'importe où atterrit dans la lave, pas sur la Baseplate.
4. Construis les plateformes. Insère d'autres parts de la même façon et utilise les outils Move et Scale pour les placer au-dessus de la lave, chacune à quelques studs au-dessus, avec des écarts à sauter entre elles. Dans Properties, vérifie que Anchored est coché sur chacune, et glisse-les dans Course.
5. Construis les pièces. Maintiens la petite flèche du bouton Part et choisis Cylinder. Fais-le petit et jaune, coche Anchored, et décoche CanCollide pour que les joueurs passent à travers au lieu de buter dedans. Mets-le dans le dossier Coins, puis appuie sur Ctrl+D (Cmd+D sur Mac) pour le dupliquer jusqu'à en avoir au moins 3, et répartis-les au-dessus des plateformes le long du parcours.
6. Construis l'arrivée. Insère une dernière part au-dessus de la lave, tout au bout, assez grande pour atterrir dessus, colore-la en vert, coche Anchored, nomme-la exactement Finish, et glisse-la directement dans Course, pas dans l'un des dossiers.
7. Déplace la SpawnLocation sur la lave au début du parcours, à côté de ta première plateforme, pour qu'elle soit posée sur la dalle. Garde-la directement dans Workspace, pas dans Course : CourseService la cherche là pour renvoyer les joueurs au départ.

Les noms comptent

CourseService trouve le parcours par son nom : un dossier appelé Course directement dans Workspace, les dossiers Lava et Coins dedans, et une part appelée Finish dedans. Écris-les exactement, avec les mêmes majuscules. Les noms des parts de lave et des pièces n'ont pas d'importance : chaque part directement dans Lava est de la lave, et chaque part directement dans Coins est une pièce.

Étape 3 : ajouter Coins et Wins à la liste des joueurs

Dans l'Explorer, survole ServerScriptService, clique sur +, insère un Script et nomme-le PlayerStats. Remplace tout son contenu par ceci :

-- Script dans ServerScriptService, nommé PlayerStats.
-- Donne à chaque joueur une statistique Coins et Wins. Un dossier nommé leaderstats dans le
-- joueur fait afficher ces valeurs par Roblox dans la liste des joueurs, en haut à droite.

local Players = game:GetService("Players")

local function onPlayerAdded(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- doit s'écrire exactement comme ça

	local coins = Instance.new("IntValue")
	coins.Name = "Coins"
	coins.Value = 0
	coins.Parent = leaderstats

	local wins = Instance.new("IntValue")
	wins.Name = "Wins"
	wins.Value = 0
	wins.Parent = leaderstats

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do -- ceux qui sont arrivés avant que cette ligne s'exécute
	onPlayerAdded(player)
end

Chaque joueur reçoit un Folder nommé leaderstats avec deux objets IntValue dedans. Une IntValue contient un nombre entier, et c'est tout ce dont un compteur de pièces a besoin. La boucle à la fin prépare tout joueur arrivé avant que la ligne PlayerAdded s'exécute, pour que personne ne soit oublié.

Le guide du classement (en anglais) construit le même dossier plus en détail, puis ajoute la sauvegarde et un top 10 global.

Étape 4 : faire marcher la lave, les pièces et l'arrivée

Insère un deuxième Script dans ServerScriptService, nomme-le CourseService et colle ceci dedans. C'est le seul endroit où Coins et Wins changent. Les deux réglages en haut sont les nombres que tu es censé modifier.

-- Script dans ServerScriptService, nommé CourseService.
-- Gère le parcours sur le serveur, pour que tous les joueurs voient la même chose et que personne
-- ne puisse se donner des pièces : les parts de lave font réapparaître les joueurs, les pièces
-- donnent 1 Coin et reviennent, et le pad Finish donne une victoire à qui a assez de pièces sur ce parcours.

local Players = game:GetService("Players")

local COINS_TO_FINISH = 3 -- pièces à ramasser sur un parcours avant que le Finish compte
local COIN_RESPAWN_SECONDS = 10

local course = workspace:WaitForChild("Course")
local lavaFolder = course:WaitForChild("Lava")
local coinFolder = course:WaitForChild("Coins")
local finish = course:WaitForChild("Finish") :: BasePart
local spawnLocation = workspace:FindFirstChildOfClass("SpawnLocation")
if not spawnLocation then
	warn("CourseService: no SpawnLocation directly in Workspace, so the Finish cannot send players back")
end

-- Pièces ramassées sur ce parcours : depuis la dernière apparition du joueur ou sa dernière arrivée
local runCoins: { [Player]: number } = {}

-- Trouve le joueur dont le personnage a touché une part, ou nil pour tout le reste
local function playerFromHit(otherPart: BasePart): Player?
	local character = otherPart:FindFirstAncestorOfClass("Model")
	return if character then Players:GetPlayerFromCharacter(character) else nil
end

local function addStat(player: Player, statName: string, amount: number)
	local leaderstats = player:FindFirstChild("leaderstats")
	local stat = leaderstats and leaderstats:FindFirstChild(statName)
	if stat and stat:IsA("IntValue") then
		stat.Value += amount
	end
end

-- Lave : toute part du dossier Lava fait réapparaître le joueur qui la touche
for _, lava in lavaFolder:GetChildren() do
	if lava:IsA("BasePart") then
		lava.Touched:Connect(function(otherPart: BasePart)
			local character = otherPart:FindFirstAncestorOfClass("Model")
			local humanoid = character and character:FindFirstChildOfClass("Humanoid")
			if humanoid and humanoid.Health > 0 then
				humanoid.Health = 0
			end
		end)
	end
end

-- Pièces : le premier joueur qui touche une pièce la prend, puis elle se cache jusqu'à sa réapparition
for _, coin in coinFolder:GetChildren() do
	if coin:IsA("BasePart") then
		local shownTransparency = coin.Transparency
		local taken = false
		coin.Touched:Connect(function(otherPart: BasePart)
			local player = playerFromHit(otherPart)
			if not player or taken then
				return -- pas un joueur, ou cette pièce a déjà été prise
			end
			taken = true
			coin.Transparency = 1
			addStat(player, "Coins", 1)
			runCoins[player] = (runCoins[player] or 0) + 1
			task.delay(COIN_RESPAWN_SECONDS, function()
				coin.Transparency = shownTransparency
				taken = false
			end)
		end)
	end
end

-- Finish : une victoire pour les joueurs qui ont fait le parcours, puis retour au départ
finish.Touched:Connect(function(otherPart: BasePart)
	local player = playerFromHit(otherPart)
	if not player or (runCoins[player] or 0) < COINS_TO_FINISH then
		return
	end
	runCoins[player] = 0 -- d'abord, pour que retoucher le pad ne compte pas deux fois
	addStat(player, "Wins", 1)
	local character = player.Character
	if character and spawnLocation then
		character:PivotTo(spawnLocation.CFrame + Vector3.new(0, 4, 0))
		player:SetAttribute("MovementCheckSkip", true) -- pour un script de vérification de vitesse, si tu en ajoutes un
	end
end)

-- Un nouveau personnage (après une réapparition ou une chute) commence un nouveau parcours
local function onPlayerAdded(player: Player)
	runCoins[player] = 0
	player.CharacterAdded:Connect(function()
		runCoins[player] = 0
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do -- ceux qui sont arrivés pendant que ce script attendait Course
	onPlayerAdded(player)
end

Players.PlayerRemoving:Connect(function(player: Player)
	runCoins[player] = nil
end)

La lave met Health à 0, comme le tutoriel de lave de Roblox. Un nouveau personnage a par défaut un ForceField pendant 10 secondes après être apparu sur une SpawnLocation, et Humanoid:TakeDamage ne fait rien tant qu'il en est protégé. Régler Health directement ignore les ForceFields, donc la lave marche même juste après une réapparition.

Le Finish déplace le personnage avec character:PivotTo(...), que la référence de Roblox présente comme la façon principale de déplacer un modèle depuis un script. Régler plutôt la position de la root part du personnage éloigne cette seule part du reste du corps.

La ligne MovementCheckSkip ne fait rien toute seule. Elle est là pour la vérification de vitesse côté serveur du guide du sprint (en anglais) : si tu ajoutes cette vérification plus tard, la téléportation du Finish n'est pas signalée comme un excès de vitesse.

Pourquoi les règles tournent sur le serveur

Chaque règle de ce parcours est dans CourseService, un Script serveur, exprès. Si un LocalScript ajoutait la pièce, la nouvelle valeur de Coins n'existerait que sur l'appareil de ce joueur : le serveur et les autres joueurs ne la verraient jamais. Et tout ce qui est sur l'appareil d'un joueur peut être modifié. Le guide de sécurité de Roblox dit qu'un tricheur a un contrôle total sur son état local et son trafic réseau, donc c'est le serveur qui doit prendre chaque décision qui compte.

La règle des pièces arrête donc la triche la plus simple, un saut direct à la fin, et pas beaucoup plus. C'est normal pour un premier jeu. Les étapes suivantes sont une vérification côté serveur qu'un personnage est vraiment près d'une pièce ou du Finish avant de payer, comme le guide de sécurité de Roblox vérifie la distance d'un joueur à une boutique ; des points de passage à atteindre dans l'ordre, comme dans le guide des points de passage d'obby ; et une vérification des déplacements comme celle du guide du sprint. Ce qui est répliqué et ce qui ne l'est pas explique plus en détail la séparation entre client et serveur (guides en anglais).

Étape 5 : tester

1. Vérifie que Test est sélectionné dans le menu du mode de test, puis appuie sur Play (F5). Ton nom apparaît dans la liste des joueurs avec Coins 0 et Wins 0.
2. Marche dans une pièce. Coins passe à 1 et la pièce disparaît. Attends 10 secondes et elle revient. Marche dedans de nouveau : Coins monte à 2.
3. Touche la lave. Ton personnage tombe K.-O. et réapparaît sur la SpawnLocation après 5 secondes, le temps de réapparition par défaut de Roblox. Coins dans la liste des joueurs ne change pas, mais ton compteur pour ce parcours repart de 0.
4. Touche le Finish avec moins de 3 pièces sur ce parcours : rien ne se passe. Ramasse 3 pièces, puis touche-le : Wins passe à 1 et tu retombes sur la SpawnLocation.
5. Appuie sur Stop (Maj+F5). Choisis Server & Clients dans le menu, règle 2 clients et appuie sur Play (ou F7). Prends une pièce dans une fenêtre client et regarde l'autre : la pièce a disparu là aussi, parce que le serveur l'a cachée pour tout le monde.

Garde la fenêtre Output ouverte tout le temps. Ces deux scripts n'affichent rien quand ils marchent, donc tout avertissement ou toute erreur rouge de PlayerStats ou CourseService est un vrai problème. Vois les erreurs courantes.

Étape 6 : publier ton jeu

1. Ouvre le menu File et choisis Publish. La fenêtre Game details s'ouvre.
2. Tape un Name, choisis un Genre (le Subgenre est facultatif) et écris une courte Description de ce que font les joueurs. Tu peux aussi envoyer une icône et une miniature ici. Vérifie d'abord leurs tailles avec le vérificateur gratuit de taille de miniature et d'icône (en anglais).
3. Clique sur Save. Roblox publie le jeu dans le cloud et le relie à ton compte, pour que tu puisses l'ouvrir depuis n'importe quel ordinateur.
4. Le jeu est maintenant publié mais privé. Seuls toi, les personnes avec un accès Edit et les membres de groupe avec les bons rôles peuvent y jouer.
5. Tu veux des avis avant de l'ouvrir au public ? Choisis File > Invite early testers et choisis jusqu'à 10 amis d'âge proche. Si tu n'as pas encore fait de vérification de l'âge, Roblox te demande d'en faire une d'abord. Les testeurs voient un filigrane qui leur dit que le jeu est un aperçu.

À partir de maintenant, sauvegarder sur Roblox depuis le menu File garde une version de ton jeu dans le cloud. C'est File > Publish qui change la version que reçoivent les joueurs. De temps en temps, joue à la copie publiée depuis Roblox, en dehors de Studio, pour vérifier qu'elle correspond à ce que tu as testé.

Étape 7 : l'ouvrir au public (rendre ton jeu public)

L'ouverture au public (release) est la façon de rendre ton jeu public, pour que d'autres personnes que toi et tes collaborateurs puissent y jouer. Avant de commencer, vérifie les conditions : ton compte doit être en règle et avoir au moins 2 jours, et il te faut une vérification de l'âge, par estimation faciale de l'âge ou par pièce d'identité.

1. Ouvre le menu File et choisis de nouveau Publish. La fenêtre Publish s'ouvre.
2. Clique sur Continue. (Le bouton Invite à côté invite plutôt des testeurs.)
3. Réponds à la première question du questionnaire Maturity & Compliance de Roblox : ton jeu contient-il du contenu soumis à restriction d'âge ? Réponds selon ce que ton jeu contient vraiment. Si tu réponds Yes, tu remplis tout le questionnaire.
4. Clique sur Publish.

Pour ne laisser entrer que tes amis, ouvre le Creator Dashboard, sélectionne le jeu, va dans Publish settings > Manage Audience, clique sur Manage access, active Friends dans l'onglet Public et clique sur Save Changes. Avec Friends activé, seuls tes amis et les personnes de l'onglet Playtest peuvent jouer.

Les mêmes conditions s'appliquent à chaque action d'ouverture au public : la première ouverture, l'ouverture d'une nouvelle version d'un jeu déjà public, l'ouverture vers un autre jeu avec Publish As, et le changement de qui peut jouer.

Le faire avec des amis

Les outils de collaboration de Studio te permettent, à toi et à un ami, de modifier le même jeu en même temps. Pour un jeu qui t'appartient :

1. Avec le jeu ouvert dans Studio, clique sur Collaborate à droite de la barre mezzanine, la barre dont le côté gauche contient le bouton Play.
2. Cherche ton ami, sélectionne-le, choisis Edit dans le menu des autorisations et clique sur Save. Pour un jeu qui t'appartient, seuls tes amis Roblox peuvent avoir l'accès Edit.
3. Ton ami ouvre le jeu depuis le Creator Dashboard, et vous travaillez tous les deux dans le même jeu en même temps.

Pour collaborer avec d'autres créateurs, tu fais d'abord une vérification de l'âge, par pièce d'identité ou estimation faciale de l'âge. Ensuite, par défaut, Studio ne te laisse collaborer qu'avec des créateurs de tranches d'âge compatibles. Tu peux utiliser Team Create seul sans vérification de l'âge. Pendant une session de collaboration, Studio sauvegarde le jeu dans le cloud toutes les quatre minutes.

En faire un vrai jeu

Le parcours est une boucle complète : jouer, ramasser, arriver, gagner. Chacun de ces guides (en anglais, sauf le premier) ajoute un système par-dessus.

• Tu débutes avec les scripts ? Scripter sur Roblox quand on débute couvre les variables, les fonctions, les événements et les boucles, les pièces dont CourseService est fait.
• Sauvegarde Coins et Wins entre les sessions avec l'étape 3 du guide du classement. Son script de sauvegarde remplace un script Coins et Wins comme PlayerStats, donc supprime PlayerStats quand tu l'ajoutes. Le tutoriel DataStore explique la sauvegarde en profondeur.
• Des points de passage dans l'ordre, avec une statistique Stage et la réapparition au dernier point de passage : le guide des points de passage d'obby. Son script crée son propre dossier leaderstats, donc copie les lignes Coins et Wins de PlayerStats dans ce dossier et supprime PlayerStats. Deux scripts qui créent chacun leaderstats donnent deux dossiers à chaque joueur, et Coins et Wins peuvent arrêter de changer.
• Dépenser les Coins dans une boutique. Elle utilise la valeur Coins des leaderstats, donc saute son script Leaderstats : PlayerStats crée déjà Coins.
• Vendre un avantage contre des Robux avec un game pass. Avant de fixer un prix, le calculateur de taxe Robux gratuit montre ce que chaque vente te rapporte après la part de Roblox, et le calculateur DevEx ce que valent ces Robux en dollars US.
• Un écran titre avec un bouton Play : le guide du menu principal.
• Des manches avec une intermission, des maps aléatoires et un minuteur : le guide du système de manches, qui ajoute à la même valeur Wins. Saute son script leaderstats, parce que PlayerStats crée déjà Wins.
• Une cinématique d'intro avec des plans de caméra, des sous-titres et un bouton Skip : le guide des cinématiques.
• Une porte vers une zone secrète qui s'ouvre avec E, avec une serrure à clé facultative : le guide des portes.
• Des pads de téléportation entre des parties de la map, ou un menu de téléportation : le guide du téléporteur.
• Sprinter avec Maj au clavier, sur téléphone et à la manette, avec la vérification des déplacements côté serveur : le guide du sprint. Sa vérification des déplacements lit l'attribut MovementCheckSkip que règle le Finish.
• Un combat ou une autre boucle : donne aux joueurs une épée ou un pistolet à raycast, ou commence un nouveau jeu où les joueurs cliquent pour gagner des pièces, achètent des améliorations et font des rebirths, avec le guide du jeu de simulateur.

Erreurs courantes

Ouvre la fenêtre Output (menu Window ou onglet Script) avant d'appuyer sur Play. La plupart des problèmes sur ce parcours affichent un avertissement ou une erreur là, ou viennent d'un nom qui ne correspond pas.

Le construire avec RoCode

Si tu préfères décrire le jeu plutôt que construire chaque élément à la main, RoCode peut le construire dans le jeu que tu as ouvert. RoCode est un agent IA indépendant pour Roblox Studio, qui n'est pas fait par Roblox : tu décris la fonctionnalité dans son chat web, et son plugin pour Studio crée les parts et les scripts dans ton Explorer, donc tu ne copies pas de code depuis une fenêtre de chat.

Le construire dans Studio ↗

Avec le plugin 3.9 ou plus récent, RoCode peut lancer un court test et lire les erreurs, et avec le plugin 3.9.11 ou plus récent contrôler un personnage de test pour vérifier que le jeu marche, mais il ne vérifie que ce qu'il a choisi de tester, donc joue toi-même. Construire un jeu entier avec RoCode marche comme ça, un système par prompt. Comment RoCode se connecte à Studio.

Questions fréquentes

Sources et lectures

• Roblox Creator Docs : Roblox Studio setup (en anglais). Studio est une application gratuite pour Windows et Mac ; installation et connexion
• Roblox Creator Docs : Create and publish games and places (en anglais). les modèles, File > Publish, privé par défaut, les testeurs, l'ouverture au public, ses conditions, la limite quotidienne et Manage Audience
• Roblox Creator Docs : Templates (en anglais). ce que contient le modèle Baseplate
• Roblox Creator Docs : Explorer window (en anglais). insérer des objets, des dossiers et dupliquer
• Roblox Creator Docs : Parts (en anglais). insérer des parts, des cylindres, déplacer, redimensionner et colorer
• Roblox Creator Docs : Deadly lava tutorial (en anglais). une part de lave qui met Health à 0 au contact
• Roblox Creator Docs : Create a coin collection mechanic (en anglais). des pièces avec CanCollide désactivé et Anchored activé
• Roblox Creator Docs : Score points tutorial (en anglais). le dossier leaderstats et son nom exact
• Roblox Creator Docs : BasePart.CanTouch (en anglais). connecter Touched à une part avec CanTouch désactivé lève une erreur
• Roblox Creator Docs : Studio testing modes (en anglais). Test, Play (F5), Stop et Server & Clients
• Roblox Creator Docs : Humanoid:TakeDamage (en anglais). la protection du ForceField, et régler Health directement
• Roblox Creator Docs : PVInstance:PivotTo (en anglais). la façon de déplacer un modèle depuis un script
• Roblox Creator Docs : Version History (en anglais). les versions sauvegardées et les versions publiées que reçoivent les joueurs
• Roblox Creator Docs : Security tactics and cheat mitigation (en anglais). ne jamais faire confiance au client ; des événements Touched à n'importe quelle distance
• Roblox Creator Docs : Network ownership, movement validation, and physics (en anglais). un client peut téléporter et faire voler son propre personnage
• Roblox Creator Docs : Defensive design (en anglais). le cas de l'obby où l'on se téléporte à la fin
• Roblox Creator Docs : Collaboration (en anglais). le bouton Collaborate, l'accès Edit, la vérification de l'âge et la sauvegarde automatique

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, 26 octobre 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.