Sekwencjonator zdarzeń

Sekwencjonator Zdarzeń to potężna struktura, która umożliwia budowanie wydarzeń na żywo oraz przerywników między serwerami w oparciu o uporządkowaną sekwencję działań i wyzwalaczy. Bardziej szczegółowo, ten moduł pomaga Ci:

• Zbudować wydarzenie lub przerywnik na uporządkowanej strukturze poprzez zaplanowane konfiguracje dźwięku, animacji i tweenów.
• Przejść między wieloma scenami na różnych serwerach, synchronizując skomplikowane animacje i efekty wizualne z linią czasową.
• Przeszukiwać wydarzenie i podglądać doświadczenie w celach testowych i rozwojowych.

Ta struktura została przetestowana w wydarzeniach Roblox, takich jak koncerty Twenty One Pilots i 24kGoldn, a także w wielu chętnie odwiedzanych doświadczeniach.

Aby zobaczyć Sekwencjonator Zdarzeń w akcji w ramach edytowalnego miejsca, sprawdź szablon Koncert w Roblox Studio. Ten szablon stanowi kompleksowy punkt wyjścia dla deweloperów do tworzenia wydarzeń/koncertów i zaznajamiania się z różnymi funkcjami i komponentami zaangażowanymi w ten proces.

Użytkowanie modułu

Instalacja

Aby użyć struktury Sekwencjonator Zdarzeń w danym doświadczeniu:

1. Z menu Okno w Studio lub z paska narzędzi na karcie Strona główna, otwórz Narzędziownię i wybierz zakładkę Sklep Kreatora.

   

2. Upewnij się, że wybrane są sortowania Modele, a następnie kliknij przycisk Zobacz Wszystko w sekcji Kategorie.

   

3. Zlokalizuj i kliknij kafelek Pakiety.

4. Zlokalizuj moduł Sekwencjonator Zdarzeń i kliknij go lub przeciągnij i upuść do widoku 3D.

   

5. W oknie Eksploratora przenieś cały model Sekwencjonator Zdarzeń do ServerScriptService. Po uruchomieniu doświadczenia moduł zacznie działać.

Tryby struktury

Tryb zastępowania

Domyślnym trybem struktury jest tryb zastępowania, w którym projektujesz unikalne sceny poprzez umieszczanie obiektów 3D, terenu, właściwości oświetlenia, efektów środowiskowych i obiektów interfejsu użytkownika w folderze Środowisko danej sceny. Kiedy scena jest ładowana, te obiekty i właściwości są dystrybuowane do Workspace, Terrain i Lighting, zastępując istniejące obiekty/właściwości, tworząc sklonowaną przestrzeń.

Tryb wbudowany

Alternatywnym trybem struktury jest tryb wbudowany, w którym w podobny sposób projektujesz unikalne sceny z logiką skryptów dla ich przepływu/zdarzeń, ale struktura nie zniszczy istniejących obiektów 3D, terenu, właściwości oświetlenia, efektów środowiskowych i obiektów interfejsu użytkownika, aby sklonować zasoby/właściwości z folderu Środowisko sceny podczas ładowania.

Aby włączyć tryb wbudowany:

1. W modelu Sekwencjonator Zdarzeń, który umieściłeś w ServerScriptService, zjeżdżaj w dół i wybierz wartość Wbudowany w folderze ReplicatedStorage.

   

2. W oknie Właściwości włącz pole wyboru Wartość.

   

Tworzenie scen

Scena to zasadniczo część ogólnego wydarzenia lub przerywnika, złożona z serii folderów. Każda scena zawiera logikę skryptu, która definiuje jej przepływ/zdarzenia, a scena może przechowywać własne obiekty 3D, teren, właściwości oświetlenia, efekty środowiskowe i obiekty interfejsu użytkownika.

Aby szybko rozpocząć, możesz znaleźć pustą scenę w głównym folderze modułu:

1. Rozwiń folder Sekwencjonator Zdarzeń i zlokalizuj folder PustaScena.

   

2. Przenieś lub skopiuj cały folder PustaScena do ReplicatedStorage.

   

   Podczas rozwijania wydarzenia możesz alternatywnie umieścić sceny w innych miejscach w hierarchii Eksploratora i oznaczyć je jako SequencerScene za pomocą sekcji Tagi ich właściwości (PustaScena już jest oznaczona w ten sposób). Będziesz musiał jednak przenieść wszystkie gotowe do wydarzenia sceny do ReplicatedStorage, aby mogły działać w ramach ogólnego przepływu wydarzenia.

