Crea una classifica personalizzata con data store ordinati

I data store sono un servizio che puoi utilizzare per salvare e caricare dati persistenti dei giocatori attraverso diverse sessioni di gioco. Memorizzano informazioni importanti, come i progressi o l'inventario di un giocatore, e ti consentono di recuperarle per il giocatore la prossima volta che entra nel tuo gioco. Senza i data store, un giocatore perderebbe tutti i propri progressi ogni volta che lascia il gioco.

Esistono due tipi di data store: standard e ordinati. Questo tutorial utilizza data store ordinati, che memorizzano dati che puoi classificare e ordinare numericamente e recuperare in ordine crescente o decrescente in base ai valori numerici memorizzati.

Utilizzando il file del tutorial Crea classifica di Gold Rush - Inizio .rbxl come punto di partenza e il file del tutorial Crea classifica di Gold Rush - Completo .rbxl come riferimento, questo tutorial ti offre le basi per creare una classifica personalizzata per i giocatori, incluse indicazioni su:

• Memorizzare i punteggi d'oro in un data store ordinato.
• Recuperare e ordinare i punteggi più alti a livello globale su tutti i server.
• Visualizzare i punteggi più alti in una classifica personalizzata nell'interfaccia utente.
• Aggiornare automaticamente la classifica personalizzata ogni pochi secondi.

Alla fine di questo tutorial, dovresti avere i seguenti elementi:

1. Sotto ServerScriptService:

   1. Uno script GoldManager aggiornato che salva il punteggio del giocatore in un data store ordinato per la classifica.
   2. Un nuovo script di modulo LeaderboardRemoteHandler che recupera e restituisce l'elenco ordinato dei punteggi più alti dalla classifica.
   3. Un nuovo script LeaderboardManager che risponde alle richieste di dati della classifica da parte del client, fungendo da ponte tra il client nello LeaderboardGuiScript e il server nel LeaderboardManager.
2. Sotto StarterGui, un nuovo script locale LeaderboardGuiScript che rende l'interfaccia utente della classifica per il giocatore.

Abilita l'accesso di Studio ai servizi API

I data store non sono memorizzati localmente sul tuo dispositivo, quindi il tuo gioco si basa sulla comunicazione server-server con il backend di Roblox per poterli utilizzare. Per impostazione predefinita, Studio limita questa comunicazione per prevenire abusi o usi accidentali. L'accesso ai servizi API in Studio è disabilitato finché non lo abiliti esplicitamente per assicurarti che solo i giochi affidabili possano leggere e scrivere nei server backend di Roblox.

Per abilitare l'accesso di Studio ai servizi API in modo da poter utilizzare i data store:

1. Apri il file Crea classifica di Gold Rush - Inizio in Studio. Questo file di partenza include già il codice del tutorial Salva i dati dei giocatori e la struttura dell'interfaccia utente per la classifica dei giocatori.
2. Pubblica il tuo gioco.
3. Torna in Studio, vai su File ⟩ Impostazioni esperienza ⟩ Sicurezza.
4. Attiva Abilita accesso di Studio ai servizi API.
5. Salva le modifiche.

Crea un data store ordinato

Quando crei un data store, dovresti sempre chiamare il DataStoreService da uno Script lato server. Farlo è importante perché:

• Roblox blocca l'accesso a tutti i data store dal client affinché solo il server abbia il permesso di accedere e modificare i dati persistenti dei giocatori.
• Gli script lato server vengono eseguiti in un ambiente centralizzato, garantendo che i dati letti e scritti nel tuo data store siano accurati e validi.
• Poiché gli script lato client vengono eseguiti sul dispositivo del giocatore, qualsiasi giocatore potrebbe potenzialmente sfruttare il gioco e rubare o sovrascrivere i dati di altri giocatori se il client avesse accesso ai tuoi data store.

Dovresti anche dare al tuo data store un nome unico per tenere i tuoi dati organizzati e per evitarne la sovrapposizione o i conflitti in diversi data store. In questo tutorial, il data store per la classifica si chiama GlobalLeaderboard.

