Tutoriel · Données des joueurs

Comment faire un leaderboard (classement) sur Roblox Studio

La liste des joueurs en haut à droite d'un jeu Roblox est pilotée par un seul dossier appelé leaderstats. Ce guide le construit à partir de zéro : le script serveur, une façon sûre de donner des points, la sauvegarde d'une session à l'autre, et un top 10 mondial.

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

En bref

Crée un Script dans ServerScriptService qui écoute Players.PlayerAdded, crée un Folder nommé exactement leaderstats (tout en minuscules) et le met dans le joueur. Chaque IntValue, NumberValue ou StringValue dans ce dossier devient une colonne de la liste des joueurs.

  • Crée et modifie les stats sur le serveur uniquement. Un changement fait par un LocalScript n'est vu que par ce joueur et par personne d'autre.
  • leaderstats n'est pas sauvegardé. Charge et sauvegarde les valeurs avec un data store si elles doivent survivre jusqu'à la session suivante.
  • Pour un classement de tous les joueurs, écris chaque score dans un ordered data store et affiche-le sur un panneau dans ton monde, ou dans la vue Global de la liste des joueurs.
Sur cette page
  1. Fonctionnement de leaderstats
  2. 1. Créer leaderstats
  3. 2. Donner des points
  4. 3. Sauvegarder
  5. 4. Top 10 mondial
  6. Problèmes courants
  7. Avec RoCode
  8. Questions fréquentes
  9. Sources et lectures

Comment marche leaderstats

Illustration animéeLes scripts leaderstats et du pad à pièces terminés, dans un jeu en cours.

Roblox affiche une liste des joueurs dans chaque jeu. Quand un joueur a un Folder enfant nommé leaderstats, la liste ajoute une colonne pour chaque objet valeur qu'il contient et affiche la valeur de ce joueur sur sa ligne. Le titre de la colonne est le Name de l'objet valeur.

Les objets valeur que tu peux mettre dans leaderstats
ObjetContientPratique pour
IntValueDes nombres entiersPièces, éliminations, victoires, niveau
NumberValueDes nombres décimauxMeilleur temps au tour, distance
StringValueDu texteRang ou titre d'équipe

Deux règles expliquent presque tous les leaderboards cassés. Le dossier doit s'appeler exactement leaderstats : Leaderstats ou leaderStats est ignoré. Et le dossier doit être créé par un Script serveur, parce que le serveur est le seul endroit d'où un changement est répliqué à tous les joueurs. Si tu ne sais pas bien où tourne le code, lis d'abord Script vs LocalScript vs ModuleScript (en anglais).

Étape 1 : créer le script leaderstats

  1. Dans l'Explorer, survole ServerScriptService, clique sur le bouton + et insère un Script.
  2. Renomme-le Leaderstats pour le retrouver plus tard.
  3. Remplace son contenu par le code ci-dessous et appuie sur Play. Ton nom apparaît dans la liste des joueurs avec Coins et Wins à 0.
Script dans ServerScriptService nommé Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- doit être exactement ce nom, tout en minuscules

	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 -- en dernier, une fois les valeurs dedans
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- Dans Studio, tu peux arriver avant que ce script tourne, donc on prépare aussi ceux déjà là
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

La boucle de la fin compte pendant les tests dans Studio : le premier joueur arrive parfois avant que PlayerAdded soit connecté, et ce joueur n'aurait aucune stat.

Étape 2 : donner des points aux joueurs, sans risque

Pour changer une stat, règle sa Value depuis un script serveur. Ce pad à pièces donne 10 pièces quand un joueur le touche. Touched se déclenche de nombreuses fois par seconde tant qu'un personnage est debout sur une part, donc le script garde un court temps de recharge par joueur.

Script dans une Part de Workspace nommé CoinPad
local Players = game:GetService("Players")

local part = script.Parent :: BasePart
local REWARD = 10
local COOLDOWN_SECONDS = 1

local lastReward: { [Player]: number } = {}

part.Touched:Connect(function(hit: BasePart)
	local character = hit:FindFirstAncestorOfClass("Model")
	local player = character and Players:GetPlayerFromCharacter(character)
	if not player then
		return
	end

	local now = os.clock()
	local last = lastReward[player]
	if last and now - last < COOLDOWN_SECONDS then
		return -- Touched se déclenche plusieurs fois par pas ; ceci évite qu'un contact paie dix fois
	end
	lastReward[player] = now

	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	if coins and coins:IsA("IntValue") then
		coins.Value += REWARD
	end
end)

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

