Plataformas de desaparición sincronizada

Una serie de plataformas que desaparecen constituye un elemento básico de los modos de juego de plataformas, como las carreras de obstáculos. Los jugadores deben calcular el tiempo de sus saltos a través de las plataformas, ya que de lo contrario se caerán y tendrán que volver a empezar.

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

Funciones del lenguaje Verse utilizadas

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

• loop: el ciclo de aparición y desaparición de la plataforma debe comenzar cuando empieza el juego y continuar hasta que termine. 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 recorrer en iteración las plataformas de tu matriz.

• sync: con la expresión sync y la simultaneidad estructurada, puedes ejecutar varias expresiones asíncronas a la vez.

API de Verse utilizadas

• Sleep(): con la API Sleep() puedes elegir cuánto tiempo permanecerá la plataforma en sus estados invisible y visible.

• Propiedades editable: varias propiedades de dispositivos de Verse están expuestas a UEFN para que puedas personalizarlas en el editor: tres retrasos para el comportamiento de las plataformas y cuatro dispositivos referencia para las plataformas.

Instrucciones

Sigue estos pasos para aprender a 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.

Cómo configurar el nivel

Este tutorial utiliza la plantilla inicial de Verse como punto de partida. Para empezar, inicializa un nuevo proyecto a partir del ejemplo de función Dispositivo de Verse.

Este ejemplo utiliza los siguientes elementos y dispositivos.

• Un dispositivo plataforma de aparición de jugador: este dispositivo establece dónde aparecerá el jugador al inicio de la partida.

• Seis Creative Prop: los elementos 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 utiliza la plataforma flotante aérea A como plataforma interactiva con el jugador, pero puedes cambiarla para adaptarla a las necesidades de tu experiencia.

Sigue estos pasos para configurar tu nivel:

1. Añade una plataforma flotante aérea A a tu escena. Colócala sobre el suelo para que el jugador se caiga si no salta de la plataforma que desaparece a tiempo. En el esquematizador, dale el nombre SynchronizedPlatform1 a la plataforma.

   

2. Duplica la plataforma varias veces para crear una línea. Coloca el dispositivo Plataforma de aparición de jugador en la plataforma donde quieras que empiece el jugador. Tu configuración completa debería tener el siguiente aspecto:

   

Cómo crear el dispositivo

Este ejemplo utiliza un dispositivo de Verse para definir el comportamiento y cambiar la visibilidad de las plataformas. Sigue estos pasos para crear el dispositivo con Verse.

1. Crea un nuevo dispositivo de Verse denominado platform_series. Para más información sobre 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 del dispositivo a UEFN para que puedas personalizarlas en el editor:

• Tres constantes de float para almacenar el tiempo que las plataformas deben estar invisibles/visibles, denominadas HeadStart, AppearDelay y DisappearDelay.

• Referencias de dispositivos a los elementos 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. Representa el tiempo que hay que esperar, en segundos, después de que las plataformas empiecen a aparecer y antes de que las plataformas empiecen a desaparecer. Inicializa este valor a 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. Representa el tiempo que hay que esperar, en segundos, antes de que aparezca la siguiente plataforma. Inicializa este valor a 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. Representa el tiempo que hay que esperar, en segundos, antes de que desaparezca la siguiente plataforma. Inicializa este valor a 1.25 o un segundo y 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. Representa una plataforma dentro del nivel que desaparecerá y aparecerá. Como tu código aún no tiene una referencia a este objeto en el nivel, lo instanciarás con un arquetipo vacío creative_prop{}. Más adelante asignarás esta referencia a tu plataforma flotante.

     Verse

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

     Copy full snippet(3 lines long)

3. Tus campos de clase platform_series deberían parecerse a esto:

   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)

   Es útil utilizar 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 cada vez, por lo que puedes iterar rápidamente y buscar valores que se ajusten a tu experiencia de juego.

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

5. En la barra de herramientas de UEFN, haz clic en Verse y, a continuación, en Compilar código de Verse para actualizar el dispositivo platform_series que hay en el nivel.

   

