Modelo de clube de comédia stand-up

Este tutorial é um documento que acompanha o Modelo de stand-up em Verse, que demonstra como usar os dispositivos que sustentam uma experiência social e cinemática dentro de um clube de comédia:

• Usando ativos detalhados do MetaHumans Animator com os dispositivos de personagem

• Acionando eventos de jogo nas vinculações de comando do jogador com os dispositivos Comando de Gatilho

• Como congelar um jogador no lugar para visualizar a experiência com o dispositivo Cadeira

Um dispositivo Verse executa o show com os conceitos essenciais do código Verse explicados abaixo.

Confira o modelo de stand-up em Verse na seção Exemplos em destaque do UEFN (Unreal Editor para Fortnite).

Dispositivos usados:

• 1 Cadeira

• 4 Gatilhos de Entrada

• 4 Personagens

• 6 Sequências Cinematográficas

Os conceitos de Verse usados neste tutorial são os seguintes:

• Assinaturas

• Declarações "if"

• Matrizes

• Sequências cinematográficas

• API do dispositivo Cadeira

• API do dispositivo Gatilho de Entrada

Configurações da ilha

Aqui estão as Configurações da Ilha modificadas para o modelo de stand-up em Verse:

Dispositivo Cadeira

Quando o jogador entra no clube de comédia, ele vê uma cadeira na frente de um palco iluminado. Ele é solicitado a sentar nessa cadeira. Sentar na cadeira mantém o jogador em um local fixo e dá início a uma série de eventos que o conduzirá pelo resto da experiência.

Estas são as Opções do Usuário modificadas para o dispositivo Cadeira:

Dispositivos Gatilho de Entrada

Um dispositivo Gatilho de Entrada é combinado com o dispositivo Cadeira. Ele vincula as entradas do jogador a várias ações, que são acionadas sempre que o jogador pressionar o botão designado. Os gatilhos de entrada são configurados para permitir que o jogador altere as câmeras enquanto a apresentação acontece.

O dispositivo tem doze entradas disponíveis dentre as quais escolher. Quando você escolhe uma entrada, pode adicionar uma descrição de HUD para esclarecer o que a nova entrada faz.

Estas são as Opções do Usuário modificadas para este dispositivo. Os dispositivos terão uma vinculação e uma descrição de HUD diferente conforme são vinculados a diferentes sequências cinematográficas.

Dispositivos Personagem

Os dispositivos de Personagem permitem que você interaja diretamente com o jogador ou com outros personagens em uma cena. Este modelo usa quatro personagens que alternam-se durante a rotina de palco.

Estas são as Opções do Usuário modificadas para o dispositivo Personagem:

O personagem principal fica sentado nas escada dos bastidores e o resto dos personagens ficam esperando em uma saleta nos fundos.

Experimente com diferentes revestimentos de personagens do menu suspenso Personagem e veja como eles ficam no palco!

Dispositivos Sequência Cinematográfica

Os seis dispositivos Sequência Cinematográfica permitem que o jogador visualize o show de vários ângulos permanecendo sentado no dispositivo Cadeira.

Esta página não detalha a criação de sequências cinematográficas. Para obter mais informações, consulte a página Sequencer e Control Rig e, para se aprofundar mais, confira Como criar filmes na Unreal Engine.

A única modificação para este dispositivo é a sequência cinematográfica carregada.

Como o Verse comanda o show

Esta modelo usa Verse para iniciar o show quando um jogador senta na cadeira, além de alterar a câmera para uma visão cinematográfica chamada Modo TV. O Verse também permite que os jogadores alternem entre várias câmeras, além de voltar para o Modo TV ou Vista Livre para aproveitarem diferentes experiências de visualização.

Crie um novo dispositivo Verse no seu projeto chamado show_template_device.verse usando o Explorador do Verse e arraste o dispositivo para o modelo. Clique duas vezes no arquivo Verse para abri-lo no Visual Studio Code.

Você definiu os dispositivos no seu modelo que ajudam a comandar o show de stand-up e agora referenciará esses dispositivos no seu código.

Adicione os seguintes campos no arquivo show_template_device:

1. Primeiramente, acima da definição da classe show_template_device, adicione um log_channel chamado 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. Agora, sobre a definição de classe show_template_device, adicione um registrador que usa o canal log_show_template_device para você saber quais declarações Print() estão vindo desse 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. Um dispositivo Cadeira editável chamado TheChair. Essa é a cadeira em que os jogadores vão sentar para começar o show de stand-up.

   Verse

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

   Copy full snippet(3 lines long)