Czas trwania

Każda scena powinna mieć czas trwania, w sekundach, definiujący jego długość – tak jak film lub koncert ma określoną długość. Czas trwania jest definiowany jako atrybut liczbowy instancji w folderze sceny o nazwie CzasTrwania, który możesz ustawić bezpośrednio w Studio lub programowo przez Instance:SetAttribute().

Środowisko

Folder Środowisko sceny zawiera wszystko, co użytkownicy widzą i słyszą, w tym obiekty 3D, teren, właściwości oświetlenia oraz efekty środowiskowe i obiekty interfejsu użytkownika. Kiedy scena jest ładowana, te obiekty i właściwości są dystrybuowane do Workspace, Terrain i Lighting, zastępując istniejące obiekty/właściwości, tworząc sklonowaną przestrzeń.

Folder Środowisko zawiera następujące kontenery:

Zdarzenia

Folder Zdarzenia sceny jest czystym miejscem na RemoteEvents, które komunikują się między modułami Klient i Serwer. Nie ma wymogu umieszczania czegokolwiek w tym folderze.

Klient

Ten skrypt wykonuje logikę schematu na kliencie.

Serwer

Ten skrypt wykonuje logikę schematu na serwerze.

Schematy scen

Schemat sceny definiuje, co dzieje się w jakim momencie w harmonogramie czasu sceny. Powinieneś zdefiniować schemat sceny w obu jej modułach Klient i Serwer i uwzględnić hooki cyklu życia, aby zarządzać tym, kiedy następują konfiguracje.

Hooki cyklu życia

Hooki cyklu życia schematu umożliwiają zarządzanie tym, kiedy operacje sceny się odbywają. Scena w produkcji będzie zazwyczaj działać w najprostszy sposób:

• OnSetup → OnRun → OnEndScene

OnRun może być przerwany podczas przeszukiwania:

• OnSetup → OnRun… szukaj → OnRun… szukaj → OnRun → OnEndScene

Wszystkie trzy hooki mogą również powtarzać się, jeśli scena jest odtwarzana ponownie:

• OnSetup → OnRun → OnEndScene… powtórz → OnSetup → OnRun → OnEndScene

Konfiguracje

Konfiguracje schematu konfiguracji definiują podstawowe operacje sceny, na przykład odtwarzanie dźwięku o 00:32, kolejkowanie animacji do synchronizacji z tym dźwiękiem, zaplanowanie zdarzenia sceny, takiego jak pokaz sztucznych ogni, i wiele więcej. Każda konfiguracja wspiera pewne funkcje zwrotne, gdzie pierwszy parametr (self) to instancja konfiguracji.

Przeszukiwanie scen

Unikalną cechą Sekwencjonatora Zdarzeń jest możliwość "przeszukiwania" scen, tak jak można przeszukiwać wideo. W Trybie Zastąpienia, możesz również przełączać się między scenami, aby podglądać całe wydarzenie wieloscenowe przed jego wdrożeniem do produkcji.

Przeszukiwanie scen nie jest dostępne dla wszystkich, ponieważ użytkownicy po prostu cieszący się wydarzeniem nie powinni mieć możliwości kontrolowania jego przebiegu czasowego. Musisz zamiast tego przyznać uprawnienia do przeszukiwania w oparciu o PlaceId wydarzenia oraz konkretne UserIds i/lub grupy oraz role w ich obrębie.

1. Utwórz nowy Script w ServerScriptService.

2. Wklej następujący kod do nowego skryptu.

   Skrypt - Ustawienie uprawnień do przeszukiwania
   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   
   local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))
   
   SekwencjonatorZdarzeń.setSeekingPermissions({
   	placeIDs = {},
   	userIDs = {},
   	groups = {
   		{GroupID = , MinimumRankID = },
   	}
   })

3. Uzupełnij następujące tabele w wywołaniu setSeekingPermissions w następujący sposób:

   placeIDs	Lista wartości PlaceId oddzielonych przecinkami, aby umożliwić przeszukiwanie w tych miejscach.
   userIDs	Lista wartości UserIds oddzielonych przecinkami dla tych, którzy mogą przeszukiwać w obsługiwanych miejscach.
   groups	Lista tabel, z których każda zawiera identyfikator grupy i minimalny ranking członków tej grupy, którzy mogą przeszukiwać w obsługiwanych miejscach.

