Abrir portas com chaves

Agora que o jogador pode pegar chaves no jogo, você adicionará a funcionalidade para destravar e abrir portas quando o jogador pegar a chave necessária. Nesta parte do tutorial, vamos modificar o blueprint BP_DoorFrame e explorar Funções nos Blueprints.

As portas destrancáveis oferecem uma maneira de controlar o fluxo do jogo e proporcionam uma sensação de progressão ao jogador. O projeto em que estamos trabalhando atualmente é dividido em salas. Portanto, pegar as chaves para destrancar portas oferece um caminho de progressão lógica para o jogador.

Antes de começar

Certifique-se de entender os tópicos abordados nas seções anteriores da série de tutoriais Como projetar uma aventura de quebra-cabeça:

• Noções básicas sobre Blueprints, incluindo Interfaces de Blueprint.

• Como criar variantes de um objeto usando uma variável de Mapa.

Você precisará dos seguintes ativos criados no tutorial anterior, Criar uma chave:

• BP_Key

• Biblioteca de funções do Blueprint BPL_FPGame

• Interface de Blueprint BPI_PlayerKeys

• Três instâncias de BP_DoorFrame colocadas em seu nível entre salas ou corredores.

Adicionar opções de cores à porta

Como o modelo em primeira pessoa já tem um blueprint de porta, você pode modificar o blueprint existente para adicionar a funcionalidade de destrancar portas com uma chave. 

Sua porta precisa de algumas coisas para funcionar com o sistema de chaves que você definiu na parte anterior deste tutorial. Assim como a chave, sua porta precisa saber que o ator que está interagindo com ela implementa a interface BPI_PlayerKeys. 

A porta deve mudar de cor para corresponder à chave que ela aceita, o que significa que ela precisa saber qual tipo de chave pode destrancá-la. Por último, ela precisa da mesma variável KeyMap com combinações das cores vermelho, amarelo e azul.

Como criar variáveis para interagir com o público jogador e com as chaves

Para adicionar novas variáveis ao blueprint BP_DoorFrame, siga estas etapas:

1. Vá para o Navegador de Conteúdo, navegue até a pasta LevelPrototyping > Interactable > Door e abra o blueprint BP_DoorFrame.

2. No painel My Blueprint, na seção Variables, adicione uma nova variável chamada UseKey, com o tipo Boolean. Isso determina se a porta precisa de uma chave para ser aberta.

3. Crie outra variável chamada RequiredKey do tipo Enum Key Type. Isso determina a chave necessária para abrir a porta. 

   

4. Clique no ícone de olho ao lado de ambas as variáveis para que o olho fique aberto, tornando-as editáveis.

5. Selecione a variável UseKey. No painel Detalhes, insira Setup (Configuração) como sua Category (Categoria).

6. Selecione RequiredKey e altere sua categoria para Configurações.

7. Crie uma nova variável chamada OtherActor do tipo Actor > Referência de objeto. Assim, armazenamos o ator que está interagindo com a porta e usaremos essa função para verificar se o público jogador se sobrepôs ao volume da porta.

   

Como construir a variável do mapa de chaves

Assim como fez em BP_Key, você adicionará a variável mapa que mapeia os tipos de chave para as cores do material. Entretanto, com a porta, você não quer que as malhas da porta mudem de forma, portanto, não adicionará novas formas de malha ao mapa.

Para criar a variável KeyMap da porta, siga estas etapas:

1. Crie uma variável chamada KeyMap, do tipo Enum Key Type. 

2. Clique nessa variável e, no painel Detalhes, clique no menu suspenso Contêiner e selecione Mapa. 

3. Altere o tipo de valor do mapa para Struct Key Data.

   

4. Compile o blueprint para adicionar valores de KeyMap.

5. Na seção Valor padrão do mapa, adicione (+) 3 novos elementos ao Key Map. 

   Ao adicionar a primeira entrada, altere o tipo para outra cor para que você possa continuar adicionando novas entradas; não é possível adicionar a mesma entrada mais de uma vez.

   

6. Para cada elemento do mapa, adicione o Key Material correspondente:

   1. M_BasicColor_Yellow

   2. M_BasicColor_Red

   3. M_BasicColor_Blue

   

7. Para cada elemento, certifique-se de que a Key Mesh (malha de chave) indique None (Nenhum). Para remover uma malha, clique no menu suspenso e selecione Limpar na parte superior da lista. 

8. Salve e compile o blueprint da porta.

Como adicionar lógica de Blueprint de mudança de cor

