Punti di valutazione | Documentazione

In precedenti tutorial, hai fatto una varietà di funzionalità dell'esperienza tra cui piattaforme sbiadenti e lava mortale . Questo tutorial lega queste cose insieme in un'esperienza giocabile in cui gli utenti vedono chi può rimanere vivo più a lungo. Ogni secondo che rimani vivo, verrà aggiunto un punto al tuo punteggio.

Configurazione

Per prima cosa, dovrai impostare la scena per la tua esperienza. Duplica le piattaforme sbiadenti che hai creato nel tutorial precedente e lascia che gli utenti competano per rimanere sul tabellone delle piattaforme il più a lungo possibile.

Puoi anche usare lava mortale per uccidere gli utenti quando cadono dalle piattaforme, o lasciarli cadere nella loro fine. Assicurati di posizionare un SpawnLocation da qualche parte in cui gli utenti possono saltare sulle piattaforme per iniziare a giocare.

Punti giocatore

Roblox ha un Leaderboard built-in per mostrare le statistiche dell'utente. Quando impostate i punti del giocatore attraverso il Classifica, vengono visualizzati sul lato destro dello schermo nell'esperienza.

Leaderboard with username and points shown

Imparerai più modi personalizzabili per visualizzare le informazioni in tutorial successivi, ma la classifica è il modo più semplice per creare un sistema di punteggio visibile in Roblox.

È meglio mettere gli script che impostano lo stato dell'esperienza in ServerScriptService poiché eseguiranno automaticamente quando l'esperienza inizia. In ServerScriptService , crea uno script chiamato SetupPoints .

SetupPoints script in place in ServerScriptService in the Explorer window

Ascolto per i giocatori

In Roblox, un servizio è un oggetto che esegue una gamma di funzioni utili. Il servizio Players ha un evento chiamato PlayerAdded che puoi utilizzare per impostare i punti per ogni utente che si unisce all'esperienza.

Puoi accedere ai servizi con la funzione GetService nell'oggetto game . game è una variabile accessibile da qualsiasi luogo che contiene tutto nella tua esperienza.

Crea una variabile per il servizio Player utilizzando game:GetService("Players") .
Crea una funzione chiamata onPlayerAdded con un parametro per il Giocatorein arrivo.

Connetti la funzione onPlayerAdded all'evento PlayerAdded.


local Players = game:GetService("Players")

local function onPlayerAdded(player)

end

Players.PlayerAdded:Connect(onPlayerAdded)

Quando si dichiara una variabile per contenere un servizio, è meglio nominarlo con il nome esatto del servizio ( "Players" ) anche se questo significa rompere le convenzioni di nome usuali per le variabili.

Crea una cartella delle statistiche

Per mostrare i punti di un utente nella Classifica, tutto ciò che devi fare è creare un nuovo Folder in loro oggetto Player chiamato "leaderstats" e metterli lì. Nuovi oggetti possono essere creati da dentro uno script tramite la funzione 2>Datatype.Instance.new()2>.

Crea un nuovo oggetto Folder utilizzando Instance.new("Folder") , memorizzando il risultato in una nuova variabile chiamata leaderstats .


local function onPlayerAdded(player)
	local leaderstats = Instance.new("Folder")
end

Imposta la proprietà Nome di leaderstats su "leaderstats" .

Parent leaderstats a player .


local Players = game:GetService("Players")

local function onPlayerAdded(player)
	local leaderstats = Instance.new("Folder")
   leaderstats.Name = "leaderstats"
   leaderstats.Parent = player
end

Players.PlayerAdded:Connect(onPlayerAdded)

Assicurati di nominare il cartello esattamente come mostrato qui ( "leaderstats" ) o non funzionerà!

Creazione dei punti

Il sistema di classifica legge qualsiasi valore nella cartella leaderstats e mostra ciò che trova.

Per aggiungere una statistica che traccerà i punti di un Giocatore, un nuovo oggetto IntValue può essere aggiunto alla cartella leaderstats. Il nome dell'oggetto di valore sarà visualizzato accanto al suo valore attuale.

