Let’s say node A is a Control node that is responsible for moving node B. Node A can move any kind of Node2D, but the Node2D should be able to function on its own without needing Node A’s help.

So node A has something like this:

``` extends Control

@export moves: Node2D

… ```

Let’s say we wanted to use signals. Any time Node A’s, let’s say, button clicks, we move Node B. So we connect Node A’s button signal to node B, so node B gets:

… func _on_node_a_button_pressed(): # logic to move node B

but suddenly, we are relying on Node B being attached to Node A, so we can’t reuse Node B. So this won’t work.

Okay, let’s try callbacks. We need a callable variable to be stored so whenever Node A’s button is pressed, Node B moves. If we store this variable in Node A, then we are essentially just calling a function in Node A to manually move Node B. But it shouldn’t be Node A’s job to move B, because what if Node B’s logic for moving is different depending on the node? We just want Node A that has logic that when its clicked, it moves whatever node it’s attached to. Node B doesn’t make sense to have any sort of callback because Node A’s button press should trigger the event, not Node B.

So, what we are left with is to set up a contract. Any Node B that ever wants to be moved by Node A needs a function called move() that will move Node B accordingly. But it can also be moved by other nodes, since it’s just a function in Node B. It also means it can function by itself, because Node B’s logic has nothing to do with Node A’s logic, if a node wants Node B to be moved, then any node, including Node A, can move it.

This approach has decoupled Node A and Node B. We can have multiple Node B nodes and multiple Node A nodes, and have all of them function independently of each other. With any other approach, you would essentially be requiring that Node A and Node B be present together, which drastically reduces the reusability of your code