10. Quebra-cabeça de estado do interruptor em Verse

Há dois quebra-cabeças criados em Verse. O primeiro é o Quebra-cabeça Luzes Marcadas. O quebra-cabeça Luzes Marcadas é usado na sala oculta atrás das escadas, no subsolo.

Você pode copiar e colar o código da última seção do tutorial, mas é altamente recomendável construir o quebra-cabeça peça a peça para entender como funciona a linguagem Verse.

O segundo quebra-cabeça usa uma chave lógica escrita diretamente no código para conferir cada dispositivo interruptor, garantindo o acionamento do interruptor correto na sequência apropriada.

Ao acionar o interruptor correto, um som de sucesso é emitido. Da mesma forma, serão emitidos um som e uma mensagem de falha quando o interruptor errado for ligado durante a sequência. Uma mensagem e um som de sucesso final são emitidos, e quatro geradores de itens são ativados quando o quebra-cabeça é solucionado.

Você pode usar uma matriz para verificar os estados válidos e inválidos, bem como acionar dispositivos conectados a um estado. Para este exemplo, a chave de resposta foi codificada para ajudar os novatos em codificação a entender o que o código está fazendo.

Como configurar dispositivos Quebra-cabeça

Para este quebra-cabeça, você precisará dos dispositivos a seguir:

• 4 Interruptor

• 3 x Dispositivo Reprodutor de Áudio

• 4 Interruptor de Item

• 2 Mensagem do HUD

• 1 Gatilho

• 1 Dispositivo Verse

Renomeie seus geradores de item com o item a ser gerado.

Dispositivo - Interruptor

Coloque um dispositivo Interruptor na parede perto da porta e configure as opções a seguir

Copie pelo menos três dispositivos Interruptor na parede e coloque-os na linha.

Dispositivo - Áudio

Coloque um dispositivo Áudio no centro do local quadrado. Defina as opções de áudio para as configurações a seguir.

Copie pelo menos dois dispositivos Áudio. Renomeie os dispositivos e adicione uma indicação sonora a cada um deles:

• Válido: Para a reprodução do dispositivo Áudio Válido, Match_Round_Change_01_Cue.

• Inválido: Para a reprodução do dispositivo Áudio Inválido, Player_Checkpoint_Trigger_Cue.

• Concluído: Para a reprodução do dispositivo Áudio Concluído, CTF_Return_Team_Cue

Dispositivo - Gatilho

À direita dos interruptores, coloque o dispositivo Gatilho e defina as seguintes opções.

Renomeie o dispositivo Gatilho Inválido.

Dispositivo - Mensagem do HUD

Configure o primeiro dispositivo Mensagem do HUD usando as opções a seguir.

Em seguida, translade o dispositivo Mensagem do HUD para fora da parede do porão, para que não fique visível na sala e copie-o.

Renomeie cada um dos dispositivos Mensagem do HUD:

• Mensagem do HUD - Encontrar itens

• Mensagem do HUD - Inválido

Dispositivo - Verse

Agora você já pode criar o programa Verse que controla o quebra-cabeça. Crie um novo dispositivo Verse chamado switch_state_puzzle usando o Explorador do Verse e arraste-o para o nível. (Para ver as etapas sobre como criar um novo dispositivo Verse, consulte Crie seu próprio dispositivo usando Verse.)

Design do quebra-cabeça

Ligar interruptores na sequência certa permite que os jogadores passem de um certo ponto na escape room.

Quando o jogador ligar um interruptor na sequência certa, um sino soará. Se o interruptor incorreto for ligado, uma campainha tocará, e o interruptor será redefinido. Em estados inválidos, uma mensagem de aviso é exibida. Ao concluir o quebra-cabeça com sucesso, um som de sucesso é emitido, uma mensagem positiva é exibida e itens são gerados.

Você pode visualizar a lógica do quebra-cabeça no fluxograma abaixo.

Clique na imagem para ampliar.

A solução correta do quebra-cabeça é mostrada na tabela abaixo.

