Secuenciador de eventos

EventSequencer es un marco de trabajo eficaz que te permite crear eventos y secuencias cinemáticas en vivo y entre servidores en una secuencia de acciones y desencadenadores estructurada. Más específicamente, este módulo te ayuda a hacer lo siguiente:

• Crear eventos o secuencias cinemáticas en un marco estructurado a través de configuraciones programadas de audio, animaciones e interpolaciones de movimiento.
• Realizar transiciones entre diversas escenas en varios servidores, mediante la sincronización de animaciones y elementos visuales complejos en una línea de tiempo.
• Realizar búsquedas en eventos y obtener una vista previa de la experiencia para fines de prueba y desarrollo.

Este marco se probó en eventos de Roblox, como los conciertos de Twenty One Pilots y 24kGoldn, así como en muchas experiencias muy visitadas.

Para ver el EventSequencer en acción dentro de un lugar editable, consulta la plantilla Concierto en Roblox Studio. Esta plantilla es un punto de partida completo para que los desarrolladores creen eventos o conciertos y se familiaricen con las diversas características y componentes que se utilizan.

Uso del módulo

Instalación

Sigue estos pasos para usar el marco EventSequencer en una experiencia:

1. En la pestaña Ver, abre la Caja de herramientas y selecciona la pestaña Mercado.

   

2. Asegúrate de que la clasificación de Modelos esté seleccionada y, a continuación, haz clic en el botón Ver todo para las Categorías.

   

3. Busca y haz clic en el mosaico MÓDULOS DE DESARROLLO.

   

4. Busca el módulo Secuenciador de eventos y haz clic en él o arrástralo y suéltalo en la vista 3D.

   

5. En la ventana del Explorador, mueve todo el modelo de EventSequencer a ServerScriptService. Al ejecutar la experiencia, el módulo se distribuirá a varios servicios y comenzará a ejecutarse.

   

Modos del marco de trabajo

Modo de reemplazo

El modo predeterminado del marco es el modo de reemplazo, en el que puedes diseñar escenas únicas al colocar objetos 3D, terrenos, propiedades de iluminación, efectos ambientales y objetos de la interfaz de usuario en la carpeta Environment de esas escenas. Cuando se carga una escena, esos objetos y propiedades se distribuyen en Workspace, Terrain y Lighting, los objetos o propiedades existentes se reemplazan para formar un espacio clonado.

Modo en línea

El modo en línea es un modo alternativo que te permite diseñar escenas únicas con lógica de scripting para sus flujos o eventos de forma similar, pero el marco no destruye los objetos 3D, los terrenos, las propiedades de iluminación, los efectos ambientales y los objetos de la interfaz de usuario existentes para clonar recursos o propiedades de la carpeta Environment de las escenas al cargarse.

Sigue estos pasos para activar el modo en línea:

1. Dentro de la carpeta EventSequencer que colocaste en ServerScriptService, busca y selecciona el valor Inline dentro de la carpeta ReplicatedStorage.

   

2. En el Propiedades ventana, cambia en su Valor casilla de verificación.

   

Creación de escenas

Básicamente, las escenas forman parte de eventos o secuencias cinemáticas generales contenidas en una serie de carpetas. Todas las escenas contienen una lógica de scripting que define su flujo o sus eventos, y pueden almacenar sus propios objetos 3D, terrenos, propiedades de iluminación, efectos ambientales y objetos de la interfaz de usuario.

Para comenzar rápidamente, puedes encontrar una escena vacía dentro de la carpeta principal del módulo:

1. Expande la carpeta EventSequencer y busca la carpeta BlankScene.

   

2. Mueve o copia toda la carpeta BlankScene en ReplicatedStorage.

   

   Mientras desarrollas un evento, también puedes colocar escenas en otro lugar de la jerarquía [Explorer](/studio/explorer) y etiquetarlas con SequencerScene mediante el Editor de etiquetas, accesible desde la pestaña [View](/studio/view-tab) (BlankScene ya está etiquetada como tal). Sin embargo, tendrás que mover todas las escenas listas para un evento a ReplicatedStorage para que funcionen dentro del flujo general del evento.

Tiempo

