Unity Code Generation
Generation de code C# Unity production-ready. Analyse le projet existant, choisit le pattern adapte, genere code + tests.
Ce que fait cette skill
- Analyse la demande (feature, systeme, type de composant)
- Inspecte la codebase existante (conventions, namespaces, assembly definitions)
- Choisit le pattern architectural via un arbre de decision
- Genere du C# propre avec les attributs Unity adequats
- Genere les tests unitaires correspondants (NUnit)
- Place les fichiers dans les bons repertoires
Prerequis
- Un projet Unity existant avec une structure de dossiers identifiable
- Acces aux fichiers du projet via les outils Claude Code (Read, Write, Edit, Grep, Glob)
- Aucune dependance MCP Unity requise
Demarrage rapide
- L'utilisateur decrit la feature ou le composant souhaite
- Inspecter le projet avec Glob/Grep pour comprendre les conventions
- Appliquer l'arbre de decision pour choisir le pattern
- Generer le code + tests dans les bons repertoires
Arbre de decision
La chose a creer...
│
├─ Stocke des donnees configurables (stats, settings) ?
│ └─ OUI → ScriptableObject Data Container
│
├─ Sert de canal de communication entre systemes ?
│ └─ OUI → ScriptableObject Event Channel
│
├─ Vit sur un GameObject dans la scene ?
│ ├─ Controle du comportement runtime ? → MonoBehaviour
│ └─ Juste un data holder sur un GO ? → MonoBehaviour simple (struct-like)
│
├─ Definit un contrat que plusieurs classes implementent ?
│ └─ OUI → Interface (+ implementations MonoBehaviour ou pure C#)
│
├─ Logique pure sans dependance Unity (math, algo, parsing) ?
│ └─ OUI → Pure C# class (pas de MonoBehaviour)
│
├─ Utilitaire stateless reutilisable ?
│ └─ OUI → Static class ou extension methods
│
├─ Gestion d'etats discrets (joueur, IA, game flow) ?
│ └─ OUI → State Machine (enum + switch ou state classes)
│
├─ Gestion d'inputs avec undo/replay ?
│ └─ OUI → Command Pattern
│
├─ Objets crees/detruits frequemment (projectiles, VFX) ?
│ └─ OUI → Object Pool
│
├─ Logique asynchrone (chargement, timer, sequence) ?
│ └─ OUI → Async Awaitable Component (Unity 6+)
│
└─ Milliers d'entites similaires a traiter en parallele ?
└─ OUI → ECS (DOTS) — hors scope de cette skill
Guide etape par etape
Etape 1 — Analyser la demande
Identifier clairement :
- Quoi : feature, systeme, composant, data container, event ?
- Ou : quel module du projet ? quel assembly definition ?
- Interactions : avec quels systemes existants ?
- Donnees : quelles donnees manipulees, persistees, serialisees ?
Etape 2 — Inspecter la codebase existante
Avant d'ecrire une seule ligne, toujours executer ces recherches :
Glob("Assets/**/*.asmdef") → assembly definitions, structure modules
Glob("Assets/**/*.cs", limit aux dossiers cibles) → fichiers existants
Grep("namespace ", type: "cs") → conventions de namespace
Grep("class .* : MonoBehaviour", type: "cs") → MonoBehaviours existants
Grep("class .* : ScriptableObject", type: "cs") → SOs existants
Grep("\\[SerializeField\\]", fichier cible) → style de serialisation
Identifier :
- Le pattern de nommage (
_camelCase pour private ? prefixes ?)
- La structure de namespace (
Game.Core, Game.Player, etc.)
- Les conventions d'attributs (
[Header], [Tooltip], [Range])
- Les patterns deja utilises (events, interfaces, state machines)
Etape 3 — Choisir le pattern
Appliquer l'arbre de decision ci-dessus. En cas de doute, privilegier la composition et les patterns simples.
Etape 4 — Generer le code C#
Appliquer systematiquement ces conventions Unity :
Attributs obligatoires :
[SerializeField] private pour les champs editables dans l'Inspector (jamais public)
[RequireComponent(typeof(X))] quand le script depend d'un autre composant
[Header("Section")] pour organiser l'Inspector par groupes logiques
[Tooltip("Explication")] sur les champs non evidents
[Range(min, max)] sur les valeurs numeriques bornees
Structure d'un fichier :
// 1. Namespace
// 2. Attributs de classe ([RequireComponent], [DisallowMultipleComponent])
// 3. Declaration de classe
// 4. Constantes
// 5. [SerializeField] champs groupes par [Header]
// 6. Events publics
// 7. Proprietes publiques (read-only si possible)
// 8. Champs prives
// 9. Awake / OnEnable / Start
// 10. OnDisable / OnDestroy
// 11. Update / FixedUpdate (si necessaire)
// 12. Methodes publiques
// 13. Methodes privees
// 14. Coroutines
Namespace : matcher la structure existante. Si le projet utilise Game.Player, ne pas inventer MyNamespace.Scripts.
Etape 5 — Generer les tests
Pour chaque fichier genere, creer le test correspondant :
- EditMode tests : logique pure, calculs, state machines, data validation
- PlayMode tests : comportement MonoBehaviour, interactions composants, coroutines
Placement des tests :
Assets/Tests/EditMode/ → tests logique (assembly ref: Game.Core, etc.)
Assets/Tests/PlayMode/ → tests comportement (assembly ref + UnityEngine.TestRunner)
Etape 6 — Placer les fichiers
- Respecter les assembly definitions et la structure de dossiers existante
- Les tests vont dans le dossier
Tests/ miroir
- Produire : fichier(s) C# source, tests NUnit, resume (pattern choisi, fichiers crees)
Regles strictes
TOUJOURS :
- Inspecter la codebase existante avant de generer (Glob + Grep)
- Matcher les conventions de nommage du projet
- Generer les tests en meme temps que le code
- Utiliser
[SerializeField] private pour les champs Inspector
- Utiliser des namespaces coherents avec la structure projet
- Ajouter
[Header] et [Tooltip] pour la lisibilite Inspector
- Privilegier la composition sur l'heritage
- Desubscribe les events dans
OnDisable ou OnDestroy
JAMAIS :
- Coder sans avoir inspecte le projet existant
- Utiliser le pattern Singleton MonoBehaviour (preferer SO ou Service Locator)
- Utiliser des champs
public (utiliser [SerializeField] private + propriete)
- Utiliser
Find*() ou SendMessage() avec des strings
- Ecrire de la logique dans
Update() sans cacher les references
- Generer du code sans tests
- Creer un fichier de plus de 500 lignes (modulariser)
- Hardcoder des valeurs magiques (utiliser SO ou
const)
Skills connexes
- Prototype rapide sans architecture ? Utiliser
/proto (Unity Rapid Proto)
- Refactorer du code existant ? Utiliser
/unity-refactor (Unity Refactor)
- Creer un custom inspector pour le composant genere ? Utiliser
/unity-editor-tools (Unity Editor Tools)
- Generer et executer les tests NUnit ? Utiliser
/unity-test (Unity Test)
- Generer un systeme audio ? Utiliser
/unity-audio (Unity Audio)
- Implementer la sauvegarde ? Utiliser
/unity-save (Unity Save System)
Troubleshooting
| Probleme |
Solution |
| Pas de convention claire dans le projet |
Utiliser les conventions Unity standard (_camelCase, PascalCase) et creer un patron coherent |
| Pas d'assembly definition existante |
Generer le code dans le dossier principal, proposer de creer des asmdef si le projet grossit |
| Le namespace ne correspond a rien |
Utiliser le nom du projet + module, ex: ProjectName.Module |
| Tests impossibles car tout est couple |
Extraire la logique dans des classes pure C# testables, garder le MonoBehaviour comme "glue" |
| Le projet utilise des Singletons partout |
Ne pas en ajouter de nouveaux, proposer une migration progressive vers SO/Service Locator |
| Conflit de nommage avec un package tiers |
Prefixer le namespace avec le nom du projet |
Templates de code detailles : voir references/code-templates.md.
1---2name: unity-code-gen3description: "Generation de code C# Unity production-ready a partir de specifications fonctionnelles. Analyse la codebase existante, choisit le bon pattern architectural, genere le code et les tests. Triggers: /unity-code-gen, 'generer script Unity', 'creer composant', 'nouveau MonoBehaviour', 'creer ScriptableObject', 'generer code Unity', 'nouveau systeme Unity', 'ajouter feature Unity'. Utiliser quand l'utilisateur demande de creer un nouveau script, composant, systeme ou feature dans Unity. Produit des fichiers C# respectant les conventions du projet avec tests NUnit associes."4metadata:5 source: https://skillmd.com/skills/juliankerignard/unity-code-gen6---78# Unity Code Generation910Generation de code C# Unity production-ready. Analyse le projet existant, choisit le pattern adapte, genere code + tests.1112## Ce que fait cette skill13141. Analyse la demande (feature, systeme, type de composant)152. Inspecte la codebase existante (conventions, namespaces, assembly definitions)163. Choisit le pattern architectural via un arbre de decision174. Genere du C# propre avec les attributs Unity adequats185. Genere les tests unitaires correspondants (NUnit)196. Place les fichiers dans les bons repertoires2021## Prerequis2223- Un projet Unity existant avec une structure de dossiers identifiable24- Acces aux fichiers du projet via les outils Claude Code (Read, Write, Edit, Grep, Glob)25- Aucune dependance MCP Unity requise2627## Demarrage rapide28291. L'utilisateur decrit la feature ou le composant souhaite302. Inspecter le projet avec Glob/Grep pour comprendre les conventions313. Appliquer l'arbre de decision pour choisir le pattern324. Generer le code + tests dans les bons repertoires3334## Arbre de decision3536```37La chose a creer...38│39├─ Stocke des donnees configurables (stats, settings) ?40│ └─ OUI → ScriptableObject Data Container41│42├─ Sert de canal de communication entre systemes ?43│ └─ OUI → ScriptableObject Event Channel44│45├─ Vit sur un GameObject dans la scene ?46│ ├─ Controle du comportement runtime ? → MonoBehaviour47│ └─ Juste un data holder sur un GO ? → MonoBehaviour simple (struct-like)48│49├─ Definit un contrat que plusieurs classes implementent ?50│ └─ OUI → Interface (+ implementations MonoBehaviour ou pure C#)51│52├─ Logique pure sans dependance Unity (math, algo, parsing) ?53│ └─ OUI → Pure C# class (pas de MonoBehaviour)54│55├─ Utilitaire stateless reutilisable ?56│ └─ OUI → Static class ou extension methods57│58├─ Gestion d'etats discrets (joueur, IA, game flow) ?59│ └─ OUI → State Machine (enum + switch ou state classes)60│61├─ Gestion d'inputs avec undo/replay ?62│ └─ OUI → Command Pattern63│64├─ Objets crees/detruits frequemment (projectiles, VFX) ?65│ └─ OUI → Object Pool66│67├─ Logique asynchrone (chargement, timer, sequence) ?68│ └─ OUI → Async Awaitable Component (Unity 6+)69│70└─ Milliers d'entites similaires a traiter en parallele ?71 └─ OUI → ECS (DOTS) — hors scope de cette skill72```7374## Guide etape par etape7576### Etape 1 — Analyser la demande7778Identifier clairement :79- **Quoi** : feature, systeme, composant, data container, event ?80- **Ou** : quel module du projet ? quel assembly definition ?81- **Interactions** : avec quels systemes existants ?82- **Donnees** : quelles donnees manipulees, persistees, serialisees ?8384### Etape 2 — Inspecter la codebase existante8586Avant d'ecrire une seule ligne, toujours executer ces recherches :8788```89Glob("Assets/**/*.asmdef") → assembly definitions, structure modules90Glob("Assets/**/*.cs", limit aux dossiers cibles) → fichiers existants91Grep("namespace ", type: "cs") → conventions de namespace92Grep("class .* : MonoBehaviour", type: "cs") → MonoBehaviours existants93Grep("class .* : ScriptableObject", type: "cs") → SOs existants94Grep("\\[SerializeField\\]", fichier cible) → style de serialisation95```9697Identifier :98- Le pattern de nommage (`_camelCase` pour private ? prefixes ?)99- La structure de namespace (`Game.Core`, `Game.Player`, etc.)100- Les conventions d'attributs (`[Header]`, `[Tooltip]`, `[Range]`)101- Les patterns deja utilises (events, interfaces, state machines)102103### Etape 3 — Choisir le pattern104105Appliquer l'arbre de decision ci-dessus. En cas de doute, privilegier la composition et les patterns simples.106107### Etape 4 — Generer le code C#108109Appliquer systematiquement ces conventions Unity :110111**Attributs obligatoires :**112- `[SerializeField] private` pour les champs editables dans l'Inspector (jamais `public`)113- `[RequireComponent(typeof(X))]` quand le script depend d'un autre composant114- `[Header("Section")]` pour organiser l'Inspector par groupes logiques115- `[Tooltip("Explication")]` sur les champs non evidents116- `[Range(min, max)]` sur les valeurs numeriques bornees117118**Structure d'un fichier :**119```csharp120// 1. Namespace121// 2. Attributs de classe ([RequireComponent], [DisallowMultipleComponent])122// 3. Declaration de classe123// 4. Constantes124// 5. [SerializeField] champs groupes par [Header]125// 6. Events publics126// 7. Proprietes publiques (read-only si possible)127// 8. Champs prives128// 9. Awake / OnEnable / Start129// 10. OnDisable / OnDestroy130// 11. Update / FixedUpdate (si necessaire)131// 12. Methodes publiques132// 13. Methodes privees133// 14. Coroutines134```135136**Namespace :** matcher la structure existante. Si le projet utilise `Game.Player`, ne pas inventer `MyNamespace.Scripts`.137138### Etape 5 — Generer les tests139140Pour chaque fichier genere, creer le test correspondant :141142- **EditMode tests** : logique pure, calculs, state machines, data validation143- **PlayMode tests** : comportement MonoBehaviour, interactions composants, coroutines144145Placement des tests :146```147Assets/Tests/EditMode/ → tests logique (assembly ref: Game.Core, etc.)148Assets/Tests/PlayMode/ → tests comportement (assembly ref + UnityEngine.TestRunner)149```150151### Etape 6 — Placer les fichiers152153- Respecter les assembly definitions et la structure de dossiers existante154- Les tests vont dans le dossier `Tests/` miroir155- Produire : fichier(s) C# source, tests NUnit, resume (pattern choisi, fichiers crees)156157## Regles strictes158159**TOUJOURS :**160- Inspecter la codebase existante avant de generer (Glob + Grep)161- Matcher les conventions de nommage du projet162- Generer les tests en meme temps que le code163- Utiliser `[SerializeField] private` pour les champs Inspector164- Utiliser des namespaces coherents avec la structure projet165- Ajouter `[Header]` et `[Tooltip]` pour la lisibilite Inspector166- Privilegier la composition sur l'heritage167- Desubscribe les events dans `OnDisable` ou `OnDestroy`168169**JAMAIS :**170- Coder sans avoir inspecte le projet existant171- Utiliser le pattern Singleton MonoBehaviour (preferer SO ou Service Locator)172- Utiliser des champs `public` (utiliser `[SerializeField] private` + propriete)173- Utiliser `Find*()` ou `SendMessage()` avec des strings174- Ecrire de la logique dans `Update()` sans cacher les references175- Generer du code sans tests176- Creer un fichier de plus de 500 lignes (modulariser)177- Hardcoder des valeurs magiques (utiliser SO ou `const`)178179---180181## Skills connexes182183- Prototype rapide sans architecture ? Utiliser `/proto` (Unity Rapid Proto)184- Refactorer du code existant ? Utiliser `/unity-refactor` (Unity Refactor)185- Creer un custom inspector pour le composant genere ? Utiliser `/unity-editor-tools` (Unity Editor Tools)186- Generer et executer les tests NUnit ? Utiliser `/unity-test` (Unity Test)187- Generer un systeme audio ? Utiliser `/unity-audio` (Unity Audio)188- Implementer la sauvegarde ? Utiliser `/unity-save` (Unity Save System)189190## Troubleshooting191192| Probleme | Solution |193|----------|----------|194| Pas de convention claire dans le projet | Utiliser les conventions Unity standard (`_camelCase`, `PascalCase`) et creer un patron coherent |195| Pas d'assembly definition existante | Generer le code dans le dossier principal, proposer de creer des asmdef si le projet grossit |196| Le namespace ne correspond a rien | Utiliser le nom du projet + module, ex: `ProjectName.Module` |197| Tests impossibles car tout est couple | Extraire la logique dans des classes pure C# testables, garder le MonoBehaviour comme "glue" |198| Le projet utilise des Singletons partout | Ne pas en ajouter de nouveaux, proposer une migration progressive vers SO/Service Locator |199| Conflit de nommage avec un package tiers | Prefixer le namespace avec le nom du projet |200201Templates de code detailles : voir `references/code-templates.md`.