unreal-engine-mcp-server 0.2.1

package/dist/tools/debug.d.ts

@@ -0,0 +1,185 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+export declare class DebugVisualizationTools {
+    private bridge;
+    constructor(bridge: UnrealBridge);
+    private _executeCommand;
+    private pyDraw;
+    drawDebugLine(params: {
+        start: [number, number, number];
+        end: [number, number, number];
+        color?: [number, number, number, number];
+        duration?: number;
+        thickness?: number;
+    }): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+    }>;
+    drawDebugBox(params: {
+        center: [number, number, number];
+        extent: [number, number, number];
+        color?: [number, number, number, number];
+        rotation?: [number, number, number];
+        duration?: number;
+        thickness?: number;
+    }): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+    }>;
+    drawDebugSphere(params: {
+        center: [number, number, number];
+        radius: number;
+        segments?: number;
+        color?: [number, number, number, number];
+        duration?: number;
+        thickness?: number;
+    }): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+    }>;
+    drawDebugCapsule(params: {
+        center: [number, number, number];
+        halfHeight: number;
+        radius: number;
+        rotation?: [number, number, number];
+        color?: [number, number, number, number];
+        duration?: number;
+    }): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+    }>;
+    drawDebugCone(params: {
+        origin: [number, number, number];
+        direction: [number, number, number];
+        length: number;
+        angleWidth: number;
+        angleHeight: number;
+        numSides?: number;
+        color?: [number, number, number, number];
+        duration?: number;
+    }): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+    }>;
+    drawDebugString(params: {
+        location: [number, number, number];
+        text: string;
+        color?: [number, number, number, number];
+        duration?: number;
+        fontSize?: number;
+    }): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+    }>;
+    drawDebugArrow(params: {
+        start: [number, number, number];
+        end: [number, number, number];
+        arrowSize?: number;
+        color?: [number, number, number, number];
+        duration?: number;
+        thickness?: number;
+    }): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+    }>;
+    drawDebugPoint(params: {
+        location: [number, number, number];
+        size?: number;
+        color?: [number, number, number, number];
+        duration?: number;
+    }): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+    }>;
+    drawDebugCoordinateSystem(params: {
+        location: [number, number, number];
+        rotation?: [number, number, number];
+        scale?: number;
+        duration?: number;
+        thickness?: number;
+    }): Promise<any>;
+    drawDebugFrustum(params: {
+        origin: [number, number, number];
+        rotation: [number, number, number];
+        fov: number;
+        aspectRatio?: number;
+        nearPlane?: number;
+        farPlane?: number;
+        color?: [number, number, number, number];
+        duration?: number;
+    }): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+    }>;
+    clearDebugDrawings(): Promise<any>;
+    showCollision(params: {
+        enabled: boolean;
+        type?: 'Simple' | 'Complex' | 'Both';
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    showBounds(params: {
+        enabled: boolean;
+    }): Promise<any>;
+    setViewMode(params: {
+        mode: 'Lit' | 'Unlit' | 'Wireframe' | 'DetailLighting' | 'LightingOnly' | 'LightComplexity' | 'ShaderComplexity' | 'LightmapDensity' | 'StationaryLightOverlap' | 'ReflectionOverride' | 'CollisionPawn' | 'CollisionVisibility';
+    }): Promise<any>;
+    showDebugInfo(params: {
+        category: 'AI' | 'Animation' | 'Audio' | 'Collision' | 'Camera' | 'Game' | 'Hitboxes' | 'Input' | 'Net' | 'Physics' | 'Slate' | 'Streaming' | 'Particles' | 'Navigation';
+        enabled: boolean;
+    }): Promise<any>;
+    showActorNames(params: {
+        enabled: boolean;
+    }): Promise<any>;
+    drawDebugPath(params: {
+        points: Array<[number, number, number]>;
+        color?: [number, number, number, number];
+        duration?: number;
+        thickness?: number;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    showNavigationMesh(params: {
+        enabled: boolean;
+    }): Promise<any>;
+    enableOnScreenMessages(params: {
+        enabled: boolean;
+        key?: number;
+        message?: string;
+        duration?: number;
+        color?: [number, number, number, number];
+    }): Promise<any>;
+    showSkeletalMeshBones(params: {
+        actorName: string;
+        enabled: boolean;
+    }): Promise<any>;
+}
+//# sourceMappingURL=debug.d.ts.map

package/dist/tools/debug.js

@@ -0,0 +1,265 @@
+export class DebugVisualizationTools {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    // Execute console command (kept for legacy operations)
+    async _executeCommand(command) {
+        return this.bridge.httpCall('/remote/object/call', 'PUT', {
+            objectPath: '/Script/Engine.Default__KismetSystemLibrary',
+            functionName: 'ExecuteConsoleCommand',
+            parameters: {
+                WorldContextObject: null,
+                Command: command,
+                SpecificPlayer: null
+            },
+            generateTransaction: false
+        });
+    }
+    // Helper to draw via Python SystemLibrary with the editor world
+    async pyDraw(scriptBody) {
+        const script = `
+import unreal
+# Use modern UnrealEditorSubsystem instead of deprecated EditorLevelLibrary
+ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
+if ues:
+    world = ues.get_editor_world()
+else:
+    # Fallback to deprecated API if subsystem not available
+    world = unreal.EditorLevelLibrary.get_editor_world()
+${scriptBody}
+`.trim()
+            .replace(/\r?\n/g, '\n');
+        try {
+            await this.bridge.executePython(script);
+            return { success: true };
+        }
+        catch (e) {
+            return { success: false, error: String(e) };
+        }
+    }
+    // Draw debug line using Python SystemLibrary
+    async drawDebugLine(params) {
+        const color = params.color || [255, 0, 0, 255];
+        const duration = params.duration ?? 5.0;
+        const thickness = params.thickness ?? 1.0;
+        const [sr, sg, sb, sa] = color;
+        const [sx, sy, sz] = params.start;
+        const [ex, ey, ez] = params.end;
+        const script = `
+start = unreal.Vector(${sx}, ${sy}, ${sz})
+end = unreal.Vector(${ex}, ${ey}, ${ez})
+color = unreal.LinearColor(${sr}/255.0, ${sg}/255.0, ${sb}/255.0, ${sa}/255.0)
+unreal.SystemLibrary.draw_debug_line(world, start, end, color, ${duration}, ${thickness})
+`;
+        return this.pyDraw(script);
+    }
+    // Draw debug box using Python SystemLibrary
+    async drawDebugBox(params) {
+        const color = params.color || [0, 255, 0, 255];
+        const rotation = params.rotation || [0, 0, 0];
+        const duration = params.duration ?? 5.0;
+        const thickness = params.thickness ?? 1.0;
+        const [cr, cg, cb, ca] = color;
+        const [cx, cy, cz] = params.center;
+        const [ex, ey, ez] = params.extent;
+        const [rp, ry, rr] = rotation;
+        const script = `
+center = unreal.Vector(${cx}, ${cy}, ${cz})
+extent = unreal.Vector(${ex}, ${ey}, ${ez})
+rot = unreal.Rotator(${rp}, ${ry}, ${rr})
+color = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)
+unreal.SystemLibrary.draw_debug_box(world, center, extent, color, rot, ${duration}, ${thickness})
+`;
+        return this.pyDraw(script);
+    }
+    // Draw debug sphere using Python SystemLibrary
+    async drawDebugSphere(params) {
+        const segments = params.segments ?? 12;
+        const color = params.color || [0, 0, 255, 255];
+        const duration = params.duration ?? 5.0;
+        const thickness = params.thickness ?? 1.0;
+        const [cr, cg, cb, ca] = color;
+        const [cx, cy, cz] = params.center;
+        const script = `
+center = unreal.Vector(${cx}, ${cy}, ${cz})
+color = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)
+unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segments}, color, ${duration}, ${thickness})
+`;
+        return this.pyDraw(script);
+    }
+    // The rest keep console-command fallbacks or editor helpers as before
+    async drawDebugCapsule(params) {
+        const rotation = params.rotation || [0, 0, 0];
+        const color = params.color || [255, 255, 0, 255];
+        const duration = params.duration || 5.0;
+        const [cx, cy, cz] = params.center;
+        const [rp, ry, rr] = rotation;
+        const [cr, cg, cb, ca] = color;
+        const script = `\ncenter = unreal.Vector(${cx}, ${cy}, ${cz})\nrot = unreal.Rotator(${rp}, ${ry}, ${rr})\ncolor = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)\nunreal.SystemLibrary.draw_debug_capsule(world, center, ${params.halfHeight}, ${params.radius}, rot, color, ${duration}, 1.0)\n`;
+        return this.pyDraw(script);
+    }
+    async drawDebugCone(params) {
+        const color = params.color || [255, 0, 255, 255];
+        const duration = params.duration || 5.0;
+        const [ox, oy, oz] = params.origin;
+        const [dx, dy, dz] = params.direction;
+        const [cr, cg, cb, ca] = color;
+        const script = `\norigin = unreal.Vector(${ox}, ${oy}, ${oz})\ndir = unreal.Vector(${dx}, ${dy}, ${dz})\ncolor = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)\nunreal.SystemLibrary.draw_debug_cone(world, origin, dir, ${params.length}, ${params.angleWidth}, ${params.angleHeight}, ${params.numSides || 12}, color, ${duration}, 1.0)\n`;
+        return this.pyDraw(script);
+    }
+    async drawDebugString(params) {
+        const color = params.color || [255, 255, 255, 255];
+        const duration = params.duration || 5.0;
+        const [x, y, z] = params.location;
+        const [r, g, b, a] = color;
+        const script = `\nloc = unreal.Vector(${x}, ${y}, ${z})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_string(world, loc, "${params.text.replace(/"/g, '\\"')}", None, color, ${duration})\n`;
+        return this.pyDraw(script);
+    }
+    async drawDebugArrow(params) {
+        const color = params.color || [0, 255, 255, 255];
+        const duration = params.duration || 5.0;
+        const thickness = params.thickness || 2.0;
+        const [sx, sy, sz] = params.start;
+        const [ex, ey, ez] = params.end;
+        const [r, g, b, a] = color;
+        const script = `\nstart = unreal.Vector(${sx}, ${sy}, ${sz})\nend = unreal.Vector(${ex}, ${ey}, ${ez})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_arrow(world, start, end, ${params.arrowSize || 10.0}, color, ${duration}, ${thickness})\n`;
+        return this.pyDraw(script);
+    }
+    async drawDebugPoint(params) {
+        const size = params.size || 10.0;
+        const color = params.color || [255, 255, 255, 255];
+        const duration = params.duration || 5.0;
+        const [x, y, z] = params.location;
+        const [r, g, b, a] = color;
+        const script = `\nloc = unreal.Vector(${x}, ${y}, ${z})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_point(world, loc, ${size}, color, ${duration})\n`;
+        return this.pyDraw(script);
+    }
+    async drawDebugCoordinateSystem(params) {
+        const rotation = params.rotation || [0, 0, 0];
+        const scale = params.scale || 100.0;
+        const duration = params.duration || 5.0;
+        const thickness = params.thickness || 2.0;
+        const command = `DrawDebugCoordinateSystem ${params.location.join(' ')} ${rotation.join(' ')} ${scale} ${duration} ${thickness}`;
+        return this.bridge.executeConsoleCommand(command);
+    }
+    async drawDebugFrustum(params) {
+        const aspectRatio = params.aspectRatio || 1.77;
+        const nearPlane = params.nearPlane || 10.0;
+        const farPlane = params.farPlane || 1000.0;
+        const color = params.color || [128, 128, 255, 255];
+        const duration = params.duration || 5.0;
+        const [ox, oy, oz] = params.origin;
+        const [rp, ry, rr] = params.rotation;
+        const [r, g, b, a] = color;
+        const script = `\norigin = unreal.Vector(${ox}, ${oy}, ${oz})\nrot = unreal.Rotator(${rp}, ${ry}, ${rr})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_frustum(world, origin, rot, ${params.fov}, ${aspectRatio}, ${nearPlane}, ${farPlane}, color, ${duration})\n`;
+        return this.pyDraw(script);
+    }
+    async clearDebugDrawings() {
+        return this.bridge.executeConsoleCommand('FlushPersistentDebugLines');
+    }
+    async showCollision(params) {
+        const commands = [];
+        if (params.enabled) {
+            const typeCmd = params.type === 'Simple' ? '1' : params.type === 'Complex' ? '2' : '3';
+            commands.push(`show Collision ${typeCmd}`);
+        }
+        else {
+            commands.push('show Collision 0');
+        }
+        for (const cmd of commands) {
+            await this.bridge.executeConsoleCommand(cmd);
+        }
+        return { success: true, message: `Collision visualization ${params.enabled ? 'enabled' : 'disabled'}` };
+    }
+    async showBounds(params) {
+        const command = params.enabled ? 'show Bounds' : 'show Bounds 0';
+        return this.bridge.executeConsoleCommand(command);
+    }
+    async setViewMode(params) {
+        // Map non-viewmode requests to appropriate show flags for safety
+        if (params.mode === 'CollisionPawn' || params.mode === 'CollisionVisibility') {
+            // Use collision visualization instead of viewmode (UE doesn't have these as view modes)
+            await this.showCollision({ enabled: true, type: 'Both' });
+            return { success: true, message: 'Collision visualization enabled (use show flags, not viewmode)' };
+        }
+        const VALID_VIEWMODES = new Set([
+            'Lit', 'Unlit', 'Wireframe', 'DetailLighting', 'LightingOnly', 'LightComplexity', 'ShaderComplexity', 'LightmapDensity', 'StationaryLightOverlap', 'ReflectionOverride'
+        ]);
+        if (!VALID_VIEWMODES.has(params.mode)) {
+            // Fallback to Lit if unknown
+            await this.bridge.executeConsoleCommand('viewmode Lit');
+            return { success: false, warning: `Unknown or unsupported viewmode '${params.mode}'. Reverted to Lit.` };
+        }
+        const UNSAFE_VIEWMODES = [
+            'LightComplexity', 'ShaderComplexity', 'LightmapDensity', 'StationaryLightOverlap'
+        ];
+        if (UNSAFE_VIEWMODES.includes(params.mode)) {
+            console.error(`⚠️ Viewmode '${params.mode}' may be unstable in some UE configurations.`);
+            try {
+                await this.bridge.executeConsoleCommand('stop');
+            }
+            catch { }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        try {
+            const command = `viewmode ${params.mode}`;
+            const result = await this.bridge.executeConsoleCommand(command);
+            if (UNSAFE_VIEWMODES.includes(params.mode)) {
+                setTimeout(async () => {
+                    try {
+                        await this.bridge.executeConsoleCommand('stat unit');
+                    }
+                    catch {
+                        await this.bridge.executeConsoleCommand('viewmode Lit');
+                    }
+                }, 2000);
+            }
+            return { ...result, warning: UNSAFE_VIEWMODES.includes(params.mode) ? `Viewmode '${params.mode}' applied. This mode may be unstable.` : undefined };
+        }
+        catch (error) {
+            await this.bridge.executeConsoleCommand('viewmode Lit');
+            throw new Error(`Failed to set viewmode '${params.mode}': ${error}. Reverted to Lit mode.`);
+        }
+    }
+    async showDebugInfo(params) {
+        const command = `showdebug ${params.enabled ? params.category : 'None'}`;
+        return this.bridge.executeConsoleCommand(command);
+    }
+    async showActorNames(params) {
+        const command = params.enabled ? 'show ActorNames' : 'show ActorNames 0';
+        return this.bridge.executeConsoleCommand(command);
+    }
+    async drawDebugPath(params) {
+        const color = params.color || [255, 128, 0, 255];
+        const duration = params.duration || 5.0;
+        const thickness = params.thickness || 2.0;
+        for (let i = 0; i < params.points.length - 1; i++) {
+            const start = params.points[i];
+            const end = params.points[i + 1];
+            await this.drawDebugLine({ start, end, color, duration, thickness });
+        }
+        return { success: true, message: `Debug path drawn with ${params.points.length} points` };
+    }
+    async showNavigationMesh(params) {
+        const command = params.enabled ? 'show Navigation' : 'show Navigation 0';
+        return this.bridge.executeConsoleCommand(command);
+    }
+    async enableOnScreenMessages(params) {
+        if (params.enabled && params.message) {
+            const key = params.key || -1;
+            const duration = params.duration || 5.0;
+            const color = params.color || [255, 255, 255, 255];
+            const command = `ke * DisplayDebugMessage ${key} "${params.message}" ${duration} ${color.join(' ')}`;
+            return this.bridge.executeConsoleCommand(command);
+        }
+        else {
+            return this.bridge.executeConsoleCommand('DisableAllScreenMessages');
+        }
+    }
+    async showSkeletalMeshBones(params) {
+        const command = params.enabled ? `ShowDebugSkelMesh ${params.actorName}` : `HideDebugSkelMesh ${params.actorName}`;
+        return this.bridge.executeConsoleCommand(command);
+    }
+}
+//# sourceMappingURL=debug.js.map

package/dist/tools/editor.d.ts

@@ -0,0 +1,88 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+export declare class EditorTools {
+    private bridge;
+    constructor(bridge: UnrealBridge);
+    isInPIE(): Promise<boolean>;
+    ensureNotInPIE(): Promise<void>;
+    playInEditor(): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
+    stopPlayInEditor(): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
+    pausePlayInEditor(): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
+    pauseInEditor(): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
+    buildLighting(): Promise<{
+        success: boolean;
+        message: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        message?: undefined;
+    }>;
+    setViewportCamera(location?: {
+        x: number;
+        y: number;
+        z: number;
+    } | [number, number, number] | null | undefined, rotation?: {
+        pitch: number;
+        yaw: number;
+        roll: number;
+    } | [number, number, number] | null | undefined): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
+    setCameraSpeed(speed: number): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
+    setFOV(fov: number): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
+}
+//# sourceMappingURL=editor.d.ts.map