Funcionalidades da linguagem Verse usadas

• if, then, else: com as expressões if, then e else, você poderá encontrar os estados válidos e inválidos para cada dispositivo interruptor e outros dispositivos que dependem de estados.

• failure: contextos de falha são usados para decidir o estado atual do quebra-cabeça e sua solução.

• for: a expressão for é usada para iterar sobre cada interruptor do quebra-cabeça e realizar operações neles.

APIs usadas

• Propriedades editáveis: várias propriedades de dispositivos criados com Verse são expostas ao UEFN para que você possa personalizá-las no editor. É possível criar novas configurações de quebra-cabeça alterando essas propriedades.

• Eventos de dispositivo: os eventos InteractedWithEvent dos botões são usados para controlar o estado do jogo.

Interação com o interruptor

Pense nos passos necessários para executar o quebra-cabeça. Primeiro, você deve conferir se o dispositivo Verse registra um evento quando o jogador marcar a caixa. Para fazer isso, escreva pseudocode antes para provar o conceito de interação.

1. Abaixo da definição da classe "switch_state_puzzle", adicione os seguintes campos editáveis.

   1. Uma matriz editável do tipo switch_device chamada Switches. Refere-se a todos os seus interruptores no quebra-cabeça.

   2. Uma matriz de variáveis do tipo cancelable (cancelável) chamada SwitchSubscriptions. Contém uma referência a cada assinatura de "switch_device" que pode ser usada para redefinir os interruptores.

    switch_state_puzzle := class(creative_device):
    
    @editable
    Interruptores: []switch_device = array{} #Faz referência aos interruptores com os quais os jogadores podem interagir

    var SwitchSubscriptions : []cancelable = array{}

    ~~~

1. No mesmo arquivo, crie uma nova classe chamada `switch_event_handler`. Nela, você identificará o dispositivo Verse e os interruptores.

1. Adicione um novo método `OnSwitchPressed()` à classe `switch_event_handler`.  Esse método compara o dispositivo Verse com a interação do jogador ao chamar `CheckSequence()` na classe `item_switch_puzzle`. Também imprime **Clicado** a cada interação com o interruptor.

~~~(verse)

## Uma classe de manipulador de eventos para manipular interações de interruptor
## O manipulador de eventos é anexado aos eventos no loop acima
switch_event_handler := class():
    PuzzleDevice : item_switch_puzzle
    Switch : switch_device

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

Copy full snippet

switch_state_puzzle := class(creative_device): @editable Interruptores: []switch_device = array{} #Faz referência aos interruptores com os quais os jogadores podem interagir var SwitchSubscriptions : []cancelable = array{} ~~~ 1. No mesmo arquivo, crie uma nova classe chamada `switch_event_handler`. Nela, você identificará o dispositivo Verse e os interruptores. 1. Adicione um novo método `OnSwitchPressed()` à classe `switch_event_handler`. Esse método compara o dispositivo Verse com a interação do jogador ao chamar `CheckSequence()` na classe `item_switch_puzzle`. Também imprime **Clicado** a cada interação com o interruptor. ~~~(verse) ## Uma classe de manipulador de eventos para manipular interações de interruptor ## O manipulador de eventos é anexado aos eventos no loop acima switch_event_handler := class(): PuzzleDevice : item_switch_puzzle Switch : switch_device OnSwitchPressed(InPlayer : agent) : void = Print("Clicado") PuzzleDevice.CheckSequence(InPlayer)

Adicionar um logger de impressão

Uma maneira de conferir se o código funciona é imprimir em um log. Ou seja, você poderá gerar mensagens para conferir visualmente quais partes do código funcionam. Adicione um logger de impressão acima da classe do dispositivo do Modo Criativo.

~~~(verse)

Print(Message:[]char, Level:log_level):void

##Referenciamento de interruptores

Agora você precisa de uma maneira de referenciar seus dispositivos Interruptor no quebra-cabeça. O referenciamento de dispositivos Interruptor proporciona um modo de executar um loop em todos os interruptores e adicionar manipuladores de evento a cada um deles durante a execução do jogo. 

