Plataformas que desaparecem de modo sincronizado

Uma série de plataformas que desaparecem é um elemento básico de modos de jogo de plataforma como pistas de obstáculos. Elas exigem que os jogadores saltem entre uma série de plataformas para não caírem e terem que recomeçar.

Seguindo este tutorial, você aprenderá a criar uma série de plataformas que aparecem e desaparecem em sequência usando um dispositivo criado com Verse no Unreal Editor para Fortnite (UEFN).

Funcionalidades da linguagem Verse usadas

• array: com o tipo array, você pode armazenar as referências da plataforma em conjunto para ter acesso rápido e evitar a duplicação de código.

• loop: o ciclo de aparecimento e desaparecimento da plataforma deve começar quando o jogo começar e ser executado continuamente. Este exemplo mostra como criar esse comportamento com a expressão loop em Verse.

• block: com a expressão block, você pode agrupar várias expressões para que sejam executadas em sequência.

• for: com a expressão for, você pode iterar sobre cada plataforma na sua matriz.

• sync: com a expressão sync e a concorrência estruturada você pode executar várias expressões ao simultaneamente tempo.

APIs Verse usadas

• Sleep(): como a API Sleep(), você pode escolher por quanto tempo as plataformas ficarão em seus estados invisível e visível.

• Propriedades editáveis: várias propriedades de dispositivos criados em Verse são expostas ao UEFN para que você possa personalizá-las no Editor: três atrasos para o comportamento das plataformas e quatro referências de dispositivo para as plataformas.

Instruções

Siga estas etapas para saber como configurar uma série de plataformas que desaparecem e aparecem periodicamente. O código completo está incluído no final deste guia como referência.

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:

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

• 6 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.

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 SynchronizedPlatform1 à plataforma no Organizador.

   

2. Duplique a plataforma várias vezes para criar uma linha. Depois coloque o dispositivo Plataforma de Surgimento de Jogador sobre a plataforma onde você quer que o jogador inicie. 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 de alternância da visibilidade das plataformas. Siga estas etapas para criar esse dispositivo usando Verse.

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

   

2. Arraste o dispositivo platform_series do Navegador de Conteúdo até o nível.

Como editar as propriedades do dispositivo no UEFN

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

• Três constantes float para armazenar por quanto tempo as plataformas devem ficar invisíveis/visíveis, chamadas HeadStart, AppearDelay e DisappearDelay.

• As referências dos dispositivos ao objeto criativo que você colocou no nível.

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

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

2. Para a definição da classe de platform_series, adicione os seguintes campos:

   • Um float editável chamado HeadStart. Ele representa quanto tempo esperar, em segundos, após as plataformas começarem a aparecer e antes de as plataformas começarem a desaparecer. Inicialize esse valor como 2.5 ou dois segundos e meio.

     Verse

       # How long to wait in seconds after platforms start appearing
       # before they start disappearing.
       @editable
       HeadStart:float = 2.5
     

     Copy full snippet(4 lines long)

   • Um float editável chamado AppearDelay. Ele representa quanto tempo esperar, em segundos, antes que a próxima plataforma apareça. Inicialize esse valor como 1.0 ou um segundo.

     Verse

       # How long to wait in seconds before the next platform appears.
       @editable
       AppearDelay:float = 1.0
     

     Copy full snippet(3 lines long)

   • Um float editável chamado DisappearDelay. Ele representa quanto tempo esperar, em segundos, antes que a próxima plataforma desapareça. Inicialize esse valor como 1.25, ou um segundo e vinte e cinco centésimos.

     Verse

       # How long to wait in seconds before the next platform disappears.
       @editable
       DisappearDelay:float = 1.25
     

     Copy full snippet(3 lines long)

   • Um creative_prop editável chamado DisappearingPlatform. Essa é a plataforma no nível que desaparecerá e aparecerá. 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

       # The in-level platform that disappears and reappears.
       @editable
       DisappearingPlatform:creative_prop = creative_prop{}
     

     Copy full snippet(3 lines long)

3. Os campos de classe de platform_series agora devem ter a seguinte aparência:

   Verse

        # A Verse-authored creative device that can be placed in a level
        platform_series := class(creative_device):
   		
        # How long to wait in seconds after platforms start appearing
        # before they start disappearing.
        @editable
        HeadStart:float = 2.5
   		
        # How long to wait in seconds before the next platform appears.
        @editable
   
   Expand code Copy full snippet(19 lines long)

   É útil usar o atributo @editable para expor valores como AppearDelay ao editor a partir de seus códigos. 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 em Compilar código Verse para atualizar o dispositivo platform_series que está no nível.

   

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

