Modello Stand-Up comedy club

Questo tutorial è un documento complementare al Modello Verse Stand-Up che mostra come utilizzare i dispositivi che supportano un'esperienza sociale e cinematica all'interno di un comedy club:

• Utilizzo di asset dettagliati di MetaHumans Animator con i dispositivi Personaggio

• Attivazione di eventi gameplay sulle associazioni di input del giocatore con dispositivi Attivatore input

• Blocco di un giocatore in posizione per visualizzare l'esperienza con il dispositivo Sedia

Un dispositivo Verse esegue lo spettacolo, con i concetti chiave del codice Verse spiegati di seguito.

Il modello Verse Stand-up è disponibile nella sezione Esempi in evidenza di UEFN (Unreal Editor per Fortnite).

Dispositivi utilizzati:

• 1 sedia

• 4 Attivatori input

• 4 personaggi

• 6 sequenze cinematiche

I concetti di Verse utilizzati in questo tutorial sono:

• Iscrizioni

• Istruzioni If

• Array

• Sequenza cinematica

• API dispositivo sedia

• API dispositivo Attivatore input

Impostazioni isola

Ecco le impostazioni dell'isola modificate per il modello Verse Stand-Up:

Dispositivo sedia

Quando il giocatore entra nel comedy club, vede una sedia davanti a un palco illuminato. Viene invitato a sedersi su questa sedia. Sedersi sulla sedia mantiene il giocatore in una posizione fissa e mette in moto la catena di eventi che lo accompagneranno per il resto dell'esperienza.

Ecco le Opzioni utente modificate per il dispositivo Sedia:

Dispositivi Attivatore input

Un dispositivo Attivatore input va di pari passo con il dispositivo Sedia. Lega gli input del giocatore a una varietà di azioni che vengono attivate ogni volta che il giocatore preme il pulsante riassegnato. Gli Attivatori input sono configurati per permettere al giocatore di cambiare telecamera mentre si svolge la performance.

Il dispositivo contiene dodici input disponibili tra cui scegliere. Una volta scelto un input, puoi aggiungere una descrizione HUD per chiarire cosa fa il nuovo input.

Ecco le Opzioni utente modificate per questo dispositivo. Ciascuno dei dispositivi avrà un collegamento e una descrizione HUD diversi poiché sono associati a dispositivi di sequenza cinematica distinti.

Dispositivi Personaggio

I dispositivi personaggio ti permettono di interagire direttamente con il giocatore o con altri personaggi in una scena. Questo modello utilizza quattro personaggi che si alternano durante la routine sul palco.

Ecco le Opzioni utente modificate per il dispositivo Personaggio:

Il personaggio principale è seduto su una scala dietro le quinte e il resto dei personaggi aspetta in una piccola stanza sul retro.

Sperimenta diverse pelli dei personaggi dal menu a discesa Personaggio e guarda come appaiono sul palco!

Dispositivi Sequenza cinematica

I sei dispositivi sequenza cinematica permettono al giocatore di vedere lo spettacolo da varie angolazioni mentre è seduto sulla sedia.

Questa pagina non entra nei dettagli sulla creazione di sequenze cinematiche. Per maggiori informazioni, vedi la pagina Sequencer e Control Rig e, per un approfondimento, dai un'occhiata a Come realizzare filmati in Unreal Engine.

L'unica modifica di questo dispositivo è la sequenza cinematica caricata.

Come Verse esegue lo spettacolo

Questo modello utilizza Verse per avviare lo spettacolo quando un giocatore si siede sulla sedia e cambiare la telecamera in una visualizzazione cinematica chiamata modalità TV. Permette inoltre al giocatore di passare da una telecamera all'altra e di tornare alla modalità TV o alla Visuale libera per esperienze visive diverse.

Crea un nuovo dispositivo Verse nel tuo progetto chiamato show_template_device.Verse utilizzando Verse Explorer e trascina il dispositivo nel modello. Fai due volte clic sul file Verse per aprirlo in Visual Studio Code.

Hai impostato i dispositivi nel tuo modello che aiuta a eseguire lo spettacolo standup e ora farai riferimento a quei dispositivo nel tuo codice.

Aggiungi i seguenti campi al file show_template_device:

1. Innanzitutto, sopra la definizione della classe show_template_device, aggiungi un log_channel denominato 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. Ora nella parte superiore della definizione della classe show_template_device aggiungi un logger che utilizza il canale log_show_template_device così puoi sapere quali istruzioni Print() provengono da questo dispositivo.

   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. Un dispositivo sedia modificabile denominato TheChair. Questa è la sedia su cui si siederanno i giocatori per iniziare lo spettacolo standup.

   Verse

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

   Copy full snippet(3 lines long)

