Plantilla de monólogo

Este tutorial es un documento complementario de la plantilla de monólogo de Verse, que muestra cómo utilizar dispositivos que permiten una experiencia social y cinematográfica dentro de un club de comedia:

• Utilización de recursos detallados de MetaHuman Animator con los dispositivos Personaje.

• Activación de eventos de juego en las asignaciones de entrada del jugador con dispositivos Activador de entrada.

• Bloqueo de un jugador para ver la experiencia con el dispositivo Silla.

Un dispositivo Verse dirige el espectáculo, con los conceptos clave del código de Verse explicados más abajo

La plantilla de monólogo de Verse se puede encontrar en la sección Ejemplos de funciones de UEFN (Unreal Editor para Fortnite).

Dispositivos utilizados:

• 1 dispositivo Silla

• 4 dispositivos Activador de entrada

• 4 dispositivos Personaje

• 6 dispositivos Secuencia cinemática

Los conceptos de Verse utilizados en este tutorial son los siguientes:

• Suscripciones

• Declaraciones if

• Matrices

• Secuencias cinemáticas

• API del dispositivo Silla

• API del dispositivo Activador de entrada

Configuración de la isla

Esta es la configuración modificada de la isla para la plantilla de monólogo de Verse:

Silla

Cuando el jugador entra en el club de la comedia, ve una silla frente a un escenario iluminado. A continuación se le pide que se siente en esa silla. Cuando el jugador se sienta en la silla este se mantiene en una ubicación fija y se activa la cadena de eventos que le llevará por el resto de la experiencia.

Estas son las opciones de usuario modificadas para el dispositivo Silla:

Dispositivos Activador de entrada

Un dispositivo Activador de entrada va a la par con el dispositivo Silla. Asigna las entradas del jugador a una serie de acciones, que se activan cada vez que el jugador pulsa el botón reasignado. Los activadores de entrada están configurados para que el jugador pueda cambiar las cámaras a medida que se desarrolla el espectáculo.

El dispositivo contiene doce entradas disponibles para elegir. Una vez elegida una entrada, puedes añadir una descripción en el HUD para aclarar lo que hace la nueva entrada.

Estas son las opciones de usuario modificadas para este dispositivo. Cada dispositivo tendrá una asignación y una descripción en el HUD diferentes, ya que están vinculados a dispositivos Secuencia cinemática distintos.

Dispositivos Personaje

Los dispositivos Personaje son formas de interactuar directamente con el jugador o con otros personajes de una escena. Esta plantilla utiliza cuatro personajes que se alternan durante la rutina en el escenario.

Estas son las opciones de usuario modificadas para el dispositivo Personaje:

El protagonista está sentado en una escalera entre bambalinas, y el resto de los personajes esperan en una pequeña sala al fondo.

Experimenta con los distintos aspectos de personaje del menú desplegable Personaje y comprueba cómo quedan en el escenario.

Dispositivos Secuencia cinemática

Los seis dispositivos Secuencia cinemática permiten al jugador ver el espectáculo desde distintos ángulos mientras está sentado en el dispositivo Silla.

Esta página no detalla la creación de secuencias cinemáticas. Para obtener más información, consulta la página Sequencer y rig de control, y para profundizar más, echa un vistazo a Cómo hacer películas en Unreal Engine.

La única modificación de este dispositivo es la secuencia cinemática cargada.

Cómo dirige Verse el espectáculo

Esta plantilla utiliza Verse para iniciar el espectáculo cuando un jugador se sienta en el dispositivo Silla, así como para cambiar la cámara a una vista cinemática denominada modo TV. También permite al jugador alternar entre varias cámaras, además de volver al modo TV o al modo Mirar libremente para disfrutar de diferentes experiencias de visualización.

Crea un nuevo dispositivo Verse en tu proyecto nombrado show_template_device.verse mediante el explorador de Verse y arrástralo a la plantilla. Haz doble clic en tu archivo de Verse para abrirlo en Visual Studio Code.

Ya has configurado dispositivos en tu plantilla que ayudan a ejecutar el espectáculo de monólogo, y ahora harás referencia a ellos en tu código.

Añade los siguientes campos al archivo show_template_device:

1. Primero, encima de la definición de la clase show_template_device, añade un log_channel denominado 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. Ahora, en la parte superior de la definición de la clase show_template_device, añade un registrador que utilice el canal log_show_template_device, para que puedas saber qué declaraciones de Print() provienen de este 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 Silla editable denominado TheChair. Esta es la silla en la que se sentarán los jugadores para comenzar el monólogo.

   Verse

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

   Copy full snippet(3 lines long)

