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.

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

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.

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.

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.

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

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:

../../../_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

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:

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

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

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

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.

../../../_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.

Acessando as Propriedades do Nó de Cena

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.

If instead reading this value is desired, drag the node again but hold Ctrl (or Cmd on macOS). This will create a 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

Como pode ser visto acima, o tipo e o valor inicial da variável podem ser alterados, assim como alguns sinais 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.

../../../_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

Likewise, hold Ctrl (or Cmd on macOS) to drop a 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

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

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

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 *:

../../../_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.

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:

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

Pressing Ctrl + F (or Cmd + F on macOS) allows you to search the list.

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

O primeiro é uma”Constant”, 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 na 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 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

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.

../../../_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

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é-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 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.

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

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 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

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.

Wait

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.

Yield

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.

Index

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.

../../../_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
  • Use most of the existing built-in functions that are available to GDScript, such as sin(), cos(), print(), as well as constructors, such as 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