Szablon klubu komediowego typu stand-up

Ten samouczek jest dokumentem uzupełniającym do szablonu stand-upu w Verse i zaprezentowano w nim sposób wykorzystania urządzeń wzmacniających doświadczenia społeczno-kinowe w klubie komediowym:

• Zastosowanie szczegółowych zasobów animatora MetaHumans z urządzeniami postaci

• Wyzwalanie zdarzeń rozgrywki przy użyciu powiązanych sygnałów wysyłanych przez gracza poprzez sterowanie za pomocą urządzeń wyzwalania sterowaniem

• Blokowanie gracza na miejscu, aby mógł obserwować przygodę, za pomocą urządzenia siedziska

Urządzenie Verse odpowiada za przebieg występu, a kluczowe zagadnienia związane z kodem Verse zostały objaśnione poniżej.

Sam szablon stand-upu w Verse można znaleźć w sekcji Wyróżnione przykłady w UEFN (Unreal Editor dla Fortnite).

Używane urządzenia:

• 1 x siedzisko

• 4 x urządzenie wyzwalania sterowaniem

• 4 x postać

• 6 x sekwencja filmowa

Elementy Verse wykorzystywane w tym samouczku:

• Subskrypcje

• Instrukcje if

• Tablice

• Sekwencje filmowe

• Interfejs API urządzenia siedziska

• Interfejs API urządzenia wyzwalania sterowaniem

Ustawienia Wyspy

Poniżej zaprezentowano zmodyfikowane ustawienia wyspy dla szablonu stand-upu w Verse:

Urządzenie siedziska

Gdy gracz wchodzi do klubu komediowego, widzi siedzisko przed podświetloną sceną. Pojawia się monit, aby gracz zajął miejsce na tym siedzisku. Gdy gracz usiądzie, siedzisko zablokuje go w stałej lokalizacji i uruchomi łańcuch zdarzeń, które przeprowadzą gracza przez pozostałą część przygody.

Poniżej zaprezentowano zmodyfikowane Opcje użytkownika dla urządzenia siedziska:

Urządzenia wyzwalania sterowaniem

Urządzenie wyzwalania sterowaniem dodawane jest razem z urządzeniem siedziska. Umożliwia ono powiązanie sygnałów wejściowych gracza z różnymi czynnościami wyzwalanymi za każdym razem, gdy gracz naciśnie przypisany przycisk. Urządzenia wyzwalania sterowaniem zostały skonfigurowane tak, aby umożliwić graczowi zmienianie kamer w trakcie występu.

Urządzenie posiada dwanaście dostępnych wejść do wyboru. Po wybraniu wejścia można dodać opis wyświetlany na HUD, aby wyjaśnić, jaka jest funkcja tego wejścia.

Poniżej zaprezentowano zmodyfikowane Opcje użytkownika dla tego urządzenia. Każde z urządzeń będzie miało inne powiązanie oraz inny opis HUD, ponieważ są one powiązane z różnymi urządzeniami sekwencji filmowej.

Urządzenia postaci

Urządzenia postaci umożliwiają bezpośrednią interakcję z graczem lub z innymi postaciami w scenie. Ten szablon wykorzystuje cztery postacie, które na zmianę będą realizować program na scenie.

Poniżej zaprezentowano zmodyfikowane Opcje użytkownika dla urządzenia postaci:

Postać główna siedzi na schodach za kulisami, a pozostałe postacie oczekują w niewielkim pomieszczeniu na tyłach.

Wypróbuj różne skórki postaci z menu rozwijanego Postać i sprawdź, jak będą się prezentować na scenie!

Urządzenia sekwencji filmowej

Za pomocą sześciu urządzeń sekwencji filmowej gracz może wyświetlać występy pod różnymi kątami, nie wstając z urządzenia siedziska.

Ta strona nie zawiera szczegółowego omówienia sposobu tworzenia sekwencji filmowych. Więcej informacji można znaleźć na stronie Sequencer i Control Rig, a szczegółowe instrukcje zawiera dokument Jak tworzyć filmy w Unreal Engine.

Jedyną modyfikacją w przypadku tego urządzenia jest załadowana sekwencja filmowa.

Jak Verse realizuje występ

