Nós e Terminologia

Antes de continuar, deve-se notar que a terminologia Node precisa ser usada com cuidado. Ao se referir a Visual Script Nodes (ou comumente Nodes), este texto se referirá às pequenas caixas que você conecta com linhas, que são parte de um gráfico. Ao se referir a Scene Nodes, fica implícito que os elementos que compõem uma Scene estão sendo referenciados, que são parte de uma árvore. Sua nomeação é semelhante, mas sua função é diferente. Ao se referir a Node aqui, estará implícito que um Visual Script Node é referido a menos que seja indicado o contrário.

Propriedades do Nó

Como na maioria das implementações de script visual, cada node tem propriedades editáveis. No Godot entretanto nós tentamos evitar nodes com controles editáveis para uma melhor leitura do todo.

Nós ainda exibem as informações necessárias como texto, mas a edição é feita por meio do Inspetor. Para editá-los, selecione qualquer nó e edite suas propriedades no Inspetor.

Portas e Conexões

A programação com Visual Script no Godot é feita via Nodes; Portas e Conexões, nas funções.

Portas

Nodes aqui, têm Portas. Elas são os pontos visíveis a esquerda e a direita dos nodes e podem ser usadas para fazer Conexões com dois tipos de Portas: De Sequencia e Dado.

Sequence Ports indicam a ordem que as operações serão executadas. Normalmente, quando um Node é processado, ele irá para o próximo nó de uma das portas à direita. Se nada estiver conectado, a função pode terminar, ou outra saída Sequence Port pode ser tentada (isso depende do nó). Graças a isso, você pode seguir o fluxo lógico dentro de uma função seguindo as linhas brancas. Nem todo Node possui Sequence Ports. Na verdade, a maioria não.

Portas de Dado contêm valores com tipos. Os tipos são de qualquer tipo normal do Godot, como os boolean, integer, string, Vector3, array, qualquer Object ou Node de cena... As Portas de Dado, a direita dum Node, são de saída e as da esquerda, de entrada. Conectá-las permite que informação flua de um node a outro.

Por isso nem todas Portas de Dado são compatíveis, permitem conexão entre si. Preste boa atenção às cores e aos ícones, pois cada tipo tem uma representação diferente:

Conexões

Conectar é um processo relativamente simples. É arrastar uma Porta de Saída a uma Porta de Entrada.

Desconectar demanda um pouco mais de prática. A desconexão de Portas de Dado é feita arrastando para longe a Entrada, já a das Portas de Sequencia é feita ao arrastar longe a Saída.

Isso pode parecer esquisito no começo, mas é assim porque Data Ports são 1:N (Uma única saída pode conectar-se a várias entradas), porquanto Sequence Ports são N:1 (Muitas saídas podem conectar-se a uma única entrada).

Conectar a espaço vazio (arrastar para conectar mas parar num espaço vazio) é também sensível ao contexto, dar-se-á uma lista das operações mais comuns. Para sequências, serão nodes condicionais:

Para dados, um menu de set/get/call abrir-se-á:

Adicionando Nós

Finalmente! Chegamos à parte divertida! Mas, antes de explicar com mais detalhes o que cada tipo de node faz, olhemos um pouquinho para como são adicionados e lidados os nodes.

Acessando os Nós de Cena

Uma das tarefas mais comuns é acessar Nodes na Árvore da Cena (mais uma vez, não confunda-se com Nodes de Visual Script). Arrastar da Árvore da Cena e soltar na tela requisitará de ti chamar um método (algumas vezes chamado de função-membro) deste node.

No acesso propriedades são desejadas na maioria das vezes (mais disso abaixo), mas chamar métodos pode ser bom também. Métodos executam ações específicas nos objetos. No exemplo acima, o ponteiro do mouse pode ser mandado a uma posição em coordenadas locais ao controle. Outro caso comum é agendar um node para remoção, que é feito com o método queue_free.