4. Dois dispositivos Sequência Cinematográfica editáveis chamados MainSequence e TVModeSequence. O MainSequence é a sequência cinematográfica que comanda o show de stand-up, conduzindo a animação e o áudio no dispositivo Personagem no nível. TVModeSequence alterna a câmera do jogador para um modo de visualização que segue MainSquence, alternando entre vários â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. Uma matriz editável de cinematic_sequence_device chamada CameraSwitches. Essa matriz contém referências a cada uma das câmeras que os jogadores podem acessar durante o show.

   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. Quatro input_trigger_devices editáveis. Cada um desses dispositivos usa a entrada do jogador para alternar entre os diferentes modos de câmera. O gatilho ReturnToFreeLook leva o jogador de volta à câmera padrão, enquanto ReturnToTVMode leva o jogador de volta a TVModeSequence. A câmera NextCamera e PreviousMode alterna o jogador entre as diferentes sequências cinematográficas na 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. Uma dispositivo Sequência Cinematográfica opcional variável chamado CurrentSequence. Se uma sequência cinematográfica como TVModeSequence estiver sendo reproduzida, esta opção armazena uma referência a ela. Não queremos reproduzir várias sequências cinematográficas para o personagem de uma vez, então você pode usar esta opção para desligar a sequência cinematográfica enquanto estiver alternando para uma nova.

   Verse

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

   Copy full snippet(2 lines long)

8. Duas variáveis lógicas chamadas MainSequencePlaying e InTvMode. Elas permitem que você acompanhe se MainSequence ou TVModeSequence estão sendo reproduzidas, 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. Uma variável int chamada CurrentCameraIndex. Ela acompanha o índice da sequência cinematográfica na matriz CameraSwitches que está em reprodução atualmente.

   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 variáveis cancelable opcionais que monitoram as assinaturas de todos os eventos referenciados nesse modelo. Diferentes funções precisam ser executadas quando o jogador alterna entre as câmeras, volta para a Vista Livre ou o Modo TV, ou sai do dispositivo Cadeira. Posteriormente neste tutorial, você assinará as funções nos eventos que as acionam, e armazenará uma referência a cada assinatura, de forma que possa cancelá-las quando não forem mais necessárias.

    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. Salve o script no Visual Studio Code e compile-o para atualizar seu dispositivo criado com Verse no nível.

12. Selecione show_template_device no seu modelo. No painel Detalhes, atribua as referências dos dispositivos no script ao dispositivo associado no nível, incluindo cada um dos gatilhos de entrada e sequências cinematográficas.

    

Como acionar a sequência

O show começa quando um jogador senta no dispositivo Cadeira, a sequência cinematográfica deve começar assim que o jogador estiver sentado. Siga os passos abaixo para acionar a sequência principal quando o jogador sentar na cadeira, assim como iniciar o Modo TV para que o jogador possa assistir ao show.

1. Adicione uma nova função RunSequence() à classe show_template_device. Essa função usa o agente que começou o show e dá início a MainSequence e TVModeSequence. Adicione o modificador à RunSequence() para que ela rode de forma assíncrona. Essa função precisa ser assíncrona para que você possa rodar outro código paralelamente a ela e permitir que o jogador alterne entre as visualizações de câmera sem interromper o 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. Em RunSequence(), chame Sleep() por um segundo para deixar a animação do jogador sentado na cadeira ser concluída antes de começar o show. Em seguida, chame Play() em MainSequence e defina MainSequencePlaying como "true".

   Verse

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

   Copy full snippet(7 lines long)

