class Godot::Node

Overview

=========================================================================== Node Idiomatic & Generic Extensions

Direct Known Subclasses

Defined in:

libgodot/extensions/node.cr
libgodot/generated/classes/classes_part1.cr
libgodot/object.cr

Constructors

Class Method Summary

Instance Method Summary

Instance methods inherited from class Godot::Object

==(other : Godot::Object) : Bool
==(other : Nil) : Bool ==, _enter_tree : Void _enter_tree, _exit_tree : Void _exit_tree, _godot_call_tool_button(button_name : String) : Void _godot_call_tool_button, _godot_call_virtual(method_name : String, delta : Float64) : Void _godot_call_virtual, _godot_call_virtual_with_data(method_name : String, args : Pointer(Pointer(Void)), ret : Pointer(Void)) : Void _godot_call_virtual_with_data, _godot_get_property(prop_name : String, ret_ptr : Pointer(Void)) : Void _godot_get_property, _godot_set_property(prop_name : String, val_ptr : Pointer(Void)) : Void _godot_set_property, _physics_process(delta : Float64) : Void _physics_process, _process(delta : Float64) : Void _process, _ready : Void _ready, add_user_signal(signal : String, arguments : Pointer(Void)) : Void add_user_signal, alive? : Bool alive?, await_signal(signal_name : String, timeout_sec : Float64 | Nil = nil) : Array(Variant) await_signal, blocking_signals? : Bool blocking_signals?, call(method : String, *args) : Pointer(Void) call, call_bool(method : String, *args) : Bool call_bool, call_deferred(method : String, *args) : Pointer(Void) call_deferred, call_f64(method : String, *args) : Float64 call_f64, call_i64(method : String, *args) : Int64 call_i64, call_obj(method : String, *args) : Node | Nil call_obj, call_obj_as(type : T.class, method : String, *args) : T | Nil forall T call_obj_as, call_str(method : String, *args) : String call_str, callv(method : String, arg_array : Pointer(Void)) : Pointer(Void) callv, can_translate_messages : Bool can_translate_messages, can_translate_messages? : Bool can_translate_messages?, cancel_free : Void cancel_free, check_alive! : Void check_alive!, class?(godot_class : String) : Bool class?, connect(signal_name : String, flags : Godot::ConnectFlags = ::Godot::ConnectFlags::None, callback : Proc(Array(Variant), Void) | Nil = nil) : SignalSubscription
connect(signal_name : String, flags : Godot::ConnectFlags = ::Godot::ConnectFlags::None, &block : Array(Variant) -> Void) : SignalSubscription
connect(signal_name : Symbol, flags : Godot::ConnectFlags = ::Godot::ConnectFlags::None, &block : Array(Variant) -> Void) : SignalSubscription
connect(signal_name : String, listener_target : Godot::Object, method_name : Symbol, flags : Godot::ConnectFlags = ::Godot::ConnectFlags::None) : SignalSubscription
connect(signal : String, callable : Pointer(Void), flags : Int64 = 0_i64) : Godot::Error connect, connect_one_shot(signal_name : String, &block : Array(Variant) -> Void) : SignalSubscription connect_one_shot, connected?(signal : String, callable : Pointer(Void)) : Bool connected?, destroy : Void destroy, destroyed? : Bool destroyed?, disconnect(signal : String, callable : Pointer(Void)) : Void
disconnect(signal_name : String) : Void disconnect, editor_hint? : Bool editor_hint?, emit_property_list_changed : Void emit_property_list_changed, emit_script_changed : Void emit_script_changed, emit_signal(name : String) : Void
emit_signal(name : String, *args) : Void emit_signal, explicitly_freed? : Bool explicitly_freed?, free : Void free, get(property : String) : Pointer(Void) get, get_class : String get_class, get_incoming_connections : Pointer(Void) get_incoming_connections, get_indexed(property_path : NodePath | String) : Pointer(Void) get_indexed, get_instance_id : Int64 get_instance_id, get_meta(name : String, default : Pointer(Void) | Nil = nil) : Pointer(Void) get_meta, get_meta_list : Pointer(Void) get_meta_list, get_method_argument_count(method : String) : Int64 get_method_argument_count, get_method_list : Pointer(Void) get_method_list, get_property_list : Pointer(Void) get_property_list, get_script : Pointer(Void) get_script, get_signal_connection_list(signal : String) : Pointer(Void) get_signal_connection_list, get_signal_list : Pointer(Void) get_signal_list, get_translation_domain : String get_translation_domain, has_connections(signal : String) : Bool has_connections, has_connections?(signal : String) : Bool has_connections?, has_meta(name : String) : Bool has_meta, has_meta?(name : String) : Bool has_meta?, has_method(method : String) : Bool has_method, has_method?(method : String) : Bool has_method?, has_signal(signal : String) : Bool has_signal, has_signal?(signal_name : String) : Bool has_signal?, has_user_signal(signal : String) : Bool has_user_signal, has_user_signal?(signal : String) : Bool has_user_signal?, hash(hasher) hash, if_alive : self | Nil if_alive, instance_id : UInt64 instance_id, is_blocking_signals : Bool is_blocking_signals, is_blocking_signals? : Bool is_blocking_signals?, is_class(godot_class : String) : Bool is_class, is_class?(godot_class : String) : Bool is_class?, is_connected(signal : String, callable : Pointer(Void)) : Bool is_connected, is_connected?(signal : String, callable : Pointer(Void)) : Bool is_connected?, is_queued_for_deletion : Bool is_queued_for_deletion, is_queued_for_deletion? : Bool is_queued_for_deletion?, is_valid? : Bool is_valid?, link_class_script : Void link_class_script, notification(what : Int64, reversed : Bool = false) : Void notification, notify_property_list_changed : Void notify_property_list_changed, pointer : Pointer(Void) pointer, pointer=(val : Pointer(Void)) pointer=, print(*args) print, printerr(*args) printerr, property_can_revert(property : String) : Bool property_can_revert, property_can_revert?(property : String) : Bool property_can_revert?, property_get_revert(property : String) : Pointer(Void) property_get_revert, property_list_changed : Godot::TypedSignal() property_list_changed, puts(*args) puts, queued_for_deletion? : Bool queued_for_deletion?, remove_meta(name : String) : Void remove_meta, remove_user_signal(signal : String) : Void remove_user_signal, script_changed : Godot::TypedSignal() script_changed, set(property : String, value : Pointer(Void)) : Void set, set_block_signals(enable : Bool) : Void set_block_signals, set_deferred(property : String, value : Pointer(Void)) : Void set_deferred, set_indexed(property_path : NodePath | String, value : Pointer(Void)) : Void set_indexed, set_message_translation(enable : Bool) : Void set_message_translation, set_meta(name : String, value : Pointer(Void)) : Void set_meta, set_script(script : Pointer(Void)) : Void set_script, set_translation_domain(domain : String) : Void set_translation_domain, signal(name : String) : Godot::BoundSignal
signal(sym : Symbol) : Godot::BoundSignal signal, signal_connection_count(signal_name : String) : Int32 signal_connection_count, signal_target_id : UInt64 signal_target_id, to_s(io : IO) : Void to_s, to_string : String to_string, to_unsafe : Pointer(Void) to_unsafe, tr(message : String, context : String = "") : String tr, tr_n(message : String, plural_message : String, n : Int64, context : String = "") : String tr_n