6. En el panel Esquematizador de UEFN, selecciona el dispositivo platform_series para abrir su panel Detalles.

7. En el panel Detalles, en Series de plataformas, establece DisappearingPlatform en SynchronizedPlatform1 (el elemento del modo Creativo que has añadido al nivel) haciendo clic en el selector de objetos y seleccionando la plataforma en el visor.

Cómo ocultar y mostrar una plataforma

Ahora que has configurado el nivel y la primera plataforma, vamos a añadir la funcionalidad de mostrar y ocultar la plataforma. Sigue estos pasos para añadir este comportamiento al dispositivo platform_series:

1. La clase creative_prop tiene dos métodos para cambiar su visibilidad: Hide() y Show(). De vuelta en Visual Studio Code, en OnBegin(), llama a Hide() y después 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 a Hide() y Show() se producen inmediatamente una después de la otra.

2. Para hacer que la plataforma permanezca más tiempo en un estado visible/invisible, puedes añadir un retraso entre las llamadas a Hide() o Show() mediante Sleep(). La función Sleep() suspende la ejecución de una rutina, y tú especificas la cantidad de tiempo (en segundos) para suspender la ejecución pasando un argumento float a la función. Llama a Sleep() antes de cada llamada a Hide() y Show(), pasando 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 Platform será invisible durante un segundo (la cantidad definida por DisappearDelay) antes de que se haga visible para el resto de la partida.

   Solo es posible llamar a la función Sleep() en un contexto asíncrono. El método OnBegin() ya tiene el especificador suspends, lo que significa que es un contexto asíncrono, no necesitas hacer nada más. Para obtener más información sobre el especificador suspends, consulta Especificadores y atributos.

Aparición y desaparición de varias plataformas

Aunque puedes repetir el código del paso anterior para cada plataforma del nivel que quieras que desaparezca, crear una matriz para almacenar todas las referencias a dispositivos es más eficiente. Esto te permitirá iterar cada plataforma en la matriz y la ejecución de código en cada uno sin tener que duplicar el dispositivo de Verse varias veces. Sigue estos pasos para que ocultar y mostrar varias plataformas:

1. En la definición de la clase platform_series, cambia el campo DisappearingPlatform por una matriz de creative_prop denominada DisappearingPlatforms. Utilizarás esta matriz para recorrer en iteración 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 utilizar la expresión for para recorrer en iteración los elementos de la matriz. La expresión for utiliza el patrón X -> Y, para darte un emparejamiento índice-valor. El índice está ligado a la parte izquierda (X) y el valor está vinculado a la parte derecha (Y). En este caso, X es el número/índice de la plataforma e Y es cada referencia de plataforma recuperada de la matriz. Primero, crea una expresión for para recorrer en iteración cada elemento, y obtener el índice de cada número en una variable PlatformNumber.

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

3. Imprime el número de la plataforma y llama a Hide() para ocultar la plataforma. A continuación, ejecuta la función Sleep() durante una cantidad de segundos 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 una frente a otra, utiliza una segunda expresión for después de la primera. Recorre en iteración cada plataforma en DisappearingPlatforms de la misma manera, solo que esta vez llama a Show() para mostrar la plataforma y a Sleep() durante una cantidad de segundos de AppearDelay.

   ~~~(verse) # Haz visible cada plataforma en DisappearingPlatforms y desactívala. for: PlatformNumber -> DisappearingPlatform:DisappearingPlatforms do: # Muestra la plataforma. DisappearingPlatform.Show() Print("La plataforma {PlatformNumber} ahora es visible") Sleep(AppearDelay) ~~~