Cuidado tem de ser tomado, pois isso só funciona se a cena sendo editada contiver o Visual Script em um de seus nodes! Caso contrário, uma advertência será mostrada.

Acessando as Propriedades do Nó de Cena

Esse é o modo mais comum de editar Nodes de Cena com Visual Scripting. Selecione um Node de Cena da Árvore da Cena, vá ao Inspetor, encontre o Nome da propriedade que você quer editar (dica, não é o valor!) e arraste-a à tela:

O resultado é o valor poder ser mudado no seu script por uma Porta de Dado.

Se, em vez disso, for necessário ler esse valor, arraste o nó novamente, mas mantenha pressionada a tecla Ctrl (ou Cmd no Mac). Isso criará um getter:

Nesse caso, o valor pode ser lido de uma Porta de Dado.

Variáveis

Variáveis são contêineres de memória locais para o script que podem conter um valor. Esse valor pode ser lido de qualquer uma das funções do script ou de outros scripts por meio do método descrito na etapa anterior.

Para adicionar uma Variável, aperte o botão "+" na seção "Variáveis" do painel dos Membros. Dê um clique duplo na nova variável para renomeá-la:

Clique com o botão direito na variável para permitir que você configure suas propiedades:

Como pode ser visto acima, o tipo e o valor inicial da variável podem ser alterados, assim como algumas inferências de propriedade. Marcando a opção "Export" torna a variável visível no Inspetor quando selecionar o nó. Isso também a torna disponível a outros scripts pelo método descrito no passo anterior.

Para usar a variável no script, basta arrastá-la para a tela para criar um getter:

Da mesma forma, segure Ctrl (ou Cmd no macOS) para soltar um setter:

Sinais

Também é possível criar seus próprios sinais em um script e usá-los. Para isso, faça as mesmas etapas que você fez para as variáveis na etapa anterior, exceto para Signals:

Um sinal também pode ser editado através do menu do botão direito do mouse para personalizar seus argumentos:

O sinal que você criou aparecerá no Inspetor, junto com os sinais de nó embutido. Isso permite conectá-lo a partir de outro script de outro * Nó da Cena *:

Finalmente, para emitir o sinal, basta arrastá-lo para a tela:

Lembre-se de que a emissão de um sinal é uma operação sequenciada, portanto, ele deve vir de uma porta sequenciada.

Adicionando mais nós

Agora que as noções básicas são abordadas, vamos discutir a grande quantidade de nós de utilitários disponíveis para sua tela! Abaixo do painel de membros, existe a lista de todos os tipos de nós disponíveis:

Pressionar Ctrl + F (ou Cmd + F no macOS) permite que você pesquise a lista.

Qualquer um deles pode ser arrastado para a cena. Ao contrário dos nós (por exemplo, arrastar uma propriedade do Inspector configura o contexto para o nó que está sendo editado automaticamente), eles são adicionados sem qualquer informação "contextual", portanto, isso deve ser feito manualmente.

Lembre-se de que você pode verificar a referência de classe para o que cada nó faz, conforme eles são documentados lá. Isso mencionado, uma breve visão geral dos tipos de nós segue:

Constantes

Nós constantes são nós que fornecem valores que, embora não mudem com o tempo, podem ser úteis como valores de referência. Na maioria das vezes eles são inteiros ou flutuantes.

O primeiro é uma "Constante", que permite selecionar qualquer valor de qualquer tipo como constante, de um inteiro (42) para uma String ("Hello!"). Em geral, esse nó não é usado frequentemente devido a valores de entrada padrão em Data Ports, mas é bom saber que existe.

O segundo é o nó GlobalConstant, que contém uma longa lista de constantes para tipos globais no Godot. Lá você pode encontrar algumas constantes úteis para se referir a nomes de teclas, joystick ou botões do mouse, etc.

O terceiro é o MathConstant, que fornece constantes matemáticas típicas, como PI, E, etc.

Dados

