Vorlage Stand-Up-Comedyclub

Dieses Tutorial ist ein Begleitdokument zur Verse Stand-Up-Vorlage, die zeigt, wie Geräte eingesetzt werden, die ein soziales und kinematografisches Erlebnis in einem Comedyclub bieten:

• Verwendung detaillierter MetaHuman-Animator-Assets mit den Charaktergeräten

• Auslösen von Gameplay-Events bei Spieler-Input-Bindungen mit Input-Trigger -Geräten

• Sperren eines Spielers an einer Position zum Ansehen der Erfahrung mit dem Stuhl-Gerät

Ein Verse-Gerät leitet die Show. Die Hauptkonzepte des Verse-Codes werden unten erläutert.

Die Verse-Stand-Up-Vorlage selbst findest du im Abschnitt **Funktionsbeispiele von UEFN (Unreal Editor für Fortnite).

Verwendete Geräte:

• 1 x Stuhl

• 4 x Input-Trigger

• 4 x Charakter

• 6 x Filmsequenz

Folgende Verse-Konzepte werden in diesem Tutorial verwendet:

• Abonnements

• If-Anweisungen

• Arrays

• Filmsequenzen

• Stuhlgerät-API

• Eingabeauslöser-Gerät-API

Inseleinstellungen

Dies sind die geänderten Inseleinstellungen für die Verse-Stand-Up-Vorlage:

Stuhlgerät

Wenn der Spieler den Comedyclub betritt, sieht er einen Stuhl vor einer beleuchteten Bühne. Er wird aufgefordert, sich auf diesen Stuhl zu setzen. Durch das Sitzen auf dem Stuhl bleibt der Spieler an einer festen Position und setzt die Ereigniskette in Bewegung, die ihn durch den Rest der Erfahrung führt.

Dies sind die geänderten Benutzeroptionen für das Stuhlgerät:

Eingabeauslöser-Geräte

Ein Input-Trigger -Gerät geht Hand in Hand mit dem Stuhlgerät. Es bindet die Spielereingaben an eine Vielzahl von Aktionen, die jedes Mal ausgelöst werden, wenn der Spieler die neu zugewiesene Taste drückt. Die Eingabeauslöser sind so konfiguriert, dass der Spieler die Kameras wechseln kann, während der Auftritt stattfindet.

Das Gerät umfasst zwölf verfügbare Eingaben, unter denen gewählt werden kann. Wenn du eine Eingabe gewählt hast, kannst du eine HUD-Beschreibung hinzufügen, um zu verdeutlichen, was die neue Eingabe macht.

Dies sind die geänderten Benutzeroptionen für dieses Gerät. Jedes der Geräte hat eine andere Bindung und HUD-Beschreibung, da sie an bestimmte Filmsequenz-Geräte gebunden sind.

Charaktergeräte

Die Charaktergeräte stellen eine Möglichkeit für dich dar, direkt mit dem Spieler oder mit anderen Charakteren in einer Szene zu interagieren. Diese Vorlage verwendet vier Charaktere, die sich während des Auftritts auf der Bühne abwechseln.

Dies sind die geänderten Benutzeroptionen für das Charaktergerät:

Der Hauptcharakter sitzt hinter der Bühne auf einer Treppe, die übrigen Charaktere warten in einem kleinen Raum im hinteren Bereich.

Experimentiere mit anderen Charakter-Skins aus dem Charakter-Dropdown-Menü und sieh dir an, wie sie auf der Bühne aussehen.

Filmsequenz-Geräte

Mit den sechs Filmsequenz-Geräten kann der Spieler sich die Vorstellung aus verschiedenen Winkeln ansehen, während er auf dem Stuhlgerät sitzt.

Diese Seite geht nicht detaillierter darauf ein, wie Filmsequenzen erstellt werden. Weitere Informationen findest du auf der Seite Sequencer und Control-Rig und eine ausführlichere Erläuterung findest unter So werden Filme in der Unreal Engine erstellt.

Die einzige Änderung für dieses Gerät ist die geladene Filmsequenz.

So regelt Verse alles

Diese Vorlage nutzt Verse, um die Vorstellung zu starten, wenn sich der Spieler auf das Stuhlgerät setzt, und seine Kamera zu der Filmansicht mit der Bezeichnung TV-Modus zu ändern. Der Spieler kann zwischen mehreren Kameras wechseln und für andere Betrachtungserfahrungen zum TV mode oder zu Free Look zurückkehren.

