Punti | Documentazione - Roblox Hub Creatori

Nei tutorial precedenti, hai creato una varietà di funzionalità esperienziali, tra cui piattaforme che scompaiono e lava mortale. Questo tutorial unisce tutto questo in un'esperienza giocabile dove gli utenti vedono chi può rimanere in vita più a lungo. Ogni secondo che rimangono in vita, un punto verrà aggiunto al loro punteggio.

Imposta

Per prima cosa, dovrai impostare la scena per la tua esperienza. Duplica le piattaforme che scompaiono che hai realizzato nel tutorial precedente e lascia che gli utenti competano per rimanere sulla tavola di piattaforme il più a lungo possibile.

Puoi anche usare la lava mortale per uccidere gli utenti quando cadono dalle piattaforme, o semplicemente lasciarli cadere nella loro dannazione. Assicurati di posizionare un SpawnLocation da qualche parte dove gli utenti possano saltare sulle piattaforme per iniziare a giocare.

Punto di spawn sopra una griglia di piattaforme che scompaiono, sopra un pavimento di lava

Punti del giocatore

Roblox ha una Leaderboard integrata per mostrare le statistiche degli utenti. Quando imposti i punti del giocatore tramite la classifica, questi appaiono sul lato destro dello schermo nell'esperienza.

Classifica con nome utente e punteggi mostrati

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

È meglio inserire gli script che impostano lo stato dell'esperienza in ServerScriptService perché verranno eseguiti automaticamente all'avvio dell'esperienza. In ServerScriptService, crea uno script chiamato SetupPoints.

Script SetupPoints in atto in ServerScriptService nella finestra Explorer

Ascolta i giocatori

In Roblox, un servizio è un oggetto che svolge una serie di funzioni utili. Il servizio Players ha un evento chiamato PlayerAdded che puoi utilizzare per impostare i punti per ogni utente che entra nell'esperienza.

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

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

Collega la funzione onPlayerAdded all'evento PlayerAdded.


local Players = game:GetService("Players")

local function onPlayerAdded(player)

end

Players.PlayerAdded:Connect(onPlayerAdded)

Quando dichiari una variabile per contenere un servizio, è meglio nominarla con il nome esatto del servizio ("Players"), anche se questo significa infrangere le normali convenzioni di denominazione per le variabili.

Crea una cartella di statistiche

Per far visualizzare i punti di un utente nella classifica, devi solo creare una nuova Folder nel loro oggetto Player chiamato "leaderstats" e mettere i loro punti lì. Nuovi oggetti possono essere creati all'interno di uno script tramite la funzione Instance.new().

Crea un nuovo oggetto Folder usando 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à Name 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 la cartella esattamente come è mostrato qui ("leaderstats") o non funzionerà!

Crea i punti

Il sistema della classifica legge qualsiasi valore nella cartella leaderstats e visualizza qualsiasi cosa trovi.

Per aggiungere una statistica che traccerà i punti di un giocatore, un nuovo oggetto IntValue può essere parentato alla cartella leaderstats. Il nome dell'oggetto valore verrà 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 mostrerà inizialmente per il giocatore.
Parent l'oggetto points alla cartella leaderstats.


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)

Testa la tua esperienza e dovresti vedere la classifica apparire nell'angolo in alto a destra con i nomi dei tuoi utenti e un punteggio di punti accanto a loro.

Conta il tempo

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

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


Players.PlayerAdded:Connect(onPlayerAdded)

while true do
  task.wait(1)
end

Elenco dei giocatori

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

Un array è un elenco di elementi memorizzati in ordine. Ogni elemento può essere accessibile tramite la sua posizione di indice, partendo da 1. Puoi ottenere la lunghezza di un array prefissandolo con #.

Memorizza il risultato di Players:GetPlayers() in una variabile playerList.
Crea un ciclo for con un valore di partenza di 1 e un valore finale di #playerList, in modo da ottenere un'iterazione del ciclo per ogni giocatore.


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

Assegna punti