Per creare il data store ordinato GlobalLeaderboard:

1. Apri lo script GoldManager esistente sotto ServerScriptService.

   

2. Sotto il data store esistente PlayerGold, chiama GetOrderedDataStore con la stringa "GlobalLeaderboard". Questo crea un data store ordinato per salvare il punteggio del giocatore quando guadagna oro.

   local leaderboardStore = DataStoreService:GetOrderedDataStore("GlobalLeaderboard")

Dopo aver creato un data store, sei in grado di fare riferimento a questo stesso data store in diversi script. Ad esempio, puoi chiamare GetOrderedDataStore sia nello script GoldManager sia nello script di modulo LeaderboardManager che creerai più avanti in questo tutorial. Riferirsi allo stesso data store in due luoghi non significa duplicare i dati; significa solo che due script stanno accedendo allo stesso spazio di archiviazione centralizzato, come due membri di un team che utilizzano una cartella per condividere informazioni.

Invia i dati dei giocatori alla classifica

I data store sono composti da chiavi, che identificano i dati, e valori, che memorizzano i dati. A differenza dei data store standard, i data store ordinati ti consentono di ordinare i dati per valore, il che li rende ideali per creare cose come le classifiche.

Ogni voce in un data store ordinato è memorizzata sotto una chiave unica che puoi classificare e ordinare numericamente, e poi recuperare in ordine crescente o decrescente in base ai valori numerici memorizzati. Questo significa che puoi utilizzare i data store ordinati per, ad esempio, mostrare un elenco dei migliori 3 che si aggiorna in tempo reale man mano che i giocatori nel tuo gioco raccolgono più oro.

Ora che hai creato il tuo data store ordinato GlobalLeaderboard, aggiorna la funzione esistente saveGold nello script GoldManager per inviare il punteggio d'oro del giocatore alla tua classifica personalizzata utilizzando 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("Impossibile salvare l'oro per", player.Name, ":", err)
  end
end

Puoi pensare al data store ordinato GlobalLeaderboard come a una cartella condivisa: SetAsync aggiunge contenuto alla cartella, mentre GetSortedAsync (che creerai più avanti nello script di modulo LeaderboardManager) legge il contenuto della cartella e lo ordina in base al punteggio.

Recupera i punteggi della classifica

Per recuperare i punteggi della classifica, dovresti utilizzare uno ModuleScript. Gli script di modulo ti consentono di organizzare e riutilizzare il tuo codice in diversi script. Invece di copiare la stessa logica in luoghi diversi, puoi scriverla una volta in uno script di modulo e chiamarla da qualsiasi punto ne abbia bisogno.

Quando memorizzi la tua logica di classifica in un modulo, sia il gestore dell'interfaccia utente sia gli script del server possono utilizzare la stessa funzione per recuperare i punteggi dei giocatori top. Se mai dovessi aggiornale, ad esempio, su come vengono recuperati i nomi degli utenti o su come vengono ordinati i punteggi, dovrai cambiare il codice in un solo posto. Dopo aver aggiornato il modulo, tutti gli script che lo utilizzano ottengono automaticamente il comportamento aggiornato.

La tua classifica personalizzata utilizza i seguenti metodi del data store ordinato per condividere i dati attraverso diversi server:

• SetAsync (dallo script GoldManager) per inviare i punteggi dei giocatori al data store ordinato GlobalLeaderboard.
• GetSortedAsync (nel modulo di script) per recuperare i punteggi più alti da tutti i server dallo stesso data store. Il metodo GetSortedAsync è esclusivo dei data store ordinati e può recuperare più chiavi ordinate in base a un ordine di ordinamento specifico, dimensione della pagina e valori minimi e massimi.

Per recuperare i punteggi della classifica:

1. Sotto ServerScriptService, crea un nuovo ModuleScript chiamato LeaderboardManager.

2. All'inizio del modulo script, chiama GetOrderedDataStore con la stringa "GlobalLeaderboard". Riferirsi allo stesso data store ordinato che hai creato nello script GoldManager consentirà all'interfaccia della classifica di recuperare e ordinare successivamente i punteggi dei giocatori più alti.

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

