10. Interruptor de estado de acertijo de Verse

Hay dos puzzle creados con Verse, el primero es el puzzle de luces combinadas. El puzzle de luces combinadas se utiliza en la habitación oculta detrás de las escaleras en el subsótano.

Puedes copiar y pegar el código que aparece en la última sección del tutorial, pero se recomienda firmemente que construyas el puzzle pieza por pieza para comprender cómo funciona el lenguaje Verse.

Para el segundo puzzle, se utiliza una clave lógica de codificación rígida para corroborar cada dispositivo interruptor, para garantizar que el interruptor correcto se haya activado en la secuencia adecuada.

Cuando se activa el interruptor adecuado, un sonido de éxito acompaña al interruptor. Del mismo modo, un mensaje y un sonido de fracaso se activan cuando se enciende el interruptor incorrecto durante la secuencia. Se reproducen un mensaje y un sonido final de éxito, y cuatro generadores de objetos se activan una vez que el puzzle se resuelve.

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

Cómo configurar los dispositivos del puzzle

Para este puzzle, necesitarás los siguientes dispositivos:

• 4 x Interruptor

• 3 x dispositivo reproductor de sonido

• 4 x Interruptor

• 2 x Dispositivo de mensajes del HUD

• 1 x Dispositivo activador

• 1 x Dispositivo de Verse

Cambia los nombres de tus generadores de objetos por los nombres de los objetos que generan.

Interruptor

Coloca un dispositivo interruptor en la pared junto a la puerta y establece las siguientes opciones

Copia tres dispositivos interruptores más en la pared y colócalos en un patrón cuadrado.

Reproductor de sonido

Coloca un reproductor de sonido en el centro del cuadrado. Configura las opciones de sonido de la siguiente manera.

Copia dos dispositivos de sonido más. Cambia el nombre a los dispositivos y agrega una señal de sonido a cada uno:

• Válido - Para la reproducción del reproductor de sonido válido, Match_Round_Change_01_Cue.

• Inválido - Para la reproducción del reproductor de sonido inválido, Player_Checkpoint_Trigger_Cue.

• Completado - Para la reproducción del reproductor de sonido completada, CTF_Return_Team_Cue.

Dispositivo activador

Coloca el dispositivo activador y establece las siguientes opciones a la derecha del cuadrado de puzzle.

Cambia el nombre del dispositivo por Activador inválido.

Dispositivo de Mensajes del HUD

Configura el primer dispositivo de mensajes del HUD de acuerdo a las siguientes opciones.

Después, saca el dispositivo de mensajes del HUD de la pared del sótano, de manera que no sea visible en la sala, y cópialo.

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

• Mensaje del HUD - Encontrar objetos

• Mensaje del HUD - Inválido

Dispositivo de Verse

Ahora ya puedes crear el programa de Verse que controla el puzzle. Crea un nuevo dispositivo de Verse denominado switch_state_puzzle con el Explorador de Verse y arrastra el dispositivo hacia el nivel. (Si deseas conocer cómo crear un nuevo dispositivo en Verse, consulta Cómo crear tu propio dispositivo con Verse.)

Diseño del puzzle

Encender los interruptores en la secuencia correcta permite a los jugadores saltearse esta parte de la sala de escape.

Cuando el jugador enciende un interruptor en la secuencia correcta, suena una campana. Si se enciende el interruptor incorrecto, se escucha un zumbido, y se reestablecen los interruptores. Los estados inválidos hacen que aparezca un mensaje, y al completar satisfactoriamente el puzzle, se reproduce un sonido de éxito, se despliega un mensaje de ayuda y se generan objetos.

Puedes visualizar la lógica del puzzle en el diagrama de flujo que está debajo.

Haz clic en la imagen para ampliarla.

La solución correcta del puzzle se muestra en el cuadro de abajo.

Funciones usadas del lenguaje Verse

• if, then, else: con las expresiones if, then, else, puedes encontrar estados válidos e inválidos para cada dispositivo interruptor y otros dispositivos dependientes de estados.

