Prática de Else/if com pontos | Documentação

Este projeto usará instruções condicionais para criar uma parte que dará ou subtrairá pontos em um placar, dependendo da cor da parte ao ser tocada. Se for azul, dará alguns pontos aos jogadores. Se for verde, dará muitos pontos. Finalmente, se for vermelha, subtrairá pontos.

Configurar o projeto

A parte que dá pontos pode ser adicionada em qualquer projeto onde os pontos sejam relevantes. Por exemplo, em um jogo de aventura onde os jogadores colecionam pontos.

Rastreamento de pontos

Para configurar este projeto, você precisará de um placar para rastrear os pontos e uma parte que muda de cor. O código para o placar será fornecido.

Crie um novo script em ServerScriptService chamado Leaderboard. Copie e cole o código abaixo no script.


--No ServerScriptService, crie um script chamado PlayerSetup com o conteúdo abaixo.

local Players = game:GetService("Players")

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

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

-- Execute onPlayerJoin quando o evento PlayerAdded disparar
Players.PlayerAdded:Connect(onPlayerJoin)

Parte que muda de cor

O script irá ciclar através de três cores diferentes para a parte. Cada cor terá uma variável para armazenar seu valor RGB, um tipo de dado que inclui um conjunto de três números (vermelho, verde, azul) que criam cores.

Crie uma parte chamada PointPart com um script anexado chamado PointScript.

No PointScript, use script.Parent para se referir à parte.


local pointPart = script.Parent

Crie variáveis para armazenar as diferentes cores. Cada variável deve ser definida como Color3.fromRGB(), que cria um valor de cor.

Azul (Alguns Pontos): (0, 0, 255)
Verde (Muitos Pontos): (0, 255, 0)
Vermelho (Perder Pontos): (255, 0, 0)


local pointPart = script.Parent

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

Adicione variáveis para uma pequena quantidade de pontos, uma quantidade maior de pontos, e uma terceira para subtrair pontos.


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

-- Valores de pontos
local smallPoints = 10
local largePoints = 50
local losePoints = 100

Adicione o serviço de jogadores

Para conceder pontos, você precisará acessar as informações do jogador que estão armazenadas no Explorer sob Players, e que são separadas do objeto personagem. É aqui que informações como estatísticas do placar podem ser encontradas.

Você pode fazer isso adicionando o serviço Players ao seu script. Serviços são conjuntos adicionais de funções predefinidas criadas pelos engenheiros do Roblox para economizar seu tempo.

Obtenha o serviço Players digitando:

local Players = game:GetService("Players")


-- Valores de pontos
local smallPoints = 10
local largePoints = 50
local losePoints = 100

-- Serviços necessários
local Players = game:GetService("Players")

Funções e eventos

O PointsScript precisará de duas funções. A primeira função dará e subtrairá pontos. A segunda função verificará se um jogador tocou a parte. Essas funções serão conectadas com um evento de toque, que será executado sempre que essa parte for tocada.

Crie uma nova função chamada givePoints() e um parâmetro chamado player. Dentro, adicione uma instrução de impressão para teste.


local Players = game:GetService("Players")

-- Dá ou subtrai pontos
local function givePoints(player)
	print("Dando pontos ao jogador")
end

Abaixo disso, crie uma segunda função chamada partTouched() com um parâmetro chamado otherPart.


-- Dá ou subtrai pontos
local function givePoints(player)
	print("Dando pontos ao jogador")
end

-- Verifica se o jogador tocou a parte
local function partTouched(otherPart)

end

Dentro da função, use a função GetPlayerFromCharacter() para verificar se há um jogador na variável otherPart.


-- Verifica se o jogador tocou a parte
local function partTouched(otherPart)
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
end

Se um jogador tocou a parte, ele será armazenado na variável player. Se não, a variável ficará vazia. Por conta própria:

Dentro da função, verifique se player tem um valor. Se houver, chame givePoints(player).
Abaixo da função, conecte partTouched() ao evento Touched de pointPart.


-- Verifica se o jogador tocou a parte
local function partTouched(otherPart)
	-- Obtém o jogador se um tocar a parte
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
	if player then
		givePoints(player)
	end
end

pointPart.Touched:Connect(partTouched)

Execute o projeto. Sempre que um jogador tocar a parte, você deve ver uma mensagem na janela de Saída dizendo: "Dando pontos ao jogador"

Dicas de Solução de Problemas:

Verifique se "Players" em game:GetService("Players") está capitalizado e entre aspas.
partTouched() deve estar conectado ao evento Touched de pointPart.

Crie Cores em Loop

Para alternar entre cores, o script usará um loop while que muda a cor da parte a cada alguns segundos. A condição para este loop será verdadeira, então ele pode rodar indefinidamente.

No final do script, crie um novo loop while onde a condição é verdadeira, o que significa que o loop sempre rodará.


-- Verifica se o jogador tocou a parte
local function partTouched(otherPart)
	-- Obtém o jogador se um tocar a parte
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
	if player then
		givePoints(player)
	end
end

pointPart.Touched:Connect(partTouched)

-- Alterna entre cores
while true do

end

Se o loop while true do não estiver na parte inferior do script, qualquer código abaixo dele nunca será executado. Como o loop while não para, continuará executando o loop em vez de qualquer código abaixo dele.

