@downdraft/engine 0.1.1 → 0.1.2-alpha.5

package/dist/mcp/src/tools/animation.js

@@ -0,0 +1,102 @@
+import { errorResult, jsonResult } from "../types.js";
+export function createAnimationTools(ctx) {
+    const tools = [
+        {
+            def: {
+                name: "play_animation",
+                description: "Play an animation clip on an entity with a skeleton.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entity: { type: "string", description: "Entity key" },
+                        clip: { type: "string", description: "Animation clip name" },
+                        speed: { type: "number", description: "Playback speed (default: 1.0)" },
+                        loop: { type: "boolean", description: "Loop the animation" },
+                        blendWeight: { type: "number", description: "Blend weight (0-1)" },
+                    },
+                    required: ["entity", "clip"],
+                },
+            },
+            handler: (params) => {
+                const entityKey = params.entity;
+                const entity = ctx.parseEntityKey(entityKey);
+                if (!entity || !ctx.isEntityAlive(entity)) {
+                    return errorResult(`Entity ${entityKey} not found or dead`);
+                }
+                const clipName = params.clip;
+                const speed = params.speed ?? 1.0;
+                const loop = params.loop ?? true;
+                const blendWeight = params.blendWeight ?? 1.0;
+                const player = ctx.animationPlayers.get(entityKey);
+                if (!player) {
+                    return errorResult(`No AnimationPlayer found for entity ${entityKey}. Attach a skeleton first.`);
+                }
+                const playing = player.isPlaying();
+                player.setSpeed(clipName, speed);
+                return jsonResult({
+                    entity: entityKey,
+                    clip: clipName,
+                    speed,
+                    loop,
+                    blendWeight,
+                    wasAlreadyPlaying: playing,
+                });
+            },
+        },
+        {
+            def: {
+                name: "stop_animation",
+                description: "Stop a playing animation on an entity.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entity: { type: "string", description: "Entity key" },
+                        clip: { type: "string", description: "Animation clip name (optional, stops all if omitted)" },
+                    },
+                    required: ["entity"],
+                },
+            },
+            handler: (params) => {
+                const entityKey = params.entity;
+                const clipName = params.clip;
+                const player = ctx.animationPlayers.get(entityKey);
+                if (!player) {
+                    return errorResult(`No AnimationPlayer found for entity ${entityKey}`);
+                }
+                player.stop();
+                return jsonResult({ entity: entityKey, stopped: true, clip: clipName ?? "all" });
+            },
+        },
+        {
+            def: {
+                name: "set_animation_state",
+                description: "Set the animation state machine to a named state.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entity: { type: "string", description: "Entity key" },
+                        state: { type: "string", description: "Target state name" },
+                        crossfade: { type: "number", description: "Crossfade duration in seconds" },
+                    },
+                    required: ["entity", "state"],
+                },
+            },
+            handler: (params) => {
+                const entityKey = params.entity;
+                const stateName = params.state;
+                const crossfade = params.crossfade ?? 0.2;
+                const player = ctx.animationPlayers.get(entityKey);
+                if (!player) {
+                    return errorResult(`No AnimationPlayer found for entity ${entityKey}`);
+                }
+                return jsonResult({
+                    entity: entityKey,
+                    state: stateName,
+                    crossfade,
+                    playing: player.isPlaying(),
+                });
+            },
+        },
+    ];
+    return tools;
+}

package/dist/mcp/src/tools/asset.js

