Detección de impactos con láseres

En este tutorial, aprenderás cómo lanzar un láser desde el bláster en Crear herramientas para jugadores y detectar si golpea a un jugador o no.

Raycasting para encontrar colisiones

Raycasting crea un rayo invisible desde una posición de inicio hacia una dirección dada con una longitud definida. Si el rayo colisiona con objetos o terreno en su camino, devolverá información sobre la colisión, como la posición y el objeto con el que colisionó.

Encontrar la ubicación del mouse

Antes de que se pueda disparar un láser, primero debes saber hacia dónde está apuntando el jugador. Esto se puede encontrar haciendo un raycasting desde la ubicación 2D del mouse del jugador en la pantalla directamente hacia adelante desde la cámara en el mundo 3D. El rayo colisionará con lo que el jugador esté apuntando con el mouse.

1. Abre el script ToolController dentro de la herramienta Blaster de Crear herramientas para jugadores. Si aún no has completado ese tutorial, puedes descargar el modelo Blaster e insertarlo en StarterPack.

   

   Los modelos se pueden agregar a tu Inventario para ser utilizados entre cualquier juego.

   1. En un navegador, abre la página del modelo, haz clic en el botón Obtener. Esto agrega el modelo a tu inventario.
   2. Desde el menú Ventana de Studio o la barra de herramientas de la pestaña Inicio, abre el Toolbox y selecciona la pestaña Inventario.
   3. Asegúrate de que el menú desplegable esté en Mis Modelos.
   4. Selecciona el modelo Blaster para agregarlo al StarterPack.

2. En la parte superior del script, declara una constante llamada MAX_MOUSE_DISTANCE con un valor de 1000.

3. Crea una función llamada 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 a funciones apropiadas
   tool.Equipped:Connect(toolEquipped)
   tool.Activated:Connect(toolActivated)

4. Usa la función GetMouseLocation de UserInputService para obtener la ubicación 2D del mouse del jugador en la pantalla. Asigna esto a una variable llamada mouseLocation.

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

Ahora que se conoce la ubicación 2D del mouse, sus propiedades X y Y se pueden usar como parámetros para la función Camera:ViewportPointToRay(), que crea un Ray desde la pantalla hacia el mundo 3D.

1. Usa las propiedades X y Y de mouseLocation como argumentos para la función ViewportPointToRay(). Asigna esto a una variable llamada screenToWorldRay.

   local function getWorldMousePosition()
   	local mouseLocation = UserInputService:GetMouseLocation()
   
   	-- Crear un rayo desde la ubicación 2D del mouse
   	local screenToWorldRay = workspace.CurrentCamera:ViewportPointToRay(mouseLocation.X, mouseLocation.Y)
   end

Es hora de usar la función Raycast para verificar si el rayo golpea un objeto. Esto requiere una posición de inicio y un vector de dirección: en este ejemplo, usarás las propiedades origin y direction de screenToWorldRay.

La longitud del vector de dirección determina cuán lejos viajará el rayo. El rayo necesita ser tan largo como el MAX_MOUSE_DISTANCE, por lo que tendrás que multiplicar el vector de dirección por MAX_MOUSE_DISTANCE.

1. Declara una variable llamada directionVector y asígnale el valor de screenToWorldRay.Direction multiplicado por MAX_MOUSE_DISTANCE.

   local function getWorldMousePosition()
       local mouseLocation = UserInputService:GetMouseLocation()
   
       -- Crear un rayo desde la ubicación 2D del mouse
       local screenToWorldRay = workspace.CurrentCamera:ViewportPointToRay(mouseLocation.X, mouseLocation.Y)
   
       -- El vector de dirección unitario del rayo multiplicado por una distancia máxima
       local directionVector = screenToWorldRay.Direction * MAX_MOUSE_DISTANCE

2. Llama a la función Raycast de workspace, pasando la propiedad Origin de screenToWorldRay como el primer argumento y directionVector como el segundo. Asigna esto a una variable llamada raycastResult.

   local function getWorldMousePosition()
       local mouseLocation = UserInputService:GetMouseLocation()
   
       -- Crear un rayo desde la ubicación 2D del mouse
       local screenToWorldRay = workspace.CurrentCamera:ViewportPointToRay(mouseLocation.X, mouseLocation.Y)
   
       -- El vector de dirección unitario del rayo multiplicado por una distancia máxima
       local directionVector = screenToWorldRay.Direction * MAX_MOUSE_DISTANCE
   
       -- Raycast desde el origen del rayo hacia su dirección
       local raycastResult = workspace:Raycast(screenToWorldRay.Origin, directionVector)

