unreal-engine-mcp-server 0.4.6 → 0.5.0

package/dist/tools/audio.js

@@ -1,762 +1,349 @@
-// Audio tools for Unreal Engine
-import JSON5 from 'json5';
-import { escapePythonString } from '../utils/python.js';
 export class AudioTools {
     bridge;
-    constructor(bridge) {
+    automationBridge;
+    constructor(bridge, automationBridge) {
         this.bridge = bridge;
+        this.automationBridge = automationBridge;
     }
-    interpretResult(resp, defaults) {
-        const normalizePayload = (payload) => {
-            const warningsValue = payload?.warnings;
-            const warningsText = Array.isArray(warningsValue)
-                ? (warningsValue.length > 0 ? warningsValue.join('; ') : undefined)
-                : typeof warningsValue === 'string' && warningsValue.trim() !== ''
-                    ? warningsValue
-                    : undefined;
-            if (payload?.success === true) {
-                const message = typeof payload?.message === 'string' && payload.message.trim() !== ''
-                    ? payload.message
-                    : defaults.successMessage;
-                return {
-                    success: true,
-                    message,
-                    details: warningsText
-                };
-            }
-            const error = (typeof payload?.error === 'string' && payload.error.trim() !== ''
-                ? payload.error
-                : undefined)
-                ?? (typeof payload?.message === 'string' && payload.message.trim() !== ''
-                    ? payload.message
-                    : undefined)
-                ?? defaults.failureMessage;
-            return {
-                success: false,
-                error,
-                details: warningsText
-            };
-        };
-        if (resp && typeof resp === 'object') {
-            const payload = resp;
-            if ('success' in payload || 'error' in payload || 'message' in payload || 'warnings' in payload) {
-                return normalizePayload(payload);
-            }
-        }
-        const raw = typeof resp === 'string' ? resp : JSON.stringify(resp);
-        const extractJson = (input) => {
-            const marker = 'RESULT:';
-            const markerIndex = input.lastIndexOf(marker);
-            if (markerIndex === -1) {
-                return undefined;
-            }
-            const afterMarker = input.slice(markerIndex + marker.length);
-            const firstBraceIndex = afterMarker.indexOf('{');
-            if (firstBraceIndex === -1) {
-                return undefined;
-            }
-            let depth = 0;
-            let inString = false;
-            let escapeNext = false;
-            for (let i = firstBraceIndex; i < afterMarker.length; i++) {
-                const char = afterMarker[i];
-                if (inString) {
-                    if (escapeNext) {
-                        escapeNext = false;
-                        continue;
-                    }
-                    if (char === '\\') {
-                        escapeNext = true;
-                        continue;
-                    }
-                    if (char === '"') {
-                        inString = false;
-                    }
-                    continue;
-                }
-                if (char === '"') {
-                    inString = true;
-                    continue;
-                }
-                if (char === '{') {
-                    depth += 1;
-                }
-                else if (char === '}') {
-                    depth -= 1;
-                    if (depth === 0) {
-                        return afterMarker.slice(firstBraceIndex, i + 1);
-                    }
-                }
-            }
-            const fallbackMatch = /\{[\s\S]*\}/.exec(afterMarker);
-            return fallbackMatch ? fallbackMatch[0] : undefined;
+    setAutomationBridge(automationBridge) { this.automationBridge = automationBridge; }
+    validateAudioParams(volume, pitch) {
+        const v = volume ?? 1.0;
+        const p = pitch ?? 1.0;
+        return {
+            volume: Math.max(0.0, Math.min(v, 4.0)),
+            pitch: Math.max(0.01, Math.min(p, 4.0))
         };
-        const jsonPayload = extractJson(raw);
-        if (jsonPayload) {
-            const parseAttempts = [
-                {
-                    label: 'json',
-                    parser: () => JSON.parse(jsonPayload)
-                },
-                {
-                    label: 'json5',
-                    parser: () => JSON5.parse(jsonPayload)
-                }
-            ];
-            const sanitizedForJson5 = jsonPayload
-                .replace(/\bTrue\b/g, 'true')
-                .replace(/\bFalse\b/g, 'false')
-                .replace(/\bNone\b/g, 'null');
-            if (sanitizedForJson5 !== jsonPayload) {
-                parseAttempts.push({ label: 'json5-sanitized', parser: () => JSON5.parse(sanitizedForJson5) });
-            }
-            const parseErrors = [];
-            for (const attempt of parseAttempts) {
-                try {
-                    const parsed = attempt.parser();
-                    if (parsed && typeof parsed === 'object') {
-                        return normalizePayload(parsed);
-                    }
-                }
-                catch (err) {
-                    parseErrors.push(`${attempt.label}: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-            const errorMatch = /["']error["']\s*:\s*(?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)')/i.exec(jsonPayload);
-            const messageMatch = /["']message["']\s*:\s*(?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)')/i.exec(jsonPayload);
-            const fallbackText = errorMatch?.[1] ?? errorMatch?.[2] ?? messageMatch?.[1] ?? messageMatch?.[2];
-            const errorText = fallbackText && fallbackText.trim().length > 0
-                ? fallbackText.trim()
-                : `${defaults.failureMessage}: ${parseErrors[0] ?? 'Unable to parse RESULT payload'}`;
-            const snippet = jsonPayload.length > 240 ? `${jsonPayload.slice(0, 240)}…` : jsonPayload;
-            const detailsParts = [];
-            if (parseErrors.length > 0) {
-                detailsParts.push(`Parse attempts failed: ${parseErrors.join('; ')}`);
-            }
-            detailsParts.push(`Raw payload: ${snippet}`);
-            const detailsText = detailsParts.join(' | ');
-            return {
-                success: false,
-                error: errorText,
-                details: detailsText
-            };
-        }
-        return { success: false, error: defaults.failureMessage };
     }
-    // Create sound cue
     async createSoundCue(params) {
-        const escapePyString = (value) => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-        const toPyNumber = (value) => value === undefined || value === null || !Number.isFinite(value) ? 'None' : String(value);
-        const toPyBool = (value) => value === undefined || value === null ? 'None' : value ? 'True' : 'False';
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Audio operations require plugin support.');
+        }
         const path = params.savePath || '/Game/Audio/Cues';
-        const wavePath = params.wavePath || '';
-        const attenuationPath = params.settings?.attenuationSettings || '';
-        const volumeLiteral = toPyNumber(params.settings?.volume);
-        const pitchLiteral = toPyNumber(params.settings?.pitch);
-        const loopingLiteral = toPyBool(params.settings?.looping);
-        const py = `
-import unreal
-import json
-
-name = r"${escapePyString(params.name)}"
-package_path = r"${escapePyString(path)}"
-wave_path = r"${escapePyString(wavePath)}"
-attenuation_path = r"${escapePyString(attenuationPath)}"
-attach_wave = ${params.wavePath ? 'True' : 'False'}
-volume_override = ${volumeLiteral}
-pitch_override = ${pitchLiteral}
-looping_override = ${loopingLiteral}
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "warnings": []
-}
-
-try:
-  asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
-  if not asset_tools:
-    result["error"] = "AssetToolsHelpers unavailable"
-    raise SystemExit(0)
-
-  factory = None
-  try:
-    factory = unreal.SoundCueFactoryNew()
-  except Exception:
-    factory = None
-
-  if not factory:
-    result["error"] = "SoundCueFactoryNew unavailable"
-    raise SystemExit(0)
-
-  package_path = package_path.rstrip('/') if package_path else package_path
-
-  asset = asset_tools.create_asset(
-    asset_name=name,
-    package_path=package_path,
-    asset_class=unreal.SoundCue,
-    factory=factory
-  )
-
-  if not asset:
-    result["error"] = "Failed to create SoundCue"
-    raise SystemExit(0)
-
-  asset_subsystem = None
-  try:
-    asset_subsystem = unreal.get_editor_subsystem(unreal.EditorAssetSubsystem)
-  except Exception:
-    asset_subsystem = None
-
-  editor_library = unreal.EditorAssetLibrary
-
-  if attach_wave:
-    wave_exists = False
-    try:
-      if asset_subsystem and hasattr(asset_subsystem, "does_asset_exist"):
-        wave_exists = asset_subsystem.does_asset_exist(wave_path)
-      else:
-        wave_exists = editor_library.does_asset_exist(wave_path)
-    except Exception as existence_error:
-      result["warnings"].append(f"Wave lookup failed: {existence_error}")
-
-    if not wave_exists:
-      result["warnings"].append(f"Wave asset not found: {wave_path}")
-    else:
-      try:
-        if asset_subsystem and hasattr(asset_subsystem, "load_asset"):
-          wave_asset = asset_subsystem.load_asset(wave_path)
-        else:
-          wave_asset = editor_library.load_asset(wave_path)
-        if wave_asset:
-          # Hooking up cue nodes via Python is non-trivial; surface warning for manual setup
-          result["warnings"].append("Sound cue created without automatic wave node hookup")
-      except Exception as wave_error:
-        result["warnings"].append(f"Failed to load wave asset: {wave_error}")
-
-  if volume_override is not None and hasattr(asset, "volume_multiplier"):
-    asset.volume_multiplier = volume_override
-  if pitch_override is not None and hasattr(asset, "pitch_multiplier"):
-    asset.pitch_multiplier = pitch_override
-  if looping_override is not None and hasattr(asset, "b_looping"):
-    asset.b_looping = looping_override
-
-  if attenuation_path:
-    try:
-      attenuation_asset = editor_library.load_asset(attenuation_path)
-      if attenuation_asset:
-        applied = False
-        if hasattr(asset, "set_attenuation_settings"):
-          try:
-            asset.set_attenuation_settings(attenuation_asset)
-            applied = True
-          except Exception:
-            applied = False
-        if not applied and hasattr(asset, "attenuation_settings"):
-          asset.attenuation_settings = attenuation_asset
-          applied = True
-        if not applied:
-          result["warnings"].append("Attenuation asset loaded but could not be applied automatically")
-    except Exception as attenuation_error:
-      result["warnings"].append(f"Failed to apply attenuation: {attenuation_error}")
-
-  try:
-    save_target = f"{package_path}/{name}" if package_path else name
-    if asset_subsystem and hasattr(asset_subsystem, "save_asset"):
-      asset_subsystem.save_asset(save_target)
-    else:
-      editor_library.save_asset(save_target)
-  except Exception as save_error:
-    result["warnings"].append(f"Save failed: {save_error}")
-
-  result["success"] = True
-  result["message"] = "Sound cue created"
-
-except SystemExit:
-  pass
-except Exception as error:
-  result["error"] = str(error)
-
-finally:
-  payload = dict(result)
-  if payload.get("success"):
-    if not payload.get("message"):
-      payload["message"] = "Sound cue created"
-    payload.pop("error", None)
-  else:
-    if not payload.get("error"):
-      payload["error"] = payload.get("message") or "Failed to create SoundCue"
-    if not payload.get("message"):
-      payload["message"] = payload["error"]
-  if not payload.get("warnings"):
-    payload.pop("warnings", None)
-  print('RESULT:' + json.dumps(payload))
-`.trim();
+        const { volume, pitch } = this.validateAudioParams(params.settings?.volume, params.settings?.pitch);
         try {
-            const resp = await this.bridge.executePython(py);
-            return this.interpretResult(resp, {
-                successMessage: 'Sound cue created',
-                failureMessage: 'Failed to create SoundCue'
+            const response = await this.automationBridge.sendAutomationRequest('create_sound_cue', {
+                name: params.name,
+                packagePath: path,
+                wavePath: params.wavePath,
+                attenuationPath: params.settings?.attenuationSettings,
+                volume,
+                pitch,
+                looping: params.settings?.looping
+            }, {
+                timeoutMs: 60000
             });
+            if (response.success === false) {
+                return { success: false, error: response.error || response.message || 'Failed to create SoundCue' };
+            }
+            return {
+                success: true,
+                message: response.message || 'Sound cue created',
+                ...(response.result || {})
+            };
         }
-        catch (e) {
-            return { success: false, error: `Failed to create sound cue: ${e}` };
+        catch (error) {
+            return { success: false, error: `Failed to create sound cue: ${error instanceof Error ? error.message : String(error)}` };
         }
     }
-    // Play sound at location
     async playSoundAtLocation(params) {
-        const volume = params.volume ?? 1.0;
-        const pitch = params.pitch ?? 1.0;
-        const startTime = params.startTime ?? 0.0;
-        const soundPath = params.soundPath ?? '';
-        const py = `
-import unreal
-import json
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "warnings": []
-}
-
-try:
-  path = "${escapePythonString(soundPath)}"
-  if not unreal.EditorAssetLibrary.does_asset_exist(path):
-    result["error"] = "Sound asset not found"
-    raise SystemExit(0)
-
-  snd = unreal.EditorAssetLibrary.load_asset(path)
-  if not snd:
-    result["error"] = f"Failed to load sound asset: {path}"
-    raise SystemExit(0)
-
-  world = None
-  try:
-    world = unreal.EditorUtilityLibrary.get_editor_world()
-  except Exception:
-    world = None
-
-  if not world:
-    editor_subsystem = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-    if editor_subsystem and hasattr(editor_subsystem, 'get_editor_world'):
-      world = editor_subsystem.get_editor_world()
-
-  if not world:
-    try:
-      world = unreal.EditorSubsystemLibrary.get_editor_world()
-    except Exception:
-      world = None
-
-  if not world:
-    result["error"] = "Unable to resolve editor world. Start PIE and ensure Editor Scripting Utilities is enabled."
-    raise SystemExit(0)
-
-  loc = unreal.Vector(${params.location[0]}, ${params.location[1]}, ${params.location[2]})
-  rot = unreal.Rotator(0.0, 0.0, 0.0)
-  unreal.GameplayStatics.spawn_sound_at_location(world, snd, loc, rot, ${volume}, ${pitch}, ${startTime})
-
-  result["success"] = True
-  result["message"] = "Sound played"
-
-except SystemExit:
-  pass
-except Exception as e:
-  result["error"] = str(e)
-finally:
-  payload = dict(result)
-  if payload.get("success"):
-    if not payload.get("message"):
-      payload["message"] = "Sound played"
-    payload.pop("error", None)
-  else:
-    if not payload.get("error"):
-      payload["error"] = payload.get("message") or "Failed to play sound"
-    if not payload.get("message"):
-      payload["message"] = payload["error"]
-  if not payload.get("warnings"):
-    payload.pop("warnings", None)
-  print('RESULT:' + json.dumps(payload))
-`.trim();
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Audio operations require plugin support.');
+        }
+        const { volume, pitch } = this.validateAudioParams(params.volume, params.pitch);
         try {
-            const resp = await this.bridge.executePythonWithResult(py);
-            return this.interpretResult(resp, {
-                successMessage: 'Sound played',
-                failureMessage: 'Failed to play sound'
+            const response = await this.automationBridge.sendAutomationRequest('play_sound_at_location', {
+                soundPath: params.soundPath,
+                location: params.location,
+                rotation: params.rotation ?? [0, 0, 0],
+                volume,
+                pitch,
+                startTime: params.startTime ?? 0.0,
+                attenuationPath: params.attenuationPath,
+                concurrencyPath: params.concurrencyPath
+            }, {
+                timeoutMs: 30000
             });
+            if (response.success === false) {
+                return { success: false, error: response.error || response.message || 'Failed to play sound' };
+            }
+            return {
+                success: true,
+                message: response.message || 'Sound played',
+                ...(response.result || {})
+            };
         }
-        catch (e) {
-            return { success: false, error: `Failed to play sound: ${e}` };
+        catch (error) {
+            return { success: false, error: `Failed to play sound: ${error instanceof Error ? error.message : String(error)}` };
         }
     }
-    // Play sound 2D
     async playSound2D(params) {
-        const volume = params.volume ?? 1.0;
-        const pitch = params.pitch ?? 1.0;
-        const startTime = params.startTime ?? 0.0;
-        const soundPath = params.soundPath ?? '';
-        const py = `
-import unreal
-import json
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "warnings": []
-}
-
-try:
-  path = "${escapePythonString(soundPath)}"
-  if not unreal.EditorAssetLibrary.does_asset_exist(path):
-    result["error"] = "Sound asset not found"
-    raise SystemExit(0)
-
-  snd = unreal.EditorAssetLibrary.load_asset(path)
-  if not snd:
-    result["error"] = f"Failed to load sound asset: {path}"
-    raise SystemExit(0)
-
-  world = None
-  try:
-    world = unreal.EditorUtilityLibrary.get_editor_world()
-  except Exception:
-    world = None
-
-  if not world:
-    editor_subsystem = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-    if editor_subsystem and hasattr(editor_subsystem, 'get_editor_world'):
-      world = editor_subsystem.get_editor_world()
-
-  if not world:
-    try:
-      world = unreal.EditorSubsystemLibrary.get_editor_world()
-    except Exception:
-      world = None
-
-  if not world:
-    result["error"] = "Unable to resolve editor world. Start PIE and ensure Editor Scripting Utilities is enabled."
-    raise SystemExit(0)
-
-  ok = False
-  try:
-    unreal.GameplayStatics.spawn_sound_2d(world, snd, ${volume}, ${pitch}, ${startTime})
-    ok = True
-  except AttributeError:
-    try:
-      unreal.GameplayStatics.play_sound_2d(world, snd, ${volume}, ${pitch}, ${startTime})
-      ok = True
-    except AttributeError:
-      pass
-
-  if not ok:
-    cam_loc = unreal.Vector(0.0, 0.0, 0.0)
-    try:
-      editor_subsystem = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-      if editor_subsystem and hasattr(editor_subsystem, 'get_level_viewport_camera_info'):
-        info = editor_subsystem.get_level_viewport_camera_info()
-        if isinstance(info, (list, tuple)) and len(info) > 0:
-          cam_loc = info[0]
-    except Exception:
-      try:
-        controller = world.get_first_player_controller()
-        if controller:
-          pawn = controller.get_pawn()
-          if pawn:
-            cam_loc = pawn.get_actor_location()
-      except Exception:
-        pass
-
-    try:
-      rot = unreal.Rotator(0.0, 0.0, 0.0)
-      unreal.GameplayStatics.spawn_sound_at_location(world, snd, cam_loc, rot, ${volume}, ${pitch}, ${startTime})
-      ok = True
-      result["warnings"].append("Fell back to 3D playback at camera location")
-    except Exception as location_error:
-      result["warnings"].append(f"Failed fallback playback: {location_error}")
-
-  if not ok:
-    result["error"] = "Failed to play sound in 2D or fallback configuration"
-    raise SystemExit(0)
-
-  result["success"] = True
-  result["message"] = "Sound2D played"
-
-except SystemExit:
-  pass
-except Exception as e:
-  result["error"] = str(e)
-finally:
-  payload = dict(result)
-  if payload.get("success"):
-    if not payload.get("message"):
-      payload["message"] = "Sound2D played"
-    payload.pop("error", None)
-  else:
-    if not payload.get("error"):
-      payload["error"] = payload.get("message") or "Failed to play sound2D"
-    if not payload.get("message"):
-      payload["message"] = payload["error"]
-  if not payload.get("warnings"):
-    payload.pop("warnings", None)
-  print('RESULT:' + json.dumps(payload))
-`.trim();
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Audio operations require plugin support.');
+        }
         try {
-            const resp = await this.bridge.executePythonWithResult(py);
-            return this.interpretResult(resp, {
-                successMessage: 'Sound2D played',
-                failureMessage: 'Failed to play sound2D'
+            const response = await this.automationBridge.sendAutomationRequest('play_sound_2d', {
+                soundPath: params.soundPath,
+                volume: params.volume ?? 1.0,
+                pitch: params.pitch ?? 1.0,
+                startTime: params.startTime ?? 0.0
+            }, {
+                timeoutMs: 30000
             });
+            if (response.success === false) {
+                return { success: false, error: response.error || response.message || 'Failed to play 2D sound' };
+            }
+            return {
+                success: true,
+                message: response.message || '2D sound played',
+                ...(response.result || {})
+            };
         }
-        catch (e) {
-            return { success: false, error: `Failed to play sound2D: ${e}` };
+        catch (error) {
+            return { success: false, error: `Failed to play 2D sound: ${error instanceof Error ? error.message : String(error)}` };
         }
     }
-    // Create audio component
-    async createAudioComponent(params) {
-        const commands = [];
-        commands.push(`AddAudioComponent ${params.actorName} ${params.componentName} ${params.soundPath}`);
-        if (params.autoPlay !== undefined) {
-            commands.push(`SetAudioComponentAutoPlay ${params.actorName}.${params.componentName} ${params.autoPlay}`);
+    async playSound(soundPath, volume, pitch) {
+        return this.playSound2D({
+            soundPath,
+            volume,
+            pitch
+        });
+    }
+    async createAudioComponent(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Creating audio components requires plugin support.');
         }
-        if (params.is3D !== undefined) {
-            commands.push(`SetAudioComponent3D ${params.actorName}.${params.componentName} ${params.is3D}`);
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('create_audio_component', {
+                actorName: _params.actorName,
+                componentName: _params.componentName,
+                soundPath: _params.soundPath,
+                autoPlay: _params.autoPlay ?? false,
+                is3D: _params.is3D ?? true
+            });
+            return response.success
+                ? { success: true, message: response.message || 'Audio component created', ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to create audio component' };
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
+        catch (error) {
+            return { success: false, error: `Failed to create audio component: ${error instanceof Error ? error.message : String(error)}` };
         }
-        return { success: true, message: `Audio component ${params.componentName} added to ${params.actorName}` };
     }
-    // Set sound attenuation
-    async setSoundAttenuation(params) {
-        const commands = [];
-        commands.push(`CreateAttenuationSettings ${params.name}`);
-        if (params.innerRadius !== undefined) {
-            commands.push(`SetAttenuationInnerRadius ${params.name} ${params.innerRadius}`);
+    async setSoundAttenuation(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Setting sound attenuation requires plugin support.');
         }
-        if (params.falloffDistance !== undefined) {
-            commands.push(`SetAttenuationFalloffDistance ${params.name} ${params.falloffDistance}`);
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('set_sound_attenuation', {
+                name: _params.name,
+                innerRadius: _params.innerRadius,
+                falloffDistance: _params.falloffDistance,
+                attenuationShape: _params.attenuationShape,
+                falloffMode: _params.falloffMode
+            });
+            return response.success
+                ? { success: true, message: response.message || 'Sound attenuation set', ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to set sound attenuation' };
         }
-        if (params.attenuationShape) {
-            commands.push(`SetAttenuationShape ${params.name} ${params.attenuationShape}`);
+        catch (error) {
+            return { success: false, error: `Failed to set sound attenuation: ${error instanceof Error ? error.message : String(error)}` };
         }
-        if (params.falloffMode) {
-            commands.push(`SetAttenuationFalloffMode ${params.name} ${params.falloffMode}`);
+    }
+    async createSoundClass(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Creating sound classes requires plugin support.');
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('create_sound_class', {
+                name: _params.name,
+                parentClass: _params.parentClass,
+                properties: _params.properties
+            });
+            return response.success
+                ? { success: true, message: response.message || 'Sound class created', ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to create sound class' };
+        }
+        catch (error) {
+            return { success: false, error: `Failed to create sound class: ${error instanceof Error ? error.message : String(error)}` };
         }
-        return { success: true, message: `Attenuation settings ${params.name} configured` };
     }
-    // Create sound class
-    async createSoundClass(params) {
-        const commands = [];
-        const parent = params.parentClass || 'Master';
-        commands.push(`CreateSoundClass ${params.name} ${parent}`);
-        if (params.properties) {
-            if (params.properties.volume !== undefined) {
-                commands.push(`SetSoundClassVolume ${params.name} ${params.properties.volume}`);
-            }
-            if (params.properties.pitch !== undefined) {
-                commands.push(`SetSoundClassPitch ${params.name} ${params.properties.pitch}`);
-            }
-            if (params.properties.lowPassFilterFrequency !== undefined) {
-                commands.push(`SetSoundClassLowPassFilter ${params.name} ${params.properties.lowPassFilterFrequency}`);
-            }
-            if (params.properties.attenuationDistanceScale !== undefined) {
-                commands.push(`SetSoundClassAttenuationScale ${params.name} ${params.properties.attenuationDistanceScale}`);
-            }
+    async createSoundMix(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Creating sound mixes requires plugin support.');
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('create_sound_mix', {
+                name: _params.name,
+                classAdjusters: _params.classAdjusters
+            });
+            return response.success
+                ? { success: true, message: response.message || 'Sound mix created', ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to create sound mix' };
+        }
+        catch (error) {
+            return { success: false, error: `Failed to create sound mix: ${error instanceof Error ? error.message : String(error)}` };
         }
-        return { success: true, message: `Sound class ${params.name} created` };
     }
-    // Create sound mix
-    async createSoundMix(params) {
-        const commands = [];
-        commands.push(`CreateSoundMix ${params.name}`);
-        if (params.classAdjusters) {
-            for (const adjuster of params.classAdjusters) {
-                commands.push(`AddSoundMixClassAdjuster ${params.name} ${adjuster.soundClass}`);
-                if (adjuster.volumeAdjuster !== undefined) {
-                    commands.push(`SetSoundMixVolume ${params.name} ${adjuster.soundClass} ${adjuster.volumeAdjuster}`);
-                }
-                if (adjuster.pitchAdjuster !== undefined) {
-                    commands.push(`SetSoundMixPitch ${params.name} ${adjuster.soundClass} ${adjuster.pitchAdjuster}`);
-                }
-                if (adjuster.fadeInTime !== undefined) {
-                    commands.push(`SetSoundMixFadeIn ${params.name} ${adjuster.soundClass} ${adjuster.fadeInTime}`);
-                }
-                if (adjuster.fadeOutTime !== undefined) {
-                    commands.push(`SetSoundMixFadeOut ${params.name} ${adjuster.soundClass} ${adjuster.fadeOutTime}`);
-                }
-            }
+    async pushSoundMix(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Pushing sound mixes requires plugin support.');
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('push_sound_mix', {
+                mixName: _params.mixName
+            });
+            return response.success
+                ? { success: true, message: response.message || 'Sound mix pushed', ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to push sound mix' };
+        }
+        catch (error) {
+            return { success: false, error: `Failed to push sound mix: ${error instanceof Error ? error.message : String(error)}` };
         }
-        return { success: true, message: `Sound mix ${params.name} created` };
-    }
-    // Push/Pop sound mix
-    async pushSoundMix(params) {
-        const command = `PushSoundMix ${params.mixName}`;
-        return this.bridge.executeConsoleCommand(command);
     }
-    async popSoundMix(params) {
-        const command = `PopSoundMix ${params.mixName}`;
-        return this.bridge.executeConsoleCommand(command);
+    async popSoundMix(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Popping sound mixes requires plugin support.');
+        }
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('pop_sound_mix', {
+                mixName: _params.mixName
+            });
+            return response.success
+                ? { success: true, message: response.message || 'Sound mix popped', ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to pop sound mix' };
+        }
+        catch (error) {
+            return { success: false, error: `Failed to pop sound mix: ${error instanceof Error ? error.message : String(error)}` };
+        }
     }
-    // Set master volume
     async setMasterVolume(params) {
-        // Clamp volume between 0 and 1
         const vol = Math.max(0.0, Math.min(1.0, params.volume));
-        // Use the proper Unreal Engine audio command
-        // Note: au.Master.Volume is the correct console variable for master volume
         const command = `au.Master.Volume ${vol}`;
         try {
             await this.bridge.executeConsoleCommand(command);
             return { success: true, message: `Master volume set to ${vol}` };
         }
         catch (e) {
-            // Fallback to Python method if console command fails
-            const py = `
-  import unreal
-  import json
-  try:
-      # Try using AudioMixerBlueprintLibrary if available
-      try:
-          unreal.AudioMixerBlueprintLibrary.set_overall_volume_multiplier(${vol})
-          print('RESULT:' + json.dumps({'success': True}))
-      except AttributeError:
-          # Fallback to GameplayStatics method using modern subsystems
-          try:
-              # Try modern subsystem first
-              try:
-                  editor_subsystem = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-                  if hasattr(editor_subsystem, 'get_editor_world'):
-                      world = editor_subsystem.get_editor_world()
-                  else:
-                      world = unreal.EditorLevelLibrary.get_editor_world()
-              except Exception:
-                  world = unreal.EditorLevelLibrary.get_editor_world()
-              unreal.GameplayStatics.set_global_pitch_modulation(world, 1.0, 0.0)  # Reset pitch
-              unreal.GameplayStatics.set_global_time_dilation(world, 1.0)  # Reset time
-              # Note: There's no direct master volume in GameplayStatics, use sound class
-              print('RESULT:' + json.dumps({'success': False, 'error': 'Master volume control not available, use sound classes instead'}))
-          except Exception as e2:
-              print('RESULT:' + json.dumps({'success': False, 'error': str(e2)}))
-  except Exception as e:
-      print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-  `.trim();
-            try {
-                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: `Master volume set to ${vol}` }
-                            : { success: false, error: parsed.error };
-                    }
-                    catch { }
-                }
-                return { success: true, message: 'Master volume set command executed' };
-            }
-            catch {
-                return { success: false, error: `Failed to set master volume: ${e}` };
-            }
+            return { success: false, error: `Failed to set master volume: ${e instanceof Error ? e.message : String(e)}` };
         }
     }
-    // Create ambient sound
-    async createAmbientSound(params) {
-        const commands = [];
-        commands.push(`SpawnAmbientSound ${params.name} ${params.location.join(' ')} ${params.soundPath}`);
-        if (params.volume !== undefined) {
-            commands.push(`SetAmbientVolume ${params.name} ${params.volume}`);
-        }
-        if (params.radius !== undefined) {
-            commands.push(`SetAmbientRadius ${params.name} ${params.radius}`);
+    async createAmbientSound(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Creating ambient sounds requires plugin support.');
         }
-        if (params.autoPlay !== undefined) {
-            commands.push(`SetAmbientAutoPlay ${params.name} ${params.autoPlay}`);
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('create_ambient_sound', {
+                soundPath: _params.soundPath,
+                location: _params.location,
+                volume: _params.volume ?? 1.0,
+                pitch: _params.pitch ?? 1.0,
+                startTime: _params.startTime ?? 0.0,
+                attenuationPath: _params.attenuationPath,
+                concurrencyPath: _params.concurrencyPath
+            });
+            return response.success
+                ? { success: true, message: response.message || 'Ambient sound created', ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to create ambient sound' };
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
+        catch (error) {
+            return { success: false, error: `Failed to create ambient sound: ${error instanceof Error ? error.message : String(error)}` };
         }
-        return { success: true, message: `Ambient sound ${params.name} created` };
     }
-    // Create reverb zone
-    async createReverbZone(params) {
-        const commands = [];
-        commands.push(`CreateReverbVolume ${params.name} ${params.location.join(' ')} ${params.size.join(' ')}`);
-        if (params.reverbEffect) {
-            commands.push(`SetReverbEffect ${params.name} ${params.reverbEffect}`);
-        }
-        if (params.volume !== undefined) {
-            commands.push(`SetReverbVolume ${params.name} ${params.volume}`);
+    async createReverbZone(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Creating reverb zones requires plugin support.');
         }
-        if (params.fadeTime !== undefined) {
-            commands.push(`SetReverbFadeTime ${params.name} ${params.fadeTime}`);
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('create_reverb_zone', {
+                name: _params.name,
+                location: _params.location,
+                size: _params.size,
+                reverbEffect: _params.reverbEffect,
+                volume: _params.volume,
+                fadeTime: _params.fadeTime
+            });
+            return response.success
+                ? { success: true, message: response.message || 'Reverb zone created', ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to create reverb zone' };
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
+        catch (error) {
+            return { success: false, error: `Failed to create reverb zone: ${error instanceof Error ? error.message : String(error)}` };
         }
-        return { success: true, message: `Reverb zone ${params.name} created` };
     }
-    // Audio analysis
-    async enableAudioAnalysis(params) {
-        const commands = [];
-        commands.push(`EnableAudioAnalysis ${params.enabled}`);
-        if (params.enabled && params.fftSize) {
-            commands.push(`SetFFTSize ${params.fftSize}`);
+    async enableAudioAnalysis(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Audio analysis controls require plugin support.');
         }
-        if (params.enabled && params.outputType) {
-            commands.push(`SetAudioAnalysisOutput ${params.outputType}`);
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('enable_audio_analysis', {
+                enabled: _params.enabled,
+                fftSize: _params.fftSize,
+                outputType: _params.outputType
+            });
+            return response.success
+                ? { success: true, message: response.message || `Audio analysis ${_params.enabled ? 'enabled' : 'disabled'}`, ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to enable audio analysis' };
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
+        catch (error) {
+            return { success: false, error: `Failed to enable audio analysis: ${error instanceof Error ? error.message : String(error)}` };
         }
-        return { success: true, message: `Audio analysis ${params.enabled ? 'enabled' : 'disabled'}` };
     }
-    // Stop all sounds
     async stopAllSounds() {
         return this.bridge.executeConsoleCommand('StopAllSounds');
     }
-    // Fade sound
-    async fadeSound(params) {
-        const type = params.fadeType || 'FadeTo';
-        const command = `${type}Sound ${params.soundName} ${params.targetVolume} ${params.fadeTime}`;
-        return this.bridge.executeConsoleCommand(command);
+    async fadeSound(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Fading sound requires plugin support.');
+        }
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('fade_sound', {
+                soundName: _params.soundName,
+                targetVolume: _params.targetVolume,
+                fadeTime: _params.fadeTime,
+                fadeType: _params.fadeType || 'FadeTo'
+            });
+            return response.success
+                ? { success: true, message: response.message || 'Sound faded', ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to fade sound' };
+        }
+        catch (error) {
+            return { success: false, error: `Failed to fade sound: ${error instanceof Error ? error.message : String(error)}` };
+        }
     }
-    // Set doppler effect
-    async setDopplerEffect(params) {
-        const commands = [];
-        commands.push(`EnableDoppler ${params.enabled}`);
-        if (params.scale !== undefined) {
-            commands.push(`SetDopplerScale ${params.scale}`);
+    async setDopplerEffect(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Doppler effect controls require plugin support.');
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('set_doppler_effect', {
+                enabled: _params.enabled,
+                scale: _params.scale ?? 1.0
+            });
+            return response.success
+                ? { success: true, message: response.message || `Doppler effect ${_params.enabled ? 'enabled' : 'disabled'}`, ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to set doppler effect' };
+        }
+        catch (error) {
+            return { success: false, error: `Failed to set doppler effect: ${error instanceof Error ? error.message : String(error)}` };
         }
-        return { success: true, message: `Doppler effect ${params.enabled ? 'enabled' : 'disabled'}` };
     }
-    // Audio occlusion
-    async setAudioOcclusion(params) {
-        const commands = [];
-        commands.push(`EnableAudioOcclusion ${params.enabled}`);
-        if (params.lowPassFilterFrequency !== undefined) {
-            commands.push(`SetOcclusionLowPassFilter ${params.lowPassFilterFrequency}`);
+    async setAudioOcclusion(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Audio occlusion controls require plugin support.');
         }
-        if (params.volumeAttenuation !== undefined) {
-            commands.push(`SetOcclusionVolumeAttenuation ${params.volumeAttenuation}`);
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('set_audio_occlusion', {
+                enabled: _params.enabled,
+                lowPassFilterFrequency: _params.lowPassFilterFrequency,
+                volumeAttenuation: _params.volumeAttenuation
+            });
+            return response.success
+                ? { success: true, message: response.message || `Audio occlusion ${_params.enabled ? 'enabled' : 'disabled'}`, ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to set audio occlusion' };
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
+        catch (error) {
+            return { success: false, error: `Failed to set audio occlusion: ${error instanceof Error ? error.message : String(error)}` };
         }
-        return { success: true, message: `Audio occlusion ${params.enabled ? 'enabled' : 'disabled'}` };
     }
 }
 //# sourceMappingURL=audio.js.map