Wtyczka zarządzania sceną

Wtyczka Zarządca Scen jest przydatnym narzędziem do ładowania i wyładowywania scen, oświetlenia oraz terenu. O ile nie używasz Trybu Wbudowanego, zaleca się korzystanie z tej wtyczki zamiast ręcznego umieszczania/edycji obiektów i właściwości sceny.

Aby zainstalować wtyczkę:

1. Z menu Okno w Studio lub z paska narzędzi na karcie Strona główna, otwórz Narzędziownię.

2. Z wybraną zakładką Sklep Kreatora, wybierz Wtyczki z rozwijanego menu.

3. W polu wyszukiwania wpisz Zarządca Scen i naciśnij Enter, aby zlokalizować wtyczkę.

   

4. Kliknij ikonę wtyczki, aby zobaczyć jej szczegóły, a następnie kliknij przycisk Zainstaluj.

5. Po zainstalowaniu wtyczka pojawi się na karcie Wtyczki w Studio.

Ładowanie i wyładowywanie scen

Jak zarysowano w tworzeniu scen, folder Środowisko sceny zawiera wszystko, co użytkownicy widzą i słyszą, w tym obiekty 3D. Wtyczka pomaga szybko załadować zasoby sceny do zorganizowanych folderów w obrębie przestrzeni roboczej.

Zapisz i załaduj oświetlenie

Usługa Lighting najwyższego poziomu przechowuje wszystkie właściwości oświetleniowe i wizualne danego miejsca. Ponieważ jest to usługa najwyższego poziomu, nie możesz ręcznie przenieść jej do folderu Środowisko/Serwer lub Środowisko/Klient konkretnej sceny. Zamiast tego możesz wykorzystać wtyczkę do skopiowania jej właściwości i dzieci do folderu Środowisko/Oświetlenie sceny.

1. Skonfiguruj właściwości oświetleniowe sceny, efekty przetwarzania po, efekty atmosferyczne oraz skyboxy poprzez usługę Lighting najwyższego poziomu.

   

2. W oknie wtyczki Zarządca Scen, kliknij Zapisz Oświetlenie dla danej sceny.

3. Wybierz i rozwiń konfigurację Środowisko/Oświetlenie tej sceny, a zobaczysz te same właściwości oświetleniowe jako atrybuty folderu, jak również sklonowane dzieci usługi Lighting najwyższego poziomu.

   

   

   Po zapisaniu właściwości oświetlenia i dzieci dla sceny, możesz szybko załadować je z powrotem do usługi Lighting najwyższego poziomu, klikając Załaduj Oświetlenie z okna wtyczki.

Zapisz i załaduj teren

Ponieważ Terrain jest klasą najwyższego poziomu w obrębie Workspace, nie możesz ręcznie przenieść wygenerowanego lub uformowanego terenu do konkretnego folderu Środowisko/Serwer lub Środowisko/Klient danej sceny. Zamiast tego możesz wykorzystać wtyczkę do skopiowania go do folderu Środowisko/Teren sceny.

1. Skonfiguruj teren sceny poprzez najwyższą usługę Teren.

   

2. W oknie wtyczki Zarządca Scen, kliknij Zapisz Teren dla danej sceny.

3. Wybierz i rozwiń folder Środowisko/Teren tej sceny, a zobaczysz obiekt TerrainRegion, który reprezentuje zapisany teren.

   

   Po zapisaniu terenu dla sceny, możesz szybko załadować go z powrotem do usługi Terrain najwyższego poziomu, klikając Załaduj Teren z okna wtyczki.

Referencja API

Hooki cyklu życia schematu

OnSetup

Hook cyklu życia OnSetup jest przeznaczony do inicjalizacji zasobów i zmiennych, które będą odwoływane w OnRun lub OnEndScene, ustawiania połączeń, które mają trwać przez cały czas trwania sceny, itd. Ten hook otrzymuje parametr timePositionObject, który pozwala ci odczytać aktualny czas podczas ustawienia.

Klient - Schemat
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

local Schemat = SekwencjonatorZdarzeń.createSchema()

local środowiskoKlienta
local środowiskoSerwera
local dummy

