Plataformas sincronizadas que desaparecen

Un serie de plataformas que desaparecen es un elemento básico en los modos de juego de plataforma como, por ejemplo, las pistas de obstáculos. Requieren que los jugadores sincronicen sus saltos entre una serie de plataformas o caerán y deberán comenzar de nuevo.

Con este tutorial, aprenderás a crear una serie de plataformas que aparecen y desaparecen secuencialmente con un dispositivo creado con Verse en Unreal Editor para Fortnite (UEFN).

Funciones usadas del lenguaje Verse

• array: con el tipo array (matriz), puedes almacenar juntas las referencias a plataformas para acceder rápidamente y evitar la duplicación de código.

• loop: el ciclo de aparición y desaparición de las plataformas debe comenzar cuando comienza el juego y continuar hasta que finaliza. Este ejemplo muestra cómo crear este comportamiento con la expresión loop de Verse.

• block: con la expresión block, puedes agrupar varias expresiones para que se ejecuten secuencialmente.

• for: con la expresión for, puedes iterar sobre cada plataforma en tu matriz.

• sync: Con la expresión sync y concurrencia estructurada, puedes ejecutar múltiples expresiones asíncronas simultáneamente.

API de Verse utilizadas

• Sleep(): con la API Sleep() puedes escoger la duración de los estados de visibilidad e invisibilidad de las plataformas.

• Propiedades editables: varias propiedades de dispositivos creados con Verse se exponen a UEFN para que puedas personalizarlas en el editor: tres retrasos para el comportamiento de las plataformas y cuatro referencias de dispositivo a la plataforma.

Instrucciones

Realiza estos pasos para aprender cómo configurar una serie de plataformas que desaparecen y aparecen periódicamente. La secuencia de comandos completa se incluye al final de esta guía como referencia.

Configuración del nivel

Este tutorial utiliza la plantilla de Verse para principiantes como punto de partida. Para empezar, inicializa un nuevo proyecto a partir del ejemplo de dispositivo de Verse.

En este ejemplo, se utilizan la utilería y los dispositivos que aparecen a continuación.

• 1 x dispositivo de plataforma de aparición de jugador: Este dispositivo define dónde generar al jugador al comienzo del juego.

• 6 x objetos del modo Creativo: los objetos del modo Creativo tienen varios comportamientos que puedes llamar con Verse, como Hide() y Show() para alternar la visibilidad y colisión de la plataforma. Este tutorial usa la plataforma aérea flotante A como plataforma que el jugador puede usar para interactuar, pero puedes cambiarla conforme lo requiera tu experiencia.

Realiza estos pasos para configurar el nivel:

1. Añade una plataforma aérea flotante A a tu escena. Coloca esto por encima del suelo para que el jugador se caiga si no salta a tiempo de la plataforma que desaparece. En el esquematizador, nombra la plataforma SynchronizedPlatform1.

   

2. Duplica la plataforma varias veces para crear una línea. Luego, coloca el dispositivo de aparición de jugador en la plataforma donde quieres que comience el jugador. Tu configuración completa debería verse así:

   

Cómo crear el dispositivo

En este ejemplo, se utiliza un dispositivo creado con Verse para definir el comportamiento de cambio de visibilidad de la plataforma. Sigue estos pasos para crear este dispositivo con Verse.

1. Crea un nuevo dispositivo Verse llamado plataforma. Para saber cómo crear un nuevo dispositivo en Verse, consulta Cómo crear tu propio dispositivo con Verse.

   

2. Arrastra el dispositivo platform_series desde el explorador de contenido hasta el nivel.

Cómo editar las propiedades del dispositivo en UEFN

Esta sección muestra cómo exponer propiedades de dispositivo a UEFN para que puedas personalizarlas en el editor:

• Tres constantes float para guardar la duración de la invisibilidad y visibilidad de las plataformas, denominadas HeadStart, AppearDelay y DisappearDelay.

• Los dispositivos hacen referencia al objeto del modo Creativo que colocaste en el nivel.

Sigue estos pasos para exponer estas propiedades desde el dispositivo platform_series que creaste en la sección anterior.

1. Abre el explorador de Verse y haz doble clic en platform_series.verse para abrir la secuencia de comandos en Visual Studio Code.

2. En la definición de la clase platform_series, añade los siguientes campos:

   • Un float editable denominado HeadStart. Esto representa cuánto esperar, en segundos, después de que las plataformas comienzan a aparecer y antes de que comiencen a desaparecer. Inicializa este valor en 2.5 o dos segundos y medio.

     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)

   • Un float editable denominado AppearDelay. Esto representa cuánto esperar, en segundos, antes de que la siguiente plataforma aparezca. Inicializa este valor en 1.0 o un segundo.

     Verse

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

     Copy full snippet(3 lines long)

   • Un float editable denominado DisappearDelay. Esto representa cuánto esperar, en segundos, antes de que la siguiente plataforma desaparezca. Inicializa este valor en 1.25 o un segundo y un cuarto.

     Verse

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

     Copy full snippet(3 lines long)

   • Un creative_prop editable denominado DisappearingPlatform. Esta es la plataforma del nivel que desaparecerá y aparecerá. Debido a que tu código aún no tiene una referencia a este objeto en el nivel, lo instanciarás con un arquetipo creative_prop{} vacío. Asignarás esta referencia a tu plataforma flotante más adelante.

     Verse

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

     Copy full snippet(3 lines long)

