unreal-engine-mcp-server 0.3.1 → 0.4.3

package/src/tools/build_environment_advanced.ts

@@ -1,4 +1,5 @@
 import { UnrealBridge } from '../unreal-bridge.js';
+import { interpretStandardResult, coerceBoolean, coerceNumber, coerceString, coerceStringArray } from '../utils/result-helpers.js';
 
 /**
  * Advanced Build Environment Tools
@@ -53,17 +54,8 @@ try:
         proc_mesh_comp = proc_actor.get_component_by_class(unreal.ProceduralMeshComponent)
     except:
         # Fallback: Create empty actor and add ProceduralMeshComponent
-        proc_actor = subsys.spawn_actor_from_class(
-            unreal.Actor,
-            location,
-            unreal.Rotator(0, 0, 0)
-        )
-        proc_actor.set_actor_label(f"{name}_ProceduralTerrain")
-        
-        # Add procedural mesh component
-        proc_mesh_comp = unreal.ProceduralMeshComponent()
-        proc_actor.add_instance_component(proc_mesh_comp)
-        proc_mesh_comp.register_component()
+        # If spawning ProceduralMeshActor failed, surface a clear error about the plugin requirement
+        raise Exception("Failed to spawn ProceduralMeshActor. Ensure the 'Procedural Mesh Component' plugin is enabled and available.")
     
     if proc_mesh_comp:
         # Generate terrain mesh
@@ -146,19 +138,85 @@ except Exception as e:
 print(f"RESULT:{json.dumps(result)}")
 `.trim();
 
-    const response = await this.bridge.executePython(pythonScript);
-    const output = this.parseResponse(response);
-    const match = output.match(/RESULT:({.*})/);
-    
-    if (match) {
-      try {
-        return JSON.parse(match[1]);
-      } catch (_e) {
-        return { success: false, error: 'Failed to parse result', details: output };
-      }
-    }
-    
-    return { success: false, error: 'No result found', output };
+        const response = await this.bridge.executePython(pythonScript);
+        const interpreted = interpretStandardResult(response, {
+            successMessage: `Created procedural terrain '${params.name}'`,
+            failureMessage: `Failed to create procedural terrain '${params.name}'`
+        });
+
+        if (!interpreted.success) {
+            const failure: {
+                success: false;
+                error: string;
+                message: string;
+                warnings?: string[];
+                details?: string[];
+                payload?: Record<string, unknown>;
+            } = {
+                success: false,
+                error: interpreted.error ?? interpreted.message,
+                message: interpreted.message
+            };
+
+            if (interpreted.warnings) {
+                failure.warnings = interpreted.warnings;
+            }
+            if (interpreted.details) {
+                failure.details = interpreted.details;
+            }
+            if (interpreted.payload && Object.keys(interpreted.payload).length > 0) {
+                failure.payload = interpreted.payload;
+            }
+
+            return failure;
+        }
+
+        const payload = { ...interpreted.payload } as Record<string, unknown>;
+        const actorName = coerceString(payload.actor_name) ?? coerceString(payload.actorName);
+        const vertices = coerceNumber(payload.vertices);
+        const triangles = coerceNumber(payload.triangles);
+        const subdivisions = coerceNumber(payload.subdivisions);
+        const sizeArray = Array.isArray(payload.size)
+            ? (payload.size as unknown[]).map(entry => {
+                    if (typeof entry === 'number' && Number.isFinite(entry)) {
+                        return entry;
+                    }
+                    if (typeof entry === 'string') {
+                        const parsed = Number(entry);
+                        return Number.isFinite(parsed) ? parsed : undefined;
+                    }
+                    return undefined;
+                }).filter((entry): entry is number => typeof entry === 'number')
+            : undefined;
+
+        payload.success = true;
+        payload.message = interpreted.message;
+
+        if (actorName) {
+            payload.actor_name = actorName;
+            payload.actorName = actorName;
+        }
+        if (typeof vertices === 'number') {
+            payload.vertices = vertices;
+        }
+        if (typeof triangles === 'number') {
+            payload.triangles = triangles;
+        }
+        if (typeof subdivisions === 'number') {
+            payload.subdivisions = subdivisions;
+        }
+        if (sizeArray && sizeArray.length === 2) {
+            payload.size = sizeArray;
+        }
+
+        if (interpreted.warnings) {
+            payload.warnings = interpreted.warnings;
+        }
+        if (interpreted.details) {
+            payload.details = interpreted.details;
+        }
+
+        return payload as any;
   }
 
   /**
@@ -193,6 +251,10 @@ try:
     subsys = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
     asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
     
+    # Validate Procedural Foliage plugin/classes are available
+    if not hasattr(unreal, 'ProceduralFoliageVolume') or not hasattr(unreal, 'ProceduralFoliageSpawner'):
+        raise Exception("Procedural Foliage plugin not available. Please enable the 'Procedural Foliage' plugin and try again.")
+    
     # Create ProceduralFoliageVolume
     volume_actor = subsys.spawn_actor_from_class(
         unreal.ProceduralFoliageVolume,
@@ -200,7 +262,7 @@ try:
         unreal.Rotator(0, 0, 0)
     )
     volume_actor.set_actor_label(f"{name}_ProceduralFoliageVolume")
-    volume_actor.set_actor_scale3d(bounds_size / 100)  # Scale is in meters
+    volume_actor.set_actor_scale3d(unreal.Vector(bounds_size.x/100.0, bounds_size.y/100.0, bounds_size.z/100.0))  # Scale is in meters
     
     # Get the procedural component
     proc_comp = volume_actor.procedural_component
@@ -231,13 +293,14 @@ try:
             )
         
         if spawner:
-            # Configure spawner
-            spawner.random_seed = seed
-            spawner.tile_size = max(bounds_size.x, bounds_size.y)
+            # Configure spawner (use set_editor_property for read-only attributes)
+            spawner.set_editor_property('random_seed', seed)
+            spawner.set_editor_property('tile_size', max(bounds_size.x, bounds_size.y))
             
             # Create foliage types
             foliage_types = []
-            for ft_params in ${JSON.stringify(params.foliageTypes)}:
+            ft_input = json.loads(r'''${JSON.stringify(params.foliageTypes)}''')
+            for ft_params in ft_input:
                 # Load mesh
                 mesh = unreal.EditorAssetLibrary.load_asset(ft_params['meshPath'])
                 if mesh:
@@ -256,26 +319,26 @@ try:
                         ft_asset = unreal.FoliageType_InstancedStaticMesh()
                     
                     if ft_asset:
-                        # Configure foliage type
-                        ft_asset.mesh = mesh
-                        ft_asset.density = ft_params.get('density', 1.0)
-                        ft_asset.random_yaw = ft_params.get('randomYaw', True)
-                        ft_asset.align_to_normal = ft_params.get('alignToNormal', True)
+                        # Configure foliage type (use set_editor_property)
+                        ft_asset.set_editor_property('mesh', mesh)
+                        ft_asset.set_editor_property('density', ft_params.get('density', 1.0))
+                        ft_asset.set_editor_property('random_yaw', ft_params.get('randomYaw', True))
+                        ft_asset.set_editor_property('align_to_normal', ft_params.get('alignToNormal', True))
                         
                         min_scale = ft_params.get('minScale', 0.8)
                         max_scale = ft_params.get('maxScale', 1.2)
-                        ft_asset.scale_x = unreal.FloatInterval(min_scale, max_scale)
-                        ft_asset.scale_y = unreal.FloatInterval(min_scale, max_scale)
-                        ft_asset.scale_z = unreal.FloatInterval(min_scale, max_scale)
+                        ft_asset.set_editor_property('scale_x', unreal.FloatInterval(min_scale, max_scale))
+                        ft_asset.set_editor_property('scale_y', unreal.FloatInterval(min_scale, max_scale))
+                        ft_asset.set_editor_property('scale_z', unreal.FloatInterval(min_scale, max_scale))
                         
-                        ft_obj.foliage_type_object = ft_asset
+                        ft_obj.set_editor_property('foliage_type_object', ft_asset)
                         foliage_types.append(ft_obj)
             
             # Set foliage types on spawner
-            spawner.foliage_types = foliage_types
+            spawner.set_editor_property('foliage_types', foliage_types)
             
             # Assign spawner to component
-            proc_comp.foliage_spawner = spawner
+            proc_comp.set_editor_property('foliage_spawner', spawner)
             
             # Save spawner asset
             unreal.EditorAssetLibrary.save_asset(spawner.get_path_name())
@@ -309,19 +372,80 @@ except Exception as e:
 print(f"RESULT:{json.dumps(result)}")
 `.trim();
 
-    const response = await this.bridge.executePython(pythonScript);
-    const output = this.parseResponse(response);
-    const match = output.match(/RESULT:({.*})/);
-    
-    if (match) {
-      try {
-        return JSON.parse(match[1]);
-      } catch (_e) {
-        return { success: false, error: 'Failed to parse result', details: output };
-      }
-    }
-    
-    return { success: false, error: 'No result found', output };
+        const response = await this.bridge.executePython(pythonScript);
+        const interpreted = interpretStandardResult(response, {
+            successMessage: `Created procedural foliage volume '${params.name}'`,
+            failureMessage: `Failed to create procedural foliage volume '${params.name}'`
+        });
+
+        if (!interpreted.success) {
+            const failure: {
+                success: false;
+                error: string;
+                message: string;
+                warnings?: string[];
+                details?: string[];
+                payload?: Record<string, unknown>;
+            } = {
+                success: false,
+                error: interpreted.error ?? interpreted.message,
+                message: interpreted.message
+            };
+
+            if (interpreted.warnings) {
+                failure.warnings = interpreted.warnings;
+            }
+            if (interpreted.details) {
+                failure.details = interpreted.details;
+            }
+            if (interpreted.payload && Object.keys(interpreted.payload).length > 0) {
+                failure.payload = interpreted.payload;
+            }
+
+            return failure;
+        }
+
+        const payload = { ...interpreted.payload } as Record<string, unknown>;
+        const volumeActor = coerceString(payload.volume_actor) ?? coerceString(payload.volumeActor);
+        const spawnerPath = coerceString(payload.spawner_path) ?? coerceString(payload.spawnerPath);
+        const foliageCount = coerceNumber(payload.foliage_types_count) ?? coerceNumber(payload.foliageTypesCount);
+        const resimulated = coerceBoolean(payload.resimulated);
+        const note = coerceString(payload.note);
+        const messages = coerceStringArray(payload.messages);
+
+        payload.success = true;
+        payload.message = interpreted.message;
+
+        if (volumeActor) {
+            payload.volume_actor = volumeActor;
+            payload.volumeActor = volumeActor;
+        }
+        if (spawnerPath) {
+            payload.spawner_path = spawnerPath;
+            payload.spawnerPath = spawnerPath;
+        }
+        if (typeof foliageCount === 'number') {
+            payload.foliage_types_count = foliageCount;
+            payload.foliageTypesCount = foliageCount;
+        }
+        if (typeof resimulated === 'boolean') {
+            payload.resimulated = resimulated;
+        }
+        if (note) {
+            payload.note = note;
+        }
+        if (messages && messages.length > 0) {
+            payload.messages = messages;
+        }
+
+        if (interpreted.warnings) {
+            payload.warnings = interpreted.warnings;
+        }
+        if (interpreted.details) {
+            payload.details = interpreted.details;
+        }
+
+        return payload as any;
   }
 
   /**
@@ -393,19 +517,59 @@ except Exception as e:
 print(f"RESULT:{json.dumps(result)}")
 `.trim();
 
-    const response = await this.bridge.executePython(pythonScript);
-    const output = this.parseResponse(response);
-    const match = output.match(/RESULT:({.*})/);
-    
-    if (match) {
-      try {
-        return JSON.parse(match[1]);
-    } catch (_e) {
-        return { success: false, error: 'Failed to parse result', details: output };
-      }
-    }
-    
-    return { success: false, error: 'No result found', output };
+        const response = await this.bridge.executePython(pythonScript);
+        const interpreted = interpretStandardResult(response, {
+            successMessage: 'Foliage instances added',
+            failureMessage: 'Failed to add foliage instances'
+        });
+
+        if (!interpreted.success) {
+            const failure: {
+                success: false;
+                error: string;
+                message: string;
+                warnings?: string[];
+                details?: string[];
+                payload?: Record<string, unknown>;
+            } = {
+                success: false,
+                error: interpreted.error ?? interpreted.message,
+                message: interpreted.message
+            };
+
+            if (interpreted.warnings) {
+                failure.warnings = interpreted.warnings;
+            }
+            if (interpreted.details) {
+                failure.details = interpreted.details;
+            }
+            if (interpreted.payload && Object.keys(interpreted.payload).length > 0) {
+                failure.payload = interpreted.payload;
+            }
+
+            return failure;
+        }
+
+        const payload = { ...interpreted.payload } as Record<string, unknown>;
+        const count = coerceNumber(payload.instances_count) ?? coerceNumber(payload.instancesCount);
+        const message = coerceString(payload.message) ?? interpreted.message;
+
+        payload.success = true;
+        payload.message = message;
+
+        if (typeof count === 'number') {
+            payload.instances_count = count;
+            payload.instancesCount = count;
+        }
+
+        if (interpreted.warnings) {
+            payload.warnings = interpreted.warnings;
+        }
+        if (interpreted.details) {
+            payload.details = interpreted.details;
+        }
+
+        return payload as any;
   }
 
   /**
@@ -455,23 +619,31 @@ try:
             # Load mesh
             mesh = unreal.EditorAssetLibrary.load_asset(mesh_path)
             if mesh:
-                # Configure grass type
+                # Configure grass type (use set_editor_property)
                 grass_variety = unreal.GrassVariety()
-                grass_variety.grass_mesh = mesh
-                grass_variety.grass_density = density * 100  # Convert to per square meter
-                grass_variety.use_grid = True
-                grass_variety.placement_jitter = 1.0
-                grass_variety.start_cull_distance = 10000
-                grass_variety.end_cull_distance = 20000
-                grass_variety.min_lod = -1
-                grass_variety.scaling = unreal.GrassScaling.UNIFORM
-                grass_variety.scale_x = unreal.FloatInterval(min_scale, max_scale)
-                grass_variety.scale_y = unreal.FloatInterval(min_scale, max_scale)
-                grass_variety.scale_z = unreal.FloatInterval(min_scale, max_scale)
-                grass_variety.random_rotation = True
-                grass_variety.align_to_surface = True
+                grass_variety.set_editor_property('grass_mesh', mesh)
+                # GrassDensity is PerPlatformFloat in UE5+; set via struct instance
+                pp_density = unreal.PerPlatformFloat()
+                pp_density.set_editor_property('Default', float(density * 100.0))
+                grass_variety.set_editor_property('grass_density', pp_density)
+                grass_variety.set_editor_property('use_grid', True)
+                grass_variety.set_editor_property('placement_jitter', 1.0)
+                # Set cull distances as PerPlatformInt and LOD as int (engine uses mixed types here)
+                pp_start = unreal.PerPlatformInt()
+                pp_start.set_editor_property('Default', 10000)
+                grass_variety.set_editor_property('start_cull_distance', pp_start)
+                pp_end = unreal.PerPlatformInt()
+                pp_end.set_editor_property('Default', 20000)
+                grass_variety.set_editor_property('end_cull_distance', pp_end)
+                grass_variety.set_editor_property('min_lod', -1)
+                grass_variety.set_editor_property('scaling', unreal.GrassScaling.UNIFORM)
+                grass_variety.set_editor_property('scale_x', unreal.FloatInterval(min_scale, max_scale))
+                grass_variety.set_editor_property('scale_y', unreal.FloatInterval(min_scale, max_scale))
+                grass_variety.set_editor_property('scale_z', unreal.FloatInterval(min_scale, max_scale))
+                grass_variety.set_editor_property('random_rotation', True)
+                grass_variety.set_editor_property('align_to_surface', True)
                 
-                grass_type.grass_varieties = [grass_variety]
+                grass_type.set_editor_property('grass_varieties', [grass_variety])
                 
                 # Save asset
                 unreal.EditorAssetLibrary.save_asset(grass_type.get_path_name())
@@ -496,31 +668,65 @@ except Exception as e:
 print(f"RESULT:{json.dumps(result)}")
 `.trim();
 
-    const response = await this.bridge.executePython(pythonScript);
-    const output = this.parseResponse(response);
-    const match = output.match(/RESULT:({.*})/);
-    
-    if (match) {
-      try {
-        return JSON.parse(match[1]);
-    } catch (_e) {
-        return { success: false, error: 'Failed to parse result', details: output };
-      }
-    }
-    
-    return { success: false, error: 'No result found', output };
-  }
+        const response = await this.bridge.executePython(pythonScript);
+        const interpreted = interpretStandardResult(response, {
+            successMessage: `Created landscape grass type '${params.name}'`,
+            failureMessage: `Failed to create landscape grass type '${params.name}'`
+        });
+
+        if (!interpreted.success) {
+            const failure: {
+                success: false;
+                error: string;
+                message: string;
+                warnings?: string[];
+                details?: string[];
+                payload?: Record<string, unknown>;
+            } = {
+                success: false,
+                error: interpreted.error ?? interpreted.message,
+                message: interpreted.message
+            };
+
+            if (interpreted.warnings) {
+                failure.warnings = interpreted.warnings;
+            }
+            if (interpreted.details) {
+                failure.details = interpreted.details;
+            }
+            if (interpreted.payload && Object.keys(interpreted.payload).length > 0) {
+                failure.payload = interpreted.payload;
+            }
+
+            return failure;
+        }
+
+        const payload = { ...interpreted.payload } as Record<string, unknown>;
+        const assetPath = coerceString(payload.asset_path) ?? coerceString(payload.assetPath);
+        const note = coerceString(payload.note);
+        const messages = coerceStringArray(payload.messages);
+
+        payload.success = true;
+        payload.message = interpreted.message;
+
+        if (assetPath) {
+            payload.asset_path = assetPath;
+            payload.assetPath = assetPath;
+        }
+        if (note) {
+            payload.note = note;
+        }
+        if (messages && messages.length > 0) {
+            payload.messages = messages;
+        }
+
+        if (interpreted.warnings) {
+            payload.warnings = interpreted.warnings;
+        }
+        if (interpreted.details) {
+            payload.details = interpreted.details;
+        }
 
-  private parseResponse(response: any): string {
-    if (response && typeof response === 'object') {
-      if (response.LogOutput && Array.isArray(response.LogOutput)) {
-        return response.LogOutput.map((log: any) => log.Output || '').join('');
-      } else if (response.CommandResult) {
-        return response.CommandResult;
-      } else if (response.ReturnValue) {
-        return JSON.stringify(response);
-      }
-    }
-    return typeof response === 'string' ? response : JSON.stringify(response);
+        return payload as any;
   }
 }