unreal-engine-mcp-server 0.4.7 → 0.5.0

package/dist/tools/lighting.js

@@ -1,52 +1,67 @@
-import { parseStandardResult } from '../utils/python-output.js';
-import { escapePythonString } from '../utils/python.js';
+import { ensureVector3 } from '../utils/validation.js';
 export class LightingTools {
     bridge;
-    constructor(bridge) {
+    automationBridge;
+    constructor(bridge, automationBridge) {
         this.bridge = bridge;
+        this.automationBridge = automationBridge;
     }
-    ensurePythonSpawnSucceeded(label, result) {
-        let logs = '';
-        if (Array.isArray(result?.LogOutput)) {
-            logs = result.LogOutput.map((l) => String(l.Output || '')).join('');
-        }
-        else if (typeof result === 'string') {
-            logs = result;
-        }
-        // If Python reported a traceback or explicit failure, propagate as error
-        if (/Traceback|Error:|Failed to spawn/i.test(logs)) {
-            throw new Error(`Unreal reported error spawning '${label}': ${logs}`);
-        }
-        // If script executed (ReturnValue true) and no error patterns, treat as success
-        const executed = result?.ReturnValue === true || result?.ReturnValue === 'true';
-        if (executed)
-            return;
-        // Fallback: if no ReturnValue but success-like logs exist, accept
-        if (/spawned/i.test(logs))
-            return;
-        // Otherwise, uncertain
-        throw new Error(`Uncertain spawn result for '${label}'. Engine logs:\n${logs}`);
-    }
-    normalizeName(value, fallback) {
+    setAutomationBridge(automationBridge) { this.automationBridge = automationBridge; }
+    normalizeName(value, defaultName) {
         if (typeof value === 'string') {
             const trimmed = value.trim();
             if (trimmed.length > 0) {
                 return trimmed;
             }
         }
-        if (typeof fallback === 'string') {
-            const trimmedFallback = fallback.trim();
-            if (trimmedFallback.length > 0) {
-                return trimmedFallback;
+        if (typeof defaultName === 'string') {
+            const trimmedDefault = defaultName.trim();
+            if (trimmedDefault.length > 0) {
+                return trimmedDefault;
+            }
+        }
+        return `Light_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
+    }
+    async spawnLightViaAutomation(lightClass, params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Cannot spawn lights without plugin support.');
+        }
+        try {
+            const payload = {
+                lightClass,
+                name: params.name,
+            };
+            if (params.location) {
+                payload.location = { x: params.location[0], y: params.location[1], z: params.location[2] };
+            }
+            if (params.rotation) {
+                if (Array.isArray(params.rotation)) {
+                    payload.rotation = { pitch: params.rotation[0], yaw: params.rotation[1], roll: params.rotation[2] };
+                }
+                else {
+                    payload.rotation = params.rotation;
+                }
+            }
+            if (params.properties) {
+                payload.properties = params.properties;
+            }
+            const response = await this.automationBridge.sendAutomationRequest('spawn_light', payload, {
+                timeoutMs: 60000
+            });
+            if (response.success === false) {
+                throw new Error(response.error || response.message || 'Failed to spawn light');
             }
+            return response;
+        }
+        catch (error) {
+            throw new Error(`Failed to spawn ${lightClass}: ${error instanceof Error ? error.message : String(error)}`);
         }
-        throw new Error('Invalid name: must be a non-empty string');
     }
-    // Create directional light
     async createDirectionalLight(params) {
         const name = this.normalizeName(params.name);
-        const escapedName = escapePythonString(name);
-        // Validate numeric parameters
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge required for light spawning');
+        }
         if (params.intensity !== undefined) {
             if (typeof params.intensity !== 'number' || !isFinite(params.intensity)) {
                 throw new Error(`Invalid intensity value: ${params.intensity}`);
@@ -60,7 +75,6 @@ export class LightingTools {
                 throw new Error(`Invalid temperature value: ${params.temperature}`);
             }
         }
-        // Validate arrays
         if (params.color !== undefined) {
             if (!Array.isArray(params.color) || params.color.length !== 3) {
                 throw new Error('Invalid color: must be an array [r,g,b]');
@@ -72,88 +86,61 @@ export class LightingTools {
             }
         }
         if (params.rotation !== undefined) {
-            if (!Array.isArray(params.rotation) || params.rotation.length !== 3) {
-                throw new Error('Invalid rotation: must be an array [pitch,yaw,roll]');
-            }
-            for (const r of params.rotation) {
-                if (typeof r !== 'number' || !isFinite(r)) {
-                    throw new Error('Invalid rotation component: must be finite numbers');
+            if (Array.isArray(params.rotation)) {
+                if (params.rotation.length !== 3) {
+                    throw new Error('Invalid rotation: must be an array [pitch,yaw,roll]');
+                }
+                for (const r of params.rotation) {
+                    if (typeof r !== 'number' || !isFinite(r)) {
+                        throw new Error('Invalid rotation component: must be finite numbers');
+                    }
                 }
             }
         }
         const rot = params.rotation || [0, 0, 0];
-        // Build property setters
-        const propSetters = [];
+        const properties = params.properties || {};
         if (params.intensity !== undefined) {
-            propSetters.push(`        light_component.set_intensity(${params.intensity})`);
+            properties.intensity = params.intensity;
         }
         if (params.color) {
-            propSetters.push(`        light_component.set_light_color(unreal.LinearColor(${params.color[0]}, ${params.color[1]}, ${params.color[2]}, 1.0))`);
+            properties.color = { r: params.color[0], g: params.color[1], b: params.color[2], a: 1.0 };
         }
         if (params.castShadows !== undefined) {
-            propSetters.push(`        light_component.set_cast_shadows(${params.castShadows ? 'True' : 'False'})`);
+            properties.castShadows = params.castShadows;
         }
         if (params.temperature !== undefined) {
-            propSetters.push(`        light_component.set_temperature(${params.temperature})`);
-        }
-        const propertiesCode = propSetters.length > 0
-            ? propSetters.join('\n')
-            : '        pass  # No additional properties';
-        const pythonScript = `
-import unreal
-
-# Get editor subsystem
-editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-
-# Spawn the directional light
-directional_light_class = unreal.DirectionalLight
-spawn_location = unreal.Vector(0, 0, 500)
-spawn_rotation = unreal.Rotator(${rot[0]}, ${rot[1]}, ${rot[2]})
-
-# Spawn the actor
-spawned_light = editor_actor_subsystem.spawn_actor_from_class(
-  directional_light_class, 
-  spawn_location, 
-  spawn_rotation
-)
-
-if spawned_light:
-  # Set the label/name
-  spawned_light.set_actor_label("${escapedName}")
-    
-  # Get the light component
-  light_component = spawned_light.get_component_by_class(unreal.DirectionalLightComponent)
-    
-  if light_component:
-${propertiesCode}
-    
-  print("Directional light '${escapedName}' spawned")
-else:
-  print("Failed to spawn directional light '${escapedName}'")
-`;
-        // Execute the Python script via bridge (UE 5.6-compatible)
-        const result = await this.bridge.executePython(pythonScript);
-        this.ensurePythonSpawnSucceeded(name, result);
-        return { success: true, message: `Directional light '${name}' spawned` };
+            properties.temperature = params.temperature;
+        }
+        if (params.useAsAtmosphereSunLight !== undefined) {
+            properties.useAsAtmosphereSunLight = params.useAsAtmosphereSunLight;
+        }
+        try {
+            await this.spawnLightViaAutomation('DirectionalLight', {
+                name,
+                location: [0, 0, 500],
+                rotation: rot,
+                properties
+            });
+            return { success: true, message: `Directional light '${name}' spawned` };
+        }
+        catch (e) {
+            return { success: false, error: `Failed to create directional light: ${e?.message ?? e}` };
+        }
     }
-    // Create point light
     async createPointLight(params) {
         const name = this.normalizeName(params.name);
-        const escapedName = escapePythonString(name);
-        // Validate location array
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge required for light spawning');
+        }
         if (params.location !== undefined) {
-            if (!Array.isArray(params.location) || params.location.length !== 3) {
-                throw new Error('Invalid location: must be an array [x,y,z]');
+            try {
+                params.location = ensureVector3(params.location, 'location');
             }
-            for (const l of params.location) {
-                if (typeof l !== 'number' || !isFinite(l)) {
-                    throw new Error('Invalid location component: must be finite numbers');
-                }
+            catch (e) {
+                throw new Error(`Invalid location: ${e instanceof Error ? e.message : String(e)}`);
             }
         }
-        // Default location if not provided
         const location = params.location || [0, 0, 0];
-        // Validate numeric parameters
         if (params.intensity !== undefined) {
             if (typeof params.intensity !== 'number' || !isFinite(params.intensity)) {
                 throw new Error(`Invalid intensity value: ${params.intensity}`);
@@ -175,7 +162,6 @@ else:
                 throw new Error(`Invalid falloffExponent value: ${params.falloffExponent}`);
             }
         }
-        // Validate color array
         if (params.color !== undefined) {
             if (!Array.isArray(params.color) || params.color.length !== 3) {
                 throw new Error('Invalid color: must be an array [r,g,b]');
@@ -186,68 +172,40 @@ else:
                 }
             }
         }
-        // Build property setters
-        const propSetters = [];
+        const properties = {};
         if (params.intensity !== undefined) {
-            propSetters.push(`        light_component.set_intensity(${params.intensity})`);
+            properties.intensity = params.intensity;
         }
         if (params.radius !== undefined) {
-            propSetters.push(`        light_component.set_attenuation_radius(${params.radius})`);
+            properties.attenuationRadius = params.radius;
         }
         if (params.color) {
-            propSetters.push(`        light_component.set_light_color(unreal.LinearColor(${params.color[0]}, ${params.color[1]}, ${params.color[2]}, 1.0))`);
+            properties.color = { r: params.color[0], g: params.color[1], b: params.color[2], a: 1.0 };
         }
         if (params.castShadows !== undefined) {
-            propSetters.push(`        light_component.set_cast_shadows(${params.castShadows ? 'True' : 'False'})`);
+            properties.castShadows = params.castShadows;
         }
         if (params.falloffExponent !== undefined) {
-            propSetters.push(`        light_component.set_light_falloff_exponent(${params.falloffExponent})`);
-        }
-        const propertiesCode = propSetters.length > 0
-            ? propSetters.join('\n')
-            : '        pass  # No additional properties';
-        const pythonScript = `
-import unreal
-
-# Get editor subsystem
-editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-
-# Spawn the point light
-point_light_class = unreal.PointLight
-spawn_location = unreal.Vector(${location[0]}, ${location[1]}, ${location[2]})
-spawn_rotation = unreal.Rotator(0, 0, 0)
-
-# Spawn the actor
-spawned_light = editor_actor_subsystem.spawn_actor_from_class(
-  point_light_class, 
-  spawn_location, 
-  spawn_rotation
-)
-
-if spawned_light:
-  # Set the label/name
-  spawned_light.set_actor_label("${escapedName}")
-    
-  # Get the light component
-  light_component = spawned_light.get_component_by_class(unreal.PointLightComponent)
-    
-  if light_component:
-${propertiesCode}
-    
-  print(f"Point light '${escapedName}' spawned at {spawn_location.x}, {spawn_location.y}, {spawn_location.z}")
-else:
-  print("Failed to spawn point light '${escapedName}'")
-`;
-        // Execute the Python script via bridge (UE 5.6-compatible)
-        const result = await this.bridge.executePython(pythonScript);
-        this.ensurePythonSpawnSucceeded(name, result);
-        return { success: true, message: `Point light '${name}' spawned at ${location.join(', ')}` };
+            properties.lightFalloffExponent = params.falloffExponent;
+        }
+        try {
+            await this.spawnLightViaAutomation('PointLight', {
+                name,
+                location,
+                rotation: params.rotation,
+                properties
+            });
+            return { success: true, message: `Point light '${name}' spawned at ${location.join(', ')}` };
+        }
+        catch (e) {
+            return { success: false, error: `Failed to create point light: ${e?.message ?? e}` };
+        }
     }
-    // Create spot light
     async createSpotLight(params) {
         const name = this.normalizeName(params.name);
-        const escapedName = escapePythonString(name);
-        // Validate required location and rotation arrays
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge required for light spawning');
+        }
         if (!params.location || !Array.isArray(params.location) || params.location.length !== 3) {
             throw new Error('Invalid location: must be an array [x,y,z]');
         }
@@ -256,15 +214,19 @@ else:
                 throw new Error('Invalid location component: must be finite numbers');
             }
         }
-        if (!params.rotation || !Array.isArray(params.rotation) || params.rotation.length !== 3) {
-            throw new Error('Invalid rotation: must be an array [pitch,yaw,roll]');
+        if (!params.rotation) {
+            throw new Error('Rotation is required');
         }
-        for (const r of params.rotation) {
-            if (typeof r !== 'number' || !isFinite(r)) {
-                throw new Error('Invalid rotation component: must be finite numbers');
+        if (Array.isArray(params.rotation)) {
+            if (params.rotation.length !== 3) {
+                throw new Error('Invalid rotation: must be an array [pitch,yaw,roll]');
+            }
+            for (const r of params.rotation) {
+                if (typeof r !== 'number' || !isFinite(r)) {
+                    throw new Error('Invalid rotation component: must be finite numbers');
+                }
             }
         }
-        // Validate optional numeric parameters
         if (params.intensity !== undefined) {
             if (typeof params.intensity !== 'number' || !isFinite(params.intensity)) {
                 throw new Error(`Invalid intensity value: ${params.intensity}`);
@@ -297,7 +259,6 @@ else:
                 throw new Error('Invalid radius: must be non-negative');
             }
         }
-        // Validate color array
         if (params.color !== undefined) {
             if (!Array.isArray(params.color) || params.color.length !== 3) {
                 throw new Error('Invalid color: must be an array [r,g,b]');
@@ -308,71 +269,43 @@ else:
                 }
             }
         }
-        // Build property setters
-        const propSetters = [];
+        const properties = {};
         if (params.intensity !== undefined) {
-            propSetters.push(`        light_component.set_intensity(${params.intensity})`);
+            properties.intensity = params.intensity;
         }
         if (params.innerCone !== undefined) {
-            propSetters.push(`        light_component.set_inner_cone_angle(${params.innerCone})`);
+            properties.innerConeAngle = params.innerCone;
         }
         if (params.outerCone !== undefined) {
-            propSetters.push(`        light_component.set_outer_cone_angle(${params.outerCone})`);
+            properties.outerConeAngle = params.outerCone;
         }
         if (params.radius !== undefined) {
-            propSetters.push(`        light_component.set_attenuation_radius(${params.radius})`);
+            properties.attenuationRadius = params.radius;
         }
         if (params.color) {
-            propSetters.push(`        light_component.set_light_color(unreal.LinearColor(${params.color[0]}, ${params.color[1]}, ${params.color[2]}, 1.0))`);
+            properties.color = { r: params.color[0], g: params.color[1], b: params.color[2], a: 1.0 };
         }
         if (params.castShadows !== undefined) {
-            propSetters.push(`        light_component.set_cast_shadows(${params.castShadows ? 'True' : 'False'})`);
-        }
-        const propertiesCode = propSetters.length > 0
-            ? propSetters.join('\n')
-            : '        pass  # No additional properties';
-        const pythonScript = `
-import unreal
-
-# Get editor subsystem
-editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-
-# Spawn the spot light
-spot_light_class = unreal.SpotLight
-spawn_location = unreal.Vector(${params.location[0]}, ${params.location[1]}, ${params.location[2]})
-spawn_rotation = unreal.Rotator(${params.rotation[0]}, ${params.rotation[1]}, ${params.rotation[2]})
-
-# Spawn the actor
-spawned_light = editor_actor_subsystem.spawn_actor_from_class(
-    spot_light_class, 
-    spawn_location, 
-    spawn_rotation
-)
-
-if spawned_light:
-    # Set the label/name
-    spawned_light.set_actor_label("${escapedName}")
-    
-    # Get the light component
-    light_component = spawned_light.get_component_by_class(unreal.SpotLightComponent)
-    
-    if light_component:
-${propertiesCode}
-    
-    print(f"Spot light '${escapedName}' spawned at {spawn_location.x}, {spawn_location.y}, {spawn_location.z}")
-else:
-    print("Failed to spawn spot light '${escapedName}'")
-`;
-        // Execute the Python script via bridge (UE 5.6-compatible)
-        const result = await this.bridge.executePython(pythonScript);
-        this.ensurePythonSpawnSucceeded(name, result);
-        return { success: true, message: `Spot light '${name}' spawned at ${params.location.join(', ')}` };
+            properties.castShadows = params.castShadows;
+        }
+        try {
+            await this.spawnLightViaAutomation('SpotLight', {
+                name,
+                location: params.location,
+                rotation: params.rotation,
+                properties
+            });
+            return { success: true, message: `Spot light '${name}' spawned at ${params.location.join(', ')}` };
+        }
+        catch (e) {
+            return { success: false, error: `Failed to create spot light: ${e?.message ?? e}` };
+        }
     }
-    // Create rect light
     async createRectLight(params) {
         const name = this.normalizeName(params.name);
-        const escapedName = escapePythonString(name);
-        // Validate required location and rotation arrays
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge required for light spawning');
+        }
         if (!params.location || !Array.isArray(params.location) || params.location.length !== 3) {
             throw new Error('Invalid location: must be an array [x,y,z]');
         }
@@ -381,15 +314,19 @@ else:
                 throw new Error('Invalid location component: must be finite numbers');
             }
         }
-        if (!params.rotation || !Array.isArray(params.rotation) || params.rotation.length !== 3) {
-            throw new Error('Invalid rotation: must be an array [pitch,yaw,roll]');
+        if (!params.rotation) {
+            throw new Error('Rotation is required');
         }
-        for (const r of params.rotation) {
-            if (typeof r !== 'number' || !isFinite(r)) {
-                throw new Error('Invalid rotation component: must be finite numbers');
+        if (Array.isArray(params.rotation)) {
+            if (params.rotation.length !== 3) {
+                throw new Error('Invalid rotation: must be an array [pitch,yaw,roll]');
+            }
+            for (const r of params.rotation) {
+                if (typeof r !== 'number' || !isFinite(r)) {
+                    throw new Error('Invalid rotation component: must be finite numbers');
+                }
             }
         }
-        // Validate optional numeric parameters
         if (params.width !== undefined) {
             if (typeof params.width !== 'number' || !isFinite(params.width)) {
                 throw new Error(`Invalid width value: ${params.width}`);
@@ -414,7 +351,6 @@ else:
                 throw new Error('Invalid intensity: must be non-negative');
             }
         }
-        // Validate color array
         if (params.color !== undefined) {
             if (!Array.isArray(params.color) || params.color.length !== 3) {
                 throw new Error('Invalid color: must be an array [r,g,b]');
@@ -425,268 +361,166 @@ else:
                 }
             }
         }
-        // Build property setters
-        const propSetters = [];
+        const properties = {};
         if (params.intensity !== undefined) {
-            propSetters.push(`        light_component.set_intensity(${params.intensity})`);
+            properties.intensity = params.intensity;
         }
         if (params.color) {
-            propSetters.push(`        light_component.set_light_color(unreal.LinearColor(${params.color[0]}, ${params.color[1]}, ${params.color[2]}, 1.0))`);
+            properties.color = { r: params.color[0], g: params.color[1], b: params.color[2], a: 1.0 };
         }
         if (params.width !== undefined) {
-            propSetters.push(`        light_component.set_source_width(${params.width})`);
+            properties.sourceWidth = params.width;
         }
         if (params.height !== undefined) {
-            propSetters.push(`        light_component.set_source_height(${params.height})`);
-        }
-        const propertiesCode = propSetters.length > 0
-            ? propSetters.join('\n')
-            : '        pass  # No additional properties';
-        const pythonScript = `
-import unreal
-
-# Get editor subsystem
-editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-
-# Spawn the rect light
-rect_light_class = unreal.RectLight
-spawn_location = unreal.Vector(${params.location[0]}, ${params.location[1]}, ${params.location[2]})
-spawn_rotation = unreal.Rotator(${params.rotation[0]}, ${params.rotation[1]}, ${params.rotation[2]})
-
-# Spawn the actor
-spawned_light = editor_actor_subsystem.spawn_actor_from_class(
-    rect_light_class, 
-    spawn_location, 
-    spawn_rotation
-)
-
-if spawned_light:
-  # Set the label/name
-  spawned_light.set_actor_label("${escapedName}")
-    
-  # Get the light component
-  light_component = spawned_light.get_component_by_class(unreal.RectLightComponent)
-    
-  if light_component:
-${propertiesCode}
-    
-  print(f"Rect light '${escapedName}' spawned at {spawn_location.x}, {spawn_location.y}, {spawn_location.z}")
-else:
-  print("Failed to spawn rect light '${escapedName}'")
-`;
-        // Execute the Python script via bridge (UE 5.6-compatible)
-        const result = await this.bridge.executePython(pythonScript);
-        this.ensurePythonSpawnSucceeded(name, result);
-        return { success: true, message: `Rect light '${name}' spawned at ${params.location.join(', ')}` };
+            properties.sourceHeight = params.height;
+        }
+        try {
+            await this.spawnLightViaAutomation('RectLight', {
+                name,
+                location: params.location,
+                rotation: params.rotation,
+                properties
+            });
+            return { success: true, message: `Rect light '${name}' spawned at ${params.location.join(', ')}` };
+        }
+        catch (e) {
+            return { success: false, error: `Failed to create rect light: ${e?.message ?? e}` };
+        }
+    }
+    async createDynamicLight(params) {
+        try {
+            const name = typeof params.name === 'string' && params.name.trim().length > 0 ? params.name.trim() : `DynamicLight_${Date.now() % 10000}`;
+            const lightTypeRaw = typeof params.lightType === 'string' && params.lightType.trim().length > 0 ? params.lightType.trim() : 'Point';
+            const location = Array.isArray(params.location) ? { x: params.location[0], y: params.location[1], z: params.location[2] } : (params.location || { x: 0, y: 0, z: 100 });
+            const toArray3 = (loc) => Array.isArray(loc)
+                ? [Number(loc[0]) || 0, Number(loc[1]) || 0, Number(loc[2]) || 0]
+                : [Number(loc?.x) || 0, Number(loc?.y) || 0, Number(loc?.z) || 0];
+            const locArr = toArray3(location);
+            const typeNorm = (lightTypeRaw || 'Point').toLowerCase();
+            switch (typeNorm) {
+                case 'directional':
+                case 'directionallight':
+                    return await this.createDirectionalLight({ name, intensity: params.intensity, color: Array.isArray(params.color) ? [params.color[0], params.color[1], params.color[2]] : (params.color ? [params.color.r, params.color.g, params.color.b] : undefined), rotation: params.rotation });
+                case 'spot':
+                case 'spotlight':
+                    return await this.createSpotLight({ name, location: locArr, rotation: params.rotation, intensity: params.intensity, innerCone: undefined, outerCone: undefined, color: Array.isArray(params.color) ? params.color : (params.color ? [params.color.r, params.color.g, params.color.b] : undefined) });
+                case 'rect':
+                case 'rectlight':
+                    return await this.createRectLight({ name, location: locArr, rotation: params.rotation, width: undefined, height: undefined, intensity: params.intensity, color: Array.isArray(params.color) ? params.color : (params.color ? [params.color.r, params.color.g, params.color.b] : undefined) });
+                case 'point':
+                default:
+                    return await this.createPointLight({ name, location: locArr, intensity: params.intensity, radius: undefined, color: Array.isArray(params.color) ? params.color : (params.color ? [params.color.r, params.color.g, params.color.b] : undefined), castShadows: undefined });
+            }
+        }
+        catch (err) {
+            return { success: false, error: `Failed to create dynamic light: ${err}` };
+        }
     }
-    // Create sky light
     async createSkyLight(params) {
         const name = this.normalizeName(params.name);
-        const escapedName = escapePythonString(name);
-        const sourceTypeRaw = typeof params.sourceType === 'string' ? params.sourceType.trim() : undefined;
-        const normalizedSourceType = sourceTypeRaw
-            ? sourceTypeRaw.toLowerCase() === 'specifiedcubemap'
-                ? 'SpecifiedCubemap'
-                : sourceTypeRaw.toLowerCase() === 'capturedscene'
-                    ? 'CapturedScene'
-                    : undefined
-            : undefined;
-        const cubemapPath = typeof params.cubemapPath === 'string' ? params.cubemapPath.trim() : undefined;
-        if (normalizedSourceType === 'SpecifiedCubemap' && (!cubemapPath || cubemapPath.length === 0)) {
+        if (params.sourceType === 'SpecifiedCubemap' && (!params.cubemapPath || params.cubemapPath.trim().length === 0)) {
             const message = 'cubemapPath is required when sourceType is SpecifiedCubemap';
             return { success: false, error: message, message };
         }
-        const escapedCubemapPath = cubemapPath ? escapePythonString(cubemapPath) : '';
-        const python = `
-import unreal
-import json
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "warnings": []
-}
-
-def add_warning(text):
-  if text:
-    result["warnings"].append(str(text))
-
-def finish():
-  if result["success"]:
-    if not result["message"]:
-      result["message"] = "Sky light ensured"
-    result.pop("error", None)
-  else:
-    if not result["error"]:
-      result["error"] = result["message"] or "Failed to ensure sky light"
-    if not result["message"]:
-      result["message"] = result["error"]
-  if not result["warnings"]:
-    result.pop("warnings", None)
-  print('RESULT:' + json.dumps(result))
-
-try:
-  actor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-  if not actor_sub:
-    result["error"] = "EditorActorSubsystem unavailable"
-    finish()
-    raise SystemExit(0)
-
-  spawn_location = unreal.Vector(0.0, 0.0, 500.0)
-  spawn_rotation = unreal.Rotator(0.0, 0.0, 0.0)
-
-  actor = None
-  try:
-    for candidate in actor_sub.get_all_level_actors():
-      try:
-        if candidate.get_class().get_name() == 'SkyLight':
-          actor = candidate
-          break
-      except Exception:
-        continue
-  except Exception:
-    pass
-
-  if actor is None:
-    actor = actor_sub.spawn_actor_from_class(unreal.SkyLight, spawn_location, spawn_rotation)
-
-  if not actor:
-    result["error"] = "Failed to spawn SkyLight actor"
-    finish()
-    raise SystemExit(0)
-
-  try:
-    actor.set_actor_label("${escapedName}")
-  except Exception:
-    pass
-
-  comp = actor.get_component_by_class(unreal.SkyLightComponent)
-  if not comp:
-    result["error"] = "SkyLight component missing"
-    finish()
-    raise SystemExit(0)
-
-  ${params.intensity !== undefined ? `
-  try:
-    comp.set_intensity(${params.intensity})
-  except Exception:
-    try:
-      comp.set_editor_property('intensity', ${params.intensity})
-    except Exception:
-      add_warning('Unable to set intensity property')
-  ` : ''}
-
-  source_type = ${normalizedSourceType ? `'${normalizedSourceType}'` : 'None'}
-  if source_type:
-    try:
-      comp.set_editor_property('source_type', getattr(unreal.SkyLightSourceType, source_type))
-    except Exception:
-      try:
-        comp.source_type = getattr(unreal.SkyLightSourceType, source_type)
-      except Exception:
-        add_warning(f"Unable to set source type {source_type}")
-
-  if source_type == 'SpecifiedCubemap':
-    path = "${escapedCubemapPath}"
-    if not path:
-      result["error"] = "cubemapPath is required when sourceType is SpecifiedCubemap"
-      finish()
-      raise SystemExit(0)
-    try:
-      exists = unreal.EditorAssetLibrary.does_asset_exist(path)
-    except Exception:
-      exists = False
-    if not exists:
-      result["error"] = f"Cubemap asset not found: {path}"
-      finish()
-      raise SystemExit(0)
-    try:
-      cube = unreal.EditorAssetLibrary.load_asset(path)
-    except Exception as load_err:
-      result["error"] = f"Failed to load cubemap asset: {load_err}"
-      finish()
-      raise SystemExit(0)
-    if not cube:
-      result["error"] = f"Cubemap asset could not be loaded: {path}"
-      finish()
-      raise SystemExit(0)
-    try:
-      if hasattr(comp, 'set_cubemap'):
-        comp.set_cubemap(cube)
-      else:
-        comp.set_editor_property('cubemap', cube)
-    except Exception as assign_err:
-      result["error"] = f"Failed to assign cubemap: {assign_err}"
-      finish()
-      raise SystemExit(0)
-
-  if ${params.recapture ? 'True' : 'False'}:
-    try:
-      comp.recapture_sky()
-    except Exception as recapture_err:
-      add_warning(f"Recapture failed: {recapture_err}")
-
-  result["success"] = True
-  result["message"] = "Sky light ensured"
-  finish()
-
-except SystemExit:
-  pass
-except Exception as run_err:
-  result["error"] = str(run_err)
-  finish()
-`.trim();
-        const resp = await this.bridge.executePython(python);
-        const parsed = parseStandardResult(resp).data;
-        if (parsed) {
-            if (parsed.success) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge required for sky light creation');
+        }
+        try {
+            const properties = {};
+            if (params.intensity !== undefined)
+                properties.Intensity = params.intensity;
+            if (params.castShadows !== undefined)
+                properties.CastShadows = params.castShadows;
+            if (params.realTimeCapture !== undefined)
+                properties.RealTimeCapture = params.realTimeCapture;
+            if (params.color)
+                properties.LightColor = { r: params.color[0], g: params.color[1], b: params.color[2], a: 1.0 };
+            const payload = {
+                name,
+                sourceType: params.sourceType || 'CapturedScene',
+                location: params.location,
+                rotation: params.rotation,
+                properties
+            };
+            if (params.cubemapPath) {
+                payload.cubemapPath = params.cubemapPath;
+            }
+            if (params.intensity !== undefined) {
+                payload.intensity = params.intensity;
+            }
+            if (params.recapture) {
+                payload.recapture = params.recapture;
+            }
+            const response = await this.automationBridge.sendAutomationRequest('spawn_sky_light', payload, {
+                timeoutMs: 60000
+            });
+            if (response.success === false) {
                 return {
-                    success: true,
-                    message: parsed.message ?? 'Sky light ensured',
-                    warnings: Array.isArray(parsed.warnings) && parsed.warnings.length > 0 ? parsed.warnings : undefined
+                    success: false,
+                    error: response.error || response.message || 'Failed to create sky light'
                 };
             }
+            return {
+                success: true,
+                message: response.message || 'Sky light created',
+                ...(response.result || {})
+            };
+        }
+        catch (error) {
             return {
                 success: false,
-                error: parsed.error ?? parsed.message ?? 'Failed to ensure sky light',
-                warnings: Array.isArray(parsed.warnings) && parsed.warnings.length > 0 ? parsed.warnings : undefined
+                error: `Failed to create sky light: ${error instanceof Error ? error.message : String(error)}`
             };
         }
-        return { success: true, message: 'Sky light ensured' };
     }
-    // Remove duplicate SkyLights and keep only one (named target label)
     async ensureSingleSkyLight(params) {
-        const fallbackName = 'MCP_Test_Sky';
-        const name = this.normalizeName(params?.name, fallbackName);
-        const escapedName = escapePythonString(name);
+        const defaultName = 'MCP_Test_Sky';
+        const name = this.normalizeName(params?.name, defaultName);
         const recapture = !!params?.recapture;
-        const py = `\nimport unreal, json\nactor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)\nactors = actor_sub.get_all_level_actors() if actor_sub else []\nskies = []\nfor a in actors:\n    try:\n        if a.get_class().get_name() == 'SkyLight':\n            skies.append(a)\n    except Exception: pass\nkeep = None\n# Prefer one with matching label; otherwise keep the first\nfor a in skies:\n    try:\n        label = a.get_actor_label()\n        if label == "${escapedName}":\n            keep = a\n            break\n    except Exception: pass\nif keep is None and len(skies) > 0:\n    keep = skies[0]\n# Rename the kept one if needed\nif keep is not None:\n    try: keep.set_actor_label("${escapedName}")\n    except Exception: pass\n# Destroy all others using the correct non-deprecated API\nremoved = 0\nfor a in skies:\n    if keep is not None and a == keep:\n        continue\n    try:\n        # Use EditorActorSubsystem.destroy_actor instead of deprecated EditorLevelLibrary\n        actor_sub.destroy_actor(a)\n        removed += 1\n    except Exception: pass\n# Optionally recapture\nif keep is not None and ${recapture ? 'True' : 'False'}:\n    try:\n        comp = keep.get_component_by_class(unreal.SkyLightComponent)\n        if comp: comp.recapture_sky()\n    except Exception: pass\nprint('RESULT:' + json.dumps({'success': True, 'removed': removed, 'kept': True if keep else False}))\n`.trim();
-        const resp = await this.bridge.executePython(py);
-        let out = '';
-        if (resp?.LogOutput && Array.isArray(resp.LogOutput)) {
-            out = resp.LogOutput.map((l) => l.Output || '').join('');
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge required for sky light management');
         }
-        else if (typeof resp === 'string') {
-            out = resp;
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('ensure_single_sky_light', {
+                name,
+                recapture
+            }, {
+                timeoutMs: 60000
+            });
+            if (response.success === false) {
+                return {
+                    success: false,
+                    error: response.error || response.message || 'Failed to ensure single sky light'
+                };
+            }
+            return {
+                success: true,
+                message: response.message || `Ensured single SkyLight (removed ${response.result?.removed || 0})`,
+                ...(response.result || {})
+            };
         }
-        else {
-            out = JSON.stringify(resp);
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to ensure single sky light: ${error instanceof Error ? error.message : String(error)}`
+            };
         }
-        const m = out.match(/RESULT:({.*})/);
-        if (m) {
+    }
+    async setupGlobalIllumination(params) {
+        if (this.automationBridge) {
             try {
-                const parsed = JSON.parse(m[1]);
-                if (parsed.success) {
-                    return { success: true, removed: parsed.removed, message: `Ensured single SkyLight (removed ${parsed.removed})` };
-                }
+                const response = await this.automationBridge.sendAutomationRequest('setup_global_illumination', {
+                    method: params.method,
+                    quality: params.quality,
+                    indirectLightingIntensity: params.indirectLightingIntensity,
+                    bounces: params.bounces
+                });
+                if (response.success)
+                    return { success: true, message: 'Global illumination configured via bridge', ...(response.result || {}) };
+            }
+            catch (_e) {
             }
-            catch { }
         }
-        return { success: true, message: 'Ensured single SkyLight' };
-    }
-    // Setup global illumination
-    async setupGlobalIllumination(params) {
         const commands = [];
         switch (params.method) {
             case 'Lightmass':
@@ -715,10 +549,25 @@ except Exception as run_err:
         for (const cmd of commands) {
             await this.bridge.executeConsoleCommand(cmd);
         }
-        return { success: true, message: 'Global illumination configured' };
+        return { success: true, message: 'Global illumination configured (console)' };
     }
-    // Configure shadows
     async configureShadows(params) {
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('configure_shadows', {
+                    shadowQuality: params.shadowQuality,
+                    cascadedShadows: params.cascadedShadows,
+                    shadowDistance: params.shadowDistance,
+                    contactShadows: params.contactShadows,
+                    rayTracedShadows: params.rayTracedShadows,
+                    virtualShadowMaps: params.rayTracedShadows
+                });
+                if (response.success)
+                    return { success: true, message: 'Shadow settings configured via bridge', ...(response.result || {}) };
+            }
+            catch (_e) {
+            }
+        }
         const commands = [];
         if (params.shadowQuality) {
             const qualityMap = { 'Low': 0, 'Medium': 1, 'High': 2, 'Epic': 3 };
@@ -739,500 +588,120 @@ except Exception as run_err:
         for (const cmd of commands) {
             await this.bridge.executeConsoleCommand(cmd);
         }
-        return { success: true, message: 'Shadow settings configured' };
+        return { success: true, message: 'Shadow settings configured (console)' };
     }
-    // Build lighting (Python-based)
     async buildLighting(params) {
-        const q = params.quality || 'High';
-        const qualityMap = {
-            'Preview': 'QUALITY_PREVIEW',
-            'Medium': 'QUALITY_MEDIUM',
-            'High': 'QUALITY_HIGH',
-            'Production': 'QUALITY_PRODUCTION'
-        };
-        const qualityEnum = qualityMap[q] || 'QUALITY_HIGH';
-        // First try to ensure precomputed lighting is allowed and force-no-precomputed is disabled, then save changes
-        const disablePrecomputedPy = `
-import unreal, json
-
-messages = []
-
-# Precheck: verify project supports static lighting (Support Static Lighting)
-try:
-    rs = unreal.get_default_object(unreal.RendererSettings)
-    support_static = False
-    try:
-        support_static = bool(rs.get_editor_property('bSupportStaticLighting'))
-    except Exception:
-        try:
-            support_static = bool(rs.get_editor_property('support_static_lighting'))
-        except Exception:
-            support_static = False
-    if not support_static:
-        print('RESULT:' + json.dumps({
-            'success': False,
-            'status': 'staticDisabled',
-            'error': 'Project has Support Static Lighting disabled (r.AllowStaticLighting=0). Enable Project Settings -> Rendering -> Support Static Lighting and restart the editor.'
-        }))
-        raise SystemExit(0)
-    else:
-        messages.append('Support Static Lighting is enabled')
-except Exception as e:
-    messages.append(f'Precheck failed: {e}')
-
-# Ensure runtime CVar does not force disable precomputed lighting
-try:
-    unreal.SystemLibrary.execute_console_command(None, 'r.ForceNoPrecomputedLighting 0')
-    messages.append('Set r.ForceNoPrecomputedLighting 0')
-except Exception as e:
-    messages.append(f'r.ForceNoPrecomputedLighting failed: {e}')
-
-# Temporarily disable source control prompts to avoid checkout dialogs during automated saves
-try:
-    prefs = unreal.SourceControlPreferences()
-    try:
-        prefs.set_enable_source_control(False)
-    except Exception:
-        try:
-            prefs.enable_source_control = False
-        except Exception:
-            pass
-    messages.append('Disabled Source Control for this session')
-except Exception as e:
-    messages.append(f'SourceControlPreferences modify failed: {e}')
-
-try:
-    ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-    les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-    world = ues.get_editor_world() if ues else None
-    
-    if world:
-        world_settings = world.get_world_settings()
-        if world_settings:
-            # Mark for modification
-            try:
-                world_settings.modify()
-            except Exception:
-                pass
-
-            # Try all known variants of the property name
-            for prop in ['force_no_precomputed_lighting', 'bForceNoPrecomputedLighting']:
-                try:
-                    world_settings.set_editor_property(prop, False)
-                    messages.append(f"Set WorldSettings.{prop}=False")
-                except Exception as e:
-                    messages.append(f"Failed setting {prop}: {e}")
-            
-            # Also update the Class Default Object (CDO) to help persistence in some versions
-            try:
-                ws_class = world_settings.get_class()
-                ws_cdo = unreal.get_default_object(ws_class)
-                if ws_cdo:
-                    try:
-                        ws_cdo.set_editor_property('bForceNoPrecomputedLighting', False)
-                        messages.append('Set CDO bForceNoPrecomputedLighting=False')
-                    except Exception:
-                        pass
-                    try:
-                        ws_cdo.set_editor_property('force_no_precomputed_lighting', False)
-                        messages.append('Set CDO force_no_precomputed_lighting=False')
-                    except Exception:
-                        pass
-            except Exception as e:
-                messages.append(f'CDO update failed: {e}')
-
-            # Apply and save level to persist change
-            try:
-                if hasattr(world_settings, 'post_edit_change'):
-                    world_settings.post_edit_change()
-            except Exception:
-                pass
-            
-            # Save current level/package
-            try:
-                wp = world.get_path_name()
-                pkg_path = wp.split('.')[0] if '.' in wp else wp
-                unreal.EditorAssetLibrary.save_asset(pkg_path)
-                messages.append(f'Saved world asset: {pkg_path}')
-            except Exception as e:
-                messages.append(f'Failed to save world asset: {e}')
-            
-            # Secondary save method
-            try:
-                if les:
-                    les.save_current_level()
-                    messages.append('LevelEditorSubsystem.save_current_level called')
-            except Exception as e:
-                messages.append(f'save_current_level failed: {e}')
-
-            # Verify final value(s)
-            try:
-                force_val = None
-                bforce_val = None
-                try:
-                    force_val = bool(world_settings.get_editor_property('force_no_precomputed_lighting'))
-                except Exception:
-                    pass
-                try:
-                    bforce_val = bool(world_settings.get_editor_property('bForceNoPrecomputedLighting'))
-                except Exception:
-                    pass
-                messages.append(f'Verify WorldSettings.force_no_precomputed_lighting={force_val}')
-                messages.append(f'Verify WorldSettings.bForceNoPrecomputedLighting={bforce_val}')
-            except Exception as e:
-                messages.append(f'Verify failed: {e}')
-except Exception as e:
-    messages.append(f'World modification failed: {e}')
-
-print('RESULT:' + json.dumps({'success': True, 'messages': messages, 'flags': {
-    'force_no_precomputed_lighting': force_val if 'force_val' in locals() else None,
-    'bForceNoPrecomputedLighting': bforce_val if 'bforce_val' in locals() else None
-}}))
-`.trim();
-        // Execute the disable script first and parse messages for diagnostics
-        const preResp = await this.bridge.executePython(disablePrecomputedPy);
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge required for lighting build');
+        }
         try {
-            const preOut = typeof preResp === 'string' ? preResp : JSON.stringify(preResp);
-            const pm = preOut.match(/RESULT:({.*})/);
-            if (pm) {
-                try {
-                    const preJson = JSON.parse(pm[1]);
-                    if (preJson && preJson.success === false && preJson.status === 'staticDisabled') {
-                        return { success: false, error: preJson.error };
-                    }
-                    if (preJson && preJson.flags) {
-                        const f = preJson.flags;
-                        if (f.bForceNoPrecomputedLighting === true || f.force_no_precomputed_lighting === true) {
-                            return {
-                                success: false,
-                                error: 'WorldSettings.bForceNoPrecomputedLighting is true. Unreal will skip static lighting builds. Please uncheck "Force No Precomputed Lighting" in this level\'s World Settings (or enable Support Static Lighting in Project Settings) and retry. If using source control, check out the map asset first.'
-                            };
-                        }
-                    }
-                }
-                catch { }
+            const response = await this.automationBridge.sendAutomationRequest('bake_lightmap', {
+                quality: params.quality || 'High',
+                buildOnlySelected: params.buildOnlySelected || false,
+                buildReflectionCaptures: params.buildReflectionCaptures !== false,
+                levelPath: params.levelPath
+            }, {
+                timeoutMs: 300000
+            });
+            if (response.success === false) {
+                return {
+                    success: false,
+                    error: response.error || response.message || 'Failed to build lighting'
+                };
             }
+            return {
+                success: true,
+                message: response.message || 'Lighting build started',
+                ...(response.result || {})
+            };
         }
-        catch { }
-        // Small delay to ensure settings are applied
-        await new Promise(resolve => setTimeout(resolve, 150));
-        // Now execute the lighting build
-        const py = `
-import unreal
-import json
-
-try:
-    les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-    if les:
-        # Build light maps with specified quality and reflection captures option
-        les.build_light_maps(unreal.LightingBuildQuality.${qualityEnum}, ${params.buildReflectionCaptures !== false ? 'True' : 'False'})
-        print('RESULT:' + json.dumps({'success': True, 'message': 'Lighting build started via LevelEditorSubsystem'}))
-    else:
-        # Fallback: Try using console command if subsystem not available
-        try:
-            unreal.SystemLibrary.execute_console_command(None, 'BuildLighting Quality=${q}')
-            ${params.buildReflectionCaptures ? "unreal.SystemLibrary.execute_console_command(None, 'BuildReflectionCaptures')" : ''}
-            print('RESULT:' + json.dumps({'success': True, 'message': 'Lighting build started via console command (fallback)'}))
-        except Exception as e2:
-            print('RESULT:' + json.dumps({'success': False, 'error': f'Build failed: {str(e2)}'}))
-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]);
-                return parsed.success ? { success: true, message: parsed.message } : { success: false, error: parsed.error };
-            }
-            catch { }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to build lighting: ${error instanceof Error ? error.message : String(error)}`
+            };
         }
-        return { success: true, message: 'Lighting build started' };
     }
-    // Create a new level with proper lighting settings as workaround
     async createLightingEnabledLevel(params) {
         const levelName = params?.levelName || 'LightingEnabledLevel';
-        const py = `
-import unreal
-import json
-
-def create_lighting_enabled_level():
-    """Create a new level with lighting enabled"""
-    try:
-        les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-        ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-        actor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-        editor_asset = unreal.EditorAssetLibrary
-        
-        if not les or not ues:
-            return {'success': False, 'error': 'Required subsystems not available'}
-        
-        # Store current actors if we need to copy them
-        actors_to_copy = []
-        if ${params?.copyActors ? 'True' : 'False'}:
-            current_world = ues.get_editor_world()
-            if current_world:
-                all_actors = actor_sub.get_all_level_actors()
-                # Filter out unnecessary actors - only copy static meshes and important gameplay actors
-                for actor in all_actors:
-                    if actor:
-                        class_name = actor.get_class().get_name()
-                        # Only copy specific actor types
-                        if class_name in ['StaticMeshActor', 'SkeletalMeshActor', 'Blueprint', 'Actor']:
-                            try:
-                                actor_data = {
-                                    'class': actor.get_class(),
-                                    'location': actor.get_actor_location(),
-                                    'rotation': actor.get_actor_rotation(),
-                                    'scale': actor.get_actor_scale3d(),
-                                    'label': actor.get_actor_label()
-                                }
-                                # Check if actor has a static mesh component
-                                mesh_comp = actor.get_component_by_class(unreal.StaticMeshComponent)
-                                if mesh_comp:
-                                    mesh = mesh_comp.get_editor_property('static_mesh')
-                                    if mesh:
-                                        actor_data['mesh'] = mesh
-                                        actors_to_copy.append(actor_data)
-                            except:
-                                pass
-                print(f'Stored {len(actors_to_copy)} actors to copy')
-        
-        # Create new level with proper template or blank
-        level_name_str = "${levelName}"
-        level_path = f'/Game/Maps/{level_name_str}'
-        
-        # Try different approaches to create a level with lighting enabled
-        level_created = False
-        
-        # Method 1: Try using the Default template (not Blank)
-        try:
-            # The Default template should have lighting enabled
-            template_path = '/Engine/Maps/Templates/Template_Default'
-            if editor_asset.does_asset_exist(template_path):
-                les.new_level_from_template(level_path, template_path)
-                print(f'Created level from Default template: {level_path}')
-                level_created = True
-        except:
-            pass
-        
-        # Method 2: Try TimeOfDay template
-        if not level_created:
-            try:
-                template_path = '/Engine/Maps/Templates/TimeOfDay'
-                if editor_asset.does_asset_exist(template_path):
-                    les.new_level_from_template(level_path, template_path)
-                    print(f'Created level from TimeOfDay template: {level_path}')
-                    level_created = True
-            except:
-                pass
-        
-        # Method 3: Create blank and manually configure
-        if not level_created:
-            les.new_level(level_path, False)
-            print(f'Created new blank level: {level_path}')
-            level_created = True
-        
-        # CRITICAL: Force disable ForceNoPrecomputedLighting using all possible methods
-        new_world = ues.get_editor_world()
-        if new_world:
-            new_ws = new_world.get_world_settings()
-            if new_ws:
-                # Method 1: Direct property modification
-                for prop in ['force_no_precomputed_lighting', 'bForceNoPrecomputedLighting', 
-                            'ForceNoPrecomputedLighting', 'bforce_no_precomputed_lighting']:
-                    try:
-                        new_ws.set_editor_property(prop, False)
-                    except:
-                        pass
-                
-                # Method 2: Modify via reflection
-                try:
-                    # Access the property through the class default object
-                    ws_class = new_ws.get_class()
-                    ws_cdo = unreal.get_default_object(ws_class)
-                    if ws_cdo:
-                        ws_cdo.set_editor_property('force_no_precomputed_lighting', False)
-                        ws_cdo.set_editor_property('bForceNoPrecomputedLighting', False)
-                except:
-                    pass
-                
-                # Method 3: Override with Lightmass settings
-                try:
-                    # Create proper Lightmass settings
-                    lightmass_settings = unreal.LightmassWorldInfoSettings()
-                    lightmass_settings.static_lighting_level_scale = 1.0
-                    lightmass_settings.num_indirect_lighting_bounces = 3
-                    lightmass_settings.use_ambient_occlusion = True
-                    lightmass_settings.generate_ambient_occlusion_material_mask = False
-                    
-                    new_ws.set_editor_property('lightmass_settings', lightmass_settings)
-                except:
-                    pass
-                
-                # Method 4: Force save and reload to apply changes
-                try:
-                    # Mark the world settings as dirty
-                    new_ws.modify()
-                    # Save immediately
-                    les.save_current_level()
-                    # Force update
-                    new_world.force_update_level_bounds()
-                except:
-                    pass
-                
-                # Verify the setting
-                try:
-                    val = new_ws.get_editor_property('force_no_precomputed_lighting')
-                    print(f'New level force_no_precomputed_lighting: {val}')
-                    if val:
-                        print('WARNING: ForceNoPrecomputedLighting is persistent - project setting override detected')
-                        print('WORKAROUND: Will use dynamic lighting only')
-                except:
-                    pass
-        
-        # Copy actors if requested
-        if actors_to_copy and actor_sub:
-            print('Copying actors to new level...')
-            copied = 0
-            for actor_data in actors_to_copy:
-                try:
-                    # Spawn a static mesh actor if we have mesh data
-                    if 'mesh' in actor_data:
-                        # Create a proper static mesh actor
-                        spawned = actor_sub.spawn_actor_from_class(
-                            unreal.StaticMeshActor,
-                            actor_data['location'],
-                            actor_data['rotation']
-                        )
-                        if spawned:
-                            spawned.set_actor_scale3d(actor_data['scale'])
-                            spawned.set_actor_label(actor_data['label'])
-                            # Set the static mesh
-                            mesh_comp = spawned.get_component_by_class(unreal.StaticMeshComponent)
-                            if mesh_comp:
-                                mesh_comp.set_static_mesh(actor_data['mesh'])
-                            copied += 1
-                    else:
-                        # Spawn regular actor
-                        spawned = actor_sub.spawn_actor_from_class(
-                            actor_data['class'],
-                            actor_data['location'],
-                            actor_data['rotation']
-                        )
-                        if spawned:
-                            spawned.set_actor_scale3d(actor_data['scale'])
-                            spawned.set_actor_label(actor_data['label'])
-                            copied += 1
-                except Exception as e:
-                    pass  # Silently skip failed copies
-            print(f'Successfully copied {copied} actors')
-        
-        # Add essential lighting actors if not using template
-        if not use_template:
-            # Add a directional light for sun
-            light = actor_sub.spawn_actor_from_class(
-                unreal.DirectionalLight,
-                unreal.Vector(0, 0, 500),
-                unreal.Rotator(-45, 45, 0)
-            )
-            if light:
-                light.set_actor_label('Sun_Light')
-                light_comp = light.get_component_by_class(unreal.DirectionalLightComponent)
-                if light_comp:
-                    light_comp.set_intensity(3.14159)  # Pi lux for realistic sun
-                    light_comp.set_light_color(unreal.LinearColor(1, 0.95, 0.8, 1))
-                print('Added directional light')
-            
-            # Add sky light for ambient
-            sky = actor_sub.spawn_actor_from_class(
-                unreal.SkyLight,
-                unreal.Vector(0, 0, 300),
-                unreal.Rotator(0, 0, 0)
-            )
-            if sky:
-                sky.set_actor_label('Sky_Light')
-                sky_comp = sky.get_component_by_class(unreal.SkyLightComponent)
-                if sky_comp:
-                    sky_comp.set_intensity(1.0)
-                print('Added sky light')
-            
-            # Add sky atmosphere for realistic sky
-            atmosphere = actor_sub.spawn_actor_from_class(
-                unreal.SkyAtmosphere,
-                unreal.Vector(0, 0, 0),
-                unreal.Rotator(0, 0, 0)
-            )
-            if atmosphere:
-                atmosphere.set_actor_label('Sky_Atmosphere')
-                print('Added sky atmosphere')
-        
-        # Save the new level
-        les.save_current_level()
-        print('New level saved')
-        
-        return {
-            'success': True, 
-            'message': f'Created new level "{level_name_str}" with lighting enabled',
-            'path': level_path
-        }
-        
-    except Exception as e:
-        return {'success': False, 'error': str(e)}
-
-result = create_lighting_enabled_level()
-print('RESULT:' + json.dumps(result))
-`.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]);
-                return parsed;
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Level creation requires plugin support.');
+        }
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('create_lighting_enabled_level', {
+                levelName,
+                copyActors: params?.copyActors === true,
+                useTemplate: params?.useTemplate === true,
+                path: params?.levelName ? `/Game/Maps/${params.levelName}` : undefined
+            }, {
+                timeoutMs: 120000
+            });
+            if (response.success === false) {
+                return {
+                    success: false,
+                    error: response.error || response.message || 'Failed to create level'
+                };
             }
-            catch { }
+            return {
+                success: true,
+                message: response.message || `Created new level "${levelName}" with lighting enabled`,
+                ...(response.result || {})
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to create lighting-enabled level: ${error}`
+            };
         }
