Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
Node
Eredita: Object
Ereditato da: AnimationMixer, AudioStreamPlayer, CanvasItem, CanvasLayer, EditorFileSystem, EditorPlugin, EditorResourcePreview, HTTPRequest, InstancePlaceholder, MissingNode, MultiplayerSpawner, MultiplayerSynchronizer, NavigationAgent2D, NavigationAgent3D, Node3D, ResourcePreloader, ShaderGlobalsOverride, StatusIndicator, Timer, Viewport, WorldEnvironment
Classe di base per tutti gli oggetti della scena.
Descrizione
I nodi sono i mattoni di Godot. Possono essere assegnati come figli di un altro nodo, risultando in una disposizione ad albero. Un determinato nodo può contenere un numero qualsiasi di nodi come figli con il requisito che tutti i fratelli (figli diretti di un nodo) debbano avere nomi univoci.
Un albero di nodi è chiamato scena. Le scene possono essere salvate su disco e quindi istanziate in altre scene. Ciò consente un'elevata flessibilità nell'architettura e nel modello di dati dei progetti Godot.
Albero di scene: il SceneTree contiene l'albero attivo dei nodi. Quando un nodo viene aggiunto all'albero di scene, riceve la notifica NOTIFICATION_ENTER_TREE e il suo callback _enter_tree() viene attivato. I nodi figli vengono sempre aggiunti dopo il loro nodo padre, ovvero il callback _enter_tree() di un nodo padre verrà attivato prima di quello del suo figlio.
Una volta che tutti i nodi sono stati aggiunti nell'albero di scene, ricevono la notifica NOTIFICATION_READY e i rispettivi callback _ready() vengono attivati. Per un insieme di nodi, il callback _ready() viene chiamato in ordine inverso, partendo dai figli e risalendo ai nodi padre.
Ciò significa che quando viene aggiunto un nodo all'albero di scene, per i callback sarà utilizzato l'ordine seguente: _enter_tree() del genitore, _enter_tree() dei figli, _ready() dei figli e infine _ready() del genitore (ricorsivamente per l'intero albero di scene).
Elaborazione: i nodi possono sovrascrivere lo stato di "processo", in modo da ricevere un callback su ogni frame che richiede loro di elaborare (fare qualcosa). L'elaborazione normale (callback _process(), attivato con set_process()) avviene il più velocemente possibile e dipende dal frame rate, con il tempo di elaborazione delta (in secondi) passato come argomento. L'elaborazione della fisica (callback _physics_process(), attivato con set_physics_process()) avviene un numero fisso di volte al secondo (60 come predefinito) ed è utile per il codice che riguarda il motore della fisica.
I nodi possono anche elaborare gli eventi di input. Quando presente, la funzione _input() sarà chiamata per ogni input ricevuto dal programma. In molti casi, questo può essere eccessivo (a meno che non sia utilizzato per progetti semplici) e potrebbe essere preferibile la funzione _unhandled_input(); essa è chiamata quando l'evento di input non è stato gestito da nessun altro (in genere, dai nodi Control), assicurando che il nodo riceva solo gli eventi destinati a esso.
Per tenere traccia della gerarchia delle scene (specialmente quando si istanziano scene in altre scene), è possibile impostare un "proprietario" per il nodo con la proprietà owner. Ciò tiene traccia di chi ha istanziato cosa. È utile soprattutto quando si scrivono strumenti per l'editor.
Infine, quando un nodo viene liberato con Object.free() o queue_free(), libererà anche tutti i suoi figli.
Gruppi: È possibile aggiungere i nodi a quanti più gruppi vuoi per facilitarne la gestione. Potresti creare gruppi come "nemici" o "oggetti da collezione" ad esempio, a seconda del tuo gioco. Vedi add_to_group(), is_in_group() e remove_from_group(). Puoi successivamente recuperare tutti i nodi in questi gruppi, iterarli e persino chiamare metodi sui gruppi tramite i metodi su SceneTree.
Connessione in rete con nodi: Dopo essersi connessi a un server (o averne creato uno, vedi ENetMultiplayerPeer), è possibile utilizzare il sistema di RPC ("Remote Procedure Call") integrato per comunicare in rete. Chiamando rpc() con il nome di un metodo, verrà chiamato localmente e in tutti i peer connessi (peer = client e il server che accetta le connessioni). Per identificare quale nodo riceve la chiamata RPC, Godot utilizzerà il suo NodePath (assicurati che i nomi dei nodi siano gli stessi su tutti i peer). Inoltre, dai un'occhiata al tutorial di rete di alto livello e alle demo corrispondenti.
Nota: La proprietà script fa parte della classe Object, non Node. Non è esposta come la maggior parte delle proprietà, ma ha un setter e un getter (vedere Object.set_script() e Object.get_script()).
Tutorial
Proprietà
|
||
|
||
|
||
|
||
|
||
|
||
|
||
BitField[ProcessThreadMessages] |
||
|
Metodi
Segnali
child_entered_tree(node: Node) 🔗
Emesso quando il nodo figlio node entra nel SceneTree, solitamente perché questo nodo è entrato nell'albero (vedi tree_entered) o è stato chiamato add_child().
Questo segnale viene emesso dopo NOTIFICATION_ENTER_TREE e tree_entered del nodo figlio.
child_exiting_tree(node: Node) 🔗
Emesso quando il figlio node sta per uscire dal SceneTree, solitamente perché questo nodo sta uscendo dall'albero (vedi tree_exiting), o perché il figlio node sta per essere rimosso o liberato.
Quando viene ricevuto questo segnale, il figlio node è ancora accessibile all'interno dell'albero. Questo segnale viene emesso dopo tree_exiting e NOTIFICATION_EXIT_TREE del figlio.
child_order_changed() 🔗
Emesso quando la lista dei figli viene cambiata. Ciò accade quando i nodi figli vengono aggiunti, spostati o rimossi.
editor_description_changed(node: Node) 🔗
Emesso quando il campo della descrizione dell'editor del nodo cambia.
editor_state_changed() 🔗
Emesso quando un attributo del nodo rilevante per l'editor viene modificato. Emesso solo nell'editor.
ready() 🔗
Emesso quando il nodo è considerato pronto, dopo che _ready() è stato chiamato.
renamed() 🔗
Emesso quando il name del nodo viene cambiato, se il nodo si trova all'interno dell'albero.
Emesso quando questo nodo viene sostituito da node, vedi replace_by().
Questo segnale viene emesso dopo che node è stato aggiunto come figlio del nodo padre originale, ma prima che tutti i nodi figlio originali siano stati riassegnati a node.
tree_entered() 🔗
Emesso quando il nodo entra nell'albero.
Questo segnale viene emesso dopo la notifica corrispondente NOTIFICATION_ENTER_TREE.
tree_exited() 🔗
Emesso dopo che il nodo esce dall'albero e non è più attivo.
Questo segnale viene emesso dopo la notifica corrispondente NOTIFICATION_EXIT_TREE.
tree_exiting() 🔗
Emesso quando il nodo sta per uscire dall'albero. Il nodo è ancora valido. In quanto tale, questo è il posto giusto per la de-inizializzazione (o un "distruttore", se preferisci).
Questo segnale viene emesso dopo il metodo _exit_tree() del nodo e prima della notifica corrispondente NOTIFICATION_EXIT_TREE.
Enumerazioni
enum ProcessMode: 🔗
ProcessMode PROCESS_MODE_INHERIT = 0
Eredita process_mode dal nodo padre. Questa è l'impostazione predefinita per qualsiasi nodo appena creato.
ProcessMode PROCESS_MODE_PAUSABLE = 1
Processes when SceneTree.paused is false. This is the inverse of PROCESS_MODE_WHEN_PAUSED, and the default for the root node.
ProcessMode PROCESS_MODE_WHEN_PAUSED = 2
Processes only when SceneTree.paused is true. This is the inverse of PROCESS_MODE_PAUSABLE.
ProcessMode PROCESS_MODE_ALWAYS = 3
Always processes. Keeps processing, ignoring SceneTree.paused. This is the inverse of PROCESS_MODE_DISABLED.
ProcessMode PROCESS_MODE_DISABLED = 4
Never processes. Completely disables processing, ignoring SceneTree.paused. This is the inverse of PROCESS_MODE_ALWAYS.
enum ProcessThreadGroup: 🔗
ProcessThreadGroup PROCESS_THREAD_GROUP_INHERIT = 0
Elabora questo nodo in base alla modalità di gruppo thread del primo nodo genitore (o antenato) che ha una modalità di gruppo thread che non è ereditata. Vedi process_thread_group per ulteriori informazioni.
ProcessThreadGroup PROCESS_THREAD_GROUP_MAIN_THREAD = 1
Elabora questo nodo (e i nodi figlio impostati per ereditare) sul thread principale. Vedi process_thread_group per ulteriori informazioni.
ProcessThreadGroup PROCESS_THREAD_GROUP_SUB_THREAD = 2
Elabora questo nodo (e i nodi figlio impostati per ereditare) su un thread secondario. Vedi process_thread_group per ulteriori informazioni.
flags ProcessThreadMessages: 🔗
ProcessThreadMessages FLAG_PROCESS_THREAD_MESSAGES = 1
Consente a questo nodo di elaborare messaggi da thread creati con call_deferred_thread_group() subito prima che sia chiamato _process().
ProcessThreadMessages FLAG_PROCESS_THREAD_MESSAGES_PHYSICS = 2
Consente a questo nodo di elaborare messaggi da thread creati con call_deferred_thread_group() subito prima che sia chiamato _physics_process().
ProcessThreadMessages FLAG_PROCESS_THREAD_MESSAGES_ALL = 3
Consente a questo nodo di elaborare messaggi da thread creati con call_deferred_thread_group() subito prima che sia chiamato _process() o _physics_process().
enum PhysicsInterpolationMode: 🔗
PhysicsInterpolationMode PHYSICS_INTERPOLATION_MODE_INHERIT = 0
Eredita physics_interpolation_mode dal nodo padre. Questa è l'impostazione predefinita per qualsiasi nodo appena creato.
PhysicsInterpolationMode PHYSICS_INTERPOLATION_MODE_ON = 1
Abilita l'interpolazione fisica per questo nodo e per i figli impostati su PHYSICS_INTERPOLATION_MODE_INHERIT. Questa è l'impostazione predefinita per il nodo radice.
PhysicsInterpolationMode PHYSICS_INTERPOLATION_MODE_OFF = 2
Disabilita l'interpolazione fisica per questo nodo e per i nodi figlio impostati su PHYSICS_INTERPOLATION_MODE_INHERIT.
enum DuplicateFlags: 🔗
DuplicateFlags DUPLICATE_SIGNALS = 1
Duplica le connessioni dei segnali del nodo che sono connesse con il flag Object.CONNECT_PERSIST.
DuplicateFlags DUPLICATE_GROUPS = 2
Duplica i gruppi del nodo.
DuplicateFlags DUPLICATE_SCRIPTS = 4
Duplica lo script del nodo (sovrascrivendo anche gli script dei figli duplicati, se combinato con DUPLICATE_USE_INSTANTIATION).
DuplicateFlags DUPLICATE_USE_INSTANTIATION = 8
Duplica utilizzando PackedScene.instantiate(). Se il nodo proviene da una scena salvata su disco, riutilizza PackedScene.instantiate() come base per il nodo duplicato e i suoi figli.
DuplicateFlags DUPLICATE_INTERNAL_STATE = 16
Duplicate also non-serializable variables (i.e. without @GlobalScope.PROPERTY_USAGE_STORAGE).
DuplicateFlags DUPLICATE_DEFAULT = 15
Duplicate using default flags. This constant is useful to add or remove a single flag.
# Duplicate non-exported variables.
var dupe = duplicate(DUPLICATE_DEFAULT | DUPLICATE_INTERNAL_STATE)
enum InternalMode: 🔗
InternalMode INTERNAL_MODE_DISABLED = 0
Il nodo non sarà interno.
InternalMode INTERNAL_MODE_FRONT = 1
Il nodo sarà posizionato all'inizio dei figli del genitore, prima di qualsiasi fratello non interno.
InternalMode INTERNAL_MODE_BACK = 2
Il nodo sarà posizionato alla fine dei figli del genitore, dopo qualsiasi fratello non interno.
enum AutoTranslateMode: 🔗
AutoTranslateMode AUTO_TRANSLATE_MODE_INHERIT = 0
Eredita auto_translate_mode dal nodo padre. Questa è l'impostazione predefinita per qualsiasi nodo appena creato.
AutoTranslateMode AUTO_TRANSLATE_MODE_ALWAYS = 1
Traduci sempre automaticamente. Questo è l'inverso di AUTO_TRANSLATE_MODE_DISABLED, ed è l'impostazione predefinita per il nodo radice.
AutoTranslateMode AUTO_TRANSLATE_MODE_DISABLED = 2
Never automatically translate. This is the inverse of AUTO_TRANSLATE_MODE_ALWAYS.
String parsing for translation template generation will be skipped for this node and children that are set to AUTO_TRANSLATE_MODE_INHERIT.
Costanti
NOTIFICATION_ENTER_TREE = 10 🔗
Notifica ricevuta quando il nodo entra in uno SceneTree. Vedi _enter_tree().
Questa notifica viene ricevuta prima del segnale correlato tree_entered.
NOTIFICATION_EXIT_TREE = 11 🔗
Notification received when the node is about to exit a SceneTree. See _exit_tree().
This notification is received after the related tree_exiting signal.
This notification is sent in reversed order.
NOTIFICATION_MOVED_IN_PARENT = 12 🔗
Deprecato: This notification is no longer sent by the engine. Use NOTIFICATION_CHILD_ORDER_CHANGED instead.
NOTIFICATION_READY = 13 🔗
Notifica ricevuta quando il nodo è pronto. Vedi _ready().
NOTIFICATION_PAUSED = 14 🔗
Notifica ricevuta quando il nodo è messo in pausa. Vedi process_mode.
NOTIFICATION_UNPAUSED = 15 🔗
Notifica ricevuta quando il nodo è ripreso. Vedi process_mode.
NOTIFICATION_PHYSICS_PROCESS = 16 🔗
Notifica ricevuta dall'albero ogni frame di fisica quando is_physics_processing() restituisce true. Vedi _physics_process().
NOTIFICATION_PROCESS = 17 🔗
Notifica ricevuta dall'albero ogni frame renderizzato quando is_processing() restituisce true. Vedi _process().
NOTIFICATION_PARENTED = 18 🔗
Notifica ricevuta quando il nodo viene impostato come figlio di un altro nodo (vedi add_child() e add_sibling()).
Nota: Questo non significa che il nodo è entrato nel SceneTree.
NOTIFICATION_UNPARENTED = 19 🔗
Notifica ricevuta quando il nodo padre chiama remove_child() su questo nodo.
Nota: Questo non significa che il nodo è uscito dal SceneTree.
NOTIFICATION_SCENE_INSTANTIATED = 20 🔗
Notifica ricevuta solo dal nodo radice appena istanziato da una scena, quando PackedScene.instantiate() è completato.
NOTIFICATION_DRAG_BEGIN = 21 🔗
Notifica ricevuta quando inizia un'operazione di trascinamento. Tutti i nodi ricevono questa notifica, non solo quello trascinato.
Può essere attivata trascinando un Control che fornisce dati di trascinamento (vedi Control._get_drag_data()) o tramite Control.force_drag().
Utilizza Viewport.gui_get_drag_data() per ottenere i dati trascinati.
NOTIFICATION_DRAG_END = 22 🔗
Notifica ricevuta al termine di un'operazione di trascinamento.
Utilizza Viewport.gui_is_drag_successful() per verificare se il trascinamento è riuscito.
NOTIFICATION_PATH_RENAMED = 23 🔗
Notifica ricevuta quando il name del nodo o di uno dei name dei suoi antenati viene modificato. Questa notifica non viene ricevuta quando il nodo viene rimosso dal SceneTree.
NOTIFICATION_CHILD_ORDER_CHANGED = 24 🔗
Notifica ricevuta quando la lista dei figli viene modificata. Ciò accade quando i nodi figli vengono aggiunti, spostati o rimossi.
NOTIFICATION_INTERNAL_PROCESS = 25 🔗
Notifica ricevuta dall'albero per ogni frame renderizzato quando is_processing_internal() restituisce true.
NOTIFICATION_INTERNAL_PHYSICS_PROCESS = 26 🔗
Notifica ricevuta dall'albero per ogni frame di fisica quando is_physics_processing_internal() restituisce true.
NOTIFICATION_POST_ENTER_TREE = 27 🔗
Notifica ricevuta quando il nodo entra nell'albero, appena prima che NOTIFICATION_READY possa essere ricevuto. A differenza di quest'ultimo, viene inviato ogni volta che il nodo entra nell'albero, non solo una volta.
NOTIFICATION_DISABLED = 28 🔗
Notifica ricevuta quando il nodo viene disabilitato. Vedi PROCESS_MODE_DISABLED.
NOTIFICATION_ENABLED = 29 🔗
Notifica ricevuta quando il nodo viene nuovamente abilitato dopo essere stato disabilitato. Vedi PROCESS_MODE_DISABLED.
NOTIFICATION_RESET_PHYSICS_INTERPOLATION = 2001 🔗
Notifica ricevuta quando viene chiamato reset_physics_interpolation() sul nodo o sui suoi antenati.
NOTIFICATION_EDITOR_PRE_SAVE = 9001 🔗
Notifica ricevuta subito prima che la scena con il nodo sia salvata nell'editor. Questa notifica è inviata solo nell'editor di Godot e non si verificherà nei progetti esportati.
NOTIFICATION_EDITOR_POST_SAVE = 9002 🔗
Notifica ricevuta subito dopo che la scena con il nodo è stata salvata nell'editor. Questa notifica è inviata solo nell'editor di Godot e non si verificherà nei progetti esportati.
NOTIFICATION_WM_MOUSE_ENTER = 1002 🔗
Notifica ricevuta quando il mouse entra nella finestra.
Implementato per finestre incorporate e su piattaforme desktop e web.
NOTIFICATION_WM_MOUSE_EXIT = 1003 🔗
Notifica ricevuta quando il mouse esce dalla finestra.
Implementato per finestre incorporate e su piattaforme desktop e web.
NOTIFICATION_WM_WINDOW_FOCUS_IN = 1004 🔗
Notifica ricevuta dal sistema operativo quando l'antenato Window del nodo è focalizzato. Questo può essere da un cambio di focus tra due finestre della stessa istanza del motore, o dal desktop del sistema operativo o da un'applicazione di terze parti a una finestra del gioco (nel qual caso viene anche ricevuta NOTIFICATION_APPLICATION_FOCUS_IN).
Un nodo Window riceve questa notifica quando è focalizzato.
NOTIFICATION_WM_WINDOW_FOCUS_OUT = 1005 🔗
Notifica ricevuta dal sistema operativo quando l'antenato Window del nodo è defocalizzato. Questo può essere da un cambio di focus tra due finestre della stessa istanza del motore, o da una finestra del gioco al desktop del sistema operativo o a un'applicazione di terze parti (nel qual caso viene anche ricevuta NOTIFICATION_APPLICATION_FOCUS_OUT).
Un nodo Window riceve questa notifica quando è defocalizzato.
NOTIFICATION_WM_CLOSE_REQUEST = 1006 🔗
Notifica ricevuta dal sistema operativo quando viene inviata una richiesta di chiusura (ad esempio, chiusura della finestra con un pulsante "Chiudi" o Alt + F4).
Implementato su piattaforme desktop.
NOTIFICATION_WM_GO_BACK_REQUEST = 1007 🔗
Emesso quando viene inviata una richiesta di torno indietro (ad esempio premendo il pulsante "Indietro" su Android), subito dopo NOTIFICATION_WM_GO_BACK_REQUEST.
Implementato solo su Android.
NOTIFICATION_WM_SIZE_CHANGED = 1008 🔗
Notifica ricevuta quando la finestra viene ridimensionata.
Nota: Solo il nodo Window ridimensionato riceve questa notifica e non viene propagata ai nodi figlio.
NOTIFICATION_WM_DPI_CHANGE = 1009 🔗
Notifica ricevuta dal sistema operativo quando la scala dei punti per pollice (DPI) dello schermo viene modificata. Implementata solo su macOS.
NOTIFICATION_VP_MOUSE_ENTER = 1010 🔗
Notifica ricevuta quando il cursore del mouse entra nell'area visibile della Viewport, che non è nascosta dietro altri Control o Window, a condizione che il suo Viewport.gui_disable_input sia false e a prescindere dal fatto che sia attualmente focalizzata o meno.
NOTIFICATION_VP_MOUSE_EXIT = 1011 🔗
Notifica ricevuta quando il cursore del mouse esce dall'area visibile della Viewport, che non è nascosta dietro altri Control o Window, a condizione che il suo Viewport.gui_disable_input sia false e a prescindere dal fatto che sia attualmente focalizzata o meno.
NOTIFICATION_WM_POSITION_CHANGED = 1012 🔗
Notifica ricevuta quando la finestra viene mossa.
NOTIFICATION_WM_OUTPUT_MAX_LINEAR_VALUE_CHANGED = 1013 🔗
Notification received when the output max linear value returned by Window.get_output_max_linear_value() has changed.
This occurs when HDR output is enabled or disabled and when any HDR output luminance values of the window have changed, such as when the player adjusts their screen brightness setting or moves the window to a different screen.
NOTIFICATION_OS_MEMORY_WARNING = 2009 🔗
Notifica ricevuta dal sistema operativo quando l'applicazione sta eccedendo la sua memoria allocata.
Implementato solo su iOS.
NOTIFICATION_TRANSLATION_CHANGED = 2010 🔗
Notifica ricevuta quando le traduzioni potrebbero essere cambiate. Può essere attivata dall'utente che cambia le impostazioni locali, cambiando auto_translate_mode o quando il nodo entra nell'albero di scene. Può essere utilizzata per rispondere alle modifiche della lingua, ad esempio per cambiare le stringhe dell'interfaccia utente al volo. Utile quando si lavora con il supporto di traduzione integrato, come Object.tr().
Nota: Questa notifica viene ricevuta insieme a NOTIFICATION_ENTER_TREE, quindi se si sta creando un'istanza di una scena, i nodi figli non saranno ancora inizializzati. È possibile utilizzarla per impostare le traduzioni per questo nodo, i nodi figli creati dallo script o, se si desidera accedere ai nodi figli aggiunti nell'editor, assicurarsi che il nodo sia pronto tramite is_node_ready().
func _notification(what):
if what == NOTIFICATION_TRANSLATION_CHANGED:
if not is_node_ready():
await ready # Attendi il segnale ready.
$Label.text = atr("%d Bananas") % banana_counter
NOTIFICATION_WM_ABOUT = 2011 🔗
Notifica ricevuta dal sistema operativo quando viene inviata una richiesta per le informazioni "About".
Implementato solo su macOS.
NOTIFICATION_CRASH = 2012 🔗
Notifica ricevuta dal gestore dei crash di Godot quando il motore sta per arrestarsi.
Implementato su piattaforme desktop, se il gestore dei crash è abilitato.
NOTIFICATION_OS_IME_UPDATE = 2013 🔗
Notification received from the OS when an update of the Input Method Engine occurs (e.g. change of IME cursor position or composition string).
Implemented on desktop and web platforms.
NOTIFICATION_APPLICATION_RESUMED = 2014 🔗
Notifica ricevuta dal sistema operativo quando l'applicazione viene ripresa.
Specifico per le piattaforme Android e iOS.
NOTIFICATION_APPLICATION_PAUSED = 2015 🔗
Notifica ricevuta dal sistema operativo quando l'applicazione è in pausa.
Specifico per le piattaforme Android e iOS.
Nota: Su iOS, hai solo circa 5 secondi per terminare un'attività avviata da questo segnale. Se superi questa soglia, iOS chiuderà l'app invece di metterla in pausa.
NOTIFICATION_APPLICATION_FOCUS_IN = 2016 🔗
Notifica ricevuta dal sistema operativo quando l'applicazione è focalizzata, ovvero quando si cambia il focus dal desktop del sistema operativo o da un'applicazione di terze parti a una finestra aperta dell'istanza di Godot.
Implementato su piattaforme desktop e mobili.
NOTIFICATION_APPLICATION_FOCUS_OUT = 2017 🔗
Notifica ricevuta dal sistema operativo quando l'applicazione è perde il focus, ovvero quando si cambia il focus dal desktop del sistema operativo o da un'applicazione di terze parti a una finestra aperta dell'istanza di Godot.
Implementato su piattaforme desktop e mobili.
NOTIFICATION_TEXT_SERVER_CHANGED = 2018 🔗
Notifica ricevuta quando il TextServer viene modificato.
NOTIFICATION_APPLICATION_PIP_MODE_ENTERED = 2019 🔗
Notification received when the application enters picture-in-picture mode.
NOTIFICATION_APPLICATION_PIP_MODE_EXITED = 2020 🔗
Notification received when the application exits picture-in-picture mode.
NOTIFICATION_ACCESSIBILITY_UPDATE = 3000 🔗
Notifica ricevuta quando è necessario un aggiornamento delle informazioni di accessibilità.
NOTIFICATION_ACCESSIBILITY_INVALIDATE = 3001 🔗
Notifica ricevuta quando gli elementi di accessibilità vengono invalidati. Tutti gli elementi di accessibilità del nodo vengono automaticamente eliminati dopo aver ricevuto di questo messaggio, pertanto è necessario eliminare tutti i riferimenti esistenti a tali elementi.
Descrizioni delle proprietà
AutoTranslateMode auto_translate_mode = 0 🔗
void set_auto_translate_mode(value: AutoTranslateMode)
AutoTranslateMode get_auto_translate_mode()
Defines if any text should automatically change to its translated version depending on the current locale (for nodes such as Label, RichTextLabel, Window, etc.). Also decides if the node's strings should be parsed for translation template generation.
Note: For the root node, auto translate mode can also be set via ProjectSettings.internationalization/rendering/root_node_auto_translate.
String editor_description = "" 🔗
Una descrizione facoltativa per il nodo. Sarà visualizzata come suggerimento quando si passa il mouse sul nodo nel pannello di Scena nell'editor.
MultiplayerAPI multiplayer 🔗
MultiplayerAPI get_multiplayer()
L'istanza di MultiplayerAPI associata a questo nodo. Vedi SceneTree.get_multiplayer().
Nota: Rinominare il nodo o spostarlo nell'albero non sposterà la MultiplayerAPI nel nuovo percorso, sarà necessario aggiornarlo manualmente.
StringName name 🔗
void set_name(value: StringName)
StringName get_name()
Il nome del nodo. Questo nome deve essere univoco tra i fratelli (altri nodi figlio dello stesso genitore). Quando impostato sul nome di un fratello esistente, il nodo viene automaticamente rinominato.
Nota: Quando si modifica il nome, i seguenti caratteri saranno sostituiti con un trattino basso: (. : @ / " %). In particolare, il carattere @ è riservato ai nomi generati automaticamente. Vedere anche String.validate_node_name().
The owner of this node. The owner must be an ancestor of this node. When packing the owner node in a PackedScene, all the nodes it owns are also saved with it. See also unique_name_in_owner.
Note: In the editor, nodes not owned by the scene root are usually not displayed in the Scene dock, and will not be saved. To prevent this, remember to set the owner after calling add_child().
Note: The owner needs to be the current scene root. See Instancing scenes in the documentation for more information.
PhysicsInterpolationMode physics_interpolation_mode = 0 🔗
void set_physics_interpolation_mode(value: PhysicsInterpolationMode)
PhysicsInterpolationMode get_physics_interpolation_mode()
La modalità di interpolazione fisica da utilizzare per questo nodo. Efficace solo se ProjectSettings.physics/common/physics_interpolation o SceneTree.physics_interpolation è impostato su true.
Come predefinito, i nodi ereditano la modalità di interpolazione fisica dal nodo genitore. Questa proprietà può abilitare o disabilitare l'interpolazione fisica individualmente per ciascun nodo, a prescindere dalla modalità di interpolazione fisica del nodo genitore.
Nota: Alcuni tipi di nodo, come VehicleWheel3D, hanno l'interpolazione fisica disabilitata come predefinito, poiché si basano su un'implementazione personalizzata.
Nota: Quando si teletrasporta un nodo in una posizione distante, si consiglia di disabilitare temporaneamente l'interpolazione con reset_physics_interpolation() dopo lo spostamento del nodo. Questo evita di creare una striscia visiva tra la vecchia e la nuova posizione.
ProcessMode process_mode = 0 🔗
void set_process_mode(value: ProcessMode)
ProcessMode get_process_mode()
Il comportamento di elaborazione del nodo. Per verificare se il nodo può eseguire la sua elaborazione nella sua modalità attuale, usa can_process().
int process_physics_priority = 0 🔗
Simile a process_priority ma per NOTIFICATION_PHYSICS_PROCESS, _physics_process() o NOTIFICATION_INTERNAL_PHYSICS_PROCESS.
L'ordine di esecuzione dei callback di processo (_process(), NOTIFICATION_PROCESS e NOTIFICATION_INTERNAL_PROCESS) del nodo. I nodi il cui valore di priorità è inferiore chiamano per primi i loro callback di processo, a prescindere dall'ordine nell'albero.
ProcessThreadGroup process_thread_group = 0 🔗
void set_process_thread_group(value: ProcessThreadGroup)
ProcessThreadGroup get_process_thread_group()
Imposta il gruppo di thread di processo per questo nodo (in pratica, se riceve NOTIFICATION_PROCESS, NOTIFICATION_PHYSICS_PROCESS, _process() o _physics_process() (e le versioni interne) sul thread principale o in un sottothread.
Per impostazione predefinita, il gruppo di thread è PROCESS_THREAD_GROUP_INHERIT, il che significa che questo nodo appartiene allo stesso gruppo del nodo genitore. I gruppi di thread indicano che i nodi in uno specifico gruppo saranno elaborati insieme, separati dagli altri gruppi (a seconda di process_thread_group_order). Se il valore impostato è PROCESS_THREAD_GROUP_SUB_THREAD, questo gruppo di thread sarà elaborato su un thread secondario (non sul thread principale), altrimenti se impostato su PROCESS_THREAD_GROUP_MAIN_THREAD sarà elaborato sul thread principale. Se non c'è un nodo genitore o nonno impostato su un valore diverso da "inherit", il nodo apparterrà al gruppo di thread predefinito. Questo gruppo predefinito sarà elaborato sul thread principale e il suo ordine di gruppo è 0.
Durante l'elaborazione in un thread secondario, non è possibile accedere alla maggior parte delle funzioni nei nodi al di fuori del gruppo di thread (e comporterà un errore in modalità debug). Usa Object.call_deferred(), call_thread_safe(), call_deferred_thread_group() e simili per comunicare dai gruppi di thread al thread principale (o ad altri gruppi di thread).
Per comprendere meglio i gruppi di thread di processo, l'idea è che qualsiasi nodo impostato su un valore diverso da PROCESS_THREAD_GROUP_INHERIT includerà tutti i nodi figlio (e nipote) impostati per ereditare nel suo gruppo di thread di processo. Ciò significa che l'elaborazione di tutti i nodi nel gruppo avverrà insieme, allo stesso tempo del nodo che li include.
int process_thread_group_order 🔗
Cambia l'ordine del gruppo di thread di processo. I gruppi con un ordine inferiore saranno elaborati prima dei gruppi con un ordine superiore. Questo è utile quando una grande quantità di nodi elabora in un thread secondario e, in seguito, un altro gruppo desidera raccogliere il loro risultato nel thread principale, ad esempio.
BitField[ProcessThreadMessages] process_thread_messages 🔗
void set_process_thread_messages(value: BitField[ProcessThreadMessages])
BitField[ProcessThreadMessages] get_process_thread_messages()
Imposta se il gruppo di thread attuale elaborerà i messaggi (chiamate a call_deferred_thread_group() sui thread) e se desidera riceverli durante i callback di processo regolare o della fisica.
Il percorso del file della scena originale, se il nodo è stato istanziato da un file PackedScene. Solo i nodi radice della scena lo contengono.
bool unique_name_in_owner = false 🔗
Se true, il nodo è accessibile da qualsiasi nodo che condivide lo stesso owner o dal owner stesso, con la sintassi speciale %Name nel metodo get_node().
Nota: Se un altro nodo con lo stesso owner condivide lo stesso name di questo nodo, l'altro nodo non sarà più accessibile come univoco.
Descrizioni dei metodi
void _enter_tree() virtual 🔗
Chiamato quando il nodo entra nello SceneTree (ad esempio durante l'istanziazione, aver cambiato scena o dopo aver chiamato add_child() in uno script). Se il nodo ha figli, sarà chiamato prima il suo callback _enter_tree() e poi quello dei figli.
Corrisponde alla notifica NOTIFICATION_ENTER_TREE in Object._notification().
void _exit_tree() virtual 🔗
Chiamato quando il nodo sta per lasciare il SceneTree (ad esempio, dopo averlo liberato, aver cambiato scena o aver chiamato remove_child() in uno script). Se il nodo ha dei figli, il suo callback _exit_tree() sarà chiamato per ultimo, dopo che tutti i suoi figli hanno lasciato l'albero.
Corrisponde alla notifica NOTIFICATION_EXIT_TREE in Object._notification() e al segnale tree_exiting. Per ricevere una notifica quando il nodo ha già lasciato l'albero attivo, connettiti a tree_exited.
PackedStringArray _get_accessibility_configuration_warnings() virtual const 🔗
Gli elementi nell'array restituiti da questo metodo sono visualizzati come avvisi nel pannello Scena se lo script che lo sovrascrive è uno script tool e gli avvisi di accessibilità sono abilitati nelle impostazioni dell'editor.
Restituire un array vuoto non produce avvisi.
PackedStringArray _get_configuration_warnings() virtual const 🔗
Gli elementi nell'array restituiti da questo metodo sono visualizzati come avvisi nel pannello di Scena se lo script che lo sovrascrive è uno script tool.
Restituire un array vuoto non produce avvisi.
Chiama update_configuration_warnings() quando è necessario aggiornare gli avvisi per questo nodo.
@export var energia = 0:
set(valore):
energia = valore
update_configuration_warnings()
func _get_configuration_warnings():
if energia < 0:
return ["Energia deve essere maggiore o uguale a 0."]
else:
return []
RID _get_focused_accessibility_element() virtual const 🔗
Chiamato durante gli aggiornamenti delle informazioni di accessibilità per determinare il sotto-elemento attualmente attivo, dovrebbe restituire un RID di sotto-elemento o il valore restituito da get_accessibility_element().
void _input(event: InputEvent) virtual 🔗
Chiamato quando è presente un evento di input. L'evento di input si propaga attraverso l'albero dei nodi finché un nodo non lo consuma.
È chiamato solo se l'elaborazione degli input è abilitata, il che avviene automaticamente se questo metodo è sovrascritto, oppure può essere abilitata con set_process_input().
Per consumare l'evento di input e impedire che si propaghi ulteriormente ad altri nodi, è possibile chiamare Viewport.set_input_as_handled().
Per gli input che riguardano il gioco, _unhandled_input() e _unhandled_key_input() sono solitamente più adatti, in quanto consentono alla GUI di intercettare prima gli eventi.
Nota: Questo metodo è chiamato solo se il nodo è presente nell'albero di scene (ovvero se non è orfano).
void _physics_process(delta: float) virtual 🔗
Chiamato una volta a ogni tick di fisica, consente ai nodi di sincronizzare la propria logica con i tick di fisica. delta è il tempo logico tra i tick di fisica in secondi ed è uguale a Engine.time_scale / Engine.physics_ticks_per_second.
È chiamato solo se è abilitata l'elaborazione della fisica, il che viene effettuato automaticamente se questo metodo è sovrascritto e si può cambiare con set_physics_process().
L'elaborazione avviene in base all'ordine di process_physics_priority, i valori con priorità più bassa vengono chiamati per primi. I nodi con la stessa priorità vengono elaborati in ordine ad albero, ovvero dall'alto verso il basso, come mostrato nell'editor (anche noto come attraversamento pre-ordine).
Corrisponde alla notifica NOTIFICATION_PHYSICS_PROCESS in Object._notification().
Nota: Questo metodo viene chiamato solo se il nodo è presente nell'albero di scene (ovvero se non è orfano).
Nota: Il delta accumulato potrebbe deviare dai secondi reali.
void _process(delta: float) virtual 🔗
Chiamato a ogni frame inattivo, prima di renderizzare, e dopo l'elaborazione dei tick di fisica. delta è il tempo trascorso tra i frame, in secondi.
Viene chiamato solo se è abilitata l'elaborazione per questo nodo, il che viene effettuato automaticamente se questo metodo è sovrascritto e si può cambiare con set_process().
L'elaborazione avviene in base all'ordine di process_physics_priority, i valori con priorità più bassa vengono chiamati per primi. I nodi con la stessa priorità vengono elaborati in ordine ad albero, ovvero dall'alto verso il basso, come mostrato nell'editor (anche noto come attraversamento pre-ordine).
Corrisponde alla notifica NOTIFICATION_PROCESS in Object._notification().
Nota: Questo metodo viene chiamato solo se il nodo è presente nell'albero di scene (ovvero se non è orfano).
Nota: Quando il motore è in difficoltà e la frequenza dei frame diminuisce, delta aumenterà. Quando delta è aumentato, il suo limite massimo è di Engine.time_scale * Engine.max_physics_steps_per_frame / Engine.physics_ticks_per_second. Pertanto, il delta accumulato potrebbe non rappresentare il tempo reale.
Nota: Quando --fixed-fps è abilitato o il motore è in esecuzione in modalità Movie Maker (vedi MovieWriter), delta sarà sempre lo stesso per ogni frame, a prescindere dal tempo impiegato per renderizzare i frame.
Nota: Il delta dei frame potrebbe essere post-elaborato da OS.delta_smoothing se questa opzione è abilitata per il progetto.
void _ready() virtual 🔗
Chiamato quando il nodo è "pronto", ovvero quando sia il nodo sia i suoi figli sono entrati nell'albero di scene. Se il nodo ha figli, i loro callback _ready() sono attivati per primi e il nodo genitore riceverà la notifica di pronto in seguito.
Corrisponde alla notifica NOTIFICATION_READY in Object._notification(). Vedi anche l'annotazione @onready per le variabili.
Solitamente usato per l'inizializzazione. Per un'inizializzazione ancora più anticipata, è possibile usare Object._init(). Vedi anche _enter_tree().
Nota: Questo metodo può essere chiamato solo una volta per ogni nodo. Dopo aver rimosso un nodo dall'albero di scene e averlo aggiunto nuovamente, _ready() non sarà chiamato una seconda volta. È possibile aggirare questa limitazione richiedendo un'altra chiamata con request_ready(), che può essere chiamato ovunque prima di aggiungere nuovamente il nodo.
void _shortcut_input(event: InputEvent) virtual 🔗
Chiamato quando un InputEventKey, InputEventShortcut o InputEventJoypadButton non è stato consumato da _input() o da qualsiasi elemento Control. È chiamato prima di _unhandled_key_input() e _unhandled_input(). L'evento di input si propaga attraverso l'albero dei nodi finché un nodo non lo consuma.
È chiamato solo se l'elaborazione delle scorciatoie è abilitata, il che avviene automaticamente se questo metodo è sovrascritto, oppure può essere abilitata con set_process_shortcut_input().
Per consumare l'evento di input e impedire che si propaghi ulteriormente ad altri nodi, è possibile chiamare Viewport.set_input_as_handled().
Questo metodo può essere utilizzato per gestire le scorciatoie. Per gli eventi generici dell'interfaccia utente, usa invece _input(). Gli eventi di gioco dovrebbero essere solitamente gestiti con _unhandled_input() o _unhandled_key_input().
Nota: Questo metodo è chiamato solo se il nodo è presente nell'albero di scene (ovvero se non è orfano).
void _unhandled_input(event: InputEvent) virtual 🔗
Chiamato quando un InputEvent non è stato consumato da _input() o da qualsiasi elemento Control. È chiamato dopo _shortcut_input() e dopo _unhandled_key_input(). L'evento di input si propaga attraverso l'albero dei nodi finché un nodo non lo consuma.
È chiamato solo se l'elaborazione degli input non gestiti è abilitata, il che avviene automaticamente se questo metodo è sovrascritto, oppure può essere abilitata con set_process_unhandled_input().
Per consumare l'evento di input e impedire che si propaghi ulteriormente ad altri nodi, è possibile chiamare Viewport.set_input_as_handled().
Per gli input di gioco, questo metodo è solitamente più adatto di _input(), poiché gli eventi dell'interfaccia utente necessitano di una priorità più alta. Per le scorciatoie da tastiera, considera di utilizzare _shortcut_input(), poiché è chiamato prima di questo metodo. Infine, per gestire gli eventi della tastiera, considera di utilizzare _unhandled_key_input() per motivi di prestazioni.
Nota: Questo metodo è chiamato solo se il nodo è presente nell'albero di scene (ovvero se non è orfano).
void _unhandled_key_input(event: InputEvent) virtual 🔗
Chiamato quando un InputEventKey non è stato consumato da _input() o da qualsiasi elemento Control. È chiamato dopo _shortcut_input() ma prima di _unhandled_input(). L'evento di input si propaga attraverso l'albero dei nodi finché un nodo non lo consuma.
È chiamato solo se l'elaborazione degli input da tastiera non gestiti è abilitata, il che avviene automaticamente se questo metodo è sovrascritto, oppure può essere abilitata con set_process_unhandled_key_input().
Per consumare l'evento di input e impedire che si propaghi ulteriormente ad altri nodi, è possibile chiamare Viewport.set_input_as_handled().
Questo metodo può essere utilizzato per gestire l'input di caratteri Unicode con i modificatori Alt, Alt + Ctrl e Alt + Shift, dopo che sono state gestite le scorciatoie.
Per l'input di gioco, questo metodo e _unhandled_input() sono solitamente più adatti di _input(), poiché gli eventi dell'interfaccia utente devono essere gestiti per primi. Questo metodo funziona anche meglio di _unhandled_input(), poiché gli eventi non correlati come InputEventMouseMotion sono filtrati automaticamente. Per le scorciatoie, considera di usare _shortcut_input().
Nota: Questo metodo è chiamato solo se il nodo è presente nell'albero di scene (ovvero se non è orfano).
void add_child(node: Node, force_readable_name: bool = false, internal: InternalMode = 0) 🔗
Aggiunge il nodo node come figlio. I nodi possono avere un numero qualsiasi di figli, ma ogni figlio deve avere un nome univoco. I nodi figlio sono eliminati automaticamente quando il nodo padre è eliminato, quindi un'intera scena si può rimuovere eliminando il suo nodo più in alto.
Se force_readable_name è true, migliora la leggibilità del node aggiunto. Se non è denominato, node viene rinominato nel suo tipo. Inoltre, se condivide il suo name con un fratello, un numero viene accodato più correttamente. Questa operazione è molto lenta. Pertanto, si consiglia di lasciare questo su false, che assegna un nome segnaposto con @ in entrambe le situazioni.
Se internal è diverso da INTERNAL_MODE_DISABLED, il figlio verrà aggiunto come nodo interno. Questi nodi sono ignorati da metodi come get_children(), a meno che il loro parametro include_internal non sia true. L'uso previsto è quello di nascondere i nodi interni all'utente, in modo che l'utente non li elimini o modifichi accidentalmente. Utilizzato da alcuni nodi dell'interfaccia utente, ad esempio ColorPicker.
Nota: Se node ha già un genitore, questo metodo fallirà. Usa prima remove_child() per rimuovere node dal suo genitore attuale. Ad esempio:
var child_node = get_child(0)
if child_node.get_parent():
child_node.get_parent().remove_child(child_node)
add_child(child_node)
Node childNode = GetChild(0);
if (childNode.GetParent() != null)
{
childNode.GetParent().RemoveChild(childNode);
}
AddChild(childNode);
Se è necessario che il nodo figlio sia aggiunto sotto un nodo specifico nell'elenco dei figli, usa add_sibling() invece di questo metodo.
Nota: Se è necessario che un figlio sia reso persistente in un PackedScene, imposta owner oltre a chiamare add_child(). Questo è in genere importante per gli script strumenti e le estensioni dell'editor. Se add_child() viene chiamato senza impostare owner, il Node appena aggiunto non sarà visibile nell'albero di scene, anche se sarà visibile nella vista 2D/3D.
void add_sibling(sibling: Node, force_readable_name: bool = false) 🔗
Aggiunge il nodo sibling al nodo genitore di questo nodo e sposta il fratello aggiunto subito sotto questo nodo.
Se force_readable_name è true, migliora la leggibilità del sibling aggiunto. Se non è denominato, sibling viene rinominato nel suo tipo. Inoltre, se condivide il suo name con un fratello, un numero viene accodato più correttamente. Questa operazione è molto lenta. Pertanto, si consiglia di lasciare questo su false, che assegna un nome fittizio con @ in entrambe le situazioni.
Usa add_child() invece di questo metodo se non c'è bisogno che il nodo figlio sia aggiunto sotto un nodo specifico nella lista dei figli.
Nota: Se questo nodo è interno, anche il fratello aggiunto sarà interno (vedi il parametro internal di add_child()).
void add_to_group(group: StringName, persistent: bool = false) 🔗
Adds the node to the group. Groups can be helpful to organize a subset of nodes, for example "enemies" or "collectables". See notes in the description, and the group methods in SceneTree.
If persistent is true, the group will be stored when saved inside a PackedScene. All groups created and displayed in the Groups dock are persistent.
Note: To improve performance, the order of group names is not guaranteed and may vary between project runs. Therefore, do not rely on the group order.
Note: SceneTree's group methods will not work on this node if not inside the tree (see is_inside_tree()).
String atr(message: String, context: StringName = "") const 🔗
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.
Questo metodo è simile a Object.tr(), ma rispetta lo stato di auto_translate_mode.
Se Object.can_translate_messages() è false, o non è disponibile alcuna traduzione, questo metodo restituisce message senza modifiche. Vedi Object.set_message_translation().
Per esempi dettagliati, vedi Internazionalizzazione dei giochi.
String atr_n(message: String, 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.
Questo metodo è simile a Object.tr_n(), ma rispetta lo stato di auto_translate_mode.
Se Object.can_translate_messages() è false, o non è disponibile alcuna traduzione, questo metodo restituisce message o plural_message, senza modifiche. Vedi Object.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, vedi Internazionalizzazione dei giochi.
Nota: I numeri negativi e float potrebbero non essere applicati correttamente ad alcuni soggetti numerabili. Si consiglia di gestire questi casi con atr().
Variant call_deferred_thread_group(method: StringName, ...) vararg 🔗
Questa funzione è simile a Object.call_deferred(), eccetto che la chiamata avrà luogo quando il gruppo di thread del nodo è elaborato. Se il gruppo di thread del nodo elabora in un thread secondario, la chiamata sarà eseguita su quel thread, subito prima che NOTIFICATION_PROCESS o NOTIFICATION_PHYSICS_PROCESS, _process() o _physics_process() o le loro versioni interne siano chiamate.
Variant call_thread_safe(method: StringName, ...) vararg 🔗
Questa funzione assicura che la chiamata di questa funzione avrà successo, a prescindere dal fatto che sia eseguita da un thread o meno. Se è chiamata da un thread a cui non è consentito chiamare la funzione, la chiamata sarà differita. Altrimenti, la chiamata sarà eseguita direttamente.
bool can_auto_translate() const 🔗
Restituisce true se il nodo può automaticamente tradurre i messaggi a seconda della lingua attuale. Vedi anche auto_translate_mode, atr() e atr_n().
Restituisce true se il nodo può ricevere notifiche di elaborazione e callback di input (NOTIFICATION_PROCESS, _input(), ecc.) dal SceneTree e Viewport. Il valore restituito dipende da process_mode:
Se impostato su PROCESS_MODE_PAUSABLE, restituisce
truequando il gioco è in elaborazione, ovvero SceneTree.paused èfalse;Se impostato su PROCESS_MODE_WHEN_PAUSED, restituisce
truequando il gioco è in pausa, ovvero SceneTree.paused ètrue;Se impostato su PROCESS_MODE_ALWAYS, restituisce sempre
true;Se impostato su PROCESS_MODE_DISABLED, restituisce sempre
false;Se impostato su PROCESS_MODE_INHERIT, usa process_mode del nodo genitore per determinare il risultato.
Se il nodo non è all'interno dell'albero, restituisce false a prescindere dal valore di process_mode.
Crea un nuovo Tween e lo associa a questo nodo.
Ciò è equivalente a fare:
get_tree().create_tween().bind_node(self)
GetTree().CreateTween().BindNode(this);
Il Tween sarà avviato automaticamente sul frame di processo o frame di fisica successivo (a seconda di TweenProcessMode). Vedi Tween.bind_node() per maggiori informazioni sui Tween associati ai nodi.
Nota: È possibile utilizzare questo metodo comunque quando il nodo non è all'interno di SceneTree. Potrebbe non funzionare nel caso improbabile in cui si utilizzi un MainLoop personalizzato.
Node duplicate(flags: int = 15) const 🔗
Duplicates the node, returning a new node with all of its properties, signals, groups, and children copied from the original, recursively. The behavior can be tweaked through the flags (see DuplicateFlags). Internal nodes are not duplicated.
Note: For nodes with a Script attached, if Object._init() has been defined with required parameters, the duplicated node will not have a Script.
Note: By default, this method will duplicate only properties marked for serialization (i.e. using @GlobalScope.PROPERTY_USAGE_STORAGE, or in GDScript, @GDScript.@export). If you want to duplicate all properties, use DUPLICATE_INTERNAL_STATE.
Node find_child(pattern: String, recursive: bool = true, owned: bool = true) const 🔗
Trova il primo discendente di questo nodo il cui name corrisponde a pattern, restituendo null se nessuna corrispondenza viene trovata. La corrispondenza viene effettuata sui nomi dei nodi, non sui loro percorsi, tramite String.match(). Pertanto, è sensibile alle maiuscole e alle minuscole, "*" corrisponde a zero o più caratteri e "?" corrisponde a qualsiasi singolo carattere.
Se recursive è false, solo i figli diretti di questo nodo sono controllati. I nodi sono controllati in ordine ad albero, quindi è controllato prima il primo figlio diretto di questo nodo, poi i suoi figli diretti, ecc., prima di passare al secondo figlio diretto e così via. Nella ricerca sono inclusi anche i figli interni (vedi il parametro internal in add_child()).
Se owned è true, sono controllati solo i discendenti con un nodo owner valido.
Nota: Questo metodo può essere molto lento. Considera di memorizzare un riferimento al nodo trovato in una variabile. In alternativa, usa get_node() con nomi univoci (vedi unique_name_in_owner).
Nota: Per trovare tutti i nodi discendenti che corrispondono a uno schema o a un tipo di classe, vedi find_children().
Array[Node] find_children(pattern: String, type: String = "", recursive: bool = true, owned: bool = true) const 🔗
Finds all descendants of this node whose names match pattern, returning an empty Array if no match is found. The matching is done against node names, not their paths, through String.match(). As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character.
If type is not empty, only descendants inheriting from type are included (see Object.is_class()).
If recursive is false, only this node's direct children are checked. Nodes are checked in tree order, so this node's first direct child is checked first, then its own direct children, etc., before moving to the second direct child, and so on. Internal children are also included in the search (see internal parameter in add_child()).
If owned is true, only descendants with a valid owner node are checked.
Note: This method can be very slow. Consider storing references to the found nodes in a variable.
Note: To find a single descendant node matching a pattern, see find_child().
Node find_parent(pattern: String) const 🔗
Trova il primo antenato di questo nodo il cui name corrisponde a pattern, restituendo null se nessuna corrispondenza viene trovata. La corrispondenza viene effettuata tramite String.match(). Pertanto, è sensibile alle maiuscole e alle minuscole, "*" corrisponde a zero o più caratteri e "?" corrisponde a qualsiasi singolo carattere. Vedi anche find_child() e find_children().
Nota: Man mano che questo metodo sale nell'albero della scena, può essere lento in nodi profondamente innestati. Considera di memorizzare un riferimento al nodo trovato in una variabile. In alternativa, utilizza get_node() con nomi univoci (vedi unique_name_in_owner).
RID get_accessibility_element() const 🔗
Restituisce il RID dell'elemento principale di accessibilità.
Nota: Si dovrebbe chiamare questo metodo solo durante gli aggiornamenti delle informazioni di accessibilità (NOTIFICATION_ACCESSIBILITY_UPDATE).
Node get_child(idx: int, include_internal: bool = false) const 🔗
Recupera un nodo figlio tramite il suo indice. Ogni nodo figlio ha un indice relativo ai suoi fratelli (vedi get_index()). Il primo figlio è all'indice 0. Si possono anche usare valori negativi per partire dalla fine della lista. Questo metodo si può usare in combinazione con get_child_count() per iterare i figli di questo nodo. Se nessun figlio esiste all'indice specificato, questo metodo restituisce null e viene generato un errore.
Se include_internal è false, i figli interni sono ignorati (vedi il parametro internal di add_child()).
# Supponendo che i seguenti siano figli di questo nodo, in ordine:
# Primo, Mezzo, Ultimo.
var a = get_child(0).name # a è "Primo"
var b = get_child(1).name # b è "Mezzo"
var b = get_child(2).name # b è "Ultimo"
var c = get_child(-1).name # c è "Ultimo"
Nota: Per recuperare un nodo tramite NodePath, usa get_node().
int get_child_count(include_internal: bool = false) const 🔗
Restituisce il numero di figli di questo nodo.
Se include_internal è false, i figli interni non sono conteggiati (vedi il parametro internal di add_child()).
Array[Node] get_children(include_internal: bool = false) const 🔗
Restituisce tutti i figli di questo nodo all'interno di un Array.
Se include_internal è false, esclude i figli interni dall'array restituito (vedi il parametro internal di add_child()).
Array[StringName] get_groups() const 🔗
Restituisce un Array di nomi dei gruppi a cui è stato aggiunto il nodo.
Nota: Per migliorare le prestazioni, l'ordine dei nomi dei gruppi non è garantito e può variare tra le esecuzioni del progetto. Pertanto, non fare affidamento sull'ordine dei gruppi.
Nota: Questo metodo può anche restituire alcuni nomi di gruppi che iniziano con un trattino basso (_). Questi sono utilizzati internamente dal motore. Per evitare conflitti, non usare gruppi personalizzati che iniziano con trattini bassi. Per escludere i gruppi interni, vedi il seguente snippet di codice:
# Memorizza solo i gruppi non interni del nodo (come array di StringNames)
var non_internal_groups = []
for group in get_groups():
if not str(group).begins_with("_"):
non_internal_groups.push_back(group)
// Memorizza solo i gruppi non interni del nodo (come List di StringName).
List<string> nonInternalGroups = new List<string>();
foreach (string group in GetGroups())
{
if (!group.BeginsWith("_"))
nonInternalGroups.Add(group);
}
int get_index(include_internal: bool = false) const 🔗
Restituisce l'ordine di questo nodo tra i suoi fratelli. L'indice del primo nodo è 0. Vedi anche get_child().
Se include_internal è false, restituisce l'indice ignorando i figli interni. Il primo figlio non interno avrà un indice di 0 (vedi il parametro internal di add_child()).
Window get_last_exclusive_window() const 🔗
Restituisce la finestra (Window) che contiene questo nodo, oppure l'ultimo figlio esclusivo in una catena di finestre che inizia con quella che contiene questo nodo.
int get_multiplayer_authority() const 🔗
Restituisce l'ID peer dell'autorità multigiocatore per questo nodo. Vedi set_multiplayer_authority().
Node get_node(path: NodePath) const 🔗
Recupera un nodo. Il NodePath può essere un percorso relativo (da questo nodo) o un percorso assoluto (da SceneTree.root) a un nodo. Se il percorso path non punta a un nodo valido, genera un errore e restituisce null. I tentativi di accedere ai metodi sul valore restituito genereranno un errore "Attempt to call <metodo> on a null instance.".
Nota: Il recupero tramite percorso assoluto funziona solo quando il nodo è all'interno dell'albero della scena (vedi is_inside_tree()).
Esempio: Supponiamo che questo metodo venga chiamato dal nodo Personaggio, all'interno del seguente albero:
┖╴root
┠╴Personaggio (sei qui!)
┃ ┠╴Spada
┃ ┖╴Zaino
┃ ┖╴Pugnale
┠╴MioGioco
┖╴Palude
┠╴Alligatore
┠╴Zanzara
┖╴Goblin
Le seguenti chiamate restituiranno un nodo valido:
get_node("Spada")
get_node("Zaino/Pugnale")
get_node("../Swamp/Alligator")
get_node("/root/MioGioco")
GetNode("Spada");
GetNode("Zaino/Pugnale");
GetNode("../Palude/Alligatore");
GetNode("/root/MioGioco");
Array get_node_and_resource(path: NodePath) 🔗
Recupera un nodo e la sua risorsa più innestata come specificato dal sotto-nome del NodePath. Restituisce un Array di dimensione 3 dove:
L'elemento
0è il Node, onullse non trovato;L'elemento
1è l'ultima Resource innestata del sotto-nome, onullse non trovata;L'elemento
2è il NodePath rimanente, che si riferisce a una proprietà esistente, di tipo non Resource (vedi Object.get_indexed()).
Esempio: Supponiamo che alla Sprite2D.texture del figlio sia stata assegnata una AtlasTexture:
var a = get_node_and_resource("Area2D/Sprite2D")
print(a[0].name) # Stampa Sprite2D
print(a[1]) # Stampa <null>
print(a[2]) # Stampa ^""
var b = get_node_and_resource("Area2D/Sprite2D:texture:atlas")
print(b[0].name) # Stampa Sprite2D
print(b[1].get_class()) # Stampa AtlasTexture
print(b[2]) # Stampa ^""
var c = get_node_and_resource("Area2D/Sprite2D:texture:atlas:region")
print(c[0].name) # Stampa Sprite2D
print(c[1].get_class()) # Stampa AtlasTexture
print(c[2]) # Stampa ^":region"
var a = GetNodeAndResource(NodePath("Area2D/Sprite2D"));
GD.Print(a[0].Name); // Stampa Sprite2D
GD.Print(a[1]); // Stampa <null>
GD.Print(a[2]); // Stampa ^"
var b = GetNodeAndResource(NodePath("Area2D/Sprite2D:texture:atlas"));
GD.Print(b[0].name); // Stampa Sprite2D
GD.Print(b[1].get_class()); // Stampa AtlasTexture
GD.Print(b[2]); // Stampa ^""
var c = GetNodeAndResource(NodePath("Area2D/Sprite2D:texture:atlas:region"));
GD.Print(c[0].name); // Stampa Sprite2D
GD.Print(c[1].get_class()); // Stampa AtlasTexture
GD.Print(c[2]); // Stampa ^":region"
Node get_node_or_null(path: NodePath) const 🔗
Recupera un nodo tramite NodePath. Simile a get_node(), ma non genera un errore se il percorso path non punta a un nodo valido.
Variant get_node_rpc_config() const 🔗
Restituisce un Dictionary che mappa i nomi dei metodi alla loro configurazione RPC definita per questo nodo tramite rpc_config().
Nota: Questo metodo restituisce solo la configurazione RPC assegnata tramite rpc_config(). Consulta Script.get_rpc_config() per recuperare le RPC definite dallo Script.
Array[int] get_orphan_node_ids() static 🔗
Restituisce gli ID oggetto di tutti i nodi orfani (nodi al di fuori dello SceneTree). Utile per il debug.
Nota: get_orphan_node_ids() funziona solo nelle build di debug. Se richiamato in un progetto esportato in modalità rilascio, get_orphan_node_ids() restituirà un array vuoto.
Restituisce il nodo genitore di questo nodo, o null se il nodo non ha un genitore.
Restituisce il percorso assoluto del nodo, relativo al SceneTree.root. Se il nodo non si trova all'interno dell'albero di scena, questo metodo fallisce e restituisce un NodePath vuoto.
NodePath get_path_to(node: Node, use_unique_path: bool = false) const 🔗
Restituisce il NodePath relativo da questo nodo al nodo node specificato. Entrambi i nodi devono essere presenti nello stesso SceneTree o gerarchia di scena, altrimenti questo metodo fallisce e restituisce un NodePath vuoto.
Se use_unique_path è true, restituisce il percorso più breve tenendo conto del nome univoco di questo nodo (vedi unique_name_in_owner).
Nota: Se si ottiene un percorso relativo che inizia da un nodo univoco, il percorso potrebbe essere più lungo di un normale percorso relativo, a causa dell'aggiunta del nome univoco del nodo.
float get_physics_process_delta_time() const 🔗
Restituisce il tempo trascorso (in secondi) dall'ultimo callback di fisica. Questo valore è identico al parametro delta di _physics_process() ed è spesso coerente in fase di esecuzione, a meno che non venga modificato Engine.physics_ticks_per_second. Vedi anche NOTIFICATION_PHYSICS_PROCESS.
Nota: Il valore restituito sarà maggiore del previsto se eseguito a un frame rate inferiore a Engine.physics_ticks_per_second / Engine.max_physics_steps_per_frame FPS. Questo viene fatto per evitare scenari di "spirale di morte" in cui le prestazioni crollerebbero a causa di un numero sempre crescente di passaggi di fisica per frame. Questo comportamento influisce sia su _process() sia su _physics_process(). Perciò, evitare di utilizzare delta per misurare il tempo in secondi reali. Per questo scopo utilizzare invece i metodi del singleton Time, ad esempio Time.get_ticks_usec().
float get_process_delta_time() const 🔗
Restituisce il tempo trascorso (in secondi) dall'ultimo callback di processo. Questo valore è identico al parametro delta di _process() e può variare da frame a frame. Vedi anche NOTIFICATION_PROCESS.
Nota: Il valore restituito sarà maggiore del previsto se eseguito a un frame rate inferiore a Engine.physics_ticks_per_second / Engine.max_physics_steps_per_frame FPS. Questo viene fatto per evitare scenari di "spirale di morte" in cui le prestazioni crollerebbero a causa di un numero sempre crescente di passaggi di fisica per frame. Questo comportamento influisce sia su _process() sia su _physics_process(). Perciò, evitare di utilizzare delta per misurare il tempo in secondi reali. Per questo scopo utilizzare invece i metodi del singleton Time, ad esempio Time.get_ticks_usec().
bool get_scene_instance_load_placeholder() const 🔗
Restituisce true se questo nodo è un segnaposto di carico di istanza. Vedi InstancePlaceholder e set_scene_instance_load_placeholder().
Restituisce lo SceneTree che contiene questo nodo. Se questo nodo non è all'interno dell'albero, genera un errore e restituisce null. Vedi anche is_inside_tree().
Restituisce l'albero come String. Utilizzato principalmente per scopi di debug. Questa versione visualizza il percorso relativo al nodo attuale ed è utile per copiare/incollare nella funzione get_node(). Può anche essere utilizzato nell'interfaccia utente di gioco.
Può stampare, ad esempio:
TheGame
TheGame/Menu
TheGame/Menu/Label
TheGame/Menu/Camera2D
TheGame/SplashScreen
TheGame/SplashScreen/Camera2D
String get_tree_string_pretty() 🔗
Simile a get_tree_string(), restituisce l'albero come String. Questa versione visualizza una rappresentazione più grafica simile a quella visualizzata nel pannello di Scena. È utile per ispezionare alberi più grandi.
Può stampare, ad esempio:
┖╴TheGame
┠╴Menu
┃ ┠╴Label
┃ ┖╴Camera2D
┖╴SplashScreen
┖╴Camera2D
Viewport get_viewport() const 🔗
Restituisce la Viewport progenitore più vicina a questo nodo, se il nodo è all'interno dell'albero. Altrimenti, restituisce null.
Restituisce la finestra (Window) che contiene questo nodo. Se il nodo è nella finestra principale, ciò equivale a ottenere il nodo radice (get_tree().get_root()).
bool has_node(path: NodePath) const 🔗
Restituisce true se il percorso fornito path punta a un nodo valido. Vedi anche get_node().
bool has_node_and_resource(path: NodePath) const 🔗
Restituisce true se il percorso path punta a un nodo valido e i suoi sotto-nomi puntano a una Resource valida, ad esempio Area2D/CollisionShape2D:shape. Le proprietà che non sono di tipo Resource (come i nodi o altri tipi Variant) non sono considerate. Vedi anche get_node_and_resource().
bool is_ancestor_of(node: Node) const 🔗
Restituisce true se il nodo fornito node è un figlio diretto o indiretto di questo nodo.
bool is_displayed_folded() const 🔗
Restituisce true se il nodo è ridotto (minimizzato) nel pannello Scena. Questo metodo è destinato all'uso di estensioni e strumenti dell'editor . Vedi anche set_display_folded().
bool is_editable_instance(node: Node) const 🔗
Restituisce true se node ha figli modificabili abilitati relativo a questo nodo. Questo metodo è destinato all'uso di estensioni e strumenti dell'editor . Vedi anche set_editable_instance().
bool is_greater_than(node: Node) const 🔗
Restituisce true se il nodo fornito node appare in seguito a questo nodo nella gerarchia della scena. Un nodo che appare in seguito è di solito elaborato per ultimo.
bool is_in_group(group: StringName) const 🔗
Restituisce true se questo nodo è stato aggiunto al gruppo group specificato. Vedi add_to_group() e remove_from_group(). Vedi anche le note nella descrizione e i metodi dei gruppi di SceneTree.
Restituisce true se questo nodo è attualmente all'interno di un SceneTree. Vedi anche get_tree().
bool is_multiplayer_authority() const 🔗
Restituisce true se il sistema locale è l'autorità multigiocatore di questo nodo.
Restituisce true se il nodo è pronto, cioè è all'interno dell'albero di scene e tutti i suoi figli sono inizializzati.
request_ready() reimposta questo valore a false.
bool is_part_of_edited_scene() const 🔗
Restituisce true se il nodo fa parte della scena attualmente aperta nell'editor.
bool is_physics_interpolated() const 🔗
Restituisce true se l'interpolazione fisica è abilitata per questo nodo (vedi physics_interpolation_mode).
Nota: L'interpolazione sarà attiva solo se il flag è impostato e l'interpolazione fisica è abilitata nello SceneTree. Ciò può essere testato usando is_physics_interpolated_and_enabled().
bool is_physics_interpolated_and_enabled() const 🔗
Restituisce true se l'interpolazione fisica è abilitata (vedi physics_interpolation_mode) e abilitata nello SceneTree.
Questa è una versione conveniente di is_physics_interpolated() che controlla anche se l'interpolazione fisica è abilitata globalmente.
Vedi SceneTree.physics_interpolation e ProjectSettings.physics/common/physics_interpolation.
bool is_physics_processing() const 🔗
Restituisce true se il processo di fisica è abilitato (vedi set_physics_process()).
bool is_physics_processing_internal() const 🔗
Restituisce true se il processo interno di fisica è abilitato (vedi set_physics_process()).
Restituisce true se il processo è abilitato (vedi set_process()).
bool is_processing_input() const 🔗
Restituisce true se il nodo sta elaborando gli input (vedi set_process_input()).
bool is_processing_internal() const 🔗
Restituisce true se il processo interno è abilitato (vedi set_process_internal()).
bool is_processing_shortcut_input() const 🔗
Restituisce true se il nodo sta elaborando scorciatoie (vedi set_process_shortcut_input()).
bool is_processing_unhandled_input() const 🔗
Restituisce true se il nodo sta elaborando gli input non gestiti (vedi set_process_unhandled_input()).
bool is_processing_unhandled_key_input() const 🔗
Restituisce true se il nodo sta elaborando gli input di tasti non gestiti (vedi set_process_unhandled_key_input()).
void move_child(child_node: Node, to_index: int) 🔗
Sposta il nodo figlio child_node all'indice specificato. L'indice di un nodo è l'ordine tra i suoi fratelli. Se to_index è negativo, l'indice è conteggiato dalla fine della lista. Vedi anche get_child() e get_index().
Nota: L'ordine di elaborazione di diversi callback del motore (_ready(), _process(), ecc.) e le notifiche inviate tramite propagate_notification() sono influenzate dall'ordine di albero. Anche i nodi CanvasItem sono renderizzati nell'ordine di albero. Vedi anche process_priority.
void notify_deferred_thread_group(what: int) 🔗
Simile a call_deferred_thread_group(), ma per le notifiche.
void notify_thread_safe(what: int) 🔗
Simile a call_thread_safe(), ma per le notifiche.
void print_orphan_nodes() static 🔗
Prints all orphan nodes (nodes outside the SceneTree). Useful for debugging.
Note: This method only works in debug builds. It does nothing in a project exported in release mode.
void print_tree() 🔗
Stampa il nodo e i suoi figli sulla console, ricorsivamente. Il nodo non deve essere all'interno dell'albero. Questo metodo restituisce NodePath relativi a questo nodo ed è utile per copiare/incollare in get_node(). Vedi anche print_tree_pretty().
Può stampare, ad esempio:
.
Menu
Menu/Label
Menu/Camera2D
SplashScreen
SplashScreen/Camera2D
void print_tree_pretty() 🔗
Stampa il nodo e i suoi figli sulla console, ricorsivamente. Il nodo non deve essere all'interno dell'albero. Simile a print_tree(), ma la rappresentazione grafica è simile a quella visualizzata nel pannello di Scena nell'editor. È utile per ispezionare alberi più grandi.
Potrebbe stampare, ad esempio:
┖╴TheGame
┠╴Menu
┃ ┠╴Label
┃ ┖╴Camera2D
┖╴SplashScreen
┖╴Camera2D
void propagate_call(method: StringName, args: Array = [], parent_first: bool = false) 🔗
Chiama il metodo con il nome method, passando args come argomenti, su questo nodo e su tutti i suoi figli, ricorsivamente.
Se parent_first è true, il metodo è chiamato prima su questo nodo, poi su tutti i suoi figli. Se false, i metodi dei figli sono chiamati prima.
void propagate_notification(what: int) 🔗
Chiama Object.notification() con what su questo nodo e tutti i suoi figli, ricorsivamente.
void queue_accessibility_update() 🔗
Accoda un aggiornamento delle informazioni di accessibilità per questo nodo.
void queue_free() 🔗
Accoda questo nodo per essere eliminato alla fine del frame attuale. Quando è eliminato, sono eliminati anche tutti i suoi figli e tutti i riferimenti al nodo e ai suoi figli diventano non validi.
A differenza di Object.free(), il nodo non è eliminato subito ed è ancora possibile accedervi prima dell'eliminazione. È anche sicuro chiamare queue_free() più volte. Usa Object.is_queued_for_deletion() per verificare se il nodo sarà eliminato alla fine del frame.
Nota: Il nodo sarà liberato solo dopo che tutte le altre chiamate differite saranno terminate. Usare questo metodo non è sempre equivalente a chiamare Object.free() tramite Object.call_deferred().
void remove_child(node: Node) 🔗
Rimuove un nodo figlio node. node, insieme ai suoi figli, non sono eliminati. Per eliminare un nodo, vedi queue_free().
Nota: Quando questo nodo è all'interno dell'albero, questo metodo imposta il owner del node rimosso (o dei suoi discendenti) su null, se il loro owner non è più un antenato (vedi is_ancestor_of()).
void remove_from_group(group: StringName) 🔗
Rimuove il nodo dal gruppo nominato group. Non fa nulla se il nodo non è nel gruppo group. Vedi anche le note nella descrizione e i metodi dei gruppi di SceneTree.
void reparent(new_parent: Node, keep_global_transform: bool = true) 🔗
Changes the parent of this Node to the new_parent. The node needs to already have a parent. The node's owner is preserved if its owner is still reachable from the new location (i.e., the node is still a descendant of the new parent after the operation).
If keep_global_transform is true, the node's global transform will be preserved if supported. Node2D, Node3D and Control support this argument (but Control keeps only position).
Warning: If ProjectSettings.physics/common/physics_interpolation is enabled and reparenting causes a large change in global transform, the object may appear to move from its old position to its new one over the next physics tick. To avoid this, call reset_physics_interpolation() after reparenting.
void replace_by(node: Node, keep_groups: bool = false) 🔗
Sostituisce questo nodo con il nodo node specificato. Tutti i figli di questo nodo vengono spostati in node.
Se keep_groups è true, il node verrà aggiunto agli stessi gruppi in cui si trova il nodo sostituito (vedi add_to_group()).
Attenzione: Il nodo sostituito viene rimosso dall'albero, ma non viene eliminato. Per evitare perdite di memoria, memorizza un riferimento al nodo in una variabile o usa Object.free().
void request_ready() 🔗
Richiede che _ready() sia chiamato di nuovo la prossima volta che il nodo entra nell'albero. Non chiama immediatamente _ready().
Nota: Questo metodo ha effetto solo sul nodo attuale. Se anche i figli del nodo devono richiedere di essere pronti, questo metodo deve essere chiamato per ognuno di loro. Quando il nodo e i suoi figli entrano di nuovo nell'albero, l'ordine dei callback _ready() sarà lo stesso del solito.
void reset_physics_interpolation() 🔗
Quando l'interpolazione della fisica è attiva, spostare un nodo in una trasformazione radicalmente diversa (ad esempio il posizionamento all'interno di un livello) può causare un evidente glitch mentre l'oggetto viene renderizzato spostandosi dalla vecchia alla nuova posizione sul tick di fisica.
Tale glitch può essere prevenuto chiamando questo metodo, che disabilita temporaneamente l'interpolazione fino al completamento del tick di fisica.
La notifica NOTIFICATION_RESET_PHYSICS_INTERPOLATION verrà ricevuta dal nodo e da tutti i figli in modo ricorsivo.
Nota: Questa funzione dovrebbe essere chiamata dopo lo spostamento del nodo, piuttosto che prima.
Error rpc(method: StringName, ...) vararg 🔗
Invia una richiesta di chiamata di procedura remota per il metodo method ai peer sulla rete (e localmente), inviando argomenti aggiuntivi al metodo chiamato dall'RPC. La richiesta di chiamata sarà ricevuta solo dai nodi con lo stesso NodePath, incluso lo stesso identico name. Il comportamento dipende dalla configurazione RPC per il method specificato (vedi rpc_config() e @GDScript.@rpc). Per impostazione predefinita, i metodi non sono esposti alle RPC.
Potrebbe restituire @GlobalScope.OK se la chiamata ha esito positivo, @GlobalScope.ERR_INVALID_PARAMETER se gli argomenti passati in method non corrispondono, @GlobalScope.ERR_UNCONFIGURED se il multiplayer del nodo non può essere recuperato (ad esempio quando il nodo non è all'interno dell'albero), @GlobalScope.ERR_CONNECTION_ERROR se la connessione di multiplayer non è disponibile
Nota: È possibile utilizzare le RPC in modo sicuro sui client solamente dopo aver ricevuto il segnale MultiplayerAPI.connected_to_server da MultiplayerAPI. È necessario anche tenere traccia dello stato della connessione, tramite i segnali della MultiplayerAPI come MultiplayerAPI.server_disconnected o verificando (get_multiplayer().peer.get_connection_status() == CONNECTION_CONNECTED).
void rpc_config(method: StringName, config: Variant) 🔗
Modifica la configurazione RPC per il metodo method. config dovrebbe essere null per disabilitare la funzionalità (come predefinito) o un Dictionary contenente le seguenti voci:
rpc_mode: vedi RPCMode;transfer_mode: vedi TransferMode;call_local: setrue, il metodo sarà chiamato anche localmente;channel: un int che rappresenta il canale su cui inviare l'RPC.
Nota: In GDScript, questo metodo corrisponde all'annotazione @GDScript.@rpc, con vari parametri passati (@rpc(any), @rpc(authority)...). Consulta anche il tutorial multiplayer di alto livello.
Error rpc_id(peer_id: int, method: StringName, ...) vararg 🔗
Invia un rpc() a un peer specifico identificato da peer_id (vedi MultiplayerPeer.set_target_peer()).
Può restituire @GlobalScope.OK se la chiamata ha esito positivo, @GlobalScope.ERR_INVALID_PARAMETER se gli argomenti passati in method non corrispondono, @GlobalScope.ERR_UNCONFIGURED se il multiplayer del nodo non può essere recuperato (ad esempio quando il nodo non è all'interno dell'albero), @GlobalScope.ERR_CONNECTION_ERROR se la connessione del multiplayer non è disponibile.
void set_deferred_thread_group(property: StringName, value: Variant) 🔗
Simile a call_deferred_thread_group(), ma per impostare le proprietà.
void set_display_folded(fold: bool) 🔗
Se impostato su true, il nodo appare minimizzato nel pannello di Scena. Pertanto, tutti i suoi figli sono nascosti. Questo metodo è pensato all'uso nelle estensioni e negli strumenti dell'editor, ma funziona anche nelle build di rilascio. Vedi anche is_displayed_folded().
void set_editable_instance(node: Node, is_editable: bool) 🔗
Imposta su true per consentire a tutti i nodi posseduti dal nodo node di essere disponibili e modificabili nel pannello di Scena, anche se il loro owner non è la radice della scena. Questo metodo è pensato all'uso nelle estensioni e negli strumenti dell'editor, ma funziona anche nelle build di rilascio. Vedi anche is_editable_instance().
void set_multiplayer_authority(id: int, recursive: bool = true) 🔗
Imposta l'autorità multigiocatore del nodo sul peer con l'id specificato. L'autorità multigiocatore è il peer che ha autorità sul nodo sulla rete. Il valore predefinito è peer ID 1 (il server). Utile in combinazione con rpc_config() e la MultiplayerAPI.
Se recursive è true, il peer specificato viene impostato ricorsivamente come autorità per tutti i figli di questo nodo.
Attenzione: Questo non replica automaticamente la nuova autorità ad altri peer. È responsabilità dello sviluppatore farlo. È possibile replicare le informazioni della nuova autorità usando MultiplayerSpawner.spawn_function, un RPC o un MultiplayerSynchronizer. Inoltre, l'autorità del genitore non si propaga ai figli appena aggiunti.
void set_physics_process(enable: bool) 🔗
Se impostato su true, abilita il processo di fisica (framerate fisso). Quando un nodo viene processato, riceverà una NOTIFICATION_PHYSICS_PROCESS a un intervallo fisso. (solitamente 60 FPS, vedi Engine.physics_ticks_per_second per modificarlo) (e verrà chiamato il callback _physics_process() se esiste).
Nota: Se _physics_process() è sovrascritto, questo sarà automaticamente abilitato prima che _ready() sia chiamato.
void set_physics_process_internal(enable: bool) 🔗
Se impostato su true, abilita la fisica interna per questo nodo. Il processo interno di fisica avviene in modo isolato dalle normali chiamate a _physics_process() ed è utilizzata da alcuni nodi internamente per garantire il loro corretto funzionamento, anche se il nodo è in pausa o il processo di fisica è disabilitato per gli script (set_physics_process()).
Attenzione: I nodi integrati si basano sull'elaborazione interna per la loro logica interna. Disabilitarla non è sicuro e potrebbe portare a comportamenti imprevisti. Utilizza questo metodo se sai cosa stai facendo.
void set_process(enable: bool) 🔗
Se impostato su true, abilita il processo. Quando un nodo viene processato, riceverà una NOTIFICATION_PROCESS su ogni frame disegnato (e verrà chiamato il callback _process() se esiste).
Nota: Se _process() è sovrascritto, questo sarà automaticamente abilitato prima che _ready() sia chiamato.
Nota: Questo metodo influisce solo sul callback _process(), ovvero non ha effetto su altri callback come _physics_process(). Se vuoi disabilitare tutta l'elaborazione per il nodo, imposta process_mode su PROCESS_MODE_DISABLED.
void set_process_input(enable: bool) 🔗
Se impostato su true, abilita l'elaborazione degli input.
Nota: Se _input() è sovrascritto, questo sarà automaticamente abilitato prima che _ready() sia chiamato. L'elaborazione degli input è inoltre già abilitata per i controlli della GUI, come Button e TextEdit.
void set_process_internal(enable: bool) 🔗
Se impostato su true, abilita il processo interno per questo nodo. Il processo interno avviene in modo isolato dalle normali chiamate a _process() ed è utilizzato da alcuni nodi internamente per garantire il loro corretto funzionamento, anche se il nodo è in pausa o il processo è disabilitato per gli script (set_process()).
Attenzione: I nodi integrati si basano sull'elaborazione interna per la loro logica interna. Disabilitarla non è sicuro e potrebbe portare a comportamenti imprevisti. Utilizza questo metodo se sai cosa stai facendo.
void set_process_shortcut_input(enable: bool) 🔗
Se impostato su true, abilita l'elaborazione delle scorciatoie per questo nodo.
Nota: Se _shortcut_input() è sovrascritto, questo sarà automaticamente abilitato prima che _ready() sia chiamato.
void set_process_unhandled_input(enable: bool) 🔗
Se impostato su true, abilita l'elaborazione degli input non gestiti. Consente al nodo di ricevere tutti gli input che non sono stati gestiti in precedenza (solitamente da un Control).
Nota: Se _unhandled_input() è sovrascritto, questo sarà automaticamente abilitato prima che _ready() sia chiamato. L'elaborazione degli input non gestiti è inoltre già abilitata per i controlli della GUI, come Button e TextEdit.
void set_process_unhandled_key_input(enable: bool) 🔗
Se impostato su true, abilita l'elaborazione degli input di tasti non gestiti.
Nota: Se _unhandled_key_input() è sovrascritto, questo sarà automaticamente abilitato prima che _ready() sia chiamato.
void set_scene_instance_load_placeholder(load_placeholder: bool) 🔗
Se impostato su true, il nodo diventa un InstancePlaceholder quando è impacchettato e istanziato da una PackedScene. Vedi anche get_scene_instance_load_placeholder().
void set_thread_safe(property: StringName, value: Variant) 🔗
Simile a call_thread_safe(), ma per impostare le proprietà.
void set_translation_domain_inherited() 🔗
Fa in modo che questo nodo erediti il dominio di traduzione dal suo nodo genitore. Se questo nodo non ha un genitore, verrà utilizzato il dominio di traduzione principale.
Questo è il comportamento predefinito per tutti i nodi. Chiamare Object.set_translation_domain() disabilita questo comportamento.
void update_configuration_warnings() 🔗
Aggiorna gli avvisi visualizzati per questo nodo nel pannello di Scena. Usa _get_configuration_warnings() per personalizzare i messaggi di avviso da visualizzare.