Créer avec l’IA un petit patch de jeu facile à vérifier et à appliquer

Apportez une modification ciblée à un jeu existant et regroupez les fichiers source modifiés. Examinez le diff, appliquez le patch en local et vérifiez le résultat.

Seele Editorial TeamMis à jour 16 novembre 2026

Une modification apportée à un jeu avec l’aide de l’IA doit être facile à examiner, à appliquer et à annuler. La consigne « n’envoyer que les fichiers modifiés » peut faciliter la transmission, mais le projet complet reste nécessaire. Le code source dépend souvent de scènes, de ressources, de paramètres et de données générées par le moteur qui doivent correspondre à la version de référence du projet.

Un développeur examine une petite modification du code de planification d’un hôtel, avec le projet complet et une liste claire des fichiers modifiés à côté.
Cette illustration montre une situation de développement fictive. Elle ne représente ni un dépôt réel ni un patch terminé.

Ce guide prend pour exemple un jeu fictif de gestion hôtelière dans lequel une règle de départ tardif doit être légèrement modifiée. Le scénario est hypothétique. Aucun projet n’a été modifié, exporté ni testé. La démarche ci-dessous vous aide à demander une modification ciblée et à préparer les éléments qu’un autre développeur pourra examiner.

Définir la version de référence et la modification demandée

Avant toute modification, identifiez la version exacte du projet, la version du moteur, la branche ou la copie de travail et le fichier qui gère le comportement concerné. Notez ce qui doit changer et ce qui doit rester identique. Dans cet exemple, un départ tardif peut décaler les disponibilités de l’équipe de ménage sans modifier le prix des chambres, les règles d’arrivée des clients ni le calendrier quotidien de paie.

Donnez à l’assistant le minimum de contexte utile, notamment le script concerné, le code qui l’appelle, le schéma des données et les conventions du projet. S’il a besoin d’autres fichiers pour comprendre les dépendances, fournissez-les-lui pour qu’il puisse s’appuyer dessus. Demandez d’abord un plan de modification, puis un patch qui répertorie tous les fichiers ajoutés, modifiés ou supprimés, ainsi que les éventuelles dépendances liées aux scènes, aux ressources, aux paramètres ou aux migrations.

Conservez une version de référence propre en local. Le contrôle de version fournit un point de comparaison stable. Pour un essai ponctuel, une copie distincte suffit. Évitez de mélanger le patch avec des modifications sans rapport. En partant d’un état propre, vous pourrez repérer précisément ce que l’assistant a changé.

Examiner la liste des fichiers et le détail du diff

Utilisez votre outil de contrôle de version pour cerner le périmètre du patch, puis examinez les modifications ligne par ligne. La documentation de Git présente des options de diff comme name-only et name-status pour lister les chemins modifiés. Ces options permettent de savoir quels fichiers ont changé. Elles ne permettent pas de savoir si le patch est correct, si le code compile ou si la modification se limite au comportement visé.

Comparez chaque fichier modifié à la demande initiale. Vérifiez que la modification de la logique reste ciblée et repérez les nouvelles dépendances, le code supprimé, les valeurs par défaut modifiées et les changements apportés aux systèmes partagés. Examinez les nouveaux fichiers avec autant d’attention que les fichiers modifiés. Vérifiez si une scène fait référence à un script renommé, si un champ de données a besoin d’une valeur par défaut et si une modification du planning a des effets sur les sauvegardes ou sur un autre système.

Demandez une brève explication pour chaque fichier modifié. Si un fichier source est associé à un fichier généré ou à un fichier issu de l’import par le moteur, demandez si le projet le régénère. Évitez d’accepter une réécriture importante sous prétexte que la liste des fichiers livrés est courte. La modification d’un seul gestionnaire peut changer le comportement de tout le jeu.

Distinguer la livraison des fichiers source de l’export du jeu