• failure: los contextos de fallo se utilizan para decidir el estado actual del acertijo y la solución.

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

API utilizadas

• Propiedades editables: se exponen a UEFN varias propiedades del dispositivo creado con Verse para poder personalizarlas en el editor. Podrás crear nuevas configuraciones del acertijo si cambias estas propiedades.

• Eventos de dispositivo: los botones InteractedWithEvent se utilizan para controlar el estado del juego.

Interacción del interruptor

Piensa sobre los pasos necesarios para ejecutar el puzzle. Primero, debes corroborar si el dispositivo de Verse registra un evento cuando el jugador marca la casilla. Para lograr esto, escribe pseudocódigo primero para probar el concepto de interacción.

1. Debajo de la definición de la clase switch_state_puzzle, añade los siguientes campos editables.

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

   2. Una matriz variable del tipo cancelable llamada SwitchSubscriptions. Esto guarda una relación con cada suscripción switch_device que puedes usar para reestablecer los interruptores.

    switch_state_puzzle := class(creative_device):
    
    @editable
    Interruptores : []switch_device = array{} #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 Interruptores : []switch_device = array{} #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, tendrás que identificar el dispositivo de Verse y los interruptores.

2. Añade un método nuevo OnSwitchPressed() a la clase switch_event_handler. Este método verifica el dispositivo de Verse con la interacción del jugador al llamar CheckSequence() en la clase item_switch_puzzle. También aparece pulsado cada vez que se interactúa con un interruptor.

# Una clase de controlador de eventos para controlar las interacciones de interruptores.
# Este controlador de eventos se adjunta a los eventos en el bucle que aparece arriba
switch_event_handler := class():
    PuzzleDevice : item_switch_puzzle
    Interruptor: switch_device

    OnSwitchPressed(InPlayer : agent) : void =
        Print("Se hizo clic.")
        PuzzleDevice.CheckSequence(InPlayer)

Copy full snippet

# Una clase de controlador de eventos para controlar las interacciones de interruptores. # Este controlador de eventos se adjunta a los eventos en el bucle que aparece arriba switch_event_handler := class(): PuzzleDevice : item_switch_puzzle Interruptor: switch_device OnSwitchPressed(InPlayer : agent) : void = Print("Se hizo clic.") PuzzleDevice.CheckSequence(InPlayer)

Agrega un registro de impresiones

Una manera de verificar si el código es exitoso o no es imprimir un registro. Esto permite ver visualmente qué partes del código funcionan según lo previsto mediante la impresión de mensajes. Añade un registro de impresiones por encima de la clase del dispositivo del modo Creativo.

    Print<native><public>(Message:[]char, Level:log_level):void

Copy full snippet

Print<native><public>(Message:[]char, Level:log_level):void

Interruptores de referencia

Ahora se necesita una manera para hacer referencia a los dispositivos interruptores en el puzzle. Dirigirse a los dispositivos interruptores ofrece una manera de pasar a través de todos lo interruptores y añadir controladores de eventos para cada interruptor cuando el juego está en ejecución.

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

2. Añade una función print debajo de la expresión for, que identifica al interruptor con el que se interactúa durante el tiempo de ejecución, y escribe Se añadió el interruptor {SwitchIndex} en el comando print.

3. Debido a que la solución del puzzle se basa en un cierto orden de estados de interruptor, es necesario verificar si el puzzle se resuelve siempre que cambia el estado de cualquier interruptor. Para hacer esto, hay que utilizar la clase switch_event_handler, definida anteriormente, para escuchar dos eventos diferentes por interruptor. Para cada interruptor, crea dos suscripciones, una para los interruptores TurnedOnEvent, y otro para los interruptores TurnedOffEvent. Suscribe ambos eventos a la función OnSwitchPressed() de la clase switch_event_handler. Pasa una referencia a switch_state_puzzley al Switch actual.

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

        # Cómo pasar a través de cada interruptor y añadir controladores de evento para cada uno
        for (SwitchIndex -> Switch : Switches):
            Print("Se añadió el interruptor {SwitchIndex}.")
            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 el dispositivo se inicia en un juego en ejecución OnBegin<override>()<suspends>:void= Print("Cargando el puzle de luces.") # Cómo pasar a través de cada interruptor y añadir controladores de evento para cada uno for (SwitchIndex -> Switch : Switches): Print("Se añadió el interruptor {SwitchIndex}.") 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.

