Sequencer di eventi

EventSequencer è un potente framework che ti consente di costruire eventi e cutscene dal vivo e cross-server su una sequenza strutturata di azioni e trigger. Più specificamente, questo modulo ti aiuta a:

• Costruire un evento o una cutscene su un framework strutturato attraverso configurazioni programmate di audio, animazioni e tweens.
• Passare tra più scene su più server, sincronizzando animazioni e visualizzazioni complesse a una timeline.
• Navigare attraverso un evento e visualizzare l'esperienza per scopi di test e sviluppo.

Questo framework è stato collaudato in eventi Roblox come i concerti dei Twenty One Pilots e 24kGoldn, così come molte esperienze ad alta affluenza.

Per vedere EventSequencer in azione all'interno di un luogo modificabile, controlla il template Concert in Roblox Studio. Questo template è un punto di partenza completo per gli sviluppatori per creare eventi/concerti e familiarizzare con le varie funzionalità e componenti coinvolti.

Utilizzo del modulo

Installazione

Per utilizzare il framework EventSequencer in un'esperienza:

1. Dal menu Finestra di Studio o dalla barra degli strumenti della scheda Home, apri il Toolbox e seleziona la scheda Negozio Creatori.

   

2. Assicurati che sia selezionato il sorting per Modelli, quindi fai clic sul pulsante Visualizza Tutti per Categorie.

   

3. Individua e fai clic sulla tessera Pacchetti.

4. Individua il modulo Sequencer di eventi e fai clic su di esso o trascinalo nella vista 3D.

   

5. Nella finestra Esplora, sposta l'intero modello EventSequencer in ServerScriptService. Al momento dell'esecuzione dell'esperienza, il modulo inizierà a funzionare.

Modi del framework

Modalità di sostituzione

La modalità predefinita del framework è la modalità di sostituzione in cui progetti scene uniche scenes posizionando oggetti 3D, terreno, proprietà di illuminazione, effetti ambientali e oggetti di interfaccia utente all'interno della cartella Environment di quella scena. Quando una scena si carica, quegli oggetti e proprietà vengono distribuiti in Workspace, Terrain e Lighting, sostituendo oggetti/proprietà esistenti per formare uno spazio clonabile.

Modalità inline

Una modalità alternativa del framework è la modalità inline in cui progetti anch'esso scene scenes uniche con logica di scripting per i loro flussi/eventi, ma il framework non distruggerà gli oggetti 3D, terreno, proprietà di illuminazione, effetti ambientali e oggetti di interfaccia utente per clonare asset/proprietà dalla cartella Environment di una scena al momento del caricamento.

Per abilitare la modalità inline:

1. All'interno del modello EventSequencer che hai posizionato in ServerScriptService, espandi e seleziona il valore Inline all'interno della cartella ReplicatedStorage.

   

2. Nella finestra Proprietà, attiva la casella Value.

   

Creare scene

Una scena è essenzialmente parte di un evento o di una cutscene avvolta in una serie di cartelle. Ogni scena contiene logica di scripting che definisce il suo flusso/eventi e una scena può memorizzare i propri oggetti 3D, terreno, proprietà di illuminazione, effetti ambientali e oggetti di interfaccia utente.

Per iniziare rapidamente, puoi trovare una scena vuota all'interno della cartella principale del modulo:

1. Espandi la cartella EventSequencer e localizza la cartella BlankScene.

   

2. Sposta o copia l'intera cartella BlankScene in ReplicatedStorage.

   

   Durante lo sviluppo di un evento, puoi alternativamente collocare scene altrove nella gerarchia dell'Esplora e contrassegnarle con SequencerScene utilizzando la sezione Tag delle loro proprietà (BlankScene è già contrassegnato come tale). Tuttavia, dovrai spostare tutte le scene pronte per l'evento in ReplicatedStorage affinché possano funzionare all'interno del flusso dell'evento generale.

Durata

Ogni scena dovrebbe avere una durata, in secondi, che definisce il suo intervallo di tempo — proprio come un film o un concerto ha una durata prestabilita. La durata è definita come un attributo numerico nella cartella della scena chiamata TimeLength che puoi impostare direttamente in Studio o programmaticamente tramite Instance:SetAttribute().

Ambiente

