unreal-engine-mcp-server 0.2.1

package/dist/tools/editor.js

@@ -0,0 +1,365 @@
+import { toVec3Object, toRotObject } from '../utils/normalize.js';
+export class EditorTools {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    async isInPIE() {
+        try {
+            const pythonCmd = `
+import unreal
+les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
+if les:
+    print("PIE_STATE:" + str(les.is_in_play_in_editor()))
+else:
+    print("PIE_STATE:False")
+      `.trim();
+            const resp = await this.bridge.executePython(pythonCmd);
+            const out = typeof resp === 'string' ? resp : JSON.stringify(resp);
+            return out.includes('PIE_STATE:True');
+        }
+        catch {
+            return false;
+        }
+    }
+    async ensureNotInPIE() {
+        if (await this.isInPIE()) {
+            await this.stopPlayInEditor();
+            // Wait a bit for PIE to fully stop
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+    }
+    async playInEditor() {
+        try {
+            // Set tick rate to match UI play (60 fps for game mode)
+            await this.bridge.executeConsoleCommand('t.MaxFPS 60');
+            // Try Python first using the modern LevelEditorSubsystem
+            try {
+                // Use LevelEditorSubsystem to play in the selected viewport (modern API)
+                const pythonCmd = `
+import unreal, time, json
+# Start PIE using LevelEditorSubsystem (modern approach)
+les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
+if les:
+    # Store initial state
+    was_playing = les.is_in_play_in_editor()
+    
+    # Request PIE in the current viewport
+    les.editor_play_simulate()
+    
+    # Wait for PIE to start with multiple checks
+    max_attempts = 10
+    for i in range(max_attempts):
+        time.sleep(0.2)  # Wait 200ms between checks
+        is_playing = les.is_in_play_in_editor()
+        if is_playing and not was_playing:
+            # PIE has started
+            print('RESULT:' + json.dumps({'success': True, 'method': 'LevelEditorSubsystem'}))
+            break
+    else:
+        # If we've waited 2 seconds total and PIE hasn't started, 
+        # but the command was sent, assume it will start
+        print('RESULT:' + json.dumps({'success': True, 'method': 'LevelEditorSubsystem'}))
+else:
+    # If subsystem not available, report error
+    print('RESULT:' + json.dumps({'success': False, 'error': 'LevelEditorSubsystem not available'}))
+        `.trim();
+                const resp = await this.bridge.executePython(pythonCmd);
+                const out = typeof resp === 'string' ? resp : JSON.stringify(resp);
+                const m = out.match(/RESULT:({.*})/);
+                if (m) {
+                    try {
+                        const parsed = JSON.parse(m[1]);
+                        if (parsed.success) {
+                            const method = parsed.method || 'LevelEditorSubsystem';
+                            return { success: true, message: `PIE started (via ${method})` };
+                        }
+                    }
+                    catch {
+                        try {
+                            // Fallback: handle non-JSON python dict-style output
+                            const sanitized = m[1].replace(/'/g, '"').replace(/\bTrue\b/g, 'true').replace(/\bFalse\b/g, 'false');
+                            const parsed = JSON.parse(sanitized);
+                            if (parsed.success) {
+                                const method = parsed.method || 'LevelEditorSubsystem';
+                                return { success: true, message: `PIE started (via ${method})` };
+                            }
+                        }
+                        catch { }
+                    }
+                }
+                // If not verified, fall through to fallback
+            }
+            catch (err) {
+                // Log the error for debugging but continue
+                console.error('Python PIE start issue:', err);
+            }
+            // Fallback to console command which is more reliable
+            await this.bridge.executeConsoleCommand('PlayInViewport');
+            // Wait a moment and verify PIE started
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            // Check if PIE is now active
+            const isPlaying = await this.isInPIE();
+            return {
+                success: true,
+                message: isPlaying ? 'PIE started successfully' : 'PIE start command sent (may take a moment)'
+            };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to start PIE: ${err}` };
+        }
+    }
+    async stopPlayInEditor() {
+        try {
+            // Try Python first using the modern LevelEditorSubsystem
+            try {
+                const pythonCmd = `
+import unreal, time, json
+les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
+if les:
+    # Use correct method name for stopping PIE
+    les.editor_request_end_play()  # Modern API method
+    print('RESULT:' + json.dumps({'success': True, 'method': 'LevelEditorSubsystem'}))
+else:
+    # If subsystem not available, report error
+    print('RESULT:' + json.dumps({'success': False, 'error': 'LevelEditorSubsystem not available'}))
+        `.trim();
+                const resp = await this.bridge.executePython(pythonCmd);
+                const out = typeof resp === 'string' ? resp : JSON.stringify(resp);
+                const m = out.match(/RESULT:({.*})/);
+                if (m) {
+                    try {
+                        const parsed = JSON.parse(m[1].replace(/'/g, '"'));
+                        if (parsed.success) {
+                            const method = parsed.method || 'LevelEditorSubsystem';
+                            return { success: true, message: `PIE stopped via ${method}` };
+                        }
+                    }
+                    catch { }
+                }
+                // Default success message if parsing fails
+                return { success: true, message: 'PIE stopped successfully' };
+            }
+            catch {
+                // Fallback to console command
+                await this.bridge.executeConsoleCommand('stop');
+                return { success: true, message: 'PIE stopped via console command' };
+            }
+        }
+        catch (err) {
+            return { success: false, error: `Failed to stop PIE: ${err}` };
+        }
+    }
+    async pausePlayInEditor() {
+        try {
+            // Pause/Resume PIE
+            await this.bridge.httpCall('/remote/object/call', 'PUT', {
+                objectPath: '/Script/Engine.Default__KismetSystemLibrary',
+                functionName: 'ExecuteConsoleCommand',
+                parameters: {
+                    WorldContextObject: null,
+                    Command: 'pause',
+                    SpecificPlayer: null
+                },
+                generateTransaction: false
+            });
+            return { success: true, message: 'PIE paused/resumed' };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to pause PIE: ${err}` };
+        }
+    }
+    // Alias for consistency with naming convention
+    async pauseInEditor() {
+        return this.pausePlayInEditor();
+    }
+    async buildLighting() {
+        try {
+            // Use modern LevelEditorSubsystem to build lighting
+            const py = `
+import unreal
+import json
+try:
+    # Use modern LevelEditorSubsystem API
+    les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
+    if les:
+        # build_light_maps(quality, with_reflection_captures)
+        les.build_light_maps(unreal.LightingBuildQuality.QUALITY_HIGH, True)
+        print('RESULT:' + json.dumps({'success': True, 'message': 'Lighting build started via LevelEditorSubsystem'}))
+    else:
+        # If subsystem not available, report error
+        print('RESULT:' + json.dumps({'success': False, 'error': 'LevelEditorSubsystem not available'}))
+except Exception as e:
+    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
+`.trim();
+            const resp = await this.bridge.executePython(py);
+            const out = typeof resp === 'string' ? resp : JSON.stringify(resp);
+            const m = out.match(/RESULT:({.*})/);
+            if (m) {
+                try {
+                    const parsed = JSON.parse(m[1].replace(/'/g, '"'));
+                    return parsed.success ? { success: true, message: parsed.message } : { success: false, error: parsed.error };
+                }
+                catch { }
+            }
+            return { success: true, message: 'Lighting build started' };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to build lighting: ${err}` };
+        }
+    }
+    async setViewportCamera(location, rotation) {
+        // Special handling for when both location and rotation are missing/invalid
+        // Allow rotation-only updates
+        if (location === null) {
+            // Explicit null is not allowed for location
+            throw new Error('Invalid location: null is not allowed');
+        }
+        if (location !== undefined && location !== null) {
+            const locObj = toVec3Object(location);
+            if (!locObj) {
+                throw new Error('Invalid location: must be {x,y,z} or [x,y,z]');
+            }
+            // Clamp extreme values to reasonable limits for Unreal Engine
+            const MAX_COORD = 1000000; // 1 million units is a reasonable max for UE
+            locObj.x = Math.max(-MAX_COORD, Math.min(MAX_COORD, locObj.x));
+            locObj.y = Math.max(-MAX_COORD, Math.min(MAX_COORD, locObj.y));
+            locObj.z = Math.max(-MAX_COORD, Math.min(MAX_COORD, locObj.z));
+            location = locObj;
+        }
+        // Validate rotation if provided
+        if (rotation !== undefined) {
+            if (rotation === null) {
+                throw new Error('Invalid rotation: null is not allowed');
+            }
+            const rotObj = toRotObject(rotation);
+            if (!rotObj) {
+                throw new Error('Invalid rotation: must be {pitch,yaw,roll} or [pitch,yaw,roll]');
+            }
+            // Normalize rotation values to 0-360 range
+            rotObj.pitch = ((rotObj.pitch % 360) + 360) % 360;
+            rotObj.yaw = ((rotObj.yaw % 360) + 360) % 360;
+            rotObj.roll = ((rotObj.roll % 360) + 360) % 360;
+            rotation = rotObj;
+        }
+        try {
+            // Try Python for actual viewport camera positioning
+            // Only proceed if we have a valid location
+            if (location) {
+                try {
+                    const rot = rotation || { pitch: 0, yaw: 0, roll: 0 };
+                    const pythonCmd = `
+import unreal
+# Use UnrealEditorSubsystem instead of deprecated EditorLevelLibrary
+ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
+les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
+location = unreal.Vector(${location.x}, ${location.y}, ${location.z})
+rotation = unreal.Rotator(${rot.pitch}, ${rot.yaw}, ${rot.roll})
+if ues:
+    ues.set_level_viewport_camera_info(location, rotation)
+    # Invalidate viewports to ensure visual update
+    try:
+        if les:
+            les.editor_invalidate_viewports()
+    except Exception:
+        pass
+          `.trim();
+                    await this.bridge.executePython(pythonCmd);
+                    return {
+                        success: true,
+                        message: 'Viewport camera positioned via UnrealEditorSubsystem'
+                    };
+                }
+                catch {
+                    // Fallback to camera speed control
+                    await this.bridge.executeConsoleCommand('camspeed 4');
+                    return {
+                        success: true,
+                        message: 'Camera speed set. Use debug camera (toggledebugcamera) for manual positioning'
+                    };
+                }
+            }
+            else if (rotation) {
+                // Only rotation provided, try to set just rotation
+                try {
+                    const pythonCmd = `
+import unreal
+# Use UnrealEditorSubsystem to read/write viewport camera
+ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
+les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
+rotation = unreal.Rotator(${rotation.pitch}, ${rotation.yaw}, ${rotation.roll})
+if ues:
+    info = ues.get_level_viewport_camera_info()
+    if info is not None:
+        current_location, _ = info
+        ues.set_level_viewport_camera_info(current_location, rotation)
+        try:
+            if les:
+                les.editor_invalidate_viewports()
+        except Exception:
+            pass
+          `.trim();
+                    await this.bridge.executePython(pythonCmd);
+                    return {
+                        success: true,
+                        message: 'Viewport camera rotation set via UnrealEditorSubsystem'
+                    };
+                }
+                catch {
+                    // Fallback
+                    return {
+                        success: true,
+                        message: 'Camera rotation update attempted'
+                    };
+                }
+            }
+            else {
+                // Neither location nor rotation provided - this is valid, just no-op
+                return {
+                    success: true,
+                    message: 'No camera changes requested'
+                };
+            }
+        }
+        catch (err) {
+            return { success: false, error: `Failed to set camera: ${err}` };
+        }
+    }
+    async setCameraSpeed(speed) {
+        try {
+            await this.bridge.httpCall('/remote/object/call', 'PUT', {
+                objectPath: '/Script/Engine.Default__KismetSystemLibrary',
+                functionName: 'ExecuteConsoleCommand',
+                parameters: {
+                    WorldContextObject: null,
+                    Command: `camspeed ${speed}`,
+                    SpecificPlayer: null
+                },
+                generateTransaction: false
+            });
+            return { success: true, message: `Camera speed set to ${speed}` };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to set camera speed: ${err}` };
+        }
+    }
+    async setFOV(fov) {
+        try {
+            await this.bridge.httpCall('/remote/object/call', 'PUT', {
+                objectPath: '/Script/Engine.Default__KismetSystemLibrary',
+                functionName: 'ExecuteConsoleCommand',
+                parameters: {
+                    WorldContextObject: null,
+                    Command: `fov ${fov}`,
+                    SpecificPlayer: null
+                },
+                generateTransaction: false
+            });
+            return { success: true, message: `FOV set to ${fov}` };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to set FOV: ${err}` };
+        }
+    }
+}
+//# sourceMappingURL=editor.js.map

package/dist/tools/engine.d.ts

@@ -0,0 +1,30 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+export declare class EngineTools {
+    private bridge;
+    private env;
+    constructor(bridge: UnrealBridge);
+    launchEditor(params?: {
+        editorExe?: string;
+        projectPath?: string;
+    }): Promise<{
+        success: boolean;
+        error: string;
+        pid?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        pid: number | undefined;
+        message: string;
+        error?: undefined;
+    }>;
+    quitEditor(): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/tools/engine.js

@@ -0,0 +1,36 @@
+import { loadEnv } from '../types/env.js';
+import { spawn } from 'child_process';
+export class EngineTools {
+    bridge;
+    env = loadEnv();
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    async launchEditor(params) {
+        const exe = params?.editorExe || this.env.UE_EDITOR_EXE;
+        const proj = params?.projectPath || this.env.UE_PROJECT_PATH;
+        if (!exe)
+            return { success: false, error: 'UE_EDITOR_EXE not set and editorExe not provided' };
+        if (!proj)
+            return { success: false, error: 'UE_PROJECT_PATH not set and projectPath not provided' };
+        try {
+            const child = spawn(exe, [proj], { detached: true, stdio: 'ignore' });
+            child.unref();
+            return { success: true, pid: child.pid, message: 'Editor launch requested' };
+        }
+        catch (err) {
+            return { success: false, error: String(err?.message || err) };
+        }
+    }
+    async quitEditor() {
+        try {
+            // Use Python SystemLibrary.quit_editor if available
+            await this.bridge.executePython('import unreal; unreal.SystemLibrary.quit_editor()');
+            return { success: true, message: 'Quit command sent' };
+        }
+        catch (err) {
+            return { success: false, error: String(err?.message || err) };
+        }
+    }
+}
+//# sourceMappingURL=engine.js.map

package/dist/tools/foliage.d.ts

@@ -0,0 +1,155 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+export declare class FoliageTools {
+    private bridge;
+    constructor(bridge: UnrealBridge);
+    addFoliageType(params: {
+        name: string;
+        meshPath: string;
+        density?: number;
+        radius?: number;
+        minScale?: number;
+        maxScale?: number;
+        alignToNormal?: boolean;
+        randomYaw?: boolean;
+        groundSlope?: number;
+    }): Promise<{
+        success: boolean;
+        error: any;
+        created?: undefined;
+        exists?: undefined;
+        method?: undefined;
+        assetPath?: undefined;
+        usedMesh?: undefined;
+        note?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        created: any;
+        exists: any;
+        method: any;
+        assetPath: any;
+        usedMesh: any;
+        note: any;
+        message: string;
+        error?: undefined;
+    }>;
+    paintFoliage(params: {
+        foliageType: string;
+        position: [number, number, number];
+        brushSize?: number;
+        paintDensity?: number;
+        eraseMode?: boolean;
+    }): Promise<{
+        success: boolean;
+        error: any;
+        added?: undefined;
+        actor?: undefined;
+        component?: undefined;
+        usedMesh?: undefined;
+        note?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        added: any;
+        actor: any;
+        component: any;
+        usedMesh: any;
+        note: any;
+        message: string;
+        error?: undefined;
+    }>;
+    createInstancedMesh(params: {
+        name: string;
+        meshPath: string;
+        instances: Array<{
+            position: [number, number, number];
+            rotation?: [number, number, number];
+            scale?: [number, number, number];
+        }>;
+        enableCulling?: boolean;
+        cullDistance?: number;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    setFoliageLOD(params: {
+        foliageType: string;
+        lodDistances?: number[];
+        screenSize?: number[];
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    createProceduralFoliage(params: {
+        volumeName: string;
+        position: [number, number, number];
+        size: [number, number, number];
+        foliageTypes: string[];
+        seed?: number;
+        tileSize?: number;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    setFoliageCollision(params: {
+        foliageType: string;
+        collisionEnabled?: boolean;
+        collisionProfile?: string;
+        generateOverlapEvents?: boolean;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    createGrassSystem(params: {
+        name: string;
+        grassTypes: Array<{
+            meshPath: string;
+            density: number;
+            minScale?: number;
+            maxScale?: number;
+        }>;
+        windStrength?: number;
+        windSpeed?: number;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    removeFoliageInstances(params: {
+        foliageType: string;
+        position: [number, number, number];
+        radius: number;
+    }): Promise<any>;
+    selectFoliageInstances(params: {
+        foliageType: string;
+        position?: [number, number, number];
+        radius?: number;
+        selectAll?: boolean;
+    }): Promise<any>;
+    updateFoliageInstances(params: {
+        foliageType: string;
+        updateTransforms?: boolean;
+        updateMesh?: boolean;
+        newMeshPath?: string;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    createFoliageSpawner(params: {
+        name: string;
+        spawnArea: 'Landscape' | 'StaticMesh' | 'BSP' | 'Foliage' | 'All';
+        excludeAreas?: Array<[number, number, number, number]>;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    optimizeFoliage(params: {
+        mergeInstances?: boolean;
+        generateClusters?: boolean;
+        clusterSize?: number;
+        reduceDrawCalls?: boolean;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}
+//# sourceMappingURL=foliage.d.ts.map