Ereignis-Sequencer

Ereignis-Sequencer ist ein leistungsstarkes Framework, das es Ihnen ermöglicht, Live-Events und Cutscenes auf einer strukturierten Abfolge von Aktionen und Triggern zu erstellen. Genauer gesagt hilft Ihnen dieses Modul dabei:

• Ein Ereignis oder eine Cutscene auf einem strukturierten Framework durch geplante Konfigurationen von Audio, Animationen und Tweens zu erstellen.
• Zwischen mehreren Szenen über mehrere Server hinweg zu wechseln und komplexe Animationen und visuelle Effekte mit einer Zeitachse zu synchronisieren.
• Durch ein Ereignis zu navigieren und das Spiel zur Test- und Entwicklungszwecken vorzuschauen.

Dieses Framework wurde in Roblox-Events wie den Konzerten von Twenty One Pilots und 24kGoldn sowie in vielen stark besuchten Spielen erprobt.

Um Ereignis-Sequencer in Aktion innerhalb eines bearbeitbaren Ortes zu sehen, schauen Sie sich die Konzert Vorlage in Roblox Studio an. Diese Vorlage ist ein umfassender Ausgangspunkt für Entwickler, um Events/Konzerte zu erstellen und sich mit den verschiedenen Funktionen und Komponenten vertraut zu machen.

Modulanwendung

Installation

Um das Ereignis-Sequencer Framework in einem Spiel zu verwenden:

1. Öffnen Sie im Studio das Toolbox über das Menü Fenster oder die Symbolleiste im Tab Start und wählen Sie den Tab Creator Store.

   

2. Stellen Sie sicher, dass die Sortierung Modelle ausgewählt ist, und klicken Sie dann auf die Schaltfläche Alle anzeigen für Kategorien.

   

3. Suchen Sie die Kachel Pakete und klicken Sie darauf.

4. Suchen Sie das Modul Ereignis-Sequencer und klicken Sie darauf oder ziehen Sie es in die 3D-Ansicht.

   

5. Verschieben Sie im Explorer Fenster das gesamte Ereignis-Sequencer Modell in ServerScriptService. Nach dem Ausführen des Spiels beginnt das Modul zu laufen.

Framework-Modi

Ersetzen-Modus

Der Standard-Framework-Modus ist der Ersetzen-Modus, in dem Sie einzigartige Szenen gestalten, indem Sie 3D-Objekte, Terrain, Lichteigenschaften, Umwelteffekte und Benutzeroberflächenobjekte in den Umgebungs-Ordner dieser Szene einfügen. Wenn eine Szene geladen wird, werden diese Objekte und Eigenschaften in Workspace, Terrain und Lighting verteilt und ersetzen vorhandene Objekte/Eigenschaften, um einen geklonten Raum zu bilden.

Inline-Modus

Ein alternativer Framework-Modus ist der Inline-Modus, in dem Sie ebenfalls einzigartige Szenen mit Skriptlogik für deren Ablauf/Ereignisse gestalten, aber das Framework nicht vorhandene 3D-Objekte, Terrain, Lichteigenschaften, Umwelteffekte und Benutzeroberflächenobjekte zerstört, um Vermögenswerte/Eigenschaften aus dem Umgebungs-Ordner einer Szene beim Laden zu klonen.

Um den Inline-Modus zu aktivieren:

1. Wählen Sie im Ereignis-Sequencer Modell, das Sie in ServerScriptService platziert haben, den Inline Wert im ReplicatedStorage Ordner aus.

   

2. Aktivieren Sie im Eigenschaften Fenster das Kontrollkästchen Wert.

   

Szenen erstellen

Eine Szene ist im Wesentlichen Teil eines Gesamtereignisses oder einer Cutscene, die in einer Reihe von Ordnern verpackt ist. Jede Szene enthält Skriptlogik, die ihren Ablauf/Ereignisse definiert, und eine Szene kann ihre eigenen 3D-Objekte, Terrain, Lichteigenschaften, Umwelteffekte und Benutzeroberflächenobjekte speichern.

Um schnell zu starten, finden Sie eine leere Szene im Hauptordner des Moduls:

1. Erweitern Sie den Ereignis-Sequencer Ordner und suchen Sie den BlankScene Ordner.

   