3. Prepara una tabella modulo per contenere tutte le funzioni e i dati che desideri esporre ad altri script.

   local leaderboardManager = {}

4. Crea una funzione chiamata GetTopScores per ottenere i punteggi dei giocatori più alti. Questa funzione:

   • Chiama GetSortedAsync per recuperare il numero limit di punteggi più alti in ordine decrescente. Se la chiamata fallisce, viene restituita una lista vuota per evitare che il resto del tuo codice vada in crash.
   • Cicla attraverso la classifica per ottenere una tabella di voci con GetCurrentPage e i nomi utente dei giocatori con GetNameFromUserIdAsync.
   • Aggiunge ogni risultato a una lista finale e costruisce una tabella di classifica con i nomi utente dei giocatori e i loro punteggi.
   • Restituisce la lista finale dei giocatori e invia i dati della classifica a qualsiasi script che chiama questa funzione 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 = "Sconosciuto"
   
        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. Rendi utilizzabile il modulo restituendo la tabella del modulo che hai creato in precedenza. Ogni volta che crei uno script di modulo, devi restituire la tabella del modulo affinché altri script possano accedervi e chiamare le funzioni al suo interno.

   return leaderboardManager

Richiedi i dati della classifica dal server

Affinché l'interfaccia utente del client possa visualizzare i punteggi della classifica, il server deve rispondere quando il client richiede dati. Un RemoteFunction consente al client di richiedere informazioni dal server e attendere una risposta.

Per richiedere i dati della classifica dal server:

1. Sotto ReplicatedStorage, inserisci una RemoteFunction chiamata LeaderboardRemote. Questa funzione remota funge da ponte tra lo script dell'interfaccia utente del client e la logica della classifica sul server.
2. Sotto ServerScriptService, crea uno script chiamato LeaderboardRemoteHandler. In questo script:

   1. Chiama ReplicatedStorage (lo spazio condiviso tra client e server), ServerScriptService (che contiene il modulo della classifica), e leaderboardRemote (la funzione remota che il client chiamerà per chiedere i dati della classifica).

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

   2. Carica il modulo LeaderboardManager che hai creato in precedenza, il quale include la funzione che ottiene i punteggi più alti dal data store ordinato.

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

   3. Imposta il comportamento per quando il client chiama InvokeServer. Il server risponde recuperando i 3 punteggi più alti e inviando il risultato indietro al client.

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

Visualizza i dati nell'interfaccia della classifica personalizzata

Dopo aver impostato gli script lato server, crea uno script locale per recuperare i primi 3 giocatori ogni 3 secondi e visualizzare i risultati in una classifica globale nell'interfaccia di gioco.

Per visualizzare i dati nella tua classifica personalizzata:

1. Sotto StarterGui ⟩ LeaderboardGui, crea uno script locale chiamato LeaderboardGuiScript.

2. All'inizio dello script, connettiti alla funzione remota. Chiama ReplicatedStorage per ottenere accesso agli oggetti condivisi tra server e client, poi chiama leaderboardRemote per consentire al client di richiedere i dati della classifica dal server.

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

3. Riferisciti agli elementi esistenti dell'interfaccia della classifica sotto LeaderboardGui.

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

4. Crea una funzione chiamata clearEntries per cancellare le vecchie voci di classifica. Questa funzione cicla attraverso tutti i figli di entriesFrame, che contiene le righe della classifica, e si assicura che la classifica venga completamente aggiornata prima di visualizzare nuovi dati.

   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. Crea una funzione chiamata renderLeaderboard per inserire e visualizzare i dati dei giocatori nelle righe della classifica. L'oggetto data è una tabella restituita dal server che contiene voci con i nomi utente dei giocatori e i punteggi.

   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 posto: %s - %d",
         i, i == 1 and "°" or i == 2 and "°" or i == 3 and "°" or "°",
         entry.Username, entry.Score)
   
       row.Parent = entriesFrame
     end
   end

