NOTIFICATION_ENTER_TREE:null = 10
Notification received when the node enters a SceneTree. See _enter_tree.
This notification is received before the related tree_entered signal.


NOTIFICATION_EXIT_TREE:null = 11
Notification received when the node is about to exit a SceneTree. See _exit_tree.
This notification is received after the related tree_exiting signal.


NOTIFICATION_MOVED_IN_PARENT:null = 12


NOTIFICATION_READY:null = 13
Notification received when the node is ready. See _ready.


NOTIFICATION_PAUSED:null = 14
Notification received when the node is paused. See process_mode.


NOTIFICATION_UNPAUSED:null = 15
Notification received when the node is unpaused. See process_mode.


NOTIFICATION_PHYSICS_PROCESS:null = 16
Notification received from the tree every physics frame when is_physics_processing returns true. See _physics_process.


NOTIFICATION_PROCESS:null = 17
Notification received from the tree every rendered frame when is_processing returns true. See _process.


NOTIFICATION_PARENTED:null = 18
Notification received when the node is set as a child of another node (see add_child and add_sibling).
Note: This does not mean that the node entered the SceneTree.


NOTIFICATION_UNPARENTED:null = 19
Notification received when the parent node calls remove_child on this node.
Note: This does not mean that the node exited the SceneTree.


NOTIFICATION_SCENE_INSTANTIATED:null = 20
Notification received only by the newly instantiated scene root node, when [method PackedScene.instantiate] is completed.


NOTIFICATION_DRAG_BEGIN:null = 21
Notification received when a drag operation begins. All nodes receive this notification, not only the dragged one.
Can be triggered either by dragging a Control that provides drag data (see [method Control._get_drag_data]) or using [method Control.force_drag].
Use [method Viewport.gui_get_drag_data] to get the dragged data.


NOTIFICATION_DRAG_END:null = 22
Notification received when a drag operation ends.
Use [method Viewport.gui_is_drag_successful] to check if the drag succeeded.


NOTIFICATION_PATH_RENAMED:null = 23
Notification received when the node's name or one of its ancestors' name is changed. This notification is not received when the node is removed from the SceneTree.


NOTIFICATION_CHILD_ORDER_CHANGED:null = 24
Notification received when the list of children is changed. This happens when child nodes are added, moved or removed.


NOTIFICATION_INTERNAL_PROCESS:null = 25
Notification received from the tree every rendered frame when is_processing_internal returns true.


NOTIFICATION_INTERNAL_PHYSICS_PROCESS:null = 26
Notification received from the tree every physics frame when is_physics_processing_internal returns true.


NOTIFICATION_POST_ENTER_TREE:null = 27
Notification received when the node enters the tree, just before NOTIFICATION_READY may be received. Unlike the latter, it is sent every time the node enters tree, not just once.


NOTIFICATION_DISABLED:null = 28
Notification received when the node is disabled. See PROCESS_MODE_DISABLED.


NOTIFICATION_ENABLED:null = 29
Notification received when the node is enabled again after being disabled. See PROCESS_MODE_DISABLED.


NOTIFICATION_RESET_PHYSICS_INTERPOLATION:null = 2001
Notification received when reset_physics_interpolation is called on the node or its ancestors.


NOTIFICATION_EDITOR_PRE_SAVE:null = 9001
Notification received right before the scene with the node is saved in the editor. This notification is only sent in the Godot editor and will not occur in exported projects.


NOTIFICATION_EDITOR_POST_SAVE:null = 9002
Notification received right after the scene with the node is saved in the editor. This notification is only sent in the Godot editor and will not occur in exported projects.


NOTIFICATION_WM_MOUSE_ENTER:null = 1002
Notification received when the mouse enters the window.
Implemented for embedded windows and on desktop and web platforms.


NOTIFICATION_WM_MOUSE_EXIT:null = 1003
Notification received when the mouse leaves the window.
Implemented for embedded windows and on desktop and web platforms.


NOTIFICATION_WM_WINDOW_FOCUS_IN:null = 1004
Notification received from the OS when the node's Window ancestor is focused. This may be a change of focus between two windows of the same engine instance, or from the OS desktop or a third-party application to a window of the game (in which case NOTIFICATION_APPLICATION_FOCUS_IN is also received).
A Window node receives this notification when it is focused.


NOTIFICATION_WM_WINDOW_FOCUS_OUT:null = 1005
Notification received from the OS when the node's Window ancestor is defocused. This may be a change of focus between two windows of the same engine instance, or from a window of the game to the OS desktop or a third-party application (in which case NOTIFICATION_APPLICATION_FOCUS_OUT is also received).
A Window node receives this notification when it is defocused.


