Un éditeur de scénarios peut rendre les affrontements d’un jeu de tir en arène au rythme rapide plus intéressants à rejouer, mais il ne doit pas devenir un deuxième moteur de combat. Laissez l’éditeur décrire l’affrontement et le jeu existant continuer à gérer les déplacements, les armes, le comportement des ennemis, les dégâts et le déroulement de la partie.

Ce guide présente une méthode de création de scénarios pour un projet existant. L’exemple de l’arène de la Fonderie est fictif : aucun éditeur, build ou test en jeu n’est présenté comme ayant été réalisé. Avant de demander à l’IA de modifier le code, identifiez les systèmes qui fonctionnent déjà et doivent rester stables, puis examinez comment le projet charge actuellement ses arènes intégrées.
Délimitez le rôle de l’éditeur avant d’ajouter des commandes
Partez de ce que le jeu sait déjà gérer. Si les arènes ont aujourd’hui des limites fixes, des points de départ pour le joueur, des types d’ennemis et des munitions à ramasser, une première version de l’éditeur peut proposer ces options. Vous n’avez besoin ni d’un langage de script, ni d’outils de création libre de la géométrie, ni d’une place de marché complète pour les mods. Ces fonctionnalités multiplient les exigences en matière de validation et de sécurité.
Décrivez en termes simples les données minimales d’un scénario : quelle arène charger, où le joueur commence, quels groupes d’ennemis apparaissent, quand chaque groupe s’active, quelle quantité de munitions ou d’armure est disponible et ce qui met fin à l’affrontement. Conservez les réglages des armes et l’IA des ennemis dans leurs systèmes actuels. L’éditeur permet de sélectionner les options prises en charge ; il ne doit pas reproduire les règles qui les appliquent.
Demandez à l’IA de cartographier le fonctionnement actuel avant toute modification. Faites-lui repérer le chemin dans la campagne ou les menus qui lance une arène, la fonction qui place les ennemis et le composant qui gère la condition de victoire. Demandez un plan de modification succinct et la liste exacte des fichiers qu’elle prévoit de toucher. Si elle propose de remplacer la boucle de combat existante pour simplifier l’éditeur, arrêtez-vous et réduisez le périmètre.
Représentez le scénario sous forme de données
Des identifiants stables comptent davantage que les libellés affichés dans une liste déroulante. Un champ peut faire référence à l’identifiant d’une arène, d’un ennemi, d’un point d’apparition ou d’un objet à ramasser déjà présent dans le jeu. Les concepteurs peuvent renommer « Entrée de la Fonderie » plus tard sans invalider un scénario qui fait référence à l’identifiant stable foundry_gate_a.
Voici un exemple de champs que pourrait contenir un scénario :
{
"scenario_id": "foundry_arena_01",
"arena_id": "foundry_main",
"player_start_id": "west_platform",
"waves": [
{"delay": 0, "spawns": [{"enemy_id": "raider", "count": 3}]},
{"delay": 20, "spawns": [{"enemy_id": "brute", "count": 1}]}
],
"ammo_budget": 120,
"win_condition_id": "clear_all_waves"
}
Cet exemple est pédagogique : le schéma n’a pas été testé. Respectez les conventions du projet pour les unités et la gestion du temps. Si les délais sont exprimés en secondes, gardez cette unité partout ; si les vagues sont déclenchées par des événements, n’introduisez pas de deuxième horloge. Prévoyez une version du schéma si les scénarios personnalisés doivent rester utilisables après les mises à jour du projet, et définissez comment signaler les identifiants d’ennemis ou d’arènes qui ont été supprimés.
Choisissez un format de données adapté à la façon dont les créateurs conçoivent et distribuent leurs scénarios. La documentation de la version stable de Godot décrit les Resources personnalisées, qui peuvent être modifiées dans l’inspecteur et sérialisées au format texte ou binaire. Son tutoriel sur les sauvegardes utilise JSON pour stocker un état simple du jeu en cours d’exécution et explique les compromis liés, par exemple, à la conversion des types et à l’encodage personnalisé. Unity 6.1 présente ScriptableObject comme un conteneur de données utilisable dans l’éditeur, indépendant des instances de classe. Ces options ne sont pas interchangeables : vérifiez comment le projet existant intègre et charge ses données.