3. Los campos de la clase platform_series deberían ser así:

   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)

   Resulta útil el atributo @editable para exponer valores como AppearDelay al editor desde tus secuencias de comandos. Esto te permite personalizar sus valores en UEFN sin tener que volver a compilar el código de Verse en cada ocasión, con lo que podrás iterar rápidamente y buscar valores que funcionen con tu experiencia de juego.

4. Guarda tu secuencia de comandos en Visual Studio Code.

5. En la barra de herramientas de UEFN, haz clic en Verse y luego en Compilar código de Verse para actualizar el dispositivo platform_series que está en el nivel.

   

6. En el panel del esquematizador en UEFN, selecciona el dispositivo platform_series para abrir su panel de detalles.

7. En el panel de detalles, bajo platform_Series, establece DisappearingPlatform a SynchronizedPlatform1 (el objeto del modo Creativo que agregaste al nivel) al hacer clic en el selector de objetos y seleccionar la plataforma en el visor.

Cómo ocultar y mostrar una plataforma

Ahora que configuraste el nivel y la primera plataforma, puedes añadir la funcionalidad para mostrar y ocultar la plataforma. Realiza estos pasos para añadir este comportamiento al dispositivo platform_series:

1. La clase creative_prop tiene dos métodos para alternar su visibilidad: Hide() y Show(). De vuelta en Visual Studio Code, en OnBegin(), llama a Hide() y luego a Show() en tu 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)

   Si ejecutas este código, no verás que la plataforma desaparece y reaparece porque las llamadas Hide() y Show() se producen inmediatamente una después de la otra.

2. Para hacer que la plataforma permanezca en un estado visible/invisible por más tiempo, puedes agregar un retraso al llamar a Hide() o Show() mediante Sleep(). La función Sleep() suspende la ejecución de una rutina y puedes especificar cuánto tiempo (en segundos) se suspende la ejecución si pasas un argumento float a la función. Llama a Sleep() antes de cada llamada a Hide() y Show() con el DisappearDelay que definiste antes.

   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)

   Si ejecutas este código, la Plataforma estará invisible durante un segundo (la cantidad definida por DisappearDelay) antes de que esté visible durante el resto del juego.

   La función Sleep() solo se puede llamar en un contexto asíncrono. El método OnBegin() ya es un contexto asíncrono, ya que tiene el especificador suspends, por lo que no necesitas hacer nada más. Para obtener más información sobre el especificador suspends, consulta Atributos y especificadores.

Cómo ocultar y mostrar múltiples plataformas

Si bien podrías repetir el código del paso anterior en cada una de las plataformas del nivel que deseas que desaparezcan, crear una matriz para almacenar todas las referencias de dispositivo es más eficiente. Esto te permite iterar en cada plataforma de la matriz, a medida que ejecutas código en cada una sin tener que duplicar el dispositivo de Verse varias veces. Realiza los siguientes pasos para que se oculten y muestren varias plataformas:

1. En tu definición de clase de platform_series, cambia el campo DisappearingPlatform a una matriz de creative_prop llamada DisappearingPlatforms. Usarás esta matriz para iterar en todas las plataformas en orden. Inicializa la variable con el valor predeterminado array{}, una matriz vacía.

   Verse

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

   Copy full snippet(3 lines long)

2. Puedes usar la expresión for para iterar en cada elemento de la matriz. La expresión for usa el patrón X -> Y para otorgar un par índice-valor. El índice está vinculado a la parte izquierda (X) y el valor está vinculado a la parte derecha (Y). En este caso, X es el número de plataforma/índice, mientras que Y es la referencia a cada plataforma recuperada de la matriz. Primero, crea una expresión for para iterar en cada elemento y obtén el índice de cada número en una variable PlatformNumber.

   ~~~(verse) # Se ejecuta cuando el dispositivo se inicia en un juego ya ejecutado. OnBegin<override>()<suspends>:void= for: PlatformNumber -> DisappearingPlatform:DisappearingPlatforms do: ~~~

3. Imprime el número de la plataforma y llama a Hide() para ocultarla. Luego, usa Sleep() para una cantidad de segundos equivalente a 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 mostrar las plataformas de nuevo, usarás una segunda expresión for tras la primera. Itera en cada plataforma en DisappearingPlatforms de la misma manera, excepto que esta vez hay que llamar a Show() para mostrar la plataforma y a Sleep() una cantidad de segundos equivalente a AppearDelay.

   ~~~(verse) # Para cada plataforma en DisappearingPlatforms, hacerla visible y usar sleep. for: PlatformNumber -> DisappearingPlatform:DisappearingPlatforms do: # Mostrar la plataforma. DisappearingPlatform.Show() Print("la plataforma {PlatformNumber} ahora está visible.") Sleep(AppearDelay) ~~~