2. Verschieben oder kopieren Sie den gesamten BlankScene Ordner in ReplicatedStorage.

   

   Während der Entwicklung eines Ereignisses können Sie alternativ Szenen an anderen Stellen in der Explorer Hierarchie platzieren und sie mit SequencerScene im Abschnitt Tags ihrer Eigenschaften kennzeichnen (BlankScene ist bereits so gekennzeichnet). Sie müssen jedoch alle einsatzbereiten Szenen in ReplicatedStorage verschieben, damit sie im gesamten Ereignisablauf funktionieren.

Zeitlänge

Jede Szene sollte eine Zeitlänge in Sekunden haben, die ihre Dauer definiert – genau wie ein Film oder Konzert eine festgelegte Dauer hat. Die Zeitlänge wird als numerisches Attribut im Ordner der Szene mit dem Namen TimeLength definiert, das Sie direkt im Studio oder programmgesteuert über Instance:SetAttribute() festlegen können.

Umgebung

Der Umgebungs-Ordner einer Szene enthält alles, was Benutzer sehen und hören, einschließlich 3D-Objekte, Terrain, Lichteigenschaften und Umwelteffekte, sowie Benutzeroberflächenobjekte. Wenn eine Szene geladen wird, werden diese Objekte und Eigenschaften in Workspace, Terrain und Lighting verteilt und ersetzen vorhandene Objekte/Eigenschaften, um einen geklonten Raum zu bilden.

Der Umgebungs-Ordner enthält die folgenden Container:

Ereignisse

Der Ereignisse-Ordner einer Szene ist rein ein Platzhalter für RemoteEvents, die zwischen den Client und Server Modulen kommunizieren. Es ist nicht erforderlich, etwas in diesem Ordner zu platzieren.

Client

Dieses Skript führt die Schema Logik auf dem Client aus.

Server

Dieses Skript führt die Schema Logik auf dem Server aus.

Szenen-Schemas

Ein Schema einer Szene definiert, was zu welchem Zeitpunkt in der Zeitachse der Szene passiert. Sie sollten das Schema einer Szene sowohl in ihren Client als auch in ihren Server Modulen definieren und Lebenszyklus-Hooks einfügen, um zu verwalten, wann Konfigurationen stattfinden.

Lebenszyklus-Hooks

Schema Lebenszyklus-Hooks ermöglichen es Ihnen, zu verwalten, wann Szenenoperationen stattfinden. Eine Szene in Produktion wird typischerweise im einfachsten Ablauf ausgeführt:

• OnSetup → OnRun → OnEndScene

OnRun kann unterbrochen werden, wenn Sie suchen:

• OnSetup → OnRun… suchen → OnRun… suchen → OnRun → OnEndScene

Alle drei Hooks können auch wiederholt werden, wenn die Szene erneut abgespielt wird:

• OnSetup → OnRun → OnEndScene… wiederholen → OnSetup → OnRun → OnEndScene

Konfigurationen

Schema Konfigurationen definieren die Kernoperationen einer Szene, z. B. Audio abspielen bei 00:32, eine Animation anstellen, um mit diesem Audio zu synchronisieren, ein Ereignis der Szene planen wie eine Feuerwerksshow und mehr. Jede Konfiguration unterstützt bestimmte Rückruffunktionen, bei denen der erste Parameter (self) die Konfigurationsinstanz ist.

Szenen suchen

Eine einzigartige Funktion des Ereignis-Sequencers ist die Möglichkeit, durch Szenen zu "suchen", wie Sie es möglicherweise bei einem Video tun würden. Im Ersetzen-Modus können Sie auch zwischen Szenen wechseln, um ein ganzes Multi-Szenen-Ereignis vorzuschauen, bevor Sie es in die Produktion bringen.

Das Suchen von Szenen ist nicht für jeden zugänglich, da Benutzer, die einfach das Ereignis genießen, nicht die Möglichkeit haben sollten, den Zeitfluss zu steuern. Stattdessen müssen Sie die Suchberechtigung basierend auf der PlaceId des Ereignisses sowie spezifischen UserIds und/oder Gruppen und Rollen innerhalb dieser gewähren.

1. Erstellen Sie ein neues Script innerhalb von ServerScriptService.

