Tutorial · Spielerdaten

Ein Leaderboard in Roblox Studio erstellen

Die Spielerliste oben rechts in einem Roblox-Spiel wird von einem einzigen Ordner namens leaderstats gesteuert. Dieser Guide baut sie von null auf: das Server-Skript, ein sicherer Weg, Punkte zu vergeben, Speichern zwischen Sitzungen und eine globale Top 10.

Aktualisiert am 12. November 20267 Min. LesezeitGeschrieben von

Kurz gesagt

Erstelle ein Script in ServerScriptService, das auf Players.PlayerAdded hört, einen Folder mit dem Namen genau leaderstats (alles klein) erstellt und ihn in den Spieler legt. Jeder IntValue, NumberValue oder StringValue in diesem Ordner wird zu einer Spalte in der Spielerliste.

  • Erstelle und ändere Werte nur auf dem Server. Eine Änderung durch ein LocalScript sieht nur dieser eine Spieler und sonst niemand.
  • leaderstats wird nicht gespeichert. Lade und speichere die Werte mit einem DataStore, wenn sie die nächste Sitzung überleben sollen.
  • Für eine Rangliste über alle Spieler schreib jeden Punktestand in einen Ordered DataStore und zeig ihn auf einer Tafel in deiner Welt oder in der Global-Ansicht der Spielerliste.
Auf dieser Seite
  1. So funktioniert leaderstats
  2. 1. leaderstats erstellen
  3. 2. Punkte vergeben
  4. 3. Werte speichern
  5. 4. Globale Top 10
  6. Häufige Fehler
  7. Mit RoCode
  8. Häufige Fragen
  9. Quellen und weiterführende Links

So funktioniert leaderstats

IllustrationDie fertigen Skripte für leaderstats und das Münz-Pad in einem laufenden Spiel.

Roblox zeigt in jedem Spiel eine Spielerliste. Hat ein Spieler einen Kind-Folder namens leaderstats, fügt die Liste für jedes Value-Objekt darin eine Spalte hinzu und zeigt den Wert dieses Spielers in seiner Zeile. Der Spaltentitel ist der Name des Value-Objekts.

Value-Objekte, die du in leaderstats legen kannst
ObjektHältGut für
IntValueGanze ZahlenCoins, Kills, Siege, Level
NumberValueDezimalzahlenBeste Rundenzeit, Entfernung
StringValueTextRang oder Teamtitel

Zwei Regeln sind schuld an fast jedem kaputten Leaderboard. Der Ordner muss genau leaderstats heißen: Leaderstats oder leaderStats wird ignoriert. Und der Ordner muss von einem Server-Script erstellt werden, weil nur Änderungen auf dem Server an jeden Spieler repliziert werden. Wenn du unsicher bist, wo Code läuft, lies zuerst Script vs LocalScript vs ModuleScript (auf Englisch).

Schritt 1: Das Leaderstats-Skript erstellen

  1. Fahr im Explorer mit der Maus über ServerScriptService, klick auf den Button + und füge ein Script ein.
  2. Nenn es Leaderstats, damit du es später wiederfindest.
  3. Ersetz seinen Inhalt durch den Code unten und drück auf Play. Dein Name erscheint in der Spielerliste, mit Coins und Wins auf 0.
Script in ServerScriptService namens Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- muss genau so heißen, alles klein

	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 -- als Letztes zuweisen, wenn die Werte drin sind
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- In Studio kannst du beitreten, bevor dieses Skript läuft, also alle einrichten, die schon da sind
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Die Schleife am Ende ist beim Testen in Studio wichtig: Der erste Spieler tritt manchmal bei, bevor PlayerAdded verbunden ist, und bekäme sonst keine Werte.

Schritt 2: Spielern sicher Punkte geben

Um einen Wert zu ändern, setz seinen Value aus einem Server-Skript. Dieses Münz-Pad zahlt 10 Coins, wenn ein Spieler es berührt. Touched feuert viele Male pro Sekunde, während eine Figur auf einem Part steht, also hält das Skript einen kurzen Cooldown pro Spieler.

Script in einem Part in Workspace namens 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 feuert pro Schritt viele Male; das verhindert, dass eine Berührung zehnmal auszahlt
	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") findet die Figur auch dann, wenn der berührende Part in einem Accessory steckt, was eine einfache Prüfung mit hit.Parent übersieht.

Kommen Punkte von etwas, das der Spieler auf seinem eigenen Bildschirm macht, zum Beispiel einem Button-Klick, sollte das LocalScript den Server mit einem RemoteEvent fragen, und der Server entscheidet, ob er auszahlt. Lass den Client nie den Betrag schicken. Der RemoteEvents-Guide (auf Englisch) zeigt das Muster mit Prüfung.