Com suas variáveis configuradas, você pode adicionar a funcionalidade de mudança de cor alterando o gráfico do Blueprint.

Primeiro, você precisa alterar a porta para ter opções de cores vermelha, azul e amarela, que são controladas pela nova variável RequiredKey adicionada. A porta deve mudar de cor conforme você a configura no nível, não quando o jogo começa. Portanto, você usará a guia Construction Script para criar essa funcionalidade. 

Para adicionar as opções de cores da porta, siga estas etapas:

1. Navegue até a guia Construction Script da porta, onde você pode criar funcionalidades para quando a porta for criada. No gráfico, localize o nó roxo Construction Script que inicia a lógica nessa função.

2. No nó Sequence que está conectado ao Construction Script, use Adicionar pin (+) para criar mais um pin, chamado Then 2, que você pode usar para desenvolver a cadeia.

   

   O nó Sequence é usado para criar uma sequência de ações, em que Then 0 é executado primeiro, Then 1 depois e assim por diante, dependendo de quantos pins você escolher adicionar. Isso ajuda a organizar seu gráfico e evita que uma cadeia de lógica fique muito longa.

3. Arraste o pin Then 2 até uma parte vazia do gráfico e crie um nó Branch. 

4. Arraste o pin Condition do nó Branch e crie um nó Get Use Key. Agora, o nó Branch testa se a porta deve usar chaves ou não. 

   

5. Arraste o pin True do nó Branch e crie um nó Fn BPLSet Key. Essa é a função da biblioteca que aplica uma nova cor de material (e malha, se fornecida) a uma matriz de malhas estáticas.

6. Arraste o pin Static Mesh Array do nó Fn BPLSet Key e crie um nó Make Array. 

7. Clique no botão Adicionar pin (+) no nó Make Array.

8. No nó Make Array, arraste o primeiro pin, [0], e crie um nó Get Door. 

   Se você observar a lista Variáveis > Componentes no painel Meu Blueprint, verá que a porta tem os componentes de malha estática (static mesh components) Door e Door2. São estes que você quer que mudem de cor.

9. Arraste o segundo pin, [1], e crie um nó Get Door 2. Isso cria uma matriz com base nos dois componentes de malha estática, Door e Door 2. 

10. No nó Fn BPLSet Key, arraste o pin Key Map e crie um nó Get Key Map. Essa é uma referência à variável KeyMap da porta.

11. Em seguida, arraste o pin Key e crie um nó Get Required Key, que é uma referência à variável RequiredKey adicionada anteriormente.

12. Compile e salve o blueprint.

O Construction Script da porta agora deve se parecer assim após o pin Then 3 do nó Sequence:

Esta é uma versão copiável dessa lógica:

Testar as cores das portas

Depois de codificar por cores o objeto de jogo porta, você pode configurar as portas para não abrirem a menos que o jogador tenha a chave correta.

Em seu nível, selecione uma das suas instâncias BP_DoorFrame.

No painel Detalhes, digite "Key" no campo de pesquisa na parte superior. Isso revela duas opções: Use Key e Required Key. Altere a Required Key para um tipo de chave diferente. A cor da porta deve mudar para corresponder ao tipo de chave.

Lembre-se de que esse é o benefício de usar a guia gráfica Construction Script no Editor de Blueprint. Você pode ver as alterações no editor de níveis em vez de ter que esperar para entrar no modo de jogo.

Criar uma lógica de porta baseada em chave

O próximo passo é criar a funcionalidade para verificar quais chaves o jogador possui. Para isso, você definirá uma função personalizada chamada fnHasKey no Blueprint BP_DoorFrame que verifica se que está jogando possui a chave necessária.   

Criar uma função para verificar as chaves

Essa função comparará a chave necessária da porta com o conjunto de chaves do personagem jogável e retornará um valor (booleano) verdadeiro ou falso. Use uma variável local para o valor de retorno booleano.

Para criar uma função com uma variável local, siga estas etapas:

1. No Blueprint BP_DoorFrame, no painel My Blueprint, use Adicionar (+) ao lado da seção Functions. Isso é semelhante a adicionar uma variável, mas, em vez disso, você está adicionando uma função. 

2. Chame a nova função de fnHasKey. 

   

3. Como uma função pode ter seu próprio conjunto de nós, ela é aberta em sua própria guia fnHasKey com um gráfico de nós separado. Se você fechar essa guia e precisar reabri-la, clique duas vezes na função na lista Funções.

