unreal-engine-mcp-server 0.5.0 → 0.5.1

package/dist/tools/niagara.js

@@ -1,4 +1,5 @@
 import { sanitizeAssetName, validateAssetParams } from '../utils/validation.js';
+import { wasmIntegration } from '../wasm/index.js';
 export class NiagaraTools {
     bridge;
     automationBridge;
@@ -12,6 +13,16 @@ export class NiagaraTools {
             if (!this.automationBridge || typeof this.automationBridge.sendAutomationRequest !== 'function') {
                 throw new Error('Automation Bridge not available. Niagara system creation requires plugin support.');
             }
+            if (params.emitters) {
+                for (const emitter of params.emitters) {
+                    if (emitter.shapeSize) {
+                        const zeroVector = [0, 0, 0];
+                        const processedSize = wasmIntegration.vectorAdd(zeroVector, emitter.shapeSize);
+                        console.error('[WASM] Using vectorAdd for Niagara emitter shape size');
+                        emitter.shapeSize = [processedSize[0], processedSize[1], processedSize[2]];
+                    }
+                }
+            }
             const path = params.savePath || '/Game/Effects/Niagara';
             const response = await this.automationBridge.sendAutomationRequest('create_niagara_system', { name: params.name, savePath: path, template: params.template }, { timeoutMs: 60000 });
             if (response && response.success !== false) {
@@ -82,8 +93,19 @@ export class NiagaraTools {
             return [value.x ?? 0, value.y ?? 0, value.z ?? 0];
         };
         const requestPayload = { systemPath: params.systemPath };
-        const start = toVector(params.start);
-        const end = toVector(params.end);
+        let start = toVector(params.start);
+        let end = toVector(params.end);
+        const zeroVector = [0, 0, 0];
+        if (start) {
+            const processed = wasmIntegration.vectorAdd(zeroVector, start);
+            console.error('[WASM] Using vectorAdd for Niagara ribbon start');
+            start = [processed[0], processed[1], processed[2]];
+        }
+        if (end) {
+            const processed = wasmIntegration.vectorAdd(zeroVector, end);
+            console.error('[WASM] Using vectorAdd for Niagara ribbon end');
+            end = [processed[0], processed[1], processed[2]];
+        }
         if (start)
             requestPayload.start = start;
         if (end)
@@ -148,6 +170,19 @@ export class NiagaraTools {
         if (!this.automationBridge || typeof this.automationBridge.sendAutomationRequest !== 'function') {
             return { success: false, error: 'AUTOMATION_BRIDGE_UNAVAILABLE', message: 'addEmitter requires automation bridge' };
         }
+        if (params.properties) {
+            const zeroVector = [0, 0, 0];
+            if (params.properties.velocityMin) {
+                const processed = wasmIntegration.vectorAdd(zeroVector, params.properties.velocityMin);
+                console.error('[WASM] Using vectorAdd for Niagara velocity min');
+                params.properties.velocityMin = [processed[0], processed[1], processed[2]];
+            }
+            if (params.properties.velocityMax) {
+                const processed = wasmIntegration.vectorAdd(zeroVector, params.properties.velocityMax);
+                console.error('[WASM] Using vectorAdd for Niagara velocity max');
+                params.properties.velocityMax = [processed[0], processed[1], processed[2]];
+            }
+        }
         try {
             const resp = await this.automationBridge.sendAutomationRequest('manage_niagara_graph', {
                 subAction: 'add_emitter',

package/dist/tools/performance.d.ts

@@ -131,7 +131,6 @@ export declare class PerformanceTools {
     }>;
     optimizeDrawCalls(params: {
         enableInstancing?: boolean;
-        enableBatching?: boolean;
         mergeActors?: boolean;
         actors?: string[];
     }): Promise<{

package/dist/tools/performance.js

@@ -354,7 +354,6 @@ export class PerformanceTools {
                     }
                     const payload = {
                         enableInstancing: params.enableInstancing,
-                        enableBatching: params.enableBatching,
                         mergeActors: params.mergeActors,
                         actors: actors
                     };

package/dist/tools/physics.js

@@ -1,5 +1,6 @@
 import { validateAssetParams, resolveSkeletalMeshPath, concurrencyDelay } from '../utils/validation.js';
 import { coerceString, coerceStringArray } from '../utils/result-helpers.js';
+import { wasmIntegration } from '../wasm/index.js';
 export class PhysicsTools {
     bridge;
     automationBridge;
@@ -309,10 +310,13 @@ export class PhysicsTools {
             throw new Error('Automation Bridge not available. Physics force application requires plugin support.');
         }
         try {
+            const zeroVector = [0, 0, 0];
+            const normalizedVector = wasmIntegration.vectorAdd(zeroVector, params.vector);
+            console.error('[WASM] Using vectorAdd for physics force vector processing');
             const response = await this.automationBridge.sendAutomationRequest('apply_force', {
                 actorName: params.actorName,
                 forceType: params.forceType,
-                vector: params.vector,
+                vector: normalizedVector,
                 boneName: params.boneName,
                 isLocal: params.isLocal
             }, {

package/dist/tools/sequence.d.ts

@@ -1,5 +1,5 @@
 import { BaseTool } from './base-tool.js';
-import { ISequenceTools } from '../types/tool-interfaces.js';
+import { ISequenceTools, StandardActionResponse } from '../types/tool-interfaces.js';
 export interface LevelSequence {
     path: string;
     name: string;
@@ -28,80 +28,80 @@ export declare class SequenceTools extends BaseTool implements ISequenceTools {
         name: string;
         path?: string;
         timeoutMs?: number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     open(params: {
         path: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     addCamera(params: {
         spawnable?: boolean;
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     addActor(params: {
         actorName: string;
         createBinding?: boolean;
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     play(params?: {
         path?: string;
         startTime?: number;
         loopMode?: 'once' | 'loop' | 'pingpong';
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     pause(params?: {
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     stop(params?: {
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setSequenceProperties(params: {
         path?: string;
         frameRate?: number;
         lengthInFrames?: number;
         playbackStart?: number;
         playbackEnd?: number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setDisplayRate(params: {
         path?: string;
         frameRate: string | number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     getSequenceProperties(params: {
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setPlaybackSpeed(params: {
         speed: number;
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     getBindings(params?: {
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     addActors(params: {
         actorNames: string[];
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     removeActors(params: {
         actorNames: string[];
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     addSpawnableFromClass(params: {
         className: string;
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     list(params?: {
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     duplicate(params: {
         path: string;
         destinationPath: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     rename(params: {
         path: string;
         newName: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     deleteSequence(params: {
         path: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     getMetadata(params: {
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     addKeyframe(params: {
         path?: string;
         bindingId?: string;
@@ -125,14 +125,14 @@ export declare class SequenceTools extends BaseTool implements ISequenceTools {
                 z: number;
             };
         };
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     listTracks(params: {
         path: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setWorkRange(params: {
         path?: string;
         start: number;
         end: number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
 }
 //# sourceMappingURL=sequence.d.ts.map

package/dist/tools/sequence.js

@@ -1,4 +1,5 @@
 import { BaseTool } from './base-tool.js';
+import { wasmIntegration } from '../wasm/index.js';
 export class SequenceTools extends BaseTool {
     sequenceCache = new Map();
     activeSequencePath;
@@ -214,6 +215,18 @@ export class SequenceTools extends BaseTool {
             frame: params.frame,
             value: params.value
         });
+        if (params.property === 'Transform' && params.value) {
+            const loc = params.value.location;
+            const rot = params.value.rotation;
+            const scale = params.value.scale;
+            if (loc && rot && scale) {
+                const locArr = [loc.x, loc.y, loc.z];
+                const rotArr = [rot.pitch, rot.yaw, rot.roll];
+                const scaleArr = [scale.x, scale.y, scale.z];
+                wasmIntegration.composeTransform(locArr, rotArr, scaleArr);
+                console.error('[WASM] Using composeTransform for keyframe validation');
+            }
+        }
         if (!resp.success && this.isUnknownActionResponse(resp)) {
             return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_add_keyframe' };
         }

package/dist/tools/ui.d.ts

@@ -69,7 +69,6 @@ export declare class UITools {
     setWidgetText(_params: {
         key: string;
         value: string;
-        componentName?: string;
     }): Promise<{
         success: boolean;
         message: string;
@@ -81,7 +80,6 @@ export declare class UITools {
     setWidgetImage(_params: {
         key: string;
         texturePath: string;
-        componentName?: string;
     }): Promise<{
         success: boolean;
         message: string;

package/dist/types/automation-responses.d.ts

@@ -0,0 +1,115 @@
+export interface AutomationResponse {
+    success: boolean;
+    message?: string;
+    error?: string | {
+        message: string;
+        code?: string;
+    };
+    result?: unknown;
+    warnings?: string[];
+    details?: unknown;
+    data?: unknown;
+    [key: string]: unknown;
+}
+export interface LevelResponse extends AutomationResponse {
+    levelPath?: string;
+    level?: string;
+    path?: string;
+    packagePath?: string;
+    objectPath?: string;
+    currentMap?: string;
+    currentMapPath?: string;
+    currentWorldLevels?: unknown[];
+    allMaps?: unknown[];
+    partitioned?: boolean;
+    streaming?: boolean;
+    loaded?: boolean;
+    visible?: boolean;
+    skipped?: boolean;
+    reason?: string;
+}
+export interface ActorResponse extends AutomationResponse {
+    actorName?: string;
+    actorLabel?: string;
+    actorPath?: string;
+    actors?: unknown[];
+    components?: unknown[];
+    location?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation?: {
+        pitch: number;
+        yaw: number;
+        roll: number;
+    };
+    scale?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    transform?: unknown;
+    tags?: string[];
+    properties?: Record<string, unknown>;
+    deleted?: boolean;
+    deletedCount?: number;
+}
+export interface AssetResponse extends AutomationResponse {
+    assetPath?: string;
+    asset?: string;
+    assets?: unknown[];
+    source?: string;
+    saved?: boolean;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+    graph?: Record<string, unknown[]>;
+}
+export interface EditorResponse extends AutomationResponse {
+    viewMode?: string;
+    fov?: number;
+    location?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation?: {
+        pitch: number;
+        yaw: number;
+        roll: number;
+    };
+    cameraSettings?: unknown;
+    camera?: {
+        location?: unknown;
+        rotation?: unknown;
+    };
+    resolution?: {
+        width: number;
+        height: number;
+    };
+    filename?: string;
+    filePath?: string;
+    isPlaying?: boolean;
+    isPaused?: boolean;
+    isInPIE?: boolean;
+    playSessionId?: string;
+    bookmarkName?: string;
+    bookmarks?: unknown[];
+    realtime?: boolean;
+}
+export interface SequenceResponse extends AutomationResponse {
+    sequencePath?: string;
+    sequence?: string;
+    bindingId?: string;
+    trackName?: string;
+    keyframe?: unknown;
+    frameNumber?: number;
+    length?: number;
+    playbackPosition?: number;
+    requestId?: string;
+}
+export interface ConsoleResponse extends AutomationResponse {
+    output?: string;
+    command?: string;
+}
+//# sourceMappingURL=automation-responses.d.ts.map

package/dist/types/automation-responses.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=automation-responses.js.map

package/dist/types/responses.d.ts

@@ -0,0 +1,249 @@
+export interface BaseResponse {
+    success: boolean;
+    message?: string;
+    error?: string;
+    errorCode?: string;
+}
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Rotator {
+    pitch: number;
+    yaw: number;
+    roll: number;
+}
+export interface Transform {
+    location?: Vector3;
+    rotation?: Rotator;
+    scale?: Vector3;
+}
+export interface SpawnActorResponse extends BaseResponse {
+    actorName?: string;
+    actorPath?: string;
+    classPath?: string;
+}
+export interface DeleteActorResponse extends BaseResponse {
+    deletedCount?: number;
+    deletedActors?: string[];
+}
+export interface GetTransformResponse extends BaseResponse {
+    location?: Vector3;
+    rotation?: Rotator;
+    scale?: Vector3;
+}
+export interface SetTransformResponse extends BaseResponse {
+    actorName?: string;
+}
+export interface FindActorsResponse extends BaseResponse {
+    actors?: Array<{
+        name: string;
+        label?: string;
+        class?: string;
+        path?: string;
+    }>;
+    count?: number;
+}
+export interface GetComponentsResponse extends BaseResponse {
+    components?: Array<{
+        name: string;
+        type: string;
+        properties?: Record<string, unknown>;
+    }>;
+}
+export interface ApplyForceResponse extends BaseResponse {
+    actorName?: string;
+    forceApplied?: Vector3;
+}
+export interface AssetInfo {
+    name: string;
+    path: string;
+    class?: string;
+    packagePath?: string;
+    size?: number;
+}
+export interface ListAssetsResponse extends BaseResponse {
+    assets?: AssetInfo[];
+    count?: number;
+    directory?: string;
+}
+export interface CreateAssetResponse extends BaseResponse {
+    assetPath?: string;
+    assetName?: string;
+}
+export interface DeleteAssetResponse extends BaseResponse {
+    deletedPath?: string;
+    deletedCount?: number;
+}
+export interface GetDependenciesResponse extends BaseResponse {
+    dependencies?: string[];
+    referencers?: string[];
+    count?: number;
+}
+export interface AssetExistsResponse extends BaseResponse {
+    exists?: boolean;
+    assetPath?: string;
+}
+export interface CreateBlueprintResponse extends BaseResponse {
+    blueprintPath?: string;
+    blueprintName?: string;
+    parentClass?: string;
+}
+export interface GetBlueprintResponse extends BaseResponse {
+    path?: string;
+    name?: string;
+    parentClass?: string;
+    variables?: Array<{
+        name: string;
+        type: string;
+        defaultValue?: unknown;
+    }>;
+    functions?: Array<{
+        name: string;
+        parameters?: Array<{
+            name: string;
+            type: string;
+        }>;
+        returnType?: string;
+    }>;
+    components?: Array<{
+        name: string;
+        type: string;
+        properties?: Record<string, unknown>;
+    }>;
+}
+export interface AddVariableResponse extends BaseResponse {
+    variableName?: string;
+    variableType?: string;
+}
+export interface CreateNodeResponse extends BaseResponse {
+    nodeId?: string;
+    nodeName?: string;
+}
+export interface ConnectPinsResponse extends BaseResponse {
+    connected?: boolean;
+    fromNode?: string;
+    toNode?: string;
+}
+export interface LoadLevelResponse extends BaseResponse {
+    levelPath?: string;
+    levelName?: string;
+}
+export interface SaveLevelResponse extends BaseResponse {
+    savedPath?: string;
+}
+export interface ListLevelsResponse extends BaseResponse {
+    levels?: Array<{
+        name: string;
+        path: string;
+        isLoaded?: boolean;
+        isVisible?: boolean;
+    }>;
+}
+export interface BuildLightingResponse extends BaseResponse {
+    quality?: string;
+    buildTime?: number;
+}
+export interface PlayInEditorResponse extends BaseResponse {
+    isPlaying?: boolean;
+    isPaused?: boolean;
+}
+export interface SetCameraResponse extends BaseResponse {
+    location?: Vector3;
+    rotation?: Rotator;
+    fov?: number;
+}
+export interface ScreenshotResponse extends BaseResponse {
+    filePath?: string;
+    width?: number;
+    height?: number;
+}
+export interface ViewModeResponse extends BaseResponse {
+    viewMode?: string;
+}
+export interface CreateSequenceResponse extends BaseResponse {
+    sequencePath?: string;
+    sequenceName?: string;
+}
+export interface AddActorToSequenceResponse extends BaseResponse {
+    bindingId?: string;
+    actorName?: string;
+}
+export interface AddKeyframeResponse extends BaseResponse {
+    frameNumber?: number;
+    property?: string;
+    value?: unknown;
+}
+export interface PlaySoundResponse extends BaseResponse {
+    soundPath?: string;
+    audioComponentId?: string;
+}
+export interface CreateSoundCueResponse extends BaseResponse {
+    cuePath?: string;
+    cueName?: string;
+}
+export interface SpawnEffectResponse extends BaseResponse {
+    effectName?: string;
+    effectPath?: string;
+    location?: Vector3;
+}
+export interface CreateNiagaraSystemResponse extends BaseResponse {
+    systemPath?: string;
+    systemName?: string;
+}
+export interface SpawnLightResponse extends BaseResponse {
+    lightName?: string;
+    lightType?: string;
+    location?: Vector3;
+}
+export interface SetupGIResponse extends BaseResponse {
+    method?: string;
+    bounces?: number;
+}
+export interface CreateAnimBlueprintResponse extends BaseResponse {
+    blueprintPath?: string;
+    skeletonPath?: string;
+}
+export interface PlayMontageResponse extends BaseResponse {
+    montagePath?: string;
+    playRate?: number;
+}
+export interface ConsoleCommandResponse extends BaseResponse {
+    command?: string;
+    output?: string;
+}
+export interface ProfileResponse extends BaseResponse {
+    profileType?: string;
+    enabled?: boolean;
+}
+export interface SetCVarResponse extends BaseResponse {
+    cvarName?: string;
+    value?: string;
+}
+export interface InspectObjectResponse extends BaseResponse {
+    objectPath?: string;
+    className?: string;
+    properties?: Record<string, unknown>;
+}
+export interface GetPropertyResponse extends BaseResponse {
+    propertyName?: string;
+    value?: unknown;
+    propertyType?: string;
+}
+export interface SetPropertyResponse extends BaseResponse {
+    propertyName?: string;
+    newValue?: unknown;
+}
+export interface CreateLandscapeResponse extends BaseResponse {
+    landscapeName?: string;
+    componentCount?: {
+        x: number;
+        y: number;
+    };
+}
+export interface AddFoliageResponse extends BaseResponse {
+    foliageType?: string;
+    instanceCount?: number;
+}
+//# sourceMappingURL=responses.d.ts.map

package/dist/types/responses.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=responses.js.map