Tutorial · Dati del giocatore

Come fare una classifica (leaderboard) in Roblox Studio

L'elenco dei giocatori in alto a destra in un gioco Roblox è controllato da una sola cartella chiamata leaderstats. Questa guida lo costruisce da zero: uno script server, un modo sicuro per assegnare punti, il salvataggio tra una sessione e l'altra e una top 10 globale.

Aggiornato il 20 novembre 20268 min di letturaScritto da

In breve

Crea uno Script in ServerScriptService che ascolta Players.PlayerAdded, crea un Folder chiamato esattamente leaderstats (tutto minuscolo) e lo rende figlio del giocatore. Ogni IntValue, NumberValue o StringValue dentro questa cartella diventa una colonna nell'elenco dei giocatori.

  • Crea e modifica le statistiche solo sul server. Una modifica fatta da un LocalScript la vede solo quel giocatore, e nessun altro.
  • leaderstats non si salva. Carica e salva i valori con un data store se devono arrivare alla sessione successiva.
  • Per una classifica di tutti i giocatori, scrivi ogni punteggio in un ordered data store e mostralo su un tabellone nel tuo mondo o nella modalità Global dell'elenco dei giocatori.
In questa pagina
  1. Come funziona leaderstats
  2. 1. Creare leaderstats
  3. 2. Assegnare punti
  4. 3. Salvataggio
  5. 4. Top 10 globale
  6. Common errors
  7. Con RoCode
  8. Domande frequenti
  9. Fonti e letture

Come funziona leaderstats

IllustrazioneGli script finiti di leaderstats e della piattaforma di monete in un gioco avviato.

Roblox mostra l'elenco dei giocatori in ogni gioco. Quando un giocatore ha un Folder figlio chiamato leaderstats, l'elenco aggiunge una colonna per ogni oggetto valore al suo interno e mostra il valore di quel giocatore nella sua riga. L'intestazione della colonna è il Name dell'oggetto valore.

Oggetti valore che puoi mettere in leaderstats
OggettoContieneAdatto per
IntValueNumeri interiMonete, uccisioni, vittorie, livello
NumberValueNumeri decimaliMiglior tempo sul giro, distanza
StringValueTestoGrado o titolo della squadra

Due regole rompono quasi ogni classifica che non funziona. Il nome della cartella deve essere esattamente leaderstats: Leaderstats o leaderStats vengono ignorati. E la cartella deve crearla uno Script sul server, perché solo le modifiche sul server vengono replicate a tutti i giocatori. Se non sei sicuro di dove gira il codice, leggi prima Script vs LocalScript vs ModuleScript (in inglese).

Passo 1: crea lo script leaderstats

  1. Nell'Explorer passa il mouse su ServerScriptService, clicca sul pulsante + e inserisci uno Script.
  2. Rinominalo Leaderstats, così lo ritrovi facilmente.
  3. Sostituisci il suo contenuto con il codice qui sotto e premi Play. Il tuo nome compare nell'elenco dei giocatori con Coins e Wins a 0.
Script in ServerScriptService chiamato Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- il nome deve essere esattamente questo, tutto minuscolo

	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 -- il genitore lo impostiamo per ultimo, quando i valori sono già dentro
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- In Studio puoi entrare prima che questo script parta, quindi configuriamo chi è già qui
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Il ciclo finale conta nei test in Studio: il primo giocatore a volte entra prima che PlayerAdded sia collegato e senza il ciclo resterebbe senza statistiche.

Passo 2: assegna punti in modo sicuro

Per cambiare una statistica, imposta il suo Value da uno script server. Questa piattaforma di monete dà 10 monete quando un giocatore la tocca. Touched scatta molte volte al secondo mentre il personaggio sta sulla parte, quindi lo script tiene un breve cooldown per ogni giocatore.

Script in parte in Workspace chiamato 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 scatta molte volte per passo; questo evita che un solo tocco paghi dieci volte
	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") trova il personaggio anche quando la parte che tocca è dentro un accessorio, cosa che un semplice controllo di hit.Parent si perde.

Se i punti arrivano per qualcosa che il giocatore fa sul proprio schermo, come premere un pulsante, il LocalScript deve chiederlo al server con un RemoteEvent e il server deve decidere se pagare. Non lasciare mai che il client mandi l'importo. La guida ai RemoteEvent mostra questo schema con il controllo.

