Sequenziatore eventi

EventSequencer è un potente framework che ti consente di costruire eventi dal Attivae scene incrociate su una sequenza strutturata di azioni e trigger.Più specificamente, questo modulo ti aiuta:

• Costruisci un evento o una scena su un framework strutturato attraverso le configurazioni programmate di audio/suono, animazioni e adolescenti.
• Transizione tra più scene su più server, sincronizzando complesse animazioni e visuali a una timeline.
• Cerca attraverso un evento e visualizza l'esperienza per scopi di test e sviluppo.

Questo framework è stato testato in battaglia negli eventi di Roblox come il Twenty One Pilots e 24kGoldn concerti, così come molte esperienze altamente visitate.

Per vedere EventSequencer in azione all'interno di un Postomodificabile, controlla il modello Concerto in Roblox Studio.Questo modello è un punto di partenza completo per i sviluppatori per creare eventi/concerti e familiarizzare con le varie funzionalità e componenti coinvolte.

Uso del modulo

Installazione

Per utilizzare il framework EventSequencer in un'esperienza:

1. Dalla Visualizzazione, apri la Toolbox e seleziona la scheda Creator Store .

   

2. Assicurati che la classificazione Modelli sia selezionata, quindi fai clic sul pulsante Vedi tutti per Categorie .

   

3. Individua e fai clic sul riquadro Moduli di sviluppo .

   

4. Individua il modulo Sequenziatore eventi e cliccalo, o trascinalo nella vista 3D.

   

5. Nella finestra Explorer, sposta l'intero modello EventSequencer nel ServerScriptService .Dopo l'esecuzione dell'esperienza, il modulo si distribuirà a vari servizi e inizierà a funzionare.

   

Modalità framework

Sostituisci modalità

La modalità framework predefinita è sostituire la modalità in cui progetti scene uniche posizionando oggetti 3D , terreno , proprietà di illuminazione , effetti ambientali e oggetti interfaccia utente nell'archiviazione Ambiente di quella scena.Quando una scena viene caricata, questi oggetti e proprietà vengono distribuiti in , e , sostituendo gli oggetti/proprietà esistenti per formare uno Spazioclonato.

Modalità inline

Un modo alternativo di framework è modalità inline in cui progetti in modo analogo scene uniche con logica di scripting per il loro flusso/eventi, ma il framework non distruggerà non oggetti 3D esistenti, terreno , proprietà di illuminazione , effetti ambientali e oggetti interfaccia utente per clonare le risorse/proprietà da una cartella dell'ambiente della scena durante il caricamento.

Per abilitare la modalità inline:

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

   

2. Nella finestra Proprietà, attiva la casella di controllo Valore .

   

Crea scene

Una scena è essenzialmente parte di un evento generale o di una cutscene avvolta in una serie di cartelle.Ogni scena contiene una logica di scripting che definisce il suo flusso/eventi e una scena può contenere i propri oggetti 3D, terreno, proprietà di illuminazione, effetti ambientali e oggetti dell'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 posizionare le scene altrove nella gerarchia di Explorer e contrassegnarle con SequencerScene usando la sezione Tag delle loro proprietà, o Studio's Tag Editor ( BlankScene è già contrassegnata come tale).Tuttavia, dovrai spostare tutte le scene pronte agli eventi a ReplicatedStorage in modo che funzionino all'interno del flusso di eventi generale.

Durata del tempo

Ogni scena dovrebbe avere una durata del tempo , in secondi, che definisce la sua durata - proprio come un film o un concerto ha una durata predefinita.La durata del tempo è definita come un attributo numerico sulla cartella della scena chiamata Durata del tempo che puoi impostare direttamente in Studio o programmaticamente attraverso .

Ambiente

La cartella ambiente di una scena contiene tutto ciò che gli utenti vedono e sentono, inclusi oggetti 3D, terreno, proprietà di illuminazione e effetti ambientali, e oggetti dell'interfaccia utente.Quando una scena viene caricata, questi oggetti e proprietà vengono distribuiti in Workspace , Terrain e Lighting , sostituendo gli oggetti/proprietà esistenti per formare uno Spazioclonato.

La cartella Ambiente contiene i seguenti container:

Eventi

La cartella Eventi di una scena è puramente un placeholder per RemoteEvents che comunica tra i moduli Client e Server.Non è un requisito mettere qualcosa in questo folder.

Cliente

