Stwórz niestandardowy ranking z uporządkowanymi bazami danych

Bazy danych są usługą, którą możesz wykorzystać do zapisywania i ładowania trwałych danych gracza w różnych sesjach. Przechowują ważne informacje, takie jak postępy gracza lub jego ekwipunek, i pozwalają na ich pobranie przy następnym dołączeniu do twojej gry. Bez baz danych gracz traciłby wszystkie swoje postępy za każdym razem, gdy opuszczał grę.

Istnieją dwa typy baz danych: standardowe i uporządkowane. Ten samouczek wykorzystuje uporządkowane bazy danych, które przechowują dane, które możnaporządkować i sortować numerycznie oraz pobrać w kolejności rosnącej lub malejącej w zależności od przechowywanych wartości numerycznych.

Używając pliku Gold Rush create leaderboard tutorial - Start .rbxl jako miejsca początkowego oraz pliku Gold Rush create leaderboard tutorial - Complete .rbxl jako odniesienia, ten samouczek daje ci podstawy do stworzenia niestandardowego rankingu graczy, w tym wskazówki dotyczące:

• Przechowywania wyników złota w uporządkowanej bazie danych.
• Pobierania i sortowania najwyższych wyników globalnie we wszystkich serwerach.
• Wyświetlania najwyższych wyników w niestandardowym rankingu w UI.
• Automatycznego odświeżania niestandardowego rankingu co kilka sekund.

Pod koniec tego samouczka powinieneś mieć następujące:

1. W ServerScriptService:

   1. Zaktualizowany skrypt GoldManager, który zapisuje wynik gracza w uporządkowanej bazie danych przeznaczonej dla rankingu.
   2. Nowy skrypt modułowy LeaderboardRemoteHandler, który pobiera i zwraca posortowaną listę najwyższych wyników z rankingu.
   3. Nowy skrypt LeaderboardManager, który odpowiada na zapytania o dane z rankingu od klienta, działając jako pomost między klientem w LeaderboardGuiScript a serwerem w LeaderboardManager.
2. W StarterGui, nowy lokalny skrypt LeaderboardGuiScript, który renderuje UI rankingu dla gracza.

Włącz dostęp Studio do usług API

Bazy danych nie są przechowywane lokalnie na twoim urządzeniu, więc twoja gra polega na komunikacji między serwerami z backendem Roblox, aby móc ich używać. Domyślnie Studio ogranicza tę komunikację, aby zapobiec nadużyciom lub przypadkowemu użyciu. Dostęp do usług API w Studio jest wyłączony, dopóki nie włączysz go wyraźnie, aby upewnić się, że tylko zaufane gry mogą odczytywać i zapisywać dane na serwerach backendowych Roblox.

Aby włączyć dostęp Studio do usług API, abyś mógł używać baz danych:

1. Otwórz plik Gold Rush create leaderboard tutorial - Start w Studio. Ten plik z miejscem początkowym już zawiera kod z samouczka Zapisz dane gracza oraz szkielet UI dla rankingu gracza.
2. Opublikuj swoją grę.
3. Wróć do Studio, przejdź do Plik ⟩ Ustawienia doświadczenia ⟩ Bezpieczeństwo.
4. Włącz Włącz dostęp Studio do usług API.
5. Zapisz swoje zmiany.

Stwórz uporządkowaną bazę danych

Podczas tworzenia bazy danych powinieneś zawsze wywoływać DataStoreService z serwerowego Script. Jest to ważne, ponieważ:

• Roblox blokuje cały dostęp do bazy danych z klienta, dzięki czemu tylko serwer ma pozwolenie na dostęp i modyfikację trwałych danych gracza.
• Skrypty serwerowe działają w zcentralizowanym środowisku, zapewniając, że odczytywane i zapisywane dane w twojej bazie danych są dokładne i ważne.
• Ponieważ skrypty klienckie działają na urządzeniu gracza, każdy gracz mógłby potencjalnie wykorzystać grę do kradzieży lub nadpisania danych innych graczy, jeśli klient miałby dostęp do twoich baz danych.

Powinieneś także nadać swojej bazie danych unikalną nazwę, aby utrzymać swoje dane w porządku i zapobiec ich nakładaniu się lub konfliktom w różnych bazach danych. W tym samouczku baza danych dla rankingu nazywa się GlobalLeaderboard.