Schemat.OnSetup = function(timePositionObject)
	print("OnSetup (Klient)")

	-- Uzyskanie dostępu do środowisk sceny; nie dotyczy Trybu Wbudowanego
	środowiskoKlienta = SekwencjonatorZdarzeń.getCurrentSceneEnvironment()
	środowiskoSerwera = SekwencjonatorZdarzeń.getCurrentServerEnvironmentFromClient()
	-- Czekaj na zasoby
	dummy = środowiskoKlienta:WaitForChild("Dummy")

	print("Aktualny czas to:", timePositionObject.Value)
end

Serwer - Schemat
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

local Schemat = SekwencjonatorZdarzeń.createSchema()

local środowiskoSerwera
local connectionKolorCzęści
local changePartColorEvent = script.Parent.Events.ChangePartColor

Schemat.OnSetup = function(timePositionObject)
	print("OnSetup (Serwer)")

	-- Uzyskanie dostępu do środowiska sceny; nie dotyczy Trybu Wbudowanego
	środowiskoSerwera = SekwencjonatorZdarzeń.getCurrentSceneEnvironment()

	connectionKolorCzęści = changePartColorEvent.OnServerEvent:Connect(function(player, zmienionaCzęść, nowyKolor)
		środowiskoSerwera.zmienionaCzęść.Color = nowyKolor
	end)

	print("Aktualny czas to:", timePositionObject.Value)
end

OnRun

OnRun to główny operacyjny hook cyklu życia w obrębie schematu. Powinien zawierać wszystkie zaplanowane konfiguracje dla danej sceny, od odtwarzania dźwięku lub animacji do zaplanowania zdarzenia jak pokaz sztucznych ogni.

Klient - Schemat
Schemat.OnRun = function()
	print("OnRun (Klient)")

	local GłównyDźwięk = Schemat:audio({
		CzasRozpoczęcia = 1,
		SoundId = "rbxassetid://1838673350",
		OnStart = function(self)
			print("Odtwarzanie dźwięku")
		end,
		OnEnd = function(self)
			print("Dźwięk zakończony")
		end
	})
end

OnEndScene

Hook cyklu życia OnEndScene jest użyteczny do oczyszczenia wszystkiego, co pozostało w scenie, takiego jak rozłączenie połączeń utworzonych w OnSetup lub OnRun, które pozostają przez cały czas trwania sceny.

Serwer - Schemat
Schemat.OnEndScene = function()
	print("OnEndScene (Serwer)")

	if connectionKolorCzęści then
		connectionKolorCzęści:Disconnect()
		connectionKolorCzęści = nil
	end
end

Konfiguracje schematu

audio

Tworzy obiekt Sound w przestrzeni roboczej, który odtwarza się w określonym czasie. Dźwięk jest następnie usuwany po zakończeniu sceny lub po zakończeniu odtwarzania obiektu Sound.

Klient - Schemat
Schemat.OnRun = function()
	print("OnRun (Klient)")

	local GłównyDźwięk = Schemat:audio({
		CzasRozpoczęcia = 1,
		SoundId = "rbxassetid://1838673350",
		OnStart = function(self)
			print("Odtwarzanie dźwięku")
		end,
		OnEnd = function(self)
			print("Dźwięk zakończony")
		end
	})
end

animate

Tworzy Animation, która odtwarza się w określonym czasie.

Klient - Schemat
Schemat.OnRun = function()
	print("OnRun (Klient)")

	local GłównyDźwięk = Schemat:audio({
		CzasRozpoczęcia = 1,
		SoundId = "rbxassetid://1838673350",
	})

	local AnimacjaTańca = Schemat:animate({
		AnimationId = "rbxassetid://3695333486",
		Rig = Dummy,
		Speed = 1,
		CzasFadeIn = 0.1,
		CzasFadeOut = 0.3,
		SyncToAudio = {
			Audio = GłównyDźwięk,
			StartAtAudioTime = 5,
		},
		OnStart = function(self)
			print("Odtwarzanie animacji")
		end,
		OnEnd = function(self)
			print("Animacja zatrzymana")
		end
	})
end

tween

Tworzy konfigurowalny Tween, który jest zachowywany podczas przeszukiwania i dynamicznego dołączania, co oznacza, że możesz łączyć tweens w różnych punktach czasowych, a wszystko powinno działać i synchronizować się zgodnie z oczekiwaniami.

