Créer un tableau de classement personnalisé avec des magasins de données ordonnés

Les magasins de données sont un service que vous pouvez utiliser pour enregistrer et charger des données persistantes des joueurs à travers différentes sessions de joueur. Ils stockent des informations importantes, comme les progrès ou l'inventaire d'un joueur, et vous permettent de les récupérer pour le joueur la prochaine fois qu'il rejoint votre jeu. Sans magasins de données, un joueur perdrait tout son progrès chaque fois qu'il quitterait le jeu.

Il existe deux types de magasins de données : standard et ordonnés. Ce tutoriel utilise des magasins de données ordonnés, qui stockent des données que vous pouvez classer et trier numériquement et récupérer dans l'ordre croissant ou décroissant en fonction des valeurs numériques stockées.

En utilisant le fichier .rbxl du tutoriel sur la création d'un tableau de classement - Début comme point de départ et le fichier .rbxl du tutoriel sur la création d'un tableau de classement - Complet comme référence, ce tutoriel vous donne la base dont vous avez besoin pour créer un tableau de classement personnalisé pour les joueurs, y compris des conseils sur :

• Stocker les scores d'or dans un magasin de données ordonné.
• Récupérer et trier les meilleurs scores à l'échelle mondiale sur tous les serveurs.
• Afficher les meilleurs scores dans un tableau de classement personnalisé dans l'interface utilisateur.
• Actualiser automatiquement le tableau de classement personnalisé toutes les quelques secondes.

À la fin de ce tutoriel, vous devriez avoir les éléments suivants :

1. Sous ServerScriptService :

   1. Un script GoldManager mis à jour qui enregistre le score du joueur dans un magasin de données ordonné pour le tableau de classement.
   2. Un nouveau script module LeaderboardRemoteHandler qui récupère et renvoie la liste triée des meilleurs scores du tableau de classement.
   3. Un nouveau script LeaderboardManager qui répond aux demandes de données du tableau de classement du client, agissant comme un pont entre le client dans LeaderboardGuiScript et le serveur dans LeaderboardManager.
2. Sous StarterGui, un nouveau script local LeaderboardGuiScript qui rend l'interface utilisateur du tableau de classement pour le joueur.

Activer l'accès Studio aux services API

Les magasins de données ne sont pas stockés localement sur votre appareil, donc votre jeu dépend de la communication serveur à serveur avec le backend de Roblox pour les utiliser. Par défaut, Studio restreint cette communication pour prévenir les abus ou une utilisation accidentelle. L'accès aux services API dans Studio est désactivé jusqu'à ce que vous l'activiez explicitement pour vous assurer que seuls les jeux de confiance peuvent lire et écrire sur les serveurs backend de Roblox.

Pour activer l'accès Studio aux services API afin que vous puissiez utiliser des magasins de données :

1. Ouvrez le fichier Gold Rush create leaderboard tutorial - Start dans Studio. Ce fichier de point de départ inclut déjà le code du tutoriel Enregistrer les données des joueurs et le squelette de l'interface utilisateur pour le tableau de classement des joueurs.
2. Publiez votre jeu.
3. De retour dans Studio, allez dans Fichier ⟩ Paramètres de l'expérience ⟩ Sécurité.
4. Activez Activer l'accès Studio aux services API.
5. Enregistrez vos modifications.

Créer un magasin de données ordonné

Lors de la création d'un magasin de données, vous devez toujours appeler le DataStoreService à partir d'un Script côté serveur. Cela est important car :

• Roblox bloque tout accès au magasin de données depuis le client afin que seul le serveur ait la permission d'accéder et de modifier les données persistantes des joueurs.
• Les scripts côté serveur s'exécutent dans un environnement centralisé, garantissant que les données lues et écrites dans votre magasin de données sont précises et valides.
• Étant donné que les scripts côté client s'exécutent sur l'appareil du joueur, tout joueur pourrait potentiellement exploiter le jeu et voler ou écraser les données d'autres joueurs si le client avait accès à vos magasins de données.

