Sequenziatore di eventi

SequenziatoreEventi è un potente framework che ti consente di costruire eventi e filmati in diretta e inter-server su una sequenza strutturata di azioni e trigger. Più nello specifico, questo modulo ti aiuta:

• Crea un evento o un filmato su un framework strutturato attraverso configurazioni programmate di audio, animazioni e interpolazioni.
• Transita tra più scene su più server, sincronizzando animazioni e immagini complesse con una timeline.
• Cerca un evento e visualizza l'anteprima dell'esperienza per scopi di test e sviluppo.

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

Per vedere SequenziatoreEventi in azione all'interno di un posto mofidificabile, controlla il modello di Concerto in Roblox Studio. Questo modello è un punto di partenza completo per gli sviluppatori al fine di creare eventi/concerti e familiarizzare con le varie funzionalità e componenti coinvolti.

Utilizzo del modulo

Installazione

Per utilizzare il framework SequenziatoreEventi in un'esperienza:

1. Dalla scheda Visualizza, aprire il Pannello degli strumenti e selezionare la scheda Marketplace.

   

2. Assicurarsi che la selezione dei modelli sia selezionata, quindi fare clic sul pulsante Vedi tutto per le Categorie.

   

3. Individuare e fare clic sulla piastrella DEV MODULES.

   

4. Individuare il modulo SequenziatoreEventi e fare clic su di esso, o trascinarlo e rilasciarlo nella visualizzazione 3D.

   

5. Nella finestra Explorer, spostare l'intero modello SequenziatoreEventi in ServerScriptService. Dopo aver avviato l'esperienza, il modulo si distribuirà a vari servizi e inizierà a funzionare.

   

Modalità di framework

Modalità Sostituisci

La modalità di framework predefinità è la modalità di sostituzione in cui progetta scene uniche posizionando oggetti 3D, terreni, proprietà di illuminazione, effetti ambientali e oggetti dell'interfaccia utente nella cartella Ambiente di quella scena. Quando una scena si carica, quegli oggetti e proprietà vengono distribuiti in Class.Workspace``Class.Terrain, e Lighting, sostituendo oggetti/proprietà esistenti per formare uno spazio clonato.

Modalità in linea

Una modalità di framework alternativa è la modalità in linea in cui progetta i modo simile scene uniche con la logica di scripting per il loro flusso/eventi, ma il framework non distruggerà gli oggetti 3D, i terreni, le proprietà di illuminazione, gli effetti ambientali e l'interfaccia utente esistenti al fine di clonare le risorse/proprietà dalla cartella Ambiente di una scena al momento di caricamento.

Per abilitare la modalità in linea:

1. All'interno della cartella SequenziatoreEventi che hai inserito in ServerScriptService, analizza in dettaglio e seleziona il valore In linea all'interno della cartella StorageReplicato.

   

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

   

Creazione di scene

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

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

1. Espandi la cartella SequenziatoreEventi e individua la cartella ScenaVuota.

   

2. Sposta o copia l'intera cartella ScenaVuota in StorageReplicato.

   

   Durante lo sviluppo di un evento, puoi in alternativa posizionare le scene di un altro punto nella struttura gerarchica di [Explorer](/studio/explorer) e contrassegnarle con SequenziatoreScena utilizzando Etichetta Editore, accessibile dalla scheda [Visualizza](/studio/view-tab) (ScenaVuota è già contrassegnata come tale). Tuttavia, dovrai spostare tutte le scene pronte per l'evento su StorageReplicato in modo che possano funzionare all'interno del flusso complessivo dell' evento.

Lunghezza di tempo

Ogni scena dovrebbe avere una lunghezza di tempo, in secondi, che definisce la sua durata: come la durata prestabilita di un film o di un concerto. La lunghezza di tempo è definita come un attributo numerico sulla cartella della scena denominata LunghezzaDiTempo che puoi impostare direttamente in Studio o programmaticamente attraverso Instance:SetAttribute().

Ambiente

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

La cartella Ambiente contiene i seguenti contenitori:

Eventi

La cartella Eventi di una scena è puramente un segnaposto per RemoteEvents che comunica tra i moduli Client e Server. Non è richiesto di inserire nulla in questa cartella.

