Singletons (Chargement Automatique)

Introduction

Bien que puissant et flexible, le gestionnaire de scène de Godot présente un inconvénient : il n’y a pas de moyen de stocker de l’information (comme le score d’un joueur ou son inventaire) nécessaire à plusieurs scènes.

Il est possible de résoudre ceci à l’aide de contournements, mais ceux-ci ont leur propres limites :

  • Vous pouvez utiliser une scène « maître » qui charge et décharge d’autres scènes comme ses enfants. Toutefois, cela signifie que vous ne pouvez plus exécuter ces scènes individuellement et vous attendre à ce qu’elles fonctionnent correctement.
  • Bien que des informations puissent être enregistrées sur le disque dans user:// et ensuite qu’elles puissent être chargées par les scènes qui en ont besoin, sauvegarder et charger fréquemment des données peut être lourd et éventuellement lent.

Le ` Patron de Conception Singleton <https://fr.wikipedia.org/wiki/Singleton_(patron_de_conception)>`_ est un outil utile pour résoudre le cas d’utilisation courante où vous devez stocker des informations persistantes entre les scènes. Dans notre cas, il est possible de réutiliser la même scène ou classe pour plusieurs singletons, à condition qu’ils aient des noms différents.

En utilisant ce concept, vous pouvez créer des objets qui :

  • Sont toujours chargées, quelle que soit la scène qui est ouverte dans l’éditeur
  • Peut stocker des variables globales, telles que les informations du joueur
  • Peut s’occuper des changements de scènes et des transitions
  • Agit comme un singleton, puisque GDScript ne supporte pas les variables globales du fait de sa conception

Les nœuds Autoloading et les scripts répondent à ce besoin.

AutoLoad

Vous pouvez utiliser AutoLoad pour charger une scène ou un script qui hérite de Node. Note : lors du chargement automatique d’un script, un Nœud sera créé et le script y sera attaché. Ce nœud sera ajouté à la fenêtre d’affichage racine avant le chargement de toute autre scène.

../../_images/singleton.png

Pour charger automatiquement une scène ou un script, sélectionnez Projet -> Paramètres du projet depuis le menu puis allez à l’onglet AutoLoad.

../../_images/autoload_tab.png