FindFirstAncestorOfClass("Model") trouve le personnage même quand la part qui touche est dans un accessoire, ce qu'une simple vérification de hit.Parent rate.

Si les points viennent de quelque chose que le joueur fait sur son propre écran, comme cliquer sur un bouton, le LocalScript doit demander au serveur avec un RemoteEvent, et c'est le serveur qui décide de payer ou non. Ne laisse jamais le client envoyer le montant. Le guide des RemoteEvents (en anglais) montre la méthode avec validation.

Quatre exemples concrets : le guide faire un jeu Roblox étape par étape donne 1 Coin pour chaque pièce qu'un joueur touche sur son parcours et une Win sur le pad d'arrivée après 3 pièces, le guide du simulateur de clics donne des Coins pour les clics sur un bouton avec une limite de clics sur le serveur, le guide de l'épée ajoute 1 à la stat Kills de celui qui a porté le dernier coup avant la mort d'un joueur, et le guide du pistolet montre comment compter une élimination quand un tir fait tomber la Health d'une cible à 0 (ces trois guides sont en anglais).

Étape 3 : sauvegarder les stats d'une session à l'autre

leaderstats ne vit que tant que le serveur existe. Pour garder les pièces et les victoires, charge-les depuis un data store quand le joueur arrive et sauvegarde-les quand il part. Cette version remplace le script de l'étape 1. Elle ne sauvegarde jamais un joueur dont les données n'ont pas pu être chargées, l'erreur qui efface la progression dans la plupart des scripts de sauvegarde copiés.

Script dans ServerScriptService nommé Leaderstats
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

-- Appelée dans chaque pcall ci-dessous, pour qu'un jeu pas encore publié
-- (sans accès aux data stores) ait quand même son leaderboard
local function statsStore(): DataStore
	return DataStoreService:GetDataStore("PlayerStats_v1")
end

-- Les joueurs dont les stats sauvegardées ont été chargées. Ceux qui manquent ici ne sont jamais
-- sauvegardés, donc un chargement raté ne peut pas écraser une vraie progression avec des zéros.
local loaded: { [Player]: boolean } = {}

local function keyFor(player: Player): string
	return "player_" .. player.UserId
end

local function onPlayerAdded(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats"

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

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

	local ok, data = pcall(function()
		return statsStore():GetAsync(keyFor(player))
	end)
	if ok then
		if type(data) == "table" then
			coins.Value = tonumber(data.Coins) or 0
			wins.Value = tonumber(data.Wins) or 0
		end
		loaded[player] = true
	else
		warn(`Could not load stats for {player.Name}: {data}`)
	end

	leaderstats.Parent = player
end

local function save(player: Player)
	if not loaded[player] then
		return
	end
	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	local wins = leaderstats and leaderstats:FindFirstChild("Wins")
	if not (coins and coins:IsA("IntValue") and wins and wins:IsA("IntValue")) then
		return
	end
	local ok, err = pcall(function()
		statsStore():SetAsync(keyFor(player), { Coins = coins.Value, Wins = wins.Value })
	end)
	if not ok then
		warn(`Could not save stats for {player.Name}: {err}`)
	end
end

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

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

-- Quand le serveur s'arrête, sauvegarde tout le monde avant qu'il ferme
game:BindToClose(function()
	local pending = 0
	for _, player in Players:GetPlayers() do
		pending += 1
		task.spawn(function()
			save(player)
			pending -= 1
		end)
	end
	while pending > 0 do
		task.wait()
	end
end)

Ça suffit pour un petit jeu. Pour les nouvelles tentatives, UpdateAsync, les limites de requêtes et la protection contre deux serveurs qui écrivent le même joueur, continue avec le tutoriel DataStore.

Étape 4 : un top 10 mondial

leaderstats ne compare que les joueurs d'un même serveur. Un classement mondial a besoin d'un ordered data store : un data store qui garde un nombre par clé et peut renvoyer les clés triées par valeur. Écris-y le score de chaque joueur depuis le serveur, puis relis les meilleures entrées.

Tu as deux façons de l'afficher. La liste des joueurs de Roblox a des vues Friends et Global qui lisent un ordered data store que tu enregistres dans le Creator Hub (une fonction en bêta au moment de l'écriture, un seul leaderboard actif par jeu). Ou tu peux dessiner le classement toi-même sur un panneau dans ton monde, ce qui marche dans tous les jeux et te laisse choisir le style. Le script ci-dessous fait la deuxième option, et les scores qu'il écrit utilisent l'ID d'utilisateur du joueur comme clé, le format qu'attend aussi le leaderboard du Creator Hub.

  1. Ajoute une Part ancrée dans Workspace, nomme-la WinsBoard et donne-lui la taille d'un panneau (par exemple 12 sur 8 sur 1 studs), face avant tournée vers ton point d'apparition.
  2. Insère un Script dans ServerScriptService nommé GlobalWinsBoard avec le code ci-dessous.
  3. Joue. Le panneau se remplit après la première mise à jour, puis se met à jour chaque minute.
