10. Puzle de estados de interruptores de Verse

Hay dos puzles creados con Verse, el primero es el puzle de luces marcadas. El puzle de luces marcadas se utiliza en la sala oculta tras las escaleras del subsótano.

Puedes copiar y pegar el código de la última sección del tutorial, pero es muy recomendable que construyas el puzle pieza a pieza para comprender cómo funciona el lenguaje Verse.

El segundo puzle utiliza una clave lógica codificada para comprobar cada dispositivo Interruptor y asegurarse de que se ha activado el interruptor correcto en la secuencia adecuada.

Cuando se acciona el interruptor adecuado, un sonido de acción correcta acompaña al interruptor. Del mismo modo, se activan un sonido y un mensaje de error cuando se acciona el interruptor equivocado durante la secuencia. Se reproducen un sonido y un mensaje finales de éxito, y se activan cuatro generadores de objetos cuando se resuelve el puzle.

Puedes utilizar una matriz para comprobar estados válidos y no válidos, así como para activar cualquier dispositivo conectado a un estado. En este ejemplo, la clave de respuesta se ha codificado para ayudar a los principiantes a entender lo que hace el código.

Cómo configurar los dispositivos del puzle

Para este puzle necesitarás los siguientes dispositivos:

• Cuatro dispositivos Interruptor

• Tres dispositivos Reproductor de audio

• Cuatro dispositivos Interruptor de objeto

• Dos dispositivos Mensaje del HUD

• Un dispositivo Activador

• Un dispositivo de Verse

Cambia el nombre de los generadores de objetos por el del objeto que generan.

Dispositivo Interruptor

Coloca un dispositivo Interruptor en la pared junto a la puerta y configura las siguientes opciones:

Copia otros tres dispositivos Interruptor en la pared y colócalos en una fila.

Dispositivo de audio

En el centro del cuadrado coloca un dispositivo de audio. Configura las opciones de sonido como se indica a continuación.

Copia otros dos dispositivos de audio. Cambia el nombre de los dispositivos y añade una señal de sonido a cada uno:

• Válido: para la reproducción del dispositivo de audio válido, Match_Round_Change_01_Cue.

• No válido: para la reproducción del dispositivo de audio no válido, Player_Checkpoint_Trigger_Cue.

• Completado: para la reproducción del dispositivo de audio completado, CTF_Return_Team_Cue

Dispositivo Activador

A la derecha de los interruptores, coloca el dispositivo Activador y configura las siguientes opciones.

Cambia el nombre del dispositivo Activador no válido.

Dispositivo Mensaje del HUD

Configura el primer dispositivo Mensaje del HUD utilizando las siguientes opciones.

Después, traslada el dispositivo Mensaje del HUD fuera de la pared del sótano para que no sea visible en la sala y cópialo.

Cambia el nombre de cada uno de los dispositivos Mensaje del HUD:

• Mensaje del HUD «Buscar objetos»

• Mensaje del HUD «No válido»

Dispositivo de Verse

Ahora estás listo para crear el programa de Verse que controla el puzle. Crea un nuevo dispositivo de Verse llamado switch_state_puzzle desde el explorador de Verse y arrastra el dispositivo al nivel. (Para obtener información sobre los pasos necesarios para crear un dispositivo nuevo de Verse, consulta Cómo crear tu propio dispositivo con Verse).

Diseño del puzle

Activar los interruptores en la secuencia correcta permite a los jugadores superar este punto del escape room.

Cuando el jugador acciona un interruptor en la secuencia correcta, suena una campana. Si se acciona el interruptor equivocado, suena un zumbador y se restablecen los interruptores. Los estados no válidos provocan la aparición de un mensaje, y si se completa el puzle con éxito, suena un sonido de acción correcta, aparece un mensaje de ayuda y se generan objetos.

Puedes visualizar la lógica del puzle utilizando el diagrama de flujo que aparece a continuación.

Haz clic en la imagen para ampliarla.

La solución correcta del puzle se muestra en la tabla siguiente.

Funciones del lenguaje Verse utilizadas

• if, then, else: con las expresiones if, then y else puedes encontrar el estado válido y no válido para cada dispositivo Switch y otro dispositivo dependiente del estado.

