Cave : Guide pour débutants

Dans la leçon précédente, vous avez appris comment Python peut contrôler des entités pendant le gameplay. Mais Python dans Cave n'est pas limité 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.

C'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 scène. Au lieu de tout faire à la main à 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 pour vous permettre de générer des niveaux de manière procédurale, des bâtiments procéduraux, et bien plus encore.

Dans cette leçon, vous allez apprendre:

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

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

Scripts de Gameplay vs Outils d'Éditeur

En résumé:

• Scripts de Gameplay s'exécutent pendant que le jeu est en cours.
• Outils d'Éditeur s'exécutent dans l'éditeur pour vous aider à travailler sur le projet.

Par exemple, un script d'ouverture de porte est une logique de gameplay car le joueur doit l'expérimenter pendant qu'il joue au jeu. Un outil qui place dix torches le long d'un couloir est une logique d'éditeur car il vous aide à construire le niveau, mais il n'a pas besoin d'exister dans le jeu exporté.

Pourquoi les Outils d'Éditeur Sont Utiles

Au début, des outils personnalisés peuvent sembler être quelque chose dont seules les grandes équipes ont besoin.

Mais même les développeurs solitaires peuvent bénéficier de petits outils car ils réduisent le travail manuel répétitif. Si vous faites la même tâche plusieurs fois, un simple script d'éditeur peut rendre le projet beaucoup plus rapide à travailler.

Les outils d'éditeur peuvent aider avec des choses comme:

• Placer des groupes d'entités.
• Vérifier si des composants requis sont manquants.
• Créer des configurations de scène communes.
• Imprimer des informations de débogage.
• Tester des valeurs sans entrer en mode Play.
• Aider les concepteurs à ajuster les données de gameplay.

Par exemple, imaginez que vous construisiez un jeu à la troisième personne avec de nombreux camps ennemis. Au lieu de créer manuellement la même structure de dossiers à chaque fois, vous pourriez créer un outil qui ajoute automatiquement un Groupe Ennemi, 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é à un usage dans l'éditeur.

Cela importe car les outils d'éditeur peuvent utiliser des API ou un comportement qui n'a de sens que dans l'éditeur. Vous ne voulez généralement pas qu'un assistant de conception de niveau ou un panneau de débogage fassent partie de l'exécution finale de votre jeu.

C'est aussi important pour indiquer à Cave quels scripts exécuter au démarrage du jeu et quels scripts ignorer. Par défaut, tous les scripts sont exécutés, donc si vous souhaitez qu'un script soit ignoré, il doit inclure ce commentaire comme première ligne.

Donc, si vous créez un script qui n'existe que pour vous aider à travailler dans l'Éditeur Cave, faites-le uniquement pour l'éditeur.

Outils d'Onglet d'Éditeur

Un moyen courant de créer un outil est avec un Onglet d'Éditeur.

Un onglet d'éditeur est un panneau personnalisé qui apparaît dans l'Éditeur Cave. Il a une méthode draw(), et Cave appelle cette méthode pendant que l'onglet est visible afin que l'outil puisse dessiner des boutons, du texte, des propriétés et d'autres contrôles.

Un très petit onglet d'éditeur ressemble à ceci:

#editoronly
import cave

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

    def draw(self):
        cave.ui.text("Ceci est un outil d'exemple.")
        cave.ui.separator()

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

        if cave.ui.buttonDark("Augmenter le compteur +1"):
            self.counter += 1
            print("Compteur augmenté de +1")

C'est aussi le code par défaut lorsque vous ajoutez un onglet d'éditeur. Si vous cliquez pour l'ouvrir dans l'onglet de propriétés puis allez à l'onglet des outils d'éditeur, vous verrez la classe d'onglet d'exemple apparaissant comme un onglet de débogage. Alors tout ce que vous avez à faire est d'enregistrer ou de recharger l'onglet et il sera disponible pour vous dans l'UI:

Cet exemple est simple, mais il 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() dessine du texte.
• cave.ui.prop() dessine une propriété éditable.
• cave.ui.buttonDark() crée un bouton.
• print() peut être utilisé pour envoyer des informations à la console.

C'est ainsi que créer des Outils personnalisés pour l'Éditeur Cave est simple. Vous pouvez utiliser cette même structure pour construire de véritables outils plus tard.

Que signifie la méthode draw()

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

Elle est appelée à plusieurs reprises pendant que l'outil est visible, car l'UI 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("Assistant de niveau:")

    if cave.ui.buttonDark("Créer un Groupe Ennemi"):
        print("Créer un groupe d'ennemis cliqué")

