Ajoutez des règles personnalisées sans remplacer votre système de combat de cartes

Ajoutez un éditeur local de règles à votre RPG de cartes, avec des limites explicites et une validation des données. Préservez la résolution des combats, les decks propres aux rôles, les modes intégrés et les sauvegardes existantes.

Seele Editorial TeamMis à jour 16 novembre 2026

Un éditeur de règles personnalisées peut diversifier les parties d’un RPG de combat de cartes, mais il touche de près à la validité des decks, aux rôles des personnages, aux effets des cartes, à la résolution des combats, à la progression et aux sauvegardes. Servez-vous-en pour proposer un choix structuré d’options prises en charge par le jeu, tout en conservant la logique de combat. Commencez par un éditeur local au périmètre restreint, validez ses données avant chaque partie et conservez les règles intégrées comme solution de repli par défaut.

L’éditeur de règles d’un RPG de combat de cartes fictif s’affiche à côté d’un aperçu de deux decks de personnages.
Ashens Archive ainsi que toutes les cartes et tous les modes présentés sont fictifs. Aucun combat n’a été lancé.

Ce guide s’adresse aux personnes qui souhaitent enrichir un RPG de cartes déjà fonctionnel. L’exemple, l’ensemble des cartes disponibles, les rôles des personnages et les résultats des tests sont inventés. Aucun dépôt de code, moteur de résolution des combats, jeu de données sur les decks, build ou test en conditions de jeu n’était disponible. Les tests proposés ci-dessous restent à exécuter et leur réussite reste à établir.

Documenter les règles actuelles avant d’ajouter des réglages

Créez un commit propre ou travaillez sur une copie distincte du projet. Consignez les règles intégrées et relevez comment une partie démarre, comment un deck est validé, quelles restrictions les rôles des personnages imposent aux cartes et quel service résout les tours et les effets. Notez où les règles et la progression sont sauvegardées. Si le jeu ne tourne pas en local, indiquez quel code vous avez examiné et laissez le comportement à l’exécution à vérifier.

Dressez la liste des invariants que l’éditeur doit préserver. Par exemple, le coût des cartes doit rester positif ou nul, chaque rôle doit conserver les familles de cartes qui lui sont autorisées, l’ordre des tours doit rester déterministe et le mode intégré doit garder sa configuration actuelle. Ces points sont à vérifier dans le projet concerné, car les règles varient d’un RPG de cartes à l’autre.

SystèmeÉléments à relever dans l’existantÀ préserver par défaut
Moteur de résolution des combatsComposant chargé des tours et des effets, ordre des événementsConserver ce moteur et éviter de dupliquer sa logique
Règles de composition des decksTaille, compatibilité avec les rôles, nombre maximal d’exemplairesConserver les contrôles de validité existants
Données des cartesChamps de coût, de cible et d’effet, ainsi que les identifiantsPréserver le catalogue de cartes à l’échelle du jeu
Modes et sauvegardesPréréglages intégrés, progression, schéma des sauvegardesStocker les brouillons personnalisés séparément

Demandez à l’IA d’examiner uniquement les fichiers effectivement fournis et de proposer un plan de modification fichier par fichier. Exigez qu’elle identifie les composants actuellement responsables de la validation des règles et de l’exécution des combats. Avant d’accepter une réécriture importante du code, assurez-vous de comprendre l’ordre de priorité des règles et les limites du périmètre de chaque ensemble de données.

Limiter le périmètre des règles personnalisables

Commencez par quelques options que le jeu existant sait déjà appliquer sans risque, comme la durée d’une partie, un préréglage de restrictions de deck ou une règle déjà prise en charge pour une famille de cartes. Pour chaque option, prévoyez un libellé clair, des valeurs autorisées et une valeur par défaut, puis précisez son interaction avec les rôles des personnages. Écartez de la première version les scripts arbitraires et l’accès à l’ensemble des champs numériques des cartes.