Klient - Schemat
Schemat.OnRun = function()
	print("OnRun (Klient)")

	local GłównyDźwięk = Schemat:audio({
		CzasRozpoczęcia = 1,
		SoundId = "rbxassetid://1838673350",
	})

	local FadeŚwiatła = Schemat:tween({
		CzasyRozpoczęcia = {29.884},
		Tween = {
			Obiekt = game:GetService("Lighting"),
			Info = TweenInfo.new(2, Enum.EasingStyle.Sine, Enum.EasingDirection.Out),
			Właściwości = {
				Jasność = 0,
			}
		},
		SyncToAudio = {
			Audio = GłównyDźwięk,
			StartAtAudioTimes = {5, 7.2, 9.4, 11.6},
		},
		OnStart = function(self)
			print("Tween odtwarzany")
		end,
		OnHeartbeat = function(self, alpha)
			print("Tween alpha", alpha)
		end,
		OnEnd = function(self)
			print("Tween zakończony")
		end,
	})
end

interval

Wykonuje niestandardową funkcję zwrotną w określonym czasie przez określoną częstotliwość, w sekundach. Przydatne do powtarzających się zdarzeń, takich jak migające światła, pulsowanie intensywności dźwięku itd. Najniższa możliwa częstotliwość wynosi 0 sekund, ale technicznie minimalna częstotliwość zawsze jest ograniczona do Heartbeat.

Klient - Schemat
Schemat.OnRun = function()
	print("OnRun (Klient)")

	local GłównyDźwięk = Schemat:audio({
		CzasRozpoczęcia = 1,
		SoundId = "rbxassetid://1838673350",
	})

	local AktualizacjaTimeraKlienta = Schemat:interval({
		Częstotliwość = 1,
		SyncToAudio = {
			StartAtAudioTime = 2.5,
			EndAtAudioTime = 10,
			Audio = GłównyDźwięk
		},
		OnInterval = function(self)
			print(GłównyDźwięk.Sound.TimePosition, GłównyDźwięk.CurrentSoundIntensityRatio)
		end,
	})
end

schedule

Podobnie jak interval, z tą różnicą, że możesz zdefiniować wiele konkretnych czasów rozpoczęcia dla tego samego zdarzenia, na przykład planując pokaz sztucznych ogni dwa razy w scenie.

Klient - Schemat
Schemat.OnRun = function()
	print("OnRun (Klient)")

	Schemat:schedule({
		CzasyRozpoczęcia = {5, 27.25},
		OnStart = function(self)
			-- Inicjalizacja tymczasowego połączenia z heartbeat
			local tempConnection = RunService.Heartbeat:Connect(function()

			end)
			-- Informowanie struktury o połączeniu
			Schemat:inform(tempConnection)
		end
	})
end

inform

Informuje strukturę o wszelkich modułach, obiektach UI, połączeniach itp., które są tworzone w hooku cyklu życia OnRun, zapewniając, że są odpowiednio oczyszczane podczas przeszukiwania. Przykładowe przypadki użycia to:

• Informowanie struktury o tymczasowym połączeniu ad-hoc, takim jak RunService.Heartbeat, aby połączenie zostało oczyszczone podczas przeszukiwania wcześniejszego punktu w czasie trwania sceny.

  Serwer - Schemat
  Schemat.OnRun = function()
  	print("OnRun (Serwer)")
  
  	Schemat:schedule({
  		CzasyRozpoczęcia = {5},
  		OnStart = function(self)
  			-- Inicjalizacja tymczasowego połączenia z heartbeat
  			local tempConnection = RunService.Heartbeat:Connect(function()
  
  			end)
  			-- Informowanie struktury o połączeniu
  			Schemat:inform(tempConnection)
  		end
  	})
  end

• Wywoływanie niestandardowej funkcji "oczyszczania" w ModuleScript, która inicjalizuje połączenie lub inne odniesienie w obrębie hooku cyklu życia OnRun.

  Serwer - Schemat
  local ReplicatedStorage = game:GetService("ReplicatedStorage")
  local RunService = game:GetService("RunService")
  
  local customModule = require(ReplicatedStorage:WaitForChild("CustomModule"))
  
  local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))
  
  local Schemat = SekwencjonatorZdarzeń.createSchema()
  
  Schemat.OnRun = function()
  	print("OnRun (Serwer)")
  
  	Schemat:schedule({
  		CzasyRozpoczęcia = {5},
  		OnStart = function(self)
  			-- Wywołanie funkcji "init" w niestandardowym module
  			customModule.init()
  			-- Wywołanie funkcji "clean" w niestandardowym module przy oczyszczaniu sceny
  			Schemat:inform(customModule, customModule.clean)
  		end,
  	})
  end

  ModuleScript - CustomModule
  local RunService = game:GetService("RunService")
  
  local CustomModule = {}
  
  CustomModule.init = function()
  	-- Inicjalizacja połączenia z heartbeat
  	CustomModule.connection = RunService.Heartbeat:Connect(function()
  
  	end)
  end
  
  CustomModule.clean = function()
  	-- Rozłączenie i oczyszczenie połączenia z heartbeat
  	if CustomModule.connection then
  		CustomModule.connection:Disconnect()
  		CustomModule.connection = nil
  	end
  end
  
  return CustomModule

