Godot: Signals
A blog post about using signals in Godot.
I decided to begin occasionally making text tutorials for Godot as I often find the pickings to be slim when I want to read something instead of watching a Youtube/Odysee video.
Signals are messages that can be sent and any object, node or script can listen to receive these messages and act accordingly within there own script. This is essential for keeping your project organised and is very powerful to have a good understanding of in Godot.
Why should you use signals?
Signals are like a radio tower broadcasting the radio station to any radio tuned to listen for that station, you can set certain nodes to listen for the signal while other nodes will ignore it.
EG: The player has just activated a power up they found in the game world. This power up can use a signal to tell a script to activate it and give say the player a desired effect.
Connecting signals
In Godot there are a couple of ways to connect signals, the easiest of which is to go to the signals tab in the inspector. For this example let's image you have a player scene with an pickup_area2D as a child. We need to connect the Area2D node to the power up object. The way to do this is to go to the signals tab and choose one. In this case let's use area_entered, double click on it and a pop up will appear for us to connect the signal to a script, in this case we will connect it to the player script.
Now if you open up the player script you should be able to see a new function.
func _on__pickup_area_2D_area_entered(area):
pass #Replace with function body
Now you can use the function and put any code you need to happen upon collision with this power up.
Custom Signals
Custom signals in Godot are your own event messages nodes can emit if something happens. They let one part of your game react tp another without needing to entangle different objects/scripts together.
A signal is basically "A thing happened" Godot already gives you built in signals as we saw before but custom signals let you define your own games specific events such as health_depleted or gun fired.
REMEMBER THIS PATTERN AND SIGNALS WILL BE EASY!
- Define the signal in the script it will emit in.
- Emit it when the thing happens
- Connect another script to react to it
Example in GDscript
extends CharacterBody2D
signal died #Define
func take_damage(amount: int) -> void:
health -= amount
if health <= 0:
died.emit #Emit
Then somewhere else:
func _ready() -> void:
Player.died.connect(_on_player_died) #connect
func _on_player_died() -> void:
print("Game Over")
Passing DATA
Custom signals can carry data too. You define parameters in the signal, then pass the values when you are emitting it. For example:
signal health_changed(new_health: int) #Define
func take_damage(amount: int) -> void:
health -= amount
health_changed.emit(health) #Emit
The receiving function must accept the same data:
func _on_health_changed(new_health: int ) -> void:
print ("Health is now :" , new health) #Connect
This could be useful for UI updates, score changes, enemy counts and similar state changes.
Why use them?
Custom signals help keep code modular. The player script does not need to know whether a UI bar, sound effect, spawner, or game_over screen is listening it only announces that something happened. This makes scenes easier to reuse and reduces messy direct references between nodes.
Signals are especially useful when on object needs to notify multiple others, or when you want to avoid hard coding scenes relationships. An example of this is a player emitting died and the UI, Audio system and Level manager all react independently.
I hope this short guide has been helpful in understanding signals in Godot keep and eye out for more posts in the future.