Séquenceur d'événements

Séquenceur d'événements est un cadre puissant qui vous permet de créer des événements en direct et des cinématiques inter-serveurs sur une séquence structurée d'actions et de déclencheurs. Plus précisément, ce module vous aide à :

• Construire un événement ou une cinématique sur une structure organisée à travers des configurations planifiées d'audio, d'animations et de tweens.
• Passer d'une scène à plusieurs scènes sur plusieurs serveurs, synchronisant des animations et des visuels complexes à 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é éprouvé dans des événements Roblox tels que les concerts de Twenty One Pilots et 24kGoldn, ainsi que de nombreuses expériences très visitées.

Pour voir Séquenceur d'événements en action dans un lieu modifiable, consultez le modèle Concert dans Roblox Studio. Ce modèle est un point de départ complet pour les développeurs pour 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 Séquenceur d'événements dans une expérience :

1. Depuis le menu Fenêtre de Studio ou la barre d'outils de l'onglet Accueil, ouvrez la Boîte à outils et sélectionnez l'onglet Magasin des créateurs.

   

2. Assurez-vous que le tri des Modèles est sélectionné, puis cliquez sur le bouton Voir Tout pour les Catégories.

   

3. Localisez et cliquez sur la tuile Packages.

4. Localisez le module Séquenceur d'événements et cliquez dessus, ou faites-le glisser et déposez-le dans la vue 3D.

   

5. Dans la fenêtre Explorateur, déplacez l'ensemble du modèle Séquenceur d'événements dans ServerScriptService. Lors de l'exécution de l'expérience, le module 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 concevez des scènes uniques en plaçant des objets 3D, terrain, propriétés d'éclairage, effets environnementaux et des objets d'interface utilisateur dans le dossier Environnement de cette scène. Lorsqu'une scène se charge, ces objets et propriétés sont répartis dans Workspace, Terrain, et Lighting, remplaçant les objets/propriétés existants pour former un espace cloné.

Mode en ligne

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

Pour activer le mode en ligne :

1. À l'intérieur du modèle Séquenceur d'événements que vous avez placé dans ServerScriptService, développez et sélectionnez la valeur Inline 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 est essentiellement une partie d'un événement global ou d'une cinématique regroupée dans une série de dossiers. Chaque scène contient une logique de script qui définit son flux/événements, et une scène peut stocker ses propres objets 3D, terrain, propriétés d'éclairage, effets environnementaux 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 Séquenceur d'événements et localisez le dossier BlankScene.

   

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

   

   Lors du développement d'un événement, vous pouvez alternativement placer les scènes ailleurs dans la hiérarchie Explorateur et les taguer avec SequencerScene en utilisant la section Tags de leurs propriétés (BlankScene est déjà tagué comme tel). Cependant, vous devrez déplacer toutes les scènes prêtes pour l'événement vers ReplicatedStorage afin qu'elles fonctionnent dans le flux global de l'événement.

Durée

Chaque scène doit avoir une durée, en secondes, définissant sa durée - tout comme un film ou un concert a une durée définie. La durée 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 programmatique à travers Instance:SetAttribute().

Environnement

Le dossier Environnement d'une scène contient tout ce que les utilisateurs voient et entendent, y compris des objets 3D, terrain, propriétés d'éclairage et effets environnementaux, ainsi que des objets d'interface utilisateur. Lorsqu'une scène se charge, ces objets et propriétés sont répartis dans Workspace, Terrain, et Lighting, remplaçant les objets/propriétés existants pour former un espace cloné.

Le dossier Environnement contient les conteneurs suivants :

Événements

Le dossier Événements d'une scène est purement un espace réservé pour RemoteEvents qui communiquent entre les modules Client et Serveur. Il n'est pas nécessaire 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ènes

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 des crochets de cycle de vie pour gérer quand les configurations se produisent.

Crochets de cycle de vie

Les crochets de cycle de vie de schéma vous permettent de gérer quand les opérations de scène se produisent. Une scène en production exécutera typiquement dans le flux le plus simple :

• OnSetup → OnRun → OnEndScene

OnRun peut être interrompu lors de la recherche :

• OnSetup → OnRun… recherche → OnRun… recherche → OnRun → OnEndScene

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

• OnSetup → OnRun → OnEndScene… rejouer → OnSetup → OnRun → OnEndScene

Configurations

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

Rechercher des scènes

Une fonctionnalité unique de Séquenceur d'événements est la capacité de "rechercher" à travers les scènes comme vous pourriez rechercher à travers une vidéo. En Mode de remplacement, vous pouvez également passer d'une scène à l'autre pour prévisualiser l'ensemble d'un événement multi-scènes avant de le déployer en production.