Le bouton est dessiné chaque fois que l'onglet se met à jour, mais le code à l'intérieur de if ne s'exécute que lorsque l'utilisateur clique sur le bouton.

Ce modèle est très courant dans les outils d'éditeur.

Une Idée d'Outil Pratique

Supposons que vous construisiez un niveau et que vous ayez souvent besoin des mêmes dossiers de base:

• Environnement
• Ennemis
• Déclencheurs de Gameplay
• Éclairage
• Audio
• Aides de Débogage

Vous pourriez créer un outil d'éditeur avec un bouton appelé Créer des Dossiers de Niveau. Lorsqu'il est cliqué, il pourrait créer ces entités de dossier dans la scène actuelle. N'oubliez pas : un dossier dans le Graphique de Scène est juste une Entité sans composants qui lui sont attachés.

Cela peut sembler petit, mais de petits outils comme celui-ci facilitent l'organisation des grands projets. Ils vous aident aussi à suivre vos propres conventions de projet sans avoir à vous souvenir de chaque étape manuellement.

Composants de l'Éditeur

Parfois, vous voulez mélanger la logique de gameplay avec la logique d'éditeur. Par exemple, vous pouvez avoir un composant attaché à une entité qui exécute également une logique d'éditeur, par exemple, pour afficher des informations de débogage ou une sphère de débogage indiquant la portée de mouvement 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é a besoin d'un comportement d'éditeur spécial, mais que ce comportement ne doit pas faire partie du jeu réel.

Par exemple:

• Un point de génie pourrait dessiner des informations d'aide dans l'éditeur.
• Un volume de déclenchement pourrait exposer des contrôles de débogage.
• Un marqueur de niveau pourrait valider s'il est configuré correctement.

L'idée importante est que les scripts d'éditeur sont pour le flux de travail autour de la création du jeu. Les scripts de gameplay sont pour le jeu lui-même.

IMPORTANT : Dans ce cas, le comportement est un peu différent d'un composant régulier, car puisque c'est un composant d'éditeur, il aura une méthode de mise à jour d'éditeur qui sera appelée à chaque image pendant que l'éditeur fonctionne et que le jeu ne l'est pas. Mais, et c'est la différence la plus importante, ce composant sera en fait enregistré, initialisé et démarré avec l'entité elle-même, que ce soit en mode jeu ou non. Donc, si vous mettez une logique dans la méthode start de ce composant, elle sera appelée même en dehors du mode jeu.

Cela peut potentiellement être dangereux, par exemple : si vous mettez une logique dans la méthode start d'un composant d'éditeur qui obtient toutes les entités dans la scène et les supprime, alors votre jeu sera entièrement supprimé dans l'éditeur de manière destructive (sans possibilité de retour en arrière). Ce n'est pas une erreur, ce n'est pas un bug, c'est ainsi que ça fonctionne par conception. Donc, soyez conscient de cela.

Si vous voulez une manière plus sûre de faire cela, vous pouvez utiliser le Composant de Code Python, car il a effectivement une méthode de mise à jour d'éditeur, et le fait d'avoir cette mise à jour d'éditeur écrite n'interférera pas avec les mises à jour de début et de fin qui seront appelées dans l'éditeur ou non (elles ne le seront pas). Vérifiez l'Ennemi dans le projet initial que Cave crée, car il utilise le Composant de Code Python pour dessiner une sphère de débogage autour des ennemis, indiquant le rayon dans lequel ils peuvent se déplacer. C'est une bonne manière d'en apprendre davantage à ce sujet.

Quand Devriez-vous Créer un Outil ?

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

Créez un outil lorsqu'il résout un véritable problème de flux de travail, tel que:

• Vous répétez la même tâche plusieurs fois.
• Une configuration est facile à oublier.
• Une scène a besoin de validation.
• 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 est préférable de d'abord construire l'objet de jeu manuellement. Ensuite, 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 les outils d'éditeur.

Les scripts de gameplay contrôlent ce qui se passe pendant que le jeu est en cours d'exécution. Les scripts d'éditeur vous aident à construire, inspecter, déboguer ou organiser le projet dans l'Éditeur Cave.

Vous n'avez pas besoin d'outils d'éditeur pour créer votre premier jeu, mais ils sont puissants lorsque votre projet commence à croître. Un petit outil qui économise cinq minutes aujourd'hui peut en économiser des heures plus tard.