Signals no Godot: Aprenda a Enviar Comandos para o seu Jogo

Nesta aula traduzida do site oficial da Godot Engine (site oficial), veremos os Signals no Godot. Eles permitem que diferentes partes do seu projeto se comuniquem de forma eficiente e desacoplada, o que significa que os objetos podem interagir sem precisar conhecer uns aos outros diretamente.

Em termos simples, os Signals funcionam da seguinte maneira: quando algo específico acontece em um objeto, ele emite um sinal. Outros objetos podem estar ouvindo esse sinal e responder a ele executando uma função específica. Isso cria uma maneira poderosa e flexível de permitir que diferentes partes do seu jogo se comuniquem e cooperem entre si.

Por exemplo, em um jogo de plataforma, quando o jogador pula, ele pode emitir um sinal chamado “pulo”. Outros objetos, como inimigos ou plataformas móveis, podem estar ouvindo esse sinal e responder de acordo. Isso pode significar fazer um inimigo pular quando o jogador pular ou mover uma plataforma quando o jogador estiver no ar.

Os Signals são uma parte fundamental da arquitetura de eventos do Godot e são uma ferramenta poderosa para criar interações complexas em seus projetos. Eles promovem o desacoplamento entre objetos, o que torna o código mais organizado e fácil de manter.

Além disso, eles oferecem uma maneira flexível de reutilizar componentes em diferentes partes do seu jogo, economizando tempo e esforço durante o desenvolvimento. Vamos falar sobre os Signals em Godot e, se tiver dúvidas, deixe um comentário.

Você também vai gostar:
Jogos em Unreal Engine
Tudo sobre Pixel Art
Aprenda a Criar Games 2D
Melhor Curso de Criação de Jogos
Criando Jogos no GameMaker

Domine a Godot

O que são os Signals no Godot?

Os Signals são mensagens que os nodes emitem quando algo específico acontece com eles, como um botão sendo pressionado. Outros nodes podem se conectar a esse sinal e chamar uma função quando o evento ocorrer.

Os signals são um mecanismo de delegação incorporado ao Godot que permite que um objeto do jogo reaja a uma mudança em outro sem que eles façam referência um ao outro. O uso de Signals limita o acoplamento e mantém seu código flexível.

Por exemplo, você pode ter uma barra de vida na tela que representa a saúde do jogador. Quando o jogador sofre dano ou usa uma poção de cura, você deseja que a barra reflita a mudança. Então, em Godot, você usaria Signals.

Conforme mencionado na introdução, os sginals são a versão de Godot do padrão observador. Você pode aprender mais sobre isso aqui. Agora usaremos um sinal para fazer com que nosso ícone Godot da lição anterior sobre os Scripts de Movimentos do Jogador se mova e pare pressionando um botão.

Como os Sinais Funcionam:

Quando um evento ocorre em um objeto, ele emite um sinal. Outros objetos podem se conectar a esse sinal e responder a ele executando uma função específica quando o sinal é recebido. Isso permite que os objetos comuniquem eventos sem a necessidade de conhecer uns aos outros diretamente.

Componentes dos Sinais:

1. Emissor (Emitter): Este é o objeto que emite o sinal quando um evento específico ocorre. Pode ser qualquer objeto no seu projeto Godot, como um nó de cena, uma instância de script ou até mesmo o próprio motor.
2. Sinal (Signal): O sinal em si é uma mensagem que o emissor envia quando um evento ocorre. Por exemplo, um objeto pode emitir um sinal chamado “botão pressionado” quando o jogador clica nele.
3. Receptor (Receiver): Este é o objeto que está ouvindo o sinal. Quando o sinal é emitido, o receptor executa uma função específica, também conhecida como “slot” ou “callback”. O receptor não precisa saber nada sobre o emissor, apenas precisa estar configurado para ouvir o sinal correto.

Criando uma Scene