• fallo: Los contextos de fallo (failure) se utilizan para decidir el estado actual del puzle y su solución.

• for: la expresión for se utiliza para iterar sobre cada interruptor del puzle y realizar operaciones en ellos.

API utilizadas

• Propiedades editables: los múltiples dispositivos diseñados con Verse propiedad están expuestos a UEFN para que puedas personalizarlos en el editor. Podrás crear nuevas configuraciones de puzle cambiando estas propiedades.

• Eventos de dispositivo](coding-dispositivo-interactions-in-Verse): Los botones InteractedWithEvent se utilizan para controlar el estado de la partida.

Interacciones con los interruptores

Piensa en los pasos necesarios para ejecutar el puzle. Primero querrás comprobar si el dispositivo de Verse registra un evento cuando un jugador marca la casilla. Para ello, primero escribe seudocódigo para demostrar el concepto de interacción.

1. Debajo de la definición de la clase switch_state_puzzle, añade el siguiente campo editable.

   1. Una matriz editable de tipo switch_device llamada Switches. Esto hará referencia a todos tus interruptores en el puzle.

   2. Una matriz variable de tipo cancelable llamada SwitchSubscriptions. Contiene una referencia a cada suscripción de switch_device que puedes utilizar para restablecer los interruptores.

    switch_state_puzzle := class(creative_device):
    
    @editable
    Switches : []switch_device = array{} #Hace referencia a los interruptores con los que los jugadores pueden interactuar.

    var SwitchSubscriptions : []cancelable = array{}

Copy full snippet

switch_state_puzzle := class(creative_device): @editable Switches : []switch_device = array{} #Hace referencia a los interruptores con los que los jugadores pueden interactuar. var SwitchSubscriptions : []cancelable = array{}

1. En el mismo archivo, crea una nueva clase llamada switch_event_handler. En esta clase identificarás el dispositivo de Verse y los interruptores.

2. Añade un nuevo método OnSwitchPressed() a la clase switch_event_handler. Este método comprueba el dispositivo de Verse frente a la interacción del jugador llamando a CheckSequence() en la clase item_switch_puzzle. También imprime Pulsado cada vez que se interactúa con un interruptor.

## Una clase de controlador de eventos para gestionar las interacciones del interruptor
## Este controlador de eventos se adjunta a los eventos del bucle anterior.
switch_event_handler := class():
    PuzzleDevice : item_switch_puzzle
    Switch : switch_device

    OnSwitchPressed(InPlayer : agent) : void =
        Print("Pulsado")
        PuzzleDevice.CheckSequence(InPlayer)

Copy full snippet

## Una clase de controlador de eventos para gestionar las interacciones del interruptor ## Este controlador de eventos se adjunta a los eventos del bucle anterior. switch_event_handler := class(): PuzzleDevice : item_switch_puzzle Switch : switch_device OnSwitchPressed(InPlayer : agent) : void = Print("Pulsado") PuzzleDevice.CheckSequence(InPlayer)

Cómo añadir un registrador de impresión

Una forma de comprobar si tu código es correcto o no es imprimir en un registro. Esto te permite ver visualmente qué partes del código funcionan según lo previsto mediante la impresión de mensajes. Añade el registrador de impresión encima de la clase de dispositivo del modo Creativo.

    Imprimir<native><public>(mensaje:[]char, nivel:log_level):void

Copy full snippet

Imprimir<native><public>(mensaje:[]char, nivel:log_level):void

Cómo hacer referencia a los interruptores

Ahora necesitas una forma de hacer referencia a tus dispositivos Interruptor en el puzle. Hacer referencia a los dispositivos Interruptor te proporciona una forma de recorrer en bucle todos los interruptores y añadir controladores de eventos a cada uno cuando la partida esté en marcha.

1. En OnBegin() de la clase switch_state_puzzle, añade una expresión for para recorrer cada Switch de la matriz Switches. Recupera el índice de cada Switch y guárdalo en una variable SwitchIndex.

2. Añade una función Print bajo la expresión para que identifica el interruptor con el que se está interactuando durante el tiempo de ejecución escribiendo Switch {SwitchIndex} added en el comando Print.

