Node

func (*Extension[T]) AsNode ¶

func (self *Extension[T]) AsNode() Instance

func (*Extension[T]) AsObject ¶

func (self *Extension[T]) AsObject() [1]gd.Object

func (ID) Instance ¶

func (id ID) Instance() (Instance, bool)

func (Instance) AddChild ¶

func (self Instance) AddChild(node Instance)

Adds a child 'node'. Nodes can have any number of children, but every child must have a unique name. Child nodes are automatically deleted when the parent node is deleted, so an entire scene can be removed by deleting its topmost node.

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 InternalModeDisabled, the child will be added as internal node. These nodes are ignored by methods like GetChildren, 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 RemoveChild first to remove 'node' from its current parent. For example:

var childNode = node.GetChild(0)
if childNode.GetParent() != Node.Nil {
	childNode.GetParent().RemoveChild(childNode)
}
node.AddChild(childNode)

If you need the child node to be added below a specific node in the list of children, use AddSibling instead of this method.

Note: If you want a child to be persisted to a PackedScene, you must set Owner in addition to calling AddChild. This is typically relevant for tool scripts and editor plugins. If AddChild 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.

func (Instance) AddSibling ¶

func (self Instance) AddSibling(sibling Instance)

Adds a 'sibling' node to this node's parent, and moves the added sibling right below this node.

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 AddChild 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 AddChild's internal parameter).

func (Instance) AddToGroup ¶

func (self Instance) AddToGroup(group string)

Adds the node to the 'group'. Groups can be helpful to organize a subset of nodes, for example "enemies" or "collectables". See notes in the description, and the group methods in SceneTree.

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 IsInsideTree).

func (Instance) AsNode ¶

func (self Instance) AsNode() Instance

func (Instance) AsObject ¶

func (self Instance) AsObject() [1]gd.Object

func (Instance) Atr ¶

func (self Instance) Atr(message string) string

Translates a 'message', using the translation catalogs configured in the Project Settings. Further 'context' can be specified to help with the translation. Note that most Control nodes automatically translate their strings, so this method is mostly useful for formatted strings or custom drawn text.

This method works the same as Object.Tr, with the addition of respecting the AutoTranslateMode state.

If Object.CanTranslateMessages is false, or no translation is available, this method returns the 'message' without changes. See Object.SetMessageTranslation.

For detailed examples, see Internationalizing games.

func (Instance) AtrN ¶

func (self Instance) AtrN(message string, plural_message string, n int) string

Translates a 'message' or 'plural_message', using the translation catalogs configured in the Project Settings. Further 'context' can be specified to help with the translation.

This method works the same as Object.TrN, with the addition of respecting the AutoTranslateMode state.

If Object.CanTranslateMessages is false, or no translation is available, this method returns 'message' or 'plural_message', without changes. See Object.SetMessageTranslation.

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 Localization using gettext.

Note: Negative and Float.X numbers may not properly apply to some countable subjects. It's recommended to handle these cases with Atr.

func (Instance) AutoTranslateMode ¶

func (self Instance) AutoTranslateMode() AutoTranslateMode

Defines if any text should automatically change to its translated version depending on the current locale (for nodes such as Label, RichTextLabel, Window, etc.). Also decides if the node's strings should be parsed for POT generation.

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

func (Instance) BindToTween ¶

func (self Instance) BindToTween(peer Tween.Instance) Tween.Instance

Binds this [Tween] with the given [param node]. [Tween]s are processed directly by the [SceneTree], so they run independently of the animated nodes. When you bind a [Node] with the [Tween], the [Tween] will halt the animation when the object is not inside tree and the [Tween] will be automatically killed when the bound object is freed. Also [constant TWEEN_PAUSE_BOUND] will make the pausing behavior dependent on the bound node. For a shorter way to create and bind a [Tween], you can use [method Node.create_tween].

func (Instance) CallDeferredThreadGroup ¶

func (self Instance) CallDeferredThreadGroup(method string, args ...any) any

This function is similar to Object.CallDeferred except that the call will take place when the node thread group is processed. If the node thread group processes in sub-threads, then the call will be done on that thread, right before NotificationProcess or NotificationPhysicsProcess, the Process or PhysicsProcess or their internal versions are called.

func (Instance) CallThreadSafe ¶

func (self Instance) CallThreadSafe(method string, args ...any) any

This function ensures that the calling of this function will succeed, no matter whether it's being done from a thread or not. If called from a thread that is not allowed to call the function, the call will become deferred. Otherwise, the call will go through directly.

func (Instance) CanAutoTranslate ¶

func (self Instance) CanAutoTranslate() bool

Returns true if this node can automatically translate messages depending on the current locale. See AutoTranslateMode, Atr, and AtrN.

func (Instance) CanProcess ¶

func (self Instance) CanProcess() bool

Returns true if the node can receive processing notifications and input callbacks (NotificationProcess, Input, etc.) from the SceneTree and Viewport. The returned value depends on ProcessMode:

- If set to ProcessModePausable, returns true when the game is processing, i.e. SceneTree.Paused is false;

- If set to ProcessModeWhenPaused, returns true when the game is paused, i.e. SceneTree.Paused is true;

- If set to ProcessModeAlways, always returns true;

- If set to ProcessModeDisabled, always returns false;

- If set to ProcessModeInherit, use the parent node's ProcessMode to determine the result.

If the node is not inside the tree, returns false no matter the value of ProcessMode.

func (Instance) CreateTween ¶

func (self Instance) CreateTween() Tween.Instance

Creates a new Tween and binds it to this node.

This is the equivalent of doing:

node.BindToTween(SceneTree.Get(node).CreateTween())

