Des règles d’équipe peuvent transformer un roguelike de construction de dés en un jeu de décisions coopératives, mais elles touchent à l’attribution des dés, aux améliorations, aux relances, au choix des résultats, à l’état de la partie et à la génération aléatoire. Préservez d’abord la boucle existante qui consiste à lancer les dés, à les modifier puis à choisir un résultat. Définissez les éléments d’état à partager, ajoutez un seul mode coopératif au périmètre bien défini et comparez-le à une partie solo connue avant de modifier le reste du jeu.

Ce guide explique comment poursuivre un projet existant. Il ne rend pas compte d’une fonctionnalité déjà mise en œuvre. Les personnages, les règles, la partie d’exemple, la graine et les résultats des tests sont inventés. Aucun code source, aucune version jouable et aucune partie réelle n’étaient disponibles. Les vérifications ci-dessous sont donc des propositions qui restent à exécuter dans le projet réel.
Cartographier la boucle de jeu des dés et déterminer qui gère chaque élément d’état
Avant de modifier le code, créez une branche propre ou une copie du projet, puis consignez le déroulement actuel d’une partie. Suivez le lancer, la modification des dés, le choix du résultat, le paiement des coûts, la résolution de la rencontre et la mise à jour des récompenses. Identifiez le composant qui gère chaque valeur et déterminez si elle est conservée d’une salle, d’un étage, d’une partie ou d’une sauvegarde à l’autre. Si le jeu ne peut pas être lancé, distinguez ce que révèle la lecture du code de ce qui a été observé à l’exécution.
Pour chaque champ d’état, déterminez à quoi il est actuellement rattaché : un joueur, un dé, l’équipe, une rencontre ou la partie. Des règles coopératives peuvent prévoir une monnaie commune ou permettre aux joueurs de discuter d’une récompense, tout en laissant à chaque personnage ses propres dés et améliorations. L’attribution doit être explicite. Sinon, une relance ou une perte de ressource risque d’être comptabilisée deux fois ou de disparaître au changement de joueur actif.
| Élément d’état | Question d’attribution | Points à préserver dans le mode actuel |
|---|---|---|
| Dés et modifications | À qui appartiennent le dé et ses améliorations ? | Conserver le fonctionnement des lancers en solo |
| Coût d’une relance ou d’une modification | Réserve personnelle ou commune ? | Préserver l’ordre de paiement actuel |
| Choix du résultat | Le joueur actif, un vote ou un chef d’équipe ? | Conserver des options de résultat déterministes pour chaque scénario |
| Points de vie et récompenses | Total commun pour la partie ou valeur propre à chaque joueur ? | Préserver les sauvegardes de campagne existantes |
| Joueur actif | Qui agit et à quel moment le contrôle change-t-il de mains ? | Conserver la responsabilité de la résolution des rencontres |
Dans l’exemple fictif d’Ember Relay, l’équipe partage une ressource liée à l’itinéraire, chaque aventurier garde son propre ensemble de dés et le joueur actif propose un résultat. Les deux joueurs peuvent chacun dépenser une aide utilisable une fois par rencontre. Ces choix servent uniquement d’illustration. Dans un projet réel, partez du modèle d’attribution existant et apportez les changements strictement nécessaires pour obtenir la coopération souhaitée.
Préserver la séquence de lancer, de modification et de choix
Pour ajouter une option d’équipe, conservez le moteur de dés s’il fonctionne déjà. Gardez l’ordre actuel des opérations : lancer les dés, modifier les faces, payer les coûts et choisir le résultat. Insérez la règle d’équipe au point précis où le jeu valide déjà une attribution ou un choix. Vous pourrez ainsi déterminer si un écart vient du déroulement des tours, de l’attribution des ressources ou de la logique existante de résolution des dés.