4. No painel Meu Blueprint, você verá uma nova seção na parte inferior chamada Variáveis locais (FnHasKey). Crie uma nova Variável local usando Adicionar (+) ao lado dessa seção. 

5. Chame a variável de HasRequiredKey e defina seu tipo como Booleano.

   

   Variáveis locais são semelhantes às variáveis regulares, mas são locais para uma função específica. Elas são úteis para armazenar valores temporários enquanto uma função é executada. Em seguida, você pode passar esse valor de volta para o restante do blueprint usando um Nó Return.

Com a função configurada, você pode adicionar a lógica que verifica se o jogador tem a chave correta.

Para verificar se o ator no volume da porta tem a chave necessária, siga estas etapas:

1. Arraste o pin do nó de entrada da função fnHasKey e crie um nó Sequence. Isso organiza a lógica da função em uma sequência de ações que são executadas em ordem.

2. Arraste o pin Then 0 do nó Sequence e crie um nó Fn BPIGet Keys (Message). Essa é a função de interface que retorna uma matriz com as chaves que o jogador já encontrou.

3. Arraste o pin Target do nó Fn BPIGet Keys e crie um nó Get Other Actor. Depois que você configurar o gráfico de eventos da porta, essa variável armazenará o ator que se sobrepõe ao volume da porta.

   

4. Arraste a variável local HasRequiredKey para perto do nó Fn BPIGet Keys e selecione Definir.

5. Arraste o pin de execução do nó FN BPIGet Keys e conecte-o ao nó Definir HasRequiredKey.

6. No nó Definir HasRequiredKey, arraste o pin HasRequiredKey e crie um nó Contains Item, listado na seção Matriz da pesquisa. Esse nó verifica se um item específico está em uma matriz e retorna verdadeiro (true) ou false (falso).

   Você também pode pesquisar por Matriz Contains Item para restringir a pesquisa a essa opção específica.

7. No nó Contains Item, arraste o pin Target Array (o pin quadrado) e conecte-o ao pin Held Keys do nó Fn BPIGet Keys. 

8. Arraste o pin Item to Find (que se parece com um círculo) do nó Contains Item e crie um nó Get Required Key.

  É assim que o gráfico de sua função deve se parecer até o momento:

Essa sequência de ações verifica se as chaves mantidas pela variável OtherActor contêm a variável RequiredKey. Em caso afirmativo, definirá HasRequiredKey como true. 

Agora, passe o resultado de HasRequiredKey para o restante do blueprint. Para fazer isso, use um nó Return, que interrompe a execução de uma função e retorna um valor para o blueprint que chamou a função. 

Para terminar a função com um nó Return, siga estas etapas:

1. No nó Sequence, arraste o pin Then 1, procure por Return na lista de ações do nó e selecione Add Return Node.

2. Para que a função retorne um valor, ela precisa de uma saída. Clique em Return Node para destacá-lo.

3. No painel Detalhes, use Adicionar (+) ao lado da seção Saídas na parte inferior. Isso adiciona uma nova saída, que é o valor que será passado para fora dessa função.

4. Nomeie essa saída como KeyFound e altere seu tipo para Booleano.

5. De volta ao gráfico, arraste o pin Key Found do nó Return e crie um nó Get HasRequiredKey.

O gráfico completo da função FnHasKey agora deve se parecer com o seguinte:

Trancar e destrancar portas com chaves

Agora, você pode modificar a porta para que ela se abra se todas as condições necessárias forem verdadeiras. 

Assim como no caso da chave, você precisará verificar se o personagem implementa a interface BPI_PlayerKeys (a "permissão" do jogador) antes que ele possa tentar abrir uma porta que usa chaves.

Portanto, antes de abrir, a porta deve verificar as seguintes condições:

• A porta está configurada para usar chaves (UseKey = True).

• O ator sobreposto é o jogador (ele implementa BPI_PlayerKeys).

• O jogador tem o tipo de chave necessário.

Para testar se o ator que está interagindo com a porta é o jogador, siga estas etapas:

1. No Event Graph do BP_DoorFrame, localize o nó Event ActorBeginOverlap. Essa coleção de nós controla o que acontece quando um personagem entra no volume de colisão da porta. Você adicionará uma interface blueprint e um requisito de chave a essa lógica para que a porta não se abra a menos que o ator seja o jogador e tenha a chave certa. 

   Você pode usar Ctrl + F para pesquisar o nome de um nó. Clique no resultado da pesquisa para ir diretamente a ele.