W tym szablonie wykorzystano Verse do uruchomienia występu, w trakcie którego gracz siedzi na urządzeniu siedziska i może zmienić ustawienie swojej kamery na widok filmowy nazywany trybem telewizyjnym. Umożliwia również graczowi przełączanie między wieloma kamerami, a także powrót do Trybu telewizyjnego lub Swobodnego rozglądania się, aby zmienić sposób obserwacji.

Za pomocą Eksploratora Verse utwórz nowe urządzenie Verse o nazwie show_template_device.verse w swoim projekcie i przeciągnij je do szablonu. Kliknij dwukrotnie swój plik Verse, aby otworzyć go w Visual Studio Code.

Skonfigurowaliśmy już w twoim szablonie urządzenia, które pomocą zrealizować występ stand-upowy, a teraz utworzysz do nich odwołania w swoim kodzie.

Dodaj do pliku show_template_device następujące pola:

1. Najpierw nad definicją klasy show_template_device dodaj log_channel o nazwie log_show_template_device.

   Verse

        # Create a custom log channel for the show_template_device. This helps with log filtering in complex games with lots of log sources.
        log_show_template_device := class(log_channel){}
   		
        # A Verse-authored creative device that can be placed in a level
        show_template_device := class(creative_device):
   

   Copy full snippet(5 lines long)

2. Teraz w górnej części definicji klasy show_template_device dodaj rejestrator korzystający z kanału log_show_template_device, aby móc stwierdzić, które instrukcje Print() napływają z tego urządzenia.

   Verse

        # A Verse-authored creative device that can be placed in a level
        show_template_device := class(creative_device):
   		
            # Logger that uses custom log channel.
            Logger:log = log{Channel := log_show_template_device}
   

   Copy full snippet(5 lines long)

3. Edytowalne urządzenie siedziska o nazwie TheChair. Jest to siedzisko, na którym gracze będą zasiadali, aby rozpocząć występ stand-upowy.

   Verse

        # The chair device the player should sit in.
        @editable
        TheChair:chair_device = chair_device{}
   

   Copy full snippet(3 lines long)

4. Dwa edytowalne urządzenia sekwencji filmowej o nazwie MainSequence i TVModeSequence. MainSequence jest sekwencją filmową odpowiedzialną za realizację występu stand-upowego poprzez sterowanie animacją i dźwiękiem urządzenia postaci w poziomie. TVModeSequence przełącza kamerę gracza na tryb oglądania, który śledzi sekwencję MainSquence, przełączając widok między różnymi kątami.

   Verse

        # The sequence that drives animation and audio on the character device in the level.
        @editable
        MainSequence:cinematic_sequence_device = cinematic_sequence_device{}
        # The sequence that drives the TV mode sequence for viewing in the level.
        @editable
        TVModeSequence:cinematic_sequence_device = cinematic_sequence_device{}
   

   Copy full snippet(6 lines long)

5. Edytowalna tablica cinematic_sequence_device o nazwie CameraSwitches. Tablica ta zawiera odwołania do każdej z kamer, między którymi gracze mogą przełączać się w trakcie występu.

   Verse

        # A list of alternative camera sequences that are provided to view from during the main sequence.
        @editable
        CameraSwitches:[]cinematic_sequence_device = array{}
   

   Copy full snippet(3 lines long)

6. Cztery edytowalne urządzenia input_trigger_device. Każde z tych urządzeń reaguje na sygnały wejściowe gracza, przełączając między różnymi trybami kamer. Wyzwalacz ReturnToFreeLook pozwala graczowi wrócić do kamery domyślnej, natomiast ReturnToTVMode umożliwia powrót do sekwencji TVModeSequence. Przełączniki kamer NextCamera i PreviousMode umożliwiają graczowi przełączanie między różnymi sekwencjami filmowymi z tablicy CameraSwitches.

   Verse

        # An input trigger that will return us to free look while in the chair.
        @editable
        ReturnToFreeLook:input_trigger_device = input_trigger_device{}
   		
        # An input trigger that will return us to TV mode when appropriate in the chair.
        @editable
        ReturnToTVMode:input_trigger_device = input_trigger_device{}
   		
        # An input trigger that will choose the next camera while in the chair.
        @editable
   
   Expand code Copy full snippet(15 lines long)