Quattro esempi pronti: la guida al primo gioco dà 1 Coin per ogni moneta che il giocatore tocca sul percorso e una Win sulla piattaforma del traguardo dopo 3 monete, la guida al simulatore clicker dà Coins per le pressioni di un pulsante con un limite di clic sul server, la guida alla spada aggiunge 1 a Kills a chi ha dato l'ultimo colpo prima della morte di un giocatore, e la guida alle armi mostra come contare un'uccisione quando un colpo porta la Health del bersaglio a 0.

Passo 3: salva le statistiche tra le sessioni

leaderstats vive solo finché vive il server. Per salvare monete e vittorie, caricale da un data store quando il giocatore entra e salvale quando esce. Questa versione sostituisce lo script del passo 1. Non salva mai un giocatore i cui dati non si sono caricati: è proprio l'errore che cancella i progressi nella maggior parte degli script di salvataggio copiati.

Script in ServerScriptService chiamato Leaderstats
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

-- Chiamata dentro ogni pcall qui sotto, così un place non ancora pubblicato
-- (senza accesso ai data store) riceve comunque la classifica
local function statsStore(): DataStore
	return DataStoreService:GetDataStore("PlayerStats_v1")
end

-- Giocatori le cui statistiche salvate si sono caricate. Chi non è qui non lo salviamo mai,
-- così un caricamento fallito non sovrascrive con degli zeri i progressi veri.
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)

-- Quando il server si spegne, salviamo tutti prima della chiusura
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)

Per un gioco piccolo basta questo. Per nuovi tentativi, UpdateAsync, limiti di richieste e protezione da due server che scrivono lo stesso giocatore, continua con il tutorial sui DataStore.

Passo 4: una top 10 globale

leaderstats confronta solo i giocatori sullo stesso server. Per una classifica globale serve un ordered data store: un data store che conserva un numero per chiave e sa restituire le chiavi ordinate per valore. Scrivici il punteggio di ogni giocatore dal server, poi rileggi le voci più alte.

Puoi mostrarla in due modi. L'elenco dei giocatori di Roblox ha le modalità Friends e Global, che leggono un ordered data store registrato nel Creator Hub (al momento della stesura è una funzione beta, una classifica attiva per gioco). Oppure puoi disegnare tu la classifica su un tabellone nel tuo mondo: funziona in qualsiasi gioco e ti permette di darle l'aspetto che vuoi. Lo script qui sotto fa la seconda cosa, e scrive i punteggi con lo user ID del giocatore come chiave, che è lo stesso formato che si aspetta la classifica del Creator Hub.

  1. Aggiungi in Workspace una Part ancorata, chiamala WinsBoard e dalle le dimensioni di un cartello (per esempio 12 per 8 per 1 stud), con la faccia anteriore verso lo spawn.
  2. Inserisci in ServerScriptService uno Script chiamato GlobalWinsBoard con il codice qui sotto.
  3. Premi Play. Il tabellone si riempie dopo il primo aggiornamento e si aggiorna ogni minuto.
Script in ServerScriptService chiamato 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

-- Il tabellone: una Part ancorata chiamata WinsBoard in Workspace. Lo script aggiunge da solo
-- la SurfaceGui e le righe, quindi devi costruire solo la Part.
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) restituisce per primi i 10 valori più alti. Un ordered data store conserva solo numeri interi, quindi tieni i punteggi come interi. Lo script scrive ogni giocatore una volta al minuto e legge la top 10 una volta al minuto, con ampio margine rispetto ai limiti standard per server (30 + 5 per giocatore al minuto per le scritture su ordered data store e 5 + 2 per giocatore per le letture ordinate, secondo la documentazione al 30 settembre 2026).

Errori comuni e soluzioni

I problemi qui sotto coprono la maggior parte delle lamentele del tipo «la mia classifica non funziona». Controlla prima la finestra Output (aprila dal menu Window in Studio o dalla scheda Script): se lo script si è fermato con un errore, lì trovi il numero di riga.

La classifica non compare proprio

Controlla che la cartella si chiami leaderstats in minuscolo, che il suo genitore sia il Player (non il personaggio) e che il codice sia uno Script in ServerScriptService, non un LocalScript.

