Detecção de impacto com lasers

Neste tutorial, você aprenderá como lançar um laser do blaster em Criar ferramentas para jogadores e detectar se ele atinge um jogador.

Raycasting para encontrar colisões

Raycasting cria um raio invisível a partir de uma posição inicial em direção a uma determinada direção com um comprimento definido. Se o raio colidir com objetos ou terreno em seu caminho, ele retornará informações sobre a colisão, como a posição e o objeto com o qual colidiu.

Encontrar a localização do mouse

Antes que um laser possa ser disparado, você deve primeiro saber onde o jogador está mirando. Isso pode ser encontrado fazendo raycasting a partir da localização 2D do mouse do jogador na tela diretamente para frente a partir da câmera no mundo 3D. O raio colidirá com o que o jogador está mirando com o mouse.

1. Abra o script ToolController dentro da ferramenta Blaster em Criar ferramentas para jogadores. Se você ainda não completou esse tutorial, pode baixar o modelo Blaster e inseri-lo no StarterPack.

   

   Modelos podem ser adicionados ao seu Inventário para serem usados entre qualquer jogo.

   1. Em um navegador, abra a página do modelo, clique no botão Obter. Isso adiciona o modelo ao seu inventário.
   2. No menu Janela do Studio ou na barra de ferramentas da aba Início, abra a Caixa de Ferramentas e selecione a aba Inventário.
   3. Certifique-se de que o dropdown esteja em Meus Modelos.
   4. Selecione o modelo Blaster para adicioná-lo ao StarterPack.

2. No topo do script, declare uma constante chamada MAX_MOUSE_DISTANCE com um valor de 1000.

3. Crie uma função chamada getWorldMousePosition.

   local tool = script.Parent
   
   local MAX_MOUSE_DISTANCE = 1000
   
   local function getWorldMousePosition()
   
   end
   
   local function toolEquipped()
   	tool.Handle.Equip:Play()
   end
   
   local function toolActivated()
   	tool.Handle.Activate:Play()
   end
   
   -- Conectar eventos às funções apropriadas
   tool.Equipped:Connect(toolEquipped)
   tool.Activated:Connect(toolActivated)

4. Use a função GetMouseLocation de UserInputService para obter a localização 2D do mouse do jogador na tela. Atribua isso a uma variável chamada mouseLocation.

   local UserInputService = game:GetService("UserInputService")
   
   local tool = script.Parent
   
   local MAX_MOUSE_DISTANCE = 1000
   
   local function getWorldMousePosition()
   	local mouseLocation = UserInputService:GetMouseLocation()
   end

Agora que a localização 2D do mouse é conhecida, suas propriedades X e Y podem ser usadas como parâmetros para a função Camera:ViewportPointToRay(), que cria um Ray da tela para o mundo 3D.

1. Use as propriedades X e Y de mouseLocation como argumentos para a função ViewportPointToRay(). Atribua isso a uma variável chamada screenToWorldRay.

   local function getWorldMousePosition()
   	local mouseLocation = UserInputService:GetMouseLocation()
   
   	-- Criar um raio a partir da localização 2D do mouse
   	local screenToWorldRay = workspace.CurrentCamera:ViewportPointToRay(mouseLocation.X, mouseLocation.Y)
   end

É hora de usar a função Raycast para verificar se o raio atinge um objeto. Isso requer uma posição inicial e um vetor de direção: neste exemplo, você usará as propriedades origin e direction de screenToWorldRay.

O comprimento do vetor de direção determina quão longe o raio viajará. O raio precisa ser tão longo quanto o MAX_MOUSE_DISTANCE, então você terá que multiplicar o vetor de direção por MAX_MOUSE_DISTANCE.

1. Declare uma variável chamada directionVector e atribua a ela o valor de screenToWorldRay.Direction multiplicado por MAX_MOUSE_DISTANCE.

   local function getWorldMousePosition()
       local mouseLocation = UserInputService:GetMouseLocation()
   
       -- Criar um raio a partir da localização 2D do mouse
       local screenToWorldRay = workspace.CurrentCamera:ViewportPointToRay(mouseLocation.X, mouseLocation.Y)
   
       -- O vetor de direção unitário do raio multiplicado por uma distância máxima
       local directionVector = screenToWorldRay.Direction * MAX_MOUSE_DISTANCE

2. Chame a função Raycast do workspace, passando a propriedade Origin de screenToWorldRay como o primeiro argumento e directionVector como o segundo. Atribua isso a uma variável chamada raycastResult.

   local function getWorldMousePosition()
       local mouseLocation = UserInputService:GetMouseLocation()
   
       -- Criar um raio a partir da localização 2D do mouse
       local screenToWorldRay = workspace.CurrentCamera:ViewportPointToRay(mouseLocation.X, mouseLocation.Y)
   
       -- O vetor de direção unitário do raio multiplicado por uma distância máxima
       local directionVector = screenToWorldRay.Direction * MAX_MOUSE_DISTANCE
   
       -- Raycast da origem do raio em direção à sua direção
       local raycastResult = workspace:Raycast(screenToWorldRay.Origin, directionVector)

Informações de colisão

Se a operação de raycast encontrar um objeto atingido pelo raio, ela retornará um RaycastResult, que contém informações sobre a colisão entre o raio e o objeto.

A propriedade Position será a posição do objeto que o mouse está pairando. Se o mouse não estiver pairando sobre nenhum objeto dentro de uma distância de MAX_MOUSE_DISTANCE, raycastResult será nil.

1. Crie uma instrução if para verificar se raycastResult existe.

2. Se raycastResult tiver um valor, retorne sua propriedade Position.