Constructor methods inherited from class Godot::Object

new(pointer : Pointer(Void) = Pointer(Void).null) new

Class methods inherited from class Godot::Object

_godot_has_virtual_method(method_name : String) : Bool _godot_has_virtual_method, find_script_path_for_class(target_cls : String) : String find_script_path_for_class, is_instance_id_valid(id : Int | UInt64) : Bool is_instance_id_valid

Constructor Detail

def self.~ : self #

Class unary ~ returns typed instance looked up from active NodeContext (by name first, then searching children)


def self.new(pointer : Pointer(Void) = Pointer(Void).null) #

Class Method Detail

def self.decompose_node_path(raw_path : String) : Tuple(Bool, String, String | Nil) #

Decomposes a raw path string, stripping leading '$' and extracting unique root prefix if present. Returns {is_unique, root_name, subpath}


def self.get_orphan_node_ids : Pointer(Void) #

def self.print_orphan_nodes : Void #

Instance Method Detail

def %(unique_name : String | NodePath) : Node #

Scene Unique Node operator (mirrors GDScript %): node % "HealthBar"


def %(type : T.class) : T forall T #

Typed Scene Unique Node operator: node % ProgressBar


def /(path : String | NodePath) : Node #

Path traversal operator: node / "Camera3D" or node / node_path!("Camera3D")


def /(type : T.class) : T forall T #

Typed path traversal operator: node / Sprite2D


def [](path : String | NodePath, type : T.class) : T forall T #

Typed path lookup: self["Visuals/Sprite2D", Sprite2D]


def [](type : T.class, path : String | NodePath) : T forall T #

Flexible type-first overload: self[Sprite2D, "Visuals/Sprite2D"]


def [](path : String) : Node #

Indexer syntactic sugar for retrieving a child node by path (e.g. self["Camera3D"])


def [](path : NodePath) : Node #

NodePath indexers


def [](type : T.class) : T forall T #

Type-inferred typed indexer: self[Sprite2D] -> looks up "Sprite2D" cast to Sprite2D


def []?(path : String | NodePath, type : T.class) : T | Nil forall T #

Safe typed path lookup: self["Visuals/Sprite2D", Sprite2D]?


def []?(type : T.class, path : String | NodePath) : T | Nil forall T #

Safe flexible type-first overload: self[Sprite2D, "Visuals/Sprite2D"]?


def []?(path : String) : Node | Nil #

Safe indexer returning nil if node not found (e.g. self["Camera3D"]?)


def []?(path : NodePath) : Node | Nil #

def []?(type : T.class) : T | Nil forall T #

Safe type-inferred indexer: self[Sprite2D]? -> returns Sprite2D? or nil if not found


def _enter_tree : Void #

Lifecycle callback called when the node enters the tree hierarchy.


def _exit_tree : Void #

Lifecycle callback called when the node exits the tree hierarchy.


def _physics_process(delta : Float64) : Void #

Fixed-rate physics process callback receiving delta timestep in seconds (Float64).


def _process(delta : Float64) : Void #

Per-frame process callback receiving delta timestep in seconds (Float64).


def _ready : Void #

Lifecycle callback called when the node enters the active scene tree.


def ~ : self #

Instance unary ~ returns self, allowing ~self or nested unary chaining


def add_child(node : Node, force_readable_name : Bool = false, internal : InternalMode | Int = 0) : Void #

Adds a child node. Falls back to local children array when running standalone. Enforces thread-safety: off-thread calls raise ThreadAffinityError when attached to SceneTree.


def add_sibling(sibling : Node, force_readable_name : Bool = false) : Void #

Adds a sibling node to the parent of this node. Enforces thread-safety: off-thread calls raise ThreadAffinityError when attached to SceneTree.


def add_to_group(group : String, persistent : Bool = false) : Void #

Adds this node to the specified group (with default non-persistent flag)


def ancestor_of?(node : Node) : Bool #

Predicate alias for #is_ancestor_of


def atr(message : String, context : String = "") : String #

def atr_n(message : String, plural_message : String, n : Int64, context : String = "") : String #

def auto_translate_mode #

Property #auto_translate_mode getter


def auto_translate_mode=(val : Int) #

Property #auto_translate_mode setter


def can_auto_translate : Bool #

def can_auto_translate? : Bool #

Predicate alias for #can_auto_translate


def can_process : Bool #

def can_process? : Bool #

Predicate alias for #can_process


def child_count : Int32 #

Idiomatic child count getter


def child_entered_tree : Godot::TypedSignal(Node) #

def child_exiting_tree : Godot::TypedSignal(Node) #

def child_order_changed : Godot::TypedSignal() #

def children(include_internal : Bool = false) : Array(Node) #

Alias for #get_children (falls back to local children array when running standalone)


def clear_children(include_internal : Bool = false) : Void #

Removes and frees all child nodes under this node.


def create_tween : Tween #

def defer_add_child(node : Node, force_readable_name : Bool = false, internal : InternalMode | Int = 0) : Void #

Explicit cross-thread helper that safely defers addition via Godot's MessageQueue


def defer_move_child(child_node : Node, to_position : Int64 | Int32) : Void #

Explicit cross-thread helper that safely defers moving child via Godot's MessageQueue


def defer_queue_free : Void #

Explicit cross-thread helper that safely queues deletion via Godot's MessageQueue


def defer_remove_child(node : Node) : Void #

Explicit cross-thread helper that safely defers removal via Godot's MessageQueue


def defer_reparent(new_parent : Node, keep_global_transform : Bool = true) : Void #

Explicit cross-thread helper that safely defers reparenting via Godot's MessageQueue


def destroy : Void #

Safely destroys this node, unregistering parent references in standalone mode.


def displayed_folded? : Bool #

Predicate alias for #is_displayed_folded


def duplicate(flags : Int64 = 15_i64) : Node #

def each_child(include_internal : Bool = false, &block : Node -> Void) : Void #

Yields each child node without allocating an intermediate array.


def editable_instance?(node : Node) : Bool #

Predicate alias for #is_editable_instance


def editor_description #

Property #editor_description getter


def editor_description=(val) #

Property #editor_description setter


def editor_description_changed : Godot::TypedSignal(Node) #

def editor_state_changed : Godot::TypedSignal() #

def emit_child_entered_tree(*args) : Void #

def emit_child_exiting_tree(*args) : Void #

def emit_child_order_changed : Void #

def emit_editor_description_changed(*args) : Void #

def emit_editor_state_changed : Void #

def emit_ready : Void #

def emit_renamed : Void #

def emit_replacing_by(*args) : Void #

def emit_tree_entered : Void #

def emit_tree_exited : Void #

def emit_tree_exiting : Void #

def find_child(pattern : String, recursive : Bool = true, owned : Bool = true) : Node #

Finds an existing child node matching pattern.


def find_child?(pattern : String, recursive : Bool = true, owned : Bool = false) : Node | Nil #

Finds child node matching pattern, returning nil if not found


def find_child_as(type : T.class, pattern : String, recursive : Bool = true, owned : Bool = false) : T | Nil forall T #

Finds child node matching pattern and casts to T, returning nil if not found


def find_children(pattern : String, get_type : String = "", recursive : Bool = true, owned : Bool = true) : Pointer(Void) #

def find_parent(pattern : String) : Node #

def get_accessibility_element : Int64 #

def get_auto_translate_mode : AutoTranslateMode #

def get_child(idx : Int64, include_internal : Bool = false) : Node #

def get_child?(idx : Int, include_internal : Bool = false) : Node | Nil #

Retrieves child at specified index, or nil if not found


def get_child_as(type : T.class, idx : Int, include_internal : Bool = false) : T | Nil forall T #

Retrieves child at specified index cast to type T, or nil if not found or not matching type


def get_child_count(include_internal : Bool = false) : Int64 #

def get_children(include_internal : Bool = false) : Array(Node) #

Returns an Array containing all child nodes belonging to this node.


def get_children_as(type : T.class, include_internal : Bool = false) : Array(T) forall T #

Returns all children of this node matching or cast to type T.


def get_editor_description : String #

def get_groups : Pointer(Void) #

def get_index(include_internal : Bool = false) : Int64 #

def get_last_exclusive_window : Window #

def get_multiplayer : MultiplayerAPI #

def get_multiplayer_authority : Int64 #

def get_name : String #

Returns the node name


def get_node(path : String) : Node #

Retrieves a child or sibling node by NodePath string. Returns the Node if found, or produces an error if the node does not exist.


def get_node(path : NodePath) : Node #

Overloads for NodePath


def get_node(path : NodePath | String) : Node #

def get_node?(path : String) : Node | Nil #

Retrieves a child or sibling node by NodePath string, or returns nil if not found. Transparently supports leading '$', scene-unique '%' prefixes, and '%UniqueRoot/sub/path' traversal.


def get_node?(path : NodePath) : Node | Nil #

def get_node_and_resource(path : NodePath | String) : Pointer(Void) #

def get_node_as(path : String | NodePath, type : T.class) : T forall T #

Retrieves a child node cast to the specified Crystal class type T. Returns the node cast to T, or produces an error if the node does not exist or cannot be cast.


def get_node_as?(path : String | NodePath, type : T.class) : T | Nil forall T #

Retrieves a child node cast to the specified Crystal class type T, or nil if not found or type mismatch.


def get_node_or_null(path : String) : Node | Nil #

Fetches a node by String path. Similar to #get_node, but returns nil if path does not point to a valid node.


def get_node_or_null(path : NodePath) : Node | Nil #

def get_node_or_null(path : NodePath | String) : Node #

def get_node_rpc_config : Pointer(Void) #

def get_orphan_node_ids : Pointer(Void) #

Instance convenience delegator for static method #get_orphan_node_ids


def get_owner : Node #

def get_parent : Node #

def get_parent? : Node | Nil #

Returns the parent Node, or nil if orphan


def get_parent_as(type : T.class) : T | Nil forall T #

Returns the parent node cast to T, or nil if parent is not of type T or is null


def get_path : NodePath #

def get_path_to(node : Node, use_unique_path : Bool = false) : NodePath #

def get_physics_interpolation_mode : PhysicsInterpolationMode #

def get_physics_process_delta_time : Float64 #

def get_physics_process_priority : Int64 #

def get_process_delta_time : Float64 #

def get_process_mode : ProcessMode #

def get_process_priority : Int64 #

def get_process_thread_group : ProcessThreadGroup #

def get_process_thread_group_order : Int64 #

def get_process_thread_messages : ProcessThreadMessages #

def get_scene_file_path : String #

def get_scene_instance_load_placeholder : Bool #

def get_scene_instance_load_placeholder? : Bool #

Predicate alias for #get_scene_instance_load_placeholder


def get_tree : SceneTree #

Returns the SceneTree containing this node.


def get_tree_string : String #

def get_tree_string_pretty : String #

def get_unique_node_as(unique_name : String, type : T.class) : T | Nil forall T #

Returns the scene unique node with name %unique_name cast to T


def get_viewport : Viewport #

def get_window : Window #

def greater_than?(node : Node) : Bool #

Predicate alias for #is_greater_than


def has_node(path : NodePath | String) : Bool #

def has_node?(path : NodePath | String) : Bool #

Predicate alias for #has_node


def has_node_and_resource(path : NodePath | String) : Bool #

def has_node_and_resource?(path : NodePath | String) : Bool #

Predicate alias for #has_node_and_resource


def in_group?(group_name : String) : Bool #

Returns true if this node belongs to the given node group.


def inside_tree? : Bool #

Predicate alias for #is_inside_tree


def is_ancestor_of(node : Node) : Bool #

def is_ancestor_of?(node : Node) : Bool #

Predicate alias for #is_ancestor_of


def is_displayed_folded : Bool #

def is_displayed_folded? : Bool #

Predicate alias for #is_displayed_folded


def is_editable_instance(node : Node) : Bool #

def is_editable_instance?(node : Node) : Bool #

Predicate alias for #is_editable_instance


def is_greater_than(node : Node) : Bool #

def is_greater_than?(node : Node) : Bool #

Predicate alias for #is_greater_than


def is_in_group(group : String) : Bool #

def is_in_group?(group : String) : Bool #

Predicate alias for #is_in_group


def is_inside_tree : Bool #

def is_inside_tree? : Bool #

Predicate alias for #is_inside_tree


def is_multiplayer_authority : Bool #

def is_multiplayer_authority? : Bool #

Predicate alias for #is_multiplayer_authority


def is_node_ready : Bool #

def is_node_ready? : Bool #

Predicate alias for #is_node_ready


def is_part_of_edited_scene : Bool #

def is_part_of_edited_scene? : Bool #

Predicate alias for #is_part_of_edited_scene


def is_physics_interpolated : Bool #

def is_physics_interpolated? : Bool #

Predicate alias for #is_physics_interpolated


def is_physics_interpolated_and_enabled : Bool #

def is_physics_interpolated_and_enabled? : Bool #

Predicate alias for #is_physics_interpolated_and_enabled


def is_physics_processing : Bool #

def is_physics_processing? : Bool #

Predicate alias for #is_physics_processing


def is_physics_processing_internal : Bool #

def is_physics_processing_internal? : Bool #

Predicate alias for #is_physics_processing_internal


def is_processing : Bool #

def is_processing? : Bool #

Predicate alias for #is_processing


def is_processing_input : Bool #

def is_processing_input? : Bool #

Predicate alias for #is_processing_input


def is_processing_internal : Bool #

def is_processing_internal? : Bool #

Predicate alias for #is_processing_internal


def is_processing_shortcut_input : Bool #

def is_processing_shortcut_input? : Bool #

Predicate alias for #is_processing_shortcut_input


def is_processing_unhandled_input : Bool #

def is_processing_unhandled_input? : Bool #

Predicate alias for #is_processing_unhandled_input


def is_processing_unhandled_key_input : Bool #

def is_processing_unhandled_key_input? : Bool #

Predicate alias for #is_processing_unhandled_key_input


def is_unique_name_in_owner : Bool #

def is_unique_name_in_owner? : Bool #

Predicate alias for #is_unique_name_in_owner


def local_groups : Set(String) #

def move_child(child_node : Node, to_index : Int64) : Void #

def move_child(child_node : Node, to_index : Int | Int64) : Void #

Moves child node to a new index in the parent's child list. Enforces thread-safety: off-thread calls raise ThreadAffinityError when attached to SceneTree.


def multiplayer #

Property #multiplayer getter


def multiplayer_authority? : Bool #

Predicate alias for #is_multiplayer_authority


def name : String #

def name=(val : String) #

def node_as(path : String | NodePath, type : T.class) : T forall T #

Shorthand for get_node_as


def node_as?(path : String | NodePath, type : T.class) : T | Nil forall T #

Shorthand for get_node_as?


def node_ready? : Bool #

Predicate alias for #is_node_ready


def notify_deferred_thread_group(what : Int64) : Void #

def notify_thread_safe(what : Int64) : Void #

def owner : Node | Nil #

Returns the scene owner node responsible for serialization packing.


def owner=(o : Node | Nil) #

Sets the scene owner node for serialization packing.


def part_of_edited_scene? : Bool #

Predicate alias for #is_part_of_edited_scene


def physics_interpolated? : Bool #

Predicate alias for #is_physics_interpolated


def physics_interpolated_and_enabled? : Bool #

Predicate alias for #is_physics_interpolated_and_enabled


def physics_interpolation_mode #

Property #physics_interpolation_mode getter


def physics_interpolation_mode=(val : Int) #

Property #physics_interpolation_mode setter


def physics_processing? : Bool #

Predicate alias for #is_physics_processing


def physics_processing_internal? : Bool #

Predicate alias for #is_physics_processing_internal


def print_orphan_nodes : Void #

Instance convenience delegator for static method #print_orphan_nodes


def print_tree : Void #

def print_tree_pretty : Void #

def process_mode #

Property #process_mode getter


def process_mode=(val : Int) #

Property #process_mode setter


def process_physics_priority #

Property #process_physics_priority getter


def process_physics_priority=(val : Int) #

Property #process_physics_priority setter


def process_priority #

Property #process_priority getter


def process_priority=(val : Int) #

Property #process_priority setter


def process_thread_group #

Property #process_thread_group getter


def process_thread_group=(val : Int) #

Property #process_thread_group setter


def process_thread_group_order #

Property #process_thread_group_order getter


def process_thread_group_order=(val : Int) #

Property #process_thread_group_order setter


def process_thread_messages #

Property #process_thread_messages getter


def process_thread_messages=(val : Int) #

Property #process_thread_messages setter


def processing? : Bool #

Predicate alias for #is_processing


def processing_input? : Bool #

Predicate alias for #is_processing_input


def processing_internal? : Bool #

Predicate alias for #is_processing_internal


def processing_shortcut_input? : Bool #

Predicate alias for #is_processing_shortcut_input


def processing_unhandled_input? : Bool #

Predicate alias for #is_processing_unhandled_input


def processing_unhandled_key_input? : Bool #

Predicate alias for #is_processing_unhandled_key_input


def propagate_call(method : String, args : Pointer(Void), parent_first : Bool = false) : Void #

def propagate_notification(what : Int64) : Void #

def queue_accessibility_update : Void #

def queue_free : Void #

Deallocates node cleanly at frame end on the Main Thread. Enforces thread-safety: off-thread calls on SceneTree nodes either raise ThreadAffinityError or auto-defer.


def ready : Godot::TypedSignal() #

def remove_child(node : Node) : Void #

Removes a child node. Falls back to local children array when running standalone. Enforces thread-safety: off-thread calls raise ThreadAffinityError when attached to SceneTree.


def remove_from_group(group : String) : Void #

def remove_from_tree : Void #

Removes this node from its parent if currently inside a parent hierarchy.


def renamed : Godot::TypedSignal() #

def reparent(new_parent : Node, keep_global_transform : Bool = true) : Void #

Reparents this node to a new parent. Enforces thread-safety: off-thread calls raise ThreadAffinityError when attached to SceneTree.


def replace_by(node : Node, keep_groups : Bool = false) : Void #

Replaces this node with another node in the tree. Enforces thread-safety: off-thread calls raise ThreadAffinityError when attached to SceneTree.


def replacing_by : Godot::TypedSignal(Node) #

def request_ready : Void #

def reset_physics_interpolation : Void #

def rpc(method : String | Symbol, *args) : Godot::Error #

Calls an RPC method on this node across the multiplayer network.


def rpc_config(method : String, config : Pointer(Void)) : Void #

def rpc_id(peer_id : Int32 | Int64, method : String | Symbol, *args) : Godot::Error #

Calls an RPC method on a specific peer ID across the multiplayer network.


def safe_queue_free : Void #

Safe queue free that checks alive? before dispatching


def scene_file_path #

Property #scene_file_path getter


def scene_file_path=(val) #

Property #scene_file_path setter


def set_auto_translate_mode(mode : AutoTranslateMode | Int) : Void #

def set_deferred_thread_group(property : String, value : Pointer(Void)) : Void #

def set_display_folded(fold : Bool) : Void #

def set_editable_instance(node : Node, is_editable : Bool) : Void #

def set_editor_description(editor_description : String) : Void #

def set_multiplayer_authority(id : Int64, recursive : Bool = true) : Void #

def set_name(name : String) : Void #

Sets the name of the node safely via dynamic reflection


def set_owner(owner : Node) : Void #

def set_physics_interpolation_mode(mode : PhysicsInterpolationMode | Int) : Void #

def set_physics_process(enable : Bool) : Void #

def set_physics_process_internal(enable : Bool) : Void #

def set_physics_process_priority(priority : Int64) : Void #

def set_process(enable : Bool) : Void #

def set_process_input(enable : Bool) : Void #

def set_process_internal(enable : Bool) : Void #

def set_process_mode(mode : ProcessMode | Int) : Void #

def set_process_priority(priority : Int64) : Void #

def set_process_shortcut_input(enable : Bool) : Void #

def set_process_thread_group(mode : ProcessThreadGroup | Int) : Void #

def set_process_thread_group_order(order : Int64) : Void #

def set_process_thread_messages(flags : ProcessThreadMessages | Int) : Void #

def set_process_unhandled_input(enable : Bool) : Void #

def set_process_unhandled_key_input(enable : Bool) : Void #

def set_scene_file_path(scene_file_path : String) : Void #

def set_scene_instance_load_placeholder(load_placeholder : Bool) : Void #

def set_thread_safe(property : String, value : Pointer(Void)) : Void #

def set_translation_domain_inherited : Void #

def set_unique_name_in_owner(enable : Bool) : Void #

def tree_entered : Godot::TypedSignal() #

def tree_exited : Godot::TypedSignal() #

def tree_exiting : Godot::TypedSignal() #

def unique_as(name : String | NodePath, type : T.class) : T forall T #

Shorthand for retrieving a scene unique node cast to type T


def unique_as?(name : String | NodePath, type : T.class) : T | Nil forall T #

Safe shorthand for retrieving a scene unique node cast to type T, or nil if not found or type mismatch


def unique_name_in_owner #

Property #unique_name_in_owner getter


def unique_name_in_owner=(val) #

Property #unique_name_in_owner setter


def unique_name_in_owner? : Bool #

Predicate alias for #is_unique_name_in_owner


def update_configuration_warnings : Void #

def with_context(&) #

Executes block with this node as the active NodeContext