Vous devez également donner à votre magasin de données un nom unique pour garder vos données organisées et pour éviter tout chevauchement ou conflit dans différents magasins de données. Dans ce tutoriel, le magasin de données pour le tableau de classement s'appelle GlobalLeaderboard.

Pour créer le magasin de données ordonné GlobalLeaderboard :

1. Ouvrez le script existant GoldManager sous ServerScriptService.

   

2. Sous le magasin de données existant PlayerGold, appelez GetOrderedDataStore avec la chaîne "GlobalLeaderboard". Cela crée un magasin de données ordonné pour enregistrer le score du joueur lorsqu'il gagne de l'or.

   local leaderboardStore = DataStoreService:GetOrderedDataStore("GlobalLeaderboard")

Après avoir créé un magasin de données, vous pouvez référencer ce même magasin de données dans différents scripts. Par exemple, vous pouvez appeler GetOrderedDataStore à la fois dans le script GoldManager et le script module LeaderboardManager que vous créerez plus tard dans ce tutoriel. Référencer le même magasin de données à deux endroits ne signifie pas que vous dupliquez des données ; cela signifie simplement que deux scripts accèdent au même stockage centralisé, comme deux coéquipiers utilisant un dossier pour partager des informations.

Envoyer les données du joueur au tableau de classement

Les magasins de données sont constitués de clés, qui identifient les données, et de valeurs, qui stockent les données. Contrairement aux magasins de données standard, les magasins de données ordonnés vous permettent de trier les données par valeur, ce qui les rend idéaux pour créer des choses comme des tableaux de classement.

Chaque entrée dans un magasin de données ordonné est stockée sous une clé unique que vous pouvez classer et trier numériquement, puis récupérer dans l'ordre croissant ou décroissant en fonction des valeurs numériques stockées. Cela signifie que vous pouvez utiliser des magasins de données ordonnés pour, par exemple, afficher une liste des 3 premiers qui se met à jour en temps réel au fur et à mesure que les joueurs de votre jeu collectionnent plus d'or.

Maintenant que vous avez créé votre magasin de données ordonné GlobalLeaderboard, mettez à jour la fonction saveGold existante dans le script GoldManager pour envoyer le score d'or du joueur à votre tableau de classement personnalisé avec 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("Impossible d'enregistrer l'or pour", player.Name, ":", err)
  end
end

Vous pouvez penser au magasin de données ordonné GlobalLeaderboard comme à un dossier partagé : SetAsync ajoute du contenu au dossier, tandis que GetSortedAsync (que vous créerez plus tard dans le script module LeaderboardManager) lit le contenu du dossier et le trie par score.

Récupérer les scores du tableau de classement

Pour récupérer les scores du tableau de classement, vous devez utiliser un ModuleScript. Les scripts modules vous permettent d'organiser et de réutiliser votre code à travers plusieurs scripts. Au lieu de copier la même logique à différents endroits, vous pouvez l'écrire une fois dans un script module et l'appeler de n'importe où en avoir besoin.

Lorsque vous stockez votre logique de tableau de classement dans un module, le gestionnaire d'interface utilisateur et les scripts serveur peuvent utiliser la même fonction pour récupérer les meilleurs scores des joueurs. Si jamais vous devez, par exemple, mettre à jour la manière dont les noms d'utilisateur sont récupérés ou comment les scores sont triés, vous n'avez qu'à changer le code à un seul endroit. Après avoir mis à jour le module, tous les scripts qui l'utilisent obtiennent également automatiquement le comportement mis à jour.

Votre tableau de classement personnalisé utilise les méthodes suivantes du magasin de données ordonné pour partager des données entre différents serveurs :

• SetAsync (depuis le script GoldManager) pour envoyer des scores de joueurs au magasin de données ordonné GlobalLeaderboard.
• GetSortedAsync (dans le script module) pour récupérer les meilleurs scores de tous les serveurs à partir du même magasin de données. La méthode GetSortedAsync est exclusive aux magasins de données ordonnés et peut récupérer plusieurs clés triées en fonction d'un ordre de tri spécifique, d'une taille de page, et de valeurs minimales et maximales.

Pour récupérer les scores du tableau de classement :