The Tween will start automatically on the next process frame or physics frame (depending on [Tween.TweenProcessMode]). See Tween.BindNode 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.

func (Instance) Duplicate ¶

func (self Instance) Duplicate() Instance

Duplicates the node, returning a new node with all of its properties, signals, groups, and children copied from the original. The behavior can be tweaked through the 'flags' (see DuplicateFlags). Internal nodes are not duplicated.

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

func (Instance) EditorDescription ¶

func (self Instance) EditorDescription() string

An optional description to the node. It will be displayed as a tooltip when hovering over the node in the editor's Scene dock.

func (Instance) FindChild ¶

func (self Instance) FindChild(pattern string) Instance

Finds the first descendant of this node whose Name matches 'pattern', returning null if no match is found. The matching is done against node names, not their paths, through String.Match. As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character.

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 AddChild).

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 GetNode with unique names (see UniqueNameInOwner).

Note: To find all descendant nodes matching a pattern or a class type, see FindChildren.

func (Instance) FindChildren ¶

func (self Instance) FindChildren(pattern string) []Instance

Finds all descendants of this node whose names match 'pattern', returning an empty slice if no match is found. The matching is done against node names, not their paths, through String.Match. As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character.

If 'type' is not empty, only ancestors inheriting from 'type' are included (see Object.IsClass).

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 AddChild).

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 FindChild.

func (Instance) FindParent ¶

func (self Instance) FindParent(pattern string) Instance

Finds the first ancestor of this node whose Name matches 'pattern', returning null if no match is found. The matching is done through String.Match. As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character. See also FindChild and FindChildren.

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 GetNode with unique names (see UniqueNameInOwner).

func (Instance) GetAccessibilityElement ¶

func (self Instance) GetAccessibilityElement() RID.AccessibilityElement

Returns main accessibility element RID.

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

func (Instance) GetChild ¶

func (self Instance) GetChild(idx int) Instance

Fetches a child node by its index. Each child node has an index relative to its siblings (see GetIndex). The first child is at index 0. Negative values can also be used to start from the end of the list. This method can be used in combination with GetChildCount to iterate over this node's children. If no child exists at the given index, this method returns null and an error is generated.

If 'include_internal' is false, internal children are ignored (see AddChild's internal parameter).

// Assuming the following are children of this node, in order:
// First, Middle, Last.
var a = node.GetChild(0).Name()  // a is "First"
var b = node.GetChild(1).Name()  // b is "Middle"
b = node.GetChild(2).Name()      // b is "Last"
var c = node.GetChild(-1).Name() // c is "Last"

Note: To fetch a node by node path, use GetNode.

func (Instance) GetChildCount ¶

func (self Instance) GetChildCount() int

Returns the number of children of this node.

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

func (Instance) GetChildren ¶

func (self Instance) GetChildren() []Instance

Returns all children of this node inside an slice.

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

func (Instance) GetGroups ¶

func (self Instance) GetGroups() []string

Returns an slice of group names that the node has been added to.

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 a slice of strings).
var nonInternalGroups []string
for _, group := range node.GetGroups() {
	if !strings.HasPrefix(group, "_") {
		nonInternalGroups = append(nonInternalGroups, group)
	}
}

func (Instance) GetIndex ¶

func (self Instance) GetIndex() int

Returns this node's order among its siblings. The first node's index is 0. See also GetChild.

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

func (Instance) GetMultiplayerAuthority ¶

func (self Instance) GetMultiplayerAuthority() int

Returns the peer ID of the multiplayer authority for this node. See SetMultiplayerAuthority.

func (Instance) GetNode ¶

func (self Instance) GetNode(path string) Instance

Fetches a node. The node path can either be a relative path (from this node), or an absolute path (from the SceneTree.Root) to a node. If 'path' does not point to a valid node, generates an error and returns null. Attempts to access methods on the return value will result in an "Attempt to call <method> on a null instance." error.

Note: Fetching by absolute path only works when the node is inside the scene tree (see IsInsideTree).

Example: Assume this method is called from the Character node, inside the following tree:

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

The following calls will return a valid node:

func (Instance) GetNodeAndResource ¶

func (self Instance) GetNodeAndResource(path string) (Instance, Resource.Instance, string)

Fetches a node and its most nested resource as specified by the node path's subname. Returns an slice of size 3 where:

- 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 node path, referring to an existing, non-Resource property (see Object.GetIndexed).

Example: Assume that the child's Sprite2D.Texture has been assigned an AtlasTexture:

node, res, path := node.GetNodeAndResource("Area2D/Sprite2D")
fmt.Println(node.Name()) // Prints Sprite2D
fmt.Println(res)         // Prints <null>
fmt.Println(path)        // Prints ^""

node, res, path = node.GetNodeAndResource("Area2D/Sprite2D:texture:atlas")
fmt.Println(node.Name())                                 // Prints Sprite2D
fmt.Println(Object.Instance(res.AsObject()).ClassName()) // Prints AtlasTexture
fmt.Println(path)                                        // Prints ^""

node, res, path = node.GetNodeAndResource("Area2D/Sprite2D:texture:atlas:region")
fmt.Println(node.Name())                                 // Prints Sprite2D
fmt.Println(Object.Instance(res.AsObject()).ClassName()) // Prints AtlasTexture
fmt.Println(path)                                        // Prints ^":region"

func (Instance) GetNodeOrNull ¶

func (self Instance) GetNodeOrNull(path string) Instance

Fetches a node by node path. Similar to GetNode, but does not generate an error if 'path' does not point to a valid node.

func (Instance) GetNodeRpcConfig ¶

func (self Instance) GetNodeRpcConfig() any

Returns a data structure mapping method names to their RPC configuration defined for this node using RpcConfig.