6. Crea un ciclo per recuperare periodicamente i dati della classifica. Ogni 3 secondi, il ciclo viene eseguito e chiama il server utilizzando la funzione InvokeServer che hai creato in precedenza nello script LeaderboardRemoteHandler. Se la chiamata ha successo, l'interfaccia utente viene aggiornata con i punteggi aggiornati.

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

Codice finale

Consulta i seguenti frammenti di codice per gli script completi GoldManager, LeaderboardManager, LeaderboardRemoteHandler e LeaderboardGuiScript. Puoi incollarli e eseguirli direttamente nel file Crea classifica di Gold Rush - Inizio .rbxl in Studio.

GoldManager

Lo script GoldManager crea un data store ordinato per gestire gli aggiornamenti della classifica.

-- Ottieni i servizi
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local CollectionService = game:GetService("CollectionService")
local DataStoreService = game:GetService("DataStoreService")

-- Evento remoto per aggiornare l'interfaccia utente
local uiEvent = ReplicatedStorage:WaitForChild("UIEvent")

-- Data store per salvare i pezzi d'oro del giocatore
local goldStore = DataStoreService:GetDataStore("PlayerGold")

-- Data store ordinato per salvare l'oro nella classifica
local leaderboardStore = DataStoreService:GetOrderedDataStore("GlobalLeaderboard")

-- Crea un generatore di numeri casuali per posizionare i pezzi d'oro
local random = Random.new()

-- Tabella per memorizzare i pezzi d'oro del giocatore per una singola sessione
local playerGold = {}

-- Costanti
local GOLD_VALUE = 10                  -- Quanto vale ogni pezzo d'oro
local GOLD_REGENERATION_BOUNDS = {     -- Limiti dell'area usati per riposizionare i pezzi d'oro casualmente
  minX = -72,
  maxX = 72,
  minZ = -72,
  maxZ = 72
}
local GOLD_REGEN_DELAY = 2             -- Il ritardo prima che un pezzo riappaia (in secondi)
local AUTOSAVE_INTERVAL = 30           -- Quanto spesso i pezzi del giocatore vengono salvati (in secondi)

-- Funzione per gestire il tocco di un pezzo d'oro
local function processGoldTouch(chunk, player)

  -- Nascondi il pezzo quando il giocatore lo raccoglie
  chunk.Parent = nil

  -- Aggiungi il pezzo al punteggio d'oro del giocatore nella sessione
  local userId = player.UserId
  playerGold[userId] = (playerGold[userId] or 0) + GOLD_VALUE
  print(player.Name, "ora ha", playerGold[userId], "d'oro")

  -- Aggiorna la barra del punteggio dell'interfaccia utente per riflettere il nuovo punteggio d'oro per questa sessione
  uiEvent:FireClient(player, {
    gold = playerGold[userId],
    doTween = true,
    showAlert = false
  })

  -- Aspetta un po' e poi riarma il pezzo d'oro appena raccolto in una posizione casuale
  task.delay(GOLD_REGEN_DELAY, function()

    -- Riarmo il pezzo d'oro in una nuova posizione casuale
    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) -- Sposta il pezzo nella nuova posizione
    chunk:SetAttribute("DropCollided", false)  -- Resetta eventuali flag di collisione
    chunk.Parent = workspace.GoldChunks
  end)
end

-- Cicla attraverso tutte le parti contrassegnate con "Gold" e collegale al rilevamento del tocco
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

-- Funzione per salvare l'oro del giocatore sia nei data store standard che in quelli ordinati
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("Impossibile salvare l'oro per", player.Name, ":", err)
  end
end