1. Sous ServerScriptService, créez un nouveau ModuleScript appelé LeaderboardManager.

2. En haut du script module, appelez GetOrderedDataStore avec la chaîne "GlobalLeaderboard". Référencer le même magasin de données ordonné que vous avez créé dans le script GoldManager permettra à l'interface du tableau de classement de récupérer et de trier les meilleurs scores des joueurs plus tard.

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

3. Préparez une table de module pour contenir toutes les fonctions et données que vous souhaitez exposer à d'autres scripts.

   local leaderboardManager = {}

4. Créez une fonction appelée GetTopScores pour obtenir les meilleurs scores des joueurs. Cette fonction :

   • Appelle GetSortedAsync pour récupérer le nombre limit de meilleurs scores dans l'ordre décroissant. Si l'appel échoue, une liste vide est renvoyée pour empêcher le reste de votre code de planter.
   • Parcourt le tableau de classement pour obtenir une table d'entrées avec GetCurrentPage et des noms d'utilisateur de joueurs avec GetNameFromUserIdAsync.
   • Ajoute chaque résultat à une liste finale et construit une table de classement avec les noms d'utilisateur des joueurs et leurs scores.
   • Renvoie la liste finale des joueurs et envoie les données du tableau de classement à tout script qui appelle cette fonction 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 = "Inconnu"
   
        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. Rendez le module utilisable en retournant la table de module que vous avez créée plus tôt. Chaque fois que vous créez un script module, vous devez retourner la table de module afin que d'autres scripts puissent y accéder et appeler les fonctions qu'elle contient.

   return leaderboardManager

Demander des données de classement au serveur

Afin que l'interface utilisateur cliente puisse afficher les scores du tableau de classement, le serveur doit répondre lorsque le client demande des données. Un RemoteFunction permet au client de demander des informations au serveur et d'attendre une réponse.

Pour demander des données de classement au serveur :