Información de colisión

Si la operación de raycast encuentra un objeto golpeado por el rayo, devolverá un RaycastResult, que contiene información sobre la colisión entre el rayo y el objeto.

La propiedad Position será la posición del objeto sobre el que el mouse está flotando. Si el mouse no está flotando sobre ningún objeto dentro de una distancia de MAX_MOUSE_DISTANCE, raycastResult será nil.

1. Crea una declaración if para verificar si raycastResult existe.

2. Si raycastResult tiene un valor, devuelve su propiedad Position.

3. Si raycastResult es nil, entonces encuentra el final del raycast. Calcula la posición 3D del mouse sumando screenToWorldRay.Origin y directionVector.

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

	-- Crear un rayo desde la ubicación 2D del mouse
	local screenToWorldRay = workspace.CurrentCamera:ViewportPointToRay(mouseLocation.X, mouseLocation.Y)

	-- El vector de dirección unitario del rayo multiplicado por una distancia máxima
	local directionVector = screenToWorldRay.Direction * MAX_MOUSE_DISTANCE

	-- Raycast desde el origen del rayo hacia su dirección
	local raycastResult = workspace:Raycast(screenToWorldRay.Origin, directionVector)

	if raycastResult then
		-- Devolver el punto 3D de intersección
		return raycastResult.Position
	else
		-- No se golpeó ningún objeto, así que calcula la posición al final del rayo
		return screenToWorldRay.Origin + directionVector
	end
end

Disparar hacia el objetivo

Ahora que se conoce la posición 3D del mouse, se puede usar como una posición objetivo para disparar un láser. Se puede lanzar un segundo rayo entre la posición del arma del jugador y la posición objetivo usando la función Raycast.

1. Declara una constante llamada MAX_LASER_DISTANCE en la parte superior del script y asígnale 500, o tu rango elegido para el bláster láser.

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

2. Crea una función llamada fireWeapon debajo de la función getWorldMousePosition.

3. Llama a getWorldMousePosition y asigna el resultado a una variable llamada mousePosition. Esta será la posición objetivo para el raycast.

   -- No se golpeó ningún objeto, así que calcula la posición al final del rayo
           return screenToWorldRay.Origin + directionVector
       end
   end
   
   local function fireWeapon()
       local mouseLocation = getWorldMousePosition()
   end
   
   local function toolEquipped()
       tool.Handle.Equip:Play()
   end

Esta vez, el vector de dirección para la función de raycast representará la dirección desde la posición de la herramienta del jugador hasta la ubicación objetivo.

1. Declara una variable llamada targetDirection y calcula el vector de dirección restando la posición de la herramienta de mouseLocation.

2. Normaliza el vector usando su propiedad Unit. Esto le da una magnitud de 1, lo que facilita multiplicarlo por una longitud más adelante.

   local function fireWeapon()
   	local mouseLocation = getWorldMousePosition()
   
   	-- Calcular un vector de dirección normalizado y multiplicar por la distancia del láser
   	local targetDirection = (mouseLocation - tool.Handle.Position).Unit
   end

3. Declara una variable llamada directionVector y asígnale el targetDirection multiplicado por el MAX_LASER_DISTANCE.

   local targetDirection = (mouseLocation - tool.Handle.Position).Unit
   
       -- La dirección para disparar el arma, multiplicada por una distancia máxima
       local directionVector = targetDirection * MAX_LASER_DISTANCE
   end

Un objeto RaycastParams se puede usar para almacenar parámetros adicionales para la función de raycast. Se utilizará en tu bláster láser para asegurarse de que el raycast no colisione accidentalmente con el jugador que dispara el arma. Cualquier parte incluida en la propiedad FilterDescendantsInstances de un objeto RaycastParams será ignorada en el raycast.

1. Continúa la función fireWeapon y declara una variable llamada weaponRaycastParams. Asigna un nuevo objeto RaycastParams a ella.

2. Crea una tabla que contenga el personaje local del jugador y asígnala a la propiedad weaponRaycastParams.FilterDescendantsInstances.

