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

Mettere in pausa i giochi e la modalità di processo

Introduzione

Nella maggior parte dei giochi è desiderabile, a un certo punto, interrompere il gioco per fare qualcos'altro, come prendersi una pausa o cambiare le opzioni. Implementare un controllo preciso su cosa può essere messo in pausa (e cosa no) richiede molto lavoro, quindi Godot fornisce un framework semplice per gestire la pausa.

Come funziona la pausa

Per mettere in pausa il gioco, è necessario impostare lo stato di pausa. Lo si fa assegnando true alla proprietà SceneTree.paused:

get_tree().paused = true

GetTree().Paused = true;

Doing this will cause two things. First, 2D and 3D physics will be stopped for all nodes. Second, the behavior of certain nodes will stop or start depending on their process mode.

Nota

I server di fisica si possono attivare mentre il gioco è in pausa usando i loro metodi set_active.

Modalità di processo

Ogni nodo in Godot ha una "Modalità di processo" che definisce quando è elaborato. È possibile trovarla e cambiarla nelle proprietà Node del nodo nell'ispettore.

È anche possibile cambiare la proprietà tramite codice:

func _ready():
    process_mode = Node.PROCESS_MODE_PAUSABLE

public override void _Ready()
{
    ProcessMode = Node.ProcessModeEnum.Pausable;
}

Ecco cosa ogni modalità indica a un nodo di fare:

Inherit: elaborazione che dipende dallo stato del genitore, del nonno, ecc. Il primo genitore che ha uno stato diverso da Inherit.
Pausable: elabora il nodo (e i suoi figli in modalità Inherit) solo quando il gioco non è in pausa.
WhenPaused: elabora il nodo (e i suoi figli in modalità Inherit) solo quando il gioco è in pausa.
Always: elabora il nodo (e i suoi figli in modalità Inherit) a prescindere da tutto. Che sia in pausa o meno, questo nodo sarà elaborato.
Disabled: il nodo (e i suoi figli in modalità Inherit) non sarà elaborato affatto.

Come predefinita, tutti i nodi hanno questa proprietà nello stato "Inherit". Se il genitore è impostato su "Inherit", verrà verificato il nonno e così via. Se non si trova uno stato in nessuno dei nonni, viene utilizzato lo stato di pausa nello SceneTree. Significa che, come predefinito, quando il gioco è in pausa, tutti i nodi saranno in pausa. Diverse cose accadono quando un nodo smette di elaborare.

Le funzioni _process, _physics_process, _input e _input_event non verranno chiamate. Tuttavia, i segnali continuano a funzionare e a far eseguire la funzione a cui sono connessi, anche se lo script di tale funzione è associato a un nodo che al momento non è in elaborazione.

I nodi di animazione metteranno in pausa l'animazione attuale, i nodi audio metteranno in pausa il flusso audio attuale e le particelle si metteranno in pausa. Queste riprenderanno automaticamente quando il gioco non sarà più in pausa.

È importante notare che, anche se un nodo è in elaborazione mentre il gioco è in pausa, la fisica NON funzionerà normalmente. Come già detto, questo è perché i server di fisica sono disattivati. I server di fisica si possono attivare mentre il gioco è in pausa usando i loro metodi set_active.

Esempio di menu di pausa

Comincia creando un pulsante che servirà per mettere in pausa il gioco.

Crea un menu contenente un pulsante di chiusura, imposta la Modalità di processo del nodo radice del menu su When Paused, poi nascondi il menu. Poiché la modalità di processo è impostata su When Paused sul nodo radice, tutti i suoi figli e nipoti erediteranno tale modalità. In questo modo, tutti i nodi del menu inizieranno l'elaborazione quando il gioco viene messo in pausa.

Allega uno script al nodo radice del menu, connetti il pulsante di pausa creato prima a un nuovo metodo nello script e, in quel metodo, metti in pausa il gioco e mostra il menu di pausa.

func _on_pause_button_pressed():
    get_tree().paused = true
    show()

private void OnPauseButtonPressed()
{
    GetTree().Paused = true;
    Show();
}

Infine, connetti il pulsante di chiusura del menu a un nuovo metodo nello script. All'interno di tale metodo, riprendi il gioco e nascondi il menu di pausa.

func _on_close_button_pressed():
    hide()
    get_tree().paused = false

private void OnCloseButtonPressed()
{
    Hide();
    GetTree().Paused = false;
}

Ora dovresti avere un menu di pausa funzionante.