3. Se raycastResult for nil, então encontre o final do raycast. Calcule a posição 3D do mouse somando screenToWorldRay.Origin e directionVector.

local function getWorldMousePosition()
	local mouseLocation = UserInputService:GetMouseLocation()

	-- Criar um raio a partir da localização 2D do mouse
	local screenToWorldRay = workspace.CurrentCamera:ViewportPointToRay(mouseLocation.X, mouseLocation.Y)

	-- O vetor de direção unitário do raio multiplicado por uma distância máxima
	local directionVector = screenToWorldRay.Direction * MAX_MOUSE_DISTANCE

	-- Raycast da origem do raio em direção à sua direção
	local raycastResult = workspace:Raycast(screenToWorldRay.Origin, directionVector)

	if raycastResult then
		-- Retornar o ponto 3D de interseção
		return raycastResult.Position
	else
		-- Nenhum objeto foi atingido, então calcule a posição no final do raio
		return screenToWorldRay.Origin + directionVector
	end
end

Disparar em direção ao alvo

Agora que a posição 3D do mouse é conhecida, ela pode ser usada como uma posição alvo para disparar um laser. Um segundo raio pode ser lançado entre a arma do jogador e a posição alvo usando a função Raycast.

1. Declare uma constante chamada MAX_LASER_DISTANCE no topo do script e atribua a ela 500, ou seu alcance escolhido para o blaster a laser.

   local UserInputService = game:GetService("UserInputService")
   
   local tool = script.Parent
   
   local MAX_MOUSE_DISTANCE = 1000
   local MAX_LASER_DISTANCE = 500

2. Crie uma função chamada fireWeapon abaixo da função getWorldMousePosition.

3. Chame getWorldMousePosition e atribua o resultado a uma variável chamada mousePosition. Esta será a posição alvo para o raycast.

   -- Nenhum objeto foi atingido, então calcule a posição no final do raio
           return screenToWorldRay.Origin + directionVector
       end
   end
   
   local function fireWeapon()
       local mouseLocation = getWorldMousePosition()
   end
   
   local function toolEquipped()
       tool.Handle.Equip:Play()
   end

Desta vez, o vetor de direção para a função raycast representará a direção da posição da ferramenta do jogador até a localização alvo.

1. Declare uma variável chamada targetDirection e calcule o vetor de direção subtraindo a posição da ferramenta de mouseLocation.

2. Normalize o vetor usando sua propriedade Unit. Isso lhe dará uma magnitude de 1, o que facilita a multiplicação por um comprimento mais tarde.

   local function fireWeapon()
   	local mouseLocation = getWorldMousePosition()
   
   	-- Calcular um vetor de direção normalizado e multiplicar pela distância do laser
   	local targetDirection = (mouseLocation - tool.Handle.Position).Unit
   end

3. Declare uma variável chamada directionVector e atribua a ela o targetDirection multiplicado pelo MAX_LASER_DISTANCE.

   local targetDirection = (mouseLocation - tool.Handle.Position).Unit
   
       -- A direção para disparar a arma, multiplicada por uma distância máxima
       local directionVector = targetDirection * MAX_LASER_DISTANCE
   end

Um objeto RaycastParams pode ser usado para armazenar parâmetros adicionais para a função raycast. Ele será usado em seu blaster a laser para garantir que o raycast não colida acidentalmente com o jogador que está disparando a arma. Quaisquer partes incluídas na propriedade FilterDescendantsInstances de um objeto RaycastParams serão ignoradas no raycast.

1. Continue a função fireWeapon e declare uma variável chamada weaponRaycastParams. Atribua um novo objeto RaycastParams a ela.

2. Crie uma tabela contendo o personagem local do jogador e atribua-a à propriedade weaponRaycastParams.FilterDescendantsInstances.

3. Raycast a partir da posição da ferramenta do jogador, em uma direção em direção ao directionVector. Lembre-se de adicionar weaponRaycastParams como um argumento desta vez. Atribua isso a uma variável chamada weaponRaycastResult.

local UserInputService = game:GetService("UserInputService")
local Players = game:GetService("Players")

local tool = script.Parent

local MAX_MOUSE_DISTANCE = 1000
local MAX_LASER_DISTANCE = 500

local function getWorldMousePosition()

local function fireWeapon()
	local mouseLocation = getWorldMousePosition()

	-- Calcular um vetor de direção normalizado e multiplicar pela distância do laser
	local targetDirection = (mouseLocation - tool.Handle.Position).Unit

	-- A direção para disparar a arma multiplicada por uma distância máxima
	local directionVector = targetDirection * MAX_LASER_DISTANCE

	-- Ignorar o personagem do jogador para evitar que ele se danifique
	local weaponRaycastParams = RaycastParams.new()
	weaponRaycastParams.FilterDescendantsInstances = {Players.LocalPlayer.Character}
	local weaponRaycastResult = workspace:Raycast(tool.Handle.Position, directionVector, weaponRaycastParams)
end

Finalmente, você precisará verificar se a operação de raycast retornou um valor. Se um valor for retornado, um objeto foi atingido pelo raio e um laser pode ser criado entre a arma e o local atingido. Se nada for retornido, a posição final precisa ser calculada para criar o laser.

1. Declare uma variável vazia chamada hitPosition.

2. Use uma instrução if para verificar se weaponRaycastResult tem um valor. Se um objeto foi atingido, atribua weaponRaycastResult.Position a hitPosition.

   local weaponRaycastResult = workspace:Raycast(tool.Handle.Position, directionVector, weaponRaycastParams)
   
   -- Verifique se algum objeto foi atingido entre a posição inicial e final
   local hitPosition
   if weaponRaycastResult then
   	hitPosition = weaponRaycastResult.Position
   end

