unity-development

Unity Development Skill

Comprehensive Unity Engine development integration for AI-assisted game creation, editor automation, and project management.

Overview

This skill provides capabilities for interacting with Unity projects, including C# scripting, scene manipulation, prefab management, and build automation. It leverages the Unity MCP ecosystem for direct editor integration when available.

Capabilities

Project Management

• Create and configure Unity projects
• Manage project settings (Player Settings, Quality Settings, etc.)
• Configure package dependencies via Package Manager
• Set up Assembly Definitions for code organization

C# Scripting

• Generate MonoBehaviour scripts with proper lifecycle methods
• Create ScriptableObjects for data-driven design
• Implement interfaces (ISerializationCallbackReceiver, etc.)
• Write custom Editor scripts and PropertyDrawers
• Generate unit tests using Unity Test Framework

Scene Management

• Create and modify scenes programmatically
• Instantiate and configure GameObjects
• Set up scene hierarchies and parent/child relationships
• Configure lighting, cameras, and post-processing

Prefab System

• Create and modify prefab assets
• Handle prefab variants and overrides
• Generate prefab instances with modifications
• Manage nested prefabs

Asset Pipeline

• Import and configure assets (textures, models, audio)
• Set up asset bundles and addressables
• Configure import settings for optimization
• Generate placeholder assets

Build System

• Configure build settings for multiple platforms
• Create build scripts for automation
• Set up CI/CD build pipelines
• Manage platform-specific configurations

Prerequisites

Unity Installation

• Unity 2021.3 LTS or higher recommended
• Unity Editor installed with required modules

MCP Server (Recommended)

For direct Unity Editor integration:

{
  "mcpServers": {
    "unity": {
      "command": "npx",
      "args": ["-y", "unity-mcp"],
      "env": {
        "UNITY_PROJECT_PATH": "/path/to/unity/project"
      }
    }
  }
}

Alternative MCP servers:

• unity-mcp (CoplayDev) - Official Unity MCP bridge
• Unity-MCP (IvanMurzak) - Editor & Runtime support
• mcp-unity (CoderGamester) - Cursor/Claude Code integration

Usage Patterns

Creating a MonoBehaviour Script

using UnityEngine;

public class PlayerController : MonoBehaviour
{
    [Header("Movement Settings")]
    [SerializeField] private float moveSpeed = 5f;
    [SerializeField] private float jumpForce = 10f;

    [Header("Ground Check")]
    [SerializeField] private Transform groundCheck;
    [SerializeField] private float groundRadius = 0.2f;
    [SerializeField] private LayerMask groundLayer;

    private Rigidbody2D rb;
    private bool isGrounded;

    private void Awake()
    {
        rb = GetComponent<Rigidbody2D>();
    }

    private void Update()
    {
        isGrounded = Physics2D.OverlapCircle(groundCheck.position, groundRadius, groundLayer);
        HandleInput();
    }

    private void FixedUpdate()
    {
        HandleMovement();
    }

    private void HandleInput()
    {
        if (Input.GetButtonDown("Jump") && isGrounded)
        {
            rb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
        }
    }

    private void HandleMovement()
    {
        float horizontal = Input.GetAxisRaw("Horizontal");
        rb.velocity = new Vector2(horizontal * moveSpeed, rb.velocity.y);
    }
}

Creating a ScriptableObject

using UnityEngine;

[CreateAssetMenu(fileName = "NewEnemyData", menuName = "Game/Enemy Data")]
public class EnemyData : ScriptableObject
{
    [Header("Basic Info")]
    public string enemyName;
    public Sprite icon;

    [Header("Stats")]
    public int maxHealth = 100;
    public float moveSpeed = 3f;
    public int damage = 10;

    [Header("Combat")]
    public float attackRange = 2f;
    public float attackCooldown = 1.5f;

    [Header("Rewards")]
    public int experienceReward = 50;
    public GameObject[] lootDrops;
}

Editor Script Example

using UnityEngine;
using UnityEditor;

[CustomEditor(typeof(EnemyData))]
public class EnemyDataEditor : Editor
{
    public override void OnInspectorGUI()
    {
        EnemyData enemyData = (EnemyData)target;

        EditorGUILayout.BeginHorizontal();
        if (enemyData.icon != null)
        {
            GUILayout.Box(enemyData.icon.texture, GUILayout.Width(64), GUILayout.Height(64));
        }
        EditorGUILayout.BeginVertical();
        EditorGUILayout.LabelField(enemyData.enemyName, EditorStyles.boldLabel);
        EditorGUILayout.LabelField(
quot;HP: {enemyData.maxHealth} | DMG: {enemyData.damage}");
        EditorGUILayout.EndVertical();
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.Space();
        DrawDefaultInspector();
    }
}

Integration with Babysitter SDK

Task Definition Example

const unityScriptTask = defineTask({
  name: 'unity-script-generation',
  description: 'Generate Unity C# script',

  inputs: {
    scriptType: { type: 'string', required: true }, // MonoBehaviour, ScriptableObject, Editor
    className: { type: 'string', required: true },
    features: { type: 'array', required: true },
    outputPath: { type: 'string', required: true }
  },

  outputs: {
    scriptPath: { type: 'string' },
    success: { type: 'boolean' }
  },

  async run(inputs, taskCtx) {
    return {
      kind: 'skill',
      title: `Generate Unity script: ${inputs.className}`,
      skill: {
        name: 'unity-development',
        context: {
          operation: 'generate_script',
          scriptType: inputs.scriptType,
          className: inputs.className,
          features: inputs.features,
          outputPath: inputs.outputPath
        }
      },
      io: {
        inputJsonPath: `tasks/${taskCtx.effectId}/input.json`,
        outputJsonPath: `tasks/${taskCtx.effectId}/result.json`
      }
    };
  }
});

MCP Server Integration

Available MCP Tools (via unity-mcp)

Configuration

{
  "mcpServers": {
    "unity": {
      "command": "uvx",
      "args": ["unity-mcp"],
      "env": {
        "UNITY_PROJECT_PATH": "C:/Projects/MyGame",
        "UNITY_VERSION": "2022.3.20f1"
      }
    }
  }
}

Best Practices

1. Assembly Definitions: Organize code with .asmdef files for faster compilation
2. Serialization: Use [SerializeField] for inspector exposure while keeping fields private
3. Null Checks: Always validate component references in Awake/Start
4. Object Pooling: Avoid runtime instantiation for frequently spawned objects
5. Coroutines: Use for time-based operations, avoid heavy logic
6. Events: Use UnityEvent or C# events for decoupled communication

Platform Considerations

References

• Unity Documentation
• Unity MCP (CoplayDev)
• Unity-MCP (IvanMurzak)
• mcp-unity (CoderGamester)
• Unity Learn
• Unity Best Practices