7. Opcjonalna zmienna urządzenia sekwencji filmowej o nazwie CurrentSequence. W trakcie odtwarzania sekwencji filmowej, takiej jak TVModeSequence, w tej opcji przechowywane jest odwołanie do tej sekwencji. Odtwarzanie wielu sekwencji filmowych dla postaci równocześnie nie jest pożądane, dlatego za pomocą tej opcji wyłączyć bieżącą sekwencję po przełączeniu na nową.

   Verse

        # The alternative camera sequence that is playing if valid.
        var CurrentSequence:?cinematic_sequence_device = false
   

   Copy full snippet(2 lines long)

8. Dwie zmienne logiczne o nazwie MainSequencePlaying i InTvMode. Umożliwiają śledzenie, kiedy odtwarzana jest sekwencja MainSequence lub TVModeSequence.

   Verse

        # Helps us track when the main sequence on the character device is playing.
        var MainSequencePlaying:logic = false
   		
        # When we are in TV mode.
        var InTVMode:logic = false
   

   Copy full snippet(5 lines long)

9. Zmienna typu liczba całkowita (int) o nazwie CurrentCameraIndex. Pozwala ona śledzić indeks sekwencji filmowej w aktualnie odtwarzanej tablicy CameraSwitches.

   Verse

        # Keeps track of what camera we are viewing when using other cameras besides TV Mode.
        var CurrentCameraIndex:int = -1
   

   Copy full snippet(2 lines long)

10. Pięć opcjonalnych zmiennych cancelable, które śledzą subskrypcje wszystkich zdarzeń, do których istnieją odwołania w tym szablonie. Konieczne jest uruchamianie różnych funkcji, gdy gracz przełącza się między kamerami, wraca do trybu swobodnego rozglądania się lub trybu telewizyjnego bądź opuszcza urządzenie siedziska. W dalszej części tego samouczka zasubskrybujesz dla funkcji zdarzenia, które je wyzwalają, a następnie zapiszesz odwołanie do każdej subskrypcji, aby móc je anulować, gdy przestaną być potrzebne.

    Verse

         # Subscriptions to all the events we listen for while running.
         var ReturnToFreeLookSubscription:?cancelable = false
         var NextCameraSubscription:?cancelable = false
         var PrevCameraSubscription:?cancelable = false
         var ReturnToTVModeSubscription:?cancelable = false
         var ChairExitSubscription:?cancelable = false
    

    Copy full snippet(6 lines long)

11. Zapisz skrypt w Visual Studio Code i skompiluj go, aby zaktualizować swoje urządzenie utworzone w Verse w poziomie.

12. Wybierz show_template_device w swoim szablonie. W panelu Szczegóły przypisz odwołanie do każdego urządzenia w swoim skrypcie do powiązanego z nim urządzenia w poziomie, uwzględniając każde z urządzeń wyzwalania sterowaniem i każdą z sekwencji filmowych.

    

Aktywowanie sekwencji

Występ zaczyna się, gdy gracz zasiada na urządzeniu siedziska, więc sekwencja filmowa powinna się rozpoczynać, gdy gracz usiądzie. Wykonaj poniższe kroki, aby wyzwolić sekwencję główną, gdy gracz zajmie miejsce na siedzisku, a także uruchomić tryb telewizyjny, aby gracz mógł oglądać występ.

1. Dodaj nową funkcję RunSequence() do klasy show_template_device. Ta funkcja pobiera agenta, który rozpoczął występ i uruchamia sekwencje MainSequence oraz TVModeSequence. Dodaj modyfikator do funkcji RunSequence(), aby umożliwić jej wykonywanie asynchroniczne. Funkcja ta musi być asynchroniczna, aby można było współbieżnie z nią uruchomić inny kod, umożliwiając graczowi przełączanie między widokami kamer bez przerywania kodu RunSequence().

   Verse

        # Handles running the main sequence which runs the character and TV mode sequences for viewing and then calls a function to await finishing.
        RunSequence(Agent:agent)<suspends>:void =

   Copy full snippet(2 lines long)

2. W funkcji RunSequence(), wywołaj Sleep() na sekundę, aby umożliwić zakończenie animacji gracza zajmującego siedzisko przed uruchomieniem występu. Następnie wywołaj Play() dla sekwencji MainSequence, a dla MainSequencePlaying ustaw wartość true.

   Verse

        # Sleep for a second because we just entered the chair and the animation to sit takes a moment.
        Sleep(1.0)
   		
        # Run the Main sequence on the character device and the TV mode viewing sequence.
        Logger.Print("Main Sequence Playing")
        set MainSequencePlaying = true
        MainSequence.Play()
   

   Copy full snippet(7 lines long)

