Sequenciador de eventos

O EventSequencer é um framework poderoso que permite que você construa eventos ao vivo, entre servidores e cutscenes em uma sequência estruturada de ações e gatilhos. Mais especificamente, esse módulo ajuda você a:

• Construir um evento ou cutscene em um quadro estruturado por meio de configurações agendadas de áudio, animações e interpolações.
• Fazer a transição entre várias cenas em vários servidores, sincronizando animações e visuais complexos em uma linha do tempo.
• Procurar em um evento e prever a experiência para teste e desenvolvimento.

Esse framework foi posto à prova em eventos da Roblox como os shows do Twenty One Pilots e 24kGoldn, além de muitas outras experiências altamente visitadas.

Para ver EventSequencer em ação em um lugar editável, confira o modelo Concerto no Roblox Studio. Este modelo é um ponto de partida abrangente para os desenvolvedores criarem eventos/concertos e se familiarizarem com os vários recursos e componentes envolvidos.

Uso do módulo

Instalação

Para usar o framework do EventSequencer em uma experiência:

1. Na aba Exibir, abra a Caixa de ferramentas e selecione a aba Mercado.

   

2. Verifique se a ordenação de Modelos está selecionada e, em seguida, clique no botão Exibir Tudo para Categorias.

   

3. Encontre e clique no painel DEV MODULES

   

4. Localize o módulo Sequenciador de Eventos e clique nele ou arraste e solte-o na visualização 3D.

   

5. Na janela do Explorador, mova todo o modelo EventSequencer para o ServerScriptService. Ao executar a experiência, o módulo será distribuído para vários serviços e começará a ser executado.

   

Modos do Framework

Modo Substituir

O modo de framework padrão é substituir o modo em que você projeta cenas únicas colocando objetos 3D, terreno, propriedades de iluminação, efeitos ambientais, e objetos de interface de usuário dentro da pasta Ambiente. Quando uma cena carrega, esses objetos e propriedades são distribuídos em Class. Workspace, Class. Terrain e Class. Lighting, substituindo objetos/propriedades existentes para formar um espaço clonado.

Modo Inline

Um modo alternativo de framework é um modo embutido no qual você também projeta cenas únicas com uma lógica de script para seu fluxo/eventos. mas o framework não irá destruir objetos 3D existentes, terreno, propriedades de iluminação, efeitos ambientais e objetos de interface de usuário a fim de clonar ativos/propriedades da pasta de cena de umAmbiente após o carregamento.

Para habilitar o modo inline:

1. Dentro da pasta EventSequencer, que foi colocada em ServerScriptService, abra e selecione o valor Inline dentro da pasta ReplicatedStorage.

   

2. Na janela Propriedades, alterne na sua caixa de seleção Valor.

   

Criando cenas

Uma cena é uma parte essencial de um evento geral ou de uma cutscene que está em uma série de pastas. Cada cena contém uma lógica de script que define seu fluxo/eventos. e uma cena pode armazenar seus próprios objetos 3D, terreno, iluminação propriedades, efeitos ambientais e objetos da interface do usuário.

Para começar rapidamente, encontre uma cena vazia dentro da pasta principal do módulo:

1. Expanda a pasta EventSequencer e localize a pasta BlankScene.

   

2. Mova ou copie toda a pasta BlankScene para ReplicatedStorage.

   

   Ao desenvolver um evento, você também pode colocar cenas em outro lugar na hierarquia do [Explorer](/studio/explorer) e marcá-los com SequencerScene usando o Tag Editor, acessível a partir da aba [View](/studio/view-tab) (BlankScene já está marcada como tal). No entanto, você precisará mover todas as cenas prontas para ReplicatedStorage para que elas funcionem dentro do fluxo geral de eventos.

Duração

O esquema de uma cena define o que acontece em que ponto da linha do tempo da cena. O tempo é definido como um atributo numérico na pasta da cena chamada TimeLength , que pode ser definida diretamente no Studio ou programaticamente através de Instance:SetAttribute().

