Plataforma que desaparece ao tocar

Plataformas que desaparecem quando você aterrissa nelas são a base dos modos de jogo de plataforma, como pistas de obstáculos. É preciso que o jogador aja rapidamente a planeje para onde vai para que não caia.

Seguindo este tutorial, você aprenderá a criar uma plataforma que desaparece quando o jogador toca nela e reaparece um número aleatório de segundos depois usando o Verse no Unreal Editor para Fortnite (UEFN). Este exemplo mostra como criar uma área sobre a qual o jogador deve saltar de plataforma em plataforma para evitar uma queda. O código completo está incluído no final deste guia como referência.

Funcionalidade da linguagem Verse usada

• spawn: a expressão spawn é usada para chamar a função assíncrona que faz a plataforma reaparecer após um número aleatório de segundos.

APIs Verse usadas

• Sleep(): a API Sleep() é usada para inserir os atrasos entre o desaparecimento e o reaparecimento da plataforma após um período aleatório de tempo.

• GetRandomFloat(): a API GetRandomFloat() é usada para calcular uma quantidade aleatória de tempo antes que a plataforma reapareça.

• Propriedades editáveis: quatro propriedades são expostas ao UEFN — três floats para controlar os atrasos no desaparecimento e no reaparecimento da plataforma e a referência da própria plataforma.

• Eventos do dispositivo: você usará o TriggeredEvent do dispositivo Gatilho para saber quando um jogador pousa na plataforma.

Como configurar o nível

Este tutorial usa o Modelo inicial em Verse como ponto de partida. Para começar, inicialize um novo projeto a partir do exemplo de funcionalidade Dispositivo Verse.

Este exemplo usa os seguintes adereços e dispositivos:

• 1x Plataforma de Surgimento de Jogador: define onde o jogador surge no início do jogo.

• 4x Adereços Criativos: têm vários comportamentos que você pode chamar com Verse, como Hide() e Show() para alternar a visibilidade e a colisão da plataforma. Este tutorial usa a Plataforma de Flutuação A como plataforma de interação com o jogador, mas fique à vontade para alterá-la para se adequar às necessidades da sua experiência.

• 4x Gatilho: você usará esses dispositivos para saber quando um jogador pousa em cada plataforma.

Siga estas etapas para configurar o nível:

1. Adicione a Plataforma de Flutuação A à sua cena. Coloque-a acima do piso para que o jogador caia se não saltar da plataforma que desaparece a tempo. Dê o nome de RecyclePlatform à plataforma no Organizador.

   

2. Adicione um dispositivo Gatilho à cena e defina-o como um filho de sua RecyclePlatform. Coloque-o sobre a plataforma e redimensione-o para se encaixar sobre toda a plataforma. No Organizador, defina Visível no Jogo como False e Vezes que Pode Ser Acionado como 1.

   

3. Posicione o dispositivo Plataforma de Surgimento de Jogador na plataforma. É aqui que o jogador surgirá quando o jogo começar. No Organizador, desative a opção Visível no Jogo para que o jogador não possa ficar sobre a plataforma depois que surgir. A configuração completa deve ter a seguinte aparência:

   

Como criar o dispositivo

Este exemplo usa um dispositivo criado com Verse para definir o comportamento para fazer a plataforma desaparecer quando o jogador pousar nela e reaparecer uma quantidade aleatória de segundos depois. Siga estas etapas para criar esse dispositivo usando Verse.

1. Crie um novo dispositivo Verse chamado disappear_on_touch_platform usando o Explorador Verse. Para aprender a criar um novo dispositivo em Verse, consulte Como criar seu próprio dispositivo usando Verse.

   

2. Arraste o dispositivo disappear_on_touch_platform do Navegador de Conteúdo para o nível.

Como editar as propriedades do dispositivo no UEFN

Esta seção mostra como expor quatro propriedades do dispositivo ao UEFN, para que você possa personalizá-las no editor:

• Uma referência do dispositivo ao objeto criativo que você colocou no nível.

• Uma constante float, chamada DisappearDelay, para armazenar o tempo de espera após o jogador tocar na plataforma para ocultá-la.

• Duas constantes float chamadas DelayMin e DelayMax que armazenam os tempos mínimo e máximo de espera antes de fazer a plataforma reaparecer. Esses dois valores definem o intervalo permitido ao obter um número aleatório.

Siga estas etapas para expor essas propriedades do dispositivo disappear_on_touch_platform criado na seção anterior.

1. Abra o Explorador Verse e clique duas vezes em disappear_on_touch_platform.verse para abrir o código no Visual Studio Code.

