unreal-engine-mcp-server 0.4.6 → 0.5.0

package/dist/tools/performance.js

@@ -1,11 +1,28 @@
-import { coerceBoolean, coerceNumber, interpretStandardResult } from '../utils/result-helpers.js';
+import { Logger } from '../utils/logger.js';
 export class PerformanceTools {
     bridge;
-    constructor(bridge) {
+    log = new Logger('PerformanceTools');
+    automationBridge;
+    constructor(bridge, automationBridge) {
         this.bridge = bridge;
+        this.automationBridge = automationBridge;
+    }
+    setAutomationBridge(automationBridge) {
+        this.automationBridge = automationBridge;
     }
-    // Start profiling
     async startProfiling(params) {
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('start_profiling', {
+                    type: params.type,
+                    duration: params.duration
+                });
+                if (response.success)
+                    return { success: true, message: `${params.type} profiling started (bridge)` };
+            }
+            catch (_e) {
+            }
+        }
         const commands = [];
         switch (params.type) {
             case 'CPU':
@@ -35,8 +52,16 @@ export class PerformanceTools {
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: `${params.type} profiling started` };
     }
-    // Stop profiling
     async stopProfiling() {
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('stop_profiling', {});
+                if (response.success)
+                    return { success: true, message: 'Profiling stopped (bridge)' };
+            }
+            catch (_e) {
+            }
+        }
         const commands = [
             'stat stopfile',
             'stat none'
@@ -44,19 +69,32 @@ export class PerformanceTools {
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Profiling stopped' };
     }
-    // Show FPS
     async showFPS(params) {
         const startTime = Date.now();
-        console.log('[PerformanceTools] Starting showFPS with params:', params);
+        this.log.debug('Starting showFPS with params:', params);
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('show_fps', {
+                    enabled: params.enabled,
+                    verbose: params.verbose
+                });
+                if (response.success)
+                    return {
+                        success: true,
+                        message: params.enabled ? 'FPS display enabled (bridge)' : 'FPS display disabled (bridge)',
+                        fpsVisible: params.enabled
+                    };
+            }
+            catch (_e) {
+            }
+        }
         try {
-            // Use stat fps as requested - shows FPS counter
-            // For more detailed timing info, use 'stat unit' instead
             const command = params.enabled
                 ? (params.verbose ? 'stat unit' : 'stat fps')
                 : 'stat none';
-            console.log(`[PerformanceTools] Executing command: ${command}`);
+            this.log.debug(`Executing command: ${command}`);
             await this.bridge.executeConsoleCommand(command);
-            console.log(`[PerformanceTools] Command completed in ${Date.now() - startTime}ms`);
+            this.log.debug(`Command completed in ${Date.now() - startTime}ms`);
             return {
                 success: true,
                 message: params.enabled ? 'FPS display enabled' : 'FPS display disabled',
@@ -72,17 +110,37 @@ export class PerformanceTools {
             };
         }
     }
-    // Show performance stats
     async showStats(params) {
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('show_stats', {
+                    category: params.category,
+                    enabled: params.enabled
+                });
+                if (response.success)
+                    return { success: true, message: `Stat '${params.category}' configured (bridge)` };
+            }
+            catch (_e) {
+            }
+        }
         const command = params.enabled
             ? `stat ${params.category.toLowerCase()}`
             : 'stat none';
         return this.bridge.executeConsoleCommand(command);
     }
-    // Set scalability settings using console commands
     async setScalability(params) {
-        // Map incoming category to the base name expected by "sg.<Base>Quality"
-        // Note: Several CVars use singular form (Shadow/Texture/Reflection)
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('set_scalability', {
+                    category: params.category,
+                    level: params.level
+                });
+                if (response.success)
+                    return { success: true, message: `${params.category} quality set to level ${params.level} (bridge)` };
+            }
+            catch (_e) {
+            }
+        }
         const categoryBaseMap = {
             ViewDistance: 'ViewDistance',
             AntiAliasing: 'AntiAliasing',
@@ -104,98 +162,35 @@ export class PerformanceTools {
             };
         }
         const base = categoryBaseMap[params.category] || params.category;
-        // Use direct console command to set with highest priority (SetByConsole)
-        // This avoids conflicts with the scalability system
         const setCommand = `sg.${base}Quality ${requestedLevel}`;
-        // Apply the console command directly
         await this.bridge.executeConsoleCommand(setCommand);