4. Dos dispositivos Secuencia cinemática editables denominados MainSequence y TVModeSequence. La MainSequence es la secuencia cinemática que ejecuta el espectáculo de comedia, controla la animación y el audio en el dispositivo Personaje en el nivel. La TVModeSequence cambia la cámara del jugador a un modo de visualización que sigue a la MainSquence, alternando entre diferentes ángulos.

   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. Una matriz editable de cinematic_sequence_device con el nombre CameraSwitches. Esta matriz contiene referencias a cada una de las cámaras entre las que los jugadores pueden cambiar durante el espectáculo.

   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. Cuatro input_trigger_device editables. Cada uno de estos dispositivos requiere la intervención del jugador para cambiar entre los distintos modos de cámara. El activador ReturnToFreeLook devuelve al jugador a la cámara predeterminada, mientras que ReturnToTVMode devuelve al jugador a la TVModeSequence. La cámara NextCamera y PreviousMode cambia al jugador entre las diferentes secuencias cinemáticas en la matriz 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. Una variable opcional de dispositivo Secuencia cinemática denominada CurrentSequence. Si se está reproduciendo una secuencia cinemática como TVModeSequence, esta opción almacena una referencia a la misma. Si no quieres reproducir varias secuencias cinemáticas para el personaje a la vez, puedes utilizar esta opción para desactivar la secuencia actual al cambiar a una nueva.

   Verse

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

   Copy full snippet(2 lines long)

8. Dos variables logic nombradas MainSequencePlaying y InTvMode. Permiten saber cuándo se está reproduciendo la MainSequence o la TVModeSequence respectivamente.

   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. Una variable int denominada CurrentCameraIndex. Registra el índice de la secuencia cinemática en la matriz CameraSwitches que se está reproduciendo en ese momento.

   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. Cinco variables opcionales cancelable que rastrean las suscripciones de todos los eventos. Cuando el jugador cambia entre cámaras, vuelve a los modos Mirar libremente o TV o sale del dispositivo Silla deben ejecutarse diferentes funciones. Más adelante en este tutorial, suscribirás las funciones a los eventos que las activan, y almacenarás una referencia a cada suscripción para poder cancelarlas cuando ya no sean necesarias.

    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. Guarda la secuencia de comandos en Visual Studio Code y compílala para actualizar tu dispositivo creado con Verse en el nivel.

12. Selecciona show_template_device en tu plantilla. En el panel Detalles, asigna cada referencia de dispositivo en tu secuencia de comandos al dispositivo asociado en el nivel, incluido cada uno de tus activadores de entrada y secuencias cinemáticas.

    

Cómo activar la secuencia

El espectáculo comienza cuando un jugador se sienta en el dispositivo Silla. La secuencia cinemática debe comenzar cuando el jugador esté sentado. Sigue los pasos que se indican a continuación para activar la secuencia principal cuando un jugador se siente en la silla, así como para iniciar el modo TV para que el jugador pueda seguir la secuencia.

1. Añade una nueva función RunSequence() a la clase show_template_device. Esta función toma el agente que inició el espectáculo y activa tanto la `MainSequence` como la TVModeSequence. Añade el modificador suspends a RunSequence() para que se ejecute de forma asíncrona. Esta función debe ser asíncrona para que puedas ejecutar otro código simultáneamente con ella, y permitir al jugador cambiar entre vistas de cámara sin interrumpir el código de 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. En RunSequence(), llama a Sleep() durante un segundo para hacer que la animación del jugador sentado en la silla termine antes de que el espectáculo empiece. Luego llama a Play() en la MainSequence, y activa MainSequencePlaying.

   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. Llama a Play() en la TVModeSequence, pasando el agente que inició el espectáculo para cambiar su cámara a la vista cinemática. Activa InTVMode y llama a una nueva función que espera el final de la MainSequence denominada AwaitMainSequenceEnding() pasando el agente. Configurarás esta función en el siguiente paso. Tu código RunSequence() finalizado debería tener este aspecto:

   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. Añade una nueva función AwaitMainSequecingEnding() a la clase show_template_device que toma el agent de RunSequence(). Esta función también necesita el modificador <suspends>, ya que te interesa que se ejecute en segundo plano y se active al terminar la 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. En AwaitMainSequencingEnding(), llama a Await() en MainSequence.StoppedEvent(). Cuando la MainSequence termine, establece MainSequencePlaying como false y echa al jugador de la silla usando la función de expulsión Eject(). Tu función CheckWin() completa debería tener el siguiente aspecto:

   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. Añade dos nuevas funciones DoReturnToTVMode() y DoReturnToFreeLook() a la clase show_template_device. Estas funciones controlan la lógica cuando un jugador vuelve a los modos TV o Mirar libremente respectivamente, pero por ahora déjalas en blanco y rellénalas más adelante en un paso posterior.

   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. Añade una nueva función OnSeated() a la clase show_template_device que toma el agente que se sentó en 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. En OnSeated(), si la MainSequence aún no se está reproduciendo, genera una función RunSequence(), pasando el agente que se sentó en el dispositivo Silla. De lo contrario, llama a DoReturnToTVMode() con el mismo 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. Añade una nueva función OnChairExited() a la clase show_template_device que toma el jugador que ha abandonado la silla. Completarás la lógica de esta función en un paso posterior.

   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. En OnBegin(), suscribe TheChair.SeatedEvent a la función OnSeated(). Ahora, cada vez que un jugador se siente en TheChair, el espectáculo comenzará.

    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)

