Erstellen Sie ein benutzerdefiniertes Ranglisten-Widget mit geordneten Datenspeichern

Datenspeicher sind ein Dienst, den Sie verwenden können, um persistente Spieldaten von Spielern über verschiedene Spielsitzungen hinweg zu speichern und zu laden. Sie speichern wichtige Informationen, wie den Fortschritt oder das Inventar eines Spielers, und ermöglichen es Ihnen, diese für den Spieler abzurufen, wenn er das nächste Mal Ihrem Spiel beitritt. Ohne Datenspeicher würde ein Spieler seinen gesamten Fortschritt jedes Mal verlieren, wenn er das Spiel verlässt.

Es gibt zwei Arten von Datenspeichern: standardmäßige und geordnete. Dieses Tutorial verwendet geordnete Datenspeicher, die Daten speichern, die Sie rangieren und numerisch sortieren können, und die Sie in aufsteigender oder absteigender Reihenfolge basierend auf den gespeicherten numerischen Werten abrufen können.

Verwenden Sie die Gold Rush Ranglisten-Tutorial - Start .rbxl Datei als Ausgangspunkt und die Gold Rush Ranglisten-Tutorial - Komplett .rbxl Datei als Referenz, um dieses Tutorial, das Ihnen das Fundament für die Erstellung eines benutzerdefinierten Spieler-Rankings bietet, zu absolvieren. Es enthält Anleitung zu:

• Speichern der Goldwerte in einem geordneten Datenspeicher.
• Abrufen und Sortieren der besten Werte weltweit über alle Server hinweg.
• Anzeigen der besten Werte in einer benutzerdefinierten Rangliste im UI.
• Automatisches Aktualisieren der benutzerdefinierten Rangliste alle paar Sekunden.

Am Ende dieses Tutorials sollten Sie Folgendes haben:

1. Unter ServerScriptService:

   1. Ein aktualisiertes GoldManager Skript, das den Punktestand des Spielers in einem geordneten Datenspeicher für die Rangliste speichert.
   2. Ein neues LeaderboardRemoteHandler Modulskript, das die sortierte Liste der besten Werte von der Rangliste abruft und zurückgibt.
   3. Ein neues LeaderboardManager Skript, das auf die Anfragen nach Ranglistendaten vom Client reagiert und als Brücke zwischen dem Client im LeaderboardGuiScript und dem Server im LeaderboardManager fungiert.
2. Unter StarterGui ein neues LeaderboardGuiScript Lokalskript, das die Ranglisten-UI für den Spieler rendert.

Aktivieren Sie den Studiozugang zu API-Diensten

Datenspeicher werden nicht lokal auf Ihrem Gerät gespeichert, sodass Ihr Spiel auf die Kommunikation von Server zu Server mit dem Backend von Roblox angewiesen ist, um sie zu verwenden. Standardmäßig schränkt der Studio diese Kommunikation ein, um Missbrauch oder versehentliche Verwendung zu verhindern. Der Zugriff auf API-Dienste im Studio ist deaktiviert, bis Sie ihn ausdrücklich aktivieren, um sicherzustellen, dass nur vertrauenswürdige Spiele von Roblox-Backend-Servern lesen und darauf schreiben können.

Um den Studiozugang zu API-Diensten zu aktivieren, damit Sie Datenspeicher verwenden können:

1. Öffnen Sie die Gold Rush Ranglisten-Tutorial - Start Datei im Studio. Diese Ausgangsdatei enthält bereits den Code aus dem Spielerdaten speichern Tutorial und die UI-Skelett für die Rangliste des Spielers.
2. Veröffentlichen Sie Ihr Spiel.
3. Gehen Sie im Studio zu Datei ⟩ Erlebnis-Einstellungen ⟩ Sicherheit.
4. Aktivieren Sie Studiozugang zu API-Diensten aktivieren.
5. Speichern Sie Ihre Änderungen.

Erstellen Sie einen geordneten Datenspeicher

Beim Erstellen eines Datenspeichers sollten Sie stets den DataStoreService von einem serverseitigen Script aufrufen. Dies ist wichtig, weil:

• Roblox allen Zugriff auf Datenspeicher vom Client aus blockiert, sodass nur der Server die Erlaubnis hat, auf persistente Spieldaten von Spielern zuzugreifen und diese zu ändern.
• Serverseitige Skripte in einer zentralisierten Umgebung ausgeführt werden, wodurch sichergestellt wird, dass die Daten, die in Ihrem Datenspeicher gelesen und geschrieben werden, genau und gültig sind.
• Da klientenseitige Skripte auf dem Gerät des Spielers ausgeführt werden, könnte jeder Spieler potenziell das Spiel ausnutzen und die Daten anderer Spieler stehlen oder überschreiben, wenn der Client Zugriff auf Ihre Datenspeicher hätte.

Sie sollten Ihrem Datenspeicher auch einen einzigartigen Namen geben, um Ihre Daten organisiert zu halten und um zu verhindern, dass es in verschiedenen Datenspeichern zu Überschneidungen oder Konflikten kommt. In diesem Tutorial wird der Datenspeicher für die Rangliste GlobalLeaderboard genannt.

Um den GlobalLeaderboard geordneten Datenspeicher zu erstellen:

1. Öffnen Sie das bestehende GoldManager Skript unter ServerScriptService.

   

2. Rufen Sie unter dem bestehenden PlayerGold Datenspeicher GetOrderedDataStore mit dem String "GlobalLeaderboard" auf. Dies erstellt einen geordneten Datenspeicher, um den Punktestand des Spielers zu speichern, wenn er Gold verdient.

   local leaderboardStore = DataStoreService:GetOrderedDataStore("GlobalLeaderboard")

Nachdem Sie einen Datenspeicher erstellt haben, können Sie denselben Datenspeicher in verschiedenen Skripten referenzieren. Zum Beispiel können Sie GetOrderedDataStore sowohl im GoldManager Skript als auch im LeaderboardManager Modulskript, das Sie später in diesem Tutorial erstellen werden, aufrufen. Die Referenzierung des gleichen Datenspeichers an zwei Stellen bedeutet nicht, dass Sie Daten duplizieren; es bedeutet nur, dass zwei Skripte auf denselben zentralisierten Speicher zugreifen, wie zwei Teamkollegen, die einen Ordner nutzen, um Informationen auszutauschen.

Senden Sie Spieldaten an die Rangliste

Datenspeicher bestehen aus Schlüsseln, die Daten identifizieren, und Werten, die Daten speichern. Im Gegensatz zu standardmäßigen Datenspeichern lassen geordnete Datenspeicher Sie Daten nach Wert sortieren, was sie ideal für die Erstellung von Dingen wie Ranglisten macht.

Jeder Eintrag in einem geordneten Datenspeicher wird unter einem einzigartigen Schlüssel gespeichert, den Sie numerisch rangieren und sortieren können und dann in aufsteigender oder absteigender Reihenfolge basierend auf den gespeicherten numerischen Werten abrufen können. Das bedeutet, dass Sie geordnete Datenspeicher verwenden können, um beispielsweise eine Top-3-Liste anzuzeigen, die sich in Echtzeit aktualisiert, während die Spieler in Ihrem Spiel mehr Gold sammeln.

Jetzt, da Sie Ihren GlobalLeaderboard geordneten Datenspeicher erstellt haben, aktualisieren Sie die bestehende Funktion saveGold im GoldManager Skript, um den Punktestand des Spielers an Ihre benutzerdefinierte Rangliste mit SetAsync zu senden:

local function saveGold(player, value)
  local userId = player.UserId
 
  local success, err = pcall(function()
    goldStore:SetAsync(userId, value)
   
    leaderboardStore:SetAsync(tostring(userId), value)
  end)
  if not success then
    warn("Konnte Gold für", player.Name, "nicht speichern:", err)
  end
end

Sie können an den geordneten Datenspeicher GlobalLeaderboard denken wie an einen gemeinsamen Ordner: SetAsync fügt Inhalte zu diesem Ordner hinzu, während GetSortedAsync (das Sie später im LeaderboardManager Modulskript erstellen) den Inhalt des Ordners liest und nach Punkten sortiert.