2. Desconecte o nó Event ActorBeginOverlap do nó Door Control mantendo pressionada a tecla Alt e clicando no fio entre os dois nós. Mova o nó Event para trás para que haja espaço para mais ações de nós antes do Door Control.

   Desconectar nós do blueprint

3. No nó Event ActorBeginOverlap, arraste seu pin e adicione um nó Set Other Actor. Conecte o pin Other Actor do nó Event ao pin Other Actor do nó Definir.

   

   Isso armazena o ator que se sobrepôs à área da porta.

4. No nó Definir Other Actor, arraste o pin azul value e crie um nó Does Object Implement Interface. Defina o valor de interface como BPI_PlayerKeys.

   

5. No nó Definir Other Actor, arraste o pin de execução e crie um novo nó Branch. 

Para verificar se a porta usa chaves, siga estas etapas:

1. Arraste o pin True do nó Branch e crie um nó Fn Has Key, que é a função que você criou anteriormente neste tutorial. Ela usa o tipo de chave necessário para abrir a porta e verifica a matriz Held Keys do jogador para esse tipo de chave. Ao chamar essa função, os nós contidos nela serão executados. 

2. No nó Fn Has Key, arraste o pin de execução e crie um novo nó Branch. 

3. Conecte o pin Key Found do nó Fn Has Key ao pin Condition do nó Branch.

4. Conecte o pin True do novo nó Branch ao pin Play do nó Door Control.

   

Até o momento, essa lógica só permite que a porta se abra quando o jogador tem a chave certa. A porta também deve se abrir quando:

• A porta não precisa de chaves;

• Um personagem não jogador tenta passar pela porta.

O primeiro nó Branch e o primeiro nó And testam essas duas condições. Se um deles estiver definido como false, o Branch também será falso. 

Para garantir que a porta se abra para os PNJs e quando as chaves não forem necessárias, siga estas etapas:

1. Conecte o pin False do primeiro nó Branch diretamente ao pin Play do nó Door Control. Você pode usar conectores clicando duas vezes em um fio entre dois nós para organizar seu blueprint.

   

2. Compile e salve o blueprint.

Agora, quando o ator não implementa a interface de chave ou a porta não requer chaves (UseKeys = False), a porta ainda se abre.

A nova lógica do Event Graph de BP_DoorFrame deve ser parecida com a seguinte:

Adicionar comentários a um blueprint

Você pode adicionar blocos de comentários em seus blueprints para criar notas visuais que agrupam nós e explicam o que cada parte do blueprint faz. Os comentários ajudam você e os membros da sua equipe a saber rapidamente qual funcionalidade os nós estão executando e a manter seus blueprints organizados.

Ao criar a lógica do blueprint, concentre-se primeiro na criação da funcionalidade e, em seguida, destaque os nós que você adicionou e adicione um comentário para descrevê-los.

Para adicionar um comentário em um blueprint, siga estas etapas:

1. Clique no gráfico para garantir que ele seja o painel ativo.

2. Pressione C no teclado. Isso adiciona uma caixa de comentários.

3. Clique duas vezes no campo de texto na parte superior da caixa para inserir um comentário.

4. Para redimensionar o comentário, certifique-se de que o comentário esteja selecionado (destacado em amarelo) e arraste uma borda ou um canto.

5. Para agrupar nós em um comentário, arraste esses nós para dentro dos limites do comentário.

Você também pode selecionar um ou vários nós e pressionar C para adicionar um comentário que contenha os nós selecionados. 

Testar suas portas

Volte ao seu nível no Editor de níveis. Use a propriedade Required Key de suas portas para configurá-las com cores diferentes e adicione uma BP_Key para cada cor.

Agora, jogue o jogo. Se você se aproximar da porta sem pegar uma chave, a porta não abrirá.

Mas, se você pegar a chave, a porta se abrirá quando você se aproximar dela. Quando você se afastar o suficiente, ela se fechará automaticamente. 

Depois de pegar uma cor de chave, tente abrir uma porta de cor diferente. A porta deve permanecer fechada.

Se estiver trabalhando com o nível de amostra deste tutorial, selecione a porta que leva ao Hallway 2 e altere a chave necessária para a chave azul. Em seguida, selecione a porta que leva ao Hallway 3 e mude a chave necessária para a chave vermelha. Deixe a porta do Hallway 1 amarela.

Adicionar feedback com mensagens de depuração

Se quiser verificar o que está acontecendo em um blueprint durante o jogo, use nós Print String para exibir mensagens na tela. A Unreal Engine não exibe essas mensagens em um jogo final.