Guarda la secuencia de comandos en Visual Studio Code, compílala y haz clic en Iniciar sesión en la barra de herramientas de UEFN para probar la plantilla. Al ejecutar el juego, el espectáculo deberá comenzar cuando te sientes en la silla, y establecer la cámara del jugador en modo cinemático. Cuando el espectáculo termina, debe expulsarse al jugador de la silla.

Cómo cambiar de cámara

Durante el espectáculo, el jugador sentado en TheChair puede cambiar entre varias vistas de cámara diferentes, controladas por distintas secuencias cinemáticas. Sigue los pasos que se indican a continuación para configurar la lógica de conmutación entre estas diferentes secuencias.

1. Añade una nueva función DoCameraSwitch() a la clase show_template_device. Esta función toma el agente cuya cámara estás cambiando, así como un int correspondiente al índice de la secuencia cinemática en 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. En DoCameraSwitch(), en una declaración if, obtén la secuencia cinemática en el índice Value de la matriz CameraSwitches. A continuación, detén las secuencias que se estén reproduciendo comprobando si CurrentSequence contiene una secuencia cinemática y llamando a Stop() en ella.

   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. Comienza a reproducir la nueva secuencia cinemática llamando a Play() en CameraSwitch. A continuación, establece CurrentSequence para indicar qué secuencia se está reproduciendo actualmente. Finalmente, usa la función Register() en el agente cuya cámara estás cambiando con los activadores de entrada ReturnToTVMode y ReturnToFreeLook para permitirles volver a esos modos cuando vean otras cámaras. Tu función DoCameraSwitch() completa debería tener el siguiente aspecto:

   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. Para cambiar entre la cámara siguiente y la anterior, establecerás dos funciones muy similares, DoNextCamera() y DoPreviousCamera(). Primero completarás la lógica para la siguiente cámara, así que añade una nueva función DoNextCamera() a la clase show_template_device. Esta función toma el agente cuya cámara estás cambiando.

   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. En DoNextCamera(), comprueba si el jugador está actualmente en el modo TV. Si es así, Stop() la TVModeSequence, desactiva InTVMode y establece CurrentCameraIndex en -1. Se usa -1 porque debes indexar en la siguiente secuencia cinemática la matriz CameraSwitches, que sería el índice 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. A continuación, debes averiguar la siguiente cámara a la que cambiar en función del índice de la cámara actual. Para ello, establece una nueva variable NextCameraValue al Mod del CurrentCameraIndex + 1 y CameraSwitches.Length. Esto te permite fijar NextCameraValue a un valor que esté entre 0 y la longitud de CameraSwitches y evita que obtengas un NextCameraValue que esté fuera de la matriz CameraSwitches. Una vez que tengas NextCameraValue, establece CurrentCameraValue en NextCameraValue, y llama a DoCameraSwitch() pasando el agent y el CurrentCameraIndex. Tu función DoNextCamera() completa debería tener el siguiente aspecto:

   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. Para cambiar a la cámara anterior, añade una nueva función nombrada DoPreviousCamera() a la clase show_template_device. Copia el código de DoNextCamera() en esta función. Al comprobar si el jugador está en el modo TV, establece CurrentCameraIndex en 0 en lugar de -1. Además, cambia NextCameraValue para que sea el Mod de CurrentCameraIndex - 1 y CameraSwitches.Length. Tu función DoPreviousCamera() completada debería tener este aspecto:

   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)