Al evaluar el nivel, cada vez que se enciende o se apaga, se debería ver impreso tanto el índice del interruptor con el que se interactuó como la palabra "pulsado".

Estados del puzzle

Cada interruptor en el puzzle puede tener dos estados: válido e inválido.

Para guardar el puzzle, el jugador necesita activar los interruptores en un cierto orden. Para implementar este orden en código, es necesario definir una secuencia de estados válidos para cada interruptor y verificar esta secuencia siempre que un jugador actualiza 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 siempre que un jugador cambie el interruptor a un estado válido, lo que le da un feedback de audio para saber que va por el camino correcto.

2. En ValidState(), imprime la cadena State que se aprobó y llama a Play() en el validAudioPlayer que se configuró anteriormente.

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

Copy full snippet

#Acciones para realizar cuando el estado es válido ValidState(State : string) : void = #Reproducir 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 reinicia todos los interruptores después de reproducir un sonido cuando el jugador activa un estado no válido.

    # Acciones para realizar cuando el estado es inválido
    InvalidState(InPlayer : agent) : void =
        #Reproducir un sonido de zumbido 
        #Borrar todos los interruptores
        Print("Inválido")
        
Copy full snippet

# Acciones para realizar cuando el estado es inválido InvalidState(InPlayer : agent) : void = #Reproducir un sonido de zumbido #Borrar todos los interruptores Print("Inválido")

1. En InvalidState(), hay que hacerle saber al jugador que activó el estado inválido mediante la impresión "Inválido" y la reproducción del clip de sonido al llamar a Play() en el InvalidAudioPlayer configurado anteriormente. Es necesario también llamar a Trigger() en el InvalidTrigger, y Show() tu InvalidHUDMessage.

	# Acciones para realizar cuando el estado es inválido
    InvalidState(InPlayer : agent) : void =
        #Reproducir un sonido de zumbido 
        #Borrar todos los interruptores
        Print("Inválido")
        InvalidAudioPlayer.Play()
        InvalidTrigger.Trigger()
        InvalidHUDMessage.Show()
        
Copy full snippet

# Acciones para realizar cuando el estado es inválido InvalidState(InPlayer : agent) : void = #Reproducir un sonido de zumbido #Borrar todos los interruptores Print("Inválido") InvalidAudioPlayer.Play() InvalidTrigger.Trigger() InvalidHUDMessage.Show()

Crea un bucle for que se suscriba a los eventos de los dispositivos interruptores. La instrucción print identifica los interruptores que acciona un jugador y la secuencia en que se accionan.

        # Cómo pasar a través de cada interruptor y apagar cada uno de ellos
        for (SwitchIndex -> Switch : Switches):
            Print("Se añadió el interruptor {SwitchIndex}.")
            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

# Cómo pasar a través de cada interruptor y apagar cada uno de ellos for (SwitchIndex -> Switch : Switches): Print("Se añadió el interruptor {SwitchIndex}.") 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, pasa a través de todos los interruptores y apaga cada uno de ellos. Debido a que el método del interruptor TurnOff() requiere un jugador instigador, pasa al jugador que activó el estado inválido.

        ## Cómo pasar a través de cada interruptor y apagar cada uno de ellos 
        for (SwitchIndex -> Switch : Switches):
            Switch.TurnOff(InPlayer)

Copy full snippet

## Cómo pasar a través de cada interruptor y apagar cada uno de ellos for (SwitchIndex -> Switch : Switches): Switch.TurnOff(InPlayer)

1. Guarda tu código, regresa a UEFN y selecciona Verse > Compilar código de Verse.