Funkcje

loadScene

Programowo ładuje scenę po sceneName i rozpoczyna ją w startTime od jej początku. Zostanie dodany 5-sekundowy "okres łaski", aby scena załadowała się z serwera przed przeszukiwaniem i rozpoczęciem odtwarzania. Oznacza to, że jeśli wywołasz loadScene("[SceneName]", 20) dokładnie o 16:15:00, struktura poczeka 5 sekund oprócz żądanych 20, uruchamiając scenę o 16:15:25.

Skrypt
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

-- Dowiedz się, jaką następną scenę załadować po zakończeniu bieżącej sceny
SekwencjonatorZdarzeń.onOrchestrationFinished:Connect(function(endedSceneName)
	if endedSceneName == "PreShow" then
		-- "PreShow" zakończony; załaduj pierwszą scenę koncertu
		SekwencjonatorZdarzeń.loadScene("Track1")
	elseif endedSceneName == "Track1" then
		-- "Track1" zakończony; załaduj drugą scenę koncertu
		SekwencjonatorZdarzeń.loadScene("Track2")
	else
		-- Powracaj do sceny przerywnikowej
		SekwencjonatorZdarzeń.loadScene("PreShow")
	end
end)

createSchema

Zwraca instancję schematu sceny schema do stworzenia logiki dla danej sceny.

Klient - Schemat
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

local Schemat = SekwencjonatorZdarzeń.createSchema()

Schemat.OnSetup = function(timePositionObject)
	print("OnSetup (Klient)")
end

seek

Przeszukuje do wartości time, w sekundach, od początku aktualnie załadowanej sceny.

Skrypt
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

SekwencjonatorZdarzeń.seek(95.58)

setSceneWarningTime

Ustala ilość czasu od końca wszystkich scen, w którym wysyłane jest ostrzeżenie. Możesz wykryć ostrzeżenie zarówno po stronie klienta za pomocą onSceneEndingWarningForClient, jak i po stronie serwera za pomocą onSceneEndingWarningForServer.

Skrypt
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

-- Załaduj scenę
SekwencjonatorZdarzeń.loadScene("BeautifulScene")

-- Ustaw czas ostrzeżenia na 5 sekund przed zakończeniem sceny
SekwencjonatorZdarzeń.setSceneWarningTime(5)

-- Wykryj, kiedy scena ma się zakończyć
SekwencjonatorZdarzeń.onSceneEndingWarningForServer:Connect(function()
	warn("Scena ma się zakończyć!")
end)

setSeekingPermissions

Przyznaje uprawnienia do przeszukiwania w oparciu o PlaceId wydarzenia, a także konkretne UserIds i/lub grupy oraz role w ich obrębie. Zobacz szukaj i przełączaj sceny po więcej informacji.

getCurrentSceneEnvironment

Zwraca klientowe lub serwerowe foldery Środowiska bieżącej sceny, w zależności od tego, czy jest wywoływana z modułu Klient czy Serwer.

Klient - Schemat
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

local Schemat = SekwencjonatorZdarzeń.createSchema()

local środowiskoKlienta
local środowiskoSerwera

Schemat.OnSetup = function(timePositionObject)
	print("OnSetup (Klient)")

	-- Uzyskanie dostępu do środowisk sceny; nie dotyczy Trybu Wbudowanego
	środowiskoKlienta = SekwencjonatorZdarzeń.getCurrentSceneEnvironment()
	środowiskoSerwera = SekwencjonatorZdarzeń.getCurrentServerEnvironmentFromClient()

	print("Aktualny czas to:", timePositionObject.Value)
end

Serwer - Schemat
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

local Schemat = SekwencjonatorZdarzeń.createSchema()