-        // Skip GameUserSettings entirely to avoid any scalability triggers
-        // Console command already applied with correct priority
-        /* eslint-disable no-useless-escape */
-        const py = `
-import unreal, json
-result = {'success': True, 'category': '${base}', 'requested': ${requestedLevel}, 'actual': ${requestedLevel}, 'method': 'ConsoleOnly'}
-
-# Simply verify the console variable was set correctly
-try:
-    # Try to read the console variable directly to verify it was set
-    # This doesn't trigger any scalability system
-    import sys
-    from io import StringIO
-    
-    # Capture console output
-    old_stdout = sys.stdout
-    sys.stdout = StringIO()
-    
-    # Execute console command to query the value
-    try:
-        unreal.SystemLibrary.execute_console_command(None, 'sg.${base}Quality', None)
-    except:
-        pass
-    
-    # Get the output
-    console_output = sys.stdout.getvalue()
-    sys.stdout = old_stdout
-    
-    # Parse the output to get the actual value
-    if 'sg.${base}Quality' in console_output:
-        # Extract the value from output like 'sg.ShadowQuality = "3"'
-        import re
-        match = re.search(r'sg\.${base}Quality\\s*=\\s*"(\\d+)"', console_output)
-        if match:
-            result['actual'] = int(match.group(1))
-            result['verified'] = True
-    
-    result['method'] = 'ConsoleOnly'
-except Exception as e:
-    # Even on error, the console command was applied
-    result['method'] = 'ConsoleOnly'
-    result['note'] = str(e)
-
-print('RESULT:' + json.dumps(result))
-`.trim();
-        /* eslint-enable no-useless-escape */
-        // Always try to apply through Python for consistency
-        try {
-            const pyResp = await this.bridge.executePython(py);
-            const interpreted = interpretStandardResult(pyResp, {
-                successMessage: `${params.category} quality set to level ${requestedLevel}`,
-                failureMessage: `Failed to set ${params.category} quality`
-            });
-            if (interpreted.success) {
-                const actual = coerceNumber(interpreted.payload.actual) ?? requestedLevel;
-                const verified = coerceBoolean(interpreted.payload.success, true) === true && actual === requestedLevel;
-                return {
-                    success: true,
-                    message: interpreted.message,
-                    verified,
-                    readback: actual,
-                    method: interpreted.payload.method || 'ConsoleOnly'
-                };
-            }
-        }
-        catch {
-            // Ignore Python errors and fall through
-        }
-        // If Python fails, the console command was still applied
         return {
             success: true,
             message: `${params.category} quality set to level ${requestedLevel}`,
-            method: 'CVarOnly'
+            method: 'Console'
         };
     }
-    // Set resolution scale
     async setResolutionScale(params) {
-        // Validate input
         if (params.scale === undefined || params.scale === null || isNaN(params.scale)) {
             return { success: false, error: 'Invalid scale parameter' };
         }
-        // Clamp scale between 10% (0.1) and 200% (2.0) - Unreal Engine limits
-        // Note: r.ScreenPercentage takes values from 10 to 200, not 0.5 to 2.0
-        const clampedScale = Math.max(0.1, Math.min(2.0, params.scale));
-        const percentage = Math.round(clampedScale * 100);
-        // Ensure percentage is within Unreal's valid range
+        let percentage;
+        if (params.scale >= 10) {
+            percentage = Math.round(params.scale);
+        }
+        else {
+            percentage = Math.round(params.scale * 100);
+        }
         const finalPercentage = Math.max(10, Math.min(200, percentage));
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('set_resolution_scale', { scale: finalPercentage });
+                if (response.success)
+                    return { success: true, message: `Resolution scale set to ${finalPercentage}% (bridge)`, actualScale: finalPercentage / 100 };
+            }
+            catch (_e) {
+            }
+        }
         const command = `r.ScreenPercentage ${finalPercentage}`;
         try {
             await this.bridge.executeConsoleCommand(command);
@@ -209,23 +204,53 @@ print('RESULT:' + json.dumps(result))
             return { success: false, error: `Failed to set resolution scale: ${e}` };
         }
     }
-    // Enable/disable vsync
     async setVSync(params) {
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('set_vsync', { enabled: params.enabled });
+                if (response.success)
+                    return { success: true, message: 'VSync configured (bridge)' };
+            }
+            catch (_e) {
+            }
+        }
         const command = `r.VSync ${params.enabled ? 1 : 0}`;
         return this.bridge.executeConsoleCommand(command);
     }