Note: This method only returns the RPC configuration assigned via RpcConfig. See Script.GetRpcConfig to retrieve the RPCs defined by the Script.

func (Instance) GetParent ¶

func (self Instance) GetParent() Instance

Returns this node's parent node, or null if the node doesn't have a parent.

func (Instance) GetPath ¶

func (self Instance) GetPath() string

Returns the node's absolute path, relative to the SceneTree.Root. If the node is not inside the scene tree, this method fails and returns an empty node path.

func (Instance) GetPathTo ¶

func (self Instance) GetPathTo(node Instance) string

Returns the relative node path from this node to the specified 'node'. Both nodes must be in the same SceneTree or scene hierarchy, otherwise this method fails and returns an empty node path.

If 'use_unique_path' is true, returns the shortest path accounting for this node's unique name (see UniqueNameInOwner).

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.

func (Instance) GetPhysicsProcessDeltaTime ¶

func (self Instance) GetPhysicsProcessDeltaTime() Float.X

Returns the time elapsed (in seconds) since the last physics callback. This value is identical to PhysicsProcess's delta parameter, and is often consistent at run-time, unless Engine.PhysicsTicksPerSecond is changed. See also NotificationPhysicsProcess.

Note: The returned value will be larger than expected if running at a framerate lower than Engine.PhysicsTicksPerSecond / Engine.MaxPhysicsStepsPerFrame 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 PhysicsProcess. 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 Time.GetTicksUsec.

func (Instance) GetProcessDeltaTime ¶

func (self Instance) GetProcessDeltaTime() Float.X

Returns the time elapsed (in seconds) since the last process callback. This value is identical to Process's delta parameter, and may vary from frame to frame. See also NotificationProcess.

Note: The returned value will be larger than expected if running at a framerate lower than Engine.PhysicsTicksPerSecond / Engine.MaxPhysicsStepsPerFrame 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 PhysicsProcess. 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 Time.GetTicksUsec.

func (Instance) GetSceneInstanceLoadPlaceholder ¶

func (self Instance) GetSceneInstanceLoadPlaceholder() bool

Returns true if this node is an instance load placeholder. See InstancePlaceholder and SetSceneInstanceLoadPlaceholder.

func (Instance) GetTreeString ¶

func (self Instance) GetTreeString() string

Returns the tree as a string. Used mainly for debugging purposes. This version displays the path relative to the current node, and is good for copy/pasting into the GetNode function. It also can be used in game UI/UX.

May print, for example:

func (Instance) GetTreeStringPretty ¶

func (self Instance) GetTreeStringPretty() string

Similar to GetTreeString, this returns the tree as a string. This version displays a more graphical representation similar to what is displayed in the Scene Dock. It is useful for inspecting larger trees.

May print, for example:

func (Instance) HasNode ¶

func (self Instance) HasNode(path string) bool

Returns true if the 'path' points to a valid node. See also GetNode.

func (Instance) HasNodeAndResource ¶

func (self Instance) HasNodeAndResource(path string) bool

Returns true if 'path' points to a valid node and its subnames point to a valid Resource, e.g. Area2D/CollisionShape2D:shape. Properties that are not Resource types (such as nodes or other any types) are not considered. See also GetNodeAndResource.

func (Instance) ID ¶

func (self Instance) ID() ID

func (Instance) IsAncestorOf ¶

func (self Instance) IsAncestorOf(node Instance) bool

Returns true if the given 'node' is a direct or indirect child of this node.

func (Instance) IsDisplayedFolded ¶

func (self Instance) IsDisplayedFolded() bool

Returns true if the node is folded (collapsed) in the Scene dock. This method is intended to be used in editor plugins and tools. See also SetDisplayFolded.

func (Instance) IsEditableInstance ¶

func (self Instance) IsEditableInstance(node Instance) bool

Returns true if 'node' has editable children enabled relative to this node. This method is intended to be used in editor plugins and tools. See also SetEditableInstance.

func (Instance) IsGreaterThan ¶

func (self Instance) IsGreaterThan(node Instance) bool

Returns true if the given 'node' occurs later in the scene hierarchy than this node. A node occurring later is usually processed last.

func (Instance) IsInGroup ¶

func (self Instance) IsInGroup(group string) bool

Returns true if this node has been added to the given 'group'. See AddToGroup and RemoveFromGroup. See also notes in the description, and the SceneTree's group methods.

func (Instance) IsInsideTree ¶

func (self Instance) IsInsideTree() bool

Returns true if this node is currently inside a SceneTree. See also GetTree.

func (Instance) IsMultiplayerAuthority ¶

func (self Instance) IsMultiplayerAuthority() bool

Returns true if the local system is the multiplayer authority of this node.

func (Instance) IsNodeReady ¶

func (self Instance) IsNodeReady() bool

Returns true if the node is ready, i.e. it's inside scene tree and all its children are initialized.

RequestReady resets it back to false.

func (Instance) IsPartOfEditedScene ¶

func (self Instance) IsPartOfEditedScene() bool

Returns true if the node is part of the scene currently opened in the editor.

func (Instance) IsPhysicsInterpolated ¶

func (self Instance) IsPhysicsInterpolated() bool

Returns true if physics interpolation is enabled for this node (see PhysicsInterpolationMode).

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 IsPhysicsInterpolatedAndEnabled.

func (Instance) IsPhysicsInterpolatedAndEnabled ¶

func (self Instance) IsPhysicsInterpolatedAndEnabled() bool

Returns true if physics interpolation is enabled (see PhysicsInterpolationMode) and enabled in the SceneTree.

This is a convenience version of IsPhysicsInterpolated that also checks whether physics interpolation is enabled globally.

See SceneTree.PhysicsInterpolation and ProjectSettings "physics/common/physics_interpolation".

