1. Epic GamesDeveloper
  3. 3. Cómo encontrar las luces en tiempo de ejecución con etiquetas de jugabilidad

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

Crea un puzle en el que el jugador tenga que encontrar la combinación correcta de luces encendidas y apagadas para que aparezca un objeto, todo en un dispositivo creado con Verse.

3. Cómo encontrar las luces en tiempo de ejecución con etiquetas de jugabilidad
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 Puzle de luces marcadas, aprenderás a utilizar las etiquetas de mecánica de juego para encontrar actores marcados con una etiqueta específica mientras se ejecuta el juego. Las etiquetas de jugabilidad te permiten trabajar con varios dispositivos sin tener que configurar sus referencias en el editor. Esto puede abrir interesantes oportunidades de juego en las que, por ejemplo, tu código cambie dinámicamente qué dispositivos están activos a medida que el jugador avanza en el juego.

Sigue estos pasos para crear una nueva etiqueta de jugabilidad y asignarla a todas las luces del nivel para el puzle:

  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 luego usa la función GetCreativeObjectsWithTag().
    • Añade using { /Verse.org/Simulation } para que pueda crear 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 nombrada puzzle_light que herede de la clase tag. El nombre de clase heredado se convierte en una etiqueta de mecánica de juego personalizada para que la utilices 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 jugabilidad.
 puzzle_light := class(tag){}

 log_tagged_lights_puzzle := class(log_channel){}
  4. En la barra de herramientas de UEFN, haz clic en Compilar secuencias de comandos de Verse para compilar el código y tu nueva etiqueta de juego puzzle_light en el proyecto.
  5. En el esquematizador de UEFN, selecciona un 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 etiquetas de Verse.
    2. Selecciona el componente VerseTagMarkup para ver su configuración en el panel Detalles.
    3. En Etiquetas de jugabilidad edita la propiedad Etiquetas y añade la etiqueta puzzle_light.
    Añadir el componente VerseTagMarkup y añade la etiqueta puzzle_light

    Se pueden añadir varias etiquetas al mismo dispositivo, por lo que cada dispositivo puede pertenecer a varios grupos al mismo tiempo. Por ejemplo, un dispositivo con tag1 y tag2 se encontrará al llamar a GetCreativeObjectsWithTag(tag1{}) o GetCreativeObjectsWithTag(tag2{}).
  7. En la definición de la clase tagged_lights_puzzle, añade dos campos de matriz de variables:
    • Una matriz de variables logic editable nombrada LightsState para representar el estado actual de todas las luces (si están apagadas o encendidas). También se utiliza para establecer el estado inicial de las luces, por lo que su número de elementos debe coincidir con el número de luces marcadas con la etiqueta puzzle_light. En este ejemplo, todas las luces están apagadas por defecto, 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 nombrada Lights para almacenar todos los dispositivos de luz personalizables etiquetados con la etiqueta de mecánica de juego puzzle_light. 
       @editable
 var Lights : []customizable_light_device = array{}
  8. Cuando comienza el juego, el dispositivo debe configurar las luces para que coincidan con la configuración inicial especificada en la matriz LightsState, y guardar las referencias en la matriz Lights para que puedan actualizarse cuando cambie el estado del juego. Este trabajo se va a realizar en un método nombrado SetupPuzzleLights() : void y se llamará en el método OnBegin() para que las luces se configuren cuando se inicie el juego. 
     SetupPuzzleLights() : void =
     Logger.Print(“Configurando las luces del juego”)
    
 OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()
  9. En SetupPuzzleLights(), busca todos los dispositivos con la etiqueta puzzle_light nombrado a GetCreativeObjectsWithTags(puzzle_light{}) y guárdalos en una matriz llamada 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 se puede deducir en este contexto. 
     SetupPuzzleLights() : void =
     Logger.Print("Setting up in-game lights")
     TaggedActors := GetCreativeObjectsWithTag(puzzle_light{})

    Diferentes llamadas a la función GetCreativeObjectsWithTag() pueden colocar los dispositivos en diferentes órdenes en el resultado de la matriz, porque no hay un orden garantizado cuando se recuperan actores con etiquetas de mecánica de juego.
  10. Ahora que has reunido todos los dispositivos que tienen la etiqueta puzzle_light, asegúrate de que cada luz coincide con el estado inicial especificado por la matriz LightsState. Puedes utilizar un bucle for para recorrer todos los dispositivos marcados. 
     for:
     ActorIndex -> TaggedActor : TaggedActors
 do:
     TaggedActor
  11. La función GetCreativeObjectsWithTag() devuelve una matriz de tipo creative_object_interface. En este ejemplo, querrás interactuar con cada TaggedActor como customizable_light_device para poder encender o apagar la luz.
    • Puedes convertir una clase en una de sus subclases (lo que se denomina casting de tipo) utilizando la sintaxis NewDeviceReference := device_type_to_cast_to[DeviceReference], donde device_type_to_cast_to es el tipo de dispositivo que deseas, que en este ejemplo es customizable_light_device. Se trata de una expresión falible, porque la conversión de tipo fallará si el dispositivo no puede convertirse a ese tipo (por ejemplo, si se trata de un tipo de dispositivo diferente). 
       LightDevice := customizable_light_device[TaggedActor]

    La función GetCreativeObjectsWithTag() tiene el tipo de retorno []creative_object_interface porque la función puede devolver distintos tipos de actores, así que su tipo de retorno es la interfaz que todos los actores deben implementar para que se devuelva con GetCreativeObjectsWithTag(). Consulta Etiquetas de jugabilidad para más información.
    • Con las expresiones for, puedes utilizar expresiones falibles como filtro y crear nuevas variables que luego puedes utilizar 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 de un 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 una matriz, por lo que el resultado de esta expresión for es una matriz de referencias a customize_light_device etiquetadas con puzzle_light. Esto significa que puedes actualizar directamente la matriz 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 debe llamar a TurnOn()/TurnOff() en las luces para que coincida con su configuración inicial LightsState en el editor. La expresión for puede devolver el índice utilizado para obtener el dispositivo marcado actual (ActorIndex en el ejemplo), que puedes utilizar para indexar en la matriz LightsState y ver si la luz debe 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()/TurnOff() dependiendo de si ShouldLightBeOn es true/false. Puedes utilizar una expresión if para ejecutar distintas expresiones en función de una condición (concretamente, una expresión falible). En este caso, la expresión falible puede utilizar el operador de consulta ? con IsLightOn, que tendrá éxito si ShouldLightBeOn es true (por lo que se llamará a TurnOn()), y fallará si ShouldLightBeOn es false (por lo que se llamará a TurnOff()). 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
      ShouldLightBeOn := LightsState[ActorIndex]
 do:
      if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff()
      LightDevice
    • Es una buena idea imprimir también el índice de la luz y su valor inicial para que puedas verificar que tu código funciona como esperas y compararlo con lo que ves en el nivel.
    • Cuando utilizas {} en medio de una cadena, la expresión entre las {} se evalúa primero y su valor se añade a la cadena. Así que puedes utilizar una expresión if en medio de una 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 el índice {ActorIndex} con estado:{if (ShouldLightBeOn?) then "On" else "Off"}")
      if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff()
      LightDevice
  12. Tu método SetupPuzzleLights() debería tener ahora este aspecto: 
     SetupPuzzleLights() : void =
     TaggedActors := GetCreativeObjectsWithTag(puzzle_light{})
     <#
     Para cada dispositivo con la etiqueta puzzle_light, comprueba si es un dispositivo customizable_light_device intentando hacerle casting a ese tipo.
     Si lo es, obtiene su LightState inicial para encender [TurnOn()] o apagar [TurnOff()] 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 el índice {ActorIndex} con estado:{if (ShouldLightBeOn?) then "On" else "Off"}")
             if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff()
             LightDevice
  13. Guarda la secuencia de comandos en Visual Studio Code.
  14. En la barra de herramientas de UEFN, haz clic en Compilar secuencias de comandos de Verse para compilar tu código.
  15. Haz clic en Jugar en la barra de herramientas de UEFN para poner a prueba el nivel.

Cuando pruebes tu nivel, deberías ver cada luz añadida a la matriz Lights, junto con su estado inicial, impresos en el registro de salida.

Siguiente paso

En el siguiente paso de este tutorial, aprenderás a activar un conjunto específico de luces cuando el jugador pulse los botones.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page