Questo script esegue la logica schema sul client.

Server

Questo script esegue la logica schema sul Server.

Schemi di scena

Lo schema di una scena define ciò che accade a che punto nella timeline della scena.Dovresti definire lo schema di una scena nei suoi moduli Client e Server, e includere hook di vita per gestire quando si Si verificano configurazioni .

Ganci di ciclo di vita

Lo schema ganci di vita ti consente di gestire quando si Si verificanole operazioni della scena. Una scena in produzione verrà tipicamente eseguita nel flusso più semplice:

• Durante l'avvio → Durante l'esecuzione → Durante la scena finale

OnRun può essere interrotto quando si cerca:

• OnSetup → OnRun … seek → OnRun … seek → OnRun → OnEndScene

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

• OnSetup → OnRun → OnEndScene … riproduzione → OnSetup → OnRun → OnEndScene

Configurazioni

Le configurazioni dello schema definiscono le operazioni principali di una scena, ad esempio riproduzione audio alle 00:32, in attesa di un'animazione sincronizzata con quell'audio/suono, programmazione di un evento della scena come uno Mostraredi fuochi d'artificio e altro ancora.Ogni configurazione supporta alcune funzioni di richiamo in cui il primo parametro ( self ) è l'istanza di configurazione.

Cerca scene

Una caratteristica unica di EventSequencer è la capacità di "cercare" intorno alle scene come potresti cercare attraverso un video.In Modalità di sostituzione, puoi anche passare da una scena all'altra per visualizzare un evento multi-scena intero prima di distribuirlo in produzione.

La ricerca della scena non è accessibile a tutti poiché gli utenti che semplicemente godono dell'evento non dovrebbero avere la possibilità di controllare il flusso del tempo.Invece, devi concedere il permesso di ricerca in base all'evento e a gruppi e ruoli specifici e/o all'interno di essi.

1. Crea una nuova Script dentro ServerScriptService .

2. Incolla il seguente codice nel nuovo script.

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

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

   placeIDs	Lista delimitata da virgola di PlaceId valori per supportare la ricerca all'interno.
   userIDs	Lista delimitata da virgola di UserIds per coloro che possono cercare all'interno dei luoghi supportati.
   groups	Lista delimitata da virgola di tabelle, ognuna delle quali contiene un ID di gruppo gruppo e il grado minimo dei membri di quel Gruppoche possono cercare all'interno dei luoghi supportati.

Collegaremanager della scena

Il plugin Gestore della scena è uno strumento utile per caricare e scaricare scene, illuminazione e terreno.A meno che tu non stia usando Modalità inline, è altamente raccomandato utilizzare questo plugin invece di posizionare/modificare manualmente oggetti e proprietà della scena.

Per installare il Collegare:

1. Dal menu Visualizza di Studio, apri la Toolbox .

   

2. Con la scheda Creator Store selezionata, seleziona Plugin dal menu a discesa.

   

3. Nel campo di ricerca, digita Gestore della scena e premi Enter per localizzare il Collegare.

   

4. Fai clic sull'icona del Collegareper visualizzare i suoi dettagli e quindi fai clic sul pulsante Installa .

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

Carica e scarica le scene

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

Salva e carica la luce

Il servizio di livello superiore Lighting memorizza tutte le proprietà di illuminazione e gli effetti visivi di un Posto.Poiché è un servizio di alto livello, non puoi spostarlo manualmente nel ambiente / server / ambiente / client della scena particolare.Invece, puoi utilizzare il plugin per copiare le sue proprietà e i figli nella cartella Ambiente / Illuminazione della scena.

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

   

2. Nella finestra del plugin Gestore della scena , clicca Salva illuminazione per la scena desiderata.

3. Seleziona e espandi la configurazione Ambiente / Illuminazione di quella scena e vedrai le stesse proprietà di illuminazione come attributi del folder, nonché i figli clonati del servizio di livello superiore .

   

   

   Una volta salvate le proprietà di illuminazione e i figli per una scena, puoi caricarli rapidamente nuovamente nel servizio di livello superiore Lighting facendo clic su Carica illuminazione dalla finestra del plugin.

Salva e carica il terreno

Dal momento che Terrain è una classe di alto livello all'interno di Workspace , non puoi spostare manualmente il terreno generato o scolpito in un particolare ambiente Environment / Server o Environment / Cliente cartella.Invece, puoi utilizzare il plugin per copiarlo nella cartella Ambiente / Terreno della scena.