A continuación, es necesario crear la lógica en la clase item_switch_puzzle que pasa a través de cada interruptor y valida su estado con la matriz del puzzle, para determinar en qué estado queda (válido o inválido) el cambio de interruptor.

Cómo organizar estados de interruptor

Corroborar la validez de un cambio de interruptor es posible mediante la creación de un método CheckSequence que utiliza la expresión for para corroborar el estado actual del interruptor. Para definir si el cambio de estado del interruptor es válido o no, se puede utilizar un enunciado if para definir qué cambio de interruptor es válido en la secuencia y cuáles no.

1. Añade un nuevo método CheckSequence(). Este método toma al jugador como instigador de los cambios del estado del interruptor y de una matriz de valores lógicos que corresponden a los estados del interruptor. En CheckSequence(), crea un bucle for para iterar a través de cada interruptor en la matriz switches. Obtén el índice de cada interruptor en la matriz y guárdalo en una variable SwitchIndex. En el bucle for, verifica cada estado del interruptor mediante una llamada a GetCurrentState[]. Luego, imprime el estado del interruptor en el registro.

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

Copy full snippet

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

Ahora es necesario crear una secuencia de estados con los cuales verificarlo, mediante CheckSequence[]. Para hacer esto, añade una nueva funcionalidad al método OnSwitchPressed() de switch_event_handler.

Estados de secuencia

Crea una secuencia para los estados de interruptor mediante el uso de matrices. Cada matriz verifica la validez de la secuencia a la que cambian los interruptores. Registra la secuencia de las acciones de los jugadores en los interruptores con el registro de impresiones para registrar si se hizo clic en los interruptores y si la secuencia es válida al imprimir el número de la secuencia en registro ("Uno", "Dos", "Tres" y "Cuatro").

1. En OnSwitchPressed(), dentro de un enunciado if , llama a CheckSequence[] pasando tanto al jugador como a la nueva matriz de valores lógicos. Esta matriz nueva debe corresponder con tu serie de interruptores, con valores false que representan los interruptores apagados, y valores true, que representan los interruptores encendidos. Configurar como true el interruptor que quieres que los jugadores presionen primero, y todos los otros valores, como falsos. Si el llamado a CheckSequence[] es exitoso, llama a ValidState() y pasa "Uno" para representar el primer interruptor presionado.

    OnSwitchPressed(InPlayer : agent) : void =
        Print("Se hizo clic.")
        PuzzleDevice.CheckSequence(InPlayer)

Copy full snippet

OnSwitchPressed(InPlayer : agent) : void = Print("Se hizo clic.") PuzzleDevice.CheckSequence(InPlayer)

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

    if:
            # comprueba los estados válidos y codifica la validación de los estados
            # [off],[off],[on],[off] 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
            #[On], [Off], [On], [Off] Estado dos
            if(Switch.GetCurrentState[] = States[SwitchIndex]) {}
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Dos")

        else if:
            # comprueba los estados válidos
            #[On], [On], [On], [Off] 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
            #[On], [On], [On], [On] Estado cuatro, puzzle completado
            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 # [off],[off],[on],[off] 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 #[On], [Off], [On], [Off] Estado dos if(Switch.GetCurrentState[] = States[SwitchIndex]) {} not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Dos") else if: # comprueba los estados válidos #[On], [On], [On], [Off] 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 #[On], [On], [On], [On] Estado cuatro, puzzle completado Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] Switches[3].GetCurrentState[] then: CompletedState()

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

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

Copy full snippet

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

1. Tu código switch_event_handler debería verse de la siguiente manera.

    # Función para validar la secuencia de los interruptores
    CheckSequence(InPlayer : agent) : void =
        for (SwitchIndex -> Switch : Switches):
            if(Switch.GetCurrentState[]) then Logger.Print("{SwitchIndex} encendido") other Logger.Print("{SwitchIndex} apagado")
        
        if:
            # comprueba los estados válidos y codifica la validación de los estados
            # [off],[off],[on],[off] 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
            #[On], [Off], [On], [Off] 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
            #[On], [On], [On], [Off] 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
            #[On], [On], [On], [On] Estado cuatro, puzzle completado
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            Switches[3].GetCurrentState[]
        then:
            CompletedState()

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