2. Fügen Sie den folgenden Code in das neue Skript ein.

   Skript - Suchberechtigungen festlegen

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

3. Füllen Sie die folgenden Tabellen innerhalb des setSeekingPermissions Aufrufs wie folgt aus:

   placeIDs	Komma-getrennte Liste von PlaceId Werten, um das Suchen innerhalb zu unterstützen.
   userIDs	Komma-getrennte Liste von UserIds für diejenigen, die innerhalb der unterstützten Orte suchen können.
   groups	Komma-getrennte Liste von Tabellen, die jeweils eine Gruppe ID und den Mindestgrad der Mitglieder dieser Gruppe enthalten, die innerhalb der unterstützten Orte suchen können.

Szenenmanager-Plugin

Das Szenenmanager Plugin ist ein nützliches Tool zum Laden und Entladen von Szenen, Licht und Terrain. Es wird dringend empfohlen, dieses Plugin zu verwenden, anstatt Szenenobjekte und -eigenschaften manuell zu platzieren/bearbeiten, es sei denn, Sie verwenden den Inline-Modus.

Um das Plugin zu installieren:

1. Öffnen Sie im Studio das Toolbox über das Menü Fenster oder die Symbolleiste im Tab Start.

2. Wählen Sie im Tab Creator Store Plugins aus dem Dropdown-Menü aus.

3. Geben Sie im Suchfeld Szenenmanager ein und drücken Sie Enter, um das Plugin zu finden.

   

4. Klicken Sie auf das Symbol des Plugins, um die Details anzuzeigen, und klicken Sie dann auf die Schaltfläche Installieren.

5. Sobald das Plugin installiert ist, erscheint es im Tab Plugins von Studio.

Szenen laden und entladen

Wie im Abschnitt Szenen erstellen beschrieben, enthält der Umgebungs-Ordner einer Szene alles, was Benutzer sehen und hören, einschließlich 3D-Objekte. Das Plugin hilft Ihnen, die Vermögenswerte einer Szene schnell in oder aus organisierten Ordnern innerhalb des Arbeitsbereichs zu laden.

Licht speichern und laden

Der oberste Lighting Dienst speichert alle Lichteigenschaften und visuellen Effekte eines Ortes. Da es sich um einen obersten Dienst handelt, können Sie ihn nicht manuell in den Umgebungs/Server oder Umgebungs/Client Ordner einer bestimmten Szene verschieben. Stattdessen können Sie das Plugin verwenden, um seine Eigenschaften und Kinder in den Umgebungs/Lighting Ordner der Szene zu kopieren.

1. Konfigurieren Sie die Lichteigenschaften, Post-Processing Effekte, atmosphärischen Effekte und Skyboxes der Szene über den obersten Lighting Dienst.

   

2. Klicken Sie im Szenenmanager Plugin-Fenster auf Licht speichern für die gewünschte Szene.

3. Wählen Sie den Umgebungs/Lighting Konfiguration dieser Szene aus und erweitern Sie sie, und Sie sehen die gleichen Lichteigenschaften als Attribute des Ordners sowie geklonte Kinder des obersten Lighting Dienstes.

   

   

   Sobald die Lichteigenschaften und Kinder für eine Szene gespeichert sind, können Sie sie schnell wieder in den obersten Lighting Dienst laden, indem Sie im Plugin-Fenster auf Licht laden klicken.

Terrain speichern und laden

Da Terrain eine oberste Klasse innerhalb von Workspace ist, können Sie generiertes oder skulptiertes Terrain nicht manuell in den Umgebungs/Server oder Umgebungs/Client Ordner einer bestimmten Szene verschieben. Stattdessen können Sie das Plugin verwenden, um es in den Umgebungs/Terrain Ordner der Szene zu kopieren.

1. Konfigurieren Sie das Terrain der Szene über den obersten Terrain Dienst.

   

2. Klicken Sie im Szenenmanager Plugin-Fenster auf Terrain speichern für die gewünschte Szene.

3. Wählen Sie den Umgebungs/Terrain Ordner dieser Szene aus und erweitern Sie ihn, und Sie sehen ein TerrainRegion Objekt, das das gespeicherte Terrain darstellt.

   

   Sobald das Terrain für eine Szene gespeichert ist, können Sie es schnell wieder in den obersten Terrain Dienst laden, indem Sie im Plugin-Fenster auf Terrain laden klicken.