Tente adicionar um nó Print String para confirmar o tipo de chave que o jogador pegou.

Para exibir uma mensagem de depuração com nós Print String, siga estas etapas:

1. No Event Graph do BP_AdventureCharacter, vá até o conjunto de nós que começa com Event fnBPIAddKey e adicione chaves à matriz HeldKeys.

2. Arraste o pin execução do nó ADD e adicione um nó Print String.

3. In String é o texto que aparece na tela. Insira texto personalizado ou conecte o pin Key Type do nó de evento à In String. Isso exibe a chave que o jogador está pegando.

   

4. Compile o Blueprint.

5. Jogue o jogo novamente e pegue as chaves. Você verá um texto de depuração confirmando cada cor de chave à medida que as pegar. 

6. Quando terminar, volte ao gráfico de nós e exclua os nós Print String e Enum to String. Compile e salve o blueprint.

Se algo não está funcionando como esperado em um blueprint, você pode adicionar nós Print String após cálculos, chamadas de eventos ou chamadas de funções para ajudar a rastrear o que está acontecendo com os valores e o fluxo.

Colocar itens de coleta

Até agora, você estava colocando as chaves no chão. Para tornar as coisas mais interessantes e envolventes para o jogador, tente introduzir um elemento de plataforma. 

No nível de exemplo deste tutorial, adicionamos um pouco de verticalidade, colocando a chave em um local alto para que o jogador tenha que pular até ela. Aqui, há um pequeno risco de cair e ter que começar de novo.

O jogador pratica saltos na primeira e na segunda plataformas antes de ser testado com o salto final mais difícil para o pilar.

Experimentar o nível de amostra

Se quiser adicionar as novas partes da sala projetadas nesta parte da série de tutoriais em vez de criar as suas próprias, copie os trechos abaixo.

Rascunho da sala inicial

Esse trecho de texto contém a rampa, o andar rebaixado, a coluna e as duas malhas de plataforma adicionadas para criar o caminho até a chave amarela.

Begin Map
   Begin Level
      Begin Actor Class=/Script/Engine.StaticMeshActor Name=Floor_168 Archetype="/Script/Engine.StaticMeshActor'/Script/Engine.Default__StaticMeshActor'" ExportPath="/Script/Engine.StaticMeshActor'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.Floor_168'"
         Begin Object Class=/Script/Engine.StaticMeshComponent Name="StaticMeshComponent0" Archetype="/Script/Engine.StaticMeshComponent'/Script/Engine.Default__StaticMeshActor:StaticMeshComponent0'" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.Floor_168.StaticMeshComponent0'"
         End Object
         Begin Object Name="StaticMeshComponent0" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.Floor_168.StaticMeshComponent0'"
            StaticMesh="/Script/Engine.StaticMesh'/Engine/MapTemplates/SM_Template_Map_Floor.SM_Template_Map_Floor'"
            bUseDefaultCollision=False
            StaticMeshDerivedDataKey="STATICMESH_34081786561B425A9523C94540EA599D_359a029847e84730ba516769d0f19427Simplygon_5_5_2156_18f808c3cf724e5a994f57de5c83cc4b_680318F3495BDBDEBE4C11B39CD497CE000000000100000001000000000000000000803F0000803F00000000000000000000344203030300000000"
            MaterialStreamingRelativeBoxes(0)=4294901760

Para as novas formas de rascunho da sala inicial (Start Room), siga estas etapas:

• No Unreal Editor, remova todas as chaves da sala inicial, para que elas não se percam na nova geometria.

• Clique em Copiar snippet inteiro.

• No Unreal Editor, certifique-se de que a janela de visualização seja o painel ativo (clique em qualquer lugar da janela de visualização ou do Organizador e pressione Esc) e, em seguida, pressione Ctrl + V.

  Se você moveu alguma das salas de rascunho na parte anterior deste tutorial, as novas malhas talvez não apareçam no lugar certo. Mova-as conforme necessário.

• Três peças de piso estão cobrindo o novo piso rebaixado. Na janela de visualização, clique em cada uma delas e pressione Excluir.

  

A seguir

O personagem jogável pode pegar chaves, mas não há feedback para informar o que ele pegou até o momento. Na próxima seção, você criará um HUD (heads-up display) para o jogador. Esse HUD mostra as chaves que estão no seu inventário.

• 

  HUD do jogador

  Crie um "heads-up display" (HUD) simples que seja atualizado quando o jogador pega um item.