1. Em `OnBegin()`, na classe `switch_state_puzzle`, adicione uma expressão `for` para iterar em cada `Switch` da matriz `Switches`. Recupere o índice de cada `Switch` e armazene na variável `SwitchIndex`.

1. Adicione uma função `Print` abaixo da expressão `for` que identifica o interruptor da interação durante o tempo de execução ao digitar **`Switch {SwitchIndex} added`** no comando `Print`.

1. Já que a solução do quebra-cabeça se baseia em uma determinada ordem de estados do interruptor, será preciso verificar se o quebra-cabeça é solucionado a cada mudança de estado do interruptor. Para isso, você usará a classe `switch_event_handler` definida anteriormente para escutar dois eventos diferentes por interruptor. Para cada interruptor, crie duas inscrições: uma para os interruptores `TurnedOnEvent` e uma para os interruptores `TurnedOffEvent`. Registre ambos os eventos na função `OnSwitchPressed()` da classe `switch_event_handler`. Passe uma referência para `switch_state_puzzle` e para o `Switch` atual.

        ~~~(verse)

    ## É executado quando o dispositivo é iniciado em um jogo em execução
    OnBegin<override>()<suspends>:void=
        Print("Carregando quebra-cabeça de interruptor")

        # Execução de loop em cada interruptor e adição de manipuladores de evento para cada um deles
        for (SwitchIndex -> Switch : Switches):
            Print("Interruptor {SwitchIndex} adicionado")
            Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)
            Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)

~~~

1. Salve o script no Visual Studio Code e, no UEFN, clique em **Verse -> Compilar código Verse**.

Ao testar sua fase, toda vez que ligar ou desligar um interruptor, deverá ser impresso o índice do interruptor da interação e a palavra **Clicado**.

##Estados do quebra-cabeça

Cada interruptor no quebra-cabeça pode ter dois estados: válido e inválido.

Para solucionar o quebra-cabeça, o jogador precisa alternar os interruptores em uma determinada ordem. Para implementar essa ordem no código, basta definir uma sequência de estados válidos para cada interruptor e verificá-la sempre que o jogador atualizar o estado do interruptor. 

1. Adicione um novo método `ValidState()` à classe `switch_state_puzzle`. Esse método obtém uma string e reproduz um clipe de áudio sempre que o jogador altera um interruptor para um estado válido, o que emite uma resposta de áudio para avisar que está no caminho certo. 

1. Em `ValidState()`, imprima a string `State` que foi passada e chame `Play()` no `ValidAudioPlayer` configurado anteriormente.

        ~~~(verse)

    # As ações a realizar quando o estado for válido
    ValidState(State : string) : void =
        # Reproduzir o som de validação
        Print("{State} válido")
        ValidAudioPlayer.Play()

~~~

1. Adicione um novo método `InvalidState()` à classe `switch_state_puzzle`. Esse método redefine todos os interruptores depois de reproduzir um som quando o jogador aciona um estado inválido.

        ~~~(verse)

    # As ações a realizar quando o estado for inválido
    InvalidState(InPlayer : agent) : void =
        # Reproduzir um som de campainha 
        # Limpar todos os interruptores
        Print("Inválido")
        
Copy full snippet

