Logic Bricks são o sistema de scripting visual do Cave.

Eles permitem que você crie comportamentos de gameplay conectando nós em vez de escrever código Python diretamente.

Esta lição apresenta o que são Logic Bricks, onde eles ficam, como eles funcionam e quando você deve usá-los. Você aprenderá todo o sistema em lições mais aprofundadas depois, mas esta visão geral ajudará você a entender onde os Logic Bricks se encaixam no fluxo de trabalho do Cave.

Tutorial em Vídeo

Temos um Tutorial em Vídeo completo sobre como começar com Logic Bricks. Recomendamos que você assista.

Assista no YouTube

Será uma abordagem muito melhor para aprender sobre eles em profundidade.

Mas se você quiser continuar aqui, então vamos a uma introdução rápida:

O Que São Logic Bricks?

Logic Bricks são gráficos lógicos visuais que permitem criar lógica rapidamente de forma visual, sem escrever código de verdade.

Se você já conhece outras abordagens de scripting visual, como o Blueprints do Unreal Engine, cada brick é essencialmente um nó. Mas, seguindo a nomenclatura do Cave, eles são chamados de Bricks. Bricks podem representar vários tipos de lógica:

Eventos.
Ações.
Valores.
Matemática.
Strings.
Utilitários do engine.
Operações em entidades.
Operações em componentes.
Referências a assets.
Funções.

Você constrói comportamento conectando bricks juntos.

Se você é novo em programação, Logic Bricks podem ser uma forma amigável de começar a criar interações, pois você pode ver o comportamento como um gráfico.

Por exemplo, um gráfico simples poderia significar:

Quando o jogador tocar neste gatilho:
  Abrir uma porta.
  Tocar um som.
  Desativar o gatilho.

Esse tipo de interação é geralmente mais fácil de entender visualmente do que como um script longo quando você ainda está aprendendo.

Esta Não É a Lição Completa sobre Logic Bricks

Esta lição é apenas uma visão geral.

Logic Bricks podem ir muito mais a fundo, com:

Funções.
Controle de fluxo.
Sockets de valores.
Depuração em tempo de execução.
Comentários.
Bricks para manipulação de assets.
Gráficos reutilizáveis.
Integração com State Machine.

Esses tópicos merecem lições específicas depois.

Por enquanto, o objetivo é entender o papel dos Logic Bricks: eles são uma forma visual de construir comportamento, conectar sistemas, prototipar interações e fazer objetos de jogo responderem a eventos.

Se quiser um tutorial completo de Logic Bricks, assista a este vídeo.

Assets de Logic Bricks

Um gráfico de Logic Bricks é um asset. Você o cria no Navegador de Assets, assim como cenas, scripts Python, timelines, materiais ou templates de entidades.

Como é um asset, ele pode ser:

Nomeado.
Organizado em pastas.
Selecionado no Navegador de Assets.
Editado na aba Propriedades.
Reutilizado por várias entidades.
Salvo com o projeto.

Isso é importante: o próprio gráfico é conteúdo do projeto.

Por exemplo, você pode criar um asset chamado Door Logic e usá-lo em várias portas. Depois, se melhorar o gráfico, essas portas podem compartilhar o comportamento atualizado, dependendo de como você estruturou a reutilização.

Componente Logic Bricks

Para executar um asset de Logic Bricks no jogo, anexe-o a uma entidade usando um Logic Bricks Component.

O componente escolhe qual asset Logic Bricks ele deve usar. Em tempo de execução, o componente cria uma instância do gráfico para a entidade dona.

Isso significa:

O asset define o comportamento compartilhado.
Cada entidade tem sua própria instância rodando.
O mesmo gráfico pode ser reutilizado por várias entidades.

Isso é parecido com o modo como um script Python reutilizável pode rodar separadamente em muitas entidades.

Logic Bricks Reutilizáveis

Logic Bricks são reutilizáveis, e essa é uma de suas maiores forças.

Por exemplo, você poderia criar um asset chamado Open Door. Depois, várias entidades de portas poderiam usar esse mesmo gráfico.

A lógica reutilizável funciona bem quando:

Muitos objetos compartilham o mesmo comportamento.
Cada objeto precisa de valores locais ligeiramente diferentes.
Você quer melhorar o comportamento em um só lugar.
Você quer que o projeto fique organizado.

Isso é similar a:

Asset Reutilizável	Reutilizado por
Python Script	Componentes Python.
Entity Template	Instâncias na Cena.
Material	Entidades de Mesh.
Logic Bricks	Componentes Logic Bricks.

Em vez de copiar o mesmo gráfico em muitos lugares, você mantém um asset de comportamento e configura cada entidade conforme necessário.

