Nodes and terminology

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.

../../../_images/visual_script16.png

Node properties

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.

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

Ports and connections

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.

../../../_images/visual_script17.png

Sequence Ports indicate the order in which operations are executed. Typically when a Node is done processing, it will go to the next node from one of the ports at the right. If nothing is connected, the function may end, or another output Sequence Port might be tried (this depends on the node). Thanks to this, you can follow the logic flow within a function by following the white lines. Not every Node has Sequence Ports. In fact, most do not.

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:

../../../_images/visual_script18.png

Conexões

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

../../../_images/visual_script_connect.gif

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.

../../../_images/visual_script_disconnect.gif

This may seem strange at first, but it happens because Data Ports are 1:N (A single output port can connect to many inputs), while Sequence Ports are N:1 (Many sequence outputs can be connected to a single input).

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:

../../../_images/visual_script52.png

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

../../../_images/visual_script53.png

Adding nodes

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.

Accessing scene nodes

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.

../../../_images/visual_script19.png

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.

../../../_images/visual_script20.png

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.

Accessing scene node properties

Esse é o modo mais comum de editar Nodes de Cena com Visual Script. 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:

../../../_images/visual_script21.png

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 Control (ou Command no Mac). Isso criará um getter:

../../../_images/visual_script22.png

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:

../../../_images/visual_script23.png

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

../../../_images/visual_script24.png ../../../_images/visual_script25.png

As it can be seen above, the type and initial value of the variable can be changed, as well as some property hints. Ticking the “Export” option makes the variable visible in the Inspector when selecting the node. This also makes it available to other scripts via the method described in the previous step.

../../../_images/visual_script28.png

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

../../../_images/visual_script26.png

Da mesma forma, segure * Control * (* Command * no Mac) para soltar um setter:

../../../_images/visual_script27.png

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:

../../../_images/visual_script29.png

A signal can also be edited via the right-click menu to customize its arguments:

../../../_images/visual_script30.png

The signal you have created will appear in the Inspector, along with the built-in node signals. This allows you to connect it from another script from another Scene Node:

../../../_images/visual_script31.png

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

../../../_images/visual_script32.png

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

Adding more nodes

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:

../../../_images/visual_script33.png

Ctrl-F (Command-F no Mac) permite procurar na 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.

../../../_images/visual_script34.png

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.

../../../_images/visual_script36.png

The first one is “Constant”, which allows you to select any value of any type as constant, from an integer (42) to a String (“Hello!”). In general, this node is not used that often because of default input values in Data Ports, but it’s good to know it exists.

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

The third one is MathConstant, which provides typical mathematical constants, such as PI, E, etc.

Dados

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

../../../_images/visual_script37.png

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.

../../../_images/visual_script38.png

Singleton do Motor

Engine singletons are global interfaces (meaning they can be accessed without a reference; unlike Scene Nodes, they are always available). They have several purposes, but in general, they are useful for low-level access or OS-related access.

../../../_images/visual_script39.png

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:

../../../_images/visual_script40.png

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.

../../../_images/visual_script41.png

Como pode ser visto acima, há dois nós disponíveis: Um getter simples e um getter sequenciado (a configuração requer uma porta de seqüê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).

Self

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.

Árvore de cena

This node is similar to the Singleton node because it references the SceneTree, which contains the active scene. SceneTree, however, only works when the node is sitting in the scene and active, otherwise accessing it will return an error.

SceneTree allows for many low-level things, like setting stretch options, calling groups, make timers, or even load another scene. It’s a good class to get familiar with.

Pré-carregamento

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.

../../../_images/visual_script42.png

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.

../../../_images/visual_script43.png

Condição

Este é um nó simples que verifica uma porta booleana. Se for verdade, ele será enviado pela porta da sequência “true”. Se falso, o segundo. Depois de ir para qualquer um deles, ele passa pela porta “done”. Deixar as portas da seqüência desconectadas é bom se nem todas forem usadas.

Iterator

Alguns tipos de dados na 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”.

Return

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.

Sequence

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.

../../../_images/visual_script55.png

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

../../../_images/visual_script54.png

Switch

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

While

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

There is a list of built-in helpers. The list is almost identical to the one from GDScript. Most of them are mathematical functions, but others can be useful helpers. Make sure to take a look at the list at some point.

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

This is the generic calling node. It is rarely used directly but by dragging to empty space on an already configured node.

Construtores

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

../../../_images/visual_script44.png

Destruidor

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

../../../_images/visual_script45.png

Emitir sinal

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

Prepare-se

Generic Getter/Setter node. Dragging properties from the Inspector works better, as they appear properly configured on drop.

Esperar

Os nós de espera 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.

Conceder

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.

Conceder Sinal

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

Index

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

Operadores

These are mostly generic operators, such as addition, multiplication, comparison, etc. By default, these mostly accept any datatype (and will throw an error at run-time if the types fed do not match those expected by the operator). It is always recommended to set the right type for operators to catch errors faster and make the graph easier to read.

../../../_images/visual_script46.png

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):
../../../_images/visual_script47.png
  • Acessar variáveis locais ou propriedades:
../../../_images/visual_script48.png
  • 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.:
../../../_images/visual_script49.png
  • Chamada da API :
../../../_images/visual_script50.png
  • Use o modo sequenciado, o qual faz mais sentido no caso de respeitar a ordem de processamento:
../../../_images/visual_script51.png