Permettre la création de quêtes sans perturber les combats

Ajoutez la création de quêtes personnalisées à un action-RPG tout en préservant les combats, la progression des personnages, le déroulement des quêtes et les sauvegardes existantes. Commencez par la validation.

Seele Editorial TeamMis à jour 16 novembre 2026

Un éditeur de quêtes personnalisées peut enrichir un action-RPG au-delà des missions livrées avec le jeu, mais les données créées par les joueurs alimentent aussi les combats en temps réel, l’inventaire, la progression des personnages et les fichiers de sauvegarde. Partez du système d’exécution des quêtes déjà en place. Définissez un schéma de données restreint, validez le graphe de quête avant son lancement et faites passer les récompenses par les règles de progression existantes afin que l’éditeur n’écrive pas directement dans l’état du jeu.

Un concepteur fictif d’action-RPG dispose des fiches de quête à côté d’une carte de combat et de notes sur la progression des personnages.
Emberfall et sa quête sont fictifs. Aucun éditeur ni aucune version intégrant les combats n’ont été testés.

Cet article propose une fonctionnalité pour un action-RPG existant. L’éditeur, la quête, les ennemis, les récompenses et les résultats présentés ci-dessous sont inventés. Aucun code source, projet, build ni essai en jeu n’était disponible. La grille de validation décrit des vérifications à effectuer.

Cartographier le système de quêtes avant de créer un éditeur

Suivez le déroulement d’une quête livrée avec le jeu, de son lancement à sa sauvegarde, en passant par le suivi des objectifs, le déclenchement ou le référencement des rencontres, la progression des dialogues, l’attribution des récompenses et les conditions d’échec. Identifiez le service qui gère l’état des objectifs, puis les services responsables des combats, de l’inventaire, de l’expérience, des déblocages et des caractéristiques des personnages. Déterminez si les missions sont définies sous forme de données, de scènes, de scripts ou d’une combinaison de ces éléments. Relevez un exemple de chaque type de quête pris en charge avant de concevoir le nouveau format.

Repérez les points de passage entre les systèmes. Un objectif émet-il un événement lorsqu’un ennemi est vaincu ? Le joueur peut-il quitter une zone avant la fin d’une rencontre ? Les choix de dialogue modifient-ils un indicateur de quête ? Une récompense peut-elle être récupérée deux fois après le chargement d’un point de contrôle ? L’éditeur doit proposer uniquement les opérations que le système d’exécution existant peut réaliser de façon déterministe et sûre.

DomaineÉléments à examinerRéférence à conserver
État de la quêteIdentifiants des objectifs et transitionsSystème existant chargé de la progression
CombatÉvénements de début et de fin de rencontreSimulation des combats et règles régissant les ennemis
RécompensesAPI des objets, de l’XP et des déblocagesProgression des personnages et inventaire
DialogueConditions des choix et indicateursÉtat de dialogue existant
SauvegardesIdentifiants des quêtes, points de contrôle et migrationsIdentité stable des joueurs et des quêtes

Définir un modèle de données de quête aux possibilités limitées

Attribuez à chaque quête un identifiant stable, une version, un titre, une condition de départ, des objectifs, des actions prises en charge, un état d’achèvement et une définition de récompense assortie de limites. Donnez à chaque objectif un identifiant stable et des champs de saisie typés. Une action « vaincre une cible » peut référencer un groupe d’ennemis autorisé. Une action « interagir » peut référencer un objet doté d’un tag que le système d’exécution reconnaît déjà. Dans la première version de l’éditeur, excluez les scripts arbitraires et le code libre.

Dans Emberfall, un jeu fictif, un auteur crée une courte quête qui consiste à récupérer une lentille de signalisation dans un poste de guet en ruine. Le graphe commence par un déclencheur de dialogue, propose un choix d’itinéraire, référence une rencontre prise en charge, puis demande au joueur d’interagir avec un objet doté d’un tag. Cet exemple est entièrement fictif, jusque dans le fonctionnement des quêtes et la chaîne de production du contenu.