3. Como la solución del puzle se basa en un orden determinado de los estados de los interruptores, tienes que comprobar si el puzle se resuelve siempre que algún interruptor cambie de estado. Para ello, utilizarás la clase switch_event_handler que definiste antes para detectar dos eventos diferentes por interruptor. Para cada interruptor, crea dos suscripciones, una para los interruptores TurnedOnEvent, y otra para los interruptores TurnedOffEvent. Suscribe ambos eventos a la función OnSwitchPressed() de tu clase switch_event_handler. Pasa una referencia tanto a switch_state_puzzle como al Switch actual.

    ## Se ejecuta cuando se inicia el dispositivo en un juego en ejecución.
    OnBegin<override>()<suspends>:void=
        Print("Cargando el puzle de interruptores")

        ## Recorrer en bucle cada interruptor y añadir controladores de eventos para cada interruptor
        para (SwitchIndex -> Switch : Switches):
            Print("Interruptor {SwitchIndex} añadido")
            Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)
            Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)

Copy full snippet

## Se ejecuta cuando se inicia el dispositivo en un juego en ejecución. OnBegin<override>()<suspends>:void= Print("Cargando el puzle de interruptores") ## Recorrer en bucle cada interruptor y añadir controladores de eventos para cada interruptor para (SwitchIndex -> Switch : Switches): Print("Interruptor {SwitchIndex} añadido") Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed) Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)

1. Guarda la secuencia de comandos en Visual Studio Code y, en UEFN, haz clic en Verse -> Compilar código de Verse.

Cuando pruebes tu nivel, cada vez que enciendas o apagues un interruptor, deberías ver impreso tanto el índice del interruptor con el que has interactuado como la palabra Pulsado.

Estados del puzle

Cada interruptor del puzle puede tener dos estados, válido y no válido.

Para resolver el puzle, el jugador tiene que activar los interruptores en un orden determinado. Para implementar este orden en código, necesitas definir una secuencia de estados válidos para cada interruptor y comprobar esta secuencia cada vez que un jugador actualice el estado del interruptor.

1. Añade un nuevo método ValidState() a la clase switch_state_puzzle. Este método toma una cadena y reproduce un clip de sonido cada vez que un jugador pone un interruptor en un estado válido (se ofrece una respuesta de sonido para que sepa que va por buen camino).

2. En ValidState(), imprime la cadena State que se ha pasado y llama a Play() en el ValidAudioPlayer que configuraste anteriormente.

    # Acciones que se realizan cuando el estado es válido
    ValidState(State : string) : void =
        # Reproduce un sonido de validación
        Print("{State} válido")
        ValidAudioPlayer.Play()

Copy full snippet

# Acciones que se realizan cuando el estado es válido ValidState(State : string) : void = # Reproduce un sonido de validación Print("{State} válido") ValidAudioPlayer.Play()

1. Añade un nuevo método InvalidState() a la clase switch_state_puzzle. Este método restablece todos los interruptores después de reproducir un sonido cuando el jugador activa un estado no válido.

    # Acciones que se realizan cuando el estado no es válido
    InvalidState(InPlayer : agent) : void =
        # Reproduce un sonido de zumbido 
        # Borra todos los interruptores
        Print("No válido")
        
Copy full snippet

# Acciones que se realizan cuando el estado no es válido InvalidState(InPlayer : agent) : void = # Reproduce un sonido de zumbido # Borra todos los interruptores Print("No válido")

1. En InvalidState(), informa al jugador de que ha activado un estado que no es válido imprimiendo No válido y reproduciendo un clip de sonido al llamar a Play() en el InvalidAudioPlayer que configuraste antes. También tienes que llamar a Trigger() en tu InvalidTrigger, y a Show() en tu InvalidHUDMessage.

	# Acciones que se realizan cuando el estado no es válido
    InvalidState(InPlayer : agent) : void =
        # Reproduce un sonido de zumbido 
        # Borra todos los interruptores
        Print("No válido")
        InvalidAudioPlayer.Play()
        InvalidTrigger.Trigger()
        InvalidHUDMessage.Show()
        
Copy full snippet

# Acciones que se realizan cuando el estado no es válido InvalidState(InPlayer : agent) : void = # Reproduce un sonido de zumbido # Borra todos los interruptores Print("No válido") InvalidAudioPlayer.Play() InvalidTrigger.Trigger() InvalidHUDMessage.Show()

