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:
-
1 Gatilho
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
| Opção | Valor | Explicação |
|---|---|---|
| Modelo do dispositivo | Disjuntor | Neste quebra-cabeça, queremos que os jogadores liguem o disjuntor. |
| Som | False | Os dispositivos de áudio tocarão indicações sonoras distintas para os estados válido, inválido e sucesso do quebra-cabeça. |
| Tempo de interação | 0.1 | O tempo de interação deverá ser imediato. |
| Raio de interação | 1.0 | O jogador deverá ficar dentro do espaço de um ladrilho na frente do interruptor para interagir com ele. |
| Conferir estado no início do jogo | False | O dispositivo Verse realizará esta verificação. |
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.
| Opção | Valor | Explicação |
|---|---|---|
| Reiniciar áudio ao ativar | True | O áudio deve poder ser reproduzido mais de uma vez, começando do início em cada uma delas. |
| Reproduzir com acerto | False | O dispositivo Verse acionará o dispositivo de áudio. |
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.
| Opção | Valor | Explicação |
|---|---|---|
| Visível no jogo | False | Este dispositivo não precisa estar visível no jogo. |
| Habilitado ao Iniciar | False | O dispositivo Verse controlará o dispositivo Gatilho. |
| Acionado por jogador | False | O dispositivo Verse controlará o dispositivo Gatilho. |
| Acionado por veículos | False | O dispositivo Verse controlará o dispositivo Gatilho. |
| Acionado por sequenciadores | False | O dispositivo Verse controlará o dispositivo Gatilho. |
| Acionado por água | False | O dispositivo Verse controlará o dispositivo Gatilho. |
| Vezes que pode ser acionado | True, 10 | O gatilho deve poder ser usado mais de uma vez no quebra-cabeça |
| Efeitos visuais de acionamento | False | Não há necessidade de efeitos visuais. |
| Acionar efeitos sonoros | False | Os dispositivos Áudio controlarão o som. |
Renomeie o dispositivo Gatilho Inválido.
Dispositivo - Mensagem do HUD
Configure o primeiro dispositivo Mensagem do HUD usando as opções a seguir.
| Opção | Valor | Explicação |
|---|---|---|
| Mensagem | Mensagem do HUD - Inválido:
Mensagem do HUD - Encontrar itens:
|
As mensagens para o quebra-cabeça que abrangem os estados de falha e sucesso. |
| Tempo de exibição | Mensagem do HUD - Inválido, 3.0 Mensagem do HUD - Concluído, 5.0 |
A quantidade de tempo pela qual mostrar as mensagens. |
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.
| Matriz de soluções do quebra-cabeça | ||||
|---|---|---|---|---|
| Interruptores | 2 | 3 | 1 | 4 |
| 1 | X | |||
| 2 | X | X | ||
| 3 | X | X | X | |
| 4 | X | X | X | X |
Funcionalidades da linguagem Verse usadas
-
if,then,else: com as expressõesif,theneelse, 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ãoforé 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
InteractedWithEventdos 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.
-
Abaixo da definição da classe "switch_state_puzzle", adicione os seguintes campos editáveis.
-
Uma matriz editável do tipo
switch_devicechamadaSwitches. Refere-se a todos os seus interruptores no quebra-cabeça. -
Uma matriz de variáveis do tipo
cancelable(cancelável) chamadaSwitchSubscriptions. 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)
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
##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")
-
Em
InvalidState(), avise ao jogador quando ele ativar um estado inválido ao imprimir Inválido e reproduzir um clipe de áudio chamandoPlay()noInvalidAudioPlayerconfigurado anteriormente. Você também precisará chamarTrigger()no seuInvalidTriggereShow()na suaInvalidHUDMessage.~~~(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)
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")
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").
- Em
OnSwitchPressed(), dentro de uma instruçãoif, chameCheckSequence()passando o jogador e uma nova matriz de valores lógicos. Essa nova matriz deve corresponder à série de interruptores, com os valoresfalserepresentando interruptores para desligar, e os valorestrueos interruptores para ligar. Defina o interruptor que você quer que os jogadores apertem primeiro comotrue, e todos os outros valores comofalse. Se a chamada deCheckSequence[]for bem-sucedida, chameValidState()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()
- Por fim, adicione no fim uma expressão
elseque chamaInvalidState(). Isso ocorrerá se alguma chamada deCheckSequence[]falhar.
else:
# Não é um estado válido, então é inválido
InvalidState(InPlayer)
- Agora o código
switch_event_handlerdeve 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)
- 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.
- 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
- Adicione um novo método
CompletedState()à classeitem_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()
- Assim que o quebra-cabeça for concluído com sucesso, você precisa chamar
Play()noCompletedAudioPlayerque configurou antes, gerar as peças de metal nos Geradores de Itens usandoItemSpawnerIndexe a chamadaEnable1eSpawnItem. Comunique ao jogador que ele precisa procurar os novos itens gerados, chamandoShow()emFindItemsHUDMessage. Além disso, você não quer que o jogador continue interagindo com seus interruptores. Adicione outra expressãoforpara executar loop em cada interruptor deSwitchese desligá-los chamandoDisable().
~~~(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()
~~~
- 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.
-
Adicione os dispositivos Interruptor do quebra-cabeça aos quatro elementos da matriz Switches no "Quebra-cabeça de Interruptor com Itens".
-
Adicione o Gatilho inválido ao espaço InvalidTrigger
-
Adicione a Mensagem do HUD - Inválido ao espaço InvalidHUDMessage.
-
Adicione Reprodutor de áudio - Inválido ao espaço InvalidAudioPlayer.
-
Adicione o Reprodutor de áudio - Válido ao espaço ValidAudioPlayer.
-
Adicione o dispositivo Mensagem do HUD - Encontrar ao espaço FindHUDMessage.
-
Adicione o Reprodutor de áudio - Concluído ao espaço CompletedAudioPlayer.
-
Adicione os Geradores de itens aos quatro elementos da matriz ItemSpawners.
-
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%