-    // Set frame rate limit
     async setFrameRateLimit(params) {
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('set_frame_rate_limit', { maxFPS: params.maxFPS });
+                if (response.success)
+                    return { success: true, message: 'Max FPS set (bridge)' };
+            }
+            catch (_e) {
+            }
+        }
         const command = `t.MaxFPS ${params.maxFPS}`;
         return this.bridge.executeConsoleCommand(command);
     }
-    // Enable GPU timing
     async enableGPUTiming(params) {
         const command = `r.GPUStatsEnabled ${params.enabled ? 1 : 0}`;
         return this.bridge.executeConsoleCommand(command);
     }
-    // Memory report
     async generateMemoryReport(params) {
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('generate_memory_report', {
+                    detailed: params.detailed ?? false,
+                    outputPath: params.outputPath
+                });
+                if (response.success) {
+                    return { success: true, message: response.message || 'Memory report generated' };
+                }
+            }
+            catch (error) {
+                if (params.outputPath) {
+                    return { success: false, error: `Failed to generate memory report: ${error instanceof Error ? error.message : String(error)}` };
+                }
+            }
+        }
         const commands = [];
         if (params.detailed) {
             commands.push('memreport -full');
@@ -234,43 +259,67 @@ print('RESULT:' + json.dumps(result))
             commands.push('memreport');
         }
         if (params.outputPath) {
-            commands.push(`obj savepackage ${params.outputPath}`);
+            throw new Error('Saving memreport to a file requires Automation Bridge support');
         }
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Memory report generated' };
     }
-    // Texture streaming
     async configureTextureStreaming(params) {
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('configure_texture_streaming', {
+                    enabled: params.enabled,
+                    poolSize: params.poolSize,
+                    boostPlayerLocation: params.boostPlayerLocation
+                });
+                if (response.success)
+                    return { success: true, message: response.message || 'Texture streaming configured (bridge)' };
+            }
+            catch (_error) {
+            }
+        }
+        if (params.boostPlayerLocation && !this.automationBridge) {
+            throw new Error('Boosting player location for streaming requires Automation Bridge support');
+        }
         const commands = [];
         commands.push(`r.TextureStreaming ${params.enabled ? 1 : 0}`);
         if (params.poolSize !== undefined) {
             commands.push(`r.Streaming.PoolSize ${params.poolSize}`);
         }
-        if (params.boostPlayerLocation !== undefined) {
-            commands.push(`r.Streaming.UseFixedPoolSize ${params.boostPlayerLocation ? 1 : 0}`);
-        }
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Texture streaming configured' };
     }
-    // LOD settings
     async configureLOD(params) {
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('configure_lod', {
+                    forceLOD: params.forceLOD,
+                    lodBias: params.lodBias
+                });
+                if (params.distanceScale !== undefined) {
+                    await this.bridge.executeConsoleCommand(`r.StaticMeshLODDistanceScale ${params.distanceScale}`);
+                    await this.bridge.executeConsoleCommand(`r.SkeletalMeshLODDistanceScale ${params.distanceScale}`);
+                }
+                if (response.success)
+                    return { success: true, message: 'LOD settings configured' };
+            }
+            catch (_e) {
+            }
+        }
         const commands = [];
         if (params.forceLOD !== undefined) {
             commands.push(`r.ForceLOD ${params.forceLOD}`);
         }
         if (params.lodBias !== undefined) {
-            // Skeletal mesh LOD bias is an integer bias value
             commands.push(`r.SkeletalMeshLODBias ${params.lodBias}`);
         }
         if (params.distanceScale !== undefined) {
-            // Apply distance scale to both static and skeletal meshes
             commands.push(`r.StaticMeshLODDistanceScale ${params.distanceScale}`);
             commands.push(`r.SkeletalMeshLODDistanceScale ${params.distanceScale}`);
         }
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'LOD settings configured' };
     }
