Enregistrer et afficher les données des joueurs | Documentation

Maintenant que vous pouvez détecter quand un joueur a collecté une pièce, vous devez compter combien de pièces les joueurs ont collectées et rendre ce montant visible sur un tableau des leaders.

Créer un script de module pour enregistrer la collecte de pièces

Pour gérer le stockage et la gestion des données de collecte de pièces de chaque joueur, vous devez créer un objet ModuleScript pour contenir une structure de données et des fonctions qui accèdent aux données de collecte de pièces pour chaque joueur. Les scripts de module sont des codes réutilisables que d'autres scripts peuvent requérir. Dans ce cas, le CoinService requiert ce script de module afin de pouvoir mettre à jour les données de collecte de pièces lorsque les joueurs touchent des pièces.

Créer PlayerData

Dans ServerStorage, créez un ModuleScript nommé PlayerData avec le code suivant :

```lua
local PlayerData = {}
PlayerData.COIN_KEY_NAME = "Coins"

local playerData = {
  --[[
    [userId: string] = {
      ["Coins"] = coinAmount: number
    }
  ]]
}

local function defaultPlayerData()
  return {
    [PlayerData.COIN_KEY_NAME] = 0
  }
end

local function getData(player)
  local data = playerData[tostring(player.UserId)] or defaultPlayerData()
  playerData[tostring(player.UserId)] = data
  return data
end

function PlayerData.getValue(player, key)
  return getData(player)[key]
end

function PlayerData.updateValue(player, key, updateFunction)
  local data = getData(player)
  local oldValue = data[key]
  local newValue = updateFunction(oldValue)

  data[key] = newValue
  return newValue
end

return PlayerData
```

Explication du code

Le script de module définit une table PlayerData qui contient zéro ou plusieurs tables playerData, représentant les données de collecte de pièces pour un joueur. Chaque script qui requiert ce script de module reçoit la même copie de la table PlayerData, permettant à plusieurs scripts de modifier et de partager les données de collecte de pièces.

Déclarer les structures de données

Le script de module commence par une déclaration d'une table vide, PlayerData, qui est renvoyée à la fin du script. Il contient également des méthodes d'accès pour obtenir et définir des valeurs dans la table.

La table playerData contient des commentaires qui décrivent la structure de la table, ce qui rend le code plus facile à comprendre. Dans ce cas, une table playerData contient un userId et un champ correspondant nommé Coins qui représente le montant de pièces collectées pour ce joueur.

local PlayerData = {}
PlayerData.COIN_KEY_NAME = "Coins"

local playerData = {
  --[[
    [userId: string] = {
        ["Coins"] = coinAmount: number
    }
  ]]
}

...

return PlayerData

Définir un accesseur de données local

getData() est une fonction locale qui récupère les données pour une table playerData spécifique. Si un joueur n'a pas collecté de pièce, elle renvoie une table de la fonction defaultPlayerData() pour s'assurer que chaque joueur a des données qui leur sont associées. Une convention courante est de créer des fonctions simples, accessibles au public, qui déchargent la logique vers des fonctions à portée locale qui effectuent le travail lourd.

local function defaultPlayerData()
  return {
    [PlayerData.COIN_KEY_NAME] = 0
  }
end

local function getData(player)
  local data = playerData[tostring(player.UserId)] or defaultPlayerData()
  playerData[tostring(player.UserId)] = data
  return data
end

Définir des accesseurs de données publics

getValue() et updateValue() sont des fonctions accessibles au public que d'autres scripts qui requièrent ce script de module peuvent appeler. Dans notre cas, le CoinService utilise ces fonctions pour mettre à jour les données de collecte de pièces d'un joueur chaque fois que ce joueur touche une pièce.

function PlayerData.getValue(player, key)
 return getData(player)[key]
end

function PlayerData.updateValue(player, key, updateFunction)
  local data = getData(player)
  local oldValue = data[key]
  local newValue = updateFunction(oldValue)

  data[key] = newValue
  return newValue
end

Implémenter un tableau des leaders

Vous pouvez représenter les données de collecte de pièces visuellement avec un tableau des leaders à l'écran. Roblox inclut un système intégré qui génère automatiquement un tableau des leaders en utilisant une interface utilisateur par défaut.

Créer Leaderboard

Dans ServerStorage, créez un ModuleScript nommé Leaderboard avec le code suivant :

```lua
local Leaderboard = {}

-- Création d'un nouveau tableau des leaders
local function setupLeaderboard(player)
  local leaderstats = Instance.new("Folder")
  -- 'leaderstats' est un nom réservé que Roblox reconnaît pour créer un tableau des leaders
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player
  return leaderstats
end

-- Création d'une nouvelle valeur de statistique de tableau des leaders
local function setupStat(leaderstats, statName)
  local stat = Instance.new("IntValue")
  stat.Name = statName
  stat.Value = 0
  stat.Parent = leaderstats
  return stat
end

-- Mise à jour de la valeur de statistique d'un joueur
function Leaderboard.setStat(player, statName, value)
  local leaderstats = player:FindFirstChild("leaderstats")
  if not leaderstats then
    leaderstats = setupLeaderboard(player)
  end

  local stat = leaderstats:FindFirstChild(statName)
  if not stat then
    stat = setupStat(leaderstats, statName)
  end

  stat.Value = value
end

return Leaderboard
```

