Enregistrement et affichage des données du joueur | Documentation

Maintenant que vous pouvez détecter quand un joueur a collecté une pièce, cette section du tutoriel vous apprend à compter le nombre de pièces que les joueurs ont collectées, et à rendre ce montant visible sur un tableau de bord.

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

Pour gérer la 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 à la collecte de pièces pour chaque joueur. Les scripts de module sont du code réutilisable que d'autres scripts peuvent exiger. Dans ce cas, le CoinService nécessite ce script de module pour qu'il puisse mettre à jour les données de collecte de pièces lorsque les

Pour créer un script de module :

Dans la fenêtre Explorateur , passez la souris sur ServerStorage et cliquez sur le bouton ⊕ . Un menu contextuel s'affiche.
Dans le menu contextuel, sélectionnez ModuleScript . Un nouveau script de module s'affiche sous ServerStorage . Vous placez un script de module dans ServerStorage car vous voulez gérer la logique de collecte de pièces sur le serveur.
Renommez le script de module en PlayerData .

Remplacez le code par défaut par le code suivant :


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

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

local DEFAULT_PLAYER_DATA = {
  [PlayerData.COIN_KEY_NAME] = 0
}

local function getData(player)
  local data = playerData[tostring(player.UserId)] or DEFAULT_PLAYER_DATA
  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 des tableaux zéro ou de nombreux tableaux playerData, qui représentent les données de collecte de pièces pour un joueur. Chaque script qui nécessite ce module script reçoit la même copie de la table PlayerData, ce qui permet à plusieurs scripts de modifier et de partager les données de collecte de pièces.

Déclaration des structures de données

Le script de module commence avec une déclaration d'une table vide, PlayerData , qui est renvoyée à la fin du script. Il contient également des méthodes d'accessoires 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é 1> Coins1> 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 accessoire de données local

getData() est une fonction locale qui récupère des données pour une table playerData spécifique. Si un joueur n'a pas collecté de pièce, il renvoie une table DEFAULT_PLAYER_DATA pour s'assurer que chaque joueur a des données associées à eux. Une convention courante est de créer des fonctions simples et côté public qui offload la logique à des fonctions locales qui font le travail lourd.


local DEFAULT_PLAYER_DATA = {
 [PlayerData.COIN_KEY_NAME] = 0
}

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

Définir des accessibles de données publiques

getValue() Player() et updateValue() sont des fonctions de niveau public que d'autres scripts qui nécessitent ce script de module peuvent appeler. Dans notre cas, le CoinService utilise ces fonctions pour mettre à jour les données de la pièce d'un joueur chaque fois qu'il 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 classement

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

Pour créer le classements:

Dans la fenêtre Explorateur , créez un ModuleScript dans ServerStorage , puis renommez le script de module à 1>Leaderboard1>.

Remplacez le code par défaut par le code suivant :


local Leaderboard = {}

-- Créer un nouveau classements
local function setupLeaderboard(player)
  local leaderstats = Instance.new("Folder")
  -- « leaderstats » est un nom réservé que Roblox reconnaît pour créer un classements
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player
  return leaderstats
end

-- Créer une nouvelle valeur de statut de classement
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 d'un stat sur 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 classement fonctionne plus en détail.

Créer un classement

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 une instance de dossier nomm


-- Créer un nouveau classements
local function setupLeaderboard(player)
  local leaderstats = Instance.new("Folder")
  -- « leaderstats » est un nom réservé que Roblox reconnaît pour créer un classements
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player
  return leaderstats
end

-- Créer une nouvelle valeur de statut de classement
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 du joueur

setStat() est la seule fonction publique dans le module Leaderboard . Il crée des valeurs de stat pour un joueur spécifié ou le tableau de bord lui-même s'il n'existe pas déjà.

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


-- Mise à jour de la valeur d'un stat sur 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 scripts de module PlayerData et Leaderboard complétés, exigez-les dans le script CoinService pour gérer et afficher les données de pièce du joueur. Pour mettre à jour 1> CoinService1> :

Dans la fenêtre Explorateur , ouvrez le script CoinService .

Remplacez le code existant par le code suivant :


-- 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 classementsdes 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 original CoinService incluent :

Importer les PlayerData et Leaderboard modules avec la fonction require().
Déclarer 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 .
Créer la fonction d'aide updatePlayerCoins() pour mettre à jour le nombre de pièces du joueur et les statistiques de classement associées.
Remplacer la déclaration de test print() par une appel à onCoinTouched() .

Test de jeu

Il est temps de voir si la collection de pièces fonctionne comme prévu. Lorsque vous touchez et collectez une pièce dans le jeu, vous devriez être en mesure de voir le montant de pièces que vous avez collectées sur l'interface de classement. Pour tester votre expérience :

Dans la barre de menu, cliquez sur le bouton Jouer . Studio entre en mode playtest.
Déplacez votre personnage pour toucher une pièce. Si vos scripts fonctionnent correctement, l'interface de classement des pièces s'affiche et augmente le nombre de pièces que vous collectez en collectant plus de pièces.