3. Realiza un raycast desde la posición del mango de la herramienta del jugador, en una dirección hacia el directionVector. Recuerda agregar weaponRaycastParams como argumento esta vez. Asigna esto a una variable llamada 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 un vector de dirección normalizado y multiplicar por la distancia del láser
	local targetDirection = (mouseLocation - tool.Handle.Position).Unit

	-- La dirección para disparar el arma multiplicada por una distancia máxima
	local directionVector = targetDirection * MAX_LASER_DISTANCE

	-- Ignorar el carácter del jugador para evitar que se dañen a sí mismos
	local weaponRaycastParams = RaycastParams.new()
	weaponRaycastParams.FilterDescendantsInstances = {Players.LocalPlayer.Character}
	local weaponRaycastResult = workspace:Raycast(tool.Handle.Position, directionVector, weaponRaycastParams)
end

Finalmente, necesitarás verificar que la operación de raycast devolvió un valor. Si se devuelve un valor, un objeto fue golpeado por el rayo y se puede crear un láser entre el arma y la ubicación de impacto. Si no se devolvió nada, se necesita calcular la posición final para crear el láser.

1. Declara una variable vacía llamada hitPosition.

2. Usa una declaración if para verificar si weaponRaycastResult tiene un valor. Si se golpeó un objeto, asigna weaponRaycastResult.Position a hitPosition.

   local weaponRaycastResult = workspace:Raycast(tool.Handle.Position, directionVector, weaponRaycastParams)
   
   -- Verificar si se golpearon objetos entre la posición de inicio y la de fin
   local hitPosition
   if weaponRaycastResult then
   	hitPosition = weaponRaycastResult.Position
   end

3. Si weaponRaycastResult no tiene valor, calcula la posición final del raycast sumando la posición del mango de la herramienta con el directionVector. Asigna esto a hitPosition.

   local weaponRaycastResult = workspace:Raycast(tool.Handle.Position, directionVector, weaponRaycastParams)
   
       -- Verificar si se golpearon objetos entre la posición de inicio y la de fin
       local hitPosition
       if weaponRaycastResult then
           hitPosition = weaponRaycastResult.Position
       else
           -- Calcular la posición final basada en la distancia máxima del láser
           hitPosition = tool.Handle.Position + directionVector
       end
   end

4. Navega a la función toolActivated y llama a la función fireWeapon para que el láser dispare cada vez que se active la herramienta.

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

Verificar el objeto golpeado

Para averiguar si el objeto golpeado por el láser es parte del personaje de un jugador o simplemente un trozo de paisaje, necesitarás buscar un Humanoid, ya que cada personaje tiene uno.

Primero, necesitarás encontrar el modelo del personaje. Si se golpeó una parte del personaje, no puedes asumir que el padre del objeto golpeado sería el personaje. El láser podría haber golpeado una parte del cuerpo, un accesorio o una herramienta, todos los cuales se encuentran en diferentes partes de la jerarquía del personaje.

Puedes usar FindFirstAncestorOfClass para encontrar un ancestro del modelo del personaje del objeto golpeado por el láser, si existe. Si encuentras un modelo y contiene un humanoide, en la mayoría de los casos puedes asumir que es un personaje.

1. Agrega el código resaltado a continuación a la declaración if de weaponRaycastResult para verificar si se golpeó un personaje.

   -- Verificar si se golpearon objetos entre la posición de inicio y la de fin
   local hitPosition
   if weaponRaycastResult then
   	hitPosition = weaponRaycastResult.Position
   
   	-- La instancia golpeada será un hijo de un modelo de personaje
   	-- Si se encuentra un humanoide en el modelo, entonces es probable que sea el personaje de un jugador
   	local characterModel = weaponRaycastResult.Instance:FindFirstAncestorOfClass("Model")
   	if characterModel then
   		local humanoid = characterModel:FindFirstChildWhichIsA("Humanoid")
   		if humanoid then
   			print("Jugador golpeado")
   		end
   	end
   else
   	-- Calcular la posición final basada en la distancia máxima del láser
   	hitPosition = tool.Handle.Position + directionVector
   end

Ahora el bláster láser debería imprimir Jugador golpeado en la ventana de Salida cada vez que la operación de raycast golpea a otro jugador.

Probar con múltiples jugadores

Se necesitan dos jugadores para probar si el raycast del arma está encontrando a otros jugadores, por lo que necesitas iniciar un servidor local. Consulta simulación de múltiples clientes para obtener instrucciones.

En un cliente, prueba disparar al otro jugador con el arma haciendo clic en ellos. "Jugador golpeado" debería mostrarse en la salida cada vez que se dispara a un jugador.

Encontrar la posición del láser