Erstelle in deinem Projekt ein neues Verse-Gerät mit der Bezeichnung show_template_device.verse und nutze dazu den [Verse-Explorer. Ziehe das Gerät in die Vorlage. Doppelklicke auf deine Verse-Datei, um sie in Visual Studio Code zu öffnen.

Du hast in deiner Vorlage Geräte eingerichtet, die den Ablauf der Stand-Up-Show unterstützen. Jetzt referenzierst du diese Gerät in deinem Code.

Füge die folgenden Felder zur Datei show_template_device hinzu:

1. Füge zunächst über der Definition der show_template_device-Klasse einen log_channel mit der Bezeichnung log_show_template_device hinzu.

   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. Füge jetzt oben in der Klassendefinition show_template_device einen Logger hinzu, der den Kanal log_show_template_device nutzt, damit du erkennst, welche Print()-Anweisungen von diesem Gerät kommen.

   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. Ein editierbares Stuhlgerät namens TheChair. Dies ist der Stuhl, auf den Spieler sich setzen, um die Stand-Up-Show zu starten.

   Verse

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

   Copy full snippet(3 lines long)

4. Zwei bearbeitbare Filmsequenz-Geräte mit der Bezeichnung MainSequence und TVModeSequence. MainSequence ist die Filmsequenz, die die Stand-Up-Show zeigt sowie die Animation und den Ton für das Charaktergerät im Level steuert. TVModeSequence schaltet die Kamera des Spielers zu einem Betrachtungsmodus um, der der MainSquence-Umschaltung zwischen verschiedenen Winkeln folgt.

   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. Ein editierbares Array von cinematic_sequence_device namens CameraSwitches. Dieses Array enthält Referenzen auf jede der Kameras, zu der die Spieler während der Show umschalten können.

   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. Vier bearbeitbare input_trigger_device. Jedes dieser Geräte nimmt Spielereingabe an, um zwischen verschiedenen Kameramodi zu wechseln. Der Trigger ReturnToFreeLook bringt den Spieler zur Standardkamera zurück, während ReturnToTVMode den Spieler zur TVModeSequence zurückbringt. Die Kamera NextCamera und PreviousMode schaltet den Spieler zwischen den verschiedenen Sequenzen im Array CameraSwitches um.

   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. Eine optionales Filmsequenz-Gerät-Variable mit dem Namen CurrentSequence. Wenn eine Filmsequenz wie TVModeSequence wiedergegeben wird, speichert diese Option eine Referenz darauf. Du möchtest für den Charakter nicht mehrere Filmsequenzen gleichzeitig wiedergeben. Daher kannst du mit dieser Option die aktuelle Sequenz ausschalten, wenn du zu einer neuen wechselst.

   Verse

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

   Copy full snippet(2 lines long)

8. Zwei logische Variablen namens MainSequencePlaying und InTvMode. Mit diesen kannst du nachverfolgen, wann MainSequence oder TVModeSequence wiedergegeben wird.

   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. Eine Variable vom Typ int namens CurrentCameraIndex. Diese verfolgt den Index der Filmsequenz im Array CameraSwitches nach, die aktuell wiedergegeben wird.

   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. Fünf optionale cancelable-Variablen, die Abonnements für alle Events verfolgen, die in dieser Vorlage referenziert werden. Wenn der Spieler zwischen Kameras umschaltet, zum freien Umschauen oder zum TV-Modus zurückkehrt oder das Stuhlgerät verlässt, müssen verschiedene Funktionen ausgeführt werden. In einem späteren Teil dieses Tutorials wirst du die Events, die sie auslösen, mit den Funktionen abonnieren und eine Referenz zu jedem Abonnement speichern, damit du sie abbrechen kannst, wenn sie nicht mehr benötigt werden.

    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. Speichere das Script in Visual Studio Code und kompiliere es, um dein in Verse erstelltes Gerät im Level zu aktualisieren.

12. Wähle das show_template_device in deiner Vorlage. Weise im Details-Panel jede Gerätreferenz in deinem Script dem zugeordneten Gerät im Level zu, einschließlich aller Eingabeauslöser und Filmsequenzen.

    

Auslösen der Sequenz

Die Show beginnt, wenn sich ein Spieler auf das Stuhlgerät setzt. Die Filmsequenz soll starten, sobald sich der Spieler hingesetzt hat. Befolge die unten aufgeführten Schritte, um die Hauptsequenz auszulösen, wenn sich ein Spieler auf den Stuhl setzt, und den TV-Modus zu starten, damit der Spieler zusehen kann.

1. Füge eine neue Funktion RunSequence() zur Klasse show_template_device hinzu. Diese Funktion nimmt den Agent entgegen, der die Show gestartet hat, und startet sowohl MainSequence als auch TVModeSequence. Füge den -Modifikator zu RunSequence() hinzu, damit es asynchron ausgeführt werden kann. Diese Funktion muss asynchron sein, damit du den übrigen Code gleichzeitig damit ausführen kannst, sodass der Spieler zwischen den Kameraansichten wechseln kann, ohne den RunSequence()-Code zu unterbrechen.

   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. Rufe in RunSequence() für eine Sekunde Sleep() auf, damit die Animation des Spielers, der auf dem Stuhl sitzt, abgeschlossen wird, bevor die Show beginnt. Rufe dann Play() auf MainSequence auf und setze MainSequencePlaying auf 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. Rufe Play() auf TVModeSequence auf und übergib den Agent, der die Show gestartet hat, um die Kamera zur Filmansicht zu ändern. Setze InTVMode auf True und rufe eine neue Funktion, die auf das Ende von MainSequence wartet, mit der Bezeichnung AwaitMainSequenceEnding() auf und übergib ihr den Agent. Du wirst diese Funktion im nächsten Schritt einrichten. Dein fertiger RunSequence()-Code sollte wie folgt aussehen:

   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. Füge eine neue Funktion AwaitMainSequecingEnding() zur Klasse show_template_device hinzu, die den agent von RunSequence() übernimmt. Diese Funktion benötigt ebenfalls den Modifikator <suspends>, da du möchtest, dass sie im Hintergrund läuft und ausgelöst wird, wenn MainSequence endet.

   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. Rufe in AwaitMainSequencingEnding() die Funktion Await() für das Ereignis MainSequence.StoppedEvent() auf. Wenn MainSequence endet, setze MainSequencePlaying auf false und wirf den Spieler mit der Funktion Eject() des Stuhls aus dem Stuhl. Deine fertige Funktion AwaitMainSequencingEnding() sollte wie folgt aussehen:

   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. Füge zwei neue Funktionen,DoReturnToTVMode() und DoReturnToFreeLook(), zur Klasse show_template_device hinzu. Diese Funktionen verarbeiten die Logik, wenn ein Spieler zum TV-Modus oder zum freien Umsehen zurückkehrt. Vorerst lässt du sie aber leer und füllst sie erst in einem späteren Schritt.

   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. Füge die neue Funktion OnSeated() zur Klasse show_template_device hinzu, die den Agent nimmt, der in TheChair gesessen hat.

   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. Wenn in OnSeated() die MainSequence nicht bereits wiedergegeben wird, spawne eine RunSequence()-Funktion, die den Agent übergibt, der im Stuhlgerät gesessen hat. Andernfalls wird DoReturnToTVMode() mit dem gleichen Agent aufgerufen.

   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. Füge eine neue Funktion OnChairExited() zur Klasse show_template_device hinzu, die den Spieler entgegennimmt, der den Stuhl verlassen hat. Du wirst die Logik für diese Funktion in einem späteren Schritt ausfüllen.

   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. Abonniere in OnBegin() das Ereignis TheChair.SeatedEvent für die Funktion OnSeated(). Immer, wenn ein Spieler sich in TheChair setzt, wird die Show ausgeführt.

    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)