La cartella Environment di una scena contiene tutto ciò che gli utenti vedono e sentono, inclusi oggetti 3D, terreno, proprietà di illuminazione e effetti ambientali, e oggetti di interfaccia utente. Quando una scena si carica, quegli oggetti e proprietà vengono distribuiti in Workspace, Terrain e Lighting, sostituendo oggetti/proprietà esistenti per formare uno spazio clonabile.

La cartella Environment contiene i seguenti contenitori:

Eventi

La cartella Events di una scena è puramente un segnaposto per RemoteEvents che comunicano tra i moduli Client e Server. Non è un requisito collocare nulla in questa cartella.

Client

Questo script esegue la logica dello schema sul client.

Server

Questo script esegue la logica dello schema sul server.

Schemi della scena

Lo schema di una scena definisce cosa accade in un determinato punto della timeline della scena. Dovresti definire lo schema di una scena sia nei suoi moduli Client che Server, e includere lifecycle hooks per gestire quando si verificano le configurazioni.

Lifecycle hooks

Gli lifecycle hooks dello schema ti consentono di gestire quando avvengono le operazioni della scena. Una scena in produzione verrà tipicamente eseguita nel flusso più semplice:

• OnSetup → OnRun → OnEndScene

OnRun può essere interrotto durante la ricerca:

• OnSetup → OnRun… cerca → OnRun… cerca → OnRun → OnEndScene

Tutti e tre gli hook possono anche ripetersi se la scena viene riprodotta:

• OnSetup → OnRun → OnEndScene… ripeti → OnSetup → OnRun → OnEndScene

Configurazioni

Le configurazioni dello schema definiscono le operazioni principali di una scena, ad esempio riprodurre audio a 00:32, mettere in coda un' animazione da sincronizzare con quell'audio, schedulare un evento di scena come uno spettacolo di fuochi d'artificio e altro ancora. Ogni configurazione supporta determinate funzioni di callback dove il primo parametro (self) è l'istanza di configurazione.

Cercare scene

Una caratteristica unica di EventSequencer è la possibilità di "cercare" tra scene proprio come potresti cercare attraverso un video. In Modalità di sostituzione, puoi anche passare tra scene per visualizzare un intero evento multi-scena prima di pubblicarlo in produzione.

La ricerca delle scene non è accessibile a tutti poiché gli utenti che godono semplicemente dell'evento non dovrebbero avere la possibilità di controllarne il flusso temporale. Invece, devi concedere autorizzazioni di ricerca in base a PlaceId dell'evento, così come a specifici UserIds e/o gruppi e ruoli al loro interno.

1. Crea un nuovo Script all'interno di ServerScriptService.

2. Incolla il seguente codice nel nuovo script.

   Script - Impostare autorizzazioni di ricerca
   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   
   local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
   
   EventSequencer.setSeekingPermissions({
   	placeIDs = {},
   	userIDs = {},
   	groups = {
   		{GroupID = , MinimumRankID = },
   	}
   })

3. Compila le seguenti tabelle all'interno della chiamata a setSeekingPermissions come segue:

   placeIDs	Elenco delimitato da virgole di valori PlaceId per supportare la ricerca all'interno.
   userIDs	Elenco delimitato da virgole di UserIds per coloro che possono cercare all'interno dei luoghi supportati.
   groups	Elenco delimitato da virgole di tabelle, ciascuna contenente un ID di gruppo e il rango minimo dei membri di quel gruppo che possono cercare all'interno dei luoghi supportati.

Plugin gestore scene

Il plugin Scene Manager è uno strumento utile per caricare e scaricare scene, illuminazione, e terreno. A meno che non stai utilizzando la Modalità Inline, è altamente consigliato utilizzare questo plugin invece di posizionare/modificare manualmente oggetti e proprietà delle scene.

Per installare il plugin:

1. Dal menu Finestra di Studio o dalla barra degli strumenti della scheda Home, apri il Toolbox.

2. Con la scheda Negozio Creatori selezionata, seleziona Plugin dal menu a discesa.

3. Nel campo di ricerca, digita Scene Manager e premi Invio per individuare il plugin.

   

4. Fai clic sull'icona del plugin per visualizzarne i dettagli e poi fai clic sul pulsante Installa.

5. Una volta installato, il plugin appare nella scheda Plugin di Studio.

Caricare e scaricare scene