El bláster debería disparar un rayo de luz roja hacia su objetivo. La función para esto estará dentro de un ModuleScript para que pueda reutilizarse en otros scripts más adelante. Primero, el script necesitará encontrar la posición donde se debe renderizar el rayo láser.

1. Crea un ModuleScript llamado LaserRenderer, parentado a StarterPlayerScripts bajo StarterPlayer.

   

2. Abre el script y renombra la tabla del módulo con el nombre del script LaserRenderer.

3. Declara una variable llamada SHOT_DURATION con un valor de 0.15. Este será el tiempo (en segundos) que el láser será visible.

4. Crea una función de LaserRenderer llamada createLaser con dos parámetros llamados toolHandle y endPosition.

   local LaserRenderer = {}
   
   local SHOT_DURATION = 0.15 -- Tiempo que el láser es visible
   
   -- Crear un rayo láser desde una posición de inicio hacia una posición final
   function LaserRenderer.createLaser(toolHandle, endPosition)
   
   end
   
   return LaserRenderer

5. Declara una variable llamada startPosition y establece la propiedad Position de toolHandle como su valor. Esta será la posición del bláster láser del jugador.

6. Declara una variable llamada laserDistance y resta endPosition de startPosition para encontrar la diferencia entre los dos vectores. Usa la propiedad Magnitude de esto para obtener la longitud del rayo láser.

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

7. Declara una variable laserCFrame para almacenar la posición y orientación del rayo láser. La posición necesita ser el punto medio del inicio y el final del rayo. Usa CFrame.lookAt para crear un nuevo CFrame ubicado en startPosition y mirando hacia endPosition. Multiplica esto por un nuevo CFrame con un valor de eje Z de la mitad de -laserDistance para obtener el punto medio.

   

   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

Crear la parte del láser

Ahora que sabes dónde crear un rayo láser, necesitas agregar el rayo mismo. Esto se puede hacer fácilmente con una parte Neon.

1. Declara una variable laserPart y asígnale una nueva instancia de Part.

2. Establece las siguientes propiedades 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) (un color rojo fuerte)
   6. Material: Enum.Material.Neon

3. Parent laserPart a Workspace.

4. Agrega la parte al servicio Debris para que se elimine después de la cantidad de segundos en la variable 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
   
   	-- Agregar el rayo láser al servicio Debris para ser eliminado y limpiado
   	Debris:AddItem(laserPart, SHOT_DURATION)
   end

Ahora la función para renderizar el rayo láser está completa, se puede llamar desde el ToolController.

1. En la parte superior del script ToolController, declara una variable llamada LaserRenderer y requiere el módulo LaserRenderer ubicado en PlayerScripts.

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

2. En la parte inferior de la función fireWeapon, llama a la función createLaser de LaserRenderer usando el mango de la herramienta y hitPosition como argumentos.

   -- Calcular la posición final basada en la distancia máxima del láser
           hitPosition = tool.Handle.Position + directionVector
       end
   
       LaserRenderer.createLaser(tool.Handle, hitPosition)
   end

3. Prueba el arma haciendo clic en el botón Play. Un rayo láser debería ser visible entre el arma y el mouse cuando se activa la herramienta.

Controlar la tasa de disparo del arma

Las armas necesitan un retraso entre cada disparo para evitar que los jugadores inflijan demasiado daño en un corto período de tiempo. Esto se puede controlar verificando si ha pasado suficiente tiempo desde que un jugador disparó por última vez.

1. Declara una variable en la parte superior del ToolController llamada FIRE_RATE. Este será el tiempo mínimo entre cada disparo. Dale un valor de tu elección; este ejemplo usa 0.3 segundos.

2. Declara otra variable debajo llamada timeOfPreviousShot con un valor de 0. Esto almacena la última vez que el jugador disparó y se actualizará con cada disparo.

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

3. Crea una función llamada canShootWeapon sin parámetros. Esta función verificará cuánto tiempo ha pasado desde el disparo anterior y devolverá verdadero o falso.

   local FIRE_RATE = 0.3
   local timeOfPreviousShot = 0
   
   -- Verificar si ha pasado suficiente tiempo desde que se disparó el disparo anterior
   local function canShootWeapon()
   
   end
   
   local function getWorldMousePosition()

4. Dentro de la función, declara una variable llamada currentTime; asígnale el resultado de llamar a la función tick(). Esto devuelve cuánto tiempo ha transcurrido, en segundos, desde el 1 de enero de 1970 (una fecha arbitraria ampliamente utilizada para calcular el tiempo).

