Hello les amis,
Je reprends ma plus belle plume de cyberpunk pour vous raconter sans filtre mon nouveau projet « Taupe qui peut ! », mon tout premier jeu vidéal.
Ce n’est pas un secret, j’adore les jeux et j’avais depuis longtemps l’envie de me frotter à l’exercice de construire un jeu par moi-même.
Vous l’aurez compris avec le titre de l’article, je ne m’en cache pas et ça ne m’intéresse pas de lancer un débat IA versus développeur artisan ici.
Mon intention, c’est simplement de partager mon processus et d’être transparent et ouvert sur la manière dont les choses ont été faites.
Ceci étant dit, si vous voulez tester le jeu, me faire des retours ou simplement en discuter, n’hésitez pas à revenir vers moi et à ouvrir la discussion.
Je ferme cette parenthèse et j’espère que vous apprécierez cette lecture et qu’elle vous sera utile.
La mise en place du GDD (game design document)
La première phase a été la mise au point de mon GDD. En fait, intellectuellement parlant, ça m’arrive de vagabonder et de réfléchir à des concepts de jeux et je n’avais jamais pris le temps et l’énergie de mettre en place ne serait-ce qu’un POC ou un début de quelque chose.
Je me souviens vaguement avoir tenté de construire un RPG il y a très longtemps mais d’avoir été saturé de problèmes techniques ou juste d’un manque de motivation pour travailler sur l’avancement de mon jeu.
Et surtout, sans avoir de connaissances mathématiques poussées, c’est ma culture jeu vidéo qui m’a guidé pour aller chercher précisément ce que je voulais concevoir.
Qu’est-ce qui a changé depuis ? Débile à dire dit comme ça, ça fait très publicité mais ce n’est pas du tout le cas : c’est l’arrivée de Gemini 3.7 et du CLI Antigravity, qui m’a bluffé par sa rapidité et sa justesse technique.
Un trajet de 6 heures de voiture pour rentrer de vacances (je précise en tant que passager), qui m’a donné l’opportunité de réfléchir une fois de plus sur un GDD et cette fois-ci de réfléchir à quelque chose que je pourrais terminer, parce que les ambitions m’ont semblé plus réalistes et atteignables avec le CLI agentique de Google.
Donc j’ai réfléchi à ma boucle de gameplay, au nom de mon jeu, aux conditions de victoire et de défaite, à des benchmarks de moteurs de jeu, tout ça sur le chemin du retour de vacances.
Mon idée ? Proposer une réinvention du jeu de tape-taupe traditionnel, mais en inversant les rôles. Je voulais que le joueur soit du point de vue des taupes et s’organise pour esquiver le marteau, soit incité à remonter à la surface et se coordonne avec les autres taupes pour ramener des butins aux terriers.
Je voulais un jeu en 3D en vue subjective taupe, mais j’ai revu mon idée et je suis plutôt parti sur une vue de dessus avec les terriers en transparence.
Et petit à petit le jeu s’est enrichi et j’ai décidé d’en faire un jeu de surcharge cognitive et de prises de décision rapides.
Finalement je crois que c’est la meilleure idée que j’ai eue dans l’évolution de mon jeu : me rapprocher de mes habiletés naturelles que j’utilise déjà au quotidien et en faire la mécanique principale de mon jeu. Quand on y pense c’est hyper logique, je n’aurais pas injecté de l’énergie dans un jeu auquel je n’aime pas jouer.
Mon deuxième objectif, c’était d’avoir des bots perçus comme des compagnons de jeu et non comme des boulets qui font pester le joueur et l’empêchent de réaliser ses objectifs.
Donc la mécanique de râlage a été pensée à la fois comme un outil de micro-pilotage (pour rameuter les bots, communiquer et coordonner les actions) et comme une vraie mécanique de risque/récompense : râler vous débloque, mais attire immédiatement l’aigle qui ne vous ratera pas si vous en abusez. En définitive, c’est le rêve d’être dans la peau d’un micro-manager toxique !
Je suis revenu ensuite à plusieurs reprises dessus et j’ai rajouté des mécaniques anti-abus, des prédateurs pour empêcher le joueur d’idle, de l’eau, des tunnels de métro (petit clin d’œil à ma vie parisienne). Tout ça pour dire que le GDD est un support capital pour la structure et l’avancement du jeu, mais que je suis revenu plusieurs fois sur le document et que je l’ai enrichi au fur et à mesure.
Première erreur, commencer à coder sans réelle structure
Je pense que c’est mon erreur la plus évitable et peut-être la plus coûteuse sur ce projet.
J’ai pris mon GDD, j’ai initialisé un repo git et vogue la galère (ou le bateau à sushi).
J’avais comme idée d’utiliser Godot et de bosser sur ma machine Windows au début pour profiter de ma carte graphique, je me suis très vite rendu compte qu’en fait je n’étais pas à l’aise dans cet environnement.
Je me suis écouté, j’ai bougé mon repo sur ma machine Linux en me disant que je pourrais toujours faire un POC en 2D vue de dessus sans forcément avoir besoin d’accélération 3D ou de mouvements de caméra élaborés. Je pense que cette décision aurait pu enterrer mon projet dès le début, j’ai donc mis toute mon énergie dans l’idée de faire un POC de jeu 2D en mode desktop.
Je vais dire un autre truc complètement débile en y repensant, Gemini a décidé de me faire un POC HTML, JS et CSS, il a complètement mis de côté mon choix technologique pour faire du vanilla JS HTML CSS.
Je pense que beaucoup de monde aurait pesté et abandonné l’IA à partir de là, mais j’ai décidé de prendre ce que m’a donné l’IA et de faire un POC dans mon POC, parce qu’il a répondu à mon injonction principale : je veux quelque chose que je peux tester et lancer rapidement, pour itérer rapidement et jeter si besoin, et après le plan c’était de le convertir en Godot.
Spoiler : j’ai pas fait ça du tout, j’ai donc maintenant un POC de POC en prod !
J’ai donc continué à itérer sur mon fichier index.html monolithe pendant un sacré bout de temps, jusqu’au moment critique où le fichier était bien trop gros, cramait trop de tokens en lecture et générait trop d’erreurs en boucle qui cassaient totalement mon jeu.
Voici une capture de mon premier prototype, dégueu hein ? hihihi
Premier habillage et terrain généré de manière procédurale
Il m’a fallu 2 semaines sur mon temps libre pour commencer à avoir quelque chose de très moche mais de « jouable ».
J’avais mes asticots, mes salades, la mécanique de déplacement des salades, et un gameplay qui marchouillait, et c’est là que les premiers vrais ennuis commencent.
J’ai partagé à quelques amis les premières versions de mon jeu et, comme c’était partagé par WhatsApp, le premier réflexe, c’est de l’ouvrir sur mobile.
Autant dire qu’avec ma taille de jeu fixe, impossible d’avoir un truc qui s’affiche proprement sur mobile et on ne parle même pas d’essayer de jouer.
J’ai eu beau forcer et expliquer que pour le moment c’est un proto crado et que j’essayais de tester la mécanique de jeu et le gameplay, les problèmes d’écran et de support mobile revenaient le plus dans mes retours de test. J’avoue que j’ai mis de côté ce problème au début, pour me concentrer sur la création procédurale de la zone de jeu.
C’est vraiment à partir de là que j’ai compris qu’il fallait que je fasse une refacto et que je mette en place des tests.
Voilà à quoi ressemblait le jeu avant la première refacto, toujours dégueu !
Donc sans surprise, dans le manuel des erreurs de dev niveau 1, faire un énorme fichier index.html avec CSS, HTML et JS vanilla procédural, ça ne scale pas du tout dès qu’on commence à avoir de la complexité.
Donc j’ai demandé à Gemini de me séparer HTML, CSS et JS dans des fichiers séparés et de commencer à me faire des tests d’intégration et de non-régression.
C’est au moment où j’ai commencé à ajouter les hypertunnels et l’eau que c’est parti en maxi sucette.
J’ai dû commencer à ajouter des règles dans tous les sens, pour que les montagnes et l’eau ne clashent pas avec la position des trous et des tunnels, au début avec les hypertunnels aux quatre coins de la carte. Mon idée, c’était d’avoir un moyen funky de traverser la carte en diagonale, plus rapidement et avec une esthétique de métro, mais plus tard je me suis rendu compte que personne ne les empruntait.
Donc je me suis concentré sur le fait de régler au fur et à mesure les softlocks que je rencontrais en jeu : des taupes superposées, des bots bloqués dans leurs déplacements, des montagnes trop proches de l’eau, et j’ai travaillé des solutions de contournement et de déblocage.
Les tests étaient de plus en plus nombreux et j’avais de moins en moins de softlocks, mais toujours un énorme fichier JS monolithique procédural et fortement couplé au front.
J’ai mis en place un tweak system, pour analyser visuellement les hitboxes, les collisions, les règles d’exclusion et tester manuellement les différents scénarios.
Un tweak system, c’est une interface de réglages et de debug qui permet d’activer ou non des features et de changer des valeurs du jeu pour débugger.
J’ai aussi commencé à me soucier des perfs et des problèmes de lisibilité des labels de mes taupes.
Ça a été un vrai game changer au moment où j’ai commencé à vouloir introduire mon bateau sushi. À partir du moment où j’ai commencé ma mécanique de bateau sushi, c’est là que j’ai compris qu’il me fallait de la vraie POO, des types et une gestion plus pro de mon JS.
Voilà à quoi ressemble mon tweak system visuellement, avec en plus plein de menus et d’options que je peux activer ou non, pour modifier à chaud ma configuration.
Deuxième refacto, TypeScript + Vitest + jeu mobile
À partir du moment où j’ai commencé à maintenir mon tweak system à part et que la codebase est devenue trop importante et concentrée dans le même fichier, j’ai demandé de split en TypeScript et de faire de la vraie POO. J’avais des comportements mutables globaux qui cassaient régulièrement mon gameplay et je demandais en plus des features complexes que Gemini avait du mal à m’intégrer sans tout casser. La mécanique du bateau sushi, la taille des aliments posés dessus, les taupes à l’intérieur, l’animation des rames, le Kraken qui a eu un nombre d’itérations important et les canons qui tirent dessus, tous ces petits détails ont nécessité un paquet de tests et d’itérations avant que je trouve la bonne taille et les bonnes animations.
Et finalement, au moment où j’ai commencé à bien polish le jeu et les animations, c’est là que je me suis occupé de la compatibilité mobile et donc que je n’ai pas eu d’autre choix que de revoir ma taille d’écran fixe. Je me suis frotté aux Progressive Web Apps et aux problèmes de déclenchement du son sous iOS, aux problèmes de plein écran et à l’accessibilité numérique.
J’ai mis en place ma modale de paramètres, les skins Reine et Monarque, les problèmes de labels avec du « Sire », « Monseigneur » que j’ai dû gérer en traduction, et le problème majeur : l’écran est bien plus petit et il faut tenir compte de la taille de l’écran et des objets pour que le jeu reste affichable et jouable aussi sur mobile.
Regarde j’ai fait une doc, je sais t’en as rien à faire
Premier réflexe des joueurs : « Je comprends rien, ça bouge de partout, il est où le tuto ? »
J’ai horreur des tutos intégrés dans les jeux qui me coupent en plein jeu pour m’apprendre comment faire des trucs, alors je me suis dit dans un premier temps que j’allais faire une page de doc interactive, sympa, avec les mêmes éléments que dans le jeu et des explications un peu plus détaillées.
J’ai eu beaucoup de mal à intégrer les éléments et à les redimensionner dans la doc sans impacter le jeu normal, parce que ce sont les mêmes éléments mais ils n’avaient pas été prévus pour avoir un changement d’échelle différent du vectoriel du changement d’écran.
J’étais encore en train de changer ma mécanique de jeu quand j’ai mis en place cette doc et j’ai dû faire plusieurs ajustements.
Au final, j’ai passé mon temps à réexpliquer aux gens ce qu’ils ne lisaient pas dans la doc, donc j’ai dû repenser mon jeu pour faire le tuto intégré.
J’en avais marre aussi d’expliquer que je voulais que les gens testent le jeu dans son équilibrage ultime avec l’ensemble des features activées, donc finalement j’ai mis en place un tuto in-game qui a complètement cassé mon jeu, puisque tout l’équilibrage et les règles de position étaient pensés autour de la mécanique de l’ensemble des features déjà en place.
Et comme certaines features n’étaient pas prévues pour être désactivées, ça cassait tout simplement le jeu car elles n’étaient pas totalement désactivées et provoquaient des paradoxes.
Par exemple, les hypertunnels qui avaient des règles de positionnement particulières ne devaient pas être pris en compte par la création de la première map qui n’avait que des petits trous.
Beaucoup de contraintes en plus et de classes de bugs ajoutées juste pour un tuto joué en principe une seule fois par le joueur.
Et les quelques retours que j’ai eus m’ont fait changer d’avis sur ma mécanique de gestion du temps, pour le meilleur. Au début, le joueur commençait avec un chrono de 3 minutes et devait ramasser des butins qui augmentaient cette jauge de temps ; il fallait arriver à 8 minutes en cumulant du temps avec les butins.
Ce qui amenait une condition de victoire avec un temps de jeu aléatoire, et si le joueur se lasse ou prend trop de malus, il se décourage et ragequit.
Donc la nouvelle option, plus classique finalement : un temps de jeu fixe de 3 minutes et un score + un grade qui représente le niveau de jeu de la personne.
Organisation agentique, optimisation et polish
Finalement en end game, j’ai commencé à avoir des besoins spécialisés comme les problèmes de mobile ou de complexité de code, des problèmes d’équilibrage du jeu, d’accessibilité numérique, donc j’ai décidé de mettre en place des agents que j’instancie seulement pour résoudre des problèmes précis.
Pour le coup je ne me suis même pas plus cassé la tête que ça, j’ai demandé à Gemini selon lui de quoi j’avais besoin en fonction de l’envergure de mon projet et j’ai complété au fur et à mesure.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
# 🤖 Guide des Agents Spécialisés : Taupe qui peut !
Ce document recense les 12 agents experts configurés pour le développement, la maintenance, les tests, l'accessibilité, la performance, la logique, la sécurité, l'équilibrage et l'intelligence artificielle du projet **Taupe qui peut !**.
---
## 📋 Table des Agents Disponibles
| Identifiant | Rôle | Domaine d'intervention |
| :--- | :--- | :--- |
| **`complexity-hunter`** | 🏹 **Chasseur de Complexité** | Élimination de la sur-ingénierie, application de KISS / YAGNI, simplification du code. |
| **`test-specialist`** | 🧪 **Spécialiste des Tests & QA** | Conception et exécution des tests unitaires, cinématiques, smoke test pré-commit et E2E Playwright. |
| **`code-reviewer`** | 🧐 **Spécialiste Revue de Code** | Analyse de qualité, sécurité, respect des standards et prévention des fuites mémoire. |
| **`garbage-collector`** | 🧹 **Garbage Collector & Oops Cleaner** | Traque du code mort, variables orphelines, logs de debug et TODOs résiduels. |
| **`mobile-specialist`** | 📱 **Spécialiste Compatibilités Mobiles** | Responsive design (portrait/paysage), ergonomie tactile, Safari iOS & Android. |
| **`gameplay-designer`** | 🎮 **Spécialiste Gameplay & Game Feel** | Équilibrage des mécaniques (vitesses, timings marteau/aigle), SFX, feedbacks visuels. |
| **`refactoring-expert`** | 🏗️ **Spécialiste Refactoring & Architecture** | Découpage modulaire, Clean Code, démantèlement des god functions sans régression. |
| **`a11y-specialist`** | ♿ **Spécialiste Accessibilité & Inclusion** | Normes WCAG 2.2, WAI-ARIA, contrastes, lecteurs d'écran, recherche Web en cas de doute. |
| **`perf-specialist`** | ⚡ **Spécialiste Performances & Fuites Mémoire** | 60 FPS constants, réduction de la charge CPU anormale en jeu, zéro allocation dans la game loop, éradication des leaks. |
| **`logic-pragmatist`** | 🧠 **Spécialiste Logique & Pragmatisme** | Traque des paradoxes, détection des consignes contradictoires, analyse de cohérence systémique à chaque demande. |
| **`security-expert`** | 🛡️ **Spécialiste Sécurité & Red Team / Fuzzing** | Crash testing, fuzzing, simulation d'injections, traque des `IndexSizeError` et patchs défensifs. |
| **`ai-behavior-expert`** | 🤖 **Architecte IA, Pathfinding & Prise de Décision** | IA bots alliés, comportements de meute/coopération, évitement d'obstacles/pièges, traque prédateurs (renard, aigle, kraken). |
---
## 🎯 Fiches Détaillées & Prompts Spécialisés des Agents
### 1. 🏹 `complexity-hunter` (Chasseur de Complexité Inutile)
* **Objectif** : Garder la base de code la plus simple, directe et efficace possible (KISS & YAGNI).
* **Compétences & Périmètre** :
- Traque des abstractions prématurées, des factory patterns inutiles et des sur-couches verbeuses.
- Simplification des calculs trigonométriques et des algorithmes de collision dans `src/systems/physics.js`.
- Élimination des états intermédiaires redondants dans `src/core/state.js`.
- Conception de la solution minimale viable sans dette technique.
* **Prompt Système / Directives Internes** :
> *"Tu es un ingénieur intransigeant sur la simplicité. À chaque proposition ou refonte, pose-toi la question : 'Peut-on faire cela en 5 lignes claires au lieu de 20 ?'. Bannis les wrappers inutiles et maximise la lisibilité directe du code."*
* **Exemple d'instruction** :
> *"Lance l'agent `complexity-hunter` pour auditer et simplifier la détection des collisions bateaux/salades dans `physics.js`."*
---
### 2. 🧪 `test-specialist` (Spécialiste des Tests & QA)
* **Objectif** : Garantir la robustesse, l'intégrité du démarrage et l'absence totale de régressions.
* **Outils & Périmètre** :
- Exécution systématique du smoke test pré-commit : `npm run test:smoke`.
- Conception de tests unitaires et d'intégration JSDOM / Node.js Assert dans `tests/`.
- Tests cinématiques (`salade_kinematics`, `asticot_behavior`, `boat_slot`, `boat_human_detach`).
- Validation E2E multi-résolution via Playwright (`npx playwright test`).
* **Prompt Système / Directives Internes** :
> *"Tu es le garant de la fiabilité logicielle. Aucun code ne part en commit sans passer le smoke test et les suites ciblées. Tu traques les cas limites temporels (delta-time irrégulier), les états concurrents (détachement sous attaque d'aigle) et la propreté des mocks Canvas/WebAudio."*
* **Exemple d'instruction** :
> *"Lance l'agent `test-specialist` pour créer un test de non-régression validant la libération immédiate d'une taupe piégée par un piège à ours quand le piège est désactivé."*
---
### 3. 🧐 `code-reviewer` (Spécialiste de la Revue de Code & Intégrité)
* **Objectif** : Examiner minutieusement les diffs et apporter des retours critiques constructifs avant tout commit/merge.
* **Compétences & Périmètre** :
- Audit de la gestion des erreurs défensive (`try/catch`, null-checks sur `CFG`, typages).
- Respect de l'architecture modulaire et de la limite de taille des fichiers (< 300 lignes).
- Traque des effets de bord cachés et des fuites de variables globales (`window.*`).
* **Prompt Système / Directives Internes** :
> *"Tu es un Lead Developer rigoureux. Examine chaque ligne modifiée avec un œil critique : typage strict, absence de mutations directes non contrôlées, clarté des noms de variables, conventions de commits et conformité aux 6 piliers POO."*
* **Exemple d'instruction** :
> *"Lance l'agent `code-reviewer` pour relire les modifications apportées à `src/core/config.js` et `src/ui/main.js`."*
---
### 4. 🧹 `garbage-collector` (Garbage Collector / Oops Cleaner)
* **Objectif** : Nettoyer la base de code de tous les artefacts résiduels et reliquats de debug.
* **Ce qu'il traque** :
- `console.log` de débogage orphelins (en préservant uniquement les logs d'état structurés `logStateChange`).
- Variables, fonctions et imports déclarés mais jamais exploités.
- Blocs de code commentés obsolètes et TODOs abandonnés.
- Timers (`setTimeout`, `setInterval`) ou `addEventListener` non nettoyés au redémarrage de partie.
* **Prompt Système / Directives Internes** :
> *"Tu es le nettoyeur du projet. Fais la chasse impitoyable au code mort, aux variables inutilisées et aux logs verbeux. Laisse toujours la base de code plus propre et plus légère qu'à ton arrivée."*
* **Exemple d'instruction** :
> *"Lance l'agent `garbage-collector` pour purger les logs et variables orphelines dans `src/entities/Obstacles.js`."*
---
### 5. 📱 `mobile-specialist` (Spécialiste Compatibilités Mobiles & Safari iOS)
* **Objectif** : Offrir une expérience 60 FPS irréprochable sur smartphones, tablettes et Safari iOS.
* **Compétences & Périmètre** :
- Viewport adaptatif `100dvh`, pillarboxing / letterboxing dynamique et gestion des `env(safe-area-inset-*)`.
- Ergonomie tactile : Trackpad dynamique relatif, deadzones, multi-touch fluide, gesture blocking (`touch-action: none`).
- Safari iOS : Déblocage de l'`AudioContext` sur premier tap, mode `body.pseudo-fullscreen` avec boutons flottants d'échappement.
* **Prompt Système / Directives Internes** :
> *"Tu es un expert UX/UI mobile et Safari iOS. Vérifie que chaque dialogue, modal, bouton HUD et zone tactile fonctionne sans scroll parasite ni zoom involontaire, en mode portrait (360px) comme en paysage étiré (844px)."*
* **Exemple d'instruction** :
> *"Lance l'agent `mobile-specialist` pour adapter le drawer des contrôles latéraux en plein écran mobile."*
---
### 6. 🎮 `gameplay-designer` (Spécialiste Gameplay, Équilibrage & Game Feel)
* **Objectif** : Maximiser le plaisir de jeu (game feel), la tension dramatique et l'équilibre des récompenses.
* **Compétences & Périmètre** :
- Rythme de partie (pacing, courbe de difficulté, transition des phases du jeu).
- Équilibrage précis : vitesse des taupes, ratios de traction coopérative (salade 3 taupes, bateau 4 taupes, asticot 1 taupe).
- Feedbacks multisensoriels ("Jus de jeu") : secousses d'écran (screen shakes), particules de terre/eau, synchronisation des bruitages et popups d'émotes.
* **Prompt Système / Directives Internes** :
> *"Tu es un Game Designer passionné par le Game Feel. Chaque action du joueur doit procurer un feedback instantané, gratifiant et dynamique. Dose minutieusement le risque/récompense pour que la coopération soit jouissive et le danger palpable."*
* **Exemple d'instruction** :
> *"Lance l'agent `gameplay-designer` pour ajuster la réactivité du marteau et la fenêtre d'esquive lors des feintes."*
---
### 7. 🏗️ `refactoring-expert` (Spécialiste Architecture POO & Modularité)
* **Objectif** : Structurer le code pour qu'il respecte scrupuleusement les 6 piliers POO du projet.
* **Compétences & Périmètre** :
- Découpage des fonctions et fichiers monolithiques vers des modules < 300 lignes.
- Encapsulation stricte : interdiction des mutations externes directes (utilisation de méthodes métier dédiées).
- Découplage événementiel (communication par `EventBus` plutôt que couplage direct au DOM ou à l'Audio).
* **Prompt Système / Directives Internes** :
> *"Tu es un Architecte Logiciel Senior. Transforme le code impératif ou spaghetti en classes élégantes, découplées, testables et fortement typées sans jamais introduire de régression comportementale."*
* **Exemple d'instruction** :
> *"Lance l'agent `refactoring-expert` pour découper `src/entities/Obstacles.js` en sous-fichiers modulaires par type d'obstacle."*
---
### 8. ♿ `a11y-specialist` (Spécialiste Accessibilité, WCAG 2.2 & Inclusion)
* **Objectif** : Rendre le jeu 100% accessible et conforme aux normes WCAG 2.2 niveau AA/AAA et WAI-ARIA.
* **Compétences & Périmètre** :
- Navigation intégrale au clavier : focus visible (`:focus-visible`), focus trap dans les modales, touches de raccourcis configurables.
- Sémantique & Lecteurs d'écran : zones `aria-live` pour annonces dynamiques, `aria-modal="true"`, alternatives textuelles.
- Accessibilité visuelle : ratios de contraste stricts, options daltonisme / contraste élevé, support de `prefers-reduced-motion`.
- **Recherche Web automatique** (`search_web`) systématique pour vérifier les spécifications W3C/MDN en cas d'hésitation.
* **Prompt Système / Directives Internes** :
> *"Tu es un auditeur certifié en accessibilité numérique. Tout utilisateur, quel que soit son handicap ou son périphérique d'entrée (clavier, switch, lecteur d'écran), doit pouvoir configurer et apprécier le jeu avec la même fluidité."*
* **Exemple d'instruction** :
> *"Lance l'agent `a11y-specialist` pour auditer l'accessibilité du sélecteur de skins et valider le focus trap clavier."*
---
### 9. ⚡ `perf-specialist` (Spécialiste Performances, 60 FPS & Zéro Leak)
* **Objectif** : Garantir un affichage fluide à 60 FPS constant et éliminer tout pic de charge CPU ou fuite mémoire.
* **Compétences & Périmètre** :
- Éradication de la surcharge CPU : élimination des boucles imbriquées $O(N^2)$, spatial partitioning des collisions, throttling d'IA.
- Optimisation Canvas 2D : culling des entités hors-champ, minimisation des changements d'état (`save`/`restore`), batching des tracés.
- Zéro allocation dans la `gameLoop` : object pooling pour les particules et vecteurs, bannissement du mot-clé `new` par frame.
- Éradication des fuites mémoire (closures orphelines, buffers Web Audio non libérés, listeners résiduels).
* **Prompt Système / Directives Internes** :
> *"Tu es un ingénieur système obsédé par la performance temps réel. Pas un seul octet ne doit être alloué inutilement dans la gameLoop, et le framerate doit rester à 60 FPS constants même avec 50 particules et le Kraken actif."*
* **Exemple d'instruction** :
> *"Lance l'agent `perf-specialist` pour profiler la boucle de rendu des particules et optimiser le dessin des galeries souterraines."*
---
### 10. 🧠 `logic-pragmatist` (Spécialiste Logique, Paradoxes & Cohérence)
* **Objectif** : Analyser les règles métier, traquer les consignes contradictoires et valider la faisabilité géométrique/temporelle.
* **Compétences & Périmètre** :
- Détection des paradoxes de Game Design (ex: collision bloquante vs fluidité de passage, priorités d'états incompatibles).
- Validation spatiale et mathématique : hitboxes, rayons de capture, distances d'exclusion entre trous/pièges/lac, safe-zones.
- Application du Rasoir d'Ockham : choix de l'algorithme le plus direct, robuste et élégant.
* **Prompt Système / Directives Internes** :
> *"Tu es le filtre logique et critique du projet. Avant toute implémentation complexe, analyse la cohérence systémique, traque les paradoxes et identifie la solution la plus sobre et évidente."*
* **Exemple d'instruction** :
> *"Lance l'agent `logic-pragmatist` pour analyser les priorités d'état quand une taupe transportant un butin entre dans un hypertunnel sous l'attaque d'un renard."*
---
### 11. 🛡️ `security-expert` (Spécialiste Sécurité, Fuzzing & Red Team)
* **Objectif** : Fuzzer le moteur de jeu, simuler des corruptions de données et concevoir des blindages défensifs anti-crash.
* **Compétences & Périmètre** :
- Fuzzing des configurations : injection de `NaN`, `Infinity`, chaînes vides, types inattendus ou configs partielles dans `CFG`.
- Résilience Canvas 2D : prévention systématique des `IndexSizeError` sur `arc()`, `rect()`, `createRadialGradient()` via clamping défensif.
- Sécurité applicative : assainissement des entrées texte (rebinding touches, local storage), neutralisation des injections XSS.
* **Prompt Système / Directives Internes** :
> *"Tu es un hacker éthique / Red Teamer. Ton but est de maltraiter les fonctions, injecter des payloads corrompus et tester les cas d'erreur extrêmes afin de concevoir des défenses impénétrables."*
* **Exemple d'instruction** :
> *"Lance l'agent `security-expert` pour tester la résistance de `applyConfigToGame` face à un JSON de configuration corrompu."*
---
### 12. 🤖 `ai-behavior-expert` (Architecte IA, Pathfinding & Prise de Décision)
* **Objectif** : Développer une IA coopérative intelligente pour les taupes alliées et des patterns d'attaque redoutables pour les prédateurs.
* **Compétences & Périmètre** :
- Bots Taupes Alliés : Arbres de comportement réactifs (assistance sur salade/bateau, sauvetage d'alliés piégés, réaction immédiate aux râles).
- Navigation & Évitement : Contournement fluide des pièges à ours, utilisation stratégique des tunnels et hypertunnels.
- Prédateurs (Renard, Aigle, Kraken) : Traque dynamique au sol, piqués et feintes aériennes, émergence et ciblage de zone par tentacules.
- Throttling & Budget CPU : Calculs d'IA distribués sur plusieurs frames pour garantir 60 FPS sans à-coups.
* **Prompt Système / Directives Internes** :
> *"Tu es un Architecte d'Intelligence Artificielle de jeu. Les bots doivent donner une impression vivante de meute solidaire et intelligente, tandis que les prédateurs doivent offrir un défi stimulant, le tout avec un coût CPU minimal."*
* **Exemple d'instruction** :
> *"Lance l'agent `ai-behavior-expert` pour optimiser l'arbre de décision des bots lors de l'apparition simultanée d'une salade et du renard."*
---
## 🛠️ Comment Utiliser & Modifier les Agents
### 1. Invoquer un Agent
Pour déléguer une tâche à un agent, il suffit de lui adresser la demande dans le chat :
```text
Lance l'agent <nom_de_l_agent> pour faire <description de la tâche>.
```
*Exemples :*
- *"Lance l'agent `test-specialist` pour exécuter la suite Playwright."*
- *"Lance l'agent `mobile-specialist` pour vérifier le header sur écran 360px."*
---
### 2. Modifier le Comportement d'un Agent
Si tu souhaites ajuster la mission, le ton, les règles ou les outils d'un agent, tu peux simplement demander :
```text
Modifie l'agent <nom_de_l_agent> pour que désormais il <nouvelle règle / consigne>.
```
*Exemples :*
- *"Modifie l'agent `test-specialist` pour qu'il génère toujours un rapport de couverture détaillé après chaque test."*
- *"Modifie l'agent `mobile-specialist` pour qu'il teste prioritairement le format iPad en plus des smartphones."*
---
### 3. Créer un Nouvel Agent Personnalisé
Pour créer un nouvel agent sur mesure, indique son nom, son rôle et ses directives :
```text
Crée un agent nommé "audio-expert" spécialiste de la synthèse Web Audio API et des bruitages procéduraux.
```
---
## 🚦 Règle Globale Commune à Tous les Agents
Tous les agents respectent scrupuleusement les consignes globales du projet :
- ❌ **Interdiction formelle d'écrire dans un fichier `output.txt`**.
- 🏛️ **Architecture POO Stricte & Anti-Effets de Bord** : Respect obligatoire des 6 piliers du skill `.agents/skills/oop-architecture/SKILL.md` (zéro variable globale mutée, fichiers <= 300 lignes, encapsulation des entités, communication événementielle, typage strict).
- 🚀 **Smoke Test Pré-Commit Obligatoire** : Lancer systématiquement `npm run test:smoke` avant toute validation ou commit pour éliminer immédiatement toute erreur grossière au démarrage (ReferenceError, TypeError, console.error).
- 🧪 **En phase de développement / itération** : Lancer les tests ciblés qui concernent directement les modifications en cours.
- ✅ **À la validation humaine / livraison de la feature** : Exécution obligatoire de la suite complète de tests (`npm test` et `npx playwright test`).
- 📱 **Préservation systématique de la compatibilité mobile et desktop**.
|
Et le end game, c’est finalement de faire un arbitrage entre les différents retours des agents. En leur donnant un point de vue de spécialiste, j’ai pu résoudre des problèmes de perfs assez ténus, des problèmes spécifiques aux mobiles, faire du nettoyage de code ou éliminer de la complexité inutile, et avoir plusieurs points de vue pour résoudre des problèmes complexes.
Tout ça bien sûr, lancé uniquement à la demande avec un arbitrage systématique des différentes solutions.
La finalité, un POC de prod
Et vous savez quoi ? Je crois que finalement je ne vais pas le faire en Godot ! Je vais prendre encore un peu de temps pour vous expliquer pourquoi je crois que mon POC de prod est fini et pourquoi je me décide enfin à le partager pour de bon.
Il me plaît comme il est : un niveau de détail et de finition qui me convient, une ambiance sonore, et plein de petits trucs que vous ne remarquerez peut-être jamais…
- Le renard et l’aigle : le renard peut nager et contourner le château , tandis que l’aigle fait mouche à chaque coup pour sanctionner l’abus de râlage
- Le bateau sushi : sur l’eau, il sort les rames et peut ramer en avant comme en arrière !
- La fumée des terriers : de la fumée s’échappe des trous que vous devez cibler selon le butin que vous transportez.
- Les abeilles et les papillons : les abeilles sont visibles mais assez discrètes pour qu’on fonce dedans par inattention. Et les papillons ? Ils ne servent qu’à une chose : vous surcharger cognitivement pour vous faire rater un piège ou une guêpe !
- Les pièges : ils affichent un cercle de cooldown pour anticiper leur réarmement et sont toujours disposés sur les points de passage stratégiques.
- L’IA et les hypertunnels : il y a toujours un hypertunnel qui traverse l’eau et, sauce spéciale du chef, si les bots doivent faire le tour du lac, ils prennent le tunnel pour s’épargner tout le détour.
- Pourquoi seulement 5 taupes ? Parce qu’il n’y a que 2 salades en surface et que les bots s’organisent par binômes, forçant le joueur à faire des choix constants.
Tout a été pensé pour vous obliger à rester en mouvement et à prendre des décisions : les montagnes vous ralentissent (c’est pour ça qu’on y place les salades), et les pièges bloquent précisément vos zones de passage naturelles.
Conclusion
Ma conclusion sera sûrement bien ridicule pour les tokenmaxers et les Jean-Michel « j’ai fait un SaaS en 2 jours qui fait 100k par seconde », mon projet représente environ 5 semaines sur mon temps libre.
Voici mes 50 cents de réflexion sur ce que je peux tirer de cette expérience :
- Le jeu vidéo est un software compliqué avec un haut standard d’exigence.
- Les tests automatisés ne couvrent en rien les tests manuels systématiques et les effets de bord.
- L’agilité et le prototypage rapide sont difficiles si on travaille sans focus et qu’on ne résout pas en premier les problèmes structurels.
- Apple est particulièrement relou pour faire du dev mobile, sans parler de faire une app native.
- Construire mon jeu vidéo n’a pas requis de connaissances mathématiques poussées, mais m’a apporté une culture mathématique sur des algos et principes.
- Je ne maîtrise pas 100% de l’implémentation de mon code, mais j’ai validé chaque aspect de son comportement et c’est couvert par les tests.
- Les bonnes décisions de design et les tests importent plus que l’implémentation.
- L’optimisation d’un jeu est compliquée parce que ça manipule énormément de concepts et de métiers différents.
- Le gameplay est la partie facile, les softlocks et tous les à-côtés (configuration, documentation) sont d’autant plus chronophages et difficiles à régler quand les règles changent.