Todas las escenas deben tener un tiempo determinado, en segundos, que defina su duración, al igual que una película o un concierto tienen una duración establecida. El tiempo se define como un atributo numérico en la carpeta de la escena denominada TimeLength, que puedes establecer directamente en Studio o mediante programación a través de Instance:SetAttribute().

Entorno

La carpeta Entorno de una escena contiene todo lo que los usuarios ven y oyen, incluidos objetos 3D, terreno, propiedades de iluminación y efectos del entorno, y objetos de interfaz de usuario. Cuando se carga una escena, esos objetos y propiedades se distribuyen en Class.Workspace``Class.Lighting, Terrain y , y los objetos o propiedades existentes se reemplazan para formar un espacio clonado.

La carpeta Environment incluye los siguientes contenedores:

Eventos

La carpeta Events de las escenas es simplemente un marcador de posición de RemoteEvents que se comunica entre los módulos de cliente y servidor. No es necesario colocar nada en esta carpeta.

Cliente

Este script ejecuta la lógica del esquema en el cliente.

Servidor

Este script ejecuta la lógica del esquema en el servidor.

Esquemas de las escenas

Los esquemas definen lo que sucede en distintos puntos de la línea de tiempo de las escenas. Debes definir los esquemas de las escenas en sus módulos de cliente y servidor e incluir enlaces de ciclo de vida para administrarlos cuando se produzcan las configuraciones.

Enlaces de ciclo de vida

El esquema de enlaces de ciclo de vida te permite administrar cuándo se producen las operaciones de las escenas. Por lo general, las escenas en producción se ejecutan con el flujo más simple:

OnRun puede interrumpirse cuando se realizan búsquedas:

Los tres enlaces también se pueden repetir si se vuelve a reproducir la escena:

Configuraciones

El esquema de configuraciones define las operaciones principales de las escenas, por ejemplo, reproducir audio en 00:32, poner una animación en cola para sincronizarla con ese audio o programar un evento de una escena, como un espectáculo de fuegos artificiales, entre otras. Todas las configuraciones admiten ciertas funciones de devolución de llamada, en las que el primer parámetro (self) es la instancia de configuración.

Búsquedas en las escenas

Una característica exclusiva de EventSequencer es la capacidad de realizar “búsquedas” en las escenas de la misma manera en la que se realizan en los videos. En el modo de reemplazo, también puedes cambiar entre escenas para previsualizar todo un evento de varias escenas antes de implementarlo en producción.

Las búsquedas en las escenas no están disponibles para todos, ya que los usuarios que simplemente disfrutan del evento no deben tener la capacidad de controlar su flujo de tiempo. Debes conceder permiso para realizar búsquedas en función de la PlaceId del evento, así como de las UserIds o los grupos y roles específicos en su interior.

1. Crea un Script nuevo en ServerScriptService.

2. Pega el siguiente código en el script nuevo.

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

3. Completa las siguientes tablas dentro de la llamada de setSeekingPermissions como se indica a continuación:

Complemento de administración de escenas

El complemento Administrador de escenas es una herramienta útil para cargar y descargar escenas, propiedades de iluminación y terrenos. A menos que uses el modo en línea, es sumamente recomendable que utilices este complemento en lugar de colocar o editar los objetos y las propiedades de las escenas de forma manual.

Sigue estos pasos para instalar el complemento:

1. En el menú Vista de Studio, abre la Caja de herramientas.

   

2. En la pestaña Mercado, selecciona Complementos en el menú desplegable.

   

3. En el campo de búsqueda, escribe Administrador de escenas y presiona Enter para buscar el complemento.

   

4. Haz clic en el icono del complemento para ver sus detalles y, luego, en el botón azul Instalar.

   

5. Una vez que el complemento se instala, se muestra en la pestaña Complementos de Studio.

   

Carga y descarga de escenas

Como se indicó en la sección Creación de escenas, la carpeta Environment de las escenas contiene todo lo que los usuarios ven y escuchan, incluidos los objetos 3D. El complemento te ayuda a cargar rápidamente los recursos de una escena dentro o fuera de las carpetas organizadas en el espacio de trabajo.

Almacenamiento y carga de propiedades de iluminación

