Criar uma chave

Nesta seção, você criará seu primeiro objeto de jogo: um Blueprint de chave.

Para criar a funcionalidade dos objetos de jogabilidade no seu nível, você usará o Script visual de Blueprint. Os blueprints na Unreal Engine são ativos com uma representação física e uma funcionalidade especial, como a possibilidade de o jogador pegá-los.

O sistema Script visual de Blueprint pode ser usado para criar funcionalidades sem escrever código, pois você está usando uma interface baseada em nós para criar o comportamento de um objeto de jogo.

Primeiro, você definirá o ator da chave no jogo, adicionando componentes que permitem configurar as chaves para que apareçam em três variações diferentes: um oval amarelo, um retângulo azul ou um cone vermelho. Em vez de criar ativos separados para cada variação, os Blueprints permitem criar todas essas opções num único ativo.

Em seguida, você adicionará o comportamento da chave, ou seja, a capacidade do personagem jogável de pegá-la. Pegar objetos é uma das mecânicas de jogo mais comuns.

Esta é uma visão geral de todos os ativos que você serão criados para criar uma chave com três opções de aparência diferentes e permitir que um personagem jogável pegue a chave:

Antes de começar

Certifique-se de entender os tópicos a seguir, abordados nas seções anteriores de Como projetar uma aventura de quebra-cabeça:

• Interface de usuário do Unreal Editor, como o Navegador de Conteúdo e a Janela de visualização.

• Sobre Blueprints. Consulte a documentação Fundamentos de Blueprints para obter mais informações.

Você precisará dos seguintes ativos de Configuração do projeto e rascunho de nível:

• Um nível com salas bloqueadas.

Definir tipos e atributos de chaves

Antes de criar o blueprint de chaves, você definirá alguns dados de chaves que o blueprint usará para criar as variações de vermelho, amarelo e azul.

Para representar os diferentes tipos de chaves usadas no seu jogo, você usará uma Enumeração e uma Estrutura.

Cada enumerador funciona como um rótulo em um contêiner, e a struct é como o conteúdo de cada contêiner.

Definir tipos de chave em uma enumeração

Primeiro, crie um ativo de Enumeração que defina suas principais variantes: Vermelho, Amarelo e Azul.  

Para criar um ativo de enumeração:

1. Abra o Navegador de Conteúdo, ou uma Gaveta de Conteúdo, usando o botão Gaveta de Conteúdo no canto inferior esquerdo da Unreal Engine.

2. Crie um local para armazenar os blueprints e os ativos compatíveis que você criará neste tutorial. Vá para a pasta Content > AdventureGame > Designer. Clique com o botão direito do mouse nela e clique em Nova pasta.

3. Chame a nova pasta de Blueprints.

4. Na pasta Blueprints, crie outra pasta chamada Core.

5. Clique com o botão direito do mouse na pasta Core , vá para Blueprint e clique em Enumeração no menu Criar ativo. Chame o novo ativo de Enum_KeyType.

   

6. Clique duas vezes no ativo para abri-lo em uma nova janela.

A Enumeração contém uma lista de opções de Enumerador. 

Para adicionar tipos de chave ao enumerador, siga estas etapas:

1. Clique três vezes no botão Adicionar enumerador para adicionar três novos enumeradores à lista.

2. Altere o Nome de exibição do primeiro enumerador para Azul. Altere o segundo para Amarelo e o terceiro para Vermelho.

   

3. Salve o arquivo do ativo de enumerador clicando no botão Salvar no canto superior esquerdo da janela. Como alternativa, use CTRL + S. 

Quando você adiciona um enumerador, está adicionando uma opção à lista. Azul, amarelo e vermelho são valores que você usará para distinguir entre os diferentes tipos de chaves.

Em comparação com blueprints, você não precisa compilar ativos de dados, pois não está compilando nenhuma funcionalidade. 

Definir atributos de chaves em uma struct

Em seguida, crie uma struct que defina os atributos que distinguem cada tipo de chave: uma forma de malha e uma cor.

Para criar um ativo de Estrutura (struct), siga estas etapas:

1. Acesse o Navegador de Conteúdo novamente e verifique se você ainda está na pasta Content > AdventureGame > Designer > Core.

2. Clique com o botão direito do mouse em qualquer lugar da pasta Core , vá para Blueprint e clique em Estrutura. Chame esse ativo de Struct_KeyData.

   

3. Clique duas vezes no novo ativo para abri-lo em uma nova janela com as propriedades da struct.

4. A struct terá uma variável por padrão, denominada MemberVar_0. Clique em Adicionar variável para adicionar uma segunda variável.

5. Altere o nome da primeira variável para Material de chave e da segunda variável para Malha da chave.

6. Cada variável tem um tipo de dados atribuído. Isso é definido como booleano (um valor verdadeiro ou falso) por padrão. Você precisa alterar o tipo de ambas as variáveis.

   Para a variável Material da chave, clique no menu suspenso que diz Booleano. Insira instância de material no campo de pesquisa, passe o mouse sobre Instância de Material e selecione Referência de objeto. 

   

7. Repita essas etapas para alterar o tipo de variável de Malha de chave para Malha estática > Referência de objeto. 

   

8. Salve o arquivo do ativo de struct. 

Agora você criou dois atributos que cada tipo de chave usará: um Material de chave que definirá a cor da chave e uma Malha de chave que definirá a forma da chave. 

