Sequenziatore di Eventi

Sequenziatore di Eventi è un potente framework che ti consente di costruire eventi dal vivo e cutscene 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 visuali complesse a una timeline.
• Cercare attraverso un evento e visualizzare il gioco per scopi di test e sviluppo.

Questo framework è stato testato in eventi di Roblox come i concerti dei Twenty One Pilots e 24kGoldn, così come in molti giochi molto visitati.

Per vedere Sequenziatore di Eventi in azione all'interno di un luogo modificabile, dai un'occhiata al template Concerto 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 Sequenziatore di Eventi in un gioco:

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

   

2. Assicurati che sia selezionato l'ordinamento Modelli, quindi fai clic sul pulsante Vedi Tutti per le Categorie.

   

3. Individua e fai clic sulla tessera Pacchetti.

4. Individua il modulo Sequenziatore di Eventi e fai clic su di esso, oppure trascinalo nella vista 3D.

   

5. Nella finestra Esplora, sposta l'intero modello Sequenziatore di Eventi in ServerScriptService. Una volta avviato il gioco, il modulo inizierà a funzionare.

Modalità 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 dell'interfaccia utente nella cartella Environment di quella scena. Quando una scena viene caricata, quegli oggetti e proprietà vengono distribuiti in Workspace, Terrain e Lighting, sostituendo oggetti/proprietà esistenti per formare uno spazio clonato.

Modalità inline

Una modalità alternativa del framework è la modalità inline in cui progetti anch'essa scene uniche scenes con logica di scripting per il loro flusso/eventi, ma il framework non distruggerà oggetti 3D esistenti, terreno, proprietà di illuminazione, effetti ambientali e oggetti dell'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 Sequenziatore di Eventi che hai posizionato in ServerScriptService, espandi e seleziona il valore Inline all'interno della cartella ReplicatedStorage.

   

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

   

Creare scene

Una scena è essenzialmente parte di un evento complessivo 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 dell'interfaccia utente.

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

1. Espandi la cartella Sequenziatore di Eventi e individua 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 Esplora e contrassegnarle con SequencerScene utilizzando la sezione Tag delle loro proprietà (BlankScene è già contrassegnata in questo modo). Tuttavia, dovrai spostare tutte le scene pronte per l'evento in ReplicatedStorage affinché funzionino all'interno del flusso complessivo dell'evento.

Durata

Ogni scena dovrebbe avere una durata, in secondi, che definisce la sua durata — proprio come un film o un concerto ha una durata prestabilita. La durata è definita come un attributo numerico attribute sulla 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 dell'interfaccia utente. Quando una scena viene caricata, quegli oggetti e proprietà vengono distribuiti in Workspace, Terrain e Lighting, sostituendo oggetti/proprietà esistenti per formare uno spazio clonato.

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 è necessario posizionare nulla in questa cartella.

Client

Questo script esegue la logica schema sul client.

Server

Questo script esegue la logica schema sul server.

Schemi delle scene

Lo schema di una scena definisce cosa succede a quale punto nella timeline della scena. Dovresti definire lo schema di una scena sia nei suoi moduli Client che Server e includere hook di ciclo di vita per gestire quando avvengono le configurazioni.

Hook di ciclo di vita

Gli hook di ciclo di vita schema ti consentono di gestire quando si verificano le operazioni della scena. Una scena in produzione funzionerà tipicamente nel flusso più semplice:

• OnSetup → OnRun → OnEndScene

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… replay → 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 per sincronizzarsi con quell'audio, programmando 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 del Sequenziatore di Eventi è la possibilità di "cercare" tra le scene come faresti cercando in un video. In Modalità di Sostituzione, puoi anche passare tra le scene per visualizzare un intero evento multi-scena prima di distribuirlo in produzione.

La ricerca delle scene non è accessibile a tutti poiché gli utenti che semplicemente godono dell'evento non dovrebbero avere la possibilità di controllare il flusso temporale. Invece, devi concedere il permesso di ricerca in base al 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 - Imposta Permessi di Ricerca

   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   
   local SequenziatoreDiEventi = require(ReplicatedStorage:WaitForChild("EventSequencer"))
   
   SequenziatoreDiEventi.setSeekingPermissions({
   	placeIDs = {},
   	userIDs = {},
   	groups = {
   		{GroupID = , MinimumRankID = },
   	}
   })

3. Compila le seguenti tabelle all'interno della chiamata 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 di gestione delle scene

Il plugin Scene Manager è uno strumento utile per caricare e scaricare scene, illuminazione e terreno. A meno che tu non stia 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 Creatore selezionata, seleziona Plugin dal menu a discesa.

3. Nella casella di ricerca, digita Scene Manager e premi Invio per localizzare 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 delineato 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 l'illuminazione

Il servizio di livello superiore Lighting memorizza tutte le proprietà di illuminazione e gli effetti visivi di un luogo. Poiché è un servizio di livello superiore, non puoi spostarlo manualmente in una 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-processing, gli effetti atmosferici e le skybox attraverso 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à di illuminazione e i figli 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 il terreno

Poiché Terrain è una classe di livello superiore all'interno di Workspace, non puoi spostare manualmente il terreno generato o scolpito in una 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 attraverso il servizio di livello superiore Terrain.

   