Abrufen der Ranglistenpunkte

Um die Ranglistenpunkte abzurufen, sollten Sie ein ModuleScript verwenden. Modulscripte ermöglichen es Ihnen, Ihren Code zu organisieren und an mehreren Stellen wiederzuverwenden. Anstatt die gleiche Logik an verschiedenen Stellen zu kopieren, können Sie sie einmal in einem Modulskript schreiben und von überall dort aufrufen, wo Sie sie benötigen.

Wenn Sie Ihre Ranglistenlogik in einem Modul speichern, können sowohl der UI-Handler als auch die Serverskripte dieselbe Funktion verwenden, um die besten Punktzahlen abzurufen. Wenn Sie jemals, zum Beispiel, aktualisieren müssen, wie Benutzernamen abgerufen oder wie Punktzahlen sortiert werden, müssen Sie den Code nur an einer Stelle ändern. Nachdem Sie das Modul aktualisiert haben, erhalten alle Skripte, die es verwenden, automatisch das aktualisierte Verhalten.

Ihr benutzerdefiniertes Ranglisten-Widget verwendet die folgenden Methoden des geordneten Datenspeichers, um Daten über verschiedene Server hinweg zu teilen:

• SetAsync (aus dem GoldManager Skript), um die Punktzahlen der Spieler an den GlobalLeaderboard geordneten Datenspeicher zu senden.
• GetSortedAsync (im Modulskript), um die besten Punktzahlen von allen Servern aus demselben Datenspeicher abzurufen. Die GetSortedAsync Methode ist exklusiv für geordnete Datenspeicher und kann mehrere sortierte Schlüssel basierend auf einer bestimmten Sortierreihenfolge, Seitenanzahl und minimalen und maximalen Werten abrufen.

Um die Ranglistenpunkte abzurufen:

1. Erstellen Sie unter ServerScriptService ein neues ModuleScript, das LeaderboardManager genannt wird.

2. Rufen Sie am Anfang des Modulskripts GetOrderedDataStore mit dem String "GlobalLeaderboard" auf. Die Referenzierung des gleichen geordneten Datenspeichers, den Sie im GoldManager Skript erstellt haben, ermöglicht es der Ranglisten-UI, später die besten Punktzahlen der Spieler abzurufen und zu sortieren.

   local DataStoreService = game:GetService("DataStoreService")
   local Players = game:GetService("Players")
   
   local leaderboardStore = DataStoreService:GetOrderedDataStore("GlobalLeaderboard")

3. Bereiten Sie eine Modultabelle vor, um alle Funktionen und Daten zu halten, die Sie anderen Skripten zur Verfügung stellen möchten.

   local leaderboardManager = {}

4. Erstellen Sie eine Funktion namens GetTopScores, um die besten Punktzahlen der Spieler zu erhalten. Diese Funktion:

   • Ruft GetSortedAsync auf, um die limit Anzahl der besten Punktzahlen in absteigender Reihenfolge abzurufen. Wenn der Aufruf fehlschlägt, wird eine leere Liste zurückgegeben, um zu verhindern, dass der Rest Ihres Codes abstürzt.
   • Schleift durch die Rangliste, um ein Tabelle von Einträgen mit GetCurrentPage und Spielernamen mit GetNameFromUserIdAsync zu erhalten.
   • Fügt jedes Ergebnis zu einer abschließenden Liste hinzu und erstellt eine Ranglisten-Tabelle mit Spielernamen und ihren Punkten.
   • Gibt die abschließende Liste von Spielern zurück und sendet die Ranglistendaten zurück an jedes Skript, das diese Funktion leaderboardManager.GetTopScores aufruft.

   function leaderboardManager.GetTopScores(limit)
     local success, pages = pcall(function()
       return leaderboardStore:GetSortedAsync(false, limit)
     end)
   
     if not success or not pages then
       return {}
     end
   
     local results = {}
   
     for _, entry in ipairs(pages:GetCurrentPage()) do
       local userId = tonumber(entry.key)
       local score = entry.value
       local username = "Unbekannt"
   
       local ok, name = pcall(function()
         return Players:GetNameFromUserIdAsync(userId)
       end)
   
       if ok then
         username = name
       end
   
       table.insert(results, {
         Username = username,
         Score = score
       })
     end
   
     return results
   end

