4. Alternar luces con botones

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.

4. Alternar luces con botones
Prerequisite topics

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

Si completas este paso del tutorial Puzle de luces marcadas, aprenderás a detectar cuándo el jugador resuelve el puzle para poder generar un objeto y evitar que se siga interactuando con el puzle.

Cómo conmutar luces

Tendrás que crear una asignación entre un botón y el grupo de luces que debe conmutar cuando el jugador interactúe con el botón. Para ello, puedes asignar cada botón a los índices de las luces de la matriz Lights.

Este ejemplo utiliza la siguiente asignación entre botones y luces:

  • El botón 1 se asigna a la luz de índice 0 y a la luz de índice 3.
  • El botón 2 se asigna a la luz de índice 0, la luz de índice 1 y la luz de índice 2.
  • El botón 3 se asigna a la luz de índice 0 y a la luz de índice 1.
  • El botón 4 se asigna a la luz de índice 1.

Puedes representar esta asignación con una matriz nombrada ButtonsToLights, donde cada elemento de ButtonsToLights es otra matriz que contiene los índices de las luces. El tipo de ButtonsToLights es entonces [][]int, para especificar que ButtonsToLights es una matriz de matrices de enteros.

Índice 0 1 2 3
Elemento array{0, 3} array{0, 1, 2} array{0, 1} array{1}