Précisez ce que le langage du graphe autorise. Les embranchements sont-ils permis ? Peut-on répéter des objectifs ? Que se passe-t-il si le joueur passe une rencontre facultative ? Si vous autorisez les cycles, définissez leur fonctionnement. Un graphe orienté acyclique simple, avec un chemin clair vers la fin de la quête, peut être plus facile à prévisualiser et à valider qu’un graphe sans restrictions. Faites ce choix en fonction des exigences du système d’exécution du jeu.

Le schéma d’un éditeur de quêtes fictif relie des nœuds d’objectif validés à une rencontre prise en charge et à un seul chemin d’attribution d’une récompense de progression.
Seuls les types d’objectifs et de récompenses pris en charge doivent être transmis au système d’exécution.

Valider les quêtes avant de les prévisualiser ou d’y jouer

Vérifiez la présence des champs obligatoires, l’unicité des identifiants, la prise en charge des types de nœuds, la validité des références, l’accessibilité des objectifs et l’existence d’au moins un chemin permettant de terminer la quête. Signalez les nœuds déconnectés, les cycles que le système d’exécution ne sait pas gérer, les identifiants de dialogue manquants, les groupes d’ennemis inconnus et les récompenses qui dépassent les plafonds configurés. Expliquez chaque erreur à l’endroit du nœud qui la provoque. Distinguez les avertissements, comme une branche facultative dépourvue de texte personnalisé, des erreurs qui rendent une quête risquée à exécuter ou impossible à terminer.

Lancez la validation lorsque l’auteur enregistre, importe ou prévisualise une quête. Un enregistrement réussi dans l’éditeur ne garantit pas que le système d’exécution pourra charger le fichier. Répétez la validation à l’entrée du système d’exécution et bloquez le lancement si un champ obligatoire est invalide. Une quête interprétée partiellement pourrait corrompre la progression. Affichez un message compréhensible en cas d’échec et conservez le fichier source pour que l’auteur puisse le corriger.

Dans sa documentation officielle, Godot décrit Resource comme une classe de base sérialisable qui sert principalement de conteneur de données et précise que les ressources peuvent être enregistrées sur disque. Si le projet utilise déjà Godot, c’est un exemple propre à ce moteur. Le format des quêtes créées par les joueurs reste à définir. Le tutoriel de Godot sur les sauvegardes présente une méthode de persistance dans laquelle les objets renvoient les données pertinentes pour la sérialisation et le chargement. Le choix du validateur, la sécurité des imports et les plafonds de récompense restent propres au jeu concerné.

Séparer la définition des quêtes de la progression du joueur

La définition d’une quête décrit ce qui peut arriver. La sauvegarde du joueur consigne ce qui est arrivé à un personnage donné. Stockez ces données séparément. Associez à chaque enregistrement de progression un identifiant de quête stable et une version, ainsi que les états des objectifs et les champs de point de contrôle dont le système d’exécution a besoin. Si un auteur met à jour une quête, décidez si la progression existante reste liée à l’ancienne version, migre vers la nouvelle ou repart de zéro.

Faites passer les récompenses par le service existant de progression des personnages. L’éditeur peut proposer une liste d’objets autorisés ou des valeurs comprises dans des limites définies, mais le service de progression doit vérifier les plafonds et appliquer le résultat une seule fois. Utilisez un identifiant de fin de quête stable pour qu’un rechargement ou un appel répété lié à un objectif ne puisse pas dupliquer l’expérience, la monnaie ou les objets uniques. Empêchez l’éditeur de modifier les formules de combat ou des attributs du personnage sans restriction.

Préservez le déroulement des quêtes livrées avec le jeu. Une quête personnalisée ne doit ni masquer un identifiant de quête officiel, ni écraser l’état de la campagne principale du joueur, ni remplacer une ressource de dialogue livrée avec le jeu. Si le jeu permet aux joueurs de partager leurs créations, traitez l’import et la modération de ces contenus séparément. La création locale de quêtes ne valide pas les fichiers externes.

