Añadir scripts

¡Es hora de unir todo este trabajo! Ahora que has creado los componentes de rayo y partícula, agregarás tres scripts prefabricados.Estos scripts gestionan el tutorial diciendo a los componentes cuándo hacer qué.Por ejemplo, los scripts crearán rayos para nuevos jugadores y emitirán partículas cada vez que interactúen con los objetivos.

Aunque puedes seguir todos estos pasos incluso si no has codificado antes, tener ese conocimiento te puede ayudar a adaptar estos scripts para tu propia experiencia.Para aprender más, vea el tutorial Fundamentos de programación.

Almacenar rayos y partículas

Antes de agregar los scripts, el rayo y las partículas deben ser movidos a donde los scripts puedan hacer copias de ellos según sea necesario.

Si está utilizando su propio proyecto, es posible que deba reemplazar los valores dentro de algunas variables programadas para coincidir con sus objetos.

En Almacenamiento replicado , crea un nuevo directorio llamado Tutorial del jugador . Mueve TutorialBeam fuera de TestPlayer y dentro del nuevo directorio.
En Almacenamiento del servidor , crea una carpeta llamada TutorialParticles .Mueva la partícula Explosión fuera de TestPlayer a esa carpeta.
Una vez que se muevan el emisor de rayos y partículas, ya no necesitas el reproductor de prueba. Eliminar TestPlayer ya que el script funcionará con jugadores reales cuando termine.

Crear eventos

Cada vez que los jugadores interactúen con una meta, el guión de tutorial deberá saberlo para que pueda actualizar el progreso de ese jugador y emitir el efecto de partículas.Para informar a los scripts, las señales se pueden enviar usando eventos .

En ReplicatedStorage > PlayerTutorial, crea dos objetos Evento remoto . Nombrarlos Siguiente objetivo y Fin del tutorial .

Añade los scripts

Los tres scripts siguientes buscarán el emisor de partículas y los objetos de rayo creados anteriormente y gestionarán el sistema de tutorial.

En ReplicatedStorage > PlayerTutorial > crea un nuevo ModuleScript llamado TutorialManager .

Reemplace el código predeterminado copiando y pegando todo el código a continuación.


local TutorialManager = {}

local ReplicatedStorage = game:GetService("ReplicatedStorage")

local tutorialFolder = ReplicatedStorage:WaitForChild("PlayerTutorial")
local TutorialEndEvent = tutorialFolder:WaitForChild("TutorialEnd")
local NextGoalEvent = tutorialFolder:WaitForChild("NextGoal")

-- Las partes del objetivo deben solicitarse en la tabla, o de lo contrario el pedido del objetivo puede ser diferente en el juego
local goalParts = {
 workspace.TutorialGoals.GoalPart1,
 workspace.TutorialGoals.GoalPart2
}

local function checkTutorialEnd(player, goalParts)
 local currentIndex = player:WaitForChild("GoalProgress")
 return currentIndex.Value >= #goalParts
end

local function finishTutorial(player)
 local playerBeam = player.Character.HumanoidRootPart:FindFirstChildOfClass("Beam")
 playerBeam:Destroy()

 print(player.Name .. " finished the tutorial")

 -- Marcador para más código. Ejemplo: si quieres enviar mensajes al servidor para hacer otras tareas

end

function TutorialManager.interactGoal(player)
 NextGoalEvent:FireServer()
end

function TutorialManager.getTutorialGoals()
 return goalParts
end

function TutorialManager.nextGoal(player, goalParts)
 if checkTutorialEnd(player, goalParts) then
   finishTutorial(player)
 else
   -- Incrementar el rastreador de objetivos del jugador
   local currentGoalIndex = player:WaitForChild("GoalProgress")
   currentGoalIndex.Value += 1
 end
end

-- Crea un valor de int para rastrear localmente el progreso del jugador a través de los objetivos del tutorial
function TutorialManager.setupPlayerProgress(player)
 local currentGoalProgress = Instance.new("IntValue")
 currentGoalProgress.Name = "GoalProgress"
 currentGoalProgress.Value = 1
 currentGoalProgress.Parent = player
end

return TutorialManager

Este script ejecuta código para administrar el progreso de un jugador en el tutorial.Esto incluye tareas como ejecutar código para interactuar con los objetivos, o lo que sucede cuando termina el tutorial.

En ServerScriptService , crea un nuevo script llamado TutorialParticles .

Pega el código a continuación.


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

local tutorialFolder = ReplicatedStorage:WaitForChild("PlayerTutorial")
local NextGoalEvent = tutorialFolder:WaitForChild("NextGoal")

local EMIT_RATE = 50

local function playParticleBurst(player)
  local character = player.Character or player.CharacterAdded:Wait()
  local humanoidRootPart = character:WaitForChild("HumanoidRootPart")
  local particleAttachment = humanoidRootPart:WaitForChild("ParticleAttachment")

  -- Ve a través de las partículas en el archivo adjunto y úsalas según el tipo de partícula
  for _, particle in particleAttachment:GetChildren() do
    if particle:IsA("ParticleEmitter") then
      particle:Emit(EMIT_RATE)
    end
  end
end