Come descritto in creare scene, la cartella Environment di una scena contiene tutto ciò che gli utenti vedono e sentono, inclusi oggetti 3D. Il plugin ti aiuta a caricare rapidamente gli asset di una scena dentro o fuori da cartelle organizzate all'interno dello spazio di lavoro.

Salvare e caricare illuminazione

Il servizio Lighting di livello superiore memorizza tutte le proprietà di illuminazione e gli effetti visivi di un luogo. Poiché è un servizio di livello superiore, non puoi spostarlo manualmente nella cartella Environment/Server o Environment/Client di una scena particolare. Invece, puoi utilizzare il plugin per copiare le sue proprietà e i suoi figli nella cartella Environment/Lighting della scena.

1. Configura le proprietà di illuminazione, gli effetti di post-elaborazione, gli effetti atmosferici e le skybox della scena tramite il servizio di livello superiore Lighting.

   

2. Nella finestra del plugin Scene Manager, fai clic su Salva Illuminazione per la scena desiderata.

3. Seleziona ed espandi la configurazione Environment/Lighting di quella scena e vedrai le stesse proprietà di illuminazione come attributi della cartella, così come i figli clonati del servizio di livello superiore Lighting.

   

   

   Una volta che le proprietà e i figli dell'illuminazione sono stati salvati per una scena, puoi rapidamente caricarli di nuovo nel servizio di livello superiore Lighting facendo clic su Carica Illuminazione dalla finestra del plugin.

Salvare e caricare terreno

Poiché Terrain è una classe di livello superiore all'interno di Workspace, non puoi spostare manualmente il terreno generato o scolpito nella cartella Environment/Server o Environment/Client di una scena particolare. Invece, puoi utilizzare il plugin per copiarlo nella cartella Environment/Terrain della scena.

1. Configura il terreno della scena tramite il servizio di livello superiore Terrain.

   

2. Nella finestra del plugin Scene Manager, fai clic su Salva Terrain per la scena desiderata.

3. Seleziona ed espandi la cartella Environment/Terrain di quella scena e vedrai un oggetto TerrainRegion che rappresenta il terreno salvato.

   

   Una volta che il terreno è stato salvato per una scena, puoi caricarlo rapidamente di nuovo nel servizio di livello superiore Terrain facendo clic su Carica Terrain dalla finestra del plugin.

Riferimento API

Lifecycle hooks dello schema

OnSetup

Il lifecycle hook OnSetup è destinato all'inizializzazione di asset e variabili che saranno referenziati in OnRun o OnEndScene, configurando connessioni che sono destinate a durare per tutta la durata della scena, ecc. Questo hook riceve il parametro timePositionObject che ti consente di leggere il tempo attuale all'impostazione.

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

	-- Accesso ambienti della scena; non si applica alla Modalità Inline
	clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
	serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()
	-- Aspetta gli asset
	dummy = clientEnvironment:WaitForChild("Dummy")

	print("Il tempo attuale è:", 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)")

	-- Accesso ambiente della scena; non si applica alla Modalità Inline
	serverEnvironment = EventSequencer.getCurrentSceneEnvironment()
	partColorConnection = changePartColorEvent.OnServerEvent:Connect(function(player, changedPart, newColor)
		serverEnvironment.changedPart.Color = newColor
	end)

	print("Il tempo attuale è:", timePositionObject.Value)
end

OnRun

OnRun è il principale lifecycle hook operativo all'interno di uno schema. Dovrebbe contenere tutte le configurazioni temporizzate per la scena, dalla riproduzione di audio o di un' animazione alla schedulazione di un evento come uno spettacolo di fuochi d'artificio.

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

	local MainAudio = Schema:audio({
		StartTime = 1,
		SoundId = "rbxassetid://1838673350",
		OnStart = function(self)
			print("Audio in riproduzione")
		end,
		OnEnd = function(self)
			print("Audio terminato")
		end
	})
end

OnEndScene

Il lifecycle hook OnEndScene è utile per liberare qualsiasi cosa in sospeso nella scena, come disconnettere connessioni create in OnSetup o OnRun che rimangono per la durata della scena.

Server Schema
Schema.OnEndScene = function()
	print("OnEndScene (Server)")

	if partColorConnection then
		partColorConnection:Disconnect()
		partColorConnection = nil
	end
end

Configurazioni dello schema

audio