-        return { success: true, message: 'New level creation attempted' };
     }
-    // Create lightmass importance volume via Python
     async createLightmassVolume(params) {
         const name = this.normalizeName(params.name);
-        const escapedName = escapePythonString(name);
-        const [lx, ly, lz] = params.location;
-        const [sx, sy, sz] = params.size;
-        const py = `
-import unreal
-editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-loc = unreal.Vector(${lx}, ${ly}, ${lz})
-rot = unreal.Rotator(0,0,0)
-actor = editor_actor_subsystem.spawn_actor_from_class(unreal.LightmassImportanceVolume, loc, rot)
-if actor:
-  try: actor.set_actor_label("${escapedName}")
-    except Exception: pass
-    # Best-effort: set actor scale to approximate size
-    try:
-        actor.set_actor_scale3d(unreal.Vector(max(${sx}/100.0, 0.1), max(${sy}/100.0, 0.1), max(${sz}/100.0, 0.1)))
-    except Exception: pass
-    print("RESULT:{'success': True}")
-else:
-    print("RESULT:{'success': False, 'error': 'Failed to spawn LightmassImportanceVolume'}")
-`.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: `LightmassImportanceVolume '${name}' created` } : { success: false, error: parsed.error };
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Lightmass volume creation requires plugin support.');
+        }
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('create_lightmass_volume', {
+                name,
+                location: { x: params.location[0], y: params.location[1], z: params.location[2] },
+                size: { x: params.size[0], y: params.size[1], z: params.size[2] }
+            }, {
+                timeoutMs: 60000
+            });
+            if (response.success === false) {
+                return {
+                    success: false,
+                    error: response.error || response.message || 'Failed to create lightmass volume'
+                };
             }