3. Wywołaj Play() dla TVModeSequence, przekazując agenta, który rozpoczął występ w celu zmiany jego kamery na widok filmowy. Ustaw dla InTVMode wartość true, a następnie wywołaj nową funkcję o nazwie AwaitMainSequenceEnding() oczekującą na zakończenie sekwencji MainSequence, przekazując agenta. Skonfigurujesz tę funkcję w kolejnym kroku. Gotowy kod funkcji RunSequence() powinien wyglądać następująco:

   Verse

        # Handles running the main sequence which runs the character and TV mode sequences for viewing and then calls a function to await finishing.
        RunSequence(Agent:agent)<suspends>:void =
   
            # Sleep for a second because we just entered the chair and the animation to sit takes a moment.
            Sleep(1.0)
   
            # Run the Main sequence on the character device and the TV mode viewing sequence.
            Logger.Print("Main Sequence Playing")
            set MainSequencePlaying = true
            MainSequence.Play()
   
   Expand code Copy full snippet(16 lines long)

4. Dodaj do klasy show_template_device nową funkcję AwaitMainSequecingEnding(), która pobiera element agent z funkcji RunSequence(). Funkcja ta również wymaga zastosowania modyfikatora <suspends>, ponieważ ma być wykonywana w tle i wyzwalana, gdy zakończy się sekwencja MainSequence.

   Verse

        # When the main sequence finishes, we clear the flag so that if the player sits back down, it will play again.
        AwaitMainSequencingEnding(Agent:agent)<suspends>:void =

   Copy full snippet(2 lines long)

5. W funkcji AwaitMainSequencingEnding() wywołaj Await() dla MainSequence.StoppedEvent(). Gdy MainSequence się zakończy, ustaw dla MainSequencePlaying wartość false i wymuś na graczu powstanie z siedziska za pomocą funkcji Eject(). Gotowa funkcja AwaitMainSequencingEnding() powinna wyglądać następująco:

   Verse

        # When the main sequence finishes, we clear the flag so that if the player sits back down, it will play again.
        AwaitMainSequencingEnding(Agent:agent)<suspends>:void =
            MainSequence.StoppedEvent.Await()
            Logger.Print("Main Sequence Ended")
            set MainSequencePlaying = false
   
            # Kick the player out of the chair after the performance
            TheChair.Eject(Agent)

   Copy full snippet(8 lines long)

6. Dodaj dwie nowe funkcje DoReturnToTVMode() i DoReturnToFreeLook() do klasy show_template_device. Funkcje te obsługują logikę sytuacji, w których gracz powraca odpowiednio do trybu telewizyjnego lub trybu swobodnego rozglądania się, jednak na ten moment pozostaną one puste i uzupełnisz je na dalszym etapie.

   Verse

        # Returns us to our TV viewing mode sequence by checking where the main sequence is and aligning our playback to that point.
        DoReturnToTVMode(Agent:agent):void =
            Logger.Print("Return to TV Mode")
   		
        # Determine if we are in TV mode or another camera sequence and return control to the main player camera.
        DoReturnToFreeLook(Agent: agent):void =
            Logger.Print("Return to Free Look")
   

   Copy full snippet(7 lines long)

7. Dodaj do klasy show_template_device nową funkcję OnSeated(), która pobiera agenta zajmującego TheChair.

   Verse

        # This function handles the player sitting down and starting up the performance if it isn't already running and setting up the input triggers.
        OnSeated(Agent:agent):void =
            Logger.Print("Player sat down")
   

   Copy full snippet(3 lines long)

8. Jeśli sekwencja MainSequence nie jest jeszcze odtwarzana, wygeneruj w OnSeated() funkcję RunSequence(), przekazując agenta, który usiadł w urządzeniu siedziska. W przeciwnym razie wywołaj DoReturnToTVMode(), uwzględniając tego samego agenta.

   Verse

        # This function handles the player sitting down and starting up the performance if it isn't already running and setting up the input triggers.
        OnSeated(Agent:agent):void =
            Logger.Print("Player sat down")
   		
            # If the main sequence is not playing on the character device in the level, run it, otherwise if it is running then just return to the TV mode viewing experience.
            if (MainSequencePlaying = false):
                spawn{RunSequence(Agent)}
            else:
                DoReturnToTVMode(Agent)
   

   Copy full snippet(9 lines long)