func (Instance) IsPhysicsProcessing ¶

func (self Instance) IsPhysicsProcessing() bool

Returns true if physics processing is enabled (see SetPhysicsProcess).

func (Instance) IsPhysicsProcessingInternal ¶

func (self Instance) IsPhysicsProcessingInternal() bool

Returns true if internal physics processing is enabled (see SetPhysicsProcessInternal).

func (Instance) IsProcessing ¶

func (self Instance) IsProcessing() bool

Returns true if processing is enabled (see SetProcess).

func (Instance) IsProcessingInput ¶

func (self Instance) IsProcessingInput() bool

Returns true if the node is processing input (see SetProcessInput).

func (Instance) IsProcessingInternal ¶

func (self Instance) IsProcessingInternal() bool

Returns true if internal processing is enabled (see SetProcessInternal).

func (Instance) IsProcessingShortcutInput ¶

func (self Instance) IsProcessingShortcutInput() bool

Returns true if the node is processing shortcuts (see SetProcessShortcutInput).

func (Instance) IsProcessingUnhandledInput ¶

func (self Instance) IsProcessingUnhandledInput() bool

Returns true if the node is processing unhandled input (see SetProcessUnhandledInput).

func (Instance) IsProcessingUnhandledKeyInput ¶

func (self Instance) IsProcessingUnhandledKeyInput() bool

Returns true if the node is processing unhandled key input (see SetProcessUnhandledKeyInput).

func (Instance) IsQueuedForDeletion ¶

func (self Instance) IsQueuedForDeletion() bool

IsQueuedForDeletion returns true if the Instance.QueueFree method was called for the object.

func (Instance) MoreArgs ¶

func (self Instance) MoreArgs() MoreArgs

MoreArgs enables certain functions to be called with additional 'optional' arguments.

func (Instance) MoveChild ¶

func (self Instance) MoveChild(child_node Instance, to_index int)

Moves 'child_node' to the given index. A node's index is the order among its siblings. If 'to_index' is negative, the index is counted from the end of the list. See also GetChild and GetIndex.

Note: The processing order of several engine callbacks (Ready, Process, etc.) and notifications sent through PropagateNotification is affected by tree order. CanvasItem nodes are also rendered in tree order. See also ProcessPriority.

func (Instance) Multiplayer ¶

func (self Instance) Multiplayer() MultiplayerAPI.Instance

The MultiplayerAPI instance associated with this node. See SceneTree.GetMultiplayer.

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.

func (Instance) Name ¶

func (self Instance) Name() string

The name of the node. This name must be unique among the siblings (other child nodes from the same parent). When set to an existing sibling's name, the node is automatically renamed.

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 String.ValidateNodeName.

func (Instance) NotifyDeferredThreadGroup ¶

func (self Instance) NotifyDeferredThreadGroup(what int)

Similar to CallDeferredThreadGroup, but for notifications.

func (Instance) NotifyThreadSafe ¶

func (self Instance) NotifyThreadSafe(what int)

Similar to CallThreadSafe, but for notifications.

func (Instance) OnChildEnteredTree ¶

func (self Instance) OnChildEnteredTree(cb func(node Instance), flags ...Signal.Flags)

Emitted when the child 'node' enters the SceneTree, usually because this node entered the tree (see OnTreeEntered), or AddChild has been called.

This signal is emitted after the child node's own NotificationEnterTree and OnTreeEntered.

func (Instance) OnChildExitingTree ¶

func (self Instance) OnChildExitingTree(cb func(node Instance), flags ...Signal.Flags)

Emitted when the child 'node' is about to exit the SceneTree, usually because this node is exiting the tree (see OnTreeExiting), or because the child 'node' is being removed or freed.

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

func (Instance) OnChildOrderChanged ¶

func (self Instance) OnChildOrderChanged(cb func(), flags ...Signal.Flags)

Emitted when the list of children is changed. This happens when child nodes are added, moved or removed.

func (Instance) OnEditorDescriptionChanged ¶

func (self Instance) OnEditorDescriptionChanged(cb func(node Instance), flags ...Signal.Flags)

Emitted when the node's editor description field changed.

func (Instance) OnEditorStateChanged ¶

func (self Instance) OnEditorStateChanged(cb func(), flags ...Signal.Flags)

Emitted when an attribute of the node that is relevant to the editor is changed. Only emitted in the editor.

func (Instance) OnReady ¶

func (self Instance) OnReady(cb func(), flags ...Signal.Flags)

Emitted when the node is considered ready, after Ready is called.

func (Instance) OnRenamed ¶

func (self Instance) OnRenamed(cb func(), flags ...Signal.Flags)

Emitted when the node's Name is changed, if the node is inside the tree.

func (Instance) OnReplacingBy ¶

func (self Instance) OnReplacingBy(cb func(node Instance), flags ...Signal.Flags)

Emitted when this node is being replaced by the 'node', see ReplaceBy.

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'.

func (Instance) OnTreeEntered ¶

func (self Instance) OnTreeEntered(cb func(), flags ...Signal.Flags)

Emitted when the node enters the tree.

This signal is emitted after the related NotificationEnterTree notification.

func (Instance) OnTreeExited ¶

func (self Instance) OnTreeExited(cb func(), flags ...Signal.Flags)

Emitted after the node exits the tree and is no longer active.

This signal is emitted after the related NotificationExitTree notification.

func (Instance) OnTreeExiting ¶

func (self Instance) OnTreeExiting(cb func(), flags ...Signal.Flags)

Emitted when the node is just about to exit the tree. The node is still valid. As such, this is the right place for de-initialization (or a "destructor", if you will).

This signal is emitted after the node's ExitTree, and before the related NotificationExitTree.