##Referenciamento de interruptores Agora você precisa de uma maneira de referenciar seus dispositivos Interruptor no quebra-cabeça. O referenciamento de dispositivos Interruptor proporciona um modo de executar um loop em todos os interruptores e adicionar manipuladores de evento a cada um deles durante a execução do jogo. 1. Em `OnBegin()`, na classe `switch_state_puzzle`, adicione uma expressão `for` para iterar em cada `Switch` da matriz `Switches`. Recupere o índice de cada `Switch` e armazene na variável `SwitchIndex`. 1. Adicione uma função `Print` abaixo da expressão `for` que identifica o interruptor da interação durante o tempo de execução ao digitar **`Switch {SwitchIndex} added`** no comando `Print`. 1. Já que a solução do quebra-cabeça se baseia em uma determinada ordem de estados do interruptor, será preciso verificar se o quebra-cabeça é solucionado a cada mudança de estado do interruptor. Para isso, você usará a classe `switch_event_handler` definida anteriormente para escutar dois eventos diferentes por interruptor. Para cada interruptor, crie duas inscrições: uma para os interruptores `TurnedOnEvent` e uma para os interruptores `TurnedOffEvent`. Registre ambos os eventos na função `OnSwitchPressed()` da classe `switch_event_handler`. Passe uma referência para `switch_state_puzzle` e para o `Switch` atual. ~~~(verse) ## É executado quando o dispositivo é iniciado em um jogo em execução OnBegin<override>()<suspends>:void= Print("Carregando quebra-cabeça de interruptor") # Execução de loop em cada interruptor e adição de manipuladores de evento para cada um deles for (SwitchIndex -> Switch : Switches): Print("Interruptor {SwitchIndex} adicionado") Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed) Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed) ~~~ 1. Salve o script no Visual Studio Code e, no UEFN, clique em **Verse -> Compilar código Verse**. Ao testar sua fase, toda vez que ligar ou desligar um interruptor, deverá ser impresso o índice do interruptor da interação e a palavra **Clicado**. ##Estados do quebra-cabeça Cada interruptor no quebra-cabeça pode ter dois estados: válido e inválido. Para solucionar o quebra-cabeça, o jogador precisa alternar os interruptores em uma determinada ordem. Para implementar essa ordem no código, basta definir uma sequência de estados válidos para cada interruptor e verificá-la sempre que o jogador atualizar o estado do interruptor. 1. Adicione um novo método `ValidState()` à classe `switch_state_puzzle`. Esse método obtém uma string e reproduz um clipe de áudio sempre que o jogador altera um interruptor para um estado válido, o que emite uma resposta de áudio para avisar que está no caminho certo. 1. Em `ValidState()`, imprima a string `State` que foi passada e chame `Play()` no `ValidAudioPlayer` configurado anteriormente. ~~~(verse) # As ações a realizar quando o estado for válido ValidState(State : string) : void = # Reproduzir o som de validação Print("{State} válido") ValidAudioPlayer.Play() ~~~ 1. Adicione um novo método `InvalidState()` à classe `switch_state_puzzle`. Esse método redefine todos os interruptores depois de reproduzir um som quando o jogador aciona um estado inválido. ~~~(verse) # As ações a realizar quando o estado for inválido InvalidState(InPlayer : agent) : void = # Reproduzir um som de campainha # Limpar todos os interruptores Print("Inválido")

1. Em InvalidState(), avise ao jogador quando ele ativar um estado inválido ao imprimir Inválido e reproduzir um clipe de áudio chamando Play() no InvalidAudioPlayer configurado anteriormente. Você também precisará chamar Trigger() no seu InvalidTrigger e Show() na sua InvalidHUDMessage.

   ~~~(verse)

   # As ações a realizar quando o estado for inválido InvalidState(InPlayer : agent) : void = # Reproduzir um som de campainha # Limpar todos os interruptores Print("Inválido") InvalidAudioPlayer.Play() InvalidTrigger.Trigger() InvalidHUDMessage.Show()

Crie um loop for que inscreva eventos nos dispositivos interruptores. A instrução print identifica quais interruptores um jogador aciona e a sequência em que esses interruptores são acionados.

~~~(verse)

        # Execução de loop em cada interruptor e adição de manipuladores de evento para cada um deles
        for (SwitchIndex -> Switch : Switches):
            Print("Interruptor {SwitchIndex} adicionado")
            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

Crie um loop for que inscreva eventos nos dispositivos interruptores. A instrução print identifica quais interruptores um jogador aciona e a sequência em que esses interruptores são acionados. ~~~(verse) # Execução de loop em cada interruptor e adição de manipuladores de evento para cada um deles for (SwitchIndex -> Switch : Switches): Print("Interruptor {SwitchIndex} adicionado") Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed) Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)