3. Se weaponRaycastResult não tiver valor, calcule a posição final do raycast somando a posição da ferramenta com o directionVector. Atribua isso a hitPosition.

   local weaponRaycastResult = workspace:Raycast(tool.Handle.Position, directionVector, weaponRaycastParams)
   
       -- Verifique se algum objeto foi atingido entre a posição inicial e final
       local hitPosition
       if weaponRaycastResult then
           hitPosition = weaponRaycastResult.Position
       else
           -- Calcule a posição final com base na distância máxima do laser
           hitPosition = tool.Handle.Position + directionVector
       end
   end

4. Navegue até a função toolActivated e chame a função fireWeapon para que o laser dispare toda vez que a ferramenta for ativada.

   local function toolActivated()
   	tool.Handle.Activate:Play()
   	fireWeapon()
   end

Verificar o objeto atingido

Para descobrir se o objeto atingido pelo laser é parte do personagem de um jogador ou apenas um pedaço de cenário, você precisará procurar um Humanoid, já que todo personagem possui um.

Primeiro, você precisará encontrar o modelo do personagem. Se uma parte do personagem foi atingida, você não pode assumir que o pai do objeto atingido seria o personagem. O laser poderia ter atingido uma parte do corpo, um acessório ou uma ferramenta, todos os quais estão localizados em diferentes partes da hierarquia do personagem.

Você pode usar FindFirstAncestorOfClass para encontrar um ancestral do modelo do personagem do objeto atingido pelo laser, se existir. Se você encontrar um modelo e ele contiver um humanoide, na maioria dos casos você pode assumir que é um personagem.

1. Adicione o código destacado abaixo à instrução if de weaponRaycastResult para verificar se um personagem foi atingido.

   -- Verifique se algum objeto foi atingido entre a posição inicial e final
   local hitPosition
   if weaponRaycastResult then
   	hitPosition = weaponRaycastResult.Position
   
   	-- A instância atingida será uma criança de um modelo de personagem
   	-- Se um humanoide for encontrado no modelo, então é provável que seja o personagem de um jogador
   	local characterModel = weaponRaycastResult.Instance:FindFirstAncestorOfClass("Model")
   	if characterModel then
   		local humanoid = characterModel:FindFirstChildWhichIsA("Humanoid")
   		if humanoid then
   			print("Jogador atingido")
   		end
   	end
   else
   	-- Calcule a posição final com base na distância máxima do laser
   	hitPosition = tool.Handle.Position + directionVector
   end

Agora o blaster a laser deve imprimir Jogador atingido na janela Output toda vez que a operação de raycast atinge outro jogador.

Testar com múltiplos jogadores

Dois jogadores são necessários para testar se o raycast da arma está encontrando outros jogadores, então você precisa iniciar um servidor local. Veja simulação de múltiplos clientes para instruções.

Em um cliente, teste disparar no outro jogador com a arma clicando nele. "Jogador atingido" deve ser exibido na saída toda vez que um jogador for atingido.

Encontrar a posição do laser

O blaster deve disparar um feixe de luz vermelho em seu alvo. A função para isso estará dentro de um ModuleScript para que possa ser reutilizada em outros scripts mais tarde. Primeiro, o script precisará encontrar a posição onde o feixe de laser deve ser renderizado.

1. Crie um ModuleScript chamado LaserRenderer, parentado a StarterPlayerScripts sob StarterPlayer.

   

2. Abra o script e renomeie a tabela do módulo para o nome do script LaserRenderer.

3. Declare uma variável chamada SHOT_DURATION com um valor de 0.15. Este será o tempo (em segundos) que o laser será visível.

4. Crie uma função de LaserRenderer chamada createLaser com dois parâmetros chamados toolHandle e endPosition.

   local LaserRenderer = {}
   
   local SHOT_DURATION = 0.15 -- Tempo que o laser é visível
   
   -- Criar um feixe de laser de uma posição inicial em direção a uma posição final
   function LaserRenderer.createLaser(toolHandle, endPosition)
   
   end
   
   return LaserRenderer

5. Declare uma variável chamada startPosition e defina a propriedade Position de toolHandle como seu valor. Esta será a posição do blaster a laser do jogador.

6. Declare uma variável chamada laserDistance e subtraia endPosition de startPosition para encontrar a diferença entre os dois vetores. Use a propriedade Magnitude disso para obter o comprimento do feixe de laser.

   function LaserRenderer.createLaser(toolHandle, endPosition)
   	local startPosition = toolHandle.Position
   
   	local laserDistance = (startPosition - endPosition).Magnitude
   end

7. Declare uma variável laserCFrame para armazenar a posição e orientação do feixe de laser. A posição precisa ser o ponto médio do início e do fim do feixe. Use CFrame.lookAt para criar um novo CFrame localizado em startPosition e voltado para endPosition. Multiplique isso por um novo CFrame com um valor de eixo Z de metade do negativo de laserDistance para obter o ponto médio.

   

   function LaserRenderer.createLaser(toolHandle, endPosition)
   	local startPosition = toolHandle.Position
   
   	local laserDistance = (startPosition - endPosition).Magnitude
   	local laserCFrame = CFrame.lookAt(startPosition, endPosition) * CFrame.new(0, 0, -laserDistance / 2)
   end

Criar a parte do laser

Agora que você sabe onde criar um feixe de laser, precisa adicionar o próprio feixe. Isso pode ser feito facilmente com uma parte Neon.

1. Declare uma variável laserPart e atribua a ela uma nova instância de Part.