-- Funzione per gestire l'ingresso del giocatore nel gioco
local function onPlayerAdded(player)
  local userId = player.UserId
  print(player.Name, "è entrato nel gioco")

  -- Prova a caricare l'oro del giocatore dal data store
  local success, storedGold = pcall(function()
    return goldStore:GetAsync(userId)
  end)

  -- Imposta il punteggio d'oro della sessione corrente utilizzando il valore del data store per il giocatore
  local currentGold = if success and storedGold then storedGold else 0
  playerGold[userId] = currentGold

  -- Aggiorna l'interfaccia utente con il valore del data store per il giocatore
  uiEvent:FireClient(player, {
    gold = currentGold,
    doTween = false,
    showAlert =  not success
  })
  if success then
    print("Caricato", currentGold, "d'oro per", player.Name)
  else

    -- Notifica il giocatore che il suo oro non è stato caricato
    uiEvent:FireClient(player, { showAlert = true })
    warn("Impossibile caricare l'oro per", player.Name)
  end

  -- Avvia la coroutine di salvataggio automatico per salvare l'oro del giocatore ogni 30 secondi
  coroutine.wrap(function()
    while player.Parent do
      task.wait(AUTOSAVE_INTERVAL)
      if playerGold[userId] then
        saveGold(player, playerGold[userId])
        print("Salvataggio automatico di", playerGold[userId], "d'oro per", player.Name)
      end
    end
  end)()
end

-- Funzione per gestire l'uscita del giocatore dal gioco
local function onPlayerRemoving(player)
  local userId = player.UserId
  print(player.Name, "ha lasciato il gioco")

  -- Controlla se l'oro del giocatore è stato tracciato
  if playerGold[userId] then

    -- Salva l'oro del giocatore nel data store prima che lasci
    saveGold(player, playerGold[userId])
  end
end

-- Collega gli eventi di ingresso e uscita del giocatore
Players.PlayerAdded:Connect(onPlayerAdded)
Players.PlayerRemoving:Connect(onPlayerRemoving)

LeaderboardManager

Lo script di modulo LeaderboardManager:

• Chiama GetSortedAsync() sul data store ordinato GlobalLeaderboard.
• Converte gli ID utente in nomi utente utilizzando GetNameFromUserIdAsync.
• Restituisce un elenco di tabelle { NomeUtente, Punteggio } per i giocatori meglio classificati.
• Viene chiamato da LeaderboardRemoteHandler ogni volta che un client richiede dati della classifica.

-- Ottieni i servizi
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

-- Data store ordinato per salvare i punteggi della classifica
local leaderboardStore = DataStoreService:GetOrderedDataStore("GlobalLeaderboard")

-- Tabella per memorizzare i punteggi della classifica
local leaderboardManager = {}