func (Instance) Owner ¶

func (self Instance) Owner() Instance

The owner of this node. The owner must be an ancestor of this node. When packing the owner node in a PackedScene, all the nodes it owns are also saved with it. See also UniqueNameInOwner.

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 AddChild.

func (Instance) PhysicsInterpolationMode ¶

func (self Instance) PhysicsInterpolationMode() PhysicsInterpolationMode

The physics interpolation mode to use for this node. Only effective if ProjectSettings "physics/common/physics_interpolation" or SceneTree.PhysicsInterpolation is true.

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 Node.ResetPhysicsInterpolation after moving the node. This avoids creating a visual streak between the old and new positions.

func (Instance) PrintTree ¶

func (self Instance) PrintTree()

Prints the node and its children to the console, recursively. The node does not have to be inside the tree. This method outputs node paths relative to this node, and is good for copy/pasting into GetNode. See also PrintTreePretty.

May print, for example:

func (Instance) PrintTreePretty ¶

func (self Instance) PrintTreePretty()

Prints the node and its children to the console, recursively. The node does not have to be inside the tree. Similar to PrintTree, but the graphical representation looks like what is displayed in the editor's Scene dock. It is useful for inspecting larger trees.

May print, for example:

func (Instance) ProcessMode ¶

func (self Instance) ProcessMode() ProcessMode

The node's processing behavior. To check if the node can process in its current mode, use CanProcess.

func (Instance) ProcessPhysicsPriority ¶

func (self Instance) ProcessPhysicsPriority() int

Similar to ProcessPriority but for NotificationPhysicsProcess, PhysicsProcess, or NotificationInternalPhysicsProcess.

func (Instance) ProcessPriority ¶

func (self Instance) ProcessPriority() int

The node's execution order of the process callbacks (Process, NotificationProcess, and NotificationInternalProcess). Nodes whose priority value is lower call their process callbacks first, regardless of tree order.

func (Instance) ProcessThreadGroup ¶

func (self Instance) ProcessThreadGroup() ProcessThreadGroup

Set the process thread group for this node (basically, whether it receives NotificationProcess, NotificationPhysicsProcess, Process or PhysicsProcess (and the internal versions) on the main thread or in a sub-thread.

By default, the thread group is ProcessThreadGroupInherit, 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 ProcessThreadGroupOrder). If the value is set is ProcessThreadGroupSubThread, this thread group will occur on a sub thread (not the main thread), otherwise if set to ProcessThreadGroupMainThread 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 Object.CallDeferred, CallThreadSafe, CallDeferredThreadGroup 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 ProcessThreadGroupInherit 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.

func (Instance) ProcessThreadGroupOrder ¶

func (self Instance) ProcessThreadGroupOrder() int

Change the process thread group order. Groups with a lesser order will process before groups with a greater order. This is useful when a large amount of nodes process in sub thread and, afterwards, another group wants to collect their result in the main thread, as an example.

func (Instance) ProcessThreadMessages ¶

func (self Instance) ProcessThreadMessages() ProcessThreadMessages

Set whether the current thread group will process messages (calls to CallDeferredThreadGroup on threads), and whether it wants to receive them during regular process or physics process callbacks.

func (Instance) PropagateCall ¶

func (self Instance) PropagateCall(method string)

Calls the given 'method' name, passing 'args' as arguments, on this node and all of its children, recursively.

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.

func (Instance) PropagateNotification ¶

func (self Instance) PropagateNotification(what int)

Calls Object.Notification with 'what' on this node and all of its children, recursively.

func (Instance) QueueAccessibilityUpdate ¶

func (self Instance) QueueAccessibilityUpdate()

Queues an accessibility information update for this node.

func (Instance) QueueFree ¶

func (self Instance) QueueFree()

Queues this node to be deleted at the end of the current frame. When deleted, all of its children are deleted as well, and all references to the node and its children become invalid.

Unlike with Object.Free, the node is not deleted instantly, and it can still be accessed before deletion. It is also safe to call QueueFree multiple times. Use Object.IsQueuedForDeletion 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 Object.Free through Object.CallDeferred.

func (Instance) RemoveChild ¶

func (self Instance) RemoveChild(node Instance)

Removes a child 'node'. The 'node', along with its children, are not deleted. To delete a node, see QueueFree.

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 IsAncestorOf).

func (Instance) RemoveFromGroup ¶

func (self Instance) RemoveFromGroup(group string)

Removes the node from the given 'group'. Does nothing if the node is not in the 'group'. See also notes in the description, and the SceneTree's group methods.

func (Instance) Reparent ¶

func (self Instance) Reparent(new_parent Instance)

Changes the parent of this Node to the 'new_parent'. The node needs to already have a parent. The node's Owner is preserved if its owner is still reachable from the new location (i.e., the node is still a descendant of the new parent after the operation).

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).

func (Instance) ReplaceBy ¶

func (self Instance) ReplaceBy(node Instance)

Replaces this node by the given 'node'. All children of this node are moved to 'node'.

If 'keep_groups' is true, the 'node' is added to the same groups that the replaced node is in (see AddToGroup).

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 Object.Free.

func (Instance) RequestReady ¶

func (self Instance) RequestReady()

Requests Ready to be called again the next time the node enters the tree. Does not immediately call Ready.

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.

func (Instance) ResetPhysicsInterpolation ¶

func (self Instance) ResetPhysicsInterpolation()

When physics interpolation is active, moving a node to a radically different transform (such as placement within a level) can result in a visible glitch as the object is rendered moving from the old to new position over the physics tick.

That glitch can be prevented by calling this method, which temporarily disables interpolation until the physics tick is complete.

The notification NotificationResetPhysicsInterpolation will be received by the node and all children recursively.