1. Configura il terreno della scena attraverso il servizio di livello superiore Terreno .

   

2. Nella finestra del plugin Gestore della scena , clicca Salva terreno per la scena desiderata.

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

   

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

Riferimento API

Ganci di ciclo di vita dello schema

Su Setup

Il hook del ciclo di vita OnSetup è destinato all'inizializzazione di risorse e variabili che saranno richiamate in OnRun o OnEndScene, impostando connections che sono destinate a durare per la durata della scena, ecc.Questo hook riceve il parametro timePositionObject che ti consente di leggere l'ora attuale durante l'installazione.

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

	-- Ambienti della scena di accesso; non si applica alla modalità inline
	clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
	serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()
	-- Aspetta le risorse
	dummy = clientEnvironment:WaitForChild("Dummy")

	print("Current time is:", timePositionObject.Value)
end

Schema del server
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)")

	-- Ambiente della scena di accesso; non si applica alla modalità inline
	serverEnvironment = EventSequencer.getCurrentSceneEnvironment()
	partColorConnection = changePartColorEvent.OnServerEvent:Connect(function(player, changedPart, newColor)
		serverEnvironment.changedPart.Color = newColor
	end)

	print("Current time is:", timePositionObject.Value)
end

Su esecuzione

OnRun è il principale hook del ciclo di vita operativo all'interno di un schema.Dovrebbe contenere tutte le configurazioni a tempo per la scena, dal riproduzione di audio o un'animazione a programmazione di un evento come un display di fuochi d'artificio.

Schema cliente
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

Sulla scena finale

Il hook di ciclo di vita OnEndScene è utile per pulire tutto ciò che è in sospeso nella scena, come la disconnessione delle connessioni create in OnSetup o OnRun che rimangono per la durata della scena.

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

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

Configurazioni di schema

audio/suono

Crea un oggetto Sound nell'area di lavoro che suona a un certo momento.Il suono viene quindi eliminato dopo che la scena è finita o dopo che l'oggetto Sound finisce di suonare.

Schema cliente
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

animare

Crea un Animation che suona a un certo momento.

Schema cliente
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

gemellati

Crea un configurabile Tween che viene preservato in cerca e in join dinamico, il che significa che puoi incatenare gli adolescenti in punti separati nel tempo e tutto dovrebbe giocare e sincronizzarsi come previsto.

Schema cliente
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

intervallo

Esegue una funzione di richiamo personalizzata per una durata specificata su una frequenza specificata, in secondi.Utile per ripetere eventi come lampeggiamenti, l'intensità di un audio/suono, ecc.La frequenza più bassa possibile è di 0 secondi, ma tecnicamente la frequenza minima è sempre limitata a Heartbeat .

Schema cliente
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

calendario

Simile a intervallo except that puoi definire più tempi di inizio specifici per lo stesso evento, come la programmazione di un display di fuochi d'artificio due volte in una scena.

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

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

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

informare

Informa il framework di qualsiasi modulo, oggetti UI, connessioni, ecc.che vengono creati nel hook del ciclo di vita OnRun, assicurandosi che vengano puliti correttamente quando cerca.Gli casi d'uso includono:

• Informare il framework di una connessione temporanea ad hoc come RunService.Heartbeat in modo che la connessione venga pulita quando si cerca un punto precedente della durata della scena.

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

• Chiamare una funzione "Pulire" personalizzata in un ModuleScript che inizializza una connessione o un altro riferimento durante il hook di vita OnRun .

  Schema del server
  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 - Modulo personalizzato
  local RunService = game:GetService("RunService")
  
  local CustomModule = {}
  
  CustomModule.init = function()
  	-- Inizializza la connessione battito cardiaco
  	CustomModule.connection = RunService.Heartbeat:Connect(function()
  
  	end)
  end
  
  CustomModule.clean = function()
  	-- Disconnetti e svuota la connessione del battito cardiaco
  	if CustomModule.connection then
  		CustomModule.connection:Disconnect()
  		CustomModule.connection = nil
  	end
  end
  
  return CustomModule

Functioni

caricareScene

Carica programmaticamente una scena da sceneName e la avvia da startTime dal suo inizio.Ci sarà un periodo di 5 secondi di "grace" per la scena per caricare dal server prima che avvenga la ricerca e la scena inizi a giocare.Questo significa che se chiami loadScene("[SceneName]", 20) alle 4:15:00 PM, il framework attenderà 5 secondi in aggiunta ai 20 richiesti, dando inizio alla scena alle 4:15:25 PM.

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

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

