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

Eles permitem criar comportamento de jogo conectando nós em vez de escrever código Python diretamente.

Esta lição apresenta o que são Logic Bricks, onde eles estão, como funcionam e quando você deve usá-los. Você aprenderá o sistema completo em lições mais profundas 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.

Assistir no YouTube

Essa será uma abordagem muito melhor para aprender em profundidade.

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

O Que São Logic Bricks?

Logic Bricks são gráficos de lógica visual que permitem criar lógica visualmente, sem escrever código real.

Se você está familiarizado com outras abordagens de script visual, como os Blueprints do Unreal Engine, cada brick é essencialmente um nó. Mas, de acordo com as convenções de nomenclatura do Cave, eles são chamados de Bricks. Os Bricks podem representar muitos tipos de lógica:

• Eventos.
• Ações.
• Valores.
• Matemática.
• Strings.
• Utilitários do motor.
• Operações de entidade.
• Operações de componente.
• Referências de ativos.
• Funções.

Você constrói comportamento conectando os bricks juntos.

Se você é novo em programação, Logic Bricks podem ser uma maneira 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 pode significar:

Quando o jogador toca este gatilho:
  Abra uma porta.
  Toque um som.
  Desative o gatilho.

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

Esta Não É a Aula Completa de Logic Bricks

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

Logic Bricks podem ir muito mais fundo que isso:

• Funções.
• Controle de fluxo.
• Sockets de valor.
• Depuração em tempo de execução.
• Comentários.
• Bricks manipuladores de ativos.
• Gráficos reutilizáveis.
• Integração de Máquina de Estados.

Esses tópicos merecem lições focadas mais tarde.

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

Se você quer um tutorial completo sobre Logic Bricks, por favor assista a este.

Ativos de Logic Bricks

Um gráfico de Logic Bricks é um ativo. Você o cria no Navegador de Ativos, assim como cria cenas, scripts Python, cronogramas, materiais ou modelos de entidade.

Porque é um ativo, ele pode ser:

• Nomeado.
• Organizado em pastas.
• Selecionado no Navegador de Ativos.
• Editado na aba de Propriedades.
• Reutilizado por múltiplas entidades.
• Salvo com o projeto.

Isso é importante: o gráfico em si é conteúdo do projeto.

Por exemplo, você pode criar um ativo Lógica da Porta e usá-lo em várias portas. Mais tarde, se você melhorar o gráfico, essas portas podem compartilhar o comportamento atualizado dependendo de como você estrutura a configuração reutilizável.

Componente de Logic Bricks

Para executar um ativo de Logic Bricks no jogo, anexe-o a uma entidade com um Componente de Logic Bricks.

O componente escolhe qual ativo de Logic Bricks deve usar. Em tempo de execução, o componente cria uma instância em tempo de execução do gráfico para sua entidade proprietária.

Isso significa:

• O ativo define o comportamento compartilhado.
• Cada entidade recebe sua própria instância em execução.
• O mesmo gráfico pode ser reutilizado por múltiplas entidades.

Isso é semelhante à forma como um script Python reutilizável pode ser executado separadamente em várias entidades.

Logic Bricks Reutilizáveis

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

Por exemplo, você poderia criar um ativo de Logic Bricks chamado Abrir Porta. Então várias entidades de porta 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 permaneça organizado.

Isso é semelhante a como:

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

Propriedades de Logic Bricks

Logic Bricks podem expor propriedades.

Essas propriedades são sincronizadas no Componente de Logic Bricks, onde podem ser substituídas localmente.

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

• Saúde Máxima.
• Quantidade de Dano.
• Tempo de recarga de Dano.
• Tag alvo.
• Se destrói o objeto após a ativação.

Assim, cada entidade que usa o gráfico pode ter valores diferentes.

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

Eventos de Fluxo

A lógica geralmente começa a partir de eventos.

Eventos de fluxo comuns incluem:

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

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

Fluxo de Lógica

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

Por exemplo:

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

A distinção importante para iniciantes é:

Uma vez que isso faz sentido, Logic Bricks se tornam muito mais fáceis de ler.

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 durante os testes.

Quando a entidade proprietária está selecionada durante o Modo de Jogo, bricks e links executados podem ser destacados para que você possa ver o que foi executado:

A depuração em tempo de execução pode ajudar a responder perguntas como:

• O evento foi executado?
• A condição passou?
• A ação foi executada?
• O gráfico alcançou o objeto correto?
• Um erro foi impresso no Console?

Se uma porta não abriu, esse feedback ajuda você a inspecionar se o evento de gatilho foi executado, se a condição passou e se a ação alcançou a porta.

Quando você seleciona um brick de lógica 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 Máquinas de Estado

Logic Bricks não são usados apenas como componentes autônomos. Eles também podem ser usados dentro de Máquinas de Estado.

Por exemplo:

• Um estado da Máquina de Estado pode usar Logic Bricks para seu comportamento.
• Uma transição pode usar Logic Bricks para sua condição.

Máquinas de Estado são explicadas mais tarde, mas é útil saber que Logic Bricks podem ser parte de sistemas de comportamento estruturados maiores.

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 uma boa escolha para:

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

Bons exemplos para iniciantes incluem:

• Uma placa de pressão abrindo uma porta.
• Um item coletável aumentando a saúde.
• Um gatilho iniciando um Cronograma.
• Um botão de UI mudando de cenas.
• Um perigo danificando o jogador.
• Um ponto de verificação salvando uma posição.

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

Uma Regra Simples

A script visual do Cave tem uma paridade um-a-um com a API Python, significando que toda função disponível através do código deve também estar disponível através de Logic Bricks. Isso significa que você pode escolher livremente qual prefere usar para criar a lógica do seu jogo. Significa:

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

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