Pratica Else/if con l'assegnazione di punti | Documentazione

Questo progetto utilizzerà istruzioni condizionali per creare una parte che aggiungerà o sottrarrà punti su una classifica a seconda del colore della parte al momento del contatto. Se blu, assegnerà ai giocatori alcuni punti. Se verde, assegnerà molti punti. Infine, se rosso, sottrarrà punti.

Imposta il progetto

La parte che assegna punti può essere aggiunta a qualsiasi progetto in cui i punti sono rilevanti. Ad esempio, un gioco di avventura in cui i giocatori raccolgono punti.

Monitoraggio dei punti

Per impostare questo progetto, avrai bisogno di una classifica per monitorare i punti e una parte che cambia colore. Il codice per la classifica sarà fornito.

Crea un nuovo script in ServerScriptService chiamato Leaderboard. Copia e incolla il codice qui sotto nello script.


--In ServerScriptService, crea uno script chiamato PlayerSetup con i contenuti sottostanti.

local Players = game:GetService("Players")

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

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

-- Esegui onPlayerJoin quando si attiva l'evento PlayerAdded
Players.PlayerAdded:Connect(onPlayerJoin)

Parte che cambia colore

Lo script ciclerà attraverso tre colori diversi per la parte. Ogni colore avrà una variabile per memorizzare il suo valore RGB, un tipo di dato che include un insieme di tre numeri (rosso, verde, blu) che creano colori.

Crea una parte chiamata PointPart con uno script allegato chiamato PointScript.

In PointScript, utilizza script.Parent per fare riferimento alla parte.


local pointPart = script.Parent

Crea variabili per memorizzare i diversi colori. Ogni variabile dovrebbe essere impostata su Color3.fromRGB(), che crea un valore di colore.

Blu (Alcuni Punti): (0, 0, 255)
Verde (Tanti Punti): (0, 255, 0)
Rosso (Perdere Punti): (255, 0, 0)


local pointPart = script.Parent

-- Colori
local blue = Color3.fromRGB(0, 0, 255)
local green = Color3.fromRGB(0, 255, 0)
local red = Color3.fromRGB(255, 0, 0)

Aggiungi variabili per una piccola quantità di punti, una maggiore quantità di punti e una terza per sottrarre punti.


-- Colori
local blue = Color3.fromRGB(0, 0, 255)
local green = Color3.fromRGB(0, 255, 0)
local red = Color3.fromRGB(255, 0, 0)

-- Valori dei punti
local smallPoints = 10
local largePoints = 50
local losePoints = 100

Aggiungi il servizio dei giocatori

Per premiare i punti, dovrai accedere alle informazioni del giocatore che sono memorizzate nell'Explorer sotto Players e sono separate dall'oggetto del personaggio. Qui sono disponibili informazioni come le statistiche della classifica.

Puoi farlo aggiungendo il servizio Players al tuo script. I Servizi sono set aggiuntivi di funzioni pre-costruite create dagli ingegneri di Roblox per risparmiarti tempo.

Ottieni il servizio Players digitando:

local Players = game:GetService("Players")


-- Valori dei punti
local smallPoints = 10
local largePoints = 50
local losePoints = 100

-- Servizi necessari
local Players = game:GetService("Players")

Funzioni ed eventi

PointsScript avrà bisogno di due funzioni. La prima funzione darà e sottrarrà punti. La seconda funzione verificherà se un giocatore ha toccato la parte. Queste funzioni saranno quindi collegate a un evento di contatto, che si attiva ogni volta che quella parte viene toccata.

Crea una nuova funzione chiamata givePoints() e un parametro chiamato player. All'interno, aggiungi una dichiarazione di stampa da utilizzare per i test.


local Players = game:GetService("Players")

-- Assegna o sottrae punti
local function givePoints(player)
	print("Assegnazione di punti al giocatore")
end

Sotto quella, crea una seconda funzione chiamata partTouched() con un parametro chiamato otherPart.


-- Assegna o sottrae punti
local function givePoints(player)
	print("Assegnazione di punti al giocatore")
end

-- Verifica se il giocatore ha toccato la parte
local function partTouched(otherPart)

end

All'interno della funzione, utilizza la funzione GetPlayerFromCharacter() per verificare se c'è un giocatore nella variabile otherPart.


-- Verifica se il giocatore ha toccato la parte
local function partTouched(otherPart)
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
end

Se un giocatore ha toccato la parte, sarà memorizzato nella variabile player. Se non lo è, la variabile rimarrà vuota. Da solo:

All'interno della funzione, verifica se player ha un valore. Se c'è, chiama givePoints(player).
Sotto la funzione, collega partTouched() all'evento Touched di pointPart.