Script dans ServerScriptService nommé GlobalWinsBoard
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

local winsBoard = DataStoreService:GetOrderedDataStore("GlobalWins_v1")

local TOP_N = 10
local REFRESH_SECONDS = 60

-- Le panneau : une Part ancrée nommée WinsBoard dans Workspace. Le script ajoute lui-même
-- la SurfaceGui et les lignes, donc la Part est tout ce que tu as à construire.
local boardPart = workspace:WaitForChild("WinsBoard") :: BasePart

local gui = Instance.new("SurfaceGui")
gui.Face = Enum.NormalId.Front
gui.SizingMode = Enum.SurfaceGuiSizingMode.PixelsPerStud
gui.PixelsPerStud = 50
gui.Parent = boardPart

local list = Instance.new("Frame")
list.Size = UDim2.fromScale(1, 1)
list.BackgroundColor3 = Color3.fromRGB(18, 11, 31)
list.Parent = gui

local layout = Instance.new("UIListLayout")
layout.SortOrder = Enum.SortOrder.LayoutOrder
layout.Parent = list

local nameCache: { [number]: string } = {}

local function nameFor(userId: number): string
	local cached = nameCache[userId]
	if cached then
		return cached
	end
	local ok, name = pcall(function()
		return Players:GetNameFromUserIdAsync(userId)
	end)
	local result = if ok then name else "Unknown player"
	nameCache[userId] = result
	return result
end

local function recordWins(player: Player)
	local leaderstats = player:FindFirstChild("leaderstats")
	local wins = leaderstats and leaderstats:FindFirstChild("Wins")
	if wins and wins:IsA("IntValue") then
		local ok, err = pcall(function()
			winsBoard:SetAsync(tostring(player.UserId), wins.Value)
		end)
		if not ok then
			warn(`Could not record wins for {player.Name}: {err}`)
		end
	end
end

local function refresh()
	local ok, pages = pcall(function()
		return winsBoard:GetSortedAsync(false, TOP_N)
	end)
	if not ok then
		warn(`Could not read the wins board: {pages}`)
		return
	end

	for _, child in list:GetChildren() do
		if child:IsA("TextLabel") then
			child:Destroy()
		end
	end

	for rank, entry in pages:GetCurrentPage() do
		local label = Instance.new("TextLabel")
		label.Size = UDim2.new(1, 0, 1 / TOP_N, 0)
		label.BackgroundTransparency = 1
		label.TextColor3 = Color3.new(1, 1, 1)
		label.TextScaled = true
		label.Text = `{rank}. {nameFor(tonumber(entry.key) or 0)}   {entry.value}`
		label.LayoutOrder = rank
		label.Parent = list
	end
end

while true do
	for _, player in Players:GetPlayers() do
		recordWins(player)
	end
	refresh()
	task.wait(REFRESH_SECONDS)
end

GetSortedAsync(false, 10) renvoie d'abord les 10 valeurs les plus hautes. Les ordered data stores ne contiennent que des nombres entiers, donc sauvegarde les scores en entiers. Le script écrit chaque joueur une fois par minute et lit le top 10 une fois par minute, bien en dessous des limites par défaut de chaque serveur (30 + 5 par joueur et par minute pour les écritures ordonnées, et 5 + 2 par joueur pour les lectures triées, selon la documentation du 30 septembre 2026).

Problèmes courants

