1. Epic GamesDeveloper
  3. 5. Detectar cuándo se ha resuelto el puzle

5. Detectar cuándo se ha resuelto el puzle

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.

5. Detectar cuándo se ha resuelto el puzle
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 detectar un puzle resuelto

Esta sección muestra cómo detectar cuándo el jugador resuelve el puzle encontrando la combinación correcta de luces. Cuando se resuelva el puzle, debe activarse el dispositivo Generador de objetos para que pueda generar su objeto.

Sigue estos pasos para detectar cuándo el jugador resuelve el puzle:

  1. Añade un campo editable item_spawner_device llamado ItemSpawner a la clase tagged_lights_puzzle para representar el dispositivo generador de elementos. 
     @editable
 ItemSpawner : item_spawner_device = item_spawner_device{}
  2. A continuación, define en qué estado deben estar las luces para resolver el puzle. Dado que la representación del estado de las luces es una matriz lógica, el estado resuelto de las luces debe ser también una matriz lógica para compararlos fácilmente. Crea un campo de matriz lógica editable llamado SolvedLightsState para la clase tagged_lights_puzzle. En este ejemplo, el jugador debe encender todas las luces para resolver el puzle, así que inicializa cada elemento con el valor true para representar que la luz está encendida. 
     @editable
 SolvedLightsState : []logic = array{true, true, true, true}
  3. Guarda el archivo en Visual Studio Code.
  4. En la barra de herramientas de UEFN, haz clic en Compilar scripts de Verse para actualizar tu dispositivo de Verse en el nivel.
  5. En el esquematizador, selecciona tagged_lights_puzzle para abrir su panel Detalles.
  6. En el panel Detalles, establece la propiedad ItemSpawner en el dispositivo Generador de objetos que hay en el nivel.
  7. A continuación, desarrolla el código que comprueba si LightsState actual coincide con SolvedLightsState. Añade un nuevo método nombrado IsPuzzleSolved() a la clase tagged_lights_puzzle. Este método debe tener éxito si el puzle está resuelto y puede fallar si no lo está, para que su invocador sepa el resultado de la comprobación. Esto significa que el método debe marcarse como falible con el especificador decides. Como el método tiene el especificador decides, también debe tener el especificador transacts, lo que significa que las acciones realizadas por este método pueden revertirse (como si nunca se hubieran realizado) si se produce un fallo en cualquier parte del método. 
     IsPuzzleSolved()<decides><transacts> : void =
     Logger.Print(“Checking if puzzle is solved”)

    Verse utiliza el mecanismo de éxito/fracaso para la toma de decisiones. Para obtener más información sobre cómo utiliza Verse el fallo, consulta Error.
  8. ¿Cuándo debe comprobar el dispositivo si se ha resuelto el puzle? El mejor momento es cuando se acaba de actualizar la matriz LightsState, lo que ocurre dentro del método ToggleLights(). Una vez que la expresión for termina de actualizar la matriz LightsState, llama al método IsPuzzleSolved[] para determinar si el puzle está resuelto y así generar un objeto (llamando a ItemSpawner.Enable()). Como IsPuzzleSolved[] es una expresión falible (por eso el método tiene [] en lugar de () cuando lo llamas) debe llamarse en un contexto de fallo. En este ejemplo, el contexto de fallo es una expresión if para que puedas ejecutar condicionalmente expresiones en función de si se resuelve el puzle. 
     ToggleLights(LightIndices : []int) : void =
     for:
         LightIndex : LightIndices
         IsLightOn := LightsState[LightIndex]
         Light := Lights[LightIndex]
     do:
         Logger.Print("Encendiendo luz en el índice {LightIndex} {if (IsLightOn?) then "Apagado" else "Encendido"}")
         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}")
    
     if (IsPuzzleSolved[]):
         Logger.Print("¡Puzle resuelto!")
         ItemSpawner.Enable()
  9. A continuación, haz que el método IsPuzzleSolved() detecte si el puzle está resuelto. Como IsPuzzleSolved() es un contexto de fallo, puedes utilizar expresiones falibles en el cuerpo del método sin necesidad de utilizar otro contexto de fallo, como una expresión if. En este caso, tendrás que comprobar si el estado de cada luz es el mismo que el del puzle resuelto. Para comprobar si dos valores logic son iguales, puedes utilizar el operador igual =, que es una expresión falible. La primera vez que dos valores que estás comprobando no sean iguales, la expresión fallará, por lo que el método fallará también y volverá al contexto de lo que lo llama (en este caso, la expresión if del método ToggleLights()). 
     IsPuzzleSolved()<decides><transacts> : void =
     Logger.Print(“Checking if puzzle is solved”)
        
     for:
         LightIndex -> IsLightOn : LightsState
         IsLightOnInSolution := SolvedLightsState[LightIndex]
     do:
         IsLightOn = IsLightOnInSolution
  10. Guarda los cambios en Visual Studio Code.
  11. En la barra de herramientas de UEFN, haz clic en Compilar secuencias de comandos de Verse para compilar tu código.
  12. Haz clic en Jugar en la barra de herramientas de UEFN para poner a prueba el nivel.