Speichere das Script in Visual Studio Code, kompiliere es und klicke in der UEFN-Werkzeugleiste auf Sitzung starten, um einen Spieltest der Vorlage auszuführen. Wenn du dein Spiel laufen lässt, sollte das Sitzen auf dem Stuhlgerät die Show starten und die Kamera des Spielers sollte auf den Filmsequenzmodus gesetzt werden. Wenn die Show endet, sollte der Spieler aus dem Stuhl hinausgeworfen werden.

Umschalten der Kameras

Während der Show kann der in TheChair sitzende Spieler zwischen mehreren verschiedenen Kameraansichten umschalten, die von den verschiedenen Filmsequenzen verarbeitet werden. Befolge die folgenden Schritte, um die Logik für das Umschalten zwischen den verschiedenen Sequenzen einzurichten.

1. Füge eine neue Funktion DoCameraSwitch() zur Klasse show_template_device hinzu. Diese Funktion nimmt den Agent, dessen Kamera du umschaltest, sowie einen int entgegen, der dem Filmsequenzindex in CameraSwitches entspricht.

   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. Wenn du dich in DoCameraSwitch() in einer if-Anweisung befindest, soll die Filmsequenz an dem Werteindex im CameraSwitches-Array abgerufen werden. Dann soll die Wiedergabe aller laufenden Sequenzen gestoppt werden, indem geprüft wird, ob CurrentSequence eine Filmsequenz enthält und dann Stop() auf ihr aufgerufen wird.

   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. Starte die Wiedergabe einer neuen Filmsequenz, indem du Play() auf CameraSwitch aufrufst. Lege dann CurrentSequence so fest, dass es angibt, welche Sequenz derzeit wiedergegeben wird. Führe zum Schluss Register() auf den agent aus, dessen Kamera du mit den Input-Triggern ReturnToTVMode und ReturnToFreeLook umschaltest, damit sie zu diesen Modi zurückkehren können, wenn andere Kameras angezeigt werden. Deine fertige Funktion DoCameraSwitch() sollte wie folgt aussehen:

   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. Um zwischen der nächsten und vorherigen Kamera umzuschalten, richtest du zwei ganz ähnliche Funktionen ein, DoNextCamera() und DoPreviousCamera(). Du füllst zuerst die Logik für die nächste Kamera aus. Füge als eine neue Funktion DoNextCamera() zur Klasse show_template_device hinzu. Diese Funktion nimmt den agent, dessen Kamera du umschaltest.

   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. Prüfe in DoNextCamera(), ob sich der Spieler aktuell im TV-Modus befindet. Ist dies der Fall, wende Stop() auf TVModeSequence an, setze InTVMode auf False und setze CurrentCameraIndex auf -1. Du verwendest hier -1, weil du den Index in der nächsten Filmsequenz des CameraSwitches-Array nutzen willst, was der Index 0 wäre.

   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. Dann musst du basierend auf dem Index der aktuellen Kamera herausfinden, welches die nächste Kamera ist, zu der gewechselt werden soll. Dazu setzt du die neue Variable NextCameraValue auf den Mod von CurrentCameraIndex + 1 und CameraSwitches.Length. Damit kannst du NextCameraValue an einen Wert anhängen, der zwischen 0 und der Länge von CameraSwitches liegt und verhindern, dass du einen NextCameraValue abrufst, der außerhalb des CameraSwitches-Arrays liegt. Sobald du NextCameraValue hast, setze CurrentCameraValue auf NextCameraValue und rufe DoCameraSwitch() auf, wobei du den agent und CurrentCameraIndex übergibst. Deine fertige Funktion DoNextCamera() sollte wie folgt aussehen:

   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. Um zur vorherigen Kamera umzuschalten, fügst du die neue Funktion DoPreviousCamera() zur Klasse show_template_device hinzu. Kopiere den Code von DoNextCamera() in diese Funktion. Wenn du prüfst, ob sich der Spieler im TV-Modus befindet, setze CurrentCameraIndex auf 0 statt auf -1. Ändere außerdem NextCameraValue zum Mod von CurrentCameraIndex – 1 und CameraSwitches.Length. Deine fertige Funktion DoPreviousCamera() sollte wie folgt aussehen:

   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)