API-Referenz

Schema-Lebenszyklus-Hooks

OnSetup

Der OnSetup Lebenszyklus-Hook ist dafür gedacht, Vermögenswerte und Variablen zu initialisieren, die in OnRun oder OnEndScene referenziert werden, Verbindungen einzurichten, die für die Dauer der Szene bestehen bleiben sollen usw. Dieser Hook erhält den Parameter timePositionObject, mit dem Sie die aktuelle Zeit beim Setup lesen können.

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

	-- Zugriff auf die Szenenumgebungen; gilt nicht für den Inline-Modus
	clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
	serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()
	-- Auf Vermögenswerte warten
	dummy = clientEnvironment:WaitForChild("Dummy")

	print("Aktuelle Zeit ist:", timePositionObject.Value)
end

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

	-- Zugriff auf die Szenenumgebung; gilt nicht für den Inline-Modus
	serverEnvironment = EventSequencer.getCurrentSceneEnvironment()
	partColorConnection = changePartColorEvent.OnServerEvent:Connect(function(player, changedPart, newColor)
		serverEnvironment.changedPart.Color = newColor
	end)

	print("Aktuelle Zeit ist:", timePositionObject.Value)
end

OnRun

OnRun ist der Hauptbetriebs-Lebenszyklus-Hook innerhalb eines Schemas. Es sollte alle zeitgesteuerten Konfigurationen für die Szene enthalten, vom Abspielen von Audio oder einer Animation bis hin zum Planen eines Ereignisses wie einer Feuerwerksshow.

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

	local MainAudio = Schema:audio({
		StartTime = 1,
		SoundId = "rbxassetid://1838673350",
		OnStart = function(self)
			print("Audio wird abgespielt")
		end,
		OnEnd = function(self)
			print("Audio ist zu Ende")
		end
	})
end

OnEndScene

Der OnEndScene Lebenszyklus-Hook ist nützlich, um alles, was in der Szene noch aussteht, aufzuräumen, z. B. Verbindungen zu trennen, die in OnSetup oder OnRun erstellt wurden und für die Dauer der Szene bestehen bleiben.

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

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

Schema-Konfigurationen

audio

Erstellt ein Sound Objekt im Arbeitsbereich, das zu einem bestimmten Zeitpunkt abgespielt wird. Der Sound wird dann gelöscht, nachdem die Szene zu Ende ist oder nachdem das Sound Objekt das Abspielen beendet hat.

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

	local MainAudio = Schema:audio({
		StartTime = 1,
		SoundId = "rbxassetid://1838673350",
		OnStart = function(self)
			print("Audio wird abgespielt")
		end,
		OnEnd = function(self)
			print("Audio ist zu Ende")
		end
	})
end

animate

Erstellt eine Animation, die zu einem bestimmten Zeitpunkt abgespielt wird.

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 wird abgespielt")
		end,
		OnEnd = function(self)
			print("Animation gestoppt")
		end
	})
end

tween

Erstellt ein konfigurierbares Tween, das beim Suchen und beim dynamischen Beitreten erhalten bleibt, was bedeutet, dass Sie Tweens zu verschiedenen Zeitpunkten verketten können und alles wie erwartet abgespielt und synchronisiert wird.

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 wird abgespielt")
		end,
		OnHeartbeat = function(self, alpha)
			print("Tween Alpha", alpha)
		end,
		OnEnd = function(self)
			print("Tween abgeschlossen")
		end,
	})
end

interval

Führt eine benutzerdefinierte Rückruffunktion über eine bestimmte Dauer mit einer bestimmten Frequenz in Sekunden aus. Nützlich für wiederholte Ereignisse wie blinkende Lichter, Pulsieren der Lautstärke eines Audios usw. Die niedrigste mögliche Frequenz beträgt 0 Sekunden, aber technisch wird die minimale Frequenz immer auf Heartbeat begrenzt.

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