-            catch { }
+            return {
+                success: true,
+                message: `LightmassImportanceVolume '${name}' created`,
+                ...(response.result || {})
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to create lightmass volume: ${error}`
+            };
         }
-        return { success: true, message: 'LightmassImportanceVolume creation attempted' };
     }
-    // Set exposure
     async setExposure(params) {
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('set_exposure', {
+                    method: params.method,
+                    compensationValue: params.compensationValue,
+                    minBrightness: params.minBrightness,
+                    maxBrightness: params.maxBrightness
+                });
+                if (response.success)
+                    return { success: true, message: 'Exposure settings updated via bridge', ...(response.result || {}) };
+            }
+            catch (_e) {
+            }
+        }
         const commands = [];
         commands.push(`r.EyeAdaptation.ExposureMethod ${params.method === 'Manual' ? 0 : 1}`);
         if (params.compensationValue !== undefined) {
@@ -1247,10 +716,23 @@ else:
         for (const cmd of commands) {
             await this.bridge.executeConsoleCommand(cmd);
         }
-        return { success: true, message: 'Exposure settings updated' };
+        return { success: true, message: 'Exposure settings updated (console)' };
     }
-    // Set ambient occlusion
     async setAmbientOcclusion(params) {
+        if (this.automationBridge) {
+            try {
+                const response = await this.automationBridge.sendAutomationRequest('set_ambient_occlusion', {
+                    enabled: params.enabled,
+                    intensity: params.intensity,
+                    radius: params.radius,
+                    quality: params.quality
+                });
+                if (response.success)
+                    return { success: true, message: 'Ambient occlusion configured via bridge', ...(response.result || {}) };
+            }
+            catch (_e) {
+            }
+        }
         const commands = [];
         commands.push(`r.AmbientOcclusion.Enabled ${params.enabled ? 1 : 0}`);
         if (params.intensity !== undefined) {
@@ -1266,27 +748,43 @@ else:
         for (const cmd of commands) {
             await this.bridge.executeConsoleCommand(cmd);
         }
-        return { success: true, message: 'Ambient occlusion configured' };
+        return { success: true, message: 'Ambient occlusion configured (console)' };
     }
-    // Setup volumetric fog (prefer Python to adjust fog actor/component)
     async setupVolumetricFog(params) {
-        // Enable/disable global volumetric fog via CVar
         await this.bridge.executeConsoleCommand(`r.VolumetricFog ${params.enabled ? 1 : 0}`);
-        const py = `\nimport unreal\ntry:\n    actor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)\n    actors = actor_sub.get_all_level_actors() if actor_sub else []\n    fog = None\n    for a in actors:\n        try:\n            if a.get_class().get_name() == 'ExponentialHeightFog':\n                fog = a\n                break\n        except Exception: pass\n    if fog:\n        comp = fog.get_component_by_class(unreal.ExponentialHeightFogComponent)\n        if comp:\n            ${params.density !== undefined ? `\n            try: comp.set_fog_density(${params.density})\n            except Exception: comp.set_editor_property('fog_density', ${params.density})\n            ` : ''}
-            ${params.scatteringIntensity !== undefined ? `\n            try: comp.set_fog_max_opacity(${Math.min(Math.max(params.scatteringIntensity, 0), 1)})\n            except Exception: pass\n            ` : ''}
-        ${params.fogHeight !== undefined ? `\n        try:\n            L = fog.get_actor_location()\n            fog.set_actor_location(unreal.Vector(L.x, L.y, ${params.fogHeight}))\n        except Exception: pass\n        ` : ''}
-    print("RESULT:{'success': True}")\nexcept Exception as e:\n    print("RESULT:{'success': False, 'error': '%s'}" % str(e))\n`.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: 'Volumetric fog configured' } : { success: false, error: parsed.error };
+        if (!this.automationBridge) {
+            return {
+                success: true,
+                message: 'Volumetric fog console setting applied (plugin required for fog actor adjustment)'
+            };
+        }
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('setup_volumetric_fog', {
+                enabled: params.enabled,
+                density: params.density,
+                scatteringIntensity: params.scatteringIntensity,
+                fogHeight: params.fogHeight
+            }, {
+                timeoutMs: 60000
+            });
+            if (response.success === false) {
+                return {
+                    success: false,
+                    error: response.error || response.message || 'Failed to configure volumetric fog'
+                };
             }
-            catch { }
+            return {
+                success: true,
+                message: 'Volumetric fog configured',
+                ...(response.result || {})
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to setup volumetric fog: ${error}`
+            };
         }
-        return { success: true, message: 'Volumetric fog configured' };
     }
 }
 //# sourceMappingURL=lighting.js.map