Registrare e visualizzare i dati dei giocatori | Documentazione

Ora che puoi rilevare quando un giocatore ha raccolto una moneta, devi contare quante monete i giocatori hanno raccolto e rendere visibile tale quantità su una classifica.

Crea uno script modulo per registrare la raccolta delle monete

Per gestire la memorizzazione e la gestione dei dati di raccolta delle monete di ciascun giocatore, devi creare un oggetto ModuleScript che contenga una struttura dati e funzioni che accedono ai dati di raccolta delle monete per ogni giocatore. Gli script modulo sono codice riutilizzabile che altri script possono richiedere. In questo caso, il CoinService richiede questo script modulo in modo da poter aggiornare i dati di raccolta delle monete quando i giocatori toccano le monete.

Crea PlayerData
In ServerStorage, crea uno Script Modulo chiamato PlayerData con il seguente codice:

```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
```

Spiegazione del codice

Lo script modulo definisce una tabella PlayerData che contiene zero o più tabelle playerData, che rappresentano i dati di raccolta delle monete per un giocatore. Ogni script che richiede questo script modulo riceve la stessa copia della tabella PlayerData, consentendo a più script di modificare e condividere i dati di raccolta delle monete.

Dichiarare le strutture dati

Lo script modulo inizia con una dichiarazione di una tabella vuota, PlayerData, che viene restituita alla fine dello script. Contiene anche metodi di accesso per ottenere e impostare valori nella tabella.

La tabella playerData contiene commenti che descrivono la struttura della tabella, il che rende il codice più facile da capire. In questo caso, una tabella playerData contiene un userId e un campo corrispondente chiamato Coins che rappresenta l'ammontare delle monete raccolte per quel giocatore.


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

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

...

return PlayerData

Definire un accesso ai dati locale

getData() è una funzione locale che recupera i dati per una specifica tabella playerData. Se un giocatore non ha raccolto una moneta, restituisce una tabella dalla funzione defaultPlayerData() per garantire che ogni giocatore abbia alcuni dati associati a loro. Una convenzione comune è creare funzioni semplici e pubbliche che delegano la logica a funzioni a portata locale che fanno il lavoro pesante.


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

Definire accessori di dati pubblici

getValue() e updateValue() sono funzioni destinate al pubblico che altri script che richiedono questo script modulo possono chiamare. Nel nostro caso, il CoinService utilizza queste funzioni per aggiornare i dati di raccolta delle monete di un giocatore ogni volta che quel giocatore tocca una moneta.


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

Implementa una classifica

Puoi rappresentare visivamente i dati di raccolta delle monete con una classifica sullo schermo. Roblox include un sistema integrato che genera automaticamente una classifica utilizzando un'interfaccia utente predefinita.

Crea Classifica
In ServerStorage, crea uno Script Modulo chiamato Leaderboard con il seguente codice:

```lua
local Leaderboard = {}

-- Creazione di una nuova classifica
local function setupLeaderboard(player)
  local leaderstats = Instance.new("Folder")
  -- 'leaderstats' è un nome riservato che Roblox riconosce per creare una classifica
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player
  return leaderstats
end

-- Creazione di un nuovo valore statistico per la classifica
local function setupStat(leaderstats, statName)
  local stat = Instance.new("IntValue")
  stat.Name = statName
  stat.Value = 0
  stat.Parent = leaderstats
  return stat
end

-- Aggiornamento del valore statistico di un giocatore
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
```

Spiegazione del codice

Le seguenti sezioni descrivono come funziona la classifica in maggior dettaglio.

Crea una classifica

La funzione setupLeaderboard() crea una nuova istanza della cartella denominata leaderstats e la impostano come figlia del giocatore specificato. Roblox riconosce automaticamente una cartella chiamata leaderstats come contenitore di statistiche e crea un elemento dell'interfaccia utente per visualizzare le statistiche. Richiede che i valori in leaderstats siano memorizzati come oggetti "valore" (come StringValue, IntValue o NumberValue).


-- Creazione di una nuova classifica
local function setupLeaderboard(player)
  local leaderstats = Instance.new("Folder")
  -- 'leaderstats' è un nome riservato che Roblox riconosce per creare una classifica
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player
  return leaderstats
end

-- Creazione di un nuovo valore statistico per la classifica
local function setupStat(leaderstats, statName)
  local stat = Instance.new("IntValue")
  stat.Name = statName
  stat.Value = 0
  stat.Parent = leaderstats
  return stat
end

Aggiorna le statistiche dei giocatori

setStat() è l'unica funzione pubblica nel modulo Leaderboard. Crea valori statistici per un giocatore specificato o per la classifica stessa se non esiste già.

FindFirstChild() prende il nome di un oggetto e restituisce l'oggetto se esiste, o nil se non esiste. È un metodo comune e sicuro per scoprire se un oggetto esiste prima di utilizzarlo.


-- Aggiornamento del valore statistico di un giocatore
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

Integra gli script modulo

Con entrambi i moduli a posto, richiedili nello script CoinService per gestire e visualizzare i dati delle monete dei giocatori.

Aggiorna CoinService
In ServerScriptService, sostituisci il codice dello Script CoinService esistente con il seguente:

```lua
-- Inizializzazione dei servizi e delle variabili
local Workspace = game:GetService("Workspace")
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")

-- Moduli
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)
  -- Aggiornare la tabella delle monete
  local newCoinAmount = PlayerData.updateValue(player, COIN_KEY_NAME, updateFunction)

  -- Aggiornare la classifica delle monete
  Leaderboard.setStat(player, COIN_KEY_NAME, newCoinAmount)
end

-- Definire il gestore degli eventi
local function onCoinTouched(otherPart, coin)
  if coin:GetAttribute("Enabled") then
    local character = otherPart.Parent
    local player = Players:GetPlayerFromCharacter(character)
    if player then
      -- Il giocatore ha toccato una moneta
      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

-- Imposta i listener degli eventi
for _, coin in coins do
  coin:SetAttribute("Enabled", true)
  coin.Touched:Connect(function(otherPart)
    onCoinTouched(otherPart, coin)
  end)
end
```

Spiegazione del codice

Le modifiche allo script CoinService originale includono:

Importare i moduli PlayerData e Leaderboard con la funzione require().
Dichiarare COIN_AMOUNT_TO_ADD come il numero di monete da aggiungere quando un giocatore raccoglie una moneta, e COIN_KEY_NAME come il nome della chiave definita in PlayerData.
Creare la funzione helper updatePlayerCoins() per aggiornare il conteggio delle monete del giocatore e la relativa statistica della classifica.
Sostituire la dichiarazione di print() nel onCoinTouched() con una chiamata a updatePlayerCoins().

Prova di gioco

Seleziona Test dal menu a discesa e fai clic su Gioca. Cammina in una moneta e conferma che la classifica appare nell'angolo e che il tuo conteggio delle monete aumenta man mano che raccogli più monete.