5. Machen Sie das Modul verwendbar, indem Sie die Modultabelle zurückgeben, die Sie zuvor erstellt haben. Jedes Mal, wenn Sie ein Modulskript erstellen, müssen Sie die Modultabelle zurückgeben, damit andere Skripte darauf zugreifen und die Funktionen darin aufrufen können.

   return leaderboardManager

Anfordern von Ranglistendaten vom Server

Damit die Client-UI die Ranglistenpunkte anzeigen kann, muss der Server antworten, wenn der Client nach Daten fragt. Eine RemoteFunction ermöglicht es dem Client, Informationen vom Server anzufordern und auf eine Antwort zu warten.

Um Ranglistendaten vom Server anzufordern:

1. Fügen Sie unter ReplicatedStorage eine RemoteFunction hinzu, die LeaderboardRemote genannt wird. Diese Remotefunktion fungiert als Brücke zwischen dem UI-Skript auf dem Client und der Ranglistenlogik auf dem Server.
2. Erstellen Sie unter ServerScriptService ein Skript namens LeaderboardRemoteHandler. In diesem Skript:

   1. Rufen Sie ReplicatedStorage (den gemeinsamen Raum zwischen Client und Server), ServerScriptService (das das Ranglistenmodul hält) und leaderboardRemote (die remote Funktion, die der Client aufruft, um die Ranglistendaten anzufordern) auf.

      local ReplicatedStorage = game:GetService("ReplicatedStorage")
      local ServerScriptService = game:GetService("ServerScriptService")
      
      local leaderboardRemote = ReplicatedStorage:WaitForChild("LeaderboardRemote")

   2. Laden Sie das LeaderboardManager Modul, das Sie zuvor erstellt haben und das die Funktion enthält, die die Top-Punktzahlen aus dem geordneten Datenspeicher abruft.

      local leaderboardManager = require(ServerScriptService:WaitForChild("LeaderboardManager"))

   3. Legen Sie das Verhalten fest, wenn der Client InvokeServer aufruft. Der Server antwortet, indem er die Top 3 Punktzahlen abruft und das Ergebnis an den Client zurücksendet.

      leaderboardRemote.OnServerInvoke = function(player)
        return leaderboardManager.GetTopScores(3)
      end

Anzeigen von Daten in der benutzerdefinierten Ranglisten-UI

Nachdem Sie die serverseitigen Skripte eingerichtet haben, erstellen Sie ein Lokalskript, um alle 3 Sekunden die Top 3 Spieler abzurufen und die Ergebnisse in einer globalen UI-Rangliste im Spiel anzuzeigen.

Um Daten in Ihrer benutzerdefinierten Rangliste anzuzeigen:

1. Erstellen Sie unter StarterGui ⟩ LeaderboardGui ein Lokalskript namens LeaderboardGuiScript.

2. Am Anfang des Skripts verbinden Sie sich mit der Remote-Funktion. Rufen Sie ReplicatedStorage auf, um Zugang zu gemeinsamen Objekten zwischen Server und Client zu erhalten, und rufen Sie dann leaderboardRemote auf, um es dem Client zu ermöglichen, die Ranglistendaten vom Server anzufordern.

   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   local leaderboardRemote = ReplicatedStorage:WaitForChild("LeaderboardRemote")

3. Referenzieren Sie die bestehenden UI-Elemente der Rangliste unter LeaderboardGui.

   local gui = script.Parent
   local leaderboardFrame = gui:WaitForChild("LeaderboardFrame")
   local entriesFrame = leaderboardFrame:WaitForChild("EntriesFrame")
   local template = entriesFrame:WaitForChild("LeaderboardEntry")

