Dans la leçon précédente, vous avez appris comment Python peut contrôler les entités pendant le gameplay. Mais Python dans Cave ne se limite pas au jeu en cours d'exécution. Vous pouvez également l’utiliser pour créer des Outils d'Éditeur qui vous aident à construire votre jeu plus rapidement.

Ceci est particulièrement utile car de nombreux projets ont des tâches répétitives. Peut-être que vous placez souvent des ennemis, créez des points de contrôle, organisez des dossiers, testez des valeurs ou inspectez des données de la scène. Au lieu de tout faire manuellement à chaque fois, vous pouvez créer de petits outils qui automatisent certaines parties de votre flux de travail. Vous pouvez même créer des éditeurs plus avancés vous permettant de réaliser des niveaux générés procéduralement, des bâtiments procéduraux, et bien plus.

Dans cette leçon, vous apprendrez :

La différence entre les scripts de gameplay et les scripts d’éditeur.
À quoi peut servir un outil d’éditeur.
Comment un outil sous forme d’onglet d’éditeur est structuré.
Pourquoi le #editoronly est important.
Quand il vaut la peine de créer un outil personnalisé.

Vous n’avez pas besoin de créer des outils immédiatement en commençant, mais il est bon de savoir que ce système existe. C’est une des fonctionnalités qui devient plus précieuse à mesure que votre projet grandit.

Scripts de Gameplay vs Outils d'Éditeur

En résumé :

Les scripts de gameplay s’exécutent pendant que le jeu tourne.
Les outils d’éditeur s’exécutent dans l’éditeur pour vous aider à travailler sur le projet.

Type de Script	Où il s'exécute	Exemple
Script de Gameplay	Mode Jeu et Jeu Exporté.	Mouvement du joueur, IA ennemie, portes, objets à ramasser.
Outil d'Éditeur	Cave Editor.	Assistant de niveau, renommage par lots, inspecteur de scène, génération procédurale de bâtiments, outil de placement.

Par exemple, un script d’ouverture de porte est une logique de gameplay car le joueur doit la vivre en jouant. Un outil qui place dix torches le long d’un couloir est une logique d’éditeur car il aide à construire le niveau, mais il n’a pas besoin d’exister dans la version exportée du jeu.

Pourquoi les Outils d'Éditeur Sont Utiles

Au début, les outils personnalisés peuvent sembler nécessaires uniquement pour les grandes équipes.

Mais même les développeurs solos peuvent bénéficier de petits outils car ils réduisent le travail manuel répétitif. Si vous effectuez souvent la même tâche, un simple script d’éditeur peut faire paraître le projet beaucoup plus rapide à utiliser.

Les outils d’éditeur peuvent aider pour :

Placer des groupes d’entités.
Vérifier si des composants nécessaires manquent.
Créer des configurations de scène courantes.
Afficher des informations de débogage.
Tester des valeurs sans passer en Mode Jeu.
Aider les designers à ajuster les données de gameplay.

Par exemple, imaginez que vous créez un jeu en vue troisième personne avec de nombreux camps ennemis. Plutôt que de créer manuellement la même structure de dossier à chaque fois, vous pourriez créer un outil qui ajoute automatiquement un Enemy Group, quelques points d’apparition et une zone de déclenchement.

Scripts Uniquement pour l'Éditeur

Les scripts d’éditeur commencent généralement par cette ligne :

#editoronly

Cela indique à Cave que le script est destiné à être utilisé dans l’éditeur.

C’est important car les outils d’éditeur peuvent utiliser des API ou des comportements qui ne font sens que dans l’éditeur. Normalement, vous ne voulez pas qu’un assistant de level design ou un panneau de débogage fasse partie de votre runtime final du jeu.

Cela permet aussi à Cave de savoir quels scripts exécuter au démarrage du jeu et lesquels ignorer. Par défaut, il exécute tous les scripts, donc si vous voulez qu’un script soit ignoré, ce commentaire doit être ajouté en première ligne.

Ainsi, si vous créez un script qui existe uniquement pour vous aider à travailler dans Cave Editor, faites-le exclusif à l’éditeur.

Outils sous Forme d’Onglet d’Éditeur

Une façon courante de créer un outil est d’utiliser un Onglet d’Éditeur.

Un onglet d’éditeur est un panneau personnalisé qui apparaît dans Cave Editor. Il possède une méthode draw(), que Cave appelle tant que l’onglet est visible pour que l’outil puisse afficher boutons, texte, propriétés et autres contrôles.

Un onglet d’éditeur très simple ressemble à ceci :

#editoronly
import cave

class ExampleTab(cave.ui.DebugTab):
    def __init__(self):
        super().__init__()
        self.counter = 0

    def draw(self):
        cave.ui.text("This is a sample tool.")
        cave.ui.separator()

        self.counter = cave.ui.prop("Counter", self.counter)

        if cave.ui.buttonDark("Increase counter +1"):
            self.counter += 1
            print("Counter increased by +1")

C’est aussi le code par défaut quand vous ajoutez un onglet d’éditeur. Si vous l’ouvrez dans l’onglet propriétés, puis allez dans l’onglet outillage d’éditeur, vous verrez la classe d’exemple apparaître comme un onglet de débogage. Ensuite, il suffit d’enregistrer ou de recharger l’onglet pour qu’il soit disponible dans l’interface utilisateur :

Cet exemple est simple, mais montre déjà l’idée de base :