-- Individua la prossima scena da caricare quando la scena attuale finisce
EventSequencer.onOrchestrationFinished:Connect(function(endedSceneName)
	if endedSceneName == "PreShow" then
		-- Finito "PreShow"; carica la prima scena nel concerto
		EventSequencer.loadScene("Track1")
	elseif endedSceneName == "Track1" then
		-- Track1 è finito; carica la seconda scena nel concerto
		EventSequencer.loadScene("Track2")
	else
		-- Loop indietro alla scena pre-show
		EventSequencer.loadScene("PreShow")
	end
end)

creare Schema

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

Schema cliente
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

local Schema = EventSequencer.createSchema()

Schema.OnSetup = function(timePositionObject)
	print("OnSetup (Client)")
end

cercare

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

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

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

EventSequencer.seek(95.58)

Imposta il tempo di avviso della scena

Imposta la quantità di tempo dall' fine di tutte le scene in cui viene inviato un avviso.Puoi rilevare l'avviso sia sul lato client attraverso onSceneEndingWarningForClient che sul lato server attraverso onSceneEndingWarningForServer.

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

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

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

-- Imposta il tempo di avvertimento a 5 secondi prima che la scena finisca
EventSequencer.setSceneWarningTime(5)

-- Rileva quando la scena sta per Terminare
EventSequencer.onSceneEndingWarningForServer:Connect(function()
	warn("Scene is about to end!")
end)

setSeekingPermsenti

Garanzie che richiedono il permesso in base all'evento di e inoltre a gruppi specifici e/o ruoli all'interno di essi.Vedi cercare e cambiare le scene per ulteriori informazioni.

ottenere l'ambiente della scena attuale

Restituisce la cartella Ambiente del lato client o lato server della scena attuale, a seconda se viene chiamata dallo script di schema Client o Server, rispettivamente.

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

	-- Ambienti della scena di accesso; non si applica alla modalità inline
	clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
	serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()

	print("Current time is:", timePositionObject.Value)
end

Schema del server
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

ottenere l'ambiente server corrente dall'client

Restituisce la cartella Server-side Ambiente della scena corrente.A differenza di getCurrentSceneEnvironment, puoi chiamarlo dallo script dello schema Client.

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

	-- Ambienti della scena di accesso; non si applica alla modalità inline
	clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
	serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()

	print("Current time is:", timePositionObject.Value)
end

èCaricamentoScena

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

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

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

print(EventSequencer.isLoadingScene())

while EventSequencer.isLoadingScene() do
	task.wait()
end
print("Scene loaded")

Eventi

sulla fine della scena di警告 per il client

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

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

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

-- Rileva quando la scena è about to end (lato client)
EventSequencer.onSceneEndingWarningForClient:Connect(function()
	warn("Scene is about to end!")
end)

sulla fine della scena di警告 per il server

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

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

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

-- Rileva quando la scena è about to end (lato server)
EventSequencer.onSceneEndingWarningForServer:Connect(function()
	warn("Scene is about to end!")
end)

onSceneLoadedForClient

Fuochi sul client quando la scena sta iniziando. Questo evento può essere collegato solo in un LocalScript .

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

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

-- Rileva quando la scena inizia (lato client)
EventSequencer.onSceneLoadedForClient:Connect(function()
	warn("Scene is starting!")
end)

suOrchestrazioneFinita

Fuochi sul server quando una scena ha raggiunto la sua durata del tempo e si è effettivamente conclusa.Questo evento riceve un argomento nome stringa endedSceneName per la scena che è appena finita e puoi incatenare questo evento per caricare condizionalmente un'altra scena .Può essere connesso solo in un Script .

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

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

-- Individua la prossima scena da caricare quando la scena attuale finisce
EventSequencer.onOrchestrationFinished:Connect(function(endedSceneName)
	if endedSceneName == "PreShow" then
		-- Finito "PreShow"; carica la prima scena nel concerto
		EventSequencer.loadScene("Track1")
	elseif endedSceneName == "Track1" then
		-- Track1 è finito; carica la seconda scena nel concerto
		EventSequencer.loadScene("Track2")
	else
		-- Loop indietro alla scena pre-show
		EventSequencer.loadScene("PreShow")
	end
end)