Você terminou de definir o tipo de dados que a chave possui. Em seguida, você configurará as cores da chave e, depois, criará cada tipo de chave.

Criar cores de chaves 

Agora que você tem os dados dos tipos de chave azul, amarela e vermelha, criará Materiais com as cores correspondentes que atribuirá a cada tipo de chave.

Na Unreal Engine, um Material define a aparência de uma superfície. Ele controla aspectos como cor, a textura, o brilho, a transparência e muito mais. Uma Instância de Material é uma cópia de um material que usa o material como base, mas pode substituir configurações específicas, como cores ou texturas, sem a necessidade de criar um material novo do zero.

Neste exemplo, você criará um Material básico que define atributos para todas as chaves do jogo. Em seguida, você criará duas Instâncias de material desse material para copiar todos os atributos, mas substituirá as cores.

Para criar um ativo de Material colorido, siga estas etapas:

1. Acesse o Navegador de Conteúdo. Navegue até a pasta Content > AdventureGame > Designer.

2. Clique com o botão direito do mouse na pasta Designer e clique em Nova pasta. Chame essa pasta de Materials.

3. Acesse a pasta Materials. Clique com o botão direito do mouse na pasta e selecione Material para criar um ativo de material.

   

4. Altere o nome do ativo de material para M_BasicColor.

   O nível de amostra do tutorial usa o prefixo M_ como uma convenção de nomenclatura para identificar materiais.

5. Clique duas vezes no Material para abri-lo. Isso abre o Editor de material em uma nova janela.

O Editor de material é um editor baseado em nós, o que significa que ele foi criado com algumas semelhanças com o Script visual de Blueprint. Você deverá ver um nó chamado M_BasicColor, que é o nó principal que pode ser usado para alterar as propriedades desse material.

A propriedade Cor de base define a cor desse material. Você pode clicar na amostra de cor cinza ao lado de Cor de base para definir manualmente a cor. 

Em vez de usar o seletor de cores, você criará um nó de parâmetro Color que pode ser substituído em cada Instância de material, criando assim um material que pode se transformar em várias cores. Criar um parâmetro é como adicionar uma variável: ele transforma a cor do material em um parâmetro editável de uma Instância de Material.

Para criar um nó de parâmetro de cor, siga estas etapas:

1. Ao lado de Cor de base, você verá um pin. Clique no pino e arraste-o até uma área vazia do gráfico. 

   

2. Na lista suspensa, digite VectorParameter no campo de pesquisa e selecione VectorParameter.

   Isso criará um novo nó que tem um seletor de cores. Uma variável de tipo de vetor tem três valores, portanto, você pode usá-la para definir os valores RGB de uma cor.

3. O nome padrão do nó, Parâmetro, é destacado quando você cria o nó pela primeira vez. Renomeie o nó Cor para facilitar a identificação em suas instâncias de material.

   Se Parâmetro não estiver destacado, clique no nó e, em seguida, clique no nome do nó para renomeá-lo.

4. No novo nó Cor, clique no quadrado quadriculado ao lado de Valor padrão para abrir um seletor de cores.

   

5. No campo Hex sRGB, altere o valor para F7DE0000, uma cor amarela, e clique em OK. 

   

6. Salve e feche o ativo de Material.

Em seguida, você criará instâncias de material para adicionar mais cores sem precisar recriar o material principal. 

Para criar três instâncias de material para suas cores principais, siga estas etapas:

1. No Navegador de Conteúdo, clique com o botão direito do mouse no ativo M_BasicColor que você criou. Na parte superior do menu de contexto, clique em Criar Instância de Material.

2. Chame o ativo criado de M_BasicColor_Red. Clique duas vezes no ativo para abri-lo.

   

   Você notará que essa janela é diferente do É Editor de material. Isso ocorre porque uma Instância de Material não precisa do conjunto completo de edição de um material: em vez disso, ela se concentra na modificação dos parâmetros que você definiu no Material de base.

3. No painel Detalhes, nos Grupos de parâmetros na parte superior, expanda Valores de parâmetro de vetor global.

   

4. Você verá uma Cor desabilitada, que é o nó VectorParameter adicionado ao material de base. Clique na caixa de seleção ao lado de Cor para habilitá-la e substituí-la.

   

5. Clique na amostra de cor ao lado de Cor e defina o valor Hex sRGB como F7005A00. Isso muda a instância do material para uma linda cor vermelha quente!

6. É sua vez de liderar o caminho! Repita esse processo para criar mais duas instâncias de material: 

   1. Crie uma Instância de Material chamada M_BasicColor_Blue. Substitua a cor por Hex sRGB = 00AFF700 e salve o ativo. 

   2. Crie uma Instância de Material chamada M_BasicColor_Yellow. Mantenha a cor do material de base e salve o ativo.  

Crie o blueprint de chave

Agora que você já tem todas as peças necessárias, é hora de criar o Blueprint de chave. O Blueprint de chave é o ativo que você pode adicionar a um nível para criar um ator instanciado dele, que tem a funcionalidade de ser pego pelo jogador.

Para criar uma nova classe de blueprint para sua chave, siga estas etapas:

1. Vá para o Navegador de Conteúdo e navegue até a pasta Content > AdventureGame > Designer > Blueprints.

2. Crie uma nova pasta chamada Key.