Sigue estos pasos para conmutar las luces:

  1. Crea una matriz de matrices de enteros nombrada ButtonsToLights e iníciala con la asignación de índices de botón a luz descrita en la tabla anterior. 
     ButtonsToLights : [][]int = array{array{0, 3}, array{0, 1, 2}, array{0, 1}, array{1}}

    Los índices de una matriz empiezan en 0 y llegan hasta el número de elementos menos 1. Así, el primer elemento de ButtonsToLights está en el índice 0 y el último en el índice 3.
  2. Añade un nuevo método llamado ToggleLights() a la clase tagged_lights_puzzle. Este método encenderá/apagará las luces de la matriz Lights basándose en los índices dados a la función como matriz de enteros (para que coincidan con los elementos de la matriz ButtonsToLights) y actualizará los elementos en los mismos índices en ButtonsToLights.
    1. Añade el parámetro LightIndices : []int al método ToggleLights() e imprime cada índice en el registro de salida utilizando la expresión for. 
       ToggleLights(LightIndices : []int) : void =
 for:
     LightIndex : LightIndices
 do:
     Logger.Print("Cambiando luz a {LightIndex}")
    2. Llama a ToggleLights() en OnBegin() para probar el método mientras lo creas. Utiliza el primer elemento de ButtonsToLights como prueba. Como indexar en una matriz es una expresión falible, tendrás que acceder a la matriz desde un contexto de fallo. Este ejemplo utiliza la expresión if para el contexto de fallo.
     OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()

     # Utiliza el primer elemento de ButtonsToLights para probar el método ToggleLights
     if (LightIndices : []int = ButtonsToLights[0]):
         ToggleLights(LightIndices)
  3. Ahora que tienes LightIndex, accede a las matrices Lights y LightsState en ese índice para obtener la referencia del dispositivo de Luz personalizable y su estado actual. Conmutar una luz significa que si la luz está encendida, se apaga; y si la luz está apagada, se enciende. Actualiza la sentencia print para que diga cuál será el nuevo estado de la luz. 
     ToggleLights(LightIndices : []int) : void =
     for:
         LightIndex : LightIndices
         Light := Lights[LightIndex]
         IsLightOn := LightsState[LightIndex]
     do:
         Logger.Print("Encendiendo luz a {LightIndex} {if (IsLightOn?) then "Off" else "On"}")
  4. Ahora actualiza el estado del dispositivo Luz personalizable tanto en el juego como en la matriz LightsState.
    1. Llama a TurnOn() en la luz si IsLightOn es false y TurnOff() en la luz si IsLightOn es true. La última expresión de un bloque de código es el resultado, por lo que establecer false o true como última expresión significa que ese valor se almacenará en NewLightState. 
       ToggleLights(LightIndices : []int) : void =
 for:
     LightIndex : LightIndices
     Light := Lights[LightIndex]
     IsLightOn := LightsState[LightIndex]
 do:
     Logger.Print("Encendiendo luz a {LightIndex} {if (IsLightOn?) then "Off" else "On"}")
     NewLightState :=
         if (IsLightOn?):
             Light.TurnOff()
             false
         else:
             Light.TurnOn()
             true
    2. Actualiza el elemento LighsState en LightIndex con el valor de NewLightState. Dado que la indexación de matrices es una expresión falible, establecer LightsState debe ir envuelto en un contexto de fallo. En este ejemplo, el contexto de fallo es la `expresión if. Imprime en el registro de salida que se ha actualizado el estado. 
       ToggleLights(LightIndices : []int) : void =
 for:
     LightIndex : LightIndices
     IsLightOn := LightsState[LightIndex]
     Light := Lights[LightIndex]
 do:
     Logger.Print("Encendiendo luz a {LightIndex} {if (IsLightOn?) then "Off" else "On"}")
     NewLightState :=
         if (IsLightOn?):
             Light.TurnOff()
             false
         else:
             Light.TurnOn()
             true
     if (set LightsState[LightIndex] = NewLightState):
         Logger.Print("Se ha actualizado el estado de la luz en {LightIndex}")

    Es buena idea imprimir en el registro de salida cuando utilices contextos de fallo. Si alguna expresión falla en un contexto de fallo, los cambios realizados en el mismo se anulan, como si no hubieran ocurrido. Si imprimes en el registro de salida, puedes volver a comprobar que el cambio se ha realizado si el texto aparece ahí, sin depender únicamente del estado en el juego para verificar si se ha realizado correctamente.

Cómo conectar la pulsación de botones con la conmutación de luces

Ahora que has definido cómo encender o apagar las luces, el siguiente paso es conectar las pulsaciones de los botones con el encendido o apagado de las luces.

Esto es posible suscribiéndose al evento InteractedWithEvent del botón. Consulta Codificación de las interacciones con dispositivos para obtener más información sobre la suscripción a eventos.

InteractedWithEvent espera un controlador de eventos con un parámetro InPlayer : agent y un tipo de retorno void, pero el controlador de eventos también necesita saber a qué luces está conectado el botón que ha enviado el evento y mantener una referencia al dispositivo de Verse tagged_lights_puzzle para poder llamar a su método ToggleLights().

Puedes agrupar toda esta información en un objeto personalizado creando una nueva clase que contenga los índices y la función a la que suscribirse. De este modo, cada botón tiene su propio estado personal y su propio controlador de eventos, representados por esta nueva clase.

Sigue estos pasos para crear un objeto personalizado para el control de eventos:

  1. Crea una clase nueva llamada button_event_handler. La definición de la clase debe tener lo siguiente:
    1. Una matriz de enteros nombrada Indices.
    2. Un campo tagged_lights_puzzle nombrado PuzzleDevice, que es la referencia a tu dispositivo de Verse, para que puedas llamar al método ToggleLights().
    3. Un método nombrado OnButtonPressed() con el parámetro InPlayer : agent y un tipo de retorno void, que llama a ToggleLights() en PuzzleDevice. 
       button_event_handler := class():
 # Posiciones utilizadas para acceder a las luces que controla este botón.
 Indices : []int

 # tagged_lights_puzzle que creó este button_event_handler para que podamos llamar a funciones en él.
 PuzzleDevice : tagged_lights_puzzle
    
 OnButtonPressed(InPlayer : agent) : void =
     # Dile a PuzzleDevice que conmute las luces en las posiciones que controla este botón.
     PuzzleDevice.ToggleLights(Indices)
  2. Crea una matriz editable button_device en la clase referenciar tagged_lights_puzzle. Haz referencia a los botones con los que el jugador puede interactuar: 
     @editable
 Buttons : []button_device = array{}
  3. Ahora actualiza OnBegin() en la clase tagged_lights_puzzle para crear una instancia de button_event_handler para cada botón. button_event_handler necesita la siguiente información:
    • Índices de las luces asociadas al botón, que puedes obtener de la matriz ButtonsToLights utilizando el ButtonIndex proporcionado por la expresión for. Puedes obtenerlo como condición de filtro de la expresión for utilizada para iterar por todos los Buttons. Esto también actúa como una salvaguarda que protege el código de la indexación de datos no válidos; si la indexación falla, el programa seguiría siendo válido, ya que esa iteración que falla se salta (este fallo podría ocurrir si olvidaras hacer coincidir el número de ButtonsToLights con el número de Buttons).
    • Una referencia a tu dispositivo de Verse, la instancia de tagged_lights_puzzle. Para obtener una referencia al objeto actual desde dentro de la definición de una clase, puedes utilizar Self.
    • Crear un objeto button_event_handler con estos datos tiene el siguiente aspecto: 
       OnBegin<override>()<suspends> : void =
  SetupPuzzleLights()
    
  for:
      ButtonIndex -> Button : Buttons
      LightIndices := ButtonsToLights[ButtonIndex]
  do:
      button_event_handler{Indices := LightIndices, PuzzleDevice := Self}
  4. Ahora puedes utilizar la función OnButtonPressed() del controlador recién creado para suscribirte al InteractedWithEvent del dispositivo Button. Cuando se llama a la función OnButtonPressed(), tienes acceso a los índices de las lices y a una referencia al dispositivo tagged_lights_puzzle asociado al botón con el que ha interactuado el jugador. 
     OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()
    
     for:
         ButtonIndex -> Button : Buttons
         LightIndices := ButtonsToLights[ButtonIndex]
     do:
         Button.InteractedWithEvent.Subscribe(button_event_handler{Indices := LightIndices, PuzzleDevice := Self}.OnButtonPressed)
  5. Guarda la secuencia de comandos en Visual Studio Code.
  6. En la barra de herramientas de UEFN, haz clic en Compilar secuencias de comandos de Verse para actualizar tu dispositivo de Verse en el nivel con tu nuevo código.
  7. En el esquematizador, selecciona el dispositivo tagged_lights_puzzle para abrir su panel Detalles.
  8. En el panel Detalles, añade cuatro elementos a la matriz Buttons y asigna un botón diferente a cada uno. No es necesario que modifiques las demás propiedades porque la secuencia de comandos las rellenará.
  9. En la barra de herramientas de UEFN, haz clic en Jugar para probar el nivel.

Cuando pruebes tu nivel ahora, deberías poder interactuar con los botones, y cada botón debería activar un conjunto diferente de luces en función de la configuración de ButtonsLightsIndices. Ten en cuenta que GetCreativeObjectsWithTag() no garantiza un orden específico, por lo que las luces que se activan en función del orden en la secuencia de comandos pueden no coincidir con el orden que se ve en el nivel.

El jugador pulsa botones y cada botón activa un juego de luces diferente.

Siguiente paso

En el siguiente paso de este tutorial, aprenderás a detectar cuándo se resuelve el puzle para poder generar un objeto y evitar que se siga interactuando.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page