@@ -0,0 +1,146 @@
+import { AssetImporter, confinePath, GLBLoader } from "@downdraft/engine";
+import { errorResult, jsonResult } from "../types.js";
+/** Base directory used for path confinement. Falls back to cwd. */
+const GAME_ROOT = process.cwd();
+export function createAssetTools(ctx) {
+    const tools = [
+        {
+            def: {
+                name: "import_texture",
+                description: "Import and convert a texture file to engine format.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Path to texture file (PNG, WebP, KTX2)" },
+                        format: { type: "string", description: "Target format (default: auto-detect)" },
+                    },
+                    required: ["path"],
+                },
+            },
+            handler: async (params) => {
+                const path = params.path;
+                try {
+                    const safePath = confinePath(GAME_ROOT, path);
+                    const data = await ctx.assetManager.load(safePath);
+                    return jsonResult({ imported: true, path: safePath, type: typeof data });
+                }
+                catch (e) {
+                    return errorResult(`Failed to import texture: ${e.message}`);
+                }
+            },
+        },
+        {
+            def: {
+                name: "convert_asset",
+                description: "Convert a 3D model asset (GLB/GLTF) to engine format with optional options.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Path to source asset file (GLB, GLTF)" },
+                        format: {
+                            type: "string",
+                            enum: ["gltf", "glb"],
+                            description: "Target format (default: glb)",
+                        },
+                        generateNormals: { type: "boolean", description: "Generate normals if missing" },
+                        generateTangents: { type: "boolean", description: "Generate tangents if missing" },
+                        flipY: { type: "boolean", description: "Flip Y axis (default: true)" },
+                        scale: { type: "number", description: "Scale factor" },
+                    },
+                    required: ["path"],
+                },
+            },
+            handler: async (params) => {
+                const path = params.path;
+                const format = params.format ?? "glb";
+                const options = {
+                    format,
+                    generateNormals: params.generateNormals,
+                    generateTangents: params.generateTangents,
+                    flipY: params.flipY,
+                    scale: params.scale,
+                };
+                try {
+                    const safePath = confinePath(GAME_ROOT, path);
+                    const { promises: fs } = await import("node:fs");
+                    const buf = await fs.readFile(safePath);
+                    const fileData = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+                    const ext = safePath.split(".").pop()?.toLowerCase() ?? "";
+                    const loader = new GLBLoader();
+                    const importer = new AssetImporter(loader);
+                    let result;
+                    if (ext === "glb") {
+                        result = await importer.importGLB(fileData, options);
+                    }
+                    else if (ext === "gltf") {
+                        const json = JSON.parse(new TextDecoder().decode(fileData));
+                        result = await importer.importGLTF(json);
+                    }
+                    else {
+                        return errorResult(`Unsupported format: ${ext}. Use GLB or GLTF.`);
+                    }
+                    return jsonResult({
+                        converted: true,
+                        path: safePath,
+                        format,
+                        warnings: result.warnings,
+                        nodeCount: result.document.nodes?.length ?? 0,
+                        meshCount: result.document.meshes?.length ?? 0,
+                    });
+                }
+                catch (e) {
+                    return errorResult(`Failed to convert asset: ${e.message}`);
+                }
+            },
+        },
+        {
+            def: {
+                name: "list_assets",
+                description: "List all loaded assets.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        filter: { type: "string", description: "Filter by extension or name substring" },
+                    },
+                },
+            },
+            handler: (params) => {
+                let assets = ctx.assetManager.list();
+                const filter = params.filter;
+                if (filter) {
+                    assets = assets.filter((a) => a.includes(filter));
+                }
+                return jsonResult({ count: assets.length, assets });
+            },
+        },
+        {
+            def: {
+                name: "validate_project",
+                description: "Check for missing assets, broken references, and invalid configurations.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            handler: () => {
+                const issues = [];
+                for (const [entityKey, meshName] of ctx.entityMeshes.entries()) {
+                    if (!ctx.meshes.has(meshName)) {
+                        issues.push(`Entity ${entityKey} references missing mesh "${meshName}"`);
+                    }
+                }
+                for (const [entityKey, materialName] of ctx.entityMaterials.entries()) {
+                    if (!ctx.materialLibrary.get(materialName)) {
+                        issues.push(`Entity ${entityKey} references missing material "${materialName}"`);
+                    }
+                }
+                return jsonResult({
+                    valid: issues.length === 0,
+                    issues,
+                    issueCount: issues.length,
+                });
+            },
+        },
+    ];
+    return tools;
+}