Crea un oggetto Sound nello spazio di lavoro che viene riprodotto a un certo punto. Il suono viene quindi eliminato dopo che la scena è terminata o dopo che l'oggetto Sound ha finito di suonare.

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

	local MainAudio = Schema:audio({
		StartTime = 1,
		SoundId = "rbxassetid://1838673350",
		OnStart = function(self)
			print("Audio in riproduzione")
		end,
		OnEnd = function(self)
			print("Audio terminato")
		end
	})
end

animate

Crea un' Animation che viene riprodotta a un certo punto.

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("Animazione in riproduzione")
		end,
		OnEnd = function(self)
			print("Animazione fermata")
		end
	})
end

tween

Crea una Tween configurabile che è preservata nella ricerca e nell'unione dinamica, il che significa che puoi concatenare tweens a punti separati nel tempo e tutto dovrebbe riprodursi e sincronizzarsi come previsto.

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 in riproduzione")
		end,
		OnHeartbeat = function(self, alpha)
			print("Tween alpha", alpha)
		end,
		OnEnd = function(self)
			print("Tween completato")
		end,
	})
end

interval

Esegue una funzione di callback personalizzata su una determinata durata a una frequenza specificata, in secondi. Utile per eventi ripetitivi come luci lampeggianti, pulsare l'intensità di un audio, ecc. La frequenza più bassa possibile è di 0 secondi, ma tecnicamente la frequenza minima è sempre limitata a 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

Simile a interval, tranne che puoi definire più tempi di avvio specifici per lo stesso evento, come pianificare un'esibizione di fuochi d'artificio due volte in una scena.

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

	Schema:schedule({
		StartTimes = {5, 27.25},
		OnStart = function(self)
			-- Inizializza connessione heartbeat temporanea
			local tempConnection = RunService.Heartbeat:Connect(function()

			end)
			-- Informare il framework della connessione
			Schema:inform(tempConnection)
		end
	})
end

inform

Informare il framework di qualsiasi modulo, oggetto UI, connessione, ecc. che viene creato nel lifecycle hook OnRun, assicurandosi che vengano liberati correttamente durante la ricerca. I casi d'uso includono:

• Informare il framework di una connessione temporanea ad hoc come RunService.Heartbeat in modo che la connessione venga liberata durante la ricerca a un punto precedente nella durata della scena.

  Server Schema
  Schema.OnRun = function()
  	print("OnRun (Server)")
  
  	Schema:schedule({
  		StartTimes = {5},
  		OnStart = function(self)
  			-- Inizializza connessione heartbeat temporanea
  			local tempConnection = RunService.Heartbeat:Connect(function()
  
  			end)
  			-- Informare il framework della connessione
  			Schema:inform(tempConnection)
  		end
  	})
  end

• Chiamare una funzione di "ripulitura" personalizzata in un ModuleScript che inizializza una connessione o altro riferimento durante il lifecycle hook 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)
  			-- Chiama la funzione "init" nel modulo personalizzato
  			customModule.init()
  			-- Chiama la funzione "clean" nel modulo personalizzato durante la pulizia della scena
  			Schema:inform(customModule, customModule.clean)
  		end,
  	})
  end

  ModuleScript - CustomModule
  local RunService = game:GetService("RunService")
  
  local CustomModule = {}
  
  CustomModule.init = function()
  	-- Inizializza connessione heartbeat
  	CustomModule.connection = RunService.Heartbeat:Connect(function()
  
  	end)
  end
  
  CustomModule.clean = function()
  	-- Disconnetti e cancella la connessione heartbeat
  	if CustomModule.connection then
  		CustomModule.connection:Disconnect()
  		CustomModule.connection = nil
  	end
  end
  
  return CustomModule

Funzioni

loadScene

Carica programmaticamente una scena per sceneName e inizia a startTime dal suo inizio. Ci sarà un "periodo di grazia" di 5 secondi per caricare la scena dal server prima che avvenga la ricerca e la scena inizi a essere riprodotta. Ciò significa che se chiami loadScene("[SceneName]", 20) esattamente alle 16:15:00, il framework attenderà 5 secondi oltre ai 20 richiesti, avviando la scena alle 16:15:25.

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

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

-- Scoprire la prossima scena da caricare quando la scena attuale finisce
EventSequencer.onOrchestrationFinished:Connect(function(endedSceneName)
	if endedSceneName == "PreShow" then
		-- "PreShow" è terminato; carica la prima scena del concerto
		EventSequencer.loadScene("Track1")
	elseif endedSceneName == "Track1" then
		-- "Track1" è terminato; carica la seconda scena del concerto
		EventSequencer.loadScene("Track2")
	else
		-- Torna alla scena pre-show
		EventSequencer.loadScene("PreShow")
	end
end)