5. Al escribir código, es una buena idea colocar el código que quieras reutilizar en funciones separadas. Esto te permite llamar al código desde diferentes contextos y evitar tener que reescribir el mismo código una y otra vez. Dependiendo de tu experiencia, deberás ocultar y mostrar las plataformas en diferentes situaciones, por lo que crearás funciones para gestionar cada una de ellas. Añade dos nuevas funciones denominadas HideAllPlatforms() y ShowAllPlatforms() a la definición de tu clase platform_series. Mueve la expresión for que se encarga de ocultar las plataformas a HideAllPlatforms(), y la expresión que se encarga de mostrar las plataformas a ShowAllPlatforms(). Como estás usando la función Sleep(), estas funciones tienen que ser asíncronas, así que añade el modificador <suspends> a cada una. A continuación, 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. El código actual solo se ejecutará una vez. Para hacer que las plataformas desaparezcan y reaparezcan durante todo el tiempo que dure la partida, puedes utilizar la expresión loop para repetir este comportamiento. Para gestionarlo, añade una expresión loop a OnBegin() que incluya las llamadas a HideAllPlatforms() y ShowAllPlatforms(). En este ejemplo, vamos a cambiar la visibilidad de las plataformas durante todo el tiempo que dure la partida, así que no es necesario añadir una expresión break para salir del bucle 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, primero desaparecerán todas las plataformas en secuencia y luego reaparecerán todas en el mismo orden (y se repetirá hasta que finalice el juego).

7. Guarda el código y compílalo. En el panel Esquematizador de UEFN, selecciona el dispositivo platform_series para abrir su panel Detalles.

8. En el panel Detalles, en DisappearingPlatforms, añade un elemento de matriz a cada plataforma del nivel. Añade nuevos elementos a la matriz con el botón Añadir elemento, luego haz clic en el selector de objetos y elige el elemento del modo Creativo en el visor. Asegúrate de que el orden de esta matriz coincide con el orden que quieres recorrer en iteración:

   

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

Sincronización de las plataformas que desaparecen y reaparecen

Para añadir más urgencia a medida que el jugador salta por los casillas, puedes hacer que las plataformas empiecen a desaparecer mientras siguen apareciendo plataformas más adelante en la secuencia. Así, el jugador tendrá que apresurarse a cruzar la serie o se caerá. Para crear este comportamiento, ambas rutinas (ShowAllPlatforms() y HideAllPlatforms()) deben ejecutarse al mismo tiempo, con la segunda retrasada con respecto a la primera, de modo que el jugador tenga ventaja para poder saltar a la siguiente plataforma antes de que desaparezca.

Sigue estos pasos para que todas las plataformas se oculten y se muestren al mismo tiempo.

1. Para que HideAllPlatforms() y ShowAllPlatforms() se ejecuten de forma simultánea, puedes usar la expresión sync. La expresión sync ejecuta al mismo tiempo las dos o más expresiones asíncronas de su bloque de código, y espera a que terminen todas sus expresiones antes de continuar. En OnBegin(), dentro de la expresión loop, añade una expresión sync 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 cual, ocultar y mostrar una plataforma ocurrirá simultáneamente. Este no es el resultado deseado, así que tendrás que retrasar un poco la desaparición de la plataforma. Para dar al jugador una ventaja, utiliza Sleep(), pasando el valor HeadStart. Como la expresión sync ejecuta todas las expresiones de su bloque de código al mismo tiempo, debes utilizar la expresión block para anidar Sleep() y HideAllPlatforms(). Añade una expresión block que abarque Sleep() y HideAllPlatforms(). Ahora la sincronización ejecutará dos expresiones. La primera llama a ShowAllPlatforms(), y la segunda a Sleep(), y después 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, haz clic en Verse y, a continuación, en Compilar código de Verse para compilar el código.

4. Haz clic en Abrir sesión en la barra de herramientas de UEFN para probar el nivel.

   

Cuando pones a prueba el nivel, las plataformas empiezan a desaparecer en la secuencia mientras que las plataformas que están más adelante en la secuencia vuelven a aparecer, y este patrón se repite mientras se ejecuta el juego.

Secuencia de comandos completa

El siguiente código es la secuencia de comandos completa para hacer desaparecer y aparecer secuencialmente una plataforma.

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 con Verse que cambia la visibilidad de una serie de plataformas durante todo el tiempo que dura la partida.

Con lo que has aprendido, intenta lo siguiente:

• Cambia 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 colocador de elementos.