Registra e visualizza i dati del giocatore | Documentazione

Ora che puoi rilevare quando un giocatore ha raccolto una moneta, questa sezione del tutorial ti insegna come contare quante monete hanno raccolto i giocatori e rendere quella cifra visibile su una Classifica.

Crea uno script del modulo per registrare la raccolta di monete

Per gestire la memorizzazione e la gestione di ogni Giocatore's coin collection data, è necessario creare un oggetto ModuleScript per contenere una struttura di dati e funzioni che accedono ai dati di raccolta di monete per ogni Giocatore. Gli script del modulo sono reusabili del codice che altri script possono Richiesto/a. In questo caso, il CoinService richiede questo script del modulo in modo che possa ag

Per creare uno script del modulo:

Nella finestra Explorer , passa il mouse su ServerStorage e fai clic sul pulsante ⊕ . Viene visualizzato un menu contestuale.
Dal menu contestuale, seleziona ModuleScript . Un nuovo script del modulo viene visualizzato sotto ServerStorage . Stai posizionando uno script del modulo in ServerStorage poiché vuoi gestire la logica di raccolta delle monete sul Server.
Rinomina lo script del modulo in PlayerData .

Remplace il codice predefinito con il seguente codice:


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

Spiegazione del codice

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

Dichiarazione delle strutture di dati

Lo script del modulo inizia con una dichiarazione di una tabella vuota, PlayerData , che viene restituita alla fine dello script. Contiene anche metodi di accessori per ottenere e impostare i 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 campo userId e un campo corrispondente chiamato 1> Coins1> che rappresenta la quantità di monete raccolte per quel Giocatore.


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

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

...

return PlayerData

Difinire un adattatore di dati locale

getData() è una funzione locale che recupera i dati per una tabella playerData specifiche. Se un giocatore non ha raccolto una moneta, restituisce una tabella DEFAULT_PLAYER_DATA per assicurare che ogni giocatore abbia alcuni dati associati a loro. Una convenzione comune è creare funzioni semplici e pubbliche-facing che offload la logica a funzioni locali scaled in modo che og


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

Difinire gli accessori ai dati pubblici

getValue() Empty() e updateValue() sono funzioni di faccia pubblica che altri script che richiedono questo script del modulo possono chiamare. Nel nostro caso, il CoinService usa queste funzioni per aggiornare i dati della moneta di un Giocatoreogni volta che 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 leaderboard

Puoi rappresentare i dati della collezione di monete in modo visivo con una Classificasullo schermo. Roblox include un sistema incorporato che genera automaticamente una classifica utilizzando un'interfaccia utente predefinita.

Per creare la Classifica:

Nella finestra Explorer, crea un ModuleScript in ServerStorage, quindi rinomina lo script del modulo in 2> Leaderboard2> .

Remplace il codice predefinito con il seguente codice:


local Leaderboard = {}

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

-- Creazione di un nuovo valore statistico della 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 della statistica 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 spiegano in dettaglio come funziona la classifica.

Creazione di una classifica

La funzione setupLeaderboard() crea una nuova cartella istanza chiamata leaderstats e la imposta come figlia del Giocatorespecificato. Roblox riconosce automaticamente una cartella chiamata <


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

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

Aggiornamento delle statistiche del giocatore

setStat() è l'unica funzione pubblica nel modulo Leaderboard . Crea valori stat per un giocatore specifico o per la leaderboard stessa se non esiste ancora.

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


-- Aggiornamento del valore della statistica 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

Incorpora gli script del modulo

Con entrambi gli script del modulo PlayerData e Leaderboard completati, richiedili nello script CoinService per gestire e visualizzare i dati dei monete del giocatore. Per aggiornare 1> CoinService1> :

Nella finestra Explorer, apri lo script CoinService.

Remplace il codice esistente con il seguente codice:


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

  -- Aggiorna la classifica delle Classifica
  Leaderboard.setStat(player, COIN_KEY_NAME, newCoinAmount)
end

-- Difinire l'evento hook
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

-- Configurazione dei lettori di 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 originale CoinService includono:

Importazione dei 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 definito in PlayerData .
Creazione della funzione helper updatePlayerCoins() per aggiornare il numero di monete del Giocatoree la statistica della classifica associata.
Rimpiazzare la dichiarazione di luogo comune print() con una chiamata a onCoinTouched() .

Playtest

È ora di vedere se la collezione di monete funziona come previsto. Quando tocchi e raccogli una moneta nel Gioco, dovresti essere in grado di vedere la quantità di monete che hai raccolto sulla UI della classifica. Per testare la tua esperienza:

Nella barra dei menu, fai clic sul pulsante Gioca . Studio entra in modalità playtest.
Sposta il tuo personaggio per toccare una moneta. Se i tuoi script funzionano correttamente, l'interfaccia leaderboard mostra e aumenta il tuo conteggio di monete mentre raccogli più monete.