Plantilla de club de comedia

Este tutorial es un complemento para la plantilla de comedia en Verse, que demuestra cómo usar dispositivos para crear una experiencia social y cinemática dentro de un club de comedia.

• Utiliza recursos detallados de animador de MetaHuman con los dispositivos de personajes

• Activa eventos de jugabilidad con las asignaciones de entradas de jugadores con los dispositivos activadores de botón

• Fija a un jugador para ver la experiencia con el dispositivo de silla

Un dispositivo de Verse se encarga de todo el espectáculo, con los conceptos clave del código de Verse detallados más adelante.

Puedes encontrar la plantilla de comedia en verse en la sección de ejemplos destacados de UEFN (Unreal Editor para Fortnite).

Dispositivos usados:

• 1 x Silla

• 4 x Activadores de entrada

• 4 x Personajes

• 6 x Secuencias cinemáticas

Los conceptos de Verse que se utilizan en este tutorial son:

• Suscripciones

• Declaraciones If

• Matrices

• Secuencias cinemáticas

• API de dispositivo de silla

• API de dispositivo de activador de botón

ajustes de isla

Estos son los ajustes de isla modificados para la plantilla de comedia de Verse.

Dispositivo de silla

Cuando el jugador entre caminando al club de comedia, verá una silla en un escenario iluminado. Se le indicará que se siente en la silla. Sentarse en la silla fija al jugador en un punto y comienza con la cadena de eventos que lo llevará por el resto de la experiencia.

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

Dispositivos de activador de botón

El dispositivo de activador de botón va de la mano con el dispositivo de silla. Su función es vincular las entradas del jugador a ciertas acciones, que se activan cada vez que el jugador presiona el botón reasignado. Los activadores de entrada se configuran para que el jugador pueda cambiar su vista de cámara mientras se desarrolla el show.

El dispositivo contiene doce entradas disponibles para elegir. Una vez que elijas una entrada, puedes añadir una descripción de HUD para aclarar qué hace la nueva entrada.

Estas son las opciones de usuario modificadas para este dispositivo. Cada uno de los dispositivos tendrá una asignación y descripción de HUD distintas porque se vinculan a diferentes dispositivos de secuencia cinemática.

Dispositivos de personaje

Los dispositivos de personaje representan una manera de interactuar directamente con el jugador o con otros personajes en una escena. Esta plantilla utiliza cuatro personajes que se alternan en la rutina del escenario.

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

El personaje principal se sienta en una escalera tras bambalinas, mientras que el resto de los personajes esperan en una pequeña habitación en la parte de atrás.

¡Experimenta con distintos atuendos de personajes en el menú desplegable Personaje y mira cómo lucen en el escenario!

Dispositivos de Secuencia cinemática

Los seis dispositivos de secuencia cinemática permiten que el jugador pueda ver el show desde distintos ángulos mientras se sienta en el dispositivo de silla.

Esta página no proporciona más detalles sobre la creación de secuencias cinemáticas. Para conocer más al respecto, consulta la página Sequencer y rigs de control. Si quieres todavía más detalles, consulta la página de uso de Sequencer (en inglés).

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

Cómo Verse se encarga del espectáculo

Esta plantilla utiliza Verse para comenzar el show cuando un jugador se sienta en el dispositivo de silla y también cambia su cámara a una vista cinemática llamada modo TV. También permite que el jugador cambie entre distintas cámaras, además de poder volver al modo TV o vista libre para tener diferentes experiencias de vista.

Crea un dispositivo de Verse nuevo llamado show_template_device.verse en tu proyecto con el explorador de Verse y arrastra el dispositivo a la plantilla. Haz doble clic en tu archivo de Verse para abrirlo en Visual Studio Code.

Ya estableciste dispositivos en tu plantilla que te permiten ejecutar el show y ahora tendrás que hacer referencia a ellos en tu código.

Añade los siguientes campos al archivo show_template_device:

1. Primero, arriba de la definición de clase show_template_device, añade un log_channel llamado 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):
   

   # 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 clase de show_template_device, añade un logger que use el canal log_show_template_device. De esta manera, podrás saber cuáles son las declaraciones Print() provenientes 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}
   

   # 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 de silla editable llamado TheChair. Esta es la silla en la que se sentarán los jugadores para comenzar el show de comedia.

   Verse

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

   # The chair device the player should sit in. @editable TheChair:chair_device = chair_device{}
   Copy full snippet(3 lines long)