-    // Apply a baseline performance profile (explicit CVar enforcement)
     async applyBaselinePerformanceSettings(params) {
         const p = {
             distanceScale: params?.distanceScale ?? 1.0,
@@ -290,32 +339,52 @@ print('RESULT:' + json.dumps(result))
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Baseline performance settings applied', params: p };
     }
-    // Draw call optimization
     async optimizeDrawCalls(params) {
+        if (params.mergeActors) {
+            if (this.automationBridge) {
+                try {
+                    const actors = Array.isArray(params.actors)
+                        ? params.actors.filter((name) => typeof name === 'string' && name.length > 0)
+                        : undefined;
+                    if (!actors || actors.length < 2) {
+                        return {
+                            success: false,
+                            error: 'Merge actors requires an "actors" array with at least 2 valid actor names.'
+                        };
+                    }
+                    const payload = {
+                        enableInstancing: params.enableInstancing,
+                        enableBatching: params.enableBatching,
+                        mergeActors: params.mergeActors,
+                        actors: actors
+                    };
+                    const response = await this.automationBridge.sendAutomationRequest('merge_actors', payload);
+                    return response.success
+                        ? { success: true, message: response.message || 'Actors merged for optimization' }
+                        : { success: false, error: response.message || response.error || 'Failed to merge actors' };
+                }
+                catch (error) {
+                    return { success: false, error: `Failed to merge actors: ${error instanceof Error ? error.message : String(error)}` };
+                }
+            }
+            throw new Error('Actor merging requires Automation Bridge support');
+        }
         const commands = [];
         if (params.enableInstancing !== undefined) {
             commands.push(`r.MeshDrawCommands.DynamicInstancing ${params.enableInstancing ? 1 : 0}`);
         }
-        // Avoid using r.RHICmdBypass; it's a low-level debug toggle and not suitable for general batching control
-        if (params.mergeActors) {
-            commands.push('MergeActors');
-        }
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Draw call optimization configured' };
     }
-    // Occlusion culling
     async configureOcclusionCulling(params) {
         const commands = [];
-        // Enable/disable HZB occlusion (boolean)
         commands.push(`r.HZBOcclusion ${params.enabled ? 1 : 0}`);
-        // Optional freeze rendering toggle
         if (params.freezeRendering !== undefined) {
             commands.push(`FreezeRendering ${params.freezeRendering ? 1 : 0}`);
         }
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Occlusion culling configured' };
     }
-    // Shader compilation
     async optimizeShaders(params) {
         const commands = [];
         if (params.compileOnDemand !== undefined) {
@@ -330,8 +399,26 @@ print('RESULT:' + json.dumps(result))
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Shader optimization configured' };
     }
-    // Nanite settings
     async configureNanite(params) {
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('configure_nanite', {
+                    enabled: params.enabled,
+                    maxPixelsPerEdge: params.maxPixelsPerEdge,
+                    streamingPoolSize: params.streamingPoolSize
+                });
+                if (params.maxPixelsPerEdge !== undefined) {
+                    await this.bridge.executeConsoleCommand(`r.Nanite.MaxPixelsPerEdge ${params.maxPixelsPerEdge}`);
+                }
+                if (params.streamingPoolSize !== undefined) {
+                    await this.bridge.executeConsoleCommand(`r.Nanite.StreamingPoolSize ${params.streamingPoolSize}`);
+                }
+                if (response.success)
+                    return { success: true, message: 'Nanite configured' };
+            }
+            catch (_e) {
+            }
+        }
         const commands = [];
         commands.push(`r.Nanite ${params.enabled ? 1 : 0}`);
         if (params.maxPixelsPerEdge !== undefined) {
@@ -343,7 +430,6 @@ print('RESULT:' + json.dumps(result))
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Nanite configured' };
     }
-    // World Partition streaming
     async configureWorldPartition(params) {
         const commands = [];
         commands.push(`wp.Runtime.EnableStreaming ${params.enabled ? 1 : 0}`);
@@ -356,14 +442,10 @@ print('RESULT:' + json.dumps(result))
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'World Partition configured' };
     }
-    // Benchmark
     async runBenchmark(params) {
         const duration = params.duration || 60;
-        // Start recording and GPU profiling
         await this.bridge.executeConsoleCommands(['stat startfile', 'profilegpu']);
-        // Wait for the requested duration
         await new Promise(resolve => setTimeout(resolve, duration * 1000));
-        // Stop recording and clear stats
         await this.bridge.executeConsoleCommands(['stat stopfile', 'stat none']);
         return { success: true, message: `Benchmark completed for ${duration} seconds` };
     }

package/dist/tools/physics.d.ts

@@ -1,18 +1,11 @@
 import { UnrealBridge } from '../unreal-bridge.js';
