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
Come funziona leaderstats
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.
| Oggetto | Contiene | Adatto per |
|---|---|---|
IntValue | Numeri interi | Monete, uccisioni, vittorie, livello |
NumberValue | Numeri decimali | Miglior tempo sul giro, distanza |
StringValue | Testo | Grado 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
- Nell'Explorer passa il mouse su ServerScriptService, clicca sul pulsante + e inserisci uno Script.
- Rinominalo
Leaderstats, così lo ritrovi facilmente. - 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.
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.
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.
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.
- Aggiungi in Workspace una Part ancorata, chiamala
WinsBoarde dalle le dimensioni di un cartello (per esempio 12 per 8 per 1 stud), con la faccia anteriore verso lo spawn. - Inserisci in ServerScriptService uno Script chiamato
GlobalWinsBoardcon il codice qui sotto. - Premi Play. Il tabellone si riempie dopo il primo aggiornamento e si aggiorna ogni minuto.
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.
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.
- 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
- Roblox Creator Docs: Leaderboards (in inglese). leaderstats, ordine delle statistiche e modalità persistenti Friends e Global
- Roblox Creator Docs: Data stores (in inglese). GetAsync, SetAsync, ordered data store e limiti
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.