3. Cómo encontrar las luces en el tiempo de ejecución con etiquetas de juego

Crear un puzzle donde el jugador tenga que encontrar la combinación correcta de luces encendidas y apagadas para generar un elemento mediante un dispositivo creado con Verse.

3. Cómo encontrar las luces en el tiempo de ejecución con etiquetas de juego
Prerequisite topics

In order to understand and use the content on this page, make sure you are familiar with the following topics:

Al completar este paso del tutorial Puzzle de luces etiquetadas, aprenderás cómo usar las Etiquetas de juego para encontrar actores marcados con una etiqueta específica mientras el juego se está ejecutando. Las etiquetas de juego te permiten trabajar con múltiples dispositivos sin tener que definir sus referencias en el editor. Esto abre oportunidades de juego interesantes donde, por ejemplo, el código cambia dinámicamente cuáles dispositivos están activos a medida que el jugador avanza en el juego.

Realiza estos pasos para crear una nueva etiqueta de juego y asignarla a todas las luces en el nivel del puzzle:

  1. Abre el explorador de Verse y haz doble clic en tagged_lights_puzzle.verse para abrir la secuencia de comandos en Visual Studio Code.
  2. En la parte superior del archivo de código:
    • Añade using { /Verse.org/Simulation/Tags } para hacer referencia a la clase tag y usa la función GetCreativeObjectsWithTag().
    • Añade using { /Verse.org/Simulation } para poder crear las propiedades editables.
     using { /Fortnite.com/Devices }
 using { /Verse.org/Native }
 using { /UnrealEngine.com/Temporary/Diagnostics }
 using { /Verse.org/Simulation/Tags }
 using { /Verse.org/Simulation }
    
 log_tagged_lights_puzzle := class(log_channel){}

  3. Sobre la clase log_tagged_lights_puzzle, añade una nueva subclase denominada puzzle_light que se herede de la clase tag. El nombre de la clase heredada se convierte en una etiqueta de juego personalizada para que la uses en cualquier dispositivo del modo Creativo.

     # Deriva de la clase `tag` en el módulo Verse.org/Simulation/Tags para crear una nueva etiqueta de juego.
 puzzle_light := class(tag){}

 log_tagged_lights_puzzle := class(log_channel){}
  4. En la barra de herramientas de UEFN, haz clic en Compilar secuencia de comandos de Verse para compilar el código y la nueva etiqueta de juego puzzle_light a tu proyecto.
  5. En el esquematizador de UEFN, selecciona Dispositivo de luz personalizable para abrir su panel Detalles.
  6. En el panel Detalles:
    1. Haz clic en Añadir nuevo componente y elige Marcado de etiqueta de Verse.
    2. Selecciona el componente VerseTagMarkup para ver su configuración en el panel de detalles.
    3. En Etiquetas de juego, edita la propiedad Etiquetas y añade la etiqueta puzzle_light.
    Añade el componente VerseTagMarkup y añade la etiqueta puzzle_light

    Es posible añadir múltiples etiquetas al mismo dispositivo de manera que cada dispositivo puede pertenecer a múltiples grupos al mismo tiempo. Por ejemplo, un dispositivo con las etiquetas tag1 y tag2 se encontrará cuando se llame a GetCreativeObjectsWithTag(tag1{}) o a GetCreativeObjectsWithTag(tag2{}).
  7. En la definición de clase tagged_lights_puzzle, añade dos campos de matriz variable:
    • Una matriz variable editable logic denominada LightsState que representa el estado actual de todas las luces (ya estén encendidas o apagadas). También se usa para definir el estado inicial de las luces; por ello, su número de elementos debe coincidir con el número de luces etiquetadas con la etiqueta puzzle_light. En este ejemplo, todas las luces están apagadas de manera predeterminada, por lo que el valor inicial de todas las luces es false. 
       @editable
 var LightsState : []logic = array{false, false, false, false}
    • Una matriz variable editable customizable_light_device denominada Lights para almacenar los dispositivos de luz personalizables etiquetados con la Etiqueta de juego puzzle_light. 
       @editable
 var Lights : []customizable_light_device = array{}
  8. Cuando comienza el juego, el dispositivo debería configurar las luces para que coincidan con la configuración inicial especificada en el array LightsState y guardar las referencias en el array Lights para poder actualizarlas cuando el estado de juego cambie. Este trabajo se realizará en un método denominado SetupPuzzleLights() : void que se llamará en el método OnBegin() para configurar las luces cuando comienza el juego. 
     SetupPuzzleLights() : void =
     Logger.Print(“Configurando luces del juego”)
    
 OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()
  9. En SetupPuzzleLights(), llama a GetCreativeObjectsWithTag(puzzle_light{}) para encontrar todos los dispositivos con la etiqueta puzzle_light y guárdalos en un array denominado TaggedActors. Como TaggedActors es una matriz constante cuyo ámbito es local al método SetupPuzzleLights(), no necesitas especificar explícitamente un tipo para la matriz porque puede inferirse en su contexto. 
     SetupPuzzleLights() : void =
     Logger.Print("Configurando luces del juego")
     TaggedActors := GetCreativeObjectsWithTag(puzzle_light{})

    Las distintas llamadas a la función GetCreativeObjectsWithTag() pueden colocar los dispositivos en distinto orden en los resultados del array porque no existe un orden garantizado al recuperar actores con las Etiquetas de juego.
  10. Ahora que recopilaste todos los dispositivos con la etiqueta puzzle_light, asegúrate de que todas las luces coincidan con el estado inicial especificado en la matriz LightsState. Puedes usar un bucle for para iterar a través de todos los dispositivos etiquetados. 
     for:
     ActorIndex -> TaggedActor : TaggedActors
 do:
     TaggedActor
  11. La función GetCreativeObjectsWithTag() devuelve un array de tipo creative_object_interface. En este ejemplo, deberías interactuar con cada TaggedActor como un customizable_light_device para poder encender y apagar la luz.
    • Puedes convertir una clase en una de sus subclases (esto se denomina proyección de tipo) con la sintaxis NewDeviceReference := device_type_to_cast_to[DeviceReference], donde device_type_to_cast_to es el tipo de dispositivo que deseas, en este ejemplo, customizable_light_device. Esta es una expresión falible porque la conversión de tipo fracasará si no se puede convertir el dispositivo a dicha clase (por ejemplo, si es un tipo distinto de dispositivo). 
       LightDevice := customizable_light_device[TaggedActor]

    La función GetCreativeObjectsWithTag() tiene el tipo de devolución []creative_object_interface porque la función puede devolver distintos tipos de actor; por lo tanto, su tipo de devolución es la interfaz que deben implementar todos los actores que devuelve GetCreativeObjectsWithTag(). Para obtener más información, consulta etiquetas de juego
    • Con las expresiones for, puedes usar expresiones falibles como filtro y crear nuevas variables para usarlas en el bloque de código for. En este caso, añade la conversión de tipo a customizable_light_device del paso anterior a la expresión de iteración. 
       for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
 do:
      LightDevice
    • La última expresión en el bloque de código es el resultado del bloque de código. La expresión for devuelve el resultado del bloque de código de cada iteración en el array; por ello, el resultado de esta expresión for es un array de referencias a customize_light_device etiquetadas con puzzle_light. Es decir, puedes actualizar directamente el array Lights con el resultado de la expresión for. 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
 do:
      LightDevice
    • Este bucle for también debería llamar a TurnOn() / TurnOff() en las luces para que coincidan con la configuración inicial de LightsState en el editor. La expresión for puede devolver el índice usado para obtener el dispositivo etiquetado actual (en este ejemplo,ActorIndex), que puede usar el índice al array LightsState para ver si la luz debería estar encendida o apagada. 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
      ShouldLightBeOn:= LightsState[ActorIndex]
 do:
      LightDevice
    • A continuación, llama a TurnOn() o TurnOff() en función de si ShouldLightBeOn es true o false. Puedes usar una expresión if para ejecutar distintas expresiones con base en una condición (específicamente, una expresión falible). En este caso, la expresión falible puede usar el operador de consulta ? con IsLightOn que tendrá éxito si ShouldLightBeOn es true (en cuyo caso, llama a TurnOn()) y fracasará si ShouldLightBeOn es false (en cuyo caso, llama a TurnOff()). 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
      ShouldLightBeOn := LightsState[ActorIndex]
 do:
      LightDevice.TurnOn() else LightDevice.TurnOff()
      LightDevice
    • También es una buena idea imprimir el índice de las luces y su valor inicial para poder verificar si el código funciona como se esperaba y comparar con lo que ves en el nivel.
    • Cuando usas {} en el medio de una cadena, la expresión entre {} se evalúa primero, y su valor se añade a la cadena. Puedes usar la expresión if en el medio de la cadena para añadir valores condicionalmente. 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[ActorIndex]
      ShouldLightBeOn := LightsState[ActorIndex]
 do:
      Logger.Print("Añadiendo luz en índice {ActorIndex} con State:{if (ShouldLightBeOn?) entonces "Encender" else "Apagar"}")
      LightDevice.TurnOn() else LightDevice.TurnOff()
      LightDevice
  12. El método SetupPuzzleLights() debería verse de la siguiente manera: 
     SetupPuzzleLights() : void =
     TaggedActors := GetCreativeObjectsWithTag(puzzle_light{})
     <#
     Para cada dispositivo con la etiqueta puzzle_light, comprueba si es un customizable_light_device al intentar proyectarlo a dicho tipo.
     Si lo es, obtiene su LightState incial para TurnOn() (encender) o TurnOff() (apagar) el LightDevice.
     Guarda todos los dispositivos customizable_light_device etiquetados en la matriz Lights.
     #>
     set Lights = for:
             ActorIndex -> TaggedActor : TaggedActors
             LightDevice := customizable_light_device[TaggedActor]
             ShouldLightBeOn := LightsState[ActorIndex]
     do:
             Logger.Print("Añadiendo luz en índice {ActorIndex} con State:{if (ShouldLightBeOn?) entonces "Encender" else "Apagar"}")
             LightDevice.TurnOn() else LightDevice.TurnOff()
             LightDevice
  13. Guarda tu secuencia de comandos en Visual Studio Code.
  14. En la barra de herramientas de UEFN, haz clic en Compilar scripts de Verse para compilar tu código.
  15. Haz clic en Jugar en la barra de herramientas de UEFN para realizar una prueba de juego del nivel.

Cuando pruebes el nivel, deberías ver todas las luces añadidas al array Lights, junto con su estado inicial, impresas en el registro de salida.

Próximo paso

En el siguiente paso de este tutorial, aprenderás cómo conmutar un conjunto específico de luces cuando el jugador pulsa los botones.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page