Útmutató · Játékosadatok

Hogyan készíts ranglistát a Roblox Studióban

A Roblox játékok jobb felső sarkában lévő játékoslistát egyetlen leaderstats nevű mappa irányítja. Ez az útmutató a nulláról építi fel: szerverscript, biztonságos pontosztás, mentés a játékmenetek között és globális top 10.

Frissítve 2026. november 20.7 perc olvasásSzerző:

Röviden

Hozz létre egy Scriptet a ServerScriptService-ben, amely a Players.PlayerAdded eseményt figyeli, létrehoz egy pontosan leaderstats nevű Folder objektumot (csupa kisbetűvel), és a játékos gyermekévé teszi. A mappában lévő minden IntValue, NumberValue vagy StringValue egy oszlop lesz a játékoslistában.

  • A statisztikákat csak a szerveren hozd létre és módosítsd. Egy LocalScriptből végzett módosítást csak az adott játékos látja, senki más.
  • A leaderstats nem mentődik. Data store segítségével töltsd be és mentsd az értékeket, ha meg kell maradniuk a következő játékmenetig.
  • Az összes játékosra kiterjedő rangsorhoz minden pontszámot írj egy ordered data store-ba, és mutasd meg egy táblán a saját világodban vagy a játékoslista Global módjában.
Ezen az oldalon
  1. Hogyan működik a leaderstats
  2. 1. A leaderstats létrehozása
  3. 2. Pontosztás
  4. 3. Mentés
  5. 4. Globális top 10
  6. Common errors
  7. RoCode-dal
  8. Gyakori kérdések
  9. Források és további olvasnivaló

Hogyan működik a leaderstats

IllusztrációA kész leaderstats és érmeplatform scriptek a futó játékban.

A Roblox minden játékban megmutatja a játékoslistát. Ha egy játékosnak van leaderstats nevű Folder gyermeke, a lista a benne lévő minden értékobjektumhoz hozzáad egy oszlopot, és a játékos sorában megmutatja az ő értékét. Az oszlop fejléce az értékobjektum Name tulajdonsága.

Értékobjektumok, amelyeket a leaderstatsba tehetsz
ObjektumMit tárolMire jó
IntValueEgész számokÉrmék, ölések, győzelmek, szint
NumberValueTizedes számokLegjobb köridő, távolság
StringValueSzövegRang vagy csapatcím

Két szabály tönkretesz szinte minden nem működő ranglistát. A mappa neve pontosan leaderstats legyen: a Leaderstats vagy a leaderStats figyelmen kívül marad. És a mappát szerveroldali Script hozza létre, mert csak a szerveren történt változások replikálódnak minden játékoshoz. Ha nem vagy biztos benne, hol fut a kód, először olvasd el a Script vs LocalScript vs ModuleScript útmutatót (angolul).

1. lépés: Hozd létre a leaderstats scriptet

  1. Az Explorerben vidd az egeret a ServerScriptService fölé, kattints a + gombra, és szúrj be egy Scriptet.
  2. Nevezd át Leaderstats-ra, hogy később könnyen megtaláld.
  3. Cseréld le a tartalmát az alábbi kódra, és nyomd meg a Play gombot. A neved megjelenik a játékoslistában 0 értékű Coins és Wins oszloppal.
Script helye: ServerScriptService neve: Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- a névnek pontosan ilyennek kell lennie, csupa kisbetűvel

	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 -- a szülőt utoljára állítjuk be, amikor az értékek már benne vannak
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- A Studióban előbb be lehet lépni, mint ahogy ez a script elindul, ezért azokat is beállítjuk, akik már itt vannak
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

A végén lévő ciklus a Studio tesztekben fontos: az első játékos néha azelőtt lép be, hogy a PlayerAdded csatlakozna, és a ciklus nélkül statisztikák nélkül maradna.

2. lépés: Ossz pontokat biztonságosan

Egy statisztika módosításához állítsd be a Value értékét egy szerverscriptből. Ez az érmeplatform 10 érmét ad, amikor a játékos megérinti. A Touched másodpercenként sokszor elsül, amíg a karakter a parton áll, ezért a script minden játékosnak rövid újratöltési időt tart.

Script helye: egy partban a Workspace-ben neve: 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 -- a Touched lépésenként sokszor elsül; ez megakadályozza, hogy egy érintés tízszer fizessen
	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)

A FindFirstAncestorOfClass("Model") akkor is megtalálja a karaktert, ha az érintő part egy kiegészítőben van, az egyszerű hit.Parent ellenőrzés viszont ezt kihagyja.

Ha a pontok olyasmiért járnak, amit a játékos a saját képernyőjén csinál, például egy gombnyomásért, a LocalScript egy RemoteEventen keresztül kérje meg a szervert, és a szerver döntse el, fizet-e. Soha ne engedd, hogy a kliens küldje az összeget. A RemoteEvents útmutató ellenőrzéssel együtt mutatja be ezt a mintát.