Wenn ein Spieler in TheChair sitzt und die Show über eine andere Kamera in CameraSwitches ansieht, kann er zum TV-Modus oder zu „Frei umschauen“ zurückkehren. Du hast die Funktionen DoReturnToFreeLook() und DoReturnToTVMode() bereits zuvor eingerichtet und füllst sie jetzt aus.

1. Prüfe in der Funktion DoReturnToFreeLook(), ob sich der Spieler aktuell im TV-Modus befindet. Ist dies der Fall, wende Stop() auf TVModeSequence an und setze InTVMode auf False. Mache das Gleiche mit CurrentSequence und prüfe, ob CurrentSequence eine Filmsequenz enthält. Rufe Stop() auf und setze es auf False, wenn dies der Fall ist.

   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. Registriere jetzt den Agent mit dem Input-Trigger ReturnToTVMode und führe Unregister() auf sie mit dem Trigger ReturnToFreeLook aus, da du keinen Spieler zum freien Umschauen zurückführen möchtest, wenn er sich bereits dort befindet. Deine fertige Funktion DoReturnToFreeLook() sollte wie folgt aussehen:

   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. Die Funktion DoReturnToTVMode() erfordert mehr Logik, da du TVModeSequence zum aktuellen Zeitpunkt der MainSequence starten musst, wenn du zum TV-Modus zurückkehrst. Prüfe zuerst, ob sich der Spieler bereits im TV-Modus befindet, wenn diese Funktion aufgerufen wird. Ist dies der Fall, führe einfach return aus, da du nichts machen musst. Prüfe dann, ob CurrentSequence eine Filmsequenz enthält. Rufe Stop() auf und setze es auf False, wenn dies der Fall ist.

   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. Nun musst du herausfinden, wo sich MainSequence bei der Wiedergabe befindet und an der gleichen Stelle TVModeSequence starten. Rufe die Wiedergabezeit von MainSequence ab, indem du GetPlayBackTime() aufrufst, und speichere sie in der Variable CurrentSeekTime. Setze die Wiedergabezeit von TVModeSequence mit SetPlaybackTime() auf CurrentSeekTime und führe Play() für die Sequenz aus, wobei du den Agent übergibst. Setze dann InTVMode auf 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. Führe schließlich Unregister() auf den Agent über den Input-Trigger ReturnToTVMode aus und führe Register() für sie mit dem Auslöser ReturnToFreeLook aus. Deine fertige Funktion DoReturnToTVMode() sollte wie folgt aussehen:

   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)