2. Defina as seguintes propriedades de laserPart:

   1. Size: Vector3.new(0.2, 0.2, laserDistance)
   2. CFrame: laserCFrame
   3. Anchored: true
   4. CanCollide: false
   5. Color: Color3.fromRGB(225, 0, 0) (uma cor vermelha forte)
   6. Material: Enum.Material.Neon

3. Parent laserPart a Workspace.

4. Adicione a parte ao serviço Debris para que ela seja removida após a quantidade de segundos na variável SHOT_DURATION.

   function LaserRenderer.createLaser(toolHandle, endPosition)
   	local startPosition = toolHandle.Position
   
   	local laserDistance = (startPosition - endPosition).Magnitude
   	local laserCFrame = CFrame.lookAt(startPosition, endPosition) * CFrame.new(0, 0, -laserDistance / 2)
   
   	local laserPart = Instance.new("Part")
   	laserPart.Size = Vector3.new(0.2, 0.2, laserDistance)
   	laserPart.CFrame = laserCFrame
   	laserPart.Anchored = true
   	laserPart.CanCollide = false
   	laserPart.Color = Color3.fromRGB(225, 0, 0)
   	laserPart.Material = Enum.Material.Neon
   	laserPart.Parent = workspace
   
   	-- Adicionar feixe de laser ao serviço Debris para ser removido e limpo
   	Debris:AddItem(laserPart, SHOT_DURATION)
   end

Agora a função para renderizar o feixe de laser está completa, ela pode ser chamada pelo ToolController.

1. No topo do script ToolController, declare uma variável chamada LaserRenderer e requer o módulo LaserRenderer localizado em PlayerScripts.

   local UserInputService = game:GetService("UserInputService")
   local Players = game:GetService("Players")
   
   local LaserRenderer = require(Players.LocalPlayer.PlayerScripts.LaserRenderer)
   
   local tool = script.Parent

2. No final da função fireWeapon, chame a função createLaser do LaserRenderer usando o punho da ferramenta e hitPosition como argumentos.

   -- Calcule a posição final com base na distância máxima do laser
           hitPosition = tool.Handle.Position + directionVector
       end
   
       LaserRenderer.createLaser(tool.Handle, hitPosition)
   end

3. Teste a arma clicando no botão Play. Um feixe de laser deve ser visível entre a arma e o mouse quando a ferramenta for ativada.

Controlar a taxa de disparo da arma

As armas precisam de um atraso entre cada disparo para impedir que os jogadores causem muito dano em um curto espaço de tempo. Isso pode ser controlado verificando se tempo suficiente passou desde que um jogador disparou pela última vez.

1. Declare uma variável no topo do ToolController chamada FIRE_RATE. Este será o tempo mínimo entre cada disparo. Dê a ela um valor de sua escolha; este exemplo usa 0.3 segundos.

2. Declare outra variável abaixo chamada timeOfPreviousShot com um valor de 0. Isso armazena o último momento em que o jogador disparou e será atualizado a cada disparo.

   local MAX_MOUSE_DISTANCE = 1000
   local MAX_LASER_DISTANCE = 300
   local FIRE_RATE = 0.3
   local timeOfPreviousShot = 0

3. Crie uma função chamada canShootWeapon sem parâmetros. Esta função verificará quanto tempo passou desde o disparo anterior e retornará verdadeiro ou falso.

   local FIRE_RATE = 0.3
   local timeOfPreviousShot = 0
   
   -- Verifique se tempo suficiente passou desde o último disparo
   local function canShootWeapon()
   
   end
   
   local function getWorldMousePosition()

4. Dentro da função, declare uma variável chamada currentTime; atribua a ela o resultado da chamada da função tick(). Isso retorna quanto tempo se passou, em segundos, desde 1º de janeiro de 1970 (uma data arbitrária amplamente utilizada para calcular o tempo).

5. Subtraia timeOfPreviousShot de currentTime e retorne falso se o resultado for menor que FIRE_RATE; caso contrário, retorne verdadeiro.

   -- Verifique se tempo suficiente passou desde o último disparo
   local function canShootWeapon()
   	local currentTime = tick()
   	if currentTime - timeOfPreviousShot < FIRE_RATE then
   		return false
   	end
   	return true
   end

6. No final da função fireWeapon, atualize timeOfPreviousShot toda vez que a arma for disparada usando tick.

   hitPosition = tool.Handle.Position + directionVector
       end
   
       timeOfPreviousShot = tick()
   
       LaserRenderer.createLaser(tool.Handle, hitPosition)
   end

7. Dentro da função toolActivated, crie uma instrução if e chame canShootWeapon para verificar se a arma pode ser disparada.

   local function toolActivated()
   	if canShootWeapon() then
   		tool.Handle.Activate:Play()
   		fireWeapon()
   	end
   end

Quando você testar o blaster, deve descobrir que não importa quão rápido você clique, sempre haverá um pequeno atraso de 0,3 segundos entre cada disparo.

Danificar o jogador

Os clientes não podem danificar outros clientes diretamente; o servidor precisa ser responsável por emitir dano quando um jogador é atingido.

Os clientes podem usar um RemoteEvent para informar ao servidor que um personagem foi atingido. Esses eventos devem ser armazenados em ReplicatedStorage, onde são visíveis tanto para o cliente quanto para o servidor.

1. Crie uma Pasta em ReplicatedStorage chamada Events.

   

2. Insira um RemoteEvent na pasta Events e nomeie-o DamageCharacter.

   