Crea un bucle for que se suscriba a los eventos de los dispositivos del interruptor. La declaración de impresión identifica qué interruptores acciona un jugador y la secuencia en la que se accionan los interruptores.

        ## Recorrer en bucle cada interruptor y añadir controladores de eventos para cada interruptor
        para (SwitchIndex -> Switch : Switches):
            Print("Interruptor {SwitchIndex} añadido")
            Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)
            Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)
            
Copy full snippet

## Recorrer en bucle cada interruptor y añadir controladores de eventos para cada interruptor para (SwitchIndex -> Switch : Switches): Print("Interruptor {SwitchIndex} añadido") Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed) Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)

En un bucle for, recorre todos los interruptores y apaga cada uno de ellos. Como el método TurnOff() del interruptor requiere un instigador de jugador, pasa el jugador que activó el estado no válido.

        ## Recorre los interruptores y apaga cada uno de ellos 
        para (SwitchIndex -> Switch : Switches):
            Switch.TurnOff(InPlayer)

Copy full snippet

## Recorre los interruptores y apaga cada uno de ellos para (SwitchIndex -> Switch : Switches): Switch.TurnOff(InPlayer)

1. Guarda el código, vuelve a UEFN y selecciona Verse > Compilar código de Verse.

A continuación, tienes que crear la lógica en la clase item_switch_puzzle que recorre cada interruptor y valida su estado con respecto a la matriz del puzle para determinar en qué estado (válido o no válido) se encuentra el interruptor.

Cómo ordenar los estados del interruptor

La comprobación de la validez de la activación de un interruptor se realiza creando un método CheckSequence que utiliza una expresión for para comprobar el estado actual del interruptor. Para definir si el cambio de estado de un interruptor es válido o no, puedes utilizar una declaración if para definir qué cambio de interruptor es válido en la secuencia y qué cambios de interruptor no lo son.

1. Añade un nuevo método CheckSequence(). Este método toma al jugador como instigador de los cambios de estado del interruptor y una matriz de valores lógicos correspondientes a los estados del interruptor. En CheckSequence(), crea un bucle para para iterar cada interruptor de la matriz Switches. Obtén el índice de cada interruptor de la matriz y guárdalo en una variable SwitchIndex. En el bucle para, comprueba el estado de cada interruptor llamando a GetCurrentState[]. A continuación, imprime el estado del interruptor en el registro.

    # Función para validar la secuencia de los interruptores
    CheckSequence(InPlayer : agent) : void =
        para (SwitchIndex -> Switch : Switches):
            if(Switch.GetCurrentState[]) then Print("{SwitchIndex} activado") else Print("{SwitchIndex} desactivado")

Copy full snippet

# Función para validar la secuencia de los interruptores CheckSequence(InPlayer : agent) : void = para (SwitchIndex -> Switch : Switches): if(Switch.GetCurrentState[]) then Print("{SwitchIndex} activado") else Print("{SwitchIndex} desactivado")

Ahora tienes que crear una secuencia de estados para comprobarlos mediante CheckSequence(). Para ello, vas a añadir una nueva funcionalidad al método OnSwitchPressed() del switch_event_handler.

Estados de la secuencia

Crea la secuencia para los estados de los interruptores utilizando matrices. Cada matriz comprueba la validez de la secuencia en que se pulsan los interruptores. Registra la secuencia de acciones del jugador sobre los interruptores mediante el registrador de impresión para registrar si los interruptores se han Pulsado y si la secuencia es válida e imprime el número de la secuencia en el registrador ("Uno", "Dos", "Tres" y "Cuatro").

1. En OnSwitchPressed(), dentro de una instrucción if, llama a CheckSequence() y pasa tanto el jugador como una nueva matriz de valores lógicos. Esta nueva matriz debe corresponder a tu serie de interruptores, con valores false que representen interruptores apagados y valores true que representen interruptores encendidos. Establece el interruptor que quieres que los jugadores pulsen primero en true, y todos los demás valores en false. Si la llamada a CheckSequence[] tiene éxito, llama a ValidState() pasando "Uno" para representar el primer interruptor pulsado.

    OnSwitchPressed(InPlayer : agent) : void =
        Print("Pulsado")
        PuzzleDevice.CheckSequence(InPlayer)