El servicio Lighting de nivel superior almacena todas las propiedades de iluminación y los efectos visuales de un lugar. Como se trata de un servicio de nivel superior, no puedes trasladarlo de forma manual a la carpeta Environment/Server o Environment/Client de una escena en particular. En su lugar, puedes utilizar el complemento para copiar sus propiedades y sus componentes secundarios en la carpeta Environment/Lighting de la escena.

1. Configura las propiedades de iluminación, los efectos de posprocesamiento, los efectos atmosféricos y los skyboxes de la escena a través del Lightingservicio de nivel superior.

   

2. En la ventana del complemento Administrador de escenas, haz clic en Guardar iluminación para la escena que desees.

   

3. Selecciona y expande la carpeta Environment/Lighting de esa escena y verás las mismas propiedades de iluminación como atributos de la carpeta, así como los elementos secundarios clonados de la carpeta del Lightingservicio de nivel superior.

Una vez que las propiedades de iluminación y los elementos secundarios de una escena se guardan, puedes volver a cargarlos rápidamente en el servicio Lightingde nivel superior al hacer clic en Cargar iluminación en la ventana del complemento.

Almacenamiento y carga de terrenos

Como Terrain es una clase de nivel superior dentro de Workspace, no puedes mover un terreno generado o esculpido de forma manual a la carpeta Environment/Server o Environment/Client de una escena en particular. En su lugar, puedes utilizar el complemento para copiarlo en la carpeta Environment/Terrain de la escena.

1. Configura el terreno de la escena a través del servicio Terrain de nivel superior.

   

2. En la ventana del complemento Administrador de escenas, haz clic en Guardar terreno para la escena que desees.

   

3. Al seleccionar y expandir la carpeta Environment/Terrain de esa escena, verás un objeto TerrainRegion que representa el terreno guardado.

   

   Una vez que el terreno se guarda para una escena, puedes volver a cargarlo rápidamente en el Terrainservicio de nivel superior al hacer clic en Cargar terreno en la ventana del complemento.

   

Referencia API

Esquema de enlaces de ciclo de vida

OnSetup

El enlace de ciclo de vida OnSetup está diseñado para inicializar recursos y variables a los que se hará referencia en OnRun u OnEndScene, y establece connections destinadas a mantenerse a lo largo de toda la duración de la escena, etc. Este enlace recibe el parámetro timePositionObject, que te permite leer la hora actual en la configuración.

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 es el enlace de ciclo de vida operativo principal dentro de un esquema. Debe contener todas las configuraciones programadas de la escena, desde la reproducción de audio o una animación hasta la programación de un evento, como una exhibición de fuegos artificiales.

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

El enlace de ciclo de vida OnEndScene es útil para limpiar todo lo que quede pendiente en la escena, por ejemplo, para desconectar las conexiones creadas en OnSetup u OnRun que se mantienen durante toda la escena.

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

Configuraciones de los esquemas

Audio

Crea un objeto Sound en el espacio de trabajo que se reproduce en un momento determinado. El sonido se elimina una vez que la escena finaliza o cuando el objeto Sound termina de reproducirse.

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

animate

Crea una Animation que se reproduce en un momento determinado.

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

Crea una Tween configurable que se mantiene en las búsquedas y las uniones dinámicas, lo que significa que puedes encadenar interpolaciones de movimiento en momentos separados y todo debe reproducirse y sincronizarse de la manera prevista.

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

interval

Ejecuta una función de devolución de llamada personalizada durante un período especificado en una frecuencia definida, en segundos. Es útil para repetir eventos, como luces intermitentes, la intensidad del audio, etc. La frecuencia más baja posible es de 0 segundos, pero, técnicamente, la frecuencia mínima siempre se depende de Heartbeat.

Client Schema
Schema.OnRun = function()
    print("OnRun (Client)")
    local MainAudio = Schema:audio({
        StartTime = 1,
        SoundId = "rbxassetid://1838673350",
    })
    local ClientTimerUpdate = Schema:interval({
        Frequency = 1,
        SyncToAudio = {
            StartAtAudioTime = 2.5,
            EndAtAudioTime = 10,
            Audio = MainAudio
        },
        OnInterval = function(self)
            print(MainAudio.Sound.TimePosition, MainAudio. CurrentSoundIntensityRatio)
        end,
    })