Note: This function should be called after moving the node, rather than before.

func (Instance) Rpc ¶

func (self Instance) Rpc(method string, args ...any) error

Sends a remote procedure call request for the given 'method' to peers on the network (and locally), sending additional arguments to the method called by the RPC. The call request will only be received by nodes with the same node path, including the exact same Name. Behavior depends on the RPC configuration for the given 'method' (see RpcConfig and ). By default, methods are not exposed to RPCs.

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

[b]Note:[/b] 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 ([code]get_multiplayer().peer.get_connection_status() == CONNECTION_CONNECTED[/code]).). By default, methods are not exposed to RPCs.

May return [Ok] if the call is successful, [ErrInvalidParameter] if the arguments passed in the 'method' do not match, [ErrUnconfigured] if the node's Multiplayer cannot be fetched (such as when the node is not inside the tree), [ErrConnectionError] if Multiplayer's connection is not available.

Note: You can only safely use RPCs on clients after you received the OnMultiplayerapi.ConnectedToServer signal from the MultiplayerAPI. You also need to keep track of the connection state, either by the MultiplayerAPI signals like OnMultiplayerapi.ServerDisconnected or by checking (get_multiplayer().peer.get_connection_status() == CONNECTION_CONNECTED).

func (Instance) RpcConfig ¶

func (self Instance) RpcConfig(method string, config any)

Changes the RPC configuration for the given 'method'. 'config' should either be null to disable the feature (as by default), or a data structure containing the following entries:

- rpc_mode: see [MultiplayerAPI.RPCMode];