-- Funzione per restituire i punteggi più alti
function leaderboardManager.GetTopScores(limit)
	-- Prova a recuperare una pagina ordinata di voci della classifica dal data store
	local success, pages = pcall(function()
		-- false = ordinamento decrescente (i punteggi più alti per primi)
		return leaderboardStore:GetSortedAsync(false, limit)
	end)

	-- Se la chiamata fallisce o non restituisce nulla, registra un avviso e restituisci una tabella vuota
	if not success or not pages then
		warn("Impossibile ottenere i dati della classifica")
		return {}
	end

	-- Crea una tabella per memorizzare i dati dei migliori giocatori
	local topPlayers = {}

	-- Cicla attraverso ogni voce sulla pagina corrente dei risultati della classifica
	for _, entry in ipairs(pages:GetCurrentPage()) do
		local userId = tonumber(entry.key)   -- Converte la chiave della voce in un numero (l'ID utente è stato memorizzato come stringa)
		local score = entry.value            -- Il valore è il punteggio del giocatore (quantità di oro)
		local username = "Sconosciuto"       -- Un nome predefinito nel caso in cui la ricerca fallisca

		-- Prova a ottenere il nome utente del giocatore dal suo ID utente
		local ok, name = pcall(function()
			return Players:GetNameFromUserIdAsync(userId)
		end)

		-- Se la ricerca ha successo, memorizza il vero nome utente
		if ok then
			username = name
		end

		-- Aggiungi questo giocatore e il suo punteggio alla lista
		table.insert(topPlayers, {
			Username = username,
			Score = score
		})
	end

	-- Restituisci l'elenco completo dei migliori giocatori con i loro nomi utente e punteggi
	return topPlayers
end

-- Restituisci il modulo LeaderboardManager in modo che altri script possano usarlo
return leaderboardManager

LeaderboardRemoteHandler

Lo script LeaderboardRemoteHandler recupera e restituisce i primi 3 punteggi al client che chiama.

-- Ottieni i servizi
local ServerScriptService = game:GetService("ServerScriptService")  -- Accesso ai moduli lato server
local ReplicatedStorage = game:GetService("ReplicatedStorage")      -- Oggetti di comunicazione client-server condivisi

-- Aspetta la RemoteFunction che il client utilizza per richiedere i dati della classifica
local leaderboardRemote = ReplicatedStorage:WaitForChild("LeaderboardRemote")

-- Carica il modulo LeaderboardManager che contiene la funzione GetTopScores
local leaderboardManager = require(ServerScriptService:WaitForChild("LeaderboardManager"))

-- Imposta un gestore per quando il client attiva la RemoteFunction della classifica
leaderboardRemote.OnServerInvoke = function(player)
	-- Chiama il modulo della classifica per ottenere i primi 3 punteggi e restituirli al client
	return leaderboardManager.GetTopScores(3)
end

LeaderboardGuiScript

Lo script locale LeaderboardGuiScript:

• Richiede dati della classifica dal server ogni 3 secondi utilizzando Class.RemoteHandler.InvokeServer|InvokeServer.
• Usa un template nascosto LeaderboardEntry per visualizzare ciascuna riga della classifica.
• Formatizza ogni riga come "1° posto: NomeUtente - Punteggio".
• Gestisce la creazione, visualizzazione e layout delle righe della classifica utilizzando UIListLayout.

-- Ottieni lo spazio condiviso per l'accesso alla RemoteFunction
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Ottieni la RemoteFunction utilizzata per richiedere i dati della classifica dal server
local leaderboardRemote = ReplicatedStorage:WaitForChild("LeaderboardRemote")

-- Riferimenti all'interfaccia utente
local gui = script.Parent                                           -- Lo script locale sotto lo ScreenGui
local leaderboardFrame = gui:WaitForChild("LeaderboardFrame")       -- Contenitore principale per la classifica
local entriesFrame = leaderboardFrame:WaitForChild("EntriesFrame")  -- Frame in cui appaiono le voci della classifica
local template = entriesFrame:WaitForChild("LeaderboardEntry")      -- Template TextLabel nascosto utilizzato per creare righe

-- Funzione per rimuovere le vecchie righe della classifica (ma non il template)
local function clearEntries()
	for _, child in ipairs(entriesFrame:GetChildren()) do
		-- Distruggi solo le etichette denominate "Row1", "Row2", ecc (lascia intatto il template)
		if child:IsA("TextLabel") and child.Name:match("^Row%d+$") then
			child:Destroy()
		end
	end
end

-- Funzione per visualizzare i dati della classifica sullo schermo
local function renderLeaderboard(data)
	-- Rimuovi prima le righe vecchie
	clearEntries()

	for i, entry in ipairs(data) do
		local row = template:Clone()           -- Clona il template nascosto
		row.Name = "Row" .. i                  -- Assegna un nome unico
		row.Visible = true                     -- Rendilo visibile
		row.LayoutOrder = i                    -- Permetti a UIListLayout di ordinarlo correttamente

		-- Formato della classifica: "1° posto: NomeUtente - 123"
		row.Text = string.format("%d%s posto: %s - %d",
			i,
			i == 1 and "°" or i == 2 and "°" or i == 3 and "°" or "°",
			entry.Username,
			entry.Score
		)

		-- Aggiungi i dati all'interfaccia utente
		row.Parent = entriesFrame
	end
end

-- Ciclo principale: aggiorna la classifica ogni 3 secondi
while true do
	-- Chiedi al server i dati della classifica
	local success, data = pcall(function()
		return leaderboardRemote:InvokeServer()
	end)

	if success and data then
		-- Mostra i risultati sulla classifica
		renderLeaderboard(data)
	else
		warn("Impossibile recuperare i dati della classifica")
	end

	-- Aspetta 3 secondi prima di aggiornare nuovamente
	task.wait(3)
end