Ähnlich wie interval, mit dem Unterschied, dass Sie mehrere spezifische Startzeiten für dasselbe Ereignis definieren können, z. B. das Planen einer Feuerwerksshow zweimal in einer Szene.

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

	Schema:schedule({
		StartTimes = {5, 27.25},
		OnStart = function(self)
			-- Temporäre Herzschlagverbindung initialisieren
			local tempConnection = RunService.Heartbeat:Connect(function()

			end)
			-- Framework über die Verbindung informieren
			Schema:inform(tempConnection)
		end
	})
end

inform

Informiert das Framework über alle Module, UI-Objekte, Verbindungen usw., die im OnRun Lebenszyklus-Hook erstellt werden, um sicherzustellen, dass sie beim Suchen ordnungsgemäß aufgeräumt werden. Anwendungsfälle sind:

• Informieren des Frameworks über eine temporäre Ad-hoc-Verbindung wie RunService.Heartbeat, damit die Verbindung beim Suchen zu einem früheren Punkt in der Dauer der Szene aufgeräumt wird.

  Server-Schema

  Schema.OnRun = function()
  	print("OnRun (Server)")
  
  	Schema:schedule({
  		StartTimes = {5},
  		OnStart = function(self)
  			-- Temporäre Herzschlagverbindung initialisieren
  			local tempConnection = RunService.Heartbeat:Connect(function()
  
  			end)
  			-- Framework über die Verbindung informieren
  			Schema:inform(tempConnection)
  		end
  	})
  end

• Aufrufen einer benutzerdefinierten "Aufräum"-Funktion in einem ModuleScript, die eine Verbindung oder eine andere Referenz während des OnRun Lebenszyklus-Hooks initialisiert.

  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)
  			-- "init" Funktion im benutzerdefinierten Modul aufrufen
  			customModule.init()
  			-- "clean" Funktion im benutzerdefinierten Modul beim Aufräumen der Szene aufrufen
  			Schema:inform(customModule, customModule.clean)
  		end,
  	})
  end

  ModuleScript - CustomModule

  local RunService = game:GetService("RunService")
  
  local CustomModule = {}
  
  CustomModule.init = function()
  	-- Herzschlagverbindung initialisieren
  	CustomModule.connection = RunService.Heartbeat:Connect(function()
  
  	end)
  end
  
  CustomModule.clean = function()
  	-- Herzschlagverbindung trennen und löschen
  	if CustomModule.connection then
  		CustomModule.connection:Disconnect()
  		CustomModule.connection = nil
  	end
  end
  
  return CustomModule

Funktionen

loadScene

Lädt programmgesteuert eine Szene nach sceneName und startet sie zu startTime von ihrem Anfang. Es gibt eine 5-sekündige "Gnadenfrist", damit die Szene vom Server geladen werden kann, bevor die Suche erfolgt und die Szene abgespielt wird. Das bedeutet, dass, wenn Sie loadScene("[SceneName]", 20) genau um 16:15:00 Uhr aufrufen, das Framework 5 Sekunden zusätzlich zu den angeforderten 20 Sekunden wartet und die Szene um 16:15:25 Uhr startet.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Nächste Szene herausfinden, die geladen werden soll, wenn die aktuelle Szene endet
EventSequencer.onOrchestrationFinished:Connect(function(endedSceneName)
	if endedSceneName == "PreShow" then
		-- "PreShow" ist zu Ende; lade die erste Szene im Konzert
		EventSequencer.loadScene("Track1")
	elseif endedSceneName == "Track1" then
		-- "Track1" ist zu Ende; lade die zweite Szene im Konzert
		EventSequencer.loadScene("Track2")
	else
		-- Zurück zur Pre-Show-Szene
		EventSequencer.loadScene("PreShow")
	end
end)

createSchema

Gibt eine Instanz des Szenen Schemas zurück, um Logik für die Szene zu erstellen.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

local Schema = EventSequencer.createSchema()

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

seek

Sucht zum time Wert, in Sekunden, vom Anfang der aktuell geladenen Szene.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

EventSequencer.seek(95.58)

setSceneWarningTime

Legt die Zeitspanne vom Ende aller Szenen fest, zu der eine Warnung ausgegeben wird. Sie können die Warnung entweder clientseitig über onSceneEndingWarningForClient oder serverseitig über onSceneEndingWarningForServer erkennen.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Szene laden
EventSequencer.loadScene("BeautifulScene")