3. Chame Play() em TVModeSequence, passando o agente que começou o show para mudar sua câmera para a visualização cinematográfica. Defina InTVMode como "true" e chame uma nova função que aguarda o fim de MainSequence chamada AwaitMainSequenceEnding(), passando o agente. Você configurará essa função no próximo passo. Seu código de RunSequence() completo ficará desta forma:

   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. Adicione uma nova função AwaitMainSequecingEnding() à classe show_template_device que usa o agent de RunSequence(). Essa função também precisa do modificador <suspends>, pois desejamos que ela rode em segundo plano e seja acionada quando MainSequence terminar.

   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. Em AwaitMainSequencingEnding(), chame Await() em MainSequence.StoppedEvent(). Quando a MainSequence terminar, defina MainSequencePlaying como false e tire o jogador da cadeira usando a função Eject() da cadeira. Sua função AwaitMainSequencingEnding() completa ficará desta forma:

   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. Adicione duas novas funções DoReturnToTVMode() e DoReturnToFreeLook() à classe show_template_device. Essas funções lidam com a lógica quando um jogador retorna ao Modo TV ou Vista Livre, respectivamente, mas você vai deixá-las vazias por enquanto e preenchê-las em uma etapa 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. Adicione uma nova função OnSeated() à classe show_template_device que recebe o agente que sentou em 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. Em OnSeated(), se MainSequence ainda não estiver sendo reproduzida, gere uma função RunSequence(), passando o agente que sentou no dispositivo Cadeira. Caso contrário, chame DoReturnToTVMode() com o mesmo 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. Adicione uma nova função OnChairExited() à classe show_template_device que recebe o jogador que saiu da cadeira. Você vai preencher a lógica para esta função em um passo 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. Em OnBegin(), registre TheChair.SeatedEvent na função OnSeated(). Agora, sempre que um jogador sentar em TheChair, o show será executado.

    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)

Salve o script no Visual Studio Code, compile-o e clique em Iniciar sessão na barra de ferramentas do UEFN para testar o modelo. Quando você executa o seu jogo, sentar no dispositivo Cadeira deve iniciar o show, e definir a câmera do jogador para o modo cinematográfico. Quando o show termina, o jogador deve ser retirado da cadeira.

Como alternar entre as câmeras

Durante o show, o jogador sentado em TheChair pode alternar entre várias visualizações de câmera diferentes, manipuladas por diferentes sequências cinematográficas. Siga os passos abaixo para configurar a lógica para alternar entre essas diferentes sequências.

1. Adicione uma nova função DoCameraSwitch() à classe show_template_device. Essa função usa o agente para cuja câmera você está alternando assim como o int correspondente ao índice de sequência cinematográfica em 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. Em DoCameraSwitch(), em uma declaração if, obtenha a sequência cinematográfica no índice "Value" na matriz CameraSwitches. Em seguida, interrompa qualquer sequência que esteja em reprodução verificando se CurrentSequence contém uma sequência cinematográfica e chamando Stop() nela.

   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. Comece a reproduzir a nova sequência cinematográfica chamando Play() em CameraSwitch. Depois, defina CurrentSequence para informar qual sequência está em reprodução no momento. Finalmente, use Register() para registrar o agent para cuja câmera você está alternando com os gatilhos de entrada ReturnToTVMode e ReturnToFreeLook, permitindo que volte para esses modos ao visualizar outras câmeras. A sua função DoCameraSwitch() completa ficará desta forma:

   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 alternar entre a câmera anterior e a próxima, você definirá duas funções muito semelhantes, DoNextCamera() e DoPreviousCamera(). Preencha a lógica para a próxima câmera primeiro adicionando uma nova função DoNextCamera() à classe show_template_device. Essa função usa o agent para cuja câmera você está alternando.

   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. Em DoNextCamera(), verifique se o jogador está atualmente no Modo TV. Se sim, use Stop() na TVModeSequence, defina InTVMode como "false" e defina CurrentCameraIndex como -1. Usamos -1 aqui porque queremos indexar na próxima sequência cinematográfica a matriz CameraSwitches, que seria o í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. Depois, você precisa descobrir a próxima câmera para a qual alternar com base no índice da câmera atual. Para fazer isso, defina uma nova variável NextCameraValue para Mod de CurrentCameraIndex + 1 e CameraSwitches.Length. Isso permite que você fixe NextCameraValue a um valor entre 0 e o comprimento de CameraSwitches e evita obter um NextCameraValue que esteja fora da matriz CameraSwitches. Quando tiver NextCameraValue, defina CurrentCameraValue como NextCameraValue e chame DoCameraSwitch() passando o agent e CurrentCameraIndex. A sua função DoNextCamera() completa ficará desta forma:

   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 alternar para a câmera anterior, adicione uma nova função chamada DoPreviousCamera() à classe show_template_device. Copie o código de DoNextCamera() para essa função. Ao verificar se o jogador está no Modo TV, defina CurrentCameraIndex como 0 em vez de -1. Além disso, altere NextCameraValue para ser o Mod de CurrentCameraIndex - 1 e CameraSwitches.Length. A sua função DoPreviousCamera() completa ficará desta forma:

   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 um jogador está sentado em TheChair e está visualizando de uma câmera diferente em CameraSwitches, ele pode voltar para o modo TV ou a Vista Livre. Você configurou as funções DoReturnToFreeLook() e DoReturnToTVMode() antes, e vai preenchê-las agora.