Para adicionar um botão ao nosso jogo, criaremos uma nova cena principal que incluirá um botão e a cena sprite_2d.tscn que criamos na lição Criando seu primeiro script. Crie uma nova cena acessando o menu Scene -> New Scene.

Na aba Scene, clique no botão Cena 2D. Isso adicionará um Node2D como nossa raiz.

No dock FileSystem, clique e arraste o arquivo sprite_2d.tscn que você salvou anteriormente no Node2D para instanciá-lo.

Queremos adicionar outro nó como irmão do Sprite2D. Para fazer isso, clique com o botão direito em Node2D e selecione Adicionar node filho. Procure o node Button e adicione-o.

O nó é pequeno por padrão. Clique e arraste a alça inferior direita do botão na viewport para redimensioná-lo.

Se você não vir as alças, certifique-se de que a ferramenta de seleção esteja ativa na barra de ferramentas.

Clique e arraste o próprio botão para aproximá-lo do sprite. Você também pode escrever um rótulo no Button editando sua propriedade Text no Inspector. Digite .Toggle motion

Sua árvore de cena e janela de visualização devem ficar assim.

Salve sua cena recém-criada como node_2d.tscn, se ainda não o fez. Você pode então executá-lo com F6 (Cmd + R no macOS). No momento, o botão estará visível, mas nada acontecerá se você pressioná-lo.

Conectando um sinal no editor

Aqui, queremos conectar o sinal “pressionado” do Button ao nosso Sprite2D e queremos chamar uma nova função que ativará e desativará seu movimento. Precisamos ter um script anexado ao nó Sprite2D, o que fizemos na lição anterior. Você pode conectar Signals no dock do Node. Selecione o nó Botão e, no lado direito do editor, clique na aba chamada “Node” ao lado do Inspetor.

O dock exibe uma lista de Signals disponíveis no nó selecionado.

Clique duas vezes no sinal “pressionado” para abrir a janela de conexão do node.

Lá você pode conectar o sinal ao nó Sprite2D. O nó precisa de um método receptor, uma função que Godot chamará quando o Button emitir o sinal. O editor gera um para você. Por convenção, chamamos esses métodos de retorno de chamada “_on_node_name_signal_name”. Aqui, será “_on_button_pressed”.

Observação: Ao conectar Signals por meio do Node do editor, você pode usar dois modos. O simples permite apenas que você se conecte a nodes que possuem um script anexado a eles e cria uma nova função de retorno de chamada neles.

A visualização avançada permite conectar-se a qualquer node e qualquer função integrada, adicionar argumentos ao retorno de chamada e definir opções. Você pode alternar o modo no canto inferior direito da janela clicando no botão Avançado.

Clique no botão Conectar para concluir a conexão do sinal e ir para a área de trabalho Script. Você deverá ver o novo método com um ícone de conexão na margem esquerda.

Se você clicar no ícone, uma janela aparecerá e exibirá informações sobre a conexão. Este recurso só está disponível ao conectar node no editor.

Vamos substituir a linha pela palavra-chave pass pelo código que alternará o movimento do nó.

Nosso Sprite2D se move graças ao código na função _process(). Godot fornece um método para ativar e desativar o processamento: Node.set_process(). Outro método da classe Node, is_processing(), retorna verdadeiro se o processamento ocioso estiver ativo. Podemos usar a palavra-chave not para inverter o valor.

func _on_button_pressed():
	set_process(not is_processing())

Esta função alternará o processamento e, por sua vez, ativará e desativará o movimento do ícone ao pressionar o botão. Antes de experimentar o jogo, precisamos simplificar nossa função _process() para mover o node automaticamente e não esperar pela entrada do usuário. Substitua-o pelo código a seguir, que vimos há duas lições atrás:

func _process(delta):
	rotation += angular_speed * delta
	var velocity = Vector2.UP.rotated(rotation) * speed
	position += velocity * delta

Seu código sprite_2d.gd completo deve ser semelhante ao seguinte.

extends Sprite2D