Négy kész példa: az első játék útmutató 1 Coint ad minden érméért, amelyet a játékos megérint a pályán, és egy Wint a célplatformon 3 érme után, a kattintós szimulátor útmutató gombnyomásokért ad Coinst, a szerveren kattintási korláttal, a kard útmutató 1-et ad a Kills értékhez annak, aki az utolsó ütést vitte be a játékos halála előtt, a fegyveres útmutató pedig megmutatja, hogyan számolj el egy ölést, amikor a lövés 0-ra viszi a célpont Health értékét.

3. lépés: Mentsd a statisztikákat a játékmenetek között

A leaderstats csak addig él, amíg a szerver. Az érmék és győzelmek megtartásához töltsd be őket egy data store-ból, amikor a játékos belép, és mentsd, amikor kilép. Ez a változat lecseréli az 1. lépés scriptjét. Soha nem menti azt a játékost, akinek az adatai nem töltődtek be: a legtöbb kimásolt mentőscriptben pontosan ez a hiba törli a haladást.

Script helye: ServerScriptService neve: Leaderstats
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

-- Az alábbi minden pcall-on belül hívódik, így egy még nem publikált place
-- (data store hozzáférés nélkül) is megkapja a ranglistát
local function statsStore(): DataStore
	return DataStoreService:GetDataStore("PlayerStats_v1")
end

-- Azok a játékosok, akiknek a mentett statisztikái betöltődtek. Akik nincsenek itt, azokat soha nem mentjük,
-- így egy sikertelen betöltés nem írja felül nullákkal a valódi haladást.
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)

-- Amikor a szerver leáll, mindenkit mentünk a bezárás előtt
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)

Egy kis játékhoz ennyi elég. Az újrapróbálkozásokról, az UpdateAsync függvényről, a kéréskorlátokról és arról, hogyan védekezz az ellen, hogy két szerver ugyanazt a játékost írja, a DataStore útmutatóban olvashatsz tovább.

4. lépés: Globális top 10

A leaderstats csak az egy szerveren lévő játékosokat hasonlítja össze. Globális rangsorhoz ordered data store kell: egy data store, amely kulcsonként egy számot tárol, és érték szerint rendezve tudja visszaadni a kulcsokat. Írd bele minden játékos pontszámát a szerverről, aztán olvasd vissza a legfelső bejegyzéseket.

Kétféleképpen mutathatod meg. A Roblox játékoslistájában van Friends és Global mód, amelyek a Creator Hubban regisztrált ordered data store-ból olvasnak (az írás idején ez béta funkció, játékonként egy aktív ranglistával). Vagy magad is megrajzolhatod a rangsort egy táblán a saját világodban: ez bármelyik játékban működik, és tetszés szerint formázhatod. Az alábbi script a második utat választja, a pontszámokat pedig a játékos user ID-jával mint kulccsal írja, ami ugyanaz a formátum, amelyet a Creator Hub ranglistája vár.

  1. Adj hozzá a Workspace-hez egy rögzített (anchored) Partot, nevezd el WinsBoard-nak, és tedd cégtábla méretűre (például 12 x 8 x 1 stud), az elülső lapjával a megjelenési pont felé.
  2. Szúrj be a ServerScriptService-be egy GlobalWinsBoard nevű Scriptet az alábbi kóddal.
  3. Nyomd meg a Play gombot. A tábla az első frissítés után feltöltődik, és percenként frissül.
Script helye: ServerScriptService neve: 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

-- A tábla: egy WinsBoard nevű rögzített Part a Workspace-ben. A script maga adja hozzá
-- a SurfaceGuit és a sorokat, így csak a Partot kell megépíteni.
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

A GetSortedAsync(false, 10) a 10 legnagyobb értéket adja vissza elsőként. Az ordered data store csak egész számokat tárol, ezért a pontszámokat egészként tárold. A script minden játékost percenként egyszer ír, és a top 10-et percenként egyszer olvassa, bőven a szerverenkénti alapkorlátokon belül (percenként 30 + 5 játékosonként az ordered data store írásaira, és 5 + 2 játékosonként a rendezett olvasásokra, a 2026. szeptember 30-i dokumentáció szerint).

Gyakori hibák és megoldásaik

Az alábbi problémák lefedik a legtöbb „nem működik a ranglistám” panaszt. Először nézd meg az Output ablakot (a Studio Window menüjéből vagy a Script fülön nyithatod meg): ha a script hibával leállt, ott lesz a sor száma.

A ranglista egyáltalán nem jelenik meg

Ellenőrizd, hogy a mappa neve kisbetűs leaderstats-e, hogy a szülője a Player-e (nem a karakter), és hogy a kód Script-e a ServerScriptService-ben, nem LocalScript.

A többi játékos nem látja a statisztikám változását

Az értéket a kliensen módosították. Tedd át a módosítást egy szerveroldali Scriptbe, és ha egy gomb vagy billentyű indítja, küldj egy RemoteEventet, és az értéket a szerver módosítsa.

