Node

继承： Object

派生： AnimationMixer, AudioStreamPlayer, CanvasItem, CanvasLayer, EditorFileSystem, EditorPlugin, EditorResourcePreview, HTTPRequest, InstancePlaceholder, MissingNode, MultiplayerSpawner, MultiplayerSynchronizer, NavigationAgent2D, NavigationAgent3D, Node3D, ResourcePreloader, ShaderGlobalsOverride, SkeletonIK3D, Timer, Viewport, WorldEnvironment

所有场景对象的基类。

描述

节点是 Godot 的构建模块。它们可以被指定为另一个节点的子节点，从而形成树状排列。一个给定的节点可以包含任意数量的节点作为子节点，要求所有的兄弟节点（即该节点的直接子节点）的名字唯一。

节点树被称为场景。场景可以被保存到磁盘上，然后被实例化到其他场景中。这使得 Godot 项目的架构和数据模型具有非常高的灵活性。

场景树：SceneTree 包含活动的节点树。当一个节点被添加到场景树中时，它将收到 NOTIFICATION_ENTER_TREE 通知，并触发其 _enter_tree 回调。子节点总是在其父节点之后被添加，即父节点的 _enter_tree 回调将在其子节点的之前被触发。

一旦所有的节点被添加到场景树中，它们就会收到 NOTIFICATION_READY 通知，其各自的 _ready 回调被触发。对于一组节点，_ready 回调是按相反的顺序调用的，从子节点开始，向上移动到父节点。

这意味着，当把一个节点添加到场景树中时，将使用下面的顺序进行回调：父节点的 _enter_tree、子节点的 _enter_tree、子节点的 _ready，最后是父节点的 _ready（对整个场景树进行递归）。

处理：节点可以覆盖“处理”状态，以便它们在每一帧上都收到回调，要求它们进行处理（做一些事情）。普通处理（回调 _process，可以使用 set_process 开关）会尽可能快地发生，并且取决于帧率，所以处理时间 delta（单位为秒）会作为参数传入。物理处理（回调 _physics_process，可以使用 set_physics_process 开关）每秒发生固定次数（默认为 60），对物理引擎相关的代码很有用。

节点也可以处理输入事件。存在 _input 函数时，程序每收到一次输入都会去调用它。在许多情况下，这么做是大材小用了（除非是用于简单的项目），用 _unhandled_input 函数可能更合适；当输入事件没有被其他节点（通常是 GUI Control 节点）处理时，才会调用这个函数，可以确保节点只接收到它该收到的事件。

为了记录场景的层次结构（尤其是在将场景实例化到其他场景时）可以用 owner 属性为节点设置一个“所有者”。它记录的是谁实例化了什么。这在编写编辑器和工具时非常有用。

最后，当一个节点被 Object.free 或 queue_free 释放时，它也将释放它的所有子节点。

分组：节点可以被添加到很多的组中，以方便管理，你可以根据自己游戏的需要来创建类似“敌人”或“收集品”这样的组。见 add_to_group、is_in_group 和 remove_from_group。加入组后，你可以检索这些组中的所有节点，对它们进行迭代，甚至通过 SceneTree 中的方法调用组内方法。

节点的网络编程：在连接到服务器（或制作服务器，见 ENetMultiplayerPeer）之后，可以使用内置的 RPC（远程过程调用）系统在网络上进行通信。在调用 rpc 时传入方法名，将在本地和所有已连接的对等体中调用对应的方法（对等体=客户端和接受连接的服务器）。为了识别哪个节点收到 RPC 调用，Godot 将使用它的 NodePath（请确保所有对等体上的节点名称相同）。另外，请参阅高级网络教程和相应的演示。

注意：script 属性是 Object 类的一部分，不属于 Node。这个属性暴露的方式和其他属性不同，但提供了 setter 和 getter（set_script() 和 get_script()）。

教程

• 节点与场景

• 所有演示

属性

方法

信号

child_entered_tree ( Node node )

在子节点进入场景树时触发，可以是因为该子节点自行进入，也可以是因为本节点带着该子节点一起进入。

这个信号会在该子节点自身的 NOTIFICATION_ENTER_TREE 和 tree_entered 之后触发。

child_exiting_tree ( Node node )

当一个子节点即将退出场景树时发出，要么是因为它正在被移除或直接释放，要么是因为该节点正在退出树。

当收到这个信号时，子 node 仍然在树中并且有效。该信号在子节点自己的 tree_exiting 和 NOTIFICATION_EXIT_TREE 之后发出。

child_order_changed ( )

子节点列表发生改变时发出。发生在添加、移动、移除子节点时。

ready ( )

当该节点就绪时发出。在 _ready 回调之后发出，遵循相同的规则。

renamed ( )

当该节点被重命名时触发。

replacing_by ( Node node )

当该节点被 node 替换时触发，见 replace_by。

这个信号的触发时机在 node 被添加为原父节点的子节点之后，但是在所有原子节点重设父节点为 node 之前。

tree_entered ( )

当该节点进入树时触发。

这个信号会在相关的 NOTIFICATION_ENTER_TREE 通知之后触发。

tree_exited ( )

当该节点退出树之后触发，并且不再处于活动状态。

tree_exiting ( )

当该节点仍处于活动状态但即将退出树时发出。这是反初始化的正确位置（如果愿意，也可以称之为“析构函数”）。

这个信号会在相关的 NOTIFICATION_EXIT_TREE 通知之前触发。

枚举

enum ProcessMode:

ProcessMode PROCESS_MODE_INHERIT = 0

从该节点的父节点继承处理模式。如果是根节点，则等价于 PROCESS_MODE_PAUSABLE。默认值。

ProcessMode PROCESS_MODE_PAUSABLE = 1

SceneTree 暂停时停止处理（取消暂停时处理）。与 PROCESS_MODE_WHEN_PAUSED 相反。

ProcessMode PROCESS_MODE_WHEN_PAUSED = 2

仅在 SceneTree 暂停时处理（取消暂停时不处理）。与 PROCESS_MODE_PAUSABLE 相反。

ProcessMode PROCESS_MODE_ALWAYS = 3

始终处理。始终继续处理，忽略 SceneTree 的 paused 属性。与 PROCESS_MODE_DISABLED 相反。

ProcessMode PROCESS_MODE_DISABLED = 4

从不处理。完全禁用处理，忽略 SceneTree 的 paused 属性。与 PROCESS_MODE_ALWAYS 相反。

enum ProcessThreadGroup:

ProcessThreadGroup PROCESS_THREAD_GROUP_INHERIT = 0

如果 process_thread_group 属性设为这个值，该节点会属于线程组不是继承的父节点（或祖父节点）。详见 process_thread_group。

ProcessThreadGroup PROCESS_THREAD_GROUP_MAIN_THREAD = 1

在主线程上处理该节点（以及设为继承的子节点）。详见 process_thread_group。

ProcessThreadGroup PROCESS_THREAD_GROUP_SUB_THREAD = 2

在子线程上处理该节点（以及设为继承的子节点）。详见 process_thread_group。

flags ProcessThreadMessages:

ProcessThreadMessages FLAG_PROCESS_THREAD_MESSAGES = 1

ProcessThreadMessages FLAG_PROCESS_THREAD_MESSAGES_PHYSICS = 2

ProcessThreadMessages FLAG_PROCESS_THREAD_MESSAGES_ALL = 3

enum DuplicateFlags:

DuplicateFlags DUPLICATE_SIGNALS = 1

复制该节点的信号。

DuplicateFlags DUPLICATE_GROUPS = 2

复制节点的组。

DuplicateFlags DUPLICATE_SCRIPTS = 4

复制该节点的脚本。

DuplicateFlags DUPLICATE_USE_INSTANTIATION = 8

使用实例化进行复制。

实例与原件保持链接，因此当原件发生变化时，实例也会发生变化。

enum InternalMode:

InternalMode INTERNAL_MODE_DISABLED = 0

该节点不是内部节点。

InternalMode INTERNAL_MODE_FRONT = 1

该节点将被放置在父节点的节点列表开头，在所有非内部兄弟节点之前。

InternalMode INTERNAL_MODE_BACK = 2

该节点将被放置在父节点的节点列表末尾，在所有非内部兄弟节点之后。

常量

NOTIFICATION_ENTER_TREE = 10

当该节点进入 SceneTree 时收到的通知。

这个通知会在相关的 tree_entered 之前发出。

NOTIFICATION_EXIT_TREE = 11

当该节点即将退出 SceneTree 时收到的通知。

这个通知会在相关的 tree_exiting 之后发出。

NOTIFICATION_MOVED_IN_PARENT = 12

已废弃。不会再发出这个通知。请改用 NOTIFICATION_CHILD_ORDER_CHANGED。

NOTIFICATION_READY = 13

当该节点就绪时接收到通知。见 _ready。

NOTIFICATION_PAUSED = 14

当该节点被暂停时接收到的通知。

NOTIFICATION_UNPAUSED = 15

当该节点被取消暂停时收到的通知。

NOTIFICATION_PHYSICS_PROCESS = 16

当设置了 physics process 标志时，每一帧都会收到的通知（见 set_physics_process）。

NOTIFICATION_PROCESS = 17

当设置了 process 标志时，每一帧都会收到的通知（见 set_process）。

NOTIFICATION_PARENTED = 18

当一个节点被设置为另一个节点的子节点时收到该通知。

注意：这并不意味着一个节点进入了 SceneTree。

NOTIFICATION_UNPARENTED = 19

当该节点失去父节点时收到的通知（父节点将其从子节点列表中删除）。

NOTIFICATION_SCENE_INSTANTIATED = 20

当场景被实例化时，该场景的所有者收到的通知。

NOTIFICATION_DRAG_BEGIN = 21

当拖拽操作开始时收到的通知。所有节点都会收到此通知，而不仅仅是被拖动的节点。

可以通过拖动提供拖动数据的 Control（见 Control._get_drag_data），或使用 Control.force_drag 来触发。

请使用 Viewport.gui_get_drag_data 获取拖动数据。

NOTIFICATION_DRAG_END = 22

当拖拽操作结束时收到的通知。

请使用 Viewport.gui_is_drag_successful 检查拖放是否成功。

NOTIFICATION_PATH_RENAMED = 23

当该节点或其祖级的名称被更改时收到的通知。当节点从场景树中移除，稍后被添加到另一个父节点时，不会收到此通知。

NOTIFICATION_CHILD_ORDER_CHANGED = 24

子节点列表发生更改时收到的通知。子节点发生添加、移动、删除时列表会发生更改。

NOTIFICATION_INTERNAL_PROCESS = 25

当设置了内部处理标志时，每一帧都会收到的通知（见 set_process_internal）。

NOTIFICATION_INTERNAL_PHYSICS_PROCESS = 26

当设置了内部物理处理标志时，每一帧都会收到的通知（见 set_physics_process_internal）。

NOTIFICATION_POST_ENTER_TREE = 27

当该节点就绪，在收到 NOTIFICATION_READY 之前收到的通知。与后者不同，该节点每次进入树时都会发送，而不是只发送一次。

NOTIFICATION_DISABLED = 28

当该节点被禁用时收到的通知。见 PROCESS_MODE_DISABLED。

NOTIFICATION_ENABLED = 29

当该节点被禁用后又再次被启用时收到的通知。见 PROCESS_MODE_DISABLED。

NOTIFICATION_EDITOR_PRE_SAVE = 9001

在编辑器中保存有节点的场景之前收到的通知。这个通知只在 Godot 编辑器中发送，不会出现在导出的项目中。

NOTIFICATION_EDITOR_POST_SAVE = 9002

在编辑器中保存有节点的场景后立即收到通知。这个通知只在 Godot 编辑器中发送，在导出的项目中不会出现。

NOTIFICATION_WM_MOUSE_ENTER = 1002

鼠标进入窗口时收到的通知。

为内嵌窗口实现，并在桌面和 Web 平台上实现。

NOTIFICATION_WM_MOUSE_EXIT = 1003

鼠标离开窗口时收到的通知。

为内嵌窗口实现，并在桌面和 Web 平台上实现。

NOTIFICATION_WM_WINDOW_FOCUS_IN = 1004

当该节点的父 Window 获得焦点时收到的通知。可能是在同一引擎实例的两个窗口之间的焦点变化，也可能是从操作系统桌面或第三方应用程序切换到游戏的某个窗口（在这种情况下，还会发出 NOTIFICATION_APPLICATION_FOCUS_IN）。

Window 节点会在获得焦点时收到该通知。

NOTIFICATION_WM_WINDOW_FOCUS_OUT = 1005

当该节点的父 Window 失去焦点时收到的通知。可能是在同一引擎实例的两个窗口之间的焦点变化，也可能是从游戏的某个窗口切换到操作系统桌面或第三方应用程序（在这种情况下，还会发出 NOTIFICATION_APPLICATION_FOCUS_OUT）。

Window 节点会在失去焦点时收到该通知。

NOTIFICATION_WM_CLOSE_REQUEST = 1006

当发出关闭请求时，从操作系统收到的通知（例如使用“关闭”按钮或按下 Alt + F4 关闭窗口时）。

在桌面平台上实现。

NOTIFICATION_WM_GO_BACK_REQUEST = 1007

当发出返回请求时，从操作系统收到的通知（例如在 Android 系统上按下“返回”按钮）。

仅限 Android 平台。

NOTIFICATION_WM_SIZE_CHANGED = 1008

当窗口大小发生改变时，从操作系统收到的通知。

NOTIFICATION_WM_DPI_CHANGE = 1009

当屏幕的 DPI 发生更改时，从操作系统受到的通知。仅在 macOS 上实现。

NOTIFICATION_VP_MOUSE_ENTER = 1010

当鼠标指针进入 Viewport 的可见区域时收到的通知，可见区域指没有被其他 Control 和 Window 遮挡的区域，并且需要 Viewport.gui_disable_input 为 false，与当前是否持有焦点无关。

NOTIFICATION_VP_MOUSE_EXIT = 1011

当鼠标指针离开 Viewport 的可见区域时收到的通知，可见区域指没有被其他 Control 和 Window 遮挡的区域，并且需要 Viewport.gui_disable_input 为 false，与当前是否持有焦点无关。

NOTIFICATION_OS_MEMORY_WARNING = 2009

当应用程序超过其分配的内存时，从操作系统收到的通知。

仅限 iOS 平台。

NOTIFICATION_TRANSLATION_CHANGED = 2010

当翻译可能发生变化时收到的通知。会在用户改变区域设置时触发。可以用来响应语言的变化，例如实时改变 UI 字符串。可配合内置的翻译支持使用，比如 Object.tr。

NOTIFICATION_WM_ABOUT = 2011

当发出“关于”信息请求时，从操作系统收到的通知。

仅限 macOS 平台。

NOTIFICATION_CRASH = 2012

当引擎即将崩溃时，从Godot的崩溃处理程序收到的通知。

如果崩溃处理程序被启用，这只会在桌面平台上实现。

NOTIFICATION_OS_IME_UPDATE = 2013

当输入法引擎发生更新时，从操作系统收到的通知（例如，IME 光标位置或组成字符串的变化）。

仅限 macOS 平台。

NOTIFICATION_APPLICATION_RESUMED = 2014

当应用程序恢复时，从操作系统收到的通知。

仅限 Android 平台。

NOTIFICATION_APPLICATION_PAUSED = 2015

当应用程序暂停时，从操作系统收到的通知。

仅限 Android 平台。

NOTIFICATION_APPLICATION_FOCUS_IN = 2016

当应用程序获得焦点时从操作系统收到的通知，即焦点将从操作系统桌面或第三方应用程序更改为 Godot 实例的任何一个打开窗口时。

在桌面平台上被实现。

NOTIFICATION_APPLICATION_FOCUS_OUT = 2017

当应用程序失去焦点时从操作系统收到通知，即焦点将从 Godot 实例的任何一个打开窗口，更改为操作系统桌面或第三方应用程序时。

在桌面平台上被实现。

NOTIFICATION_TEXT_SERVER_CHANGED = 2018

文本服务器被更改时，收到的通知。

属性说明

String editor_description = ""

• void set_editor_description ( String value )

• String get_editor_description ( )

为该节点添加自定义描述。该节点在编辑器的场景树中处于悬停状态时，该描述将显示在工具提示中。

MultiplayerAPI multiplayer

• MultiplayerAPI get_multiplayer ( )

与该节点关联的 MultiplayerAPI 实例。见 SceneTree.get_multiplayer。

注意：将节点重命名或者在树中移动都不会将 MultiplayerAPI 移动至新的路径，你需要手动进行更新。

StringName name

• void set_name ( StringName value )

• StringName get_name ( )

该节点的名称。这个名称在兄弟节点（来自同一父节点的其他子节点）中是唯一的。当设置为现有名称时，节点将自动重命名。

注意：自动生成的名称可能包含 @ 字符，在使用 add_child 时保留该字符用于唯一名称。手动设置名称时，将删除任何 @。

Node owner

• void set_owner ( Node value )

• Node get_owner ( )

该节点的所有者。节点的所有者可以是任何祖先节点（即父节点、祖父节点等沿场景树向上的节点）。也就是说，应该在设置所有者之前调用 add_child，这样才能存在父子关系。（通过 PackedScene）保存节点时，它拥有的所有节点也会随之保存。这样就可以创建复杂的场景树，能够进行实例化和子实例化。

注意：如果想要将子节点持久化进 PackedScene，除了调用 add_child 之外还必须设置 owner。通常在工具脚本和编辑器插件中会用到。如果将新节点添加到了场景树中但没有将场景树中的祖先设置为所有者，那么这个节点在 2D/3D 视图中可见，但在场景树中不可见（也不会在打包或保存时进行持久化）。

ProcessMode process_mode = 0

• void set_process_mode ( ProcessMode value )

• ProcessMode get_process_mode ( )

可用于暂停或取消暂停该节点，也可以让该节点根据 SceneTree 来暂停，还可以让它继承父级的处理模式（默认）。

int process_physics_priority = 0

• void set_physics_process_priority ( int value )

• int get_physics_process_priority ( )

与 process_priority 类似，但是作用于 NOTIFICATION_PHYSICS_PROCESS、_physics_process 以及内部版本。

int process_priority = 0

• void set_process_priority ( int value )

• int get_process_priority ( )

该节点在已启用的处理回调（即 NOTIFICATION_PROCESS、NOTIFICATION_PHYSICS_PROCESS 及其内部对应物）的执行顺序中的优先级。进程优先级值较低的节点将首先执行其处理回调。

ProcessThreadGroup process_thread_group = 0

• void set_process_thread_group ( ProcessThreadGroup value )

• ProcessThreadGroup get_process_thread_group ( )

设置这个节点的处理线程组（基本上就是在主线程还是子线程中接收 NOTIFICATION_PROCESS、NOTIFICATION_PHYSICS_PROCESS、_process、_physics_process 以及这些回调的内部版本）。

默认情况下线程组为 PROCESS_THREAD_GROUP_INHERIT，表示这个节点属于和父节点一样的线程组。同一线程组中的节点会一起处理，独立于其他线程组（由 process_thread_group_order 决定）。如果设为 PROCESS_THREAD_GROUP_SUB_THREAD，则该线程组会在子线程（非主线程）中执行，否则设为 PROCESS_THREAD_GROUP_MAIN_THREAD 就会在主线程中处理。如果父节点和先祖节点都没有设置为非继承，则该节点属于默认线程组。默认分组在主线程中处理，分组顺序为 0。

在子线程中处理时，线程组之外的大多数函数都禁止访问（调试模式下会报错）。请使用 Object.call_deferred、call_thread_safe、call_deferred_thread_group 等方法与主线程（或其他线程组）通信。

线程组更好的理解方式是，非 PROCESS_THREAD_GROUP_INHERIT 的节点都会将设为继承的子节点（以及后续子孙节点）纳入它的处理线程组。这样该分组中的节点就会一起处理，包括包含它们的节点。

int process_thread_group_order

• void set_process_thread_group_order ( int value )

• int get_process_thread_group_order ( )

修改处理线程组的顺序。顺序取值较小的分组会在较大的分组前处理。例如，可以让大量的节点先在子线程中处理，然后另一组节点要在主线程中获取它们的处理结果。

BitField<ProcessThreadMessages> process_thread_messages

• void set_process_thread_messages ( BitField<ProcessThreadMessages> value )

• BitField<ProcessThreadMessages> get_process_thread_messages ( )

设置当前线程组是否会在线程中处理消息（调用 call_deferred_thread_group），以及是否需要在常规处理和物理处理回调中接收消息。

String scene_file_path

• void set_scene_file_path ( String value )

• String get_scene_file_path ( )

如果一个场景是从一个文件实例化来的，则其最顶层的节点的 scene_file_path 中，将包含它从何处被加载的绝对文件路径（例如 res://levels/1.tscn）。否则 scene_file_path 被设置为一个空字符串。

bool unique_name_in_owner = false

• void set_unique_name_in_owner ( bool value )

• bool is_unique_name_in_owner ( )

将这个节点的名称设置为其 owner 中的唯一名称。这样就可以从该场景中的任意节点处使用 %名称 来访问这个节点，无需使用完整路径。

如果所有者相同的另一个节点已经将该名称声明为唯一，那么其他节点就无法再将此名称设置为唯一名称。

方法说明

void _enter_tree ( ) virtual

当节点进入 SceneTree 时调用（例如实例化时，场景改变时，或者在脚本中调用 add_child 后）。如果节点有子节点，则首先调用它的 _enter_tree 回调函数，然后再调用子节点的回调函数。

对应于 Object._notification 中的 NOTIFICATION_ENTER_TREE 通知。

void _exit_tree ( ) virtual

当节点即将离开 SceneTree 时被调用（例如，在释放、场景改变或在脚本中调用 remove_child 后）。如果该节点有子节点，它的 _exit_tree 回调将在所有子节点离开树后被最后调用。

对应于 Object._notification 中的 NOTIFICATION_EXIT_TREE 通知和 tree_exiting 信号。要在节点已经离开活动树时得到通知，请连接到 tree_exited。

PackedStringArray _get_configuration_warnings ( ) virtual const

如果覆盖这个方法的脚本是 tool 脚本，那么这个函数所返回的数组中的元素会在“场景”面板中显示为警告。

返回空数组不会生成警告。

这个节点的警告需要更新时，请调用 update_configuration_warnings。

@export var energy = 0:
    set(value):
        energy = value
        update_configuration_warnings()
func _get_configuration_warnings():
    if energy < 0:
        return ["Energy 必须大于等于 0。"]
    else:
        return []

void _input ( InputEvent event ) virtual

有输入事件时会被调用。输入事件会沿节点树向上传播，直到有节点将其消耗。

只有在启用输入处理时才会被调用，如果该方法被重写则会自动启用，可以使用 set_process_input 进行切换。

要消耗输入事件，阻止它进一步传播到其他节点，可以调用 Viewport.set_input_as_handled。

对于游戏输入，_unhandled_input 和 _unhandled_key_input 通常更适合，因为它们允许 GUI 首先拦截事件。

注意：仅当该节点存在于场景树中时（即不是孤立节点），此方法才会被调用。

void _physics_process ( float delta ) virtual

在主循环的物理处理步骤中被调用。物理处理意味着帧率与物理同步，即 delta 变量应该是常量。 delta 的单位是秒。

只有当物理处理被启用时才会被调用，如果这个方法被重写，就会自动被调用，并且可以使用 set_physics_process 进行切换。

对应于 Object._notification 中的 NOTIFICATION_PHYSICS_PROCESS 通知。

注意：这个方法只有在当节点存在于场景树中时才会被调用（也就是说，如果它不是“孤儿”）。

void _process ( float delta ) virtual

在主循环的处理步骤中被调用。处理发生在每一帧，并且尽可能快，所以从上一帧开始的 delta 时间不是恒定的。delta 的单位是秒。

只有在启用处理的情况下才会被调用，如果这个方法被重写，会自动进行处理，可以用 set_process 来开关。

对应于 Object._notification 中的 NOTIFICATION_PROCESS 通知。

注意：这个方法只有在节点存在于场景树中时才会被调用（也就是说，如果它不是“孤儿”）。

void _ready ( ) virtual

当节点“就绪”时被调用，即当节点及其子节点都已经进入场景树时。如果该节点有子节点，将首先触发子节点的 _ready 回调，稍后父节点将收到就绪通知。

对应 Object._notification 中的 NOTIFICATION_READY 通知。另请参阅用于变量的 @onready 注解。

通常用于初始化。对于更早的初始化，可以使用 Object._init。另见 _enter_tree。

注意：对于每个节点可能仅调用一次 _ready。从场景树中移除一个节点后，并再次添加该节点时，将不会第二次调用 _ready。这时可以通过使用 request_ready，它可以在再次添加节点之前的任何地方被调用。

void _shortcut_input ( InputEvent event ) virtual

当一个 InputEventKey 或 InputEventShortcut，尚未被 _input 或任何 GUI Control 项使用时调用。这是在 _unhandled_key_input 和 _unhandled_input 之前调用的。输入事件通过节点树向上传播，直到一个节点消耗它。

它仅在启用快捷键处理时调用，如果此方法被覆盖，则会自动调用，并且可以使用 set_process_shortcut_input 进行开关。

要消耗输入事件，并阻止它进一步传播到其他节点，可以调用 Viewport.set_input_as_handled。

此方法可用于处理快捷键。如果是常规的 GUI 事件，请改用 _input。游戏事件通常应该使用 _unhandled_input 或 _unhandled_key_input 处理。

注意：仅当该节点存在于场景树中（即它不是一个孤儿节点）时，此方法才会被调用。

void _unhandled_input ( InputEvent event ) virtual

当一个 InputEvent 尚未被 _input 或任何 GUI Control 项消耗时调用。这是在 _shortcut_input 和 _unhandled_key_input 之后调用的。输入事件通过节点树向上传播，直到一个节点消耗它。

只有在未处理的输入处理被启用时，才会被调用，如果该方法被重写，则会自动被调用，并且可以使用 set_process_unhandled_input 进行切换。

要消耗输入事件，并阻止它进一步传播到其他节点，可以调用 Viewport.set_input_as_handled。

对于游戏输入，这个方法通常比 _input 更合适，因为 GUI 事件需要更高的优先级。对于键盘快捷键，请考虑改用 _shortcut_input，因为是在这个方法之前调用的。最后，如果要处理键盘事件，那么出于性能方面的原因请考虑使用 _unhandled_key_input。

注意：仅当该节点存在于场景树中（即不是孤儿节点）时，该方法才会被调用。

void _unhandled_key_input ( InputEvent event ) virtual

当 InputEventKey 没有被 _input 或任何 GUI Control 项目消耗时调用。这是在 _shortcut_input 之后、_unhandled_input 之前调用的。输入事件通过节点树向上传播，直到某个节点将其消耗。

只有在启用了未处理按键输入处理时才会被调用，如果覆盖了这个方法就会自动启用，并且可以用 set_process_unhandled_key_input 来开关。

要消耗输入事件并阻止它进一步传播到其他节点，可以调用 Viewport.set_input_as_handled。

在处理快捷键后，此方法可用于使用 Alt、Alt + Ctrl 和 Alt + Shift 修饰符处理 Unicode 字符输入。

对于游戏输入，这和 _unhandled_input 通常比 _input 更适合，因为应该先处理 GUI 事件。该方法的性能也比 _unhandled_input 更好，因为 InputEventMouseMotion 等无关事件会被自动过滤。

注意：只有当节点存在于场景树中（即不是孤儿节点）时，该方法才会被调用。

void add_child ( Node node, bool force_readable_name=false, InternalMode internal=0 )

将 node 添加为子节点。节点可以有任意数量的子节点，但子节点的名称必须唯一。删除父节点时会自动删除子节点，因此可以通过删除最顶层的节点来删除整个场景。

如果 force_readable_name 为 true，则将提高所添加的 node 的可读性。如果尚未命名，node 将重命名为它的类型，如果存在 name 相同的兄弟节点，则会添加合适的数字后缀。这个操作很慢。因此，建议将其保留为 false，在这两种情况下会分配包含 @ 的虚拟名称。

如果 internal 不同于 INTERNAL_MODE_DISABLED，则该子节点将被添加为内部节点。get_children 等方法会忽略这种节点，除非它们的参数 include_internal 为 true。这种功能的设计初衷是对用户隐藏内部节点，这样用户就不会意外删除或修改这些节点。部分 GUI 节点会使用这个功能，例如 ColorPicker。可用的模式见 InternalMode。

注意：如果子节点已经有父节点，则该函数会失败。请先使用 remove_child 将节点从当前父节点中移除。例如：

GDScriptC#

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

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

如果你需要将子节点添加到子节点列表中特定节点的下方，请使用 add_sibling 而不是该方法。

注意：如果想让子节点持久化到某个 PackedScene 的，除了调用 add_child 之外，还必须设置 owner。通常在工具脚本和编辑器插件中会用到。如果在没有设置 owner，只调用了 add_child，则新添加的 Node 在场景树中将不可见，但在 2D/3D 视图中却是可见的。

void add_sibling ( Node sibling, bool force_readable_name=false )

将一个 sibling 节点添加到当前节点的父节点，与该节点处于同一级别，就在它的正下方。

如果 force_readable_name 为 true，则提高添加的 sibling 的可读性。如果没有命名，sibling 将被重命名为它的类型，如果它与一个同级节点共享 name，则添加一个更合适的数字后缀。这个操作很慢。因此，建议将其保留为 false，这会在两种情况下分配一个以 @ 为特色的虚拟名称。

如果不需要将该子节点添加到子列表中特定节点的下方，请使用 add_child 而不是该方法。

注意：如果这个节点是内部的，则新的同级节点也将是内部的（参见 add_child 中的 internal 参数）。

void add_to_group ( StringName group, bool persistent=false )

将节点添加到一个组中。组是命名和组织节点子集的辅助工具，例如“敌人”或“收集品”等。一个节点可以在任意数量的组中。节点可以随时被分配到一个组中，但在它们进入场景树之前不会添加（参见 is_inside_tree）。参阅描述中的注释，以及 SceneTree 中的分组方法。

persistent 选项在将节点打包到 PackedScene 并保存到文件时使用。非持久化的组不会被存储。

注意：出于性能原因，不保证节点组的顺序。不应依赖节点组的顺序，因为它可能因项目运行而异。

Variant call_deferred_thread_group ( StringName method, … ) vararg

这个函数类似于 Object.call_deferred，但是会在处理节点线程组时进行调用。如果节点线程组在子线程中处理，那么调用就会在该线程中进行，时机为 NOTIFICATION_PROCESS 和 NOTIFICATION_PHYSICS_PROCESS、_process 和 _physics_process，或者对应的内部版本之前。

Variant call_thread_safe ( StringName method, … ) vararg

这个函数能够确保调用成功，无论是否从线程中调用。如果是从不允许调用该函数的线程中调用的，那么调用就会变成延迟调用。否则就会直接调用。

bool can_process ( ) const

如果场景树暂停时节点可以处理（请参阅 process_mode），则返回 true。如果场景树未被暂停，则始终返回 true，如果该节点不在树中，则始终返回 false。

Tween create_tween ( )

新建 Tween 并将其绑定到这个节点。与如下操作等价：

GDScriptC#

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

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

该 Tween 将在下一个处理帧或物理处理帧时自动开始（取决于 TweenProcessMode）。

Node duplicate ( int flags=15 ) const

复制该节点，返回一个新的节点。

可以使用 flags 微调该行为（请参阅 DuplicateFlags）。

注意：如果节点包含一个带有构造参数的脚本（即需要向 Object._init 方法提供参数），它将无法正常工作。在这种情况下，节点将在没有脚本的情况下被复制。

Node find_child ( String pattern, bool recursive=true, bool owned=true ) const

查找此节点的后代中，其名称与 String.match 中的 pattern 匹配的第一个节点。也会查找内部子节点（见 add_child 的 internal 参数）。

pattern 不匹配完整路径，只匹配单个节点名称。它区分大小写，"*" 匹配零个或多个字符，"?" 匹配除 "." 之外的任意单个字符。

如果 recursive 为 true，则查找范围包括所有子节点，即使嵌套很深。节点按树顺序检查，因此首先检查该节点的第一个直接子节点，然后是该直接子节点的直接子节点，等等，然后移动到第二个直接子节点，依此类推。如果 recursive 为 false，则仅匹配该节点的直接子节点。

如果 owned 为 true，则该方法仅查找分配有 owner 的节点。这对于通过脚本实例化的场景尤其重要，因为这些场景没有所有者。

如果找不到匹配的 Node，则返回 null。

注意：由于该方法会遍历节点的所有后代，因此它是获取对另一个节点的引用的最慢方法。只要有可能，请考虑改用使用唯一名称的 get_node（请参阅 unique_name_in_owner），或将该节点引用缓存到变量中。

注意：要查找匹配一个模式或类类型的所有后代节点，请参阅 find_children。

Node[] find_children ( String pattern, String type=””, bool recursive=true, bool owned=true ) const

查找该节点的后代节点，其名称与 String.match 中的 pattern 匹配，和/或类型与 Object.is_class 中的 type 匹配。也会查找内部子节点（见 add_child 的 internal 参数）。

pattern 不匹配完整路径，只匹配单个节点名称。它区分大小写，"*" 匹配零个或多个字符，"?" 匹配除 "." 之外的任意单个字符。

type 将检查相等性或继承关系，并且区分大小写。"Object" 会匹配类型为 "Node" 的节点，但反之则不然。

如果 recursive 为 true，则匹配范围包括所有子节点，即使嵌套很深。节点按树顺序检查，因此首先检查该节点的第一个直接子节点，然后是该直接子节点的直接子节点，等等，然后移动到第二个直接子节点，依此类推。如果 recursive 为 false，则仅匹配该节点的直接子节点。

如果 owned 为 true，则该方法仅查找分配有 owner 的节点。这对于通过脚本实例化的场景尤其重要，因为这些场景没有所有者。

如果找不到匹配的节点，则返回空数组。

注意：由于该方法会遍历节点的所有后代，因此它是获取对其他节点的引用的最慢方法。只要有可能，请考虑将节点引用缓存到变量中。

注意：如果只想查找匹配模式的第一个后代节点，请参阅 find_child。

Node find_parent ( String pattern ) const

查找当前节点的第一个父节点，其名称与 String.match 中的 pattern 匹配。

pattern 不匹配完整路径，只匹配单个节点名称。它区分大小写，"*" 匹配零个或多个字符，"?" 匹配除 "." 之外的任意单个字符。

注意：由于该方法在场景树中向上遍历，因此在大型、深度嵌套的场景树中可能会很慢。只要有可能，请考虑使用具有唯一名称的 get_node（请参阅 unique_name_in_owner），或将该节点引用缓存到变量中。

Node get_child ( int idx, bool include_internal=false ) const

按索引返回一个子节点（见 get_child_count）。这个方法经常被用于遍历一个节点的所有子节点。

负索引将从最后一个开始访问子节点。

如果 include_internal 为 false，则跳过内部子节点（见 add_child 中的 internal 参数）。

要通过名称访问一个子节点，请使用 get_node。

int get_child_count ( bool include_internal=false ) const

返回子节点的数量。

如果 include_internal 为 false ，则不计算内部子节点（见 add_child 的 internal 参数）。

Node[] get_children ( bool include_internal=false ) const

返回一组对节点子节点的引用。

如果 include_internal 为 false，则返回的数组将不包含内部子节点（见 add_child 中的 internal 参数）。

StringName[] get_groups ( ) const

返回一个列出该节点所属的分组的数组。

注意：出于性能原因，不保证节点分组的顺序。 不应依赖节点分组的顺序，因为它可能因项目运行而异。

注意：引擎在内部使用了一些分组名称（全部以下划线开头）。为避免与内部分组冲突，请勿添加名称以下划线开头的自定义分组。要在遍历 get_groups 时排除内部分组，请使用以下代码段：

GDScriptC#

# 仅存储节点的非内部分组（作为一个字符串数组）。
var non_internal_groups = []
for group in get_groups():
    if not group.begins_with("_"):
        non_internal_groups.push_back(group)

// 仅存储节点的非内部分组（作为一个字符串列表）。
List<string> nonInternalGroups = new List<string>();
foreach (string group in GetGroups())
{
    if (!group.BeginsWith("_"))
        nonInternalGroups.Add(group);
}

int get_index ( bool include_internal=false ) const

返回节点在场景树分支中的顺序。例如，如果在第一个子节点上调用，则位置为 0。

如果 include_internal 为 false，则索引将不会考虑内部子节点，即第一个非内部子节点的索引将为 0（见 add_child 中的 internal 参数）。

Window get_last_exclusive_window ( ) const

返回包含该节点的 Window，或者是从包含该节点的窗口开始的窗口链中最近的独占子项。

int get_multiplayer_authority ( ) const

返回这个节点多人游戏控制者的对等体 ID。见 set_multiplayer_authority。

Node get_node ( NodePath path ) const

获取一个节点。NodePath 可以是到一个节点的相对路径（从当前节点）或绝对路径（在场景树中）。如果该路径不存在，则返回 null 并记录一个错误。尝试访问该返回值上的方法，将产生一个“尝试在一个 null 实例上调用 <method>。”错误。

注意：获取绝对路径，仅在节点位于场景树内部时有效（参见 is_inside_tree）。

示例：假设你当前的节点是 Character 和以下树：

/root
/root/Character
/root/Character/Sword
/root/Character/Backpack/Dagger
/root/MyGame
/root/Swamp/Alligator
/root/Swamp/Mosquito
/root/Swamp/Goblin

可能的路径有：

GDScriptC#

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

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

Array get_node_and_resource ( NodePath path )

按照 NodePath 的子名称（例如 Area2D/CollisionShape2D:shape）指定的方式，获取节点及其一个资源。如果在 NodePath 中指定了多个嵌套资源，则将获取最后一个。

返回值是一个大小为 3 的数组：第一个索引指向该 Node（如果未找到，则为 null），第二个索引指向 Resource（或者未找到时为 null），第三个索引是剩余的 NodePath，如果有的话。

例如，假设 Area2D/CollisionShape2D 是一个有效的节点，并且它的 shape 属性已被分配了一个 RectangleShape2D 资源，那么可以得到这样的输出：

GDScriptC#

print(get_node_and_resource("Area2D/CollisionShape2D")) # [[CollisionShape2D:1161], Null, ]
print(get_node_and_resource("Area2D/CollisionShape2D:shape")) # [[CollisionShape2D:1161], [RectangleShape2D:1156], ]
print(get_node_and_resource("Area2D/CollisionShape2D:shape:extents")) # [[CollisionShape2D:1161], [RectangleShape2D:1156], :extents]

GD.Print(GetNodeAndResource("Area2D/CollisionShape2D")); // [[CollisionShape2D:1161], Null, ]
GD.Print(GetNodeAndResource("Area2D/CollisionShape2D:shape")); // [[CollisionShape2D:1161], [RectangleShape2D:1156], ]
GD.Print(GetNodeAndResource("Area2D/CollisionShape2D:shape:extents")); // [[CollisionShape2D:1161], [RectangleShape2D:1156], :extents]

Node get_node_or_null ( NodePath path ) const

类似于 get_node，但在 path 没有指向有效的 Node 时不会记录错误。

Node get_parent ( ) const

返回当前节点的父节点，如果节点缺少父节点，则返回 null。

NodePath get_path ( ) const

返回当前节点的绝对路径。这只在当前节点在场景树中起作用（见 is_inside_tree）。

NodePath get_path_to ( Node node, bool use_unique_path=false ) const

返回从该节点到指定节点 node 的相对 NodePath。这两个节点都必须在同一个场景中，否则函数会失败。

如果 use_unique_path 为 true，则会返回考虑唯一节点的最短路径。

注意：如果你获取了从唯一节点开始的相对路径，则该路径可能由于唯一节点的名称长度而比普通的相对路径长。

float get_physics_process_delta_time ( ) const

返回自上一个物理绑定帧以来经过的时间（单位为秒）（见 _physics_process）。除非通过 Engine.physics_ticks_per_second 更改每秒帧数，否则这在物理处理中始终是一个恒定值。

float get_process_delta_time ( ) const

返回自上次处理回调以来经过的时间（单位为秒）。这个值可能因帧而异。

bool get_scene_instance_load_placeholder ( ) const

如果这是一个实例加载占位符，则返回 true。见 InstancePlaceholder。

SceneTree get_tree ( ) const

返回包含该节点的 SceneTree。如果该节点不在场景树内，则返回 null 并打印错误。另见 is_inside_tree。

String get_tree_string ( )

将树以 String 的形式返回。主要用于调试。这个版本显示相对于当前节点的路径，适合复制/粘贴到 get_node 函数中。也可以用于游戏中的 UI/UX。

示例输出：

TheGame
TheGame/Menu
TheGame/Menu/Label
TheGame/Menu/Camera2D
TheGame/SplashScreen
TheGame/SplashScreen/Camera2D

String get_tree_string_pretty ( )

类似于 get_tree_string，会将树以 String 的形式返回。这个版本使用的是一种更加图形化的呈现方式，类似于在“场景”面板中显示的内容。非常适合检查较大的树。

输出示例：

┖╴TheGame
   ┠╴Menu
   ┃  ┠╴Label
   ┃  ┖╴Camera2D
   ┖╴SplashScreen
      ┖╴Camera2D

Viewport get_viewport ( ) const

返回节点的 Viewport。

Window get_window ( ) const

返回包含该节点的 Window。如果该节点在主窗口中，则相当于获取根节点（get_tree().get_root()）。

bool has_node ( NodePath path ) const

如果 NodePath 指向的节点存在，则返回 true。

bool has_node_and_resource ( NodePath path ) const

如果 NodePath 指向一个有效的节点，并且它的子名称指向一个有效的资源，例如 Area2D/CollisionShape2D:shape，则返回 true。具有非 Resource 类型的属性（例如节点或基本数学类型）不被认为是资源。

bool is_ancestor_of ( Node node ) const

如果给定节点是当前节点的直接或间接子节点，则返回 true。

bool is_displayed_folded ( ) const

如果该节点在“场景”面板中被折叠，则返回 true。该方法仅适用于编辑器工具。

bool is_editable_instance ( Node node ) const

如果 node 有与相对于此节点的可编辑子节点，则返回 true。该方法仅适用于编辑器工具。

bool is_greater_than ( Node node ) const

如果给定节点在场景层次结构中出现的时间晚于当前节点，则返回 true。

bool is_in_group ( StringName group ) const

如果该节点在指定的组中，则返回 true。参阅描述中的注释和 SceneTree 中的组方法。

bool is_inside_tree ( ) const

如果该节点当前在 SceneTree 中，返回 true。

bool is_multiplayer_authority ( ) const

如果本地系统为这个节点的多人游戏控制者，则返回 true。

bool is_node_ready ( ) const

如果该节点已就绪，则返回 true，即该节点位于场景树中，并且所有子项均已初始化。

request_ready 会将其重置回 false。

bool is_physics_processing ( ) const

如果启用了物理处理，返回 true（见 set_physics_process）。

bool is_physics_processing_internal ( ) const

如果内部物理处理被启用，返回 true（见 set_physics_process_internal）。

bool is_processing ( ) const

如果开启了处理，返回 true（见 set_process）。

bool is_processing_input ( ) const

如果节点正在处理输入，则返回 true（见 set_process_input）。

bool is_processing_internal ( ) const

如果启用了内部处理，则返回 true（见 set_process_internal）。

bool is_processing_shortcut_input ( ) const

如果节点正在处理快捷键，则返回 true（见 set_process_shortcut_input）。

bool is_processing_unhandled_input ( ) const

如果节点正在处理未被处理的输入，则返回 true（见 set_process_unhandled_input）。

bool is_processing_unhandled_key_input ( ) const

如果节点正在处理未被处理的键输入，则返回 true（见 set_process_unhandled_key_input）。

void move_child ( Node child_node, int to_index )

在其他子节点中将子节点移动到不同的索引（顺序）。由于调用、信号等是按树顺序执行的，因此更改子节点的顺序可能会很有用。如果 to_index 为负数，索引将从末尾开始计算。

注意：内部子节点只能在其期望的“内部范围”内移动（参见 add_child 中的 internal 参数）。

void notify_deferred_thread_group ( int what )

类似于 call_deferred_thread_group，但针对的是通知。

void notify_thread_safe ( int what )

类似于 call_thread_safe，但针对的是通知。

void print_orphan_nodes ( ) static

输出所有孤立节点（SceneTree 之外的节点）。用于调试。

注意：print_orphan_nodes 只在调试版本中有效。在以发布模式导出的项目中调用时，print_orphan_nodes 不会输出任何内容。

void print_tree ( )

将树打印到标准输出。主要用于调试。这个版本显示相对于当前节点的路径，适合复制/粘贴到 get_node 函数中。

示例输出：

TheGame
TheGame/Menu
TheGame/Menu/Label
TheGame/Menu/Camera2D
TheGame/SplashScreen
TheGame/SplashScreen/Camera2D

void print_tree_pretty ( )

类似于 print_tree，会将树打印到标准输出。这个版本显示了一种更加图形化的表示方式，类似于在场景面板中显示的内容。非常适合检查较大的树。

输出示例：

┖╴TheGame
   ┠╴Menu
   ┃  ┠╴Label
   ┃  ┖╴Camera2D
   ┖╴SplashScreen
      ┖╴Camera2D

void propagate_call ( StringName method, Array args=[], bool parent_first=false )

在该节点上并递归地在其所有子节点上，使用 args 中给出的参数调用给定方法（如果存在）。如果 parent_first 参数为 true，则该方法将首先在当前节点上调用，然后在其所有子节点上调用。如果 parent_first 为 false，则子节点上的方法将首先被调用。

void propagate_notification ( int what )

通过对所有节点调用 Object.notification，递归地通知当前节点和它的所有子节点。

void queue_free ( )

将节点加入队列，在当前帧结束时删除。节点被删除时，它的所有子节点也将被删除，对该节点及其子节点的引用也会失效，见 Object.free。

同一帧可以对同一个节点调用多次 queue_free，也可以 Object.free 已经排队删除的节点。请使用 Object.is_queued_for_deletion 检查节点是否将在帧结束时被删除。

该节点会在所有其他已延迟的调用结束后释放，所以使用 queue_free 并不总是和通过 Object.call_deferred 调用 Object.free 相同。

void remove_child ( Node node )

删除一个子节点。该节点不会被删除，必须手动删除。

注意：如果该 owner 不再是父节点或祖先，则该函数可以将被移除节点（或其后代）的 owner 设置为 null。

void remove_from_group ( StringName group )

从 group 中移除一个节点。如果该节点不在 group 中，则不执行任何操作。见描述中的注意项，以及 SceneTree 中的分组方法。

void reparent ( Node new_parent, bool keep_global_transform=true )

将这个 Node 的父节点更改为 new_parent。该节点需要拥有父节点。

如果 keep_global_transform 为 true，则会在支持时保持该节点的全局变换。Node2D、Node3D、Control 支持这个参数（但 Control 只会保留位置）。

void replace_by ( Node node, bool keep_groups=false )

将场景中的某个节点替换为给定的节点。经过该节点的订阅会丢失。

如果 keep_groups 为 true，则 node 被添加到被替换节点所在的相同分组中。

注意：给定的节点将成为被替换节点的所有子节点的新的父节点。

注意：被替换的节点不会被自动释放，因此需要将其保存在变量中以备后用，或者使用 Object.free 释放它。

void request_ready ( )

请求再次调用 _ready。注意，该方法不会被立即调用，而是被安排在该节点再次被添加到场景树时。只会为进行了请求的节点调用 _ready，也就是说，如果你想让每个子节点都调用 _ready，就需要为它们分别进行就绪请求（在这种情况下，_ready 的调用顺序与正常情况下相同）。

Error rpc ( StringName method, … ) vararg

将给定 method 的远程过程调用请求发送到网络（和本地）上的对等体，可选择将所有其他参数作为参数发送给 RPC 调用的方法。调用请求只会被具有相同 NodePath 的节点接收，该节点包括完全相同的节点名称。行为取决于给定方法的 RPC 配置，请参阅 rpc_config 和 @GDScript.@rpc。默认情况下，方法不会暴露给 RPC。返回 null。

注意：只有在收到来自 MultiplayerAPI 的 connected_to_server 信号后，才能在客户端上安全地使用 RPC。还需要跟踪连接状态，可通过 MultiplayerAPI 信号（例如 server_disconnected）或检查 get_multiplayer().peer.get_connection_status() == CONNECTION_CONNECTED 来跟踪。

void rpc_config ( StringName method, Variant config )

将给定方法 method 的 RPC 模式更改为给定的配置 config，该配置应该是 null（表示禁用）或者是以下形式的 Dictionary：

{
    rpc_mode = MultiplayerAPI.RPCMode,
    transfer_mode = MultiplayerPeer.TransferMode,
    call_local = false,
    channel = 0,
}

见 RPCMode 和 TransferMode。另一种选择是使用相应的 @GDScript.@rpc 注解对方法和属性进行注解（例如 @rpc("any_peer")、@rpc("authority")）。默认情况下，方法不会被暴露给网络（和 RPC）。

Error rpc_id ( int peer_id, StringName method, … ) vararg

向指定的对等体发送 rpc，对等体由 peer_id 标识（见 MultiplayerPeer.set_target_peer）。返回 null。

void set_deferred_thread_group ( StringName property, Variant value )

类似于 call_deferred_thread_group，但针对的是设置属性。

void set_display_folded ( bool fold )

设置该节点在“场景”面板中的折叠状态。这个方法仅适用于编辑器工具。

void set_editable_instance ( Node node, bool is_editable )

设置 node 相对于这个节点的可编辑子节点状态。这个方法仅适用于编辑器工具。

void set_multiplayer_authority ( int id, bool recursive=true )

将该节点的多人游戏控制方设置为具有给定对等体 ID 的对等体。多人游戏控制方是对网络上的节点具有控制权限的对等体。可以与 rpc_config 和 MultiplayerAPI 结合使用。默认为对等体 ID 1（服务器）。如果 recursive，则给定的对等体会被递归设置为该节点所有子节点的控制方。

警告：这样做不会自动将新的控制方复制给其他对等体。开发者需要自己负责。你可以使用 MultiplayerSpawner.spawn_function、RPC、MultiplayerSynchronizer 等方法将这个信息传播出去。另外，父节点的控制方不会传播给新添加的子节点。

void set_physics_process ( bool enable )

启用或禁用物理（即固定帧率）处理。当一个节点正在被处理时，它会在一个固定的（通常是 60 FPS，参见 Engine.physics_ticks_per_second 以更改）时间间隔，接收一个 NOTIFICATION_PHYSICS_PROCESS （如果存在 _physics_process 回调，该回调将被调用）。如果 _physics_process 被重写，则自动被启用。在 _ready 之前对该函数的任何调用，都将被忽略。

void set_physics_process_internal ( bool enable )

启用或禁用该节点的内部物理。内部物理处理与正常的 _physics_process 调用隔离进行，并且由某些节点内部使用，以确保正常工作，即使节点暂停或物理处理因脚本而禁用（set_physics_process）。仅适用于用于操纵内置节点行为的高级用途。

警告：内置节点依靠内部处理来实现自己的逻辑，所以从你的代码中改变这个值可能会导致意外的行为。为特定的高级用途提供了对此内部逻辑的脚本访问，但不安全且不支持。

void set_process ( bool enable )

启用或禁用帧处理。当一个节点被处理时，它将在每个绘制的帧上收到一个NOTIFICATION_PROCESS（如果存在，_process回调将被调用）。如果_process被重写，则自动启用。在 _ready 之前对它的任何调用都将被忽略。

void set_process_input ( bool enable )

启用或禁用输入处理。对于 GUI 控件来说不是必需的。如果 _input 被覆盖，则自动启用。任何在 _ready 之前对它的调用都将被忽略。

void set_process_internal ( bool enable )

启用或禁用此节点的内部处理。内部处理与正常的 _process 调用隔离进行，并且由某些节点内部使用，以确保正常工作，即使节点已暂停或处理因脚本而禁用（set_process）。仅适用于操纵内置节点行为的高级用途。

警告：内置节点依赖于内部处理来实现自己的逻辑，因此更改代码中的这个值可能会导致意外行为。为特定的高级用途提供了对此内部逻辑的脚本访问，但不安全且不支持。

void set_process_shortcut_input ( bool enable )

启用快捷键处理。如果 _shortcut_input 被覆盖，则自动启用。在 _ready 之前对此的任何调用都将被忽略。

void set_process_unhandled_input ( bool enable )

启用未处理的输入处理。这对 GUI 控件来说是不需要的！它使节点能够接收所有以前没有处理的输入（通常是由 Control 处理的）。如果 _unhandled_input 被覆盖，则自动启用。在 _ready 之前对它的任何调用都将被忽略。

void set_process_unhandled_key_input ( bool enable )

启用未处理的按键输入处理。如果 _unhandled_key_input 被重写，则自动启用。任何在 _ready 之前对它的调用都将被忽略。

void set_scene_instance_load_placeholder ( bool load_placeholder )

设置这是否是实例加载占位符。见 InstancePlaceholder。

void set_thread_safe ( StringName property, Variant value )

类似于 call_thread_safe，但用于设置属性。

void update_configuration_warnings ( )

更新在场景面板中为该节点显示的警告。

使用 _get_configuration_warnings 配置要显示的警告消息。

Previous Next

© 版权所有 2014-present Juan Linietsky, Ariel Manzur and the Godot community (CC BY 3.0). Revision b1c660f7.

Built with Sphinx using a theme provided by Read the Docs.