Cuando pruebes tu nivel con los ajustes que se muestran en este ejemplo, interactuar con todos los botones una vez debería resolver el puzle y hacer aparecer el objeto.

El jugador interactúa con los botones para encontrar la combinación correcta de luces con el fin de resolver el puzle y hacer aparecer un objeto

Cómo eliminar la interacción de los botones cuando el puzle está resuelto

Después de que el jugador haya completado el puzle, no debería poder interactuar con los botones ni encender o apagar las luces. Esta sección muestra cómo anular la suscripción a un evento para que el controlador de eventos deje de ser llamado cuando un jugador interactúa con el botón.

Cuando llamas a Subscribe() en un evento de dispositivo, la llamada a la función tiene un resultado cancellable. Llamar a Cancel() en una variable cancelable anula la suscripción a la función que controla el evento, de modo que ya no se llamará a la función cuando se envíe el evento.

Sigue estos pasos para eliminar las interacciones de los botones una vez resuelto el puzle:

  1. Añade un campo variable de matriz cancelable nombrado ButtonSubscriptions a la clase tagged_lights_puzzle para almacenar el resultado de suscribirse al evento de cada botón, e inicializa el campo con una matriz vacía. 
     var ButtonSubscriptions : []cancelable = array{}
  2. Como esta es la última sentencia de la expresión for, sus valores devueltos de todas las iteraciones correctas se recopilan en una matriz del tipo de retorno de la expresión. Como ya se ha explicado, el tipo de retorno de una llamada a Subscribe a un evento es cancelable; esto se refiere a ToggleLights los resultados de for en una matriz de elementos cancelable ([]cancelable). Eso coincide con el tipo ButtonsSubscription, por lo que puedes asignar el resultado de la expresión for a la matriz ButtonsSubscription. Añade este código en la función OnBegin, después de SetupPuzzleLights: 
     OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()
    
     set ButtonSubscriptions = for:
         ButtonIndex -> Button : Buttons
         LightIndices := ButtonsToLights[ButtonIndex]
     do:
         Button.InteractedWithEvent.Subscribe(button_event_handler{Indices := LightIndices, PuzzleDevice := Self}.OnButtonPressed)
  3. Por último, recuerda que los botones deben estar desactivados para que el jugador ya no pueda cambiar LightsState. Eso se consigue anulando la suscripción de los controladores InteractedWithEvent de cada botón con una llamada a su suscripción cancelable. Estos ButtonSubscriptions se guardaron cuando se crearon los controladores de eventos en OnBegin. Lo único que queda por hacer es recorrer esta matriz y llamar a cancelar en cada ButtonSubcription: 
     ToggleLights(LightIndices : []int) : void =
     for:
         LightIndex : LightIndices
         IsLightOn := LightsState[LightIndex]
         Light := Lights[LightIndex]
     do:
         Logger.Print("Encendiendo luz en el índice {LightIndex} {if (IsLightOn?) then "Apagado" else "Encendido"}")
         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}")
    
     if (IsPuzzleSolved[]):
         Logger.Print("¡Puzle resuelto!")
         ItemSpawner.Enable()
    
         para (ButtonSubscription : ButtonSubscriptions):
             ButtonSubscription.Cancel()
  4. Guarda los cambios en Visual Studio Code.
  5. En la barra de herramientas de UEFN, haz clic en Compilar secuencias de comandos de Verse para compilar tu código.
  6. Haz clic en Jugar en la barra de herramientas de UEFN para poner a prueba el nivel.

Con las propiedades predeterminadas, interactuar con todos los botones una vez debería resolver el puzle, hacer aparecer el objeto y desactivar otras interacciones con los botones.

Siguiente paso

En el último paso de este tutorial, podrás ver la secuencia de comandos completa de este tutorial e ideas para seguir modificando el ejemplo.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page