9. Dodaj do klasy show_template_device nową funkcję OnChairExited() pobierającą gracza, który wstał z siedziska. Logikę tej funkcji uzupełnisz na dalszym etapie.

   Verse

        # Handles the player leaving the chair and removing access to the input triggers that are available while in the chair.
        OnChairExited(Agent:agent):void =
            Logger.Print("Player got up")
   

   Copy full snippet(3 lines long)

10. W funkcji OnBegin() zasubskrybuj zdarzenie TheChair.SeatedEvent do funkcji OnSeated(). Teraz za każdym razem, gdy gracz usiądzie na siedzisku TheChair, występ będzie uruchamiany.

    Verse

         # Runs when the device is started in a running game.
         OnBegin<override>()<suspends>:void =
             Logger.Print("Standup Template device started")
             TheChair.SeatedEvent.Subscribe(OnSeated)

    Copy full snippet(4 lines long)

Zapisz skrypt w Visual Studio Code, skompiluj go, a następnie na pasku narzędzi UEFN kliknij opcję Uruchom sesję, aby przetestować szablon w grze. Po uruchomieniu gry zajęcie miejsca na urządzeniu siedziska powinno spowodować rozpoczęcie występu i ustawienie dla kamery gracza trybu filmowego. Po zakończeniu występu program powinien wymusić powstanie gracza z siedziska.

Przełączanie kamer

W trakcie występu gracz zajmujący siedzisko TheChair może przełączać między różnymi widokami kamery obsługiwanymi przez różne sekwencje filmowe. Wykonaj poniższą procedurę, aby skonfigurować logikę przełączania między tymi różnymi sekwencjami.

1. Dodaj nową funkcję DoCameraSwitch() do klasy show_template_device. Funkcja ta pobiera agenta, którego kamera będzie przełączana, a także ciąg int odpowiadający indeksowi sekwencji filmowej w tablicy CameraSwitches.

   Verse

        # Switches us between camera sequences that have been specified by stopping any current ones and moving to the next appropriate one on the list.
        DoCameraSwitch(Agent:agent, Value:int):void =
   

   Copy full snippet(2 lines long)

2. W wyrażeniu if w DoCameraSwitch() pobierz sekwencję filmową pod indeksem Value w tablicy CameraSwitches. Następnie zatrzymaj wszelkie odtwarzane aktualnie sekwencje filmowe, sprawdzając, czy parametr CurrentSequence zawiera sekwencję filmową i wywołując dla niego Stop().

   Verse

        # Switches us between camera sequences that have been specified by stopping any current ones and moving to the next appropriate one on the list.
        DoCameraSwitch(Agent:agent, Value:int):void =
            if (CameraSwitch := CameraSwitches[Value]):
                Logger.Print("Switching Cameras to {Value}")
   		
                # Stop any currently playing other camera sequence.
                if (PlayingSequence := CurrentSequence?):
                    PlayingSequence.Stop(Agent)
   

   Copy full snippet(8 lines long)

3. Rozpocznij odtwarzanie nowej sekwencji filmowej, wywołując Play() dla CameraSwitch. Następnie ustaw CurrentSequence tak, aby wskazywana była aktualnie odtwarzana sekwencja. Na końcu wywołaj Register() dla agenta agent, którego kamera jest przełączana, wykorzystując urządzenia wyzwalania sterowaniem ReturnToTVMode i ReturnToFreeLook, aby umożliwić powrót do tych trybów podczas wyświetlania innych kamer. Gotowa funkcja DoCameraSwitch() powinna wyglądać następująco:

   Verse

        # Switches us between camera sequences that have been specified by stopping any current ones and moving to the next appropriate one on the list.
        DoCameraSwitch(Agent:agent, Value:int):void =
            if (CameraSwitch := CameraSwitches[Value]):
                Logger.Print("Switching Cameras to {Value}")
   		
                # Stop any currently playing other camera sequence.
                if (PlayingSequence := CurrentSequence?):
                    PlayingSequence.Stop(Agent)
   		
                # Start up the new camera viewing sequence.
   
   Expand code Copy full snippet(16 lines long)