Copy full snippet

OnSwitchPressed(InPlayer : agent) : void = Print("Pulsado") PuzzleDevice.CheckSequence(InPlayer)

1. Codifica la clave de respuesta para las pulsaciones de cada uno de los interruptores de tu puzle, en el orden en que quieras que se pulsen.

    if:
            # comprueba los estados válidos y codifica la validación de los estados
            # [apagado],[apagado],[encendido],[apagado] Estado uno
            not Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Uno")

        else if:
            # comprueba los estados válidos
            #[encendido], [apagado], [encendido], [apagado] Estado dos
            Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Dos")

        else if:
            # comprueba los estados válidos
            #[encendido], [encendido], [encendido], [apagado] Estado tres
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Tres")
            
        else if:
            # comprueba los estados válidos
            #[encendido], [encendido], [encendido], [encendido] Estado cuatro, el puzle se ha resuelto
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            Switches[3].GetCurrentState[]
        then:
            CompletedState()

Copy full snippet

if: # comprueba los estados válidos y codifica la validación de los estados # [apagado],[apagado],[encendido],[apagado] Estado uno not Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Uno") else if: # comprueba los estados válidos #[encendido], [apagado], [encendido], [apagado] Estado dos Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Dos") else if: # comprueba los estados válidos #[encendido], [encendido], [encendido], [apagado] Estado tres Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Tres") else if: # comprueba los estados válidos #[encendido], [encendido], [encendido], [encendido] Estado cuatro, el puzle se ha resuelto Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] Switches[3].GetCurrentState[] then: CompletedState()

1. Por último, añade una expresión else al final que llame a InvalidState(). Esto ocurrirá si falla alguna de las llamadas a CheckSequence[].

    
    else:
            # No es un estado válido, por lo que es inválido
            InvalidState(InPlayer)

Copy full snippet

else: # No es un estado válido, por lo que es inválido InvalidState(InPlayer)

1. Tu código switch_event_handler debería parecerse a esto.

    # Función para validar la secuencia de los interruptores
    CheckSequence(InPlayer : agent) : void =
        para (SwitchIndex -> Switch : Switches):
            if(Switch.GetCurrentState[]) then Print("{SwitchIndex} activado") else Print("{SwitchIndex} desactivado")
        
        if:
            # comprueba los estados válidos y codifica la validación de los estados
            # [apagado],[apagado],[encendido],[apagado] Estado uno
            not Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Uno")

        else if:
            # comprueba los estados válidos
            #[encendido], [apagado], [encendido], [apagado] Estado dos
            Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Dos")

        else if:
            # comprueba los estados válidos
            #[encendido], [encendido], [encendido], [apagado] Estado tres
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Tres")
            
        else if:
            # comprueba los estados válidos
            #[encendido], [encendido], [encendido], [encendido] Estado cuatro, el puzle se ha resuelto
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            Switches[3].GetCurrentState[]
        then:
            CompletedState()

        else:
            # No es un estado válido, por lo que es inválido
            InvalidState(InPlayer)

Copy full snippet

# Función para validar la secuencia de los interruptores CheckSequence(InPlayer : agent) : void = para (SwitchIndex -> Switch : Switches): if(Switch.GetCurrentState[]) then Print("{SwitchIndex} activado") else Print("{SwitchIndex} desactivado") if: # comprueba los estados válidos y codifica la validación de los estados # [apagado],[apagado],[encendido],[apagado] Estado uno not Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Uno") else if: # comprueba los estados válidos #[encendido], [apagado], [encendido], [apagado] Estado dos Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Dos") else if: # comprueba los estados válidos #[encendido], [encendido], [encendido], [apagado] Estado tres Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Tres") else if: # comprueba los estados válidos #[encendido], [encendido], [encendido], [encendido] Estado cuatro, el puzle se ha resuelto Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] Switches[3].GetCurrentState[] then: CompletedState() else: # No es un estado válido, por lo que es inválido InvalidState(InPlayer)

1. Guarda el código, vuelve a UEFN y selecciona Verse > Compilar código de Verse.