2. Na definição da classe disappear_on_touch_platform, adicione os seguintes campos:

   • Um float editável chamado DisappearDelay. Esse é o tempo de espera depois que o jogador toca na plataforma para ocultá-la. Inicialize este valor como 1.0, ou um segundo.

     Verse

       # How long to wait after the player touches the platform before hiding it.
       @editable
       DisappearDelay:float = 1.0
     

     Copy full snippet(3 lines long)

   • Um float editável chamado DelayMin. Essa é o tempo mínimo de espera antes de fazer a plataforma reaparecer. Inicialize-o como 3.0, ou três segundos.

     Verse

       # The minimum amount of time to wait before making the platform reappear.
       @editable
       DelayMin:float = 3.0
     

     Copy full snippet(3 lines long)

   • Um float editável chamado DelayMax. Essa é o tempo máximo de espera antes de fazer a plataforma reaparecer. Inicialize-o como 4.0, ou quatro segundos.

     Verse

       # The maximum amount of time to wait before making the platform reappear.
       @editable
       DelayMax:float = 4.0
     

     Copy full snippet(3 lines long)

   • Um creative_prop editável chamado DisappearingPlatform. Essa é a plataforma no nível que desaparecerá e aparecerá periodicamente. Como seu código ainda não tem uma referência a esse objeto no nível, você instanciará isso com um arquétipo vazio creative_prop{}. Você atribuirá essa referência a sua plataforma flutuante mais tarde.

     Verse

       # Reference to the platform in the level.
       @editable
       DisappearingPlatform:creative_prop = creative_prop{}
     

     Copy full snippet(3 lines long)

   • Um trigger_device editável chamado PlatformTrigger. Você precisará do evento TriggeredEvent deste dispositivo para saber quando um jogador pousa na plataforma.

     Verse

       # The zone a player enters when landing on the platform.
       @editable
       PlatformTrigger:trigger_device = trigger_device{}
     

     Copy full snippet(3 lines long)

3. Os campos de classe disappear_on_touch_platform agora devem ficar assim:

   Verse

        # A Verse-authored creative device that can be placed in a level
        disappear_on_touch_platform := class(creative_device):
   		
            # How long to wait after the player touches the platform before hiding it.
            @editable
            DisappearDelay:float = 1.0
   		
            # The minimum amount of time to wait before making the platform reappear.
            @editable
            DelayMin:float = 3.0
   
   Expand code Copy full snippet(22 lines long)

   É útil usar o atributo @editable para expor valores como ToggleDelay ao editor a partir de seus scripts. Assim, você pode personalizar seus valores no UEFN sem ter que recompilar o código Verse a todo momento, podendo iterar rapidamente e encontrar os valores adequados para a sua experiência de jogo.

4. Salve o script no Visual Studio Code.

5. Na barra de ferramentas do UEFN, clique em Verse e depois em Compilar código Verse para atualizar o dispositivo disappear_on_touch_platform no nível.

6. No painel Organizador no UEFN, selecione o dispositivo disappear_on_touch_platform para abrir o painel Detalhes.

7. No painel Detalhes, sob a plataforma que desaparece ao tocar, defina a Plataforma como RecyclePlatform (o adereço criativo adicionado no nível) clicando no seletor de objetos e selecionando o dispositivo de plataforma na janela de visualização.

8. Agora que você tem um adereço referenciado pelo seu dispositivo Verse, selecione os dois dispositivos e duplique-os várias vezes no nível para criar uma série de plataformas entre as quais o jogador vai saltar. Cada novo dispositivo Verse que você cria deve fazer referencia a sua própria plataforma.

   

Como ocultar e exibir a plataforma

Agora que você já configurou o nível e os dispositivos, pode adicionar a funcionalidade para exibir e ocultar a plataforma quando um jogador pousar nela. Siga estas etapas para adicionar esse comportamento à classe disappear_on_touch_platform:

1. A classe creative_prop tem dois métodos para alternar sua visibilidade: Hide() e Show(). Voltando ao Visual Studio Code, em OnBegin(), chame Hide() e depois Show() em DisappearingPlatform.

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
   
            # Make the platform invisible.
            DisappearingPlatform.Hide()
   
            # Make the platform visible.
            DisappearingPlatform.Show()

   Copy full snippet(8 lines long)

   Se você executar esse código, não verá a plataforma desaparecer e reaparecer porque as chamadas de Hide() e Show() ocorrem imediatamente uma após a outra.

