Séquenceur d'événements

EventSequencer est un cadre puissant qui vous permet de créer des événements et des scènes de coupe en direct, inter-serveur sur une séquence structurée d'actions et de déclencheurs. Plus spécifiquement, ce module vous aide à :

• Créez un événement ou une scène de coupe sur un cadre structuré grâce à des configurations planifiées d'audio, d'animations et d'interpolations.
• Transition entre plusieurs scènes sur plusieurs serveurs, synchroniser les animations et les visuels complexes sur une chronologie.
• Rechercher à travers un événement et prévisualiser l'expérience à des fins de test et de développement.

Ce cadre a été testé en bataille dans les événements de Roblox, comme les Twenty One Pilots et les contenus de 24kGoldn, ainsi que de nombreuses expériences très visitées.

Pour voir EventSequencer en action dans un emplacement modifiable, vérifiez le modèle de concert dans Roblox Studio. Ce modèle est un point de départ complet pour que les développeurs puissent créer des événements / concerts et se familiariser avec les diverses fonctionnalités et composants impliqués.

Utilisation du module

Installation

Pour utiliser le cadre EventSequencer dans une expérience :

1. Dans l'onglet Voir, ouvrez la Boîte à outils et sélectionnez l'onglet Marketplace.

   

2. Assurez-vous que le filtre Modèles est sélectionné, puis cliquez sur le bouton Voir tout pour afficher les catégories.

   

3. Localisez et cliquez sur la vignette MODULES DEV.

   

4. Localisez le module Event Sequencer et cliquez dessus, ou faites-le glisser dans la visualisation 3D.

   

5. Dans la fenêtre Explorateur, déplacez l'intégralité du modèle EventSequencer dans ServerScriptService. Lors de l'exécution de l'expérience, le module se distribuera lui-même vers divers services et commencera à s'exécuter.

   

Modes de cadre

Mode de remplacement

Le mode de cadre par défaut est le mode de remplacement dans lequel vous créez des scènes uniques en plaçant des objets 3D, le terrain, les propriétés d'éclairage, les effets d'environnement et les objets de l'interface utilisateur dans le dossier Environnement de cette scène. Lorsqu'une scène se charge, ces objets et propriétés sont distribués dans Workspace, Terrain et Lighting, en remplaçant les objets / propriétés existantes pour former un espace cloné.

Mode en ligne

Un mode de cadre alternatif est le mode en ligne dans lequel vous créez des scènes uniques avec une logique de script pour leur flux / événements, mais le cadre ne détruira pas les objets 3D existants, le terrain, les propriétés d'éclairage, les effets d'environnement et les objets de l'interface utilisateur afin de cloner des éléments / propriétés à partir du dossier Environnement d'une scène lors du chargement.

Pour activer le mode en ligne :

1. Dans le dossier EventSequencer que vous avez placé dans ServerScriptService, explorez et sélectionnez la valeur En ligne dans le dossier ReplicatedStorage.

   

2. Dans la fenêtre Propriétés, activez sa case à cocher Valeur.

   

Créer des scènes

Une scène fait essentiellement partie d'un événement global ou d'une scène de coupe enveloppée dans une série de dossiers. Chaque scène comporte une logique de script qui définit son flux / événements, et une scène peut stocker ses propres objets 3D, terrains, propriétés d'éclairage, effets d'environnement et objets d'interface utilisateur.

Pour commencer rapidement, vous pouvez trouver une scène vide dans le dossier principal du module :

1. Développez le dossier EventSequencer et localisez le dossier BlankScene.

   

2. Déplacez ou copiez l'intégralité du dossier BlankScene dans ReplicatedStorage.

   

   Tout en développant un événement, vous pouvez alternativement placer des scènes ailleurs dans la hiérarchie de l'[Explorer](/studio/explorer) et les marquer avec SequencerScene en utilisant l'Éditeur de tags, accessible à partir de l'onglet [View](/studio/view-tab) (BlankScene est déjà étiqueté comme tel). Cependant, vous devrez déplacer toutes les scènes prêtes à l'événement sur ReplicatedStorage pour qu'elles fonctionnent dans le flux d'événement global.

Longueur de temps

Chaque scène doit avoir une durée de temps, en secondes, définissant sa durée — tout comme un film ou un concert a une durée définie. La longueur de temps est définie comme un attribut numérique dans le dossier de la scène nommé TimeLength que vous pouvez définir directement dans Studio ou par programme via Instance:SetAttribute().