Por conta própria, codifique um loop while true do que muda pointPart para as variáveis de cor que você criou. Não se esqueça de usar task.wait() entre as cores. Quando terminar, verifique seu código contra a versão abaixo.


-- Alterna entre 3 cores, esperando entre cada cor
while true do
	pointPart.Color = blue
	task.wait(3)
	pointPart.Color = green
	task.wait(2)
	pointPart.Color = red
	task.wait(1)
end

Teste jogando e verifique se todas as três cores estão em loop sem parar.

Dicas de Solução de Problemas

Neste momento, se o looping de cores não estiver funcionando como pretendido, tente uma das opções abaixo.

Verifique se o loop while está na parte inferior do script, abaixo do evento Touched. Se o loop não estiver na parte inferior, impedirá outras partes do script de serem executadas corretamente.
Verifique se cada cor dentro de Color3.fromRGB() está escrita corretamente. Deve haver três números entre 0 e 255 separados por vírgulas, como (255, 50, 0).

Dê Pontos aos Jogadores

Os jogadores receberão pontos com base na cor atual da parte quando a tocarem.

Encontre a cor atual

Sempre que um jogador tocar a parte, o script precisará saber a cor atual da parte para conceder pontos depois.

Encontre givePoints(). Substitua sua mensagem de teste por uma variável para a cor atual de pointPart. Esta variável determinará quantos pontos o jogador ganha (ou perde).


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

Para afetar os pontos de um jogador, essa função precisa acessar o placar do jogador. Crie uma variável para armazená-lo.


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

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

Agora adicione uma variável para obter o valor de Points do jogador, que é um filho do placar dele.


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

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

Dê ou subtraia pontos

A seguir, você usará if e elseif para dar ou subtrair pontos dependendo da cor da parte ao ser tocada. Lembre-se de que o azul fornece uma pequena quantidade, o verde fornece muitos e o vermelho subtrai pontos.

Dentro de givePoints(), abaixo das variáveis, use uma instrução if para verificar se a cor atual é azul e, se sim, adicione smallPoints ao valor atual de pontos do jogador.


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

Para verificar se é verde, adicione uma condição else if. Se for verde, adicione a variável largePoints aos pontos do jogador.


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

Use uma instrução else para subtrair pontos se pointsPart não for nem azul nem verde.


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

Por fim, destrua a parte após a instrução if para que o script não possa continuar dando pontos.


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

pointPart:Destroy()

Teste jogando e verifique se cada cor dá pontos como esperado. Não se esqueça de testar todas as três condições.

Dê Feedback aos Jogadores

A PointPart funciona, mas os jogadores podem não notar que algo aconteceu, a menos que estejam olhando para seu placar. Corrija isso criando partículas quando a PointPart for destruída.

Adicionar feedback quando os jogadores usam uma parte, como sons, tremores ou partículas, torna as interações com objetos mais satisfatórias para os jogadores.

Crie um efeito de partículas

O efeito de partículas terá a mesma cor que a parte quando tocada. Como as cores foram armazenadas em variáveis, é fácil reutilizá-las.

Em givePoints() na parte inferior, crie uma nova instância de ParticleEmitter. Certifique-se de que o nome da instância esteja escrito exatamente como mostrado.
```
local particle = Instance.new("ParticleEmitter")
end
```

ParticleEmitters usam sequências de cores para controlar sua propriedade Color. Crie uma nova ColorSequence e passe a cor atual da parte.


-- Destrói a parte
pointPart:Destroy()

-- Cria partículas
local particle = Instance.new("ParticleEmitter")
particle.Color = ColorSequence.new(currentColor)

A partícula precisará ser parentada ao jogador que a tocou. Crie uma variável para obter o modelo do personagem do jogador. Em seguida, parenta a partícula à cabeça do jogador.


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

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

Use task.wait() por um segundo, e então destrua as partículas.


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

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

task.wait(1)
particle:Destroy()

Teste o jogo e certifique-se de que partículas sigam o jogador brevemente após tocar cada cor.

Dicas de Solução de Problemas

Neste momento, se as partículas não funcionarem como pretendido, tente uma das opções abaixo.

Verifique se, ao criar uma nova instância, ParticleEmitter está escrito exatamente como mostrado e dentro de aspas.
Ao parentar as partículas, certifique-se de usar : entre playerCharacter e WaitForChild() sem espaços entre.

Complete o PointScript

Uma versão finalizada do script pode ser referenciada abaixo.


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

-- Dá alguns pontos
local blue = Color3.fromRGB(0, 0, 255)
-- Dá mais pontos
local green = Color3.fromRGB(0, 255, 0)
-- Faz os jogadores perderem pontos
local red = Color3.fromRGB(255, 0, 0)

-- pontos dados aos jogadores
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")

	-- Dá pontos ao jogador com base na cor da parte
	if currentColor == blue then
		playerPoints.Value += smallPoints
	elseif currentColor == green then
		playerPoints.Value += largePoints
	else
		playerPoints.Value -= losePoints
	end

	-- Destrói a parte, espera um segundo e depois destrói a partícula
	pointPart:Destroy()

	-- Cria um efeito de faíscas e o destrói
	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)

-- Muda a cor da parte com base nas variáveis. Precisa estar na parte inferior do script.
while true do
	pointPart.Color = blue
	task.wait(4)
	pointPart.Color = green
	task.wait(3)
	pointPart.Color = red
	task.wait(2)
end