La recherche de scènes n'est pas accessible à tout le monde puisque les utilisateurs qui profitent simplement de l'événement ne devraient pas avoir la capacité de contrôler son flot temporel. Au lieu de cela, vous devez accorder l'autorisation de recherche basée sur le PlaceId de l'événement ainsi que des UserIds spécifiques et/ou des groupes et des rôles au sein de ceux-ci.

1. Créez un nouveau Script dans ServerScriptService.

2. Collez le code suivant dans le nouveau script.

   Script - Définir les autorisations de recherche
   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   
   local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
   
   EventSequencer.setSeekingPermissions({
   	placeIDs = {},
   	userIDs = {},
   	groups = {
   		{GroupID = , MinimumRankID = },
   	}
   })

3. Remplissez les tableaux suivants dans l'appel setSeekingPermissions comme suit :

   placeIDs	Liste délimitée par des virgules des valeurs PlaceId pour prendre en charge la recherche.
   userIDs	Liste délimitée par des virgules des UserIds de ceux qui peuvent rechercher dans les lieux pris en charge.
   groups	Liste délimitée par des virgules de tableaux, chacun contenant un ID de groupe et le rang minimum des membres de ce groupe qui peuvent rechercher dans les lieux pris en charge.

Plugin de gestion de scènes

Le plugin Gestionnaire de scènes est un outil utile pour charger et décharger des scènes, des éclairages, et du terrain. À moins que vous n'utilisiez le Mode en ligne, il est fortement recommandé d'utiliser ce plugin plutôt que de placer/modifier manuellement des objets et des propriétés de scène.

Pour installer le plugin :

1. Depuis le menu Fenêtre de Studio ou la barre d'outils de l'onglet Accueil, ouvrez la Boîte à outils.

2. Avec l'onglet Magasin des créateurs sélectionné, sélectionnez Plugins dans le menu déroulant.

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

   

4. Cliquez sur l'icône du plugin pour voir ses détails et cliquez ensuite sur le bouton Installer.

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

Charger et décharger des scènes

Comme souligné dans création de scènes, le dossier Environnement d'une scène contient tout ce que les utilisateurs voient et entendent, y compris des objets 3D. Le plugin vous aide à rapidement charger les actifs d'une scène dans ou hors des dossiers organisés au sein de l'espace de travail.

Enregistrer et charger l'éclairage

Le service de niveau supérieur Lighting stocke toutes les propriétés d'éclairage et effets visuels d'un lieu. Étant un service de niveau supérieur, vous ne pouvez pas le déplacer manuellement vers le dossier Environnement/Serveur ou Environnement/Client d'une scène particulière. Au lieu de cela, vous pouvez utiliser le plugin pour copier ses propriétés et enfants vers le dossier Environnement/Éclairage de la scène.

1. Configurez les propriétés d'éclairage, les effets de post-traitement, les effets atmosphériques, et les ciel de la scène via le service de niveau supérieur Lighting.

   

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

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

   

   

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

Enregistrer et charger le terrain

Puisque Terrain est une classe de niveau supérieur au sein de Workspace, vous ne pouvez pas déplacer manuellement le terrain généré ou sculpté vers le dossier Environnement/Serveur ou Environnement/Client d'une scène particulière. Au lieu de cela, vous pouvez utiliser le plugin pour le copier dans le dossier Environnement/Terrain de la scène.

1. Configurez le terrain de la scène via le service de niveau supérieur Terrain.

   

2. Dans la fenêtre du plugin Gestionnaire de scènes, 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 de niveau supérieur Terrain en cliquant sur Charger le terrain depuis la fenêtre du plugin.

Référence API

Crochets de cycle de vie du schéma

OnSetup

Le crochet de cycle de vie OnSetup est destiné à l'initialisation des actifs et des variables qui seront référencés dans OnRun ou OnEndScene, établissant des connexions qui sont destinées à durer pendant toute la durée de la scène, etc. Ce crochet reçoit le paramètre timePositionObject qui vous permet de lire le temps actuel lors de la configuration.

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

	-- Accéder aux environnements de scène ; cela ne s'applique pas au Mode en ligne
	clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
	serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()
	-- Attendre les actifs
	dummy = clientEnvironment:WaitForChild("Dummy")

	print("Le temps actuel est :", 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)")

	-- Accéder à l'environnement de scène ; cela ne s'applique pas au Mode en ligne
	serverEnvironment = EventSequencer.getCurrentSceneEnvironment()
	partColorConnection = changePartColorEvent.OnServerEvent:Connect(function(player, changedPart, newColor)
		serverEnvironment.changedPart.Color = newColor
	end)

	print("Le temps actuel est :", timePositionObject.Value)