Explication du code

Les sections suivantes décrivent comment le tableau des leaders fonctionne plus en détail.

Créer un tableau des leaders

La fonction setupLeaderboard() crée une nouvelle instance de dossier nommée leaderstats et la définit comme enfant du joueur spécifié. Roblox reconnaît automatiquement un dossier nommé leaderstats comme un conteneur de statistiques et crée un élément d'interface utilisateur pour afficher les statistiques. Il exige que les valeurs dans leaderstats soient stockées sous forme d'objets "valeur" (tels que StringValue, IntValue ou NumberValue).

-- Création d'un nouveau tableau des leaders
local function setupLeaderboard(player)
  local leaderstats = Instance.new("Folder")
  -- 'leaderstats' est un nom réservé que Roblox reconnaît pour créer un tableau des leaders
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player
  return leaderstats
end

-- Création d'une nouvelle valeur de statistique de tableau des leaders
local function setupStat(leaderstats, statName)
  local stat = Instance.new("IntValue")
  stat.Name = statName
  stat.Value = 0
  stat.Parent = leaderstats
  return stat
end

Mettre à jour les statistiques des joueurs

setStat() est la seule fonction publique dans le module Leaderboard. Elle crée des valeurs de statistiques pour un joueur spécifié ou pour le tableau des leaders lui-même si elles n'existent pas déjà.

FindFirstChild() prend le nom d'un objet et renvoie l'objet s'il existe, ou nil s'il n'existe pas. C'est une méthode courante et sûre pour savoir si un objet existe avant de l'utiliser.

-- Mise à jour de la valeur de statistique d'un joueur
function Leaderboard.setStat(player, statName, value)
  local leaderstats = player:FindFirstChild("leaderstats")
  if not leaderstats then
    leaderstats = setupLeaderboard(player)
  end

  local stat = leaderstats:FindFirstChild(statName)
  if not stat then
    stat = setupStat(leaderstats, statName)
  end

  stat.Value = value
end

Intégrer les scripts de module

Avec les deux modules en place, requérez-les dans le script CoinService pour gérer et afficher les données de pièces des joueurs.

Mettre à jour CoinService

Dans ServerScriptService, remplacez le code du script CoinService existant par le suivant :

```lua
-- Initialisation des services et des variables
local Workspace = game:GetService("Workspace")
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")

-- Modules
local Leaderboard = require(ServerStorage.Leaderboard)
local PlayerData = require(ServerStorage.PlayerData)

local coinsFolder = Workspace.World.Coins
local coins = coinsFolder:GetChildren()

local COIN_KEY_NAME = PlayerData.COIN_KEY_NAME
local COOLDOWN = 10
local COIN_AMOUNT_TO_ADD = 1

local function updatePlayerCoins(player, updateFunction)
  -- Mettre à jour la table des pièces
  local newCoinAmount = PlayerData.updateValue(player, COIN_KEY_NAME, updateFunction)

  -- Mettre à jour le tableau des leaders des pièces
  Leaderboard.setStat(player, COIN_KEY_NAME, newCoinAmount)
end

-- Définition du gestionnaire d'événements
local function onCoinTouched(otherPart, coin)
  if coin:GetAttribute("Enabled") then
    local character = otherPart.Parent
    local player = Players:GetPlayerFromCharacter(character)
    if player then
      -- Le joueur a touché une pièce
      coin.Transparency = 1
      coin:SetAttribute("Enabled", false)
      updatePlayerCoins(player, function(oldCoinAmount)
        oldCoinAmount = oldCoinAmount or 0
        return oldCoinAmount + COIN_AMOUNT_TO_ADD
      end)

      task.wait(COOLDOWN)
      coin.Transparency = 0
      coin:SetAttribute("Enabled", true)
    end
  end
end

-- Configuration des écouteurs d'événements
for _, coin in coins do
  coin:SetAttribute("Enabled", true)
  coin.Touched:Connect(function(otherPart)
    onCoinTouched(otherPart, coin)
  end)
end
```

Explication du code

Les modifications apportées au script CoinService original incluent :

Importation des modules PlayerData et Leaderboard avec la fonction require().
Déclaration de COIN_AMOUNT_TO_ADD comme le nombre de pièces à ajouter lorsqu'un joueur collecte une pièce, et COIN_KEY_NAME comme le nom de clé défini dans PlayerData.
Création de la fonction d'assistance updatePlayerCoins() pour mettre à jour le nombre de pièces du joueur et la statistique associée du tableau des leaders.
Remplacement de l'instruction print() par défaut dans onCoinTouched() par un appel à updatePlayerCoins().

Tester

Sélectionnez Test dans le menu déroulant et cliquez sur Jouer. Marchez dans une pièce et confirmez que le tableau des leaders apparaît dans le coin et que votre nombre de pièces augmente à mesure que vous collectez plus de pièces.