Aby stworzyć uporządkowaną bazę danych GlobalLeaderboard:

1. Otwórz istniejący skrypt GoldManager w ServerScriptService.

   

2. Pod istniejącą bazą danych PlayerGold, wywołaj GetOrderedDataStore z ciągiem "GlobalLeaderboard". To tworzy uporządkowaną bazę danych do zapisywania wyniku gracza, gdy zdobywa złoto.

   local leaderboardStore = DataStoreService:GetOrderedDataStore("GlobalLeaderboard")

Po utworzeniu bazy danych możesz odwoływać się do tej samej bazy danych w różnych skryptach. Na przykład możesz wywołać GetOrderedDataStore zarówno w skrypcie GoldManager, jak i w skrypcie modułowym LeaderboardManager, który stworzysz później w tym samouczku. Odwoływanie się do tej samej bazy danych w dwóch miejscach nie oznacza, że duplikujesz dane; oznacza to tylko, że dwa skrypty uzyskują dostęp do tej samej scentralizowanej pamięci, jak dwa członkowie zespołu korzystający z jednego folderu do dzielenia się informacjami.

Wyślij dane gracza do rankingu

Bazy danych składają się z kluczy, które identyfikują dane, oraz wartości, które przechowują dane. W przeciwieństwie do standardowych baz danych, uporządkowane bazy danych pozwalają na sortowanie danych według wartości, co czyni je idealnymi do tworzenia takich rzeczy jak rankingi.

Każdy wpis w uporządkowanej bazie danych przechowywany jest pod unikalnym kluczem, który można sortować numerycznie i następnie pobierać w kolejności rosnącej lub malejącej w zależności od przechowywanych wartości numerycznych. Oznacza to, że możesz użyć uporządkowanych baz danych, aby na przykład pokazać listę najlepszych 3, która aktualizuje się w czasie rzeczywistym, gdy gracze w twojej grze zdobywają więcej złota.

Teraz, gdy stworzyłeś swoją uporządkowaną bazę danych GlobalLeaderboard, zaktualizuj istniejącą funkcję saveGold w skrypcie GoldManager, aby wysłać wynik złota gracza do twojego niestandardowego rankingu za pomocą SetAsync:

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("Nie udało się zapisać złota dla", player.Name, ":", err)
  end
end

Możesz myśleć o uporządkowanej bazie danych GlobalLeaderboard jak o wspólnym folderze: SetAsync dodaje zawartość do folderu, podczas gdy GetSortedAsync (który stworzysz później w skrypcie modułowym LeaderboardManager) odczytuje zawartość folderu i sortuje ją według wyniku.

Pobierz wyniki rankingu

Aby pobrać wyniki rankingu, powinieneś użyć ModuleScript. Skrypty modułowe pozwalają ci zorganizować i ponownie wykorzystać swój kod w wielu skryptach. Zamiast kopiować tę samą logikę w różnych miejscach, możesz napisać ją raz w skrypcie modułowym i wywołać stamtąd, gdzie tylko jest potrzebna.

Gdy przechowujesz logikę swojego rankingu w module, zarówno obsługa UI, jak i skrypty serwerowe mogą korzystać z tej samej funkcji do pobierania wyników najlepszych graczy. Jeśli kiedykolwiek będziesz musiał na przykład zaktualizować sposób pobierania nazw użytkowników lub sortowania wyników, wystarczy, że zmienisz kod w jednym miejscu. Po aktualizacji modułu, wszystkie skrypty, które go używają, automatycznie uzyskają zaktualizowane zachowanie.

Twój niestandardowy ranking wykorzystuje następujące metody uporządkowanej bazy danych do dzielenia się danymi w różnych serwerach:

• SetAsync (z skryptu GoldManager) do przesyłania wyników graczy do uporządkowanej bazy danych GlobalLeaderboard.
• GetSortedAsync (w skrypcie modułowym) do pobierania najwyższych wyników z wszystkich serwerów z tej samej bazy danych. Metoda GetSortedAsync jest ekskluzywna dla uporządkowanych baz danych i może pobierać wiele posortowanych kluczy w oparciu o konkretną kolejność sortowania, rozmiar strony oraz minimalne i maksymalne wartości.

Aby pobrać wyniki rankingu:

1. W ServerScriptService, utwórz nowy ModuleScript o nazwie LeaderboardManager.

2. Na początku skryptu modułowego wywołaj GetOrderedDataStore z ciągiem "GlobalLeaderboard". Odwoływanie się do tej samej uporządkowanej bazy danych, którą stworzyłeś w skrypcie GoldManager, umożliwi UI rankingu pobranie i posortowanie najwyższych wyników graczy później.

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

3. Przygotuj tabelę modułu, aby przechować wszystkie funkcje i dane, które chcesz udostępnić innym skryptom.

   local leaderboardManager = {}

4. Stwórz funkcję o nazwie GetTopScores, aby uzyskać najwyższe wyniki graczy. Ta funkcja:

   • Wywołuje GetSortedAsync, aby pobrać limit najwyższych wyników w porządku malejącym. Jeśli wywołanie się nie powiedzie, zwracana jest pusta lista, aby zapobiec awarii reszty kodu.
   • Przechodzi przez ranking, aby uzyskać tabelę wpisów za pomocą GetCurrentPage i nazwy użytkowników graczy za pomocą GetNameFromUserIdAsync.
   • Dodaje każdy wynik do ostatecznej listy i buduje tabelę rankingu z nazwami użytkowników graczy i ich wynikami.
   • Zwraca ostateczną listę graczy i przesyła dane z rankingu z powrotem do każdego skryptu, który wywołuje tę funkcję leaderboardManager.GetTopScores.

   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 = "Unknown"
   
        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. Uczyń moduł użytecznym, zwracając tabelę modułu, którą stworzyłeś wcześniej. Kiedy tworzysz skrypt modułowy, zawsze musisz zwrócić tabelę modułu, aby inne skrypty miały do niej dostęp i mogły wywoływać funkcje w niej zawarte.

   return leaderboardManager

Żądanie danych rankingu z serwera

Aby interfejs użytkownika klienta mógł wyświetlić wyniki rankingu, serwer musi odpowiedzieć, gdy klient poprosi o dane. RemoteFunction pozwala klientowi na żądanie informacji z serwera i czekanie na odpowiedź.

Aby żądać danych rankingu z serwera:

1. W ReplicatedStorage, wstaw RemoteFunction o nazwie LeaderboardRemote. Ta zdalna funkcja działa jako pomost między skryptem UI na kliencie a logiką rankingu na serwerze.
2. W ServerScriptService, utwórz skrypt o nazwie LeaderboardRemoteHandler. W tym skrypcie:

   1. Wywołaj ReplicatedStorage (wspólna przestrzeń między klientem a serwerem), ServerScriptService (który zawiera moduł rankingu) i leaderboardRemote (zdalną funkcję, którą klient wywoła, aby poprosić o dane rankingu).

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

   2. Załaduj moduł LeaderboardManager, który stworzyłeś wcześniej i który zawiera funkcję, która pobiera najwyższe wyniki z uporządkowanej bazy danych.

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

   3. Ustaw zachowanie, gdy klient wywołuje InvokeServer. Serwer odpowiada, pobierając 3 najwyższe wyniki i przesyłając rezultat z powrotem do klienta.

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

Wyświetlanie danych w niestandardowym interfejsie rankingu

Po skonfigurowaniu skryptów po stronie serwera stwórz lokalny skrypt, aby pobierać 3 najlepszych graczy co 3 sekundy i wyświetlać wyniki w globalnym UI rankingu w grze.

Aby wyświetlić dane w swoim niestandardowym rankingu:

1. W StarterGui ⟩ LeaderboardGui, utwórz lokalny skrypt o nazwie LeaderboardGuiScript.

2. Na początku skryptu, połącz się z zdalną funkcją. Wywołaj ReplicatedStorage, aby uzyskać dostęp do wspólnych obiektów między serwerem a klientem, a następnie wywołaj leaderboardRemote, aby pozwolić klientowi na żądanie danych rankingu z serwera.

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

3. Odwołaj się do istniejących elementów UI rankingu w LeaderboardGui.

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