2. Nella finestra del plugin Scene Manager, fai clic su Salva Terreno 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 rapidamente caricarlo di nuovo nel servizio di livello superiore Terrain facendo clic su Carica Terreno dalla finestra del plugin.

Riferimento API

Hook di ciclo di vita dello schema

OnSetup

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

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

local Schema = SequenziatoreDiEventi.createSchema()

local clientEnvironment
local serverEnvironment
local dummy

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

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

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

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

local Schema = SequenziatoreDiEventi.createSchema()

local serverEnvironment
local partColorConnection
local changePartColorEvent = script.Parent.Events.ChangePartColor

Schema.OnSetup = function(timePositionObject)
	print("OnSetup (Server)")

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

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

OnRun

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

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

L'hook di ciclo di vita OnEndScene è utile per ripulire qualsiasi cosa in sospeso nella scena, come disconnettere connessioni create in OnSetup o OnRun che rimangono per la durata della scena.

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 tempo. Il suono viene quindi eliminato dopo che la scena è finita o dopo che l'oggetto Sound ha terminato la riproduzione.

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 tempo.

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 un Tween configurabile che viene preservato nella ricerca e nell'ingresso dinamico, il che significa che puoi concatenare tweens in punti separati nel tempo e tutto dovrebbe riprodursi e sincronizzarsi come previsto.

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("Alpha del tween", alpha)
		end,
		OnEnd = function(self)
			print("Tween completato")
		end,
	})
end

interval

Esegue una funzione di callback personalizzata su una durata specificata 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.

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 per il fatto che puoi definire più tempi di inizio specifici per lo stesso evento, come programmare un'esibizione di fuochi d'artificio due volte in una scena.

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

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

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

inform

Informare il framework di eventuali moduli, oggetti UI, connessioni, ecc. che vengono creati nell'hook di ciclo di vita OnRun, assicurando che vengano puliti correttamente quando si cerca. I 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 a un punto precedente nella durata della scena.

  Schema Server

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

• Chiamare una funzione di "pulizia" personalizzata in un ModuleScript che inizializza una connessione o altro riferimento durante l'hook di ciclo di vita OnRun.

  Schema Server

  local ReplicatedStorage = game:GetService("ReplicatedStorage")
  local RunService = game:GetService("RunService")
  
  local customModule = require(ReplicatedStorage:WaitForChild("CustomModule"))
  
  local SequenziatoreDiEventi = require(ReplicatedStorage:WaitForChild("EventSequencer"))
  
  local Schema = SequenziatoreDiEventi.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 la connessione di heartbeat
  	CustomModule.connection = RunService.Heartbeat:Connect(function()
  
  	end)
  end
  
  CustomModule.clean = function()
  	-- Disconnetti e cancella la connessione di heartbeat
  	if CustomModule.connection then
  		CustomModule.connection:Disconnect()
  		CustomModule.connection = nil
  	end
  end
  
  return CustomModule

Funzioni

loadScene

Carica programmaticamente una scena per sceneName e la avvia a startTime dall'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 riprodursi. 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.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

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

createSchema

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

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

local Schema = SequenziatoreDiEventi.createSchema()

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

seek

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

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

SequenziatoreDiEventi.seek(95.58)

setSceneWarningTime

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

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

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

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

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

setSeekingPermissions

Concede il permesso di ricerca in base al PlaceId dell'evento, così come a specifici UserIds e/o gruppi e ruoli al loro interno. Vedi cercare e passare tra le scene per ulteriori informazioni.

getCurrentSceneEnvironment

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

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

local Schema = SequenziatoreDiEventi.createSchema()

local clientEnvironment
local serverEnvironment

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

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

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

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

local Schema = SequenziatoreDiEventi.createSchema()

local serverEnvironment
local partColorConnection
local changePartColorEvent = script.Parent.Events.ChangePartColor

Schema.OnSetup = function(timePositionObject)
	print("OnSetup (Server)")

	serverEnvironment = SequenziatoreDiEventi.getCurrentSceneEnvironment()

	partColorConnection = changePartColorEvent.OnServerEvent:Connect(function(player, changedPart, newColor)
		serverEnvironment.changedPart.Color = newColor
	end)
end

getCurrentServerEnvironmentFromClient

Restituisce la cartella server-side Environment della scena attuale. A differenza di getCurrentSceneEnvironment, puoi chiamare questa funzione dallo script dello schema Client.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

local Schema = SequenziatoreDiEventi.createSchema()

local clientEnvironment
local serverEnvironment

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

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

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

isLoadingScene

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

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

print(SequenziatoreDiEventi.isLoadingScene())

while SequenziatoreDiEventi.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.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Rileva quando la scena sta per finire (lato client)
SequenziatoreDiEventi.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.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Rileva quando la scena sta per finire (lato server)
SequenziatoreDiEventi.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.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Rileva quando la scena sta per iniziare (lato client)
SequenziatoreDiEventi.onSceneLoadedForClient:Connect(function()
	warn("La scena sta per iniziare!")
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 appena finita e puoi concatenare questo evento per caricare condizionatamente un'altra scena. Può essere connesso solo in un Script.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

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