Environnement

Le dossier Environnement d'une scène comporte tout ce que les utilisateurs voient et entendent, y compris les objets 3D, le terrain, les propriétés d'éclairage et les effets d'environnement, et les objets d'interface utilisateur. Lorsqu'une scène se charge, ces objets et propriétés sont distribués dans Workspace, Terrain et , eLightingn remplaçant les objets / propriétés existantes pour former un espace cloné.

Le dossier Environnement comporte les récipients suivants :

Événements

Le dossier Événements d'une scène est purement un espace réservé pour RemoteEvents qui communique entre les modules Client et Serveur. Ce n'est pas une exigence de placer quoi que ce soit dans ce dossier.

Client

Ce script exécute la logique de schéma sur le client.

Serveur

Ce script exécute la logique de schéma sur le serveur.

Schémas de scène

Le schéma d'une scène définit ce qui se passe à quel moment dans la chronologie de la scène. Vous devez définir le schéma d'une scène dans ses modules Client et Serveur et inclure les crochets de cycle de vie pour gérer les configurations se produisent.

Crochets de cycle de vie

Les crochets de cycle de vie du schéma vous permettent de gérer les opérations de la scène lorsqu'elles se produisent. Une scène dans la production s'exécutera généralement dans le flux le plus simple :

OnRun peut être interrompu lorsque vous cherchez :

Les trois crochets peuvent également se répéter si la scène est rejouée :

Configurations

Les configurations de schéma définissent les opérations de base d'une scène, par exemple la lecture d'audio à 00:32, la mise en file d'attente d'une animation à synchroniser avec cet audio, la planification d'un événement de scène comme un feu d'artifice s'affiche, et plus encore. Chaque configuration prend en charge certaines fonctions de rappel où le premier paramètre (self) est l'instance de configuration.

Rechercher les scènes

Une fonctionnalité unique d'EventSequencer est la possibilité de « chercher » autour des scènes que vous pourriez rechercher à travers une vidéo. En mode remplacer, vous pouvez également passer d'une scène à l'autre pour prévisualiser un événement multiscène avant de le déployer en production.

La recherche de scène n'est pas accessible à tout le monde, car les utilisateurs qui profitent simplement de l'événement ne doivent pas avoir la possibilité de gérer son flux temporel. Au lieu de cela, vous devez accorder la permission de recherche en fonction du PlaceId de l'événement ainsi que des UserIds ou groupes spécifiques et des rôles dans ceux-ci.

1. Créez un nouveau Script dans ServerScriptService.

2. Collez le code suivant dans le nouveau script.

   Script - Set Seeking Permissions
   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
   EventSequencer.setSeekingPermissions({
    placeIDs = {},
    userIDs = {},
    groups = {
        {GroupID = , MinimumRankID = },
    }
   })

3. Complétez les tableaux suivants dans l'appel setSeekingPermissions comme suit :

Plugin gestionnaire de scène

Le plugin gestionnaire de scène est un outil utile pour charger et décharger les scènes, l'éclairage et le terrain. Sauf si vous utilisez le mode en ligne, il est fortement recommandé d'utiliser ce plugin au lieu de placer / modifier manuellement les objets et les propriétés de la scène.

Pour installer le plugin :

1. Dans le menu Affichage de Studio, ouvrez la Boîte à outils.

   

2. Avec l'onglet Marketplace sélectionné, sélectionnez Plugins dans le menu déroulant.

   

3. Dans le champ de recherche, saisissez Gestionnaire de scène et appuyez sur Entrée pour localiser le plugin.

   

4. Cliquez sur l'icône du plugin pour afficher ses détails, puis cliquez sur le bouton Installer bleu.

   

5. Une fois que le plugin est installé, il apparaît dans l'onglet Plugins de Studio.

   

Charger et décharger les scènes

Comme décrit dans Créer des scènes, le dossier Environnement d'une scène comporte tout ce que les utilisateurs voient et entendent, y compris les objets 3D. Le plugin vous aide à charger rapidement les éléments d'une scène dans ou hors des dossiers organisés dans l'espace de travail.

Enregistrer et charger l'éclairage