attempt to index nil with 'Coins'

A kód azelőtt próbálta kiolvasni a player.leaderstats.Coins értéket, hogy a mappa megjelent volna, vagy a név másképp van írva. A szerveren használd a FindFirstChild függvényt, és ellenőrizd az eredményt; LocalScriptben használd a player:WaitForChild("leaderstats") hívást. A script hibák útmutató részletesen elemzi ezt a hibát.

Egy érintésre 10, 20 vagy 50 érme jön

A Touched újra és újra elsül, amíg a partok átfedik egymást. Adj hozzá játékosonkénti újratöltési időt, ahogy a 2. lépésben, vagy töröld a tárgyat a felvétel után.

A statisztikák minden újbóli belépéskor nullázódnak

A Roblox nem menti a leaderstatsot. Add hozzá a 3. lépés scriptjét. A mentés Studióban való teszteléséhez publikáld a place-t, és kapcsold be a Studio Access to API Services opciót az Experience Settingsben.

Elkészítés a RoCode-dal

Ha nincs kedved mindezt kézzel összerakni, a RoCode mindent megépíthet a nálad nyitott place-ben. Ez egy AI-ügynök, amely egy Roblox Studio pluginon keresztül dolgozik, így a scripteket és a partokat az Explorerben hozza létre, nem beillesztendő kódot ad.

Te írod

Adj hozzá egy ranglistát Coins és Wins oszloppal, amely megmarad a játékmenetek között, és egy győzelmek szerinti top 10 táblát egy parton a megjelenési pont közelében.

A RoCode elvégzi
  • Először megkeresheti a place-edben a meglévő leaderstats vagy DataStore kódot, hogy kiegészítse, ami már megvan, és ne adjon hozzá egy második ranglistát
  • Létrehozza a szerverscriptet a ServerScriptService-ben és a tábla partját a Workspace-ben
  • Befejezés előtt a Studióban ellenőrzi, hogy a megírt scriptek lefordulnak-e
  • A módosításokat csomagokban küldi, és minden csomag visszavonási pontként jelenik meg a Studio előzményeiben

Az eredményt továbbra is te ellenőrzöd, és te teszteled a játékban a statisztikákat és a mentést: 3.9-es vagy újabb pluginnal a RoCode rövid playtestet indíthat, és elolvashatja a hibákat, 3.9.11-es vagy újabb pluginnal pedig egy tesztkaraktert irányíthat, és ellenőrizheti az olyan értékeket, mint a Coins és a Wins, de csak azt ellenőrzi, amit maga választott ki tesztelésre. A leaderstats általában az első a játék sok rendszere közül: építsd fel a játék többi részét kérésenként egy rendszerrel ugyanígy. Hogyan csatlakozik a RoCode a Studióhoz.

Gyakori kérdések

Mi a leaderstats a Robloxban?

Egy pontosan leaderstats nevű, csupa kisbetűs Folder a Playerben. A Roblox a benne lévő minden IntValue, NumberValue vagy StringValue objektumot oszlopként mutatja a játékoslistában. Szerveroldali Scriptből hozd létre, ahogy az 1. lépésben.

Hogyan készíthetek globális ranglistát a Robloxban?

A szerverről írd minden játékos pontszámát egy ordered data store-ba, aztán olvasd vissza a legfelső bejegyzéseket, és mutasd meg őket egy táblán a saját világodban. A 4. lépésben megtalálod a teljes scriptet a top 10-hez.

A Roblox automatikusan menti a leaderstatsot?

Nem. A leaderstats csak addig létezik, amíg a játékos a szerveren van. Data store segítségével mentsd az értékeket, amikor a játékos kilép, és töltsd be, amikor belép, ahogy a 3. lépésben.

Elrejthetek egy értéket a ranglistából?

Igen. Csak a leaderstats mappán belüli értékek látszanak. A rejtett adatokat egy másik mappában tárold a játékosnál, vagy egy táblázatban a szerverscriptben.

Hogyan rejthetem el az egész játékoslistát?

Egy LocalScriptből hívd meg a StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.PlayerList, false) függvényt. Adj át true értéket, hogy újra megjelenjen.

Használhatok NumberValue-t az érmékhez?

Használhatsz, de egész számokból álló valutához az IntValue jobban illik, az ordered data store pedig csak egész számokat fogad el, ha később rangsort akarsz építeni belőlük.

Források és további olvasnivaló

Hogyan ellenőriztük a kódot: az oldalon minden script átmegy a Luau szigorú típusellenőrzésén a Roblox API definícióival (luau-lsp, 2026. november 20.). A típusellenőrzés kiszűri az elírt API-neveket és a rossz típusokat, de a játéklogikai hibákat nem, ezért publikálás előtt mindent tesztelj a Studióban.

Próbáld ki a RoCode-ot a saját játékodban.

Ingyenes kreditek minden nap, bankkártya nélkül. Telepítsd a plugint, írd le a funkciót, és nézd meg, mi jelenik meg a Studióban.