7. No painel Detalhes sob platform_series, defina DisappearingPlatform como SynchronizedPlatform1 (o adereço criativo adicionado no nível) clicando no seletor de objetos e selecionando a plataforma na janela de visualização.

Como ocultar e exibir uma plataforma

Agora que você configurou o nível e a primeira plataforma, vamos adicionar a funcionalidade para mostrar e ocultar a plataforma. Siga estas etapas para adicionar esse comportamento ao dispositivo platform_series:

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=
   		
            # Hide the platform.
            DisappearingPlatform.Hide()
   		
            # Show the platform.
            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

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

   Se você executar esse 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.

Como ocultar e mostrar várias plataformas

Embora você pudesse repetir o código na etapa anterior para todas as plataformas no nível que quer que desapareçam, criar uma matriz para armazenar todas as referências a dispositivos é mais eficiente. Assim, você pode iterar entre cada plataforma na matriz, executando o código em cada uma sem ter que duplicar o dispositivo Verse várias vezes. Siga estes passos para ocultar e exibir várias plataformas:

1. Na definição da classe de platform_series, altere o campo DisappearingPlatform para uma matriz de creative_prop chamada DisappearingPlatforms. Você usará essa matriz para iterar nas plataformas em ordem. Inicialize a variável com o valor padrão array{}, uma matriz vazia.

   Verse

        # The in-level platforms that disappear and reappear in sequence.
        @editable
        DisappearingPlatforms:[]creative_prop = array{}
   

   Copy full snippet(3 lines long)

2. Você pode usar a expressão for para iterar sobre os elementos da matriz. A expressão for usa o padrão X -> Y, para fornecer um par índice-valor. O índice está vinculado à parte esquerda (X) e o valor é vinculado à parte direita (Y). Neste caso, X é o número/índice da plataforma e Y, a referência de cada plataforma obtida da matriz. Primeiro, crie uma expressão for para iterar sobre cada elemento, e obtenha o índice de cada número na variável PlatformNumber.

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

3. Imprima o número da plataforma e chame Hide() para ocultar a plataforma. Depois, Sleep() pela quantidade de segundos em DisappearDelay.

   Verse

        # For each platform in DisappearingPlatforms, make it invisible and sleep.
        for:
            PlatformNumber -> DisappearingPlatform:DisappearingPlatforms
        do:
            # Hide the platform
            DisappearingPlatform.Hide()
            Print("Platform {PlatformNumber} is now hidden")
            Sleep(DisappearDelay)
   

   Copy full snippet(8 lines long)

4. Para exibir as plataformas novamente, você usará uma segunda expressão for depois da primeira. Itere sobre cada plataforma em DisappearingPlatforms da mesma forma, mas desta vez chame Show() para exibir a plataforma e Sleep() pela quantidade de segundos em AppearDelay.

   ~~~(verse) # Para cada plataforma em DisappearingPlatforms, faça com que fique visível em entre e suspensão. for: PlatformNumber -> DisappearingPlatform:DisappearingPlatforms do: # Exiba a plataforma. DisappearingPlatform.Show() Print("A plataforma {PlatformNumber} está visível") Sleep(AppearDelay) ~~~

5. Quando estiver escrevendo seu código, é uma boa ideia linhas que você possa reutilizar em funções separadas. Assim, você pode chamar o código de diferentes contextos e evitar ter que reescrever o mesmo código várias vezes. Dependendo da sua experiência talvez você queira ocultar e exibir as plataformas em diferentes situações, então criará funções para gerenciar esses casos. Adicione duas novas funções chamadas HideAllPlatforms() e ShowAllPlatforms() à definição da classe de platform_series. Mova a expressão for que gerencia ocultar as plataformas para HideAllPlatforms() e a expressão que gerencia exibir as plataformas para ShowAllPlatforms(). Como você está usando a função Sleep(), essas funções precisam ser assíncronas, então adicione o modificador <suspends> a cada uma. Depois, em OnBegin(), chame HideAllPlatforms() e ShowAllPlatforms().

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
            HideAllPlatforms()
            ShowAllPlatforms()
   
        HideAllPlatforms()<suspends>:void=
            # For each platform in DisappearingPlatforms, make it invisible and sleep.
            for:
                PlatformNumber -> DisappearingPlatform:DisappearingPlatforms
            do:
   
   Expand code Copy full snippet(24 lines long)

