Ajouter des règles d’équipe sans modifier les choix liés aux dés

Ajoutez un mode coopératif à un roguelike de construction de dés tout en préservant les dés modifiés, les choix de résultats, l’état de la partie et les règles du mode solo. Préparez un correctif réversible et testable.

Seele Editorial TeamMis à jour 16 novembre 2026

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.

Deux aventuriers fictifs comparent une réserve commune de dés et leurs pistes d’amélioration individuelles avant une partie de roguelike.
Ember Relay, ses joueurs et ses dés sont fictifs. Aucun jeu n’a été testé.

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’étatQuestion d’attributionPoints à 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 modificationRéserve personnelle ou commune ?Préserver l’ordre de paiement actuel
Choix du résultatLe 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écompensesTotal commun pour la partie ou valeur propre à chaque joueur ?Préserver les sauvegardes de campagne existantes
Joueur actifQui 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.

Un déroulement de jeu fictif montre un lancer de dés, une étape de modification et un choix de résultat commun à l’équipe.
Les joueurs peuvent se coordonner tout en conservant la séquence actuelle de lancer, de modification et de choix.

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 probableAjout possibleÀ conserver par défaut
RèglesUne définition versionnée du mode équipePréréglage solo déjà disponible
AttributionAssocier les identifiants de ressources aux joueurs et à l’équipeRègles de modification des dés
ChoixUne étape de décision d’équipe sur le résultatLancer de base et logique de résolution des rencontres
SauvegardeChamp de mode facultatif avec valeur de repliClés de progression existantes
TestsVérifications de l’attribution des ressources en équipe et tests de non-régression en soloTables 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.

Une maquette de roguelike de dés fictif présente deux plateaux de joueur à côté d’une liste de vérifications et d’un repère distinct pour le mode solo.
Ce plan de test est fourni à titre d’illustration. Aucune suite de valeurs produite par le générateur aléatoire ni aucun comportement multijoueur n’ont été testés.
Vérification proposéeActionÉléments à relever
Référence en soloJouer une séquence connue avec les règles existantesVersion exécutable, état de la partie, historique des lancers et des résultats
Attribution des ressources en équipeDépenser une ressource commune et utiliser une relance personnelleValeurs avant et après, identifiants des détenteurs
Ordre des toursInverser l’ordre des joueurs avec le même jeu de données de testOrdre attendu et résultat choisi
Règles invalidesCharger des règles dont les identifiants sont absents ou inconnusRejet sans conséquence indésirable et message indiquant comment corriger le problème
Compatibilité des sauvegardesOuvrir une copie d’une ancienne sauvegarde soloComportement de repli documenté et progression préservée
Retour en arrièreRestaurer la branche de référence propreDisponibilité 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.

Sources

SEELE AI

Transformez ce guide en projet jouable.

Commencez par un brief précis, puis développez votre idée dans Seele AI Workspace.

Commencer à créer