Le service Lighting de haut niveau stocke toutes les propriétés d'éclairage et les effets visuels d'un emplacement. Comme il s'agit d'un service de haut niveau, vous ne pouvez pas le déplacer manuellement vers l'Environnement / Serveur ou le dossier Environnement / Client d'une scène spécifique. Au lieu de cela, vous pouvez utiliser le plugin pour copier ses propriétés et ses enfants dans le dossier Environnement / Éclairage de la scène.

1. Paramétrez les propriétés d'éclairage de la scène, les effets de post-traitement, les effets atmosphériques et les skyboxes via le service Lighting de haut niveau.

   

2. Dans la fenêtre de plugin Gestionnaire de scène, cliquez sur Enregistrer l'éclairage pour la scène souhaitée.

   

3. Sélectionnez et développez le dossier Environnement / Éclairage de cette scène et vous verrez les mêmes propriétés d'éclairage que les attributs du dossier, ainsi que les enfants clonés du service Lighting de haut niveau.

Une fois que les propriétés d'éclairage et les enfants sont enregistrés pour une scène, vous pouvez rapidement les charger dans le service Lighting de haut niveau en cliquant sur Charger l'éclairage dans la fenêtre de plugin.

Enregistrer et charger le terrain

Puisque Terrain est un class de haut niveau dans Workspace, vous ne pouvez pas déplacer manuellement le terrain généré ou sculpé vers l'Environnement / Serveur ou le dossier Environnement / Client d'une scène spécifique. Au lieu de cela, vous pouvez utiliser le plugin pour le copier dans le dossier Environnement / Terrain de la scène.

1. Paramétrez le terrain de la scène via le service de Terrain de haut niveau.

   

2. Dans la fenêtre de plugin Gestionnaire de scène, cliquez sur Enregistrer le terrain pour la scène souhaitée.

   

3. Sélectionnez et développez le dossier Environnement / Terrain de cette scène et vous verrez un objet TerrainRegion qui représente le terrain enregistré.

   

   Une fois que le terrain est enregistré pour une scène, vous pouvez rapidement le charger dans le service Terrain de haut niveau en cliquant sur Charger le terrain dans la fenêtre de plugin.

   

Référence API

Crochets de cycle de vie de schéma

OnSetup

Le crochet de cycle de vie OnSetup est destiné à initialiser les éléments et les variables qui seront référencés dans OnRun ou OnEndScene, en mettant en place connections qui sont destinés à durer pendant la durée de la scène, etc. Ce crochet reçoit le paramètre timePositionObject qui vous permet de lire l'heure actuelle à l'installation.

Client Schema
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
local Schema = EventSequencer.createSchema()
local clientEnvironment
local serverEnvironment
local dummy
Schema.OnSetup = function(timePositionObject)
    print("OnSetup (Client)")
    -- Access scene environments; does not apply to Inline Mode
    clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
    serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()
    -- Wait for assets
    dummy = clientEnvironment:WaitForChild("Dummy")
    print("Current time is:", timePositionObject.Value)
end

Server Schema
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
local Schema = EventSequencer.createSchema()
local serverEnvironment
local partColorConnection
local changePartColorEvent = script.Parent.Events.ChangePartColor
Schema.OnSetup = function(timePositionObject)
    print("OnSetup (Server)")
    -- Access scene environment; does not apply to Inline Mode
    serverEnvironment = EventSequencer.getCurrentSceneEnvironment()
    partColorConnection = changePartColorEvent.OnServerEvent:Connect(function(player, changedPart, newColor)
        serverEnvironment.changedPart.Color = newColor
    end)
    print("Current time is:", timePositionObject.Value)
end

OnRun

OnRun est le principal crochet de cycle de vie opérationnel dans un schéma. Il doit comporter toutes les configurations chronométrées pour la scène, de la lecture audio ou d'une animation à la planification d'un événement comme un feu d'artifice s'affiche.

Client Schema
Schema.OnRun = function()
    print("OnRun (Client)")
    local MainAudio = Schema:audio({
        StartTime = 1,
        SoundId = "rbxassetid://1838673350",
        OnStart = function(self)
            print("Audio playing")
        end,
        OnEnd = function(self)
            print("Audio ended")
        end
    })
end

OnEndScene

Le crochet de cycle de vie OnEndScene est utile pour nettoyer tout ce qui est exceptionnel dans la scène, comme débrancher les liaisons créées dans OnSetup ou OnRun qui restent pendant la durée de la scène.