end

schedule

Es similar a interval, excepto que te permite definir varias horas de inicio específicas para un mismo evento, por ejemplo, puedes programar una exhibición de fuegos artificiales dos veces en una misma escena.

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

inform

Le informa al marco la creación de cualquier módulo, objeto de la interfaz de usuario, conexión, etc. que se realice en el enlace de ciclo de vida OnRun, lo que garantiza que se limpien correctamente al realizar búsquedas. Estos son algunos de los casos de uso:

• Informar al marco una conexión temporal ad hoc, como , RunService.Heartbeatpara que la conexión se limpie cuando se realice una búsqueda en un punto anterior en la duración de la escena.

  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

• Llamar a una función de “limpieza” personalizada en un ModuleScript que inicializa una conexión u otra referencia durante el enlace de 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

Funciones

loadScene

loadScene(sceneName:string, startTime:number?)

Se carga una escena por mediante programación sceneNamey se la inicia en startTimedesde su comienzo. Habrá un “período de gracia” de cinco segundos para que la escena se cargue desde el servidor antes de que se produzca la búsqueda y la escena comience a reproducirse. Esto significa que si llamas a loadScene("[SceneName]", 20)exactamente a las 4:15:00 p. m., el marco esperará cinco segundos además de los 20 solicitados y la escena se iniciará a las 4:15:25 p.

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)

createSchema

createSchema():table

Devuelve una instancia del esquema de la escena para crear la lógica de la escena.

Client Schema
local ReplicatedStorage = game: GetService("ReplicatedStorage")
local EventSequencer = require(ReplicatedStorage:WaitForChild("EventSequencer"))
local Schema = EventSequencer.createSchema()
Schema. OnSetup = function(timePositionObject)
    print("OnSetup (Client)")
end

seek

seek(time:number)

Realiza una búsqueda en el valor time, en segundos, desde el comienzo de la escena cargada en el momento.

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

setSceneWarningTime

setSceneWarningTime(endSceneTimeWindow:number)

Establece el período desde el final de todas las escenas en el que se envía una advertencia. Puedes detectar la advertencia del lado del cliente a través de onSceneEndingWarningForClient o del lado del servidor a través de 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)

setSeekingPermissions

setSeekingPermissions(permissions:table)

Concede permiso de búsqueda en función de la PlaceId del evento, así como de UserIds o grupos y roles específicos en su interior. Consulta Búsquedas en las escenas y cambio de escenas para obtener más información.

getCurrentSceneEnvironment

getCurrentSceneEnvironment():Folder YIELDS

Devuelve la carpeta Environment del lado del cliente o del lado del servidor de la escena actual, en función de si se llama desde el script del esquema del cliente o el script del esquema del 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():Folder YIELDS

Devuelve la carpeta Environment del lado del servidor de la escena actual. A diferencia de getCurrentSceneEnvironment, puedes llamarla desde el script del esquema del 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

Se llama a esta función desde el servidor para saber si una escena se está cargando.

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

Se desencadena en el cliente antes de que la escena esté a punto de terminar. El tiempo predeterminado es de 3 segundos, pero puedes configurarlo a través de setSceneWarningTime. Este evento solo se puede conectar en 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)

onSceneEndingWarningForServer

onSceneEndingWarningForServer(): RBXScriptSignal

Se desencadena en el servidor antes de que la escena esté a punto de terminar. El tiempo predeterminado es de 3 segundos, pero puedes configurarlo a través de setSceneWarningTime. Este evento solo se puede conectar en 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)

onSceneLoadedForClient

onSceneLoadedForClient(): RBXScriptSignal

Se desencadena en el cliente cuando la escena se está iniciando. Este evento solo se puede conectar en 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)

onOrchestrationFinished

onOrchestrationFinished(): RBXScriptSignal

Se desencadena en el servidor cuando una escena alcanza su duración y se termina efectivamente. Este evento recibe un argumento de nombre de cadena endedSceneName para la escena que acaba de terminar, y puedes encadenarlo para cargar otra escena de forma condicional. Solo se puede conectar en 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)