Propriedades dos Logic Bricks

Logic Bricks podem expor propriedades.

Essas propriedades são sincronizadas no Logic Bricks Component, onde podem ser sobrescritas localmente.

Por exemplo, um gráfico de dano reutilizável poderia expor:

Health máxima.
Quantidade de dano.
Tempo de recarga do dano.
Tag do alvo.
Se destrói o objeto após ser ativado.

Então cada entidade que usa o gráfico pode ter valores diferentes.

Uma armadilha de espinhos pode causar pouco dano, enquanto um volume de lava pode usar a mesma lógica com dano muito maior.

Eventos de Fluxo

A lógica normalmente começa com eventos.

Eventos comuns de fluxo incluem:

Evento	Quando acontece
`On Start`	Quando a lógica começa.
`On First Update`	No primeiro update após iniciar.
`On Update`	Repetidamente enquanto o jogo atualiza.
`On Paused Update`	Durante atualizações permitidas em pausa.
`On Late Update`	Mais tarde no ciclo de atualização.
`On End`	Quando a lógica está terminando.

Eventos são os pontos de entrada do gráfico.

Sem um evento ou algum outro gatilho, o gráfico não tem motivo para começar a funcionar.

Fluxo de Lógica

O fluxo de lógica decide o que acontece e em qual ordem. Sockets de fluxo conectam bricks de eventos e ações.

Por exemplo:

Isso significa que a ação de imprimir acontece quando o gráfico começa.

A distinção importante para iniciantes é:

Tipo de Conexão	Propósito
Conexões de fluxo	Definem quando as ações executam.
Conexões de valor	Fornecem dados para as ações.

Quando isso ficar claro, Logic Bricks ficam muito mais fáceis de entender.

Gráficos mais complexos podem ramificar, atrasar, agendar, chamar funções, ler valores, modificar entidades e se comunicar com componentes.

Depuração em Tempo de Execução

Logic Bricks podem mostrar feedback útil em tempo de execução enquanto você testa.

Quando a entidade dona está selecionada no Modo de Jogo, bricks e links executados podem ser destacados para que você veja o que rodou:

A depuração em runtime pode ajudar a responder perguntas como:

O evento foi executado?
A condição foi satisfeita?
A ação foi disparada?
O gráfico alcançou o objeto correto?
Algum erro foi mostrado no Console?

Se uma porta não abriu, esse feedback ajuda a verificar se o evento do gatilho rodou, se a condição passou e se a ação chegou até a porta.

Quando você seleciona um logic brick após testar o jogo, ele também mostra no canto inferior esquerdo da tela quantas vezes foi executado e o tempo médio de execução.

Logic Bricks em State Machines

Logic Bricks não são usados só como componentes independentes. Eles também podem ser usados dentro de State Machines.

Por exemplo:

Um estado de State Machine pode usar Logic Bricks para seu comportamento.
Uma transição pode usar Logic Bricks para sua condição.

State Machines serão explicadas depois, mas é útil saber que Logic Bricks podem fazer parte de sistemas de comportamento mais estruturados.

Isso significa que você pode usar lógica visual para interações simples e também para comportamentos organizados como estados de inimigos.

Quando Usar Logic Bricks

Logic Bricks são adequados para:

Iniciantes aprendendo lógica de gameplay.
Designers que preferem lógica visual.
Protótipos rápidos.
Interações simples.
Gatilhos.
Comportamento de UI.
Eventos de gameplay reutilizáveis.
Conectar sistemas entre si.

Bons exemplos para iniciantes incluem:

Uma placa de pressão que abre uma porta.
Um item que aumenta a saúde.
Um gatilho que inicia uma Timeline.
Um botão de UI que troca de cena.
Um perigo que causa dano ao jogador.
Um checkpoint que salva a posição.

Para sistemas muito grandes ou complexos, Python pode ser mais fácil de organizar. Para muitas interações de gameplay, Logic Bricks são rápidos, visuais e fáceis de inspecionar.

Uma Regra Simples

A linguagem visual do Cave tem paridade um-para-um com a API Python, o que significa que toda função disponível via código também deve estar disponível via Logic Bricks.

Isso quer dizer que você pode escolher livremente qual prefere para criar a lógica do seu jogo. Ou seja:

Use Logic Bricks quando quiser ver o comportamento como um gráfico.
Use Python quando o comportamento for mais fácil de expressar como código.
Você também pode combinar ambos!

Ambas as abordagens fazem parte do Cave, e muitos projetos usam lógica visual para alguns sistemas e Python para outros.

Cave: Guia de Introdução