No loop de for, execute um loop em todos os interruptores e desligue cada um deles. Já que o método TurnOff() do interruptor requer um instigador de jogador, passe o jogador que acionou o estado inválido.

~~~(verse)

## Execução de loop nos interruptores e desligamento de cada um deles for (SwitchIndex -> Switch : Switches): Switch.TurnOff(InPlayer)

1. **Salve** seu código, volte para o UEFN e selecione **Verse** > **Compilar código Verse**.

Em seguida, você precisa criar a lógica na classe `item_switch_puzzle` que executará o loop em cada interruptor e validará seu estado em relação à matriz do quebra-cabeça, para determinar em que estado (válido ou inválido) a mudança do interruptor está. 

##Classificação de estados do interruptor

Para conferir a validade da alteração de um interruptor, crie um método **CheckSequence** que usa uma expressão `for` para verificar o estado atual do interruptor. Para definir se uma alteração de estado do interruptor é válida ou não, você pode usar uma instrução `if` para definir qual alteração de interruptor é válida na sequência e quais não são.

1. Adicione um novo método 'CheckSequence()'. Este método considera que o jogador está instigando as alterações de estado do interruptor e uma matriz de valores lógicos que correspondem aos estados do interruptor. Em `CheckSequence()`, crie um loop `for` para iterar através de cada interruptor na matriz `Switches`. Obtenha o índice de cada interruptor da matriz e salve na variável `SwitchIndex`. No loop de `for`, confira cada estado do interruptor chamando `GetCurrentState[]`. Em seguida, imprima o estado do interruptor no log.

~~~(verse)

    # Função para validar a sequência dos interruptores
    CheckSequence(InPlayer : agent) : void =
        for (SwitchIndex -> Switch : Switches):
            if(Switch.GetCurrentState[]) then Print("{SwitchIndex} Ligado") else Print("{SwitchIndex} Desligado")

Copy full snippet

1. **Salve** seu código, volte para o UEFN e selecione **Verse** > **Compilar código Verse**. Em seguida, você precisa criar a lógica na classe `item_switch_puzzle` que executará o loop em cada interruptor e validará seu estado em relação à matriz do quebra-cabeça, para determinar em que estado (válido ou inválido) a mudança do interruptor está. ##Classificação de estados do interruptor Para conferir a validade da alteração de um interruptor, crie um método **CheckSequence** que usa uma expressão `for` para verificar o estado atual do interruptor. Para definir se uma alteração de estado do interruptor é válida ou não, você pode usar uma instrução `if` para definir qual alteração de interruptor é válida na sequência e quais não são. 1. Adicione um novo método 'CheckSequence()'. Este método considera que o jogador está instigando as alterações de estado do interruptor e uma matriz de valores lógicos que correspondem aos estados do interruptor. Em `CheckSequence()`, crie um loop `for` para iterar através de cada interruptor na matriz `Switches`. Obtenha o índice de cada interruptor da matriz e salve na variável `SwitchIndex`. No loop de `for`, confira cada estado do interruptor chamando `GetCurrentState[]`. Em seguida, imprima o estado do interruptor no log. ~~~(verse) # Função para validar a sequência dos interruptores CheckSequence(InPlayer : agent) : void = for (SwitchIndex -> Switch : Switches): if(Switch.GetCurrentState[]) then Print("{SwitchIndex} Ligado") else Print("{SwitchIndex} Desligado")

Agora você precisa criar uma sequência de estados para comparar usando CheckSequence(). Para isso, você adicionará uma nova funcionalidade ao método OnSwitchPressed() do switch_event_handler.

Estados de sequências

Crie a sequência para os estados do interruptor usando matrizes. Cada matriz verifica a validade da sequência em que há mudança nos interruptores. Registre a sequência das ações do jogador nos interruptores usando o logger de impressão para registrar se houve Cliques nos interruptores e se a sequência é válida imprimindo o número da sequência no logger ("Um", "Dois", "Três" e "Quadro").