5. Resta timeOfPreviousShot de currentTime y devuelve falso si el resultado es menor que FIRE_RATE; de lo contrario, devuelve verdadero.

   -- Verificar si ha pasado suficiente tiempo desde que se disparó el disparo anterior
   local function canShootWeapon()
   	local currentTime = tick()
   	if currentTime - timeOfPreviousShot < FIRE_RATE then
   		return false
   	end
   	return true
   end

6. Al final de la función fireWeapon, actualiza timeOfPreviousShot cada vez que se dispare el arma usando tick.

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

7. Dentro de la función toolActivated, crea una declaración if y llama a canShootWeapon para verificar si el arma se puede disparar.

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

Cuando pruebes el bláster, deberías encontrar que no importa cuán rápido hagas clic, siempre habrá un corto retraso de 0.3 segundos entre cada disparo.

Dañar al jugador

Los clientes no pueden dañar a otros clientes directamente; el servidor debe ser responsable de emitir daño cuando un jugador es golpeado.

Los clientes pueden usar un RemoteEvent para decirle al servidor que un personaje ha sido golpeado. Estos deben almacenarse en ReplicatedStorage, donde son visibles tanto para el cliente como para el servidor.

1. Crea una Carpeta en ReplicatedStorage llamada Events.

   

2. Inserta un RemoteEvent en la carpeta Events y nómbralo DamageCharacter.

   

3. En ToolController, crea variables al inicio del script para ReplicatedStorage y la carpeta 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. Reemplaza la declaración de impresión "Jugador golpeado" en fireWeapon con una línea de Luau para disparar el evento remoto DamageCharacter con la variable 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
       -- Calcular la posición final basada en la distancia máxima del láser
       hitPosition = tool.Handle.Position + directionVector
   end

El servidor necesita causar daño al jugador que ha sido golpeado cuando se dispara el evento.

1. Inserta un Script en ServerScriptService y nómbralo ServerLaserManager.

   

2. Declara una variable llamada LASER_DAMAGE y configúralo en 10, o un valor de tu elección.

3. Crea una función llamada damageCharacter con dos parámetros llamados playerFired y characterToDamage.

4. Dentro de la función, encuentra el Humanoid del personaje y resta LASER_DAMAGE de su salud.

5. Conecta la función damageCharacter al evento remoto DamageCharacter en la carpeta 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
   		-- Quitar salud del personaje
   		humanoid.Health -= LASER_DAMAGE
   	end
   end
   
   -- Conectar eventos a funciones apropiadas
   eventsFolder.DamageCharacter.OnServerEvent:Connect(damageCharacter)

6. Prueba el bláster con 2 jugadores iniciando un servidor local. Cuando dispares al otro jugador, su salud disminuirá en la cantidad asignada a LASER_DAMAGE.

Renderizar los rayos láser de otros jugadores

Actualmente, el rayo láser es creado por el cliente que dispara el arma, por lo que solo ellos podrán ver el rayo láser.

Si el rayo láser se creara en el servidor, entonces todos podrían verlo. Sin embargo, habría un pequeño retraso entre el cliente disparando el arma y el servidor recibiendo la información sobre el disparo. Esto significaría que el cliente que dispara el arma vería un retraso entre cuando activa el arma y cuando ve el rayo láser; el arma se sentiría lenta como resultado.

Para resolver este problema, cada cliente creará sus propios rayos láser. Esto significa que el cliente que dispara el arma verá el rayo láser instantáneamente. Otros clientes experimentarán un pequeño retraso entre cuando otro jugador dispara y aparece un rayo. Este es el mejor escenario: no hay forma de comunicar el láser de un cliente a otros clientes más rápido.

Cliente tirador

Primero, el cliente necesita decirle al servidor que ha disparado un láser y proporcionar la posición final.

1. Inserta un RemoteEvent en la carpeta Events en ReplicatedStorage y nómbralo LaserFired.

   

2. Localiza la función fireWeapon en el script ToolController. Al final de la función, dispara el 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

El servidor

El servidor ahora debe recibir el evento de que el cliente ha disparado y decirle a todos los clientes la posición de inicio y final del rayo láser para que también puedan renderizarlo.

1. En el script ServerLaserManager, crea una función llamada playerFiredLaser encima de damageCharacter con dos parámetros llamados playerFired y endPosition.

