Punteggio

Nei tutorial precedenti, hai creato una varietà di funzionalità di gioco, tra cui piattaforme che svaniscono e lava mortale. Questo tutorial unisce tutto ciò in un gioco giocabile in cui gli utenti vedono chi riesce a 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 il tuo gioco. Duplica le piattaforme che svaniscono che hai creato 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 verso la loro rovina. Assicurati di posizionare un SpawnLocation da qualche parte dove gli utenti possano saltare sulle piattaforme per iniziare a giocare.

Punti dei giocatori

Roblox ha un Leaderboard integrato per mostrare le statistiche degli utenti. Quando imposti i punti dei giocatori tramite la leaderboard, questi appaiono sul lato destro dello schermo nel gioco.

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

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

Ascolta i giocatori

In Roblox, un servizio è un oggetto che esegue una serie di funzioni utili. Il servizio Players ha un evento chiamato PlayerAdded che puoi usare per impostare i punti per ogni utente che si unisce al gioco.

Puoi accedere ai servizi con la funzione GetService nell'oggetto game. game è una variabile accessibile da qualsiasi parte che contiene tutto nel tuo gioco.

1. Crea una variabile per il servizio Players usando game:GetService("Players").

2. Crea una funzione chiamata onPlayerAdded con un parametro per il giocatore in arrivo.

3. Collega la funzione onPlayerAdded all'evento PlayerAdded.

   local Players = game:GetService("Players")
   
   local function onPlayerAdded(player)
   
   end
   
   Players.PlayerAdded:Connect(onPlayerAdded)

Crea una cartella di statistiche

Per far visualizzare i punti di un utente nella leaderboard, tutto ciò che devi fare è creare una nuova Folder nel loro oggetto Player chiamata "leaderstats" e mettere i loro punti lì. Nuovi oggetti possono essere creati all'interno di uno script tramite la funzione Instance.new().

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

2. Imposta la proprietà Name di leaderstats su "leaderstats".

3. Parent leaderstats al 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)

Crea i punti

Il sistema di leaderboard legge qualsiasi valore nella cartella leaderstats e visualizza ciò che trova.

Per aggiungere una statistica che tracci 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.

1. Usa una variabile chiamata points per creare un nuovo oggetto IntValue usando Instance.new().
2. Imposta il Name su "Points".
3. Imposta il Value su 0; questo è ciò che la leaderboard visualizzerà inizialmente per il giocatore.
4. 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)

Prova il tuo gioco e dovresti vedere la leaderboard apparire in alto a destra con i nomi dei tuoi utenti e un punteggio 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.

1. Alla fine dello script, crea un ciclo while con true come condizione.
2. 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 nel gioco, devi iterare attraverso l'array di utenti restituito dalla funzione GetPlayers.

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

1. Memorizza il risultato di Players:GetPlayers() in una variabile playerList.
2. 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 la tua logica qui per ogni giocatore nell'elenco dei giocatori
  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, puoi muoverti attraverso ogni utente nell'elenco con ogni iterazione del ciclo.

1. Memorizza l'utente in playerList[currentPlayer] in una variabile chiamata player.
2. Memorizza l'oggetto Points dell'utente in una variabile chiamata points.
3. 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 il tuo gioco e dovresti scoprire che la leaderboard mostra il punteggio del tuo giocatore che aumenta di 1 ogni secondo.

Ascolta i personaggi

L'obiettivo del gioco è vedere chi riesce a rimanere in vita più a lungo, quindi gli utenti che muoiono dovranno avere i loro punti resettati a 0.

Dovrai ottenere il modello Character per l'utente per rilevare quando sono morti. Questo modello viene aggiunto al gioco dopo che l'oggetto Player è stato caricato e puoi usare 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'effettivo evento CharacterAdded restituisce solo il personaggio, non l'utente associato. Per passare anche 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

Resetta i punti

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

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

local Players = game:GetService("Players")

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

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

1. Collega una nuova funzione anonima all'evento Died dell'Humanoid.
2. Nella funzione anonima, crea una variabile chiamata points per l'oggetto Points del giocatore.
3. 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

Prova questo e vedrai che il punteggio dell'utente si resetta quando muore.

Controlla il giocatore

Se gli utenti continuano a guadagnare punti anche quando sono morti, non è certo nello spirito del gioco, quindi il codice deve controllare se gli utenti sono vivi prima di assegnare un punto.

Devi iniziare definendo un attributo nella funzione onPlayerAdded che può essere utilizzato per controllare se l'utente è vivo. A questo punto, l'utente non è ancora vivo e apparso, 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 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 rinasce, il valore di IsAlive deve essere cambiato in true in modo che l'utente possa iniziare a guadagnare punti di nuovo.

1. In onCharacterAdded, imposta l'attributo IsAlive di player su true.
2. 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 di qualsiasi punto venga assegnato nel ciclo while alla fine dello script. La funzione GetAttribute prende il nome di un attributo e restituisce il valore. Nel ciclo while, avvolgi 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

Prova ora il tuo gioco e dovresti scoprire che l'utente guadagna punti ogni secondo che è vivo, e rimane a 0 quando non è vivo. Fai giocare i tuoi amici con te e vedi chi riesce a ottenere il punteggio più alto.

Questo è solo l'inizio: puoi continuare a migliorare il tuo gioco per i tuoi utenti. Ecco alcuni suggerimenti:

• Metti il codice per tutte le piattaforme in un unico script, rendendo molto più facile l'aggiornamento.
• Crea un'area di attesa dove gli utenti aspettano di essere teletrasportati nell'area di gioco, consentendo agli utenti di iniziare simultaneamente.
• 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