Un patch de code source regroupe des modifications à appliquer à la version correspondante d’un projet. Il peut contenir un script et un fichier de données sans inclure les scènes, les sprites, la configuration ou les métadonnées du moteur. Appliquez-le au projet complet prévu, puis suivez les étapes habituelles du projet dans l’éditeur, de l’import à la compilation et à l’export. Un dossier source partiel ne suffit pas toujours à faire tourner le jeu.

Certains moteurs prennent en charge des formats de patch spécifiques. La documentation de Godot pour la version stable décrit les options de ligne de commande export-patch, qui concerne les fichiers modifiés, et patches. Elle précise aussi que les commandes d’export s’appuient sur des préréglages configurés et qu’il faut tenir compte de l’export de base associé. Cette fonctionnalité de création de patchs est propre à Godot. Ne supposez pas qu’une archive ZIP des fichiers source modifiés soit équivalente, ni que le même mécanisme s’applique à Unity ou à un autre moteur.

Un petit ensemble de fichiers source modifiés s’intègre à la version complète correspondante du jeu de gestion hôtelière, tandis que les scènes et les ressources dont ils dépendent restent en place.
Pour utiliser les fichiers modifiés, il faut disposer de la version correspondante du projet.

Si la livraison est destinée à une revue de code, incluez les fichiers modifiés, un diff lisible, des notes sur les dépendances, les versions du projet et du moteur ainsi que les instructions exactes d’application du patch. Si vous devez livrer une version compilée pour une plateforme ou un patch au format du moteur, utilisez la procédure d’export prise en charge par le moteur et testez le fichier ainsi produit. Précisez ce que vous livrez.

Demander un patch qu’un autre développeur pourra comprendre

Vous pouvez formuler une demande ciblée ainsi. Modifiez uniquement la règle de planification des départs tardifs. Conservez l’attribution des chambres, les tarifs, les arrivées et la paie. Laissez intactes les scènes sans rapport avec la modification. Listez les fichiers nouveaux et modifiés, expliquez les dépendances nécessaires et indiquez comment revenir en arrière. Demandez à l’assistant de fournir un diff unifié ou un dossier contenant uniquement les fichiers modifiés, en précisant la version de référence utilisée.

Examinez le patch avant de copier ses fichiers dans le projet de travail. Vérifiez que les chemins sont relatifs à la racine du projet, que les noms de fichiers sont corrects, que le patch ne contient ni secrets ni fichiers de cache locaux et que le nouveau code suit les conventions du projet. Si le patch remplace un fichier entier, comparez-le à la version de référence pour éviter de perdre du contenu sans rapport avec la modification.

Après avoir appliqué le patch, vérifiez l’état des fichiers avec votre outil de contrôle de version. Si l’assistant annonce une modification de deux fichiers et que le diff en montre dix, arrêtez-vous pour en comprendre la raison. Certains fichiers générés peuvent changer lors d’un import par le moteur. Distinguez-les des modifications prévues du code source et suivez les règles habituelles du dépôt.

Appliquer le patch, compiler le jeu et vérifier son comportement

Appliquez le patch à une copie ou à une branche propre, puis ouvrez le projet complet avec la version prévue du moteur. Corrigez les problèmes d’import et les erreurs de compilation avant d’évaluer le comportement demandé. Dans l’exemple de l’hôtel, vérifiez la date du départ tardif, la disponibilité de la chambre, l’arrivée du client et le planning du ménage. Vérifiez aussi que les tarifs et la paie, qui ne sont pas concernés par la modification, restent identiques.

Gardez une trace de l’état avant et après la modification en consignant la version du projet, les fichiers modifiés, les étapes suivies, le résultat attendu et le résultat observé. Testez un scénario courant, un cas limite et le retour à la version précédente. Si les données modifiées sont persistantes, testez aussi leur sauvegarde et leur rechargement. Si vous livrez une version téléchargeable, testez-la sur la plateforme cible, au-delà de l’aperçu dans l’éditeur.