2. Para fazer com que a plataforma permaneça em um estado visível/invisível por mais tempo, você pode adicionar um atraso chamando Hide() ou Show() usando Sleep(). A função Sleep() suspende a execução de uma rotina, e você especifica a quantidade de tempo (em segundos) para suspender a execução passando um argumento float para a função. Chame Sleep() antes de cada chamada de Hide() e Show(), passando DisappearDelay que você definiu anteriormente.

   ~~~(verse) # É executado quando o dispositivo é iniciado em um jogo em execução OnBegin<override>()<suspends>:void=

   # Espere a quantidade de segundos em DisappearDelay. Sleep(DisappearDelay)

   # Deixe a plataforma invisível. DisappearingPlatform.Hide()

   # Espere a quantidade de segundos em DisappearDelay. Sleep(DisappearDelay)

   # Deixe a plataforma visível. DisappearingPlatform.Show() ~~~

   Agora, se você executar este código, a plataforma ficará invisível por um segundo (o tempo definido por DisappearDelay) antes de se tornar visível pelo resto do jogo.

   A função Sleep() só pode ser chamada em um contexto assíncrono. Como o método OnBegin() já é um contexto assíncrono, pois tem um especificador suspends, você não precisa fazer mais nada. Para saber mais sobre o especificador suspends, consulte Especificadores e atributos.

3. Variar o tempo que a plataforma demora para reaparecer pode deixar o jogo mais interessante. Em vez de fornecer sempre o mesmo valor para Sleep(), você pode obter um número aleatório de segundos com a função GetRandomFloat() e passar seu valor para Sleep().

   • Na parte superior do arquivo, adicione using { /Verse.org/Random } para usar a função GetRandomFloat().

     Verse

       using { /Fortnite.com/Devices }
       using { /Verse.org/Random }
       using { /Verse.org/Simulation }
       using { /UnrealEngine.com/Temporary/Diagnostics }
     
       # See https://dev.epicgames.com/documentation/en-us/uefn/create-your-own-device-in-verse for how to create a verse device.
     
       # A Verse-authored creative device that can be placed in a level
     
       disappear_on_touch_platform := class(creative_device):
     

     Copy full snippet(10 lines long)

   • Use a função GetRandomFloat() como um argumento para Sleep() quando estiver decidindo o tempo pelo qual esperar antes de fazer a plataforma reaparecer e defina o intervalo de segundos permitido com DelayMin e DelayMax.

     Verse

       # Runs when the device is started in a running game
       OnBegin<override>()<suspends>:void=
     
       # Wait for DisappearDelay seconds.
       Sleep(DisappearDelay)
     
       # Make the platform invisible.
       DisappearingPlatform.Hide()
     
       # Wait between DelayMin and DelayMax seconds.
     
     Expand code Copy full snippet(14 lines long)

   Agora a plataforma aguardará 1.0 segundos antes de desaparecer e reaparecerá entre 3.0 e 4.0 segundos depois.

Como detectar o pouso do jogador na plataforma

Para poder detectar quando o jogador pousa na plataforma, você pode se inscrever no evento TriggeredEvent que a classe trigger_device expõe. O gatilho só envia o TriggeredEvent quando um jogador passa por ele. Como você definiu Vezes que Pode Ser Acionado como 1, você precisará chamar Reset() no gatilho para redefinir seu estado e permitir que ele envie o TriggeredEvent novamente.

Siga estas etapas para detectar quando o jogador toca a plataforma e use o código que você escreveu na seção anterior para fazer com que a plataforma seja ocultada e reapareça em resposta.

1. O TriggeredEvent exige uma assinatura de função com um player opcional como um parâmetro e void como o tipo de retorno. O agente é opcional nesta função pois você também pode ativar os dispositivos Gatilho por meio de código, então precisa verificar se um jogador foi quem o ativou. Adicione um novo método à classe disappear_on_touch_platform chamado OnPlayerTouch().

   Verse

        OnPlayerTouch(ActivatingPlayer:?agent):void=
   

   Copy full snippet(1 line long)

2. Em OnPlayerTouch(), em uma expressão if, tente obter o jogador a partir da opção ActivatingPlayer. Se essa chamada for efetivada, você sabe que um jogador ativou o gatilho, e não foi um código.

   Verse

        OnPlayerTouch(ActivatingPlayer:?agent):void=
            if:
                Player := ActivatingPlayer?
            then:
                Print("A player touched a platform!")
   

   Copy full snippet(5 lines long)

3. Em OnBegin(), inscreva-se em PlatformTrigger.TriggeredEvent usando OnPlayerTouch como o identificador do evento. Agora, sempre que um jogador pousar em uma plataforma, o TriggeredEvent será ativado e OnPlayerTouch() será executado.

   Verse

        OnBegin<override>()<suspends>:void=
   
            # Subscribe to the PlatformTrigger's TriggeredEvent to know
            # when a player lands on the platform.
            PlatformTrigger.TriggeredEvent.Subscribe(OnPlayerTouch)

   Copy full snippet(5 lines long)

4. Quando a plataforma é ocultada, os jogadores devem poder ativar o gatilho, pois eles devem atravessar a plataforma. Para gerenciar isso, em OnBegin(), adicione chamadas a PlatformTrigger.Disable() e Enable() depois de Hide() e Show(), respectivamente. Agora não será possível interagir com o seu gatilho enquanto a plataforma estiver oculta.

   Verse

        OnBegin<override>()<suspends>:void=
   
            # Subscribe to the PlatformTrigger's TriggeredEvent to know
            # when a player lands on the platform.
            PlatformTrigger.TriggeredEvent.Subscribe(OnPlayerTouch)
   
            # Wait for DisappearDelay seconds.
            Sleep(DisappearDelay)
   
            # Hide the platform and disable the trigger.
   
   Expand code Copy full snippet(19 lines long)