3. Vá para a pasta Key. Clique com o botão direito do mouse na pasta e selecione Classe de blueprint.

4. Selecione Ator como a classe pai.

   

5. Chame esse novo ator de BP_Key e clique duas vezes para abri-lo.

   O nível de amostra do tutorial usa o prefixo BP_ como uma convenção de nomenclatura para identificar as classes de blueprint.

A classe pai Actor é comumente usada para um objeto que pode ser colocado em um nível - ela não vem com funcionalidades adicionais, como movimento, como na classe pai Character, mas pode ser usada para criar interações e lógica.

Você precisa adicionar alguns itens ao nosso blueprint da chave para que ele funcione corretamente:

1. Uma malha estática para representar visualmente a chave em seu projeto.

2. Um volume de colisão que detecta quando o jogador está perto o suficiente para pegar a chave.

3. Uma maneira de saber qual é o tipo de chave.

4. Lógica de jogo para determinar o que acontece quando o jogador colide com a chave.

Configurar os componentes da chave 

Primeiro, configure os componentes da chave para que você tenha algo para colocar e interagir no mundo do jogo.

Para adicionar um componente de colisão e uma forma de malha à chave, siga estas etapas:

1. Em BP_Key, vá para a guia Janelas de visualização.

2. No painel Componentes, no canto superior esquerdo, clique em Adicionar , procure e selecione Colisão de cápsulas.

   

   Esse é o volume de colisão que o jogador pode tocar para pegar a chave. Sem isso, o jogador não seria capaz de detectar a chave. 

   Você poderia adicionar a colisão à própria malha principal, mas o uso de uma forma de colisão ajuda a uniformizar a geometria complexa, melhorando a detecção de colisão e o desempenho do jogo. 

3. Selecione o componente de Cápsula e clique em Adicionar novamente. Dessa vez, procure e selecione uma forma básica Sphere e renomeie-a como KeyMesh. 

   Ao selecionar o componente de Cápsula e, em seguida, adicionar a malha Sphere, a malha se torna filha da Cápsula, e a Cápsula é o componente pai da malha. O componente filho herda todas as propriedades do componente pai. 

4. Configure o componente KeyMesh:

   1. Selecione o componente KeyMesh. No painel Detalhes, vá para a categoria Transformar. Ao lado de Escala, altere os valores para 0,3, 0,3 e 1,0. 

      

      Isso encolhe os lados da malha em um formato oval.

   2. Na categoria Colisão, defina Predefinições de colisão como Sem colisão.

      

      Você adicionou a colisão com o componente de Cápsula, portanto, isso desativa a colisão na malha, garantindo que o personagem do jogador possa coletar a chave sem problemas, sem ricochetear na malha estática.

5. Configure o componente de Cápsula:

   • Selecione o componente de Cápsula. No painel Detalhes , na categoria Transformar, defina o Local como 0,0, 0,0, 80,0.

     Isso faz com que a chave flutue acima do solo. A malha se move com a cápsula porque a malha é um componente filho que herda todas as propriedades de seu componente pai.

   • Na categoria Forma, defina a Altura da metade da cápsula como 60,0. Isso amplia o volume de colisão para envolver melhor a malha.  

6. No painel Componentes, selecione DefaultSceneRoot. Clique em Adicionar e selecione Movimento rotativo. Isso gira lentamente sua chave para torná-la mais interessante para o jogador.

   

7. Salve e compile o blueprint.

Configurar as propriedades da chave

Sua chave também precisa armazenar informações, como o tipo de chave que é e quais materiais e malhas correspondem a cada tipo de chave. 

Para configurar isso, você usará a enumeração Tipo de chave e a estrutura de Dados de chave que você criou anteriormente. 

Para adicionar uma variável de tipo de chave ao blueprint, siga estas etapas:

1. No painel Componentes , você verá o painel Meu blueprint. Na seção Variables, clique no botão de adição (+) para adicionar uma nova variável.

2. Chame a variável de KeyType.

3. Por padrão, seu tipo é booleano. Clique na lista suspensa de tipos, procure Tipo de chave de enumeração e selecione-o. Esse tipo de variável é a enumeração que você criou anteriormente — então é hora de usá-la! Aqui, isso significa que a variável KeyType pode ser definida como Red, Yellow ou Blue.

   Nos blueprints, o tipo de variável também é chamado de tipo de pino porque as variáveis aparecem como pinos nos nós.

4. Clique no olho ao lado da variável KeyType para torná-la uma variável pública e editável. Isso é importante para você editar o valor dessa variável no Unreal Editor mais tarde e definir o tipo de cada tecla em seu nível.

   

5. Clique em KeyType para selecioná-lo. No painel Detalhes, ao lado da propriedade Categoria, exclua Padrão e insira Configuração.

   Isso faz a propriedade KeyType aparecer no painel Detalhes em uma categoria chamada Configuração.

   

Cada tipo de chave deve ter uma combinação de forma e cor. Na próxima etapa, você criará uma variável de Mapa para definir essas combinações.

Para configurar uma variável que mapeia tipos de chave para formas e cores, siga estas etapas:

1. No painel Meu Blueprint, adicione uma nova variável chamada KeyMap, também do tipo Tipo de chave de enumeração.

2. Com a variável KeyMap selecionada, no painel Detalhes, ao lado do menu suspenso Tipo, há outro menu que define o Tipo de contêiner da variável ou quantos valores a variável contém. Altere o tipo de contêiner para Mapa.

   

