Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
Object
Hérité par : AccessibilityServer, AudioServer, CameraServer, ClassDB, DisplayServer, EditorFileSystemDirectory, EditorInterface, EditorPaths, EditorSelection, EditorUndoRedoManager, EditorVCSInterface, Engine, EngineDebugger, FramebufferCacheRD, GDExtensionManager, Geometry2D, Geometry3D, GodotInstance, Input, InputMap, IP, JavaClassWrapper, JavaScriptBridge, JNISingleton, JSONRPC, MainLoop, Marshalls, MovieWriter, NativeMenu, NavigationMeshGenerator, NavigationServer2D, NavigationServer2DManager, NavigationServer3D, NavigationServer3DManager, Node, OpenXRExtensionWrapper, OpenXRInteractionProfileMetadata, OS, Performance, PhysicsDirectBodyState2D, PhysicsDirectBodyState3D, PhysicsDirectSpaceState2D, PhysicsDirectSpaceState3D, PhysicsServer2D, PhysicsServer2DManager, PhysicsServer3D, PhysicsServer3DManager, PhysicsServer3DRenderingServerHandler, ProjectSettings, RefCounted, RenderData, RenderingDevice, RenderingServer, RenderSceneData, ResourceLoader, ResourceSaver, ResourceUID, ScriptLanguage, ShaderIncludeDB, TextServerManager, ThemeDB, TileData, Time, TranslationServer, TreeItem, UndoRedo, UniformSetCacheRD, WorkerThreadPool, XRServer, XRVRS
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
flags 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
Persisting connections are stored when the object is serialized (such as when using PackedScene.pack()). In the editor, connections created through the Signals dock are always persisting.
Note: Connections to lambda functions (that is, when the function code is embedded in the connect() call) cannot be made persistent.
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
On signal emission, the source object is automatically appended after the original arguments of the signal, regardless of the connected Callable's unbinds which affect only the original arguments of the signal (see Callable.unbind(), Callable.get_unbound_arguments_count()).
extends Object
signal test_signal
func test():
print(self) # Prints e.g. <Object#35332818393>
test_signal.connect(prints.unbind(1), CONNECT_APPEND_SOURCE_OBJECT)
test_signal.emit("emit_arg_1", "emit_arg_2") # Prints emit_arg_1 <Object#35332818393>
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 received when the object is about to be deleted. Can be used like destructors in object-oriented programming languages.
This notification is sent in reversed order.
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 🔗
Override this method to customize the behavior of get(). Should return the given property's value, or null if the property should be handled normally.
Combined with _set() and _get_property_list(), this method allows defining custom properties, which is particularly useful for editor plugins.
Note: This method is not called when getting built-in properties of an object, including properties defined with @GDScript.@export.
func _get(property):
if property == "fake_property":
print("Getting my property!")
return 4
return null
func _get_property_list():
return [
{ "name": "fake_property", "type": TYPE_INT }
]
public override Variant _Get(StringName property)
{
if (property == "FakeProperty")
{
GD.Print("Getting my property!");
return 4;
}
return default;
}
public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetPropertyList()
{
return
[
new Godot.Collections.Dictionary()
{
{ "name", "FakeProperty" },
{ "type", (int)Variant.Type.Int },
},
];
}
Note: Unlike other virtual methods, this method is called automatically for every script that overrides it. This means that the base implementation should not be called via super in GDScript or its equivalents in other languages. The bottom-most sub-class will be called first, with subsequent calls ascending the class hierarchy. The call chain will stop on the first class that returns a non-null value.
Warning: This method must be thread-safe if overridden. Otherwise, the engine may crash when trying to save a resource containing the object.
Array[Dictionary] _get_property_list() virtual 🔗
Override this method to provide a custom list of additional properties to handle by the engine.
Should return a property list, as an Array of dictionaries. The result is added to the array of get_property_list(), and should be formatted in the same way. Each Dictionary must at least contain the name and type entries.
You can use _property_can_revert() and _property_get_revert() to customize the default values of the properties added by this method.
The example below displays a list of numbers shown as words going from ZERO to FIVE, with number_count controlling the size of the list:
@tool
extends Node
@export var number_count = 3:
set(nc):
number_count = nc
numbers.resize(number_count)
notify_property_list_changed()
var numbers = PackedInt32Array([0, 0, 0])
func _get_property_list():
var properties: Array[Dictionary] = []
for i in range(number_count):
properties.append({
"name": "number_%d" % i,
"type": TYPE_INT,
"hint": PROPERTY_HINT_ENUM,
"hint_string": "ZERO,ONE,TWO,THREE,FOUR,FIVE",
})
return properties
func _get(property):
if property.begins_with("number_"):
var index = property.get_slice("_", 1).to_int()
return numbers[index]
return null
func _set(property, value):
if property.begins_with("number_"):
var index = property.get_slice("_", 1).to_int()
numbers[index] = value
return true
return false
[Tool]
public partial class MyNode : Node
{
private int _numberCount;
[Export]
public int NumberCount
{
get => _numberCount;
set
{
_numberCount = value;
_numbers.Resize(_numberCount);
NotifyPropertyListChanged();
}
}
private Godot.Collections.Array<int> _numbers = [];
public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetPropertyList()
{
Godot.Collections.Array<Godot.Collections.Dictionary> properties = [];
for (int i = 0; i < _numberCount; i++)
{
properties.Add(new Godot.Collections.Dictionary()
{
{ "name", $"number_{i}" },
{ "type", (int)Variant.Type.Int },
{ "hint", (int)PropertyHint.Enum },
{ "hint_string", "Zero,One,Two,Three,Four,Five" },
});
}
return properties;
}
public override Variant _Get(StringName property)
{
string propertyName = property.ToString();
if (propertyName.StartsWith("number_"))
{
int index = int.Parse(propertyName.Substring("number_".Length));
return _numbers[index];
}
return default;
}
public override bool _Set(StringName property, Variant value)
{
string propertyName = property.ToString();
if (propertyName.StartsWith("number_"))
{
int index = int.Parse(propertyName.Substring("number_".Length));
_numbers[index] = value.As<int>();
return true;
}
return false;
}
}
Note: This method is intended for advanced purposes. For most common use cases, the scripting languages offer easier ways to handle properties. See @GDScript.@export, @GDScript.@export_enum, @GDScript.@export_group, etc. If you want to customize exported properties, use _validate_property().
Note: If the object's script is not @GDScript.@tool, this method will not be called in the editor.
Note: Unlike other virtual methods, this method is called automatically for every script that overrides it. This means that the base implementation should not be called via super in GDScript or its equivalents in other languages. The bottom-most sub-class will be called first, with subsequent calls ascending the class hierarchy.
Warning: This method must be thread-safe if overridden. Otherwise, the engine may crash when trying to save a resource containing the object.
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 🔗
Initializes the iterator. iter stores the iteration state. Since GDScript does not support passing arguments by reference, a single-element array is used as a wrapper. Returns true so long as the iterator has not reached the end.
class MyRange:
var _from
var _to
func _init(from, to):
assert(from <= to)
_from = from
_to = to
func _iter_init(iter):
iter[0] = _from
return iter[0] < _to
func _iter_next(iter):
iter[0] += 1
return iter[0] < _to
func _iter_get(iter):
return iter
func _ready():
var my_range = MyRange.new(2, 5)
for x in my_range:
print(x) # Prints 2, 3, 4.
Note: Avoid storing iterator state in a member variable, use the iter parameter instead. Otherwise, you won't be able to reuse the same iterator instance in nested loops.
See also online docs.
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 🔗
Called when the object receives a notification, which can be identified in what by comparing it with a constant. See also notification().
func _notification(what):
if what == NOTIFICATION_PREDELETE:
print("Goodbye!")
public override void _Notification(int what)
{
if (what == NotificationPredelete)
{
GD.Print("Goodbye!");
}
}
Note: The base Object defines a few notifications (NOTIFICATION_POSTINITIALIZE and NOTIFICATION_PREDELETE). Inheriting classes such as Node define a lot more notifications, which are also received by this method.
Note: Unlike other virtual methods, this method is called automatically for every script that overrides it. This means that the base implementation should not be called via super in GDScript or its equivalents in other languages. Call order depends on the reversed argument of notification() and varies between different notifications. Most notifications are sent in the forward order (i.e. Object class first, most derived class last).
bool _property_can_revert(property: StringName) virtual 🔗
Override this method to customize the given property's revert behavior. Should return true if the property has a custom default value and is revertible in the Inspector dock. Use _property_get_revert() to specify the property's default value.
Note: This method must return consistently, regardless of the current value of the property.
Note: Unlike other virtual methods, this method is called automatically for every script that overrides it. This means that the base implementation should not be called via super in GDScript or its equivalents in other languages. The bottom-most sub-class will be called first, with subsequent calls ascending the class hierarchy. The call chain will stop on the first class that returns true.
Variant _property_get_revert(property: StringName) virtual 🔗
Override this method to customize the given property's revert behavior. Should return the default value for the property. If the default value differs from the property's current value, a revert icon is displayed in the Inspector dock.
Note: _property_can_revert() must also be overridden for this method to be called.
Note: Unlike other virtual methods, this method is called automatically for every script that overrides it. This means that the base implementation should not be called via super in GDScript or its equivalents in other languages. The bottom-most sub-class will be called first, with subsequent calls ascending the class hierarchy. The call chain will stop on the first class that returns a non-null value.
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 },
},
] ;
}
Note : Contrairement à d'autres méthodes virtuelles, cette méthode est appelée automatiquement pour chaque script qui l'écrase. Cela signifie que la mise en œuvre de base ne doit pas être appelée via super dans GDScript ou ses équivalents dans d'autres langues. La sous-classe la plus basse sera appelée en premier, avec des appels subséquents ascendant la hiérarchie de classe. La chaîne d'appels s'arrête sur la première classe qui retourne true.
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 🔗
Calls the method on the object during idle time. Always returns null, not the method's result.
Idle time happens mainly at the end of process and physics frames. In it, deferred calls will be run until there are none left, which means you can defer calls from other deferred calls and they'll still be run in the current idle time cycle. This means you should not call a method deferred from itself (or from a method called by it), as this causes infinite recursion the same way as if you had called the method directly.
This method supports a variable number of arguments, so parameters can be passed as a comma separated list.
var node = Node3D.new()
node.call_deferred("rotate", Vector3(1.0, 0.0, 0.0), 1.571)
var node = new Node3D();
node.CallDeferred(Node3D.MethodName.Rotate, new Vector3(1f, 0f, 0f), 1.571f);
For methods that are deferred from the same thread, the order of execution at idle time is identical to the order in which call_deferred was called.
See also Callable.call_deferred().
Note: In C#, method must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the MethodName class to avoid allocating a new StringName on each call.
Note: If you're looking to delay the function call by a frame, refer to the SceneTree.process_frame and SceneTree.physics_frame signals.
var node = Node3D.new()
# Make a Callable and bind the arguments to the node's rotate() call.
var callable = node.rotate.bind(Vector3(1.0, 0.0, 0.0), 1.571)
# Connect the callable to the process_frame signal, so it gets called in the next process frame.
# CONNECT_ONE_SHOT makes sure it only gets called once instead of every frame.
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) 🔗
Connects a signal by name to a callable. Optional flags can be also added to configure the connection's behavior (see ConnectFlags constants).
A signal can only be connected once to the same Callable. If the signal is already connected, this method returns @GlobalScope.ERR_INVALID_PARAMETER and generates an error, unless the signal is connected with CONNECT_REFERENCE_COUNTED. To prevent this, use is_connected() first to check for existing connections.
Note: If the callable's object is freed, the connection will be lost.
Note: In GDScript, it is generally recommended to connect signals with Signal.connect() instead.
Note: This method, and all other signal-related methods, are 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 🔗
Returns the list of existing signals as an Array of dictionaries.
Note: Due to the implementation, each Dictionary is formatted very similarly to the returned values of 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: StringName) 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 🔗
Returns true if the methods Node.queue_free() or SceneTree.queue_delete() was called for the object.
Note: This method does not return true on children of the node that Node.queue_free() has been called on, even though they will be freed together with the parent.
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().