Registra e visualizza i dati del giocatore

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

Crea uno script del modulo per registrare la raccolta di monete

Per gestire il deposito e la gestione dei dati di raccolta delle monete di ogni Giocatore, devi creare un oggetto ModuleScript per contenere una struttura di dati e funzioni che accedono ai dati di raccolta delle monete per ogni Giocatore.Gli script del modulo sono codice riutilizzabile che altri script possono Richiesto/a.In questo caso, il CoinService richiede questo script del modulo in modo che possa aggiornare i dati di raccolta delle monete quando i giocatori toccano le monete.

Per creare uno script del modulo:

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

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

Dichiarare le strutture dei dati

Lo script del modulo inizia con una dichiarazione di un tavolo vuoto, PlayerData , che viene restituita alla fine dello script.Contiene anche metodi accessori 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 comprendere.In questo caso, una tabella playerData contiene un userId e un campo corrispondente chiamato Coins 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

Definire un accessore di dati locale

getData() è una funzione locale che recupera i dati per una tabella specifica playerData .Se un giocatore non ha raccolto una moneta, restituisce una tabella DEFAULT_PLAYER_DATA per garantire che ogni giocatore abbia alcuni dati associati a loro.Una convenzione comune è creare funzioni semplici e rivolte al pubblico che scaricano la logica su funzioni a scopo locale che svolgono il sollevamento pesante.


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

Definire accessori di dati pubblici

getValue() e updateValue() sono funzioni a faccia pubblica che altri script che richiedono questo script del modulo possono chiamare.Nel nostro caso, il CoinService utilizza queste funzioni per aggiornare i dati di raccolta delle monete di un Giocatoreogni 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 i dati della collezione di monete visivamente con una Classificasullo schermo.Roblox include un sistema integrato che genera automaticamente una classifica usando un'interfaccia utente predefinita.

Per creare la Classifica:

Nella finestra Explorer , crea un ModuleScript in ServerStorage , quindi rinomina lo script del modulo a Classifica .

Sostituisci il codice predefinito con il seguente codice:


local Leaderboard = {}

-- Creazione di una nuova Classifica
local function setupLeaderboard(player)
  local leaderstats = Instance.new("Folder")
  -- Il nome '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 di statistica 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 di stato 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 dettaglio.

Crea una classifica

La funzione setupLeaderboard() crea una nuova istanza di cartella chiamata leaderstats e la imposta come figlia del Giocatorespecificato.Roblox riconosce automaticamente una cartella chiamata leaderstats come contenitore di statistiche e crea un elemento UI per visualizzare le statistiche.Richiede che i valori in leaderstats vengano memorizzati come oggetti "value" (come StringValue , IntValue o NumberValue ).


-- Creazione di una nuova Classifica
local function setupLeaderboard(player)
  local leaderstats = Instance.new("Folder")
  -- Il nome '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 di statistica della 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 del giocatore

setStat() è l'unica funzione pubblica nel modulo Classifica .Crea valori di stato per un giocatore specifico 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 di stato 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

Integrare gli script del modulo

Con entrambi gli script del modulo Dati di gioco e Classifica completati, richiedili nell' script CoinService per gestire e visualizzare i dati delle monete del giocatore.Per aggiornare CoinService :

Nella finestra Explorer , apri lo script CoinService .

Sostituisci 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 dei leader delle monete
  Leaderboard.setStat(player, COIN_KEY_NAME, newCoinAmount)
end

-- Definire il gestore 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

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

I cambiamenti allo script originale CoinService includono:

Importazione dei moduli PlayerData e Leaderboard con la funzione require().
Dichiarare COIN_AMOUNT_TO_ADD come numero di monete da aggiungere quando un giocatore raccoglie una moneta e COIN_KEY_NAME come nome della chiave definito in PlayerData .
Creazione della funzione ausiliaria updatePlayerCoins() per aggiornare il conteggio delle monete del Giocatoree lo stato della classifica associata.
Sostituzione della dichiarazione placeholder con una chiamata a .

Test di gioco

È tempo 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 sull'interfaccia utente della classifica.Per testare la tua esperienza:

Nella barra degli strumenti, 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 utente della classifica viene visualizzata e aumenta il numero di monete che raccogli mentre raccogli più monete.

Crea uno script del modulo per registrare la raccolta di monete

Dichiarare le strutture dei dati

Definire un accessore di dati locale

Definire accessori di dati pubblici

Implementa una Classifica

Crea una classifica

Aggiorna le statistiche del giocatore

Integrare gli script del modulo

Test di gioco

Su questa pagina