Dans l’exemple fictif d’Ashen Archive, un préréglage personnalisé local définit le plafond initial de ressources, le nombre maximal d’exemplaires d’une carte et l’autorisation ou l’interdiction d’une famille de cartes donnée. Cet exemple est purement pédagogique. Un projet réel peut ne pas prendre en charge ces réglages. Attendez que le système de combat définisse précisément le comportement associé à chacun avant de les ajouter.

Un panneau fictif de configuration des règles transmet les options validées à un processus distinct de résolution des combats de cartes.
Les données structurées des règles sont validées avant d’être utilisées par le système de combat existant.

Documentez explicitement l’ordre de priorité. Si un préréglage global limite l’utilisation d’une carte et qu’un rôle de personnage impose lui aussi une restriction, déterminez quelle règle s’applique et si les deux conditions doivent être remplies. Pour les dérogations propres à une carte, définissez les champs modifiables et gardez les identifiants des cartes stables. Définissez le comportement en partie indépendamment de l’ordre d’affichage des options dans l’éditeur.

Séparer les données des règles de la résolution des combats

Privilégiez un objet-valeur représentant l’ensemble de règles, lisible par le système actuel de préparation des parties et par les composants de validation. L’éditeur modifie ces données tandis que le moteur existant continue de gérer les tours et les effets. Cette séparation entre la configuration des règles et leur exécution en combat facilite la comparaison entre une partie personnalisée et une partie avec le préréglage par défaut.

Un enregistrement pourrait contenir une version du schéma, un identifiant de l’ensemble de règles, la version du jeu d’origine, les valeurs des options prises en charge et un nom d’affichage. Stockez uniquement des données et excluez les expressions exécutables. Laissez le jeu appliquer les options validées à l’aide des règles existantes. Si le moteur actuel ne sait pas interpréter une valeur, l’éditeur ne doit pas laisser entendre que son enregistrement suffit à produire l’effet attendu.

La documentation JSON de Godot explique comment analyser du texte JSON pour obtenir un Variant, puis comment sérialiser les données au format JSON. Son guide sur la gestion des fichiers à l’exécution présente FileAccess pour lire et écrire des fichiers, avec notamment des exemples de contenu fourni par l’utilisateur. Ces références attestent l’existence des API du moteur. Le schéma proposé ici reste un exemple, et ces références n’apportent ni garantie de sécurité ni démonstration d’une implémentation fonctionnelle d’Ashen Archive.

Pour les données créées par les joueurs, validez la version et chacun des champs avant utilisation. Rejetez les identifiants de règles inconnus, sauf si le projet prévoit une politique de compatibilité avec les versions futures. Appliquez les bornes minimale et maximale définies par le projet et exigez des identifiants de familles de cartes connus ainsi que des clés de rôles de personnages valides. Excluez l’instanciation de ressources arbitraires et l’exécution comme code du texte provenant d’un fichier de règles. Si le jeu prend en charge l’importation de contenu, testez ce parcours et documentez ses contraintes séparément.

Préserver les modes intégrés et les anciennes sauvegardes

Stockez les brouillons personnalisés à part des modes de référence et des données de progression. Lorsqu’un joueur modifie un préréglage, créez une copie pour éviter d’écraser l’original à son insu. Si le jeu propose des succès, des parties classées ou une campagne dont l’état est sauvegardé, distinguez les résultats des parties jouées avec des règles personnalisées. Indiquez explicitement si ces règles donnent accès à ces fonctionnalités.

Versionnez le schéma et indiquez la version du jeu d’origine. Lorsqu’un champ change, prévoyez une migration ou un refus de chargement clairement signalé. Testez ces deux cas avec des copies des sauvegardes existantes et des ensembles de règles créés par les joueurs. Pour un champ absent, utilisez une valeur susceptible d’influer sur l’équilibrage uniquement si le responsable du projet l’a définie comme valeur par défaut.

