Cursor + Unity Développement de Jeux : Guide d'Intégration Complet

Unity est l'un des moteurs de jeu les plus populaires, et l'associer aux capacités d'IA de Cursor peut accélérer considérablement votre flux de travail de développement de jeux. Ce guide couvre tout ce dont vous avez besoin pour configurer Cursor pour le développement Unity, de la configuration du projet aux scripts assistés par IA.

Prérequis

Avant de commencer :

• Unity 2022.3 LTS ou plus récent installé
• Cursor avec plan Pro (recommandé pour les projets plus importants)
• .NET SDK (pour la prise en charge du serveur de langage C#)
• Projet Unity avec dossier Scripts

Étape 1 : Générer les fichiers de projet C# dans Unity

Cursor a besoin des fichiers .csproj pour IntelliSense et la compréhension du contexte IA.

Activer les outils externes

1. Ouvrir l'éditeur Unity
2. Aller dans Edit > Preferences (Windows) ou Unity > Settings (macOS)
3. Naviguer vers External Tools
4. Définir External Script Editor sur Cursor (ou parcourir jusqu'à l'exécutable Cursor)
5. Cocher Generate .csproj files for:
   • Registry packages
   • Build-in packages
   • Local packages
   • Embedded packages
6. Cliquer sur Regenerate project files

Alternative : Package VS Code manuel

Si Cursor n'apparaît pas dans la liste :

1. Installer le package Visual Studio Code Editor dans Unity :
   • Window > Package Manager
   • Rechercher "Visual Studio Editor"
   • Installer/Mettre à jour vers la dernière version
2. Définir External Script Editor sur Visual Studio Code
3. Régénérer les fichiers de projet

Étape 2 : Ouvrir le projet Unity dans Cursor

Méthode 1 : Depuis Unity

1. Double-cliquer sur n'importe quel script C# dans la fenêtre Project d'Unity
2. Unity ouvrira Cursor avec le projet chargé

Méthode 2 : Ouverture directe

# Naviguer vers votre projet Unity
cd ~/MyUnityProject

# Ouvrir dans Cursor
cursor .

Méthode 3 : Utiliser le fichier .sln

# Ouvrir directement le fichier solution
cursor MyUnityProject.sln

Étape 3 : Configurer IntelliSense

Vérifier C# Dev Kit

1. Dans Cursor, ouvrir Extensions (Cmd/Ctrl + Shift + X)
2. S'assurer que C# Dev Kit est installé
3. Sinon, l'installer depuis le marketplace

Vérifier le chargement du projet

Après avoir ouvert votre projet Unity :

1. Attendre que le serveur de langage C# se charge (la barre d'état affiche le chargement)
2. Ouvrir n'importe quel fichier script
3. Tester IntelliSense en tapant transform. — vous devriez voir des suggestions d'API Unity

Dépannage d'IntelliSense

Si IntelliSense ne fonctionne pas :

# Régénérer les fichiers de projet depuis la ligne de commande
# Sur macOS
/Applications/Unity/Hub/Editor/2022.3.x/Unity.app/Contents/MacOS/Unity \
  -quit -batchmode -projectPath ~/MyUnityProject

# Supprimer les fichiers de projet en cache
rm -rf ~/MyUnityProject/.vscode
rm -f ~/MyUnityProject/*.sln
rm -f ~/MyUnityProject/Assembly-CSharp*.csproj

Puis régénérer depuis les préférences External Tools d'Unity.

Étape 4 : Règles Cursor pour Unity

Créer .cursor/rules/unity-development.mdc :

---
description: 'Directives de développement Unity pour Cursor'
globs: ['Assets/**/*.cs']
alwaysApply: true
---

# Règles de développement Unity

## Style de code
- Utiliser PascalCase pour les méthodes et propriétés publiques
- Utiliser camelCase pour les champs privés (préfixe avec underscore)
- Utiliser SerializeField au lieu des champs publics pour l'exposition dans l'inspecteur
- Mettre en cache les références de composants dans Awake() ou Start()

## Performance
- Éviter GetComponent() dans Update() — mettre en cache dans Start()
- Utiliser l'object pooling pour les objets fréquemment instanciés
- Préférer RaycastNonAlloc à RaycastAll
- Utiliser les Coroutines pour les opérations temporisées au lieu des vérifications Update()

## Patterns
- Utiliser ScriptableObjects pour les données/configurations partagées
- Implémenter la logique de jeu dans MonoBehaviours, les données dans ScriptableObjects
- Utiliser Events/Actions pour la communication découplée
- Préférer la composition à l'héritage

Étape 5 : Scripting Unity assisté par IA

Génération de composants

Exemple de prompt :

Créer un script de contrôleur de joueur pour un platformer 2D avec :
- Mouvement fluide avec accélération/décélération
- Hauteur de saut variable selon la durée d'appui sur le bouton
- Temps de coyote pour des sauts plus indulgents
- Détection du sol en utilisant des raycasts
- Entrées en utilisant le nouveau Input System

Refactoring de MonoBehaviours

Exemple de prompt :

Refactoriser ce PlayerController pour utiliser :
1. Le pattern state machine (états Idle, Run, Jump, Fall)
2. ScriptableObject pour les paramètres de mouvement
3. Système de santé basé sur les événements
4. Séparer la gestion des entrées de la logique de mouvement

Création d'outils d'éditeur

Créer une fenêtre d'éditeur personnalisée qui :
- Liste tous les GameObjects dans la scène sans colliders
- Affiche des boutons pour ajouter BoxCollider ou SphereCollider
- Affiche le nombre d'objets par layer
- A un bouton "Tout sélectionner"

Étape 6 : Déboguer Unity dans Cursor

Attacher le débogueur

1. Installer l'extension Unity dans Cursor
2. Ouvrir votre projet Unity dans Cursor
3. Appuyer sur F5 ou aller dans Run > Start Debugging
4. Sélectionner Unity Debugger
5. Dans Unity, entrer en mode Play
6. Les points d'arrêt seront maintenant atteints

Intégration de la console

Utiliser le terminal de Cursor pour exécuter Unity en mode batch :

# Exécuter les tests Unity depuis la ligne de commande
Unity -batchmode -quit -projectPath ~/MyUnityProject -executeMethod BuildScript.RunTests

Étape 7 : Serveur MCP Unity (Avancé)

Pour une intégration avancée, utiliser le Serveur MCP Unity :

Configuration

1. Installer le package Unity MCP :

# Dans Unity Package Manager
# Ajouter depuis l'URL git : https://github.com/unity-mcp/server.git

2. Configurer dans les paramètres MCP de Cursor :

{
  "mcpServers": {
    "unity": {
      "command": "dotnet",
      "args": ["run", "--project", "path/to/unity-mcp"]
    }
  }
}

Ce que vous pouvez faire

• Interroger la hiérarchie de la scène
• Créer/modifier des GameObjects
• Ajuster les propriétés des composants
• Construire et tester depuis Cursor

Exemple :

[@unity] Créer un nouveau GameObject nommé "EnemySpawner" à la position (0, 5, 0) et ajouter un script MonoBehaviour avec un intervalle de spawn de 2 secondes.

Bonnes pratiques

Structure du projet

Assets/
  Scripts/
    Core/           # Game managers, singletons
    Player/         # Scripts liés au joueur
    Enemies/        # IA ennemie et contrôleurs
    UI/             # Contrôleurs UI et managers
    Utils/          # Méthodes d'extension, helpers
  ScriptableObjects/
    PlayerData/     # Configurations du joueur
    EnemyData/      # Configurations ennemies
    LevelData/      # Paramètres de niveau
  Editor/           # Outils d'éditeur personnalisés

Contrôle de version

Ajouter à .gitignore :

# Unity
[Ll]ibrary/
[Tt]emp/
[Oo]bj/
[Bb]uild/
[Bb]uilds/
[Ll]ogs/
[Uu]ser[Ss]ettings/

# Cursor
.cursor/
.vscode/

Profilage des performances

Utiliser Cursor pour analyser les performances :

Réviser cette méthode Update() et identifier les problèmes de performance :
[coller le code]

Suggérer des optimisations en utilisant :
1. L'object pooling
2. Les références mises en cache
3. Des structures de données efficaces

Problèmes courants et solutions

Problème	Solution
IntelliSense ne fonctionne pas	Régénérer les fichiers .csproj dans Unity
Les points d'arrêt ne sont pas atteints	S'assurer qu'Unity est en mode Play
Suggestions d'API Unity manquantes	Vérifier que C# Dev Kit est installé
Chargement lent du projet	Exclure le dossier Library/ de l'indexation Cursor
L'IA suggère du code non-Unity	Ajouter des règles Unity à .cursor/rules/

Commandes rapides

Tâche	Commande
Régénérer les fichiers de projet	Unity > Edit > Preferences > External Tools > Regenerate
Ouvrir un script dans Cursor	Double-cliquer sur le script dans Unity
Attacher le débogueur	F5 dans Cursor
Rechercher l'API Unity	Utiliser le symbole @ dans le chat Cursor

Ressources connexes

• Guide Cursor C# Dev Kit
• Utiliser efficacement les règles Cursor
• Gérer les grands projets avec Cursor