var speed = 400
var angular_speed = PI


func _process(delta):
	rotation += angular_speed * delta
	var velocity = Vector2.UP.rotated(rotation) * speed
	position += velocity * delta


func _on_button_pressed():
	set_process(not is_processing())

Execute a cena agora e clique no botão para ver o sprite iniciar e parar.

Conectando um sinal via código

Você pode conectar sginals via código em vez de usar o editor. Isso é necessário ao criar nodes ou instanciar cenas dentro de um script. Vamos usar um nó diferente aqui. Godot tem um node Timer que é útil para implementar tempos de espera de habilidades, recarga de armas e muito mais.

Volte para o espaço de trabalho 2D. Você pode clicar no texto “2D” na parte superior da janela ou pressionar Ctrl + F1 (Ctrl + Cmd + 1 no macOS). Na aba Scene, clique com o botão direito no nó Sprite2D e adicione um novo nó filho. Procure por Timer e adicione o nó correspondente. Sua cena agora deve ficar assim.

Com o node Timer selecionado, vá até o Inspetor e habilite a propriedade Autostart .

Clique no ícone de script próximo a Sprite2D para voltar ao espaço de trabalho de script.

Precisamos fazer duas operações para conectar os nodes via código:

1. Obtenha uma referência ao Timer do Sprite2D.
2. Chame o connect()método no sinal de “timeout” do Timer.

Observação: Para se conectar a um sinal via código, você precisa chamar o connect() método do sinal que deseja ouvir. Neste caso, queremos ouvir o sinal de “timeout” do Timeout.

Queremos conectar o sinal quando a cena for instanciada, e podemos fazer isso usando a função integrada Node._ready(), que é chamada automaticamente pelo mecanismo quando um nó é totalmente instanciado. Para obter uma referência a um nó relativo ao atual, usamos o método Node.get_node(). Podemos armazenar a referência em uma variável.

func _ready():
	var timer = get_node("Timer")

A função get_node()analisa os filhos do Sprite2D e obtém os nodes por seus nomes. Por exemplo, se você renomeasse o node Timer para “BlinkingTimer” no editor, seria necessário alterar a chamada para get_node("BlinkingTimer"). Agora podemos conectar o Timer ao Sprite2D na função _ready()

func _ready():
	var timer = get_node("Timer")
	timer.timeout.connect(_on_timer_timeout)

A linha é assim: conectamos o sinal de “tempo limite” do Timer ao nó ao qual o script está anexado. Quando o Timer emite timeout, queremos chamar a função _on_timer_timeout() que precisamos definir. Vamos adicioná-lo na parte inferior do nosso script e usá-lo para alternar a visibilidade do nosso sprite.

Observação: Por convenção, nomeamos esses métodos de retorno de chamada em GDScript como “_on_node_name_signal_name” e em C# como “OnNodeNameSignalName”. Aqui, será “_on_timer_timeout” para GDScript e OnTimerTimeout() para C#.

func _on_timer_timeout():
	visible = not visible

A propriedade visible é um booleano que controla a visibilidade do nosso node. A linha visible = not visiblevisible alterna o valor. Se for true, torna-se false e vice-versa. Se você executar a cena agora, verá que o sprite pisca, em intervalos de um segundo.

Script Completo

E com tudo isso, seu código escrito em GDScript deve ficar assim:

extends Sprite2D

var speed = 400
var angular_speed = PI


func _ready():
	var timer = get_node("Timer")
	timer.timeout.connect(_on_timer_timeout)


func _process(delta):
	rotation += angular_speed * delta
	var velocity = Vector2.UP.rotated(rotation) * speed
	position += velocity * delta


func _on_button_pressed():
	set_process(not is_processing())


func _on_timer_timeout():
	visible = not visible

FAQ Rápido

Fale conosco nos comentários e diga oque achou dessa matéria e aproveite para ler mais notícias e matérias, como por exemplo, nosso guia para criar jogos, no nosso site.