Ajouter des scripts | Documentation

Il est temps de rassembler tout ce travail ! Maintenant que vous avez créé les composants de faisceau et de particule, vous ajouterez trois scripts prédéfinis. Ces scripts gèrent le tutoriel en informant les composants quand faire quoi. Par exemple, les scripts créeront des faisceaux pour les nouveaux joueurs et émettront des particules chaque fois qu'ils interagissent avec des buts.

Bien que vous puissiez suivre toutes ces étapes même si vous n'avez pas codé auparavant, avoir cette connaissance peut vous aider à ajuster ces scripts pour votre propre expérience. Pour en savoir plus, voir le Fondamentaux du codage tutoriel.

Stockage des rayons et des particules

Avant d'ajouter les scripts, le faisceau et les particules doivent être déplacées là où les scripts pourront faire des copies si nécessaire.

Si vous utilisez votre propre projet, vous devrez peut-être remplacer les valeurs dans certaines variables scriptées pour correspondre à vos objets.

Dans ReplicatedStorage , créez un nouveau dossier nommé PlayerTutorial . Déplacez le TutorialBeam à partir de TestPlayer, et dans le nouveau dossier.
Dans ServerStorage , créez un dossier nommé TutorialParticles . Déplacez la particule de Burst dans ce dossier.
Une fois que l'émetteur de faisceau et de particules est déplacé, vous n'avez plus besoin du TestPlayer. Supprimer TestPlayer car le script fonctionnera avec des joueurs réels lorsque vous aurez terminé.

Créer des événements

Chaque fois qu'un joueur interagit avec un but, le script de tutoriel doit savoir pour qu'il puisse mettre à jour la progression de ce joueur et émettre l'effet de particule. Pour informer les scripts, les signaux peuvent être envoyés en utilisant événements .

Dans ReplicatedStorage > PlayerTutorial, créez deux objets RemoteEvent. Noms-les NextGoal et TutorialEnd.

Ajouter les scripts

Les trois scripts ci-dessous rechercheront l'objet d'émission de particules et le rayon d'objet créés plus tôt et géreront le système de tutoriel.

Dans ReplicatedStorage > PlayerTutorial > créez un nouveau ModuleScript nommé TutorialManager .

Remplacez le code par défaut en copiant et en collant le code entier ci-dessous.


local TutorialManager = {}

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Les parties de but doivent être commandées dans le tableau, ou bien l'ordre du but peut être différent dans le jeu
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")

 -- Espace réservé pour le code suivant. Par exemple, si vous souhaitez envoyer des messages au serveur pour exécuter d'autres tâches

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
   -- Augmenter le traceur de but du joueur
   local currentGoalIndex = player:WaitForChild("GoalProgress")
   currentGoalIndex.Value += 1
 end
end

-- Crée une valeur int pour suivre localement la progression du joueur à travers les buts du tutoriel
function TutorialManager.setupPlayerProgress(player)
 local currentGoalProgress = Instance.new("IntValue")
 currentGoalProgress.Name = "GoalProgress"
 currentGoalProgress.Value = 1
 currentGoalProgress.Parent = player
end

return TutorialManager

Ce script exécute du code pour gérer la progression d'un joueur dans le tutoriel. Cela inclut des tâches comme exécuter du code pour interagir avec des buts, ou ce qui se passe quand le tutoriel est terminé.

Dans ServerScriptService , créez un nouveau Script nommé TutorialParticles .

Collez le code ci-dessous.


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

  -- Passez par les particules sur l'attribut et jouez-y selon le type de particule
  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

    -- Clonez des particules dans le dossier, même si il y en a plus d'un et attachez-les au joueur
    for _, emitter in ServerStorage.TutorialParticles:GetChildren() do
      emitter:Clone().Parent = playerParticleAttachment
    end
  end)
end

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

Ce script joue la particule d'éclat chaque fois que les joueurs interagissent avec des buts. Il y a également une variable nommée EMIT_RATE qui détermine le nombre de particules générées pendant une interaction.

Dans StarterPlayer > StarterPlayerScripts, créez un nouveau LocalScript nommé TutorialScript .

Ensuite, collez le script ci-dessous. Ce script crée et gère le faisceau utilisé pour guider les joueurs.


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)

Jouez le projet pour tester les scripts. Déplacez-vous du stand à l'autre, en utilisant la fonction d'interaction pour voir si le code fonctionne.

Conseils de débogage

Problème : Les particules jouent quand le jeu démarre.

Allez dans ServerStorage > Particles de tutoriel > Explosion. Vérifiez qu'il est activé pour être off. Problème : Avertissements dans le compilateur tels qu'un "rendu infini".
Comme le script recherche des objets spécifiques à certains endroits, il est possible qu'une partie soit nommée incorrectement. Vérifiez deux fois que le nom et l'emplacement de chaque partie dans le jeu correspondent au tutoriel.

Avantages et limites des scripts

Si vous utilisez ce système de tutoriel dans votre expérience, tenez compte des points suivre: Avantages

Des événements tels que TutorialEnd peuvent être utilisés pour déclencher d'autres scripts. Par instance, vous pouvez attribuer des joueurs un élément spécial lorsque cet événement se déclenche.
Le script TutorialParticles peut jouer plusieurs particules à la fois. Vous pouvez ajouter plus de particules dans ServerStorage/TutorialParticles pour des effets plus complexes. Limiteurs
La progression du joueur dans le tutoriel n'est pas persistante, ce qui signifie que vous devrez codez une façon de sauvegarder cette progression. Pour plus de conseils, consultez l'article : Enregistrement des données.