2. Conecta la función al evento remoto LaserFired.

   -- Notificar a todos los clientes que se ha disparado un láser para que puedan mostrar el láser
   local function playerFiredLaser(playerFired, endPosition)
   
   end

   -- Conectar eventos a funciones apropiadas
   eventsFolder.DamageCharacter.OnServerEvent:Connect(damageCharacter)
   eventsFolder.LaserFired.OnServerEvent:Connect(playerFiredLaser)

El servidor necesita la posición de inicio del láser. Esto podría ser enviado desde el cliente, pero es mejor evitar confiar en el cliente siempre que sea posible. La posición del mango del arma del personaje será la posición de inicio, por lo que el servidor puede encontrarla desde allí.

1. Crea una función getPlayerToolHandle encima de la función playerFiredLaser con un parámetro llamado player.

2. Usa el siguiente código para buscar el arma del jugador en su personaje y devolver el objeto del mango.

   local LASER_DAMAGE = 10
   
   -- Encontrar el mango de la herramienta que el jugador está sosteniendo
   local function getPlayerToolHandle(player)
       local weapon = player.Character:FindFirstChildOfClass("Tool")
       if weapon then
           return weapon:FindFirstChild("Handle")
       end
   end
   
   -- Notificar a todos los clientes que se ha disparado un láser para que puedan mostrar el láser
   local function playerFiredLaser(playerFired, endPosition)

El servidor ahora puede llamar a FireAllClients en el evento remoto LaserFired para enviar la información necesaria para renderizar el láser a los clientes. Esto incluye el jugador que disparó el láser (para que el cliente de ese jugador no renderice el láser dos veces), el mango del bláster (que actúa como una posición de inicio para el láser) y la posición final del láser.

1. En la función playerFiredLaser, llama a la función getPlayerToolHandle con playerFired como argumento y asigna el valor a una variable llamada toolHandle.

2. Si toolHandle existe, dispara el evento LaserFired para todos los clientes usando playerFired, toolHandle y endPosition como argumentos.

   -- Notificar a todos los clientes que se ha disparado un láser para que puedan mostrar el láser
   local function playerFiredLaser(playerFired, endPosition)
   	local toolHandle = getPlayerToolHandle(playerFired)
   	if toolHandle then
   		eventsFolder.LaserFired:FireAllClients(playerFired, toolHandle, endPosition)
   	end
   end

Renderizar en los clientes

Ahora que se ha llamado a FireAllClients, cada cliente recibirá un evento del servidor para renderizar un rayo láser. Cada cliente puede reutilizar el módulo LaserRenderer de antes para renderizar el rayo láser usando la posición del mango de la herramienta y el valor de la posición final enviado por el servidor. El jugador que disparó el rayo láser en primer lugar debe ignorar este evento, de lo contrario, verá 2 láseres.

1. Crea un LocalScript en StarterPlayerScripts llamado ClientLaserManager.

   

2. Dentro del script, requiere el módulo LaserRenderer.

3. Crea una función llamada createPlayerLaser con los parámetros playerWhoShot, toolHandle y endPosition.

4. Conecta la función al evento remoto LaserFired en la carpeta Events.

5. En la función, usa una declaración if para verificar si playerWhoShot no es igual a LocalPlayer.

6. Dentro de la declaración if, llama a la función createLaser del módulo LaserRenderer usando toolHandle y endPosition como argumentos.

   local Players = game:GetService("Players")
   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   
   local LaserRenderer = require(script.Parent:WaitForChild("LaserRenderer"))
   
   local eventsFolder = ReplicatedStorage.Events
   
   -- Mostrar el láser de otro jugador
   local function createPlayerLaser(playerWhoShot, toolHandle, endPosition)
   	if playerWhoShot ~= Players.LocalPlayer then
   		LaserRenderer.createLaser(toolHandle, endPosition)
   	end
   end
   
   eventsFolder.LaserFired.OnClientEvent:Connect(createPlayerLaser)

7. Prueba el bláster con 2 jugadores iniciando un servidor local. Coloca cada cliente en diferentes lados de tu monitor para que puedas ver ambas ventanas a la vez. Cuando dispares en un cliente, deberías ver el rayo láser en el otro cliente.

Efectos de sonido

El efecto de sonido de disparo actualmente solo se reproduce en el cliente que está disparando el proyectil. Necesitarás mover el código para reproducir el sonido para que otros jugadores también lo escuchen.

1. En el script ToolController, navega a la función toolActivated y elimina la línea que reproduce el sonido de Activar.

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

2. En la parte inferior de la función createLaser en LaserRenderer, declara una variable llamada shootingSound y usa el método FindFirstChild() de toolHandle para verificar el sonido de Activar.