Per assegnare un punto a ciascun utente nel ciclo for, dovrai estrarre l'utente dall'array e aggiungere 1 all'oggetto Points memorizzato nella loro cartella leaderstats.

Gli oggetti memorizzati in un array sono accessibili utilizzando parentesi quadri - ad esempio, il primo elemento nell'array playerList può essere accessibile con playerList[1]. Se scrivi playerList[currentPlayer] nel ciclo for, potrai muoverti attraverso ciascun utente nella lista con ogni iterazione del ciclo.

Memorizza l'utente in playerList[currentPlayer] in una variabile chiamata player.
Memorizza l'oggetto Points dell'utente in una variabile chiamata 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

Testa la tua esperienza e dovresti scoprire che la classifica mostra il punteggio del tuo giocatore che aumenta di 1 ogni secondo.

Ascolta i personaggi

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

Dovrai ottenere il modello Character per l'utente per rilevare quando sono morti. Questo modello viene aggiunto all'esperienza dopo che l'oggetto Player è stato caricato e puoi utilizzare l'evento CharacterAdded per ascoltare quando il personaggio è pronto per essere utilizzato. Crea una funzione chiamata onCharacterAdded con due parametri: uno per il personaggio, uno per il giocatore.


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)

end

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

Sebbene tu abbia incluso l'utente nei parametri della funzione onCharacterAdded, l'evento effettivo CharacterAdded restituisce solo il personaggio, non l'utente associato. Per passare anche l'oggetto player, usa una funzione anonima per la connessione all'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

Ripristina i punti

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

Il Humanoid si trova all'interno del modello Character, ma i contenuti di quel modello vengono assemblati solo quando l'utente respawn. Per far sì che il tuo codice attenda in modo sicuro il caricamento dell'oggetto Humanoid, utilizza la funzione WaitForChild(). Puoi richiamarla su qualsiasi oggetto genitore, passando il nome della stringa del figlio che stai aspettando. Crea una variabile per attendere il Humanoid usando character:WaitForChild("Humanoid").


local Players = game:GetService("Players")

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

La funzione a cui devi connetterti all'evento Died è molto breve e sarà necessaria solo qui, quindi puoi utilizzare nuovamente una funzione anonima.

Collega una nuova funzione anonima all'evento Died del Humanoid.
Nella funzione anonima, crea una variabile chiamata points per l'oggetto Points del giocatore.
Imposta la proprietà 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

Testa questo e vedrai che il punteggio dell'utente si ripristina quando muoiono.

Controlla il giocatore

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

Devi iniziare definendo un attributo nella funzione onPlayerAdded che possa essere utilizzato per controllare se l'utente è vivo. A questo punto, l'utente non è ancora vivo e respawn, poiché il loro modello di personaggio deve ancora essere aggiunto.

Gli attributi ti permettono di personalizzare gli oggetti in Roblox con i tuoi dati. Un attributo è composto da un nome e un valore. Puoi crearne uno su qualsiasi oggetto utilizzando la funzione SetAttribute. Chiama SetAttribute su player per creare un nuovo attributo chiamato "IsAlive" con il valore false.


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 del personaggio dell'utente respawna, il valore di IsAlive deve essere cambiato in true in modo che l'utente possa iniziare a guadagnare punti di nuovo.

In onCharacterAdded, imposta l'attributo IsAlive di player su true.
In onCharacterDied, imposta l'attributo IsAlive di player su false.


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 che venga assegnato qualsiasi punto nel ciclo while alla fine dello script. La funzione GetAttribute prende il nome di un attributo e restituisce il valore. Nel ciclo while, incapsula il codice per assegnare un punto in un'istruzione if con la condizione player:GetAttribute("IsAlive").


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

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

Questo è solo l'inizio: puoi continuare a migliorare la tua esperienza per i tuoi utenti. Ecco alcuni suggerimenti:

Inserisci tutto il codice per le piattaforme in un unico script, rendendolo molto più facile da aggiornare.
Crea un'area di attesa dove gli utenti possono attendere di essere teletrasportati nell'area dell'esperienza, permettendo agli utenti di iniziare contemporaneamente.
Annuncia 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