Tutorial · Datos del jugador

Cómo hacer un leaderboard en Roblox Studio

La lista de jugadores de la esquina superior derecha de un juego de Roblox depende de una sola carpeta llamada leaderstats. Esta guía la construye desde cero: el script de servidor, una forma segura de dar puntos, guardar entre sesiones y un top 10 global.

Actualizado el 12 de noviembre de 20268 min de lecturaEscrito por

La respuesta corta

Crea un Script en ServerScriptService que escuche Players.PlayerAdded, cree un Folder llamado exactamente leaderstats (todo en minúsculas) y lo haga hijo del jugador. Cada IntValue, NumberValue o StringValue dentro de esa carpeta se convierte en una columna de la lista de jugadores.

  • Crea y cambia las estadísticas solo en el servidor. Un cambio hecho por un LocalScript solo lo ve ese jugador y nadie más.
  • leaderstats no se guarda. Carga y guarda los valores con un data store si deben seguir en la próxima sesión.
  • Para un ranking entre todos los jugadores, escribe cada puntuación en un ordered data store y muéstrala en un tablero dentro de tu mundo, o en la vista Global de la lista de jugadores.
En esta página
  1. Cómo funciona leaderstats
  2. 1. Crear leaderstats
  3. 2. Dar puntos
  4. 3. Guardar estadísticas
  5. 4. Top 10 global
  6. Errores comunes
  7. Con RoCode
  8. Preguntas frecuentes
  9. Fuentes y lecturas

Cómo funciona leaderstats

IlustraciónLos scripts terminados de leaderstats y de la plataforma de monedas en un juego en marcha.

Roblox muestra una lista de jugadores en todos los juegos. Cuando un jugador tiene un Folder hijo llamado leaderstats, la lista añade una columna por cada objeto de valor que hay dentro y muestra el valor de ese jugador en su fila. El título de la columna es el Name del objeto de valor.

Objetos de valor que puedes poner en leaderstats
ObjetoGuardaSirve para
IntValueNúmeros enterosMonedas, kills, victorias, nivel
NumberValueNúmeros decimalesMejor tiempo de vuelta, distancia
StringValueTextoRango o título del equipo

Dos reglas explican casi todos los leaderboards rotos. El nombre de la carpeta tiene que ser exactamente leaderstats: Leaderstats o leaderStats se ignoran. Y la carpeta la tiene que crear un Script de servidor, porque el servidor es el único lugar desde el que un cambio se replica a todos los jugadores. Si no tienes claro dónde se ejecuta el código, lee primero Script vs LocalScript vs ModuleScript (en inglés).

Paso 1: crea el script de leaderstats

  1. En el Explorer, pasa el ratón sobre ServerScriptService, haz clic en el botón + e inserta un Script.
  2. Cámbiale el nombre a Leaderstats para encontrarlo después.
  3. Sustituye su contenido por el código de abajo y pulsa Play. Tu nombre aparece en la lista de jugadores con Coins y Wins en 0.
Script en ServerScriptService llamado Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- tiene que ser exactamente este nombre, todo en minúsculas

	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 -- asigna el padre al final, cuando los valores ya están dentro
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- En Studio puedes entrar antes de que se ejecute este script, así que prepara a quien ya esté aquí
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

El bucle del final importa al probar en Studio: a veces el primer jugador entra antes de que PlayerAdded esté conectado, y ese jugador se quedaría sin estadísticas.

Paso 2: da puntos a los jugadores de forma segura

Para cambiar una estadística, pon su Value desde un script de servidor. Esta plataforma de monedas paga 10 monedas cuando un jugador la toca. Touched se dispara muchas veces por segundo mientras un personaje está sobre una parte, así que el script guarda una espera corta por jugador.

Script en una Part de Workspace llamado 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 dispara muchas veces por paso; esto evita que un toque pague diez veces
	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") encuentra el personaje incluso cuando la parte que toca está dentro de un accesorio, algo que una comprobación simple con hit.Parent no detecta.

Si los puntos vienen de algo que el jugador hace en su propia pantalla, como pulsar un botón, el LocalScript debe pedírselo al servidor con un RemoteEvent y el servidor debe decidir si paga. Nunca dejes que el cliente envíe la cantidad. La guía de RemoteEvents (en inglés) muestra el patrón con validación.

