unreal-engine-mcp-server 0.4.0 → 0.4.3

package/src/tools/audio.ts

@@ -1,21 +1,174 @@
 // Audio tools for Unreal Engine
+import JSON5 from 'json5';
 import { UnrealBridge } from '../unreal-bridge.js';
+import { escapePythonString } from '../utils/python.js';
 
 export class AudioTools {
   constructor(private bridge: UnrealBridge) {}
 
-  // Execute console command
-  private async _executeCommand(command: string) {
-    return this.bridge.httpCall('/remote/object/call', 'PUT', {
-      objectPath: '/Script/Engine.Default__KismetSystemLibrary',
-      functionName: 'ExecuteConsoleCommand',
-      parameters: {
-        WorldContextObject: null,
-        Command: command,
-        SpecificPlayer: null
-      },
-      generateTransaction: false
-    });
+  private interpretResult(
+    resp: unknown,
+    defaults: { successMessage: string; failureMessage: string }
+  ): { success: true; message: string; details?: string } | { success: false; error: string; details?: string } {
+    const normalizePayload = (
+      payload: Record<string, unknown>
+    ): { success: true; message: string; details?: string } | { success: false; error: string; details?: string } => {
+      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 as const,
+          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 as const,
+        error,
+        details: warningsText
+      };
+    };
+
+    if (resp && typeof resp === 'object') {
+      const payload = resp as Record<string, unknown>;
+      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: string): string | undefined => {
+      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;
+    };
+
+    const jsonPayload = extractJson(raw);
+
+    if (jsonPayload) {
+      const parseAttempts: Array<{ label: string; parser: () => unknown }> = [
+        {
+          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: string[] = [];
+
+      for (const attempt of parseAttempts) {
+        try {
+          const parsed = attempt.parser();
+          if (parsed && typeof parsed === 'object') {
+            return normalizePayload(parsed as Record<string, unknown>);
+          }
+        } 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: string[] = [];
+      if (parseErrors.length > 0) {
+        detailsParts.push(`Parse attempts failed: ${parseErrors.join('; ')}`);
+      }
+      detailsParts.push(`Raw payload: ${snippet}`);
+      const detailsText = detailsParts.join(' | ');
+
+      return {
+        success: false as const,
+        error: errorText,
+        details: detailsText
+      };
+    }
+
+    return { success: false as const, error: defaults.failureMessage };
   }
 
   // Create sound cue
@@ -30,44 +183,164 @@ export class AudioTools {
       attenuationSettings?: string;
     };
   }) {
-    const path = params.savePath || '/Game/Audio/Cues';
-    const py = `
+  const escapePyString = (value: string) => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const toPyNumber = (value?: number) =>
+    value === undefined || value === null || !Number.isFinite(value) ? 'None' : String(value);
+  const toPyBool = (value?: boolean) =>
+    value === undefined || value === null ? 'None' : value ? 'True' : 'False';
+
+  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"${params.name}"
-path = r"${path}"
+
+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()
+  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:
-        factory = unreal.SoundCueFactoryNew()
-    except Exception:
-        factory = None
-    if not factory:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'SoundCueFactoryNew unavailable'}))
+      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:
-        asset = asset_tools.create_asset(asset_name=name, package_path=path, asset_class=unreal.SoundCue, factory=factory)
-        if asset:
-            if ${params.wavePath !== undefined ? 'True' : 'False'}:
-                try:
-                    wave_path = r"${params.wavePath || ''}"
-                    if wave_path and unreal.EditorAssetLibrary.does_asset_exist(wave_path):
-                        snd = unreal.EditorAssetLibrary.load_asset(wave_path)
-                        # Simple node hookup via SoundCueGraph is non-trivial via Python; leave as empty cue
-                except Exception:
-                    pass
-            unreal.EditorAssetLibrary.save_asset(f"{path}/{name}")
-            print('RESULT:' + json.dumps({'success': True}))
+      try:
+        if asset_subsystem and hasattr(asset_subsystem, "load_asset"):
+          wave_asset = asset_subsystem.load_asset(wave_path)
         else:
-            print('RESULT:' + json.dumps({'success': False, 'error': 'Failed to create SoundCue'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
+          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();
     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: 'Sound cue created' } : { success: false, error: parsed.error }; } catch {} }
-      return { success: true, message: 'Sound cue creation attempted' };
+      return this.interpretResult(resp, {
+        successMessage: 'Sound cue created',
+        failureMessage: 'Failed to create SoundCue'
+      });
     } catch (e) {
       return { success: false, error: `Failed to create sound cue: ${e}` };
     }
@@ -84,41 +357,86 @@ except Exception as e:
     const volume = params.volume ?? 1.0;
     const pitch = params.pitch ?? 1.0;
     const startTime = params.startTime ?? 0.0;
+    const soundPath = params.soundPath ?? '';
 
-    const py = `
+  const py = `
 import unreal
 import json
-loc = unreal.Vector(${params.location[0]}, ${params.location[1]}, ${params.location[2]})
-path = r"${params.soundPath}"
+
+result = {
+  "success": False,
+  "message": "",
+  "error": "",
+  "warnings": []
+}
+
 try:
-    if not unreal.EditorAssetLibrary.does_asset_exist(path):
-        print('RESULT:' + json.dumps({'success': False, 'error': 'Sound asset not found'}))
-    else:
-        snd = unreal.EditorAssetLibrary.load_asset(path)
-        # Get editor world via EditorSubsystem first to avoid deprecation
-        try:
-            world = unreal.EditorSubsystemLibrary.get_editor_world()
-        except Exception:
-            try:
-                world = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem).get_editor_world()
-            except Exception:
-                world = unreal.EditorLevelLibrary.get_editor_world()
-        rot = unreal.Rotator(0.0, 0.0, 0.0)
-        # Use spawn_* variant with explicit rotation before optional floats
-        unreal.GameplayStatics.spawn_sound_at_location(world, snd, loc, rot, ${volume}, ${pitch}, ${startTime})
-        print('RESULT:' + json.dumps({'success': True}))
+  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:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(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();
     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: 'Sound played' } : { success: false, error: parsed.error }; } catch {} }
-      return { success: true, message: 'Sound play attempted' };
-    } catch (e) {
-      return { success: false, error: `Failed to play sound: ${e}` };
-    }
+      const resp = await this.bridge.executePythonWithResult(py);
+      return this.interpretResult(resp, {
+        successMessage: 'Sound played',
+        failureMessage: 'Failed to play sound'
+      });
+  } catch (e) {
+    return { success: false, error: `Failed to play sound: ${e}` };
+  }
   }
 
   // Play sound 2D
@@ -131,55 +449,123 @@ except Exception as e:
     const volume = params.volume ?? 1.0;
     const pitch = params.pitch ?? 1.0;
     const startTime = params.startTime ?? 0.0;
+    const soundPath = params.soundPath ?? '';
 
-    const py = `
+  const py = `
 import unreal
 import json
-path = r"${params.soundPath}"
+
+result = {
+  "success": False,
+  "message": "",
+  "error": "",
+  "warnings": []
+}
+
 try:
-    if not unreal.EditorAssetLibrary.does_asset_exist(path):
-        print('RESULT:' + json.dumps({'success': False, 'error': 'Sound asset not found'}))
-    else:
-        snd = unreal.EditorAssetLibrary.load_asset(path)
-        # Get editor world via EditorSubsystem first to avoid deprecation
-        try:
-            world = unreal.EditorSubsystemLibrary.get_editor_world()
-        except Exception:
-            try:
-                world = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem).get_editor_world()
-            except Exception:
-                world = unreal.EditorLevelLibrary.get_editor_world()
-        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:
-                # Fallback: play at camera location as 2D substitute
-                try:
-                    info = unreal.EditorLevelLibrary.get_level_viewport_camera_info()
-                    cam_loc = info[0] if isinstance(info, (list, tuple)) and len(info) > 0 else unreal.Vector(0.0, 0.0, 0.0)
-                except Exception:
-                    cam_loc = unreal.Vector(0.0, 0.0, 0.0)
-                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
-        print('RESULT:' + json.dumps({'success': True} if ok else {'success': False, 'error': 'No suitable 2D playback method found'}))
+  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:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(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();
     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: 'Sound2D played' } : { success: false, error: parsed.error }; } catch {} }
-      return { success: true, message: 'Sound2D play attempted' };
-    } catch (e) {
-      return { success: false, error: `Failed to play sound2D: ${e}` };
-    }
+      const resp = await this.bridge.executePythonWithResult(py);
+      return this.interpretResult(resp, {
+        successMessage: 'Sound2D played',
+        failureMessage: 'Failed to play sound2D'
+      });
+  } catch (e) {
+    return { success: false, error: `Failed to play sound2D: ${e}` };
+  }
   }
 
   // Create audio component
@@ -363,9 +749,17 @@ except Exception as e:
           unreal.AudioMixerBlueprintLibrary.set_overall_volume_multiplier(${vol})
           print('RESULT:' + json.dumps({'success': True}))
       except AttributeError:
-          # Fallback to GameplayStatics method
+          # Fallback to GameplayStatics method using modern subsystems
           try:
-              world = unreal.EditorLevelLibrary.get_editor_world()
+              # 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