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 scores.

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 contenant 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 du code réutilisable que d'autres scripts peuvent nécessiter. Dans ce cas, le CoinService nécessite 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 nécessite ce script de module reçoit la même copie de la table PlayerData, permettant à plusieurs scripts de modifier et de partager des données de collecte de pièces.

Déclarez les structures de données

Le script de module commence par une déclaration d'une table vide, PlayerData, qui est retourné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 des 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 accès 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 retourne une table de la fonction defaultPlayerData() pour s'assurer que chaque joueur a des données associées à lui. Une convention courante est de créer des fonctions simples, orientées vers le public, qui déchargent la logique vers des fonctions locales 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 orientées vers le public que d'autres scripts nécessitant 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

Mettre en œuvre un tableau des scores

Vous pouvez représenter les données de collecte de pièces visuellement avec un tableau des scores sur l'écran. Roblox comprend un système intégré qui génère automatiquement un tableau des scores à l'aide d'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 scores
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 scores
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player
  return leaderstats
end

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

-- Mise à jour d'une 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 plus en détail comment fonctionne le tableau des scores.

Créer un tableau des scores

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 en tant qu'objets "valeur" (tels que StringValue, IntValue ou NumberValue).


-- Création d'un nouveau tableau des scores
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 scores
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player
  return leaderstats
end

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

Mise à jour des statistiques des joueurs

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

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


-- Mise à jour d'une 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, exigez-les dans le script CoinService pour gérer et afficher les données des pièces des joueurs.

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

```lua
-- Initialisation des services et 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)
  -- Met à jour le tableau des pièces
  local newCoinAmount = PlayerData.updateValue(player, COIN_KEY_NAME, updateFunction)

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

-- Définir le 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

-- Configurer les é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 :

L'importation des modules PlayerData et Leaderboard avec la fonction require().
La 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 la clé défini dans PlayerData.
La création de la fonction d'assistance updatePlayerCoins() pour mettre à jour le nombre de pièces du joueur et la statistique du tableau associé.
Le remplacement de l'énoncé de test print() dans onCoinTouched() par un appel à updatePlayerCoins().

Tester

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