Consignez l’ordre de priorité des règles. Par exemple, une capacité peut permettre à un joueur de modifier son propre dé, puis un jeton d’équipe peut agir sur un résultat choisi. La rencontre se résout ensuite selon le résultat retenu. Précisez si un effet d’équipe s’applique avant ou après les améliorations personnelles, s’il peut se cumuler et ce qui se passe lorsque le dé ciblé est indisponible. Attendez d’avoir précisé le premier cas d’usage en équipe avant d’ajouter un système général de modificateurs pour de futurs modes.
La documentation de la version stable de Godot décrit la graine et l’état propres à chaque instance de RandomNumberGenerator. Elle précise qu’une même graine produit une suite pseudo-aléatoire reproductible. Cette possibilité propre au moteur ne prouve ni que le jeu concerné l’utilise, ni que son comportement reste déterministe d’une version du moteur à l’autre, ni que le jeu est équilibré. Examinez le générateur aléatoire que le jeu utilise réellement avant de choisir une stratégie de test. Distinguez les suggestions sur les jeux de données de test déterministes des affirmations vérifiées sur l’implémentation.
Définir un seul ensemble de règles d’équipe, simple et versionné
Séparez les données des règles de la logique d’exécution du jeu. Un ensemble de règles compact peut indiquer le mode, la version du schéma, le nombre de joueurs, l’ordre des tours, les règles d’attribution des ressources et de sélection du résultat, ainsi qu’une courte liste d’effets d’équipe pris en charge. Privilégiez les types énumérés explicites et les valeurs bornées plutôt que les scripts libres. Le moteur de règles doit rejeter les options qu’il ne reconnaît pas au lieu de les ignorer silencieusement.
Choisissez une valeur par défaut qui préserve le mode déjà disponible. Les règles d’équipe doivent s’activer sur demande et être stockées séparément de la progression de campagne existante, sauf si le cahier des charges prévoit explicitement une migration. Si les anciennes sauvegardes ne contiennent pas d’information sur le mode, documentez la valeur par défaut retenue pour assurer la compatibilité et testez-la sur des copies de sauvegardes. Le tutoriel de Godot sur les sauvegardes montre comment sélectionner et sérialiser des champs persistants dans un exemple propre à ce moteur. Il ne définit pas de modèle universel de sauvegarde d’une partie.
Pour les règles configurables ou créées par les utilisateurs, validez avant le lancement la version du schéma, les identifiants des joueurs, les règles d’attribution des ressources, les identifiants d’effets, les limites applicables aux tours et la présence des valeurs par défaut requises. Gardez les noms affichés distincts des identifiants de règles. Enregistrez les règles personnalisées comme brouillon et évitez de modifier les préréglages intégrés quand un joueur fait des essais.
Rendre les décisions coopératives visibles
Le jeu en équipe doit donner lieu à un véritable choix. Si un joueur décide toujours du résultat, l’autre risque de devenir spectateur. Si chaque choix exige un vote, la partie risque de s’enliser. Déterminez quand les joueurs peuvent se concerter, si le joueur actif valide le choix, si une règle permet de trancher les égalités et comment le jeu réagit à une déconnexion si le multijoueur existe déjà. Si le jeu propose uniquement des tours en local, ne promettez pas de mode coopératif en réseau.
Affichez les ressources communes et personnelles dans des groupes visuellement distincts. Avant l’utilisation d’un effet d’équipe, indiquez qui en paie le coût et quels dés ou quel résultat il peut affecter. Après la résolution, montrez ce qui a changé et à qui revient l’amélioration obtenue. Gardez le mode solo accessible. Si des règles propres à l’équipe apparaissent dans les menus du mode habituel, identifiez-les clairement.
Prévoir des changements minimaux et un retour en arrière
Demandez à l’IA d’examiner les fichiers réels et de proposer un correctif détaillé fichier par fichier avant toute modification. Une première étape pourrait inclure un modèle de données pour les règles, un point d’intégration pour la sélection du mode, un adaptateur pour gérer l’attribution à l’équipe lors du choix de résultat existant et des tests ciblés. Préservez les faces des dés, les algorithmes de modification, la logique centrale de résolution des rencontres, les paramètres d’équilibrage du mode solo et les mécanismes de lecture des anciennes sauvegardes, sauf si des éléments concrets du projet justifient un changement.
Définissez la liste des fichiers autorisés et exigez le diff complet. Des modifications imprévues qui touchent tous les dés, toutes les tables de récompenses, tous les gestionnaires de partie ou tous les modes existants doivent conduire à suspendre la mise en œuvre. Créez un commit de référence propre avant d’appliquer le correctif. Si la structure de données retenue pour l’équipe exige une migration des sauvegardes de campagne, traitez cette migration séparément et testez-la sur des copies. Évitez de l’intégrer à une modification de fonctionnalité qui n’a pas été revue.
| Périmètre probable | Ajout possible | À conserver par défaut |
|---|---|---|
| Règles | Une définition versionnée du mode équipe | Préréglage solo déjà disponible |
| Attribution | Associer les identifiants de ressources aux joueurs et à l’équipe | Règles de modification des dés |
| Choix | Une étape de décision d’équipe sur le résultat | Lancer de base et logique de résolution des rencontres |
| Sauvegarde | Champ de mode facultatif avec valeur de repli | Clés de progression existantes |
| Tests | Vérifications de l’attribution des ressources en équipe et tests de non-régression en solo | Tables de récompenses en production |
Tester les parties avec une graine et vérifier l’absence de régression en solo
Utilisez le mécanisme de test pris en charge par le projet réel. Si son générateur accepte une graine, consignez cette graine, la version du jeu, l’ordre des joueurs et les actions. Sinon, utilisez des jeux de données de test déterministes ou une séquence documentée de dés de test. Évitez de supposer qu’une partie aléatoire peut être rejouée à l’identique. Obtenir le même lancer à l’écran n’est qu’un point de contrôle. Vérifiez aussi les modifications, le coût, l’identité de la personne qui choisit et l’état final.

