unreal-engine-mcp-server 0.4.7 → 0.5.1

package/dist/tools/property-dictionary.d.ts

@@ -0,0 +1,13 @@
+export interface PropertyDictionaryEntry {
+    description: string;
+    typeHint?: string;
+    commonValues?: Array<string | number | boolean>;
+    recommendedActions?: string[];
+    category?: string;
+}
+export declare const PROPERTY_DICTIONARY: Record<string, PropertyDictionaryEntry>;
+export declare function normalizeDictionaryKey(name: string | undefined): string;
+export declare function lookupPropertyMetadata(property: {
+    name?: string;
+} | string): PropertyDictionaryEntry;
+//# sourceMappingURL=property-dictionary.d.ts.map

package/dist/tools/property-dictionary.js

@@ -0,0 +1,82 @@
+export const PROPERTY_DICTIONARY = {
+    intensity: {
+        description: 'Controls the brightness emitted by the light component.',
+        typeHint: 'float (lumens for point/spot, lux for directional)',
+        commonValues: [1000, 5000, 10000],
+        recommendedActions: ['Adjust to match the desired exposure', 'Animate via sequencer for flicker effects'],
+        category: 'Lighting'
+    },
+    lightcolor: {
+        description: 'Tint applied to emitted light. Uses linear RGBA (0-255) values.',
+        typeHint: 'FColor',
+        recommendedActions: ['Set to emphasize mood', 'Match art direction color palette'],
+        category: 'Lighting'
+    },
+    mobility: {
+        description: 'Whether the component is Static, Stationary, or Movable.',
+        typeHint: 'enum (EComponentMobility)',
+        commonValues: ['Static', 'Stationary', 'Movable'],
+        recommendedActions: ['Switch to Movable for runtime transforms', 'Use Static for baked lighting'],
+        category: 'Rendering'
+    },
+    relativelocation: {
+        description: 'Local-space translation of the component relative to its parent.',
+        typeHint: 'FVector',
+        recommendedActions: ['Adjust to reposition relative to parent', 'Consider zeroing to reset offsets'],
+        category: 'Transform'
+    },
+    relativerotation: {
+        description: 'Local-space rotation applied after parent transforms.',
+        typeHint: 'FRotator',
+        recommendedActions: ['Tweak to orient the component correctly'],
+        category: 'Transform'
+    },
+    relativescale3d: {
+        description: 'Local-space non-uniform scale relative to parent.',
+        typeHint: 'FVector',
+        commonValues: [1],
+        recommendedActions: ['Use uniform scaling to avoid skewing', 'Reset to (1,1,1) when debugging'],
+        category: 'Transform'
+    },
+    tags: {
+        description: 'Gameplay or editor tags applied to the actor for lookup operations.',
+        typeHint: 'string[]',
+        recommendedActions: ['Add descriptive tags to enable find_by_tag', 'Standardise tag prefixes for systems'],
+        category: 'Metadata'
+    },
+    collisionenabled: {
+        description: 'Specifies whether the primitive participates in collision queries.',
+        typeHint: 'enum (ECollisionEnabled)',
+        commonValues: ['NoCollision', 'QueryOnly', 'PhysicsOnly', 'QueryAndPhysics'],
+        recommendedActions: ['Disable when using purely visual meshes', 'Enable QueryAndPhysics for interactive props'],
+        category: 'Physics'
+    },
+    simulatephysics: {
+        description: 'Enables physics simulation for the component allowing forces and gravity.',
+        typeHint: 'bool',
+        recommendedActions: ['Enable for ragdolls or dynamic rigid bodies', 'Disable for static set dressing'],
+        category: 'Physics'
+    },
+    materials: {
+        description: 'Array of material slots applied to the mesh component.',
+        typeHint: 'UMaterialInterface[]',
+        recommendedActions: ['Replace slot materials to change surface look', 'Verify slot count matches mesh sections'],
+        category: 'Rendering'
+    },
+    skeletalmeshsocketnames: {
+        description: 'Sockets exposed by the skeletal mesh for attachments.',
+        typeHint: 'string[]',
+        recommendedActions: ['Attach weapons or FX to named sockets', 'Use to verify sockets exist before attaching'],
+        category: 'Animation'
+    }
+};
+export function normalizeDictionaryKey(name) {
+    if (!name)
+        return '';
+    return name.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+}
+export function lookupPropertyMetadata(property) {
+    const key = typeof property === 'string' ? normalizeDictionaryKey(property) : normalizeDictionaryKey(property.name);
+    return PROPERTY_DICTIONARY[key];
+}
+//# sourceMappingURL=property-dictionary.js.map

package/dist/tools/sequence.d.ts