Ambiente

A pasta do Ambiente de uma cena contém tudo que usuários veem e ouvem, incluindo objetos 3D, terreno, propriedades de iluminação e efeitos ambientais, além de objetos da interface do usuário. Quando uma cena carrega, esses objetos e propriedades são distribuídos em Class. Workspace, Class. Terrain e Class. Lighting, substituindo objetos/propriedades existentes para formar um espaço clonado.

A pasta Ambiente contém os seguintes contêineres:

Eventos

A pasta Eventos de uma cena é puramente um espaço reservado para que Class. RemoteEvent|RemoteEvents se comunique entre os módulos Cliente e Servidor. Não é um requisito colocar algo nessa pasta.

Cliente

Esse script executa a lógica do esquema no cliente.

Servidor

Esse script executa a lógica do esquema no servidor.

Esquemas de cenas

Define o tempo a partir do final de todas as cenas no qual um aviso é enviado. Você pode detectar o aviso no lado do cliente por meio de onSceneEndingWarningForClient ou no lado do servidor usando onSceneEndingWarningForServer.

Hooks de ciclo de vida

Os hooks do ciclo de vida do esquema permitem que você gerencie quando operações na cena ocorrem. Uma cena em produção geralmente é executada no fluxo mais simples:

OnRun pode ser interrompido ao procurar:

Todos os três hooks também podem se repetir se a cena for tocada novamente:

Configurações

As configurações do esquema definem as operações principais de uma cena, por exemplo, reproduzir áudio em 00:32, enfileirar uma animação de modo a sincronizá-la com o áudio, programar um evento na cena, como um show de fogos de artifício e muito mais. Toda configuração oferece suporte a certas funções de callback, nas quais o primeiro parâmetro (self) é a instância de configuração.

Procurando nas cenas

Uma funcionalidade exclusiva do EventSequencer é a capacidade de "procurar" nas cenas, como se você procurasse um momento dentro de um vídeo. No Modo Substituir, também é possível alternar entre cenas para pré-visualizar um evento inteiro de várias cenas antes de enviar para a produção.

A procura de cenas não está acessível a todos, já que o usuários que estão simplesmente assistindo ao evento não deve ter acesso de controlar o fluxo da cena. Em vez disso, você deve conceder uma permissão de busca baseada na PlaceId do evento bem como nas UserIds específicas e/ou grupos e papéis dentro deles.

1. Crie um novo Class. Script dentro de Class. ServerScriptService.

2. Cole o seguinte código dentro do script novo.

   Script - Set Seeking Permissions
   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
   EventSequencer.setSeekingPermissions({
    placeIDs = {},
    userIDs = {},
    groups = {
        {GroupID = , MinimumRankID = },
    }
   })

3. Preencha as seguintes tabelas na chamada de setSeekingPermissions da seguinte forma:

Plugin do Gerenciador de Cenas

O plugin Gerenciador de Cenas é uma ferramenta útil para carregar e descarregar cenas, iluminação e terreno. A menos que você esteja usando o Modo Inline, é altamente recomendável que você use esse plugin em vez de colocar/editar manualmente objetos e propriedades da cena.

Para instalar o plugin:

1. No menu Exibir do Studio, abra a Caixa de Ferramentas.

   

2. Com a aba Mercado selecionada, selecione Plugins no menu suspenso.

   

3. No campo de pesquisa, digite Gerenciador de Cenas e pressione Enter para localizar o plugin.

   

4. Clique no ícone do plugin para visualizar os detalhes e, em seguida, clique no botão azul Instalar.

   

5. Após a instalação do plugin, ele aparecerá na aba Plugins do Studio.

   

Carregando e descarregando cenas

Conforme delineado em Criando cenas, a pasta Ambiente de uma cena contém tudo o que os usuários veem e ouvem, incluindo os objetos 3D. O plugin ajuda a carregar rapidamente os componentes de uma cena para dentro ou para fora das pastas organizadas na área de trabalho.

Salvando e carregando iluminação

