Tutorial de Scripting Visual (Blocos de Lógica)

Nesta lição, criaremos a lógica usada para coletar o item usando os Logic Bricks do Cave Engine.

Você aprenderá a detectar quando o Jogador colide com um item colecionável, identificar esse item usando uma tag, removê-lo da cena e atualizar um simples contador de UI mostrando quantos itens foram coletados.

Este é o começo de um sistema de jogabilidade muito comum: interação com itens. A mesma ideia pode ser expandida mais tarde para criar moedas, chaves, coletáveis de munição, coletáveis de saúde, objetos de missão, power-ups ou qualquer outro objeto que o Jogador possa coletar.

1. Criando a Lógica para Coletar o Item

Dentro da lógica do nosso Player, detectaremos colisões com itens colecionáveis diretamente do próprio Jogador.

Após a lógica de movimento, criaremos o sistema responsável por detectar o contato com o item e removê-lo da cena.

Primeiro, obtenha a Entity e acesse seu Character Component usando Get Character.

Do Character Component, use o nó Get Collision With. Este nó nos permite detectar colisões com base em uma Tag específica.

Neste caso, usaremos a tag item, que foi atribuída ao nosso item colecionável na lição anterior.

É por isso que adicionar uma tag ao item era importante. Em vez de verificar um nome específico da Entity, podemos simplesmente perguntar ao Jogador se ele colidiu com algo marcado como item. Isso torna a lógica mais flexível, pois qualquer objeto colecionável com essa mesma tag pode ser detectado pelo mesmo sistema.

O resultado dessa detecção deve ser conectado a um nó Get, que retorna as informações de colisão, também conhecidas como Collision Info.

Então, obtemos o índice 0, que representa a primeira colisão detectada.

Finalmente, conecte esse resultado ao nó Kill, que é responsável por remover uma Entity da cena.

A Entity que será removida vem diretamente das Collision Info. Em outras palavras, o item coletado em si é passado como entrada para Kill, fazendo com que ele desapareça da cena quando tocado pelo Jogador.

Com essa lógica, o Jogador já pode detectar um item colecionável e removê-lo da cena.

Na prática, isso significa que, quando o Jogador toca uma Entity marcada como item, essa Entity será coletada e deletada da cena atual.

2. Criando a UI de Coletáveis

Agora precisamos mostrar ao jogador que um item foi realmente coletado.

Para isso, vamos criar uma interface de UI simples que exibe:

• o ícone do item
• o número de itens coletados
• o número total de itens disponíveis no mapa

Para começar, acesse o Player Template e adicione um componente de Interface, especificamente um UI Element. Este UI Element será responsável por construir a parte visual do nosso HUD.

A partir desse elemento, criaremos e configuraremos o ícone do item colecionável. Este ícone servirá como base visual para mostrar as informações de coleta na tela do jogador.

Na aba Basic do UI Element, podemos configurar a posição e a escala do ícone.

Clicando no ícone de âncora da propriedade de posição, você pode ancorá-lo ao canto inferior esquerdo da tela.

Na configuração de escala, mantenha o ponto de referência bloqueado no centro e mantenha os bloqueios de posição e escala ativados. Isso torna os valores relativos e ajuda o layout a se adaptar corretamente a diferentes resoluções de tela.

Por fim, defina o valor Layer como 2. Isso garante que o ícone será renderizado acima de outros UI Elements com prioridade inferior.

Ajuste os valores de Scale até que o ícone tenha o tamanho desejado.

Então, use os valores de Position para colocá-lo no lado esquerdo da tela ou em qualquer outra área que você preferir dentro da interface.

Essas configurações permitem que você controle precisamente tanto o tamanho quanto a posição do elemento no HUD.

Na aba Behaviour, podemos remover o Default Style que vem por padrão e adicionar uma Texture personalizada para nosso ícone.

Você também pode ajustar a cor de Tint e a transparência de Alpha para alcançar o resultado visual desejado.

A opção de 9-Slice Scaling é usada para evitar distorção quando uma imagem é esticada no layout. Quando ativada, você pode ajustar seus valores de acordo com as necessidades do ícone, mantendo a imagem consistente mesmo quando redimensionada. No nosso caso, não usaremos o 9-Slice, já que nossa imagem é um ícone.

Agora, vamos criar 3 novas Entities de interface do tipo Text.

Elas serão responsáveis por exibir o número de itens coletados e o total de itens disponíveis no mapa.

Primeiro, renomeie o primeiro Text para TextCollect. Este texto exibirá o número de itens coletados pelo jogador.

Então, o segundo Text conterá apenas o caractere “/”, funcionando como um separador visual entre os valores na UI.

Finalmente, renomeie o terceiro Text para TextMax. Este representará a quantidade máxima de itens disponíveis no mapa.

Agora acesse a aba Text dos UI Elements que foram criados.