4. Erstellen Sie eine Funktion namens clearEntries, um alte Ranglisteneinträge zu löschen. Diese Funktion durchläuft alle Kinder von entriesFrame, das die Ranglistenzeilen enthält, und stellt sicher, dass die Rangliste vollständig aktualisiert wird, bevor neue Daten angezeigt werden.

   local function clearEntries()
     for _, child in ipairs(entriesFrame:GetChildren()) do
       if child:IsA("TextLabel") and child.Name:match("^Row%d+$") then
         child:Destroy()
       end
     end
   end

5. Erstellen Sie eine Funktion namens renderLeaderboard, um Spieler Daten in den Ranglistenreihen einzufügen und anzuzeigen. Das data Objekt ist eine Tabelle, die vom Server zurückgegeben wird und Einträge mit den Spielernamen und Punktzahlen enthält.

   local function renderLeaderboard(data)
     clearEntries()
   
     for i, entry in ipairs(data) do
       local row = template:Clone()
       row.Name = "Row" .. i
       row.Visible = true
       row.LayoutOrder = i
   
       row.Text = string.format("%d%s Platz: %s - %d",
         i, i == 1 and "st" or i == 2 and "nd" or i == 3 and "rd" or "th",
         entry.Username, entry.Score)
   
       row.Parent = entriesFrame
     end
   end

6. Erstellen Sie eine Schleife, um die Ranglistendaten regelmäßig abzurufen. Alle 3 Sekunden wird die Schleife ausgeführt und der Server mit der Funktion InvokeServer aufgerufen, die Sie zuvor im Skript LeaderboardRemoteHandler erstellt haben. Wenn der Aufruf erfolgreich ist, wird die UI mit den aktualisierten Punktzahlen aktualisiert.

   while true do
     local success, data = pcall(function()
       return leaderboardRemote:InvokeServer()
     end)
   
     if success and data then
       renderLeaderboard(data)
     end
   
     task.wait(3)
   end

Abschlusscode

Siehe die folgenden Codeschnipsel für die vollständigen GoldManager, LeaderboardManager, LeaderboardRemoteHandler und LeaderboardGuiScript Skripte. Sie können sie direkt in der Gold Rush Ranglisten-Tutorial - Start .rbxl Datei im Studio einfügen und ausführen.

GoldManager

Das GoldManager Skript erstellt einen geordneten Datenspeicher zur Verwaltung der Aktualisierungen der Rangliste.

-- Dienste abrufen
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local CollectionService = game:GetService("CollectionService")
local DataStoreService = game:GetService("DataStoreService")

-- Remote-Ereignis zum Aktualisieren der UI
local uiEvent = ReplicatedStorage:WaitForChild("UIEvent")

-- Datenspeicher zum Speichern der Goldstücke des Spielers
local goldStore = DataStoreService:GetDataStore("PlayerGold")

-- Geordneter Datenspeicher zum Speichern von Gold in der Rangliste
local leaderboardStore = DataStoreService:GetOrderedDataStore("GlobalLeaderboard")

-- Erstellen Sie einen Zufallszahlengenerator für die Positionierung von Goldstücken
local random = Random.new()

-- Tabelle zum Speichern der Goldstücke des Spielers für eine einzelne Sitzung
local playerGold = {}

-- Konstanten
local GOLD_VALUE = 10                  -- Wie viel jedes Goldstück wert ist
local GOLD_REGENERATION_BOUNDS = {     -- Gebietsgrenzen, die verwendet werden, um Goldstücke zufällig neu zu positionieren
  minX = -72,
  maxX = 72,
  minZ = -72,
  maxZ = 72
}
local GOLD_REGEN_DELAY = 2             -- Die Verzögerung, bevor ein Stück neu erscheint (in Sekunden)
local AUTOSAVE_INTERVAL = 30           -- Wie oft die Goldstücke des Spielers gespeichert werden (in Sekunden)