1. Sous ReplicatedStorage, insérez une RemoteFunction appelée LeaderboardRemote. Cette fonction distante sert de pont entre le script de l'interface utilisateur sur le client et la logique du tableau de classement sur le serveur.
2. Sous ServerScriptService, créez un script appelé LeaderboardRemoteHandler. Dans ce script :

   1. Appelez ReplicatedStorage (l'espace partagé entre le client et le serveur), ServerScriptService (qui contient le module de tableau de classement), et leaderboardRemote (la fonction distante que le client appellera pour demander les données du tableau de classement).

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

   2. Chargez le module LeaderboardManager que vous avez créé plus tôt, qui comprend la fonction qui obtient les meilleurs scores à partir du magasin de données ordonné.

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

   3. Définissez le comportement pour lorsque le client appelle InvokeServer. Le serveur répond en récupérant les 3 meilleurs scores et en renvoyant le résultat au client.

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

Afficher les données dans l'interface utilisateur personnalisée du tableau de classement

Après avoir configuré les scripts côté serveur, créez un script local pour récupérer les 3 meilleurs joueurs toutes les 3 secondes et afficher les résultats dans un tableau de classement UI global à l'intérieur du jeu.

Pour afficher les données dans votre tableau de classement personnalisé :

1. Sous StarterGui ⟩ LeaderboardGui, créez un script local appelé LeaderboardGuiScript.

2. En haut du script, connectez-vous à la fonction distante. Appelez ReplicatedStorage pour accéder aux objets partagés entre le serveur et le client, puis appelez leaderboardRemote pour permettre au client de demander les données du tableau de classement au serveur.

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

3. Référencez les éléments UI du tableau de classement existants sous LeaderboardGui.

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

4. Créez une fonction appelée clearEntries pour effacer les anciennes entrées du tableau de classement. Cette fonction parcourt tous les enfants de entriesFrame, qui contient les lignes du tableau de classement, et s'assure que le tableau de classement est entièrement actualisé avant d'afficher de nouvelles données.

   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. Créez une fonction appelée renderLeaderboard pour insérer et afficher les données des joueurs dans les lignes du tableau de classement. L'objet data est une table renvoyée par le serveur qui contient des entrées avec les noms d'utilisateur des joueurs et les scores.

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

6. Créez une boucle pour récupérer périodiquement les données du tableau de classement. Toutes les 3 secondes, la boucle s'exécute et appelle le serveur en utilisant la fonction InvokeServer que vous avez créée plus tôt dans le script LeaderboardRemoteHandler. Si l'appel est réussi, l'interface est actualisée avec les scores mis à jour.

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

Code final

Consultez les extraits de code suivants pour les scripts complets GoldManager, LeaderboardManager, LeaderboardRemoteHandler et LeaderboardGuiScript. Vous pouvez les coller et les exécuter directement dans le fichier Gold Rush create leaderboard tutorial - Start .rbxl dans Studio.

GoldManager

Le script GoldManager crée un magasin de données ordonné pour gérer les mises à jour du tableau de classement.

-- Obtenir des services
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local CollectionService = game:GetService("CollectionService")
local DataStoreService = game:GetService("DataStoreService")

-- Événement distant pour mettre à jour l'interface utilisateur
local uiEvent = ReplicatedStorage:WaitForChild("UIEvent")

-- Magasin de données pour enregistrer les morceaux d'or du joueur
local goldStore = DataStoreService:GetDataStore("PlayerGold")

-- Magasin de données ordonné pour enregistrer l'or dans le tableau de classement
local leaderboardStore = DataStoreService:GetOrderedDataStore("GlobalLeaderboard")

-- Créer un générateur de nombres aléatoires pour le positionnement des morceaux d'or
local random = Random.new()

-- Table pour stocker les morceaux d'or du joueur pour une session unique
local playerGold = {}

-- Constantes
local GOLD_VALUE = 10                  -- Valeur de chaque morceau d'or
local GOLD_REGENERATION_BOUNDS = {     -- Limites de zone utilisées pour repositionner les morceaux d'or aléatoirement
  minX = -72,
  maxX = 72,
  minZ = -72,
  maxZ = 72
}
local GOLD_REGEN_DELAY = 2             -- Le délai avant qu'un morceau ne respawn (en secondes)
local AUTOSAVE_INTERVAL = 30           -- À quelle fréquence les morceaux du joueur sont enregistrés (en secondes)

-- Fonction pour gérer le joueur qui collecte un morceau d'or
local function processGoldTouch(chunk, player)

  -- Cacher le morceau lorsque le joueur le collecte
  chunk.Parent = nil

  -- Ajouter le morceau au score d'or de la session du joueur
  local userId = player.UserId
  playerGold[userId] = (playerGold[userId] or 0) + GOLD_VALUE
  print(player.Name, "a maintenant", playerGold[userId], "d'or")

  -- Mettre à jour la barre de score de l'interface utilisateur pour refléter le nouveau score d'or pour cette session
  uiEvent:FireClient(player, {
    gold = playerGold[userId],
    doTween = true,
    showAlert = false
  })

  -- Attendre un peu, puis respawn le morceau d'or qui vient d'être collecté à un endroit aléatoire
  task.delay(GOLD_REGEN_DELAY, function()

    -- Respawn le morceau d'or à une nouvelle position aléatoire
    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) -- Déplacer le morceau à la nouvelle position
    chunk:SetAttribute("DropCollided", false)  -- Réinitialiser tous les indicateurs de collision
    chunk.Parent = workspace.GoldChunks
  end)
end

-- Boucle à travers toutes les pièces étiquetées "Gold" et les connecte à la détection de contact
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

-- Fonction pour enregistrer l'or du joueur dans les magasins de données standard et ordonnés
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("Impossible d'enregistrer l'or pour", player.Name, ":", err)
  end
end