Cas de compatibilitéQuestion à trancherÉlément de vérification
Ancien fichier de règles personnaliséesCette version du schéma peut-elle être migrée ?Copie du fichier de test réalisée avant la migration
Option manquanteExiste-t-il une valeur par défaut documentée ?Application de la valeur par défaut vérifiée par un test
Famille de cartes inconnueFaut-il refuser le chargement ou afficher un avertissement ?Erreur visible, sans substitution silencieuse
Préréglage intégréL’édition peut-elle modifier la valeur fournie avec le jeu ?Empreinte ou copie du préréglage d’origine
Résultat d’une partie personnaliséeA-t-il un effet sur la campagne ou le classement ?Règle explicite pour ce mode

Développer uniquement le parcours initial de l’éditeur

Une interface minimale doit proposer la liste des réglages pris en charge, un aperçu des règles qui seront appliquées, un récapitulatif de la validation et des commandes pour enregistrer sous un autre nom, dupliquer et rétablir les valeurs par défaut. Indiquez quelles contraintes découlent du rôle de personnage sélectionné. Si l’option choisie est incompatible avec un rôle ou un ensemble de cartes, expliquez le conflit avant le lancement de la partie pour éviter un échec en plein combat.

Utilisez des unités claires et imposez des limites aux valeurs saisies. Réservez les libellés « équilibré » ou « compétitif » aux options pour lesquelles le projet dispose d’éléments qui les justifient. Proposez un ensemble de règles par défaut qui reproduit le comportement de la version distribuée et permettez d’y revenir facilement. Masquez les champs avancés tant que le jeu à l’exécution, l’interface et les tests ne peuvent pas les prendre en charge.

L’interface fictive de l’illustration générée est une simple maquette visuelle. Elle ne présente ni éditeur de règles réel, ni données de jeu réelles, ni validation achevée. Dans le projet réel, respectez les conventions d’interface existantes et réutilisez le service de gestion des règles déjà en place.

Prévoir une modification minimale et un retour en arrière

Notez quels fichiers peuvent être modifiés avant d’accepter le code. Une première intervention ciblée pourrait couvrir un écran d’édition, un modèle ou un adaptateur pour l’ensemble de règles, un point d’entrée pour la validation, un service d’enregistrement local des brouillons et des tests ciblés. Préservez le moteur de résolution des combats, l’intégralité de la base de données des cartes, la logique des rôles de personnages, les préréglages intégrés et le lecteur de sauvegardes de campagne, sauf si l’examen du projet révèle une dépendance qui exige de les modifier.

Examinez l’intégralité du diff. Demandez à l’IA d’expliquer chaque fichier modifié et de signaler tout changement apporté aux valeurs par défaut, à l’ordre des événements, aux valeurs des cartes ou aux points d’intégration de la progression. Comparez les modifications à la liste des éléments autorisés. Si la tâche s’étend au rééquilibrage de toutes les cartes ou à la refonte du système de combat, interrompez cette intervention et traitez ces travaux séparément, avec leur propre périmètre.

Travaillez sur une branche dédiée ou une copie propre. Avant toute migration, conservez un exemplaire du préréglage par défaut et une copie de chaque ancien fichier de règles. Si un ensemble de règles personnalisé modifie un mode existant ou qu’un deck connu devient inopinément invalide, revenez à l’état de référence et réduisez le périmètre des modifications. Prévoyez une opération concrète dans votre outil de gestion de versions pour revenir en arrière.

Tester les interactions entre les règles sur des copies

Testez chaque option séparément avant de tester les combinaisons. Vérifiez ensuite les interactions entre les restrictions globales, les règles de deck propres aux rôles, les limites du nombre d’exemplaires et les paramètres de partie. Couvrez les cas suivants : une partie personnalisée valide, un deck invalide, une valeur non prise en charge, un ancien schéma, un champ manquant et le rétablissement du préréglage intégré. Exécutez ces tests dans le projet réel avant d’affirmer que les règles sont compatibles ou équilibrées.