Ahora, cuando actives interruptores en el juego, se imprimirá el registro:

• Cargando puzle de interruptores: cuando empieza la partida.

• Interruptor {SwitchIndex} añadido: cuando se añade un interruptor al bucle.

• Pulsado: cuando un jugador enciende un interruptor.

• {State} válido: si el jugador enciende el interruptor de la derecha en el orden de la secuencia.

• No válido: si el jugador enciende el interruptor equivocado.

Si el registro informa correctamente a tus interruptores, está todo listo para añadir más dispositivos editables a la clase item_switch_puzzle y hacer que cada uno de estos estados haga algo.

Cómo añadir dispositivos

Una vez que el puzle ha sido completado con éxito por el jugador y el puzle ha recorrido los estados válidos de los interruptores hasta llegar al estado completado, el resultado debería hacer algo, como conceder objetos.

Lo mismo sucede para los estados no válidos. Si un jugador se equivoca en el puzle, la secuencia de comandos debe tenerlo en cuenta y avisar a los jugadores de que deben intentarlo de nuevo. Para conseguirlo, tienes que añadir dispositivos adicionales a la clase item_switch_puzzle.

Al añadir dispositivos editables a tu secuencia de comandos, los dispositivos aparecen en las opciones de usuario del dispositivo de Verse, donde puedes conectar los dispositivos al dispositivo de Verse para que funcionen en la partida, tal y como está escrito en la secuencia de comandos de Verse.

1. Añade los siguientes dispositivos @editable debajo de item_switch_puzzle:

	@editable 
	InvalidTrigger : trigger_device = trigger_device{}

	@editable 
	InvalidHUDMessage : hud_message_device = hud_message_device{}

	@editable 
	InvalidAudioPlayer : audio_player_device = audio_player_device{}

	@editable 
	ValidAudioPlayer : audio_player_device = audio_player_device{}

	@editable 
	FindItemsHUDMessage : hud_message_device = hud_message_device{}

	@editable 
	CompletedAudioPlayer : audio_player_device = audio_player_device{}

	@editable 
	ItemSpawners : item_spawner_device = item_spawner_device{} #Esto coge todos los generadores de objetos asociados a este puzle
    
Copy full snippet

@editable InvalidTrigger : trigger_device = trigger_device{} @editable InvalidHUDMessage : hud_message_device = hud_message_device{} @editable InvalidAudioPlayer : audio_player_device = audio_player_device{} @editable ValidAudioPlayer : audio_player_device = audio_player_device{} @editable FindItemsHUDMessage : hud_message_device = hud_message_device{} @editable CompletedAudioPlayer : audio_player_device = audio_player_device{} @editable ItemSpawners : item_spawner_device = item_spawner_device{} #Esto coge todos los generadores de objetos asociados a este puzle

1. Añade un nuevo método CompletedState() a la clase item_switch_puzzle. Este método se encarga de las acciones que se realizan cuando se completa el puzle.

    ## Acciones que se realizan cuando se completa el puzle
    CompletedState() : void =
        # Reproducir un sonido de éxito
        # Desactivar todos los interruptores
        # Generar objetos en los generadores de objetos adjuntos
        Print("Completado")

Copy full snippet

## Acciones que se realizan cuando se completa el puzle CompletedState() : void = # Reproducir un sonido de éxito # Desactivar todos los interruptores # Generar objetos en los generadores de objetos adjuntos Print("Completado")

Añade una expresión for al método CompletedState() que recorre cada generador de objetos en ItemSpawners. Activa cada generador de objetos con Enable(), y luego llama a SpawnItem() para conceder al jugador la recompensa por resolver el puzle.

    ## Recorre en bucle los generadores de objetos, lo que te permite llamar a cada generador de objetos para activar y generar su objeto.
        para (ItemSpawnerIndex -> ItemSpawner : ItemSpawners):
            ItemSpawner.Enable()
            ItemSpawner.SpawnItem()

Copy full snippet

## Recorre en bucle los generadores de objetos, lo que te permite llamar a cada generador de objetos para activar y generar su objeto. para (ItemSpawnerIndex -> ItemSpawner : ItemSpawners): ItemSpawner.Enable() ItemSpawner.SpawnItem()