Alles miteinander verknüpfen

Du hast in den bisherigen Teilen des Tutorials sehr viele Funktionen eingerichtet. Jetzt ist es an der Zeit, alle miteinander mit den verschiedenen Eingabeauslösern zu verbinden, die sie aufrufen.

1. Führe in OnSeated() Register() für den Agent mit den Input-Triggern ReturnToFreeLook, NextCamera und PreviousCamera aus, da dies die Trigger sind, auf die ein Spieler anfänglich Zugriff hat, wenn er sich zum ersten Mal auf den Stuhl setzt. Lege dann ReturnToFreeLookSubscription, NextCameraSubscription und PreviousCameraSubscription fest, indem du jeden Input-Trigger mit seiner zugeordneten Funktion abonnierst. Lege ReturnToTVModeSubscription und ChairExitSubscription auf die gleiche Art fest.

   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. Füge eine neue Funktion CancelSubscription() zur Klasse show_template_device hinzu, die einen optional abbrechbaren Wert nimmt. Prüfe in CancelSubscription(), ob Subscription einen Wert enthält. Falls zutreffend, führe Cancel() aus. Deine fertige Funktion CancelSubscription() sollte wie folgt aussehen:

   Verse

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

   Copy full snippet(4 lines long)

3. Wenn ein Spieler den Stuhl verlässt, musst du alle aktuell laufenden Sequenzen für den Spieler stoppen sowie alle Abonnements für Eingabeauslöser abbrechen, die der Spieler registriert hatte. Prüfe für die Funktion OnChairExited() wie in DoReturnToFreeLook(), ob sich der Spieler im TV-Modus befindet, sowie ob CurrentSequence eine Filmsequenz enthält. Rufe in diesem Fall Stop() auf jede Sequenz auf und setze InTVMode auf false, wenn sich der Spieler im TV-Modus befindet. Setze dann CurrentSequence auf 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. Hebe nun alle Spielerabonnements auf, indem du jedes Abonnement an die Funktion CancelSubscription() übergibst. Führe außerdem Unregister() für den Spieler für jeden Input-Trigger aus, da er nicht in der Lage sein sollte, diese Schaltflächen aufzurufen, wenn er den Stuhl verlassen hat. Deine fertige Funktion OnChairExited() sollte wie folgt aussehen:

   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)

Speichere das Script in Visual Studio Code, kompiliere es und klicke in der UEFN-Werkzeugleiste auf Sitzung starten, um einen Spieltest der Vorlage auszuführen. Wenn du einen Spieltest ausführst, sollte die Show starten, wenn du dich auf das Stuhlgerät setzt. Während der Show solltest du zwischen TV-Modus, freiem Umschauen und verschiedenen anderen Kamerawinkeln wechseln können. Bei der Rückkehr zum TV-Modus sollte die TV-Modussequenz mit der Hauptsequenz abgeglichen werden. Wenn die Show endet, solltest du zum freien Umsehen zurückgeführt werden und den Stuhl verlassen.