Vier ausgearbeitete Beispiele: Der Guide zum ersten Spiel zahlt 1 Coin für jede Münze, die ein Spieler auf seinem Parcours berührt, und einen Win am Ziel-Pad nach 3 Münzen, der Clicker-Simulator-Guide zahlt Coins für Button-Klicks mit einem Klicklimit auf dem Server, der Schwert-Guide gibt dem, der den letzten Treffer vor dem Tod eines Spielers gelandet hat, 1 auf den Wert Kills, und der Waffen-Guide zeigt, wie man einen Kill zählt, wenn ein Schuss die Health eines Ziels auf 0 bringt (die letzten drei auf Englisch).

Schritt 3: Die Werte zwischen Sitzungen speichern

leaderstats lebt nur so lange wie der Server. Um Coins und Wins zu behalten, lade sie beim Beitreten aus einem DataStore und speichere sie beim Verlassen. Diese Version ersetzt das Skript aus Schritt 1. Sie speichert nie einen Spieler, dessen Daten nicht geladen werden konnten, und genau dieser Fehler löscht in den meisten kopierten Speicherskripten den Fortschritt.

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

-- Wird in jedem pcall unten aufgerufen, damit ein noch nicht veröffentlichtes Spiel
-- (ohne DataStore-Zugriff) trotzdem sein Leaderboard bekommt
local function statsStore(): DataStore
	return DataStoreService:GetDataStore("PlayerStats_v1")
end

-- Spieler, deren gespeicherte Werte geladen wurden. Wer hier fehlt, wird nie gespeichert,
-- also kann ein fehlgeschlagenes Laden echten Fortschritt nicht mit Nullen überschreiben.
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)

-- Wenn der Server herunterfährt, alle speichern, bevor er schließt
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)

Für ein kleines Spiel reicht das. Für Wiederholungsversuche, UpdateAsync, Anfragelimits und den Schutz davor, dass zwei Server denselben Spieler schreiben, mach mit dem DataStore-Tutorial weiter.

Schritt 4: Eine globale Top 10

leaderstats vergleicht nur Spieler auf demselben Server. Eine globale Rangliste braucht einen Ordered DataStore: einen DataStore, der pro Schlüssel eine Zahl hält und die Schlüssel nach Wert sortiert zurückgeben kann. Schreib den Punktestand jedes Spielers vom Server hinein und lies dann die obersten Einträge zurück.

Du hast zwei Wege, sie anzuzeigen. Die Spielerliste von Roblox hat die Ansichten Friends und Global, die aus einem Ordered DataStore lesen, den du im Creator Hub registrierst (zum Zeitpunkt des Schreibens eine Beta-Funktion, ein aktives Leaderboard pro Spiel). Oder du zeichnest die Rangliste selbst auf eine Tafel in deiner Welt, was in jedem Spiel funktioniert und dich das Aussehen bestimmen lässt. Das Skript unten macht das Zweite, und die Punktestände, die es schreibt, nutzen die User-ID des Spielers als Schlüssel, also auch das Format, das das Creator-Hub-Leaderboard erwartet.

  1. Füge dem Workspace einen verankerten Part hinzu, nenn ihn WinsBoard und gib ihm die Größe eines Schilds (zum Beispiel 12 mal 8 mal 1 Studs), mit der Vorderseite zu deinem Spawn.
  2. Füge in ServerScriptService ein Script namens GlobalWinsBoard mit dem Code unten ein.
  3. Spiel. Die Tafel füllt sich, sobald die erste Aktualisierung gelaufen ist, und aktualisiert sich jede Minute.
Script in ServerScriptService namens 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

-- Die Tafel: ein verankerter Part namens WinsBoard in Workspace. Das Skript fügt die
-- SurfaceGui und die Zeilen selbst hinzu, also musst du nur den Part bauen.
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) gibt die 10 höchsten Werte zuerst zurück. Ordered DataStores halten nur ganze Zahlen, also speichere Punktestände als Integer. Das Skript schreibt jeden Spieler einmal pro Minute und liest die Top 10 einmal pro Minute, weit innerhalb der Standardlimits pro Server (30 + 5 pro Spieler und Minute für Schreibzugriffe auf Ordered DataStores und 5 + 2 pro Spieler für sortierte Lesezugriffe, laut Dokumentation am 30. September 2026).

Häufige Fehler und Lösungen

Die Probleme unten erklären die meisten Beiträge à la „mein Leaderboard funktioniert nicht“. Prüf zuerst das Output-Fenster (zu öffnen über das Menü Window oder den Tab Script von Studio): Ist ein Skript abgebrochen, steht dort die Zeilennummer.

Das Leaderboard erscheint gar nicht

Prüf, ob der Ordner klein geschrieben leaderstats heißt, ob er im Player liegt (nicht in der Figur) und ob der Code ein Script in ServerScriptService ist, kein LocalScript.

Andere Spieler sehen meine geänderten Werte nicht

Der Wert wurde auf dem Client geändert. Verschieb die Änderung in ein Server-Script, und wenn ein Button oder Tastendruck sie auslöst, schick ein RemoteEvent und lass den Server den Wert ändern.

