Else/If Practice com Giving Points | Documentação

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

Configurando o Projeto

O ponto de partida pode ser adicionado a qualquer projeto onde pontos são 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 peça que muda as cores. O código para a tabela de classificação será fornecido.

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


--In 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 emPlayerJoin quando o evento PlayerAdded for disparado
Players.PlayerAdded:Connect(onPlayerJoin)

Peça Mudando de Cor

O script irá alternar entre três cores para a peça. 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 peça chamada PointPart com um script anexado chamado PointScript.

In PointScript, use script.Parent para referir-se à parte.


local pointPart = script.Parent

Crie variáveis para armazenar as diferentes cores. Cada variável deve ser definido para 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 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 de ponto
local smallPoints = 10
local largePoints = 50
local losePoints = 100

Adicionando o Serviço de Jogadores

Para recompensar pontos, você precisará ter acesso à informação do jogador que está armazenada no Explorer sob Jogadores, e é separada do Objetode personagem. É aqui que informações como estatísticas de classificação podem ser encontradas.

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

Obtenha o serviço Jogadores digitando:

local Players = game:GetService("Players")


-- Valores de ponto
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 adicionará e subtrairá peças. A segunda função verificará se um jogador tocou na peça. Essas funções serão então conectadas a um evento de toque, que é executado sempre que essa peça for tocada.

Crie uma nova função chamada givePoints() e um parâmetro chamado player . Dentro, adicione uma declaraçã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 a 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 outraPeça.


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

Se um jogador tocar a peça, ela será armazenada dentro da variável do jogador. Se não, a variável ficará vazia. Por conta possuir:

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


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

pointPart.Touched:Connect(partTouched)

Executar o projeto. Sempre que um jogador toca a 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 ser conectado ao evento de pontoTouched do Touched.

Criar Cores de Loop

Para loopar através de cores, o script usará um while = loop que muda a cor da peça a cada alguns segundos. A condição para este loop será verdade, então ele pode ser executado indefinidamente.

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


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

pointPart.Touched:Connect(partTouched)

-- Looping através de cores
while true do

end

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

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


-- Looping 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

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

Dicas de solução de problemas

Neste ponto, se o looping de cor não funcionar como deveria, tente um dos seguintes abaixo.

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

Dando Pontos aos Jogadores

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

Encontrando a Cor Atual

Quando um jogador tocar a peça, o script precisará saber a cor atual da peça para recompensar pontos mais tarde.

Encontre givePoints() . Substitua sua mensagem de teste por uma variável para a cor atual do pontoPart. Essa variável determinará quantos pontos o jogador recebe (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 de 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

Dando ou Subtrair Pontos

Em seguida, você usará if e elif 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, adicionar smallPoints ao valor de pontos atual 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 a condição. Se verde, então adicione a variável largePoints ao ponto do jogador.


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

Use outra declaração para subtrair pontos se a parte de ponto não fosse azul ou verde.


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

Por último, destrua a peça depois da declaraçã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á os pontos esperados. Certifique-se de testar todas as três condições.

Dando Feedback aos Jogadores

O PointPart funciona, mas os jogadores podem não notar que algo aconteceu a menos que eles estejam olhando para sua tabela de classificação. Corrige isso criando partículas quando o PointPart for destruído.

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.

Criando um Efeito de Particula

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 instância de ParticleEmitter . Certifique-se de que o nome da instância está escrito exatamente como mostrado.


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

Os ParticleEmitters usam séquências de cores para controlar sua propriedade de cor. Crie uma nova Sequência de Cores e passe na cor atual do part.


-- Destruir parte
pointPart:Destroy()

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

A partícula precisará ser pai para o jogador que a tocou. Crie uma variável para obter o modelo de Personagem do jogador. Então, pai a partícula para a 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, 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 as partículas seguem brevemente o jogador após tocar cada cor.

Dicas de solução de problemas

Neste ponto, se as partículas não funcionarem como deveriam, tente uma das seguintes abaixo.

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

Complete PointScript

Uma versão final do script pode ser referenciado 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 com que os jogadores percam 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 partícula
	pointPart:Destroy()

	-- Cria um efeito de brilhos 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 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