4. Stwórz funkcję o nazwie clearEntries, aby usunąć stare wpisy w rankingu. Ta funkcja przeszukuje wszystkie dzieci entriesFrame, które zawierają wiersze rankingu, i upewnia się, że ranking jest całkowicie odświeżany przed wyświetleniem nowych danych.

   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. Stwórz funkcję o nazwie renderLeaderboard, aby wstawić i wyświetlić dane gracza w wierszach rankingu. Obiekt data to tabela zwrócona przez serwer, która zawiera wpisy z nazwami użytkowników graczy i wynikami.

   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 miejsce: %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. Stwórz pętlę, aby okresowo pobierać dane z rankingu. Co 3 sekundy pętla uruchamia się i wywołuje serwer za pomocą funkcji InvokeServer, którą stworzyłeś wcześniej w skrypcie LeaderboardRemoteHandler. Jeśli wywołanie powiedzie się, UI odświeża się z aktualnymi wynikami.

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

Ostateczny kod

Zobacz poniższe fragmenty kodu dla kompletnych skryptów GoldManager, LeaderboardManager, LeaderboardRemoteHandler oraz LeaderboardGuiScript. Możesz je wkleić i uruchomić bezpośrednio w pliku Gold Rush create leaderboard tutorial - Start .rbxl w Studio.

GoldManager

Skrypt GoldManager tworzy uporządkowaną bazę danych do zarządzania aktualizacjami rankingu.

-- Pobierz usługi
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local CollectionService = game:GetService("CollectionService")
local DataStoreService = game:GetService("DataStoreService")

-- Zdalne zdarzenie do aktualizacji UI
local uiEvent = ReplicatedStorage:WaitForChild("UIEvent")

-- Baza danych do zapisywania złotej liczby gracza
local goldStore = DataStoreService:GetDataStore("PlayerGold")

-- Uporządkowana baza danych do zapisywania złota w rankingu
local leaderboardStore = DataStoreService:GetOrderedDataStore("GlobalLeaderboard")

-- Stwórz generator losowych liczb do pozycjonowania złotych kawałków
local random = Random.new()

-- Tabela do przechowywania złotych kawałków gracza podczas jednej sesji
local playerGold = {}

-- Stałe
local GOLD_VALUE = 10                  -- Ile warte jest każdy kawałek złota
local GOLD_REGENERATION_BOUNDS = {     -- Granice obszarów używanych do ponownego położenia złotych kawałków losowo
  minX = -72,
  maxX = 72,
  minZ = -72,
  maxZ = 72
}
local GOLD_REGEN_DELAY = 2             -- Opóźnienie przed ponownym pojawieniem się kawałka (w sekundach)
local AUTOSAVE_INTERVAL = 30           -- Jak często złote kawałki gracza są zapisywane (w sekundach)

-- Funkcja do obsługi zbierania kawałka złota przez gracza
local function processGoldTouch(chunk, player)

  -- Ukryj kawałek, gdy gracz go zbiera
  chunk.Parent = nil

  -- Dodaj kawałek do wyniku złota sesji gracza
  local userId = player.UserId
  playerGold[userId] = (playerGold[userId] or 0) + GOLD_VALUE
  print(player.Name, "ma teraz", playerGold[userId], "złota")

  -- Zaktualizuj pasek wyniku w UI, aby odzwierciedlić nowy wynik złota za ten okres
  uiEvent:FireClient(player, {
    gold = playerGold[userId],
    doTween = true,
    showAlert = false
  })

  -- Poczekaj chwilę, a następnie ponownie pojaw się kawałek złota, który właśnie został zebrany, w losowej lokalizacji
  task.delay(GOLD_REGEN_DELAY, function()

    -- Ponownie pojaw się kawałek złota w nowej losowej pozycji
    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) -- Przesuń kawałek do nowej pozycji
    chunk:SetAttribute("DropCollided", false)  -- Zresetuj wszelkie flagi kolizji
    chunk.Parent = workspace.GoldChunks
  end)
end

-- Pętla przez wszystkie części oznaczone jako "Gold" i połącz je z wykrywaniem dotyku
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

-- Funkcja do zapisywania złota gracza w standardowych i uporządkowanych bazach danych
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("Nie udało się zapisać złota dla", player.Name, ":", err)
  end
end