package/dist/mcp/src/tools/audio.js

@@ -0,0 +1,80 @@
+import { createAudioListener, createAudioSource } from "../engine-context.js";
+import { errorResult, jsonResult } from "../types.js";
+export function createAudioTools(ctx) {
+    const tools = [
+        {
+            def: {
+                name: "add_audio_source",
+                description: "Add an audio source to an entity with optional spatial positioning.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entity: { type: "string", description: "Entity key" },
+                        asset: { type: "string", description: "Audio asset path" },
+                        spatial: { type: "boolean", description: "Whether this is a spatial (3D) source" },
+                        volume: { type: "number", description: "Volume (0-1)" },
+                        loop: { type: "boolean", description: "Loop the audio" },
+                    },
+                    required: ["entity", "asset"],
+                },
+            },
+            handler: (params) => {
+                const entityKey = params.entity;
+                const entity = ctx.parseEntityKey(entityKey);
+                if (!entity || !ctx.isEntityAlive(entity)) {
+                    return errorResult(`Entity ${entityKey} not found or dead`);
+                }
+                const spatial = params.spatial ?? false;
+                const volume = params.volume ?? 1.0;
+                const loop = params.loop ?? false;
+                const sourceData = createAudioSource("-1", {
+                    spatial,
+                    volume,
+                    loop,
+                    autoPlay: false,
+                });
+                const cid = ctx.getComponentIdByName("AudioSource");
+                ctx.ecsWorld.addComponent(entity, cid, sourceData);
+                ctx.ecsWorld.flushCommands();
+                ctx.audioSources.set(entityKey, sourceData);
+                return jsonResult({
+                    entity: entityKey,
+                    asset: params.asset,
+                    spatial,
+                    volume,
+                    loop,
+                });
+            },
+        },
+        {
+            def: {
+                name: "set_audio_listener",
+                description: "Set the audio listener to follow an entity or camera.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entity: { type: "string", description: "Entity key to attach listener to" },
+                        followCamera: { type: "boolean", description: "Follow the camera (default: true)" },
+                    },
+                },
+            },
+            handler: (params) => {
+                const followCamera = params.followCamera ?? true;
+                const entityKey = params.entity;
+                if (entityKey) {
+                    const entity = ctx.parseEntityKey(entityKey);
+                    if (!entity || !ctx.isEntityAlive(entity)) {
+                        return errorResult(`Entity ${entityKey} not found or dead`);
+                    }
+                    const listenerData = createAudioListener({ active: true });
+                    const cid = ctx.getComponentIdByName("AudioListener");
+                    ctx.ecsWorld.addComponent(entity, cid, listenerData);
+                    ctx.ecsWorld.flushCommands();
+                    ctx.audioListeners.set(entityKey, listenerData);
+                }
+                return jsonResult({ followCamera, entity: entityKey ?? null });
+            },
+        },
+    ];
+    return tools;
+}

package/dist/mcp/src/tools/build.js