- transfer_mode: see [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, with various parameters passed ([code]@rpc(any)[/code], [code]@rpc(authority)[/code]...). See also the [url=https://docs.godotengine.org/tutorials/networking/high_level_multiplayer.html]high-level multiplayer[/url] tutorial. annotation, with various parameters passed (@rpc(any), @rpc(authority)...). See also the high-level multiplayer tutorial.

func (Instance) RpcId ¶

func (self Instance) RpcId(peer_id int, method string, args ...any) error

Sends a Rpc to a specific peer identified by 'peer_id' (see MultiplayerPeer.SetTargetPeer).

May return [Ok] if the call is successful, [ErrInvalidParameter] if the arguments passed in the 'method' do not match, [ErrUnconfigured] if the node's Multiplayer cannot be fetched (such as when the node is not inside the tree), [ErrConnectionError] if Multiplayer's connection is not available.

func (Instance) SceneFilePath ¶

func (self Instance) SceneFilePath() string

The original scene's file path, if the node has been instantiated from a PackedScene file. Only scene root nodes contains this.

func (Instance) SetAutoTranslateMode ¶

func (self Instance) SetAutoTranslateMode(value AutoTranslateMode)

SetAutoTranslateMode sets the property returned by [GetAutoTranslateMode].

func (Instance) SetDeferredThreadGroup ¶

func (self Instance) SetDeferredThreadGroup(property string, value any)

Similar to CallDeferredThreadGroup, but for setting properties.

func (Instance) SetDisplayFolded ¶

func (self Instance) SetDisplayFolded(fold bool)

If set to true, the node appears folded in the Scene dock. As a result, all of its children are hidden. This method is intended to be used in editor plugins and tools, but it also works in release builds. See also IsDisplayedFolded.

func (Instance) SetEditableInstance ¶

func (self Instance) SetEditableInstance(node Instance, is_editable bool)

Set to true to allow all nodes owned by 'node' to be available, and editable, in the Scene dock, even if their Owner is not the scene root. This method is intended to be used in editor plugins and tools, but it also works in release builds. See also IsEditableInstance.

func (Instance) SetEditorDescription ¶

func (self Instance) SetEditorDescription(value string)

SetEditorDescription sets the property returned by [GetEditorDescription].

func (Instance) SetMultiplayerAuthority ¶

func (self Instance) SetMultiplayerAuthority(id int)

Sets the node's multiplayer authority to the peer with the given peer 'id'. The multiplayer authority is the peer that has authority over the node on the network. Defaults to peer ID 1 (the server). Useful in conjunction with RpcConfig and the MultiplayerAPI.

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 MultiplayerSpawner.SpawnFunction, an RPC, or a MultiplayerSynchronizer. Furthermore, the parent's authority does not propagate to newly added children.

func (Instance) SetName ¶

func (self Instance) SetName(value string)

SetName sets the property returned by [GetName].

func (*Instance) SetObject ¶

func (self *Instance) SetObject(obj [1]gd.Object) bool

func (Instance) SetOwner ¶

func (self Instance) SetOwner(value Instance)

SetOwner sets the property returned by [GetOwner].

func (Instance) SetPhysicsInterpolationMode ¶

func (self Instance) SetPhysicsInterpolationMode(value PhysicsInterpolationMode)

SetPhysicsInterpolationMode sets the property returned by [GetPhysicsInterpolationMode].

func (Instance) SetPhysicsProcess ¶

func (self Instance) SetPhysicsProcess(enable bool)

If set to true, enables physics (fixed framerate) processing. When a node is being processed, it will receive a NotificationPhysicsProcess at a fixed (usually 60 FPS, see Engine.PhysicsTicksPerSecond to change) interval (and the PhysicsProcess callback will be called if it exists).

Note: If PhysicsProcess is overridden, this will be automatically enabled before Ready is called.

func (Instance) SetPhysicsProcessInternal ¶

func (self Instance) SetPhysicsProcessInternal(enable bool)

If set to true, enables internal physics for this node. Internal physics processing happens in isolation from the normal PhysicsProcess calls and is used by some nodes internally to guarantee proper functioning even if the node is paused or physics processing is disabled for scripting (SetPhysicsProcess).

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.

func (Instance) SetProcess ¶

func (self Instance) SetProcess(enable bool)

If set to true, enables processing. When a node is being processed, it will receive a NotificationProcess on every drawn frame (and the Process callback will be called if it exists).

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 PhysicsProcess. If you want to disable all processing for the node, set ProcessMode to ProcessModeDisabled.

func (Instance) SetProcessInput ¶

func (self Instance) SetProcessInput(enable bool)

If set to true, enables input processing.

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.

func (Instance) SetProcessInternal ¶

func (self Instance) SetProcessInternal(enable bool)

If set to true, enables internal processing for this node. Internal processing happens in isolation from the normal Process calls and is used by some nodes internally to guarantee proper functioning even if the node is paused or processing is disabled for scripting (SetProcess).

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.

func (Instance) SetProcessMode ¶

func (self Instance) SetProcessMode(value ProcessMode)

SetProcessMode sets the property returned by [GetProcessMode].

func (Instance) SetProcessPhysicsPriority ¶

func (self Instance) SetProcessPhysicsPriority(value int)

SetProcessPhysicsPriority sets the property returned by [GetPhysicsProcessPriority].

func (Instance) SetProcessPriority ¶

func (self Instance) SetProcessPriority(value int)

SetProcessPriority sets the property returned by [GetProcessPriority].

func (Instance) SetProcessShortcutInput ¶

func (self Instance) SetProcessShortcutInput(enable bool)

If set to true, enables shortcut processing for this node.

Note: If ShortcutInput is overridden, this will be automatically enabled before Ready is called.

func (Instance) SetProcessThreadGroup ¶

func (self Instance) SetProcessThreadGroup(value ProcessThreadGroup)

SetProcessThreadGroup sets the property returned by [GetProcessThreadGroup].

func (Instance) SetProcessThreadGroupOrder ¶

func (self Instance) SetProcessThreadGroupOrder(value int)

SetProcessThreadGroupOrder sets the property returned by [GetProcessThreadGroupOrder].

func (Instance) SetProcessThreadMessages ¶

func (self Instance) SetProcessThreadMessages(value ProcessThreadMessages)

SetProcessThreadMessages sets the property returned by [GetProcessThreadMessages].

func (Instance) SetProcessUnhandledInput ¶

func (self Instance) SetProcessUnhandledInput(enable bool)

If set to true, enables unhandled input processing. It enables the node to receive all input that was not previously handled (usually by a Control).

Note: If UnhandledInput 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.

func (Instance) SetProcessUnhandledKeyInput ¶

func (self Instance) SetProcessUnhandledKeyInput(enable bool)

If set to true, enables unhandled key input processing.

Note: If UnhandledKeyInput is overridden, this will be automatically enabled before Ready is called.

func (Instance) SetSceneFilePath ¶

func (self Instance) SetSceneFilePath(value string)

SetSceneFilePath sets the property returned by [GetSceneFilePath].

func (Instance) SetSceneInstanceLoadPlaceholder ¶

func (self Instance) SetSceneInstanceLoadPlaceholder(load_placeholder bool)

If set to true, the node becomes an InstancePlaceholder when packed and instantiated from a PackedScene. See also GetSceneInstanceLoadPlaceholder.

func (Instance) SetThreadSafe ¶

func (self Instance) SetThreadSafe(property string, value any)

Similar to CallThreadSafe, but for setting properties.

func (Instance) SetTranslationDomainInherited ¶

func (self Instance) SetTranslationDomainInherited()

Makes this node inherit the translation domain from its parent node. If this node has no parent, the main translation domain will be used.

This is the default behavior for all nodes. Calling Object.SetTranslationDomain disables this behavior.

func (Instance) SetUniqueNameInOwner ¶

func (self Instance) SetUniqueNameInOwner(value bool)

SetUniqueNameInOwner sets the property returned by [IsUniqueNameInOwner].

func (Instance) UniqueNameInOwner ¶

func (self Instance) UniqueNameInOwner() bool

If true, the node can be accessed from any node sharing the same Owner or from the Owner itself, with special %Name syntax in GetNode.

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.

func (Instance) UpdateConfigurationWarnings ¶

func (self Instance) UpdateConfigurationWarnings()

Refreshes the warnings displayed for this node in the Scene dock. Use GetConfigurationWarnings to customize the warning messages to display.

func (Instance) Virtual ¶

func (self Instance) Virtual(name string) reflect.Value

func (MoreArgs) AddChild ¶

func (self MoreArgs) AddChild(node Instance, force_readable_name bool, internal_ InternalMode)

Adds a child 'node'. Nodes can have any number of children, but every child must have a unique name. Child nodes are automatically deleted when the parent node is deleted, so an entire scene can be removed by deleting its topmost node.

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 InternalModeDisabled, the child will be added as internal node. These nodes are ignored by methods like GetChildren, 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 RemoveChild first to remove 'node' from its current parent. For example:

var childNode = node.GetChild(0)
if childNode.GetParent() != Node.Nil {
	childNode.GetParent().RemoveChild(childNode)
}
node.AddChild(childNode)

If you need the child node to be added below a specific node in the list of children, use AddSibling instead of this method.

Note: If you want a child to be persisted to a PackedScene, you must set Owner in addition to calling AddChild. This is typically relevant for tool scripts and editor plugins. If AddChild 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.

func (MoreArgs) AddSibling ¶

func (self MoreArgs) AddSibling(sibling Instance, force_readable_name bool)

Adds a 'sibling' node to this node's parent, and moves the added sibling right below this node.

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 AddChild 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 AddChild's internal parameter).

func (MoreArgs) AddToGroup ¶

func (self MoreArgs) AddToGroup(group string, persistent bool)

Adds the node to the 'group'. Groups can be helpful to organize a subset of nodes, for example "enemies" or "collectables". See notes in the description, and the group methods in SceneTree.

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 IsInsideTree).

func (MoreArgs) Atr ¶

func (self MoreArgs) Atr(message string, context string) string

Translates a 'message', using the translation catalogs configured in the Project Settings. Further 'context' can be specified to help with the translation. Note that most Control nodes automatically translate their strings, so this method is mostly useful for formatted strings or custom drawn text.

This method works the same as Object.Tr, with the addition of respecting the AutoTranslateMode state.

If Object.CanTranslateMessages is false, or no translation is available, this method returns the 'message' without changes. See Object.SetMessageTranslation.

For detailed examples, see Internationalizing games.

func (MoreArgs) AtrN ¶

func (self MoreArgs) AtrN(message string, plural_message string, n int, context string) string

Translates a 'message' or 'plural_message', using the translation catalogs configured in the Project Settings. Further 'context' can be specified to help with the translation.

This method works the same as Object.TrN, with the addition of respecting the AutoTranslateMode state.

If Object.CanTranslateMessages is false, or no translation is available, this method returns 'message' or 'plural_message', without changes. See Object.SetMessageTranslation.

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 Localization using gettext.

Note: Negative and Float.X numbers may not properly apply to some countable subjects. It's recommended to handle these cases with Atr.

func (MoreArgs) Duplicate ¶

func (self MoreArgs) Duplicate(flags int) Instance

Duplicates the node, returning a new node with all of its properties, signals, groups, and children copied from the original. The behavior can be tweaked through the 'flags' (see DuplicateFlags). Internal nodes are not duplicated.

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

func (MoreArgs) FindChild ¶

func (self MoreArgs) FindChild(pattern string, recursive bool, owned bool) Instance

Finds the first descendant of this node whose Name matches 'pattern', returning null if no match is found. The matching is done against node names, not their paths, through String.Match. As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character.

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 AddChild).

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 GetNode with unique names (see UniqueNameInOwner).