Empêchez le lancement des scénarios invalides
La validation doit avoir lieu avant le démarrage de la scène de combat. Vérifiez que l’arène sélectionnée existe, que le point de départ du joueur appartient à cette arène, que chaque identifiant d’ennemi est connu, que le nombre de vagues et les délais sont valides et qu’il est possible de remplir la condition de fin de l’affrontement. Si le jeu impose des coûts en ressources, appliquez un budget clairement défini plutôt que d’accepter des valeurs qu’aucun objet à ramasser disponible ne permet d’atteindre.
Pour chaque erreur, indiquez le champ concerné et ce qu’il faut corriger. « Identifiant d’ennemi inconnu dans la vague 2 » est plus utile que « Scénario invalide ». Si un point d’apparition se trouve en dehors de la zone jouable, précisez au créateur de quel point il s’agit. Évitez de remplacer une valeur par défaut sans le signaler : un scénario qui semble s’enregistrer correctement mais charge un autre ennemi peut faire perdre du temps à son créateur et masquer un problème dans les données.
Appliquez des contraintes adaptées au jeu actuel. Une arène très exiguë peut respecter les règles tout en désavantageant le joueur. L’éditeur peut émettre un avertissement si l’espace disponible est inférieur à un seuil défini par le projet, sans prétendre évaluer automatiquement l’équilibrage. Le nombre d’ennemis, les lignes de vue, les munitions et la difficulté interagissent. Les vérifications statiques peuvent repérer les données mal formées, mais seuls les essais en jeu permettent de savoir si l’affrontement est plaisant et s’il peut être mené à son terme.
Gardez la validation indépendante du système de combat. Un module de validation simple peut renvoyer une liste d’erreurs et d’avertissements. L’écran d’aperçu peut afficher ces messages et désactiver le bouton « Démarrer » tant que les erreurs bloquantes ne sont pas corrigées. Le chargeur d’arènes existant n’a ainsi pas à interpréter des données partiellement valides.
Utilisez le circuit de chargement du jeu pour l’aperçu
Un aperçu n’est utile que s’il emprunte le même circuit de chargement des scénarios qu’une partie normale. Faites en sorte que l’éditeur enregistre ou conserve les données du scénario, puis les transmette via le point d’entrée que le jeu utilise déjà pour lancer une arène. Une simulation qui place les ennemis différemment de la véritable scène de combat ne suffit pas à valider l’intégration.
Pour une première version, choisissez une arène intégrée et quelques identifiants d’ennemis connus. Ajoutez un affrontement personnalisé avec deux vagues, un seul budget de ressources et la condition de victoire existante. Gardez le scénario de campagne actuel comme témoin. Comparez les mêmes comportements de déplacement, d’utilisation des armes, des ennemis et de redémarrage avant et après l’ajout de l’éditeur.