6. Como se encontra, o código será executado apenas uma vez. Para fazer as plataformas desaparecerem e reaparecerem enquanto o jogo estiver em execução, você pode usar a expressão loop para repetir esse comportamento. Para gerenciar esse comportamento, adicione uma expressão loop a OnBegin() que inclui chamadas a HideAllPlatforms() e ShowAllPlatforms(). Neste exemplo, você alternará a visibilidade das plataformas pelo tempo que o jogo fica em execução, então não há necessidade de adicionar uma expressão break para sair de loop.

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
            loop:
                # Hide all platforms.
                HideAllPlatforms()
   
                # Show all platforms.
                ShowAllPlatforms()

   Copy full snippet(8 lines long)

   Se você executar esse código, todas as plataformas desaparecerão em sequência primeiro e depois todas reaparecerão na mesma ordem, com o processo se repetindo até que o jogo termine.

7. Salve o código e compile-o. No painel Organizador no UEFN, selecione o dispositivo platform_series para abrir seu painel Detalhes.

8. No painel Detalhes, em DisappearingPlatforms, adicione um elemento de matriz para cada plataforma. Adicione novos elementos à matriz com o botão "Adicionar elemento", e depois clique no seletor de objetos e selecione o adereço criativo na janela de visualização. Certifique-se de que a ordem dessa matriz corresponda à ordem sobre a qual você quer iterar:

   

Se você executar o código agora, as plataformas desaparecerão em sequência primeiro e depois reaparecerão na mesma ordem, com o processo se repetindo até que o jogo termine.

Como sincronizar as plataformas que desaparecem e reaparecem

Para adicionar mais urgência à medida que o jogador salta pelos quadrados, você pode fazer as plataformas começarem a desaparecer enquanto as plataformas posteriores da sequência ainda estão aparecendo. Dessa forma, o jogador terá que correr pela série ou cairá. Para criar esse comportamento, as duas rotinas (ShowAllPlatforms() e HideAllPlatforms()) devem ser executadas ao mesmo tempo, com a segunda atrasada em relação à primeira, para que o jogador tenha uma vantagem inicial para pular para a próxima plataforma antes que ela desapareça.

Siga estas etapas para fazer com que todas as plataformas desapareçam e apareçam ao mesmo tempo.

1. Para que HideAllPlatforms() e ShowAllPlatforms() sejam executados simultaneamente, você pode usar a expressão sync. A expressão sync executa duas ou mais expressões assíncronas em seu bloco de código ao mesmo tempo e espera até que todas as suas expressões sejam concluídas antes de continuar. Em OnBegin(), dentro da expressão loop, adicione uma expressão sync em HideAllPlatforms() e ShowAllPlatforms()

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
            loop:
                # Run both expressions concurrently using sync.
                sync:
                    # Hide all platforms.
                    HideAllPlatforms()
   
                    # Show all platforms.
                    ShowAllPlatforms()

   Copy full snippet(10 lines long)

2. Se você executar esse código como se encontra, os processos de ocultar e exibir uma plataforma acontecerão simultaneamente. Esse não é o resultado desejado, então você precisará atrasar um pouco o desaparecimento da plataforma. Para dar ao jogador uma vantagem, você deve usar Sleep(), passando o valor HeadStart. Como a expressão sync executa todas as expressões em seu bloco de código ao mesmo tempo, você deve usar a expressão block para aninhar Sleep() e HideAllPlatforms(). Adicione a expressão block que cobre Sleep() e HideAllPlatforms(). Agora, "sync" executará as duas expressões. A primeira chama ShowAllPlatforms(), a segunda, Sleep() e, posteriormente, HideAllPlatforms().

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
            loop:
                # Run both expressions concurrently using sync.
                sync:
                    block:
                        Sleep(HeadStart)
                        # Hide all platforms.
                        HideAllPlatforms()
                    # Show all platforms.
   
   Expand code Copy full snippet(11 lines long)

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

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

   

Quando você testar o nível, as plataformas começarão a desaparecer em sequência enquanto as plataformas posteriores da sequência estiverem reaparecendo, e esse padrão se repetirá enquanto o jogo estiver em execução.

Script completo

O código a seguir é o script completo para criar uma série de plataformas que aparecem e desaparecem em sequência.

using { /Fortnite.com/Devices }
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
platform_series := class(creative_device):

    # How long to wait in seconds after platforms start appearing

Por si só

Ao concluir este tutorial, você terá aprendido a criar um dispositivo usando Verse que alterna a visibilidade de uma série de plataformas enquanto o jogo estiver em execução.

Usando o que você aprendeu, tente o seguinte:

• Altere a ordem em que as plataformas aparecem e desaparecem.

• Aplique os mesmos conceitos para chamar funções periodicamente em outros tipos de dispositivo, como o Propulsor de Adereços.