attempt to index nil with 'Coins'

Der Code hat versucht, player.leaderstats.Coins zu lesen, bevor der Ordner existierte, oder der Name ist anders geschrieben. Nutze auf dem Server FindFirstChild und prüf das Ergebnis; nutze in einem LocalScript player:WaitForChild("leaderstats"). Der Guide zu Skriptfehlern erklärt diesen Fehler ausführlich.

Coins steigen durch eine Berührung um 10, 20 oder 50

Touched feuert wiederholt, solange sich Parts überlappen. Füge einen Cooldown pro Spieler hinzu wie in Schritt 2, oder entferne das Pickup, wenn es eingesammelt wurde.

Die Werte werden bei jedem erneuten Beitreten zurückgesetzt

leaderstats wird von Roblox nicht gespeichert. Füge das Skript aus Schritt 3 hinzu. Um das Speichern in Studio zu testen, veröffentliche das Spiel und schalte in den Experience Settings Studio Access to API Services ein.

Mit RoCode bauen

Wenn du das nicht von Hand verdrahten willst, kann RoCode es in dem Spiel bauen, das du offen hast. Es ist ein KI-Agent, der über ein Roblox Studio Plugin arbeitet, also erstellt er die Skripte und Parts in deinem Explorer, statt dir Code zum Einfügen zu geben. Prompts kannst du auf Deutsch schreiben.

Du schreibst

Füge ein Leaderboard mit Coins und Wins hinzu, das zwischen Sitzungen speichert, und eine Top-10-Tafel für Wins auf einem Part in der Nähe des Spawns.

RoCode macht
  • Kann dein Spiel zuerst nach vorhandenem leaderstats- oder DataStore-Code durchsuchen, um das Bestehende zu erweitern, statt ein zweites Leaderboard hinzuzufügen
  • Erstellt das Server-Skript in ServerScriptService und den Tafel-Part in Workspace
  • Prüft die Skripte, die es geschrieben hat, in Studio auf Kompilierfehler, bevor es fertig ist
  • Schickt seine Änderungen in Runden, und jede Runde wird in der Studio-Historie als Undo-Punkt markiert

Das Ergebnis prüfst du trotzdem selbst und testest die Werte und das Speichern im Playtest: Mit Plugin 3.9 oder neuer kann RoCode einen kurzen Playtest machen und die Fehler lesen, und mit Plugin 3.9.11 oder neuer eine Testfigur steuern und Werte wie Coins und Wins prüfen, aber es prüft nur, was es selbst zum Testen ausgewählt hat. Leaderstats sind meist das erste von vielen Systemen in einem Spiel: bau den Rest deines Spiels genauso, ein System pro Prompt. Wie sich RoCode mit Studio verbindet.

Häufige Fragen

Was ist leaderstats in Roblox?

Ein Folder mit dem Namen genau leaderstats, alles klein, in einem Player. Roblox zeigt jeden IntValue, NumberValue oder StringValue darin als Spalte in der Spielerliste. Erstelle ihn aus einem Server-Script, wie in Schritt 1.

Wie mache ich ein globales Leaderboard in Roblox?

Schreib den Punktestand jedes Spielers vom Server in einen Ordered DataStore, lies dann die obersten Einträge zurück und zeig sie auf einer Tafel in deiner Welt. Schritt 4 hat das komplette Skript für eine Top 10.

Speichert Roblox leaderstats automatisch?

Nein. leaderstats existiert nur, solange der Spieler auf dem Server ist. Speichere die Werte mit einem DataStore, wenn der Spieler geht, und lade sie, wenn er beitritt, wie in Schritt 3.

Kann ich einen Wert im Leaderboard verstecken?

Ja. Nur Werte im Ordner leaderstats werden angezeigt. Bewahre private Daten in einem anderen Ordner am Spieler auf, oder in einer Tabelle in einem Server-Skript.

Wie verstecke ich die ganze Spielerliste?

Ruf aus einem LocalScript StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.PlayerList, false) auf. Übergib true, um sie wieder anzuzeigen.

Kann ich einen NumberValue für Coins nutzen?

Kannst du, aber ein IntValue passt besser zu einer Währung mit ganzen Zahlen, und Ordered DataStores akzeptieren nur ganze Zahlen, falls du später danach sortierst.

Quellen und weiterführende Links

So wurde der Code geprüft: Jedes Skript auf dieser Seite besteht die strikte Typprüfung von Luau mit den Roblox API-Definitionen (luau-lsp, 12. November 2026). Eine Typprüfung findet falsch geschriebene APIs und falsche Typen, aber keine Fehler in der Spiellogik. Teste also in Studio, bevor du veröffentlichst.

Probier RoCode in deinem eigenen Spiel aus.

Jeden Tag kostenlose Credits, ohne Karte. Installiere das Plugin, beschreibe das Feature und prüfe, was in Studio ankommt.