3. No ToolController, crie variáveis no início do script para ReplicatedStorage e a pasta Events.

   local UserInputService = game:GetService("UserInputService")
   local Players = game:GetService("Players")
   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   
   local LaserRenderer = require(Players.LocalPlayer.PlayerScripts.LaserRenderer)
   
   local tool = script.Parent
   local eventsFolder = ReplicatedStorage.Events
   
   local MAX_MOUSE_DISTANCE = 1000
   local MAX_LASER_DISTANCE = 500

4. Substitua a instrução de impressão "Jogador atingido" em fireWeapon por uma linha de Luau para disparar o evento remoto DamageCharacter com a variável characterModel como argumento.

   local characterModel = weaponRaycastResult.Instance:FindFirstAncestorOfClass("Model")
       if characterModel then
           local humanoid = characterModel:FindFirstChildWhichIsA("Humanoid")
           if humanoid then
               eventsFolder.DamageCharacter:FireServer(characterModel, hitPosition)
           end
       end
   else
       -- Calcule a posição final com base na distância máxima do laser
       hitPosition = tool.Handle.Position + directionVector
   end

O servidor precisa lidar com o dano ao jogador que foi atingido quando o evento é disparado.

1. Insira um Script no ServerScriptService e nomeie-o ServerLaserManager.

   

2. Declare uma variável chamada LASER_DAMAGE e defina-a como 10, ou um valor de sua escolha.

3. Crie uma função chamada damageCharacter com dois parâmetros chamados playerFired e characterToDamage.

4. Dentro da função, encontre o Humanoid do personagem e subtraia LASER_DAMAGE de sua saúde.

5. Conecte a função damageCharacter ao evento remoto DamageCharacter na pasta Events.

   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   local eventsFolder = ReplicatedStorage.Events
   local LASER_DAMAGE = 10
   
   function damageCharacter(playerFired, characterToDamage)
   	local humanoid = characterToDamage:FindFirstChildWhichIsA("Humanoid")
   	if humanoid then
   		-- Remover saúde do personagem
   		humanoid.Health -= LASER_DAMAGE
   	end
   end
   
   -- Conectar eventos às funções apropriadas
   eventsFolder.DamageCharacter.OnServerEvent:Connect(damageCharacter)

6. Teste o blaster com 2 jogadores iniciando um servidor local. Quando você atirar no outro jogador, a saúde dele diminuirá pelo valor atribuído a LASER_DAMAGE.

Renderizar os feixes de laser de outros jogadores

Atualmente, o feixe de laser é criado pelo cliente que dispara a arma, então apenas ele poderá ver o feixe de laser.

Se o feixe de laser fosse criado no servidor, então todos poderiam vê-lo. No entanto, haveria um pequeno atraso entre o cliente disparando a arma e o servidor recebendo a informação sobre o disparo. Isso significaria que o cliente disparando a arma veria um atraso entre quando ativa a arma e quando vê o feixe de laser; a arma pareceria lenta como resultado.

Para resolver esse problema, cada cliente criará seus próprios feixes de laser. Isso significa que o cliente disparando a arma verá o feixe de laser instantaneamente. Outros clientes experimentarão um pequeno atraso entre quando outro jogador dispara e um feixe aparece. Este é o melhor cenário: não há como comunicar o laser de um cliente a outros clientes mais rápido.

Cliente do atirador

Primeiro, o cliente precisa informar ao servidor que disparou um laser e fornecer a posição final.

1. Insira um RemoteEvent na pasta Events em ReplicatedStorage e nomeie-o LaserFired.

   

2. Localize a função fireWeapon no script ToolController. No final da função, dispare o evento remoto LaserFired usando hitPosition como argumento.

   hitPosition = tool.Handle.Position + directionVector
       end
   
       timeOfPreviousShot = tick()
   
       eventsFolder.LaserFired:FireServer(hitPosition)
       LaserRenderer.createLaser(tool.Handle, hitPosition)
   end

O servidor

O servidor agora deve receber o evento de que o cliente disparou e informar a todos os clientes a posição inicial e final do feixe de laser para que eles também possam renderizá-lo.

1. No script ServerLaserManager, crie uma função chamada playerFiredLaser acima de damageCharacter com dois parâmetros chamados playerFired e endPosition.

2. Conecte a função ao evento remoto LaserFired.

   -- Notificar todos os clientes que um laser foi disparado para que possam exibir o laser
   local function playerFiredLaser(playerFired, endPosition)
   
   end

   -- Conectar eventos às funções apropriadas
   eventsFolder.DamageCharacter.OnServerEvent:Connect(damageCharacter)
   eventsFolder.LaserFired.OnServerEvent:Connect(playerFiredLaser)

O servidor precisa da posição inicial do laser. Isso poderia ser enviado do cliente, mas é melhor evitar confiar no cliente sempre que possível. A posição da ferramenta do personagem será a posição inicial, então o servidor pode encontrá-la a partir daí.

1. Crie uma função getPlayerToolHandle acima da função playerFiredLaser com um parâmetro chamado player.

2. Use o seguinte código para procurar a ferramenta do jogador e retornar o objeto do punho.

   local LASER_DAMAGE = 10
   
   -- Encontrar o punho da ferramenta que o jogador está segurando
   local function getPlayerToolHandle(player)
       local weapon = player.Character:FindFirstChildOfClass("Tool")
       if weapon then
           return weapon:FindFirstChild("Handle")
       end
   end
   
   -- Notificar todos os clientes que um laser foi disparado para que possam exibir o laser
   local function playerFiredLaser(playerFired, endPosition)

O servidor agora pode chamar FireAllClients no evento remoto LaserFired para enviar as informações necessárias para renderizar o laser aos clientes. Isso inclui o jogador que disparou o laser (para que o cliente desse jogador não renderize o laser duas vezes), o punho do blaster (que atua como uma posição inicial para o laser) e a posição final do laser.

