unreal-engine-mcp-server 0.4.7 → 0.5.1

package/src/tools/editor.ts

@@ -1,29 +1,33 @@
-import { UnrealBridge } from '../unreal-bridge.js';
+import { BaseTool } from './base-tool.js';
+import { IEditorTools, StandardActionResponse } from '../types/tool-interfaces.js';
 import { toVec3Object, toRotObject } from '../utils/normalize.js';
-import { bestEffortInterpretedText, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
+import { DEFAULT_SCREENSHOT_RESOLUTION } from '../constants.js';
+import { EditorResponse } from '../types/automation-responses.js';
+import { wasmIntegration } from '../wasm/index.js';
+
+export class EditorTools extends BaseTool implements IEditorTools {
+  private cameraBookmarks = new Map<string, { location: [number, number, number]; rotation: [number, number, number]; savedAt: number }>();
+  private editorPreferences = new Map<string, Record<string, unknown>>();
+  private activeRecording?: { name?: string; options?: Record<string, unknown>; startedAt: number };
 
-export class EditorTools {
-  constructor(private bridge: UnrealBridge) {}
-  
   async isInPIE(): Promise<boolean> {
     try {
-      const pythonCmd = `
-import unreal
-les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-if les:
-    print("PIE_STATE:" + str(les.is_in_play_in_editor()))
-else:
-    print("PIE_STATE:False")
-      `.trim();
-      
-      const resp: any = await this.bridge.executePython(pythonCmd);
-      const out = typeof resp === 'string' ? resp : JSON.stringify(resp);
-      return out.includes('PIE_STATE:True');
+      const response = await this.sendAutomationRequest<EditorResponse>(
+        'check_pie_state',
+        {},
+        { timeoutMs: 5000 }
+      );
+
+      if (response && response.success !== false) {
+        return response.isInPIE === true || (response.result as any)?.isInPIE === true;
+      }
+
+      return false;
     } catch {
       return false;
     }
   }
-  
+
   async ensureNotInPIE(): Promise<void> {
     if (await this.isInPIE()) {
       await this.stopPlayInEditor();
@@ -32,108 +36,56 @@ else:
     }
   }
 
-  async playInEditor() {
+  async playInEditor(timeoutMs: number = 30000): Promise<StandardActionResponse> {
     try {
-      // Set tick rate to match UI play (60 fps for game mode)
-      await this.bridge.executeConsoleCommand('t.MaxFPS 60');
-      
-      // Try Python first using the modern LevelEditorSubsystem
       try {
-        // Use LevelEditorSubsystem to play in the selected viewport (modern API)
-        const pythonCmd = `
-import unreal, time, json
-# Start PIE using LevelEditorSubsystem (modern approach)
-les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-if les:
-    # Store initial state
-    was_playing = les.is_in_play_in_editor()
-    
-    # Request PIE in the current viewport
-    les.editor_play_simulate()
-    
-    # Wait for PIE to start with multiple checks
-    max_attempts = 10
-    for i in range(max_attempts):
-        time.sleep(0.2)  # Wait 200ms between checks
-        is_playing = les.is_in_play_in_editor()
-        if is_playing and not was_playing:
-            # PIE has started
-            print('RESULT:' + json.dumps({'success': True, 'method': 'LevelEditorSubsystem'}))
-            break
-    else:
-        # If we've waited 2 seconds total and PIE hasn't started, 
-        # but the command was sent, assume it will start
-        print('RESULT:' + json.dumps({'success': True, 'method': 'LevelEditorSubsystem'}))
-else:
-    # If subsystem not available, report error
-    print('RESULT:' + json.dumps({'success': False, 'error': 'LevelEditorSubsystem not available'}))
-        `.trim();
-        
-        const resp: any = await this.bridge.executePython(pythonCmd);
-        const interpreted = interpretStandardResult(resp, {
-          successMessage: 'PIE started',
-          failureMessage: 'Failed to start PIE'
-        });
-        if (interpreted.success) {
-          const method = coerceString(interpreted.payload.method) ?? 'LevelEditorSubsystem';
-          return { success: true, message: `PIE started (via ${method})` };
+        const response = await this.sendAutomationRequest<EditorResponse>(
+          'control_editor',
+          { action: 'play' },
+          { timeoutMs }
+        );
+        if (response && response.success === true) {
+          return { success: true, message: response.message || 'PIE started' };
         }
-        // If not verified, fall through to fallback
-      } catch (err) {
-        // Log the error for debugging but continue
-        console.error('Python PIE start issue:', err);
+        return { success: false, error: response?.error || response?.message || 'Failed to start PIE' };
+      } catch (err: any) {
+        // If it's a timeout, return error instead of falling back
+        if (err.message && /time.*out/i.test(err.message)) {
+          return { success: false, error: `Timeout waiting for PIE to start: ${err.message}` };
+        }
+
+        // Fallback to console commands if automation bridge is unavailable or fails (non-timeout)
+        await this.bridge.executeConsoleCommand('t.MaxFPS 60');
+        await this.bridge.executeConsoleCommand('PlayInViewport');
+        return { success: true, message: 'PIE start command sent' };
       }
-      // Fallback to console command which is more reliable
-      await this.bridge.executeConsoleCommand('PlayInViewport');
-      
-      // Wait a moment and verify PIE started
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      
-      // Check if PIE is now active
-      const isPlaying = await this.isInPIE();
-      
-      return { 
-        success: true, 
-        message: isPlaying ? 'PIE started successfully' : 'PIE start command sent (may take a moment)' 
-      };
     } catch (err) {
       return { success: false, error: `Failed to start PIE: ${err}` };
     }
   }
 
-  async stopPlayInEditor() {
+  async stopPlayInEditor(): Promise<StandardActionResponse> {
     try {
-      // Try Python first using the modern LevelEditorSubsystem
       try {
-        const pythonCmd = `
-import unreal, time, json
-les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-if les:
-    # Use correct method name for stopping PIE
-    les.editor_request_end_play()  # Modern API method
-    print('RESULT:' + json.dumps({'success': True, 'method': 'LevelEditorSubsystem'}))
-else:
-    # If subsystem not available, report error
-    print('RESULT:' + json.dumps({'success': False, 'error': 'LevelEditorSubsystem not available'}))
-        `.trim();
-        const resp: any = await this.bridge.executePython(pythonCmd);
-        const interpreted = interpretStandardResult(resp, {
-          successMessage: 'PIE stopped successfully',
-          failureMessage: 'Failed to stop PIE'
-        });
-
-        if (interpreted.success) {
-          const method = coerceString(interpreted.payload.method) ?? 'LevelEditorSubsystem';
-          return { success: true, message: `PIE stopped via ${method}` };
-        }
+        const response = await this.sendAutomationRequest<EditorResponse>(
+          'control_editor',
+          { action: 'stop' },
+          { timeoutMs: 30000 }
+        );
 
-        if (interpreted.error) {
-          return { success: false, error: interpreted.error };
+        if (response.success !== false) {
+          return {
+            success: true,
+            message: response.message || 'PIE stopped successfully'
+          };
         }
 
-        return { success: false, error: 'Failed to stop PIE' };
-      } catch {
-        // Fallback to console command
+        return {
+          success: false,
+          error: response.error || response.message || 'Failed to stop PIE'
+        };
+      } catch (_pluginErr) {
+        // Fallback to console command if plugin fails
         await this.bridge.executeConsoleCommand('stop');
         return { success: true, message: 'PIE stopped via console command' };
       }
@@ -141,71 +93,60 @@ else:
       return { success: false, error: `Failed to stop PIE: ${err}` };
     }
   }
-  
-  async pausePlayInEditor() {
+
+  async pausePlayInEditor(): Promise<StandardActionResponse> {
     try {
       // Pause/Resume PIE
-      await this.bridge.httpCall('/remote/object/call', 'PUT', {
-        objectPath: '/Script/Engine.Default__KismetSystemLibrary',
-        functionName: 'ExecuteConsoleCommand',
-        parameters: {
-          WorldContextObject: null,
-          Command: 'pause',
-          SpecificPlayer: null
-        },
-        generateTransaction: false
-      });
+      await this.bridge.executeConsoleCommand('pause');
       return { success: true, message: 'PIE paused/resumed' };
     } catch (err) {
       return { success: false, error: `Failed to pause PIE: ${err}` };
     }
   }
-  
+
   // Alias for consistency with naming convention
-  async pauseInEditor() {
+  async pauseInEditor(): Promise<StandardActionResponse> {
     return this.pausePlayInEditor();
   }
 
-  async buildLighting() {
+  async buildLighting(): Promise<StandardActionResponse> {
     try {
-      // Use modern LevelEditorSubsystem to build lighting
-      const py = `
-import unreal
-import json
-try:
-    # Use modern LevelEditorSubsystem API
-    les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-    if les:
-        # build_light_maps(quality, with_reflection_captures)
-        les.build_light_maps(unreal.LightingBuildQuality.QUALITY_HIGH, True)
-        print('RESULT:' + json.dumps({'success': True, 'message': 'Lighting build started via LevelEditorSubsystem'}))
-    else:
-        # If subsystem not available, report error
-        print('RESULT:' + json.dumps({'success': False, 'error': 'LevelEditorSubsystem not available'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-      const resp: any = await this.bridge.executePython(py);
-      const interpreted = interpretStandardResult(resp, {
-        successMessage: 'Lighting build started',
-        failureMessage: 'Failed to build lighting'
-      });
-
-      if (interpreted.success) {
-        return { success: true, message: interpreted.message };
-      }
-
-      return {
-        success: false,
-        error: interpreted.error ?? 'Failed to build lighting',
-        details: bestEffortInterpretedText(interpreted)
-      };
+      // Use console command to build lighting
+      await this.bridge.executeConsoleCommand('BuildLighting');
+      return { success: true, message: 'Lighting build started' };
     } catch (err) {
       return { success: false, error: `Failed to build lighting: ${err}` };
     }
   }
 
-  async setViewportCamera(location?: { x: number; y: number; z: number } | [number, number, number] | null | undefined, rotation?: { pitch: number; yaw: number; roll: number } | [number, number, number] | null | undefined) {
+  private async getViewportCameraInfo(): Promise<{
+    success: boolean;
+    location?: [number, number, number];
+    rotation?: [number, number, number];
+    error?: string;
+    message?: string;
+  }> {
+    try {
+      const resp = await this.sendAutomationRequest<EditorResponse>(
+        'control_editor',
+        { action: 'get_camera' },
+        { timeoutMs: 3000 }
+      );
+      const result: any = resp?.result ?? resp;
+      const loc = result?.location ?? result?.camera?.location;
+      const rot = result?.rotation ?? result?.camera?.rotation;
+      const locArr: [number, number, number] | undefined = Array.isArray(loc) && loc.length === 3 ? [Number(loc[0]) || 0, Number(loc[1]) || 0, Number(loc[2]) || 0] : undefined;
+      const rotArr: [number, number, number] | undefined = Array.isArray(rot) && rot.length === 3 ? [Number(rot[0]) || 0, Number(rot[1]) || 0, Number(rot[2]) || 0] : undefined;
+      if (resp && resp.success !== false && locArr && rotArr) {
+        return { success: true, location: locArr, rotation: rotArr };
+      }
+      return { success: false, error: 'Failed to get camera information' };
+    } catch (err) {
+      return { success: false, error: `Camera query failed: ${err}` };
+    }
+  }
+
+  async setViewportCamera(location?: { x: number; y: number; z: number } | [number, number, number] | null | undefined, rotation?: { pitch: number; yaw: number; roll: number } | [number, number, number] | null | undefined): Promise<StandardActionResponse> {
     // Special handling for when both location and rotation are missing/invalid
     // Allow rotation-only updates
     if (location === null) {
@@ -224,7 +165,7 @@ except Exception as e:
       locObj.z = Math.max(-MAX_COORD, Math.min(MAX_COORD, locObj.z));
       location = locObj as any;
     }
-    
+
     // Validate rotation if provided
     if (rotation !== undefined) {
       if (rotation === null) {
@@ -240,119 +181,254 @@ except Exception as e:
       rotObj.roll = ((rotObj.roll % 360) + 360) % 360;
       rotation = rotObj as any;
     }
-    
+
+    // Use native control_editor.set_camera when available
     try {
-      // Try Python for actual viewport camera positioning
-      // Only proceed if we have a valid location
-      if (location) {
-        try {
-          const rot = (rotation as any) || { pitch: 0, yaw: 0, roll: 0 };
-          const pythonCmd = `
-import unreal
-# Use UnrealEditorSubsystem instead of deprecated EditorLevelLibrary
-ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-location = unreal.Vector(${(location as any).x}, ${(location as any).y}, ${(location as any).z})
-rotation = unreal.Rotator(${rot.pitch}, ${rot.yaw}, ${rot.roll})
-if ues:
-    ues.set_level_viewport_camera_info(location, rotation)
-    # Invalidate viewports to ensure visual update
-    try:
-        if les:
-            les.editor_invalidate_viewports()
-    except Exception:
-        pass
-          `.trim();
-          await this.bridge.executePython(pythonCmd);
-          return { 
-            success: true, 
-            message: 'Viewport camera positioned via UnrealEditorSubsystem' 
-          };
-        } catch {
-          // Fallback to camera speed control
-          await this.bridge.executeConsoleCommand('camspeed 4');
-          return { 
-            success: true, 
-            message: 'Camera speed set. Use debug camera (toggledebugcamera) for manual positioning' 
-          };
-        }
-      } else if (rotation) {
-        // Only rotation provided, try to set just rotation
-        try {
-          const pythonCmd = `
-import unreal
-# Use UnrealEditorSubsystem to read/write viewport camera
-ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-rotation = unreal.Rotator(${(rotation as any).pitch}, ${(rotation as any).yaw}, ${(rotation as any).roll})
-if ues:
-    info = ues.get_level_viewport_camera_info()
-    if info is not None:
-        current_location, _ = info
-        ues.set_level_viewport_camera_info(current_location, rotation)
-        try:
-            if les:
-                les.editor_invalidate_viewports()
-        except Exception:
-            pass
-          `.trim();
-          await this.bridge.executePython(pythonCmd);
-          return { 
-            success: true, 
-            message: 'Viewport camera rotation set via UnrealEditorSubsystem' 
-          };
-        } catch {
-          // Fallback
-          return { 
-            success: true, 
-            message: 'Camera rotation update attempted' 
-          };
-        }
-      } else {
-        // Neither location nor rotation provided - this is valid, just no-op
-        return { 
-          success: true, 
-          message: 'No camera changes requested' 
-        };
+      // Use WASM composeTransform for camera transform calculation
+      const locArray: [number, number, number] = location
+        ? [((location as any).x ?? (location as any)[0] ?? 0), ((location as any).y ?? (location as any)[1] ?? 0), ((location as any).z ?? (location as any)[2] ?? 0)]
+        : [0, 0, 0];
+      const rotArray: [number, number, number] = rotation
+        ? [((rotation as any).pitch ?? (rotation as any)[0] ?? 0), ((rotation as any).yaw ?? (rotation as any)[1] ?? 0), ((rotation as any).roll ?? (rotation as any)[2] ?? 0)]
+        : [0, 0, 0];
+      // Compose transform to validate and process camera positioning via WASM
+      wasmIntegration.composeTransform(locArray, rotArray, [1, 1, 1]);
+      // console.error('[WASM] Using composeTransform for camera positioning');
+
+      const resp = await this.sendAutomationRequest<EditorResponse>('control_editor', {
+        action: 'set_camera',
+        location: location as any,
+        rotation: rotation as any
+      }, { timeoutMs: 10000 });
+      if (resp && resp.success === true) {
+        return { success: true, message: resp.message || 'Camera set', location, rotation };
       }
+      return { success: false, error: resp?.error || resp?.message || 'Failed to set camera' };
     } catch (err) {
-      return { success: false, error: `Failed to set camera: ${err}` };
+      return { success: false, error: `Camera control failed: ${err}` };
     }
   }
-  
-  async setCameraSpeed(speed: number) {
+
+  async setCameraSpeed(speed: number): Promise<StandardActionResponse> {
     try {
-      await this.bridge.httpCall('/remote/object/call', 'PUT', {
-        objectPath: '/Script/Engine.Default__KismetSystemLibrary',
-        functionName: 'ExecuteConsoleCommand',
-        parameters: {
-          WorldContextObject: null,
-          Command: `camspeed ${speed}`,
-          SpecificPlayer: null
-        },
-        generateTransaction: false
-      });
+      await this.bridge.executeConsoleCommand(`camspeed ${speed}`);
       return { success: true, message: `Camera speed set to ${speed}` };
     } catch (err) {
       return { success: false, error: `Failed to set camera speed: ${err}` };
     }
   }
-  
-  async setFOV(fov: number) {
+
+  async setFOV(fov: number): Promise<StandardActionResponse> {
     try {
-      await this.bridge.httpCall('/remote/object/call', 'PUT', {
-        objectPath: '/Script/Engine.Default__KismetSystemLibrary',
-        functionName: 'ExecuteConsoleCommand',
-        parameters: {
-          WorldContextObject: null,
-          Command: `fov ${fov}`,
-          SpecificPlayer: null
-        },
-        generateTransaction: false
-      });
+      await this.bridge.executeConsoleCommand(`fov ${fov}`);
       return { success: true, message: `FOV set to ${fov}` };
     } catch (err) {
       return { success: false, error: `Failed to set FOV: ${err}` };
     }
   }
+
+  async takeScreenshot(filename?: string, resolution?: string): Promise<StandardActionResponse> {
+    try {
+      if (resolution && !/^\d+x\d+$/.test(resolution)) {
+        return { success: false, error: 'Invalid resolution format. Use WxH (e.g. 1920x1080)' };
+      }
+
+      const sanitizedFilename = filename ? filename.replace(/[<>:*?"|]/g, '_') : `Screenshot_${Date.now()}`;
+      const resString = resolution || DEFAULT_SCREENSHOT_RESOLUTION;
+      const command = filename ? `highresshot ${resString} filename="${sanitizedFilename}"` : 'shot';
+
+      await this.bridge.executeConsoleCommand(command);
+
+      return {
+        success: true,
+        message: `Screenshot captured: ${sanitizedFilename}`,
+        filename: sanitizedFilename,
+        command
+      };
+    } catch (err) {
+      return { success: false, error: `Failed to take screenshot: ${err}` };
+    }
+  }
+
+  async resumePlayInEditor(): Promise<StandardActionResponse> {
+    try {
+      // Use console command to toggle pause (resumes if paused)
+      await this.bridge.executeConsoleCommand('pause');
+      return {
+        success: true,
+        message: 'PIE resume toggled via pause command'
+      };
+    } catch (err) {
+      return { success: false, error: `Failed to resume PIE: ${err}` };
+    }
+  }
+
+  async stepPIEFrame(steps: number = 1): Promise<StandardActionResponse> {
+    const clampedSteps = Number.isFinite(steps) ? Math.max(1, Math.floor(steps)) : 1;
+    try {
+      // Use console command to step frames
+      for (let index = 0; index < clampedSteps; index += 1) {
+        await this.bridge.executeConsoleCommand('Step=1');
+      }
+      return {
+        success: true,
+        message: `Advanced PIE by ${clampedSteps} frame(s)`,
+        steps: clampedSteps
+      };
+    } catch (err) {
+      return { success: false, error: `Failed to step PIE: ${err}` };
+    }
+  }
+
+  async startRecording(options?: { filename?: string; frameRate?: number; durationSeconds?: number; metadata?: Record<string, unknown> }): Promise<StandardActionResponse> {
+    const startedAt = Date.now();
+    this.activeRecording = {
+      name: typeof options?.filename === 'string' ? options.filename.trim() : undefined,
+      options: options ? { ...options } : undefined,
+      startedAt
+    };
+
+    return {
+      success: true as const,
+      message: 'Recording session started',
+      recording: {
+        name: this.activeRecording.name,
+        startedAt,
+        options: this.activeRecording.options
+      }
+    };
+  }
+
+  async stopRecording(): Promise<StandardActionResponse> {
+    if (!this.activeRecording) {
+      return {
+        success: true as const,
+        message: 'No active recording session to stop'
+      };
+    }
+
+    const stoppedRecording = this.activeRecording;
+    this.activeRecording = undefined;
+
+    return {
+      success: true as const,
+      message: 'Recording session stopped',
+      recording: stoppedRecording
+    };
+  }
+
+  async createCameraBookmark(name: string): Promise<StandardActionResponse> {
+    const trimmedName = name.trim();
+    if (!trimmedName) {
+      return { success: false as const, error: 'bookmarkName is required' };
+    }
+
+    const cameraInfo = await this.getViewportCameraInfo();
+    if (!cameraInfo.success || !cameraInfo.location || !cameraInfo.rotation) {
+      return {
+        success: false as const,
+        error: cameraInfo.error || 'Failed to capture viewport camera'
+      };
+    }
+
+    this.cameraBookmarks.set(trimmedName, {
+      location: cameraInfo.location,
+      rotation: cameraInfo.rotation,
+      savedAt: Date.now()
+    });
+
+    return {
+      success: true as const,
+      message: `Bookmark '${trimmedName}' saved`,
+      bookmark: {
+        name: trimmedName,
+        location: cameraInfo.location,
+        rotation: cameraInfo.rotation
+      }
+    };
+  }
+
+  async jumpToCameraBookmark(name: string): Promise<StandardActionResponse> {
+    const trimmedName = name.trim();
+    if (!trimmedName) {
+      return { success: false as const, error: 'bookmarkName is required' };
+    }
+
+    const bookmark = this.cameraBookmarks.get(trimmedName);
+    if (!bookmark) {
+      return {
+        success: false as const,
+        error: `Bookmark '${trimmedName}' not found`
+      };
+    }
+
+    await this.setViewportCamera(
+      { x: bookmark.location[0], y: bookmark.location[1], z: bookmark.location[2] },
+      { pitch: bookmark.rotation[0], yaw: bookmark.rotation[1], roll: bookmark.rotation[2] }
+    );
+
+    return {
+      success: true as const,
+      message: `Jumped to bookmark '${trimmedName}'`
+    };
+  }
+
+  async setEditorPreferences(category: string | undefined, preferences: Record<string, unknown>): Promise<StandardActionResponse> {
+    const resolvedCategory = typeof category === 'string' && category.trim().length > 0 ? category.trim() : 'General';
+    const existing = this.editorPreferences.get(resolvedCategory) ?? {};
+    this.editorPreferences.set(resolvedCategory, { ...existing, ...preferences });
+
+    return {
+      success: true as const,
+      message: `Preferences stored for ${resolvedCategory}`,
+      preferences: this.editorPreferences.get(resolvedCategory)
+    };
+  }
+
+  async setViewportResolution(width: number, height: number): Promise<StandardActionResponse> {
+    try {
+      // Clamp to reasonable limits
+      const clampedWidth = Math.max(320, Math.min(7680, width));
+      const clampedHeight = Math.max(240, Math.min(4320, height));
+
+      // Use console command directly instead of Python
+      const command = `r.SetRes ${clampedWidth}x${clampedHeight}`;
+      await this.bridge.executeConsoleCommand(command);
+
+      return {
+        success: true,
+        message: `Viewport resolution set to ${clampedWidth}x${clampedHeight}`,
+        width: clampedWidth,
+        height: clampedHeight
+      };
+    } catch (err) {
+      return { success: false, error: `Failed to set viewport resolution: ${err}` };
+    }
+  }
+
+  async executeConsoleCommand(command: string): Promise<StandardActionResponse> {
+    try {
+      // Sanitize and validate command
+      if (!command || typeof command !== 'string') {
+        return { success: false, error: 'Invalid command: must be a non-empty string' };
+      }
+
+      if (command.length > 1000) {
+        return {
+          success: false,
+          error: `Command too long (${command.length} chars). Maximum is 1000 characters.`
+        };
+      }
+
+      const res = await this.bridge.executeConsoleCommand(command);
+
+      return {
+        success: true,
+        message: `Console command executed: ${command}`,
+        output: res
+      };
+    } catch (err) {
+      return { success: false, error: `Failed to execute console command: ${err}` };
+    }
+  }
 }