Cuatro ejemplos completos: la guía de tu primer juego paga 1 Coin por cada moneda que un jugador toca en su recorrido y una Win en la plataforma de meta tras 3 monedas, la guía de simulador de clics paga Coins por pulsar botones con un límite de clics en el servidor, la guía de espadas suma 1 a la estadística Kills de quien dio el último golpe antes de que muriera un jugador, y la guía de armas muestra cómo contar una kill cuando un disparo deja la Health de un objetivo en 0. La guía de armas está en inglés.

Paso 3: guarda las estadísticas entre sesiones

leaderstats solo existe mientras existe el servidor. Para conservar monedas y victorias, cárgalas desde un data store cuando el jugador entra y guárdalas cuando sale. Esta versión sustituye el script del paso 1. Nunca guarda a un jugador cuyos datos no se cargaron, que es el error que borra el progreso en la mayoría de los scripts de guardado copiados.

Script en ServerScriptService llamado Leaderstats
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

-- Se llama dentro de cada pcall de abajo, así que un place que aún no está publicado
-- (sin acceso a data stores) sigue teniendo su leaderboard
local function statsStore(): DataStore
	return DataStoreService:GetDataStore("PlayerStats_v1")
end

-- Jugadores cuyas estadísticas guardadas se cargaron. Quien no esté aquí nunca se guarda,
-- así que una carga fallida no puede sobrescribir el progreso real con ceros.
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)

-- Cuando el servidor se apaga, guarda a todos antes de cerrar
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)

Esto basta para un juego pequeño. Para reintentos, UpdateAsync, límites de peticiones y protegerte de dos servidores que escriben al mismo jugador, sigue con el tutorial de DataStore.

Paso 4: un top 10 global

leaderstats solo compara jugadores del mismo servidor. Un ranking global necesita un ordered data store: un data store que guarda un número por clave y puede devolver las claves ordenadas por valor. Escribe en él la puntuación de cada jugador desde el servidor y luego lee las primeras entradas.

Tienes dos formas de mostrarlo. La lista de jugadores de Roblox tiene las vistas Friends y Global, que leen de un ordered data store que registras en Creator Hub (una función beta en el momento de escribir esto, con un leaderboard activo por juego). O puedes dibujar tú el ranking en un tablero dentro de tu mundo, lo que funciona en cualquier juego y te deja darle estilo. El script de abajo hace lo segundo, y las puntuaciones que escribe usan el ID de usuario del jugador como clave, que también es el formato que espera el leaderboard de Creator Hub.

  1. Añade una Part anclada a Workspace, llámala WinsBoard y dale tamaño de cartel (por ejemplo 12 por 8 por 1 studs), con la cara frontal mirando hacia tu spawn.
  2. Inserta un Script en ServerScriptService llamado GlobalWinsBoard con el código de abajo.
  3. Juega. El tablero se llena cuando termina la primera actualización, y se actualiza cada minuto.
Script en ServerScriptService llamado 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

-- El tablero: una Part anclada llamada WinsBoard en Workspace. El script añade por sí mismo
-- la SurfaceGui y las filas, así que la Part es lo único que tienes que construir.
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) devuelve primero los 10 valores más altos. Los ordered data stores solo guardan números enteros, así que guarda las puntuaciones como enteros. El script escribe cada jugador una vez por minuto y lee el top 10 una vez por minuto, muy por debajo de los límites por servidor por defecto (30 + 5 por jugador por minuto para escrituras ordenadas y 5 + 2 por jugador para lecturas ordenadas, según la documentación del 30 de septiembre de 2026).

Errores comunes y soluciones

Los problemas de abajo explican la mayoría de las publicaciones de "mi leaderboard no funciona". Mira primero la ventana Output (ábrela desde el menú Window de Studio o la pestaña Script): si un script dio error, ahí está el número de línea.

El leaderboard no aparece

Comprueba que la carpeta se llama leaderstats en minúsculas, que es hija del Player (no del personaje) y que el código es un Script en ServerScriptService, no un LocalScript.

Los demás jugadores no ven el cambio de mi estadística