| Vérification proposée | Action | Éléments à relever |
|---|---|---|
| Référence en solo | Jouer une séquence connue avec les règles existantes | Version exécutable, état de la partie, historique des lancers et des résultats |
| Attribution des ressources en équipe | Dépenser une ressource commune et utiliser une relance personnelle | Valeurs avant et après, identifiants des détenteurs |
| Ordre des tours | Inverser l’ordre des joueurs avec le même jeu de données de test | Ordre attendu et résultat choisi |
| Règles invalides | Charger des règles dont les identifiants sont absents ou inconnus | Rejet sans conséquence indésirable et message indiquant comment corriger le problème |
| Compatibilité des sauvegardes | Ouvrir une copie d’une ancienne sauvegarde solo | Comportement de repli documenté et progression préservée |
| Retour en arrière | Restaurer la branche de référence propre | Disponibilité de la boucle solo d’origine |
Cette matrice propose des tests à effectuer. Elle ne présente aucun résultat de test. Lors de l’exécution, consignez ce qui s’est réellement passé, ainsi que la version du projet, la version des règles, la graine ou le jeu de données de test, l’ordre des joueurs, l’état avant et après chaque choix et tout écart par rapport à la référence solo. L’image d’un tableau fictif ne permet de vérifier ni la reproductibilité du générateur aléatoire, ni l’attribution des ressources en équipe, ni l’équilibrage, ni la compatibilité des sauvegardes.
Fonder les affirmations sur l’équilibrage sur des observations
Un mode peut fonctionner de manière cohérente tout en donnant lieu à des décisions répétitives ou inéquitables. Avant de vous prononcer sur l’équilibrage, organisez des sessions de test avec des rôles, des configurations de dés et des types de rencontres représentatifs. Relevez quels joueurs participent aux décisions, si l’aide vaut son coût et si une ressource d’équipe rend une difficulté dérisoire. Une revue de code ou quelques exemples inventés ne suffisent pas à qualifier une configuration d’équilibrée.
Pour explorer un concept distinct de roguelike de construction de dés, essayez SEELE AI Game Maker. Cet outil sert à explorer des concepts et ne permet pas de modifier un projet existant.
Questions fréquentes
Que doivent définir les règles d’équipe d’un roguelike de dés ?
Définissez si les dés, les améliorations, les points de vie, la monnaie et les choix d’itinéraire relèvent de chaque joueur ou de l’équipe. Précisez qui choisit le résultat d’un lancer et comment les tours se résolvent. Commencez par une seule modification des règles pour introduire la coopération et veillez à ne pas mêler par inadvertance les ressources communes à la progression solo existante.
Comment préserver les mécaniques existantes de modification des dés ?
Prenez comme référence la séquence actuelle de lancer, de modification et de choix. Ajoutez les règles d’attribution à l’équipe à partir de l’état obtenu, sans remplacer les faces des dés ni les règles de relance. Comparez les résultats à ceux d’une partie solo connue et vérifiez que les choix, les coûts et les résultats restent cohérents après l’application du correctif.
Les coéquipiers doivent-ils partager une réserve de dés ou garder leurs propres dés ?
Faites votre choix en fonction du modèle d’attribution existant et du type de décision coopérative que vous souhaitez introduire. Une réserve commune peut favoriser la collaboration à chaque tour, tandis que des réserves distinctes préservent les configurations individuelles. Documentez comment s’appliquent les améliorations, les relances et les pertes, puis testez les deux ordres de passage des joueurs avant d’étendre les règles.
Comment tester les résultats de lancers de dés aléatoires ?
Utilisez des graines enregistrées ou un autre jeu de données de test déterministe pris en charge par le projet, si possible, et précisez où intervient le générateur aléatoire. Exécutez le même scénario avant et après la modification des règles d’équipe. Une séquence obtenue à partir d’une graine peut faciliter la reproduction d’un test, mais elle ne prouve ni l’équilibrage ni un comportement identique entre les versions du moteur.
L’IA peut-elle ajouter des règles coopératives à mon jeu de dés existant ?
L’IA peut examiner les fichiers fournis, retracer les changements d’état actuels et proposer un correctif au périmètre défini ainsi qu’une matrice de tests. Elle ne peut pas confirmer la compatibilité sans avoir accès à votre code et sans exécution de parties. Fournissez une liste des fichiers autorisés, une partie d’exemple, les règles d’attribution attendues et un commit de référence pour le retour en arrière, puis examinez chaque fichier modifié.
Ajouter le jeu en équipe à la boucle de dés existante
Commencez par déterminer à qui appartient chaque élément d’état, définissez un seul ensemble de règles d’équipe versionné et ajoutez une décision commune clairement définie tout en conservant la séquence actuelle de lancer, de modification et de choix. Préservez le mode solo et les anciennes sauvegardes. Sur une copie du projet, vérifiez l’état de l’équipe, l’ordre des joueurs et l’absence de régressions, puis conservez un moyen concret de revenir en arrière. Traitez les vérifications encore à effectuer et les exemples fictifs comme des propositions.