Ici, vous pouvez ajouter un nombre illimité de scènes ou de scripts. Chaque entrée de la liste nécessite un nom, qui est assigné comme propriété ``nom`” du nœud. L’ordre des entrées telles qu’elles sont ajoutées à l’arborescence de scène globale peut être manipulé à l’aide des touches fléchées haut/bas.

../../_images/autoload_example.png

Cela veut dire que n’importe quel nœud peut accéder à un singleton appelé « PlayerVariables » avec :

var player_vars = get_node("/root/PlayerVariables")
player_vars.health -= 10
var playerVariables = (PlayerVariables)GetNode("/root/PlayerVariables");
playerVariables.Health -= 10; // Instance field.

Si la colonne « Activer » est cochée (vrai par défaut), vous pouvez simplement accéder directement au singleton :

PlayerVariables.health -= 10
// Static members can be accessed by using the class name.
PlayerVariables.Health -= 10;

Notez que les objets chargés automatiquement (scripts et/ou scènes) sont accessibles comme n’importe quel autre nœud dans l’arborescence de la scène. En fait, si vous examinez l’arborescence de la scène en cours d’exécution, vous verrez que les nœuds auto-chargés apparaissent :

../../_images/autoload_runtime.png

Sélecteur de scène personnalisé

Ce court tutoriel vous expliquera comment faire un sélecteur de scènes avec l’auto-chargement. Pour une sélection simple de scène, la méthode SceneTree.change_scene() class_SceneTree_method_change_scene> suffit (décrite dans:ref:doc_scene_tree), donc cette méthode convient pour des comportements plus complexes lorsqu’il s’agit de jongler entre les scènes.

D’abord télécharger le modèle à partir d’ici : autoload.zip , ensuite, l’ouvrir dans Godot.

Le projet contient deux scènes : Scene1.tscn et Scene2.tscn. Chaque scène contient une étiquette affichant le nom de la scène et un bouton avec son signal pressé() actif. Quand vous exécutez le projet, il démarre à Scene1.tscn. Cependant, appuyer sur le bouton ne fait rien.

Global.gd

Passez à l’onglet « Script » et créez un nouveau script appelé Global.gd. Assurez-vous qu’il hérite de `` Node`` :

../../_images/autoload_script.png

L’étape suivante consiste à ajouter ce script à la liste d’auto-chargement. Ouvrez Projet > Paramètres du projet dans le menu, allez dans l’onglet « AutoLoad » et sélectionnez le script en cliquant sur le bouton .. ou en tapant son chemin : res://Global.gd. Appuyez sur « Ajouter » pour l’ajouter à la liste d’auto-chargement :

../../_images/autoload_tutorial1.png

Maintenant, chaque fois que vous lancez n’importe laquelle de vos scènes, le script sera toujours chargé.

Revenant au script, il doit récupérer la scène en cours dans la fonction _ready (). La scène actuelle (celle avec le bouton) et `` global.gd`` sont des enfants de root, mais les nœuds auto-chargés sont toujours les premiers. Cela veut dire que le dernier enfant de root est toujours la scène chargée.

extends Node

var current_scene = null

func _ready():
    var root = get_tree().get_root()
    current_scene = root.get_child(root.get_child_count() - 1)
using Godot;
using System;

public class Global : Godot.Node
{
    public Node CurrentScene { get; set; }

    public override void _Ready()
    {
        Viewport root = GetTree().GetRoot();
        CurrentScene = root.GetChild(root.GetChildCount() - 1);
    }
}

La prochaine étape est la fonction de changement de scène. Cette fonction libère la scène en cours et la remplace par celle demandée.

func goto_scene(path):
    # This function will usually be called from a signal callback,
    # or some other function in the current scene.
    # Deleting the current scene at this point is
    # a bad idea, because it may still be executing code.
    # This will result in a crash or unexpected behavior.

    # The solution is to defer the load to a later time, when
    # we can be sure that no code from the current scene is running:

    call_deferred("_deferred_goto_scene", path)


func _deferred_goto_scene(path):
    # It is now safe to remove the current scene
    current_scene.free()

    # Load the new scene.
    var s = ResourceLoader.load(path)

    # Instance the new scene.
    current_scene = s.instance()

    # Add it to the active scene, as child of root.
    get_tree().get_root().add_child(current_scene)

    # Optionally, to make it compatible with the SceneTree.change_scene() API.
    get_tree().set_current_scene(current_scene)
public void GotoScene(string path)
{
    // This function will usually be called from a signal callback,
    // or some other function from the current scene.
    // Deleting the current scene at this point is
    // a bad idea, because it may still be executing code.
    // This will result in a crash or unexpected behavior.

    // The solution is to defer the load to a later time, when
    // we can be sure that no code from the current scene is running:

    CallDeferred(nameof(DeferredGotoScene), path);
}

public void DeferredGotoScene(string path)
{
    // It is now safe to remove the current scene
    CurrentScene.Free();

    // Load a new scene.
    var nextScene = (PackedScene)GD.Load(path);

    // Instance the new scene.
    CurrentScene = nextScene.Instance();

    // Add it to the active scene, as child of root.
    GetTree().GetRoot().AddChild(CurrentScene);

    // Optionally, to make it compatible with the SceneTree.change_scene() API.
    GetTree().SetCurrentScene(CurrentScene);
}

Avec: ref: Object.call_deferred () <class_Object_method_call_deferred>, la deuxième fonction ne sera exécutée que lorsque tout le code de la scène actuelle sera terminé. Ainsi, la scène en cours ne sera pas supprimée tant qu’elle est encore utilisée (c’est-à-dire que son code est toujours en cours d’exécution).

Enfin, nous devons remplir les fonctions de rappel vides dans les deux scènes :

# Add to 'Scene1.gd'.

func _on_Button_pressed():
    Global.goto_scene("res://Scene2.tscn")
// Add to 'Scene1.cs'.

public void OnButtonPressed()
{
    var global = (Global)GetNode("/root/Global");
    global.GotoScene("res://Scene2.tscn");
}

et

# Add to 'Scene2.gd'.

func _on_Button_pressed():
    Global.goto_scene("res://Scene1.tscn")
// Add to 'Scene2.cs'.

public void OnButtonPressed()
{
    var global = (Global)GetNode("/root/Global");
    global.GotoScene("res://Scene1.tscn");
}

Maintenant, si vous lancez le projet, vous pouvez basculer entre les deux scènes en appuyant sur le bouton.

Remarque: lorsque les scènes sont petites, la transition est instantanée. Cependant, si vos scènes sont plus complexes, leur affichage peut prendre un certain temps. Pour apprendre à gérer cela, consultez le tutoriel suivant : Background loading