Copy full snippet

# Función para validar la secuencia de los interruptores CheckSequence(InPlayer : agent) : void = for (SwitchIndex -> Switch : Switches): if(Switch.GetCurrentState[]) then Logger.Print("{SwitchIndex} encendido") other Logger.Print("{SwitchIndex} apagado") if: # comprueba los estados válidos y codifica la validación de los estados # [off],[off],[on],[off] 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 #[On], [Off], [On], [Off] 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 #[On], [On], [On], [Off] 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 #[On], [On], [On], [On] Estado cuatro, puzzle completado Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] Switches[3].GetCurrentState[] then: CompletedState() else: # No es un estado válido, así que es inválido InvalidState(InPlayer)

1. Guarda tu código, regresa a UEFN y selecciona Verse > Compilar código de Verse.

Ahora, mientras enciendes los interruptores en el juego, el registro mostrará lo siguiente:

• Cargando puzzle de interruptor: cuando el juego comienza

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

• Presionado: cuando un jugador enciende el interruptor.

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

• Inválido: si el jugador enciende el interruptor incorrecto

Si el registro se presenta correctamente en cuanto a tus cambios de interruptores, podrás 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 jugador completó correctamente el puzzle y que el puzzle pasó a través de los estados válidos de los interruptores hasta el estado completado, el resultado satisfactorio debería hacer algo, como otorgar objetos.

Lo mismo es verdadero para los InvalidStates. Si el jugador hace mal el puzzle, la secuencia de comandos debería considerar eso y hacerle saber a los jugadores que necesitan intentarlo nuevamente. Para lograr esto, es necesario añadir dispositivos adicionales a la clase item_switch_puzzle.

Al añadir dispositivos editables a la secuencia de comandos, los dispositivos se muestran en las opciones de usuario del dispositivo de Verse, donde puedes conectar los dispositivos al dispositivo de Verse de manera que funcionen en el juego como si estuviera escrito en la secuencia de comandos de Verse.

1. Añade los siguientes dispositivos @editable debajo del 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 toma todos los generadores de objetos asociados con este puzzle
    
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 toma todos los generadores de objetos asociados con este puzzle

1. Añade un nuevo método CompletedState() a la clase item_switch_puzzle. Este método maneja las acciones realizadas cuando se completa el acertijo.

    #Acciones para realizar cuando se completa el puzzle
    CompletedState() : void =
        # Reproducir un sonido de éxito
        # Establecer todos los interruptores como deshabilitados
        # Generar objetos en los generadores de objetos adjuntos
        Print("Completado.")

Copy full snippet

#Acciones para realizar cuando se completa el puzzle CompletedState() : void = # Reproducir un sonido de éxito # Establecer todos los interruptores como deshabilitados # Generar objetos en los generadores de objetos adjuntos Print("Completado.")

1. Añade una expresión for al método CompletedState() que itera a través de cada generador de objetos en ItemSpawners. Habilita cada dispositivo de aparición de objetos con Enable(); luego, llama a SpawnItem() para otorgarle al jugador la recompensa por resolver el acertijo.

    ## Pasar a través de los generadores de objetos, lo que permite llamar a cada generador de objetos para habilitar y generar este objeto
        for (ItemSpawnerIndex -> ItemSpawner : ItemSpawners):
            ItemSpawner.Enable()
            ItemSpawner.SpawnItem()

Copy full snippet

## Pasar a través de los generadores de objetos, lo que permite llamar a cada generador de objetos para habilitar y generar este objeto for (ItemSpawnerIndex -> ItemSpawner : ItemSpawners): ItemSpawner.Enable() ItemSpawner.SpawnItem()

