How to pass arguments from _init() to _ready()?

Question

I'm trying to implement a component architecture for scripts for my project. I'd like for each scene to have just one script at its root that creates each script (behavior) and passes the necessary node paths (resources). Example:

# scene_specific_script.gd
extends Node

export(NodePath) var resource_node_path

func _ready():
    add_child(load('res://generic_behavior_script.gd').new(resource_node_path))

The behavior script then has access to whatever resource nodes it needs; agnostic of the scene's structure:

# generic_behavior_script.gd
extends Node

var resource_node

func _init(resource_node_path):
    resource_node = get_node(resource_node_path)

# Perform operations using resource_node

The issue is that get_node() must be called after the node has entered the tree, as in, from_ready() and not _init(). So, how do I resolve this while still being able to pass arguments through new()? I know I could just store the path in a class variable, but I'd rather not have this kind of temporary value cluttering the namespace. Alternatively, is there a better approach to reusing generic behavior scripts?

Answer 1

You can do everything on _ready or _enter_tree, the architecture sounds a bit strange if a node needs to access the tree when is outside of it.

There are many other ways to do that like using groups or a specific autoloaded script or scene that takes care of organizing and giving a list of required resources to new nodes as they enter the tree (using notifications, signals).

ps: there is no class/static variables in Godot, only methods.

Comments

Well no, the node is expected to access the tree once it has entered. The question is how to wait until that time to call get_node(). I could create an autoloaded script that holds a list to resources, but that seems messy, and defeats the organization of the tree and self-contained scenes.

I guess I meant instance variables.

---

A manager looks messy on the usual way (real singletons) but on Godot are just scenes with special behaviour and location on the tree, you can have many for different uses, like managing connections, pauses, saves and other top level stuff, if well organized (with groups, notifications, etc.), the self-contained approach should not be affected by those utility scenes, on the contrary, that will prevent it because depending on external nodes breaks that containment directly.

---

The time to call get_node is from _enter_tree and until _exit_tree, on _ready the Node/scene should be fully initialized in the tree so is usually safe to use it there (normally there is no need to process nodes before ready).

If you want to postpone the call (you may need a node that is not -yet - on the tree), call_deferred should help, to assign to a variable do call_deferred on a function that process the initialization part that depends on the get_node (maybe with hasnode>getnode and call deferred again if fail).

---

Adding all to a group and letting something else notify all of them for a special set-up (notify_group/call_group) may be cleaner IMHO.

More or less like the answer of avencherus.

---

Ah, I guess I didn't realize autoload could be used on an entire scene. That's helpful, thank you!