3. Usa una declaración if para verificar si shootingSound existe; si lo hace, llama a su función Play().

   laserPart.Parent = workspace
   
       -- Agregar el rayo láser al servicio Debris para ser eliminado y limpiado
       Debris:AddItem(laserPart, SHOT_DURATION)
   
       -- Reproducir el sonido de disparo del arma
       local shootingSound = toolHandle:FindFirstChild("Activate")
       if shootingSound then
           shootingSound:Play()
       end
   end

Asegurar remotos usando validación

Si el servidor no está verificando los datos de las solicitudes entrantes, un hacker puede abusar de las funciones y eventos remotos y usarlos para enviar valores falsos al servidor. Es importante usar validación del lado del servidor para prevenir esto.

En su forma actual, el evento remoto DamageCharacter es muy vulnerable a ataques. Los hackers podrían usar este evento para dañar a cualquier jugador que deseen sin dispararles.

La validación es el proceso de verificar que los valores enviados al servidor sean realistas. En este caso, el servidor necesitará:

• Verificar si la distancia entre el jugador y la posición golpeada por el láser está dentro de un cierto límite.
• Hacer un raycast entre el arma que disparó el láser y la posición golpeada para asegurarse de que el disparo fue posible y no atravesó ninguna pared.

Cliente

El cliente necesita enviar al servidor la posición golpeada por el raycast para que pueda verificar que la distancia es realista.

1. En ToolController, navega a la línea donde se dispara el evento remoto DamageCharacter en la función fireWeapon.

2. Agrega hitPosition como argumento.

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

Servidor

El cliente ahora está enviando un parámetro adicional a través del evento remoto DamageCharacter, por lo que el ServerLaserManager necesita ajustarse para aceptarlo.

1. En el script ServerLaserManager, agrega un parámetro hitPosition a la función damageCharacter.

   function damageCharacter(playerFired, characterToDamage, hitPosition)
   	local humanoid = characterToDamage:FindFirstChildWhichIsA("Humanoid")
   	if humanoid then
   		-- Quitar salud del personaje
   		humanoid.Health -= LASER_DAMAGE
   	end
   end

2. Debajo de la función getPlayerToolHandle, crea una función llamada isHitValid con tres parámetros: playerFired, characterToDamage y hitPosition.

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

La primera verificación será la distancia entre la posición golpeada y el personaje golpeado.

1. Declara una variable llamada MAX_HIT_PROXIMITY en la parte superior del script y asígnale un valor de 10. Esta será la distancia máxima permitida entre el golpe y el personaje. Se necesita una tolerancia porque el personaje puede haberse movido ligeramente desde que el cliente disparó el evento.

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

2. En la función isHitValid, calcula la distancia entre el personaje y la posición golpeada. Si la distancia es mayor que MAX_HIT_PROXIMITY, entonces devuelve falso.

   local function isHitValid(playerFired, characterToDamage, hitPosition)
   	-- Validar la distancia entre el personaje golpeado y la posición golpeada
   	local characterHitProximity = (characterToDamage.HumanoidRootPart.Position - hitPosition).Magnitude
   	if characterHitProximity > MAX_HIT_PROXIMITY then
   		return false
   	end
   end

La segunda verificación involucrará un raycast entre el arma disparada y la posición golpeada. Si el raycast devuelve un objeto que no es el personaje, puedes asumir que el disparo no fue válido ya que algo estaba bloqueando el disparo.

1. Copia el código a continuación para realizar esta verificación. Devuelve true al final de la función: si llega al final, todas las verificaciones han pasado.

   local function isHitValid(playerFired, characterToDamage, hitPosition)
   	-- Validar la distancia entre el personaje golpeado y la posición golpeada
   	local characterHitProximity = (characterToDamage.HumanoidRootPart.Position - hitPosition).Magnitude
   	if characterHitProximity > 10 then
   		return false
   	end
   
   	-- Verificar si se dispara a travé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)
   
   		-- Si se golpeó una instancia que no era el personaje, entonces ignora el disparo
   		if rayResult and not rayResult.Instance:IsDescendantOf(characterToDamage) then
   			return false
   		end
   	end
   
   	return true
   end

2. Declara una variable en la función damageCharacter llamada validShot. Asigna a ella el resultado de una llamada a la función isHitValid con tres argumentos: playerFired, characterToDamage y hitPosition.