3. Quando você define o contêiner de Mapa, outro menu suspenso de tipo aparece ao lado do tipo de contêiner. Esse é o tipo de dados armazenados em cada opção de mapa. Como você definiu esses dados-chave anteriormente em uma struct, clique no menu suspenso e defina o tipo de dados como Struct_KeyData.

4. Compile o blueprint para que você possa preencher o KeyMap com materiais e formas de malha, configurando um par de material/malha para cada opção de KeyType.

5. No painel Detalhes, vá para a categoria Valor padrão.

6. Ao lado de Key Map, clique no botão + para adicionar um novo elemento ao mapa.

7. Altere o Tipo de chave de azul para uma cor diferente. Se você não fizer isso, talvez não consiga adicionar um novo elemento, pois já existe um elemento com o tipo de chave padrão.

8. Repita esse procedimento mais duas vezes para criar o segundo e o terceiro elementos.

9. Com seus três elementos de mapa adicionados, configure seus tipos de chave com os seguintes valores:

   Tipo de chave	Material da chave	Malha da chave
   Vermelho	M_BasicColor_Red	"Cone"
   Amarelo	M_BasicColor_Yellow	Sphere
   Azul	M_BasicColor_Blue	Cubo

   Há várias malhas denominadas Cube e Sphere no projeto. As malhas Cube e Sphere corretas devem aparecer em segundo lugar na lista quando você as procurar. Quando você passar o mouse sobre elas, elas deverão ter um caminho de /Engine/BasicShapes em suas dicas de ferramenta. 

   

   Seu KeyMap agora deve se parecer com o seguinte: 

   

10. Salve e compile o blueprint. 

Por fim, você precisa de uma variável que armazene uma referência ao personagem jogável quando ele tocar na chave. 

Para criar uma variável que armazene uma referência a outro ator, siga estas etapas:

1. Na seção Variáveis, adicione uma nova variável chamada OtherActor.

2. Altere seu tipo para Ator > Referência de objeto.

3. No painel Detalhes, altere o Tipo de contêiner para Único, pois você só precisa fazer referência a um ator que interage com essa chave: o jogador.

Agora, as variáveis da chave devem se parecer com o seguinte:

Testar a chave

Faça um teste com a chave e veja como ela está se saindo até o momento. 

Volte para o seu nível e, no Navegador de Conteúdo, arraste BP_Key até o seu nível. Você criou um blueprint que pode adicionar instâncias ao seu jogo, e isso merece ser comemorado! No entanto, ele ainda é cinza.

Com a chave selecionada, vá para o painel Detalhes. Procure a categoria Configuração que você criou e encontre a propriedade Tipo de chave. Você pode alterar isso de Azul para Amarelo e para Vermelho, mas ainda não está alterando a chave oval cinza. 

Isso ocorre porque você adicionou componentes e dados à sua chave, mas essas partes ainda não estão se comunicando entre si. É aqui que entra o script visual de Blueprint: você criará lógica (nós e fios) para passar informações em um blueprint e realizar ações com essas informações.

Definir valores-chave com uma função de blueprint

Em seguida, você criará uma função que conecta as opções de KeyMap ao componente KeyMesh, definindo automaticamente a forma correta da malha e a cor do material para uma chave com base no seu tipo.

Em vez de criar a função no blueprint principal, você a colocará em uma nova Biblioteca de funções de blueprint, que é um tipo de ativo de blueprint que armazena uma coleção de funções reutilizáveis. Essas funções não estão vinculadas a um blueprint ou ator específico. Em vez disso, eles podem ser acessados globalmente em todo o seu projeto. Bibliotecas mantêm funções úteis em um único lugar para que não seja necessário copiá-las e colá-las em vários blueprints.

Para criar uma biblioteca de funções de blueprint com uma nova função, siga estas etapas:

1. Vá para o Navegador de Conteúdo e navegue até Content > AdventureGame > Designer > Core.

2. Clique com o botão direito do mouse na pasta Core, vá para Blueprint e selecione Biblioteca de funções de Blueprints. Chame o novo ativo de BPL_FPGame e abra-o.

   

3. No painel Meu Blueprint, na seção Funções, você começa com uma nova função que está destacada. Chame-a de fnBPLSetKey.

   

   O projeto de exemplo do tutorial usa um rótulo BPL para funções em uma biblioteca blueprint e um prefixo fn para funções. Isso ajuda a identificar o que é SetKey e de onde ele vem, além de facilitar a localização da função na lista de ações do nó.

Em seguida, configure a função com as entradas e saídas necessárias. 

Entradas são valores que você passa para uma função para que ela possa fazer seu trabalho. Elas agem de forma semelhante a variáveis. A função fnBPLSetKey precisa executar ações entre o KeyType, o KeyMap e o KeyMesh, portanto, esses devem ser inputs.

Saídas são informações que a função passa de volta para o blueprint, geralmente após a criação de um resultado. A função fnBPLSetKey não precisa de nenhuma saída. 

Para adicionar entradas à função fnBPLSetKey, siga estas etapas:

1. Clique na função fnBPLSetKey para selecioná-la. No painel Detalhes, ao lado da categoria Inputs, clique no botão de + para criar uma nova entrada.

   Assim como as variáveis, cada entrada tem um nome, um tipo de pin de variável e um tipo de contêiner.