4. Do przełączania między kolejną a poprzednią kamerą skonfigurujesz dwie bardzo podobne funkcje DoNextCamera() i DoPreviousCamera(). Najpierw uzupełnisz logikę funkcji wyboru kolejnej kamery, więc dodaj nową funkcję DoNextCamera() do klasy show_template_device. Funkcja ta pobiera agenta agent, którego kamera będzie przełączana.

   Verse

        # Switches to the next camera on our list, or the first if we are in TV mode.
        DoNextCamera(Agent:agent):void =
            Logger.Print("Next Camera")
   

   Copy full snippet(3 lines long)

5. W DoNextCamera() sprawdź, czy gracz korzysta obecnie z trybu telewizyjnego. Jeśli tak, wykonaj Stop() dla TVModeSequence, ustaw dla InTVMode wartość false, a dla CurrentCameraIndex ustaw wartość -1. Konieczna jest tutaj wartość -1, ponieważ chcesz przejść w indeksie do kolejnej sekwencji filmowej z tablicy CameraSwitches, która miałaby wartość 0.

   Verse

        # If we are currently viewing from TV Mode, end that sequence and clear associated values.
        if (InTVMode?):
            TVModeSequence.Stop(Agent)
            set InTVMode = false
            set CurrentCameraIndex = -1
   

   Copy full snippet(5 lines long)

6. Następnie musisz ustalić, która kamera będzie kolejną na liście przełączania, biorąc pod uwagę indeks bieżącej kamery. W tym celu ustaw dla nowej zmiennej NextCameraValue wartość Mod zmiennych CurrentCameraIndex + 1 oraz CameraSwitches.Length. Dzięki temu ograniczysz wartość NextCameraValue do wartości z przedziału od 0 do wartości długości CameraSwitches i uniemożliwisz uzyskanie wartości NextCameraValue wykraczającej poza tablicę CameraSwitches. Po ustawieniu wartości NextCameraValue, ustaw dla zmiennej CurrentCameraValue wartość NextCameraValue i wywołaj DoCameraSwitch(), przekazując element agent oraz CurrentCameraIndex. Gotowa funkcja DoNextCamera() powinna wyglądać następująco:

   Verse

        # Switches to the next camera on our list, or the first if we are in TV mode.
        DoNextCamera(Agent:agent):void =
            Logger.Print("Next Camera")
   		
            # If we are currently viewing from TV Mode, end that sequence and clear associated values.
            if (InTVMode?):
                TVModeSequence.Stop(Agent)
                set InTVMode = false
                set CurrentCameraIndex = -1
   		
   
   Expand code Copy full snippet(14 lines long)

7. Aby umożliwić przełączanie na poprzednią kamerę, dodaj nową funkcję o nazwie DoPreviousCamera() do klasy show_template_device. Skopiuj do tej funkcji kod z funkcji DoNextCamera(). Podczas sprawdzania, czy gracz korzysta z trybu telewizyjnego, ustaw dla CurrentCameraIndex wartość 0 zamiast -1. Zmień również wartość NextCameraValue na Mod zmiennych CurrentCameraIndex - 1 i CameraSwitches.Length. Gotowa funkcja DoPreviousCamera() powinna wyglądać następująco:

   Verse

        # Switches us to the previous camera on the list or last camera if we are leaving TV mode.
        DoPreviousCamera(Agent:agent):void =
            Logger.Print("Prev Camera")
   		
            # If we are currently viewing from TV Mode, end that sequence and clear associated values.
            if (InTVMode?):
                TVModeSequence.Stop(Agent)
                set InTVMode = false
                set CurrentCameraIndex = 0
   		
   
   Expand code Copy full snippet(14 lines long)

Gracz siedzący na siedzisku TheChair i oglądający występ z innej kamery w CameraSwitches może powrócić do trybu telewizyjnego lub swobodnego rozglądania się. Wcześniej skonfigurowaliśmy funkcje DoReturnToFreeLook() oraz DoReturnToTVMode(), a teraz je uzupełnimy.

1. W funkcji DoReturnToFreeLook() sprawdź, czy gracz jest obecnie w trybie telewizyjnym. Jeśli tak, wykonaj Stop() dla TVModeSequence i ustaw dla InTVMode wartość false. Zrób to samo z CurrentSequence, sprawdzając, czy CurrentSequence zawiera sekwencję filmową, wywołując Stop() i ustawiając wartość false w przypadku pozytywnego wyniku weryfikacji.

   Verse

        # If TV Mode is active, stop it.
        if (InTVMode?):
            TVModeSequence.Stop(Agent)
            set InTVMode = false
   		
        # If we are playing another viewing experience, stop it.
        if (TempSeq := CurrentSequence?):
            TempSeq.Stop(Agent)
            set CurrentSequence = false
   

   Copy full snippet(9 lines long)