4. Due dispositivi sequenze cinematica modificabili denominati MainSequence e TVModeSequence. MainSequence è la sequenza cinematica che esegue lo spettacolo standup, guidando l'animazione e l'audio sul dispositivo del personaggio nel livello. TVModeSequence commuta la telecamera del giocatore in una modalità di visualizzazione che segue insieme a MainSquence, passando da più angolazioni.

   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. Array modificabile di cinematic_sequence_device denominato CameraSwitches. Questo array contiene riferimenti a ciascuna delle telecamere tra cui i giocatori possono passare durante lo spettacolo.

   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. Quattro input_trigger_device modificabili. Ciascuno di questi dispositivi riceve l'input del giocatore per passare da una modalità telecamera all'altra. Il trigger ReturnToFreeLook riporta il giocatore alla telecamera predefinita, mentre ReturnToTVMode riporta il giocatore a TVModeSequence. La telecamera NextCamera e PreviousMode fa passare il giocatore tra le diverse sequenze cinematiche nell'array 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. Variabile opzionale del dispositivo sequenza cinematica denominata CurrentSequence. Se è in riproduzione una sequenza cinematica come TVModeSequence, questa opzione ne memorizza un riferimento. Non vuoi riprodurre più sequenze cinematiche per il personaggio contemporaneamente, quindi puoi utilizzare questa opzione per disattivare la sequenza corrente quando passi a una nuova.

   Verse

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

   Copy full snippet(2 lines long)

8. Due variabili logiche denominate MainSequencePlaying e InTvMode. Queste ti permettono di tenere traccia quando viene riprodotta rispettivamente MainSequence o 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. Variabile int denominata CurrentCameraIndex. Tiene traccia dell'indice della sequenza cinematica nell'array CameraSwitches attualmente in riproduzione.

   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. Cinque variabili opzionali annullabili che tengono traccia delle sottoscrizioni di tutti gli eventi a cui si fa riferimento in questo modello. Diverse funzioni devono essere eseguite quando il giocatore passa da una telecamera all'altra, torna alla visione libera o alla modalità TV o esce dal dispositivo sedia. Più avanti in questo tutorial, ti sottoscriverai le funzioni degli eventi che le attivano e memorizzerai un riferimento a ciascuna sottoscrizione per annullarle quando non sono più necessarie.

    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. Salva lo script in Visual Studio Code e compilalo per aggiornare il dispositivo creato da Verse nel livello.

12. Seleziona show_template_device nel tuo modello. Nel pannello Dettagli, assegna ciascun riferimento al dispositivo nello script al dispositivo associato nel livello, inclusi ciascuno degli Attivatori input e sequenze cinematiche.

    

Attivazione della sequenza

Lo spettacolo inizia quando un giocatore si siede sulla sedia, vorrai che la sequenza cinematica inizi una volta che il giocatore è seduto. Segui gli step seguenti per attivare la sequenza principale quando un giocatore si siede sulla sedia e per avviare la modalità TV in modo che il giocatore possa guardarla.

1. Aggiungi una nuova funzione RunSequence() alla classe show_template_device. Questa funzione prende l'agente che ha avviato lo spettacolo e avvia sia MainSequence che TVModeSequence. Aggiungi il modificatore a RunSequence() per permetterne l'esecuzione in modo asincrono. Questa funzione deve essere asincrona in modo da eseguire altro codice contemporaneamente con essa e permettere al giocatore di passare da una visualizzazione della telecamera all'altra senza interrompere il codice 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. In RunSequence(), chiama Sleep() per un secondo per far terminare l'animazione del giocatore seduto sulla sedia prima di iniziare lo spettacolo. Quindi chiama Play() su MainSequence e Imposta MainSequencePlaying su vero.

   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. Chiama Play() su TVModeSequence, passando l'agente che ha iniziato lo spettacolo per cambiare la telecamera nella visuale cinematica. Imposta InTVMode su vero e chiama una nuova funzione che attende la fine di MainSequence denominata AwaitMainSequenceEnding(), passando l'agente. Imposterai questa funzione nello step successivo. Il codice RunSequence() completato deve essere simile al seguente:

   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. Aggiungi una nuova funzione AwaitMainSequecingEnding() alla classe show_template_device che prende l'agente da RunSequence(). Questa funzione necessita anche del modificatore <suspends> poiché vuoi che venga eseguita in background e si attivi al termine di 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. In AwaitMainSequencingEnding(), chiama Await() on the MainSequence.StoppedEvent(). Quando MainSequence termina, Imposta MainSequencePlaying su falso e caccia il giocatore dalla sedia utilizzando la funzione Eject() della sedia. La funzione AwaitMainSequencingEnding() completata deve essere simile alla seguente:

   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. Aggiungi due nuove funzioni DoReturnToTVMode() e DoReturnToFreeLook() alla classe show_template_device. Queste funzioni gestiscono la logica quando un giocatore torna rispettivamente alla modalità TV o alla visione libera, ma per ora le lascerai vuote e le compilerai in uno step successivo.

   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. Aggiungi una nuova funzione OnSeated() alla classe show_template_device che prende l'agente seduto su 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. In OnSeated(), se MainSequence non è già in riproduzione, genera una funzione RunSequence(), passando l'agente seduto sulla sedia. In caso contrario, chiama DoReturnToTVMode() con lo stesso agente.

   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. Aggiungi una nuova funzione OnChairExited() alla classe show_template_device che prende il giocatore che è uscito dalla sedia. Compilerai la logica per questa funzione in uno step successivo.

   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. In OnBegin(), sottoscrivi TheChair.SeatedEvent alla funzione OnSeated(). Ora ogni volta che un giocatore si siede su TheChair, lo spettacolo viene eseguito.

    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)