Note: To find all descendant nodes matching a pattern or a class type, see FindChildren.

func (MoreArgs) FindChildren ¶

func (self MoreArgs) FindChildren(pattern string, atype string, recursive bool, owned bool) []Instance

Finds all descendants of this node whose names match 'pattern', returning an empty slice if no match is found. The matching is done against node names, not their paths, through String.Match. As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character.

If 'type' is not empty, only ancestors inheriting from 'type' are included (see Object.IsClass).

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 AddChild).

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 FindChild.

func (MoreArgs) GetChild ¶

func (self MoreArgs) GetChild(idx int, include_internal bool) Instance

Fetches a child node by its index. Each child node has an index relative to its siblings (see GetIndex). The first child is at index 0. Negative values can also be used to start from the end of the list. This method can be used in combination with GetChildCount to iterate over this node's children. If no child exists at the given index, this method returns null and an error is generated.

If 'include_internal' is false, internal children are ignored (see AddChild's internal parameter).

// Assuming the following are children of this node, in order:
// First, Middle, Last.
var a = node.GetChild(0).Name()  // a is "First"
var b = node.GetChild(1).Name()  // b is "Middle"
b = node.GetChild(2).Name()      // b is "Last"
var c = node.GetChild(-1).Name() // c is "Last"

Note: To fetch a node by node path, use GetNode.

func (MoreArgs) GetChildCount ¶

func (self MoreArgs) GetChildCount(include_internal bool) int

Returns the number of children of this node.

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

func (MoreArgs) GetChildren ¶

func (self MoreArgs) GetChildren(include_internal bool) []Instance

Returns all children of this node inside an slice.

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

func (MoreArgs) GetIndex ¶

func (self MoreArgs) GetIndex(include_internal bool) int

Returns this node's order among its siblings. The first node's index is 0. See also GetChild.

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

func (MoreArgs) GetPathTo ¶

func (self MoreArgs) GetPathTo(node Instance, use_unique_path bool) string

Returns the relative node path from this node to the specified 'node'. Both nodes must be in the same SceneTree or scene hierarchy, otherwise this method fails and returns an empty node path.

If 'use_unique_path' is true, returns the shortest path accounting for this node's unique name (see UniqueNameInOwner).

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.

func (MoreArgs) PropagateCall ¶

func (self MoreArgs) PropagateCall(method string, args []any, parent_first bool)

Calls the given 'method' name, passing 'args' as arguments, on this node and all of its children, recursively.

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.

func (MoreArgs) Reparent ¶

func (self MoreArgs) Reparent(new_parent Instance, keep_global_transform bool)

Changes the parent of this Node to the 'new_parent'. The node needs to already have a parent. The node's Owner is preserved if its owner is still reachable from the new location (i.e., the node is still a descendant of the new parent after the operation).

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).

func (MoreArgs) ReplaceBy ¶

func (self MoreArgs) ReplaceBy(node Instance, keep_groups bool)

Replaces this node by the given 'node'. All children of this node are moved to 'node'.

If 'keep_groups' is true, the 'node' is added to the same groups that the replaced node is in (see AddToGroup).

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 Object.Free.

func (MoreArgs) SetMultiplayerAuthority ¶

func (self MoreArgs) SetMultiplayerAuthority(id int, recursive bool)

Sets the node's multiplayer authority to the peer with the given peer 'id'. The multiplayer authority is the peer that has authority over the node on the network. Defaults to peer ID 1 (the server). Useful in conjunction with RpcConfig and the MultiplayerAPI.

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 MultiplayerSpawner.SpawnFunction, an RPC, or a MultiplayerSynchronizer. Furthermore, the parent's authority does not propagate to newly added children.