unreal-engine-mcp-server 0.4.0 → 0.4.4

package/dist/tools/audio.js

@@ -1,67 +1,304 @@
+// Audio tools for Unreal Engine
+import JSON5 from 'json5';
+import { escapePythonString } from '../utils/python.js';
 export class AudioTools {
     bridge;
     constructor(bridge) {
         this.bridge = bridge;
     }
-    // Execute console command
-    async _executeCommand(command) {
-        return this.bridge.httpCall('/remote/object/call', 'PUT', {
-            objectPath: '/Script/Engine.Default__KismetSystemLibrary',
-            functionName: 'ExecuteConsoleCommand',
-            parameters: {
-                WorldContextObject: null,
-                Command: command,
-                SpecificPlayer: null
-            },
-            generateTransaction: false
-        });
+    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;
+        };
+        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';
         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}` };
@@ -72,43 +309,82 @@ 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 = `
 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' };
+            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}` };
@@ -119,57 +395,119 @@ 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 = `
 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' };
+            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}` };
@@ -292,9 +630,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