El valor se cambió en el cliente. Mueve el cambio a un Script de servidor, y si lo activa un botón o una tecla, envía un RemoteEvent y deja que el servidor cambie el valor.

attempt to index nil with 'Coins'

El código intentó leer player.leaderstats.Coins antes de que existiera la carpeta, o el nombre está escrito de otra forma. En el servidor usa FindFirstChild y comprueba el resultado; en un LocalScript usa player:WaitForChild("leaderstats"). La guía de errores de scripts explica este error en detalle.

Las monedas suben 10, 20 o 50 con un solo toque

Touched se dispara una y otra vez mientras las partes se superponen. Añade una espera por jugador como en el paso 2, o quita el objeto cuando se recoge.

Las estadísticas se reinician cada vez que vuelvo a entrar

Roblox no guarda leaderstats. Añade el script del paso 3. Para probar el guardado en Studio, publica el place y activa Studio Access to API Services en Experience Settings.

Constrúyelo con RoCode

Si prefieres no conectarlo todo a mano, RoCode puede construirlo dentro del place que tienes abierto. Es un agente de IA que trabaja mediante un plugin de Roblox Studio, así que crea los scripts y las partes en tu Explorer en lugar de darte código para pegar.

Tú escribes

Añade un leaderboard con Coins y Wins que se guarde entre sesiones, y un tablero con el top 10 de victorias en una parte cerca del spawn.

RoCode hace
  • Puede buscar primero en tu place código de leaderstats o DataStore que ya exista, para ampliar lo que tienes en lugar de añadir un segundo leaderboard
  • Crea el script de servidor en ServerScriptService y la parte del tablero en Workspace
  • Comprueba dentro de Studio que los scripts que escribió compilan antes de terminar
  • Envía sus cambios en lotes, y cada lote queda marcado como punto de deshacer en el historial de Studio

Tú sigues revisando el resultado y probando tú mismo las estadísticas y el guardado: con el plugin 3.9 o posterior RoCode puede hacer una prueba corta y leer los errores, y con el plugin 3.9.11 o posterior puede controlar un personaje de prueba y comprobar valores como Coins y Wins, pero solo comprueba lo que eligió probar. Las leaderstats suelen ser el primero de muchos sistemas de un juego: construye el resto de tu juego con un sistema por prompt de la misma forma. Cómo se conecta RoCode a Studio.

Preguntas frecuentes

¿Qué es leaderstats en Roblox?

Un Folder llamado exactamente leaderstats, todo en minúsculas, dentro de un Player. Roblox muestra cada IntValue, NumberValue o StringValue que contiene como una columna de la lista de jugadores. Créalo desde un Script de servidor, como en el paso 1.

¿Cómo hago un leaderboard global en Roblox?

Escribe la puntuación de cada jugador en un ordered data store desde el servidor, luego lee las primeras entradas y muéstralas en un tablero dentro de tu mundo. El paso 4 tiene el script completo para un top 10.

¿Roblox guarda leaderstats automáticamente?

No. leaderstats solo existe mientras el jugador está en el servidor. Guarda los valores con un data store cuando el jugador sale y cárgalos cuando entra, como en el paso 3.

¿Puedo ocultar un valor del leaderboard?

Sí. Solo se muestran los valores que están dentro de la carpeta leaderstats. Guarda los datos privados en otra carpeta del jugador, o en una tabla en un script de servidor.

¿Cómo oculto toda la lista de jugadores?

Desde un LocalScript, llama a StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.PlayerList, false). Pasa true para volver a mostrarla.

¿Puedo usar un NumberValue para las monedas?

Puedes, pero un IntValue encaja mejor con una moneda de números enteros, y los ordered data stores solo aceptan números enteros si más adelante haces un ranking con ella.

Fuentes y lecturas

Cómo se comprobó el código: cada script de esta página pasa el verificador de tipos estricto de Luau con las definiciones de la API de Roblox (luau-lsp, 12 de noviembre de 2026). Una verificación de tipos detecta APIs mal escritas y tipos incorrectos, no la lógica del juego, así que pruébalo en Studio antes de publicar.

Prueba RoCode en tu propio juego.

Créditos gratis cada día, sin tarjeta. Instala el plugin, describe la función y revisa lo que aparece en Studio.