-- Fonction pour gérer l'ajout du joueur au jeu
local function onPlayerAdded(player)
  local userId = player.UserId
  print(player.Name, "a rejoint le jeu")

  -- Essayer de charger l'or du joueur à partir du magasin de données
  local success, storedGold = pcall(function()
    return goldStore:GetAsync(userId)
  end)

  -- Définir le score d'or de la session actuelle en utilisant la valeur du magasin de données pour le joueur
  local currentGold = if success and storedGold then storedGold else 0
  playerGold[userId] = currentGold

  -- Mettre à jour l'interface utilisateur avec la valeur du magasin de données pour le joueur
  uiEvent:FireClient(player, {
    gold = currentGold,
    doTween = false,
    showAlert =  not success
  })
  if success then
    print("Chargé", currentGold, "d'or pour", player.Name)
  else

    -- Informer le joueur que son or n'a pas pu être chargé
    uiEvent:FireClient(player, { showAlert = true })
    warn("Impossible de charger l'or pour", player.Name)
  end

  -- Démarrer la coroutine d'enregistrement automatique pour enregistrer l'or du joueur toutes les 30 secondes
  coroutine.wrap(function()
    while player.Parent do
      task.wait(AUTOSAVE_INTERVAL)
      if playerGold[userId] then
        saveGold(player, playerGold[userId])
        print("Sauvegarde automatique de", playerGold[userId], "d'or pour", player.Name)
      end
    end
  end)()
end

-- Fonction pour gérer le départ du joueur du jeu
local function onPlayerRemoving(player)
  local userId = player.UserId
  print(player.Name, "a quitté le jeu")

  -- Vérifiez si l'or du joueur a été suivi
  if playerGold[userId] then

    -- Sauvegarder l'or du joueur dans le magasin de données avant qu'il ne parte
    saveGold(player, playerGold[userId])
  end
end

-- Connectez les événements d'ajout et de départ des joueurs
Players.PlayerAdded:Connect(onPlayerAdded)
Players.PlayerRemoving:Connect(onPlayerRemoving)

LeaderboardManager

Le script module LeaderboardManager :

• Appelle GetSortedAsync() sur le magasin de données ordonné GlobalLeaderboard.
• Convertit les userIds en noms d'utilisateur en utilisant GetNameFromUserIdAsync.
• Retourne une liste de tables { Username, Score } pour les joueurs les mieux classés.
• Est appelé par LeaderboardRemoteHandler chaque fois qu'un client demande des données de tableau de classement.

-- Obtenir des services
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

-- Magasin de données ordonné pour enregistrer les scores du tableau de classement
local leaderboardStore = DataStoreService:GetOrderedDataStore("GlobalLeaderboard")

-- Table pour stocker les scores du tableau de classement
local leaderboardManager = {}

