Adicionando Scripts

É hora de trazer tudo isso juntos! Agora que você criou os componentes de raios e partículas, você adicionará três scripts pré-feitos. Esses scripts gerenciam o tutorial ao dizer aos componentes quando fazer o que. Por exemplo, os scripts criarão raios para novos jogadores e emitem partículas sempre que eles interagem com metas.

Embora você possa seguir todos esses passos, mesmo se você não tiver codificado antes, ter esse conhecimento pode ajudá-lo a adaptar esses scripts para sua própria experiência. Para aprender mais, veja o TutorialFundamentos de Código.

Armazenando Raio e Partículas

Antes de adicionar os scripts, o feixe e as partículas precisam ser movidos para onde os scripts poderão fazer cópias deles, se necessário.

Se você estiver usando seu próprio projeto, pode precisar substituir os valores dentro de algumas variáveis scriptadas para corresponder a seus objetos.

In ReplicatedStorage , create a new folder named PlayerTutorial . Move TutorialBeam out of TestPlayer, and into the new folder.
Em Armazenamento do Servidor , crie uma pasta chamada Particles de Tutorial . Move a Explosão parte para fora do TestPlayer para essa pasta.
Uma vez que o emissor de feixe e partícula são movidos, você não precisa mais do TestPlayer. Excluir TestPlayer, pois o script funcionará com jogadores reais quando terminar.

Criando Eventos

Cada vez que os jogadores interagem com um gol, o script de tutorial precisará saber para que ele possa atualizar o progresso desse jogador e emitir o efeito de partículas. Para informar scripts, sinais podem ser enviados usando eventos .

In ReplicatedStorage > PlayerTutorial, create two objetos de evento remoto objects. Name them PróximoGoal e TutorialEnd .

Os três scripts abaixo procurarão o emissor de partículas e os objetos de raios criados anteriormente e gerenciarão o sistema de tutorial.

In ReplicatedStorage > PlayerTutorial > create a new ModuleScript named TutorialManager .

Substitua o código padrão copiando e coletando todo o código abaixo.


local TutorialManager = {}

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- As partes da meta devem ser pedidas na tabela, ou a ordem da meta pode ser diferente no jogo
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")

 -- Espaço reservado para código adicional. Ex. Se você quiser enviar mensagens ao servidor para fazer outras tarefas

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 o rastreador de Goal do jogador
   local currentGoalIndex = player:WaitForChild("GoalProgress")
   currentGoalIndex.Value += 1
 end
end

-- Cria um valor int para rastrear o progresso do jogador localmente através dos Golos do Tutorial
function TutorialManager.setupPlayerProgress(player)
 local currentGoalProgress = Instance.new("IntValue")
 currentGoalProgress.Name = "GoalProgress"
 currentGoalProgress.Value = 1
 currentGoalProgress.Parent = player
end

return TutorialManager

Este script executa código para gerenciar o progresso de um jogador no Tutorial. Isso inclui tarefas como executar código para interagir com metas ou o que acontece quando o tutorial terminar.

Em ServerScriptService , crie um novo Script chamado TutorialParticles .

Paste o código abaixo.


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")

  -- Passe pelas partículas na peça e jogue-as de acordo com o tipo de peça
  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

    -- Clone as partículas na pasta, mesmo que haja mais de uma e anexar ao jogador
    for _, emitter in ServerStorage.TutorialParticles:GetChildren() do
      emitter:Clone().Parent = playerParticleAttachment
    end
  end)
end

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

Este script desencadeia a partícula de choque sempre que os jogadores interagem com metas. Há uma variável chamada EMIT_RATE que determina quantas partículas de choque são geradas durante uma interação.

In StarterPlayer > StarterPlayerScripts, create a new ScriptLocal named TutorialScript .

Então, cole o script abaixo. Este script cria e gerencia o feixe usado para guiar os jogadores.


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)

Jogue o projeto para testar os scripts. Mova-se de cabine em cabine, usando o recurso de interação para ver se o código está funcionando.

Dicas de solução de problemas

Problema : Partículas jogadas quando o jogo começa.

Vá para o Armazenamento do Servidor > Partículas de Tutorial > Rajada. Verifique se o Enabled está desligado. Problema : Avisos no compilador, como um "rendimento infinito".
Como o script está procurando por objetos específicos em certos locais, é possível que uma parte seja chamada de maneira errada. Verifique duas vezes se o nome e o local de cada parte no jogo correspondem ao Tutorial.

Benefícios e Limitações de Script

Se você estiver usando este sistema de tutorial em sua experiência, lembre-se do seguindo: Benefícios

Eventos como TutorialEnd podem ser usados para acionar outros scripts. Por instância, você pode conceder aos jogadores um item especial quando esse evento é acionado.
O script TutorialParticles pode jogar várias partículas de uma vez. Você pode adicionar mais partículas em ServerStorage/TutorialParticles para efeitos mais complexos. Limitações
O progresso do jogador no tutorial não é persistente, o que significa que você terá que codificar alguma maneira de salvar esse progresso. Para obter orientações, consulte o artigo: Saving Data.