-- Warnzeit auf 5 Sekunden vor dem Ende der Szene festlegen
EventSequencer.setSceneWarningTime(5)

-- Erkennen, wann die Szene kurz vor dem Ende steht
EventSequencer.onSceneEndingWarningForServer:Connect(function()
	warn("Szene steht kurz vor dem Ende!")
end)

setSeekingPermissions

Gewährt Suchberechtigungen basierend auf der PlaceId des Ereignisses sowie spezifischen UserIds und/oder Gruppen und Rollen innerhalb dieser. Siehe Suchen und Szenen wechseln für weitere Informationen.

getCurrentSceneEnvironment

Gibt den aktuellen Szenen-Client- oder Server-Umgebungs Ordner zurück, abhängig davon, ob er aus dem Client Schema-Skript oder dem Server Schema-Skript aufgerufen wird.

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

	-- Zugriff auf die Szenenumgebungen; gilt nicht für den Inline-Modus
	clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
	serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()

	print("Aktuelle Zeit ist:", timePositionObject.Value)
end

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

Gibt den aktuellen Szenen-Server Umgebungs Ordner zurück. Im Gegensatz zu getCurrentSceneEnvironment können Sie dies aus dem Client Schema-Skript aufrufen.

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

	-- Zugriff auf die Szenenumgebungen; gilt nicht für den Inline-Modus
	clientEnvironment = EventSequencer.getCurrentSceneEnvironment()
	serverEnvironment = EventSequencer.getCurrentServerEnvironmentFromClient()

	print("Aktuelle Zeit ist:", timePositionObject.Value)
end

isLoadingScene

Wird vom Server aufgerufen, um zu wissen, ob eine Szene gerade geladen wird.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

print(EventSequencer.isLoadingScene())

while EventSequencer.isLoadingScene() do
	task.wait()
end
print("Szene geladen")

Ereignisse

onSceneEndingWarningForClient

Wird auf dem Client ausgelöst, bevor die Szene zu Ende geht. Die Standardzeit beträgt 3 Sekunden, kann jedoch über setSceneWarningTime konfiguriert werden. Dieses Ereignis kann nur in einem LocalScript verbunden werden.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Erkennen, wann die Szene kurz vor dem Ende steht (clientseitig)
EventSequencer.onSceneEndingWarningForClient:Connect(function()
	warn("Szene steht kurz vor dem Ende!")
end)

onSceneEndingWarningForServer

Wird auf dem Server ausgelöst, bevor die Szene zu Ende geht. Die Standardzeit beträgt 3 Sekunden, kann jedoch über setSceneWarningTime konfiguriert werden. Dieses Ereignis kann nur in einem Script verbunden werden.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Erkennen, wann die Szene kurz vor dem Ende steht (serverseitig)
EventSequencer.onSceneEndingWarningForServer:Connect(function()
	warn("Szene steht kurz vor dem Ende!")
end)

onSceneLoadedForClient

Wird auf dem Client ausgelöst, wenn die Szene startet. Dieses Ereignis kann nur in einem LocalScript verbunden werden.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Erkennen, wann die Szene startet (clientseitig)
EventSequencer.onSceneLoadedForClient:Connect(function()
	warn("Szene startet!")
end)

onOrchestrationFinished

Wird auf dem Server ausgelöst, wenn eine Szene ihre Zeitlänge erreicht hat und effektiv zu Ende ist. Dieses Ereignis erhält ein endedSceneName String-Argument für die Szene, die gerade beendet wurde, und Sie können von diesem Ereignis aus bedingt eine andere Szene laden. Kann nur in einem Script verbunden werden.

local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Nächste Szene herausfinden, die geladen werden soll, wenn die aktuelle Szene endet
EventSequencer.onOrchestrationFinished:Connect(function(endedSceneName)
	if endedSceneName == "PreShow" then
		-- "PreShow" ist zu Ende; lade die erste Szene im Konzert
		EventSequencer.loadScene("Track1")
	elseif endedSceneName == "Track1" then
		-- "Track1" ist zu Ende; lade die zweite Szene im Konzert
		EventSequencer.loadScene("Track2")
	else
		-- Zurück zur Pre-Show-Szene
		EventSequencer.loadScene("PreShow")
	end
end)