+import { AutomationBridge } from '../automation/index.js';
 export declare class PhysicsTools {
     private bridge;
-    constructor(bridge: UnrealBridge);
-    /**
-     * Helper to find a valid skeletal mesh in the project
-     */
+    private automationBridge?;
+    constructor(bridge: UnrealBridge, automationBridge?: AutomationBridge | undefined);
+    setAutomationBridge(automationBridge?: AutomationBridge): void;
     private findValidSkeletalMesh;
-    /**
-     * Setup Ragdoll Physics
-     * NOTE: Requires a valid skeletal mesh to create physics asset
-     * @param skeletonPath - Path to an existing skeletal mesh asset (required)
-     * @param physicsAssetName - Name for the new physics asset
-     * @param savePath - Directory to save the asset (default: /Game/Physics)
-     */
     setupRagdoll(params: {
         skeletonPath: string;
         physicsAssetName: string;
@@ -27,35 +20,7 @@ export declare class PhysicsTools {
                 twist?: number;
             };
         }>;
-    }): Promise<{
-        success: true;
-        message: string;
-        path: string;
-        existingAsset?: boolean;
-        warnings?: string[];
-        details?: string[];
-    } | {
-        success: boolean;
-        message: string;
-        error: string | undefined;
-        warnings?: undefined;
-        details?: undefined;
-    } | {
-        success: false;
-        message: string;
-        error: string;
-        warnings: string[] | undefined;
-        details: string[] | undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-        warnings?: undefined;
-        details?: undefined;
-    }>;
-    /**
-     * Create Physics Constraint
-     */
+    }): Promise<any>;
     createConstraint(params: {
         name: string;
         actor1: string;
@@ -78,9 +43,6 @@ export declare class PhysicsTools {
         error: string;
         message?: undefined;
     }>;
-    /**
-     * Setup Chaos Destruction
-     */
     setupDestruction(params: {
         meshPath: string;
         destructionName: string;
@@ -103,9 +65,6 @@ export declare class PhysicsTools {
         message?: undefined;
         path?: undefined;
     }>;
-    /**
-     * Configure Vehicle Physics
-     */
     configureVehicle(params: {
         vehicleName: string;
         vehicleType: 'Car' | 'Bike' | 'Tank' | 'Aircraft';
@@ -125,46 +84,27 @@ export declare class PhysicsTools {
             gears: number[];
             finalDriveRatio: number;
         };
+        pluginDependencies?: string[];
     }): Promise<{
         success: boolean;
+        error: string;
+        missingPlugins: string[];
         message: string;
-        error?: undefined;
+        warnings?: undefined;
     } | {
         success: boolean;
-        error: string;
-        message?: undefined;
+        message: string;
+        warnings: string[];
+        error?: undefined;
+        missingPlugins?: undefined;
     }>;
-    /**
-     * Apply Force or Impulse to Actor
-     */
     applyForce(params: {
         actorName: string;
         forceType: 'Force' | 'Impulse' | 'Velocity' | 'Torque';
         vector: [number, number, number];
         boneName?: string;
         isLocal?: boolean;
-    }): Promise<{
-        success: boolean;
-        message: string;
-        availableActors: string[] | undefined;
-        details: string[] | undefined;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        availableActors: string[] | undefined;
-        details: string[] | undefined;
-        message?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-        availableActors?: undefined;
-        details?: undefined;
-    }>;
-    /**
-     * Configure Cloth Simulation
-     */
+    }): Promise<any>;
     setupCloth(params: {
         meshName: string;
         clothPreset: 'Silk' | 'Leather' | 'Denim' | 'Rubber' | 'Custom';
@@ -185,9 +125,6 @@ export declare class PhysicsTools {
         error: string;
         message?: undefined;
     }>;
-    /**
-     * Create Fluid Simulation (Niagara-based)
-     */
     createFluidSimulation(params: {
         name: string;
         fluidType: 'Water' | 'Smoke' | 'Fire' | 'Lava' | 'Custom';
@@ -209,5 +146,23 @@ export declare class PhysicsTools {
         error: string;
         message?: undefined;
     }>;
+    setupPhysicsSimulation(params: {
+        meshPath?: string;
+        skeletonPath?: string;
+        physicsAssetName?: string;
+        savePath?: string;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        error: string | undefined;
+    } | {
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
 }
 //# sourceMappingURL=physics.d.ts.map