Server Schema
Schema.OnEndScene = function()
    print("OnEndScene (Server)")
    if partColorConnection then
        partColorConnection:Disconnect()
        partColorConnection = nil
    end
end

Configurations de schéma

Audio

Crée un objet Sound dans l'espace de travail qui joue à un certain moment. Le son est ensuite supprimé après que la scène est terminée ou après que l'objet Sound finit de jouer.

Client Schema
Schema.OnRun = function()
    print("OnRun (Client)")
    local MainAudio = Schema:audio({
        StartTime = 1,
        SoundId = "rbxassetid://1838673350",
        OnStart = function(self)
            print("Audio playing")
        end,
        OnEnd = function(self)
            print("Audio ended")
        end
    })
end

animer

Crée un Animation qui joue à un certain moment.

Client Schema
Schema.OnRun = function()
    print("OnRun (Client)")
    local MainAudio = Schema:audio({
        StartTime = 1,
        SoundId = "rbxassetid://1838673350",
    })
    local DanceAnimation = Schema:animate({
        AnimationId = "rbxassetid://3695333486",
        Rig = Dummy,
        Speed = 1,
        FadeInTime = 0.1,
        FadeOutTime = 0.3,
        SyncToAudio = {
            Audio = MainAudio,
            StartAtAudioTime = 5,
        },
        OnStart = function(self)
            print("Animation playing")
        end,
        OnEnd = function(self)
            print("Animation stopped")
        end
    })
end

tween

Crée un Tween paramétrable qui est préservé dans la recherche et dans la jointure dynamique, ce qui signifie que vous pouvez enchaîner les interpolations à des points séparés dans le temps et que tout doit jouer et synchroniser comme prévu.

Client Schema
Schema.OnRun = function()
    print("OnRun (Client)")
    local MainAudio = Schema:audio({
        StartTime = 1,
        SoundId = "rbxassetid://1838673350",
    })
    local LightFadeOut = Schema:tween({
        StartTimes = {29.884},
        Tween = {
            Object = game:GetService("Lighting"),
            Info = TweenInfo.new(2, Enum.EasingStyle.Sine, Enum.EasingDirection.Out),
            Properties = {
                Brightness = 0,
            }
        },
        SyncToAudio = {
            Audio = MainAudio,
            StartAtAudioTimes = {5, 7.2, 9.4, 11.6},
        },
        OnStart = function(self)
            print("Tween playing")
        end,
        OnHeartbeat = function(self, alpha)
            print("Tween alpha", alpha)
        end,
        OnEnd = function(self)
            print("Tween completed")
        end,
    })
end

intervalle

Exécute une fonction de rappel personnalisée sur une durée spécifiée, sur une fréquence spécifiée, en secondes. Utile pour répéter des événements comme les lumières clignotantes, pulser l'intensité d'un audio, etc. La fréquence la plus basse possible est de 0 sec, mais techniquement, la fréquence minimale est toujours fixée à Heartbeat.

Client Schema
Schema.OnRun = function()
    print("OnRun (Client)")
    local MainAudio = Schema:audio({
        StartTime = 1,
        SoundId = "rbxassetid://1838673350",
    })
    local ClientTimerUpdate = Schema:interval({
        Frequency = 1,
        SyncToAudio = {
            StartAtAudioTime = 2.5,
            EndAtAudioTime = 10,
            Audio = MainAudio
        },
        OnInterval = function(self)
            print(MainAudio.Sound.TimePosition, MainAudio.CurrentSoundIntensityRatio)
        end,
    })
end

calendrier

Semblable à l'intervalle, sauf que vous pouvez définir plusieurs moments de départ spécifiques pour le même événement, comme planifier un feu d'artifice s'affiche deux fois dans une scène.

Client Schema
Schema.OnRun = function()
    print("OnRun (Client)")
    Schema:schedule({
        StartTimes = {5, 27.25},
        OnStart = function(self)
            -- Initialize temporary heartbeat connection
            local tempConnection = RunService.Heartbeat:Connect(function()
            end)
            -- Inform framework of connection
            Schema:inform(tempConnection)
        end
    })
end

informer

Informe le cadre de tous les modules, objets d'UI, liaisons, etc. qui sont créés dans le crochet de cycle de vie OnRun, en veillant à ce qu'ils soient correctement nettoyés lorsque vous cherchez. Les cas d'utilisation comprennent :