4. Dos dispositivos de Secuencia cinemática editables llamados MainSequence y TVModeSequence. MainSequence es la secuencia cinemática que ejecuta el show de comedia y que controla la animación y audio en el dispositivo de personaje en el nivel. TVModeSequence cambia la cámara del jugador a un modo de vista que siga a MainSequence, alternando entre distintos á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{}
   

   # 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 llamada CameraSwitches. Esta matriz contiene referencias a cada una de las cámaras que los jugadores pueden ir eligiendo durante el show.

   Verse

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

   # 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 toma la entrada del jugador para alternar entre modos de cámara. El activador ReturnToFreeLook devuelve al jugador a la cámara predeterminada, mientras que ReturnToTVMode devuelve al jugador a TVModeSequence. Las cámaras NextCamera y PreviousMode hacen que el jugador vaya cambiando entre las distintas 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 codeCopy full snippet(15 lines long)

7. Una variable de dispositivo opcional de secuencia cinemática llamada CurrentSequence. Si se está reproduciendo una secuencia cinemática como TVModeSequence, esta opción almacena una referencia a ella. Si no quieres reproducir varias secuencias cinemáticas para el personaje a la vez, puedes utilizar esta opción para desactivar la secuencia actual cuando cambies a una nueva.

   Verse

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

   # The alternative camera sequence that is playing if valid. var CurrentSequence:?cinematic_sequence_device = false
   Copy full snippet(2 lines long)

8. Dos variables lógicas llamadas MainSequencePlaying y InTvMode. Te permiten rastrear cuando se reproducen MainSequence o 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
   

   # 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 llamada CurrentCameraIndex. Esto da seguimiento a la secuencia cinemática de la matriz CameraSwitches que se está reproduciendo actualmente.

   Verse

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

   # 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 cancelable opcionales que rastrean las suscripciones para todos los eventos referenciados en esta plantilla. Se deben ejecutar distintas funciones cuando el jugador alterne entre cámaras, necesite volver a vista libre o modo TV o cuando salga del dispositivo de silla. En una parte posterior de este tutorial, tendrás que suscribir estas funciones a los eventos que las activan y almacenar una referencia a cada suscripción para que puedas cancelarlas cuando ya no las necesites.

    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
    

    # 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. Elige el show_template_device en tu plantilla. En el panel de detalles, asigna cada referencia de dispositivo en tu secuencia de comandos al dispositivo asociado en el nivel, incluyendo a cada uno de tus activadores de entrada y secuencias cinemáticas.

    

Activación de la secuencia

El show comienza cuando un jugador se sienta en un dispositivo de silla. Es preferible que la secuencia cinemática comience cuando el jugador se haya sentado. Sigue los pasos a continuación para activar la secuencia principal cuando un jugador se siente en la silla, además de activar el modo TV para que el jugador también pueda ver.

1. Añade una función RunSequence() nueva a la clase show_template_device. Esta función toma al agente que inició el show e inicia tanto a MainSequence como a TVModeSequence. Añade el modificador a RunSequence() para que se ejecute de forma asíncrona. Esta función debe ser asíncrona para que puedes ejecutar más código de forma concurrente junto con ella, al mismo tiempo que permites que el jugador cambie de vistas de cámara sin interrumpir el código 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 =

   # 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() por un segundo para permitir que la animación del jugador que se sienta en la silla termine antes de comenzar el show. Luego llama a Play() en la MainSequence y establece MainSequencePlaying en verdadero.

   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()
   

   # 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 al agente que comenzó el show para cambiar su cámara a la vista cinemática. Establece InTVMode en verdadero y llama a una nueva función que espere el final de la MainSequence y que se llame AwaitMainSequenceEnding(), que pase al agente. Configurarás esta función en el paso siguiente. Tu código RunSequence() completo debería verse de la siguiente manera:

   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 codeCopy full snippet(16 lines long)