-- Funktion zum Verarbeiten des Berührens eines Goldstücks durch den Spieler
local function processGoldTouch(chunk, player)

  -- Verstecken Sie das Stück, wenn der Spieler es sammelt
  chunk.Parent = nil

  -- Fügen Sie das Stück zum Goldpunktestand des Spielers in dieser Sitzung hinzu
  local userId = player.UserId
  playerGold[userId] = (playerGold[userId] or 0) + GOLD_VALUE
  print(player.Name, "hat jetzt", playerGold[userId], "Gold")

  -- Aktualisieren Sie die UI-Punktzahl, um den neuen Goldpunktestand für diese Sitzung widerzuspiegeln
  uiEvent:FireClient(player, {
    gold = playerGold[userId],
    doTween = true,
    showAlert = false
  })

  -- Warten Sie eine Weile und erscheinen Sie dann das Goldstück, das gerade gesammelt wurde, an einem zufälligen Ort wieder
  task.delay(GOLD_REGEN_DELAY, function()

    -- Erscheinen Sie das Goldstück an einer neuen zufälligen Position neu
    local nextPositionX = random:NextInteger(GOLD_REGENERATION_BOUNDS.minX, GOLD_REGENERATION_BOUNDS.maxX)
    local nextPositionZ = random:NextInteger(GOLD_REGENERATION_BOUNDS.minZ, GOLD_REGENERATION_BOUNDS.maxZ)
    chunk.CFrame = CFrame.new(nextPositionX, 50, nextPositionZ) -- Bewegen Sie das Stück an die neue Position
    chunk:SetAttribute("DropCollided", false)  -- Setzen Sie alle Kollisionsflags zurück
    chunk.Parent = workspace.GoldChunks
  end)
end

-- Durchlaufen Sie alle Teile, die mit "Gold" gekennzeichnet sind, und verbinden Sie sie mit der Berührungserkennung
for _, chunk in ipairs(CollectionService:GetTagged("Gold")) do
  chunk.Touched:Connect(function(otherPart)
    local player = Players:GetPlayerFromCharacter(otherPart.Parent)
    if player then
      processGoldTouch(chunk, player)
    end
  end)
end

-- Funktion zum Speichern des Gold des Spielers in sowohl dem standardmäßigen als auch dem geordneten Datenspeicher
local function saveGold(player, value)
  local userId = player.UserId
  local success, err = pcall(function()
    goldStore:SetAsync(userId, value)
    leaderboardStore:SetAsync(tostring(userId), value)
  end)
  if not success then
    warn("Konnte Gold für", player.Name, "nicht speichern:", err)
  end
end

-- Funktion zur Behandlung des Beitritts des Spielers zum Spiel
local function onPlayerAdded(player)
  local userId = player.UserId
  print(player.Name, "hat dem Spiel beigetreten")

  -- Versuchen Sie, das Gold des Spielers aus dem Datenspeicher zu laden
  local success, storedGold = pcall(function()
    return goldStore:GetAsync(userId)
  end)

  -- Setzen Sie den aktuellen Goldpunktestand mit dem Wert aus dem Datenspeicher für den Spieler
  local currentGold = if success and storedGold then storedGold else 0
  playerGold[userId] = currentGold

  -- Aktualisieren Sie die UI mit dem Wert aus dem Datenspeicher für den Spieler
  uiEvent:FireClient(player, {
    gold = currentGold,
    doTween = false,
    showAlert =  not success
  })
  if success then
    print("Geladen", currentGold, "Gold für", player.Name)
  else

    -- Benachrichtigen Sie den Spieler, dass sein Gold nicht geladen werden konnte
    uiEvent:FireClient(player, { showAlert = true })
    warn("Konnte Gold für", player.Name, "nicht laden")
  end

  -- Starten Sie die Autosave-Koroutine, um das Gold des Spielers alle 30 Sekunden zu speichern
  coroutine.wrap(function()
    while player.Parent do
      task.wait(AUTOSAVE_INTERVAL)
      if playerGold[userId] then
        saveGold(player, playerGold[userId])
        print("Automatisches Speichern von", playerGold[userId], "Gold für", player.Name)
      end
    end
  end)()
end