-- Funkcja do obsługi dołączenia gracza do gry
local function onPlayerAdded(player)
  local userId = player.UserId
  print(player.Name, "dołączył do gry")

  -- Spróbuj załadować złoto gracza z bazy danych
  local success, storedGold = pcall(function()
    return goldStore:GetAsync(userId)
  end)

  -- Ustaw aktualny wynik złota sesji, używając wartości z bazy danych dla gracza
  local currentGold = if success and storedGold then storedGold else 0
  playerGold[userId] = currentGold

  -- Zaktualizuj UI z wartością z bazy danych dla gracza
  uiEvent:FireClient(player, {
    gold = currentGold,
    doTween = false,
    showAlert =  not success
  })
  if success then
    print("Załadowano", currentGold, "złota dla", player.Name)
  else

    -- Powiadom gracza, że jego złoto nie mogło zostać załadowane
    uiEvent:FireClient(player, { showAlert = true })
    warn("Nie udało się załadować złota dla", player.Name)
  end

  -- Rozpocznij współbieżną funkcję automatycznego zapisywania złota gracza co 30 sekund
  coroutine.wrap(function()
    while player.Parent do
      task.wait(AUTOSAVE_INTERVAL)
      if playerGold[userId] then
        saveGold(player, playerGold[userId])
        print("Automatycznie zapisano", playerGold[userId], "złota dla", player.Name)
      end
    end
  end)()
end

-- Funkcja do obsługi opuszczenia gry przez gracza
local function onPlayerRemoving(player)
  local userId = player.UserId
  print(player.Name, "opuścił grę")

  -- Sprawdzenie, czy złoto gracza było śledzone
  if playerGold[userId] then

    -- Zapisz złoto gracza w bazie danych przed jego wyjściem
    saveGold(player, playerGold[userId])
  end
end

-- Połącz zdarzenia dołączania i opuszczania gracza
Players.PlayerAdded:Connect(onPlayerAdded)
Players.PlayerRemoving:Connect(onPlayerRemoving)

LeaderboardManager

Skrypt modułowy LeaderboardManager:

• Wywołuje GetSortedAsync() na uporządkowanej bazie danych GlobalLeaderboard.
• Przekształca identyfikatory użytkowników w nazwy użytkowników za pomocą GetNameFromUserIdAsync.
• Zwraca listę tabel { Username, Score } dla najlepszych graczy.
• Jest wywoływana przez LeaderboardRemoteHandler, gdy klient żąda danych rankingu.

-- Pobierz usługi
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

-- Uporządkowana baza danych do zapisywania wyników rankingu
local leaderboardStore = DataStoreService:GetOrderedDataStore("GlobalLeaderboard")

-- Tabela do przechowywania wyników rankingu
local leaderboardManager = {}

-- Funkcja do zwracania najwyższych wyników
function leaderboardManager.GetTopScores(limit)
	-- Spróbuj pobrać posortowaną stronę wpisów rankingu z bazy danych
	local success, pages = pcall(function()
		-- false = malejąco (najwyższe wyniki jako pierwsze)
		return leaderboardStore:GetSortedAsync(false, limit)
	end)

	-- Jeśli wywołanie zakończy się niepowodzeniem lub zwróci nic, zaloguj ostrzeżenie i zwróć pustą tabelę
	if not success or not pages then
		warn("Nie udało się pobrać danych rankingu")
		return {}
	end

	-- Utwórz tabelę do przechowywania danych najlepszych graczy
	local topPlayers = {}

	-- Przejdź przez każdy wpis na aktualnej stronie wyników rankingu
	for _, entry in ipairs(pages:GetCurrentPage()) do
		local userId = tonumber(entry.key)   -- Przekształć klucz wpisu na liczbę (identyfikator użytkownika jest przechowywany jako ciąg)
		local score = entry.value            -- Wartość to wynik gracza (ilość złota)
		local username = "Unknown"           -- Domyślna nazwa w przypadku niepowodzenia wyszukiwania

		-- Spróbuj uzyskać nazwę użytkownika gracza z jego identyfikatora użytkownika
		local ok, name = pcall(function()
			return Players:GetNameFromUserIdAsync(userId)
		end)

		-- Jeśli wyszukiwanie się powiodło, przechowaj prawdziwą nazwę użytkownika
		if ok then
			username = name
		end

		-- Dodaj tego gracza i jego wynik do listy
		table.insert(topPlayers, {
			Username = username,
			Score = score
		})
	end

	-- Zwróć pełną listę najlepszych graczy z ich nazwami użytkowników i wynikami
	return topPlayers
end

-- Zwróć moduł LeaderboardManager, aby inne skrypty mogły go używać
return leaderboardManager

