Tutorial de Scripting Visual (Blocos de Lógica)

Nesta lição, vamos explorar uma nova maneira de ativar eventos dentro do jogo.

Em vez de usar itens coletáveis, vamos criar um sistema baseado em botões que precisam ser ativados pelo jogador para liberar uma plataforma ou executar outra ação.

Este exemplo é um pouco mais avançado e nos ajudará a praticar vários conceitos aprendidos até agora, como comunicação entre Entities, uso de propriedades, tags e organização da lógica visual.

Nesta primeira parte, vamos criar a lógica da plataforma e aprender como usar propriedades armazenadas diretamente na Scene.

Isso é muito útil quando você precisa compartilhar informações entre diferentes Entities no jogo. Em vez de armazenar dados apenas dentro de uma Entity, a Scene pode funcionar como um local centralizado onde vários sistemas podem ler e modificar as mesmas informações.

Neste exemplo, os botões aumentarão um valor armazenado na Scene, e a plataforma lerá esse mesmo valor para saber quando todos os botões foram ativados.

1. Criando a Plataforma

Primeiro, assim como aprendemos nas lições anteriores, vamos criar um novo Entity Template para nossa plataforma.

Configure o Mesh que será usado como representação visual da plataforma de acordo com o estilo e as necessidades do seu projeto.

Em seguida, adicione e configure a colisão, para que o Player possa interagir corretamente com a plataforma dentro da cena.

Neste exemplo, a plataforma não precisará de nenhuma Tag ou Property específica, porque a lógica de ativação será controlada pelos outros elementos do sistema que criaremos nas próximas etapas.

2. Criando a Lógica da Plataforma

Agora vamos criar um novo Logic Brick e vinculá-lo à nossa Entity plataforma.

Dentro deste Logic Brick, desenvolveremos a lógica responsável por controlar o comportamento da plataforma e sua interação com o restante do sistema.

Você pode adicionar este Logic Brick diretamente à Entity ou configurá-lo através do Template da plataforma, da mesma forma que fizemos nas lições anteriores.

Como essa plataforma é algo que você pode querer reutilizar, configurá-la através do Template geralmente é uma boa opção.

Primeiro, vamos criar duas propriedades.

A primeira será adicionada ao Logic Brick da plataforma. Deve ser uma propriedade Int chamada Buttons.

Esta propriedade armazenará mais tarde o número total de botões disponíveis no mapa.

Com este valor, a plataforma poderá saber quantos botões existem e comparar esse número com quantos botões já foram ativados pelo jogador.

A segunda propriedade será criada diretamente na Scene, para que possamos acessá-la facilmente de diferentes partes da lógica do jogo.

Para fazer isso, na 3D View, clique no céu/fundo da cena para selecionar a Scene em si.

Em seguida, no painel de Propriedades, você deve ver que o tipo de objeto selecionado é Scene, junto com o nome da cena atual.

Esta propriedade será usada mais tarde para armazenar e compartilhar informações globais.

Clique na aba de Properties da Scene e crie uma nova propriedade chamada Button Count.

Esta propriedade fará mais sentido quando criarmos os botões, pois os botões serão responsáveis por mudar seu valor sempre que forem ativados pelo jogador.

Mesmo assim, podemos já criá-la agora, pois também será usada em breve pela lógica da plataforma.

Em resumo:

• Buttons pertence à plataforma e armazena quantos botões existem.
• Button Count pertence à Scene e armazena quantos botões já foram ativados.

Agora que criamos as duas propriedades, uma na Scene e uma no Logic Brick da plataforma, vamos começar a desenvolver a lógica da plataforma.

Retorne ao Graph.

A primeira informação que precisamos é o número total de botões que existem no mapa.

Como esse valor precisa ser calculado uma única vez quando o jogo começa, executaremos essa lógica através do On Start.

Primeiro, obtenha a Scene e use o nó que procura todas as Entities com a tag button.

Ainda não criamos os botões, mas já podemos preparar essa lógica porque adicionaremos essa tag a eles mais tarde.

Em seguida, use o nó Size para obter o número de Entities encontradas nessa lista.

Esse valor representa o número total de botões presentes na cena.

Por fim, armazene esse resultado na propriedade Buttons da plataforma usando Set Buttons.

Agora vamos criar a lógica responsável por ativar a ação da plataforma após todos os botões terem sido pressionados.

Neste exemplo, removeremos a plataforma da cena, mas você pode adaptar essa lógica para fazer qualquer coisa que desejar, como mover a plataforma, tocar uma animação, abrir uma passagem, habilitar outro objeto ou acionar uma cutscene.

Para essa verificação, usaremos On Update, garantindo que a condição seja verificada continuamente enquanto o jogo estiver em execução.

Primeiro, obtenha a Scene e acesse suas propriedades.

Como anteriormente criamos a propriedade Button Count na Scene, podemos acessá-la através do nó Get Properties, que retorna um dicionário contendo todas as propriedades da Scene.

Em seguida, conecte esse dicionário ao nó Get Property e informe o nome Button Count para recuperar exatamente a propriedade que criamos na Scene.

Por padrão, a saída do Get Property é do tipo Any.

Como precisamos comparar esse valor com a propriedade Buttons da plataforma, que é um número inteiro, mude o tipo de saída do Get Property para Int.

Depois, compare esse valor com a propriedade Buttons da plataforma, que armazena o número total de botões disponíveis no mapa.

Se ambos os valores forem iguais, significa que todos os botões foram ativados pelo jogador.

Neste momento, podemos executar a ação desejada.

Neste exemplo, removeremos a Entity da plataforma da cena.

Perfeito. A lógica da nossa plataforma agora está pronta.

A plataforma já é capaz de identificar automaticamente, quando o jogo começa, quantos botões existem no mapa.

Isso nos dá liberdade para adicionar ou remover botões da cena sem ter que mudar manualmente nenhum valor, porque a lógica recalculará a quantidade sempre que o jogo começar.

Com isso, a plataforma pode determinar dinamicamente quando todos os botões foram ativados, comparando o número total de botões com o valor armazenado na propriedade Button Count da Scene.

Também preparamos toda a estrutura para a próxima etapa, incluindo o uso da tag button, que será adicionada aos botões mais tarde.

Isso significa que a comunicação entre os elementos já está planejada:

• a plataforma conta quantos botões existem
• cada botão atualizará a propriedade da Scene quando ativado
• a plataforma verifica a propriedade da Scene
• quando a contagem corresponder ao total, a plataforma executa sua ação

Agora estamos prontos para passar para a próxima etapa: criar os botões e desenvolver a lógica que os conecta à plataforma, completando a interação entre esses dois sistemas.