-- Funktion zur Behandlung des Verlassens des Spielers aus dem Spiel
local function onPlayerRemoving(player)
  local userId = player.UserId
  print(player.Name, "hat das Spiel verlassen")

  -- Überprüfen Sie, ob das Gold des Spielers verfolgt wurde
  if playerGold[userId] then

    -- Speichern Sie das Gold des Spielers im Datenspeicher, bevor er geht
    saveGold(player, playerGold[userId])
  end
end

-- Verbinden Sie die Ereignisse für das Beitreten und Verlassen von Spielern
Players.PlayerAdded:Connect(onPlayerAdded)
Players.PlayerRemoving:Connect(onPlayerRemoving)

LeaderboardManager

Das LeaderboardManager Modulskript:

• Ruft GetSortedAsync() auf dem GlobalLeaderboard geordneten Datenspeicher auf.
• Konvertiert Benutzer-IDs in Benutzernamen, indem es GetNameFromUserIdAsync verwendet.
• Gibt eine Liste von { Username, Score } Tabellen für die bestplatzierten Spieler zurück.
• Wird von LeaderboardRemoteHandler aufgerufen, wann immer ein Client Ranglistendaten anfordert.

-- Dienste abrufen
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

-- Geordneter Datenspeicher zum Speichern der Ranglistenpunkte
local leaderboardStore = DataStoreService:GetOrderedDataStore("GlobalLeaderboard")

-- Tabelle zum Speichern der Ranglistenpunkte
local leaderboardManager = {}

-- Funktion zum Zurückgeben der besten Punkte
function leaderboardManager.GetTopScores(limit)
	-- Versuchen Sie, eine sortierte Seite von Ranglisteneinträgen aus dem Datenspeicher abzurufen
	local success, pages = pcall(function()
		-- false = absteigend (höchste Punkte zuerst)
		return leaderboardStore:GetSortedAsync(false, limit)
	end)

	-- Wenn der Aufruf fehlschlägt oder nichts zurückgibt, protokollieren Sie eine Warnung und geben Sie eine leere Tabelle zurück
	if not success or not pages then
		warn("Fehler beim Abrufen der Ranglistendaten")
		return {}
	end

	-- Erstellen Sie eine Tabelle zum Speichern der besten Spielern
	local topPlayers = {}

	-- Schleife durch jeden Eintrag auf der aktuellen Seite der Ranglistenergebnisse
	for _, entry in ipairs(pages:GetCurrentPage()) do
		local userId = tonumber(entry.key)   -- Konvertieren Sie den Eintrags-Schlüssel in eine Zahl (userId wurde als String gespeichert)
		local score = entry.value            -- Der Wert ist die Punktzahl des Spielers (Menge an Gold)
		local username = "Unbekannt"           -- Ein Standardname für den Fall, dass die Suche fehlschlägt

		-- Versuchen Sie, den Benutzernamen des Spielers aus seiner userId zu erhalten
		local ok, name = pcall(function()
			return Players:GetNameFromUserIdAsync(userId)
		end)

		-- Wenn die Suche erfolgreich ist, speichern Sie den echten Benutzernamen
		if ok then
			username = name
		end

		-- Fügen Sie diesen Spieler und seine Punkte zur Liste hinzu
		table.insert(topPlayers, {
			Username = username,
			Score = score
		})
	end

	-- Geben Sie die gesamte Liste der besten Spieler mit ihren Benutzernamen und Punkten zurück
	return topPlayers
end

-- Geben Sie das LeaderboardManager Modul zurück, damit andere Skripte es verwenden können
return leaderboardManager

LeaderboardRemoteHandler

Das LeaderboardRemoteHandler Skript ruft die besten 3 Punkte ab und gibt sie an den anrufenden Client zurück.

-- Dienste abrufen
local ServerScriptService = game:GetService("ServerScriptService")  -- Zugriff auf serverseitige Module
local ReplicatedStorage = game:GetService("ReplicatedStorage")      -- Gemeinsame Objekte für die Kommunikation zwischen Client und Server