• Informer le cadre d'une liaison ad hoc temporaire telle que RunService.Heartbeat afin que la liaison soit nettoyée lorsque vous cherchez à un point plus tôt dans la durée de la scène.

  Server Schema
  Schema.OnRun = function()
    print("OnRun (Server)")
    Schema:schedule({
        StartTimes = {5},
        OnStart = function(self)
            -- Initialize temporary heartbeat connection
            local tempConnection = RunService.Heartbeat:Connect(function()
            end)
            -- Inform framework of connection
            Schema:inform(tempConnection)
        end
    })
  end

• Appeler une fonction de « nettoyage » personnalisée dans un ModuleScript qui initialise une liaison ou une autre référence pendant le crochet de cycle de vie OnRun.

  Server Schema
  local ReplicatedStorage = game:GetService("ReplicatedStorage")
  local RunService = game:GetService("RunService")
  local customModule = require(ReplicatedStorage:WaitForChild("CustomModule"))
  local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
  local Schema = EventSequencer.createSchema()
  Schema.OnRun = function()
    print("OnRun (Server)")
    Schema:schedule({
        StartTimes = {5},
        OnStart = function(self)
            -- Call "init" function in custom module
            customModule.init()
            -- Call "clean" function in custom module on scene cleanup
            Schema:inform(customModule, customModule.clean)
        end,
    })
  end

  ModuleScript - CustomModule
  local RunService = game:GetService("RunService")
  local CustomModule = {}
  CustomModule.init = function()
    -- Initialize heartbeat connection
    CustomModule.connection = RunService.Heartbeat:Connect(function()
    end)
  end
  CustomModule.clean = function()
    -- Disconnect and clear heartbeat connection
    if CustomModule.connection then
        CustomModule.connection:Disconnect()
        CustomModule.connection = nil
    end
  end
  return CustomModule

Fonctions

loadScene

loadScene(sceneName:string, startTime:number?)

Charge par programme une scène par sceneName et la commence startTime dès son début. Il y aura une deuxième « période de grâce » de 5 secondes pour la scène à charger à partir du serveur avant que la recherche ne se produise et que la scène commence à jouer. Cela signifie que si vous appelez loadScene("[SceneName]", 20) à exactement 16 h 15 min 00 s, le cadre attendra 5 secondes en plus des 20 demandées, donnant le coup d'envoi de la scène à 16 h 15 min 25 s.

Script
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
-- Figure out next scene to load when current scene finishes
EventSequencer.onOrchestrationFinished:Connect(function(endedSceneName)
    if endedSceneName == "PreShow" then
        -- "PreShow" ended; load the first scene in the concert
        EventSequencer.loadScene("Track1")
    elseif endedSceneName == "Track1" then
        -- "Track1" ended; load the second scene in the concert
        EventSequencer.loadScene("Track2")
    else
        -- Loop back to the pre-show scene
        EventSequencer.loadScene("PreShow")
    end
end)

createSchema

createSchema():table

Renvoie une instance du schéma de la scène pour créer une logique pour la scène.

Client Schema
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
local Schema = EventSequencer.createSchema()
Schema.OnSetup = function(timePositionObject)
    print("OnSetup (Client)")
end

chercher

seek(time:number)

Cherche à la valeur time , en secondes, du début de la scène actuellement chargée.

Script
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
EventSequencer.seek(95.58)

setSceneWarningTime

setSceneWarningTime(endSceneTimeWindow:number)

Définit le temps entre la fin de toutes les scènes auxquelles un avertissement est envoyé. Vous pouvez détecter l'avertissement côté client via onSceneEndingWarningForClient ou côté serveur via onSceneEndingWarningForServer.

Script
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
-- Load scene
EventSequencer.loadScene("BeautifulScene")
-- Set warning time to 5 seconds before the scene ends
EventSequencer.setSceneWarningTime(5)
-- Detect when scene is about to end
EventSequencer.onSceneEndingWarningForServer:Connect(function()
    warn("Scene is about to end!")
end)
end)

setSeekingPermissions

setSeekingPermissions(permissions:table)

Accords cherchant la permission en fonction du PlaceId de l'événement ainsi que des UserIds spécifiques ou groupes et rôles dans ceux-ci. Voir Chercher et changer de scènes pour plus d'informations.

getCurrentSceneEnvironment

