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
Ereditato da: 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 di base per tutte le altre classi nel motore.
Descrizione
Un tipo di Variant avanzato. Tutte le classi nel motore ereditano da Object. Ogni classe può definire nuove proprietà, metodi o segnali, che sono disponibili per tutte le classi ereditanti. Ad esempio, un'istanza Sprite2D è in grado di chiamare Node.add_child() perché eredita da Node.
Puoi creare nuove istanze, usando Object.new() in GDScript, o new GodotObject in C#.
Per eliminare un'istanza di Object, chiama free(). Ciò è necessario per la maggior parte delle classi che ereditano Object, perché non gestiscono la memoria da sole e altrimenti causeranno perdite di memoria quando non sono più in uso. Esistono alcune classi che gestiscono la loro memoria. Ad esempio, RefCounted (e per estensione Resource) elimina se stesso quando non è più referenziato e Node elimina i suoi figli quando viene liberato.
Gli oggetti possono avere uno Script allegato. Una volta istanziato lo Script, agisce effettivamente come un'estensione della classe base, consentendogli di definire ed ereditare nuove proprietà, metodi e segnali.
All'interno di uno Script, _get_property_list() può essere sovrascritto per personalizzare le proprietà in diversi modi. Ciò consente loro di essere disponibili all'editor, di essere visualizzate come liste di opzioni, di essere suddivise in gruppi, di essere salvate su disco, ecc. I linguaggi di scripting offrono modi più semplici per personalizzare le proprietà, come con l'annotazione @GDScript.@export.
Godot è molto dinamico. Lo script di un oggetto, e quindi le sue proprietà, metodi e segnali, possono essere modificati in fase di esecuzione. Per questo motivo, possono esserci occasioni in cui, ad esempio, una proprietà richiesta da un metodo potrebbe non esistere. Per evitare errori di durante l'esecuzione, vedi metodi come set(), get(), call(), has_method(), has_signal(), ecc. Nota che questi metodi sono molto più lenti dei riferimenti diretti.
In GDScript, è anche possibile verificare se una determinata proprietà, metodo o nome di segnale esiste in un oggetto con l'operatore in:
var node = Node.new()
print("name" in node) # Stampa true
print("get_parent" in node) # Stampa true
print("tree_entered" in node) # Stampa true
print("unknown" in node) # Stampa false
Le notifiche sono costanti int comunemente inviate e ricevute dagli oggetti. Ad esempio, su ogni frame renderizzato, SceneTree notifica i nodi all'interno dell'albero con una Node.NOTIFICATION_PROCESS. I nodi la ricevono e possono chiamare Node._process() per aggiornarsi. Per utilizzare le notifiche, vedi notification() e _notification().
Infine, ogni oggetto può anche contenere metadati (dati sui dati). set_meta() può essere utile per memorizzare informazioni da cui l'oggetto stesso non dipende. Per mantenere pulito il codice, si sconsiglia di fare un uso eccessivo di metadati.
Nota: A differenza di riferimenti a un RefCounted, i riferimenti a un oggetto memorizzato in una variabile possono diventare non validi senza essere impostati su null. Per verificare se un oggetto è stato eliminato, non confrontarlo con null. Invece, usa @GlobalScope.is_instance_valid(). Si consiglia inoltre di ereditare da RefCounted per le classi che memorizzano dati anziché Object.
Nota: Lo script non è esposto come la maggior parte delle proprietà. Per impostare o ottenere lo Script di un oggetto in codice, usa rispettivamente set_script() e get_script().
Nota: In un contesto booleano, un Object verrà valutato come false se è uguale a null o è stato liberato. Altrimenti, un Object verrà sempre valutato come true. Vedi anche @GlobalScope.is_instance_valid().
Tutorial
Metodi
Segnali
property_list_changed() 🔗
Emesso quando notify_property_list_changed() viene chiamato.
script_changed() 🔗
Emesso quando lo script dell'oggetto viene cambiato.
Nota: Quando questo segnale viene emesso, il nuovo script non è ancora inizializzato. Se devi accedere al nuovo script, differisci le connessioni a questo segnale con CONNECT_DEFERRED.
Enumerazioni
flags ConnectFlags: 🔗
ConnectFlags CONNECT_DEFERRED = 1
Le connessioni differite attivano i loro Callable durante il tempo di inattività (alla fine del frame), anziché istantaneamente.
ConnectFlags CONNECT_PERSIST = 2
Le connessioni persistenti sono memorizzate quando l'oggetto viene serializzato (ad esempio quando si usa PackedScene.pack()). Nell'editor, le connessioni create tramite il pannello Segnali sono sempre persistenti.
Nota: Le connessioni alle funzioni lambda (ovvero, quando il codice della funzione è incorporato nella chiamata a connect()) non si possono rendere persistenti.
ConnectFlags CONNECT_ONE_SHOT = 4
Le connessioni a colpo singolo si disconnettono dopo l'emissione.
ConnectFlags CONNECT_REFERENCE_COUNTED = 8
Le connessioni con conteggio dei riferimenti possono essere assegnate allo stesso Callable più volte. Ogni disconnessione diminuisce il contatore interno. Il segnale si disconnette completamente solo quando il contatore raggiunge 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>
Costanti
NOTIFICATION_POSTINITIALIZE = 0 🔗
Notifica ricevuta quando l'oggetto viene inizializzato, prima che il suo script venga allegato. Utilizzato internamente.
NOTIFICATION_PREDELETE = 1 🔗
Notifica ricevuta quando l'oggetto sta per essere eliminato. Può fungere da distruttore nei linguaggi di programmazione orientati agli oggetti.
Questa notifica è inviata in ordine inverso.
NOTIFICATION_EXTENSION_RELOADED = 2 🔗
Notifica ricevuta quando l'oggetto termina il ricaricamento a caldo. Questa notifica viene inviata solo per le classi di estensioni e derivate.
Descrizioni dei metodi
Variant _get(property: StringName) virtual 🔗
Sovrascrivi questo metodo per personalizzare il comportamento di get(). Dovrebbe restituire il valore della proprietà property, oppure null se la property deve essere gestita normalmente.
In combinazione con _set() e _get_property_list(), questo metodo consente di definire proprietà personalizzate, il che è particolarmente utile per le estensioni dell'editor.
Nota: Questo metodo non viene chiamato quando si ottengono le proprietà integrate di un oggetto, incluse le proprietà definite con @GDScript.@export.
func _get(property):
if property == "fake_property":
print("Ottenendo la mia proprietà!")
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("Ottenendo la mia proprietà!");
return 4;
}
return default;
}
public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetPropertyList()
{
return new Godot.Collections.Array<Godot.Collections.Dictionary>()
{
new Godot.Collections.Dictionary()
{
{ "name", "FakeProperty" },
{ "type", (int)Variant.Type.Int },
}
};
}
Nota: A differenza di altri metodi virtuali, questo metodo viene chiamato automaticamente per ogni script che lo sovrascrive. Ciò significa che non si dovrebbe chiamare l'implementazione di base tramite super in GDScript o i suoi equivalenti in altri linguaggi. La sottoclasse più in basso verrà chiamata per prima, con le chiamate successive che risalgono la gerarchia delle classi. La catena di chiamate si interromperà sulla prima classe che restituisce un valore diverso da null.
Attenzione: Questo metodo deve essere thread-safe se sovrascritto. Se no, il motore potrebbe bloccarsi quando tenta di salvare una risorsa contenente l'oggetto.
Array[Dictionary] _get_property_list() virtual 🔗
Sovrascrivi questo metodo per fornire un elenco personalizzato di proprietà aggiuntive da gestire dal motore.
Dovrebbe restituire un elenco di proprietà, come Array di dizionari. Il risultato viene aggiunto all'array di get_property_list() e dovrebbe essere formattato nello stesso modo. Ogni Dictionary deve contenere almeno le voci name e type.
È possibile usare _property_can_revert() e _property_get_revert() per personalizzare i valori predefiniti delle proprietà aggiunte da questo metodo.
L'esempio seguente mostra un elenco di numeri mostrati come parole che vanno da ZERO a FIVE, con number_count che controlla la dimensione dell'elenco:
@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;
}
}
Nota: Questo metodo è pensato per scopi avanzati. Per la maggior parte dei casi d'uso comuni, i linguaggi di scripting offrono modi più semplici per gestire le proprietà. Vedi @GDScript.@export, @GDScript.@export_enum, @GDScript.@export_group, ecc. Se si desidera personalizzare le proprietà esportate, usa _validate_property().
Nota: Se lo script dell'oggetto non è @GDScript.@tool, questo metodo non sarà chiamato nell'editor.
Nota: A differenza di altri metodi virtuali, questo metodo viene chiamato automaticamente per ogni script che lo sovrascrive. Ciò significa che non si dovrebbe chiamare l'implementazione di base tramite super in GDScript o i suoi equivalenti in altri linguaggi. La sottoclasse più in basso verrà chiamata per prima, risalendo la gerarchia della classe a ogni chiamata successiva.
Attenzione: Questo metodo deve essere thread-safe se sovrascritto. Se no, il motore potrebbe bloccarsi quando tenta di salvare una risorsa contenente l'oggetto.
void _init() virtual 🔗
Chiamato quando lo script dell'oggetto è istanziato, spesso dopo che l'oggetto è stato inizializzato in memoria (tramite Object.new() in GDScript, o new GodotObject in C#). Può anche essere definito per accettare parametri. Questo metodo è simile a un costruttore nella maggior parte dei linguaggi di programmazione.
Nota: Se _init() è definito con parametri obbligatori, l'oggetto con lo script può essere creato solo direttamente. Se si usano altri mezzi (come PackedScene.instantiate() o Node.duplicate()) , l'inizializzazione dello script fallirà.
Variant _iter_get(iter: Variant) virtual 🔗
Restituisce il valore iterabile attuale. iter memorizza lo stato dell'iterazione, ma a differenza di _iter_init() e _iter_next() lo stato dovrebbe essere di sola lettura, quindi non c'è alcun Array come wrapper.
Suggerimento: in GDScript, è possibile usare un sottotipo di Variant come tipo restituito per _iter_get(). Il tipo specificato sarà usato per impostare il tipo della variabile iteratore nei cicli for, garantendo migliore sicurezza di tipo.
bool _iter_init(iter: Array) virtual 🔗
Inizializza l'iteratore. iter memorizza lo stato dell'iterazione. Poiché GDScript non supporta il passaggio di argomenti per riferimento, è utilizzato un array con un singolo elemento come wrapper. Restituisce true finché l'iteratore non ha raggiunto la fine.
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.
Nota: Evita di memorizzare lo stato dell'iteratore in una variabile membro, utilizza invece il parametro iter. Altrimenti, non sarà possibile riutilizzare la stessa istanza dell'iteratore nei cicli annidati.
Consulta anche la documentazione online.
bool _iter_next(iter: Array) virtual 🔗
Sposta l'iteratore all'iterazione successiva. iter memorizza lo stato dell'iterazione. Poiché GDScript non supporta il passaggio di argomenti per riferimento, viene utilizzato un array con un singolo elemento come wrapper. Restituisce true finché l'iteratore non ha raggiunto la fine.
void _notification(what: int) virtual 🔗
Chiamato quando l'oggetto riceve una notifica, la quale può essere identificata in what confrontandola con una costante. Vedi anche notification().
func _notification(what):
if what == NOTIFICATION_PREDELETE:
print("Addio!")
public override void _Notification(int what)
{
if (what == NotificationPredelete)
{
GD.Print("Addio!");
}
}
Nota: L'Object base definisce alcune notifiche (NOTIFICATION_POSTINITIALIZE e NOTIFICATION_PREDELETE). Le classi che lo ereditano come Node definiscono molte più notifiche, che sono anche ricevute da questo metodo.
Nota: A differenza di altri metodi virtuali, questo metodo viene chiamato automaticamente per ogni script che lo sovrascrive. Ciò significa che non si dovrebbe chiamare l'implementazione di base tramite super in GDScript o i suoi equivalenti in altri linguaggi. L'ordine delle chiamate dipende dall'argomento reversed di notification() e varia tra le diverse notifiche. La maggior parte delle notifiche è inviata in avanti (ovvero, prima la classe Object, poi la classe più derivata).
bool _property_can_revert(property: StringName) virtual 🔗
Sovrascrivi questo metodo per personalizzare il comportamento di ripristino della proprietà denominata property. Dovrebbe restituire true se property ha un valore predefinito personalizzato ed è ripristinabile nel pannello dell'Ispettore. Usa _property_get_revert() per specificare il valore predefinito di property.
Nota: Questo metodo deve restituire in modo costante, a prescindere dal valore attuale della proprietà denominata property.
Nota: A differenza di altri metodi virtuali, questo metodo viene chiamato automaticamente per ogni script che lo sovrascrive. Ciò significa che non si dovrebbe chiamare l'implementazione di base tramite super in GDScript o i suoi equivalenti in altri linguaggi. La sottoclasse più in basso verrà chiamata per prima, risalendo la gerarchia della classe a ogni chiamata successiva. La catena di chiamate si interromperà sulla prima classe che restituisce true.
Variant _property_get_revert(property: StringName) virtual 🔗
Sovrascrivi questo metodo per personalizzare il comportamento di ripristino della proprietà denominata property. Dovrebbe restituire il valore predefinito per property. Se il valore predefinito è diverso dal valore attuale della proprietà denominata property, è visualizzata un'icona di ripristino nel pannello dell'Ispettore.
Nota: _property_can_revert() deve essere sovrascritto affinché questo metodo sia chiamato.
Nota: A differenza di altri metodi virtuali, questo metodo viene chiamato automaticamente per ogni script che lo sovrascrive. Ciò significa che non si dovrebbe chiamare l'implementazione di base tramite super in GDScript o i suoi equivalenti in altri linguaggi. La sottoclasse più in basso verrà chiamata per prima, con le chiamate successive che risalgono la gerarchia delle classi. La catena di chiamate si interromperà sulla prima classe che restituisce un valore diverso da null.
bool _set(property: StringName, value: Variant) virtual 🔗
Sovrascrivi questo metodo per personalizzare il comportamento di set(). Dovrebbe impostare la proprietà property su value e restituire true, o false se la proprietà property dovrebbe essere gestita normalmente. Il modo esatto per impostare la proprietà property dipende dall'implementazione di questo metodo.
In combinazione con _get() e _get_property_list(), questo metodo consente di definire proprietà personalizzate, il che è particolarmente utile per le estensioni dell'editor.
Nota: Questo metodo non viene chiamato quando si ottengono le proprietà integrate di un oggetto, incluse le proprietà definite con @GDScript.@export.
var internal_data = {}
func _set(property, value):
if property == "fake_property":
# Memorizza i valori nella proprietà fasulla.
internal_data["fake_property"] = value
return true
return false
func _get_property_list():
return [
{ "name": "fake_property", "type": TYPE_INT }
]
private Godot.Collections.Dictionary _internalData = new Godot.Collections.Dictionary();
public override bool _Set(StringName property, Variant value)
{
if (property == "FakeProperty")
{
// Storing the value in the fake property.
_internalData["FakeProperty"] = value;
return true;
}
return false;
}
public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetPropertyList()
{
return
[
new Godot.Collections.Dictionary()
{
{ "name", "FakeProperty" },
{ "type", (int)Variant.Type.Int },
},
];
}
Nota: A differenza di altri metodi virtuali, questo metodo viene chiamato automaticamente per ogni script che lo sovrascrive. Ciò significa che non si dovrebbe chiamare l'implementazione di base tramite super in GDScript o i suoi equivalenti in altri linguaggi. La sottoclasse più in basso verrà chiamata per prima, risalendo la gerarchia della classe a ogni chiamata successiva. La catena di chiamate si interromperà sulla prima classe che restituisce true.
Sovrascrivi questo metodo per personalizzare il valore restituito da to_string() e quindi la rappresentazione dell'oggetto come String.
func _to_string():
return "Benvenuto su Godot 4!"
func _init():
print(self) # Stampa "Benvenuto su Godot 4!"
var a = str(self) # a è "Benvenuto su Godot 4!"
void _validate_property(property: Dictionary) virtual 🔗
Sovrascrivi questo metodo per personalizzare le proprietà esistenti. Ogni informazione sulle proprietà passa attraverso questo metodo, tranne le proprietà aggiunte con _get_property_list(). Il contenuto del dizionario è lo stesso di _get_property_list().
@tool
extends Node
@export var is_number_editable: bool:
set(value):
is_number_editable = value
notify_property_list_changed()
@export var number: int
func _validate_property(property: Dictionary):
if property.name == "number" and not is_number_editable:
property.usage |= PROPERTY_USAGE_READ_ONLY
[Tool]
public partial class MyNode : Node
{
private bool _isNumberEditable;
[Export]
public bool IsNumberEditable
{
get => _isNumberEditable;
set
{
_isNumberEditable = value;
NotifyPropertyListChanged();
}
}
[Export]
public int Number { get; set; }
public override void _ValidateProperty(Godot.Collections.Dictionary property)
{
if (property["name"].AsStringName() == PropertyName.Number && !IsNumberEditable)
{
var usage = property["usage"].As<PropertyUsageFlags>() | PropertyUsageFlags.ReadOnly;
property["usage"] = (int)usage;
}
}
}
void add_user_signal(signal: String, arguments: Array = []) 🔗
Aggiunge un segnale definito dall'utente con il nome signal. È possibile aggiungere argomenti opzionali per il segnale come un Array di dizionari, ognuno dei quali definisce un nome (name) String e un tipo (type) int (vedi Variant.Type). Vedi anche has_user_signal() e remove_user_signal().
add_user_signal("hurt", [
{ "name": "damage", "type": TYPE_INT },
{ "name": "source", "type": TYPE_OBJECT }
])
AddUserSignal("Hurt", new Godot.Collections.Array()
{
new Godot.Collections.Dictionary()
{
{ "name", "damage" },
{ "type", (int)Variant.Type.Int },
},
new Godot.Collections.Dictionary()
{
{ "name", "source" },
{ "type", (int)Variant.Type.Object },
}
});
Variant call(method: StringName, ...) vararg 🔗
Chiama il metodo denominato method sull'oggetto e restituisce il risultato. Questo metodo supporta un numero variabile di argomenti, quindi è possibile passare i parametri come un elenco separato da virgole.
var node = Node3D.new()
node.call("rotate", Vector3(1.0, 0.0, 0.0), 1.571)
var node = new Node3D();
node.Call(Node3D.MethodName.Rotate, new Vector3(1f, 0f, 0f), 1.571f);
Nota: In C#, method deve essere in snake_case quando si fa riferimento ai metodi integrati di Godot. Preferisci usare i nomi esposti nella classe MethodName per evitare di allocare un nuovo StringName a ogni chiamata.
Variant call_deferred(method: StringName, ...) vararg 🔗
Chiama il metodo denominato method sull'oggetto durante il tempo di inattività. Restituisce sempre null, non il risultato del metodo.
Il tempo di inattività si verifica principalmente alla fine dei frame di processo e di fisica. In esso, le chiamate differite saranno eseguite finché non ne rimarrà nessuna, il che significa che è possibile differire le chiamate da altre chiamate differite e saranno comunque eseguite nel ciclo di tempo di inattività attuale. Ciò significa che non dovresti chiamare un metodo differito da se stesso (o da un metodo chiamato da esso), poiché ciò causa una ricorsione infinita allo stesso modo di se avessi chiamato il metodo direttamente.
Questo metodo supporta un numero variabile di argomenti, quindi è possibile passare i parametri come un elenco separato da virgole.
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);
Per i metodi che sono differiti dallo stesso thread, l'ordine di esecuzione in fase di inattività è identico all'ordine in cui è stato chiamato call_deferred.
Vedi anche Callable.call_deferred().
Nota: In C#, method deve essere in snake_case quando si fa riferimento ai metodi integrati di Godot. Preferisci usare i nomi esposti nella classe MethodName per evitare di allocare un nuovo StringName a ogni chiamata.
Nota: Se vuoi ritardare la chiamata alla funzione di un frame, usa i segnali SceneTree.process_frame e SceneTree.physics_frame.
var node = Node3D.new()
# Crea un chiamabile e associa gli argomenti alla chiamata rotate() del nodo.
var callable = node.rotate.bind(Vector3(1.0, 0.0, 0.0), 1.571)
# Collega il chiamabile al segnale process_frame, in modo che sia chiamato nel frame di processo successivo.
# CONNECT_ONE_SHOT assicura che sia chiamato solo una volta invece di ogni frame.
get_tree().process_frame.connect(callable, CONNECT_ONE_SHOT)
Variant callv(method: StringName, arg_array: Array) 🔗
Chiama il metodo denominato method sull'oggetto e ne restituisce il risultato. A differenza di call(), questo metodo si aspetta che tutti i parametri siano contenuti all'interno di arg_array.
var node = Node3D.new()
node.callv("rotate", [Vector3(1.0, 0.0, 0.0), 1.571])
var node = new Node3D();
node.Callv(Node3D.MethodName.Rotate, new Godot.Collections.Array { new Vector3(1f, 0f, 0f), 1.571f });
Nota: In C#, method deve essere in snake_case quando si fa riferimento ai metodi integrati di Godot. Preferisci usare i nomi esposti nella classe MethodName per evitare di allocare un nuovo StringName a ogni chiamata.
bool can_translate_messages() const 🔗
Restituisce true se all'oggetto è permesso tradurre i messaggi con tr() e tr_n(). Vedi anche set_message_translation().
void cancel_free() 🔗
Se questo metodo viene chiamato durante NOTIFICATION_PREDELETE, questo oggetto rifiuterà di liberarsi e rimarrà allocato. Questa è principalmente una funzione interna utilizzata per la gestione degli errori per evitare che l'utente liberi oggetti quando non è previsto.
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) 🔗
Disconnette il segnale denominato signal dal chiamabile callable. Se la connessione non esiste, genera un errore. Usa is_connected() per assicurarti che la connessione esista.
Error emit_signal(signal: StringName, ...) vararg 🔗
Emette il segnale signal per nome. Il segnale deve esistere, quindi dovrebbe essere un segnale integrato di questa classe o di una delle sue classi ereditate, o un segnale definito dall'utente (vedi add_user_signal()). Questo metodo supporta un numero variabile di argomenti, quindi è possibile passare i parametri come un elenco separato da virgole.
Restituisce @GlobalScope.ERR_UNAVAILABLE se signal non esiste o i parametri non sono validi.
emit_signal("hit", "sword", 100)
emit_signal("game_over")
EmitSignal(SignalName.Hit, "sword", 100);
EmitSignal(SignalName.GameOver);
Nota: In C#, signal deve essere in snake_case quando si fa riferimento ai segnali integrati di Godot. Preferisci usare i nomi esposti nella classe SignalName per evitare di allocare un nuovo StringName a ogni chiamata.
void free() 🔗
Elimina l'oggetto dalla memoria. I riferimenti preesistenti all'oggetto diventano non validi e qualsiasi tentativo di accedervi causerà un errore di esecuzione. Verificare i riferimenti con @GlobalScope.is_instance_valid() restituirà false. Questo è equivalente alla funzione memdelete in GDExtension C++.
Variant get(property: StringName) const 🔗
Restituisce il valore Variant della proprietà property specificata. Se la proprietà property non esiste, questo metodo restituisce null.
var node = Node2D.new()
node.rotation = 1.5
var a = node.get("rotation") # a è 1.5
var node = new Node2D();
node.Rotation = 1.5f;
var a = node.Get(Node2D.PropertyName.Rotation); // a è 1.5
Nota: In C#, property deve essere in snake_case quando si fa riferimento alle proprietà integrate di Godot. Preferisci utilizzare i nomi esposti nella classe PropertyName per evitare di allocare un nuovo StringName a ogni chiamata.
Restituisce il nome della classe integrata dell'oggetto, come String. Vedi anche is_class().
Nota: Questo metodo ignora le dichiarazioni class_name. Se lo script di questo oggetto ha definito un class_name, viene restituito invece il nome della classe integrata di base.
Array[Dictionary] get_incoming_connections() const 🔗
Restituisce un Array di connessioni di segnale ricevute da questo oggetto. Ogni connessione è rappresentata come un Dictionary che contiene tre voci:
signalè un riferimento al Signal;callableè un riferimento al Callable;flagsè una combinazione di ConnectFlags.
Variant get_indexed(property_path: NodePath) const 🔗
Ottiene la proprietà dell'oggetto indicizzata dal parametro property_path specificato. Il percorso deve essere un NodePath relativo all'oggetto attuale e può utilizzare il carattere due punti (:) per accedere alle proprietà innestate.
Esempi: "position:x" o "material:next_pass:blend_mode".
var node = Node2D.new()
node.position = Vector2(5, -10)
var a = node.get_indexed("position") # a è Vector2(5, -10)
var b = node.get_indexed("position:y") # b è -10
var node = new Node2D();
node.Position = new Vector2(5, -10);
var a = node.GetIndexed("position"); // a è Vector2(5, -10)
var b = node.GetIndexed("position:y"); // b è -10
Nota: In C#, property_path deve essere in snake_case quando si fa riferimento alle proprietà integrate di Godot. Preferisci usare i nomi esposti nella classe PropertyName per evitare di allocare un nuovo StringName a ogni chiamata.
Nota: Questo metodo non supporta percorsi per i nodi in SceneTree, solo percorsi di sotto-proprietà. Nel contesto dei nodi, usa invece Node.get_node_and_resource().
Restituisce l'ID univoco di istanza dell'oggetto. Questo ID può essere salvato in EncodedObjectAsID e può essere utilizzato per recuperare questa istanza di oggetto con @GlobalScope.instance_from_id().
Nota: Questo ID è utile solo durante la sessione attuale. Non corrisponderà a un oggetto simile se l'ID viene inviato tramite rete o caricato da un file in un secondo momento.
Variant get_meta(name: StringName, default: Variant = null) const 🔗
Restituisce il valore del metadato dell'oggetto per la voce name specificata. Se la voce non esiste, restituisce default. Se default è null, viene generato anche un errore.
Nota: Il nome di un metadato deve essere un identificatore valido come per il metodo StringName.is_valid_identifier().
Nota: I metadati che hanno un nome che inizia con un trattino basso (_) sono considerati solo per l'editor. I metadati solo per l'editor non sono visualizzati nell'Ispettore e non dovrebbero essere modificati, sebbene si possano comunque trovare con questo metodo.
Array[StringName] get_meta_list() const 🔗
Restituisce i nomi delle voci dei metadati dell'oggetto come un Array di StringName.
int get_method_argument_count(method: StringName) const 🔗
Restituisce il numero di argomenti del metodo method specificato per nome.
Nota: In C#, method deve essere in snake_case quando si fa riferimento ai metodi integrati di Godot. Preferisci usare i nomi esposti nella classe MethodName per evitare di allocare un nuovo StringName a ogni chiamata.
Array[Dictionary] get_method_list() const 🔗
Restituisce i metodi di questo oggetto e le loro firme sotto forma di un Array di dizionari. Ogni Dictionary contiene le seguenti voci:
nameè il nome del metodo, come String;argsè un Array di dizionari che rappresentano gli argomenti;default_argssono gli argomenti predefiniti come Array di varianti;flagsè una combinazione di MethodFlags;idè l'identificatore interno del metodo, come int;returnè il valore restituito, come Dictionary;
Nota: I dizionari di args e return sono formattati in modo identico ai risultati di get_property_list(), sebbene non vengano utilizzate tutte le voci.
Array[Dictionary] get_property_list() const 🔗
Restituisce la lista delle proprietà dell'oggetto come Array di dizionari. Ogni Dictionary contiene le seguenti voci:
nameè il nome della proprietà, come String;class_nameè uno StringName vuoto, a meno che la proprietà non sia @GlobalScope.TYPE_OBJECT e non erediti da una classe;typeè il tipo della proprietà, come int (vedi Variant.Type);hintè in che modo si intende modificare la proprietà (vedi PropertyHint);hint_stringdipende dall'indicazione (vedi PropertyHint);usageè una combinazione di PropertyUsageFlags.
Nota: In GDScript, tutti i membri di una classe sono trattati come proprietà. In C# e GDExtension potrebbe essere necessario contrassegnare esplicitamente i membri di una classe come proprietà di Godot utilizzando decoratori o attributi.
Restituisce l'istanza dello Script dell'oggetto oppure null se nessuno script è allegato.
Array[Dictionary] get_signal_connection_list(signal: StringName) const 🔗
Restituisce un Array di connessioni per il segnale denominato signal. Ogni connessione è rappresentata come Dictionary che contiene tre voci:
signalè un riferimento al Signal;callableè un riferimento al Callable connesso;flagsè una combinazione di 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 🔗
Restituisce il nome del dominio di traduzione usato da tr() e tr_n(). Vedi anche TranslationServer.
bool has_connections(signal: StringName) const 🔗
Restituisce true se esiste una qualsiasi connessione al segnale con il nome signal.
Nota: In C#, signal deve essere in snake_case quando si fa riferimento ai metodi integrati di Godot. Preferisci usare i nomi esposti nella classe SignalName per evitare di allocare un nuovo StringName a ogni chiamata.
bool has_meta(name: StringName) const 🔗
Restituisce true se viene trovata una voce di metadati con il nome name. Vedi anche get_meta(), set_meta() e remove_meta().
Nota: Il nome di un metadato deve essere un identificatore valido come per il metodo StringName.is_valid_identifier().
Nota: I metadati che hanno un nome che inizia con un trattino basso (_) sono considerati solo per l'editor. I metadati solo per l'editor non sono visualizzati nell'Ispettore e non dovrebbero essere modificati, sebbene si possano comunque trovare con questo metodo.
bool has_method(method: StringName) const 🔗
Restituisce true se un metodo con il nome method esiste nell'oggetto.
Nota: In C#, method deve essere in snake_case quando si fa riferimento ai metodi integrati di Godot. Preferisci usare i nomi esposti nella classe MethodName per evitare di allocare un nuovo StringName a ogni chiamata.
bool has_signal(signal: StringName) const 🔗
Restituisce true se un segnale con il nome signal esiste nell'oggetto.
Nota: In C#, signal deve essere in snake_case quando si fa riferimento ai segnali integrati di Godot. Preferisci usare i nomi esposti nella classe SignalName per evitare di allocare un nuovo StringName a ogni chiamata.
bool has_user_signal(signal: StringName) const 🔗
Restituisce true se esiste il segnale definito dall'utente con il nome signal. Sono inclusi solo i segnali aggiunti con add_user_signal(). Vedi anche remove_user_signal().
bool is_blocking_signals() const 🔗
Restituisce true se l'oggetto sta bloccando l'emissione dei suoi segnali. Vedi set_block_signals().
bool is_class(class: StringName) const 🔗
Restituisce true se l'oggetto eredita dalla classe class specificata. Vedi anche get_class().
var sprite2d = Sprite2D.new()
sprite2d.is_class("Sprite2D") # Restituisce true
sprite2d.is_class("Node") # Restituisce true
sprite2d.is_class("Node3D") # Restituisce false
var sprite2D = new Sprite2D();
sprite2D.IsClass("Sprite2D"); // Restituisce true
sprite2D.IsClass("Node"); // Restituisce true
sprite2D.IsClass("Node3D"); // Restituisce false
Nota: Questo metodo ignora le dichiarazioni di class_name nello script dell'oggetto.
bool is_connected(signal: StringName, callable: Callable) const 🔗
Restituisce true se esiste una connessione tra il segnale con il nome signal e callable.
Nota: In C#, signal deve essere in snake_case quando si fa riferimento ai segnali integrati di Godot. Preferisci usare i nomi esposti nella classe SignalName per evitare di allocare un nuovo StringName a ogni chiamata.
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) 🔗
Invia la notifica what specificata a tutte le classi ereditate dall'oggetto, attivando le chiamate a _notification(), a partire dall'antenato più alto (la classe Object) e arrivando fino allo script dell'oggetto.
Se reversed è true, l'ordine delle chiamate è invertito.
var player = Node2D.new()
player.set_script(load("res://player.gd"))
player.notification(NOTIFICATION_ENTER_TREE)
# L'ordine delle chiamate è Object -> Node -> Node2D -> player.gd.
player.notification(NOTIFICATION_ENTER_TREE, true)
# L'ordine delle chiamate è player.gd -> Node2D -> Node -> Object.
var player = new Node2D();
player.SetScript(GD.Load("res://player.gd"));
player.Notification(NotificationEnterTree);
// L'ordine delle chiamate è GodotObject -> Node -> Node2D -> player.gd.
player.Notification(NotificationEnterTree, true);
// L'ordine delle chiamate è player.gd -> Node2D -> Node -> GodotObject.
void notify_property_list_changed() 🔗
Emette il segnale property_list_changed. È utilizzato principalmente per aggiornare l'editor, in modo che le estensioni dell'editor e l'Ispettore siano aggiornati correttamente.
bool property_can_revert(property: StringName) const 🔗
Restituisce true se la proprietà property specificata ha un valore predefinito personalizzato. Usa property_get_revert() per ottenere il valore predefinito di property.
Nota: Questo metodo è utilizzato dal pannello dell'Ispettore per visualizzare un'icona di ripristino. L'oggetto deve implementare _property_can_revert() per personalizzare il valore predefinito. Se _property_can_revert() non è implementato, questo metodo restituisce false.
Variant property_get_revert(property: StringName) const 🔗
Restituisce il valore predefinito personalizzato della proprietà property specificata. Usa property_can_revert() per verificare se la proprietà property ha un valore predefinito personalizzato.
Nota: Questo metodo è utilizzato dal pannello dell'Ispettore per visualizzare un'icona di ripristino. L'oggetto deve implementare _property_get_revert() per personalizzare il valore predefinito. Se _property_get_revert() non è implementato, questo metodo restituisce null.
void remove_meta(name: StringName) 🔗
Rimuove la voce con il nome name dai metadati dell'oggetto. Vedi anche has_meta(), get_meta() e set_meta().
Nota: Il nome di un metadato deve essere un identificatore valido come per il metodo StringName.is_valid_identifier().
Nota: I metadati che hanno un nome che inizia con un trattino basso (_) sono considerati solo per l'editor. I metadati solo per l'editor non sono visualizzati nell'Ispettore e non dovrebbero essere modificati, sebbene si possano comunque trovare con questo metodo.
void remove_user_signal(signal: StringName) 🔗
Rimuove il segnale utente con il nome signal dall'oggetto. Vedi anche add_user_signal() e has_user_signal().
void set(property: StringName, value: Variant) 🔗
Assegna value alla proprietà property specificata. Se la proprietà non esiste o il tipo del valore value non corrisponde, non succede nulla.
var node = Node2D.new()
node.set("global_scale", Vector2(8, 2.5))
print(node.global_scale) # Stampa (8.0, 2.5)
var node = new Node2D();
node.Set(Node2D.PropertyName.GlobalScale, new Vector2(8, 2.5f));
GD.Print(node.GlobalScale); // Stampa (8, 2.5)
Nota: In C#, property deve essere in snake_case quando si fa riferimento alle proprietà integrate di Godot. Preferisci utilizzare i nomi esposti nella classe PropertyName per evitare di allocare un nuovo StringName a ogni chiamata.
void set_block_signals(enable: bool) 🔗
Se impostato su true, l'oggetto non è più in grado di emettere segnali. Di conseguenza, emit_signal() e le connessioni dei segnali non funzioneranno, finché non sarà impostato su false.
void set_deferred(property: StringName, value: Variant) 🔗
Assegna value alla proprietà property specificata, alla fine del frame attuale. Ciò equivale a chiamare set() tramite call_deferred().
var node = Node2D.new()
add_child(node)
node.rotation = 1.5
node.set_deferred("rotation", 3.0)
print(node.rotation) # Stampa 1.5
await get_tree().process_frame
print(node.rotation) # Stampa 3.0
var node = new Node2D();
node.Rotation = 1.5f;
node.SetDeferred(Node2D.PropertyName.Rotation, 3f);
GD.Print(node.Rotation); // Stampa 1.5
await ToSignal(GetTree(), SceneTree.SignalName.ProcessFrame);
GD.Print(node.Rotation); // Stampa 3.0
Nota: in C#, property deve essere in snake_case quando si fa riferimento alle proprietà integrate di Godot. Preferisci usare i nomi esposti nella classe PropertyName per evitare di allocare un nuovo StringName a ogni chiamata.
void set_indexed(property_path: NodePath, value: Variant) 🔗
Assegna un nuovo value alla proprietà identificata da property_path. Il percorso dovrebbe essere un NodePath relativo a questo oggetto e può utilizzare il carattere due punti (:) per accedere alle proprietà innestate.
var node = Node2D.new()
node.set_indexed("position", Vector2(42, 0))
node.set_indexed("position:y", -10)
print(node.position) # Stampa (42.0, -10.0)
var node = new Node2D();
node.SetIndexed("position", new Vector2(42, 0));
node.SetIndexed("position:y", -10);
GD.Print(node.Position); // Stampa (42, -10)
Nota: In C#, property_path deve essere in snake_case quando si fa riferimento alle proprietà integrate di Godot. Preferisci usare i nomi esposti nella classe PropertyName per evitare di allocare un nuovo StringName a ogni chiamata.
void set_message_translation(enable: bool) 🔗
Se impostato su true, consente all'oggetto di tradurre i messaggi con tr() e tr_n(). Abilitato per impostazione predefinita. Vedi anche can_translate_messages().
void set_meta(name: StringName, value: Variant) 🔗
Aggiunge o modifica la voce con il nome name all'interno dei metadati dell'oggetto. Per i metadati, value può essere un qualsiasi Variant, nonostante alcuni tipi non si possano serializzare correttamente.
Se value è null, la voce viene rimossa. Ciò equivale a usare remove_meta(). Vedi anche has_meta() e get_meta().
Nota: il nome di un metadato deve essere un identificatore valido come per il metodo StringName.is_valid_identifier().
Nota: I metadati che hanno un nome che inizia con un trattino basso (_) sono considerati solo per l'editor. I metadati solo per l'editor non sono visualizzati nell'Ispettore e non dovrebbero essere modificati, sebbene si possano comunque trovare con questo metodo.
void set_script(script: Variant) 🔗
Allega script all'oggetto e ne crea un'istanza. Di conseguenza, viene chiamato il _init() dello script. Uno Script serve per estendere la funzionalità dell'oggetto.
Se uno script esiste già, la sua istanza viene staccata e i suoi valori di proprietà e lo stato vengono persi. I valori di proprietà integrate vengono comunque mantenuti.
void set_translation_domain(domain: StringName) 🔗
Imposta il nome del dominio di traduzione usato da tr() e tr_n(). Vedi anche TranslationServer.
Restituisce una String che rappresenta l'oggetto. Il valore predefinito è "<ClassName#RID>". Sovrascrivi _to_string() per personalizzare la rappresentazione in stringa dell'oggetto.
String tr(message: StringName, context: StringName = &"") const 🔗
Traduce la stringa message, utilizzando i cataloghi di traduzione configurati nelle Impostazioni del progetto. È possibile specificare un ulteriore contesto (context) per facilitare la traduzione. Nota che la maggior parte dei nodi Control traduce automaticamente le proprie stringhe, quindi questo metodo è utile soprattutto per stringhe formattate o testo disegnato personalizzato.
Se can_translate_messages() è false, o nessuna traduzione è disponibile, questo metodo restituisce message senza modifiche. Vedi set_message_translation().
Per esempi dettagliati, consulta Internazionalizzazione dei giochi.
Nota: Questo metodo non può essere utilizzato senza un'istanza di Object, poiché richiede il metodo can_translate_messages(). Per tradurre delle stringhe in un contesto statico, usa TranslationServer.translate().
String tr_n(message: StringName, plural_message: StringName, n: int, context: StringName = &"") const 🔗
Traduce la stringa message o plural_message, utilizzando i cataloghi di traduzione configurati nelle Impostazioni del progetto. È possibile specificare un ulteriore contesto (context) per facilitare la traduzione.
Se can_translate_messages() è false o nessuna traduzione è disponibile, questo metodo restituisce message o plural_message, senza modifiche. Vedi set_message_translation().
n è il numero, o la quantità, del soggetto del messaggio. È utilizzato dal sistema di traduzione per recuperare la forma plurale corretta per la lingua attuale.
Per esempi dettagliati, consulta Localizzazione tramite gettext.
Nota: I numeri negativi e float potrebbero non essere applicati correttamente ad alcuni soggetti numerabili. Si consiglia di gestire questi casi con tr().
Nota: Questo metodo non può essere utilizzato senza un'istanza di Object, poiché richiede il metodo can_translate_messages(). Per tradurre delle stringhe in un contesto statico, usa TranslationServer.translate_plural().