Usa una variabile chiamata points per creare un nuovo oggetto IntValue usando Instance.new() .
Imposta il Name su "Points" .
Imposta il Value su 0 ; questo è ciò che la classifica inizialmente mostrerà per il Giocatore.
Parent the points oggetto to the leaderstats cartella.


local Players = game:GetService("Players")

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats
end

Players.PlayerAdded:Connect(onPlayerAdded)

Prova la tua esperienza e dovresti vedere la classifica appaiono in alto a destra con i nomi dei tuoi utenti e un punteggio punti accanto a loro.

Tempo di conteggio

Ogni utente dovrebbe guadagnare un punto per ogni secondo in cui è vivo. Un while loop e la funzione task.wait() possono essere utilizzati per aggiornare il valore dei punti ogni secondo.

Alla fine dello script, crea un while loop con true come condizione.
In loop, task.wait() per 1 secondo.


Players.PlayerAdded:Connect(onPlayerAdded)

while true do
  task.wait(1)
end

Lista giocatore

Per eseguire il codice per ogni utente nell'esperienza, devi itere attraverso l'array di utenti restituiti dalla funzione GetPlayers .

Un array è una lista di elementi memorizzati in ordine. Ogni elemento può essere accessato dal suo indice posizione, iniziando da 1 . Puoi ottenere la lunghezza di un array premendo con # .

Store the result of Players:GetPlayers() in a playerList variabile.
Crea un per loop con un valore iniziale di 1 e un valore finale di #playerList in modo che tu ottenga un ciclo per Giocatore.


while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for currentPlayer = 1, #playerList do
    -- Aggiungi la tua logica qui per ogni giocatore nella playerList
  end
end

Assegnazione dei punti

Per assegnare un punto a ciascun utente nella forza, dovrai far uscire l'utente dall' array e aggiungere 1 all' oggetto Punti memorizzato nel loro cartella leaderstats .

Gli oggetti memorizzati in un matricone sono accessibili utilizzando parentesi quadre - ad esempio, il primo elemento nell' array playerList può essere accessibile con playerList[1]] . Se scrivi 1>playerList[currentPlayer]1> nella forza, puoi muoverti attraverso ogni utente nell' elenco con ogni incremento della forza.

Store the user at playerList[currentPlayer] in a variable called player .
Store the user's Points object in a variable called points .
Imposta la proprietà Value di points su points.Value + 1 .


while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for currentPlayer = 1, #playerList do
    local player = playerList[currentPlayer]
    local points = player.leaderstats.Points
    points.Value += 1
  end
end

Prova la tua esperienza e dovresti trovare che la classifica mostra il punteggio del tuo Giocatorecontare da 1 ogni secondo.

Ascolto per i personaggi

L'obiettivo dell'esperienza è mostrare chi può rimanere vivo più a lungo, quindi gli utenti che muoiono dovranno avere i loro punti ripristinati a 0.

Avrai bisogno di ottenere il modello Personaggio per l'utente in modo da poter rilevare quando sono morti. Questo modello viene aggiunto all'esperienza dopo che l'oggetto Player è stato caricato e puoi utilizzare l'evento


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)

end

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")

Anche se hai incluso l'utente nella funzione onCharacterAdded, l'evento reale CharacterAdded restituisce solo il personaggio, non l'utente associato. Per passare l'oggetto player , usa una funzione anonima per la connessione dell'evento.


local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats

  player.CharacterAdded:Connect(function(character)
    onCharacterAdded(character, player)
  end)
end

Ripristinare i punti

Quando un utente muore, il loro Humanoid attiva automaticamente un evento Died . Puoi utilizzare questo evento per sapere quando ripristinare i loro punti.

Il Humanoid è trovato all'interno del modello Character, ma i contenuti di quel modello vengono assemblati solo quando l'utente spawna. Per rendere il tuo codice sicuro che Caricarel'Humanoid oggetto, usa la funzione WaitForChild() . Puoi chiamarlo su qualsiasi oggetto padre, passando il nome della stringa del figlio


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  local humanoid = character:WaitForChild("Humanoid")
end

