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...
Node
Hérite de : Object
Hérité par : AnimationMixer, AudioStreamPlayer, CanvasItem, CanvasLayer, EditorFileSystem, EditorPlugin, EditorResourcePreview, HTTPRequest, InstancePlaceholder, MissingNode, MultiplayerSpawner, MultiplayerSynchronizer, NavigationAgent2D, NavigationAgent3D, Node3D, ResourcePreloader, ShaderGlobalsOverride, StatusIndicator, Timer, Viewport, WorldEnvironment
Classe de base pour les objets de scène.
Description
Les nœuds sont les blocs de construction de Godot. Ils peuvent être assignés comme enfant d'un autre nœud, ce qui résulte en un arrangement en arbre. Un nœud donné peut contenir n'importe quel nombre de nœuds enfants mais tous ces enfants doivent avoir des noms différents.
Une arborescence de nœuds est appelé une scène. Les scènes peuvent être sauvegardées sur le disque et ensuite instanciées dans d'autres scènes. Cela permet une très grande flexibilité dans l'architecture et le modèle de données des projets Godot.
Arbre de scène : Le SceneTree contient l'arborescence des nœuds. Lorsqu'un nœud est ajouté à l'arborescence de scène, il reçoit la notification NOTIFICATION_ENTER_TREE et sa méthode _enter_tree() est appelée. Les nœuds enfants sont toujours ajoutés après leur nœud parent, c'est-à-dire la méthode _enter_tree() d'un nœud parent sera appelée avant celle de son enfant.
Une fois que tous les nœuds ont été ajoutés dans l'arborescence de la scène, ils reçoivent la notification NOTIFICATION_READY et leurs méthodes respectives _ready() sont appelées. Pour les groupes de nœuds, la méthode _ready() est appelée en un ordre inversé, en commençant par les enfants et en allant jusqu'aux nœuds parent.
Cela signifie qu'en ajoutant un nœud à l'arborescence de la scène, l'ordre suivant sera utilisé pour les callbacks : _enter_tree() du parent, _enter_tree() des enfants, _ready() des enfants et enfin _ready() du parent (récursivement pour l'arborescence complète de la scène).
Traitement : Les nœuds peuvent redéfinir l'état "traitement", de sorte qu'ils reçoivent un callback sur chaque trame leur demandant de traiter (faire quelque chose). Le traitement normal (callback _process(), associé à set_process()) se produit le plus rapidement possible et dépend du taux de rafraîchissement, de sorte que le temps de traitement delta (en secondes) est passé comme argument. Le traitement de la physique (callback _physics_process(), activé avec set_physics_process()) se produit un nombre fixe de fois par seconde (60 par défaut) et est utile pour du code lié au moteur physique.
Les nœuds peuvent également traiter les événements d'entrée. Lorsque présente, la fonction _input() sera appelée pour chaque entrée que le programme reçoit. Dans de nombreux cas, cela peut être overkill (sauf pour des projets simples), et la fonction _unhandled_input() pourrait être préférée. Elle est appelée lorsque l'événement d'entrée n'a pas été géré par quelqu'un d'autre (généralement les nœuds GUI Control), en veillant à ce que le nœud ne reçoive que les événements qui lui étaient destinés.
Pour suivre la hiérarchie de la scène (surtout lorsque des scènes s'instancient dans d'autres scènes), un « propriétaire » peut être défini pour le nœud avec la propriété owner. Cela permet de savoir qui a instancié quoi. Ceci est surtout utile lors de l'écriture des éditeurs et des outils, cependant.
Enfin, lorsqu'un nœud est libéré avec Object.free() ou queue_free(), il libérera également tous ses enfants.
Groupes : Les nœuds peuvent être ajoutés à autant de groupes que vous voulez pour être faciles à gérer, vous pouvez créer des groupes comme "ennemis" ou "collectables" par exemple, selon votre jeu. Voir add_to_group(), is_in_group() et remove_from_group(). Vous pouvez alors récupérer tous les nœuds de ces groupes, itérer dessus et même appeler les méthodes sur les groupes via les méthodes sur SceneTree.
Réseau avec des nœuds : Après la connexion à un serveur (ou la création d'un serveur, voir ENetMultiplayerPeer), il est possible d'utiliser le système RPC intégré (Remote Procedure Call, appel de procédure à distance) pour communiquer sur le réseau. En appelant rpc() avec un nom de méthode, elle sera appelée localement et dans tous les pairs connectés (pairs = clients et le serveur qui accepte les connexions). Pour identifier quel nœud reçoit l'appel RPC, Godot utilisera son NodePath (assurez vous que les noms de nœud sont les mêmes pour tous les pairs). De plus, jetez un coup d'œil au tutoriel de réseau de haut niveau et aux démos correspondantes.
Note : La propriété script fait partie de la classe Object, et non Node. Elle n'est pas exposée comme la plupart des propriétés mais a un setter et getter (voir Object.set_script() et Object.get_script()).
Tutoriels
Propriétés
|
||
|
||
|
||
|
||
|
||
|
||
|
||
BitField[ProcessThreadMessages] |
||
|
Méthodes
Signaux
child_entered_tree(node: Node) 🔗
Émis lorsque le nœud enfant node entre dans le SceneTree, parce qu'il est entré dans l'arborescence, parce que ce nœud est entré dans l'arborescence (voir tree_entered), ou que add_child() a été appelée.
Ce signal est émis après la notification NOTIFICATION_ENTER_TREE et le signal tree_entered du nœud enfant.
child_exiting_tree(node: Node) 🔗
Émis lorsque le nœud enfant node va sortir du SceneTree, parce que ce nœud va sortir de l'arborescence (voir tree_exiting) ou que node est supprimé ou libéré.
Lorsque ce signal est reçu, node est toujours accessible à l'intérieur de l'arborescence. Ce signal est émis après la notification NOTIFICATION_EXIT_TREE et le signal tree_exiting du nœud enfant.
child_order_changed() 🔗
Émis lorsque la liste des enfants est modifiée. Cela se produit lorsque des nœuds enfants sont ajoutés, déplacés ou retirés.
editor_description_changed(node: Node) 🔗
Émis quand le champ de description du nœud dans l'éditeur a changé.
editor_state_changed() 🔗
Émis lorsqu'un attribut du nœud qui est pertinent pour l'éditeur est modifié. Seulement émis dans l'éditeur.
ready() 🔗
Émis lorsque le nœud est considéré prêt, après que _ready() soit appelée.
renamed() 🔗
Émis lorsque le nom name du nœud est changé, si le nœud est à l'intérieur de l'arborescence.
Émis lorsque ce nœud est remplacé par le nœud node, voir replace_by().
Ce signal est émis après que node a été ajouté en tant qu'enfant du nœud parent d'origine, mais avant tous les nœuds enfants originaux ont été re-parentés avec node.
tree_entered() 🔗
Émis quand le nœud entre dans l'arborescence.
Ce signal est émis après la notification correspondante NOTIFICATION_ENTER_TREE.
tree_exited() 🔗
Émis après que le nœud sort de l'arborescence et n'est plus actif.
Ce signal est émis après la notification NOTIFICATION_EXIT_TREE correspondante.
tree_exiting() 🔗
Émis quand le nœud est sur le point de sortir de l’arborescence. Le nœud est toujours valide. Ainsi, c'est le bon endroit pour la de-initialisation (ou un "destructeur", si vous préférez).
Ce signal est émis après la méthode _exit_tree() du nœud, et avant la notification liée NOTIFICATION_EXIT_TREE.
Énumérations
enum ProcessMode: 🔗
ProcessMode PROCESS_MODE_INHERIT = 0
Hérite le process_mode du parent du nœud. Il s'agit de la valeur par défaut pour tout nœud nouvellement créé.
ProcessMode PROCESS_MODE_PAUSABLE = 1
Processes when SceneTree.paused is false. This is the inverse of PROCESS_MODE_WHEN_PAUSED, and the default for the root node.
ProcessMode PROCESS_MODE_WHEN_PAUSED = 2
Processes only when SceneTree.paused is true. This is the inverse of PROCESS_MODE_PAUSABLE.
ProcessMode PROCESS_MODE_ALWAYS = 3
Always processes. Keeps processing, ignoring SceneTree.paused. This is the inverse of PROCESS_MODE_DISABLED.
ProcessMode PROCESS_MODE_DISABLED = 4
Never processes. Completely disables processing, ignoring SceneTree.paused. This is the inverse of PROCESS_MODE_ALWAYS.
enum ProcessThreadGroup: 🔗
ProcessThreadGroup PROCESS_THREAD_GROUP_INHERIT = 0
Process this node based on the thread group mode of the first parent (or grandparent) node that has a thread group mode that is not inherit. See process_thread_group for more information.
ProcessThreadGroup PROCESS_THREAD_GROUP_MAIN_THREAD = 1
Process this node (and child nodes set to inherit) on the main thread. See process_thread_group for more information.
ProcessThreadGroup PROCESS_THREAD_GROUP_SUB_THREAD = 2
Process this node (and child nodes set to inherit) on a sub-thread. See process_thread_group for more information.
flags ProcessThreadMessages: 🔗
ProcessThreadMessages FLAG_PROCESS_THREAD_MESSAGES = 1
Allows this node to process threaded messages created with call_deferred_thread_group() right before _process() is called.
ProcessThreadMessages FLAG_PROCESS_THREAD_MESSAGES_PHYSICS = 2
Allows this node to process threaded messages created with call_deferred_thread_group() right before _physics_process() is called.
ProcessThreadMessages FLAG_PROCESS_THREAD_MESSAGES_ALL = 3
Allows this node to process threaded messages created with call_deferred_thread_group() right before either _process() or _physics_process() are called.
enum PhysicsInterpolationMode: 🔗
PhysicsInterpolationMode PHYSICS_INTERPOLATION_MODE_INHERIT = 0
Hérite physics_interpolation_mode du parent du nœud. Il s'agit de la valeur par défaut pour tout nœud nouvellement créé.
PhysicsInterpolationMode PHYSICS_INTERPOLATION_MODE_ON = 1
Active l'interpolation de la physique pour ce nœud et pour les enfants définis à PHYSICS_INTERPOLATION_MODE_INHERIT. Il s'agit de la valeur par défaut pour le nœud racine.
PhysicsInterpolationMode PHYSICS_INTERPOLATION_MODE_OFF = 2
Désactive l'interpolation de la physique pour ce nœud et pour ses enfants définis à PHYSICS_INTERPOLATION_MODE_INHERIT.
enum DuplicateFlags: 🔗
DuplicateFlags DUPLICATE_SIGNALS = 1
Dupliquer les connexions de signal du nœud qui sont connectées avec le drapeau Object.CONNECT_PERSIST.
DuplicateFlags DUPLICATE_GROUPS = 2
Dupliquer les groupes du nœud.
DuplicateFlags DUPLICATE_SCRIPTS = 4
Dupliquer le script du nœud (redéfinit également les scripts des enfants dupliqués, si combiné avec DUPLICATE_USE_INSTANTIATION).
DuplicateFlags DUPLICATE_USE_INSTANTIATION = 8
Dupliquer en utilisant PackedScene.instantiate(). Si le nœud vient d'une scène sauvegardée sur le disque, réutilise PackedScene.instantiate() comme base pour le nœud dupliqué et ses enfants.
DuplicateFlags DUPLICATE_INTERNAL_STATE = 16
Duplicate also non-serializable variables (i.e. without @GlobalScope.PROPERTY_USAGE_STORAGE).
DuplicateFlags DUPLICATE_DEFAULT = 15
Duplicate using default flags. This constant is useful to add or remove a single flag.
# Duplicate non-exported variables.
var dupe = duplicate(DUPLICATE_DEFAULT | DUPLICATE_INTERNAL_STATE)
enum InternalMode: 🔗
InternalMode INTERNAL_MODE_DISABLED = 0
Ce nœud ne sera pas interne.
InternalMode INTERNAL_MODE_FRONT = 1
Le nœud sera placé au début des enfants du parent, avant tout frère non interne.
InternalMode INTERNAL_MODE_BACK = 2
Le nœud sera placé à la fin des enfants du parent, après tout frère non interne.
enum AutoTranslateMode: 🔗
AutoTranslateMode AUTO_TRANSLATE_MODE_INHERIT = 0
Hérite auto_translate_mode du parent du nœud. Il s'agit de la valeur par défaut pour tout nœud nouvellement créé.
AutoTranslateMode AUTO_TRANSLATE_MODE_ALWAYS = 1
Toujours traduire automatiquement. Il s'agit de l'inverse de AUTO_TRANSLATE_MODE_DISABLED, et la valeur par défaut pour le nœud racine.
AutoTranslateMode AUTO_TRANSLATE_MODE_DISABLED = 2
Never automatically translate. This is the inverse of AUTO_TRANSLATE_MODE_ALWAYS.
String parsing for translation template generation will be skipped for this node and children that are set to AUTO_TRANSLATE_MODE_INHERIT.
Constantes
NOTIFICATION_ENTER_TREE = 10 🔗
Notification reçue lorsque le nœud entre dans un SceneTree. Voir _enter_tree().
Cette notification est reçue avant le signal tree_entered correspondant.
NOTIFICATION_EXIT_TREE = 11 🔗
La notification reçue quand le nœud va quitter le SceneTree. Voir _exit_tree().
Cette notification est émise après le tree_exiting correspondant.
Cette notification est envoyée en ordre inverse.
NOTIFICATION_MOVED_IN_PARENT = 12 🔗
Obsolète : This notification is no longer sent by the engine. Use NOTIFICATION_CHILD_ORDER_CHANGED instead.
NOTIFICATION_READY = 13 🔗
La notification reçue quand le nœud est prêt. Voir _ready().
NOTIFICATION_PAUSED = 14 🔗
Notification reçue lorsque le nœud est mis en pause. Voir process_mode.
NOTIFICATION_UNPAUSED = 15 🔗
Notification reçue lorsque le nœud est sorti de la pause. Voir process_mode.
NOTIFICATION_PHYSICS_PROCESS = 16 🔗
Notification reçue de l’arborescence à chaque trame de physique lorsque is_physics_processing() renvoie true. Voir _physics_process().
NOTIFICATION_PROCESS = 17 🔗
Notification reçue de l’arborescence à chaque trame rendue lorsque is_processing() renvoie true. Voir _process().
NOTIFICATION_PARENTED = 18 🔗
Notification reçue lorsque le nœud est défini comme un enfant d'un autre nœud (voir add_child() et add_sibling()).
Note : Cela ne signifie pas que le nœud est entré dans le SceneTree.
NOTIFICATION_UNPARENTED = 19 🔗
Notification reçue lorsque le nœud parent appelle remove_child() sur ce nœud.
Note : Cela ne signifie pas que le nœud est sorti du SceneTree.
NOTIFICATION_SCENE_INSTANTIATED = 20 🔗
Notification reçue seulement par le nœud racine de la scène nouvellement instanciée, lorsque PackedScene.instantiate() est complétée.
NOTIFICATION_DRAG_BEGIN = 21 🔗
Notification received when a drag operation begins. All nodes receive this notification, not only the dragged one.
Can be triggered either by dragging a Control that provides drag data (see Control._get_drag_data()) or using Control.force_drag().
Use Viewport.gui_get_drag_data() to get the dragged data.
NOTIFICATION_DRAG_END = 22 🔗
La notification reçue à la fin d'une opération de déposé-glissé.
Utilisez Viewport.gui_is_drag_successful() pour vérifier si l'opération a réussi.
NOTIFICATION_PATH_RENAMED = 23 🔗
Notification reçue lorsque le nom name du nœud ou le name d'un de ses ancêtres est modifié. Cette notification n'est pas reçue lorsque le nœud est retiré du SceneTree.
NOTIFICATION_CHILD_ORDER_CHANGED = 24 🔗
Notification reçue lorsque la liste des enfants est modifiée. Cela se produit lorsque des nœuds enfants sont ajoutés, déplacés ou retirés.
NOTIFICATION_INTERNAL_PROCESS = 25 🔗
Notification reçue de l'arborescence à chaque trame rendue lorsque is_processing_internal() renvoie true.
NOTIFICATION_INTERNAL_PHYSICS_PROCESS = 26 🔗
Notification reçue de l'arborescence à chaque trame rendue lorsque is_physics_processing_internal() renvoie true.
NOTIFICATION_POST_ENTER_TREE = 27 🔗
Notification reçue lorsque le nœud entre dans l'arborescence, juste avant que NOTIFICATION_READY soit reçue. Contrairement à cette dernière, cette notification est envoyée à chaque fois que le nœud entre dans l'arborescence, et pas juste une seule fois.
NOTIFICATION_DISABLED = 28 🔗
Notification reçue lorsque le nœud est désactivé. Voir PROCESS_MODE_DISABLED.
NOTIFICATION_ENABLED = 29 🔗
Notification reçue lorsque le nœud est activé à nouveau après avoir été désactivé. Voir PROCESS_MODE_DISABLED.
NOTIFICATION_RESET_PHYSICS_INTERPOLATION = 2001 🔗
Notification reçue lorsque reset_physics_interpolation() est appelée sur le nœud ou ses ancêtres.
NOTIFICATION_EDITOR_PRE_SAVE = 9001 🔗
Notification reçue juste avant que la scène avec le nœud soit sauvegardée dans l'éditeur. Cette notification n'est envoyée que dans l'éditeur Godot et ne se produira pas dans des projets exportés.
NOTIFICATION_EDITOR_POST_SAVE = 9002 🔗
Notification reçue juste après que la scène avec le nœud soit sauvegardée dans l'éditeur. Cette notification n'est envoyée que dans l'éditeur Godot et ne se produira pas dans des projets exportés.
NOTIFICATION_WM_MOUSE_ENTER = 1002 🔗
Notification reçue lorsque la souris entre dans la fenêtre.
Implémenté pour les fenêtres intégrées et sur les plateformes de bureau et web.
NOTIFICATION_WM_MOUSE_EXIT = 1003 🔗
Notification reçue lorsque la souris quitte la fenêtre.
Implémenté pour les fenêtres intégrées et sur les plateformes de bureau et web.
NOTIFICATION_WM_WINDOW_FOCUS_IN = 1004 🔗
Notification reçue du système d'exploitation lorsque l'ancêtre Window du nœud reçoit le focus. Il peut s'agir d'un changement de focus entre deux fenêtres de la même instance du moteur, ou du bureau du système ou d'une application tierce vers une fenêtre du jeu (dans ce cas NOTIFICATION_APPLICATION_FOCUS_IN est également reçue).
Un nœud Window reçoit cette notification lorsqu'il reçoit le focus.
NOTIFICATION_WM_WINDOW_FOCUS_OUT = 1005 🔗
Notification reçue du système d'exploitation lorsque l'ancêtre Window du nœud perd le focus. Il peut s'agir d'un changement de focus entre deux fenêtres de la même instance du moteur, ou d'une fenêtre du jeu vers le bureau du système ou une application tierce (dans ce cas NOTIFICATION_APPLICATION_FOCUS_OUT est également reçue).
Un nœud Window reçoit cette notification lorsqu'il perd le focus.
NOTIFICATION_WM_CLOSE_REQUEST = 1006 🔗
Notification reçue du système d'exploitation lorsqu'une requête de fermeture est envoyée (par exemple, fermer la fenêtre avec un bouton "Fermer" ou Alt + F4).
Implémentée sur les plateformes de bureau.
NOTIFICATION_WM_GO_BACK_REQUEST = 1007 🔗
Notification reçue de l'OS lorsqu'une demande de retour est envoyée (p. ex. appuyant sur le bouton « Retour » sur Android).
Implémentée uniquement sur Android.
NOTIFICATION_WM_SIZE_CHANGED = 1008 🔗
Notification reçue lorsque la fenêtre est redimensionnée.
Note : Seul le nœud Window redimensionné reçoit cette notification, et elle n'est pas propagée aux nœuds enfants.
NOTIFICATION_WM_DPI_CHANGE = 1009 🔗
Notification reçue de l'OS lorsque l'échelle de points par pouce (DPI) de l'écran est modifiée. Seulement implémentée sur macOS.
NOTIFICATION_VP_MOUSE_ENTER = 1010 🔗
Notification reçue lorsque le curseur de la souris pénètre dans la zone visible du Viewport, qui n'est pas occultée derrière d'autres Controls ou Windows, pourvu que son Viewport.gui_disable_input vaille false et peu importe s'il a le focus ou non.
NOTIFICATION_VP_MOUSE_EXIT = 1011 🔗
Notification reçue lorsque le curseur de la souris sort de la zone visible du Viewport, qui n'est pas occultée derrière d'autres Controls ou Windows, pourvu que son Viewport.gui_disable_input vaille false et peu importe s'il a le focus ou non.
NOTIFICATION_WM_POSITION_CHANGED = 1012 🔗
Notification reçue lorsque la fenêtre est déplacée.
NOTIFICATION_WM_OUTPUT_MAX_LINEAR_VALUE_CHANGED = 1013 🔗
Notification received when the output max linear value returned by Window.get_output_max_linear_value() has changed.
This occurs when HDR output is enabled or disabled and when any HDR output luminance values of the window have changed, such as when the player adjusts their screen brightness setting or moves the window to a different screen.
NOTIFICATION_OS_MEMORY_WARNING = 2009 🔗
Notification du système d'exploitation lorsque l'application dépasse sa mémoire allouée.
Implémentée seulement sur iOS.
NOTIFICATION_TRANSLATION_CHANGED = 2010 🔗
Notification reçue lorsque les traductions ont peut-être changé. Peut être déclenché par l'utilisateur changeant la langue, changeant auto_translate_mode ou lorsque le nœud entre dans l'arborescence de la scène. Peut être utilisé pour répondre aux changements de langue, par exemple pour changer les chaînes de l'interface utilisateur à la volée. Utile pour travailler avec le support des traductions intégré, comme Object.tr().
Note : Cette notification est reçue avec NOTIFICATION_ENTER_TREE, donc si vous instanciez une scène, les nœuds enfants ne seront pas encore initialisés. Vous pouvez l'utiliser pour configurer les traductions pour ce nœud et les nœuds enfants créés à partir d'un script, ou si vous voulez accéder aux nœuds enfants ajoutés dans l'éditeur, assurez-vous que le nœud est prêt en utilisant is_node_ready().
func _notification(what):
if what == NOTIFICATION_TRANSLATION_CHANGED:
if not is_node_ready():
await ready # Attendre le signal ready.
$Label.text = atr("%d Bananes") % banana_counter
NOTIFICATION_WM_ABOUT = 2011 🔗
Notification reçue de l'OS lorsqu'une demande d'information "À propos" est envoyée.
Implémentée uniquement sur macOS.
NOTIFICATION_CRASH = 2012 🔗
Notification reçue du gestionnaire de plantage de Godot lorsque le moteur est sur le point de planter.
Implémenté sur les plateformes de bureau, si le gestionnaire de plantage est activé.
NOTIFICATION_OS_IME_UPDATE = 2013 🔗
Notification received from the OS when an update of the Input Method Engine occurs (e.g. change of IME cursor position or composition string).
Implemented on desktop and web platforms.
NOTIFICATION_APPLICATION_RESUMED = 2014 🔗
Notification reçue du système d'exploitation une fois de retour sur l'application.
Spécifique aux plateformes Android et iOS.
NOTIFICATION_APPLICATION_PAUSED = 2015 🔗
Notification reçue du système d'exploitation lorsque l'application est mise en pause.
Spécifique aux plateformes Android et iOS.
Note : Sur iOS, vous n'avez qu'environ 5 secondes pour terminer une tâche commencée par ce signal. Si vous dépassez ce temps attribué, iOS va tuer l'application au lieu de la mettre en pause.
NOTIFICATION_APPLICATION_FOCUS_IN = 2016 🔗
Notification reçue du système d'exploitation lorsque l'application prend le focus, c.à.d. lors du changement de focus du bureau de l'OS ou d'une application tierce vers n'importe quelle fenêtre de l'instance Godot.
Implémentée sur les plateformes mobiles et de bureau.
NOTIFICATION_APPLICATION_FOCUS_OUT = 2017 🔗
Notification reçue du système d'exploitation lorsque l'application perd le focus, c.à.d. lors du changement de focus de n'importe quelle fenêtre de l'instance Godot vers le bureau de l'OS ou une application tierce.
Implémentée sur les plateformes mobiles et de bureau.
NOTIFICATION_TEXT_SERVER_CHANGED = 2018 🔗
Notification reçue lorsque le TextServer est changé.
NOTIFICATION_APPLICATION_PIP_MODE_ENTERED = 2019 🔗
Notification received when the application enters picture-in-picture mode.
NOTIFICATION_APPLICATION_PIP_MODE_EXITED = 2020 🔗
Notification received when the application exits picture-in-picture mode.
NOTIFICATION_ACCESSIBILITY_UPDATE = 3000 🔗
Notification reçue lorsqu'une mise à jour d'information d'accessibilité est requise.
NOTIFICATION_ACCESSIBILITY_INVALIDATE = 3001 🔗
Notification reçue lorsque les éléments d'accessibilité sont invalidés. Tous les éléments d'accessibilité du nœud sont automatiquement supprimés après avoir reçu ce message, donc toutes les références existantes à ces éléments devraient être supprimées.
Descriptions des propriétés
AutoTranslateMode auto_translate_mode = 0 🔗
void set_auto_translate_mode(value: AutoTranslateMode)
AutoTranslateMode get_auto_translate_mode()
Defines if any text should automatically change to its translated version depending on the current locale (for nodes such as Label, RichTextLabel, Window, etc.). Also decides if the node's strings should be parsed for translation template generation.
Note: For the root node, auto translate mode can also be set via ProjectSettings.internationalization/rendering/root_node_auto_translate.
String editor_description = "" 🔗
Une description facultative du nœud. Elle s'affichera sous forme d'info-bulle lors du survol du nœud dans le dock Scene de l'éditeur.
MultiplayerAPI multiplayer 🔗
MultiplayerAPI get_multiplayer()
L'instance MultiplayerAPI associée à ce nœud. Voir SceneTree.get_multiplayer().
Note : Renommer le nœud, ou le déplacer dans l'arborescence, ne déplacera pas le MultiplayerAPI au nouveau chemin, vous devrez mettre à jour ceci manuellement.
StringName name 🔗
void set_name(value: StringName)
StringName get_name()
Le nom du nœud. Ce nom doit être unique parmi les frères (autres nœuds enfants du même parent). Lorsqu'il est défini au nom d'un frère existant, le nœud est automatiquement renommé.
Note : Lors de la modification du nom, les caractères suivants seront remplacés par un tiret-bas : (. : @ / " %). En particulier, le caractère @ est réservé aux noms autogénérés. Voir aussi String.validate_node_name().
The owner of this node. The owner must be an ancestor of this node. When packing the owner node in a PackedScene, all the nodes it owns are also saved with it. See also unique_name_in_owner.
Note: In the editor, nodes not owned by the scene root are usually not displayed in the Scene dock, and will not be saved. To prevent this, remember to set the owner after calling add_child().
Note: The owner needs to be the current scene root. See Instancing scenes in the documentation for more information.
PhysicsInterpolationMode physics_interpolation_mode = 0 🔗
void set_physics_interpolation_mode(value: PhysicsInterpolationMode)
PhysicsInterpolationMode get_physics_interpolation_mode()
Le mode d'interpolation de la physique à utiliser pour ce nœud. Seulement effectif si ProjectSettings.physics/common/physics_interpolation ou SceneTree.physics_interpolation vaut true.
Par défaut, les nœuds héritent du mode d'interpolation de la physique de leur parent. Cette propriété peut activer ou désactiver l'interpolation de la physique individuellement pour chaque nœud, indépendamment du mode d'interpolation de la physique de leurs parents.
Note : Certains types de nœuds comme VehicleWheel3D ont une interpolation de la physique désactivée par défaut, car ils se reposent sur leur propre solution personnalisée.
Note : Lors de la téléportation d'un nœud vers une position éloignée, il est recommandé de désactiver temporairement l'interpolation avec reset_physics_interpolation() après le déplacement du nœud. Cela évite de créer un trait visuel entre l'ancienne et la nouvelle position.
ProcessMode process_mode = 0 🔗
void set_process_mode(value: ProcessMode)
ProcessMode get_process_mode()
Le comportement de traitement du nœud. Pour vérifier si le nœud peut traiter dans son mode actuel, utilisez can_process().
int process_physics_priority = 0 🔗
Similaire à process_priority mais pour NOTIFICATION_PHYSICS_PROCESS, _physics_process(), ou NOTIFICATION_INTERNAL_PHYSICS_PROCESS.
L'ordre d'exécution du nœud des callbacks de traitement (_process(), NOTIFICATION_PROCESS et NOTIFICATION_INTERNAL_PROCESS). Les nœuds dont la valeur de priorité est plus basse auront leurs callback de traitement appelés en premier, peu importe l'ordre de l'arborescence.
ProcessThreadGroup process_thread_group = 0 🔗
void set_process_thread_group(value: ProcessThreadGroup)
ProcessThreadGroup get_process_thread_group()
Set the process thread group for this node (basically, whether it receives NOTIFICATION_PROCESS, NOTIFICATION_PHYSICS_PROCESS, _process() or _physics_process() (and the internal versions) on the main thread or in a sub-thread.
By default, the thread group is PROCESS_THREAD_GROUP_INHERIT, which means that this node belongs to the same thread group as the parent node. The thread groups means that nodes in a specific thread group will process together, separate to other thread groups (depending on process_thread_group_order). If the value is set is PROCESS_THREAD_GROUP_SUB_THREAD, this thread group will occur on a sub thread (not the main thread), otherwise if set to PROCESS_THREAD_GROUP_MAIN_THREAD it will process on the main thread. If there is not a parent or grandparent node set to something other than inherit, the node will belong to the default thread group. This default group will process on the main thread and its group order is 0.
During processing in a sub-thread, accessing most functions in nodes outside the thread group is forbidden (and it will result in an error in debug mode). Use Object.call_deferred(), call_thread_safe(), call_deferred_thread_group() and the likes in order to communicate from the thread groups to the main thread (or to other thread groups).
To better understand process thread groups, the idea is that any node set to any other value than PROCESS_THREAD_GROUP_INHERIT will include any child (and grandchild) nodes set to inherit into its process thread group. This means that the processing of all the nodes in the group will happen together, at the same time as the node including them.
int process_thread_group_order 🔗
Change l'ordre du groupe de thread de traitement. Les groupes avec un ordre inférieur traiteront avant les groupes avec un ordre plus élevé. Ceci est utile par exemple lorsqu'une grande quantité de nœuds se traitent dans un sous-thread et, par la suite, un autre groupe veut recueillir leur résultat dans le thread principal.
BitField[ProcessThreadMessages] process_thread_messages 🔗
void set_process_thread_messages(value: BitField[ProcessThreadMessages])
BitField[ProcessThreadMessages] get_process_thread_messages()
Définit si le groupe de thread actuel traitera les messages (appels à call_deferred_thread_group() sur les threads), et s'il veut les recevoir lors des callbacks de traitement régulier ou de traitement de la physique.
Le chemin de fichier de la scène originale, si le nœud a été instancié à partir d'un fichier PackedScene. Seuls les nœuds racine de scène contiennent ceci.
bool unique_name_in_owner = false 🔗
Si true, le nœud peut être accessible à partir de n'importe quel nœud partageant le même owner ou de l'owner lui-même, avec la syntaxe spéciale %Nom dans get_node().
Note : Si un autre nœud avec le même owner partage le même name que ce nœud, l'autre nœud ne sera plus accessible en tant que nœud unique.
Descriptions des méthodes
void _enter_tree() virtual 🔗
Appelé lorsque le nœud entre dans la SceneTree (par exemple en étant instancié, au changement de scène, ou après avoir appelé add_child() dans un script). Si le nœud a des enfants, sa méthode _enter_tree() sera appelée d'abord, puis ensuite celle de ses enfants.
Correspond à la notification NOTIFICATION_ENTER_TREE dans Object._notification().
void _exit_tree() virtual 🔗
Appelée lorsque le nœud va quitter la SceneTree (par exemple sur la suppression, au changement de scène, ou après avoir appelé remove_child() dans un script). Si le nœud a des enfants, sa méthode _exit_tree() sera appelée en dernier, quand tous ses enfants auront quitté l'arborescence.
Correspond à la notification NOTIFICATION_EXIT_TREE dans Object._notification() et signal tree_exiting. Pour être notifié lorsque le nœud a déjà quitté l'arborescence active, connectez-vous à tree_exited.
PackedStringArray _get_accessibility_configuration_warnings() virtual const 🔗
Les éléments du tableau renvoyé de cette méthode sont affichés comme avertissements dans le dock Scène si le script qui la redéfinit est un script tool, et les avertissements d'accessibilité sont activés dans les paramètres de l'éditeur.
Renvoyer un tableau vide ne produit aucun avertissement.
PackedStringArray _get_configuration_warnings() virtual const 🔗
Les éléments du tableau renvoyé par cette méthode sont affichés comme avertissements dans le dock Scène si le script qui le redéfinit est un script tool.
Le renvoi d'un tableau vide ne produit aucun avertissement.
Appelez update_configuration_warnings() lorsque les avertissements doivent être mis à jour pour ce nœud.
@export var energie = 0:
set(valeur):
energie = valeur
update_configuration_warnings()
func _get_configuration_warnings():
if energie < 0:
return ["L'énergie doit être supérieure ou égale à 0."]
else:
return []
RID _get_focused_accessibility_element() virtual const 🔗
Appelée lors des mises à jour d'information sur l'accessibilité pour déterminer le sous-élément ayant actuellement le focus, devait renvoyer un RID de sous-élément ou la valeur renvoyée par get_accessibility_element().
void _input(event: InputEvent) virtual 🔗
Appelée quand il y a un événement d'entrée. Cet événement se propage vers le haut de l'arborescence jusqu'à ce qu'un nœud le consomme.
Elle n'est appelée que si le traitement des entrées est activé, ce qui est fait automatiquement quand cette méthode est redéfinie, et peut être activé avec set_process_input().
Pour consommer l'événement d'entrée et arrêter sa propagation vers les autres nœuds, la méthode Viewport.set_input_as_handled() peut être appelée.
Pour les entrées de jeu, les méthodes _unhandled_input() et _unhandled_key_input() sont généralement plus adaptées puisqu'elles permettent aux éléments d'interface d'intercepter les événements en premier.
Note : Cette méthode n'est seulement appelé que si le nœud est présent dans l'arborescence (c-à-d n'est pas un orphelin).
void _physics_process(delta: float) virtual 🔗
Called once on each physics tick, and allows Nodes to synchronize their logic with physics ticks. delta is the logical time between physics ticks in seconds and is equal to Engine.time_scale / Engine.physics_ticks_per_second.
It is only called if physics processing is enabled for this Node, which is done automatically if this method is overridden, and can be toggled with set_physics_process().
Processing happens in order of process_physics_priority, lower priority values are called first. Nodes with the same priority are processed in tree order, or top to bottom as seen in the editor (also known as pre-order traversal).
Corresponds to the NOTIFICATION_PHYSICS_PROCESS notification in Object._notification().
Note: This method is only called if the node is present in the scene tree (i.e. if it's not an orphan).
Note: Accumulated delta may diverge from real world seconds.
void _process(delta: float) virtual 🔗
Called on each idle frame, prior to rendering, and after physics ticks have been processed. delta is the time between frames in seconds.
It is only called if processing is enabled for this Node, which is done automatically if this method is overridden, and can be toggled with set_process().
Processing happens in order of process_priority, lower priority values are called first. Nodes with the same priority are processed in tree order, or top to bottom as seen in the editor (also known as pre-order traversal).
Corresponds to the NOTIFICATION_PROCESS notification in Object._notification().
Note: This method is only called if the node is present in the scene tree (i.e. if it's not an orphan).
Note: When the engine is struggling and the frame rate is lowered, delta will increase. When delta is increased, it's capped at a maximum of Engine.time_scale * Engine.max_physics_steps_per_frame / Engine.physics_ticks_per_second. As a result, accumulated delta may not represent real world time.
Note: When --fixed-fps is enabled or the engine is running in Movie Maker mode (see MovieWriter), process delta will always be the same for every frame, regardless of how much time the frame took to render.
Note: Frame delta may be post-processed by OS.delta_smoothing if this is enabled for the project.
void _ready() virtual 🔗
Appelée lorsque le nœud est « prêt », c'est-à-dire lorsque le nœud et ses enfants sont entrés dans l'arborescence de la scène. Si le nœud a des enfants, leurs callbacks _ready() seront appelés en premier, et le nœud parent recevra la notification « prêt » après cela.
Correspond à la notification NOTIFICATION_READY dans Object._notification(). Voir aussi l'annotation @onready pour les variables.
Habituellement utilisé pour l'initialisation. Pour une initialisation encore plus précoce, Object._init() peut être utilisé. Voir aussi _enter_tree().
Note : Cette méthode ne peut être appelée qu'une seule fois pour chaque nœud. Après avoir retiré un nœud de l'arborescence de scène et l'ajouté à nouveau, _ready() ne sera pas appelé une deuxième fois. Cela peut être changé en demandant un autre appel avec request_ready(), qui peut être appelé n'importe où avant d'ajouter le nœud à nouveau.
void _shortcut_input(event: InputEvent) virtual 🔗
Appelée quand un InputEventKey, InputEventShortcut ou InputEventJoypadButton n'a pas été traité par _input() ou n'importe quel élément Control du GUI. Elle est appelée avant _unhandled_key_input() et _unhandled_input(). L'événement d'entrée se propage vers le haut de l'arborescence jusqu'à ce qu'un nœud le consomme.
Elle n'est appelée que si le processus de traitement des entrées est activé, ce qui est fait automatiquement si cette méthode est redéfinie, et peut être activé par set_process_shortcut_input().
Pour consommer l'événement d'entrée et arrêter sa propagation vers les autres nœuds, la méthode Viewport.set_input_as_handled() peut être appelée.
Cette méthode peut-être utilisée pour gérer les raccourcis. Pour les envenimements GUI génériques, utilisez plutôt _input(). Les évènement de gameplay devraient plutôt être gérés avec _unhandled_input() ou _unhandled_key_input().
Note : Cette méthode n'est seulement appelé que si le nœud est présent dans l'arborescence (c-à-d n'est pas un orphelin).
void _unhandled_input(event: InputEvent) virtual 🔗
Called when an InputEvent hasn't been consumed by _input() or any GUI Control item. It is called after _shortcut_input() and after _unhandled_key_input(). The input event propagates up through the node tree until a node consumes it.
It is only called if unhandled input processing is enabled, which is done automatically if this method is overridden, and can be toggled with set_process_unhandled_input().
To consume the input event and stop it propagating further to other nodes, Viewport.set_input_as_handled() can be called.
For gameplay input, this method is usually a better fit than _input(), as GUI events need a higher priority. For keyboard shortcuts, consider using _shortcut_input() instead, as it is called before this method. Finally, to handle keyboard events, consider using _unhandled_key_input() for performance reasons.
Note: This method is only called if the node is present in the scene tree (i.e. if it's not an orphan).
void _unhandled_key_input(event: InputEvent) virtual 🔗
Called when an InputEventKey hasn't been consumed by _input() or any GUI Control item. It is called after _shortcut_input() but before _unhandled_input(). The input event propagates up through the node tree until a node consumes it.
It is only called if unhandled key input processing is enabled, which is done automatically if this method is overridden, and can be toggled with set_process_unhandled_key_input().
To consume the input event and stop it propagating further to other nodes, Viewport.set_input_as_handled() can be called.
This method can be used to handle Unicode character input with Alt, Alt + Ctrl, and Alt + Shift modifiers, after shortcuts were handled.
For gameplay input, this and _unhandled_input() are usually a better fit than _input(), as GUI events should be handled first. This method also performs better than _unhandled_input(), since unrelated events such as InputEventMouseMotion are automatically filtered. For shortcuts, consider using _shortcut_input() instead.
Note: This method is only called if the node is present in the scene tree (i.e. if it's not an orphan).
void add_child(node: Node, force_readable_name: bool = false, internal: InternalMode = 0) 🔗
Ajoute un nœud enfant node. Les nœuds peuvent avoir n'importe quel nombre d'enfants, mais chaque enfant doit avoir un nom unique. Les nœuds enfants sont automatiquement supprimés lorsque le nœud parent est supprimé, de sorte qu'une scène entière peut être supprimée en supprimant son nœud le plus haut.
Si force_readable_name vaut true, améliore la lisibilité du node ajouté. S'il n'est pas nommé, le node est renommé à son type, et s'il partage name avec un frère, un nombre est ajouté en suffixe. Cette opération est très lente. Il est donc recommandé de laisser cela à false, ce qui attribue un nom factice comportant @ dans les deux cas.
Si internal est différent de INTERNAL_MODE_DISABLED, l'enfant sera ajouté comme nœud interne. Ces nœuds sont ignorés par des méthodes comme get_children(), sauf si leur paramètre include_internal vaut true. Cela empêche également que ces nœuds soient dupliqués avec leur parent. L'usage prévu est de cacher les nœuds internes à l'utilisateur, pour que l'utilisateur ne les supprime pas accidentellement ou les modifie. Utilisé par certains nœuds de GUI, par exemple ColorPicker.
Note : Si node a déjà un parent, cette méthode échouera. Utilisez remove_child() d'abord pour supprimer node de son parent actuel. Par exemple :
var noeud_enfant = get_child(0)
if noeud_enfant.get_parent():
noeud_enfant.get_parent().remove_child(noeud_enfant)
add_child(noeud_enfant)
Node noeudEnfant = GetChild(0);
if (noeudEnfant.GetParent() != null)
{
noeudEnfant.GetParent().RemoveChild(noeudEnfant);
}
AddChild(noeudEnfant);
Si vous avez besoin que le noeud enfant soit ajouté sous un nœud spécifique dans la liste des enfants, utilisez add_sibling() au lieu de cette méthode.
Note : Si vous voulez qu'un enfant persiste dans une PackedScene, vous devez définir owner en plus d'appeler add_child(). Ceci est généralement pertinent pour les scripts d'outil et les plugins éditeur. Si add_child() est appelé sans définir owner, le Node nouvellement ajouté ne sera pas visible dans l'arborescence de scène, bien qu'il sera visible dans la vue 2D/3D.
void add_sibling(sibling: Node, force_readable_name: bool = false) 🔗
Ajoute un nœud frère sibling au parent de ce nœud, et déplace le frère ajouté juste en dessous de ce nœud.
Si force_readable_name vaut true, améliore la lisibilité du nom de sibling. S'il n'est pas nommé, sibling est renommé à son type, et s'il partage name avec un frère, un nombre est suffixé de manière plus appropriée. Cette opération est très lente. Il est donc recommandé de laisser cela à false, ce qui attribue un nom factice comportant @ dans les deux cas.
Utilisez add_child() au lieu de cette méthode si vous n'avez pas besoin que le nœud enfant soit ajouté sous un nœud spécifique dans la liste des enfants.
Note : Si ce nœud est interne, le frère ajouté sera aussi interne (voir le paramètre internal de add_child()).
void add_to_group(group: StringName, persistent: bool = false) 🔗
Adds the node to the group. Groups can be helpful to organize a subset of nodes, for example "enemies" or "collectables". See notes in the description, and the group methods in SceneTree.
If persistent is true, the group will be stored when saved inside a PackedScene. All groups created and displayed in the Groups dock are persistent.
Note: To improve performance, the order of group names is not guaranteed and may vary between project runs. Therefore, do not rely on the group order.
Note: SceneTree's group methods will not work on this node if not inside the tree (see is_inside_tree()).
String atr(message: String, context: StringName = "") const 🔗
Traduit un message, en utilisant les catalogues de traduction configurés dans les Paramètres du projet. De plus, du contexte context peut être spécifié pour aider à la traduction. Notez que la plupart des nœuds Control traduisent automatiquement leurs chaînes, ainsi cette méthode est surtout utile pour les chaînes formatées ou du texte dessiné de manière personnalisée.
Cette méthode fonctionne de la même manière que Object.tr(), avec l'ajout du respect de l'état de auto_translate_mode.
Si Object.can_translate_messages() vaut false, ou qu'aucune traduction n'est disponible, cette méthode renverra le message sans modifications. Voir Object.set_message_translation().
Pour des exemples détaillés, voir Internationaliser des jeux.
String atr_n(message: String, plural_message: StringName, n: int, context: StringName = "") const 🔗
Traduit un message ou plusieurs messages (plural_message), en utilisant les catalogues de traduction configurés dans les Paramètres du projet. De plus, du contexte context peut être spécifié pour aider à la traduction.
Cette méthode fonctionne de la même manière que Object.tr_n(), avec l'ajout du respect de l'état de auto_translate_mode.
Si Object.can_translate_messages() vaut false, ou qu'aucune traduction n'est disponible, cette méthode renverra le message ou plural_message sans modifications. Voir Object.set_message_translation().
n est le nombre, ou la quantité, du sujet du message. Il est utilisé par le système de traduction pour obtenir la bonne forme plurielle pour la langue actuelle.
Pour des exemples détaillés, voir Localisation à l'aide de gettext.
Note : Les nombres négatifs et les float peuvent ne pas s'appliquer correctement à certains sujets comptables. Il est recommandé de traiter ces cas avec atr().
Variant call_deferred_thread_group(method: StringName, ...) vararg 🔗
This function is similar to Object.call_deferred() except that the call will take place when the node thread group is processed. If the node thread group processes in sub-threads, then the call will be done on that thread, right before NOTIFICATION_PROCESS or NOTIFICATION_PHYSICS_PROCESS, the _process() or _physics_process() or their internal versions are called.
Variant call_thread_safe(method: StringName, ...) vararg 🔗
Cette fonction assure que l'appel de cette fonction réussira, peu importe si elle est faite à partir d'un thread ou non. Si appelée d'un thread qui n'est pas autorisé à appeler la fonction, l'appel sera reporté. Sinon, l'appel passera directement.
bool can_auto_translate() const 🔗
Renvoie true si ce nœud peut automatiquement traduire des messages en fonction de la langue actuelle. Voir auto_translate_mode, atr(), et atr_n().
Renvoie true si le nœud peut recevoir des notifications de traitement et des callbacks d'entrée (NOTIFICATION_PROCESS, _input(), etc.) du SceneTree et d'un Viewport. La valeur renvoyée dépend de process_mode :
Si défini à PROCESS_MODE_PAUSABLE, renvoie
truelorsque le jeu est en cours de traitement, c-à-d que SceneTree.paused vautfalse;Si défini à PROCESS_MODE_WHEN_PAUSED, renvoie
truelorsque le jeu est en pause, c-à-d que SceneTree.paused vauttrue;Si défini à PROCESS_MODE_ALWAYS, renvoie toujours
true;Si défini à PROCESS_MODE_DISABLED, renvoie toujours
false;Si défini à PROCESS_MODE_INHERIT, utilise le process_mode du nœud parent pour déterminer le résultat.
Si le nœud n'est pas à l'intérieur de l'arborescence, renvoie false, peu importe la valeur de process_mode.
Crée un nouveau Tween et le lie à ce nœud.
C'est l'équivalent de faire :
get_tree().create_tween().bind_node(self)
GetTree().CreateTween().BindNode(this);
Le Tween commencera automatiquement sur le prochain trame de traitement ou de physique (selon TweenProcessMode). Voir Tween.bind_node() pour plus d'informations sur les Tweens lié à des nœuds.
Note : La méthode peut encore être utilisée lorsque le nœud n'est pas à l'intérieur de SceneTree. Elle peut échouer dans un cas improbable d'utilisation d'une boucle de traitement MainLoop personnalisée.
Node duplicate(flags: int = 15) const 🔗
Duplicates the node, returning a new node with all of its properties, signals, groups, and children copied from the original, recursively. The behavior can be tweaked through the flags (see DuplicateFlags). Internal nodes are not duplicated.
Note: For nodes with a Script attached, if Object._init() has been defined with required parameters, the duplicated node will not have a Script.
Note: By default, this method will duplicate only properties marked for serialization (i.e. using @GlobalScope.PROPERTY_USAGE_STORAGE, or in GDScript, @GDScript.@export). If you want to duplicate all properties, use DUPLICATE_INTERNAL_STATE.
Node find_child(pattern: String, recursive: bool = true, owned: bool = true) const 🔗
Trouve le premier descendant de ce nœud dont le nom name correspond à pattern, renvoyant null si aucune correspondance n'est trouvée. La correspondance est faite sur les noms des nœuds, pas sur leurs chemins, avec String.match(). Ainsi, elle est sensible à la casse, "*" correspond à zéro ou plus de caractères, et "?" correspond à tout caractère unique.
Si recursive vaut false, seuls les enfants directs de ce nœud sont vérifiés. Les nœuds sont contrôlés dans l'ordre de l'arborescence, de sorte que le premier enfant direct de ce nœud est vérifié en premier, puis ses propres enfants directs, etc., avant de passer au deuxième enfant direct, etc. Les enfants internes sont également inclus dans la recherche (voir le paramètre internal dans add_child()).
Si owned vaut true, seuls les descendants ayant un nœud owner valide sont vérifiés.
Note : Cette méthode peut être très lente. Envisagez de stocker une référence au nœud trouvé dans une variable. Alternativement, utilisez get_node() avec des noms uniques (voir unique_name_in_owner).
Note : Pour trouver tous les nœuds descendants correspondant à un motif ou un type de classe, voir find_children().
Array[Node] find_children(pattern: String, type: String = "", recursive: bool = true, owned: bool = true) const 🔗
Finds all descendants of this node whose names match pattern, returning an empty Array if no match is found. The matching is done against node names, not their paths, through String.match(). As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character.
If type is not empty, only descendants inheriting from type are included (see Object.is_class()).
If recursive is false, only this node's direct children are checked. Nodes are checked in tree order, so this node's first direct child is checked first, then its own direct children, etc., before moving to the second direct child, and so on. Internal children are also included in the search (see internal parameter in add_child()).
If owned is true, only descendants with a valid owner node are checked.
Note: This method can be very slow. Consider storing references to the found nodes in a variable.
Note: To find a single descendant node matching a pattern, see find_child().
Node find_parent(pattern: String) const 🔗
Trouve le premier ancêtre de ce nœud dont le nom name correspond à pattern, renvoyant null si aucune correspondance n'est trouvée. La correspondance est faite avec String.match(). Ainsi, elle est sensible à la casse, "*" correspond à zéro ou plus de caractères, et "?" correspond à tout caractère unique. Voir aussi find_child() et find_children().
Note : Comme cette méthode remonte l'arborescence de scène, elle peut être lente dans des nœuds profondément nichés. Envisagez de stocker une référence au nœud trouvé dans une variable. Alternativement, utilisez get_node() avec des noms uniques (voir unique_name_in_owner).
RID get_accessibility_element() const 🔗
Renvoie le RID de l'élément d'accessibilité principal.
Note : Cette méthode ne devrait être appelée que lors des mises à jour d'information d'accessibilité (NOTIFICATION_ACCESSIBILITY_UPDATE).
Node get_child(idx: int, include_internal: bool = false) const 🔗
Récupère un nœud enfant par son index. Chaque nœud enfant a un index par rapport à ses frères (voir get_index()). Le premier enfant est à l'index 0. Des valeurs négatives peuvent également être utilisées pour commencer à partir de la fin de la liste. Cette méthode peut être utilisée en combinaison avec get_child_count() pour itérer sur les enfants de ce nœud. Si aucun enfant n'existe à l'index donné, cette méthode renvoie null et une erreur est générée.
Si include_internal vaut false, les enfants internes sont ignorés (voir le paramètre internal de add_child()).
# En supposant ce qui suit représente des enfants de ce nœud, dans l'ordre :
# Premier, Milieu, Dernier.
var a = get_child(0).name # a vaut "Premier"
var b = get_child(1).name # b vaut "Milieu"
var b = get_child(2).name # b vaut "Dernier"
var c = get_child(-1).name # c vaut "Dernier"
Note : Pour récupérer un nœud par son NodePath, utilisez get_node().
int get_child_count(include_internal: bool = false) const 🔗
Renvoie le nombre d'enfants de ce nœud.
Si include_internal vaut false, les enfants internes ne sont pas comptés (voir le paramètre internal de add_child()).
Array[Node] get_children(include_internal: bool = false) const 🔗
Renvoie tous les enfants de ce nœud dans un Array.
Si include_internal vaut false, exclut les enfants internes du tableau renvoyé (voir le paramètre internal de add_child()).
Array[StringName] get_groups() const 🔗
Renvoie un Array des noms de groupe auxquels le nœud a été ajouté.
Note : Pour améliorer la performance, l'ordre des noms de groupe n'est pas garanti et peut varier entre les exécutions du projet. Par conséquent, ne comptez pas sur l'ordre des groupes.
Note : Cette méthode peut également renvoyer certains noms de groupe commençant par un tiret-bas (_). Ils sont utilisés en interne par le moteur. Pour éviter les conflits, n'utilisez pas de groupes personnalisés commençant par des tirets-bas. Pour exclure les groupes internes, voir le bout de code suivant :
# Stocke les groupes non internes du nœud seulement (en tant que tableau de StringNames).
var groupes_non_internes = []
for groupe in get_groups():
if not str(groupe).begins_with("_"):
groupes_non_internes.push_back(groupe)
// Stocke les groupes non internes du nœud seulement (en tant que List de StringNames).
List<string> groupesNonInternes = new List<string>();
foreach (string groupe in GetGroups())
{
if (!groupe.BeginsWith("_"))
groupesNonInternes.Add(groupe);
}
int get_index(include_internal: bool = false) const 🔗
Renvoie l'ordre de ce nœud parmi ses frères. L'index du premier nœud est 0. Voir aussi get_child().
Si include_internal vaut false, renvoie l'index en ignorant les enfants internes. Le premier enfant non interne aura un indice de 0 (voir le paramètre internal de add_child()).
Window get_last_exclusive_window() const 🔗
Renvoie la Window qui contient ce nœud, ou le dernier enfant exclusif dans une chaîne de fenêtres commençant par celle qui contient ce nœud.
int get_multiplayer_authority() const 🔗
Renvoie l'identifiant du pair de l'autorité multijoueur pour ce nœud. Voir set_multiplayer_authority().
Node get_node(path: NodePath) const 🔗
Récupère un nœud. Le NodePath peut être un chemin relatif (depuis le nœud actuel) ou absolu (depuis le SceneTree.root) vers un nœud. Si le path ne pointe pas vers un nœud valide, null est renvoyé et une erreur est générée. Appeler une méthode sur la valeur retournée si le nœud n'existe pas lancera une erreur comme "Attempt to call <method> on a null instance.".
Note : Récupérer un nœud avec un chemin absolu ne fonctionne que si ce nœud est dans l'arborescence (voir is_inside_tree()).
Exemple : En assumant que le nœud actuel soit "Personnage" et que l'arborescence soit la suivante :
┖╴root
┠╴Personnage (vous êtes ici !)
┃ ┠╴Épée
┃ ┖╴Sac-à-dos
┃ ┖╴Dague
┠╴MonJeu
┖╴Bassin
┠╴Alligator
┠╴Moustique
┖╴Goblin
Les chemins possibles sont :
get_node("Épée")
get_node("Sac-à-dos/Dague")
get_node("../Bassin/Alligator")
get_node("/root/MonJeu")
GetNode("Épée");
GetNode("Sac-à-dos/Dague");
GetNode("../Bassin/Alligator");
GetNode("/root/MonJeu");
Array get_node_and_resource(path: NodePath) 🔗
Récupère un nœud et sa ressource la plus imbriquée comme spécifié par le sous-nom du NodePath. Renvoie un Array de taille 3 où :
L'élément
0est le Node, ounullsi non trouvé;L'élément
1est la dernière Resource imbriquée du sous-nom, ounullsi non trouvée;L'élément
2est le NodePath restant, se référant à une propriété non-Resource existante (voir Object.get_indexed()).
Exemple : Supposons que la Sprite2D.texture de l'enfant a été assignée une AtlasTexture :
var a = get_node_and_resource("Area2D/Sprite2D")
print(a[0].name) # Affiche Sprite2D
print(a[1]) # Affiche <null>
print(a[2]) # Affiche ^""
var b = get_node_and_resource("Area2D/Sprite2D:texture:atlas")
print(b[0].name) # Affiche Sprite2D
print(b[1].get_class()) # Affiche AtlasTexture
print(b[2]) # Affiche ^""
var c = get_node_and_resource("Area2D/Sprite2D:texture:atlas:region")
print(c[0].name) # Affiche Sprite2D
print(c[1].get_class()) # Affiche AtlasTexture
print(c[2]) # Affiche ^":region"
var a = GetNodeAndResource(NodePath("Area2D/Sprite2D"));
GD.Print(a[0].Name); // Affiche Sprite2D
GD.Print(a[1]); // Affiche <null>
GD.Print(a[2]); // Affiche ^"
var b = GetNodeAndResource(NodePath("Area2D/Sprite2D:texture:atlas"));
GD.Print(b[0].name); // Affiche Sprite2D
GD.Print(b[1].get_class()); // Affiche AtlasTexture
GD.Print(b[2]); // Affiche ^""
var c = GetNodeAndResource(NodePath("Area2D/Sprite2D:texture:atlas:region"));
GD.Print(c[0].name); // Affiche Sprite2D
GD.Print(c[1].get_class()); // Affiche AtlasTexture
GD.Print(c[2]); // Affiche ^":region"
Node get_node_or_null(path: NodePath) const 🔗
Récupère un nœud par son NodePath. Semblable à get_node(), mais ne génère pas d'erreur si path ne pointe pas vers un nœud valide.
Variant get_node_rpc_config() const 🔗
Renvoie un Dictionary associant des noms de méthodes à leur configuration RPC définie pour ce nœud en utilisant rpc_config().
Note : Cette méthode ne renvoie que la configuration RPC assignée via rpc_config(). Voir Script.get_rpc_config() pour récupérer les RPCs définis par le Script.
Array[int] get_orphan_node_ids() static 🔗
Renvoie les identifiants d'objet de tous les nœuds orphelins (nœuds en dehors du SceneTree). Utilisé pour le débogage.
Note : get_orphan_node_ids() ne fonctionne que dans les compilations de débogage. Lorsqu'appelé dans un projet exporté en mode release, get_orphan_node_ids() renverra un tableau vide.
Renvoie le nœud parent de ce nœud, ou null si le nœud n'a pas de parent.
Renvoie le chemin absolu du nœud actuel, relatif à SceneTree.root. Si le nœud actuel n'est pas à l'intérieur de l'arborescence de la scène, cette méthode échoue et renvoie un NodePath vide.
NodePath get_path_to(node: Node, use_unique_path: bool = false) const 🔗
Renvoie le NodePath relatif de ce nœud vers le nœud node spécifié. Les deux nœuds doivent être dans le même SceneTree ou hiérarchie de scène, sinon cette méthode échoue et renvoie un NodePath vide.
Si use_unique_path vaut true, renvoie le chemin le plus court correspondant au nom unique de ce nœud (voir unique_name_in_owner).
Note : Si vous obtenez un chemin relatif qui part d'un nœud unique, le chemin peut être plus long qu'un chemin relatif normal, à cause de l'ajout du nom unique du nœud.
float get_physics_process_delta_time() const 🔗
Renvoie le temps écoulé (en secondes) depuis le dernier callback de physique. Cette valeur est identique au paramètre delta de _physics_process(), et elle est souvent consistante durant l'exécution, à moins que Engine.physics_ticks_per_second ne soit modifié. Voir aussi NOTIFICATION_PHYSICS_PROCESS.
Note : La valeur renvoyée sera plus grande que prévu lors de l'exécution à un framerate inférieur à Engine.physics_ticks_per_second / Engine.max_physics_steps_per_frame FPS. Ceci est fait pour éviter les scénarios de « spirale de la mort » où la performance chuterait en raison d'un nombre en augmentation constante d'étapes de physique par trame. Ce comportement affecte à la fois _process() et _physics_process(). Par conséquent, évitez d'utiliser delta pour les mesures de temps en secondes réelles. Utilisez les méthodes du singleton Time à cette fin, comme Time.get_ticks_usec().
float get_process_delta_time() const 🔗
Renvoie le temps écoulé (en secondes) depuis le dernier callback de traitement. Cette valeur est identique au paramètre delta de _process() et peut varier d'une trame à l'autre. Voir aussi NOTIFICATION_PROCESS.
Note : La valeur renvoyée sera plus grande que prévu lors de l'exécution à un framerate inférieur à Engine.physics_ticks_per_second / Engine.max_physics_steps_per_frame FPS. Ceci est fait pour éviter les scénarios de « spirale de la mort » où la performance chuterait en raison d'un nombre en augmentation constante d'étapes de physique par trame. Ce comportement affecte à la fois _process() et _physics_process(). Par conséquent, évitez d'utiliser delta pour les mesures de temps en secondes réelles. Utilisez les méthodes du singleton Time à cette fin, comme Time.get_ticks_usec().
bool get_scene_instance_load_placeholder() const 🔗
Returns true if this node is an instance load placeholder. See InstancePlaceholder and set_scene_instance_load_placeholder().
Renvoie le SceneTree qui contient ce nœud. Si ce nœud n'est pas à l'intérieur de l'arborescence, génère une erreur et renvoie null. Voir aussi is_inside_tree().
Renvoie l’arborescence en tant que String. Utilisée principalement à des fins de débogage. Cette version affiche le chemin par rapport au nœud actuel, et est pratique pour copier/coller dans la fonction get_node(). Elle peut également être utilisé dans l'UI/UX du jeu.
Peut afficher, par exemple :
LeJeu
LeJeu/Menu
LeJeu/Menu/Label
LeJeu/Menu/Camera2D
LeJeu/EcranDemarrage
LeJeu/EcranDemarrage/Camera2D
String get_tree_string_pretty() 🔗
Comme get_tree_string(), cela renvoie l’arborescence en tant que String. Cette version affiche une représentation plus graphique semblable à ce qui est affiché dans le Dock Scène. Elle est utile pour inspecter de grandes arborescences.
Peut afficher, par exemple:
┖╴LeJeu
┠╴Menu
┃ ┠╴Label
┃ ┖╴Camera2D
┖╴EcranDemarrage
┖╴Camera2D
Viewport get_viewport() const 🔗
Renvoie l'ancêtre Viewport le plus proche du nœud, si le nœud est à l'intérieur de l'arborescence. Sinon, renvoie null.
Renvoie la Window qui contient ce nœud. Si le nœud est dans la fenêtre principale, cela équivaut à obtenir le nœud racine (get_tree().get_root()).
bool has_node(path: NodePath) const 🔗
Renvoie true si le chemin path pointe vers un nœud valide. Voir aussi get_node().
bool has_node_and_resource(path: NodePath) const 🔗
Renvoie true si le chemin path désigne un nœud valide et que son sous-nom désigne une Resource valide, par exemple Area2D/CollisionShape2D:shape. Les propriétés avec un type qui n'est pas une Resource (par exemple les nœuds ou les autres types Variant) ne sont pas considérées. Voir aussi get_node_and_resource().
bool is_ancestor_of(node: Node) const 🔗
Renvoie true si le nœud node donné est un enfant direct ou indirect de ce nœud.
bool is_displayed_folded() const 🔗
Renvoie true si le nœud est replié (réduit) dans le dock Scène. Cette méthode est destinée à être utilisée dans les plugins et outils de l'éditeur. Voir aussi set_display_folded().
bool is_editable_instance(node: Node) const 🔗
Returns true if node has editable children enabled relative to this node. This method is intended to be used in editor plugins and tools. See also set_editable_instance().
bool is_greater_than(node: Node) const 🔗
Renvoie true si le nœud node donné apparaît plus tard dans la hiérarchie de la scène que ce nœud. Un nœud survenant plus tard est généralement traité plus tard.
bool is_in_group(group: StringName) const 🔗
Renvoie true si ce nœud a été ajouté au groupe group donné. Voir add_to_group() et remove_from_group(). Voir aussi les notes dans la description, et les méthodes de groupe de SceneTree.
Renvoie true si ce nœud est actuellement dans un SceneTree. Voir aussi get_tree().
bool is_multiplayer_authority() const 🔗
Renvoie true si le système local est l'autorité multijoueur de ce nœud.
Renvoie true si le nœud est prêt, c'est-à-dire qu'il est dans l'arborescence de la scène et que tous ses enfants sont initialisés.
request_ready() le réinitialise à false.
bool is_part_of_edited_scene() const 🔗
Renvoie true si le nœud fait partie de la scène actuellement ouverte dans l'éditeur.
bool is_physics_interpolated() const 🔗
Renvoie true si l'interpolation de la physique est activée pour ce nœud (voir physics_interpolation_mode).
Note : L'interpolation ne sera active que si le drapeau est défini et que l'interpolation de la physique est activée dans SceneTree. Ceci peut être testé en utilisant is_physics_interpolated_and_enabled().
bool is_physics_interpolated_and_enabled() const 🔗
Renvoie true si l'interpolation de la physique est activée (voir physics_interpolation_mode) et activée dans le SceneTree.
Il s'agit d'une version pratique de is_physics_interpolated() qui vérifie également si l'interpolation de la physique est activée globalement.
Voir SceneTree.physics_interpolation et ProjectSettings.physics/common/physics_interpolation.
bool is_physics_processing() const 🔗
Renvoie true si le traitement physique est activé (voir set_physics_process()).
bool is_physics_processing_internal() const 🔗
Renvoie true si le traitement physique interne est activé (voir set_physics_process_internal()).
Renvoie true si le traitement est activé (voir set_process()).
bool is_processing_input() const 🔗
Renvoie true si le nœud gère les entrées (voir set_process_input()).
bool is_processing_internal() const 🔗
Renvoie true si le traitement interne est activé (voir set_process_internal()).
bool is_processing_shortcut_input() const 🔗
Renvoie true si le nœud traite des raccourcis (voir set_process_shortcut_input()).
bool is_processing_unhandled_input() const 🔗
Renvoie true si le nœud gère les entrées non traitées (voir set_process_unhandled_input()).
bool is_processing_unhandled_key_input() const 🔗
Renvoie true si le nœud gère les entrées de touche non traitée (voir set_process_unhandled_key_input()).
void move_child(child_node: Node, to_index: int) 🔗
Déplace le nœud enfant child_node vers l'index donné. L'index d'un nœud est l'ordre parmi ses frères. Si to_index est négatif, l'index est compté à partir de la fin de la liste. Voir aussi get_child() et get_index().
Note : L'ordre de traitement de plusieurs callbacks du moteur (_ready(), _process(), etc.) et les notifications envoyées à travers propagate_notification() sont affectées par l'ordre de l'arbre. Les nœuds CanvasItem sont également rendus dans l'ordre de l'arbre. Voir aussi process_priority.
void notify_deferred_thread_group(what: int) 🔗
Similaire à call_deferred_thread_group(), mais pour les notifications.
void notify_thread_safe(what: int) 🔗
Similaire à call_thread_safe(), mais pour les notifications.
void print_orphan_nodes() static 🔗
Prints all orphan nodes (nodes outside the SceneTree). Useful for debugging.
Note: This method only works in debug builds. It does nothing in a project exported in release mode.
void print_tree() 🔗
Affiche le nœud et ses enfants dans la console, récursivement. Le nœud ne doit pas forcément être à l'intérieur de l'arbre. Cette méthode produit des NodePath relatifs à ce nœud, et est bon pour copier/coller dans get_node(). Voir aussi print_tree_pretty().
Peut afficher, par exemple :
.
Menu
Menu/Label
Menu/Camera2D
SplashScreen
SplashScreen/Camera2D
void print_tree_pretty() 🔗
Affiche le nœud et ses enfants dans la console, récursivement. Le nœud ne doit forcément pas être à l'intérieur de l'arborescence. Semblable à print_tree(), mais la représentation graphique ressemble à ce qui est affiché dans le dock Scène de l'éditeur. Elle est utile pour inspecter les grands arbres.
Peut afficher, par exemple :
┖╴LeJeu
┠╴Menu
┃ ┠╴Etiquette
┃ ┖╴Camera2D
┖╴SplashScreen
┖╴Camera2D
void propagate_call(method: StringName, args: Array = [], parent_first: bool = false) 🔗
Appelle le nom de méthode method donné, en passant args comme arguments, sur ce nœud et tous ses enfants, de façon récursive.
Si parent_first vaut true, la méthode est appelée d'abord sur ce nœud, puis sur tous ses enfants. Si false, les méthodes des enfants sont appelées en premier.
void propagate_notification(what: int) 🔗
Appelle Object.notification() avec what sur ce nœud et tous ses enfants, récursivement.
void queue_accessibility_update() 🔗
Queues an accessibility information update for this node.
void queue_free() 🔗
Place le nœud dans une file d'attente pour le supprimer à la fin de la trame actuelle. Lorsque supprimé, tous ses nœuds enfants seront supprimés aussi, et toutes les références au nœud et ses enfants deviennent invalides.
Contrairement à Object.free(), le nœud n'est pas supprimé instantanément, et il peut encore être accédé avant la suppression. Il est également sûr d'appeler plusieurs fois queue_free(). Utilisez Object.is_queued_for_deletion() pour vérifier si le nœud sera supprimé à la fin de la trame.
Note : Le nœud ne sera libéré qu'après la fin de tous les autres appels différés. Utiliser cette méthode n'est pas toujours identique à l'appel de Object.free() à travers Object.call_deferred().
void remove_child(node: Node) 🔗
Retire un nœud node enfant. Le node, ainsi que ses enfants, ne sont pas supprimés. Pour supprimer un nœud, voir queue_free().
Note : Lorsque ce nœud se trouve à l'intérieur de l'arborescence, cette méthode définit le owner du node retiré (ou ses descendants) à null, si leur owner n'est plus un ancêtre (voir is_ancestor_of()).
void remove_from_group(group: StringName) 🔗
Retire le nœud du groupe group donné. Ne fait rien si le nœud n'est pas dans le groupe. Voir aussi les notes dans la description, et les méthodes de groupe de SceneTree.
void reparent(new_parent: Node, keep_global_transform: bool = true) 🔗
Changes the parent of this Node to the new_parent. The node needs to already have a parent. The node's owner is preserved if its owner is still reachable from the new location (i.e., the node is still a descendant of the new parent after the operation).
If keep_global_transform is true, the node's global transform will be preserved if supported. Node2D, Node3D and Control support this argument (but Control keeps only position).
Warning: If ProjectSettings.physics/common/physics_interpolation is enabled and reparenting causes a large change in global transform, the object may appear to move from its old position to its new one over the next physics tick. To avoid this, call reset_physics_interpolation() after reparenting.
void replace_by(node: Node, keep_groups: bool = false) 🔗
Remplace ce nœud par le nœud node donné. Tous les enfants de ce nœud sont déplacés vers node.
Si keep_groups vaut true, le nœud node est ajouté aux mêmes groupes dans lesquels se trouvait le nœud remplacé (voir add_to_group()).
Attention : Le nœud remplacé est retiré de l'arbre, mais il n'est pas supprimé. Pour éviter les fuites de mémoire, stockez une référence au nœud dans une variable, ou utilisez Object.free().
void request_ready() 🔗
Demande à ce que _ready() soit appelée à nouveau la prochaine fois que le nœud entre dans l'arborescence. N'appelle pas immédiatement _ready().
Note : Cette méthode n'affecte que le nœud actuel. Si les enfants du nœud ont également besoin d'appeler ready, cette méthode doit être appelée pour chacun d'eux. Lorsque le nœud et ses enfants entrent à nouveau dans l'arborescence, l'ordre des callbacks de _ready() sera le même qu'habituellement.
void reset_physics_interpolation() 🔗
Lorsque l'interpolation de la physique est activée, déplacer un nœud vers une transformation radicalement différente (comme le placement dans un niveau) peut résulter en un glitch visible car l'objet est rendu se déplaçant de l'ancienne à la nouvelle position pendant la tic de physique.
Ce glitch peut être empêché en appelant cette méthode, qui désactive temporairement l'interpolation jusqu'à ce que le tic de physique soit fini.
La notification NOTIFICATION_RESET_PHYSICS_INTERPOLATION sera reçue par le nœud et tous ses enfants de manière récursive.
Note : Cette fonction doit être appelée après le déplacement du nœud, plutôt qu'avant.
Error rpc(method: StringName, ...) vararg 🔗
Sends a remote procedure call request for the given method to peers on the network (and locally), sending additional arguments to the method called by the RPC. The call request will only be received by nodes with the same NodePath, including the exact same name. Behavior depends on the RPC configuration for the given method (see rpc_config() and @GDScript.@rpc). By default, methods are not exposed to RPCs.
May return @GlobalScope.OK if the call is successful, @GlobalScope.ERR_INVALID_PARAMETER if the arguments passed in the method do not match, @GlobalScope.ERR_UNCONFIGURED if the node's multiplayer cannot be fetched (such as when the node is not inside the tree), @GlobalScope.ERR_CONNECTION_ERROR if multiplayer's connection is not available.
Note: You can only safely use RPCs on clients after you received the MultiplayerAPI.connected_to_server signal from the MultiplayerAPI. You also need to keep track of the connection state, either by the MultiplayerAPI signals like MultiplayerAPI.server_disconnected or by checking (get_multiplayer().peer.get_connection_status() == CONNECTION_CONNECTED).
void rpc_config(method: StringName, config: Variant) 🔗
Change la configuration RPC pour la méthode method donnée. config doit valoir soit null pour désactiver la fonctionnalité (par défaut), soit un Dictionary contenant les entrées suivantes :
rpc_mode: voir RPCMode;transfer_mode: voir TransferMode;call_local: sitrue, la méthode sera également appelée localement;channel: un int représentant le canal auquel envoyer la RPC.
Note : En GDScript, cette méthode correspond à l'annotation @GDScript.@rpc, avec divers paramètres passés (@rpc(any), @rpc(authority)...). Voir aussi le tutoriel API multijoueur de haut niveau.
Error rpc_id(peer_id: int, method: StringName, ...) vararg 🔗
Envoie une rpc() à un pair spécifique identifié par peer_id (voir MultiplayerPeer.set_target_peer()).
Peut renvoyer @GlobalScope.OK si l'appel est un succès, @GlobalScope.ERR_INVALID_PARAMETER si les arguments passés dans method ne correspondent pas, @GlobalScope.ERR_UNCONFIGURED si le multiplayer du nœud ne peut être récupéré (comme lorsque le nœudn'est pas dans l'arborescence), @GlobalScope.ERR_CONNECTION_ERROR si la connexion de multiplayer n'est pas disponible.
void set_deferred_thread_group(property: StringName, value: Variant) 🔗
Similaire à call_deferred_thread_group(), mais pour définir des propriétés.
void set_display_folded(fold: bool) 🔗
Si défini à true, le nœud apparaît replié dans le dock Scène. En conséquence, tous ses enfants sont cachés. Cette méthode est destinée à être utilisée dans les plugins et les outils d'éditeur, mais elle fonctionne également dans les compilations de release. Voir aussi is_displayed_folded().
void set_editable_instance(node: Node, is_editable: bool) 🔗
Défini à true pour permettre à tous les nœuds appartenant à node d'être disponibles, et modifiables, dans le dock Scène, même si leur propriétaire owner n'est pas la racine de scène. Cette méthode est destinée à être utilisée dans les plugins et les outils d'éditeur, mais elle fonctionne également dans les compilations de release. Voir aussi is_editable_instance().
void set_multiplayer_authority(id: int, recursive: bool = true) 🔗
Définit l'autorité multijoueur du nœud au pair avec l'identifiant de pair id donné. L'autorité multijoueur est le pair qui a autorité sur le nœud sur le réseau. Vaut par défaut l'identifiant de pair 1 (le serveur). Utile en conjonction avec rpc_config() et MultiplayerAPI.
Si recursive vaut true, le pair donné est défini de façon récursive comme autorité sur tous les enfants de ce nœud.
Attention : Cela ne réplique pas automatiquement la nouvelle autorité à d'autres pairs. La responsabilité de le faire est sur le développeur. Vous pouvez répliquer les informations de la nouvelle autorité en utilisant MultiplayerSpawner.spawn_function, une RPC, ou un MultiplayerSynchronizer. De plus, l'autorité du parent ne se propage pas aux enfants nouvellement ajoutés.
void set_physics_process(enable: bool) 🔗
Si défini à true, active le traitement de la physique (à framerate fixe). Lorsqu'un nœud est traité, il recevra une notification NOTIFICATION_PHYSICS_PROCESS à un intervalle fixe (généralement 60 FPS, voir Engine.physics_ticks_per_second pour changer) (et le callback _physics_process() sera appelé s'il existe).
Note : Si _physics_process() est redéfinie, cela sera automatiquement activé avant que _ready() soit appelée.
void set_physics_process_internal(enable: bool) 🔗
Si défini à true, active la physique en interne pour ce nœud. Le traitement de la physique en interne se produit séparément des appels normaux de _physics_process() et est utilisé par certains nœuds en interne pour garantir le bon fonctionnement même si le nœud est mis ou en pause ou que le traitement de la physique est désactivé pour le scripting (set_physics_process()).
Attention : Les nœuds intégrés s'appuient sur du traitement interne pour leur logique interne. Désactiver cela est dangereux et peut conduire à un comportement inattendu. Utilisez cette méthode si vous savez ce que vous faites.
void set_process(enable: bool) 🔗
Si défini à true, active le traitement. Lorsqu'un nœud est en cours de traitement, il recevra un NOTIFICATION_PROCESS à chaque trame dessinée (et le callback _process() sera appelé s'il existe).
Note : Si _process() est redéfinie, cela sera automatiquement activé avant que _ready() soit appelée.
Note : Cette méthode n'affecte que le callback _process(), c'est-à-dire qu'elle n'a aucun effet sur d'autres callbacks comme _physics_process(). Si vous voulez désactiver tout traitement pour le nœud, définissez process_mode à PROCESS_MODE_DISABLED.
void set_process_input(enable: bool) 🔗
Si défini à true, active le traitement des entrées.
Note : Si _input() est redéfinie, cela sera automatiquement activé avant que _ready() soir appelée. Le traitement des entrées est également déjà activé pour les contrôles de GUI, tels que Button et TextEdit.
void set_process_internal(enable: bool) 🔗
Si défini à true, active la traitement en interne pour ce nœud. Le traitement en interne se produit séparément des appels normaux de _process() et est utilisé par certains nœuds en interne pour garantir un bon fonctionnement même si le nœud est mis ou en pause ou que le traitement est désactivé pour le scripting (set_process()).
Attention : Les nœuds intégrés s'appuient sur du traitement interne pour leur logique interne. Désactiver cela est dangereux et peut conduire à un comportement inattendu. Utilisez cette méthode si vous savez ce que vous faites.
void set_process_shortcut_input(enable: bool) 🔗
Si défini à true, active le traitement des raccourcis pour ce nœud.
Note : Si _shortcut_input() est redéfinie, cela sera automatiquement activé avant que _ready() soit appelée.
void set_process_unhandled_input(enable: bool) 🔗
Si défini à true, active le traitement des entrées non gérées. Cela permet au nœud de recevoir toutes les entrées qui n'ont pas été gérées précédemment (généralement par un Control).
Note : Si _unhandled_input() est redéfinie, cela sera automatiquement activé avant que _ready() soit appelée. Le traitement des entrées non gérées est généralement déjà activé pour les contrôles GUI tels que Button et TextEdit.
void set_process_unhandled_key_input(enable: bool) 🔗
Si défini à true, active le traitement des entrées de touche non traitées.
Note : Si _unhandled_key_input() est redéfinie, cela sera automatiquement activé avant que _ready() soit appelée.
void set_scene_instance_load_placeholder(load_placeholder: bool) 🔗
Si défini à true, le nœud devient un InstancePlaceholder lorsqu'il est compacté et instancié depuis une PackedScene. Voir aussi get_scene_instance_load_placeholder().
void set_thread_safe(property: StringName, value: Variant) 🔗
Similaire à call_thread_safe(), mais pour définir des propriétés.
void set_translation_domain_inherited() 🔗
Fait hériter ce nœud du domaine de traduction de son nœud parent. Si ce nœud n'a pas de parent, le domaine de traduction principal sera utilisé.
Il s'agit du comportement par défaut pour tous les nœuds. Appeler Object.set_translation_domain() désactive ce comportement.
void update_configuration_warnings() 🔗
Rafraîchit les avertissements affichés pour ce nœud dans le dock Scène. Utilisez _get_configuration_warnings() pour personnaliser les messages d'avertissement à afficher.