1. Em OnSwitchPressed(), dentro de uma instrução if, chame CheckSequence() passando o jogador e uma nova matriz de valores lógicos. Essa nova matriz deve corresponder à série de interruptores, com os valores false representando interruptores para desligar, e os valores true os interruptores para ligar. Defina o interruptor que você quer que os jogadores apertem primeiro como true, e todos os outros valores como false. Se a chamada de CheckSequence[] for bem-sucedida, chame ValidState() passando "Um" para representar o primeiro interruptor pressionado.

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

    ~~~

1. Codifique a chave de resposta para a inversão dos interruptores de cada um dos interruptores do quebra-cabeça, na ordem em que você deseja que eles sejam pressionados. 

~~~(verse)

    if:
            # verificar se há estados válidos e codifica a validação desses estados
            #[Desligado], [Desligado], [Ligado], [Desligado] Estado Um
            not Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Um")

        else if:
            # verifica estados válidos
            #[Ligado], [Desligado], [Ligado], [Desligado] Estado Dois
            Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Dois")

        else if:
            # verifica estados válidos
            #[Ligado], [Ligado], [Ligado], [Desligado] Estado Três
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Três")
            
        else if:
            # verifica estados válidos
            #[Ligado], [Ligado], [Ligado], [Ligado] Estado Quatro, quebra-cabeça concluído
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            Switches[3].GetCurrentState[]
        then:
            CompletedState()

Copy full snippet

OnSwitchPressed(InPlayer : agent) : void = Print("Clicado") PuzzleDevice.CheckSequence(InPlayer) ~~~ 1. Codifique a chave de resposta para a inversão dos interruptores de cada um dos interruptores do quebra-cabeça, na ordem em que você deseja que eles sejam pressionados. ~~~(verse) if: # verificar se há estados válidos e codifica a validação desses estados #[Desligado], [Desligado], [Ligado], [Desligado] Estado Um not Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Um") else if: # verifica estados válidos #[Ligado], [Desligado], [Ligado], [Desligado] Estado Dois Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Dois") else if: # verifica estados válidos #[Ligado], [Ligado], [Ligado], [Desligado] Estado Três Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Três") else if: # verifica estados válidos #[Ligado], [Ligado], [Ligado], [Ligado] Estado Quatro, quebra-cabeça concluído Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] Switches[3].GetCurrentState[] then: CompletedState()

1. Por fim, adicione no fim uma expressão else que chama InvalidState(). Isso ocorrerá se alguma chamada de CheckSequence[] falhar.

    
    else:
            # Não é um estado válido, então é inválido
            InvalidState(InPlayer)

Copy full snippet

else: # Não é um estado válido, então é inválido InvalidState(InPlayer)

1. Agora o código switch_event_handler deve se parecer com o exemplo abaixo.

    # Função para validar a sequência dos interruptores
    CheckSequence(InPlayer : agent) : void =
        for (SwitchIndex -> Switch : Switches):
            if(Switch.GetCurrentState[]) then Print("{SwitchIndex} Ligado") else Print("{SwitchIndex} Desligado")
        
        if:
            # verificar se há estados válidos e codifica a validação desses estados
            #[Desligado], [Desligado], [Ligado], [Desligado] Estado Um
            not Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Um")

        else if:
            # verifica estados válidos
            #[Ligado], [Desligado], [Ligado], [Desligado] Estado Dois
            Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Dois")

        else if:
            # verifica estados válidos
            #[Ligado], [Ligado], [Ligado], [Desligado] Estado Três
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Três")
            
        else if:
            # verifica estados válidos
            #[Ligado], [Ligado], [Ligado], [Ligado] Estado Quatro, quebra-cabeça concluído
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            Switches[3].GetCurrentState[]
        then:
            CompletedState()

        else:
            # Não é um estado válido, então é inválido
            InvalidState(InPlayer)

Copy full snippet

