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

Mettre en pause des jeux et le mode de traitement

Introduction

Dans la plupart des jeux, il est souhaitable, à un moment donné, d'interrompre le jeu pour faire autre chose, comme prendre une pause ou changer des options. La mise en œuvre d'un contrôle fin pour ce qui peut être interrompu (et ce qui ne peut pas) est beaucoup de travail, donc un cadre simple pour la pause est fourni dans Godot.

Comment fonctionne la pause

Pour activer le mode pause, l'état de pause doit être défini. Cela se fait en assignant true à la propriété SceneTree.paused :

get_tree().paused = true

GetTree().Paused = true;

Faire ceci causera deux choses. Premièrement, la physique 2D et 3D sera arrêtée pour tous les nœuds. Deuxièmement, le comportement de certains nœuds s'arrêtera ou commencera selon leur mode de traitement.

Note

Les serveurs de physique peuvent être rendus actifs pendant que le jeu est en pause en utilisant leurs méthodes set_active.

Modes de traitement

Each node in Godot has a "Process Mode" that defines when it processes. It can be found and changed under a node's Node properties in the inspector.

Vous pouvez aussi changer la propriété avec du code :

func _ready():
    process_mode = Node.PROCESS_MODE_PAUSABLE

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

Voici ce que chaque mode indique à un nœud :

Inherit : L'exécution dépend de l'état du parent, du grand-parent, etc. Le premier parent qui a un état n'étant pas Inherit.
Pausable: Process the node (and its children in Inherit mode) only when the game is not paused.
WhenPaused: Process the node (and its children in Inherit mode) only when the game is paused.
Always: Process the node (and its children in Inherit mode) no matter what. Paused or not, this node will process.
Disabled: The node (and its children in Inherit mode) will not process at all.

Par défaut, tous les nœuds ont cette propriété avec l'état "Inherit". Si le parent est défini sur "Inherit", alors le grand-parent sera vérifié, et ainsi de suite. En fin de compte, si un état ne peut être trouvé dans aucun des grands-parents, l'état de pause dans SceneTree est utilisé. Cela signifie que, par défaut, lorsque le jeu est mis en pause, chaque nœud sera mis en pause. Plusieurs choses se passent lorsqu'un nœud arrête le traitement.

The _process, _physics_process, _input, and _input_event functions will not be called. However signals still work and cause their connected function to run, even if that function's script is attached to a node that is not currently being processed.

Les nœuds d'animation vont mettre en pause leur animation actuelle, les nœuds audio vont mettre en pause leur flux audio actuel, et les particules vont se mettre en pause. Ils reprendront automatiquement quand le jeu ne sera plus en pause.

Il est important de noter que même si un nœud calcule pendant que le jeu est en pause, la physique ne marchera pas pour lui par défaut. Comme indiqué plus haut, c'est parce que les serveurs de physique sont éteints. Les serveurs de physique peuvent être rendus actifs pendant que le jeu est interrompu en utilisant leurs méthodes set_active.

Pause menu example

Start by creating a button that will be used to pause the game.

Create a menu containing a close button, set the Process Mode of the menu's root node to When Paused, then hide the menu. Since the process mode is set to When Paused on the root node, all its children and grandchildren will inherit that process mode. This way, all the nodes in the menu will start processing when the game is paused.

Attach a script to the menu's root node, connect the pause button created earlier to a new method in the script, and inside that method pause the game and show the pause menu.

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

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

Finally, connect the menu's close button to a new method in the script. Inside that method, unpause the game and hide the pause menu.

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

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

You should now have a working pause menu.