-- Verifica se il giocatore ha toccato la parte
local function partTouched(otherPart)
	-- Ottiene il giocatore se uno ha toccato la parte
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
	if player then
		givePoints(player)
	end
end

pointPart.Touched:Connect(partTouched)

Esegui il progetto. Ogni volta che un giocatore tocca la parte, dovresti vedere un messaggio nella finestra di Output che dice: "Assegnazione di punti al giocatore"

Suggerimenti per la risoluzione dei problemi:

Verifica che "Players" in game:GetService("Players") sia maiuscolo e tra virgolette.
partTouched() dovrebbe essere collegato all'evento Touched di pointPart.

Crea colori ciclici

Per ciclare tra colori, lo script utilizzerà un ciclo while =loop che cambia il colore della parte ogni pochi secondi. La condizione per questo ciclo sarà vera, il che significa che può girare indefinitamente.

Alla fine dello script, crea un nuovo ciclo while in cui la condizione è vera, il che significa che il ciclo viene eseguito sempre.


-- Verifica se il giocatore ha toccato la parte
local function partTouched(otherPart)
	-- Ottiene il giocatore se uno ha toccato la parte
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
	if player then
		givePoints(player)
	end
end

pointPart.Touched:Connect(partTouched)

-- Cicla tra colori
while true do

end

Se il ciclo while true do non è in fondo allo script, qualsiasi codice sotto di esso non sarà mai eseguito. Poiché il ciclo while non si ferma, continuerà a eseguire il ciclo invece di qualsiasi codice sottostante.

Da solo, programma un ciclo while true do che cambia pointPart nei colori variabili che hai creato. Non dimenticare di usare task.wait() tra i colori. Quando hai finito, confronta il tuo codice con la versione qui sotto.


-- Cicla attraverso 3 colori, aspettando tra ogni colore
while true do
	pointPart.Color = blue
	task.wait(3)
	pointPart.Color = green
	task.wait(2)
	pointPart.Color = red
	task.wait(1)
end

Esegui il test e verifica che tutti e tre i colori ciclino senza fermarsi.

Suggerimenti per la risoluzione dei problemi

A questo punto, se la sequenza di colori non funziona come previsto, prova una delle seguenti soluzioni.

Verifica che il ciclo while sia in fondo allo script, sotto l'evento Touched. Se il ciclo non si trova in fondo, impedirà ad altre parti dello script di eseguire correttamente.
Verifica che ogni colore all'interno di Color3.fromRGB() sia scritto correttamente. Devono esserci tre numeri tra 0 e 255 separati da virgole, come (255, 50, 0).

Assegna punti ai giocatori

I giocatori riceveranno punti in base al colore attuale della parte quando la toccano.

Trova il colore attuale

Ogni volta che un giocatore tocca la parte, lo script dovrà sapere il colore attuale della parte per assegnare punti in seguito.

Trova givePoints(). Sostituisci il tuo messaggio di test con una variabile per il colore attuale di pointPart. Questa variabile determinerà quanti punti riceve (o perde) il giocatore.


local function givePoints(player)
	local currentColor = pointPart.Color
end

Per influenzare i punti di un giocatore, quella funzione ha bisogno di accesso alla classifica del giocatore. Crea una variabile per memorizzarla.


local function givePoints(player)
	local currentColor = pointPart.Color

	local playerStats = player:WaitForChild("leaderstats")
end

Aggiungi ora una variabile per ottenere il valore Points del giocatore, che è un figlio della sua classifica.


local function givePoints(player)
	local currentColor = pointPart.Color

	local playerStats = player:WaitForChild("leaderstats")
	local playerPoints = playerStats:WaitForChild("Points")
end

Assegna o sottrai punti

Successivamente, utilizzerai if e elseif per assegnare o sottrarre punti a seconda del colore della parte quando viene toccata. Ricorda che il blu fornisce una piccola quantità, il verde fornisce molti e il rosso sottrae punti.

All'interno di givePoints(), sotto le variabili, utilizza un'istruzione if per controllare se il colore attuale è blu e in tal caso aggiungi smallPoints al valore attuale dei punti del giocatore.


local function givePoints(player)
	local currentColor = pointPart.Color

	local playerStats = player:WaitForChild("leaderstats")
	local playerPoints = playerStats:WaitForChild("Points")

	if currentColor == blue then
		playerPoints.Value += smallPoints
	end
end

Per controllare il verde, aggiungi una condizione else if. Se è verde, allora aggiungi la variabile largePoints ai punti del giocatore.


if currentColor == blue then
	playerPoints.Value += smallPoints
elseif currentColor == green then
	playerPoints.Value += largePoints
end

Usa un'istruzione else per sottrarre punti se pointsPart non era né blu né verde.