Cliente

Questo script esegue la logica dello schema sul client.

Server

Questo script esegue la logica dello schema sul server.

Schemi di scena

Lo schema di una scena definisce ciò che accade in quale punto della timeline della scena. Dovresti definire lo schema di una scena sia nei suoi moduli Client che Server e includere agganci del ciclo di vita da gestire quando si verificano le configurazioni.

Agganci al ciclo di vita

Gli agganci al ciclo di vita dello schema ti consentono di gestire quando si verificano le operazioni di scena. Una scena in produzione verrà in genere eseguita nel flusso più semplice:

OnRun può essere interrotto quando si cerca:

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

Configurazioni

Le configurazioni dello schema definiscono le operazioni principali di una scena, ad esempio la riproduzione dell'audio a 00:32, la messa in coda di un'animazione per la sincronizzazione con quell'audio, la programmazione di un evento di scena come uno spettacolo pirotecnico e altro ancora. Ogni configurazione supporta alcune funzioni di richiamo in cui il primo parametro (self) è l'istanza di configurazione.

Ricerca di scene

Una caratteristica unica di SequenziatoreEventi è la capacità di "cercare" tra le scene come potresti cercare attraverso un video. In Modalità Sostituisci, puoi anche passare da una scena all'altra per visualizzare l'anteprima di un intero evento multi-scena prima di distribuirlo in produzione.

La ricerca di una scena non è accessibile a tutti poiché gli utenti che semplicemente partecipano all'evento non dovrebbero avere la capacità di controllare il suo flusso temporale. Invece, devi concedere l'autorizzazione alla ricerca in base all'evento PlaceId e 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 - Set Seeking Permissions
   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 impostaCercaautorizzazioni come segue:

Plugin di Gestione di Scena

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

Per installare il plugin:

1. Dal menu Visualizza di Studio, apri la casella degli strumenti.

   

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

   

3. Nel campo di ricerca, digita Gestore di scena e premi Invio per individuare il plugin.

   

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

   

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

   

Caricamento e scaricamento di scene

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

Salvataggio e caricamento dell'illuminazione

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

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

   

2. Nella finestra del plugin Gestore di scena, fai clic su Salva illuminazione per la scena desiderata.

   

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

Una volta che le proprietà di illuminazione e i figli vengono salvati per una scena, puoi caricarli rapidamente nel Lightingservizio di livello superiore facendo clic su Carica illuminazione dalla finestra del plugin.

Salvataggio e caricamento del terreno

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

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

   

2. Nella finestra del plugin Gestore di scena, fai clic su Salva terreno per la scena desiderata.

   

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

   

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

   

Riferimento API

Agganci del ciclo di vita dello schema

OnSetup

L'aggancio del ciclo di vita di OnSetup è destinato all'inizializzazione di risorse e variabili a cui sarà fatto riferimento in OnRun o OnEndScene, impostando connectionsche sono destinati a durare per la durata della scena, ecc. Questo aggancio riceve il parametro timePositionObject che ti consente di leggere l'ora corrente all'impostazione. Questo gancio riceve il timePositionObject parametro che ti consente di leggere l'ora corrente alla configurazione.

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

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

OnRun

OnRun è il principale aggancio del ciclo di vita operativo all'interno di uno schema. Dovrebbe contenere tutte le configurazioni a tempo per la scena, dalla riproduzione di un suono o di un'animazione alla programmazione di un evento come uno spettacolo pirotecnico.

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

OnEndScene

L'aggancio del ciclo di vita di OnEndScene è utile per ripulire qualsiasi cosa in sospeso nella scena, come la disconnessione delle 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 Soundoggetto nello spazio di lavoro che viene riprodotto in un certo momento. Il suono viene quindi eliminato dopo che la scena è finita o dopo che l'Soundoggetto termina la riproduzione.

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

anima

Crea un Animation che viene riprodotto in un certo momento.

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

gemellati

Crea un Tween configurabile che viene preservato nella ricerca e nell'unione dinamica, nel senso che puoi concatenare le interpolazioni in punti separati nel tempo e tutto dovrebbe essere riprodotto e sincronizzato 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 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 determinata su una frequenza specifica, in secondi. Utile per ripetere eventi come luci lampeggianti, pulsare l'intensità di un audio, ecc. Utile per ripetere eventi come luci lampeggianti, pulsare l'intensità di un suono, ecc. La frequenza più bassa possibile è 0 secondi, ma tecnicamente la frequenza minima è sempre fissata 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

