Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
Object
派生： AccessibilityServer, AudioServer, CameraServer, ClassDB, DisplayServer, EditorFileSystemDirectory, EditorInterface, EditorPaths, EditorSelection, EditorUndoRedoManager, EditorVCSInterface, Engine, EngineDebugger, FramebufferCacheRD, GDExtensionManager, Geometry2D, Geometry3D, GodotInstance, Input, InputMap, IP, JavaClassWrapper, JavaScriptBridge, JNISingleton, JSONRPC, MainLoop, Marshalls, MovieWriter, NativeMenu, NavigationMeshGenerator, NavigationServer2D, NavigationServer2DManager, NavigationServer3D, NavigationServer3DManager, Node, OpenXRExtensionWrapper, OpenXRInteractionProfileMetadata, OS, Performance, PhysicsDirectBodyState2D, PhysicsDirectBodyState3D, PhysicsDirectSpaceState2D, PhysicsDirectSpaceState3D, PhysicsServer2D, PhysicsServer2DManager, PhysicsServer3D, PhysicsServer3DManager, PhysicsServer3DRenderingServerHandler, ProjectSettings, RefCounted, RenderData, RenderingDevice, RenderingServer, RenderSceneData, ResourceLoader, ResourceSaver, ResourceUID, ScriptLanguage, ShaderIncludeDB, TextServerManager, ThemeDB, TileData, Time, TranslationServer, TreeItem, UndoRedo, UniformSetCacheRD, WorkerThreadPool, XRServer, XRVRS
引擎中所有其他类的基类。
描述
一种高级的 Variant 类型。引擎中的所有类都继承自 Object。每个类都可以定义新的属性、方法或信号，并且这些对所有继承的类都可用。例如，一个 Sprite2D 实例能够调用 Node.add_child() 因为它继承自 Node。
可以使用 GDScript 中的 Object.new() 或 C# 中的 new GodotObject 来创建新实例。
要删除一个 Object 实例，请调用 free()。这对于大多数继承 Object 的类来说是必须的，因为它们本身并不管理内存，如果不调用该方法的话，在不再使用时会造成内存泄漏。有几个类会执行内存管理。例如，RefCounted（以及扩展的 Resource）在不再被引用时删除自身，而 Node 在释放时会删除其子节点。
对象可以附加一个 Script。一旦该 Script 被实例化，它就有效地充当了基类的扩展，允许它定义和继承新的属性、方法和信号。
在 Script 中，_get_property_list() 可以被可以重写，以通过多种方式自定义属性。这允许它们对编辑器可用，显示为选项列表，细分为组，保存在磁盘上，等等。脚本语言提供更简单的方式来自定义属性，例如使用 @GDScript.@export 注解。
Godot 是非常动态的。一个对象的脚本，以及它的属性、方法和信号，都可以在运行时改变。正因为如此，可能会出现这样的情况，例如，一个方法所需的属性可能不存在。为了防止运行时出错，可以参考 set()、get()、call()、has_method()、has_signal() 等方法。请注意，这些方法比直接引用慢得多。
在 GDScript 中，还可以使用 in 运算符来检查对象中是否存在给定的属性、方法或信号名称：
var node = Node.new()
print("name" in node) # 输出 true
print("get_parent" in node) # 输出 true
print("tree_entered" in node) # 输出 true
print("unknown" in node) # 输出 false
通知是 int 常量，通常由对象发送和接收。例如，在每个渲染帧上，SceneTree 使用 Node.NOTIFICATION_PROCESS 通知树内的节点。节点收到它后，可以调用 Node._process() 进行更新。要使用通知，请参阅 notification() 和 _notification()。
最后，每个对象还可以包含元数据（关于数据的数据）。set_meta() 可用于存储对象本身不依赖的信息。为了保持代码整洁，不鼓励过度使用元数据。
注意：与对 RefCounted 的引用不同，对存储在变量中的对象的引用，可能会在未被设置为 null 的情况下变得无效。要检查对象是否已被删除，请不要将其与 null 进行比较。而是使用 @GlobalScope.is_instance_valid()。存储数据的类，建议从 RefCounted 继承而不是 Object。
注意：script 不像大多数属性那样公开。要在代码中设置或获取一个对象的 Script，请分别使用 set_script() 和 get_script()。
注意：在布尔值上下文中，Object 等于 null 或已释放时会求值为 false。否则 Object 始终求值为 true。 另见 @GlobalScope.is_instance_valid()。
教程
方法
信号
property_list_changed() 🔗
调用 notify_property_list_changed() 时发出。
script_changed() 🔗
该对象的脚本发生改变时发出。
注意：发出这个信号时，新脚本还没有初始化。如果你需要访问新脚本，请用 CONNECT_DEFERRED 推迟与这个信号的连接。
枚举
flags ConnectFlags: 🔗
ConnectFlags CONNECT_DEFERRED = 1
延迟连接会在空闲时触发 Callable（当前帧的末尾），不会立即触发。
ConnectFlags CONNECT_PERSIST = 2
持久连接会在序列化对象时存储（比如使用 PackedScene.pack() 时）。在编辑器中，通过“信号”面板创建的连接总是持久的。
注意：与 Lambda 函数（即函数代码嵌入在 connect() 调用中的）的连接无法持久化。
ConnectFlags CONNECT_ONE_SHOT = 4
一次性连接，会在触发后自行断开。
ConnectFlags CONNECT_REFERENCE_COUNTED = 8
引用计数连接可以多次分配给同一个 Callable。每断开一次连接会让内部计数器减一。信号会在计数器变为 0 时完全断开连接。
ConnectFlags CONNECT_APPEND_SOURCE_OBJECT = 16
信号发出时，源对象会自动追加到信号的原始参数之后，与连接的 Callable 的解绑操作无关，因为解绑操作只会影响信号的原始参数（见 Callable.unbind() 和 Callable.get_unbound_arguments_count()）。
extends Object
signal test_signal
func test():
print(self) # 输出如：<Object#35332818393>
test_signal.connect(prints.unbind(1), CONNECT_APPEND_SOURCE_OBJECT)
test_signal.emit("emit_arg_1", "emit_arg_2") # 输出：emit_arg_1 <Object#35332818393>
常量
NOTIFICATION_POSTINITIALIZE = 0 🔗
该对象初始化时收到的通知，发生在附加脚本之前。内部使用。
NOTIFICATION_PREDELETE = 1 🔗
该对象即将被删除时收到的通知。可以用作面向对象编程语言中的析构函数。
该通知会以反向顺序发送。
NOTIFICATION_EXTENSION_RELOADED = 2 🔗
当对象完成热重加载时收到的通知。该通知仅针对扩展类和派生类发送。
方法说明
Variant _get(property: StringName) virtual 🔗
重写此方法以自定义 get() 的行为。应该返回给定 property（属性）的值；如果该 property 应该按常规方式处理，则返回 null。
结合 _set() 和 _get_property_list()，此方法允许定义自定义属性，这在编辑器插件的开发中尤其有用。
注意： 当获取对象的内置属性，包括使用 @GDScript.@export 定义的属性时，不会调用此方法。
func _get(property):
if property == "fake_property":
print("Getting my property!")
return 4
return null
func _get_property_list():
return [
{ "name": "fake_property", "type": TYPE_INT }
]
public override Variant _Get(StringName property)
{
if (property == "FakeProperty")
{
GD.Print("Getting my property!");
return 4;
}
return default;
}
public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetPropertyList()
{
return
[
new Godot.Collections.Dictionary()
{
{ "name", "FakeProperty" },
{ "type", (int)Variant.Type.Int },
},
];
}
注意： 与其他虚方法不同，每个重写了此方法的脚本都会自动调用它。这意味着不应该通过 GDScript 中的 super（或其他语言中的等效关键字）来调用其基类的实现。调用会从层级最底层的子类开始，随后沿着类继承层级向上依次调用。调用链会在第一个返回非 null 值的类那里停止。
警告： 如果重写了此方法，它必须是线程安全的。否则，当尝试保存包含该对象的资源时，引擎可能会崩溃。
Array[Dictionary] _get_property_list() virtual 🔗
重写此方法，以向引擎提供一个自定义的额外属性列表来进行处理。
应该返回一个属性列表，形式为包含字典的 Array（数组）。该结果会被添加到 get_property_list() 的数组中，并且应该采用相同的格式。每个 Dictionary（字典）必须至少包含 name（名称）和 type（类型）这两个条目。
你可以使用 _property_can_revert() 和 _property_get_revert() 来定制通过此方法添加的属性的默认值。
下面的示例展示了一个从 ZERO 到 FIVE 以单词形式显示的数字列表，其中 number_count 用于控制列表的大小：
@tool
extends Node
@export var number_count = 3:
set(nc):
number_count = nc
numbers.resize(number_count)
notify_property_list_changed()
var numbers = PackedInt32Array([0, 0, 0])
func _get_property_list():
var properties: Array[Dictionary] = []
for i in range(number_count):
properties.append({
"name": "number_%d" % i,
"type": TYPE_INT,
"hint": PROPERTY_HINT_ENUM,
"hint_string": "ZERO,ONE,TWO,THREE,FOUR,FIVE",
})
return properties
func _get(property):
if property.begins_with("number_"):
var index = property.get_slice("_", 1).to_int()
return numbers[index]
return null
func _set(property, value):
if property.begins_with("number_"):
var index = property.get_slice("_", 1).to_int()
numbers[index] = value
return true
return false
[Tool]
public partial class MyNode : Node
{
private int _numberCount;
[Export]
public int NumberCount
{
get => _numberCount;
set
{
_numberCount = value;
_numbers.Resize(_numberCount);
NotifyPropertyListChanged();
}
}
private Godot.Collections.Array<int> _numbers = [];
public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetPropertyList()
{
Godot.Collections.Array<Godot.Collections.Dictionary> properties = [];
for (int i = 0; i < _numberCount; i++)
{
properties.Add(new Godot.Collections.Dictionary()
{
{ "name", $"number_{i}" },
{ "type", (int)Variant.Type.Int },
{ "hint", (int)PropertyHint.Enum },
{ "hint_string", "Zero,One,Two,Three,Four,Five" },
});
}
return properties;
}
public override Variant _Get(StringName property)
{
string propertyName = property.ToString();
if (propertyName.StartsWith("number_"))
{
int index = int.Parse(propertyName.Substring("number_".Length));
return _numbers[index];
}
return default;
}
public override bool _Set(StringName property, Variant value)
{
string propertyName = property.ToString();
if (propertyName.StartsWith("number_"))
{
int index = int.Parse(propertyName.Substring("number_".Length));
_numbers[index] = value.As<int>();
return true;
}
return false;
}
}
注意： 此方法是为高级用途设计的。对于大多数常见的使用场景，各脚本语言都提供了更简便的方式来处理属性。详见 @GDScript.@export、@GDScript.@export_enum、@GDScript.@export_group 等注解。如果你只是想自定义已导出的属性，请使用 _validate_property()。
注意： 如果该对象的脚本没有标记 @GDScript.@tool，此方法在编辑器中将不会被调用。
注意： 与其他虚方法不同，每个重写了此方法的脚本都会自动调用它。这意味着不应该通过 GDScript 中的 super（或其他语言中的等效关键字）来调用其基类的实现。调用会从层级最底层的子类开始，随后沿着类继承层级向上依次进行。
警告： 如果重写了此方法，它必须是<线程安全的>。否则，当尝试保存包含该对象的资源时，引擎可能会崩溃。
void _init() virtual 🔗
实例化对象的脚本时调用，通常是在对象在内存中初始化之后（通过 GDScript 中的 Object.new() 或 C# 中的 new GodotObject）。也可以将其定义为接受参数的形式。该方法类似于大多数编程语言中的构造函数。
注意：如果为 _init() 定义了必填的参数，则带脚本的 Object 只能直接创建。使用任何其他方式（例如 PackedScene.instantiate() 或 Node.duplicate()）创建时，该脚本的初始化都将失败。
Variant _iter_get(iter: Variant) virtual 🔗
返回当前的可迭代值。iter 存储迭代状态，但与 _iter_init() 和 _iter_next() 不同，此处的状态只读，因此不使用 Array 封装。
贴士：在 GDScript 中，你可以使用 Variant 子类型作为 _iter_get() 的返回类型。该类型会用来设置 for 循环中迭代器变量的类型，提升类型安全。
bool _iter_init(iter: Array) virtual 🔗
初始化迭代器。iter 用于存储迭代的状态。由于 GDScript 不支持通过引用传递参数，因此使用一个单元素数组作为包装。只要迭代器还没有到达末尾，就返回 true。
class MyRange:
var _from
var _to
func _init(from, to):
assert(from <= to)
_from = from
_to = to
func _iter_init(iter):
iter[0] = _from
return iter[0] < _to
func _iter_next(iter):
iter[0] += 1
return iter[0] < _to
func _iter_get(iter):
return iter
func _ready():
var my_range = MyRange.new(2, 5)
for x in my_range:
print(x) # Prints 2, 3, 4.
注意： 避免将迭代器的状态存储在成员变量中，请改用 iter 参数。否则，你将无法在嵌套循环中重复使用同一个迭代器实例。
更多详情请参阅 online docs。
bool _iter_next(iter: Array) virtual 🔗
将迭代器移动到下一次迭代。iter 存储迭代状态。由于 GDScript 不支持按引用传递参数，这里使用单元素数组作为包装器。只要迭代器尚未到达末尾就会返回 true。
void _notification(what: int) virtual 🔗
当对象收到通知时被调用，可以通过将 what 与常量比较来识别通知。另见 notification()。
func _notification(what):
if what == NOTIFICATION_PREDELETE:
print("再见！")
public override void _Notification(int what)
{
if (what == NotificationPredelete)
{
GD.Print("再见！");
}
}
注意：基类 Object 定义了一些通知（NOTIFICATION_POSTINITIALIZE 和 NOTIFICATION_PREDELETE）。Node 等继承类定义了更多通知，这些通知也由该方法接收。
注意：与其他虚方法不同，该方法会被每个覆盖的脚本自动调用。这意味着不应该通过 GDScript 中的 super 或其他语言中的类似手段来调用基类实现。调用顺序取决于 notification() 方法的 reversed 参数，并且不同的通知类型的调用顺序也可能不同。大多数通知都按正向顺序发送（即先调用 Object 类，最后调用派生程度最高的类）。
bool _property_can_revert(property: StringName) virtual 🔗
覆盖该方法以自定义给定 property 的恢复行为。如果 property 具有自定义默认值并且可在检查器面板中恢复，则应返回 true。使用 _property_get_revert() 来指定 property 的默认值。
注意：无论 property 的当前值如何，该方法都必须始终如一地返回。
注意：与其他虚方法不同，该方法会被每个重写它的脚本自动调用。这意味着不应该通过 GDScript 中的 super 或其他语言中的类似手段来调用基类实现。最底层的子类最先被调用，后续调用将沿着类层次结构向上进行。调用链会在第一个返回 true 的类处停止。
Variant _property_get_revert(property: StringName) virtual 🔗
覆盖该方法以自定义给定 property 的还原行为。应返回 property 的默认值。如果默认值与 property 的当前值不同，则检查器停靠面板中会显示一个还原图标。
注意：_property_can_revert() 也必须被覆盖，该方法才能被调用。
注意：与其他虚方法不同，该方法会被每个重写它的脚本自动调用。这意味着不应该通过 GDScript 中的 super 或其他语言中的类似手段来调用基类实现。最底层的子类最先被调用，后续调用将沿着类层次结构向上进行。调用链会在第一个返回非 null 的类处停止。
bool _set(property: StringName, value: Variant) virtual 🔗
覆盖该方法以自定义 set() 的行为。应将 property 设置为 value 并返回 true，如果 property 被正常处理则返回 false。设置 property 的确切方式取决于该方法的实现。
结合 _get() 和 _get_property_list()，该方法允许定义自定义属性，这对编辑器插件特别有用。
注意：设置对象的内置属性时不会调用该方法，包括使用 @GDScript.@export 定义的属性。
var internal_data = {}
func _set(property, value):
if property == "fake_property":
# 在冒牌属性中存值。
internal_data["fake_property"] = value
return true
return false
func _get_property_list():
return [
{ "name": "fake_property", "type": TYPE_INT }
]
private Godot.Collections.Dictionary _internalData = new Godot.Collections.Dictionary();
public override bool _Set(StringName property, Variant value)
{
if (property == "FakeProperty")
{
// 在冒牌属性中存值。
_internalData["FakeProperty"] = value;
return true;
}
return false;
}
public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetPropertyList()
{
return
[
new Godot.Collections.Dictionary()
{
{ "name", "FakeProperty" },
{ "type", (int)Variant.Type.Int },
},
];
}
注意： 和其他虚拟方法不同，每一个被脚本覆盖了的该方法都会被自动调用。这意味着基础实现不应该用 GDScript 中的 super 或者其他语言中的同等构造来调用。最底层子类的该方法会首先被调用，接着是沿类层次结构向上依次调用。调用链会在第一个返回了 true 的类停止。
覆盖该方法以自定义 to_string() 的返回值，将对象表示为 String。
func _to_string():
return "欢迎来到 Godot 4！"
func _init():
print(self) # 输出“欢迎来到 Godot 4！”
var a = str(self) # a 是“欢迎来到 Godot 4！”
void _validate_property(property: Dictionary) virtual 🔗
覆盖该方法以自定义已有属性。除了使用 _get_property_list() 添加的属性之外，每个属性信息都经过该方法。字典内容与 _get_property_list() 中的相同。
@tool
extends Node
@export var is_number_editable: bool:
set(value):
is_number_editable = value
notify_property_list_changed()
@export var number: int
func _validate_property(property: Dictionary):
if property.name == "number" and not is_number_editable:
property.usage |= PROPERTY_USAGE_READ_ONLY
[Tool]
public partial class MyNode : Node
{
private bool _isNumberEditable;
[Export]
public bool IsNumberEditable
{
get => _isNumberEditable;
set
{
_isNumberEditable = value;
NotifyPropertyListChanged();
}
}
[Export]
public int Number { get; set; }
public override void _ValidateProperty(Godot.Collections.Dictionary property)
{
if (property["name"].AsStringName() == PropertyName.Number && !IsNumberEditable)
{
var usage = property["usage"].As<PropertyUsageFlags>() | PropertyUsageFlags.ReadOnly;
property["usage"] = (int)usage;
}
}
}
void add_user_signal(signal: String, arguments: Array = []) 🔗
添加名为 signal 的用户定义的信号。信号的参数是可选的，以字典的 Array 形式添加，字典中定义名称 name String，类型 type int（见 Variant.Type）。另见 has_user_signal() 和 remove_user_signal()。
add_user_signal("hurt", [
{ "name": "damage", "type": TYPE_INT },
{ "name": "source", "type": TYPE_OBJECT }
])
AddUserSignal("Hurt",
[
new Godot.Collections.Dictionary()
{
{ "name", "damage" },
{ "type", (int)Variant.Type.Int },
},
new Godot.Collections.Dictionary()
{
{ "name", "source" },
{ "type", (int)Variant.Type.Object },
},
]);
Variant call(method: StringName, ...) vararg 🔗
在对象上调用 method 并返回结果。该方法支持可变数量的参数，因此参数可以作为逗号分隔的列表传递。
var node = Node3D.new()
node.call("rotate", Vector3(1.0, 0.0, 0.0), 1.571)
var node = new Node3D();
node.Call(Node3D.MethodName.Rotate, new Vector3(1f, 0f, 0f), 1.571f);
注意：在 C# 中，在引用 Godot 内置方法时，method 必须为 snake_case 格式。最好使用 MethodName 类中公开的名称，以避免在每次调用时分配新的 StringName。
Variant call_deferred(method: StringName, ...) vararg 🔗
在空闲时调用该对象的 method 方法。始终返回 null，不返回该方法的结果。
空闲时间主要出现在处理帧和物理帧的末尾。延迟的调用会在此时执行，直到全部执行完毕，这意味着你可以从其他延迟调用中延迟调用，并且它们仍将在当前空闲时间周期中运行。这意味着你不应从延迟调用的方法（或从其调用的方法）中延迟调用其自身，因为这会导致无限递归，就像你直接调用该方法一样。
这个方法支持可变数量的参数，所以参数可以用逗号分隔列表的形式传递。
var node = Node3D.new()
node.call_deferred("rotate", Vector3(1.0, 0.0, 0.0), 1.571)
var node = new Node3D();
node.CallDeferred(Node3D.MethodName.Rotate, new Vector3(1f, 0f, 0f), 1.571f);
对于从同一线程中延迟执行的方法，在空闲时执行的顺序与调用 call_deferred 的顺序相同。
注意：在 C# 中，method 引用内置的 Godot 方法时必须使用 snake_case 的形式。请优先使用 MethodName 类中暴露的名称，避免每次调用都分配一个新的 StringName。
注意：如果你想要延迟一帧再调用函数，请使用 SceneTree.process_frame 和 SceneTree.physics_frame 信号。
var node = Node3D.new()
# 制作可调用体并将参数绑定到该节点的 rotate() 调用。
var callable = node.rotate.bind(Vector3(1.0, 0.0, 0.0), 1.571)
# 将可调用体连接到 process_frame 信号，这样就能够在下一个处理帧中调用。
# CONNECT_ONE_SHOT 能够确保只调用一次，不会每帧都调用。
get_tree().process_frame.connect(callable, CONNECT_ONE_SHOT)
Variant callv(method: StringName, arg_array: Array) 🔗
在对象上调用 method 并返回结果。与 call() 不同，该方法期望所有参数都包含在 arg_array 中。
var node = Node3D.new()
node.callv("rotate", [Vector3(1.0, 0.0, 0.0), 1.571])
var node = new Node3D();
node.Callv(Node3D.MethodName.Rotate, [new Vector3(1f, 0f, 0f), 1.571f]);
注意：在 C# 中，method 在引用 Godot 内置方法时必须是 snake_case。最好使用 MethodName 类中公开的名称，以避免在每次调用时分配新的 StringName。
bool can_translate_messages() const 🔗
如果允许该对象使用 tr() 和 tr_n() 翻译消息，则返回 true。另见 set_message_translation()。
void cancel_free() 🔗
如果在 NOTIFICATION_PREDELETE 时调用该方法，则该对象拒绝释放，仍会保持已分配的状态。主要是作为内部函数使用，用于错误处理，避免用户释放不想释放的对象。
Error connect(signal: StringName, callable: Callable, flags: int = 0) 🔗
将名为 signal 的信号与可调用体 callable 连接。还可以通过 flags 添加标志，配置连接行为（见 ConnectFlags 常量）。
一个信号与同一个 Callable 只能连接一次。如果信号已连接，则该方法会返回 @GlobalScope.ERR_INVALID_PARAMETER 并报错误，除非信号是使用 CONNECT_REFERENCE_COUNTED 连接的。要防止出现这种情况，请先使用 is_connected() 检查是否已存在连接。
注意：如果 callable 的对象被释放，连接就会丢失。
注意：在 GDScript 中，通常建议使用 Signal.connect() 来连接信号。
注意：该方法以及所有其他与信号相关的方法都是线程安全的。
void disconnect(signal: StringName, callable: Callable) 🔗
按名称从给定的 callable 断开 signal。如果连接不存在，则生成一个错误。使用 is_connected() 确保该连接存在。
Error emit_signal(signal: StringName, ...) vararg 🔗
按名称发出给定的 signal。该信号必须存在，所以它应该是该类或其继承类之一的内置信号，或者是用户定义的信号（参见 add_user_signal()）。该方法支持可变数量的参数，所以参数可以以逗号分隔的列表形式传递。
如果 signal 不存在或参数无效，则返回 @GlobalScope.ERR_UNAVAILABLE。
emit_signal("hit", "剑", 100)
emit_signal("game_over")
EmitSignal(SignalName.Hit, "剑", 100);
EmitSignal(SignalName.GameOver);
注意：在C#中，在引用内置 Godot 信号时，signal 必须是 snake_case。最好使用 SignalName 类中公开的名称，以避免在每次调用时分配一个新的 StringName。
void free() 🔗
从内存中删除该对象。此前存在的对该对象的引用会失效，尝试访问这些引用会产生运行时错误。使用 @GlobalScope.is_instance_valid() 检查引用时将返回 false。等价于 GDExtension C++ 中的 memdelete 函数。
Variant get(property: StringName) const 🔗
返回给定 property 的 Variant 值。如果 property 不存在，则该方法返回 null。
var node = Node2D.new()
node.rotation = 1.5
var a = node.get("rotation") # a 为 1.5
var node = new Node2D();
node.Rotation = 1.5f;
var a = node.Get(Node2D.PropertyName.Rotation); // a 为 1.5
注意：在 C# 中，在引用 Godot 内置属性时，property 必须是 snake_case。最好使用 PropertyName 类中公开的名称，以避免在每次调用时分配一个新的 StringName。
返回该对象的内置类名，作为一个 String。另见 is_class()。
注意：该方法将忽略 class_name 声明。如果该对象的脚本定义了一个 class_name，则改为返回内置基类名称。
Array[Dictionary] get_incoming_connections() const 🔗
返回该对象接收到的信号连接的 Array。每个连接都被表示为包含三个条目的 Dictionary：
signal是对 Signal 的引用；callable是对 Callable 的引用；flags是 ConnectFlags 的组合。
Variant get_indexed(property_path: NodePath) const 🔗
获取该对象的某个属性，该属性的属性路径由 property_path 给出。该路径应该是相对于当前对象的 NodePath，可使用英文冒号（:）访问内嵌属性。
示例："position:x" 或 "material:next_pass:blend_mode"。
var node = Node2D.new()
node.position = Vector2(5, -10)
var a = node.get_indexed("position") # a 为 Vector2(5, -10)
var b = node.get_indexed("position:y") # b 为 -10
var node = new Node2D();
node.Position = new Vector2(5, -10);
var a = node.GetIndexed("position"); // a 为 Vector2(5, -10)
var b = node.GetIndexed("position:y"); // b 为 -10
注意：在 C# 中引用内置 Godot 属性时 property_path 必须为 snake_case 蛇形大小写。请优先使用 PropertyName 类中暴露的名称，避免每次调用都重新分配一个 StringName。
注意：这个方法不支持指向 SceneTree 中节点的路径，仅支持子属性路径。在节点语境下，请改用 Node.get_node_and_resource()。
返回该对象的唯一实例 ID。该 ID 可以保存在 EncodedObjectAsID 中，通过 @GlobalScope.instance_from_id() 可以检索到对应的对象实例。
注意：该 ID 仅在当前会话中有意义：通过网络传输后并不对应相同的对象，隔段时间后从文件中加载亦然。
Variant get_meta(name: StringName, default: Variant = null) const 🔗
返回该对象的元数据中名称为 name 的条目。如果不存在该条目，则返回 default。如果 default 为 null，则还会生成错误。
注意：元数据的名称必须是符合 StringName.is_valid_identifier() 的有效标识符。
注意：名称以下划线（_）开头的元数据仅供编辑器使用。仅供编辑器使用的元数据不会在“检查器”中显示，虽然仍然能够被这个方法找到，但是不应该进行编辑。
Array[StringName] get_meta_list() const 🔗
将该对象的元数据条目名称以元素为 StringName 的 Array 形式返回。
int get_method_argument_count(method: StringName) const 🔗
根据名称返回给定 method 的参数数量。
注意：在 C# 中引用内置 Godot 方法时，method 必须采用 snake_case 蛇形命名法。请优先使用 MethodName 类中公开的名称，以避免在每次调用时分配一个新的 StringName。
Array[Dictionary] get_method_list() const 🔗
将该对象的方法及对应签名作为字典 Array 返回。每个 Dictionary 包含以下条目：
-name 是该方法的名称，为 String；
-args 是代表参数的字典 Array；
-default_args 是默认参数，为变体 Array；
-flags 是 MethodFlags 的组合；
-id 是该方法的内部标识符 int；
-return 是返回值，为 Dictionary；
注意：args 和 return 的字典格式与 get_property_list() 的结果相同，但不会用到所有条目。
Array[Dictionary] get_property_list() const 🔗
以字典 Array 的形式返回该对象的属性列表。每个 Dictionary 中都包含如下条目：
name是该属性的名称，类型为 String；class_name为空 StringName，除非该属性为 @GlobalScope.TYPE_OBJECT 并继承自某个类；type是该属性的类型，类型为 int（见 Variant.Type）；hint是应当如何编辑该属性（见 PropertyHint）；hint_string取决于 hint（见 PropertyHint）；usage是 PropertyUsageFlags 的组合。
注意：在 GDScript 中，类的所有成员都被视为属性。在 C# 和 GDExtension 中，则需要使用装饰器或特性将类的成员显式标记为 Godot 属性。
返回该对象的 Script 实例，如果没有附加脚本，则返回 null。
Array[Dictionary] get_signal_connection_list(signal: StringName) const 🔗
返回给定 signal 名称的连接的 Array。每个连接都被表示为包含三个条目的 Dictionary：
signal是对 Signal 的引用；callable是对已连接 Callable 的引用；flags是 ConnectFlags 的组合。
Array[Dictionary] get_signal_list() const 🔗
将现有信号的列表返回为字典的一个 Array 。
注意：由于该实现，每个 Dictionary 的格式与 get_method_list() 的返回值非常相似。
StringName get_translation_domain() const 🔗
返回 tr() 和 tr_n() 所使用的翻译域的名称。另见 TranslationServer。
bool has_connections(signal: StringName) const 🔗
如果给定的信号名称 signal 存在连接，则返回 true。
注意：在 C# 中，引用 Godot 内置方法时 signal 必须使用 snake_case 形式命名。请优先使用 SignalName 类中暴露的名称，避免每次调用都分配一个新的 StringName。
bool has_meta(name: StringName) const 🔗
如果找到名称为 name 的元数据条目，则返回 true。另见 get_meta()、set_meta() 和 remove_meta()。
注意：元数据的名称必须是符合 StringName.is_valid_identifier() 的有效标识符。
注意：名称以下划线（_）开头的元数据仅供编辑器使用。仅供编辑器使用的元数据不会在“检查器”中显示，虽然仍然能够被这个方法找到，但是不应该进行编辑。
bool has_method(method: StringName) const 🔗
如果该对象中存在给定的方法名 method，则返回 true。
注意：在 C# 中引用内置 Godot 方法时 method 必须为 snake_case 蛇形大小写。请优先使用 MethodName 类中暴露的名称，避免每次调用都重新分配一个 StringName。
bool has_signal(signal: StringName) const 🔗
如果对象中存在给定的信号名称 signal，则返回 true。
注意：在 C# 中，引用 Godot 内置方法时 signal 必须使用 snake_case 形式命名。请优先使用 SignalName 类中暴露的名称，避免每次调用都分配一个新的 StringName。
bool has_user_signal(signal: StringName) const 🔗
如果存在给定的用户定义信号名称 signal，则返回 true。仅包含通过 add_user_signal() 添加的信号。另见 remove_user_signal()。
bool is_blocking_signals() const 🔗
如果该对象正在阻止发出信号，则返回 true。见 set_block_signals()。
bool is_class(class: StringName) const 🔗
如果该对象继承自给定的 class 则返回 true。另见 get_class()。
var sprite2d = Sprite2D.new()
sprite2d.is_class("Sprite2D") # 返回 true
sprite2d.is_class("Node") # 返回 true
sprite2d.is_class("Node3D") # 返回 false
var sprite2D = new Sprite2D();
sprite2D.IsClass("Sprite2D"); // 返回 true
sprite2D.IsClass("Node"); // 返回 true
sprite2D.IsClass("Node3D"); // 返回 false
注意：此方法忽略对象脚本中的 class_name 声明。
bool is_connected(signal: StringName, callable: Callable) const 🔗
如果给定的信号名称 signal 与可调用体 callable 之间存在连接，则返回 true。
注意：在 C# 中，引用 Godot 内置方法时 signal 必须使用 snake_case 形式命名。请优先使用 SignalName 类中暴露的名称，避免每次调用都分配一个新的 StringName。
bool is_queued_for_deletion() const 🔗
如果已为该对象调用了方法 Node.queue_free() 或 SceneTree.queue_delete()，则返回 true。
注意： 即使子节点将随父节点一起被释放，该方法也不会对已调用 Node.queue_free() 的节点的子节点返回 true。
void notification(what: int, reversed: bool = false) 🔗
将给定的 what 通知发送给对象继承的所有类，触发对 _notification() 的调用，从最高祖先（Object 类）开始，向下一直到对象的脚本。
如果 reversed 为 true，则调用顺序会被颠倒。
var player = Node2D.new()
player.set_script(load("res://player.gd"))
player.notification(NOTIFICATION_ENTER_TREE)
# 调用顺序是 Object -> Node -> Node2D -> player.gd。
player.notification(NOTIFICATION_ENTER_TREE, true)
# 调用顺序是 player.gd -> Node2D -> Node -> Object。
var player = new Node2D();
player.SetScript(GD.Load("res://player.gd"));
player.Notification(NotificationEnterTree);
// 调用顺序是 GodotObject -> Node -> Node2D -> player.gd。
player.Notification(NotificationEnterTree, true);
// 调用顺序是 player.gd -> Node2D -> Node -> GodotObject。
void notify_property_list_changed() 🔗
发出 property_list_changed 信号。这主要是用来刷新编辑器，以让检查器和编辑器插件被正确更新。
bool property_can_revert(property: StringName) const 🔗
如果给定的属性 property 有自定义的默认值，则返回 true。请使用 property_get_revert() 获取 property 的默认值。
注意：“检查器”面板会使用这个方法来显示恢复图标。该对象必须实现 _property_can_revert() 来自定义默认值。如果未实现 _property_can_revert()，则这个方法返回 false。
Variant property_get_revert(property: StringName) const 🔗
返回给定的属性 property 的自定义默认值。请使用 property_can_revert() 检查 property 是否有自定义的默认值。
注意：“检查器”面板会使用这个方法来显示恢复图标。该对象必须实现 _property_get_revert() 来自定义默认值。如果未实现 _property_get_revert()，则这个方法返回 null。
void remove_meta(name: StringName) 🔗
从对象的元数据中移除名称为 name 的条目。另见 has_meta()、get_meta() 和 set_meta()。
注意：元数据的名称必须是符合 StringName.is_valid_identifier() 的有效标识符。
注意：名称以下划线（_）开头的元数据仅供编辑器使用。仅供编辑器使用的元数据不会在“检查器”中显示，虽然仍然能够被这个方法找到，但是不应该进行编辑。
void remove_user_signal(signal: StringName) 🔗
从对象中移除给定的用户信号 signal。另见 add_user_signal() 和 has_user_signal()。
void set(property: StringName, value: Variant) 🔗
将给定属性 property 的值分配为 value。如果该属性不存在，或者给定 value 的类型不匹配，则不会发生任何事情。
var node = Node2D.new()
node.set("global_scale", Vector2(8, 2.5))
print(node.global_scale) # 输出 (8.0, 2.5)
var node = new Node2D();
node.Set(Node2D.PropertyName.GlobalScale, new Vector2(8, 2.5f));
GD.Print(node.GlobalScale); // 输出 (8, 2.5)
注意：在 C# 中，引用 Godot 内置方法时 property 必须使用 snake_case 形式命名。请优先使用 PropertyName 类中暴露的名称，避免每次调用都分配一个新的 StringName。
void set_block_signals(enable: bool) 🔗
如果设置为 true，这该对象将无法发出信号。因此，emit_signal() 和信号连接将不起作用，直到该属性被设置为 false。
void set_deferred(property: StringName, value: Variant) 🔗
在当前帧的末尾，将给定属性 property 的值分配为 value。等价于通过 call_deferred() 调用 set()。
var node = Node2D.new()
add_child(node)
node.rotation = 1.5
node.set_deferred("rotation", 3.0)
print(node.rotation) # 输出 1.5
await get_tree().process_frame
print(node.rotation) # 输出 3.0
var node = new Node2D();
node.Rotation = 1.5f;
node.SetDeferred(Node2D.PropertyName.Rotation, 3f);
GD.Print(node.Rotation); // 输出 1.5
await ToSignal(GetTree(), SceneTree.SignalName.ProcessFrame);
GD.Print(node.Rotation); // 输出 3.0
注意：在 C# 中引用内置 Godot 属性时 property 必须为 snake_case 蛇形大小写。请优先使用 PropertyName 类中暴露的名称，避免每次调用都重新分配一个 StringName。
void set_indexed(property_path: NodePath, value: Variant) 🔗
将由属性路径 property_path 标识的属性的值分配为 value。该路径应为相对于这个对象的 NodePath，可以使用英文冒号（:）访问内嵌属性。
var node = Node2D.new()
node.set_indexed("position", Vector2(42, 0))
node.set_indexed("position:y", -10)
print(node.position) # 输出 (42.0, -10.0)
var node = new Node2D();
node.SetIndexed("position", new Vector2(42, 0));
node.SetIndexed("position:y", -10);
GD.Print(node.Position); // 输出 (42, -10)
注意：在 C# 中，引用 Godot 内置方法时 property_path 必须使用 snake_case 形式命名。请优先使用 PropertyName 类中暴露的名称，避免每次调用都分配一个新的 StringName。
void set_message_translation(enable: bool) 🔗
如果设置为 true，则允许对象使用 tr() 和 tr_n() 翻译消息。该属性默认启用。另见 can_translate_messages()。
void set_meta(name: StringName, value: Variant) 🔗
添加或更改对象元数据中名称为 name 的条目。元数据值 value 可以是任何 Variant，尽管某些类型无法正确序列化。
如果 value 为 null，则该条目被移除。等价于使用 remove_meta()。另见 has_meta() 和 get_meta()。
注意：元数据的名称必须是符合 StringName.is_valid_identifier() 的有效标识符。
注意：名称以下划线（_）开头的元数据仅供编辑器使用。仅供编辑器使用的元数据不会在“检查器”中显示，虽然仍然能够被这个方法找到，但是不应该进行编辑。
void set_script(script: Variant) 🔗
将脚本 script 附加至该对象，并进行实例化。因此会调用该脚本的 _init()。Script 可用于扩展对象的功能。
如果已存在脚本，则该脚本的实例会被分离，其属性值和状态会丢失。仍会保留内置属性的值。
void set_translation_domain(domain: StringName) 🔗
设置 tr() 和 tr_n() 所使用的翻译域的名称。另见 TranslationServer。
返回表示对象的 String。默认为 "<ClassName#RID>"。覆盖 _to_string() 以自定义对象的字符串表示形式。
String tr(message: StringName, context: StringName = &"") const 🔗
翻译一条 message，该翻译使用项目设置中配置的翻译目录。可指定额外的 context 来辅助翻译。请注意，大多数 Control 节点会自动翻译其上的字符串，因此该方法主要用于格式化字符串或自定义绘制的文本。
若 can_translate_messages() 为 false，或者无可用的翻译，则该方法将原样返回 message。见 set_message_translation()。
详细示例请见国际化游戏。
注意：该方法无法在没有 Object 实例的情况下使用，因为它依赖 can_translate_messages() 方法。静态上下文中的字符串翻译，请使用 TranslationServer.translate()。
String tr_n(message: StringName, plural_message: StringName, n: int, context: StringName = &"") const 🔗
使用项目设置中配置的翻译目录，翻译一个 message 或 plural_message。可以进一步指定 context 来帮助翻译。
如果 can_translate_messages() 为 false，或者没有翻译可用，则该方法将返回 message 或 plural_message，而不做任何更改。请参阅 set_message_translation()。
n 是消息主题的数字或数量。它被翻译系统用来获取当前语言的正确复数形式。
有关详细示例，请参阅《使用 gettext 进行本地化》。
注意：负数和 float 数字可能不适用于某些可数科目。建议使用 tr() 处理这些情况。
注意：如果没有 Object 实例，则无法使用该方法，因为它需要 can_translate_messages() 方法。要在静态上下文中翻译字符串，请使用 TranslationServer.translate_plural()。