2. Altere o nome da entrada para Matriz de malha estática.

3. Altere seu tipo para um Componente de malha estática > Referência de objeto. No gráfico de nós da função, observe como o nó roxo de entrada da função agora tem um pino com a entrada que você criou, e o estilo do pino reflete o tipo (matriz de malha estática).

4. Clique no menu suspenso Tipo de contêiner ao lado do tipo e escolha Matriz.

   

   Uma matriz é uma variável que armazena vários valores do mesmo tipo em um único contêiner. Cada valor é armazenado como um elemento de matriz.

5. Configure outra entrada para corresponder à propriedade KeyMap da chave:

   1. Adicione outra entrada e chame-a de KeyMap.

   2. Clique na lista suspensa Tipo de pin e defina-a como Tipo de chave de enumeração.

   3. Clique no menu suspenso Tipo de contêiner e selecione Mapa.

   4. Clique no menu suspenso Tipo de valor e defina-o como Dados da chave de struct.

6. Configure uma entrada de tipo de chave:

   1. Adicione outra entrada chamada Chave.

   2. Defina seu Contêiner como Único e mantenha seu tipo como Tipo de chave de enumeração.

Suas três entradas agora devem ter a seguinte aparência:

Agora, você pode criar os nós da função. No painel do gráfico, você pode ver o nó de entrada da função fnBPLSetKey com as entradas que acabou de criar: uma Matriz de malha estática, um mapa de chaves e uma chave.

Para adicionar lógica à função que configura as teclas com uma nova forma de malha de teclas, siga estas etapas:

1. Arraste o pin Execução (exec) desse nó, procure por Loop For Each e selecione-o na lista de ações do nó. Isso cria um novo nó conectado ao nó fnBPLSetKey.

   Com o nó Loop For Each, você pode executar algumas ações em cada item de uma matriz. Qualquer lógica que você conectar ao pin de execução Corpo do loop será executada uma vez por elemento da matriz. Quando o loop for concluído, a execução continuará por meio do pin Concluído.

   

2. Arraste o pin Matriz de malha estática do nó fnBPLSetKey e conecte-o ao pin Matriz do Loop For Each.

   

   A chave tem apenas uma malha, mas fnBPLSetKey usa uma matriz de malha estática para que você possa usá-la com uma variedade de objetos de nível. Por exemplo, na próxima parte desta série de tutoriais, você trabalhará com o blueprint da porta que tem duas malhas estáticas para as portas direita e esquerda.

3. Em seguida, arraste o pin Mapa de chaves do nó fnBPLSetKey, procure e selecione um nó Localizar. Esse nó pode receber um Tipo de chave e extrair a malha e o material correspondentes do Mapa de chaves.

4. Clique com o botão direito do mouse no pin de saída azul do nó Localizar nó e clique em Dividir pin de estrutura. 

   

   Isso divide a saída em Material de chave e Malha de chave, que são as duas variáveis em Struct_KeyData.

5. Conecte o pin Chave do nó fnBPLSetKey ao pin Chave turquesa do nó Localizar. 

   

6. Agora, no nó Para cada loop, arraste do pin Corpo do loop e procure É válida na categoria Struct. Adicione o nó É válido com um ícone de ponto de interrogação (?) próximo a ele, já que esse é o nó que você usa para valores de estrutura. 

   

   Esse nó verifica se uma forma de malha válida foi passada para a função. Se for o caso, você definirá a malha estática do objeto e seu material. Caso contrário, você apenas definirá o material. 

7. Conecte o pin Malha da chave do nó Localizar ao pin Objeto de entrada do nó É válido. 

   

8. No nó É válido, arraste o pin É válido e alterne a opção Sensível ao contexto para Falso.

   

9. Procure e adicione um nó Definir malha estática.

10. No nó Loop For Each, arraste o pin Elemento da matriz e conecte-o ao pin Destino do nó Definir malha estática.

    O Alvo é a entidade na qual o nó atuará. Você deseja executar a ação Definir malha estática no KeyMesh, portanto, a Matriz de malha estática deve ser o destino.

11. No nó Localizar, arraste o pin Malha de chave e conecte-o ao pin Nova malha do nó Definir malha estática. 

O gráfico da função agora deve ter a seguinte aparência:

Você pode clicar duas vezes em um fio entre dois nós para criar um conector adicional. Passe o mouse sobre o conector até que o cursor se transforme em quatro setas e, em seguida, arraste o conector para remodelar os fios. Isso pode ajudar a posicionar seus nós e linhas livremente.

Selecione um fio e pressione a tecla Q para endireitá-lo.

Você definiu a nova forma de malha na chave, agora só precisa definir também o novo material.

Para adicionar uma lógica que configure as teclas com uma nova cor de Material de chave, siga estas etapas:

1. Arraste o pin Exec do nó Definir malha estática e procure o nó Definir material (na categoria Renderização > Material) e crie-o.

2. Arraste seu pin Alvo até o Elemento da matriz do nó Loop For Each.

3. Arraste seu pin Material até o pin Material de chave do nó Localizar.

   

4. Para garantir que o material seja definido quando uma malha não for fornecida, conecte o pino Não é válido do nó ao pino exec do nó Definir material. Adicione dois conectores para remodelar o fio.

5. Salve e compile o blueprint.

Sua função fnBPLSetKey completa agora deve ter a seguinte aparência:

Inicializar as chaves

Agora, você está pronto para usar a funcionalidade que criou dentro do blueprint da chave. Primeiro, você inicializará a chave com base no KeyType que atribuiu a ela. 

Para inicializar a chave, siga estas etapas:

1. Arraste o pin Exec do nó Script de construção e procure a função fnBPLSetKey que você criou anteriormente.

   

   O nó da função requer uma Matriz de malha estática, um Mapa de chaves e uma Chave, que você fornecerá a partir de BP_Key.

2. No painel Meu blueprint, na seção Variáveis, expanda a categoria Configuração e arraste a variável KeyType até o gráfico de nós próximo ao nó de função. 

   

3. Isso pergunta se você deseja Obter ou Definir o valor da variável. Nesse caso, você precisa verificar o tipo de chave. Portanto, selecione Obter. 

4. Conecte o pin do novo nó Obter tipo de chave ao pin Chave do nó Fn BPLSet Key.

   

5. Repita o mesmo processo para a variável KeyMap. Arraste-o até o gráfico de nós e crie um nó Obter. Conecte o pin desse nó ao pin KeyMap do nó Fn BPLSet Key.

   

6. Em seguida, no painel Componentes, arraste KeyMesh até o gráfico e crie um nó Obter. 

7. O nó Malha da chave contém uma única referência de componente de malha estática, mas o nó de função precisa de uma matriz. A Unreal Engine pode cuidar disso para você: conecte o pino Malha da chave ao pino Matriz de malha estática do nó Fn BPLSet Key.

8. Salve e Compile seu blueprint.

  O script de construção da chave agora deve ter a seguinte aparência: 

Testar a funcionalidade da chave

Agora, você pode testar a funcionalidade de mudança de cor que criou em sua chave e na nova função. 

Feche a janela do Editor de Blueprint e volte para o editor de níveis.  

Como o valor padrão de Tipo de chave é Azul, sua chave deve ser inicializada como um retângulo azul. 

Selecione o ator principal e, no painel Detalhes, na seção Configuração, altere o Tipo de chave entre Amarelo e Vermelho. Ao alterá-la, você verá a chave atualizar sua cor e forma no nível!

Se as chaves retangulares e ovais parecerem muito grandes, talvez você tenha selecionado os ativos de malha errados ao criar KeyMap. Volte aos detalhes do KeyMap e verifique se as malhas Sphere e Cube estão no caminho /Engine/BasicShapes.

Conceder chaves ao personagem jogável

Seu jogador precisa de uma maneira de pegar as chaves e de outros objetos que saibam quais chaves o jogador tem em mãos. Para lidar com a concessão e a recuperação de chaves, você usará uma Interface de Blueprint.

Usar uma Interface de Blueprint para se comunicar entre blueprints 

Uma interface de blueprint armazena uma lista de funções que podem ser usadas por cada blueprint que tenha acesso à interface. Implementar uma interface significa dar ao seu blueprint a capacidade de responder a um conjunto compartilhado de eventos (ou mensagens).

Em um jogo em que os personagens do jogador e do PNJ estão andando por aí, a chave precisa de uma maneira de garantir que esteja interagindo apenas com o personagem do jogador. Para fazer isso, você criará uma Interface de Blueprint para implementar em BP_AdventureCharacter. Isso funciona como uma permissão que o blueprint do jogador usa para ouvir a mensagem de coleta da chave. 

As interfaces de blueprint são úteis quando você deseja que diferentes blueprints se comuniquem sem conhecer os detalhes uns dos outros.

Para criar uma Interface de Blueprint com duas funções, siga estas etapas:

1. Vá para o Navegador de Conteúdo e navegue até Content > AdventureGame > Designer > Blueprints > Core.

2. Clique com o botão direito do mouse na pasta Core, vá para Blueprint e crie uma nova Interface de Blueprint. Chame esse ativo de BPI_PlayerKeys e abra-o clicando duas vezes nele.

   Essa janela é semelhante ao Editor de Blueprint. No lado direito, você tem o painel Meu Blueprint que lista todas as funções dessa interface. Abaixo dele está o painel Detalhes.

3. No painel Meu Blueprint, já existe uma função inicial criada para você. Dê a ela o nome de fnBPIAddKey.

4. Selecione a função e, no painel Detalhes , na seção Inputs, pressione o botão + para adicionar uma nova entrada.

5. Chame a entrada de KeyType e altere seu tipo para Tipo de chave de enumeração.

   

6. Também no painel Detalhes, ao lado de Categoria, digite Chaves. Isso facilita a localização de sua função na lista de Interfaces de blueprint.

7. Em seguida, adicione uma nova função no painel Meu Blueprint chamada fnBPIGetKeys, que tratará da recuperação de chaves. 

   

8. Selecione a nova função fnBPIGetKeys e, no painel Detalhes, na seção Outputs (Saídas), clique no botão + para adicionar um novo parâmetro chamado Held Keys (Chaves coletadas). 

9. Altere seu tipo para Tipo de chave de enumeração e o valor de retorno para Matriz para que ele possa retornar as chaves encontradas pelo jogador. 

   

10. Salve e compile sua interface. Agora você pode fechar a janela BPI_PlayerKeys.

    Como uma interface está relacionada ao sistema de blueprint, você precisa compilá-la da mesma forma que faz com os blueprints.

