Up to date

This page is up to date for Godot 4.3. If you still find outdated information, please open an issue.

Notifications Godot

Chaque objet dans Godot implémente une méthode _notification. Son but est de permettre à l'objet de répondre à une variété de rappels au niveau moteur qui peuvent s'y rapporter. Par exemple, si le moteur indique à un CanvasItem de "draw", il appellera _notification(NOTIFICATION_DRAW).

Certaines de ces notifications, comme draw, sont utiles pour remplacer les scripts. A tel point que Godot expose beaucoup d'entre eux avec des fonctions dédiées :

_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

Ce que les utilisateurs peuvent ne pas comprendre, c'est que les notifications existent pour des types autres que seulement Node, par exemple :

Object::NOTIFICATION_POSTINITIALIZE : un callback qui se déclenche pendant l'initialisation de l'objet. Non accessible aux scripts.
Object::NOTIFICATION_PREDELETE : un callback qui se déclenche avant que le moteur ne supprime un objet, c'est-à-dire un "destructeur".

Et beaucoup de rappels qui existent dans les Nœuds n'ont pas de méthodes dédiées, mais sont quand même très utiles.

Node::NOTIFICATION_PARENTED : un callback qui déclenche chaque fois qu'un nœud enfant est ajouté à un autre nœud.
Node::NOTIFICATION_UNPARENTED : un callback qui déclenche chaque fois qu'un nœud enfant est supprimé d'un autre nœud.

On peut accéder à toutes ces notifications personnalisées à partir de la méthode universelle _notification().

Note

Les méthodes de la documentation étiquetées comme "virtuelles" sont également destinées à être substituée par des scripts.

Un exemple classique est la méthode _init dans Object. Bien qu'il n'ait pas d'équivalent NOTIFICATION_*, le moteur appelle toujours la méthode. La plupart des langages (à l'exception du C#) s'en servent comme constructeur.

Alors, dans quelle situation faut-il utiliser chacune de ces notifications ou fonctions virtuelles ?

_process vs. _physics_process vs. *_input

Utilisez _process() lorsqu'on a besoin d'écart de temps dépendant du temps entre les images. Si le code qui met à jour les données objet doit être mis à jour aussi souvent que possible, c'est le bon endroit. Les vérifications logiques récurrentes et la mise en cache des données s'exécutent souvent ici, mais cela dépend de la fréquence à laquelle on a besoin de les mettre à jour. S'ils n'ont pas besoin d'exécuter à toutes les images, l'implémentation d'une boucle Timer-timeout est une autre option.

# Allows for recurring operations that don't trigger script logic
# every frame (or even every fixed frame).
func _ready():
    var timer = Timer.new()
    timer.autostart = true
    timer.wait_time = 0.5
    add_child(timer)
    timer.timeout.connect(func():
        print("This block runs every 0.5 seconds")
    )

using Godot;

public partial class MyNode : Node
{
    // Allows for recurring operations that don't trigger script logic
    // every frame (or even every fixed frame).
    public override void _Ready()
    {
        var timer = new Timer();
        timer.Autostart = true;
        timer.WaitTime = 0.5;
        AddChild(timer);
        timer.Timeout += () => GD.Print("This block runs every 0.5 seconds");
    }
}

Utilisez _physics_process() quand vous avez besoin d'écart de temps indépendant du temps entre les images. Si le code a besoin de mises à jour consistantes au fil du temps, quelle que soit la vitesse ou la lenteur de l'avancement du temps, c'est le bon endroit. Les opérations récurrentes de cinématique et de transformation d'objets doivent être exécutées ici.

Bien que cela soit possible, pour d'obtenir les meilleures performances, il faut éviter d'effectuer des contrôles d'entrée pendant ces rappels. _process() et _physics_process() se déclenchent à chaque occasion (ils ne se "reposent" pas par défaut). En revanche, les rappels *_input() ne se déclenchent que sur les trames dans lesquelles le moteur a effectivement détecté l'entrée.

On peut tout de même vérifier les actions d'entrée dans les rappels d'entrée. Si l'on veut utiliser l'écart de temps, on peut le récupérer à partir des méthodes d'écart de temps correspondantes si nécessaire.

# Called every frame, even when the engine detects no input.
func _process(delta):
    if Input.is_action_just_pressed("ui_select"):
        print(delta)

# Called during every input event.
func _unhandled_input(event):
    match event.get_class():
        "InputEventKey":
            if Input.is_action_just_pressed("ui_accept"):
                print(get_process_delta_time())

using Godot;

public partial class MyNode : Node
{

    // Called every frame, even when the engine detects no input.
    public void _Process(double delta)
    {
        if (Input.IsActionJustPressed("ui_select"))
            GD.Print(delta);
    }