-- Fonction pour renvoyer les meilleurs scores
function leaderboardManager.GetTopScores(limit)
	-- Essayer de récupérer une page triée des entrées du tableau de classement depuis le magasin de données
	local success, pages = pcall(function()
		-- false = décroissant (les scores les plus élevés en premier)
		return leaderboardStore:GetSortedAsync(false, limit)
	end)

	-- Si l'appel échoue ou ne renvoie rien, enregistrez un avertissement et renvoyez une table vide
	if not success or not pages then
		warn("Échec de l'obtention des données du tableau de classement")
		return {}
	end

	-- Créez une table pour stocker les meilleurs joueurs
	local topPlayers = {}

	-- Parcourez chaque entrée sur la page actuelle des résultats du tableau de classement
	for _, entry in ipairs(pages:GetCurrentPage()) do
		local userId = tonumber(entry.key)   -- Convertir la clé d'entrée en nombre (userId a été stocké en tant que chaîne)
		local score = entry.value            -- La valeur est le score du joueur (montant d'or)
		local username = "Inconnu"           -- Un nom par défaut au cas où la recherche échoue

		-- Essayez d'obtenir le nom d'utilisateur du joueur à partir de son userId
		local ok, name = pcall(function()
			return Players:GetNameFromUserIdAsync(userId)
		end)

		-- Si la recherche réussit, stockez le vrai nom d'utilisateur
		if ok then
			username = name
		end

		-- Ajoutez ce joueur et son score à la liste
		table.insert(topPlayers, {
			Username = username,
			Score = score
		})
	end

	-- Renvoie la liste complète des meilleurs joueurs avec leurs noms d'utilisateur et scores
	return topPlayers
end

-- Retournez le module LeaderboardManager afin que d'autres scripts puissent l'utiliser
return leaderboardManager

LeaderboardRemoteHandler

Le script LeaderboardRemoteHandler récupère et renvoie les 3 meilleurs scores au client demandeur.

-- Obtenir des services
local ServerScriptService = game:GetService("ServerScriptService")  -- Accéder aux modules côté serveur
local ReplicatedStorage = game:GetService("ReplicatedStorage")      -- Objets de communication partagés entre client et serveur

-- Attendez la RemoteFunction que le client utilise pour demander des données de tableau de classement
local leaderboardRemote = ReplicatedStorage:WaitForChild("LeaderboardRemote")

-- Chargez le module LeaderboardManager qui contient la fonction GetTopScores
local leaderboardManager = require(ServerScriptService:WaitForChild("LeaderboardManager"))

-- Configurez un gestionnaire pour lorsque le client invoque la RemoteFunction du tableau de classement
leaderboardRemote.OnServerInvoke = function(player)
	-- Appelez le module de tableau de classement pour obtenir les 3 meilleurs scores et les renvoyer au client
	return leaderboardManager.GetTopScores(3)
end

LeaderboardGuiScript

Le script local LeaderboardGuiScript :

• Demande des données de tableau de classement au serveur toutes les 3 secondes en utilisant Class.RemoteHandler.InvokeServer|InvokeServer.
• Utilise un modèle de LeaderboardEntry caché pour afficher chaque ligne du tableau de classement.
• Formate chaque ligne comme "1er place : Nom d'utilisateur - Score".
• Gère la création, l'affichage et la mise en page des lignes du tableau de classement à l'aide de UIListLayout.

-- Obtenir le stockage partagé pour l'accès à la RemoteFunction
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Obtenir la RemoteFunction utilisée pour demander des données de tableau de classement au serveur
local leaderboardRemote = ReplicatedStorage:WaitForChild("LeaderboardRemote")

-- Références UI
local gui = script.Parent                                           -- Le LocalScript sous le ScreenGui
local leaderboardFrame = gui:WaitForChild("LeaderboardFrame")       -- Conteneur principal pour le tableau de classement
local entriesFrame = leaderboardFrame:WaitForChild("EntriesFrame")  -- Cadre où les entrées du tableau de classement apparaissent
local template = entriesFrame:WaitForChild("LeaderboardEntry")      -- Étiquette de texte modèle cachée utilisée pour créer des lignes

-- Fonction pour supprimer les anciennes lignes de tableau de classement (mais pas le modèle)
local function clearEntries()
	for _, child in ipairs(entriesFrame:GetChildren()) do
		-- Détruire uniquement les étiquettes nommées "Row1", "Row2", etc. (laisser le modèle intact)
		if child:IsA("TextLabel") and child.Name:match("^Row%d+$") then
			child:Destroy()
		end
	end
end

-- Fonction pour afficher les données du tableau de classement à l'écran
local function renderLeaderboard(data)
	-- D'abord, retirez d'anciennes lignes
	clearEntries()

	for i, entry in ipairs(data) do
		local row = template:Clone()           -- Cloner le modèle caché
		row.Name = "Row" .. i                  -- Donnez-lui un nom unique
		row.Visible = true                     -- Rendez-le visible
		row.LayoutOrder = i                    -- Laissez UIListLayout l'ordonner correctement

		-- Format du tableau de classement : "1er place : Nom d'utilisateur - 123"
		row.Text = string.format("%d%s place : %s - %d",
			i,
			i == 1 and "er" or i == 2 and "ème" or i == 3 and "ème" or "ème",
			entry.Username,
			entry.Score
		)

		-- Ajoutez les données à l'interface utilisateur
		row.Parent = entriesFrame
	end
end

-- Boucle principale : met à jour le tableau de classement toutes les 3 secondes
while true do
	-- Demandez au serveur des données du tableau de classement
	local success, data = pcall(function()
		return leaderboardRemote:InvokeServer()
	end)

	if success and data then
		-- Afficher les résultats sur le tableau de classement
		renderLeaderboard(data)
	else
		warn("Échec de la récupération des données du tableau de classement")
	end

	-- Attendez 3 secondes avant de mettre à jour à nouveau
	task.wait(3)
end