programma

Simile all'intervallo tranne che tu possa definire più tempi di inizio specifici per lo stesso evento, come la programmazione di uno spettacolo pirotecnico due volte in una scena.

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

informare

Informa il framework di qualsiasi modulo, oggetti dell'UI, connessioni, ecc. che vengono creati nell'aggancio del ciclo di vita di OnRun, assicurando che siano correttamente puliti quando si cerca. I casi di utilizzo includono:

• Informare il quadro di una connessione temporanea ad hoc come RunService.Heartbeat affinché la connessione venga ripulita quando si cerca un punto precedente nella durata della scena.

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

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

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

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

Funzioni

caricaScena

loadScene(sceneName:string, startTime:number?)

Carica programmaticamente una scena per sceneName e l'avvia a startTimedal suo inizio. Ci sarà un "periodo di tolleranza" di 5 secondi per la scena da caricare dal server prima che si verifichi la ricerca e si riproduca la scena. Ciò significa che se chiami esattamente loadScene("[SceneName]", 20)alle 16:15:00, il framework aspetterà 5 secondi in aggiunta ai 20 richiesti, dando il via alla scena alle 16:15:25.

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

creaSchema

createSchema():table

Restituisce un'istanza dello schema di scena per creare la 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

cerca

seek(time:number)

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

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

impostaTempoAvvisoScena

setSceneWarningTime(endSceneTimeWindow:number)

Imposta la quantità di tempo dalla fine di tutte le scene in cui viene inviato un avviso. Puoi rilevare l'avviso sia lato client attraverso AvvisoDiFineScenaPerClient o lato server attraverso AvvisoDiFineScenaPerServer.

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

impostaCercaautorizzazioni

setSeekingPermissions(permissions:table)

Concede la ricerca dell'autorizzazione in base al PlaceId dell'evento oltre a UserIds e/o gruppi specifici e ruoli al loro interno. Vedi Ricerca e commutazione di scene per maggiori informazioni.

getCurrentSceneEnvironment

getCurrentSceneEnvironment():Folder YIELDS

Restituisce la cartella Ambiente lato client o lato server della scena corrente, a seconda che sia chiamata dallo script dello schema Client o dallo script dello schema Server, rispettivamente.

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

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

ottieniAmbienteServerCorrenteDalClient

getCurrentServerEnvironmentFromClient():Folder YIELDS

Restituisce la cartella Ambiente lato server della scena corrente. A differenza di ottieniAmbienteScenaCorrente, puoi chiamarlo 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)")
    -- Access scene environments; does not apply to Inline Mode
    clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
    serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()
    print("Current time is:", timePositionObject.Value)
end

isLoadingScene

isLoadingScene():booleano

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

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

Eventi

AvvisoDiFinesuScenaPerClient

onSceneEndingWarningForClient(): RBXScriptSignal

Si accende sul client prima che la scena stia per terminare. Il tempo predefinito è di 3 secondi, ma puoi configurarlo attraverso impostaTempoDiAvvisoDiScena. Questo evento può essere collegato solo in un LocalScript.

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

AvvisoDiFinesuScenaPerServer

onSceneEndingWarningForServer(): RBXScriptSignal

Si accende sul server prima che la scena stia per terminare. Il tempo predefinito è di 3 secondi, ma puoi configurarlo attraverso impostaTempoDiAvvisoDiScena. Questo evento può essere collegato solo in un Script.

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

CaricatosuScenaPerClient

onSceneLoadedForClient(): RBXScriptSignal

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

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

suOrchestrazioneFinita

onOrchestrationFinished(): RBXScriptSignal

Si accende sul server quando una scena ha raggiunto la sua lunghezza di tempo ed è effettivamente terminata. Questo evento riceve un argomento con nome stringa endedSceneName per la scena che hai appena finito e puoi incatenare questo evento per caricare condizionalmente un'altra scena. Può essere collegato solo in un Script.

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