cave.ui.DebugTab crée un onglet d’éditeur personnalisé.
draw() définit ce que l’onglet affiche.
cave.ui.text() affiche du texte.
cave.ui.prop() affiche une propriété éditable.
cave.ui.buttonDark() crée un bouton.
print() peut envoyer des informations à la console.

Créer des outils personnalisés pour Cave Editor est ainsi très simple. Vous pouvez utiliser cette même structure pour construire de vrais outils plus tard.

À quoi Sert la Méthode `draw()`

La méthode draw() n’est pas comme start() dans un composant de gameplay.

Elle est appelée de manière répétée tant que l’outil est visible, car l’interface de l’éditeur doit être dessinée et mise à jour. Cela signifie que le code à l’intérieur de draw() doit décrire l’interface actuelle de l’outil.

Par exemple :

def draw(self):
    cave.ui.text("Level Helper:")

    if cave.ui.buttonDark("Create Enemy Group"):
        print("Create enemy group clicked")

Le bouton est dessiné à chaque mise à jour de l’onglet, mais le code dans le if ne s’exécute que lorsque l’utilisateur clique sur le bouton.

Ce schéma est très courant dans les outils d’éditeur.

Une Idée d’Outil Pratique

Imaginons que vous construisez un niveau et que vous avez souvent besoin des mêmes dossiers de base :

Environment
Enemies
Gameplay Triggers
Lighting
Audio
Debug Helpers

Vous pourriez créer un outil d’éditeur avec un bouton appelé Create Level Folders. Cliqué, il pourrait créer ces dossiers sous forme d’entités dans la scène actuelle. Rappel : un Dossier dans le Scene Graph est juste une Entité sans composants attachés.

Cela peut sembler petit, mais ces petits outils facilitent l’organisation de grands projets. Ils vous aident aussi à respecter vos conventions de projet sans devoir vous souvenir de chaque étape manuellement.

Composants d'Éditeur

Parfois, vous souhaitez mélanger la logique du gameplay et de l’éditeur. Par exemple, vous pouvez vouloir un composant attaché à une entité qui exécute aussi une logique d’éditeur, pour afficher des informations de débogage ou une sphère indiquant la portée de déplacement ou d’attaque d’un ennemi. Dans ce cas, au lieu d’utiliser cave.Component, vous utilisez cave.EditorComponent.

Ceci est utile lorsqu’une entité nécessite un comportement spécial dans l’éditeur, mais que ce comportement ne doit pas faire partie du jeu final.

Par exemple :

Un point d’apparition peut afficher des informations d’aide dans l’éditeur.
Un volume de déclenchement peut exposer des contrôles de débogage.
Un marqueur de niveau peut valider sa bonne configuration.

L’idée importante est que les scripts d’éditeur servent au flux de travail de création du jeu. Les scripts de gameplay servent au jeu lui-même.

IMPORTANT : Dans ce cas, le comportement est un peu différent d’un composant classique, car en tant que composant d’éditeur, il aura une méthode de mise à jour d’éditeur appelée à chaque frame tant que l’éditeur tourne et que le jeu ne joue pas. Mais, et c’est la différence la plus importante, ce composant est enregistré, initialisé et démarré avec l’entité elle-même, que le jeu soit en mode lecture ou non. Donc, si vous mettez une logique dans la méthode start de ce composant, elle sera appelée même hors du mode jeu.

Ceci peut potentiellement être dangereux, par exemple : si vous mettez une logique dans la méthode start d’un composant d’éditeur qui supprime toutes les entités de la scène, alors votre jeu sera entièrement supprimé dans l’éditeur de façon irréversible (sans possibilité d’annuler). Ce n’est pas un bug, c’est le fonctionnement prévu. Soyez-en conscient.

Pour une manière plus sûre de faire cela, vous pouvez utiliser le Python Code Component, car il dispose d’une méthode de mise à jour d’éditeur, et l’écriture de cette mise à jour d’éditeur n’interfère pas avec l’appel des méthodes start et end dans l’éditeur (elles ne sont pas appelées). Regardez l’ennemi dans le projet initial créé par Cave, il utilise le Python Code Component pour dessiner une sphère de débogage autour des ennemis, indiquant le rayon dans lequel ils peuvent se déplacer. C’est un excellent exemple pour apprendre.

Quand Faut-il Créer un Outil ?

Ne créez pas un outil personnalisé pour chaque petite action.

Créez un outil quand il résout un vrai problème de flux de travail, par exemple :

Vous répétez la même tâche plusieurs fois.
Une configuration est facile à oublier.
Une scène doit être validée.
Un designer a besoin d’une interface plus claire pour modifier des valeurs.
Un prototype a besoin de boutons de débogage rapides.

Pour un débutant, il vaut mieux d’abord créer l’objet de jeu manuellement. Puis, une fois que vous comprenez les étapes, vous pouvez automatiser la partie ennuyeuse.

Ce Que Vous Devriez Retenir

Python dans Cave peut être utilisé à la fois pour le gameplay et pour l’outillage d’éditeur.

Les scripts de gameplay contrôlent ce qui se passe pendant que le jeu tourne. Les scripts d’éditeur vous aident à construire, inspecter, déboguer ou organiser le projet dans Cave Editor.

Vous n’avez pas besoin d’outils d’éditeur pour faire votre premier jeu, mais ils sont très puissants quand votre projet commence à grandir. Un petit outil qui vous fait gagner cinq minutes aujourd’hui peut faire économiser des heures plus tard.

Cave : Guide de démarrage