2. Teraz wykonaj Register() dla agenta, wykorzystując urządzenie wyzwalania sterowaniem ReturnToTVMode, a następnie wykonaj dla niego Unregister() z użyciem wyzwalacza ReturnToFreeLook, aby gracz nie powracał do trybu swobodnego rozglądania się, jeśli już znajduje się w tym trybie. Gotowa funkcja DoReturnToFreeLook() powinna wyglądać następująco:

   Verse

        # Determine if we are in TV mode or another camera sequence and return control to the main player camera.
        DoReturnToFreeLook(Agent: agent):void =
            Logger.Print("Return to Free Look")
   		
            # If TV Mode is active, stop it.
            if (InTVMode?):
                TVModeSequence.Stop(Agent)
                set InTVMode = false
   		
            # If we are playing another viewing experience, stop it.
   
   Expand code Copy full snippet(17 lines long)

3. Funkcja DoReturnToTVMode() wymaga dodatkowej logiki, ponieważ przy powracaniu do trybu telewizyjnego trzeba uruchomić TVModeSequence w czasie bieżącym sekwencji MainSequence. Najpierw sprawdź, czy gracz jest już w trybie telewizyjnym w momencie wywołania tej funkcji. Jeśli tak, wykonaj return, ponieważ nie trzeba nic robić. Następnie sprawdź, czy CurrentSequence zawiera sekwencję filmową, wywołując Stop(), a w przypadku pozytywnego wyniku weryfikacji ustawiając wartość false.

   Verse

        # If we are already in TV mode no need to return to it.
        if (InTVMode?):
            return
   		
        # If we have another camera sequence playing, stop it and clear associated values.
        if (TempSeq := CurrentSequence?):
            TempSeq.Stop(Agent)
            set CurrentSequence = false
   

   Copy full snippet(8 lines long)

4. Teraz musisz ustalić, na jakim etapie odtwarzania jest MainSequence i rozpocząć odtwarzanie TVModeSequence od tego miejsca. Pobierz czas odtwarzania MainSequence, wywołując GetPlayBackTime(), i zapisz wartość w zmiennej CurrentSeekTime. Ustaw czas odtwarzania TVModeSequence na CurrentSeekTime, wykorzystując SetPlaybackTime(), a następnie wykonaj Play() dla sekwencji, przekazując agenta. Następnie ustaw dla InTVMode wartość true.

   Verse

        # Figure out where the main sequence is in its playback and start up the TV mode sequence at the same spot to provide the proper viewing experience.
        CurrentSeekTime := MainSequence.GetPlaybackTime()
        TVModeSequence.SetPlaybackTime(CurrentSeekTime)
        TVModeSequence.Play(Agent)
        set InTVMode = true
   

   Copy full snippet(5 lines long)

5. Na końcu wykonaj Unregister(), aby wyrejestrować agenta z urządzenia wyzwalania sterowaniem ReturnToTVMode, po czym wykonaj Register() dla agenta z użyciem wyzwalacza ReturnToFreeLook. Gotowa funkcja DoReturnToTVMode() powinna wyglądać następująco:

   Verse

        # Returns us to our TV viewing mode sequence by checking where the main sequence is and aligning our playback to that point.
        DoReturnToTVMode(Agent:agent):void =
            Logger.Print("Return to TV Mode")
   		
            # If we are already in TV mode no need to return to it.
            if (InTVMode?):
                return
   		
            # If we have another camera sequence playing, stop it and clear associated values.
            if (TempSeq := CurrentSequence?):
   
   Expand code Copy full snippet(22 lines long)

Łączenie wszystkiego razem

W poprzedniej części tego samouczka skonfigurowaliśmy mnóstwo funkcji. Teraz czas połączyć je wszystkie z różnymi urządzeniami aktywacji sterowaniem, które je wywołują.

