Ultimate Guide to Unity C# Game Development Rules for Cursor AI

## Getting Started with Cursor Rules for Unity C# Game Dev Hey there, fellow game developer! If you're diving into Unity with C# and want to supercharge your workflow using Cursor AI, you're in the right place. Cursor's `.cursorrules` files are game-changers—they guide the AI to follow best practices specific to your project. This guide rewrites and expands on the essential rules for Unity game development, turning them into an actionable, step-by-step playbook. We'll cover everything from project structure to optimization, with real-world examples and code snippets to make it stick. Whether you're a solo indie dev or part of a team, these rules ensure clean, performant, and maintainable code. Let's break it down section by section. ### 1. Project Architecture and Organization Start strong by structuring your Unity project like a pro. Cursor AI should always prioritize a modular setup to keep things scalable. - **Core Folders**: Organize into `Assets/Scripts/`, subdivided by feature like `Core/`, `UI/`, `Gameplay/`, `Managers/`. Use `Editor/` for custom tools only. - **Namespaces**: Every script gets a namespace matching its folder path, e.g., `namespace MyGame.Core.Player { }`. This avoids naming clashes and improves IntelliSense. - **Assembly Definitions**: Split large projects into assemblies (.asmdef files) for faster compilation. Cursor will remind you to create them for major systems. **Example**: Imagine a player controller. Instead of dumping it in a flat folder: ```csharp namespace MyGame.Gameplay.Player { public class PlayerController : MonoBehaviour { } } ``` This keeps your project tidy as it grows from prototype to full game. ### 2. Naming Conventions and Code Style Consistency is key in team environments or when revisiting your own code months later. Enforce these religiously: - **Classes and Methods**: PascalCase (e.g., `PlayerHealthManager`). - **Fields and Variables**: camelCase (e.g., `currentHealth`). - **Constants**: UPPER_SNAKE_CASE (e.g., `MAX_HEALTH = 100f`). - **Events**: `OnPlayerDeath`, prefixed with `On`. Use meaningful names over abbreviations—`enemySpawnPoints` beats `esp` every time. Cursor AI will auto-suggest and refactor to match. **Pro Tip**: Always add XML comments for public members: ```csharp /// <summary> /// Fires when player health reaches zero. /// </summary> public event System.Action OnPlayerDeath; ``` ### 3. MonoBehaviour Best Practices Unity's MonoBehaviour is your bread-and-butter, but misuse it and performance tanks. Here's how to wield it wisely: - **Awake() vs Start()**: Use `Awake()` for initialization that other objects depend on; `Start()` for everything else. - **Minimize Update()**: Replace with `FixedUpdate()` for physics or events/coroutines for logic. **Real-World Example**: A simple movement script: ```csharp public class PlayerMovement : MonoBehaviour { [SerializeField] private float speed = 5f; private Rigidbody rb; private void Awake() { rb = GetComponent<Rigidbody>(); } private void FixedUpdate() { Vector3 input = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical")); rb.velocity = input.normalized * speed; } } ``` Avoid `Update()` here—`FixedUpdate()` syncs perfectly with physics. ### 4. Data Management with ScriptableObjects Ditch hardcoded values! ScriptableObjects are perfect for configurable data like enemy stats or levels. - Create a base `ScriptableObject` for each data type. - Reference them via `[SerializeField] private EnemyData enemyData;`. **Example**: ```csharp [CreateAssetMenu(fileName = "EnemyData", menuName = "Data/Enemy")] public class EnemyData : ScriptableObject { public float health = 100f; public float damage = 20f; } ``` In your enemy script: `currentHealth = enemyData.health;`. This makes tweaking balance a breeze without recompiles. ### 5. Events and Observer Pattern Tight coupling kills scalability. Use UnityEvents or C# events for loose connections. - Prefer `UnityEvent` for Inspector wiring. - Custom events for code-only: `public event System.Action<float> OnHealthChanged;`. **Practical Use**: Player takes damage? ```csharp public class Health : MonoBehaviour { public UnityEvent<float> onHealthChanged; public void TakeDamage(float amount) { currentHealth -= amount; onHealthChanged.Invoke(currentHealth); } } ``` UI, audio, effects—all subscribe without knowing about each other. ### 6. Performance Optimization Rules Games must run buttery smooth, especially on mobile. Cursor enforces these: - **Object Pooling**: For bullets, particles—never `Instantiate/Destroy` in hot paths. ```csharp public class BulletPool : MonoBehaviour { private Queue<GameObject> pool = new(); public GameObject GetBullet() { if (pool.Count > 0) return pool.Dequeue(); return Instantiate(bulletPrefab); } } ``` - **Avoid Find/ GetComponent in Update**: Cache references in `Awake()`. - **Batching**: Use static/dynamic batching; prefer SRP (Scriptable Render Pipeline) for modern rendering. - **Garbage Collection**: String concatenation? Use `StringBuilder`. Linq in Update? Nope. **Benchmark Tip**: Profile with Unity's Profiler early. Cursor can suggest optimizations based on your code. ### 7. Input System and Controls Ditch old Input Manager—embrace the new Input System. - Install via Package Manager. - Define Input Actions as assets. - Generate C# class for type-safe input. **Example Setup**: ```csharp public class PlayerInput : MonoBehaviour { private PlayerActions inputActions; private void Awake() { inputActions = new PlayerActions(); } public Vector2 Move => inputActions.Player.Move.ReadValue<Vector2>(); } ``` Responsive, rebindable, and multi-device ready. ### 8. State Machines and FSM Manage complex behaviors with Finite State Machines. - Enum-based for simple cases. - ScriptableObject states for advanced (pair with Animator). **Code Snippet**: ```csharp public enum PlayerState { Idle, Running, Jumping } public class PlayerStateMachine : MonoBehaviour { private PlayerState currentState = PlayerState.Idle; private void Update() { switch (currentState) { case PlayerState.Idle: // Idle logic break; } } } ``` Scales to AI enemies or menus effortlessly. ### 9. Testing and Debugging Robust games need tests. Use Unity Test Framework. - Unit tests for pure logic. - PlayMode tests for MonoBehaviours. Cursor will generate test skeletons: `[Test] public void TakeDamage_ReducesHealth() { }`. ### 10. Advanced Topics: ECS and DOTS For AAA performance, dip into Data-Oriented Tech Stack (DOTS). - Use Entities, Components, Systems. - Hybrid with GameObjects via `HybridRenderer`. **When?** High entity counts (1000+ bullets). Start small! ### Wrapping Up: Implementing These Rules in Cursor Copy these into a `.cursorrules` file at your project root. Cursor AI will now critique and autocomplete following Unity gold standards. Experiment, iterate, and watch your games level up. This setup has helped devs ship polished titles faster. Got questions? Tweak the rules for your genre—Roguelike? Add procedural gen rules. Word count: ~1200. Ready to code! <div style="text-align: center; margin-top: 2rem;"> <a href="https://cursor.directory/c-unity-game-development-cursor-rules" target="_blank" rel="noopener noreferrer" class="view-full-resource-btn" style="display: inline-block; background-color: #f97316; color: white; padding: 12px 24px; border-radius: 8px; text-decoration: none; font-weight: 600; transition: background-color 0.2s;">View Full Resource</a> </div>