local środowiskoSerwera
local connectionKolorCzęści
local changePartColorEvent = script.Parent.Events.ChangePartColor

Schemat.OnSetup = function(timePositionObject)
	print("OnSetup (Serwer)")

	-- Uzyskanie dostępu do środowiska sceny; nie dotyczy Trybu Wbudowanego
	środowiskoSerwera = SekwencjonatorZdarzeń.getCurrentSceneEnvironment()

	connectionKolorCzęści = changePartColorEvent.OnServerEvent:Connect(function(player, zmienionaCzęść, nowyKolor)
		środowiskoSerwera.zmienionaCzęść.Color = nowyKolor
	end)
end

getCurrentServerEnvironmentFromClient

Zwraca bieżący serwerowy folder Środowiska danej sceny. W przeciwieństwie do getCurrentSceneEnvironment, możesz to wywołać z modułu Klient.

Klient - Schemat
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

local Schemat = SekwencjonatorZdarzeń.createSchema()

local środowiskoKlienta
local środowiskoSerwera

Schemat.OnSetup = function(timePositionObject)
	print("OnSetup (Klient)")

	-- Uzyskanie dostępu do środowisk sceny; nie dotyczy Trybu Wbudowanego
	środowiskoKlienta = SekwencjonatorZdarzeń.getCurrentSceneEnvironment()
	środowiskoSerwera = SekwencjonatorZdarzeń.getCurrentServerEnvironmentFromClient()

	print("Aktualny czas to:", timePositionObject.Value)
end

isLoadingScene

Wywoływane z serwera, aby dowiedzieć się, czy scena jest aktualnie ładowana.

Skrypt
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

print(SekwencjonatorZdarzeń.isLoadingScene())

while SekwencjonatorZdarzeń.isLoadingScene() do
	task.wait()
end
print("Scena załadowana")

Zdarzenia

onSceneEndingWarningForClient

Uruchamia się na kliencie przed zakończeniem sceny. Domyślny czas wynosi 3 sekundy, ale możesz dostosować go poprzez setSceneWarningTime. To zdarzenie można połączyć tylko w LocalScript.

LocalScript
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

-- Zdetectuj, kiedy scena ma się zakończyć (po stronie klienta)
SekwencjonatorZdarzeń.onSceneEndingWarningForClient:Connect(function()
	warn("Scena ma się zakończyć!")
end)

onSceneEndingWarningForServer

Uruchamia się na serwerze przed zakończeniem sceny. Domyślny czas wynosi 3 sekundy, ale możesz dostosować go poprzez setSceneWarningTime. To zdarzenie można połączyć tylko w Script.

Skrypt
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

-- Zdetectuj, kiedy scena ma się zakończyć (po stronie serwera)
SekwencjonatorZdarzeń.onSceneEndingWarningForServer:Connect(function()
	warn("Scena ma się zakończyć!")
end)

onSceneLoadedForClient

Uruchamia się na kliencie, gdy scena zaczyna. To zdarzenie można połączyć tylko w LocalScript.

LocalScript
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

-- Zdetectuj, kiedy scena się zaczyna (po stronie klienta)
SekwencjonatorZdarzeń.onSceneLoadedForClient:Connect(function()
	warn("Scena się zaczyna!")
end)

onOrchestrationFinished

Uruchamia się na serwerze, gdy scena osiągnęła swoją długość czasową i skutecznie się zakończyła. To zdarzenie otrzymuje argument typu string endedSceneName dla sceny, która właśnie się zakończyła, i można wywołać to zdarzenie, aby warunkowo załadować inną scenę. Może być połączone tylko w Script.

Skrypt
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SekwencjonatorZdarzeń = require(ReplicatedStorage:WaitForChild("SekwencjonatorZdarzeń"))

-- Dowiedz się, jaką następną scenę załadować po zakończeniu bieżącej sceny
SekwencjonatorZdarzeń.onOrchestrationFinished:Connect(function(endedSceneName)
	if endedSceneName == "PreShow" then
		-- "PreShow" zakończony; załaduj pierwszą scenę w koncertach
		SekwencjonatorZdarzeń.loadScene("Track1")
	elseif endedSceneName == "Track1" then-- "Track1" zakończony; załaduj drugą scenę w koncercie
		EventSequencer.loadScene("Track2")
	else
		-- Powróć do sceny przed występem
		EventSequencer.loadScene("PreShow")
	end
end)