1. W OnSeated() wykonaj Register() dla agenta z użyciem urządzeń wyzwalania sterowaniem ReturnToFreeLook, NextCamera oraz PreviousCamera, ponieważ są to wyzwalacze, do których gracz będzie miał początkowo dostęp, gdy zajmie miejsce na siedzisku. Następnie ustaw ReturnToFreeLookSubscription, NextCameraSubscription i PreviousCameraSubscription, subskrybując dla każdego urządzenia wyzwalania sterowaniem powiązaną z nim funkcję. W ten sam sposób ustaw ReturnToTVModeSubscription i ChairExitSubscription.

   Verse

        # Register for the input trigger for free look and subscribe to the pressed event when sitting.
        ReturnToFreeLook.Register(Agent)
        set ReturnToFreeLookSubscription = option{ReturnToFreeLook.PressedEvent.Subscribe(DoReturnToFreeLook)}
   		
        # Register for the input trigger for the next camera and subscribe to the pressed event when sitting.
        NextCamera.Register(Agent)
        set NextCameraSubscription = option{NextCamera.PressedEvent.Subscribe(DoNextCamera)}
   		
        # Register for the input trigger for the previous camera and subscribe to the pressed event when sitting.
        PreviousCamera.Register(Agent)
   
   Expand code Copy full snippet(17 lines long)

2. Dodaj do klasy show_template_device nową funkcję CancelSubscription(), która przyjmuje opcjonalną wartość, którą można anulować. W CancelSubscription() sprawdź, czy Subscription zawiera wartość. Jeśli tak, wykonaj Cancel() dla tej subskrypcji. Gotowa funkcja CancelSubscription() powinna wyglądać następująco:

   Verse

        # Cancel a subscription if it is valid.
        CancelSubscription(Subscription:?cancelable):void =
            if (SubscriptionToCancel := Subscription?):
                SubscriptionToCancel.Cancel()
   

   Copy full snippet(4 lines long)

3. Gdy gracz opuszcza siedzisko, musisz zatrzymać wszelkie sekwencje odtwarzane w danej chwili na odtwarzaczu, a także anulować wszelkie subskrypcje urządzeń aktywacji sterowaniem, w których gracz był zarejestrowany. W funkcji OnChairExited(), podobnie jak w DoReturnToFreeLook(), sprawdź, czy gracz jest w trybie telewizyjnym, a także czy CurrentSequence zawiera sekwencję filmową. Jeśli tak, wywołaj Stop() dla każdej sekwencji, a jeśli gracz jest w trybie telewizyjnym, ustaw dla InTVMode wartość false. Następnie ustaw dla CurrentSequence wartość false.

   Verse

        # Stop the TV camera view when we leave the chair if it is active.
        if (InTVMode = true):
            TVModeSequence.Stop(Agent)
            set InTVMode = false
   		
        # Stop the camera sequence we were using if it is active when we leave the chair.
        if (TempSeq := CurrentSequence?):
            TempSeq.Stop(Agent)
   		
        # Clear whatever the current sequence was when we leave the chair.
   
   Expand code Copy full snippet(11 lines long)

4. Teraz anuluj wszystkie subskrypcje gracza, przekazując każdą subskrypcję do funkcji CancelSubscription(). Ponadto wykonaj Unregister(), aby wyrejestrować gracza z każdego urządzenia wyzwalania sterowaniem, ponieważ po opuszczeniu siedziska nie powinien mieć dostępu do tych przycisków. Gotowa funkcja OnChairExited() powinna wyglądać następująco:

   Verse

        # Handles the player leaving the chair and removing access to the input triggers that are available while in the chair.
        OnChairExited(Agent:agent):void =
            Logger.Print("Player got up")
   		
            # Stop the TV camera view when we leave the chair if it is active.
            if (InTVMode = true):
                TVModeSequence.Stop(Agent)
                set InTVMode = false
   		
            # Stop the camera sequence we were using if it is active when we leave the chair.
   
   Expand code Copy full snippet(28 lines long)

Zapisz skrypt w Visual Studio Code, skompiluj go, a następnie na pasku narzędzi UEFN kliknij opcję Uruchom sesję, aby przetestować szablon w grze. W trakcie testu gry zajęcie przez gracza miejsca w urządzeniu siedziska powinno spowodować rozpoczęcie występu. W trakcie występu gracz powinien mieć możliwość przełączania między trybem telewizyjnym, trybem swobodnego rozglądania się oraz wieloma innymi kątami ustawienia kamer. Powrót do trybu telewizyjnego powinien powodować zsynchronizowanie sekwencji trybu telewizyjnego z sekwencją główną. Po zakończeniu występu powinien nastąpić powrót do trybu swobodnego rozglądania się, a program powinien wymusić powstanie gracza z siedziska.