    // Called during every input event. Equally true for _input().
    public void _UnhandledInput(InputEvent @event)
    {
        switch (@event)
        {
            case InputEventKey:
                if (Input.IsActionJustPressed("ui_accept"))
                    GD.Print(GetProcessDeltaTime());
                break;
        }
    }

}

_init vs. initialization vs. export

Si le script initialise son propre sous-arbre de nœuds, sans scène, ce code devrait s'exécuter dans _init(). D'autres propriétés ou initialisation indépendantes de l'arbre de SceneTree devraient également être exécutées ici.

Note

L'équivalent C# au ``_init()``de GDScript est le constructeur.

_init() se déclenche avant _enter_tree() ou ready(), mais après qu'un script crée et initialise ses proprietés. Lors de l'instanciation d'une scène, les valeurs des propriétés seront définies selon la séquence suivante :

**Première assignation de valeur :**la propriété est attribuée à la valeur d'initialisation ou la valeur par défaut. Si un donneur existe, il n'est pas utilisé.
``_init()`` affectation: la valeur de la propriété est remplacée par n'importe quel affectation faite dans _init(), déclenchant le donneur.
Affectation de valeur exporté: une valeur de propriété exporté est de nouveau remplacé par n'importe quel valeur définie dans l'Inspecteur, déclenchant le donneur.

# test is initialized to "one", without triggering the setter.
@export var test: String = "one":
    set(value):
        test = value + "!"

func _init():
    # Triggers the setter, changing test's value from "one" to "two!".
    test = "two"

# If someone sets test to "three" from the Inspector, it would trigger
# the setter, changing test's value from "two!" to "three!".

using Godot;

public partial class MyNode : Node
{
    private string _test = "one";

    [Export]
    public string Test
    {
        get { return _test; }
        set { _test = $"{value}!"; }
    }

    public MyNode()
    {
        // Triggers the setter, changing _test's value from "one" to "two!".
        Test = "two";
    }

    // If someone sets Test to "three" in the Inspector, it would trigger
    // the setter, changing _test's value from "two!" to "three!".
}

Par conséquent, l'instanciation d'un script par rapport à une scène peut affecter à la fois l'initialisation et le nombre de fois que le moteur appelle le setter.

_ready vs. _enter_tree vs. NOTIFICATION_PARENTED

Lors de l'instanciation d'une scène connectée à la première scène exécutée, Godot instancie les nœuds en bas de l'arbre (en faisant des appels _init()) et construit l'arbre en partant de la racine. Ceci provoque la cascade des appels _enter_tree() vers le bas de l'arbre. Une fois l'arbre terminé, les nœuds feuilles appellent _ready. Un nœud appellera cette méthode une fois que tous les nœuds enfants auront fini d'appeler les leurs. Ceci provoque alors une cascade inverse remontant jusqu'à la racine de l'arbre.

Lors de l'instanciation d'un script ou d'une scène autonome, les nœuds ne sont pas ajoutés au SceneTree lors de la création, donc aucun callback _enter_tree ne se déclenche. A la place, seul l'appel _init() se produit. Lorsque la scène est ajoutée au SceneTree, les appels _enter_tree() et _ready() se produisent.

Si l'on a besoin de déclencher un comportement qui se produit lorsque un nœud devient parent d'un autre, qu'il se produise dans le cadre de la scène principale/active ou non, on peut utiliser la notification PARENTED. Par exemple, voici un extrait qui connecte la méthode d'un nœud à un signal personnalisé sur le nœud parent sans échouer. Utile sur les nœuds centrés sur les données que l'on peut créer lors de l'exécution.

extends Node

var parent_cache

func connection_check():
    return parent_cache.has_user_signal("interacted_with")

func _notification(what):
    match what:
        NOTIFICATION_PARENTED:
            parent_cache = get_parent()
            if connection_check():
                parent_cache.interacted_with.connect(_on_parent_interacted_with)
        NOTIFICATION_UNPARENTED:
            if connection_check():
                parent_cache.interacted_with.disconnect(_on_parent_interacted_with)

func _on_parent_interacted_with():
    print("I'm reacting to my parent's interaction!")

using Godot;

public partial class MyNode : Node
{
    private Node _parentCache;

    public bool ConnectionCheck()
    {
        return _parentCache.HasUserSignal("InteractedWith");
    }

    public void _Notification(int what)
    {
        switch (what)
        {
            case NotificationParented:
                _parentCache = GetParent();
                if (ConnectionCheck())
                {
                    _parentCache.Connect("InteractedWith", Callable.From(OnParentInteractedWith));
                }
                break;
            case NotificationUnparented:
                if (ConnectionCheck())
                {
                    _parentCache.Disconnect("InteractedWith", Callable.From(OnParentInteractedWith));
                }
                break;
        }
    }

    private void OnParentInteractedWith()
    {
        GD.Print("I'm reacting to my parent's interaction!");
    }
}