local function setupPlayerParticles(player)
  player.CharacterAdded:Connect(function(character)
    local humanoidRootPart = character:WaitForChild("HumanoidRootPart")
    local playerParticleAttachment = Instance.new("Attachment")
    playerParticleAttachment.Name = "ParticleAttachment"
    playerParticleAttachment.Parent = humanoidRootPart

    -- Clona partículas en la carpeta, incluso si hay más de una y se adjunta al jugador
    for _, emitter in ServerStorage.TutorialParticles:GetChildren() do
      emitter:Clone().Parent = playerParticleAttachment
    end
  end)
end

Players.PlayerAdded:Connect(setupPlayerParticles)
NextGoalEvent.OnServerEvent:Connect(playParticleBurst)

Este script reproduce la partícula de explosión cada vez que los jugadores interactúan con los objetivos.También hay una variable llamada EMIT_RATE que determina cuántas partículas se generan durante una interacción.

En StarterPlayer > StarterPlayerScripts, crea un nuevo LocalScript llamado TutorialScript .

Luego, pega el script a continuación. Este script crea y gestiona el rayo utilizado para guiar a los jugadores.


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

local tutorialFolder = ReplicatedStorage:WaitForChild("PlayerTutorial")
local TutorialManager = require(tutorialFolder:WaitForChild("TutorialManager"))
local TutorialEndEvent = tutorialFolder:WaitForChild("TutorialEnd")

local player = Players.LocalPlayer
local goalParts = TutorialManager.getTutorialGoals()
local playerBeam = nil
local goalIndex = nil

local function getTargetAttachment()
  local currentTarget = goalParts[goalIndex.Value]
  local interactionPart = currentTarget:FindFirstChild("InteractionPart")
  local attachment = interactionPart and interactionPart:FindFirstChildOfClass("Attachment")

  if not attachment then
    attachment = Instance.new("Attachment")
    attachment.Name = "BeamAttachment"
    attachment.Parent = currentTarget
  end

  return attachment
end

local function updateBeamTarget()
  playerBeam = player.Character.HumanoidRootPart:FindFirstChildOfClass("Beam")

  local targetBeamAttachment = getTargetAttachment()

  if targetBeamAttachment then
    playerBeam.Attachment1 = targetBeamAttachment
  else
    warn("Attachment not found in a goal. Check that goals have attachments or they're included under the InteractionPart")
  end
end

local function setupGoals()
  for _, part in goalParts do
    local interactionPart = part:FindFirstChild("InteractionPart")
    local proximityPrompt = interactionPart and interactionPart:FindFirstChild("ProximityPrompt")

    if proximityPrompt then
      proximityPrompt.Triggered:Connect(function(player)
        proximityPrompt.Enabled = false
        TutorialManager.nextGoal(player, goalParts)
        TutorialManager.interactGoal(player)
      end)
    else
      warn("Proximity prompt not included in goal. Add one to each goal part under the InteractionPart")
    end
  end
end

local function createBeamForCharacter(character)
  local humanoidRootPart = character:WaitForChild("HumanoidRootPart")
  local playerBeamAttachment = Instance.new("Attachment")
  local beamTemplate = tutorialFolder:WaitForChild("TutorialBeam")

  if not beamTemplate then
    warn("Tutorial Beam not found in ReplicatedStorage")
  end

  playerBeamAttachment.Name = "BeamAttachment"
  playerBeamAttachment.Parent = humanoidRootPart

  local targetBeamAttachment = getTargetAttachment()

  playerBeam = beamTemplate:Clone()
  playerBeam.Attachment0 = playerBeamAttachment
  playerBeam.Attachment1 = targetBeamAttachment
  playerBeam.Enabled = true
  playerBeam.Parent = humanoidRootPart
end

local function setupPlayer()
  setupGoals()
  TutorialManager.setupPlayerProgress(player)
  goalIndex = player:WaitForChild("GoalProgress")

  player.CharacterAdded:Connect(createBeamForCharacter)
  if player.Character then
    createBeamForCharacter(player.Character)
  end
end

setupPlayer()
goalIndex.Changed:Connect(updateBeamTarget)

Juega el proyecto para probar los scripts. Muévete de cabina a cabina, usando la función de interacción para ver si el código funciona.

Consejos de solución de problemas

Problema : Las partículas juegan cuando comienza el juego.

Ve a Almacenamiento de servidor > Partículas de tutorial > Explosión. Compruebe que Está desactivado para estar desactivado. Problema : Advertencias en el compilador como un "rendimiento infinito".
Debido a que el script busca objetos específicos en ciertas ubicaciones, es posible que una parte se llame incorrectamente.Asegúrate de que el nombre y la ubicación de cada parte en el juego coincidan con el tutorial.

Beneficios y limitaciones de los scripts

Si estás usando este sistema de tutorial en tu experiencia, ten en cuenta lo siguiendo: Beneficios

Los eventos como TutorialEnd se pueden usar para activar otros scripts. Por instancia, puedes otorgarle a los jugadores un artículo especial cuando este evento se active.
El script TutorialParticles puede reproducir múltiples partículas a la vez.Puedes agregar más partículas en ServerStorage/TutorialParticles para efectos más complejos. Limitaciones
El progreso del jugador en el tutorial no es persistente, lo que significa que tendrás que codificar alguna forma de guardar ese progreso.Para obtener orientación, consulte el artículo: Guardar datos.

Almacenar rayos y partículas

Crear eventos

Añade los scripts

Consejos de solución de problemas

Beneficios y limitaciones de los scripts

En esta página