DonnéesDéfinition ou progression ?Responsable
Graphe des objectifsDéfinitionContenu créé dans l’éditeur de quêtes
Objectif en coursProgression du joueurSystème d’exécution des quêtes ou service de sauvegarde
Référence de rencontreDéfinitionCatalogue des contenus de combat autorisés
Résultat de l’attribution d’une récompenseÉvénement de progressionService existant d’inventaire ou de progression
Version de la quêteDéfinition et référence dans la sauvegardeChaîne de production du contenu et règles de migration

Créer une première version de l’éditeur avec un aperçu isolé

Demandez à l’IA d’examiner le système d’exécution des quêtes, les interactions avec le système de combat, la gestion des récompenses et les fichiers de sauvegarde avant de proposer du code pour l’éditeur. Limitez la première version aux nœuds pris en charge, à la modification des champs, à la validation et à un aperçu avec un personnage de test jetable. Dressez la liste des fichiers à modifier et des systèmes à préserver. Relisez les modifications pour repérer toute exécution cachée de scripts arbitraires ou tout second circuit d’attribution des récompenses.

Gardez l’espace de travail de l’éditeur séparé de l’état du jeu en cours. L’aperçu doit charger une copie des données de quête et une sauvegarde de test jetable pour préserver la campagne active du joueur. Indiquez clairement qu’un contenu invalide ne peut pas être lancé. Ajoutez un bouton de réinitialisation qui restaure l’environnement de prévisualisation sans supprimer le fichier de quête créé par l’auteur. Conservez une branche propre et documentez la révision à restaurer en cas de retour arrière.

Tester les données mal formées, l’enchaînement entre quête et combat et les anciennes sauvegardes

Testez une quête valide minimale, chaque branche prise en charge, une action non prise en charge, des identifiants en double, une cible manquante, une fin de quête inaccessible et des récompenses au plafond autorisé puis au-delà. Jouez la quête avec un personnage de test jetable et vérifiez qu’à l’issue du combat, l’objectif retrouve l’état attendu. Chargez une ancienne sauvegarde de campagne et vérifiez que les quêtes livrées avec le jeu se déroulent toujours correctement.

La maquette d’un éditeur de quêtes fictif pour action-RPG présente la validation à côté d’icônes représentant l’aperçu du combat, le plafond de récompense et une liste de vérification des anciennes sauvegardes.
Simple maquette d’un écran d’assurance qualité. Aucune quête personnalisée n’a été chargée ni jouée.
Vérification proposéeActionÉléments à relever
Chemin validePrévisualiser et terminer une petite quêteTransitions entre les objectifs et identifiant du résultat
Graphe invalideSupprimer la cible et ajouter un nœud déconnectéErreurs de validation précises
Enchaînement entre quête et combatLancer et terminer la rencontre référencéeÉtat de la quête avant et après le combat
Plafond de récompenseDéfinir une récompense valide puis une récompense supérieure au plafondValeur acceptée et motif du rejet
Fin de quête signalée deux foisRecharger la sauvegarde et renvoyer l’événement de fin de quêteUne seule modification de l’inventaire ou de l’XP
Ancienne sauvegardeCharger une copie de la campagne datant d’avant l’ajout de l’éditeurÉtat de la quête livrée avec le jeu et état du personnage
Retour arrièreRestaurer la révision de référenceDéroulement d’origine de la quête et du combat

Cette grille présente des vérifications à réaliser. Consignez le build, l’identifiant et la version de la quête, la copie de la sauvegarde utilisée, les données d’entrée, la séquence des événements liés aux objectifs, le résultat de la rencontre, la variation due à la récompense, ainsi que le comportement attendu et celui observé. Une capture de la maquette de l’éditeur ne suffit pas à prouver que le graphe est correct ou qu’il fonctionne avec le système d’exécution.

