Overview

MCPity Studio connects Claude AI to your game engine or 3D tool in real time. You describe what you want in plain English, Claude generates the code, and the MCPity plugin pushes it directly into your running engine instance. No copy paste required.

Code your game

Every plan can build a game by hand in the Web Engine, with no AI and no install. Open Studio, pick "Code it yourself" (or "Start from a blank game" in the Code tab), and edit the code while the preview reloads on every save. Having MCPity build it for you needs a paid plan.

Files and the entry file

• The game runs from src/index.ts. A blank game starts it as an empty lit stage with a camera and a render loop.
• Write TypeScript or plain JavaScript. The browser bundles it on every save.
• Add more files under src/ and import them with relative paths (import { spawn } from "./enemies").
• The only packages you can import by name are three (and its three/addons/), @babylonjs/*, cannon-es and @dimforge/rapier3d-compat.

Three.js or Babylon.js

There is no switch to flip: the preview reads your imports. A game that imports from @babylonjs/core runs on Babylon.js, and anything else runs on Three.js.

import * as THREE from "three";

const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(60, innerWidth / innerHeight, 0.1, 500);
const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setSize(innerWidth, innerHeight);
document.body.appendChild(renderer.domElement);

// Tell MCPity where the player is, for the heatmap and Play together.
const player = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshStandardMaterial());
scene.add(player);
(window as any).MCPityPlayer = player;

Runtime helpers

These are on window. The first three are always there in the Studio preview and on your /play link. The rest arrive when you add their free No-AI pattern from Build Steps or the Editor tab panels.

Set window.MCPityPlayer to your player object (a Three.js object, a Babylon.js node, or anything with a position). The heatmap reads where players died or stopped from it, and Play together draws teammates from it.

Edits made in the live editor

When you move, recolour or hide an object in the Editor tab, the change is saved into your code as a block between MCPITY_TWEAKS_BEGIN and MCPITY_TWEAKS_END. Leave that block in place: it applies your edits wherever the game runs.

From your own editor

On a paid plan, the MCPity CLI streams files you edit locally into a Studio project's live preview. Coding in the Studio Code tab stays free.

npx @mcpity/cli auth login
npx @mcpity/cli push --watch --studio <project id>

Blender Add-on Setup

Step 1: Download

Download the correct file for your Blender version from the Setup Wizard inside the app, or directly below:

Step 2: Install

Blender 4.2+ (Extensions system)

1. 1Open Blender
2. 2Go to Edit → Preferences → Add-ons
3. 3Click Install from Disk… (top-right of the Add-ons panel)
4. 4Select mcpity_blender_addon_4_2.zip
5. 5Click Install from Disk to confirm
6. 6Find MCPity in the list and enable the checkbox next to it

Blender 3.6, 4.1 (Legacy)

1. 1Open Blender
2. 2Go to Edit → Preferences → Add-ons
3. 3Click Install… (top-right of the Add-ons panel)
4. 4Select mcpity_blender_addon_legacy.zip
5. 5Click Install Add-on to confirm
6. 6Find MCPity in the list and enable the checkbox next to it

Step 3: Configure

Expand the add-on's preferences by clicking the arrow next to MCPity in the Add-ons list. Set these two fields:

Step 4: Connect

1. 1In Blender, open the 3D Viewport
2. 2Press N to open the N-Panel (right sidebar)
3. 3Click the MCPity tab
4. 4Click Connect
5. 5The status indicator turns green

Unity Plugin Setup

1. 1Open Window → Package Manager in Unity
2. 2Click + → Add package from git URL
3. 3Paste:
   https://github.com/mcpity/unity-plugin.git
4. 4Wait for the import to complete
5. 5Go to Window → MCPity to open the plugin panel
6. 6Paste your Auth Token in Plugin Settings

SaaS Animation API

The MCPity Animation API lets you integrate AI-powered animation code generation directly into your SaaS product. Your application sends prompts and receives engine-specific code (C# or Python) that can be pushed to a live engine via the MCPity plugin.

Authentication

All API requests must include your MCPity API key in the x-mcpity-api-key header. Optionally, include your Claude API key in x-claude-api-key for BYOK (Bring Your Own Key), available at Growth tier and above.

POST /functions/v1/supabase-functions-animation-api?action=generate
x-mcpity-api-key: mcp_live_abc123...
x-claude-api-key: sk-ant-...           ← optional BYOK
Content-Type: application/json

POST /generate: Generate animation code

// Sync request
{
  "prompt": "Create a smooth walk cycle for a humanoid character",
  "engine": "unity"
}

// Sync response
{
  "generation_id": "gen_abc123",
  "engine": "unity",
  "animation_type": "skeletal",
  "files": [
    {
      "filename": "WalkCycleController.cs",
      "language": "csharp",
      "content": "using UnityEngine;\npublic class WalkCycleController : MonoBehaviour { ... }"
    }
  ],
  "preview_data": { "format": "threejs_compatible", "scene": { ... } },
  "metadata": {
    "tokens_input": 312,
    "tokens_output": 748,
    "generation_time_ms": 2340,
    "model": "claude-3-5-sonnet-20241022"
  }
}

// Async request
{
  "prompt": "Create an explosion particle system",
  "engine": "unity",
  "async": true,
  "webhook_url": "https://your-app.com/webhooks/mcpity"
}

// Async response (immediate)
{
  "generation_id": "gen_xyz789",
  "status": "pending",
  "message": "Generation queued. Poll /status or wait for webhook."
}

POST /refine: Refine a previous generation

// Request
{
  "generation_id": "gen_abc123",
  "refinement_prompt": "Make the arm swing wider and add a subtle head bob"
}

// Response: same shape as /generate, plus:
{
  "generation_id": "gen_def456",
  "parent_generation_id": "gen_abc123",
  "engine": "unity",
  "files": [ ... ]
}

GET /templates: List animation templates

// GET ?action=templates&engine=unity&category=character

{
  "templates": [
    {
      "id": "walk-cycle-unity",
      "name": "Humanoid Walk Cycle",
      "description": "Smooth locomotion animation for Unity Animator",
      "engines": ["unity"],
      "animation_type": "skeletal",
      "category": "character",
      "difficulty": "beginner",
      "tags": ["locomotion", "humanoid", "animator"],
      "prompt_template": "Create a walk cycle animation for a {character_type} character ...",
      "parameters": [
        { "key": "character_type", "label": "Character Type", "default": "humanoid", "description": "Type of character rig" }
      ]
    }
  ],
  "count": 1,
  "filters": { "engine": "unity", "category": "character", "animation_type": null }
}

POST /preview: Three.js preview data

// Response
{
  "preview_data": {
    "format": "threejs_compatible",
    "version": "1.0",
    "engine": "unity",
    "animation_type": "transform",
    "scene": {
      "objects": [ { "type": "mesh", "geometry": "BoxGeometry", ... } ],
      "animations": [ { "name": "walk", "duration": 1.0, "tracks": [ ... ] } ],
      "camera": { "position": [0, 2, 5], "target": [0, 1, 0] }
    }
  },
  "format": "threejs_compatible"
}

GET /status: Poll async generation

// Pending
{ "generation_id": "gen_xyz789", "status": "pending", "engine": "unity" }

// Generating
{ "generation_id": "gen_xyz789", "status": "generating", "engine": "unity" }

// Completed
{
  "generation_id": "gen_xyz789",
  "status": "completed",
  "engine": "unity",
  "completed_at": "2025-03-01T12:00:05Z",
  "files": [ ... ],
  "preview_data": { ... },
  "metadata": { ... }
}

// Failed
{
  "generation_id": "gen_xyz789",
  "status": "failed",
  "error_message": "Claude API error: rate limit exceeded"
}

Webhooks

When a webhook_url is provided on a generate request, MCPity POSTs the completed payload to your URL. Requests are signed with HMAC-SHA256 so you can verify they genuinely came from MCPity.

{
  "event": "animation.generation.completed",
  "generation_id": "gen_xyz789",
  "status": "completed",
  "engine": "unity",
  "files": [ ... ],
  "metadata": { ... }
}

// Node.js / Next.js webhook verification
import crypto from "crypto";

export async function POST(request: Request) {
  const body      = await request.arrayBuffer();
  const signature = request.headers.get("X-MCPity-Signature") ?? "";
  const secret    = process.env.MCPITY_WEBHOOK_SECRET!;

  const expected = crypto
    .createHmac("sha256", secret)
    .update(Buffer.from(body))
    .digest("hex");

  if (!crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature))) {
    return Response.json({ error: "invalid signature" }, { status: 401 });
  }

  const event = JSON.parse(Buffer.from(body).toString());
  console.log("Animation ready:", event.generation_id);
  return Response.json({ ok: true });
}

Client SDKs

Official SDKs are available for TypeScript/JavaScript, Python, and C#. All SDKs cover all five endpoints, error handling, async polling helpers, and webhook signature verification.

import { MCPityAnimationClient } from "@mcpity/animation-client";

const client = new MCPityAnimationClient({
  apiKey: "mcp_live_abc123...",
});
const result = await client.generate({
  prompt: "Create a walk cycle",
  engine: "unity",
});

from mcpity_client import MCPityAnimationClient

client = MCPityAnimationClient(
    api_key="mcp_live_abc123...",
)
result = client.generate(
    prompt="Create a walk cycle",
    engine="unity",
)

var client = new MCPityAnimationClient(
  new MCPityClientConfig {
    ApiKey = "mcp_live_abc123...",
  }
);
var result = await client.GenerateAsync(
  new GenerateRequest {
    Prompt = "Create a walk cycle",
    Engine = "unity",
  }
);