Un écran de planning hôtelier est comparé avant et après un petit patch. Une version de référence a été sauvegardée pour permettre un retour en arrière.
Cette illustration montre le principe de la vérification. Elle ne prouve pas qu’un patch a été appliqué ou testé.

Limiter et vérifier le retour en arrière

Avant d’appliquer une modification, conservez un point de restauration propre. Si le patch échoue, restaurez uniquement les fichiers qu’il a modifiés ou annulez le commit qui lui est consacré. La commande restore de Git peut restaurer les chemins sélectionnés, mais la restauration d’un chemin efface aussi ses modifications en cours dans l’arbre de travail. Vérifiez au préalable qu’il ne contient pas de modifications sans rapport avec le patch.

Vérifiez aussi le retour en arrière. Rouvrez le projet, confirmez que le comportement initial est rétabli et assurez-vous que les modifications non validées ont été conservées. Évitez les commandes de réinitialisation ou de nettoyage globales lorsque le patch de l’assistant est mêlé à d’autres modifications locales.

Questions fréquentes

Puis-je envoyer uniquement les fichiers source modifiés du jeu à un assistant IA ?

Oui, si l’assistant reçoit aussi le code environnant pertinent, les conventions du projet et les contraintes. Conservez en local la version de référence du projet complet, demandez un diff et vérifiez que les éléments transmis indiquent les dépendances nécessaires aux fichiers modifiés. Précisez les chemins et les versions dans la note qui accompagne la livraison.

Un ensemble de fichiers modifiés suffit-il à produire une version complète du jeu ?

Non. Les fichiers source peuvent dépendre de scènes, de ressources, de paramètres, de fichiers générés ou de données d’import du moteur qui ne sont pas inclus. Appliquez le patch à la version correspondante du projet complet, puis compilez ou exportez le jeu selon la procédure habituelle du projet. La personne qui examine le patch doit savoir de quelle version du projet complet elle a besoin.

Comment lister uniquement les fichiers modifiés avec Git ?

Utilisez une option de diff de Git comme name-only ou name-status pour comparer les fichiers à la version de référence prévue, puis examinez aussi le détail du diff. La liste des fichiers montre l’étendue des modifications. Elle ne permet pas de savoir si le code est correct ou s’il présente des risques. Vérifiez que l’état de votre arbre de travail est suffisamment propre pour interpréter le diff.

Godot peut-il exporter uniquement les fichiers modifiés ?

Le tutoriel sur la ligne de commande de la version stable de Godot documente l’option export-patch pour les fichiers modifiés ainsi que les listes de patchs. Cette fonctionnalité dépend du préréglage d’export et d’un export de base compatible. Elle ne produit ni une archive ZIP générique du dossier source ni une version autonome du jeu. Suivez les exigences documentées pour le préréglage et l’export de base de la version du moteur utilisée.

Comment annuler un patch du code d’un jeu créé avec l’IA ?

Conservez la version de référence ou un point de restauration propre dans votre système de contrôle de version avant d’appliquer les modifications. Restaurez uniquement les fichiers examinés ou annulez le patch, puis recompilez le jeu et vérifiez son comportement. Évitez les commandes de nettoyage globales lorsque vous avez des modifications non validées. Confirmez que le projet restauré compile et que le comportement initial est rétabli.

Préciser ce que vous livrez

Gardez le projet complet comme référence. Transmettez un petit patch facile à examiner, en précisant ses dépendances et sa version de référence, puis compilez et testez le jeu selon la procédure habituelle du projet. L’autre développeur reçoit ainsi les fichiers modifiés dont il a besoin et sait que ces fichiers seuls ne constituent pas un jeu fini.

Pour explorer une idée distincte sous la forme d’un prototype jouable dans un navigateur, essayez SEELE AI Game Maker. Cet outil sert à créer un prototype séparé. Il ne permet pas d’appliquer un patch au code ni d’exporter 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