NOTIFICATION_WM_CLOSE_REQUEST:null = 1006
Notification received from the OS when a close request is sent (e.g. closing the window with a "Close" button or kbdAlt + F4[/kbd]).
Implemented on desktop platforms.


NOTIFICATION_WM_GO_BACK_REQUEST:null = 1007
Notification received from the OS when a go back request is sent (e.g. pressing the "Back" button on Android).
Implemented only on Android.


NOTIFICATION_WM_SIZE_CHANGED:null = 1008
Notification received when the window is resized.
Note: Only the resized Window node receives this notification, and it's not propagated to the child nodes.


NOTIFICATION_WM_DPI_CHANGE:null = 1009
Notification received from the OS when the screen's dots per inch (DPI) scale is changed. Only implemented on macOS.


NOTIFICATION_VP_MOUSE_ENTER:null = 1010
Notification received when the mouse cursor enters the Viewport's visible area, that is not occluded behind other Controls or Windows, provided its [member Viewport.gui_disable_input] is false and regardless if it's currently focused or not.


NOTIFICATION_VP_MOUSE_EXIT:null = 1011
Notification received when the mouse cursor leaves the Viewport's visible area, that is not occluded behind other Controls or Windows, provided its [member Viewport.gui_disable_input] is false and regardless if it's currently focused or not.


NOTIFICATION_WM_POSITION_CHANGED:null = 1012
Notification received when the window is moved.


NOTIFICATION_OS_MEMORY_WARNING:null = 2009
Notification received from the OS when the application is exceeding its allocated memory.
Implemented only on iOS.


NOTIFICATION_TRANSLATION_CHANGED:null = 2010
Notification received when translations may have changed. Can be triggered by the user changing the locale, changing auto_translate_mode or when the node enters the scene tree. Can be used to respond to language changes, for example to change the UI strings on the fly. Useful when working with the built-in translation support, like [method Object.tr].
Note: This notification is received alongside NOTIFICATION_ENTER_TREE, so if you are instantiating a scene, the child nodes will not be initialized yet. You can use it to setup translations for this node, child nodes created from script, or if you want to access child nodes added in the editor, make sure the node is ready using is_node_ready.
func _notification(what): if what == NOTIFICATION_TRANSLATION_CHANGED: if not is_node_ready(): await ready # Wait until ready signal. $Label.text = atr("%d Bananas") % banana_counter


NOTIFICATION_WM_ABOUT:null = 2011
Notification received from the OS when a request for "About" information is sent.
Implemented only on macOS.


NOTIFICATION_CRASH:null = 2012
Notification received from Godot's crash handler when the engine is about to crash.
Implemented on desktop platforms, if the crash handler is enabled.


NOTIFICATION_OS_IME_UPDATE:null = 2013
Notification received from the OS when an update of the Input Method Engine occurs (e.g. change of IME cursor position or composition string).
Implemented on desktop and web platforms.


NOTIFICATION_APPLICATION_RESUMED:null = 2014
Notification received from the OS when the application is resumed.
Specific to the Android and iOS platforms.


NOTIFICATION_APPLICATION_PAUSED:null = 2015
Notification received from the OS when the application is paused.
Specific to the Android and iOS platforms.
Note: On iOS, you only have approximately 5 seconds to finish a task started by this signal. If you go over this allotment, iOS will kill the app instead of pausing it.


NOTIFICATION_APPLICATION_FOCUS_IN:null = 2016
Notification received from the OS when the application is focused, i.e. when changing the focus from the OS desktop or a thirdparty application to any open window of the Godot instance.
Implemented on desktop and mobile platforms.


NOTIFICATION_APPLICATION_FOCUS_OUT:null = 2017
Notification received from the OS when the application is defocused, i.e. when changing the focus from any open window of the Godot instance to the OS desktop or a thirdparty application.
Implemented on desktop and mobile platforms.


NOTIFICATION_TEXT_SERVER_CHANGED:null = 2018
Notification received when the TextServer is changed.


NOTIFICATION_ACCESSIBILITY_UPDATE:null = 3000
Notification received when an accessibility information update is required.


NOTIFICATION_ACCESSIBILITY_INVALIDATE:null = 3001
Notification received when accessibility elements are invalidated. All node accessibility elements are automatically deleted after receiving this message, therefore all existing references to such elements should be discarded.

PROCESS_MODE_INHERIT:null = 0
Inherits process_mode from the node's parent. This is the default for any newly created node.


PROCESS_MODE_PAUSABLE:null = 1
Stops processing when [member SceneTree.paused] is true. This is the inverse of PROCESS_MODE_WHEN_PAUSED, and the default for the root node.