Salva lo script in Visual Studio Code, compilalo e fai clic su Avvia sessione nella barra degli strumenti UEFN per eseguire il playtest del modello. Quando esegui il gioco, sedendoti sulla sedia, il dispositivo deve avviare lo spettacolo e impostare la telecamera del giocatore in modalità cinematica. Quando lo spettacolo finisce, il giocatore deve essere cacciato dalla sedia.

Cambio di telecamera

Durante lo spettacolo, il giocatore seduto su TheChair può passare da una telecamera all'altra, gestite da diverse sequenze cinematiche. Segui gli step seguenti per impostare la logica per il passaggio tra queste diverse sequenze.

1. Aggiungi una nuova funzione DoCameraSwitch() alla classe show_template_device. Questa funzione prende l'agente di cui stai cambiando la telecamera, e un int corrispondente all'indice della sequenza cinematica in 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. In DoCameraSwitch(), in un'istruzione if, ottieni la sequenza cinematica nell'indice Value nell'array CameraSwitches. Quindi interrompi qualsiasi sequenza attualmente in riproduzione controllando se CurrentSequence contiene una sequenza cinematica e chiamando Stop() su di essa.

   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. Avvia la riproduzione della nuova sequenza cinematica chiamando Play() su CameraSwitch. Quindi imposta CurrentSequence per dire quale sequenza è attualmente in riproduzione. Infine, Register() l'agent di cui stai cambiando la telecamera con gli Attivatori input ReturnToTVMode e ReturnToFreeLook per permettergli di tornare a quelle modalità durante la visualizzazione di altre telecamere. La funzione DoCameraSwitch() completata deve essere simile alla seguente:

   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. Per passare dalla telecamera successiva a quella precedente, è necessario impostare due funzioni molto simili, DoNextCamera() e DoPreviousCamera(). Compilerai prima la logica per la telecamera successiva, quindi aggiungi una nuova funzione DoNextCamera() alla classe show_template_device. Questa funzione prende l'agent di cui si sta cambiando la telecamera.

   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. In DoNextCamera(), controlla se il giocatore è attualmente in modalità TV. In caso affermativo, Stop() TVModeSequence, Imposta InTVMode su falso e imposta CurrentCameraIndex su -1. In questo caso utilizzi -1 perché vuoi indicizzare nella sequenza cinematica successiva l'array CameraSwitches che è l'indice 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. Devi quindi individuare la telecamera successiva a cui passare in base all'indice della telecamera corrente. Per fare ciò, imposta una nuova variabile NextCameraValue su Mod di CurrentCameraIndex + 1 e CameraSwitches.Length. In questo modo è possibile bloccare NextCameraValue su un valore compreso tra 0 e la lunghezza di CameraSwitches e si impedisce di ottenere un NextCameraValue esterno all'array CameraSwitches. Una volta ottenuto NextCameraValue, imposta CurrentCameraValue su NextCameraValue e chiama DoCameraSwitch() passando agent e CurrentCameraIndex. La funzione DoNextCamera() completata deve essere simile alla seguente:

   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. Per passare alla telecamera precedente, aggiungi una nuova funzione denominata DoPreviousCamera() alla classe show_template_device. Copia il codice da DoNextCamera() in questa funzione. Quando controlli se il giocatore è in Modalità TV, imposta CurrentCameraIndex su 0 invece di -1. Inoltre, modifica NextCameraValue in modo che sia la Mod di CurrentCameraIndex - 1 e CameraSwitches.Length. La funzione completata DoPreviousCamera() deve essere simile alla seguente:

   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)