LeaderboardRemoteHandler

Skrypt LeaderboardRemoteHandler pobiera i z powrotem zwraca najlepsze 3 wyniki do wywołującego klienta.

-- Pobierz usługi
local ServerScriptService = game:GetService("ServerScriptService")  -- Dostęp do modułów po stronie serwera
local ReplicatedStorage = game:GetService("ReplicatedStorage")      -- Wspólne obiekty komunikacyjne między klientem a serwerem

-- Czekaj na RemoteFunction, którego klient używa do żądania danych rankingu
local leaderboardRemote = ReplicatedStorage:WaitForChild("LeaderboardRemote")

-- Załaduj moduł LeaderboardManager, który zawiera funkcję GetTopScores
local leaderboardManager = require(ServerScriptService:WaitForChild("LeaderboardManager"))

-- Ustaw handler dla sytuacji, gdy klient wywołuje zdalną funkcję rankingu
leaderboardRemote.OnServerInvoke = function(player)
	-- Wywołaj moduł rankingu, aby uzyskać 3 najwyższe wyniki i zwrócić je do klienta
	return leaderboardManager.GetTopScores(3)
end

LeaderboardGuiScript

Lokalny skrypt LeaderboardGuiScript:

• Żąda danych rankingu z serwera co 3 sekundy za pomocą Class.RemoteHandler.InvokeServer|InvokeServer.
• Używa ukrytego szablonu LeaderboardEntry do wyświetlania każdego wiersza rankingu.
• Formatuje każdy wiersz jako "1. miejsce: Nazwa użytkownika - Wynik".
• Zarządza tworzeniem, wyświetlaniem i układem wierszy rankingu za pomocą UIListLayout.

-- Pobierz wspólną pamięć dla dostępu do zdalnej funkcji
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Pobierz zdalną funkcję wykorzystywaną do żądania danych rankingu od serwera
local leaderboardRemote = ReplicatedStorage:WaitForChild("LeaderboardRemote")

-- Odniesienia do UI
local gui = script.Parent                                           -- LocalScript pod ScreenGui
local leaderboardFrame = gui:WaitForChild("LeaderboardFrame")       -- Główny kontener dla rankingu
local entriesFrame = leaderboardFrame:WaitForChild("EntriesFrame")  -- Ramka, w której pojawiają się wpisy w rankingu
local template = entriesFrame:WaitForChild("LeaderboardEntry")      -- Ukryty szablon TextLabel wykorzystywany do tworzenia wierszy

-- Funkcja do usunięcia starych wierszy rankingu (ale nie szablonu)
local function clearEntries()
	for _, child in ipairs(entriesFrame:GetChildren()) do
		-- Zabij tylko etykiety o nazwach "Row1", "Row2", itd. (zostaw szablon nietknięty)
		if child:IsA("TextLabel") and child.Name:match("^Row%d+$") then
			child:Destroy()
		end
	end
end

-- Funkcja do wyświetlania danych rankingu na ekranie
local function renderLeaderboard(data)
	-- Najpierw usuń stare wiersze
	clearEntries()

	for i, entry in ipairs(data) do
		local row = template:Clone()           -- Klonuj ukryty szablon
		row.Name = "Row" .. i                  -- Nadaj mu unikalną nazwę
		row.Visible = true                     -- Uczyń go widocznym
		row.LayoutOrder = i                    -- Pozwól UIListLayout dobrze go uporządkować

		-- Format rankingu: "1. miejsce: Nazwa użytkownika - 123"
		row.Text = string.format("%d%s miejsce: %s - %d",
			i,
			i == 1 and "st" or i == 2 and "nd" or i == 3 and "rd" or "th",
			entry.Username,
			entry.Score
		)

		-- Dodaj dane do UI
		row.Parent = entriesFrame
	end
end

-- Główna pętla: aktualizacja rankingu co 3 sekundy
while true do
	-- Poproś serwer o dane rankingu
	local success, data = pcall(function()
		return leaderboardRemote:InvokeServer()
	end)

	if success and data then
		-- Wyświetlanie wyników w rankingu
		renderLeaderboard(data)
	else
		warn("Nie udało się pobrać danych rankingu")
	end

	-- Czekaj 3 sekundy przed ponownym uaktualnieniem
	task.wait(3)
end