PROCESS_MODE_WHEN_PAUSED:null = 2
Process only when [member SceneTree.paused] is true. This is the inverse of PROCESS_MODE_PAUSABLE.


PROCESS_MODE_ALWAYS:null = 3
Always process. Keeps processing, ignoring [member SceneTree.paused]. This is the inverse of PROCESS_MODE_DISABLED.


PROCESS_MODE_DISABLED:null = 4
Never process. Completely disables processing, ignoring [member SceneTree.paused]. This is the inverse of PROCESS_MODE_ALWAYS.

PROCESS_THREAD_GROUP_INHERIT:null = 0
Process this node based on the thread group mode of the first parent (or grandparent) node that has a thread group mode that is not inherit. See process_thread_group for more information.


PROCESS_THREAD_GROUP_MAIN_THREAD:null = 1
Process this node (and child nodes set to inherit) on the main thread. See process_thread_group for more information.


PROCESS_THREAD_GROUP_SUB_THREAD:null = 2
Process this node (and child nodes set to inherit) on a sub-thread. See process_thread_group for more information.

FLAG_PROCESS_THREAD_MESSAGES:null = 1
Allows this node to process threaded messages created with call_deferred_thread_group right before _process is called.


FLAG_PROCESS_THREAD_MESSAGES_PHYSICS:null = 2
Allows this node to process threaded messages created with call_deferred_thread_group right before _physics_process is called.


FLAG_PROCESS_THREAD_MESSAGES_ALL:null = 3
Allows this node to process threaded messages created with call_deferred_thread_group right before either _process or _physics_process are called.

PHYSICS_INTERPOLATION_MODE_INHERIT:null = 0
Inherits physics_interpolation_mode from the node's parent. This is the default for any newly created node.


PHYSICS_INTERPOLATION_MODE_ON:null = 1
Enables physics interpolation for this node and for children set to PHYSICS_INTERPOLATION_MODE_INHERIT. This is the default for the root node.


PHYSICS_INTERPOLATION_MODE_OFF:null = 2
Disables physics interpolation for this node and for children set to PHYSICS_INTERPOLATION_MODE_INHERIT.

DUPLICATE_SIGNALS:null = 1
Duplicate the node's signal connections that are connected with the [constant Object.CONNECT_PERSIST] flag.


DUPLICATE_GROUPS:null = 2
Duplicate the node's groups.


DUPLICATE_SCRIPTS:null = 4
Duplicate the node's script (also overriding the duplicated children's scripts, if combined with DUPLICATE_USE_INSTANTIATION).


DUPLICATE_USE_INSTANTIATION:null = 8
Duplicate using [method PackedScene.instantiate]. If the node comes from a scene saved on disk, reuses [method PackedScene.instantiate] as the base for the duplicated node and its children.

INTERNAL_MODE_DISABLED:null = 0
The node will not be internal.


INTERNAL_MODE_FRONT:null = 1
The node will be placed at the beginning of the parent's children, before any non-internal sibling.


INTERNAL_MODE_BACK:null = 2
The node will be placed at the end of the parent's children, after any non-internal sibling.

AUTO_TRANSLATE_MODE_INHERIT:null = 0
Inherits auto_translate_mode from the node's parent. This is the default for any newly created node.


AUTO_TRANSLATE_MODE_ALWAYS:null = 1
Always automatically translate. This is the inverse of AUTO_TRANSLATE_MODE_DISABLED, and the default for the root node.


AUTO_TRANSLATE_MODE_DISABLED:null = 2
Never automatically translate. This is the inverse of AUTO_TRANSLATE_MODE_ALWAYS.
String parsing for POT generation will be skipped for this node and children that are set to AUTO_TRANSLATE_MODE_INHERIT.

This signal is emitted after the child node's own NOTIFICATION_ENTER_TREE and tree_entered.

When this signal is received, the child node is still accessible inside the tree. This signal is emitted after the child node's own tree_exiting and NOTIFICATION_EXIT_TREE.

This signal is emitted after node has been added as a child of the original parent node, but before all original child nodes have been reparented to node.

This signal is emitted after the related NOTIFICATION_ENTER_TREE notification.

This signal is emitted after the related NOTIFICATION_EXIT_TREE notification.

This signal is emitted after the node's _exit_tree, and before the related NOTIFICATION_EXIT_TREE.

Note: For the root node, auto translate mode can also be set via [member ProjectSettings.internationalization/rendering/root_node_auto_translate].

Note: Renaming the node, or moving it in the tree, will not move the MultiplayerAPI to the new path, you will have to update this manually.