Embora você precise ocultar a plataforma quando um jogador pousa nela, você não pode adicionar o código para ocultar e exibir a plataforma diretamente ao método OnPlayerTouch(). A função Sleep() só pode ser chamada em um contexto assíncrono, e você não pode adicionar o especificador suspends a OnPlayerTouch(), porque TriggeredEvent não permite funções assíncronas como seu manipulador de eventos. Em vez disso, você pode usar spawn para chamar uma função assíncrona de OnPlayerTouch(). Siga estas etapas para adicionar a função assíncrona.

1. Adicione um novo método RecyclePlatform() à definição da classe disappear_on_touch_platform. Adicione o modificador <suspends> para permitir que esse código seja executado de forma assíncrona e mova o código para ocultar e exibir a plataforma e o gatilho de OnBegin para o bloco de código RecyclePlatform().

   Verse

        # Hide the platform and reset the PlatformTrigger. Then wait a random amount of time and reactivate show the platform.
        RecyclePlatform()<suspends> : void =
   
            # Wait for DisappearDelay seconds.
            Sleep(DisappearDelay)
   
            # Hide the platform and disable the trigger.
            DisappearingPlatform.Hide()
            PlatformTrigger.Disable()
   
   
   Expand code Copy full snippet(16 lines long)

2. Em OnPlayerTouch(), chame spawn{} em RecyclePlatform() para executar o código de forma assíncrona. Sua função RecyclePlatform() completa deve ficar assim:

   Verse

        # Runs when a player lands on the platform. Calls RecyclePlatform() to hide the platform
        # and reset trigger state.
        OnPlayerTouch(ActivatingPlayer:?agent):void=
            if:
                Player := ActivatingPlayer?
            then:
                Print("A player touched a platform!")
                spawn{RecyclePlatform()}
   

   Copy full snippet(8 lines long)

   Se você executar esse código, a plataforma desaparecerá e reaparecerá quando o jogador subir pela primeira vez nela.

   Assíncrono sugere que um trecho de código pode levar algum tempo para ser concluído. Nesse caso, por exemplo, reiniciar o ciclo da plataforma leva alguns segundos devido a todas as chamadas Sleep(). As funções assíncronas permitem realizar operações sem bloquear a execução do código que chama a função assíncrona. Para saber mais sobre contextos assíncronos e a expressão spawn, consulte Simultaneidade.

3. No momento, o TriggeredEvent só é enviado na primeira vez que o jogador pousa na plataforma. Para fazer com que o evento possa ser acionado novamente, você pode chamar uma redefinição do gatilho. Em RecyclePlatform(), chame Reset() em PlatformTrigger depois de chamar Enable().

   Verse

        # Hide the platform and reset the PlatformTrigger. Then wait a random amount of time and reactivate show the platform.
        RecyclePlatform()<suspends> : void =
   
            # Wait for DisappearDelay seconds.
            Sleep(DisappearDelay)
   
            # Hide the platform and disable the trigger.
            DisappearingPlatform.Hide()
            PlatformTrigger.Disable()
   
   
   Expand code Copy full snippet(19 lines long)

4. Salve o código e clique em Verse e em Compilar código Verse para compilar o código.

5. Clique em Iniciar Sessão na barra de ferramentas do UEFN para testar o nível.

6. Quando você testa o nível, cada plataforma deve desaparecer quando você pousa nela e reaparecer uma quantidade aleatória de segundos depois.

Script completo

O código a seguir é o script completo para fazer uma plataforma desaparecer quando o jogador pousar nela e reaparecer após alguns segundos.

using { /Fortnite.com/Devices }
using { /Verse.org/Random }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

# See https://dev.epicgames.com/documentation/en-us/uefn/create-your-own-device-in-verse for how to create a verse device.
# A Verse-authored creative device that can be placed in a level
disappear_on_touch_platform := class(creative_device):

    # How long to wait after the player touches the platform before hiding it.

Por si só

Depois de concluir este tutorial, você terá aprendido a criar um dispositivo usando Verse que faz uma plataforma desaparecer quando o jogador pousa nela e reaparecer uma quantidade aleatória de segundos depois.

Usando o que você aprendeu, tente o seguinte:

• Teste os tamanhos e as posições das plataformas para criar um desafio interessante.

• Neste exemplo, o jogador não marca pontos e nada acontece quando ele cai. Você consegue pensar em como implementaria um sistema de pontuação e uma condição de derrota?