1. Na função DoReturnToFreeLook(), verifique se o jogador está atualmente no Modo TV. Se sim, use Stop() em TVModeSequence e defina InTVMode como "false". Faça o mesmo com CurrentSequence, verificando se CurrentSequence contém uma sequência cinematográfica, chamando Stop() e definindo-a como "false" se sim.

   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. Agora use Register() para registrar o agente no gatilho de entrada ReturnToTVMode e use Unregister() para cancelar o registro no gatilho ReturnToFreeLook, pois não queremos retornar o jogador à Vista Livre enquanto ele já está lá. A sua função DoReturnToFreeLook() completa ficará desta forma:

   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. A função DoReturnToTVMode() precisa de mais lógica, pois ao voltar ao Modo TV você precisa iniciar TVModeSequence no momento atual de MainSequence. Primeiramente, verifique se o jogador já está no Modo TV quando esta função for chamada. Se for esse o caso, basta usar return, pois não há nada que você precise fazer. Em seguida, verifique se CurrentSequence contém uma sequência cinematográfica, chamando Stop() e definindo-a como false se sim.

   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. Agora você precisa descobrir onde MainSequence está em sua reprodução e iniciar TVModeSequence do mesmo ponto. Obtenha o tempo de reprodução de MainSequence chamando GetPlayBackTime() e salve-o em uma variável CurrentSeekTime. Defina o tempo de reprodução de TVModeSequence para CurrentSeekTime usando SetPlaybackTime() e use Play() na sequência que está passando o agente. Depois, defina InTVMode como true.

   Verse

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

   Copy full snippet(5 lines long)

5. Por fim, use Unregister() para cancelar o registro do agente no gatilho de entrada ReturnToTVMode e use Register() para registrá-lo no gatilho ReturnToFreeLook. A sua função DoReturnToTVMode() completa ficará desta forma:

   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)

É hora de juntar todas as partes

Você configurou muitas funções na parte anterior deste tutorial e agora chegou a hora de vincular todas elas aos vários gatilhos de entrada que as chamam.

1. Em OnSeated(), registre com Register() o agente nos gatilhos de entrada ReturnToFreeLook, NextCamera e PreviousCamera, pois eles são os gatilhos aos quais um jogador terá acesso inicialmente quando sentar pela primeira vez na cadeira. Depois, defina ReturnToFreeLookSubscription, NextCameraSubscription e PreviousCameraSubscription assinando cada gatilho de entrada à sua função associada. Defina ReturnToTVModeSubscription e ChairExitSubscription da mesma forma.

   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. Adicione uma nova função CancelSubscription(), que usa o valor cancelável opcional para a classe show_template_device. Em CancelSubscription(), verifique se Subscription contém um valor. Se sim, cancele-o com Cancel(). Sua função CancelSubscription() completa deve ter a seguinte aparência:

   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 um jogador sai da cadeira, você precisa interromper todas as sequências em reprodução no jogador, além de cancelar todas as assinaturas aos gatilhos de entrada nos quais o jogador está registrado. Para a função OnChairExited(), como em DoReturnToFreeLook(), verifique se o jogador está no Modo TV, bem como se CurrentSequence contém uma sequência cinematográfica. Chame Stop() em cada sequência se assim for, e defina InTVMode como false se o jogador estiver no Modo TV. Depois defina CurrentSequence como 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. Agora cancele todas as inscrições do jogador passando todas as assinaturas para a função CancelSubscription(). Cancele também o registro do jogador com Unregister() de todos os gatilhos de entrada, pois eles não devem poder acessar esses botões ao sair da cadeira. A sua função OnChairExited() completa ficará desta forma:

   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)

Salve o script no Visual Studio Code, compile-o e clique em Iniciar sessão na barra de ferramentas do UEFN para testar o modelo. Quando você testar o jogo, sentar no dispositivo Cadeira deve iniciar o show. Durante o show, o jogador deve poder alternar entre o Modo TV, a Vista Livre e os vários ângulos de câmera. Ao voltar ao Modo TV, a sequência do Modo TV deve se alinhar à sequência principal. Quando o show terminar, o jogador deve voltar à Vista Livre e sair da cadeira.