Les problèmes ci-dessous expliquent la plupart des messages « mon leaderboard ne marche pas ». Regarde d'abord la fenêtre Output (ouvre-la depuis le menu Window de Studio ou l'onglet Script) : si un script a planté, le numéro de ligne s'y trouve.

Le leaderboard ne s'affiche pas du tout

Vérifie que le dossier s'appelle leaderstats en minuscules, qu'il est dans le Player (pas dans le personnage), et que le code est un Script dans ServerScriptService, pas un LocalScript.

Les autres joueurs ne voient pas ma stat changer

La valeur a été changée sur le client. Déplace le changement dans un Script serveur, et si un bouton ou une touche le déclenche, envoie un RemoteEvent et laisse le serveur changer la valeur.

attempt to index nil with 'Coins'

Le code a essayé de lire player.leaderstats.Coins avant que le dossier existe, ou le nom est écrit autrement. Sur le serveur, utilise FindFirstChild et vérifie le résultat ; dans un LocalScript, utilise player:WaitForChild("leaderstats"). Le guide des erreurs de script explique cette erreur en détail.

Les pièces augmentent de 10, 20 ou 50 pour un seul contact

Touched se déclenche plusieurs fois tant que les parts se chevauchent. Ajoute un temps de recharge par joueur comme à l'étape 2, ou retire l'objet une fois ramassé.

Les stats repartent à zéro chaque fois que je reviens

Roblox ne sauvegarde pas leaderstats. Ajoute le script de l'étape 3. Pour tester la sauvegarde dans Studio, publie le jeu et active Studio Access to API Services dans Experience Settings.

Le faire avec RoCode

Si tu préfères ne pas tout câbler à la main, RoCode peut le construire dans le jeu que tu as ouvert. C'est un agent IA qui travaille grâce à un plugin pour Roblox Studio, donc il crée les scripts et les parts dans ton Explorer au lieu de te donner du code à coller.

Tu écris

Ajoute un leaderboard avec Coins et Wins qui se sauvegarde d'une session à l'autre, et un panneau du top 10 des victoires sur une part près du point d'apparition.

RoCode fait
  • Peut d'abord chercher dans ton jeu du code leaderstats ou DataStore existant, pour compléter ce que tu as au lieu d'ajouter un deuxième leaderboard
  • Crée le script serveur dans ServerScriptService et la part du panneau dans Workspace
  • Vérifie dans Studio la compilation des scripts qu'il a écrits avant de terminer
  • Envoie ses changements par lots, et chaque lot est marqué comme point d'annulation dans l'historique de Studio

Tu relis toujours le résultat et tu testes toi-même les stats et la sauvegarde : 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 et vérifier des valeurs comme Coins et Wins, mais il ne vérifie que ce qu'il a choisi de tester. Les leaderstats sont en général le premier de nombreux systèmes dans un jeu : construis le reste de ton jeu un système par demande de la même façon. Comment RoCode se connecte à Studio.

Questions fréquentes

C'est quoi leaderstats sur Roblox ?

Un Folder nommé exactement leaderstats, tout en minuscules, dans un Player. Roblox affiche chaque IntValue, NumberValue ou StringValue qu'il contient comme une colonne de la liste des joueurs. Crée-le depuis un Script serveur, comme à l'étape 1.

Comment faire un leaderboard mondial sur Roblox ?

Écris le score de chaque joueur dans un ordered data store depuis le serveur, puis relis les meilleures entrées et affiche-les sur un panneau dans ton monde. L'étape 4 contient le script complet d'un top 10.

Roblox sauvegarde-t-il leaderstats automatiquement ?

Non. leaderstats n'existe que tant que le joueur est sur le serveur. Sauvegarde les valeurs avec un data store quand le joueur part et charge-les quand il arrive, comme à l'étape 3.

Peut-on cacher une valeur du leaderboard ?

Oui. Seules les valeurs du dossier leaderstats sont affichées. Garde les données privées dans un autre dossier du joueur, ou dans une table d'un script serveur.

Comment cacher toute la liste des joueurs ?

Depuis un LocalScript, appelle StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.PlayerList, false). Passe true pour la réafficher.

Peut-on utiliser une NumberValue pour les pièces ?

Oui, mais une IntValue convient mieux à une monnaie en nombres entiers, et les ordered data stores n'acceptent que des nombres entiers si tu fais un classement dessus plus tard.

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.