5. Al escribir código, es buena idea ir apartando código que quieras reutilizar para separar funciones. Esto te permite llamar el código desde diferentes contextos sin tener que volver a escribirlo una y otra vez. Según tu experiencia, quizá prefieras ocultar y mostrar las plataformas dependiendo de las situaciones, así que tendrás que crear funciones para cada caso. Añade dos funciones nuevas llamadas HideAllPlatforms() y ShowAllPlatforms() a tu definición de clase platform_series. Mueve la expresión for que gestiona la acción de ocultar las plataformas a HideAllPlatforms(), y la expresión que gestiona la acción de mostrar las plataformas a ShowAllPlatforms(). Como estás usando la función Sleep(), las funciones deben ser asíncronas, así que debes agregarles el modificador <suspends> a cada una. Luego, en OnBegin(), llama a HideAllPlatforms() y luego a 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. Así como está, este código solo se ejecutará una vez. Para hacer que la plataforma desaparezca y reaparezca mientras se ejecute el juego, puedes utilizar la expresión loop para repetir este comportamiento. Para gestionar esto, añade una expresión loop a OnBegin() que incluya las llamadas a HideAllPlatforms() y ShowAllPlatforms(). En este ejemplo, quieres cambiar la visibilidad de las plataformas durante todo el tiempo que dure la partida, así que no hay necesidad de añadir una expresión break para salir del 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)

   Si ejecutas este código, las plataformas desaparecerán todas en secuencia primero y, a continuación, reaparecerán en el mismo orden y esto se repetirá hasta que finalice el juego.

7. Guarda tu código y compílalo. En el panel del esquematizador en UEFN, selecciona el dispositivo platform_series para abrir su panel de detalles.

8. En el panel de detalles', bajo DisappearingPlatforms, añade un elemento de matriz para cada plataforma en el nivel. Añade nuevos elementos a la matriz con el botón "Agregar elemento" y, a continuación, haz clic en el selector de objetos y selecciona el objeto del modo Creativo en el visor. Procura que el orden de esta matriz coincida con el orden sobre el que quieres iterar:

   

Ahora, si ejecutas este código, las plataformas desaparecerán todas en secuencia primero y, a continuación, reaparecerán en el mismo orden y esto se repetirá hasta que finalice el juego.

Sincroniza la desaparición y reaparición de la plataforma

Para añadir más emoción a medida que el jugador salta entre los cuadros, puedes hacer que las plataformas comiencen a desaparecer mientras las plataformas posteriores de la secuencia aún está apareciendo. De esa manera, el jugador deberá correr entre la serie o se caerá. Para crear este comportamiento, ambas rutinas (ShowAllPlatforms() y HideAllPlatforms()) deben ejecutarse al mismo tiempo, con la segunda a la zaga de la primera, de manera que el jugador tenga una ventaja para saltar a la siguiente plataforma antes de que desaparezca.

Realiza los siguientes pasos para que todas las plataformas se oculten y muestren al mismo tiempo.

1. Para que HideAllPlatforms() y ShowAllPlatforms() se ejecuten simultáneamente, puedes utilizar la expresión sync. La expresión sync ejecuta dos o más expresiones asíncronas en su bloque de código al mismo tiempo y espera a que todas las expresiones finalicen para continuar. En OnBegin(), dentro de la expresión de bucle, añade una expresión de sincronización en HideAllPlatforms() y 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. Si ejecutas este código tal como está, la desaparición y aparición de una plataforma ocurrirá simultáneamente. Este no es el resultado buscado, así que deberás aplicar un retraso a la desaparición de la plataforma. Para darle una ventaja inicial al jugador, querrás usar Sleep(), pasando el valor de HeadStart. Debido a que la expresión sync ejecuta todas las expresiones en su bloque de código al mismo tiempo, deberías usar la expresión block para que Sleep() y HideAllPlatforms() queden anidadas. Añade una expresión block que abarque a Sleep() y HideAllPlatforms(). Ahora la expresión sync ejecutará dos expresiones. La primera llama a ShowAllPlatforms() y la segunda llama a Sleep(). Luego, llama a 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. Guarda la secuencia de comandos y haz clic en Verse y, luego, en Compilar código de Verse para compilar el código.

4. Haz clic en Comenzar sesión en la barra de herramientas de UEFN para realizar una prueba de juego del nivel.

   

Cuando pruebas el juego, las plataformas comienzan a desaparecer en secuencia mientras que las plataformas posteriores de la secuencia reaparecen y este patrón se repite mientras el juego se esté ejecutando.

Secuencia de comandos completa

El siguiente código es la secuencia de comandos completa para hacer que una serie de plataformas aparezcan y desaparezcan en secuencia.

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 tu cuenta

Al completar este tutorial, habrás aprendido a crear un dispositivo usando Verse que cambia la visibilidad de una serie de plataformas todo el tiempo que dura la partida.

Con lo que aprendiste, prueba lo siguiente:

• Cambiar el orden en que aparecen y desaparecen las plataformas

• Aplica los mismos conceptos para llamar periódicamente a funciones en otros tipos de dispositivos, como el dispositivo movedor de objetos.