# Função para validar a sequência dos interruptores CheckSequence(InPlayer : agent) : void = for (SwitchIndex -> Switch : Switches): if(Switch.GetCurrentState[]) then Print("{SwitchIndex} Ligado") else Print("{SwitchIndex} Desligado") if: # verificar se há estados válidos e codifica a validação desses estados #[Desligado], [Desligado], [Ligado], [Desligado] Estado Um not Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Um") else if: # verifica estados válidos #[Ligado], [Desligado], [Ligado], [Desligado] Estado Dois Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Dois") else if: # verifica estados válidos #[Ligado], [Ligado], [Ligado], [Desligado] Estado Três Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Três") else if: # verifica estados válidos #[Ligado], [Ligado], [Ligado], [Ligado] Estado Quatro, quebra-cabeça concluído Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] Switches[3].GetCurrentState[] then: CompletedState() else: # Não é um estado válido, então é inválido InvalidState(InPlayer)

1. Salve seu código, volte para o UEFN e selecione Verse > Compilar código Verse.

À medida que você liga os interruptores no jogo, o log será impresso:

• Carregando quebra-cabeça de interruptor: quando o jogo começa

• Interruptor {SwitchIndex} adicionado: quando um interruptor for adicionado ao loop

• Clicado: quando um jogador ligar um interruptor

• {State} válido: se o jogador ligar o interruptor correto na ordem da sequência

• Inválido: se o jogador ligar o interruptor errado

Se o log corresponder corretamente às mudanças do interruptor, você poderá adicionar mais dispositivos editáveis à classe "item_switch_puzzle" e fazer com que cada um desses estados faça alguma coisa.

Como adicionar dispositivos

Quando o quebra-cabeça for concluído com sucesso pelo jogador e tiver sido executado em loop em ValidStates dos interruptores até terminar em CompletedState, o resultado de sucesso deverá fazer algo, como conceder itens.

Isso também se aplica a InvalidStates. Se o jogador errar a solução do quebra-cabeça, o script deverá considerar isso e avisar os jogadores de que precisam tentar novamente. Para isso, você precisa adicionar dispositivos extras à classe "item_switch_puzzle".

Adicionando dispositivos editáveis ao seu script, eles aparecerão nas opções do usuário do dispositivo Verse. Nelas, é possível conectar os dispositivos com o dispositivo Verse para que funcionem no jogo conforme escrito no script Verse.

1. Adicione os seguintes dispositivos @editable em 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{} #Obtém todos os geradores de itens associados a este quebra-cabeça
    
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{} #Obtém todos os geradores de itens associados a este quebra-cabeça

1. Adicione um novo método CompletedState() à classe item_switch_puzzle. Este método manipula as ações realizadas quando o quebra-cabeça for concluído.

    ## As ações a realizar quando o quebra-cabeça for concluído
    CompletedState() : void =
        # Reproduzir som de sucesso
        # Definir todos os interruptores para desabilitado
        # Gerar itens nos geradores de itens anexados
        Print("Concluído")

    ~~~

    1. Adicione uma expressão `for` ao método `CompletedState()` a ser iterado em cada gerador de itens de `ItemSpawners`. Habilite cada gerador de itens com `Enable()`, depois chame `SpawnItem()` para conceder ao jogador a recompensa por solucionar o quebra-cabeça.

~~~(verse)

    ## Execução de loop nos geradores de itens de modo que cada gerador de itens possa ser chamado para habilitar e gerar seu item
        for (ItemSpawnerIndex -> ItemSpawner : ItemSpawners):
            ItemSpawner.Enable()
            ItemSpawner.SpawnItem()

Copy full snippet