Quando un giocatore è seduto su TheChair e guarda da un'altra telecamera in CameraSwitches può tornare alla modalità TV o visione libera. Hai impostato le funzioni DoReturnToFreeLook() e DoReturnToTVMode() in precedenza e le compilerai adesso.

1. Nella funzione DoReturnToFreeLook() controlla se il giocatore è attualmente in modalità TV. In caso affermativo, imposta Stop() su TVModeSequence e Imposta InTVMode su falso. Fai lo stesso con CurrentSequence, controllando se CurrentSequence contiene una sequenza cinematica, chiamando Stop() e impostandola su falso in tal caso.

   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. Ora Register() l'agente con l'Attivatore input ReturnToTVMode e Unregister() con il trigger ReturnToFreeLook poiché non vuoi far tornare un giocatore alla visione libera mentre è già lì. La funzione DoReturnToFreeLook() completata deve essere simile alla seguente:

   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. La funzione DoReturnToTVMode() richiede più logica poiché quando si torna alla modalità TV è necessario avviare TVModeSequence all'ora corrente di MainSequence. Innanzitutto, controlla se il giocatore è già in modalità TV quando viene chiamata questa funzione. In tal caso, return poiché non c'è nulla che devi fare. Quindi controlla se CurrentSequence contiene una sequenza cinematica, chiamando Stop() e impostandolo su falso in tal caso.

   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. Ora devi capire dove si trova MainSequence lungo la sua riproduzione e avviare TVModeSequence dallo stesso punto. Ottieni il tempo di riproduzione di MainSequence chiamando GetPlayBackTime() e salvalo in una variabile CurrentSeekTime. Imposta il tempo di riproduzione di TVModeSequence su CurrentSeekTime utilizzando SetPlaybackTime() e Play() la sequenza passando l'agente. Quindi imposta InTVMode su vero.

   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. Infine, Unregister() l'agente dall'Attivatore input ReturnToTVMode e Register() con il trigger ReturnToFreeLook. La funzione DoReturnToTVMode() completata deve essere simile alla seguente:

   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)

Collegare tutto insieme

Nella parte precedente di questo tutorial hai impostato molte funzioni e ora è il momento di collegarle tutte insieme ai vari Attivatori input che le chiamano.

1. In OnSeated(), Register() l'agente con gli Attivatori input ReturnToFreeLook, NextCamera e PreviousCamera, poiché questi sono i trigger a cui un giocatore avrà inizialmente accesso quando si siede per la prima volta sulla sedia. Quindi imposta ReturnToFreeLookSubscription, NextCameraSubscription e PreviousCameraSubscription sottoscrivendo ogni Attivatore input alla funzione associata. Imposta ReturnToTVModeSubscription e ChairExitSubscription allo stesso modo.

   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. Aggiungi una nuova funzione CancelSubscription() che assume un valore annullabile opzionale alla classe show_template_device. In CancelSubscription(), controlla se Subscription contiene un valore. In tal caso, Cancel(). La funzione CancelSubscription() completata deve essere simile alla seguente:

   Verse

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

   Copy full snippet(4 lines long)

3. Quando un giocatore esce dalla sedia, devi interrompere tutte le sequenze attualmente in riproduzione sul giocatore e annullare tutte le sottoscrizioni agli Attivatori input a cui il giocatore è stato registrato. Per la funzione OnChairExited(), comein in DoReturnToFreeLook(), controlla se il giocatore è in modalità TV e se CurrentSequence contiene una sequenza cinematica. Chiama Stop() su ogni sequenza in tal caso e imposta InTVMode su falso se il giocatore è in modalità TV. Quindi imposta CurrentSequence su falso.

   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. Ora annulla tutte le sottoscrizioni dei giocatori passando ogni sottoscrizione alla funzione CancelSubscription(). Inoltre Unregister() il giocatore da ogni Attivatore input poiché non deve accedere a quei pulsanti quando si alza dalla sedia. La funzione completata OnChairExited() deve essere simile alla seguente:

   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)

Salva lo script in Visual Studio Code, compilalo e fai clic su Avvia sessione nella barra degli strumenti UEFN per eseguire il playtest del modello. Quando esegui il playtest, sedersi sulla sedia deve avviare lo spettacolo. Durante lo spettacolo, devi essere in grado di passare dalla modalità TV alla visione libera e a molte altre angolazioni della telecamera. Il ritorno alla modalità TV deve allineare la sequenza della modalità TV con la sequenza principale. Al termine dello spettacolo, devi tornare a guardare liberamente e uscire dalla sedia.