O serviço Class. Lighting de nível superior armazena todas as propriedades de iluminação e efeitos visuais de um local. Como se trata de um serviço de nível superior, não é possível movê-lo manualmente para a pasta Environment/Server ou Environment/Client de uma cena específica. Em vez disso, você pode usar o plugin para copiar as propriedades e os filhos para a pasta Environment/Lighting da cena.

1. Configure os efeitos de pós-processamento das propriedades de iluminação da cena, efeitos atmosféricos e skyboxes através do serviço de alto nível Class.Lightining.

   

2. No painel do plugin Gerenciador de Cenas, clique em Salvar iluminação para a cena desejada.

   

3. Selecione e expanda a pasta Ambiente/Iluminação e você verá as mesmas propriedades de iluminação como atributos da pasta, bem como crianças clonadas do serviço de alto nível Lighting.

Depois que as propriedades de iluminação e filhos forem salvos para uma cena, você pode carregá-los rapidamente de volta ao serviço Class. Lighting de nível superior clicando em Carregar iluminação na janela do plug-in.

Salvando e carregando terrenos

Terrain é uma classe de nível superior dentro de Class. Workspace, você não pode mover manualmente o terreno gerado ou desenhado para a pasta Environment/Server ou Environment/Client de uma cena específica. Em vez disso, use o plugin para copiá-lo para a pasta Environment/Terrain da cena.

1. Configure o terreno da cena por meio do serviço de Terreno de nível superior.

   

2. Na janela do plugin Gerenciador de Cenas, clique em Salvar terreno para a cena desejada.

   

3. Selecione e expanda a pasta Environment/Terrain dessa cena e você verá um objeto TerrainRegion que representa o terreno salvo.

   

   O hook do ciclo de vida OnSetup se destina a inicializar componentes e variáveis que serão referenciados em OnRun ou OnEndScene, à configuração de connections que deve durar na cena, etc. Esse hook recebe o parâmetro timePositionObject que permite que você leia o tempo atual na configuração.

   

Referência de API

Hooks do ciclo de vida do esquema

OnSetup

Cada cena deve ter um tempo de duração, em segundos, que defina sua duração — assim como um filme ou concerto tem uma duração definida. A duração é definida como um atributo numérico na pasta da cena chamada TimeLength, que você pode definir diretamente no Studio ou programando por meio de Class. Este hook recebe o parâmetro <code>timePositionObject que permite ler a hora atual na configuração.

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
.

OnRun

OnRun é o principal hook do ciclo de vida operacional dentro de um esquema. Deve conter todas as configurações cronometradas para a cena, da reprodução de áudio ou uma animação à programação de um evento, como uma exibição de fogos de artifício.

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

O hook do ciclo de vida OnEndScene é útil para limpar qualquer pendência na cena, como desconectar conexões criadas em OnSetup ou OnRun que permanecem durante a cena.

Server Schema
Schema. OnEndScene = function()
    print("OnEndScene (Server)")
    if partColorConnection then
        partColorConnection:Disconnect()
        partColorConnection = nil
    end
end

Configurações do esquema

Áudio

Cria um objeto Class. Sound na área de trabalho que é reproduzido em um determinado momento. O som é excluído após a cena terminar ou o objeto Class. Sound terminar sua reprodução.

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

animar

Cria um objeto Class. Animation que é reproduzido em um determinado 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

tween

Cria um objeto Class. Tween configurável que é preservado na procura e na mescla dinâmica, o que significa que você pode encadear interpolações em pontos separados e tudo é tocado de forma sincronizada.

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

intervalo

Executa uma função de callback personalizada em uma duração específica a uma frequência específica, em segundos. Útil para repetir eventos como luzes piscantes, pulsar a intensidade de um áudio, etc. Útil para repetir eventos como luzes piscando, intensidade de um áudio pulsante, etc. A frequência mínima possível é de 0 segundos, mas tecnicamente a frequência mínima é sempre limitada a Class. RunService. Heartbeat|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

agenda