Os nós de dados lidam com todos os tipos de acesso à informação. Qualquer informação no Godot é acessada através desses nós, então eles são alguns dos mais importantes para usar e bastante diversificados.

Existem muitos tipos de nós de interessantes aqui, então uma breve tentativa de descrevê-los seguirá:

Ação

Os nós de ação são vitais ao lidar com a entrada de um dispositivo. Você pode ler mais sobre ações no (@TODO ACTION TUTE LINK). No exemplo a seguir abaixo, o controle é movido para a direita quando a ação "move_right" é pressionada.

Singleton do Motor

Singletons da engine são interfaces globais (o que significa que eles podem ser acessados sem uma referência; ao contrário dos nós de cena, eles estão sempre disponíveis). Eles têm várias finalidades, mas em geral são úteis para acesso de baixo nível ou acesso relacionado ao sistema operacional.

Lembre-se de que arrastar uma conexão para um espaço vazio ajudará você a chamar funções ou definir / obter propriedades sobre elas:

Variáveis Locais

Esses são nós que você pode usar como armazenamento temporário para seus gráficos. Certifique-se de que todos tenham o mesmo nome e tipo ao usá-los e eles farão referência à mesma parte da memória.

Como pode ser visto acima, há dois nós disponíveis: Um getter simples e um setter sequenciado (a configuração requer uma porta de sequência).

Nó de Cena

Esta é apenas uma referência a um nó na árvore, mas é mais fácil usar esse nó arrastando o nó real da árvore de cena para a tela (isso irá criá-lo e configurá-lo).

Próprio

Em algumas raras ocasiões, pode ser desejado passar este Nó de Cena como argumento. Ele pode ser usado para chamar funções e definir / obter propriedades ou arrastar nós (ou o próprio nó do evento que possui o script) da Árvore de cena para a tela para isso.

SceneTree

Esse nó é semelhante ao nó Singleton porque ele faz referência à SceneTree, que contém a cena ativa. O SceneTree, no entanto, só funciona quando o nó estiver posto na cena e ativo, caso contrário, o acesso retornará um erro.

O SceneTree permite muitas coisas de baixo nível, como definir opções de stretch, chamar grupos, criar temporizadores ou até mesmo carregar outra cena. É uma boa classe com a qual se familiarizar.

Pré Carregar

Isso faz a mesma função que o preload () no GDScript. Ele mantém esse recurso carregado e pronto para uso. Em vez de instanciar o nó, é mais simples arrastar o recurso desejado da doca do sistema de arquivos para a tela.

Caminho do Recurso

Este nó é um auxiliar simples para obter uma cadeia com um caminho para um recurso que você pode escolher. É útil em funções que carregam coisas do disco.

Comente

Um nó Comentário funciona como um nó que você pode redimensionar para colocar em outros nós. Não vai tentar obter foco ou ser levado ao topo ao selecioná-lo. Também pode ser usado para escrever texto nele.

Controle de fluxo

Os nós de controle de fluxo permitem que a execução tenha ramificações diferentes, geralmente dependendo de uma determinada condição.

Condição

Este é um nó simples que verifica uma porta booleana. Se for verdadeira, ele será enviado pela porta de sequência "true". Se for falsa, o segundo. Depois de ir para qualquer um deles, ele passa pela porta "done". Você pode deixar portas de sequência desconectadas se nem todas forem usadas.

Iterador

Alguns tipos de dados no Godot (isto é, matrizes, dicionários) são iteráveis. Isso significa que um pouco de código pode ser executado para cada elemento que ele possui.

O nó Iterator passa por todos os elementos e, para cada um deles, passa pela porta de seqüência "each", disponibilizando o elemento na porta de dados "elem".

Quando concluído, ele passa pela porta de seqüência "exit".

Retornar

Algumas funções podem retornar valores. Em geral, para os virtuais, Godot adicionará o nó Return para você. Um nó de retorno força a função a terminar.

Sequência