1. Na função playerFiredLaser, chame a função getPlayerToolHandle com playerFired como argumento e atribua o valor a uma variável chamada toolHandle.

2. Se toolHandle existir, dispare o evento LaserFired para todos os clientes usando playerFired, toolHandle e endPosition como argumentos.

   -- Notificar todos os clientes que um laser foi disparado para que possam exibir o laser
   local function playerFiredLaser(playerFired, endPosition)
   	local toolHandle = getPlayerToolHandle(playerFired)
   	if toolHandle then
   		eventsFolder.LaserFired:FireAllClients(playerFired, toolHandle, endPosition)
   	end
   end

Renderizar nos clientes

Agora que FireAllClients foi chamado, cada cliente receberá um evento do servidor para renderizar um feixe de laser. Cada cliente pode reutilizar o módulo LaserRenderer de antes para renderizar o feixe de laser usando a posição do punho da ferramenta e o valor da posição final enviado pelo servidor. O jogador que disparou o feixe de laser inicialmente deve ignorar este evento, caso contrário, verá 2 lasers.

1. Crie um LocalScript em StarterPlayerScripts chamado ClientLaserManager.

   

2. Dentro do script, requer o módulo LaserRenderer.

3. Crie uma função chamada createPlayerLaser com os parâmetros playerWhoShot, toolHandle e endPosition.

4. Conecte a função ao evento remoto LaserFired na pasta Events.

5. Na função, use uma instrução if para verificar se playerWhoShot é diferente de LocalPlayer.

6. Dentro da instrução if, chame a função createLaser do módulo LaserRenderer usando toolHandle e endPosition como argumentos.

   local Players = game:GetService("Players")
   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   
   local LaserRenderer = require(script.Parent:WaitForChild("LaserRenderer"))
   
   local eventsFolder = ReplicatedStorage.Events
   
   -- Exibir o laser de outro jogador
   local function createPlayerLaser(playerWhoShot, toolHandle, endPosition)
   	if playerWhoShot ~= Players.LocalPlayer then
   		LaserRenderer.createLaser(toolHandle, endPosition)
   	end
   end
   
   eventsFolder.LaserFired.OnClientEvent:Connect(createPlayerLaser)

7. Teste o blaster com 2 jogadores iniciando um servidor local. Posicione cada cliente em lados diferentes do seu monitor para que você possa ver ambas as janelas ao mesmo tempo. Quando você atirar em um cliente, deve ver o laser no outro cliente.

Efeitos sonoros

O efeito sonoro de disparo atualmente só toca no cliente que está disparando o projétil. Você precisará mover o código para tocar o som para que outros jogadores também o ouçam.

1. No script ToolController, navegue até a função toolActivated e remova a linha que toca o som de Ativação.

   local function toolActivated()
   	if canShootWeapon() then
   		fireWeapon()
   	end
   end

2. No final da função createLaser em LaserRenderer, declare uma variável chamada shootingSound e use o método FindFirstChild() de toolHandle para verificar o som de Ativação.

3. Use uma instrução if para verificar se shootingSound existe; se existir, chame sua função Play().

   laserPart.Parent = workspace
   
       -- Adicionar feixe de laser ao serviço Debris para ser removido e limpo
       Debris:AddItem(laserPart, SHOT_DURATION)
   
       -- Tocar o som de disparo da arma
       local shootingSound = toolHandle:FindFirstChild("Activate")
       if shootingSound then
           shootingSound:Play()
       end
   end

Proteger remotos usando validação

Se o servidor não estiver verificando os dados de solicitações recebidas, um hacker pode abusar de funções e eventos remotos e usá-los para enviar valores falsos ao servidor. É importante usar validação do lado do servidor para evitar isso.

Na sua forma atual, o evento remoto DamageCharacter é muito vulnerável a ataques. Hackers poderiam usar esse evento para danificar qualquer jogador que quisessem sem atingi-los.

A validação é o processo de verificar se os valores enviados ao servidor são realistas. Neste caso, o servidor precisará:

• Verificar se a distância entre o jogador e a posição atingida pelo laser está dentro de um certo limite.
• Fazer raycast entre a arma que disparou o laser e a posição atingida para garantir que o disparo foi possível e não passou por nenhuma parede.

Cliente

O cliente precisa enviar ao servidor a posição atingida pelo raycast para que ele possa verificar se a distância é realista.

1. No ToolController, navegue até a linha onde o evento remoto DamageCharacter é disparado na função fireWeapon.

2. Adicione hitPosition como um argumento.

   if characterModel then
   	local humanoid = characterModel:FindFirstChildWhichIsA("Humanoid")
   	if humanoid then
   		eventsFolder.DamageCharacter:FireServer(characterModel, hitPosition)
   	end
   end

Servidor

O cliente agora está enviando um parâmetro extra através do evento remoto DamageCharacter, então o ServerLaserManager precisa ser ajustado para aceitá-lo.

1. No script ServerLaserManager, adicione um parâmetro hitPosition à função damageCharacter.

   function damageCharacter(playerFired, characterToDamage, hitPosition)
   	local humanoid = characterToDamage:FindFirstChildWhichIsA("Humanoid")
   	if humanoid then
   		-- Remover saúde do personagem
   		humanoid.Health -= LASER_DAMAGE
   	end
   end

2. Abaixo da função getPlayerToolHandle, crie uma função chamada isHitValid com três parâmetros: playerFired, characterToDamage e hitPosition.

   end
   
   local function isHitValid(playerFired, characterToDamage, hitPosition)
   
   end