Semelhante a interval, exceto que você pode definir vários momentos de início específicos para o mesmo evento, como programar uma exibição de fogos de artifício duas vezes em uma cena.

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

informar

Informa ao framework a respeito de quaisquer módulos, objetos de interface de usuário, conexões, etc. que são criados no hook do ciclo de vida OnRun, garantindo que sejam limpos corretamente ao procurar. Casos de uso incluem:

• Informação ao framework a respeito de uma conexão ad-hoc temporária, como Class. RunService. Heartbeat para que a conexão seja limpa ao procurar um ponto anterior da duração da cena.

  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

• Chamar uma função de "limpeza" personalizada em um objeto Class. ModuleScript que inicializa uma conexão ou outra referência durante o hook do ciclo de vida 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

Funções

loadScene

loadScene(sceneName:string, startTime:number?)

Carrega uma cena de forma programática por sceneName e a inicia em startTime a partir do início. Haverá um "período de carência" de 5 segundos para a cena ser carregada do servidor antes que a procura ocorra e a cena comece a ser reproduzida. Isso quer dizer que, se você chamar loadScene("[SceneName]", 20) exatamente às 16h15h00, o framework aguardará 5 segundos além dos 20 solicitados e, com isso, a cena será iniciada às 16h15h25.

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

createSchema

createSchema():table

Retorna uma instância do esquema da cena para criar a lógica para ela.

Client Schema
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)

procurar

seek(time:number)

Procura o valor time em segundos, a partir do início da cena atualmente carregada.

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

setSceneWarningTime

setSceneWarningTime(endSceneTimeWindow:number)

Define a quantidade de tempo do fim de todas as cenas em que um aviso foi despachado. Você pode detectar o aviso do lado cliente através do onSceneEndingWarningForClient ou o lado do servidor através do onSceneEndingWarningForServer.

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

setSeekingPermissions

setSeekingPermissions(permissions:table)

Concede permissões de procura com base em PlaceId do evento, bem como objetos UserIds específicos e/ou grupos e funções dentro deles. Consulte Procurando e trocando de cenas para mais informações.

getCurrentSceneEnvironment

getCurrentSceneEnvironment():Class. Folder YIELDS

Retorna a pasta Ambiente do lado do cliente ou do lado do servidor da cena atual, dependendo se ela foi chamada a partir do script do esquema do cliente ou do script do esquema do servidor, respectivamente.

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

getCurrentServerEnvironmentFromClient

getCurrentServerEnvironmentFromClient():Class. Folder YIELDS

Retorna a pasta Ambiente do lado do servidor da cena atual. Ao contrário de getCurrentSceneEnvironment, você pode chamar a função a partir do script do esquema Cliente.

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():boolean

Função chamada do servidor que confere se uma cena está sendo carregada no momento.

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

Eventos

onSceneEndingWarningForClient

onSceneEndingWarningForClient(): RBXScriptSignal

É acionado no cliente antes que a cena esteja prestes a terminar. O tempo padrão é de 3 segundos, mas você pode configurá-lo por meio de setSceneWarningTime. O evento só pode ser conectado a um Class. 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)

onSceneEndingWarningForServer

onSceneEndingWarningForServer(): RBXScriptSignal

É acionado no servidor antes que a cena esteja prestes a terminar. O tempo padrão é de 3 segundos, mas você pode configurá-lo por meio de setSceneWarningTime. O evento só pode ser conectado a um Class. 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)

onSceneLoadedForClient

onSceneLoadedForClient(): RBXScriptSignal

É acionado no cliente quando a cena está começando. O evento só pode ser conectado a um Class. 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!")
Value)
end

onOrchestrationFinished

onOrchestrationFinished(): RBXScriptSignal

É acionado no servidor quando uma cena atinge sua duração e termina efetivamente. Esse evento recebe um argumento em string endedSceneName para a cena que acabou de terminar, assim você pode encadear esse evento para carregar outra cena condicionalmente. Só pode ser conectado em um Class. 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)