Nesta seção, há um campo onde podemos definir o conteúdo que será exibido na tela.

Para os dois textos que representam valores de itens, TextMax e TextCollect, vamos manter o valor inicial como 0.

O texto utilizado como separador deve conter apenas o caractere “/”, separando visualmente a quantidade coletada da quantidade total de itens.

Agora, vamos posicionar os textos da UI para que eles estejam organizados ao lado do ícone.

• Primeiro, posicione TextCollect.
• Depois, coloque o texto “/” logo em seguida.
• Finalmente, posicione TextMax após a barra.

Dessa forma, a UI ficará organizada como um contador de progresso, exibindo claramente algo como:

itens coletados / total de itens

Por exemplo:

0 / 10

Nota: Alternativamente, você também pode criar uma única Entity e programaticamente (via Logic Bricks), concatenar as strings para alcançar o mesmo resultado.

3. Criando a Lógica do Contador de Itens

Agora precisamos fazer com que a UI reflita os itens coletados.

No momento, o item pode ser removido da cena, mas a UI ainda não sabe que o Jogador coletou algo. Então, agora implementaremos a lógica do contador.

Primeiro, volte ao Player Logic Brick e crie uma nova propriedade chamada Collected Item, do tipo Int.

Essa propriedade armazenará quantos itens o Jogador coletou durante o jogo.

O valor inicial dessa propriedade deve ser 0.

Na lógica do Jogador, logo após o nó Kill que remove o item coletado, criaremos a lógica responsável por atualizar a contagem de itens.

Primeiro, obtenha a propriedade Collected Item.

Em seguida, adicione +1 ao seu valor atual.

Por fim, defina o resultado de volta na propriedade Collected Item.

Dessa forma, toda vez que o Jogador coletar um item, o valor de Collected Item aumentará em 1, mantendo o contador atualizado.

No entanto, esse valor ainda está armazenado somente na propriedade. Agora precisamos exibi-lo no texto da UI.

Logo depois disso, continue a lógica conectando o fluxo de Set Collected Item a um nó Set Text.

Esse nó será responsável por atualizar o texto exibido na interface.

Para usar Set Text, precisamos fornecer duas coisas:

• o UI Element Component que terá seu texto atualizado
• o novo valor de texto

Como os textos foram criados como filhos do Jogador, podemos acessá-los diretamente através da hierarquia da Entity.

Para fazer isso, use Entity, em seguida, Get Child, informando o nome do objeto de texto. Ative a opção Recursive para ter certeza de que a busca também acontece dentro de filhos de filhos do Jogador.

Então, obtenha o UI Element Component da Entity que foi encontrada.

Para o valor do texto, obtenha a propriedade Collected Item, converta-a para String, e conecte-a ao Set Text.

Dessa forma, o texto da UI será automaticamente atualizado com o mesmo valor armazenado na propriedade do Jogador.

Agora vamos fazer com que o texto que representa o total de itens funcione também.

Ainda no Player Logic Bricks, crie uma nova propriedade chamada Max Item, do tipo Int.

Essa propriedade armazenará o número total de itens colecionáveis disponíveis no mapa.

Agora, para armazenar o número total de itens no mapa dentro dessa propriedade, usaremos o evento On Start do Jogador.

Esse valor precisa ser calculado apenas uma vez no início do jogo, porque representa quantos itens colecionáveis existem na cena quando o jogo começa.

Primeiro, obtenha a Scene do jogo.

Em seguida, use o nó que retorna todas as Entities na cena filtradas pela tag item. Como essa tag está presente apenas em nossos itens colecionáveis, isso retornará a lista de todos os colecionáveis no mapa atual.

Com essa lista de Entities, use o nó Size.

O nó Size retorna o número total de elementos na lista como um inteiro. Esse valor representa exatamente quantos itens existem no mapa.

Por fim, defina esse resultado na propriedade Max Item, garantindo que o jogo comece com a quantidade total correta de itens colecionáveis armazenados na propriedade.

Agora só precisamos enviar esse valor para o texto da UI.

Para fazer isso, usaremos a mesma lógica que usamos para Item Colecionado.

Obtenha a propriedade Max Item, converta o valor para String e conecte-o ao nó Set Text.

Em seguida, acesse o Elemento UI correspondente ao texto do item máximo usando a hierarquia do Player com Get Child, digitando o nome correto e habilitando Recursive se necessário.

Por fim, conecte esse Componente de Elemento UI ao Set Text.

Dessa forma, o total de itens será exibido corretamente na interface do jogador.

Neste ponto, o sistema de itens colecionáveis está funcional.

O Player pode detectar itens colecionáveis usando a tag item, removê-los da cena, aumentar o contador de itens colecionados e atualizar a UI para mostrar tanto a quantidade coletada quanto a quantidade total de itens disponíveis no mapa.