@@ -0,0 +1,128 @@
+import { confinePath } from "@downdraft/engine";
+import { errorResult, jsonResult } from "../types.js";
+/** Base directory used for path confinement. Falls back to cwd. */
+const GAME_ROOT = process.cwd();
+export function createBuildTools(ctx) {
+    const tools = [
+        {
+            def: {
+                name: "build_game",
+                description: "Package the game for a target platform.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        target: {
+                            type: "string",
+                            enum: ["win", "mac", "linux", "android", "ios", "all"],
+                            description: "Build target platform",
+                        },
+                        stage: {
+                            type: "string",
+                            enum: ["build", "package", "release"],
+                            description: "Release stage: build (Vite only), package (package existing build), release (build+package+sign). Default: release.",
+                        },
+                        output: { type: "string", description: "Output directory" },
+                        mode: {
+                            type: "string",
+                            enum: ["dev", "debug", "prod"],
+                            description: "Build mode (default: prod)",
+                        },
+                    },
+                    required: ["target"],
+                },
+            },
+            handler: (params) => {
+                const target = params.target;
+                const stage = params.stage ?? "release";
+                const mode = params.mode ?? "prod";
+                const output = params.output ?? `release`;
+                return jsonResult({
+                    note: "Build system requires the CLI tool. Run 'draft release --stage=<stage> --target=<target>' from the project root.",
+                    target,
+                    stage,
+                    mode,
+                    output,
+                });
+            },
+        },
+        {
+            def: {
+                name: "validate_build",
+                description: "Validate that the project is ready for building (assets, scripts, scene integrity).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        target: {
+                            type: "string",
+                            enum: ["win", "mac", "linux"],
+                            description: "Build target to validate against (default: linux)",
+                        },
+                    },
+                },
+            },
+            handler: (params) => {
+                const target = params.target ?? "linux";
+                const issues = [];
+                for (const [entityKey, meshName] of ctx.entityMeshes.entries()) {
+                    if (!ctx.meshes.has(meshName)) {
+                        issues.push(`Entity ${entityKey} references missing mesh "${meshName}"`);
+                    }
+                }
+                for (const [entityKey, materialName] of ctx.entityMaterials.entries()) {
+                    if (!ctx.materialLibrary.get(materialName)) {
+                        issues.push(`Entity ${entityKey} references missing material "${materialName}"`);
+                    }
+                }
+                if (ctx.lights.length === 0) {
+                    issues.push("No lights in scene — build will produce a dark scene");
+                }
+                const scripts = ctx.scriptingSystem.getScriptNames();
+                if (scripts.length === 0) {
+                    issues.push("No scripts loaded — game will have no logic");
+                }
+                const entityCount = ctx.ecsWorld.entityCount();
+                if (entityCount <= 1) {
+                    issues.push("Scene is empty (only root entity)");
+                }
+                return jsonResult({
+                    target,
+                    valid: issues.length === 0,
+                    issues,
+                    issueCount: issues.length,
+                    stats: {
+                        entities: entityCount,
+                        meshes: ctx.meshes.size,
+                        materials: ctx.materialLibrary.list().length,
+                        lights: ctx.lights.length,
+                        scripts: scripts.length,
+                    },
+                });
+            },
+        },
+        {
+            def: {
+                name: "export_scene",
+                description: "Export the current scene to a file.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Output file path" },
+                    },
+                    required: ["path"],
+                },
+            },
+            handler: async (params) => {
+                const path = params.path;
+                try {
+                    const safePath = confinePath(GAME_ROOT, path);
+                    await ctx.saveSystem.saveToFile(ctx.ecsWorld, ctx.scene.name, safePath);
+                    return jsonResult({ exported: true, path: safePath, scene: ctx.scene.name });
+                }
+                catch (e) {
+                    return errorResult(`Failed to export: ${e.message}`);
+                }
+            },
+        },
+    ];
+    return tools;
+}

package/dist/mcp/src/tools/camera.js

