Object
Hérité par : AudioServer, CameraServer, ClassDB, DisplayServer, EditorFileSystemDirectory, EditorInterface, EditorPaths, EditorSelection, EditorUndoRedoManager, EditorVCSInterface, Engine, EngineDebugger, FramebufferCacheRD, GDExtensionManager, Geometry2D, Geometry3D, Input, InputMap, IP, JavaClassWrapper, JavaScriptBridge, JNISingleton, JSONRPC, MainLoop, Marshalls, MovieWriter, NativeMenu, NavigationMeshGenerator, NavigationServer2D, NavigationServer3D, Node, OpenXRExtensionWrapper, OpenXRInteractionProfileMetadata, OS, Performance, PhysicsDirectBodyState2D, PhysicsDirectBodyState3D, PhysicsDirectSpaceState2D, PhysicsDirectSpaceState3D, PhysicsServer2D, PhysicsServer2DManager, PhysicsServer3D, PhysicsServer3DManager, PhysicsServer3DRenderingServerHandler, ProjectSettings, RefCounted, RenderData, RenderingDevice, RenderingServer, RenderSceneData, ResourceLoader, ResourceSaver, ResourceUID, ScriptLanguage, ShaderIncludeDB, TextServerManager, ThemeDB, TileData, Time, TranslationServer, TreeItem, UndoRedo, UniformSetCacheRD, WorkerThreadPool, XRServer, XRVRS
Classe de base pour toutes les autres classes du moteur.
Description
Un type de Variant avancé. Toutes les classes du moteur héritent d'Object. Chaque classe peut définir de nouvelles propriétés, méthodes ou signaux, disponibles pour toutes les classes héritantes. Par exemple, une instance de Sprite2D peut appeler Node.add_child() parce qu'elle hérite de Node.
Vous pouvez créer de nouvelles instances en utilisant Object.new() en GDScript, ou new GodotObject dans C#.
Pour supprimer une instance objet, appelez free(). Cela est nécessaire pour la plupart des classes héritant d'Objet, parce qu'ils ne gèrent pas la mémoire toute seules, et provoquera sinon des fuites de mémoire quand ils ne sont plus utilisés. Il y a quelques classes qui effectuent la gestion de la mémoire. Par exemple, RefCounted (et par extension Resource) se supprime lorsqu'il n'est plus référencé, et Node supprime ses enfants lorsqu'il est libéré.
Les objets peuvent avoir un Script attaché à eux. Une fois le Script instancié, il agit efficacement comme une extension à la classe de base, lui permettant de définir et d'hériter de nouvelles propriétés, méthodes et signaux.
Dans un Script, _get_property_list() peut être redéfini pour personnaliser les propriétés de plusieurs façons. Cela leur permet d'être disponibles pour l'éditeur, de les afficher sous forme de listes d'options, de sous-diviser en groupes, d'enregistrer sur disque, etc. Les langages de Scripting offrent des façons plus faciles de personnaliser les propriétés, comme avec l'annotation @GDScript.@export.
Godot est très dynamique. Le script d'un objet, et donc ses propriétés, méthodes et signaux, peuvent être modifiés à l'exécution. Pour cette raison, il peut y avoir des occasions où, par exemple, une propriété requise par une méthode peut ne pas exister. Pour éviter les erreurs durant l'exécution, voir des méthodes telles que set(), get(), call(), has_method(), has_signal(), etc. Notez que ces méthodes sont beaucoup plus lentes que les références directes.
En GDScript, vous pouvez également vérifier si un nom de propriété, de méthode ou de signal donné existe dans un objet avec l'opérateur in :
var noeud = Node.new()
print("name" in noeud) # Affiche true
print("get_parent" in noeud) # Affiche true
print("tree_entered" in noeud) # Affiche true
print("inconnu" in noeud) # Affiche false
Les notifications sont des constantes int généralement envoyées et reçues par des objets. Par exemple, sur chaque trame rendue, le SceneTree notifie les nœuds à l'intérieur de l'arbre avec un Node.NOTIFICATION_PROCESS. Les nœuds la reçoivent et peuvent appeler Node._process() pour se mettre à jour. Pour utiliser les notifications, voir notification() et _notification().
Enfin, chaque objet peut également contenir des métadonnées (des données sur des données). set_meta() peut être utile pour stocker des informations sur lesquelles l'objet lui-même ne dépend pas. Pour garder votre code propre, faire un usage excessif des métadonnées est déconseillé.
Note : Contrairement aux références à un RefCounted, les références à un objet stocké dans une variable peuvent devenir invalides sans être définies à null. Pour vérifier si un objet a été supprimé, ne le comparez pas avec null. Au lieu de cela, utilisez @GlobalScope.is_instance_valid(). Il est également recommandé d'hériter de RefCounted pour les classes qui stockent des données au lieu d'Object.
Note : Le script n'est pas exposé comme la plupart des propriétés. Pour définir ou obtenir le Script d'un objet dans le code, utilisez set_script() et get_script() respectivement.
Note : Dans un contexte booléen, un Object évaluera à false s'il est égal à null ou s'il a été libéré. Dans le cas contraire, un Object évaluera toujours à true. Voir aussi @GlobalScope.is_instance_valid().
Tutoriels
Méthodes
Signaux
property_list_changed() 🔗
Émis lorsque notify_property_list_changed() est appelée.
script_changed() 🔗
Émis lorsque le script de l'objet est changé.
Note : Lorsque ce signal est émis, le nouveau script n'est pas encore initialisé. Si vous devez accéder au nouveau script, reportez les connexions à ce signal avec CONNECT_DEFERRED.
Énumérations
enum ConnectFlags: 🔗
ConnectFlags CONNECT_DEFERRED = 1
Deferred connections trigger their Callables on idle time (at the end of the frame), rather than instantly.
ConnectFlags CONNECT_PERSIST = 2
Les connexions persistantes sont stockées lorsque l'objet est sérialisé (comme lors de l'utilisation de PackedScene.pack()). Dans l'éditeur, les connexions créées par le Dock Nœud persistent toujours.
ConnectFlags CONNECT_ONE_SHOT = 4
Les connections uniques (one-shot) se déconnectent après l'émission.
ConnectFlags CONNECT_REFERENCE_COUNTED = 8
Les connexions comptées par référence peuvent être assignées au même Callable plusieurs fois. Chaque déconnexion diminue le compteur interne. Le signal se déconnecte entièrement seulement lorsque le compteur atteint 0.
ConnectFlags CONNECT_APPEND_SOURCE_OBJECT = 16
L'objet source est automatiquement lié lorsqu'une PackedScene est instanciée. Si ce bit de drapeau est activé, l'objet source sera ajouté juste après les arguments originaux du signal.
Constantes
NOTIFICATION_POSTINITIALIZE = 0 🔗
Notification reçue lorsque l'objet est initialisé, avant que son script soit attaché. Utilisé en interne.
NOTIFICATION_PREDELETE = 1 🔗
Notification reçue lorsque l'objet est sur le point d'être supprimé. Peut être utilisé comme destructeurs dans des langages de programmation orientés objet.
NOTIFICATION_EXTENSION_RELOADED = 2 🔗
Notification reçue lorsque l'objet termine le rechargement à chaud. Cette notification n'est envoyée que pour les classes d'extension et leurs dérivées.
Descriptions des méthodes
Variant _get(property: StringName) virtual 🔗
Redéfinissez cette méthode pour personnaliser le comportement de get(). Devrait renvoyer la valeur de la propriété property donnée, ou null si property devrait être traitée normalement.
Combiné avec _set() et _get_property_list(), cette méthode permet de définir des propriétés personnalisées, ce qui est particulièrement utile pour les plugins éditeurs.
Note : Cette méthode n'est pas appelée pour obtenir des propriétés intégrées d'un objet, y compris les propriétés définies avec @GDScript.@export.
func _get(property):
if property == "fausse_propriete":
print("Obtenir ma propriété !")
return 4
func _get_property_list():
return [
{ "name": "fausse_propriete", "type": TYPE_INT }
]
public override Variant _Get(StringName property)
{
if (property == "FaussePropriete")
{
GD.Print("Obtenir ma propriété !");
return 4;
}
return default;
}
public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetPropertyList()
{
return
[
new Godot.Collections.Dictionary()
{
{ "name", "FaussePropriete" },
{ "type", (int)Variant.Type.Int },
},
];
}
Array[Dictionary] _get_property_list() virtual 🔗
Redéfinissez cette méthode pour fournir une liste personnalisée des propriétés supplémentaires à manipuler par le moteur.
Devrait renvoyer une liste de propriétés, en tant qu'Array de dictionnaires. Le résultat est ajouté au tableau de get_property_list(), et devrait être formaté de la même manière. Chaque Dictionary doit au moins contenir les entrées name et type.
Vous pouvez utiliser _property_can_revert() et _property_get_revert() pour personnaliser les valeurs par défaut des propriétés ajoutées par cette méthode.
L'exemple ci-dessous affiche une liste de nombres indiqués comme mots allant de ZERO à CINQ, avec compte_nombre contrôlant la taille de la liste :
@tool
extends Node
@export var compte_nombre = 3:
set(cn):
compte_nombre = cn
nombres.resize(compte_nombre)
notify_property_list_changed()
var nombres = PackedInt32Array([0, 0, 0])
func _get_property_list():
var proprietes = []
for i in range(compte_nombre):
proprietes.append({
"name": "nombre_%d" % i,
"type": TYPE_INT,
"hint": PROPERTY_HINT_ENUM,
"hint_string": "ZERO,UN,DEUX,TROIS,QUATRE,CINQ",
})
return proprietes
func _get(property):
if property.begins_with("nombre_"):
var index = property.get_slice("_", 1).to_int()
return nombres[index]
func _set(property, value):
if property.begins_with("nombre_"):
var index = property.get_slice("_", 1).to_int()
nombres[index] = value
return true
return false
[Tool]
public partial class MonNoeud : Node
{
private int _compteNombre;
[Export]
public int CompteNombre
{
get => _compteNombre;
set
{
_compteNombre = value;
_nombres.Resize(_compteNombre);
NotifyPropertyListChanged();
}
}
private Godot.Collections.Array<int> _nombres = [];
public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetPropertyList()
{
Godot.Collections.Array<Godot.Collections.Dictionary> proprietes = [];
for (int i = 0; i < _compteNombre; i++)
{
proprietes.Add(new Godot.Collections.Dictionary()
{
{ "name", $"nombre_{i}" },
{ "type", (int)Variant.Type.Int },
{ "hint", (int)PropertyHint.Enum },
{ "hint_string", "Zero,Un,Deux,Trois,Quatre,Cinq" },
});
}
return proprietes;
}
public override Variant _Get(StringName property)
{
string nomPropriete = property.ToString();
if (nomPropriete.StartsWith("nombre_"))
{
int index = int.Parse(nomPropriete.Substring("nombre_".Length));
return _nombres[index];
}
return default;
}
public override bool _Set(StringName property, Variant value)
{
string nomPropriete = property.ToString();
if (nomPropriete.StartsWith("nombre_"))
{
int index = int.Parse(nomPropriete.Substring("nombre_".Length));
_nombres[index] = value.As<int>();
return true;
}
return false;
}
}
Note : Cette méthode est destinée à des fins avancées. Pour la plupart des cas d'utilisation courants, les langages de script offrent des façons plus faciles de gérer les propriétés. Voir @GDScript.@export, @GDScript.@export_enum, @GDScript.@export_group, etc... Si vous voulez personnaliser les propriétés exportées, utilisez _validate_property().
Note : Si le script de l'objet n'a pas l'annotation @GDScript.@tool, cette méthode ne sera pas appelée dans l'éditeur.
void _init() virtual 🔗
Appelé lorsque le script de l'objet est instancié, souvent après l'initialisation de l'objet en mémoire (via Object.new() en GDScript, ou new GodotObject en C#). Elle peut également être définie pour prendre des paramètres. Cette méthode est semblable à un constructeur dans la plupart des langages de programmation.
Note : Si _init() est défini avec des paramètres obligatoires, l'Object avec le script ne peut être créé que directement. Si d'autres moyens (comme PackedScene.instantiate() ou Node.duplicate()) sont utilisés, l'initialisation du script échouera.
Variant _iter_get(iter: Variant) virtual 🔗
Renvoie la valeur itérable courante. iter stocke l'état de l'itération, mais contrairement à _iter_init() et _iter_next(), l'état est censé être en lecture seule, donc il n'y a pas de wrapper Array.
Astuce : En GDScript, vous pouvez utiliser un sous-type de Variant comme type de retour pour _iter_get(). Le type spécifié sera utilisé pour définir le type de la variable d'itération dans les boucles for, améliorant la sûreté du typage.
bool _iter_init(iter: Array) virtual 🔗
Initialise l'itérateur. iter stocke l'état d'itération. Puisque GDScript ne supporte pas le passage d'arguments par référence, un tableau avec un seul élément est utilisé comme wrapper. Renvoie true tant que l'itérateur n'a pas atteint la fin.
class MonIntervalle:
var _de
var _vers
func _init(de, vers):
assert(de <= vers)
_de = de
_vers = vers
func _iter_init(iter):
iter[0] = _de
return iter[0] < _vers
func _iter_next(iter):
iter[0] += 1
return iter[0] < _vers
func _iter_get(iter):
return iter
func _ready():
var mon_intervalle = MonIntervalle.new(2, 5)
for x in mon_intervalle:
print(x) # Affiche 2, 3, 4.
Note : Sinon, vous pouvez ignorer iter et utiliser l'état de l'objet à la place, voir la documentation en ligne par exemple. Notez que dans ce cas vous ne serez pas en mesure de réutiliser la même instance d'itérateur dans les boucles imbriquées. Assurez-vous également de réinitialiser l'état de l'itérateur dans cette méthode si vous voulez réutiliser la même instance plusieurs fois.
bool _iter_next(iter: Array) virtual 🔗
Déplace l'itérateur à la prochaine itération. iter stocke l'état de l'itération. Puisque GDScript ne supporte pas les arguments de passés par référence, un tableau avec un seul élément est utilisé comme wrapper. Renvoie true tant que l'itérateur n'a pas atteint la fin.
void _notification(what: int) virtual 🔗
Appelée lorsque l'objet reçoit une notification, qui peut être identifiée dans what en la comparant à une constante. Voir aussi notification().
func _notification(what):
if what == NOTIFICATION_PREDELETE:
print("Au revoir !")
public override void _Notification(int what)
{
if (what == NotificationPredelete)
{
GD.Print("Au revoir !");
}
}
Note : L'Object de base définit quelques notifications (NOTIFICATION_POSTINITIALIZE et NOTIFICATION_PREDELETE). Les classes dérivées telles que Node définissent beaucoup plus de notifications, qui sont également reçues par cette méthode.
Note : Contrairement à d'autres méthodes virtuelles, cette méthode est appelée automatiquement pour chaque script qui la redéfinit. Cela signifie que l'implémentation de base ne doit pas être appelée via super en GDScript ou ses équivalents dans d'autres langages.
bool _property_can_revert(property: StringName) virtual 🔗
Redéfinissez cette méthode pour personnaliser le comportement de restauration de la propriété property donnée. Doit renvoyer true si la propriété property a une valeur par défaut personnalisée et est réversible dans le dock Inspecteur. Utilisez _property_get_revert() pour spécifier la valeur par défaut de property.
Note : Cette méthode doit renvoyer systématiquement, peu importe la valeur actuelle de property.
Variant _property_get_revert(property: StringName) virtual 🔗
Redéfinissez cette méthode pour personnaliser le comportement de restauration de la propriété property donnée. Devrait renvoyer la valeur par défaut de property. Si la valeur par défaut diffère de la valeur actuele de property, une icône de restauration est affichée dans le dock Inspecteur.
Note : _property_can_revert() doit aussi être redéfinie pour que cette méthode soit appelée.
bool _set(property: StringName, value: Variant) virtual 🔗
Redéfinissez cette méthode pour personnaliser le comportement de set(). Doit définir la propriété property à la valeur value et renvoyer true, ou false si la propriété property devrait être manipulée normalement. La façon exacte de configurer property dépend de l'implémentation de cette méthode.
Combiné avec _get() et _get_property_list(), cette méthode permet de définir des propriétés personnalisées, ce qui est particulièrement utile pour les plugins éditeurs.
Note : Cette méthode n'est pas appelée lorsque vous définissez des propriétés intégrées d'un objet, y compris les propriétés définies par @GDScript.@export.
var donnees_internes = {}
func _set(property, value):
if property == "fausse_propriete":
# Stocker la valeur dans la fausse propriété.
donnees_internes["fausse_propriete"] = value
return true
return false
func _get_property_list():
return [
{ "name": "fausse_propriete", "type": TYPE_INT }
]
private Godot.Collections.Dictionary _donneesInternes= new Godot.Collections.Dictionary();
public override bool _Set(StringName property, Variant value)
{
if (property == "FaussePropriete")
{
// Stocker la valeur dans la fausse propriété.
_donneesInternes["FaussePropriete"] = value;
return true;
}
return false;
}
public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetPropertyList()
{
return
[
new Godot.Collections.Dictionary()
{
{ "name", "FaussePropriete" },
{ "type", (int)Variant.Type.Int },
},
];
}
Redéfinissez cette méthode pour personnaliser la valeur de renvoi de to_string(), et donc la représentation de l'objet comme String.
func _to_string():
return "Bienvenue dans Godot 4!"
func _init():
print(self) # Affiche "Bienvenue dans Godot 4!
var a = str(self) # a vaut "Bienvenue dans Godot 4!
void _validate_property(property: Dictionary) virtual 🔗
Redéfinissez cette méthode pour personnaliser les propriétés existantes. Chaque info de propriété passe par cette méthode, sauf les propriétés ajoutées avec _get_property_list(). Le contenu du dictionnaire est le même que dans _get_property_list().
@tool
extends Node
@export var le_nombre_est_modifiable: bool:
set(value):
le_nombre_est_modifiable = value
notify_property_list_changed()
@export var nombre: int
func _validate_property(property: Dictionary):
if property.name == "nombre" and not le_nombre_est_modifiable:
property.usage |= PROPERTY_USAGE_READ_ONLY
[Tool]
public partial class MyNode : Node
{
private bool _leNombreEstModifiable;
[Export]
public bool LeNombreEstModifiable;
{
get => _leNombreEstModifiable;
set
{
_leNombreEstModifiable = value;
NotifyPropertyListChanged();
}
}
[Export]
public int Nombre { get; set; }
public override void _ValidateProperty(Godot.Collections.Dictionary property)
{
if (property["name"].AsStringName() == PropertyName.Nombre && !LeNombreEstModifiable)
{
var usage = property["usage"].As<PropertyUsageFlags>() | PropertyUsageFlags.ReadOnly;
property["usage"] = (int)usage;
}
}
}
void add_user_signal(signal: String, arguments: Array = []) 🔗
Ajout d'un signal défini par l'utilisateur nommé signal. Les arguments optionnels du signal peuvent être ajoutés comme un Array de dictionnaires, chacun définissant un String name et un int type (voir Variant.Type). Voir aussi has_user_signal() et remove_user_signal().
add_user_signal("blesse", [
{ "name": "degats", "type": TYPE_INT },
{ "name": "source", "type": TYPE_OBJECT }
])
AddUserSignal("Blesse",
[
new Godot.Collections.Dictionary()
{
{ "name", "degats" },
{ "type", (int)Variant.Type.Int },
},
new Godot.Collections.Dictionary()
{
{ "name", "source" },
{ "type", (int)Variant.Type.Object },
},
]);
Variant call(method: StringName, ...) vararg 🔗
Appelle la méthode method sur l'objet et renvoie le résultat. Cette méthode supporte un nombre variable d'arguments, ces paramètres étant passés dans une liste séparée par des virgules.
var noeud = Node3D.new()
noeud.call("rotate", Vector3(1.0, 0.0, 0.0), 1.571)
var noeud = new Node3D();
noeud.Call(Node3D.MethodName.Rotate, new Vector3(1f, 0f, 0f), 1.571f);
Note : En C#, method doit être en snake_case si elle se réfère à une méthode de Godot intégrée. Préférez utiliser les noms exposés dans la classe MethodName pour éviter d'allouer un nouveau StringName à chaque appel.
Variant call_deferred(method: StringName, ...) vararg 🔗
Appelle la méthode method sur l'objet pendant le temps d'inaction. Renvoie toujours null, pas le résultat de la méthode.
Le temps d'inaction se produit principalement à la fin des trames de traitement et de physique. Dans ce cas, les appels différés seront exécutés jusqu'à ce qu'il n'y en ait plus, ce qui signifie que vous pouvez reporter les appels d'autres appels différés et qu'ils seront toujours exécutés dans le cycle de temps d'inaction actuel. Cela signifie que vous ne devriez pas appeler une méthode différée depuis elle-même (ou d'une méthode qu'elle appelle), car cela provoque une récursion infinie de la même manière que si vous aviez appelé la méthode directement.
Cette méthode prend en charge un nombre variable d'arguments, de sorte que les paramètres peuvent être passés en tant que liste séparée par des virgules.
var noeud = Node3D.new()
noeud.call_deferred("rotate", Vector3(1.0, 0.0, 0.0), 1.571)
var noeud = new Node3D();
noeud.CallDeferred(Node3D.MethodName.Rotate, new Vector3(1f, 0f, 0f), 1.571f);
Voir aussi Callable.call_deferred().
Note : En C#, method doit être en snake_case si elle se réfère à une méthode de Godot intégrée. Préférez utiliser les noms exposés dans la classe MethodName pour éviter d'allouer un nouveau StringName à chaque appel.
Note : Si vous cherchez à différer l'appel de fonction d'une trame, reportez-vous aux signaux SceneTree.process_frame et SceneTree.physics_frame.
var noeud = Node3D.new()
# Faire un Callable et lier les arguments à l'appel de rotate() du nœud.
var callable = noeud.rotate.bind(Vector3(1.0, 0.0, 0.0), 1.571)
# Connecter le Callable au signal process_frame, ainsi, il est appelle à la prochaine trame de traitement.
# CONNECT_ONE_SHOT s'assure qu'il n'est appelé qu'une fois au lieu de à chaque trame.
get_tree().process_frame.connect(callable, CONNECT_ONE_SHOT)
Variant callv(method: StringName, arg_array: Array) 🔗
Appelle la méthode method sur l'objet et renvoie le résultat. Contrairement à call(), cette méthode s'attend à ce que tous les paramètres soient dans le tableau arg_array :
var noeud = Node3D.new()
noeud.callv("rotate", [Vector3(1.0, 0.0, 0.0), 1.571])
var noeud = new Node3D();
noeud.Callv(Node3D.MethodName.Rotate, [new Vector3(1f, 0f, 0f), 1.571f]);
Note : En C#, method doit être en snake_case si elle se réfère à une méthode de Godot intégrée. Préférez utiliser les noms exposés dans la classe MethodName pour éviter d'allouer un nouveau StringName à chaque appel.
bool can_translate_messages() const 🔗
Renvoie true si l'objet est autorisé à traduire des messages avec tr() et tr_n(). Voir aussi set_message_translation().
void cancel_free() 🔗
Si cette méthode est appelée pendant NOTIFICATION_PREDELETE, cet objet rejettera sa libération et restera alloué. Il s'agit principalement d'une fonction interne utilisée pour la manipulation des erreurs afin d'éviter à l'utilisateur de libérer des objets lorsqu'ils ne sont pas destinés à l'être.
Error connect(signal: StringName, callable: Callable, flags: int = 0) 🔗
Connecte un signal par nom à un callable. Des drapeaux flags optionnels peuvent aussi être ajoutés pour configurer le comportement de la connexion (voir les constantes ConnectFlags).
Un signal ne peut être connecté qu'une fois au même Callable. Si le signal est déjà connecté, cette méthode renvoie @GlobalScope.ERR_INVALID_PARAMETER et génère une erreur, sauf si le signal est connecté avec CONNECT_REFERENCE_COUNTED. Pour éviter cela, utilisez is_connected() d'abord pour vérifier les connexions existantes.
Note : Si l'objet de callable est libéré, la connexion sera perdue.
Note : En GDScript, il est généralement recommandé de connecter des signaux avec Signal.connect() à la place.
Note : Cette opération (et toutes les autres opérations reliées au signal) est thread-safe.
void disconnect(signal: StringName, callable: Callable) 🔗
Déconnecte un signal par nom depuis un callable donné. Si la connexion n'existe pas, génère une erreur. Utilisez is_connected() pour vous assurer que la connexion existe.
Error emit_signal(signal: StringName, ...) vararg 🔗
Émet le signal donné par nom. Le signal doit exister, ainsi il devrait être un signal intégré de cette classe ou une de ses classes héritées, ou un signal défini par l'utilisateur (voir add_user_signal()). Cette méthode prend en charge un nombre variable d'arguments, de sorte que les paramètres peuvent être passés en tant que liste séparée par des virgules.
Renvoie @GlobalScope.ERR_UNAVAILABLE si signal n'existe pas ou si les paramètres sont invalides.
emit_signal("touche", "epee", 100)
emit_signal("game_over")
EmitSignal(SignalName. Touche, "Epee", 100);
EmitSignal(SignalName.GameOver);
Note : En C#, signal doit être en snake_case lorsqu'il s'agit de signaux Godot intégrés. Préférez utiliser les noms exposés dans la classe SignalName pour éviter d'allouer un nouveau StringName à chaque appel.
void free() 🔗
Supprime l'objet de la mémoire. Les références préexistantes à l'objet deviennent invalides, et toute tentative d'y accéder entraînera une erreur d'exécution. Vérifier les références avec @GlobalScope.is_instance_valid() renverra false. Ceci est équivalent à la fonction memdelete dans la GDExtension C++.
Variant get(property: StringName) const 🔗
Renvoie la valeur Variant de la propriété property donnée. Si la propriété property n'existe pas, cette méthode renvoie null.
var noeud = Node2D.new()
noeud.rotation = 1.5
var a = noeud.get("rotation") # a vaut 1.5
var noeud= new Node2D();
noeud.Rotation = 1.5f;
var a = noeud.Get(Node2D.PropertyName.Rotation); // a vaut 1.5
Note : En C#, property doit être en snake_case si elle se réfère à une propriété de Godot intégrée. Préférez utiliser les noms exposés dans la classe PropertyName pour éviter d'allouer un nouveau StringName à chaque appel.
Renvoie le nom de la classe intégrée de l'objet, en tant que String. Voir aussi is_class().
Note : Cette méthode ignore les déclarations class_name. Si le script de cet objet a défini un class_name, le nom de la classe intégrée de base est renvoyé à la place.
Array[Dictionary] get_incoming_connections() const 🔗
Renvoie un Array des connexions de signal reçues par cet objet. Chaque connexion est représentée en tant que Dictionary contenant trois entrées :
signalest une référence au Signal;callableest une référence au Callable;flagsest une combinaison de ConnectFlags.
Variant get_indexed(property_path: NodePath) const 🔗
Obtient la propriété de l'objet indexée par le chemin property_path donné. Le chemin devrait être un NodePath par rapport à l'objet courant et peut utiliser des deux-points (:) pour accéder aux propriétés imbriquées.
Exemples : "position:x" ou "material:next_pass:blend_mode".
var noeud = Node2D.new()
noeud.position = Vector2(5, -10)
var a = noeud.get_indexed("position") # a vaut Vector2(5, -10)
var b = noeud.get_indexed("position:y") # b vaut -10
var noeud = new Node2D();
noeud.Position = new Vector2(5, -10);
var a = noeud.GetIndexed("position"); // a vaut Vector2(5, -10)
var b = noeud.GetIndexed("position:y"); // b vaut -10
Note : En C#, property_path doit être en snake_case si elle se réfère à une propriété de Godot intégrée. Préférez utiliser les noms exposés dans la classe PropertyName pour éviter d'allouer un nouveau StringName à chaque appel.
Note : Cette méthode ne supporte pas les chemins réels vers des nœuds dans le SceneTree, seulement les chemins de sous-propriété. Dans un contexte de nœuds, utilisez plutôt Node.get_node_and_resource().
Renvoie l'identifiant d'instance unique de l'objet. Cet ID peut être enregistré dans EncodedObjectAsID, et peut être utilisé pour récupérer cette instance objet avec @GlobalScope.instance_from_id().
Note : Cet identifiant n'est utile que pendant la session en cours. Il ne correspondra pas à un objet similaire si l'ID est envoyé sur un réseau, ou chargé à partir d'un fichier ultérieurement.
Variant get_meta(name: StringName, default: Variant = null) const 🔗
Renvoie la valeur d'une métadonnée de l'objet pour le nom name d'entrée donné. Si l'entrée n'existe pas, renvoie default. Si default vaut null, une erreur est également générée.
Note : Le nom de la métadonnée doit être un identifiant valide selon la méthode StringName.is_valid_identifier().
Note : Les métadonnées qui ont un nom commençant par un tiret du bas (_) sont considérées uniquement comme données de l'éditeur. Les métadonnées d'éditeur ne sont pas affichées dans l'Inspecteur et ne doivent pas être modifiées, bien qu'elles puissent encore être trouvées par cette méthode.
Array[StringName] get_meta_list() const 🔗
Renvoie les métadonnées de l'objet en tant qu'Array de StringNames.
int get_method_argument_count(method: StringName) const 🔗
Renvoie le nombre d'arguments de la méthode method donnée par nom.
Note : En C#, method doit être en snake_case lorsqu'il s'agit de méthodes Godot intégrées. Préférez en utilisant les noms exposés dans la classe MethodName pour éviter d'attribuer un nouveau StringName à chaque appel.
Array[Dictionary] get_method_list() const 🔗
Renvoie les méthodes de cet objet et leurs signatures en tant qu'Array de dictionnaires. Chaque Dictionary contient les entrées suivantes :
nameest le nom de la méthode, en tant que String;argsest un Array de dictionnaires représentant les arguments;default_argsest les arguments par défaut comme Array de Variants;flagsest une combinaison de MethodFlags;idest l'identifiant interne (int) de la méthode;returnest la valeur renvoyée, en tant que Dictionary;
Note : Les dictionnaires de args et return sont formatés de façon identique aux résultats de get_property_list(), bien que toutes les entrées ne soient pas utilisées.
Array[Dictionary] get_property_list() const 🔗
Renvoie la liste des propriétés de l'objet en tant qu'Array de dictionnaires. Chaque Dictionary contient les entrées suivantes :
nameest le nom de la propriété, en tant que String;class_nameest un StringName vide, sauf si la propriété du type @GlobalScope.TYPE_OBJECT et qu'elle hérite d'une classe;typeest le type de la propriété, en tant qu'int (voir Variant.Type);hintindique comment la propriété est destinée à être modifiée (voir PropertyHint);hint_stringdépend de "hint" (voir PropertyHint);usageest une combinaison de drapeaux PropertyUsageFlags.
Note : En GDScript, tous les membres de classe sont traités comme des propriétés. En C# et en GDExtension, il peut être nécessaire de marquer explicitement les membres de classe comme des propriétés Godot en utilisant des décorateurs ou des attributs.
Renvoie l'instance de Script de l'objet, ou null si aucun script n'est attaché.
Array[Dictionary] get_signal_connection_list(signal: StringName) const 🔗
Renvoie un Array des connexions pour le nom de signal signal donné. Chaque connexion est représentée en tant que Dictionary qui contient trois entrées :
signalest une référence au Signal;callableest une référence au Callable connecté;flagsest une combinaison de drapeaux ConnectFlags.
Array[Dictionary] get_signal_list() const 🔗
Renvoie la liste des signaux existants en tant qu'Array de dictionnaires.
Note : À cause de l'implémentation, chaque Dictionary est formaté de manière très similaire aux valeurs renvoyées par get_method_list().
StringName get_translation_domain() const 🔗
Renvoie le nom du domaine de traduction utilisé par tr() et tr_n(). Voir aussi TranslationServer.
bool has_connections(signal: StringName) const 🔗
Renvoie true si une connexion existe sur le nom de signal donné.
Note : En C#, signal doit être en snake_case lorsqu'il s'agit de signaux Godot intégrés. Préférez utiliser les noms exposés dans la classe SignalName pour éviter d'allouer un nouveau StringName à chaque appel.
bool has_meta(name: StringName) const 🔗
Renvoie true si une entrée de métadonnées est trouvée avec le nom name donné. Voir aussi get_meta(), set_meta() et remove_meta().
Note : Le nom d'une métadonnée doit être un identifiant valide selon la méthode StringName.is_valid_identifier().
Note : Les métadonnées qui ont un nom commençant par un tiret du bas (_) sont considérées uniquement comme données de l'éditeur. Les métadonnées d'éditeur ne sont pas affichées dans l'Inspecteur et ne doivent pas être modifiées, bien qu'elles puissent encore être trouvées par cette méthode.
bool has_method(method: StringName) const 🔗
Renvoie true si le nom de méthode method donné existe dans l'objet.
Note : En C#, method doit être en snake_case lorsqu'il s'agit de méthodes Godot intégrées. Préférez utiliser les noms exposés dans la classe MethodName pour éviter d'attribuer un nouveau StringName à chaque appel.
bool has_signal(signal: StringName) const 🔗
Renvoie true si le nom de signal signal donné existe dans l'objet.
Note : En C#, signal doit être en snake_case lorsqu'il s'agit de signaux Godot intégrés. Préférez utiliser les noms exposés dans la classe SignalName pour éviter d'attribuer un nouveau StringName à chaque appel.
bool has_user_signal(signal: StringName) const 🔗
Renvoie true si le nom de signal signal défini par l'utilisateur existe. Seuls les signaux ajoutés avec add_user_signal() sont inclus. Voir aussi remove_user_signal().
bool is_blocking_signals() const 🔗
Renvoie true si l'objet bloque l'émission de ses signaux. Voir set_block_signals().
bool is_class(class: String) const 🔗
Renvoie true si l'objet hérite de la class donnée. Voir aussi get_class().
var sprite2d = Sprite2D.new()
sprite2d.is_class("Sprite2D") # Renvoie true
sprite2d.is_class("Node") # Renvoie true
sprite2d.is_class("Node3D") # Renvoie false
var sprite2D = new Sprite2D();
sprite2D.IsClass("Sprite2D"); // Renvoie true
sprite2D.IsClass("Node"); // Renvoie true
sprite2D.IsClass("Node3D"); // Renvoie false
Note : Cette méthode ignore les déclarations class_name dans le script de l'objet.
bool is_connected(signal: StringName, callable: Callable) const 🔗
Renvoie true si une connexion existe entre le nom de signal et le callable donnés.
Note : En C#, signal doit être en snake_case lorsqu'il s'agit de signaux Godot intégrés. Préférez utiliser les noms exposés dans la classe SignalName pour éviter d'allouer un nouveau StringName à chaque appel.
bool is_queued_for_deletion() const 🔗
Renvoie true si la méthode Node.queue_free() a été appelée pour cet objet.
void notification(what: int, reversed: bool = false) 🔗
Envoie la notification what donnée à toutes les classes héritées par l'objet, déclenchant des appels à _notification(), à partir du plus haut ancêtre (la classe Object) et descendant vers le script de l'objet.
Si reversed vaut true, l'ordre d'appel est inversé.
var joueur = Node2D.new()
joueur.set_script(load("res://joueur.gd"))
joueur.notification(NOTIFICATION_ENTER_TREE)
# L'ordre d'appel est Object -> Node -> Node2D -> joueur.gd.
player.notification(NOTIFICATION_ENTER_TREE, true)
# L'ordre d'appel est joueur.gd -> Node2D -> Node -> Object.
var joueur = new Node2D();
joueur.SetScript(GD.Load("res://joueur.gd"));
joueur.Notification(NotificationEnterTree);
// L'ordre d'appel est GodotObject -> Node -> Node2D -> joueur.gd.
joueur.Notification(NotificationEnterTree, true);
// L'ordre d'appel est joueur.gd -> Node2D -> Node -> GodotObject.
void notify_property_list_changed() 🔗
Émet le signal property_list_changed. Ceci est principalement utilisé pour rafraîchir l'éditeur, de sorte que l'Inspecteur et les plugins éditeur sont correctement mis à jour.
bool property_can_revert(property: StringName) const 🔗
Renvoie true si la propriété property donnée a une valeur par défaut personnalisée. Utilisez property_get_revert() pour obtenir la valeur par défaut de property.
Note : Cette méthode est utilisée par le dock Inspecteur pour afficher une icône de restauration. L'objet doit implémenter _property_can_revert() pour personnaliser la valeur par défaut. Si _property_can_revert() n'est pas implémenté, cette méthode renvoie false.
Variant property_get_revert(property: StringName) const 🔗
Renvoie la valeur par défaut personnalisée de la propriété property donnée. Utilisez property_can_revert() pour vérifier si la propriété property a une valeur par défaut personnalisée.
Note : Cette méthode est utilisée par le dock Inspecteur pour afficher une icône de restauration. L'objet doit implémenter _property_get_revert() pour personnaliser la valeur par défaut. Si _property_get_revert() n'est pas implémenté, cette méthode renvoie null.
void remove_meta(name: StringName) 🔗
Enlève l'entrée de nom name donnée des métadonnées de l'objet. Voir aussi has_meta(), get_meta() et set_meta().
Note : Le nom de la métadonnée doit être un identifiant valide selon la méthode StringName.is_valid_identifier().
Note : Les métadonnées qui ont un nom commençant par un tiret du bas (_) sont considérées uniquement comme données de l'éditeur. Les métadonnées d'éditeur ne sont pas affichées dans l'Inspecteur et ne doivent pas être modifiées, bien qu'elles puissent encore être trouvées par cette méthode.
void remove_user_signal(signal: StringName) 🔗
Retire le signal utilisateur signal donné de l'objet. Voir aussi add_user_signal() et has_user_signal().
void set(property: StringName, value: Variant) 🔗
Assigne la valeur value à la propriété property donnée. Si la propriété n'existe pas ou le type de la valeur value donnée ne correspond pas, rien ne se passe.
var noeud = Node2D.new()
noeud.set("global_scale", Vector2(8, 2.5))
print(noeud.global_scale) # Affiche (8.0, 2.5)
var noeud = new Node2D();
noeud.Set(Node2D.PropertyName.GlobalScale, new Vector2(8, 2.5f));
GD.Print(noeud.GlobalScale); // Affiche (8, 2.5)
Note : En C#, property doit être en snake_case s'il se réfère à une propriété de Godot intégrée. Préférez utiliser les noms exposés dans la classe PropertyName pour éviter d'allouer un nouveau StringName à chaque appel.
void set_block_signals(enable: bool) 🔗
Si défini à true, l'objet devient incapable d'émettre des signaux. Ainsi, emit_signal() et les connexions de signal ne fonctionneront pas, jusqu'à ce que ceci soit défini sur false.
void set_deferred(property: StringName, value: Variant) 🔗
Attribue la valeur value à la propriété property donnée, à la fin de la trame actuelle. Cela équivaut à appeler set() par call_deferred().
var noeud = Node2D.new()
add_child(noeud)
noeud.rotation = 1.5
noeud.set_deferred("rotation", 3.0)
print(noeud.rotation) # Affiche 1.5
await get_tree().process_frame
print(noeud.rotation) # Affiche 3.0
var noeud = new Node2D();
noeud.Rotation = 1.5f;
noeud.SetDeferred(Node2D.PropertyName.Rotation, 3f);
GD.Print(noeud.Rotation); // Affiche 1.5
await ToSignal(GetTree(), SceneTree.SignalName.ProcessFrame);
GD.Print(noeud.Rotation); // Affiche 3.0
Note : En C#, property doit être en snake_case s'il se réfère à une propriété de Godot intégrée. Préférez utiliser les noms exposés dans la classe PropertyName pour éviter d'allouer un nouveau StringName à chaque appel.
void set_indexed(property_path: NodePath, value: Variant) 🔗
Attribue une nouvelle valeur value à la propriété identifiée par le chemin property_path. Le chemin devrait être un NodePath relatif à cet objet, et peut utiliser les deux-points (:) pour accéder à des propriétés imbriquées.
var noeud = Node2D.new()
noeud.set_indexed("position", Vector2(42, 0))
noeud.set_indexed("position:y", -10)
print(noeud.position) # Affiche (42.0, -10.0)
var noeud = new Node2D();
noeud.SetIndexed("position", new Vector2(42, 0));
noeud.SetIndexed("position:y", -10);
GD.Print(node.Position); // Affiche (42, -10)
Note : En C#, property_path doit être en snake_case s'il se réfère à une propriété de Godot intégrée. Préférez utiliser les noms exposés dans la classe PropertyName pour éviter d'allouer un nouveau StringName à chaque appel.
void set_message_translation(enable: bool) 🔗
Si défini à true, autorise l'objet à traduire des messages avec tr() et tr_n(). Activé par défaut. Voir aussi can_translate_messages().
void set_meta(name: StringName, value: Variant) 🔗
Ajoute ou modifie l'entrée name dans les métadonnées de l'objet. La valeur value de la métadonnée peut être n'importe quel Variant, même si certains types ne peuvent pas être sérialisés correctement.
Si value vaut null, l'entrée est retirée. C'est l'équivalent d'utiliser remove_meta(). Voir aussi has_meta() et get_meta().
Note : Le nom de la métadonnée doit être un identifiant valide selon la méthode StringName.is_valid_identifier().
Note : Les métadonnées qui ont un nom commençant par un tiret du bas (_) sont considérées uniquement comme données de l'éditeur. Les métadonnées d'éditeur ne sont pas affichées dans l'Inspecteur et ne doivent pas être modifiées, bien qu'elles puissent encore être trouvées par cette méthode.
void set_script(script: Variant) 🔗
Attache un script à l'objet, et l'instancie. Par conséquent, l'_init() du script est appelé. Un Script est utilisé pour étendre la fonctionnalité de l'objet.
Si un script existe déjà, son instance est détachée, et ses valeurs de propriété et son état sont perdus. Les valeurs de propriétés intégrées sont toujours conservées.
void set_translation_domain(domain: StringName) 🔗
Définit le nom du domaine de traduction utilisé par tr() et tr_n(). Voir aussi TranslationServer.
Renvoie un String représentant l'objet. Vaut par défaut "<ClassName#RID>". Redéfinissez _to_string() pour personnaliser la représentation en chaîne de l'objet.
String tr(message: StringName, context: StringName = &"") const 🔗
Traduit un message, en utilisant les catalogues de traduction configurés dans les Paramètres du projet. Du contexte peut être spécifié pour aider à la traduction. Notez que la plupart des nœuds Control traduisent automatiquement leurs chaînes, de sorte que cette méthode est surtout utile pour des chaînes formatées ou du texte dessiné personnalisé.
Si can_translate_messages() vaut false, ou qu'aucune traduction n'est disponible, cette méthode renvoie le message sans modification. Voir set_message_translation().
Pour des exemples détaillés, voir Internationalisation des jeux.
Note : Cette méthode ne peut pas être utilisée sans une instance Object, car elle nécessite la méthode can_translate_messages(). Pour traduire les chaînes dans un contexte statique, utilisez TranslationServer.translate().
String tr_n(message: StringName, plural_message: StringName, n: int, context: StringName = &"") const 🔗
Traduit un message message ou plusieurs messages plural_message, en utilisant les catalogues de traduction configurés dans les paramètres du projet. Plus de contexte peut être spécifié avec context pour aider à la traduction.
Si can_translate_messages() vaut false, ou si aucune traduction n'est disponible, cette méthode renvoie message ou plural_message, sans modifications. Voir set_message_translation().
Le n est le numéro, ou le montant, 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 en utilisant gettext.
Note : Les nombres négatifs et float peuvent ne pas s'appliquer correctement à certains sujets comptables. Il est recommandé de gérer ces cas avec tr().
Note : Cette méthode ne peut pas être utilisée sans une instance d'Object, car elle nécessite la méthode can_translate_messages(). Pour traduire les chaînes dans un contexte statique, utilisez TranslationServer.translate_plural().