Donner aux auteurs des indications utiles

Affichez un aperçu lisible du déroulement de la quête à côté du graphe. Permettez aux auteurs de sélectionner un nœud pour voir les champs obligatoires, les valeurs acceptées et la transition suivante. Indiquez dans les avertissements ce que l’auteur peut faire et conservez les données sources si l’aperçu échoue. Fournissez une quête d’exemple qui utilise des mécaniques prises en charge et distinguez clairement les statuts « brouillon », « validée » et « jouable ».

Pour explorer un autre concept d’action-RPG, essayez SEELE AI Game Maker. Cet outil sert à explorer des concepts de jeu. Il ne permet pas d’éditer un projet existant.

Questions fréquentes

Que doit permettre de modifier un éditeur de quêtes personnalisées ?

Commencez par les champs que le système d’exécution prend déjà en charge, comme le texte des objectifs, les cibles autorisées, les prérequis et quelques actions liées aux événements. Dans la première version, excluez les scripts arbitraires, les formules de récompense non contrôlées et les modifications directes des statistiques de combat. Chaque valeur saisie doit relever d’un composant clairement désigné, être soumise à une règle de validation et disposer d’une solution de repli sûre.

Comment un éditeur de quêtes peut-il empêcher la création de graphes invalides ?

Avant de publier ou de prévisualiser une quête, vérifiez la présence des champs obligatoires, la stabilité des identifiants de nœuds, l’accessibilité des objectifs, la validité des liens, la prise en charge des types d’actions et l’existence d’un chemin permettant de terminer la quête. Affichez les erreurs à côté du nœud concerné et bloquez le lancement en jeu si des champs obligatoires sont manquants. Testez aussi les cycles et les nœuds déconnectés selon les règles de construction des quêtes prévues pour le jeu.

Les quêtes personnalisées doivent-elles influer sur la progression des personnages ?

Faites passer les récompenses par le système de progression existant et appliquez-y les plafonds. Limitez les récompenses définies dans l’éditeur aux objets, plages de valeurs d’expérience ou déblocages autorisés. Testez les fins de quête répétées et les valeurs invalides pour éviter que les quêtes personnalisées dupliquent des récompenses ou contournent les règles de progression des personnages.

Comment sauvegarder les données des quêtes personnalisées ?

Respectez les formats de contenu et de sauvegarde existants du projet et séparez les définitions de quêtes de la progression en jeu de chaque joueur. Utilisez des identifiants de quête et d’objectif stables pour que les mises à jour ne perturbent pas les anciennes sauvegardes. Testez sur des copies la progression des anciennes quêtes et le traitement des fichiers mal formés avant de prendre en charge les imports ou le contenu créé par les joueurs.

L’IA peut-elle créer un éditeur de quêtes pour mon action-RPG ?

L’IA peut examiner les fichiers qui lui sont fournis pour le système d’exécution des quêtes, les combats, la progression et les sauvegardes, proposer un schéma de création restreint et rédiger des tests de validation. Pour vérifier que les données personnalisées fonctionnent en combat en temps réel, elle doit avoir accès au projet et disposer de builds exécutés. Fournissez une liste des modifications autorisées, un catalogue des actions prises en charge, des exemples de quêtes et une révision à restaurer en cas de retour arrière.

Commencer par des quêtes personnalisées validées

Proposez uniquement les actions que le système d’exécution actuel peut réaliser, validez le graphe avant la prévisualisation et séparez le contenu créé de la progression du joueur. Soumettez les récompenses aux plafonds existants et confiez leur attribution aux composants qui gèrent déjà ces transactions. Testez dans un build jetable les graphes mal formés, les enchaînements entre quête et combat, les fins de quête signalées plusieurs fois et les anciennes sauvegardes. L’éditeur fictif illustre la conception d’un système de quêtes personnalisées. Il ne prouve pas qu’un tel système a été livré.

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