end

OnRun

OnRun est le principal crochet de cycle de vie opérationnel au sein d'un schéma. Il devrait contenir toutes les configurations chronométrées pour la scène, de la lecture d'audio ou d'une animation à la programmation d'un événement tel qu'un feu d'artifice.

Client Schema
Schema.OnRun = function()
	print("OnRun (Client)")

	local MainAudio = Schema:audio({
		StartTime = 1,
		SoundId = "rbxassetid://1838673350",
		OnStart = function(self)
			print("Audio en cours de lecture")
		end,
		OnEnd = function(self)
			print("Audio terminé")
		end
	})
end

OnEndScene

Le crochet de cycle de vie OnEndScene est utile pour nettoyer tout ce qui reste dans la scène, comme déconnecter les connexions créées dans OnSetup ou OnRun qui restent pendant toute 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 la fin de la scène ou après que l'objet Sound a fini de jouer.

Client Schema
Schema.OnRun = function()
	print("OnRun (Client)")

	local MainAudio = Schema:audio({
		StartTime = 1,
		SoundId = "rbxassetid://1838673350",
		OnStart = function(self)
			print("Audio en cours de lecture")
		end,
		OnEnd = function(self)
			print("Audio terminé")
		end
	})
end

animate

Crée une 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 en cours de lecture")
		end,
		OnEnd = function(self)
			print("Animation arrêtée")
		end
	})
end

tween

Crée un Tween configurable qui est préservé lors de la recherche et dans les entrées dynamiques, ce qui signifie que vous pouvez enchaîner des tweens à des moments différents et que tout jouera et sera synchronisé comme attendu.

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 en cours de lecture")
		end,
		OnHeartbeat = function(self, alpha)
			print("Alpha du tween", alpha)
		end,
		OnEnd = function(self)
			print("Tween terminé")
		end,
	})
end

interval

Exécute une fonction de rappel personnalisée sur une durée spécifiée à une fréquence spécifiée, en secondes. Utile pour des événements répétitifs comme des lumières clignotantes, pulser l'intensité d'un audio, etc. La fréquence la plus basse possible est de 0 secondes, mais techniquement la fréquence minimale est toujours plafonné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

schedule

Semblable à interval sauf que vous pouvez définir plusieurs temps de départ spécifiques pour le même événement, tel que la programmation d'un feu d'artifice deux fois dans une scène.

Client Schema
Schema.OnRun = function()
	print("OnRun (Client)")

	Schema:schedule({
		StartTimes = {5, 27.25},
		OnStart = function(self)
			-- Initialiser la connexion de battement temporaire
			local tempConnection = RunService.Heartbeat:Connect(function()

			end)
			-- Informer le cadre de la connexion
			Schema:inform(tempConnection)
		end
	})
end

inform

Informe le cadre de tout module, objet UI, connexions, etc. qui sont créés dans le crochet de cycle de vie OnRun, en s'assurant qu'ils sont correctement nettoyés lors de la recherche. Les cas d'utilisation incluent :

• Informer le cadre d'une connexion temporaire ad hoc telle que RunService.Heartbeat afin que la connexion soit nettoyée lors de la recherche vers un point antérieur dans la durée de la scène.

  Server Schema
  Schema.OnRun = function()
  	print("OnRun (Server)")
  
  	Schema:schedule({
  		StartTimes = {5},
  		OnStart = function(self)
  			-- Initialiser la connexion de battement temporaire
  			local tempConnection = RunService.Heartbeat:Connect(function()
  
  			end)
  			-- Informer le cadre de la connexion
  			Schema:inform(tempConnection)
  		end
  	})
  end

• Appeler une fonction de "nettoyage" personnalisée dans un ModuleScript qui initialise une connexion ou 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)
  			-- Appeler la fonction "init" dans le module personnalisé
  			customModule.init()
  			-- Appeler la fonction "clean" dans le module personnalisé lors du nettoyage de la scène
  			Schema:inform(customModule, customModule.clean)
  		end,
  	})
  end

  ModuleScript - CustomModule
  local RunService = game:GetService("RunService")
  
  local CustomModule = {}
  
  CustomModule.init = function()
  	-- Initialiser la connexion de battement
  	CustomModule.connection = RunService.Heartbeat:Connect(function()
  
  	end)
  end
  
  CustomModule.clean = function()
  	-- Déconnecter et effacer la connexion de battement
  	if CustomModule.connection then
  		CustomModule.connection:Disconnect()
  		CustomModule.connection = nil
  	end
  end
  
  return CustomModule