A primeira verificação será a distância entre a posição atingida e o personagem atingido.

1. Declare uma variável chamada MAX_HIT_PROXIMITY no topo do script e atribua a ela um valor de 10. Esta será a distância máxima permitida entre o atingido e o personagem. Uma tolerância é necessária porque o personagem pode ter se movido ligeiramente desde que o cliente disparou o evento.

   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   local eventsFolder = ReplicatedStorage.Events
   local LASER_DAMAGE = 10
   local MAX_HIT_PROXIMITY = 10

2. Na função isHitValid, calcule a distância entre o personagem e a posição atingida. Se a distância for maior que MAX_HIT_PROXIMITY, retorne falso.

   local function isHitValid(playerFired, characterToDamage, hitPosition)
   	-- Validar a distância entre o personagem atingido e a posição atingida
   	local characterHitProximity = (characterToDamage.HumanoidRootPart.Position - hitPosition).Magnitude
   	if characterHitProximity > MAX_HIT_PROXIMITY then
   		return false
   	end
   end

A segunda verificação envolverá um raycast entre a arma disparada e a posição atingida. Se o raycast retornar um objeto que não seja o personagem, você pode assumir que o disparo não foi válido, pois algo estava bloqueando o disparo.

1. Copie o código abaixo para realizar essa verificação. Retorne verdadeiro no final da função: se chegar ao final, todas as verificações passaram.

   local function isHitValid(playerFired, characterToDamage, hitPosition)
   	-- Validar a distância entre o personagem atingido e a posição atingida
   	local characterHitProximity = (characterToDamage.HumanoidRootPart.Position - hitPosition).Magnitude
   	if characterHitProximity > 10 then
   		return false
   	end
   
   	-- Verifique se está disparando através de paredes
   	local toolHandle = getPlayerToolHandle(playerFired)
   	if toolHandle then
   		local rayLength = (hitPosition - toolHandle.Position).Magnitude
   		local rayDirection = (hitPosition - toolHandle.Position).Unit
   		local raycastParams = RaycastParams.new()
   		raycastParams.FilterDescendantsInstances = {playerFired.Character}
   		local rayResult = workspace:Raycast(toolHandle.Position, rayDirection * rayLength, raycastParams)
   
   		-- Se uma instância foi atingida que não era o personagem, então ignore o disparo
   		if rayResult and not rayResult.Instance:IsDescendantOf(characterToDamage) then
   			return false
   		end
   	end
   
   	return true
   end

2. Declare uma variável na função damageCharacter chamada validShot. Atribua a ela o resultado de uma chamada à função isHitValid com três argumentos: playerFired, characterToDamage e hitPosition.

3. Na instrução if abaixo, adicione um operador and para verificar se validShot é verdadeiro.

   function damageCharacter(playerFired, characterToDamage, hitPosition)
   	local humanoid = characterToDamage:FindFirstChildWhichIsA("Humanoid")
   	local validShot = isHitValid(playerFired, characterToDamage, hitPosition)
   	if humanoid and validShot then
   		-- Remover saúde do personagem
   		humanoid.Health -= LASER_DAMAGE
   	end
   end

Agora o evento remoto damageCharacter está mais seguro e evitará que a maioria dos jogadores o abuse. Observe que alguns jogadores maliciosos frequentemente encontrarão maneiras de contornar a validação; manter eventos remotos seguros é um esforço contínuo.

Seu blaster a laser agora está completo, com um sistema básico de detecção de impacto usando raycasting. Tente o tutorial Detectando Entrada do Usuário para descobrir como você pode adicionar uma ação de recarga ao seu blaster a laser, ou crie um mapa divertido e experimente seu blaster a laser com outros jogadores!

Código final

ToolController

