@hybridlabor-api/aos 4.2.0 → 4.4.0

package/mcps/unreal_mcp/tests/mcp-tools/gameplay/manage-ai.test.mjs

@@ -1,299 +0,0 @@
-#!/usr/bin/env node
-/**
- * manage_ai Tool Integration Tests
- * Covers all 43 actions with real captured asset paths.
- */
-
-import { runToolTests } from '../../test-runner.mjs';
-
-const ts = Date.now();
-const TEST_FOLDER = `/Game/MCPTest/GameplayAssets/ManageAI_${ts}`;
-const testActorName = `TestAIActor_${ts}`;
-const controllerName = `TestAIController_${ts}`;
-const blackboardName = `TestBlackboard_${ts}`;
-const aliasBlackboardName = `TestAliasBlackboard_${ts}`;
-const behaviorTreeName = `TestBehaviorTree_${ts}`;
-const eqsQueryName = `TestEQSQuery_${ts}`;
-const stateTreeName = `TestStateTree_${ts}`;
-const smartObjectName = `TestSmartObject_${ts}`;
-const massConfigName = `TestMassConfig_${ts}`;
-const blueprintName = `BP_TestAI_${ts}`;
-const navLinkName = `BP_TestNavLink_${ts}`;
-const blackboardKeyName = `TargetActor_${ts}`;
-const childStateName = `Patrol_${ts}`;
-
-const testCases = [
-  // === SETUP ===
-  { scenario: 'Setup: create test folder', toolName: 'manage_asset', arguments: { action: 'create_folder', path: TEST_FOLDER }, expected: 'success' },
-  {
-    scenario: 'Setup: create test blueprint',
-    toolName: 'manage_blueprint',
-    arguments: { action: 'create', name: blueprintName, path: TEST_FOLDER, parentClass: 'Actor' },
-    expected: 'success',
-    captureResult: { key: 'blueprintPath', fromField: 'result.assetPath' }
-  },
-  { scenario: 'Setup: spawn test actor', toolName: 'control_actor', arguments: { action: 'spawn', classPath: '/Engine/BasicShapes/Cube', actorName: testActorName, location: { x: 0, y: 0, z: 100 } }, expected: 'success' },
-
-  // === CREATE / CONTROLLER ===
-  {
-    scenario: 'CREATE: create_ai_controller',
-    toolName: 'manage_ai',
-    arguments: { action: 'create_ai_controller', name: controllerName, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'controllerPath', fromField: 'result.assetPath' }
-  },
-  {
-    scenario: 'CREATE: create_blackboard_asset',
-    toolName: 'manage_ai',
-    arguments: { action: 'create_blackboard_asset', name: blackboardName, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'blackboardPath', fromField: 'result.assetPath' }
-  },
-  {
-    scenario: 'CREATE: create_behavior_tree',
-    toolName: 'manage_ai',
-    arguments: { action: 'create_behavior_tree', name: behaviorTreeName, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'behaviorTreePath', fromField: 'result.assetPath' }
-  },
-  { scenario: 'CONNECT: assign_behavior_tree', toolName: 'manage_ai', arguments: { action: 'assign_behavior_tree', controllerPath: '${captured:controllerPath}', behaviorTreePath: '${captured:behaviorTreePath}' }, expected: 'success' },
-  { scenario: 'CONNECT: assign_blackboard', toolName: 'manage_ai', arguments: { action: 'assign_blackboard', controllerPath: '${captured:controllerPath}', blackboardPath: '${captured:blackboardPath}' }, expected: 'success' },
-
-  // === BLACKBOARD ===
-  { scenario: 'ADD: add_blackboard_key', toolName: 'manage_ai', arguments: { action: 'add_blackboard_key', blackboardPath: '${captured:blackboardPath}', keyName: blackboardKeyName, keyType: 'Bool', isInstanceSynced: false }, expected: 'success' },
-  { scenario: 'CONFIG: set_key_instance_synced', toolName: 'manage_ai', arguments: { action: 'set_key_instance_synced', blackboardPath: '${captured:blackboardPath}', keyName: blackboardKeyName, isInstanceSynced: true }, expected: 'success' },
-  { scenario: 'CONFIG: set_blackboard_value', toolName: 'manage_ai', arguments: { action: 'set_blackboard_value', blackboardPath: '${captured:blackboardPath}', keyName: blackboardKeyName, value: 'true' }, expected: 'success' },
-  { scenario: 'INFO: get_blackboard_value', toolName: 'manage_ai', arguments: { action: 'get_blackboard_value', blackboardPath: '${captured:blackboardPath}', keyName: blackboardKeyName }, expected: 'success' },
-
-  // === BEHAVIOR TREE ===
-  { scenario: 'ADD: add_composite_node', toolName: 'manage_ai', arguments: { action: 'add_composite_node', behaviorTreePath: '${captured:behaviorTreePath}', compositeType: 'Sequence' }, expected: 'success' },
-  { scenario: 'ADD: add_task_node', toolName: 'manage_ai', arguments: { action: 'add_task_node', behaviorTreePath: '${captured:behaviorTreePath}', taskType: 'Wait' }, expected: 'success' },
-  { scenario: 'ADD: add_decorator', toolName: 'manage_ai', arguments: { action: 'add_decorator', behaviorTreePath: '${captured:behaviorTreePath}', decoratorType: 'Blackboard' }, expected: 'success' },
-  { scenario: 'ADD: add_service', toolName: 'manage_ai', arguments: { action: 'add_service', behaviorTreePath: '${captured:behaviorTreePath}', serviceType: 'DefaultFocus' }, expected: 'success' },
-  { scenario: 'CONFIG: configure_bt_node', toolName: 'manage_ai', arguments: { action: 'configure_bt_node', behaviorTreePath: '${captured:behaviorTreePath}', nodeId: 'Root' }, expected: 'success' },
-  { scenario: 'ACTION: run_behavior_tree', toolName: 'manage_ai', arguments: { action: 'run_behavior_tree', controllerPath: '${captured:controllerPath}', behaviorTreePath: '${captured:behaviorTreePath}' }, expected: 'success' },
-  { scenario: 'PLAYBACK: stop_behavior_tree', toolName: 'manage_ai', arguments: { action: 'stop_behavior_tree', controllerPath: '${captured:controllerPath}' }, expected: 'success' },
-
-  // === EQS ===
-  {
-    scenario: 'CREATE: create_eqs_query',
-    toolName: 'manage_ai',
-    arguments: { action: 'create_eqs_query', name: eqsQueryName, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'queryPath', fromField: 'result.assetPath' }
-  },
-  { scenario: 'ADD: add_eqs_generator', toolName: 'manage_ai', arguments: { action: 'add_eqs_generator', queryPath: '${captured:queryPath}', generatorType: 'ActorsOfClass', generatorSettings: { searchRadius: 600, actorClass: '/Script/Engine.Actor' } }, expected: 'success' },
-  { scenario: 'ADD: add_eqs_context', toolName: 'manage_ai', arguments: { action: 'add_eqs_context', queryPath: '${captured:queryPath}', contextType: 'Querier' }, expected: 'success' },
-  { scenario: 'ADD: add_eqs_test', toolName: 'manage_ai', arguments: { action: 'add_eqs_test', queryPath: '${captured:queryPath}', testType: 'Distance' }, expected: 'success' },
-  { scenario: 'CONFIG: configure_test_scoring', toolName: 'manage_ai', arguments: { action: 'configure_test_scoring', queryPath: '${captured:queryPath}', testIndex: 0, testSettings: { scoringEquation: 'Square', clampMin: 0, clampMax: 1, filterType: 'Range', floatMin: 0, floatMax: 5000 } }, expected: 'success' },
-
-  // === PERCEPTION ===
-  { scenario: 'ADD: add_ai_perception_component', toolName: 'manage_ai', arguments: { action: 'add_ai_perception_component', blueprintPath: '${captured:blueprintPath}' }, expected: 'success' },
-  { scenario: 'CONFIG: configure_sight_config', toolName: 'manage_ai', arguments: { action: 'configure_sight_config', blueprintPath: '${captured:blueprintPath}', sightConfig: { sightRadius: 3000, loseSightRadius: 3500, peripheralVisionAngle: 90 } }, expected: 'success' },
-  { scenario: 'CONFIG: configure_hearing_config', toolName: 'manage_ai', arguments: { action: 'configure_hearing_config', blueprintPath: '${captured:blueprintPath}', hearingConfig: { hearingRange: 2000 } }, expected: 'success' },
-  { scenario: 'CONFIG: configure_damage_sense_config', toolName: 'manage_ai', arguments: { action: 'configure_damage_sense_config', blueprintPath: '${captured:blueprintPath}', damageConfig: { maxAge: 10 } }, expected: 'success' },
-  { scenario: 'CONFIG: set_perception_team', toolName: 'manage_ai', arguments: { action: 'set_perception_team', blueprintPath: '${captured:blueprintPath}', teamId: 1 }, expected: 'success' },
-  { scenario: 'ACTION: setup_perception', toolName: 'manage_ai', arguments: { action: 'setup_perception', blueprintPath: '${captured:blueprintPath}', enableSight: true, sightRadius: 2800, loseSightRadius: 3300, peripheralVisionAngle: 85, enableHearing: true, hearingRange: 1900, enableDamage: true, dominantSense: 'Sight' }, expected: 'success' },
-
-  // === STATE TREE ===
-  {
-    scenario: 'CREATE: create_state_tree',
-    toolName: 'manage_ai',
-    arguments: { action: 'create_state_tree', name: stateTreeName, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'stateTreePath', fromField: 'result.assetPath' }
-  },
-  { scenario: 'ADD: add_state_tree_state', toolName: 'manage_ai', arguments: { action: 'add_state_tree_state', stateTreePath: '${captured:stateTreePath}', stateName: childStateName, parentStateName: 'Root', stateType: 'State' }, expected: 'success' },
-  { scenario: 'ADD: add_state_tree_transition', toolName: 'manage_ai', arguments: { action: 'add_state_tree_transition', stateTreePath: '${captured:stateTreePath}', fromState: 'Root', toState: childStateName, triggerType: 'OnStateCompleted' }, expected: 'success' },
-  { scenario: 'CONFIG: configure_state_tree_task', toolName: 'manage_ai', arguments: { action: 'configure_state_tree_task', stateTreePath: '${captured:stateTreePath}', stateName: childStateName }, expected: 'success' },
-
-  // === SMART OBJECTS ===
-  {
-    scenario: 'CREATE: create_smart_object_definition',
-    toolName: 'manage_ai',
-    arguments: { action: 'create_smart_object_definition', name: smartObjectName, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'definitionPath', fromField: 'result.definitionPath' }
-  },
-  { scenario: 'ADD: add_smart_object_slot', toolName: 'manage_ai', arguments: { action: 'add_smart_object_slot', definitionPath: '${captured:definitionPath}', offset: { x: 100, y: 0, z: 0 }, rotation: { pitch: 0, yaw: 0, roll: 0 }, enabled: true }, expected: 'success' },
-  { scenario: 'CONFIG: configure_slot_behavior', toolName: 'manage_ai', arguments: { action: 'configure_slot_behavior', definitionPath: '${captured:definitionPath}', slotIndex: 0, enabled: true }, expected: 'success' },
-  { scenario: 'ADD: add_smart_object_component', toolName: 'manage_ai', arguments: { action: 'add_smart_object_component', blueprintPath: '${captured:blueprintPath}' }, expected: 'success' },
-
-  // === MASS AI ===
-  {
-    scenario: 'CREATE: create_mass_entity_config',
-    toolName: 'manage_ai',
-    arguments: { action: 'create_mass_entity_config', name: massConfigName, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'configPath', fromField: 'result.configPath' }
-  },
-  { scenario: 'CONFIG: configure_mass_entity', toolName: 'manage_ai', arguments: { action: 'configure_mass_entity', configPath: '${captured:configPath}' }, expected: 'success' },
-  { scenario: 'ADD: add_mass_spawner', toolName: 'manage_ai', arguments: { action: 'add_mass_spawner', blueprintPath: '${captured:blueprintPath}', configPath: '${captured:configPath}', componentName: 'MassSpawner', spawnCount: 10 }, expected: 'success' },
-
-  // === UTILITY / ALIASES ===
-  { scenario: 'INFO: get_ai_info', toolName: 'manage_ai', arguments: { action: 'get_ai_info', controllerPath: '${captured:controllerPath}' }, expected: 'success' },
-  {
-    scenario: 'CREATE: create_blackboard',
-    toolName: 'manage_ai',
-    arguments: { action: 'create_blackboard', name: aliasBlackboardName, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'aliasBlackboardPath', fromField: 'result.blackboardPath' }
-  },
-  {
-    scenario: 'CREATE: create_nav_link_proxy',
-    toolName: 'manage_ai',
-    arguments: {
-      action: 'create_nav_link_proxy',
-      actorName: navLinkName,
-      location: { x: 250, y: 0, z: 100 },
-      startPoint: { x: -100, y: 0, z: 0 },
-      endPoint: { x: 100, y: 0, z: 0 },
-      direction: 'BothWays'
-    },
-    expected: 'success',
-    captureResult: { key: 'navLinkPath', fromField: 'result.actorPath' }
-  },
-  { scenario: 'CONFIG: set_focus', toolName: 'manage_ai', arguments: { action: 'set_focus', controllerPath: '${captured:controllerPath}', focusActorName: testActorName }, expected: 'success' },
-  { scenario: 'DELETE: clear_focus', toolName: 'manage_ai', arguments: { action: 'clear_focus', controllerPath: '${captured:controllerPath}' }, expected: 'success' },
-
-  // === CLEANUP ===
-  { scenario: 'Cleanup: delete test actor', toolName: 'control_actor', arguments: { action: 'delete', actorName: testActorName }, expected: 'success|not found' },
-  { scenario: 'Cleanup: delete test folder', toolName: 'manage_asset', arguments: { action: 'delete', path: TEST_FOLDER, force: true }, expected: 'success|not found' }
-];
-
-// === BEHAVIOR TREE GRAPH ACTIONS ===
-{
-  /**
-   * manage_ai behavior tree action integration tests
-   * Covers all 6 actions with proper setup/teardown sequencing.
-   */
-
-  const TEST_FOLDER = '/Game/MCPTest/GameplayAssets';
-  const ts = Date.now();
-  const behaviorTreeName = `BT_Test_${ts}`;
-
-  testCases.push(
-    // === SETUP ===
-    { scenario: 'Setup: create test folder', toolName: 'manage_asset', arguments: { action: 'create_folder', path: TEST_FOLDER }, expected: 'success|already exists' },
-
-    // === ACTION ===
-    {
-      scenario: 'ACTION: create',
-      toolName: 'manage_ai',
-      arguments: { action: 'create', name: behaviorTreeName, savePath: TEST_FOLDER },
-      expected: 'success',
-      captureResult: { key: 'behaviorTreePath', fromField: 'assetPath' }
-    },
-    // === ADD ===
-    {
-      scenario: 'ADD: add sequence node',
-      toolName: 'manage_ai',
-      arguments: { action: 'add_node', assetPath: '${captured:behaviorTreePath}', nodeType: 'Sequence', x: 0, y: 0 },
-      expected: 'success',
-      captureResult: { key: 'sequenceNodeId', fromField: 'nodeId' }
-    },
-    {
-      scenario: 'ADD: add wait task node',
-      toolName: 'manage_ai',
-      arguments: { action: 'add_node', assetPath: '${captured:behaviorTreePath}', nodeType: 'Wait', x: 300, y: 120 },
-      expected: 'success',
-      captureResult: { key: 'waitNodeId', fromField: 'nodeId' }
-    },
-    // === CONNECT ===
-    {
-      scenario: 'CONNECT: connect_nodes',
-      toolName: 'manage_ai',
-      arguments: {
-        action: 'connect_nodes',
-        assetPath: '${captured:behaviorTreePath}',
-        parentNodeId: '${captured:sequenceNodeId}',
-        childNodeId: '${captured:waitNodeId}'
-      },
-      expected: 'success'
-    },
-    // === CONFIG ===
-    {
-      scenario: 'CONFIG: set_node_properties',
-      toolName: 'manage_ai',
-      arguments: {
-        action: 'set_node_properties',
-        assetPath: '${captured:behaviorTreePath}',
-        nodeId: '${captured:waitNodeId}',
-        comment: 'MCP behavior tree live test node',
-        properties: { WaitTime: 1.0 }
-      },
-      expected: 'success'
-    },
-    // === ACTION ===
-    {
-      scenario: 'ACTION: break_connections',
-      toolName: 'manage_ai',
-      arguments: { action: 'break_connections', assetPath: '${captured:behaviorTreePath}', nodeId: '${captured:sequenceNodeId}' },
-      expected: 'success'
-    },
-    // === DELETE ===
-    {
-      scenario: 'DELETE: remove_node',
-      toolName: 'manage_ai',
-      arguments: { action: 'remove_node', assetPath: '${captured:behaviorTreePath}', nodeId: '${captured:waitNodeId}' },
-      expected: 'success'
-    },
-
-    // === CLEANUP ===
-    { scenario: 'Cleanup: delete behavior tree', toolName: 'manage_asset', arguments: { action: 'delete', path: `${TEST_FOLDER}/${behaviorTreeName}`, force: true }, expected: 'success|not found' },
-    { scenario: 'Cleanup: delete test folder', toolName: 'manage_asset', arguments: { action: 'delete', path: TEST_FOLDER, force: true }, expected: 'success|not found' },
-  );
-}
-
-// === NAVIGATION ACTIONS ===
-{
-  /**
-   * manage_ai navigation action integration tests
-   * Covers all 12 actions with proper setup/teardown sequencing.
-   */
-
-  const ts = Date.now();
-  const TEST_FOLDER = `/Game/MCPTest/WorldAssets_${ts}`;
-  const NAV_BLUEPRINT = `BP_NavTest_${ts}`;
-  const NAV_ACTOR = `NavTestActor_${ts}`;
-  const NAV_LINK = `TestNavLinkProxy_${ts}`;
-  const SMART_LINK = `TestSmartLink_${ts}`;
-  const NAV_MODIFIER = `NavModifier_${ts}`;
-  const OBSTACLE_AREA = '/Script/NavigationSystem.NavArea_Obstacle';
-
-  testCases.push(
-    // === SETUP ===
-    { scenario: 'Setup: create test folder', toolName: 'manage_asset', arguments: { action: 'create_folder', path: TEST_FOLDER }, expected: 'success|already exists' },
-    { scenario: 'Setup: create navigation blueprint', toolName: 'manage_blueprint', arguments: { action: 'create', name: NAV_BLUEPRINT, path: TEST_FOLDER, parentClass: 'Actor' }, expected: 'success', captureResult: { key: 'navBlueprintPath', fromField: 'result.assetPath' } },
-    // === CONFIG ===
-    { scenario: 'CONFIG: configure_nav_mesh_settings', toolName: 'manage_ai', arguments: {"action": "configure_nav_mesh_settings", "cellSize": 19, "cellHeight": 10, "tileSizeUU": 1000, "minRegionArea": 0, "mergeRegionSize": 400, "maxSimplificationError": 1.3}, expected: 'success' },
-    { scenario: 'CONFIG: set_nav_agent_properties', toolName: 'manage_ai', arguments: {"action": "set_nav_agent_properties", "agentRadius": 35, "agentHeight": 144, "agentStepHeight": 35, "agentMaxSlope": 44}, expected: 'success' },
-    // === ACTION ===
-    { scenario: 'ACTION: rebuild_navigation', toolName: 'manage_ai', arguments: {"action": "rebuild_navigation"}, expected: 'success' },
-    // === CREATE ===
-    { scenario: 'CREATE: create_nav_modifier_component', toolName: 'manage_ai', arguments: {"action": "create_nav_modifier_component", "blueprintPath": "${captured:navBlueprintPath}", "componentName": NAV_MODIFIER, "areaClass": OBSTACLE_AREA, "failsafeExtent": {"x": 120, "y": 80, "z": 60}, "save": true}, expected: 'success' },
-    { scenario: 'Setup: spawn nav test actor', toolName: 'control_actor', arguments: { action: 'spawn_blueprint', blueprintPath: '${captured:navBlueprintPath}', actorName: NAV_ACTOR, location: { x: 0, y: 0, z: 100 } }, expected: 'success' },
-    // === CONFIG ===
-    { scenario: 'CONFIG: set_nav_area_class', toolName: 'manage_ai', arguments: {"action": "set_nav_area_class", "actorName": NAV_ACTOR, "areaClass": OBSTACLE_AREA}, expected: 'success' },
-    { scenario: 'CONFIG: configure_nav_area_cost', toolName: 'manage_ai', arguments: {"action": "configure_nav_area_cost", "areaClass": OBSTACLE_AREA, "areaCost": 1.0}, expected: 'success' },
-    // === CREATE ===
-    { scenario: 'CREATE: create_nav_link_proxy', toolName: 'manage_ai', arguments: {"action": "create_nav_link_proxy", "actorName": NAV_LINK, "location": {"x": 0, "y": 0, "z": 100}, "startPoint": {"x": -100, "y": 0, "z": 0}, "endPoint": {"x": 100, "y": 0, "z": 0}, "direction": "BothWays"}, expected: 'success' },
-    // === CONFIG ===
-    { scenario: 'CONFIG: configure_nav_link', toolName: 'manage_ai', arguments: {"action": "configure_nav_link", "actorName": NAV_LINK, "snapRadius": 30}, expected: 'success' },
-    { scenario: 'CONFIG: set_nav_link_type', toolName: 'manage_ai', arguments: {"action": "set_nav_link_type", "actorName": NAV_LINK, "linkType": "smart"}, expected: 'success' },
-    // === CREATE ===
-    { scenario: 'CREATE: create_smart_link', toolName: 'manage_ai', arguments: {"action": "create_smart_link", "actorName": SMART_LINK, "location": {"x": 0, "y": 200, "z": 100}, "startPoint": {"x": -100, "y": 0, "z": 0}, "endPoint": {"x": 100, "y": 0, "z": 0}, "direction": "BothWays"}, expected: 'success' },
-    // === CONFIG ===
-    { scenario: 'CONFIG: configure_smart_link_behavior', toolName: 'manage_ai', arguments: {"action": "configure_smart_link_behavior", "actorName": SMART_LINK, "linkEnabled": true, "enabledAreaClass": "/Script/NavigationSystem.NavArea_Default", "disabledAreaClass": "/Script/NavigationSystem.NavArea_Null", "broadcastRadius": 900, "broadcastInterval": 0, "bCreateBoxObstacle": true, "obstacleAreaClass": "/Script/NavigationSystem.NavArea_Null", "obstacleExtent": {"x": 75, "y": 50, "z": 40}, "obstacleOffset": {"x": 0, "y": 0, "z": 20}}, expected: 'success' },
-    // === INFO ===
-    { scenario: 'INFO: get_navigation_info', toolName: 'manage_ai', arguments: {"action": "get_navigation_info"}, expected: 'success' },
-
-    // === CLEANUP ===
-    { scenario: 'Cleanup: delete nav test actor', toolName: 'control_actor', arguments: { action: 'delete', actorName: NAV_ACTOR }, expected: 'success|not found' },
-    { scenario: 'Cleanup: delete nav link proxy', toolName: 'control_actor', arguments: { action: 'delete', actorName: NAV_LINK }, expected: 'success|not found' },
-    { scenario: 'Cleanup: delete smart link proxy', toolName: 'control_actor', arguments: { action: 'delete', actorName: SMART_LINK }, expected: 'success|not found' },
-    { scenario: 'Cleanup: delete test folder', toolName: 'manage_asset', arguments: { action: 'delete', path: TEST_FOLDER, force: true }, expected: 'success|not found' },
-  );
-}
-
-runToolTests('manage-ai', testCases);