getCurrentSceneEnvironment():Folder RENDEMENTS

Renvoie le dossier Environnement côté client ou côté serveur de la scène actuelle, selon qu'il est appelé à partir du script de schéma Client ou du script de schéma Serveur, respectivement.

Client Schema
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
local Schema = EventSequencer.createSchema()
local clientEnvironment
local serverEnvironment
Schema.OnSetup = function(timePositionObject)
    print("OnSetup (Client)")
    -- Access scene environments; does not apply to Inline Mode
    clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
    serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()
    print("Current time is:", timePositionObject.Value)
end

Server Schema
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
local Schema = EventSequencer.createSchema()
local serverEnvironment
local partColorConnection
local changePartColorEvent = script.Parent.Events.ChangePartColor
Schema.OnSetup = function(timePositionObject)
    print("OnSetup (Server)")
    serverEnvironment = EventSequencer.getCurrentSceneEnvironment()
    partColorConnection = changePartColorEvent.OnServerEvent:Connect(function(player, changedPart, newColor)
        serverEnvironment.changedPart.Color = newColor
    end)
end

getCurrentServerEnvironmentFromClient

getCurrentServerEnvironmentFromClient():Folder RENDEMENTS

Renvoie le dossier Environnement côté serveur de la scène actuelle. À la différence de getCurrentSceneEnvironment, vous pouvez appeler cela à partir du script de schéma Client.

Client Schema
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
local Schema = EventSequencer.createSchema()
local clientEnvironment
local serverEnvironment
Schema.OnSetup = function(timePositionObject)
    print("OnSetup (Client)")
    -- Access scene environments; does not apply to Inline Mode
    clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
    serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()
    print("Current time is:", timePositionObject.Value)
end

isLoadingScene

isLoadingScene():boolean

Appelé à partir du serveur pour savoir si une scène se charge actuellement.

Script
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
print(EventSequencer.isLoadingScene())
while EventSequencer.isLoadingScene() do
    task.wait()
end
print("Scene loaded")

Événements

onSceneEndingWarningForClient

onSceneEndingWarningForClient(): RBXScriptSignal

Se déclenche sur le client avant que la scène est sur le point de se terminer. Le temps par défaut est de 3 sec, mais vous pouvez le configurer via setSceneWarningTime. Cet événement peut uniquement être lié dans un LocalScript.

LocalScript
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
-- Detect when scene is about to end (client-side)
EventSequencer.onSceneEndingWarningForClient:Connect(function()
    warn("Scene is about to end!")
end)
end)

onSceneEndingWarningForServer

onSceneEndingWarningForServer(): RBXScriptSignal

Se déclenche sur le serveur avant que la scène est sur le point de se terminer. Le temps par défaut est de 3 sec, mais vous pouvez le configurer via setSceneWarningTime. Cet événement peut uniquement être lié dans un Script.

Script
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
-- Detect when scene is about to end (server-side)
EventSequencer.onSceneEndingWarningForServer:Connect(function()
    warn("Scene is about to end!")
end)
end)

onSceneLoadedForClient

onSceneLoadedForClient(): RBXScriptSignal

Se déclenche sur le client lorsque la scène commence. Cet événement peut uniquement être lié dans un LocalScript.

LocalScript
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
-- Detect when scene is starting (client-side)
EventSequencer.onSceneLoadedForClient:Connect(function()
    warn("Scene is starting!")
end)
end)

onOrchestrationFinished

onOrchestrationFinished(): RBXScriptSignal

Se déclenche sur le serveur lorsqu'une scène a atteint sa durée et a pris fin efficacement. Cet événement reçoit un argument de nom de chaîne endedSceneName pour la scène qui vient de se terminer et vous pouvez enchaîner cet événement pour charger une autre scène. Peut uniquement être lié dans un Script.

Script
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
-- Figure out next scene to load when current scene finishes
EventSequencer.onOrchestrationFinished:Connect(function(endedSceneName)
    if endedSceneName == "PreShow" then
        -- "PreShow" ended; load the first scene in the concert
        EventSequencer.loadScene("Track1")
    elseif endedSceneName == "Track1" then
        -- "Track1" ended; load the second scene in the concert
        EventSequencer.loadScene("Track2")
    else
        -- Loop back to the pre-show scene
        EventSequencer.loadScene("PreShow")
    end
end)