Utilisez l’IA pour produire des modifications faciles à examiner
Donnez à l’assistant des consignes précises : préserver les scripts de déplacement et de combat existants, ne proposer que les options déjà disponibles pour les arènes, les points d’apparition, les ennemis, le rythme et les ressources, ajouter une validation avant le lancement et continuer à charger les scénarios intégrés par le circuit existant. Demandez-lui de préciser ses hypothèses sur le format des données, les fichiers modifiés, les conséquences de la migration et la procédure de retour en arrière.
Examinez les modifications par petits lots. Vérifiez que les identifiants de scénario sont stables, que les références manquantes déclenchent une erreur accompagnée d’un message utile et que l’éditeur n’écrase pas le contenu intégré. Si les scénarios créés par les utilisateurs sont stockés séparément, rendez cette séparation explicite. Gardez une copie du projet d’origine et d’au moins un fichier de scénario existant pour pouvoir comparer le comportement au chargement.
Le résultat généré par l’IA peut sembler convaincant tout en dupliquant la logique de combat ou en introduisant une dépendance cachée à des ressources réservées à l’éditeur. Générez un build du projet et examinez les journaux d’exécution dans la configuration cible. Un aperçu réussi dans l’éditeur ne prouve ni que le contenu exporté se charge correctement ni que l’affrontement est équilibré.
Testez le chargement du contenu au-delà de l’écran de l’éditeur
Utilisez un petit tableau de tests et consignez la version du projet, l’identifiant du scénario, les étapes, le résultat attendu et le résultat observé. Il s’agit de vérifications proposées : rien n’indique que l’arène fictive les a réussies.
| Cas | Vérification | Comportement attendu |
|---|---|---|
| Scénario intégré | Lancer l’arène d’origine depuis son menu habituel | Le fonctionnement de la campagne et du combat reste intact |
| Données personnalisées valides | Charger un scénario avec deux vagues connues et un budget conforme aux règles | Le point de départ du joueur, les apparitions, le rythme et la condition de victoire correspondent aux données |
| Référence inconnue | Utiliser une copie de test dans laquelle il manque un identifiant d’ennemi | La validation indique le champ manquant et bloque le lancement |
| Cas limite | Placer un point d’apparition près des limites de l’arène ou en dehors | L’éditeur affiche un avertissement ou refuse le placement selon les règles du projet |
| Redémarrages répétés | Relancer plusieurs fois le même scénario | Les apparitions et les quantités de ressources sont réinitialisées de la même façon à chaque fois |
Testez ensuite un build exporté si la version à publier doit en inclure un. Vérifiez que les scénarios des utilisateurs sont présents ou chargés depuis l’emplacement prévu, que le contenu intégré fonctionne toujours et que le jeu signale les données non prises en charge au lieu de les modifier en silence. Présentez ces résultats séparément des recommandations de conception et des illustrations préparatoires.
Questions fréquentes
Que doit permettre de régler un éditeur de scénarios de combat personnalisés ?
Commencez par les réglages que le jeu prend déjà en charge : les limites de l’arène, le point de départ du joueur, les groupes d’ennemis à faire apparaître, les délais des vagues, le budget de ressources et la condition de victoire. Laissez le comportement des armes et l’IA des ennemis en dehors de l’éditeur, sauf si ces systèmes proposent déjà des paramètres que l’on peut modifier sans risque.
Un éditeur de scénarios doit-il stocker ses données en JSON ou dans des ressources du moteur ?
Choisissez le format adapté au projet et à la façon dont les scénarios sont créés. Godot décrit les Resources personnalisées comme des ressources de données modifiables. Son tutoriel sur les sauvegardes utilise JSON pour stocker un état simple du jeu en cours d’exécution et en explique les limites. Unity présente ScriptableObject comme un conteneur de données du projet ; il ne constitue pas à lui seul un système de sauvegarde en cours de jeu.
Comment empêcher le lancement d’arènes personnalisées invalides ?
Validez les champs obligatoires avant l’aperçu : une arène connue, un point de départ du joueur à l’intérieur de ses limites, au moins un groupe d’apparition valide, des délais positifs ou nuls, des identifiants d’ennemis connus et une sortie accessible ou une condition de victoire réalisable. Signalez le champ à corriger au lieu de l’ignorer en silence.
Comment préserver le fonctionnement de mon jeu de tir en ajoutant un éditeur ?
Limitez le rôle de l’éditeur à la production des données du scénario et faites en sorte que les systèmes de combat actuels les reçoivent via un point d’entrée bien délimité. Préservez les déplacements, les armes, le comportement des ennemis et le chargement de la campagne. Examinez les modifications fichier par fichier avant d’accepter celles que propose l’IA.
Que faut-il tester avant de partager un scénario personnalisé ?
Testez un scénario intégré, un scénario personnalisé valide, des champs manquants ou invalides, une arène volontairement exiguë et des redémarrages répétés. Notez la version du projet et les étapes suivies. Un simple aperçu visuel ne prouve pas que le combat est équilibré ni qu’il peut être mené à son terme.
Enrichissez l’éditeur une fois le circuit des données stabilisé
Commencez par une arène et quelques valeurs prises en charge. Ajoutez des options de placement ou de partage plus poussées seulement quand la gestion des données de scénario, leur validation et leur chargement en jeu suivent un circuit stable. La fonctionnalité reste ainsi plus simple à comprendre, plus facile à retirer et moins susceptible d’altérer les sensations de jeu existantes.
Si vous avez une idée de prototype distinct jouable dans le navigateur, essayez SEELE AI Game Maker. Ce lien vous invite à créer un prototype séparé, sans modifier un projet de jeu de tir existant.