1. Una vez que el acertijo se completó con éxito, debes llamar a Play() en el CompletedAudioPlayer que configuraste antes, generar las piezas de metal en los dispositivos de aparición de objetos a través del ItemSpawnerIndex y llamar a Enable1 y SpawnItem. Para informar al jugador que necesita buscar los elementos que se acaban de generar, llama a Show() en el FindItemsHUDMessage. Además, no quieres que el jugador continúe interactuando con los interruptores. Añade una segunda expresión for para hacer un bucle a través de cada interruptor en Switches y deshabilitarlos mediante una llamada a Disable().

    # Acciones para realizar cuando se completa el puzzle
    CompletedState() : void =
        # Reproducir un sonido de éxito
        # Establecer todos los interruptores como deshabilitados
        # Generar objetos en los generadores de objetos adjuntos
        Print("Completado.")
        
        # Pasar a través de los generadores de objetos, lo que permite llamar a cada generador de objetos para habilitar y generar este objeto
        for (ItemSpawnerIndex -> ItemSpawner : ItemSpawners):
            ItemSpawner.Enable()
            ItemSpawner.SpawnItem()

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

        #Reproduce un mensaje del HUD para decirle a los jugadores que busquen los nuevos objetos generados
        FindItemsHudMessage.Show()

	    #Deshabilitar todos los interruptores al completar correctamente el puzzle
        for (SwitchIndex -> Switch : Switches):
            Switch.Disable()

Copy full snippet

# Acciones para realizar cuando se completa el puzzle CompletedState() : void = # Reproducir un sonido de éxito # Establecer todos los interruptores como deshabilitados # Generar objetos en los generadores de objetos adjuntos Print("Completado.") # Pasar a través de los generadores de objetos, lo que permite llamar a cada generador de objetos para habilitar y generar este objeto for (ItemSpawnerIndex -> ItemSpawner : ItemSpawners): ItemSpawner.Enable() ItemSpawner.SpawnItem() #Reproduce la señal de sonido especial para completar la secuencia del puzzle CompletedAudioPlayer.Play() #Reproduce un mensaje del HUD para decirle a los jugadores que busquen los nuevos objetos generados FindItemsHudMessage.Show() #Deshabilitar todos los interruptores al completar correctamente el puzzle for (SwitchIndex -> Switch : Switches): Switch.Disable()

1. Guarda tu código, regresa a UEFN y selecciona Verse > Compilar código de Verse.

Ahora estos dispositivos se añadieron al dispositivo de puzzle de interruptores de objetos en UEFN.

Seleccionar dispositivos

@editable se añaden al dispositivo de Verse. Ahora es necesario adjuntar estos dispositivos que se sacaron para crear el puzzle en el dispositivo de Verse. Para hacer esto, selecciona item_switch_puzzle en el esquematizador, y todas las ranuras del dispositivo estarán visibles en el panel de detalles. Solo se tiene que unir el dispositivo con la ranura.

1. Añade los dispositivos de interruptores del acertijo a los elementos de la matriz de 4 interruptores con el nombre Acertijo de interruptores de objetos.

   

2. Añade el activador inválido a la ranura InvalidTrigger

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

4. Añade el reproductor de sonido inválido a la ranura InvalidAudioPlayer.

   

5. Añade el reproductor de sonido válido a la ranura ValidAudioPlayer.

6. Añade el dispositivo de encontrar mensaje del HUD a la ranura FindHUDMessage.

7. Añade el reproductor de sonido completado a la ranura CompletedAudioPlayer.

   

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

   

9. Desmarca la opción Visible durante el juego para que el dispositivo de Verse quede oculto durante el juego.

   

Ahora es posible realizar una prueba de juego de tu nivel y ver cómo se añaden los puzzle a la experiencia de la sala de escape.

Siguiente sección

Con el puzzle de estado de interruptor en funcionamiento, ya es posible crear una secuencia de comandos de Verse de teletransporte automático, que lleva a los jugadores de estar mirando en la cinemática de apertura a la sala de espera, en la cabina del subsótano, una vez que la cinemática termina de reproducirse.