Cuando un jugador está sentado en TheChair y mirando desde una cámara diferente en CameraSwitches, puede volver a los modos TV o Mirar libremente. Anteriormente configuraste las funciones DoReturnToFreeLook() y DoReturnToTVMode(), y ahora las completarás.

1. En la función DoReturnToFreeLook(), verifica si el jugador está actualmente en el modo TV. Si es así, detén la TVModeSequence mediante Stop() y desactiva InTVMode. Haz lo mismo con CurrentSequence. Para ello, comprueba si CurrentSequence contiene una secuencia cinemática llamando a Stop() y desactivándola si es así.

   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. Ahora aplica la función Register() al agente con el activador de entrada ReturnToTVMode, y anula el registro mediante Unregister() con el activador ReturnToFreeLook, ya que no te interesa que un jugador mire libremente mientras ya está allí. Tu función DoReturnToFreeLook() completa debería tener el siguiente aspecto:

   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 función DoReturnToTVMode() requiere más lógica, ya que al volver al modo TV es necesario iniciar la TVModeSequence en el momento actual de la MainSequence. En primer lugar, comprueba si el jugador ya está en el modo TV cuando llames a esta función. Si es así, simplemente vuelve mediante return, ya que no necesitas hacer nada. Luego comprueba si CurrentSequence contiene una secuencia cinemática, llamando a Stop(), y desactivándola (false) si es así.

   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. Ahora tienes que averiguar dónde se encuentra la MainSequence a lo largo de su reproducción e iniciar la TVModeSequence desde el mismo punto. Obtén el tiempo de reproducción de MainSequence llamando a GetPlayBackTime() y guárdalo en una variable CurrentSeekTime. Establece el tiempo de reproducción de TVModeSequence en CurrentSeekTime utilizando SetPlaybackTime() y reproduce (Play()) la secuencia pasando el agente. A continuación, activa (true) InTVMode.

   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. Finalmente, anula el registro del agente del activador de entrada ReturnToTVMode con Unregister(), y regístralo mediante Register() con el activador ReturnToFreeLook. Tu función DoReturnToTVMode() completa debería tener el siguiente aspecto:

   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)

Cómo vincular todo

Has configurado un montón de funciones en la parte anterior de este tutorial, y ahora es el momento de vincularlas todas a los diversos activadores de entrada que las llaman.

1. En OnSeated(), registra (Register()) el agente con los activadores de entrada ReturnToFreeLook, NextCamera y PreviousCamera, ya que estos son los activadores a los que un jugador tendrá acceso inicialmente cuando se siente en la silla por primera vez. A continuación, establece ReturnToFreeLookSubscription, NextCameraSubscription y PreviousCameraSubscription suscribiendo cada activador de entrada a su función asociada. Configura la ReturnToTVModeSubscription y la ChairExitSubscription del mismo 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. Añade una nueva función CancelSubscription() que toma un valor opcional cancelable a la clase show_template_device. En CancelSubscription(), comprueba si Subscription contiene un valor. Si es así, cancélala mediante Cancel(). Tu función CancelSubscription() finalizada debería tener este aspecto:

   Verse

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

   Copy full snippet(4 lines long)

3. Cuando un jugador abandona la silla, debes detener las secuencias que se estén reproduciendo en él, así como cancelar las suscripciones a activadores de entrada a los que estuviera registrado. En la función OnChairExited(), al igual que en DoReturnToFreeLook(), comprueba si el jugador está en el modo TV, así como si CurrentSequence contiene una secuencia cinemática. Si es así, llama a Stop() en cada secuencia, y desactiva InTVMode (false) si el jugador se encuentra en el modo TV. Luego desactiva CurrentSequence (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. Ahora cancela todas las suscripciones de los jugadores pasando cada suscripción a la función CancelSubscription(). También anula el registro del jugador a cada activador de entrada mediante Unregister(), ya que no debería poder acceder a esos botones al abandonar la silla. Tu función OnChairExited() finalizada debería tener este aspecto:

   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)

Guarda la secuencia de comandos en Visual Studio Code, compílala y haz clic en Iniciar sesión en la barra de herramientas de UEFN para probar la plantilla. Cuando hagas la prueba de juego, el espectáculo debería comenzar al sentarte en el dispositivo Silla. Durante la actuación, deberías poder cambiar entre el modo TV, el modo Mirar libremente y distintos ángulos de cámara. La vuelta al modo TV debería alinear la secuencia del modo TV con la secuencia principal. Cuando termine el espectáculo, deberás volver a mirar libremente y abandonar la silla.