4. Añade una nueva función AwaitMainSequecingEnding() a la clase show_template_device para que tome al agent de RunSequence(). Esta función también necesita el modificador <suspends> porque necesitarás ejecutarla en segundo plano y activarla cuando termine 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 =

   # 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 termine la MainSequence, establece MainSequencePlaying en false y expulsa al jugador de la silla con la función de silla Eject(). Tu función AwaitMainSequencingEnding() completa debería verse de la siguiente manera:

   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)

   # 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 funciones nuevas, `DoReturnToTVMode() y DoReturnToFreeLook() a la clase show_template_device. Estas funciones gestionan la lógica que ocurre cuando un jugador vuelve al modo TV o a la vista libre respectivamente, pero los dejaremos vacío por ahora y nos encargaremos de llenarlos más adelante.

   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")
   

   # 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 tome 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")
   

   # 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 no se está reproduciendo ya, genera una función RunSequence(), pasando al agente que se sentó en el dispositivo de silla. De lo contrario, se debe llamar 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)
   

   # 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 al jugador que salió de la silla. Tendrás que llenar la lógica para 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")
   

   # 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, cuando un jugador se siente en TheChair, se presentará el show.

    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)

    # 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 Comenzar sesión en la barra de herramientas de UEFN para probar la plantilla. Cuando ejecutes tu juego, sentarse en la silla debería comenzar con el show y establecer la cámara del jugador al modo cinemático. Cuando el show termine, el jugador debería ser expulsado de la silla.

Cambio de cámaras

En el show, el jugador que se siente en TheChair puede alternar entre distintas vistas de cámara, que se gestionan con distintas secuencias cinemáticas. Sigue los pasos a continuación para establecer la lógica para cambiar entre las distintas secuencias.

1. Añade una nueva función DoCameraSwitch() a la clase show_template_device. Esta función toma al agente cuya cámara estás cambiando, así como un int correspondiente al índice de 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 =
   

   # 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 del valor del índice en la matriz CameraSwitches. Luego, detén cualquier secuencia que se esté reproduciendo al comprobar si CurrentSequence contiene una secuencia cinemática, para después llamar a Stop().

   Verse

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

   # 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. Empieza a reproducir la nueva secuencia cinemática al llamar Play() en CameraSwitch. Luego, establece CurrentSequence para saber cuál es la secuencia que se está reproduciendo actualmente. Finalmente, ejecuta Register() al agent cuya cámara estás cambiando con los activadores de entrada ReturnToTVMode y ReturnToFreeLook, para permitirles volver a esos modos cuando esté viendo otras cámaras. Tu función DoCameraSwitch() completa debería verse de la siguiente manera:

   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 codeCopy full snippet(16 lines long)

4. Para alternar entre las cámaras anteriores y siguientes, tendrás que establecer dos funciones muy similares: DoNextCamera() y DoPreviousCamera(). Completarás la lógica para la cámara 'siguiente' primero, así que añade una nueva función DoNextCamera() a la clase show_template_device. Esta función toma al agent 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")
   

   # 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 se encuentra en modo TV. Si es así, ejecuta Stop() en TVModeSequence, establece InTVMode en falso y establece CurrentCameraIndex en -1. Aquí utilizas -1 porque queremos pasar al índice de la siguiente secuencia cinemática de la matriz CameraSwitches, que tendrí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
   

   # 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. Entonces, necesitas conocer la siguiente cámara la que debes cambiar según el índice de la cámara actual. Para hacerlo, establece una nueva variable NextCameraValue para el Mod de CurrentCameraIndex + 1 y CameraSwitches.Length. Esto te permite establecer NextCameraValue en un valor entre 0 y la longitud de CameraSwitches e impide que obtengas un NextCameraValue que se salga de la matriz CameraSwitches. Una vez que tengas NextCameraValue, establece CurrentCameraValue a NextCameraValue y llama DoCameraSwitch(), pasando el agent y el CurrentCameraIndex. Tu función DoNextCamera() completa debería verse de la siguiente manera:

   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 codeCopy full snippet(14 lines long)

7. Para cambiar a la cámara anterior, añade una nueva función DoPreviousCamera() a la clase show_template_device. Copia el código de DoNextCamera() a esta función. Al comprobar si el jugador está en modo TV, establece CurrentCameraIndex en 0 en vez de -1. Además, cambia NextCameraValue para que sea el Mod de CurrentCameraIndex - 1 y CameraSwitches.Length. Tu función DoPreviousCamera() completa debería verse de la siguiente manera:

   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 codeCopy full snippet(14 lines long)

Cuando un jugador está sentado en TheChair y está viendo desde una cámara distinta en CameraSwitches, pueden volver a modo TV o a vista libre. Ya estableciste las funciones DoReturnToFreeLook() y DoReturnToTVMode(), ahora hay que llenarlas.

