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...

Processo di inattività e di fisica

I giochi sono eseguiti in ciclo. A ogni frame, è necessario aggiornare lo stato del mondo di gioco prima di visualizzarlo sullo schermo. Godot fornisce due metodi virtuali nella classe Node per farlo: Node._process() e Node._physics_process(). Se si definisce uno o entrambi in uno script, il motore li chiamerà automaticamente.

Sono disponibili due tipi di processo:

L'elaborazione di inattività (idle processing) consente di eseguire codice che aggiorna un nodo a ogni frame, il più spesso possibile.
L'elaborazione fisica avviene a una velocità fissa, normalmente 60 volte al secondo. Questo è indipendente dal frame rate effettivo del gioco, e ciò fa funzionare la fisica in maniera fluida. Si dovrebbe usare per qualsiasi cosa che coinvolga il motore di fisica, come il movimento di un corpo che entra in collisione con l'ambiente.

Il processo d'inattività si attiva definendo il metodo _process() in uno script. Può essere attivato o disattivato con la funzione Node.set_process().

Il motore chiama questo metodo ogni volta che disegna un frame:

func _process(delta):
    # Do something...
    pass

public override void _Process(double delta)
{
    // Do something...
}

È importante tenere a mente che la frequenza con cui il motore chiama _process() dipende da quanti fotogrammi al secondo (FPS) è in esecuzione la propria applicazione, il che varia nel tempo e tra i dispositivi.

Il parametro delta della funzione è il tempo trascorso in secondi dalla precedente chiamata a _process(). Utilizzare questo parametro per effettuare calcoli indipendenti dal frame rate. Ad esempio, di dovrebbe sempre moltiplicare un valore di velocità per delta per animare un oggetto in movimento.

Il processo di fisica funziona con una funzione virtuale simile: _physics_process(). Si usa per i calcoli che è necessario eseguire prima di ogni passaggio fisico, come lo spostamento di un personaggio che entra in collisione con il mondo di gioco. Come accennato in precedenza, _physics_process() viene eseguito a intervalli di tempo fissi il più possibile per mantenere stabili le interazioni fisiche. È possibile modificare l'intervallo tra i passaggi fisici nelle Impostazioni del progetto, in Fisica -> Comuni -> FPS di fisica. Come valore predefinito, è impostato per eseguirsi 60 volte al secondo.

Il motore chiama questo metodo prima di ogni passo di fisica:

func _physics_process(delta):
    # Do something...
    pass

public override void _PhysicsProcess(double delta)
{
    // Do something...
}

La funzione _process() non è sincronizzata con la fisica. La sue frequenza non è costante e dipende dall'hardware e dall'ottimizzazione del gioco. Viene eseguita dopo il passaggio di fisica nei giochi a thread singolo.

Si può vedere la funzione _process() al lavoro creando una scena con un singolo nodo Label, a cui si allega il seguente script:

extends Label

var time = 0

func _process(delta):
    time += delta
    text = str(time) # 'text' is a built-in Label property.

using Godot;

public partial class CustomLabel : Label
{
    private double _time;

    public override void _Process(double delta)
    {
        _time += delta;
        Text = _time.ToString(); // 'Text' is a built-in Label property.
    }
}

Quando la scena viene eseguita, sarà visualizzato un contatore che incrementa a ogni frame.