@@ -0,0 +1,157 @@
+import { errorResult, jsonResult } from "../types.js";
+function toVec3(arr) {
+    return [arr[0], arr[1], arr[2]];
+}
+export function createCameraTools(ctx, undoRedo) {
+    const tools = [
+        {
+            def: {
+                name: "set_camera",
+                description: "Position and aim the camera at a target.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        position: {
+                            type: "array",
+                            items: { type: "number" },
+                            description: "Camera position [x, y, z]",
+                        },
+                        target: {
+                            type: "array",
+                            items: { type: "number" },
+                            description: "Look-at target [x, y, z]",
+                        },
+                        fov: { type: "number", description: "Field of view in degrees" },
+                        near: { type: "number", description: "Near plane" },
+                        far: { type: "number", description: "Far plane" },
+                    },
+                },
+            },
+            handler: (params) => {
+                const oldData = ctx.camera.getData();
+                if (params.position) {
+                    const pos = params.position;
+                    ctx.camera.position = toVec3(pos);
+                }
+                if (params.target) {
+                    const tgt = params.target;
+                    ctx.camera.target = toVec3(tgt);
+                }
+                if (params.fov !== undefined) {
+                    ctx.camera.fov = params.fov * (Math.PI / 180);
+                }
+                if (params.near !== undefined)
+                    ctx.camera.near = params.near;
+                if (params.far !== undefined)
+                    ctx.camera.far = params.far;
+                ctx.camera.orbit(0, 0);
+                undoRedo.execute({
+                    description: `set_camera`,
+                    undo: () => {
+                        ctx.camera.position = toVec3(oldData.position);
+                        ctx.camera.target = toVec3(oldData.target);
+                        ctx.camera.fov = oldData.fov;
+                        ctx.camera.near = oldData.near;
+                        ctx.camera.far = oldData.far;
+                        ctx.camera.orbit(0, 0);
+                    },
+                    redo: () => {
+                        if (params.position) {
+                            const pos = params.position;
+                            ctx.camera.position = toVec3(pos);
+                        }
+                        if (params.target) {
+                            const tgt = params.target;
+                            ctx.camera.target = toVec3(tgt);
+                        }
+                        if (params.fov !== undefined)
+                            ctx.camera.fov = params.fov * (Math.PI / 180);
+                        if (params.near !== undefined)
+                            ctx.camera.near = params.near;
+                        if (params.far !== undefined)
+                            ctx.camera.far = params.far;
+                        ctx.camera.orbit(0, 0);
+                    },
+                });
+                return jsonResult({
+                    position: [ctx.camera.position[0], ctx.camera.position[1], ctx.camera.position[2]],
+                    target: [ctx.camera.target[0], ctx.camera.target[1], ctx.camera.target[2]],
+                    fov: ctx.camera.fov * (180 / Math.PI),
+                    near: ctx.camera.near,
+                    far: ctx.camera.far,
+                });
+            },
+        },
+        {
+            def: {
+                name: "set_camera_mode",
+                description: "Set camera mode (orbit, fps, cinematic, follow).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        mode: {
+                            type: "string",
+                            enum: ["orbit", "fps", "cinematic", "follow"],
+                            description: "Camera mode",
+                        },
+                        followEntity: { type: "string", description: "Entity key to follow (for follow mode)" },
+                    },
+                    required: ["mode"],
+                },
+            },
+            handler: (params) => {
+                const mode = params.mode;
+                const followEntity = params.followEntity;
+                const prevFollow = ctx.cameraFollowEntity;
+                if (mode === "follow" && followEntity) {
+                    const entity = ctx.parseEntityKey(followEntity);
+                    if (!entity || !ctx.isEntityAlive(entity)) {
+                        return errorResult(`Entity ${followEntity} not found or dead`);
+                    }
+                    ctx.cameraFollowEntity = entity;
+                }
+                else {
+                    ctx.cameraFollowEntity = null;
+                }
+                undoRedo.execute({
+                    description: `set_camera_mode(${mode})`,
+                    undo: () => {
+                        ctx.cameraFollowEntity = prevFollow;
+                    },
+                    redo: () => {
+                        if (mode === "follow" && followEntity) {
+                            const entity = ctx.parseEntityKey(followEntity);
+                            if (entity && ctx.isEntityAlive(entity)) {
+                                ctx.cameraFollowEntity = entity;
+                            }
+                        }
+                        else {
+                            ctx.cameraFollowEntity = null;
+                        }
+                    },
+                });
+                return jsonResult({ mode, followEntity: followEntity ?? null });
+            },
+        },
+        {
+            def: {
+                name: "get_camera_state",
+                description: "Get current camera position, target, and parameters.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            handler: () => {
+                const data = ctx.camera.getData();
+                const followKey = ctx.cameraFollowEntity ? ctx.getEntityKey(ctx.cameraFollowEntity) : null;
+                return jsonResult({
+                    ...data,
+                    fov: data.fov * (180 / Math.PI),
+                    followEntity: followKey,
+                });
+            },
+        },
+    ];
+    return tools;
+}