Agregar Scripts | Documentación del Centro de creación de Roblox

¡Es hora de llevar todo este trabajo juntos! Ahora que has creado los componentes de rayo y partícula, añadirás tres scripts prefabricados. Estos scripts manejan el tutorial diciendo a los componentes cuándo hacer qué. Por ejemplo, los scripts crearán rayos para los nuevos jugadores y emiten partículas cuando interactúan con los objetivos.

Mientras puede seguir todos estos pasos incluso si no ha codificado antes, tener ese conocimiento puede ayudarlo a adaptar estos scripts para su propia experiencia. Para aprender más, consulte el tutorial Cómo aprender a codificar.

Almacenando Rayo y Partículas

Antes de agregar los scripts, el rayo y las partículas deben ser movidas a donde las scripts podrán hacer copias de ellas si es necesario.

Si está usando su propio proyecto, puede que necesite reemplazar los valores dentro de algunas variables de script para que coinciden con sus objetos.

En Almacenamiento Replicado , crea una nueva carpeta llamada Tutorial del jugador . Mueve TutorialBeam fuera de TestPlayer, y en la nueva carpeta.
En Almacenamiento del servidor, crea una carpeta llamada Partículas de tutorial. Mueve la partícula de salida de prueba a esa carpeta.
Una vez que el emisor de rayo y partículas se haya movido, ya no necesitas el TestPlayer. Eliminar TestPlayer ya que el script funcionará con jugadores reales cuando se termine.

Crear Eventos

Cada vez que los jugadores interactúen con un objetivo, el script de tutorial necesitará saber 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 RemoteEvent . Los nombra Siguiente objetivo y Tutorial final .

Agregar los scripts

Los tres scripts a continuación buscarán el objeto de emisor de partículas y el objeto de rayo creado anteriormente y administrará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 de la portería deben ser pedidas en la tabla, o bien la orden de la portería 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 obtener más código. Por ejemplo, si desea 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
   -- Incrementa el rastreador de metas del jugador
   local currentGoalIndex = player:WaitForChild("GoalProgress")
   currentGoalIndex.Value += 1
 end
end

-- Crea un valor de int para rastrear el progreso del jugador a través de los Goles 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 el tutorial termina.

En Servicio de Script del Servidor, crea un nuevo Script llamado Partículas de Tutorial.

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 accesorio y jóvalas 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 añadirlas 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 juega la partícula de salto cuando los jugadores interactúan con los objetivos. También hay una variable llamada EMIT_RATE que determina la cantidad de partículas que se generan durante una interacción.

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

Luego, pegue 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.Parent = humanoidRootPart
  playerBeam.Enabled = true
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. Mueve de cabina en 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.

Vaya a ServerStorage > Partículas de Tutorial > Explosión. Compruebe que esté habilitado para estar desactivado. Problema : Advertencias en el compilador, como un "rendimiento infinito".
Dado que el script está buscando objetos específicos en ciertas ubicaciones, es posible que una parte se llame incorrectamente. Compruebe dos veces que el nombre y la ubicación de cada parte en el juego coinciden con el tutorial.

Beneficios y Limitaciones de los Script

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 desencadenar otros scripts. Por instancia, puede otorgar a los jugadores un artículo especial cuando este evento se activa.
El script TutorialParticles puede jugar múltiples partículas a la vez. Puedes agregar más partículas en ServerStorage/TutorialParticles para obtener efectos más complejos. Limitaciones
El progreso del jugador en el tutorial no es persistente, lo que significa que tendrás que codificar alguna manera de guardar ese progreso. Para obtener más información, consulta el artículo: Guardando datos.