-- Warten Sie auf die RemoteFunction, die der Client verwendet, um Ranglistendaten anzufordern
local leaderboardRemote = ReplicatedStorage:WaitForChild("LeaderboardRemote")

-- Laden Sie das LeaderboardManager Modul, das die GetTopScores Funktion enthält
local leaderboardManager = require(ServerScriptService:WaitForChild("LeaderboardManager"))

-- Richten Sie einen Handler ein, wenn der Client die Ranglisten RemoteFunction aufruft
leaderboardRemote.OnServerInvoke = function(player)
	-- Rufen Sie das Ranglistenmodul auf, um die besten 3 Punkte zu erhalten und geben Sie sie an den Client zurück
	return leaderboardManager.GetTopScores(3)
end

LeaderboardGuiScript

Das LeaderboardGuiScript Lokalskript:

• Fordert alle 3 Sekunden Ranglistendaten vom Server an, indem es Class.RemoteHandler.InvokeServer|InvokeServer verwendet.
• Verwendet eine versteckte Ranglisten-Eintragvorlage, um jede Ranglistenreihe anzuzeigen.
• Formatiert jede Reihe als "1. Platz: Benutzername - Punktzahl".
• Verwaltet das Erstellen, Anzeigen und Anordnen der Ranglistenreihen mittels UIListLayout.

-- Gemeinsamen Speicher für RemoteFunction-Zugriff abrufen
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Holen Sie sich die RemoteFunction, die verwendet wird, um Ranglistendaten vom Server anzufordern
local leaderboardRemote = ReplicatedStorage:WaitForChild("LeaderboardRemote")

-- UI-Referenzen
local gui = script.Parent                                           -- Das LocalScript unter dem ScreenGui
local leaderboardFrame = gui:WaitForChild("LeaderboardFrame")       -- Hauptcontainer für die Rangliste
local entriesFrame = leaderboardFrame:WaitForChild("EntriesFrame")  -- Frame, in dem Ranglisteneinträge erscheinen
local template = entriesFrame:WaitForChild("LeaderboardEntry")      -- Versteckte Vorlagen-TextLabel, die zur Erstellung von Reihen verwendet wird

-- Funktion zum Entfernen alter Ranglistenreihen (aber nicht die Vorlage)
local function clearEntries()
	for _, child in ipairs(entriesFrame:GetChildren()) do
		-- Zerstören Sie nur Labels mit den Namen "Row1", "Row2" usw. (lassen Sie die Vorlage unverändert)
		if child:IsA("TextLabel") and child.Name:match("^Row%d+$") then
			child:Destroy()
		end
	end
end

-- Funktion zum Anzeigen von Ranglistendaten auf dem Bildschirm
local function renderLeaderboard(data)
	-- Entfernen Sie zuerst alte Reihen
	clearEntries()

	for i, entry in ipairs(data) do
		local row = template:Clone()           -- Klonen Sie die versteckte Vorlage
		row.Name = "Row" .. i                  -- Geben Sie ihm einen einzigartigen Namen
		row.Visible = true                     -- Machen Sie es sichtbar
		row.LayoutOrder = i                    -- Lassen Sie das UIListLayout es ordentlich anordnen

		-- Ranglistenformat: "1. Platz: Benutzername - 123"
		row.Text = string.format("%d%s Platz: %s - %d",
			i,
			i == 1 and "st" or i == 2 and "nd" or i == 3 and "rd" or "th",
			entry.Username,
			entry.Score
		)

		-- Fügen Sie die Daten zur UI hinzu
		row.Parent = entriesFrame
	end
end

-- Hauptschleife: aktualisieren Sie die Rangliste alle 3 Sekunden
while true do
	-- Fragen Sie den Server nach Ranglistendaten
	local success, data = pcall(function()
		return leaderboardRemote:InvokeServer()
	end)

	if success and data then
		-- Zeigen Sie die Ergebnisse in der Rangliste an
		renderLeaderboard(data)
	else
		warn("Fehler beim Abrufen der Ranglistendaten")
	end

	-- Warten Sie 3 Sekunden, bevor Sie erneut aktualisieren
	task.wait(3)
end