La funzione che devi connettere all'evento Died è molto breve e sarà necessaria solo qui, quindi puoi utilizzare di nuovo una funzione anonima.

Connetti una nuova funzione anonima all'evento Died dell'Humanoid.
Nella funzione anonima, crea una variabile chiamata points per l'oggetto Points del Giocatore.
Imposta il valore Value di points su 0 .


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  local humanoid = character:WaitForChild("Humanoid")

  humanoid.Died:Connect(function()
    local points = player.leaderstats.Points
    points.Value = 0
  end)
end

Provalo e vedrai il punteggio dell'utente resettarsi quando muore.

Controllo del giocatore

Se gli utenti continuano a guadagnare punti anche quando sono morti, non è nell' spirito dell'esperienza, quindi il codice deve verificare se gli utenti sono vivi prima di assegnare un punto.

Devi iniziare definendo un attributo in la funzione onPlayerAdded che può essere utilizzata per controllare se l'utente è vivo. In questo punto, l'utente non è ancora vivo e generato, poiché il loro modello di personaggio deve ancora essere aggiunto.

Gli attributi ti consentono di personalizzare gli oggetti in Roblox con i tuoi dati. Un attributo consiste in un nome e un valore. Puoi crearne uno su qualsiasi oggetto usando la funzione SetAttribute . Chiama Class.Instance:SetAttribute()|


local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats

  player:SetAttribute("IsAlive", false)

  player.CharacterAdded:Connect(function(character)
    onCharacterAdded(character, player)
  end)
end

Una volta che il modello di personaggio dell'utente respawna, il valore di IsAlive deve essere cambiato in true in modo che l'utente possa iniziare a guadagnare nuovi punti.

In onCharacterAdded, imposta l'attributo IsAlive di player su 1> vero1> .
In onCharacterDied, imposta l'attributo IsAlive di player su 1> false1> .


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  player:SetAttribute("IsAlive", true)

  local humanoid = character:WaitForChild("Humanoid")

  humanoid.Died:Connect(function()
    local points = player.leaderstats.Points
    points.Value = 0
    player:SetAttribute("IsAlive", false)
  end)
end

Infine, IsAlive dovrebbe essere controllato prima di assegnare un punto nel while ciclo alla fine dello script. La funzione 1> Class.Instance:GetAttribute()|GetAttribute1> prende


while true do
  task.wait(1)
  local playerList = Players:GetPlayers()

  for currentPlayer = 1, #playerList do
    local player = playerList[currentPlayer]

    if player:GetAttribute("IsAlive") then
      local points = player.leaderstats.Points
      points.Value += 1
    end
  end
end

Prova la tua esperienza ora e dovresti trovare l'utente guadagna punti ogni secondo che è vivo, e rimane a 0 quando non è vivo. Invita i tuoi amici a giocare con te e vedi chi può ottenere il punteggio più alto.

Questa è solo l'Iniziare, cominciare: puoi continuare a migliorare la tua esperienza per i tuoi utenti. Ecco alcuni consigli:

Inserisci il codice per tutte le piattaforme in un singolo script, rendendo molto più semplice l'Aggiornarmento.
Crea un'area della lobby in cui gli utenti aspettano di essere teletrasportati nell'area dell'esperienza, consentendo agli utenti di iniziare contemporaneamente.
Announciare i vincitori di ogni round.

Codice finale


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  player:SetAttribute("IsAlive", true)
  local humanoid = character:WaitForChild("Humanoid")

  humanoid.Died:Connect(function()
    local points = player.leaderstats.Points
    points.Value = 0
    player:SetAttribute("IsAlive", false)
  end)
end

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats

  player:SetAttribute("IsAlive", false)

  player.CharacterAdded:Connect(function(character)
    onCharacterAdded(character, player)
  end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for i = 1, #playerList do
    local player = playerList[i]
    if player:GetAttribute("IsAlive") then
      local points = player.leaderstats.Points
      points.Value += 1
    end
  end
end