Note: When changing the name, the following characters will be replaced with an underscore: (. : @ / " %). In particular, the @ character is reserved for auto-generated names. See also [method String.validate_node_name].

Note: In the editor, nodes not owned by the scene root are usually not displayed in the Scene dock, and will not be saved. To prevent this, remember to set the owner after calling add_child.

By default, nodes inherit the physics interpolation mode from their parent. This property can enable or disable physics interpolation individually for each node, regardless of their parents' physics interpolation mode.
Note: Some node types like VehicleWheel3D have physics interpolation disabled by default, as they rely on their own custom solution.
Note: When teleporting a node to a distant position, it's recommended to temporarily disable interpolation with [method Node.reset_physics_interpolation] after moving the node. This avoids creating a visual streak between the old and new positions.

By default, the thread group is PROCESS_THREAD_GROUP_INHERIT, which means that this node belongs to the same thread group as the parent node. The thread groups means that nodes in a specific thread group will process together, separate to other thread groups (depending on process_thread_group_order). If the value is set is PROCESS_THREAD_GROUP_SUB_THREAD, this thread group will occur on a sub thread (not the main thread), otherwise if set to PROCESS_THREAD_GROUP_MAIN_THREAD it will process on the main thread. If there is not a parent or grandparent node set to something other than inherit, the node will belong to the default thread group. This default group will process on the main thread and its group order is 0.
During processing in a sub-thread, accessing most functions in nodes outside the thread group is forbidden (and it will result in an error in debug mode). Use [method Object.call_deferred], call_thread_safe, call_deferred_thread_group and the likes in order to communicate from the thread groups to the main thread (or to other thread groups).
To better understand process thread groups, the idea is that any node set to any other value than PROCESS_THREAD_GROUP_INHERIT will include any child (and grandchild) nodes set to inherit into its process thread group. This means that the processing of all the nodes in the group will happen together, at the same time as the node including them.

Note: If another node with the same owner shares the same name as this node, the other node will no longer be accessible as unique.

Corresponds to the NOTIFICATION_ENTER_TREE notification in [method Object._notification].

Corresponds to the NOTIFICATION_EXIT_TREE notification in [method Object._notification] and signal tree_exiting. To get notified when the node has already left the active tree, connect to the tree_exited.

Returning an empty array produces no warnings.

Returning an empty array produces no warnings.
Call update_configuration_warnings when the warnings need to be updated for this node.
@export var energy = 0: set(value): energy = value update_configuration_warnings() func _get_configuration_warnings(): if energy < 0: return ["Energy must be 0 or greater."] else: return []

It is only called if input processing is enabled, which is done automatically if this method is overridden, and can be toggled with set_process_input.
To consume the input event and stop it propagating further to other nodes, [method Viewport.set_input_as_handled] can be called.
For gameplay input, _unhandled_input and _unhandled_key_input are usually a better fit as they allow the GUI to intercept the events first.
Note: This method is only called if the node is present in the scene tree (i.e. if it's not an orphan).

It is only called if physics processing is enabled for this Node, which is done automatically if this method is overridden, and can be toggled with set_physics_process.
Processing happens in order of process_physics_priority, lower priority values are called first. Nodes with the same priority are processed in tree order, or top to bottom as seen in the editor (also known as pre-order traversal).
Corresponds to the NOTIFICATION_PHYSICS_PROCESS notification in [method Object._notification].
Note: This method is only called if the node is present in the scene tree (i.e. if it's not an orphan).
Note: Accumulated delta may diverge from real world seconds.

It is only called if processing is enabled for this Node, which is done automatically if this method is overridden, and can be toggled with set_process.
Processing happens in order of process_priority, lower priority values are called first. Nodes with the same priority are processed in tree order, or top to bottom as seen in the editor (also known as pre-order traversal).
Corresponds to the NOTIFICATION_PROCESS notification in [method Object._notification].
Note: This method is only called if the node is present in the scene tree (i.e. if it's not an orphan).
Note: When the engine is struggling and the frame rate is lowered, delta will increase. When delta is increased, it's capped at a maximum of [member Engine.time_scale] * [member Engine.max_physics_steps_per_frame] / [member Engine.physics_ticks_per_second]. As a result, accumulated delta may not represent real world time.
Note: When --fixed-fps is enabled or the engine is running in Movie Maker mode (see MovieWriter), process delta will always be the same for every frame, regardless of how much time the frame took to render.
Note: Frame delta may be post-processed by [member OS.delta_smoothing] if this is enabled for the project.

Corresponds to the NOTIFICATION_READY notification in [method Object._notification]. See also the @onready annotation for variables.
Usually used for initialization. For even earlier initialization, [method Object._init] may be used. See also _enter_tree.
Note: This method may be called only once for each node. After removing a node from the scene tree and adding it again, _ready will not be called a second time. This can be bypassed by requesting another call with request_ready, which may be called anywhere before adding the node again.

It is only called if shortcut processing is enabled, which is done automatically if this method is overridden, and can be toggled with set_process_shortcut_input.
To consume the input event and stop it propagating further to other nodes, [method Viewport.set_input_as_handled] can be called.
This method can be used to handle shortcuts. For generic GUI events, use _input instead. Gameplay events should usually be handled with either _unhandled_input or _unhandled_key_input.
Note: This method is only called if the node is present in the scene tree (i.e. if it's not orphan).

It is only called if unhandled input processing is enabled, which is done automatically if this method is overridden, and can be toggled with set_process_unhandled_input.
To consume the input event and stop it propagating further to other nodes, [method Viewport.set_input_as_handled] can be called.
For gameplay input, this method is usually a better fit than _input, as GUI events need a higher priority. For keyboard shortcuts, consider using _shortcut_input instead, as it is called before this method. Finally, to handle keyboard events, consider using _unhandled_key_input for performance reasons.
Note: This method is only called if the node is present in the scene tree (i.e. if it's not an orphan).

It is only called if unhandled key input processing is enabled, which is done automatically if this method is overridden, and can be toggled with set_process_unhandled_key_input.
To consume the input event and stop it propagating further to other nodes, [method Viewport.set_input_as_handled] can be called.
This method can be used to handle Unicode character input with kbdAlt[/kbd], kbdAlt + Ctrl[/kbd], and kbdAlt + Shift[/kbd] modifiers, after shortcuts were handled.
For gameplay input, this and _unhandled_input are usually a better fit than _input, as GUI events should be handled first. This method also performs better than _unhandled_input, since unrelated events such as InputEventMouseMotion are automatically filtered. For shortcuts, consider using _shortcut_input instead.
Note: This method is only called if the node is present in the scene tree (i.e. if it's not an orphan).

If force_readable_name is true, improves the readability of the added node. If not named, the node is renamed to its type, and if it shares name with a sibling, a number is suffixed more appropriately. This operation is very slow. As such, it is recommended leaving this to false, which assigns a dummy name featuring @ in both situations.
If internal is different than INTERNAL_MODE_DISABLED, the child will be added as internal node. These nodes are ignored by methods like get_children, unless their parameter include_internal is true. It also prevents these nodes being duplicated with their parent. The intended usage is to hide the internal nodes from the user, so the user won't accidentally delete or modify them. Used by some GUI nodes, e.g. ColorPicker.
Note: If node already has a parent, this method will fail. Use remove_child first to remove node from its current parent. For example:

var child_node = get_child(0) if child_node.get_parent(): child_node.get_parent().remove_child(child_node) add_child(child_node)

Node childNode = GetChild(0); if (childNode.GetParent() != null) { childNode.GetParent().RemoveChild(childNode); } AddChild(childNode);

If you need the child node to be added below a specific node in the list of children, use add_sibling instead of this method.
Note: If you want a child to be persisted to a PackedScene, you must set owner in addition to calling add_child. This is typically relevant for [url=$DOCS_URL/tutorials/plugins/running_code_in_the_editor.html]tool scripts[/url] and [url=$DOCS_URL/tutorials/plugins/editor/index.html]editor plugins[/url]. If add_child is called without setting owner, the newly added Node will not be visible in the scene tree, though it will be visible in the 2D/3D view.

If force_readable_name is true, improves the readability of the added sibling. If not named, the sibling is renamed to its type, and if it shares name with a sibling, a number is suffixed more appropriately. This operation is very slow. As such, it is recommended leaving this to false, which assigns a dummy name featuring @ in both situations.
Use add_child instead of this method if you don't need the child node to be added below a specific node in the list of children.
Note: If this node is internal, the added sibling will be internal too (see add_child's internal parameter).

If persistent is true, the group will be stored when saved inside a PackedScene. All groups created and displayed in the Node dock are persistent.
Note: To improve performance, the order of group names is not guaranteed and may vary between project runs. Therefore, do not rely on the group order.
Note: SceneTree's group methods will not work on this node if not inside the tree (see is_inside_tree).

This method works the same as [method Object.tr], with the addition of respecting the auto_translate_mode state.
If [method Object.can_translate_messages] is false, or no translation is available, this method returns the message without changes. See [method Object.set_message_translation].
For detailed examples, see [url=$DOCS_URL/tutorials/i18n/internationalizing_games.html]Internationalizing games[/url].

This method works the same as [method Object.tr_n], with the addition of respecting the auto_translate_mode state.
If [method Object.can_translate_messages] is false, or no translation is available, this method returns message or plural_message, without changes. See [method Object.set_message_translation].
The n is the number, or amount, of the message's subject. It is used by the translation system to fetch the correct plural form for the current language.
For detailed examples, see [url=$DOCS_URL/tutorials/i18n/localization_using_gettext.html]Localization using gettext[/url].
Note: Negative and float numbers may not properly apply to some countable subjects. It's recommended to handle these cases with atr.

- If set to PROCESS_MODE_PAUSABLE, returns true when the game is processing, i.e. [member SceneTree.paused] is false;
- If set to PROCESS_MODE_WHEN_PAUSED, returns true when the game is paused, i.e. [member SceneTree.paused] is true;
- If set to PROCESS_MODE_ALWAYS, always returns true;
- If set to PROCESS_MODE_DISABLED, always returns false;
- If set to PROCESS_MODE_INHERIT, use the parent node's process_mode to determine the result.
If the node is not inside the tree, returns false no matter the value of process_mode.

This is the equivalent of doing:

get_tree().create_tween().bind_node(self)

GetTree().CreateTween().BindNode(this);

The Tween will start automatically on the next process frame or physics frame (depending on [enum Tween.TweenProcessMode]). See [method Tween.bind_node] for more info on Tweens bound to nodes.
Note: The method can still be used when the node is not inside SceneTree. It can fail in an unlikely case of using a custom MainLoop.

Note: For nodes with a Script attached, if [method Object._init] has been defined with required parameters, the duplicated node will not have a Script.

If recursive is false, only this node's direct children are checked. Nodes are checked in tree order, so this node's first direct child is checked first, then its own direct children, etc., before moving to the second direct child, and so on. Internal children are also included in the search (see internal parameter in add_child).
If owned is true, only descendants with a valid owner node are checked.
Note: This method can be very slow. Consider storing a reference to the found node in a variable. Alternatively, use get_node with unique names (see unique_name_in_owner).
Note: To find all descendant nodes matching a pattern or a class type, see find_children.

If type is not empty, only ancestors inheriting from type are included (see [method Object.is_class]).
If recursive is false, only this node's direct children are checked. Nodes are checked in tree order, so this node's first direct child is checked first, then its own direct children, etc., before moving to the second direct child, and so on. Internal children are also included in the search (see internal parameter in add_child).
If owned is true, only descendants with a valid owner node are checked.
Note: This method can be very slow. Consider storing references to the found nodes in a variable.
Note: To find a single descendant node matching a pattern, see find_child.

Note: As this method walks upwards in the scene tree, it can be slow in large, deeply nested nodes. Consider storing a reference to the found node in a variable. Alternatively, use get_node with unique names (see unique_name_in_owner).

Note: This method should be called only during accessibility information updates (NOTIFICATION_ACCESSIBILITY_UPDATE).

If include_internal is false, internal children are ignored (see add_child's internal parameter).
# Assuming the following are children of this node, in order: # First, Middle, Last. var a = get_child(0).name # a is "First" var b = get_child(1).name # b is "Middle" var b = get_child(2).name # b is "Last" var c = get_child(-1).name # c is "Last"
Note: To fetch a node by NodePath, use get_node.

If include_internal is false, internal children are not counted (see add_child's internal parameter).

If include_internal is false, excludes internal children from the returned array (see add_child's internal parameter).

Note: To improve performance, the order of group names is not guaranteed and may vary between project runs. Therefore, do not rely on the group order.
Note: This method may also return some group names starting with an underscore (_). These are internally used by the engine. To avoid conflicts, do not use custom groups starting with underscores. To exclude internal groups, see the following code snippet:

# Stores the node's non-internal groups only (as an array of StringNames). var non_internal_groups = [] for group in get_groups(): if not str(group).begins_with("_"): non_internal_groups.push_back(group)

// Stores the node's non-internal groups only (as a List of StringNames). List<string> nonInternalGroups = new List<string>(); foreach (string group in GetGroups()) { if (!group.BeginsWith("_")) nonInternalGroups.Add(group); }

If include_internal is false, returns the index ignoring internal children. The first, non-internal child will have an index of 0 (see add_child's internal parameter).

Note: Fetching by absolute path only works when the node is inside the scene tree (see is_inside_tree).
Example: Assume this method is called from the Character node, inside the following tree:
[codeblock lang=text]
┖╴root
┠╴Character (you are here!)
┃ ┠╴Sword
┃ ┖╴Backpack
┃ ┖╴Dagger
┠╴MyGame
┖╴Swamp
┠╴Alligator
┠╴Mosquito
┖╴Goblin
[/codeblock]
The following calls will return a valid node:

get_node("Sword") get_node("Backpack/Dagger") get_node("../Swamp/Alligator") get_node("/root/MyGame")

GetNode("Sword"); GetNode("Backpack/Dagger"); GetNode("../Swamp/Alligator"); GetNode("/root/MyGame");

- Element 0 is the Node, or null if not found;
- Element 1 is the subname's last nested Resource, or null if not found;
- Element 2 is the remaining NodePath, referring to an existing, non-Resource property (see [method Object.get_indexed]).
Example: Assume that the child's [member Sprite2D.texture] has been assigned an AtlasTexture:

var a = get_node_and_resource("Area2D/Sprite2D") print(a[0].name) # Prints Sprite2D print(a[1]) # Prints <null> print(a[2]) # Prints ^"" var b = get_node_and_resource("Area2D/Sprite2D:texture:atlas") print(b[0].name) # Prints Sprite2D print(b[1].get_class()) # Prints AtlasTexture print(b[2]) # Prints ^"" var c = get_node_and_resource("Area2D/Sprite2D:texture:atlas:region") print(c[0].name) # Prints Sprite2D print(c[1].get_class()) # Prints AtlasTexture print(c[2]) # Prints ^":region"

var a = GetNodeAndResource(NodePath("Area2D/Sprite2D")); GD.Print(a[0].Name); // Prints Sprite2D GD.Print(a[1]); // Prints <null> GD.Print(a[2]); // Prints ^" var b = GetNodeAndResource(NodePath("Area2D/Sprite2D:texture:atlas")); GD.Print(b[0].name); // Prints Sprite2D GD.Print(b[1].get_class()); // Prints AtlasTexture GD.Print(b[2]); // Prints ^"" var c = GetNodeAndResource(NodePath("Area2D/Sprite2D:texture:atlas:region")); GD.Print(c[0].name); // Prints Sprite2D GD.Print(c[1].get_class()); // Prints AtlasTexture GD.Print(c[2]); // Prints ^":region"

Note: This method only returns the RPC configuration assigned via rpc_config. See [method Script.get_rpc_config] to retrieve the RPCs defined by the Script.

Note: get_orphan_node_ids only works in debug builds. When called in a project exported in release mode, get_orphan_node_ids will return an empty array.

If use_unique_path is true, returns the shortest path accounting for this node's unique name (see unique_name_in_owner).
Note: If you get a relative path which starts from a unique node, the path may be longer than a normal relative path, due to the addition of the unique node's name.

Note: The returned value will be larger than expected if running at a framerate lower than [member Engine.physics_ticks_per_second] / [member Engine.max_physics_steps_per_frame] FPS. This is done to avoid "spiral of death" scenarios where performance would plummet due to an ever-increasing number of physics steps per frame. This behavior affects both _process and _physics_process. As a result, avoid using delta for time measurements in real-world seconds. Use the Time singleton's methods for this purpose instead, such as [method Time.get_ticks_usec].

Note: The returned value will be larger than expected if running at a framerate lower than [member Engine.physics_ticks_per_second] / [member Engine.max_physics_steps_per_frame] FPS. This is done to avoid "spiral of death" scenarios where performance would plummet due to an ever-increasing number of physics steps per frame. This behavior affects both _process and _physics_process. As a result, avoid using delta for time measurements in real-world seconds. Use the Time singleton's methods for this purpose instead, such as [method Time.get_ticks_usec].

May print, for example:
[codeblock lang=text]
TheGame
TheGame/Menu
TheGame/Menu/Label
TheGame/Menu/Camera2D
TheGame/SplashScreen
TheGame/SplashScreen/Camera2D
[/codeblock]

May print, for example:
[codeblock lang=text]
┖╴TheGame
┠╴Menu
┃ ┠╴Label
┃ ┖╴Camera2D
┖╴SplashScreen
┖╴Camera2D
[/codeblock]

request_ready resets it back to false.

Note: Interpolation will only be active if both the flag is set and physics interpolation is enabled within the SceneTree. This can be tested using is_physics_interpolated_and_enabled.

This is a convenience version of is_physics_interpolated that also checks whether physics interpolation is enabled globally.
See [member SceneTree.physics_interpolation] and [member ProjectSettings.physics/common/physics_interpolation].

Note: The processing order of several engine callbacks (_ready, _process, etc.) and notifications sent through propagate_notification is affected by tree order. CanvasItem nodes are also rendered in tree order. See also process_priority.

Note: This method only works in debug builds. Does nothing in a project exported in release mode.

May print, for example:
[codeblock lang=text]
.
Menu
Menu/Label
Menu/Camera2D
SplashScreen
SplashScreen/Camera2D
[/codeblock]

May print, for example:
[codeblock lang=text]
┖╴TheGame
┠╴Menu
┃ ┠╴Label
┃ ┖╴Camera2D
┖╴SplashScreen
┖╴Camera2D
[/codeblock]

If parent_first is true, the method is called on this node first, then on all of its children. If false, the children's methods are called first.

Unlike with [method Object.free], the node is not deleted instantly, and it can still be accessed before deletion. It is also safe to call queue_free multiple times. Use [method Object.is_queued_for_deletion] to check if the node will be deleted at the end of the frame.
Note: The node will only be freed after all other deferred calls are finished. Using this method is not always the same as calling [method Object.free] through [method Object.call_deferred].

Note: When this node is inside the tree, this method sets the owner of the removed node (or its descendants) to null, if their owner is no longer an ancestor (see is_ancestor_of).

If keep_global_transform is true, the node's global transform will be preserved if supported. Node2D, Node3D and Control support this argument (but Control keeps only position).

If keep_groups is true, the node is added to the same groups that the replaced node is in (see add_to_group).
Warning: The replaced node is removed from the tree, but it is not deleted. To prevent memory leaks, store a reference to the node in a variable, or use [method Object.free].

Note: This method only affects the current node. If the node's children also need to request ready, this method needs to be called for each one of them. When the node and its children enter the tree again, the order of _ready callbacks will be the same as normal.

That glitch can be prevented by calling this method, which temporarily disables interpolation until the physics tick is complete.
The notification NOTIFICATION_RESET_PHYSICS_INTERPOLATION will be received by the node and all children recursively.
Note: This function should be called after moving the node, rather than before.

May return OK if the call is successful, ERR_INVALID_PARAMETER if the arguments passed in the method do not match, ERR_UNCONFIGURED if the node's multiplayer cannot be fetched (such as when the node is not inside the tree), ERR_CONNECTION_ERROR if multiplayer's connection is not available.
Note: You can only safely use RPCs on clients after you received the [signal MultiplayerAPI.connected_to_server] signal from the MultiplayerAPI. You also need to keep track of the connection state, either by the MultiplayerAPI signals like [signal MultiplayerAPI.server_disconnected] or by checking (get_multiplayer().peer.get_connection_status() == CONNECTION_CONNECTED).

- rpc_mode: see [enum MultiplayerAPI.RPCMode];
- transfer_mode: see [enum MultiplayerPeer.TransferMode];
- call_local: if true, the method will also be called locally;
- channel: an int representing the channel to send the RPC on.
Note: In GDScript, this method corresponds to the [annotation @GDScript.@rpc] annotation, with various parameters passed (@rpc(any), @rpc(authority)...). See also the [url=$DOCS_URL/tutorials/networking/high_level_multiplayer.html]high-level multiplayer[/url] tutorial.

May return OK if the call is successful, ERR_INVALID_PARAMETER if the arguments passed in the method do not match, ERR_UNCONFIGURED if the node's multiplayer cannot be fetched (such as when the node is not inside the tree), ERR_CONNECTION_ERROR if multiplayer's connection is not available.

If recursive is true, the given peer is recursively set as the authority for all children of this node.
Warning: This does not automatically replicate the new authority to other peers. It is the developer's responsibility to do so. You may replicate the new authority's information using [member MultiplayerSpawner.spawn_function], an RPC, or a MultiplayerSynchronizer. Furthermore, the parent's authority does not propagate to newly added children.

Note: If _physics_process is overridden, this will be automatically enabled before _ready is called.

Warning: Built-in nodes rely on internal processing for their internal logic. Disabling it is unsafe and may lead to unexpected behavior. Use this method if you know what you are doing.

Note: If _process is overridden, this will be automatically enabled before _ready is called.
Note: This method only affects the _process callback, i.e. it has no effect on other callbacks like _physics_process. If you want to disable all processing for the node, set process_mode to PROCESS_MODE_DISABLED.

Note: If _input is overridden, this will be automatically enabled before _ready is called. Input processing is also already enabled for GUI controls, such as Button and TextEdit.

Warning: Built-in nodes rely on internal processing for their internal logic. Disabling it is unsafe and may lead to unexpected behavior. Use this method if you know what you are doing.

Note: If _shortcut_input is overridden, this will be automatically enabled before _ready is called.

Note: If _unhandled_input is overridden, this will be automatically enabled before _ready is called. Unhandled input processing is also already enabled for GUI controls, such as Button and TextEdit.

Note: If _unhandled_key_input is overridden, this will be automatically enabled before _ready is called.

This is the default behavior for all nodes. Calling [method Object.set_translation_domain] disables this behavior.