local UserInputService = game:GetService("UserInputService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local LaserRenderer = require(Players.LocalPlayer.PlayerScripts.LaserRenderer)

local tool = script.Parent
local eventsFolder = ReplicatedStorage.Events

local MAX_MOUSE_DISTANCE = 1000
local MAX_LASER_DISTANCE = 500
local FIRE_RATE = 0.3
local timeOfPreviousShot = 0

-- Verifique se tempo suficiente passou desde o último disparo
local function canShootWeapon()
	local currentTime = tick()
	if currentTime - timeOfPreviousShot < FIRE_RATE then
		return false
	end
	return true
end

local function getWorldMousePosition()
	local mouseLocation = UserInputService:GetMouseLocation()

	-- Criar um raio a partir da localização 2D do mouse
	local screenToWorldRay = workspace.CurrentCamera:ViewportPointToRay(mouseLocation.X, mouseLocation.Y)

	-- O vetor de direção unitário do raio multiplicado por uma distância máxima
	local directionVector = screenToWorldRay.Direction * MAX_MOUSE_DISTANCE

	-- Raycast da origem do raio em direção à sua direção
	local raycastResult = workspace:Raycast(screenToWorldRay.Origin, directionVector)

	if raycastResult then
		-- Retornar o ponto 3D de interseção
		return raycastResult.Position
	else
		-- Nenhum objeto foi atingido, então calcule a posição no final do raio
		return screenToWorldRay.Origin + directionVector
	end
end

local function fireWeapon()
	local mouseLocation = getWorldMousePosition()

	-- Calcular um vetor de direção normalizado e multiplicar pela distância do laser
	local targetDirection = (mouseLocation - tool.Handle.Position).Unit

	-- A direção para disparar a arma, multiplicada por uma distância máxima
	local directionVector = targetDirection * MAX_LASER_DISTANCE

	-- Ignorar o personagem do jogador para evitar que ele se danifique
	local weaponRaycastParams = RaycastParams.new()
	weaponRaycastParams.FilterDescendantsInstances = {Players.LocalPlayer.Character}
	local weaponRaycastResult = workspace:Raycast(tool.Handle.Position, directionVector, weaponRaycastParams)

	-- Verifique se algum objeto foi atingido entre a posição inicial e final
	local hitPosition
	if weaponRaycastResult then
		hitPosition = weaponRaycastResult.Position

		-- A instância atingida será uma criança de um modelo de personagem
		-- Se um humanoide for encontrado no modelo, então é provável que seja o personagem de um jogador
		local characterModel = weaponRaycastResult.Instance:FindFirstAncestorOfClass("Model")
		if characterModel then
			local humanoid = characterModel:FindFirstChildWhichIsA("Humanoid")
			if humanoid then
				eventsFolder.DamageCharacter:FireServer(characterModel, hitPosition)
			end
		end
	else
		-- Calcule a posição final com base na distância máxima do laser
		hitPosition = tool.Handle.Position + directionVector
	end

	timeOfPreviousShot = tick()

	eventsFolder.LaserFired:FireServer(hitPosition)
	LaserRenderer.createLaser(tool.Handle, hitPosition)
end

local function toolEquipped()
	tool.Handle.Equip:Play()
end

local function toolActivated()
	if canShootWeapon() then
		fireWeapon()
	end
end

tool.Equipped:Connect(toolEquipped)
tool.Activated:Connect(toolActivated)

LaserRenderer

local LaserRenderer = {}

local Debris = game:GetService("Debris")

local SHOT_DURATION = 0.15 -- Tempo que o laser é visível

-- Criar um feixe de laser de uma posição inicial em direção a uma posição final
function LaserRenderer.createLaser(toolHandle, endPosition)
	local startPosition = toolHandle.Position

	local laserDistance = (startPosition - endPosition).Magnitude
	local laserCFrame = CFrame.lookAt(startPosition, endPosition) * CFrame.new(0, 0, -laserDistance / 2)

	local laserPart = Instance.new("Part")
	laserPart.Size = Vector3.new(0.2, 0.2, laserDistance)
	laserPart.CFrame = laserCFrame
	laserPart.Anchored = true
	laserPart.CanCollide = false
	laserPart.Color = Color3.fromRGB(255, 0, 0)
	laserPart.Material = Enum.Material.Neon
	laserPart.Parent = workspace

	-- Adicionar feixe de laser ao serviço Debris para ser removido e limpo
	Debris:AddItem(laserPart, SHOT_DURATION)

	-- Tocar o som de disparo da arma
	local shootingSound = toolHandle:FindFirstChild("Activate")
	if shootingSound then
		shootingSound:Play()
	end
end

return LaserRenderer

ServerLaserManager

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local eventsFolder = ReplicatedStorage.Events
local LASER_DAMAGE = 10
local MAX_HIT_PROXIMITY = 10

-- Encontrar o punho da ferramenta que o jogador está segurando
local function getPlayerToolHandle(player)
	local weapon = player.Character:FindFirstChildOfClass("Tool")
	if weapon then
		return weapon:FindFirstChild("Handle")
	end
end

local function isHitValid(playerFired, characterToDamage, hitPosition)
	-- Validar a distância entre o personagem atingido e a posição atingida
	local characterHitProximity = (characterToDamage.HumanoidRootPart.Position - hitPosition).Magnitude
	if characterHitProximity > MAX_HIT_PROXIMITY then
		return false
	end

	-- Verifique se está disparando através de paredes
	local toolHandle = getPlayerToolHandle(playerFired)
	if toolHandle then
		local rayLength = (hitPosition - toolHandle.Position).Magnitude
		local rayDirection = (hitPosition - toolHandle.Position).Unit
		local raycastParams = RaycastParams.new()
		raycastParams.FilterDescendantsInstances = {playerFired.Character}
		local rayResult = workspace:Raycast(toolHandle.Position, rayDirection * rayLength, raycastParams)

		-- Se uma instância foi atingida que não era o personagem, então ignore o disparo
		if rayResult and not rayResult.Instance:IsDescendantOf(characterToDamage) then
			return false
		end
	end

	return true
end

-- Notificar todos os clientes que um laser foi disparado para que possam exibir o laser
local function playerFiredLaser(playerFired, endPosition)
	local toolHandle = getPlayerToolHandle(playerFired)
	if toolHandle then
		eventsFolder.LaserFired:FireAllClients(playerFired, toolHandle, endPosition)
	end
end

function damageCharacter(playerFired, characterToDamage, hitPosition)
	local humanoid = characterToDamage:FindFirstChildWhichIsA("Humanoid")
	local validShot = isHitValid(playerFired, characterToDamage, hitPosition)
	if humanoid and validShot then
		-- Remover saúde do personagem
		humanoid.Health -= LASER_DAMAGE
	end
end

-- Conectar eventos às funções apropriadas
eventsFolder.DamageCharacter.OnServerEvent:Connect(damageCharacter)
eventsFolder.LaserFired.OnServerEvent:Connect(playerFiredLaser)

ClientLaserManager

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local LaserRenderer = require(Players.LocalPlayer.PlayerScripts:WaitForChild("LaserRenderer"))

local eventsFolder = ReplicatedStorage.Events

-- Exibir o laser de outro jogador
local function createPlayerLaser(playerWhoShot, toolHandle, endPosition)
	if playerWhoShot ~= Players.LocalPlayer then
		LaserRenderer.createLaser(toolHandle, endPosition)
	end
end

eventsFolder.LaserFired.OnClientEvent:Connect(createPlayerLaser)