package/mcps/unreal_mcp/tests/mcp-tools/gameplay/manage-character.test.mjs

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-/**
- * manage_character Tool Integration Tests
- * Covers all 27 actions with real Blueprint state captured from creation.
- */
-
-import { runToolTests } from '../../test-runner.mjs';
-
-const ts = Date.now();
-const TEST_FOLDER = `/Game/MCPTest/GameplayCharacter_${ts}`;
-const CHARACTER_NAME = `BP_MCP_Character_${ts}`;
-const ANIM_BLUEPRINT_NAME = `ABP_MCP_Character_${ts}`;
-const TEST_ACTOR = `TestCharacterActor_${ts}`;
-const TEST_SKELETAL_MESH_PATH = '/Engine/EngineMeshes/SkeletalCube';
-const TEST_SKELETON_PATH = '/Engine/EngineMeshes/SkeletalCube_Skeleton';
-
-const testCases = [
-  // === SETUP ===
-  { scenario: 'Setup: create test folder', toolName: 'manage_asset', arguments: { action: 'create_folder', path: TEST_FOLDER }, expected: 'success|already exists' },
-  {
-    scenario: 'Setup: create animation blueprint for mesh assignment',
-    toolName: 'animation_physics',
-    arguments: { action: 'create_anim_blueprint', name: ANIM_BLUEPRINT_NAME, path: TEST_FOLDER, skeletonPath: TEST_SKELETON_PATH, parentClass: 'AnimInstance' },
-    expected: 'success|already exists',
-    captureResult: { key: 'animBlueprintPath', fromField: 'data.result.assetPath' }
-  },
-  { scenario: 'Setup: spawn test actor', toolName: 'control_actor', arguments: { action: 'spawn', classPath: '/Engine/BasicShapes/Cube', actorName: TEST_ACTOR, location: { x: 0, y: 0, z: 100 } }, expected: 'success' },
-
-  // === CREATE ===
-  {
-    scenario: 'CREATE: create_character_blueprint',
-    toolName: 'manage_character',
-    arguments: { action: 'create_character_blueprint', name: CHARACTER_NAME, path: TEST_FOLDER, parentClass: 'Character' },
-    expected: 'success',
-    captureResult: { key: 'blueprintPath', fromField: 'result.assetPath' },
-    assertions: [
-      { path: 'structuredContent.result.parentClass', equals: 'Character', label: 'created blueprint uses Character parent' },
-      { path: 'structuredContent.result.existsAfter', equals: true, label: 'character blueprint asset exists after creation' }
-    ]
-  },
-
-  // === COMPONENT CONFIG ===
-  { scenario: 'CONFIG: configure_capsule_component', toolName: 'manage_character', arguments: { action: 'configure_capsule_component', blueprintPath: '${captured:blueprintPath}', capsuleRadius: 44, capsuleHalfHeight: 96 }, expected: 'success', assertions: [{ path: 'structuredContent.result.capsuleRadius', equals: 44, label: 'capsule radius applied' }] },
-  { scenario: 'CONFIG: configure_mesh_component', toolName: 'manage_character', arguments: { action: 'configure_mesh_component', blueprintPath: '${captured:blueprintPath}', skeletalMeshPath: TEST_SKELETAL_MESH_PATH, animBlueprintPath: '${captured:animBlueprintPath}', meshOffset: { x: 0, y: 0, z: -96 }, meshRotation: { pitch: 0, yaw: -90, roll: 0 } }, expected: 'success', assertions: [{ path: 'structuredContent.result.skeletalMeshAssigned', equals: true, label: 'skeletal mesh asset assigned' }, { path: 'structuredContent.result.animBlueprintAssigned', equals: true, label: 'animation blueprint assigned' }] },
-  { scenario: 'CONFIG: configure_camera_component', toolName: 'manage_character', arguments: { action: 'configure_camera_component', blueprintPath: '${captured:blueprintPath}', springArmLength: 350, cameraUsePawnControlRotation: true, springArmLagEnabled: true, springArmLagSpeed: 12 }, expected: 'success', assertions: [{ path: 'structuredContent.result.springArmLength', equals: 350, label: 'spring arm length applied' }] },
-
-  // === MOVEMENT COMPONENT ===
-  { scenario: 'CONFIG: configure_movement_speeds', toolName: 'manage_character', arguments: { action: 'configure_movement_speeds', blueprintPath: '${captured:blueprintPath}', runSpeed: 420, crouchSpeed: 180, swimSpeed: 320, flySpeed: 500, acceleration: 1400, deceleration: 1600, groundFriction: 7 }, expected: 'success', assertions: [{ path: 'structuredContent.result.runSpeedApplied', equals: true, label: 'runSpeed applied when walkSpeed omitted' }, { path: 'structuredContent.result.walkSpeed', equals: 420, label: 'runSpeed maps to max walk speed' }] },
-  { scenario: 'CONFIG: configure_jump', toolName: 'manage_character', arguments: { action: 'configure_jump', blueprintPath: '${captured:blueprintPath}', jumpHeight: 650, airControl: 0.45, gravityScale: 1.1, fallingLateralFriction: 0.15, maxJumpCount: 2, jumpHoldTime: 0.25 }, expected: 'success' },
-  { scenario: 'CONFIG: configure_rotation', toolName: 'manage_character', arguments: { action: 'configure_rotation', blueprintPath: '${captured:blueprintPath}', orientToMovement: true, useControllerRotationYaw: false, useControllerRotationPitch: false, useControllerRotationRoll: false, rotationRate: 540 }, expected: 'success' },
-  { scenario: 'ADD: add_custom_movement_mode', toolName: 'manage_character', arguments: { action: 'add_custom_movement_mode', blueprintPath: '${captured:blueprintPath}', modeName: `Dash_${ts}`, modeId: 3, customSpeed: 900 }, expected: 'success', assertions: [{ path: 'structuredContent.result.modeId', equals: 3, label: 'custom movement mode id applied' }] },
-  { scenario: 'CONFIG: configure_nav_movement', toolName: 'manage_character', arguments: { action: 'configure_nav_movement', blueprintPath: '${captured:blueprintPath}', navAgentRadius: 42, navAgentHeight: 192, avoidanceEnabled: true }, expected: 'success' },
-
-  // === ADVANCED MOVEMENT ===
-  { scenario: 'ACTION: setup_mantling', toolName: 'manage_character', arguments: { action: 'setup_mantling', blueprintPath: '${captured:blueprintPath}', mantleHeight: 180, mantleReachDistance: 120 }, expected: 'success', assertions: [{ path: 'structuredContent.result.mantleHeight', equals: 180, label: 'mantle height applied' }] },
-  { scenario: 'ACTION: setup_vaulting', toolName: 'manage_character', arguments: { action: 'setup_vaulting', blueprintPath: '${captured:blueprintPath}', vaultHeight: 120, vaultDepth: 200 }, expected: 'success', assertions: [{ path: 'structuredContent.result.vaultDepth', equals: 200, label: 'vault depth applied' }] },
-  { scenario: 'ACTION: setup_climbing', toolName: 'manage_character', arguments: { action: 'setup_climbing', blueprintPath: '${captured:blueprintPath}', climbSpeed: 240, climbableTag: 'Climbable' }, expected: 'success', assertions: [{ path: 'structuredContent.result.climbSpeed', equals: 240, label: 'climb speed applied' }] },
-  { scenario: 'ACTION: setup_sliding', toolName: 'manage_character', arguments: { action: 'setup_sliding', blueprintPath: '${captured:blueprintPath}', slideSpeed: 850, slideDuration: 1.1, slideCooldown: 0.6 }, expected: 'success', assertions: [{ path: 'structuredContent.result.slideSpeed', equals: 850, label: 'slide speed applied' }] },
-  { scenario: 'ACTION: setup_wall_running', toolName: 'manage_character', arguments: { action: 'setup_wall_running', blueprintPath: '${captured:blueprintPath}', wallRunSpeed: 720, wallRunDuration: 1.8, wallRunGravityScale: 0.5 }, expected: 'success', assertions: [{ path: 'structuredContent.result.wallRunGravityScale', equals: 0.5, label: 'wall run gravity scale applied' }] },
-  { scenario: 'ACTION: setup_grappling', toolName: 'manage_character', arguments: { action: 'setup_grappling', blueprintPath: '${captured:blueprintPath}', grappleRange: 1500, grappleSpeed: 1800, grappleTargetTag: 'GrappleTarget' }, expected: 'success', assertions: [{ path: 'structuredContent.result.grappleRange', equals: 1500, label: 'grapple range applied' }] },
-
-  // === FOOTSTEPS ===
-  { scenario: 'ACTION: setup_footstep_system', toolName: 'manage_character', arguments: { action: 'setup_footstep_system', blueprintPath: '${captured:blueprintPath}', footstepEnabled: true, footstepSocketLeft: 'foot_l', footstepSocketRight: 'foot_r', footstepTraceDistance: 75 }, expected: 'success', assertions: [{ path: 'structuredContent.result.traceDistance', equals: 75, label: 'footstep trace distance applied' }] },
-  { scenario: 'ACTION: map_surface_to_sound', toolName: 'manage_character', arguments: { action: 'map_surface_to_sound', blueprintPath: '${captured:blueprintPath}', surfaceType: 'Default' }, expected: 'success', assertions: [{ path: 'structuredContent.result.surfaceType', equals: 'Default', label: 'surface type mapped' }] },
-  { scenario: 'CONFIG: configure_footstep_fx', toolName: 'manage_character', arguments: { action: 'configure_footstep_fx', blueprintPath: '${captured:blueprintPath}', volumeMultiplier: 0.8, particleScale: 1.25 }, expected: 'success', assertions: [{ path: 'structuredContent.result.particleScale', equals: 1.25, label: 'footstep particle scale applied' }] },
-
-  // === INFO ===
-  { scenario: 'INFO: get_character_info', toolName: 'manage_character', arguments: { action: 'get_character_info', blueprintPath: '${captured:blueprintPath}' }, expected: 'success', assertions: [{ path: 'structuredContent.result.hasCamera', equals: true, label: 'character info sees camera component' }] },
-
-  // === MOVEMENT SHORTCUTS ===
-  { scenario: 'ACTION: setup_movement', toolName: 'manage_character', arguments: { action: 'setup_movement', blueprintPath: '${captured:blueprintPath}', walkSpeed: 500, acceleration: 1500 }, expected: 'success' },
-  { scenario: 'CONFIG: set_walk_speed', toolName: 'manage_character', arguments: { action: 'set_walk_speed', blueprintPath: '${captured:blueprintPath}', walkSpeed: 520 }, expected: 'success', assertions: [{ path: 'structuredContent.result.walkSpeed', equals: 520, label: 'walk speed applied' }] },
-  { scenario: 'CONFIG: set_jump_height', toolName: 'manage_character', arguments: { action: 'set_jump_height', blueprintPath: '${captured:blueprintPath}', jumpHeight: 700 }, expected: 'success', assertions: [{ path: 'structuredContent.result.jumpHeight', equals: 700, label: 'jump height applied' }] },
-  { scenario: 'CONFIG: set_gravity_scale', toolName: 'manage_character', arguments: { action: 'set_gravity_scale', blueprintPath: '${captured:blueprintPath}', gravityScale: 0.9 }, expected: 'success', assertions: [{ path: 'structuredContent.result.gravityScale', equals: 0.9, label: 'gravity scale applied' }] },
-  { scenario: 'CONFIG: set_ground_friction', toolName: 'manage_character', arguments: { action: 'set_ground_friction', blueprintPath: '${captured:blueprintPath}', groundFriction: 5.5 }, expected: 'success', assertions: [{ path: 'structuredContent.result.groundFriction', equals: 5.5, label: 'ground friction applied' }] },
-  { scenario: 'CONFIG: set_braking_deceleration', toolName: 'manage_character', arguments: { action: 'set_braking_deceleration', blueprintPath: '${captured:blueprintPath}', brakingDeceleration: 1200 }, expected: 'success', assertions: [{ path: 'structuredContent.result.brakingDeceleration', equals: 1200, label: 'braking deceleration applied' }] },
-  { scenario: 'CONFIG: configure_crouch', toolName: 'manage_character', arguments: { action: 'configure_crouch', blueprintPath: '${captured:blueprintPath}', canCrouch: true, crouchSpeed: 180, crouchedHalfHeight: 48 }, expected: 'success', assertions: [{ path: 'structuredContent.result.crouchedHalfHeight', equals: 48, label: 'crouched half-height applied' }, { path: 'structuredContent.result.canCrouch', equals: true, label: 'crouch enabled flag applied' }] },
-  { scenario: 'CONFIG: configure_sprint', toolName: 'manage_character', arguments: { action: 'configure_sprint', blueprintPath: '${captured:blueprintPath}', sprintSpeed: 850 }, expected: 'success', assertions: [{ path: 'structuredContent.result.sprintSpeed', equals: 850, label: 'sprint speed applied' }, { path: 'structuredContent.result.stateVariable', equals: 'bIsSprinting', label: 'sprint state variable created' }] },
-
-  // === CLEANUP ===
-  { scenario: 'Cleanup: delete test actor', toolName: 'control_actor', arguments: { action: 'delete', actorName: TEST_ACTOR }, expected: 'success|not found' },
-  { scenario: 'Cleanup: delete test folder', toolName: 'manage_asset', arguments: { action: 'delete', path: TEST_FOLDER, force: true }, expected: 'success|not found' },
-];
-
-runToolTests('manage-character', testCases);