Este nó é útil principalmente para organizar seu gráfico. Ele chama suas portas de seqüência em ordem.

Tipo de elenco

Este é um nó útil e comumente usado. Você pode usá-lo para transmitir argumentos ou outros objetos para o tipo desejado. Depois, você pode até mesmo arrastar a saída do objeto para obter a conclusão completa.

Também é possível converter para um script, o que permitirá as propriedades e funções completas do script:

Switch

O nó Switch é semelhante ao nó Condition, mas corresponde a muitos valores ao mesmo tempo.

Enquanto

Essa é uma forma mais primitiva de iteração. A saída de sequência "repeat" será chamada desde que a condição na porta de dados "cond" seja atendida.

Funções

Funções são ajudantes simples, na maioria das vezes deterministas. Eles tomam alguns argumentos como entrada e retornam uma saída. Eles quase nunca são seqüenciados.

Embutido

Existe uma lista de ajudantes internos. A lista é quase idêntica à do GDScript. A maioria deles são funções matemáticas, mas outros podem ser ajudantes úteis. Dê uma olhada na lista em algum momento.

Por tipo

Esses são os métodos disponíveis para tipos básicos. Por exemplo, se você quiser um produto de ponto, poderá procurar "ponto" em vez da categoria Vetor3. Na maioria dos casos, basta pesquisar a lista de nós, deve ser mais rápido.

Call

Este é o nó de chamada genérico. Raramente é usado diretamente, mas arrastando para o espaço vazio em um nó já configurado.

Construtores

Estas são todas as funções necessárias para criar tipos de dados básicos no Godot. Por exemplo, se você precisar criar um Vector3 de 3 flutuantes, um construtor deve ser usado.

Destruidor

Isso é o oposto do Construtor, ele permite separar qualquer tipo básico (isto é, Vector3) em seus sub-elementos.

Emit Signal

Emite sinais de qualquer objeto. Em geral, não é tão útil, pois arrastar um sinal para a tela funciona melhor.

Get/Set

Nó Getter/Setter genérico. As propriedades de arrastamento do Inspetor funcionam melhor, já que aparecem corretamente configuradas ao soltar.

Esperar

Os nós Wait suspenderão a execução da função até que algo aconteça (muitos quadros podem passar até a retomada, na verdade). Os nós padrão permitem que você aguarde a passagem de um quadro, um quadro fixo ou um determinado período de tempo até que a execução seja retomada.

Aguardar Retorno

Esse nó suspende completamente a execução do script e fará com que a função retorne um valor que possa ser usado para retomar a execução.

Yield Signal

O mesmo que Yield, mas esperará até que um determinado sinal seja emitido.

Índice

Operador genérico de indexação, não é frequentemente usado, mas é bom que exista apenas no caso.

Operadores

Estes são principalmente operadores genéricos, como adição, multiplicação, comparação, etc. Por padrão, estes costumam aceitar qualquer tipo de dados (e haverá erro em tempo de execução se os tipos alimentados não corresponderem ao tipos esperados pelo operador). É sempre recomendável definir o tipo certo para os operadores capturarem erros mais rapidamente e facilitar a leitura do gráfico.

Nó de Expressão

Entre os operadores, o nó Expressão é o mais poderoso. Se bem usado, permite simplificar enormemente scripts visuais que envolvem muita matemática ou lógica. Digite qualquer expressão nele e será executado em tempo real.

Os nós de Expressão podem:

• Executar expressões matemáticas e lógicas com base em entradas personalizadas (Exemplo: "a*5+b", aonde a e b são valores personalizados):

• Acessar variáveis locais ou propriedades:

• Usar a maioria das funções embutidas já existentes que estão disponíveis para o GDScript, como sin(), cos(), print(), como também construtores, como Vector3(x, y, z), Rect2(...), etc.:

• Chamada da API :

• Use o modo sequenciado, o qual faz mais sentido no caso de respeitar a ordem de processamento: