Godot 通知

Godot 中的每个对象都实现了 _notification 方法。其目的是允许对象响应可能与之相关的各种引擎级回调。例如，如果引擎告诉 CanvasItem 去“绘制”，则它将调用 _notification(NOTIFICATION_DRAW)。

在所有这些通知之中，有很多类似“绘制”这样经常需要在脚本中去覆盖的通知，多到 Godot 要提供专用函数的地步：

  • _ready(): NOTIFICATION_READY

  • _enter_tree(): NOTIFICATION_ENTER_TREE

  • _exit_tree(): NOTIFICATION_EXIT_TREE

  • _process(delta): NOTIFICATION_PROCESS

  • _physics_process(delta): NOTIFICATION_PHYSICS_PROCESS

  • _draw(): NOTIFICATION_DRAW

用户可能不会意识到 Node 之外的类型也有通知，例如：

并且，在节点中也有很多很有用的回调，但是这些回调不存在专门的方法。

你可以在通用的 _notification() 方法中访问所有这些自定义通知。

备注

文档中被标记为“virtual”的方法（即虚方法）可以被脚本覆盖重写。

一个经典的例子是 Object 中的 _init 方法。虽然它没有等效的 NOTIFICATION_* 通知，但是引擎仍然会调用该方法。大多数语言（C#除外）都将其用作构造函数。

所以说，应该在哪些情况下使用这些通知或虚函数呢？

_process vs. _physics_process vs. *_input

当需要使用“依赖于帧速率的 delta 时间增量”时，请使用 _process 。如果需要尽可能频繁地更新对象数据，也应该在这里处理。频繁执行的逻辑检查和数据缓存操作，大多数都在这里执行。但也需要注意执行频率，如果不需要每帧都执行，则可以选择用定时器循环来替代。

GDScriptC#

  1. # Allows for recurring operations that don't trigger script logic
  2. # every frame (or even every fixed frame).
  3. func _ready():
  4.     var timer = Timer.new()
  5.     timer.autostart = true
  6.     timer.wait_time = 0.5
  7.     add_child(timer)
  8.     timer.timeout.connect(func():
  9.         print("This block runs every 0.5 seconds")
  10.     )
  1. using Godot;
  3. public partial class MyNode : Node
  4. {
  5.     // Allows for recurring operations that don't trigger script logic
  6.     // every frame (or even every fixed frame).
  7.     public override void _Ready()
  8.     {
  9.         var timer = new Timer();
  10.         timer.Autostart = true;
  11.         timer.WaitTime = 0.5;
  12.         AddChild(timer);
  13.         timer.Timeout += () => GD.Print("This block runs every 0.5 seconds");
  14.     }
  15. }

当需要与帧速率无关的时间增量时，请使用 _physics_process 。如果代码需要随着时间的推移进行一致的更新，不管时间推进速度是快还是慢，那么就应该在这里执行代码。频繁执行的运动学和对象变换操作，应在此处执行。

为了获得最佳性能，应尽可能避免在这些回调期间进行输入检查。 _process 和 _physics_process 每次都会触发（默认情况下这些更新回调不会 “休眠”）。相反， *_input 回调仅在引擎实际检测到输入的帧上触发。

在 input 回调中同样可以检查输入动作。如果要使用增量时间，则可以使用相关的增量时间获取方法来获取。

GDScriptC#

  1. # Called every frame, even when the engine detects no input.
  2. func _process(delta):
  3.     if Input.is_action_just_pressed("ui_select"):
  4.         print(delta)
  6. # Called during every input event.
  7. func _unhandled_input(event):
  8.     match event.get_class():
  9.         "InputEventKey":
  10.             if Input.is_action_just_pressed("ui_accept"):
  11.                 print(get_process_delta_time())
  1. using Godot;
  3. public partial class MyNode : Node
  4. {
  6.     // Called every frame, even when the engine detects no input.
  7.     public void _Process(double delta)
  8.     {
  9.         if (Input.IsActionJustPressed("ui_select"))
  10.             GD.Print(delta);
  11.     }
  13.     // Called during every input event. Equally true for _input().
  14.     public void _UnhandledInput(InputEvent @event)
  15.     {
  16.         switch (@event)
  17.         {
  18.             case InputEventKey:
  19.                 if (Input.IsActionJustPressed("ui_accept"))
  20.                     GD.Print(GetProcessDeltaTime());
  21.                 break;
  22.         }
  23.     }
  25. }

_init vs. 初始化 vs. 导出

如果脚本初始化它自己的没有场景的节点子树，则该代码将会在 _init() 中执行。其他属性或独立于 SceneTree 的初始化也应在此处运行。

备注

与 GDScript 的 _init() 方法等效的 C# 方法是构造函数。

_init() 在 _enter_tree() 或 _ready() 之前触发，但在脚本创建并初始化其属性之后。实例化场景时，属性值将按照以下顺序设置：

  1. Initial value assignment: the property is assigned its initialization value, or its default value if one is not specified. If a setter exists, it is not used.

  2. ``_init()`` assignment: the property’s value is replaced by any assignments made in _init(), triggering the setter.

  3. Exported value assignment: an exported property’s value is again replaced by any value set in the Inspector, triggering the setter.

GDScriptC#

  1. # test is initialized to "one", without triggering the setter.
  2. @export var test: String = "one":
  3.     set(value):
  4.         test = value + "!"
  6. func _init():
  7.     # Triggers the setter, changing test's value from "one" to "two!".
  8.     test = "two"
  10. # If someone sets test to "three" from the Inspector, it would trigger
  11. # the setter, changing test's value from "two!" to "three!".
  1. using Godot;
  3. public partial class MyNode : Node
  4. {
  5.     private string _test = "one";
  7.     [Export]
  8.     public string Test
  9.     {
  10.         get { return _test; }
  11.         set { _test = $"{value}!"; }
  12.     }
  14.     public MyNode()
  15.     {
  16.         // Triggers the setter, changing _test's value from "one" to "two!".
  17.         Test = "two";
  18.     }
  20.     // If someone sets Test to "three" in the Inspector, it would trigger
  21.     // the setter, changing _test's value from "two!" to "three!".
  22. }

As a result, instantiating a script versus a scene may affect both the initialization and the number of times the engine calls the setter.

_ready、_enter_tree、NOTIFICATION_PARENTED对比

首次实例化一个场景并添加到场景树时，Godot将实例化节点（调用 _init）为树，同时自上而下地调用 _enter_tree。当树构建完成后，再自下而上地调用 _ready，最终反向回到树的顶点。

当实例化脚本或独立的场景时，节点不会在创建时被添加到 SceneTree 中，所以未触发 _enter_tree 回调。而只有 _init 调用发生。当场景被添加到 SceneTree 时，才会调用 _enter_tree 和 _ready 。

如果需要触发作为节点设置父级到另一个节点而发生的行为, 无论它是否作为在主要/活动场景中的部分发生, 都可以使用 PARENTED 通知. 例如, 这有一个将节点方法连接到其父节点上自定义信号, 而不会失败的代码段。对可能在运行时创建并以数据为中心的节点很有用。

GDScriptC#

  1. extends Node
  3. var parent_cache
  5. func connection_check():
  6.     return parent_cache.has_user_signal("interacted_with")
  8. func _notification(what):
  9.     match what:
  10.         NOTIFICATION_PARENTED:
  11.             parent_cache = get_parent()
  12.             if connection_check():
  13.                 parent_cache.interacted_with.connect(_on_parent_interacted_with)
  14.         NOTIFICATION_UNPARENTED:
  15.             if connection_check():
  16.                 parent_cache.interacted_with.disconnect(_on_parent_interacted_with)
  18. func _on_parent_interacted_with():
  19.     print("I'm reacting to my parent's interaction!")
  1. using Godot;
  3. public partial class MyNode : Node
  4. {
  5.     private Node _parentCache;
  7.     public void ConnectionCheck()
  8.     {
  9.         return _parentCache.HasUserSignal("InteractedWith");
  10.     }
  12.     public void _Notification(int what)
  13.     {
  14.         switch (what)
  15.         {
  16.             case NotificationParented:
  17.                 _parentCache = GetParent();
  18.                 if (ConnectionCheck())
  19.                 {
  20.                     _parentCache.Connect("InteractedWith", Callable.From(OnParentInteractedWith));
  21.                 }
  22.                 break;
  23.             case NotificationUnparented:
  24.                 if (ConnectionCheck())
  25.                 {
  26.                     _parentCache.Disconnect("InteractedWith", Callable.From(OnParentInteractedWith));
  27.                 }
  28.                 break;
  29.         }
  30.     }
  32.     private void OnParentInteractedWith()
  33.     {
  34.         GD.Print("I'm reacting to my parent's interaction!");
  35.     }
  36. }

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.