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

Este projeto usará declarações condicionais para criar uma parte que dará ou subtrairá pontos em uma tabela de classificação dependendo de qual cor a parte é quando tocada. Se azul, então dará aos jogadores alguns pontos. Se verde, então dará muitos pontos. Finalmente, se vermelho, então tirará pontos.

Configurando o projeto

A parte de pontos pode ser adicionada a qualquer projeto onde os pontos sejam relevantes. Por instância, um jogo de aventura onde os jogadores coletam pontos.

Rastreamento de Pontos

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

Crie um novo script no 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

-- Corra no PlayerJoin quando o evento PlayerAdded disparar
Players.PlayerAdded:Connect(onPlayerJoin)

Peça que muda de cor

O script passará por três cores diferentes para a peça. Cada cor terá uma variável para armazenar seu valor RGB, um tipo de dados que inclui um conjunto de três números (vermelho, verde e azul) que criam cores.

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

Em script, use script.Parent para se referir à peça.


local pointPart = script.Parent

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

Azul (Alguns Pontos): (0, 0, 255)
Verde (Muitos Pontos): (0, 255, 0)
Vermelho (Pontos Perdidos): (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 um terço para remover pontos.


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

-- Valores dos Pontos
local smallPoints = 10
local largePoints = 50
local losePoints = 100

Adicionando o Serviço de Jogadores

Para recompensar pontos, você precisará ter acesso às informações do jogador, que estão armazenadas no Explorador em Jogadores, e são separadas do Objetodo personagem. É aqui que informações como estatísticas da tabela de classificação podem ser encontradas.

Você pode fazer isso adicionando o serviço Players ao seu script. Services são conjuntos adicionais de funções pré-construídas feitas por engenheiros do Roblox para economizar tempo.

Obtenha o serviço Players digitando:

local Players = game:GetService("Players")


-- Valores dos Pontos
local smallPoints = 10
local largePoints = 50
local losePoints = 100

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

Funções e Eventos

PointsScript precisará de duas funções. A primeira função dará e subtrairá peças. A segunda função verificará se um jogador tocou na peça. Essas funções serão conectadas a um evento de toque, que será rodado sempre que essa peça for tocada.

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


local Players = game:GetService("Players")

-- Dá ou subtrai pontos
local function givePoints(player)
	print("Giving player points")
end

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


-- Dá ou subtrai pontos
local function givePoints(player)
	print("Giving player points")
end

-- Verifica se o jogador tocou na peça
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 na peça
local function partTouched(otherPart)
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
end

Se um jogador tocar na peça, ela será armazenada dentro da variável do jogador. Caso contrário, a variável permanecerá vazia. Por conta possuir:

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


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

pointPart.Touched:Connect(partTouched)

Corra o projeto. Sempre que um jogador tocar na peça, você deve ver uma mensagem na Janela de Saída dizendo: "Giving player points" Dicas de solução de problemas:

Verifique se "Players" em game:GetService("Players") está capitalizado e em citações.
partTouched() deve estar conectado ao evento Touched do pointPart.

Criar Cores Looping

Para passar por cores, o script usará um while =loop que muda a cor da peça a cada poucos segundos. A condição para esse loop será verdadeira, então pode ser rodada indefinidamente.

No final do script, crie um novo loop temporário onde a condição seja verdadeira, o que significa que o loop sempre funcionará.


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

pointPart.Touched:Connect(partTouched)

-- Loops através de 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á executar. Como o loop while não para, ele continuará rodando o loop em vez de qualquer código abaixo dele.

Por conta possuir, codifique um loop que muda o 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.


-- Loop através de 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

Jogue-teste e verifique se todas as três cores giram sem parar.

Dicas de solução de problemas

Neste ponto, se o loop de cores não funcionar conforme o esperado, tente um dos seguintes procedimentos abaixo.

Verifique se o loop temporário está na parte inferior do script, abaixo do evento Touched. Se o loop não estiver na parte inferior, ele impedirá que outras partes do script corram 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).

Dar Pontos aos Jogadores

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

Encontrando a Cor Atual

Sempre que um jogador tocar na peça, o script precisará saber a cor atual da peça para atribuir pontos mais tarde.

Encontre givePoints() . Substitua sua mensagem de teste por uma variável para a cor atual do pointPart. Essa 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 de acesso à tabela de classificação do jogador. Crie uma variável para armazená-la.


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

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

Agora adicione uma variável para obter o valor dos Pontos do jogador, que é um filho de sua tabela de classificação.


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

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

Dar ou Subtrair Pontos

Em seguida, você usará if e elseif para dar ou subtrair pontos dependendo da cor da peça quando 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 declaração if para verificar se a cor atual é azul e, se sim, adicione smallPoints ao valor atual dos 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 há verde, adicione outro se condição. Se verde, então adicione a largePoints variável 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 azul ou verde.


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

Finalmente, destrói 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 e verifique se cada cor dá pontos como esperado. Certifique-se de testar todas as três condições .

Dar feedback aos jogadores

A PointPart funciona, mas os jogadores podem não perceber que algo aconteceu a menos que estejam olhando para sua tabela de classificação. Corrija isso criando partículas quando a PointPart é destruída.

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

Criando um Efeito de Partícula

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

Em givePoints() na parte inferior, crie uma nova ParticleEmitter instância. Certifique-se de que o nome da instância seja soletrado 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 na cor da peça atual.


-- Destruir parte
pointPart:Destroy()

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

A parte precisa ser atribuída ao jogador que a tocou. Crie uma variável para obter o modelo de personagem do jogador. Em seguida, atribua a parte à 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 rápido, depois 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 as partículas sigam o jogador brevemente depois de tocar em cada cor.

Dicas de solução de problemas

Neste ponto, se as partículas não funcionarem como pretendido, tente um dos seguintes procedimentos.

Faça ao criar uma nova instância que ParticleEmitter seja soletrado exatamente como mostrado e dentro das citações.
Ao criar as partículas, certifique-se de usar : entre playerCharacter e WaitForChild() sem espaços entre eles.

Completar PointScript

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


local pointPart = script.Parent
--armazenamento local = jogo: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)

-- ouro dado 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á ouro ao jogador com base na cor da peça
	if currentColor == blue then
		playerPoints.Value += smallPoints
	elseif currentColor == green then
		playerPoints.Value += largePoints
	else
		playerPoints.Value -= losePoints
	end

	-- Destrua a peça, espere um segundo e depois destrua a parte
	pointPart:Destroy()
	
	-- Cria um efeito de brilho e destrói-o
	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 peça com base em 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