@@ -1,4 +1,5 @@
-import { UnrealBridge } from '../unreal-bridge.js';
+import { BaseTool } from './base-tool.js';
+import { ISequenceTools, StandardActionResponse } from '../types/tool-interfaces.js';
 export interface LevelSequence {
     path: string;
     name: string;
@@ -17,97 +18,121 @@ export interface SequenceTrack {
     type: string;
     sections?: any[];
 }
-export declare class SequenceTools {
-    private bridge;
-    private log;
+export declare class SequenceTools extends BaseTool implements ISequenceTools {
     private sequenceCache;
-    private retryAttempts;
-    private retryDelay;
-    constructor(bridge: UnrealBridge);
-    private ensureSequencerPrerequisites;
-    /**
-     * Execute with retry logic for transient failures
-     */
-    private executeWithRetry;
-    /**
-     * Parse Python execution result with better error handling
-     */
-    private parsePythonResult;
+    private activeSequencePath?;
+    private resolveSequencePath;
+    private sendAction;
+    private isUnknownActionResponse;
     create(params: {
         name: string;
         path?: string;
-    }): Promise<any>;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
     open(params: {
         path: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     addCamera(params: {
         spawnable?: boolean;
-    }): Promise<any>;
+        path?: string;
+    }): Promise<StandardActionResponse>;
     addActor(params: {
         actorName: string;
         createBinding?: boolean;
-    }): Promise<any>;
-    /**
-     * Play the current level sequence
-     */
+        path?: string;
+    }): Promise<StandardActionResponse>;
     play(params?: {
+        path?: string;
         startTime?: number;
         loopMode?: 'once' | 'loop' | 'pingpong';
-    }): Promise<any>;
-    /**
-     * Pause the current level sequence
-     */
-    pause(): Promise<any>;
-    /**
-     * Stop/close the current level sequence
-     */
-    stop(): Promise<any>;
-    /**
-     * Set sequence properties including frame rate and length
-     */
+    }): Promise<StandardActionResponse>;
+    pause(params?: {
+        path?: string;
+    }): Promise<StandardActionResponse>;
+    stop(params?: {
+        path?: string;
+    }): Promise<StandardActionResponse>;
     setSequenceProperties(params: {
         path?: string;
         frameRate?: number;
         lengthInFrames?: number;
         playbackStart?: number;
         playbackEnd?: number;
-    }): Promise<any>;
-    /**
-     * Get sequence properties
-     */
+    }): Promise<StandardActionResponse>;
+    setDisplayRate(params: {
+        path?: string;
+        frameRate: string | number;
+    }): Promise<StandardActionResponse>;
     getSequenceProperties(params: {
         path?: string;
-    }): Promise<any>;
-    /**
-     * Set playback speed/rate
-     */
+    }): Promise<StandardActionResponse>;
     setPlaybackSpeed(params: {
         speed: number;
-    }): Promise<any>;
-    /**
-     * Get all bindings in the current sequence
-     */
+        path?: string;
+    }): Promise<StandardActionResponse>;
     getBindings(params?: {
         path?: string;
-    }): Promise<any>;
-    /**
-     * Add multiple actors to sequence at once
-     */
+    }): Promise<StandardActionResponse>;
     addActors(params: {
         actorNames: string[];
-    }): Promise<any>;
-    /**
-     * Remove actors from binding
-     */
+        path?: string;
+    }): Promise<StandardActionResponse>;
     removeActors(params: {
         actorNames: string[];
-    }): Promise<any>;
-    /**
-     * Create a spawnable from an actor class
-     */
+        path?: string;
+    }): Promise<StandardActionResponse>;
     addSpawnableFromClass(params: {
         className: string;
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
+    list(params?: {
+        path?: string;
+    }): Promise<StandardActionResponse>;
+    duplicate(params: {
+        path: string;
+        destinationPath: string;
+    }): Promise<StandardActionResponse>;
+    rename(params: {
+        path: string;
+        newName: string;
+    }): Promise<StandardActionResponse>;
+    deleteSequence(params: {
+        path: string;
+    }): Promise<StandardActionResponse>;
+    getMetadata(params: {
+        path?: string;
+    }): Promise<StandardActionResponse>;
+    addKeyframe(params: {
+        path?: string;
+        bindingId?: string;
+        actorName?: string;
+        property: 'Transform';
+        frame: number;
+        value: {
+            location?: {
+                x: number;
+                y: number;
+                z: number;
+            };
+            rotation?: {
+                roll: number;
+                pitch: number;
+                yaw: number;
+            };
+            scale?: {
+                x: number;
+                y: number;
+                z: number;
+            };
+        };
+    }): Promise<StandardActionResponse>;
+    listTracks(params: {
+        path: string;
+    }): Promise<StandardActionResponse>;
+    setWorkRange(params: {
+        path?: string;
+        start: number;
+        end: number;
+    }): Promise<StandardActionResponse>;
 }
 //# sourceMappingURL=sequence.d.ts.map