Fonctions

loadScene

Charge programatiquement une scène par sceneName et la commence à startTime depuis son début. Il y aura une période de "grâce" de 5 secondes pour que la scène se charge depuis le 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 à 16h15, le cadre attendra 5 secondes en plus des 20 demandés, lançant la scène à 16h15:25.

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

local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))

-- Figurez la prochaine scène à charger lorsque la scène actuelle se termine
EventSequencer.onOrchestrationFinished:Connect(function(endedSceneName)
	if endedSceneName == "PreShow" then
		-- "PreShow" s'est terminé ; chargez la première scène du concert
		EventSequencer.loadScene("Track1")
	elseif endedSceneName == "Track1" then
		-- "Track1" s'est terminé ; chargez la deuxième scène du concert
		EventSequencer.loadScene("Track2")
	else
		-- Revenir à la scène de pré-spectacle
		EventSequencer.loadScene("PreShow")
	end
end)

createSchema

Renvoie une instance du schéma de 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

seek

Recherche la valeur time, en secondes, depuis le 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

Définit la durée de temps avant la fin de toutes les scènes à laquelle un avertissement est envoyé. Vous pouvez détecter l'avertissement soit côté client via onSceneEndingWarningForClient ou côté serveur via onSceneEndingWarningForServer.

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

local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))

-- Charger la scène
EventSequencer.loadScene("BeautifulScene")

-- Définir le temps d'avertissement à 5 secondes avant la fin de la scène
EventSequencer.setSceneWarningTime(5)

-- Détecter lorsque la scène est sur le point de se terminer
EventSequencer.onSceneEndingWarningForServer:Connect(function()
	warn("La scène est sur le point de se terminer !")
end)

setSeekingPermissions

Accorde la permission de recherche en fonction du PlaceId de l'événement ainsi que de UserIds spécifiques et/ou des groupes et des rôles au sein de ceux-ci. Voir chercher et changer de scènes pour plus d'informations.

getCurrentSceneEnvironment

Renvoie le dossier Environnement côté client ou côté serveur de la scène actuelle, selon qu'il soit appelé depuis le script de module Client ou Serveur.

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

	-- Accéder aux environnements de scène ; cela ne s'applique pas au Mode en ligne
	clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
	serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()

	print("Le temps actuel est :", 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

Renvoie le dossier Environnement côté serveur de la scène actuelle. Contrairement à getCurrentSceneEnvironment, vous pouvez appeler cela depuis le script de module 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)")

	-- Accéder aux environnements de scène ; cela ne s'applique pas au Mode en ligne
	clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
	serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()

	print("Le temps actuel est :", timePositionObject.Value)
end

isLoadingScene

Appelé depuis le serveur pour savoir si une scène est actuellement en cours de chargement.

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

local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))

print(EventSequencer.isLoadingScene())

while EventSequencer.isLoadingScene() do
	task.wait()
end
print("Scène chargée")

Événements

onSceneEndingWarningForClient

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

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

local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))

-- Détecter lorsque la scène est sur le point de se terminer (côté client)
EventSequencer.onSceneEndingWarningForClient:Connect(function()
	warn("La scène est sur le point de se terminer !")
end)

onSceneEndingWarningForServer

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

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

local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))

-- Détecter lorsque la scène est sur le point de se terminer (côté serveur)
EventSequencer.onSceneEndingWarningForServer:Connect(function()
	warn("La scène est sur le point de se terminer !")
end)

onSceneLoadedForClient

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

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

local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))

-- Détecter lorsque la scène commence (côté client)
EventSequencer.onSceneLoadedForClient:Connect(function()
	warn("La scène commence !")
end)

onOrchestrationFinished

Se déclenche sur le serveur lorsqu'une scène a atteint sa durée et a effectivement pris fin. Cet événement reçoit un argument de chaîne endedSceneName pour la scène qui vient de se terminer et vous pouvez enchaîner cet événement pour chargement conditionnel d'une autre scène. Ne peut être connecté que dans un Script.

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

local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))

-- Figurez la prochaine scène à charger lorsque la scène actuelle se termine
EventSequencer.onOrchestrationFinished:Connect(function(endedSceneName)
	if endedSceneName == "PreShow" then
		-- "PreShow" s'est terminé ; chargez la première scène du concert
		EventSequencer.loadScene("Track1")
	elseif endedSceneName == "Track1" then
		-- "Track1" s'est terminé ; chargez la deuxième scène du concert
		EventSequencer.loadScene("Track2")
	else
		-- Revenir à la scène de pré-spectacle
		EventSequencer.loadScene("PreShow")
	end
end)