La maquette d’un RPG de cartes fictif affiche des scénarios de test de parties, des decks propres aux rôles et un point de réinitialisation pour tester les règles.
Cette illustration montre uniquement comment planifier les tests. Aucun test n’a porté sur l’équilibrage, la validité des decks ou l’issue des parties.
Vérification proposéeActionÀ consigner
Non-régression des règles par défautLancer une partie connue avec les règles intégréesBuild, préréglage, decks, déroulement observé dans le moteur de résolution
Compatibilité avec les rôlesUtiliser une carte soumise à restriction avec chaque rôle de personnageRésultat de la validation et explication
BornesSaisir des valeurs hors des limites autoriséesRejet, correction et absence de ramenée silencieuse aux bornes
Contenu mal forméCharger des fichiers comportant des champs manquants, invalides ou propres à des versions futuresRefus sans risque et message d’erreur indiquant comment corriger le problème
Migration des sauvegardesCharger une copie d’un ancien ensemble de règles personnaliséMigration ou refus documenté
Retour en arrièreRestaurer la branche de référence dans son état propreLes modes par défaut fonctionnent comme auparavant

Ce tableau présente les tests à effectuer. Pour chaque test, consignez la version du jeu, la version de l’ensemble de règles, les rôles des personnages, les identifiants des decks, l’action effectuée, le comportement attendu, le comportement observé et tout écart. Pour établir qu’une combinaison de règles est équitable ou qu’une ancienne sauvegarde se charge toujours, une maquette ne suffit pas.

Questions fréquentes

Quels réglages un éditeur de règles personnalisées doit-il proposer ?

Proposez uniquement les options de partie que le système de combat existant peut appliquer sans risque, comme un nombre maximal de tours ou quelques restrictions documentées sur les cartes. Gardez les valeurs lisibles et fixez-leur des limites. La première version de l’éditeur doit préserver le cœur du moteur de résolution, la progression des personnages et éviter de donner la main sur tous les effets des cartes.

Comment éviter que les règles personnalisées ne perturbent les combats de cartes ?

Conservez le moteur de résolution actuel comme référence et transmettez-lui un objet de règles validé. Définissez l’ordre de priorité lorsque les règles globales, les rôles des personnages et le texte des cartes interagissent. Testez une partie connue avec les règles par défaut, puis comparez le résultat après l’ajout de l’éditeur.

Faut-il laisser les joueurs modifier toutes les valeurs des cartes ?

Commencez par une courte liste d’options autorisées et prises en charge. Dans cette première version, écartez la saisie libre des dégâts et des coûts ainsi que les scripts d’effets arbitraires. Fixez des bornes aux valeurs numériques et rejetez les combinaisons non prises en charge. Ajoutez un réglage uniquement si le jeu définit clairement la règle correspondante et dispose d’un cas de test pour ses interactions.

Comment enregistrer et mettre à jour les ensembles de règles personnalisées ?

Utilisez un format de données versionné, indiquez la version du jeu d’origine et stockez les règles créées par les joueurs séparément des préréglages intégrés. Validez les champs avant le chargement et prévoyez une procédure claire pour migrer ou refuser les anciennes données. Testez les modifications sur une copie pour préserver les sauvegardes existantes et les modes officiels.

L’IA peut-elle équilibrer les règles personnalisées de mon jeu de cartes ?

L’IA peut aider à examiner les règles fournies, à recenser les interactions et à formuler des cas de test. Pour démontrer l’équilibre, il faut disposer de l’ensemble réel des cartes, de la logique de combat et de données de jeu. Traitez les valeurs générées comme des propositions. Examinez l’intégralité du diff et jouez des parties représentatives avant de partager un ensemble de règles.

Ajouter des options de règles sans remplacer le système de combat

Documentez le comportement des règles intégrées, proposez une courte liste de réglages autorisés, validez un enregistrement de données versionné et transmettez uniquement les valeurs prises en charge au moteur de résolution des combats existant. Stockez les brouillons personnalisés séparément des préréglages intégrés et des anciennes sauvegardes. Examinez l’intégralité du diff, testez sur des copies et conservez un état de référence propre auquel revenir avant d’affirmer que l’éditeur fonctionne.

Pour explorer un concept distinct de RPG de combat de cartes, essayez SEELE AI Game Maker. Cet outil sert à explorer des concepts de jeu et ne permet pas de modifier un projet existant.

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