package/mcps/unreal_mcp/tests/mcp-tools/gameplay/manage-combat.test.mjs

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-/**
- * manage_combat Tool Integration Tests
- * Covers all 39 actions with real Blueprint state captured from creation.
- */
-
-import { runToolTests } from '../../test-runner.mjs';
-
-const ts = Date.now();
-const TEST_FOLDER = `/Game/MCPTest/GameplayCombat_${ts}`;
-const TEST_ACTOR = `TestCombatActor_${ts}`;
-const WEAPON_NAME = `BP_MCP_Weapon_${ts}`;
-const PROJECTILE_NAME = `BP_MCP_Projectile_${ts}`;
-const DAMAGE_TYPE_NAME = `BP_MCP_DamageType_${ts}`;
-const DAMAGE_EFFECT_NAME = `BP_MCP_DamageEffect_${ts}`;
-const ALIAS_DAMAGE_TYPE_NAME = `BP_MCP_DamageAlias_${ts}`;
-
-const weaponPath = '${captured:weaponPath}';
-const projectilePath = '${captured:projectilePath}';
-
-const testCases = [
-  // === SETUP ===
-  { scenario: 'Setup: create test folder', toolName: 'manage_asset', arguments: { action: 'create_folder', path: TEST_FOLDER }, expected: 'success|already exists' },
-  { scenario: 'Setup: spawn test actor', toolName: 'control_actor', arguments: { action: 'spawn', classPath: '/Engine/BasicShapes/Cube', actorName: TEST_ACTOR, location: { x: 0, y: 0, z: 100 } }, expected: 'success' },
-
-  // === WEAPON BASE ===
-  {
-    scenario: 'CREATE: create_weapon_blueprint',
-    toolName: 'manage_combat',
-    arguments: { action: 'create_weapon_blueprint', name: WEAPON_NAME, path: TEST_FOLDER, baseDamage: 37, fireRate: 480, range: 9000, spread: 1.5 },
-    expected: 'success',
-    captureResult: { key: 'weaponPath', fromField: 'result.blueprintPath' },
-    assertions: [
-      { path: 'structuredContent.result.baseDamage', equals: 37, label: 'weapon base damage applied at creation' },
-      { path: 'structuredContent.result.fireRate', equals: 480, label: 'weapon fire rate applied at creation' }
-    ]
-  },
-  { scenario: 'CONFIG: configure_weapon_mesh', toolName: 'manage_combat', arguments: { action: 'configure_weapon_mesh', blueprintPath: weaponPath, weaponMeshPath: '/Engine/BasicShapes/Cube.Cube' }, expected: 'success', assertions: [{ path: 'structuredContent.result.meshPath', equals: '/Engine/BasicShapes/Cube.Cube', label: 'weapon mesh path applied' }] },
-  { scenario: 'CONFIG: configure_weapon_sockets', toolName: 'manage_combat', arguments: { action: 'configure_weapon_sockets', blueprintPath: weaponPath, muzzleSocketName: 'MuzzleSocket', ejectionSocketName: 'ShellSocket' }, expected: 'success', assertions: [{ path: 'structuredContent.result.muzzleSocket', equals: 'MuzzleSocket', label: 'muzzle socket name applied' }] },
-  { scenario: 'CONFIG: set_weapon_stats', toolName: 'manage_combat', arguments: { action: 'set_weapon_stats', blueprintPath: weaponPath, baseDamage: 45, fireRate: 540, range: 11000, spread: 1 }, expected: 'success', assertions: [{ path: 'structuredContent.result.baseDamage', equals: 45, label: 'weapon stat damage applied' }] },
-
-  // === FIRING MODES ===
-  { scenario: 'CONFIG: configure_hitscan', toolName: 'manage_combat', arguments: { action: 'configure_hitscan', blueprintPath: weaponPath, hitscanEnabled: true, traceChannel: 'Visibility', range: 12000 }, expected: 'success', assertions: [{ path: 'structuredContent.result.range', equals: 12000, label: 'hitscan range applied' }] },
-  { scenario: 'CONFIG: configure_projectile', toolName: 'manage_combat', arguments: { action: 'configure_projectile', blueprintPath: weaponPath, projectileClass: '/Script/Engine.Actor', projectileSpeed: 4500 }, expected: 'success', assertions: [{ path: 'structuredContent.result.projectileSpeed', equals: 4500, label: 'weapon projectile speed applied' }] },
-  { scenario: 'CONFIG: configure_spread_pattern', toolName: 'manage_combat', arguments: { action: 'configure_spread_pattern', blueprintPath: weaponPath, spreadPattern: 'Shotgun', spreadIncrease: 0.5, spreadRecovery: 2 }, expected: 'success', assertions: [{ path: 'structuredContent.result.patternType', equals: 'Shotgun', label: 'spread pattern applied' }] },
-  { scenario: 'CONFIG: configure_recoil_pattern', toolName: 'manage_combat', arguments: { action: 'configure_recoil_pattern', blueprintPath: weaponPath, recoilPitch: 2, recoilYaw: 0.5, recoilRecovery: 6 }, expected: 'success', assertions: [{ path: 'structuredContent.result.recoilYaw', equals: 0.5, label: 'recoil yaw applied' }] },
-  { scenario: 'CONFIG: configure_aim_down_sights', toolName: 'manage_combat', arguments: { action: 'configure_aim_down_sights', blueprintPath: weaponPath, adsEnabled: true, adsFov: 55, adsSpeed: 0.5, adsSpreadMultiplier: 0.5 }, expected: 'success', assertions: [{ path: 'structuredContent.result.adsFov', equals: 55, label: 'ADS FOV applied' }] },
-
-  // === PROJECTILES ===
-  {
-    scenario: 'CREATE: create_projectile_blueprint',
-    toolName: 'manage_combat',
-    arguments: { action: 'create_projectile_blueprint', name: PROJECTILE_NAME, path: TEST_FOLDER, projectileSpeed: 6000, projectileGravityScale: 0, collisionRadius: 8, projectileMeshPath: '/Engine/BasicShapes/Sphere.Sphere' },
-    expected: 'success',
-    captureResult: { key: 'projectilePath', fromField: 'result.blueprintPath' },
-    assertions: [{ path: 'structuredContent.result.projectileMeshPath', equals: '/Engine/BasicShapes/Sphere.Sphere', label: 'projectile mesh path consumed' }, { path: 'structuredContent.result.projectileMeshLoaded', equals: true, label: 'projectile mesh asset loaded' }, { path: 'structuredContent.result.existsAfter', equals: true, label: 'projectile blueprint exists after creation' }]
-  },
-  { scenario: 'CONFIG: configure_projectile_movement', toolName: 'manage_combat', arguments: { action: 'configure_projectile_movement', blueprintPath: projectilePath, projectileSpeed: 6500, projectileGravityScale: 0.5, projectileLifespan: 4 }, expected: 'success', assertions: [{ path: 'structuredContent.result.existsAfter', equals: true, label: 'projectile exists after movement configuration' }] },
-  { scenario: 'CONFIG: configure_projectile_collision', toolName: 'manage_combat', arguments: { action: 'configure_projectile_collision', blueprintPath: projectilePath, collisionRadius: 12, bounceEnabled: true, bounceVelocityRatio: 0.5 }, expected: 'success' },
-  { scenario: 'CONFIG: configure_projectile_homing', toolName: 'manage_combat', arguments: { action: 'configure_projectile_homing', blueprintPath: projectilePath, homingEnabled: true, homingAcceleration: 15000 }, expected: 'success' },
-  { scenario: 'VERIFY: projectile combat info', toolName: 'manage_combat', arguments: { action: 'get_combat_info', blueprintPath: projectilePath }, expected: 'success', assertions: [{ path: 'structuredContent.result.combatInfo.hasProjectileMovement', equals: true, label: 'projectile movement component present' }, { path: 'structuredContent.result.combatInfo.hasCollision', equals: true, label: 'projectile collision component present' }] },
-
-  // === DAMAGE SYSTEM ===
-  { scenario: 'CREATE: create_damage_type', toolName: 'manage_combat', arguments: { action: 'create_damage_type', name: DAMAGE_TYPE_NAME, path: TEST_FOLDER }, expected: 'success', assertions: [{ path: 'structuredContent.result.existsAfter', equals: true, label: 'damage type asset exists after creation' }] },
-  { scenario: 'CONFIG: configure_damage_execution', toolName: 'manage_combat', arguments: { action: 'configure_damage_execution', blueprintPath: weaponPath, damageImpulse: 700, criticalMultiplier: 2, headshotMultiplier: 3 }, expected: 'success', assertions: [{ path: 'structuredContent.result.headshotMultiplier', equals: 3, label: 'headshot multiplier applied' }] },
-  { scenario: 'ACTION: setup_hitbox_component', toolName: 'manage_combat', arguments: { action: 'setup_hitbox_component', blueprintPath: weaponPath, hitboxType: 'Box', hitboxBoneName: 'spine_03', hitboxSize: { extent: { x: 12, y: 18, z: 22 } }, isDamageZoneHead: true, damageMultiplier: 2 }, expected: 'success', assertions: [{ path: 'structuredContent.result.hitboxType', equals: 'Box', label: 'hitbox type applied' }, { path: 'structuredContent.result.hitboxSize.extent.x', equals: 12, label: 'hitbox extent x applied' }, { path: 'structuredContent.result.hitboxSize.extent.y', equals: 18, label: 'hitbox extent y applied' }, { path: 'structuredContent.result.hitboxSize.extent.z', equals: 22, label: 'hitbox extent z applied' }] },
-
-  // === WEAPON FEATURES ===
-  { scenario: 'ACTION: setup_reload_system', toolName: 'manage_combat', arguments: { action: 'setup_reload_system', blueprintPath: weaponPath, magazineSize: 24, reloadTime: 2, reloadAnimationPath: '/Game/MCPTest/FakeReloadMontage' }, expected: 'success', assertions: [{ path: 'structuredContent.result.magazineSize', equals: 24, label: 'magazine size applied' }, { path: 'structuredContent.result.reloadAnimationPath', equals: '/Game/MCPTest/FakeReloadMontage', label: 'reload animation path consumed' }, { path: 'structuredContent.result.reloadAnimationLoaded', equals: false, label: 'missing reload animation handled without applying object reference' }] },
-  { scenario: 'ACTION: setup_ammo_system', toolName: 'manage_combat', arguments: { action: 'setup_ammo_system', blueprintPath: weaponPath, ammoType: 'Rifle', maxAmmo: 120, startingAmmo: 48, ammoPerShot: 1, infiniteAmmo: false }, expected: 'success', assertions: [{ path: 'structuredContent.result.maxAmmo', equals: 120, label: 'max ammo applied' }, { path: 'structuredContent.result.ammoPerShot', equals: 1, label: 'ammo per shot applied' }, { path: 'structuredContent.result.infiniteAmmo', equals: false, label: 'infinite ammo flag applied' }] },
-  { scenario: 'ACTION: setup_attachment_system', toolName: 'manage_combat', arguments: { action: 'setup_attachment_system', blueprintPath: weaponPath, attachmentSlots: [{ slotName: 'Optic', socketName: 'OpticSocket', allowedTypes: ['Scope'] }, { slotName: 'Magazine', socketName: 'MagazineSocket', allowedTypes: ['Magazine'] }] }, expected: 'success', assertions: [{ path: 'structuredContent.result.attachmentSlots', length: 2, label: 'attachment slots registered' }, { path: 'structuredContent.result.componentsCreated', length: 2, label: 'attachment scene components created' }] },
-  { scenario: 'ACTION: setup_weapon_switching', toolName: 'manage_combat', arguments: { action: 'setup_weapon_switching', blueprintPath: weaponPath, switchInTime: 0.5, switchOutTime: 0.25, equipAnimationPath: '/Game/MCPTest/FakeEquipMontage', unequipAnimationPath: '/Game/MCPTest/FakeUnequipMontage' }, expected: 'success', assertions: [{ path: 'structuredContent.result.switchInTime', equals: 0.5, label: 'weapon switch-in time applied' }, { path: 'structuredContent.result.equipAnimationPath', equals: '/Game/MCPTest/FakeEquipMontage', label: 'equip animation path consumed' }, { path: 'structuredContent.result.unequipAnimationPath', equals: '/Game/MCPTest/FakeUnequipMontage', label: 'unequip animation path consumed' }, { path: 'structuredContent.result.equipAnimationLoaded', equals: false, label: 'missing equip animation handled without applying object reference' }, { path: 'structuredContent.result.unequipAnimationLoaded', equals: false, label: 'missing unequip animation handled without applying object reference' }] },
-
-  // === EFFECTS ===
-  { scenario: 'CONFIG: configure_muzzle_flash', toolName: 'manage_combat', arguments: { action: 'configure_muzzle_flash', blueprintPath: weaponPath, muzzleFlashParticlePath: '/Game/MCPTest/FakeMuzzleFlash', muzzleFlashScale: 1.5, muzzleSoundPath: '/Game/MCPTest/FakeMuzzleSound' }, expected: 'success', assertions: [{ path: 'structuredContent.result.particlePath', equals: '/Game/MCPTest/FakeMuzzleFlash', label: 'muzzle flash particle path applied' }, { path: 'structuredContent.result.soundPath', equals: '/Game/MCPTest/FakeMuzzleSound', label: 'muzzle sound path consumed' }, { path: 'structuredContent.result.scale', equals: 1.5, label: 'muzzle flash scale applied' }, { path: 'structuredContent.result.particleLoaded', equals: false, label: 'missing muzzle particle handled without object reference' }, { path: 'structuredContent.result.soundLoaded', equals: false, label: 'missing muzzle sound handled without object reference' }] },
-  { scenario: 'CONFIG: configure_tracer', toolName: 'manage_combat', arguments: { action: 'configure_tracer', blueprintPath: weaponPath, tracerParticlePath: '/Game/MCPTest/FakeTracerParticle', tracerSpeed: 15000 }, expected: 'success', assertions: [{ path: 'structuredContent.result.tracerPath', equals: '/Game/MCPTest/FakeTracerParticle', label: 'tracer particle path applied' }, { path: 'structuredContent.result.tracerSpeed', equals: 15000, label: 'tracer speed applied' }] },
-  { scenario: 'CONFIG: configure_impact_effects', toolName: 'manage_combat', arguments: { action: 'configure_impact_effects', blueprintPath: weaponPath, impactParticlePath: '/Game/MCPTest/FakeImpactParticle', impactSoundPath: '/Game/MCPTest/FakeImpactSound', impactDecalPath: '/Game/MCPTest/FakeImpactDecal' }, expected: 'success', assertions: [{ path: 'structuredContent.result.particlePath', equals: '/Game/MCPTest/FakeImpactParticle', label: 'impact particle path applied' }, { path: 'structuredContent.result.soundPath', equals: '/Game/MCPTest/FakeImpactSound', label: 'impact sound path applied' }, { path: 'structuredContent.result.decalPath', equals: '/Game/MCPTest/FakeImpactDecal', label: 'impact decal path applied' }] },
-  { scenario: 'CONFIG: configure_shell_ejection', toolName: 'manage_combat', arguments: { action: 'configure_shell_ejection', blueprintPath: weaponPath, shellMeshPath: '/Engine/BasicShapes/Cube.Cube', shellEjectionForce: 400, shellLifespan: 3 }, expected: 'success', assertions: [{ path: 'structuredContent.result.shellMeshPath', equals: '/Engine/BasicShapes/Cube.Cube', label: 'shell mesh path applied' }, { path: 'structuredContent.result.ejectionForce', equals: 400, label: 'shell ejection force applied' }] },
-
-  // === MELEE COMBAT ===
-  { scenario: 'CREATE: create_melee_trace', toolName: 'manage_combat', arguments: { action: 'create_melee_trace', blueprintPath: weaponPath, meleeTraceStartSocket: 'BladeBase', meleeTraceEndSocket: 'BladeTip', meleeTraceRadius: 16 }, expected: 'success', assertions: [{ path: 'structuredContent.result.traceRadius', equals: 16, label: 'melee trace radius applied' }] },
-  { scenario: 'CONFIG: configure_combo_system', toolName: 'manage_combat', arguments: { action: 'configure_combo_system', blueprintPath: weaponPath, comboWindowTime: 0.5, maxComboCount: 4 }, expected: 'success', assertions: [{ path: 'structuredContent.result.maxComboCount', equals: 4, label: 'max combo count applied' }] },
-  { scenario: 'CREATE: create_hit_pause', toolName: 'manage_combat', arguments: { action: 'create_hit_pause', blueprintPath: weaponPath, hitPauseDuration: 0.0625, hitPauseTimeDilation: 0.5 }, expected: 'success', assertions: [{ path: 'structuredContent.result.timeDilation', equals: 0.5, label: 'hit pause dilation applied' }] },
-  { scenario: 'CONFIG: configure_hit_reaction', toolName: 'manage_combat', arguments: { action: 'configure_hit_reaction', blueprintPath: weaponPath, hitReactionMontage: '/Game/MCPTest/FakeHitReactionMontage', hitReactionStunTime: 0.5 }, expected: 'success', assertions: [{ path: 'structuredContent.result.hitReactionMontage', equals: '/Game/MCPTest/FakeHitReactionMontage', label: 'hit reaction montage path applied' }, { path: 'structuredContent.result.stunTime', equals: 0.5, label: 'hit reaction stun time applied' }, { path: 'structuredContent.result.animationLoaded', equals: false, label: 'missing hit reaction montage handled without object reference' }] },
-  { scenario: 'ACTION: setup_parry_block_system', toolName: 'manage_combat', arguments: { action: 'setup_parry_block_system', blueprintPath: weaponPath, parryWindowStart: 0, parryWindowEnd: 0.25, parryAnimationPath: '/Game/MCPTest/FakeParryMontage', blockDamageReduction: 0.5, blockStaminaCost: 12 }, expected: 'success', assertions: [{ path: 'structuredContent.result.parryAnimationPath', equals: '/Game/MCPTest/FakeParryMontage', label: 'parry animation path consumed' }, { path: 'structuredContent.result.blockDamageReduction', equals: 0.5, label: 'block reduction applied' }, { path: 'structuredContent.result.parryAnimationLoaded', equals: false, label: 'missing parry animation handled without object reference' }] },
-  { scenario: 'CONFIG: configure_weapon_trails', toolName: 'manage_combat', arguments: { action: 'configure_weapon_trails', blueprintPath: weaponPath, weaponTrailParticlePath: '/Game/MCPTest/FakeWeaponTrail', weaponTrailStartSocket: 'TrailStart', weaponTrailEndSocket: 'TrailEnd' }, expected: 'success', assertions: [{ path: 'structuredContent.result.trailParticlePath', equals: '/Game/MCPTest/FakeWeaponTrail', label: 'weapon trail particle path applied' }, { path: 'structuredContent.result.trailStartSocket', equals: 'TrailStart', label: 'weapon trail start socket applied' }] },
-
-  // === INFO AND ALIASES ===
-  { scenario: 'INFO: get_combat_info', toolName: 'manage_combat', arguments: { action: 'get_combat_info', blueprintPath: weaponPath }, expected: 'success', assertions: [{ path: 'structuredContent.result.combatInfo.parentClass', equals: 'Actor', label: 'weapon parent class reported' }, { path: 'structuredContent.result.combatInfo.hasWeaponMesh', equals: true, label: 'weapon info sees mesh component' }, { path: 'structuredContent.result.combatInfo.components', length: 4, label: 'weapon info reports mesh, hitbox, and attachment components' }] },
-  { scenario: 'ACTION: setup_damage_type', toolName: 'manage_combat', arguments: { action: 'setup_damage_type', name: ALIAS_DAMAGE_TYPE_NAME, path: TEST_FOLDER }, expected: 'success', assertions: [{ path: 'structuredContent.result.damageTypePath', equals: `${TEST_FOLDER}/${ALIAS_DAMAGE_TYPE_NAME}.${ALIAS_DAMAGE_TYPE_NAME}`, label: 'setup_damage_type returns created path' }] },
-  { scenario: 'CONFIG: configure_hit_detection', toolName: 'manage_combat', arguments: { action: 'configure_hit_detection', blueprintPath: weaponPath, hitboxType: 'Sphere', damageMultiplier: 1.5 }, expected: 'success', assertions: [{ path: 'structuredContent.result.hitboxType', equals: 'Sphere', label: 'hit detection hitbox type applied' }] },
-  { scenario: 'INFO: get_combat_stats', toolName: 'manage_combat', arguments: { action: 'get_combat_stats', blueprintPath: weaponPath }, expected: 'success', assertions: [{ path: 'structuredContent.result.combatInfo.parentClass', equals: 'Actor', label: 'combat stats reports weapon parent class' }] },
-
-  // === DAMAGE EFFECTS AND DEFENSE ===
-  { scenario: 'CREATE: create_damage_effect', toolName: 'manage_combat', arguments: { action: 'create_damage_effect', name: DAMAGE_EFFECT_NAME, path: TEST_FOLDER, duration: 8, damagePerSecond: 15, effectType: 'DamageOverTime' }, expected: 'success', assertions: [{ path: 'structuredContent.result.duration', equals: 8, label: 'damage effect duration applied' }] },
-  { scenario: 'ACTION: apply_damage', toolName: 'manage_combat', arguments: { action: 'apply_damage', blueprintPath: weaponPath, damageAmount: 33, damageType: 'Fire' }, expected: 'success', assertions: [{ path: 'structuredContent.result.damageAmount', equals: 33, label: 'damage amount applied' }] },
-  { scenario: 'ACTION: heal', toolName: 'manage_combat', arguments: { action: 'heal', blueprintPath: weaponPath, healAmount: 25, maxHealth: 125 }, expected: 'success', assertions: [{ path: 'structuredContent.result.maxHealth', equals: 125, label: 'max health applied' }] },
-  { scenario: 'CREATE: create_shield', toolName: 'manage_combat', arguments: { action: 'create_shield', blueprintPath: weaponPath, shieldAmount: 60, maxShield: 120, shieldRegenRate: 6, shieldRegenDelay: 3 }, expected: 'success', assertions: [{ path: 'structuredContent.result.maxShield', equals: 120, label: 'max shield applied' }, { path: 'structuredContent.result.shieldRegenDelay', equals: 3, label: 'shield regen delay applied' }] },
-  { scenario: 'CONFIG: modify_armor', toolName: 'manage_combat', arguments: { action: 'modify_armor', blueprintPath: weaponPath, armorValue: 75, damageReduction: 0.25 }, expected: 'success', assertions: [{ path: 'structuredContent.result.armorValue', equals: 75, label: 'armor value applied' }] },
-
-  // === CLEANUP ===
-  { scenario: 'Cleanup: delete test actor', toolName: 'control_actor', arguments: { action: 'delete', actorName: TEST_ACTOR }, expected: 'success|not found' },
-  { scenario: 'Cleanup: delete test folder', toolName: 'manage_asset', arguments: { action: 'delete', path: TEST_FOLDER, force: true }, expected: 'success|not found' },
-];
-
-runToolTests('manage-combat', testCases);