1. En la función DoReturnToFreeLook(), comprueba si el jugador se encuentra en modo TV. Si es así, ejecuta Stop() en TVModeSequence y establece InTVMode en falso. Haz lo mismo con CurrentSequence, comprueba si CurrentSequence contiene una secuencia cinemática, llama a Stop() y establécela en falso de ser 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
   

   # 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, ejecuta Register() en el agente con el activador de entrada ReturnToTVMode y ejecuta Unregister() con el activador de entrada ReturnToFreeLook, puesto que no queremos devolver a un jugador a la vista libre si ya se encuentra ahí. Tu función DoReturnToFreeLook() completa debería verse de la siguiente manera:

   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 codeCopy full snippet(17 lines long)

3. La función DoReturnToTVMode() necesita más lógica, puesto que, al volver al modo TV, necesitas comenzar la TVModeSequence en el tiempo actual de MainSequence. Primero, comprueba si el jugador ya se encuentra en modo TV cuando se llama esta función. De ser así, solo ejecuta return, puesto que no hay nada más por hacer. Luego, comprueba si CurrentSequence contiene una secuencia cinemática, llama a Stop() y establécela en false de ser 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
   

   # 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 debes averiguar en qué punto de reproducción se encuentra la MainSequence y comenzar TVModeSequence desde el mismo lugar. Obtén el tiempo de reproducción MainSequence mediante el llamado de GetPlayBackTime() y guárdalo en una variable llamada CurrentSeekTime. Establece el tiempo de reproducción de TVModeSequence a CurrentSeekTime mediante SetPlaybackTime() y ejecuta Play() en la secuencia, pasando al agente. Luego, establece InTVMode en 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
   

   # 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, ejecuta Unregister() en el agente del activador de entrada ReturnToTVMode y ejecuta Register() al activador de entrada ReturnToFreeLook. Tu función DoReturnToTVMode() completa debería verse de la siguiente manera:

   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 codeCopy full snippet(22 lines long)

Hora de unir todo

Estableciste muchas funciones en la parte anterior de este tutorial. Ahora, tienes que vincularlas todas a los distintos activadores de entrada que las llaman.

1. En OnSeated(), ejecuta Register() en el agente con los activadores de entrada ReturnToFreeLook, NextCamera y PreviousCamera, puesto que estos son los activadores a los que el jugador tendrá acceso inicialmente cuando se siente en la silla. Luego, establece ReturnToFreeLookSubscription, NextCameraSubscription y PreviousCameraSubscription al suscribir cada activador de entrada a su función asociada. Establece ReturnToTVModeSubscription y ChairExitSubscription de la misma manera.

   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 codeCopy full snippet(17 lines long)

2. Añade una nueva función CancelSubscription() que recibe un valor opcional cancelable a la clase show_template_device. En CancelSubscription(), comprobar si la Subscription contiene un valor. De ser así, ejecuta Cancel(). Tu función CancelSubscription() completa debería verse de la siguiente manera:

   Verse

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

   # 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 sale de la silla, debes detener cualquier secuencia que se esté reproduciendo y cancelar todas las suscripciones a activadores de entrada a las que se había registrado el jugador. En la función OnChairExited(), como en DoReturnToFreeLook(), comprueba si el jugador está en el modo TV y también si CurrentSequence contiene una secuencia cinemática. Llama a Stop() para cada secuencia de ser así y establece InTVMode en false si el jugador está en modo TV. Luego, establece CurrentSequence en 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 codeCopy full snippet(11 lines long)

4. Ahora, cancela todas las suscripciones del jugador al pasar cada suscripción por la función CancelSubscription(). También ejecuta Unregister() al jugador para cada activador de entrada, puesto que no debería poder acceder a esos botones si sale de la silla. Tu función OnChairExited() completa debería verse de la siguiente manera:

   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 codeCopy full snippet(28 lines long)

Guarda la secuencia de comandos en Visual Studio Code, compílala y haz clic en Comenzar sesión en la barra de herramientas de UEFN para probar la plantilla. Cuando hagas una prueba de juego, sentarte en la silla debería comenzar con el show. En el show, deberías poder alternar entre el modo TV, la vista libre y varios ángulos de cámara. Volver al modo TV debería alinear la secuencia de modo TV con la secuencia principal. Cuando el show termine, deberías volver al modo de vista libre y salir de la silla.