## As ações a realizar quando o quebra-cabeça for concluído CompletedState() : void = # Reproduzir som de sucesso # Definir todos os interruptores para desabilitado # Gerar itens nos geradores de itens anexados Print("Concluído") ~~~ 1. Adicione uma expressão `for` ao método `CompletedState()` a ser iterado em cada gerador de itens de `ItemSpawners`. Habilite cada gerador de itens com `Enable()`, depois chame `SpawnItem()` para conceder ao jogador a recompensa por solucionar o quebra-cabeça. ~~~(verse) ## Execução de loop nos geradores de itens de modo que cada gerador de itens possa ser chamado para habilitar e gerar seu item for (ItemSpawnerIndex -> ItemSpawner : ItemSpawners): ItemSpawner.Enable() ItemSpawner.SpawnItem()

1. Assim que o quebra-cabeça for concluído com sucesso, você precisa chamar Play() no CompletedAudioPlayer que configurou antes, gerar as peças de metal nos Geradores de Itens usando ItemSpawnerIndex e a chamada Enable1 e SpawnItem. Comunique ao jogador que ele precisa procurar os novos itens gerados, chamando Show() em FindItemsHUDMessage. Além disso, você não quer que o jogador continue interagindo com seus interruptores. Adicione outra expressão for para executar loop em cada interruptor de Switches e desligá-los chamando Disable().

~~~(verse)

# As ações a realizar quando o quebra-cabeça for concluído CompletedState() : void = # Reproduzir som de sucesso # Definir todos os interruptores para desabilitado # Gerar itens nos geradores de itens anexados Print("Concluído")

# Execução de loop nos geradores de itens de modo que cada gerador de itens possa ser chamado para habilitar e gerar seu item for (ItemSpawnerIndex -> ItemSpawner : ItemSpawners): ItemSpawner.Enable() ItemSpawner.SpawnItem()

# Reproduz uma indicação sonora especial por concluir a sequencia do quebra-cabeça CompletedAudioPlayer.Play()

# Reproduz uma nova mensagem do HUD para dizer aos jogadores que procurem os itens gerados recentemente FindItemsHUDMessage.Show()

# Desabilitar todos os interruptores ao concluir o quebra-cabeça com sucesso for (SwitchIndex -> Switch : Switches): Switch.Disable()

~~~

1. Salve seu código, volte para o UEFN e selecione Verse > Compilar código Verse.

Agora esses dispositivos foram adicionados ao dispositivo Quebra-cabeça de Interruptor com Itens no UEFN.

Selecionar dispositivos

Todos os dispositivos @editable são adicionados ao dispositivo Verse. Agora você precisa anexar os dispositivos extraídos para criar o quebra-cabeça para o dispositivo Verse. Para isso, selecione "item_switch_puzzle" no Organizador e todos os espaços de dispositivos ficarão visíveis no painel Detalhes. Você só precisa combinar o dispositivo com o espaço.

1. Adicione os dispositivos Interruptor do quebra-cabeça aos quatro elementos da matriz Switches no "Quebra-cabeça de Interruptor com Itens".

   

2. Adicione o Gatilho inválido ao espaço InvalidTrigger

3. Adicione a Mensagem do HUD - Inválido ao espaço InvalidHUDMessage.

4. Adicione Reprodutor de áudio - Inválido ao espaço InvalidAudioPlayer.

   

5. Adicione o Reprodutor de áudio - Válido ao espaço ValidAudioPlayer.

6. Adicione o dispositivo Mensagem do HUD - Encontrar ao espaço FindHUDMessage.

7. Adicione o Reprodutor de áudio - Concluído ao espaço CompletedAudioPlayer.

   

8. Adicione os Geradores de itens aos quatro elementos da matriz ItemSpawners.

   

9. Desmarque a opção Visível no jogo para ocultar o dispositivo Verse durante o jogo.

   

Você já pode fazer o teste de jogo do seu nível e ver como os quebra-cabeças contribuem para sua experiência de "escape room".

Próxima seção

Com o quebra-cabeça de estado do interruptor funcionando, você já pode criar o script de teletransporte automático de Verse. Ele leva os jogadores do início da cena de abertura até a sala de espera, no subsolo do chalé, quando a cena terminar.

%escape-room-11-teleporting-players-in-unreal-editor-for-fortnite:topic%