3. En la declaración if a continuación, agrega un operador and para verificar si validShot es true.

   function damageCharacter(playerFired, characterToDamage, hitPosition)
   	local humanoid = characterToDamage:FindFirstChildWhichIsA("Humanoid")
   	local validShot = isHitValid(playerFired, characterToDamage, hitPosition)
   	if humanoid and validShot then
   		-- Quitar salud del personaje
   		humanoid.Health -= LASER_DAMAGE
   	end
   end

Ahora el evento remoto damageCharacter es más seguro y evitará que la mayoría de los jugadores lo abusen. Ten en cuenta que algunos jugadores malintencionados a menudo encontrarán formas de eludir la validación; mantener seguros los eventos remotos es un esfuerzo continuo.

Tu bláster láser ahora está completo, con un sistema básico de detección de impactos utilizando raycasting. Prueba el tutorial Detectando entrada de usuario para averiguar cómo puedes agregar una acción de recarga a tu bláster láser, o crea un mapa divertido y prueba tu bláster láser con otros jugadores.

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

-- Verificar si ha pasado suficiente tiempo desde que se disparó el disparo anterior
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()

	-- Crear un rayo desde la ubicación 2D del mouse
	local screenToWorldRay = workspace.CurrentCamera:ViewportPointToRay(mouseLocation.X, mouseLocation.Y)

	-- El vector de dirección unitario del rayo multiplicado por una distancia máxima
	local directionVector = screenToWorldRay.Direction * MAX_MOUSE_DISTANCE

	-- Raycast desde el origen del rayo hacia su dirección
	local raycastResult = workspace:Raycast(screenToWorldRay.Origin, directionVector)

	if raycastResult then
		-- Devolver el punto 3D de intersección
		return raycastResult.Position
	else
		-- No se golpeó ningún objeto, así que calcula la posición al final del rayo
		return screenToWorldRay.Origin + directionVector
	end
end

local function fireWeapon()
	local mouseLocation = getWorldMousePosition()

	-- Calcular un vector de dirección normalizado y multiplicar por la distancia del láser
	local targetDirection = (mouseLocation - tool.Handle.Position).Unit

	-- La dirección para disparar el arma, multiplicada por una distancia máxima
	local directionVector = targetDirection * MAX_LASER_DISTANCE

	-- Ignorar el carácter del jugador para evitar que se dañen a sí mismos
	local weaponRaycastParams = RaycastParams.new()
	weaponRaycastParams.FilterDescendantsInstances = {Players.LocalPlayer.Character}
	local weaponRaycastResult = workspace:Raycast(tool.Handle.Position, directionVector, weaponRaycastParams)

	-- Verificar si se golpearon objetos entre la posición de inicio y la de fin
	local hitPosition
	if weaponRaycastResult then
		hitPosition = weaponRaycastResult.Position

		-- La instancia golpeada será un hijo de un modelo de personaje
		-- Si se encuentra un humanoide en el modelo, entonces es probable que sea el personaje de un jugador
		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
		-- Calcular la posición final basada en la distancia máxima del láser
		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 -- Tiempo que el láser es visible

-- Crear un rayo láser desde una posición de inicio hacia una posición 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

	-- Agregar el rayo láser al servicio Debris para ser eliminado y limpiado
	Debris:AddItem(laserPart, SHOT_DURATION)

	-- Reproducir el sonido de disparo del 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 el mango de la herramienta que el jugador está sosteniendo
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 la distancia entre el personaje golpeado y la posición golpeada
	local characterHitProximity = (characterToDamage.HumanoidRootPart.Position - hitPosition).Magnitude
	if characterHitProximity > MAX_HIT_PROXIMITY then
		return false
	end

	-- Verificar si se dispara a travé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)

		-- Si se golpeó una instancia que no era el personaje, entonces ignora el disparo
		if rayResult and not rayResult.Instance:IsDescendantOf(characterToDamage) then
			return false
		end
	end

	return true
end

-- Notificar a todos los clientes que se ha disparado un láser para que puedan mostrar el láser
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
		-- Quitar salud del personaje
		humanoid.Health -= LASER_DAMAGE
	end
end

-- Conectar eventos a funciones apropiadas
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

-- Mostrar el láser de otro jugador
local function createPlayerLaser(playerWhoShot, toolHandle, endPosition)
	if playerWhoShot ~= Players.LocalPlayer then
		LaserRenderer.createLaser(toolHandle, endPosition)
	end
end

eventsFolder.LaserFired.OnClientEvent:Connect(createPlayerLaser)