Gli altri giocatori non vedono le modifiche alla mia statistica

Il valore è stato cambiato sul client. Sposta la modifica in uno Script sul server e, se la fa partire un pulsante o un tasto, manda un RemoteEvent e lascia che sia il server a cambiare il valore.

attempt to index nil with 'Coins'

Il codice ha provato a leggere player.leaderstats.Coins prima che la cartella esistesse, oppure il nome è scritto diversamente. Sul server usa FindFirstChild e controlla il risultato; in un LocalScript usa player:WaitForChild("leaderstats"). La guida agli errori degli script spiega questo errore nel dettaglio.

Le monete aumentano di 10, 20 o 50 con un solo tocco

Touched scatta più e più volte mentre le parti si sovrappongono. Aggiungi un cooldown per giocatore come nel passo 2, oppure elimina l'oggetto dopo averlo raccolto.

Le statistiche si azzerano a ogni nuovo ingresso

Roblox non salva leaderstats. Aggiungi lo script del passo 3. Per provare il salvataggio in Studio, pubblica il place e attiva Studio Access to API Services in Experience Settings.

Farlo con RoCode

Se non hai voglia di montarlo a mano, RoCode può costruire tutto dentro il place che hai aperto. È un agente IA che lavora tramite un plugin di Roblox Studio, quindi crea script e parti nel tuo Explorer invece di darti codice da incollare.

Tu scrivi

Aggiungi una classifica con Coins e Wins che si salva tra le sessioni e un tabellone top 10 per vittorie su una parte vicino allo spawn.

RoCode fa
  • Può prima cercare nel place codice leaderstats o DataStore già esistente, per completare quello che c'è invece di aggiungere una seconda classifica
  • Crea lo script server in ServerScriptService e la parte del tabellone in Workspace
  • Controlla che gli script scritti compilino dentro Studio prima di finire
  • Invia le modifiche a blocchi, e ogni blocco viene segnato come punto di annullamento nella cronologia di Studio

Il risultato lo controlli comunque tu, e provi tu in gioco statistiche e salvataggio: con il plugin 3.9 o successivo RoCode può avviare un breve playtest e leggere gli errori, e con il plugin 3.9.11 o successivo può guidare un personaggio di prova e controllare valori come Coins e Wins, ma verifica solo ciò che ha scelto di provare. Leaderstats di solito è il primo di molti sistemi di un gioco: costruisci il resto del gioco un sistema per richiesta nello stesso modo. Come RoCode si collega a Studio.

Domande frequenti

Cos'è leaderstats in Roblox?

Un Folder chiamato esattamente leaderstats, tutto minuscolo, dentro il Player. Roblox mostra ogni IntValue, NumberValue o StringValue al suo interno come colonna nell'elenco dei giocatori. Crealo da uno Script sul server, come nel passo 1.

Come si fa una classifica globale in Roblox?

Scrivi il punteggio di ogni giocatore in un ordered data store dal server, poi rileggi le voci più alte e mostrale su un tabellone nel tuo mondo. Nel passo 4 c'è lo script completo per una top 10.

Roblox salva leaderstats in automatico?

No. leaderstats esiste solo finché il giocatore è sul server. Salva i valori con un data store quando il giocatore esce e caricali quando entra, come nel passo 3.

Posso nascondere un valore dalla classifica?

Sì. Vengono mostrati solo i valori dentro la cartella leaderstats. Tieni i dati privati in un'altra cartella del giocatore o in una tabella in uno script server.

Come si nasconde tutto l'elenco dei giocatori?

Da un LocalScript chiama StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.PlayerList, false). Passa true per mostrarlo di nuovo.

Posso usare NumberValue per le monete?

Puoi, ma per una valuta a numeri interi IntValue è più adatto, e un ordered data store accetta solo numeri interi se più avanti vuoi costruirci una classifica.

Fonti e letture

Come è stato controllato il codice: ogni script di questa pagina supera il controllo dei tipi rigoroso di Luau con le definizioni dell'API di Roblox (luau-lsp, 20 novembre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.

Prova RoCode nel tuo gioco.

Crediti gratis ogni giorno, senza carta. Installa il plugin, descrivi la funzione e controlla cosa compare in Studio.