createSchema

Restituisce un'istanza dello schema schema per creare logica per la scena.

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

Cerca il valore time, in secondi, dall'inizio della scena attualmente caricata.

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

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

EventSequencer.seek(95.58)

setSceneWarningTime

Imposta l'importo di tempo dalla fine di tutte le scene in cui viene inviato un avviso. Puoi rilevare l'avviso lato client tramite onSceneEndingWarningForClient o lato server tramite onSceneEndingWarningForServer.

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

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

-- Carica scena
EventSequencer.loadScene("BeautifulScene")

-- Imposta il tempo di avviso a 5 secondi prima della fine della scena
EventSequencer.setSceneWarningTime(5)

-- Rileva quando la scena sta per finire
EventSequencer.onSceneEndingWarningForServer:Connect(function()
	warn("La scena sta per finire!")
end)

setSeekingPermissions

Concede autorizzazioni di ricerca in base a PlaceId dell'evento, così come a specifici UserIds e/o gruppi e ruoli all'interno di essi. Vedi cercare e passare da una scena all'altra per ulteriori informazioni.

getCurrentSceneEnvironment

Restituisce la cartella Environment client-side o server-side della scena corrente, a seconda di se viene chiamata dallo script dello schema Client o dallo schema Server.

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

	-- Accesso ambienti della scena; non si applica alla Modalità Inline
	clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
	serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()

	print("Il tempo attuale è:", 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

Restituisce la cartella server-side Environment della scena corrente. A differenza di getCurrentSceneEnvironment, puoi chiamare questa funzione dallo script dello schema 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)")

	-- Accesso ambienti della scena; non si applica alla Modalità Inline
	clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
	serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()

	print("Il tempo attuale è:", timePositionObject.Value)
end

isLoadingScene

Chiamato dal server per sapere se una scena è attualmente in fase di caricamento.

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

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

print(EventSequencer.isLoadingScene())

while EventSequencer.isLoadingScene() do
	task.wait()
end
print("Scena caricata")

Eventi

onSceneEndingWarningForClient

Si attiva sul client prima che la scena stia per finire. Il tempo predefinito è di 3 secondi, ma puoi configurarlo tramite setSceneWarningTime. Questo evento può essere connesso solo in un LocalScript.

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

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

-- Rileva quando la scena sta per finire (lato client)
EventSequencer.onSceneEndingWarningForClient:Connect(function()
	warn("La scena sta per finire!")
end)

onSceneEndingWarningForServer

Si attiva sul server prima che la scena stia per finire. Il tempo predefinito è di 3 secondi, ma puoi configurarlo tramite setSceneWarningTime. Questo evento può essere connesso solo in un Script.

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

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

-- Rileva quando la scena sta per finire (lato server)
EventSequencer.onSceneEndingWarningForServer:Connect(function()
	warn("La scena sta per finire!")
end)

onSceneLoadedForClient

Si attiva sul client quando la scena sta per iniziare. Questo evento può essere connesso solo in un LocalScript.

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

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

-- Rileva quando la scena sta per iniziare (lato client)
EventSequencer.onSceneLoadedForClient:Connect(function()
	warn("La scena sta iniziando!")
end)

onOrchestrationFinished

Si attiva sul server quando una scena ha raggiunto la sua durata e ha effettivamente terminato. Questo evento riceve un argomento stringa endedSceneName per il nome della scena che è appena finita e puoi concatenare su questo evento per caricare condizionatamente un'altra scena. Può essere connesso solo in un Script.

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

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

-- Scoprire la prossima scena da caricare quando la scena attuale finisce
EventSequencer.onOrchestrationFinished:Connect(function(endedSceneName)
	if endedSceneName == "PreShow" then
		-- "PreShow" è terminato; carica la prima scena del concerto
		EventSequencer.loadScene("Track1")
	elseif endedSceneName == "Track1" then
		-- "Track1" è terminato; carica la seconda scena del concerto
		EventSequencer.loadScene("Track2")
	else
		-- Torna alla scena pre-show
		EventSequencer.loadScene("PreShow")
	end
end)