1. Una vez que el puzle se haya completado correctamente, tienes que llamar reproducir() en CompletedAudioPlayer que configuraste antes, generar el contenido de metal en el generador de objetos mediante el ItemSpawnerIndex y el llamar Enable1 y SpawnItem. . Informa al jugador de que tiene que buscar los objetos recién generados llamando a Show() en FindItemsHUDMessage. Además, no quieres que el jugador siga interactuando con tus interruptores. Añade una segunda expresión para para recorrer cada interruptor de Switches y desactivarlos llamando a desactivado().

    # Acciones que se realizan cuando se completa el puzle
    CompletedState() : void =
        # Reproducir un sonido de éxito
        # Desactivar todos los interruptores
        # Generar objetos en los generadores de objetos adjuntos
        Print("Completado")
        
        # Recorre en bucle los generadores de objetos, lo que te permite llamar a cada generador de objetos para activar y generar su objeto
        para (ItemSpawnerIndex -> ItemSpawner : ItemSpawners):
            ItemSpawner.Enable()
            ItemSpawner.SpawnItem()

        # Reproduce la señal de audio especial para completar la secuencia del puzle.
        CompletedAudioPlayer.Play()

        # Reproduce un mensaje del HUD para indicar a los jugadores que busquen los objetos recién aparecidos.
        FindItemsHUDMessage.Show()

	    # Desactiva todos los interruptores cuando el puzle se haya completado correctamente.
        para (SwitchIndex -> Switch : Switches):
            Switch.Disable()

Copy full snippet

# Acciones que se realizan cuando se completa el puzle CompletedState() : void = # Reproducir un sonido de éxito # Desactivar todos los interruptores # Generar objetos en los generadores de objetos adjuntos Print("Completado") # Recorre en bucle los generadores de objetos, lo que te permite llamar a cada generador de objetos para activar y generar su objeto para (ItemSpawnerIndex -> ItemSpawner : ItemSpawners): ItemSpawner.Enable() ItemSpawner.SpawnItem() # Reproduce la señal de audio especial para completar la secuencia del puzle. CompletedAudioPlayer.Play() # Reproduce un mensaje del HUD para indicar a los jugadores que busquen los objetos recién aparecidos. FindItemsHUDMessage.Show() # Desactiva todos los interruptores cuando el puzle se haya completado correctamente. para (SwitchIndex -> Switch : Switches): Switch.Disable()

1. Guarda el código, vuelve a UEFN y selecciona Verse > Compilar código de Verse.

Ahora estos dispositivos se han añadido al dispositivo Interruptor de objetos del puzle en UEFN.

Selección de los dispositivos

Todos los dispositivos @editable se añaden al dispositivo de Verse. Ahora tienes que asociar al dispositivo de Verse los dispositivos que sacaste para crear el puzle. Para ello, selecciona item_interruptor_puzzle en el esquematizador y todas las ranuras de los dispositivos serán visibles en el panel Detalles. Solo tienes que hacer coincidir el dispositivo con la ranura.

1. Añade los dispositivos Interruptor del puzle a los cuatro elementos de la matriz Switch en Interruptor de objetos del puzle.

   

2. Añade el Activador no válido a la ranura InvalidTrigger.

3. Añade el Mensaje inválido del HUD a la ranura InvalidHUDMessage.

4. Añade el Reproductor de audio no válido a la ranura InvalidAudioPlayer.

   

5. Añade el Reproductor de audio válido a la ranura ValidAudioPlayer.

6. Añade Buscar mensaje del HUD a la ranura FindHUDMessage.

7. Añade el Reproductor de audio completado a la ranura CompletedAudioPlayer.

   

8. Añade los generadores de objetos a los cuatro elementos de la matriz ItemSpawners.

   

9. Desmarca la opción Visible en la partida para que el dispositivo de Verse esté oculto durante la partida.

   

Ahora ya puedes probar tu nivel y ver cómo los puzles mejoran la experiencia del escape room.

Siguiente sección

Con el puzle de estados de interruptores en marcha, está todo listo para crear la secuencia de comandos de Verse de teletransporte automático que lleva a los jugadores de la cinemática de apertura a la sala de espera en el subsótano de la cabaña cuando termina de reproducirse la cinemática.