if currentColor == blue then
	playerPoints.Value += smallPoints
elseif currentColor == green then
	playerPoints.Value += largePoints
else
	playerPoints.Value -= losePoints
end

Infine, distruggi la parte dopo l'istruzione if in modo che lo script non possa continuare a assegnare punti.


if currentColor == blue then
	playerPoints.Value += smallPoints
elseif currentColor == green then
	playerPoints.Value += largePoints
else
	playerPoints.Value -= losePoints
end

pointPart:Destroy()

Esegui il test e verifica che ogni colore assegni punti come previsto. Assicurati di testare tutte e tre le condizioni.

Assegna feedback ai giocatori

La PointPart funziona, ma i giocatori potrebbero non notare che è successo qualcosa a meno che non stiano guardando la loro classifica. Risolvi questo creando particelle quando la PointPart viene distrutta.

Aggiungere feedback quando i giocatori utilizzano una parte, come suoni, scosse o particelle, rende le interazioni con gli oggetti più gratificanti per i giocatori.

Crea un effetto particellare

L'effetto particellare avrà lo stesso colore della parte quando viene toccata. Poiché i colori sono stati memorizzati in variabili, è facile riutilizzarli.

In givePoints() in fondo, crea una nuova istanza di ParticleEmitter. Assicurati che il nome dell'istanza sia scritto esattamente come mostrato.


local particle = Instance.new("ParticleEmitter")
end

I ParticleEmitters utilizzano sequenze di colore per controllare la loro proprietà Color. Crea una nuova ColorSequence e passala al colore attuale della parte.


-- Distruggi la parte
pointPart:Destroy()

-- Crea particelle
local particle = Instance.new("ParticleEmitter")
particle.Color = ColorSequence.new(currentColor)

La particella dovrà essere parentata al giocatore che l'ha toccata. Crea una variabile per ottenere il modello del personaggio del giocatore. Quindi, parenta la particella alla testa del giocatore.


local particle = Instance.new("ParticleEmitter")
particle.Color = ColorSequence.new(currentColor)

local playerCharacter = player.Character
particle.Parent = playerCharacter:WaitForChild("Head")

Usa task.wait() per un secondo veloce, quindi distruggi le particelle.


local particle = Instance.new("ParticleEmitter")
particle.Color = ColorSequence.new(currentColor)

local playerCharacter = player.Character
particle.Parent = playerCharacter:WaitForChild("Head")

task.wait(1)
particle:Destroy()

Esegui il test del gioco e assicurati che le particelle seguano brevemente il giocatore dopo aver toccato ciascun colore.

Suggerimenti per la risoluzione dei problemi

A questo punto, se le particelle non funzionano come previsto, prova una delle seguenti soluzioni.

Verifica che quando crei una nuova istanza, ParticleEmitter sia scritto esattamente come mostrato e tra virgolette.
Quando parenti le particelle, assicurati di utilizzare : tra playerCharacter e WaitForChild() senza spazi tra.

Completa PointScript

Una versione completata dello script può essere consultata qui sotto.


local pointPart = script.Parent
--local storage = game:GetService("ServerStorage")

-- Assegna alcuni punti
local blue = Color3.fromRGB(0, 0, 255)
-- Assegna più punti
local green = Color3.fromRGB(0, 255, 0)
-- Fa perdere punti ai giocatori
local red = Color3.fromRGB(255, 0, 0)

-- oro dato ai giocatori
local smallPoints = 10
local largePoints = 50
local losePoints = 100

local Players = game:GetService("Players")

local function givePoints(player)
	local currentColor = pointPart.Color

	local playerStats = player:WaitForChild("leaderstats")
	local playerPoints = playerStats:WaitForChild("Points")

	-- Assegna oro al giocatore in base al colore della parte
	if currentColor == blue then
		playerPoints.Value += smallPoints
	elseif currentColor == green then
		playerPoints.Value += largePoints
	else
		playerPoints.Value -= losePoints
	end

	-- Distruggi la parte, aspetta un secondo e poi distruggi la particella
	pointPart:Destroy()

	-- Crea un effetto scintillante e distruggilo
	local playerCharacter = player.Character
	local particle = Instance.new("ParticleEmitter")
	particle.Color = ColorSequence.new(currentColor)
	particle.Parent = playerCharacter:WaitForChild("Head")
	task.wait(1)
	particle:Destroy()
end

local function partTouched(otherPart)
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)

	if player then
		givePoints(player)
	end
end

pointPart.Touched:Connect(partTouched)

-- Cambia il colore della parte in base alle variabili. Deve essere in fondo allo script.
while true do
	pointPart.Color = blue
	task.wait(4)
	pointPart.Color = green
	task.wait(3)
	pointPart.Color = red
	task.wait(2)
end