Observe que, na interface do blueprint, você só criou declarações de funções. As funções de interface não contêm lógica em si, mas sua configuração determina como você pode usá-las em blueprints. 

As funções de interface sem saídas (fnBPIAddKeys) funcionam como eventos, enquanto as funções com saídas (fnBPIGetKeys) funcionam como funções regulares às quais você pode adicionar lógica.

Criar um novo personagem jogável

Antes de adicionar o personagem, você duplicará um personagem de jogador padrão que vem com o projeto para criar sua própria variante. Você também precisará alterar as configurações do modo de jogo para usar o novo personagem.

Para criar um personagem jogável para usar em seu projeto, siga estas etapas:

1. Vá para o Navegador de Conteúdo e navegue até a pasta Content > AdventureGame > Designer > Blueprints.

2. Crie uma nova pasta chamada Characters.

3. Vá para a pasta Content > Variant_Shooter > Blueprints > FirstPerson.

4. Arraste o ativo BP_ShooterChracter até a pasta Characters que você criou e selecione Copiar aqui.

5. Clique com o botão direito do mouse na nova cópia na pasta Characters para renomeá-la como BP_AdventureCharacter.

6. Acesse Editar > Configurações de Projeto. No painel esquerdo, acesse configurações de Projeto > Mapas e modos.

7. Na configuração DefaultGameMode, expanda SelectedGameMode.

   Um ativo de Modo de Jogo que define um conjunto de regras para o mundo, incluindo o personagem jogável padrão. Você precisará alterá-lo para usar o novo personagem que criou. Você pode alterar as configurações do modo de jogo aqui ou abrindo o próprio ativo.

8. Altere a Default Pawn Class para BP_AdventureCharacter.

   

9. Feche a janela Configurações do projeto.

Para alterar as configurações do modo de jogo por nível, e não para todo o projeto, use World Settings. Você pode encontrar essa guia ao lado do painel Detalhes.  

Se você não conseguir ver o painel World Settings, na barra de menu principal, vá para Janela e selecione World Settings. 

Adicionar a interface de blueprint ao jogador 

Nesta seção, você modificará o blueprint do personagem jogável. Esse personagem tem muitas funções e interfaces úteis já configuradas para você, e você adicionará a interface BPI_PlayerKeys que criou anteriormente para permitir que ele pegue as teclas.

Em seguida, modificará o novo BP_AdventureCharacter para usar chaves. 

Para adicionar as funções da Interface de Blueprint ao personagem, siga estas etapas:

1. Navegue até sua nova pasta Characters e abra BP_AdventureCharacter.

2. Você adicionará a interface BPI Player Keys para garantir que o blueprint do jogador a implemente. Na barra de ferramentas na parte superior da nova janela, clique no botão Configurações da classe.

3. No painel Detalhes, no lado direito, na seção Interfaces > Interfaces implementadas, clique em Adicionar e selecione BPI_PlayerKeys no menu suspenso. Isso concede ao seu personagem a capacidade de implementar as funções fnBPIGetKeys e fnBPIAddKey.

   

4. Compile o blueprint para que você possa usar as funções de interface. Na seção Interfaces do painel Meu Blueprint, você verá uma categoria Chaves contendo fnBPIAddKey e fnBPIGetKey. Ele tem um ícone amarelo em vez de cinza, o que significa que essas funções funcionam como eventos. 

Armazenar chaves coletadas 

O jogador precisa armazenar as chaves que coletou, portanto, crie uma nova variável para isso. A variável precisa conter até três chaves, portanto, deve ser uma matriz.

Para criar uma variável de matriz para armazenar as chaves do jogador, siga estas etapas:

1. No blueprint BP_AdventureCharacter, adicione uma nova variável à lista Variáveis no painel Meu Blueprint.

2. Chame a variável de Chaves mantidas.

3. Selecione a variável e, no painel Detalhes, defina o contêiner como uma matriz do tipo Tipo de chave de enumeração. O uso de uma matriz é importante, pois o jogador pode manter várias teclas simultaneamente.

   

Para adicionar chaves à matriz Chaves mantidas quando o jogador pegar uma chave, siga estas etapas:

1. Vá para a guia Gráfico de eventos do personagem.

2. Clique com o botão direito do mouse no gráfico e procure o evento fnBPIAddKey. Esse é o nó de evento que é executado quando a função fnBPIAddKey é chamada.

3. Arraste a partir de seu pin de execução, procure Adição de matriz e selecione um nó Adicionar. Esse nó recebe um novo elemento e o adiciona a uma matriz.

4. Adicione uma referência à variável Chaves mantidas arrastando a variável até o Gráfico de eventos e selecione Obter.

5. Conecte o nó Chaves mantidas à entrada Matriz alvo do nó Adição de matriz. Esse pin se parece com um quadrado.

6. Conecte o pin Tipo de chave do nó Evento à entrada Novo item do nó Adicionar.

   

Agora, quando essa função de evento for acionada, o personagem do jogador adicionará o Tipo de chave fornecido à sua matriz Chaves mantidas.

Recuperar a lista de chaves do jogador

A porta com a qual você trabalhará na próxima parte deste tutorial precisa verificar todas as chaves do jogador, portanto, adicione uma funcionalidade ao jogador que retorne uma matriz de chaves que ele pegou.

Para lidar com a recuperação de chaves, siga estas etapas:

1. No blueprint BP_AdventureCharacter , em Meu Blueprint > Interfaces, expanda a seção Chaves.

   

    Na lista, fnBPIGetKeys tem um ícone cinza, o que significa que você pode usá-la como uma função normal, não apenas como um evento.

2. Clique duas vezes em fnBPIGetKeys para abrir o gráfico da função.

3. Adicione uma referência à variável Chaves mantidas arrastando-a e selecionando Obter.

4. Conecte o nó Obter chaves mantidas ao pin Chaves mantidas do nó Retornar.

O gráfico fnBPIGetKeys agora deve se parecer com o seguinte:

Fazer com que as chaves detectem colisões com o jogador

Em seguida, você adicionará uma funcionalidade que aciona a função de evento fnBPIGetKeys quando o jogador pega uma tecla. Isso deve acontecer quando o jogador tocar o volume de colisão da chave. 

Você adicionará um evento que pertence ao componente de colisão Cápsula. Um evento é acionado quando algo acontece durante o jogo. Nesse caso, quando o ator jogador se sobrepõe à Cápsula da chave, a chave deve executar algumas ações.

Para adicionar um evento de sobreposição e verificar se o ator sobreposto é o jogador, siga estas etapas:

1. Abra seu blueprint BP_Key e navegue até uma área vazia do Gráfico de eventos.

2. No painel Componentes, clique com o botão direito do mouse no componente Cápsula e selecione Adicionar evento > Adicionar OnComponentBeginOverlap. O nó associado aparece em seu gráfico de eventos. Esse nó de evento é acionado se ocorrer uma sobreposição entre esse e outro ator.

   

   O nó do evento vem com informações sobre esse evento. Por exemplo, o ator sobreposto que acionou o evento é passado pelo pin Outro ator.

3. Arraste a variável Outro ator da lista Variáveis até o gráfico e selecione Definir. Um nó Definir salva um novo valor nessa variável.

4. Arraste o pino Execução do nó Event OnComponentBeginOverlap e conecte-o à entrada Execução do nó Definir outro ator. 

5. Arraste o pino Outro ator do nó Event OnComponentBeginOverlap e conecte-o à entrada Outro ator do nó Definir outro ator.

   

6. Antes de fazer qualquer coisa com a chave, verifique se o ator sobreposto é o jogador, pois esse é o único personagem que deve ser capaz de coletar chaves. Você sabe que é o jogador se ele tiver a Interface de Blueprint.

   Clique com o botão direito do mouse próximo ao nó Definir e adicione um nó O objeto implementa a interface.

7. No nó O objeto implementa a interface, altere o pin Interface para BPI_PlayerKeys.

8. Conecte o pin de entrada Objeto de teste ao pin azul do nó Definir outro ator. Esse pin funciona como um nó Obter outro ator.

9. No nó O objeto implementa a interface, arraste o pin Valor de retorno e adicione um nó Ramificação. 

10. Conecte o pin de entrada Execução do nó Ramificação ao nó Definir. 

    

Um nó Ramificação verifica se uma condição é verdadeira ou falsa para que você possa executar ações diferentes para cada resultado. Aqui, você criará uma lógica para dois cenários, verdadeiro e falso, com base no que acontece se o ator sobreposto for ou não o jogador. 

Para chamar a função de adicionar chave quando o jogador tiver tocado na chave, siga estas etapas:

1. Se o resultado de Ramificação for verdadeiro, o ator poderá pegar as chaves e, assim, acionar a função de evento da interface. Arraste o pin Verdadeiro do nó Ramificação e adicione um nó Fn BPIAdd Key (Message).

   Você está adicionando um nó de mensagem em vez de um nó de função normal porque, ao chamar uma função de interface de blueprint, você está enviando uma mensagem. O blueprint Alvo só responderá se implementar essa interface.

2. Arraste o pin Alvo do nó Fn BPIAdd Key e adicione um nó Obter outro ator.

3. Arraste o pin Tipo de chave e adicione um nó Obter tipo de chave. Essa é outra maneira de adicionar referências a variáveis. 

   

4. Quando sua chave for pega, ela deverá desaparecer após um breve atraso, para que não possa ser pega novamente. Para lidar com isso, arraste o pin Execução do nó Fn BPIAdd Key e adicione um nó Atraso. Mantenha a duração padrão de 0,2. 

5. Quando o cronômetro expirar, sua chave deverá desaparecer, portanto, conecte um nó Destruir ator ao pino Concluídas do nó Atraso. Certifique-se de que o Alvo esteja definido como auto, o que significa que o ator principal deve se remover do nível.

   

6. Salve e Compile seu blueprint.

  O gráfico de eventos completo da chave agora deve se parecer com o seguinte: 

Aqui está o diagrama de ativos do início desta página novamente, mas desta vez ele mostra um resumo de todos os ativos e funções que você criou e como eles se combinam para criar a aparência e o comportamento da chave: 

Testar a chave final

Volte ao seu nível e adicione uma chave de cada cor. Agora você pode tentar pegar as chaves no jogo caminhando sobre elas.

Próxima

Na próxima seção, você mudará o blueprint da porta para que ela possa mudar de cor como as chaves e permanecer fechada a menos que o jogador tenha pegado a chave correspondente.

• 

  Abrir portas com chaves

  Configure o blueprint BP_DoorFrame para que as portas mudem de cor e só abram com a BP_Key correspondente.