unreal-engine-mcp-server 0.6.0-beta-e → 0.6.0

package/dist/tools/catalog/capabilities/records/gameplay/manage-ai/set-actions.data.js

@@ -1,203 +0,0 @@
-import { BT, aiRecord } from './builder.js';
-import { NAV } from './properties-navigation.js';
-import { AI } from './properties.js';
-const A = AI;
-const N = NAV;
-const OUT_STR = (d) => ({ type: 'string', description: d });
-const OUT_NUM = (d) => ({ type: 'number', description: d });
-const OUT_BOOL = (d) => ({ type: 'boolean', description: d });
-const OUT_STR_ARRAY = (d) => ({ type: 'array', items: { type: 'string' }, description: d });
-export const AI_SET_RECORDS = [
-    aiRecord({
-        action: 'rebuild_navigation', summary: 'Rebuild navigation for the loaded editor world.',
-        use: 'NavMesh geometry is stale after level or settings edits.',
-        avoid: 'Use configure_nav_mesh_settings to change generation parameters.',
-        props: {},
-        example: {}, result: 'Navigation rebuilt',
-    }),
-    aiRecord({
-        action: 'remove_node', summary: 'Remove a Behavior Tree graph node.',
-        use: 'A graph node must be deleted.',
-        avoid: 'Use break_connections to keep the node but detach it.',
-        props: { assetPath: A.assetPath, behaviorTreePath: A.behaviorTreePath, nodeId: A.nodeId },
-        requiredOneOf: ['assetPath', 'behaviorTreePath'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { assetPath: '/Game/AI/BT_Enemy', nodeId: 'Node_1' }, result: 'Node removed',
-    }),
-    aiRecord({
-        action: 'run_behavior_tree', summary: 'Author the run-on-start Behavior Tree of an AIController asset.',
-        use: 'A controller asset should start a Behavior Tree when it possesses a pawn.',
-        avoid: 'Use control_editor to start a PIE session; this edits the asset only.',
-        props: { controllerPath: A.controllerPath, behaviorTreePath: A.behaviorTreePath },
-        required: ['controllerPath', 'behaviorTreePath'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { controllerPath: '/Game/AI/AIC_Enemy', behaviorTreePath: '/Game/AI/BT_Enemy' },
-        result: 'Behavior Tree run configured',
-    }),
-    aiRecord({
-        action: 'set_blackboard_value', summary: 'Set a Blackboard key value on a Blackboard asset.',
-        use: 'A Blackboard key needs a different authored default.',
-        avoid: 'Use add_blackboard_key to create the key.',
-        props: {
-            blackboardPath: A.blackboardPath,
-            keyName: A.keyName, value: A.value,
-        },
-        required: ['blackboardPath', 'keyName'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { blackboardPath: '/Game/AI/BB_Enemy', keyName: 'TargetActor', value: 'true' },
-        result: 'Blackboard value set',
-    }),
-    aiRecord({
-        action: 'set_focus', summary: 'Author the focus target on an AIController asset.',
-        use: 'A controller asset should focus a named actor.',
-        avoid: 'Use clear_focus to remove the target.',
-        props: { controllerPath: A.controllerPath, focusActorName: A.focusActorName },
-        required: ['controllerPath'],
-        out: { assetPath: A.assetPath },
-        example: { controllerPath: '/Game/AI/AIC_Enemy', focusActorName: 'PlayerStart' },
-        result: 'Focus set',
-    }),
-    aiRecord({
-        action: 'set_key_instance_synced', summary: 'Set Blackboard key instance synchronization.',
-        use: 'A Blackboard key must share its value across instances.',
-        avoid: 'Use add_blackboard_key to create the key.',
-        props: {
-            blackboardPath: A.blackboardPath,
-            keyName: A.keyName, isInstanceSynced: A.isInstanceSynced,
-        },
-        required: ['blackboardPath', 'keyName'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { blackboardPath: '/Game/AI/BB_Enemy', keyName: 'TargetActor', isInstanceSynced: true },
-        result: 'Key sync set',
-    }),
-    aiRecord({
-        action: 'set_nav_agent_properties', summary: 'Set project navigation agent properties.',
-        use: 'The navigation agent dimensions must change.',
-        avoid: 'Use configure_nav_mesh_settings for generation tuning.',
-        props: {
-            agentRadius: N.agentRadius, agentHeight: N.agentHeight,
-            agentStepHeight: N.agentStepHeight, agentMaxSlope: N.agentMaxSlope,
-        },
-        example: { agentRadius: 35, agentHeight: 144 }, result: 'Nav agent properties set',
-    }),
-    aiRecord({
-        action: 'set_nav_area_class', summary: 'Set the navigation area class on a placed actor that already carries a NavModifierComponent (add one with create_nav_modifier first).',
-        use: 'A placed actor should carve a specific navigation area.',
-        avoid: 'Use configure_nav_area_cost to change the area cost itself.',
-        props: {
-            actorName: A.actorName, areaClass: N.areaClass,
-            componentName: { type: 'string', description: 'NavModifierComponent to retarget when the actor carries several; defaults to the first one.' },
-        },
-        required: ['actorName', 'areaClass'],
-        out: { actorName: A.actorName },
-        example: { actorName: 'NavTestActor', areaClass: '/Script/NavigationSystem.NavArea_Obstacle' },
-        result: 'Nav area class set',
-    }),
-    aiRecord({
-        action: 'set_nav_link_type', summary: 'Set an authored navigation link type.',
-        use: 'A link must switch between the simple and smart form.',
-        avoid: 'Use configure_smart_link_behavior to tune a smart link.',
-        props: { actorName: A.actorName, linkType: N.linkType },
-        required: ['actorName'],
-        out: { actorName: A.actorName },
-        example: { actorName: 'NavLinkProxy_0', linkType: 'smart' }, result: 'Nav link type set',
-    }),
-    aiRecord({
-        action: 'set_node_properties', summary: 'Set Behavior Tree graph node properties.',
-        use: 'A graph node needs property or comment edits.',
-        avoid: 'Use configure_bt_node for the asset-level route.',
-        props: {
-            assetPath: A.assetPath, behaviorTreePath: A.behaviorTreePath, nodeId: A.nodeId,
-            comment: A.comment, properties: A.properties,
-        },
-        requiredOneOf: ['assetPath', 'behaviorTreePath'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { assetPath: '/Game/AI/BT_Enemy', nodeId: 'Node_1', properties: { WaitTime: 1 } },
-        result: 'Node properties set',
-    }),
-    aiRecord({
-        action: 'set_perception_team', summary: 'Set perception team data on a Blueprint asset.',
-        use: 'An AI must belong to a specific perception team.',
-        avoid: 'Use configure_sight_config for sense tuning.',
-        props: { blueprintPath: A.blueprintPath, teamId: A.teamId },
-        required: ['blueprintPath'],
-        out: { blueprintPath: A.blueprintPath },
-        example: { blueprintPath: '/Game/AI/BP_Enemy', teamId: 2 }, result: 'Perception team set',
-    }),
-    aiRecord({
-        action: 'setup_perception', summary: 'Set up AI perception on a Blueprint asset.',
-        use: 'A Blueprint needs perception added and several senses tuned at once.',
-        avoid: 'Use the individual configure_*_config actions for one sense.',
-        props: {
-            blueprintPath: A.blueprintPath,
-            enableSight: A.enableSight, enableHearing: A.enableHearing, enableDamage: A.enableDamage,
-            sightRadius: A.sightRadius, loseSightRadius: A.loseSightRadius,
-            peripheralVisionAngle: A.peripheralVisionAngle, hearingRange: A.hearingRange,
-            dominantSense: A.dominantSense,
-        },
-        required: ['blueprintPath'],
-        out: { blueprintPath: A.blueprintPath },
-        example: { blueprintPath: '/Game/AI/BP_Enemy', enableSight: true, dominantSense: 'Sight' },
-        result: 'Perception set up',
-    }),
-    aiRecord({
-        action: 'stop_behavior_tree', summary: 'Clear the run-on-start Behavior Tree of an AIController asset.',
-        use: 'A controller asset should no longer start a Behavior Tree.',
-        avoid: 'Use control_editor to stop a PIE session; this edits the asset only.',
-        props: { controllerPath: A.controllerPath },
-        required: ['controllerPath'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { controllerPath: '/Game/AI/AIC_Enemy' }, result: 'Behavior Tree run cleared',
-    }),
-    aiRecord({
-        action: 'set_ai_perception',
-        summary: 'Configure the sight and hearing senses of an AIController perception component.',
-        use: 'One call should add the perception component and set its senses together.',
-        avoid: 'Only one sense needs tuning; configure_sight_config and configure_hearing_config edit them separately.',
-        props: {
-            controllerPath: A.controllerPath,
-            enableSight: A.enableSight, sightRadius: A.sightRadius, loseSightRadius: A.loseSightRadius,
-            peripheralVisionAngle: A.peripheralVisionAngle, enableHearing: A.enableHearing,
-            hearingRange: A.hearingRange, enableDamage: A.enableDamage, dominantSense: A.dominantSense,
-        },
-        required: ['controllerPath'],
-        out: {
-            controllerPath: A.controllerPath,
-            createdNew: OUT_BOOL('Whether the perception component was added by this call.'),
-            sensesConfigured: OUT_STR_ARRAY('Names of the senses this call configured.'),
-            dominantSense: OUT_STR('Sense the component treats as dominant.'),
-        },
-        example: { controllerPath: '/Game/AI/AIC_Enemy', enableSight: true, sightRadius: 2500, peripheralVisionAngle: 75 },
-        result: 'AI perception configured',
-    }),
-    aiRecord({
-        action: 'set_ai_movement',
-        summary: 'Set the movement limits on the CharacterMovement component of a Blueprint.',
-        use: 'Walk speed, acceleration, braking or rotation rate must change on a pawn asset.',
-        avoid: 'The pawn has no CharacterMovement component; the call reports the missing component instead.',
-        props: {
-            blueprintPath: A.blueprintPath,
-            maxWalkSpeed: A.maxWalkSpeed, maxAcceleration: A.maxAcceleration,
-            brakingDeceleration: A.brakingDeceleration, rotationRate: A.rotationRate,
-            useAccelerationForPaths: { type: 'boolean', description: 'Path following uses acceleration instead of setting velocity directly; left unchanged when omitted.' },
-            orientRotationToMovement: { type: 'boolean', description: 'Rotate the pawn toward its movement direction; left unchanged when omitted.' },
-            useRVOAvoidance: { type: 'boolean', description: 'Enable RVO avoidance; left unchanged when omitted.' },
-            avoidanceWeight: { type: 'number', description: 'RVO avoidance weight (0 or more); left unchanged when omitted.' },
-            maxFlySpeed: { type: 'number', description: 'Maximum flying speed; left unchanged when omitted.' },
-            jumpZVelocity: { type: 'number', description: 'Initial upward jump velocity; left unchanged when omitted.' },
-        },
-        required: ['blueprintPath'],
-        out: {
-            blueprintPath: A.blueprintPath,
-            propertiesSet: OUT_STR_ARRAY('Names of the movement properties this call changed.'),
-            propertyCount: OUT_NUM('How many movement properties were changed.'),
-            maxWalkSpeed: A.maxWalkSpeed, maxAcceleration: A.maxAcceleration,
-            rotationRateYaw: OUT_NUM('Yaw component of the resulting rotation rate.'),
-            orientRotationToMovement: OUT_BOOL('Whether the component orients rotation to movement.'),
-            useRVOAvoidance: OUT_BOOL('Whether RVO avoidance is enabled on the component.'),
-        },
-        example: { blueprintPath: '/Game/AI/BP_Enemy', maxWalkSpeed: 450, rotationRate: 360 },
-        result: 'AI movement configured',
-    }),
-];
-//# sourceMappingURL=set-actions.data.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-character/character-1.data.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../../model.js';
-export declare const CHARACTER_1: readonly CapabilityRecordSource[];
-//# sourceMappingURL=character-1.data.d.ts.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-character/character-1.data.js

@@ -1,81 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { P } from '../properties.js';
-import { CHARACTER_P as C } from './character.props.js';
-const T = 'manage_character';
-const F = 'character';
-const W = ['A character Blueprint or its movement must be authored.'];
-export const CHARACTER_1 = [
-    buildRecord({ parentTool: T, id: `${T}.create_character_blueprint`, action: 'create_character_blueprint', family: F,
-        topics: ['character blueprint', 'player character', 'new character', 'pawn', 'third person character'],
-        summary: 'Create a Character Blueprint asset.', whenToUse: W, whenNotToUse: ['A Pawn suffices.'],
-        inputProps: { name: P.name, path: P.path, parentClass: { type: 'string', description: 'Character class to derive from (default Character): a native Character subclass or a Character Blueprint path.' }, skeletalMeshPath: P.skeletalMeshPath }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        outputProps: { blueprintPath: P.blueprintPath }, outputRequired: ['blueprintPath'],
-        exampleInput: { action: 'create_character_blueprint', name: 'BP_Char', parentClass: 'Character' }, exampleOutput: { success: true, message: 'Character Blueprint created', blueprintPath: '/Game/BP_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_capsule_component`, action: 'configure_capsule_component', family: F,
-        summary: 'Configure the capsule collision component; only the sizes sent change.', whenToUse: ['Capsule size must change.'], whenNotToUse: ['Use configure_mesh_component.'],
-        inputProps: { blueprintPath: P.blueprintPath, capsuleRadius: C.capsuleRadius, capsuleHalfHeight: C.capsuleHalfHeight }, required: ['blueprintPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_capsule_component', blueprintPath: '/Game/BP_Char', capsuleRadius: 42, capsuleHalfHeight: 96 } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_mesh_component`, action: 'configure_mesh_component', family: F,
-        summary: 'Configure the skeletal mesh component.', whenToUse: ['Mesh must change.'], whenNotToUse: ['Use configure_capsule_component.'],
-        inputProps: { blueprintPath: P.blueprintPath, skeletalMeshPath: P.skeletalMeshPath, animBlueprintPath: C.animBlueprintPath, meshOffset: C.meshOffset, meshRotation: C.meshRotation }, required: ['blueprintPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_mesh_component', blueprintPath: '/Game/BP_Char', skeletalMeshPath: '/Game/SM_Char', meshOffset: { x: 0, y: 0, z: -96 } } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_camera_component`, action: 'configure_camera_component', family: F,
-        summary: 'Configure the camera spring arm, creating a boom and camera when missing; an existing boom changes only in the fields sent.', whenToUse: ['Camera setup needed.'], whenNotToUse: ['Use configure_mesh_component.'],
-        inputProps: { blueprintPath: P.blueprintPath, springArmLength: C.springArmLength, springArmLagEnabled: C.springArmLagEnabled, springArmLagSpeed: C.springArmLagSpeed, cameraUsePawnControlRotation: C.cameraUsePawnControlRotation }, required: ['blueprintPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_camera_component', blueprintPath: '/Game/BP_Char', springArmLength: 300, cameraUsePawnControlRotation: true } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_movement_speeds`, action: 'configure_movement_speeds', family: F,
-        summary: 'Configure walk/run/sprint speeds.', whenToUse: ['Speeds must change.'], whenNotToUse: ['Use set_walk_speed.'],
-        inputProps: { blueprintPath: P.blueprintPath, walkSpeed: C.walkSpeed, runSpeed: C.runSpeed, crouchSpeed: C.crouchSpeed, swimSpeed: C.swimSpeed, flySpeed: C.flySpeed, acceleration: C.acceleration, deceleration: C.deceleration, groundFriction: C.groundFriction, jumpHeight: C.jumpHeight, jumpHoldTime: C.jumpHoldTime, maxJumpCount: C.maxJumpCount, airControl: C.airControl, gravityScale: C.gravityScale, fallingLateralFriction: C.fallingLateralFriction }, required: ['blueprintPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_movement_speeds', blueprintPath: '/Game/BP_Char', walkSpeed: 600, crouchSpeed: 300 } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_jump`, action: 'configure_jump', family: F,
-        summary: 'Configure jump height, hold time, multi-jump, air control and gravity.', whenToUse: ['Jump must change.'], whenNotToUse: ['Use set_jump_height.'],
-        inputProps: { blueprintPath: P.blueprintPath, jumpHeight: C.jumpHeight, jumpHoldTime: C.jumpHoldTime, maxJumpCount: C.maxJumpCount, airControl: C.airControl, gravityScale: C.gravityScale, fallingLateralFriction: C.fallingLateralFriction }, required: ['blueprintPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_jump', blueprintPath: '/Game/BP_Char', jumpHeight: 600, maxJumpCount: 2 } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_rotation`, action: 'configure_rotation', family: F,
-        summary: 'Configure rotation / use-controller-rotation flags.', whenToUse: ['Rotation policy must change.'], whenNotToUse: ['Use configure_movement_speeds.'],
-        inputProps: { blueprintPath: P.blueprintPath, orientToMovement: C.orientToMovement, rotationRate: C.rotationRate, useControllerRotationYaw: C.useControllerRotationYaw, useControllerRotationPitch: C.useControllerRotationPitch, useControllerRotationRoll: C.useControllerRotationRoll }, required: ['blueprintPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_rotation', blueprintPath: '/Game/BP_Char', orientToMovement: true, rotationRate: 540 } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_nav_movement`, action: 'configure_nav_movement', family: F,
-        summary: 'Configure AI-navigation movement on the character.', whenToUse: ['AI movement needed.'], whenNotToUse: ['Use configure_movement_speeds.'],
-        inputProps: { blueprintPath: P.blueprintPath, navAgentRadius: C.navAgentRadius, navAgentHeight: C.navAgentHeight, avoidanceEnabled: C.avoidanceEnabled }, required: ['blueprintPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_nav_movement', blueprintPath: '/Game/BP_Char', navAgentRadius: 42, avoidanceEnabled: true } }),
-    buildRecord({ parentTool: T, id: `${T}.setup_movement`, action: 'setup_movement', family: F,
-        summary: 'Set up the base character movement component.', whenToUse: ['Movement component must initialize.'], whenNotToUse: ['Use configure_movement_speeds.'],
-        inputProps: { blueprintPath: P.blueprintPath, walkSpeed: C.walkSpeed, runSpeed: C.runSpeed, acceleration: C.acceleration }, required: ['blueprintPath'],
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        exampleInput: { action: 'setup_movement', blueprintPath: '/Game/BP_Char', walkSpeed: 600, acceleration: 2048 } }),
-    buildRecord({ parentTool: T, id: `${T}.set_walk_speed`, action: 'set_walk_speed', family: F,
-        summary: 'Set the character walk speed (authoring).', whenToUse: ['Walk speed must change.'], whenNotToUse: ['Use configure_movement_speeds.'],
-        inputProps: { blueprintPath: P.blueprintPath, walkSpeed: C.walkSpeed }, required: ['blueprintPath', 'walkSpeed'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'set_walk_speed', blueprintPath: '/Game/BP_Char', walkSpeed: 300 } }),
-    buildRecord({ parentTool: T, id: `${T}.set_jump_height`, action: 'set_jump_height', family: F,
-        summary: 'Set the character jump height (authoring).', whenToUse: ['Jump height must change.'], whenNotToUse: ['Use configure_jump.'],
-        inputProps: { blueprintPath: P.blueprintPath, jumpHeight: C.jumpHeight }, required: ['blueprintPath', 'jumpHeight'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'set_jump_height', blueprintPath: '/Game/BP_Char', jumpHeight: 600 } }),
-    buildRecord({ parentTool: T, id: `${T}.set_gravity_scale`, action: 'set_gravity_scale', family: F,
-        summary: 'Set gravity scale (authoring).', whenToUse: ['Gravity must change.'], whenNotToUse: ['Use set_walk_speed.'],
-        inputProps: { blueprintPath: P.blueprintPath, gravityScale: C.gravityScale }, required: ['blueprintPath', 'gravityScale'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'set_gravity_scale', blueprintPath: '/Game/BP_Char', gravityScale: 1 } }),
-    buildRecord({ parentTool: T, id: `${T}.set_ground_friction`, action: 'set_ground_friction', family: F,
-        summary: 'Set ground friction (authoring).', whenToUse: ['Friction must change.'], whenNotToUse: ['Use set_braking_deceleration.'],
-        inputProps: { blueprintPath: P.blueprintPath, groundFriction: C.groundFriction }, required: ['blueprintPath', 'groundFriction'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'set_ground_friction', blueprintPath: '/Game/BP_Char', groundFriction: 8 } }),
-    buildRecord({ parentTool: T, id: `${T}.set_braking_deceleration`, action: 'set_braking_deceleration', family: F,
-        summary: 'Set braking deceleration (authoring).', whenToUse: ['Decel must change.'], whenNotToUse: ['Use set_ground_friction.'],
-        inputProps: { blueprintPath: P.blueprintPath, brakingDeceleration: C.brakingDeceleration }, required: ['blueprintPath', 'brakingDeceleration'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'set_braking_deceleration', blueprintPath: '/Game/BP_Char', brakingDeceleration: 2048 } }),
-];
-//# sourceMappingURL=character-1.data.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-character/character-2.data.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../../model.js';
-export declare const CHARACTER_2: readonly CapabilityRecordSource[];
-//# sourceMappingURL=character-2.data.d.ts.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-character/character-2.data.js

@@ -1,46 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { P } from '../properties.js';
-import { CHARACTER_P as C } from './character.props.js';
-const T = 'manage_character';
-const F = 'character';
-export const CHARACTER_2 = [
-    buildRecord({ parentTool: T, id: `${T}.get_character_info`, action: 'get_character_info', family: F,
-        topics: ['movement settings', 'walk speed', 'jump velocity', 'capsule size'],
-        summary: 'Read a character Blueprint\'s defaults: capsule size, walk speed, jump velocity and count, air control, gravity scale, spring arm and camera settings, and the live player view state in PIE.',
-        whenToUse: ['A character\'s movement, capsule or camera defaults must be read before tuning them.'], whenNotToUse: ['Mutate the character.'],
-        inputProps: { blueprintPath: P.blueprintPath }, required: ['blueprintPath'],
-        effect: 'read', latency: 'instant', resources: 'low',
-        outputProps: {
-            blueprintPath: P.blueprintPath,
-            assetName: P.string_,
-            capsuleRadius: P.num_,
-            capsuleHalfHeight: P.num_,
-            walkSpeed: P.num_,
-            jumpZVelocity: P.num_,
-            airControl: P.num_,
-            orientToMovement: P.bool_,
-            gravityScale: P.num_,
-            maxJumpCount: P.num_,
-            useControllerRotationYaw: P.bool_,
-            hasSpringArm: P.bool_,
-            hasCamera: P.bool_,
-            playerViewState: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Player camera/view state.' },
-            customMovementSpeed: P.num_,
-            targetArmLength: P.num_,
-            usePawnControlRotation: P.bool_,
-            enableCameraLag: P.bool_,
-            cameraLagSpeed: P.num_,
-            fieldOfView: P.num_,
-            springArmTemplates: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Spring-arm component templates found on the Blueprint.' },
-            cameraTemplates: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Camera component templates found on the Blueprint.' },
-            movementVariables: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'CharacterMovement values read from the Blueprint CDO.' },
-        }, outputRequired: [],
-        exampleInput: { action: 'get_character_info', blueprintPath: '/Game/BP_Char' },
-        exampleOutput: { success: true, message: 'Character info', blueprintPath: '/Game/BP_Char', capsuleRadius: 42, hasSpringArm: true } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_crouch`, action: 'configure_crouch', family: F,
-        summary: 'Configure crouch height, speed and whether crouching is allowed; only the fields sent change.', whenToUse: ['Crouch needed.'], whenNotToUse: ['Use configure_sprint.'],
-        inputProps: { blueprintPath: P.blueprintPath, canCrouch: C.canCrouch, crouchSpeed: C.crouchSpeed, crouchedHalfHeight: C.crouchedHalfHeight }, required: ['blueprintPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_crouch', blueprintPath: '/Game/BP_Char', canCrouch: true, crouchSpeed: 300 } }),
-];
-//# sourceMappingURL=character-2.data.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-character/character-3.data.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../../model.js';
-export declare const CHARACTER_3: readonly CapabilityRecordSource[];
-//# sourceMappingURL=character-3.data.d.ts.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-character/character-3.data.js

@@ -1,73 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { P } from '../properties.js';
-import { CHARACTER_P as C } from './character.props.js';
-const T = 'manage_character';
-const F = 'metahuman';
-export const CHARACTER_3 = [
-    buildRecord({ parentTool: T, id: `${T}.metahuman_status`, action: 'metahuman_status', family: F,
-        topics: ['metahuman', 'digital human', 'realistic character', 'metahuman ready', 'core data'],
-        summary: 'Report MetaHuman readiness: plugin present, Core Data installed, and whether a character is rigged and buildable.',
-        whenToUse: ['Before authoring or assembling a MetaHuman, to see every blocker at once.'],
-        whenNotToUse: ['Use get_character_info for a gameplay Character Blueprint.'],
-        inputProps: { characterPath: C.characterPath }, required: [],
-        effect: 'read', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        outputProps: { pluginAvailable: { type: 'boolean', description: 'MetaHuman Creator is loaded on this editor.' },
-            coreDataInstalled: { type: 'boolean', description: 'MetaHuman Creator Core Data is installed next to the engine.' },
-            ready: { type: 'boolean', description: 'No blockers remain.' },
-            blockers: { type: 'array', items: { type: 'string' }, description: 'Every unmet prerequisite, each phrased as an action to take.' } },
-        outputRequired: ['pluginAvailable', 'coreDataInstalled', 'ready', 'blockers'],
-        exampleInput: { action: 'metahuman_status', characterPath: '/Game/MetaHumans/MH_Neo' },
-        exampleOutput: { success: true, message: 'MetaHuman has 1 blocker(s).', pluginAvailable: true, coreDataInstalled: false, ready: false, blockers: ['MetaHuman Creator Core Data is not installed'] } }),
-    buildRecord({ parentTool: T, id: `${T}.create_metahuman`, action: 'create_metahuman', family: F,
-        topics: ['metahuman', 'create metahuman', 'digital human', 'photoreal character'],
-        summary: 'Create a MetaHuman Character asset.',
-        whenToUse: ['A photoreal human is needed and MetaHuman Creator is available.'],
-        whenNotToUse: ['Use create_character_blueprint for a gameplay pawn.'],
-        inputProps: { name: P.name, path: P.path }, required: ['name'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'medium',
-        outputProps: { characterPath: C.characterPath, created: { type: 'boolean', description: 'False when the asset already existed.' } },
-        outputRequired: ['characterPath', 'created'],
-        exampleInput: { action: 'create_metahuman', name: 'MH_Neo', path: '/Game/MetaHumans' },
-        exampleOutput: { success: true, message: 'MetaHuman character created', characterPath: '/Game/MetaHumans/MH_Neo', created: true } }),
-    buildRecord({ parentTool: T, id: `${T}.rig_metahuman`, action: 'rig_metahuman', family: F,
-        topics: ['metahuman', 'auto rig', 'face rig', 'rig character'],
-        summary: 'Auto-rig a MetaHuman character so it can be assembled. Runs on an Epic cloud service.',
-        whenToUse: ['A MetaHuman must be rigged before build_metahuman will accept it.'],
-        whenNotToUse: ['The character is already rigged; check metahuman_status first.'],
-        inputProps: { characterPath: C.characterPath, rigType: C.rigType, blocking: C.blocking, reportProgress: C.reportProgress },
-        required: ['characterPath'],
-        effect: 'write', behavior: { longRunning: true }, latency: 'long-running', resources: 'high',
-        outputProps: { characterPath: C.characterPath, canBuild: { type: 'boolean', description: 'Whether the character is now buildable.' } },
-        outputRequired: ['characterPath', 'canBuild'],
-        exampleInput: { action: 'rig_metahuman', characterPath: '/Game/MetaHumans/MH_Neo', rigType: 'JointsAndBlendShapes' },
-        exampleOutput: { success: true, message: 'MetaHuman rigged', characterPath: '/Game/MetaHumans/MH_Neo', canBuild: true } }),
-    buildRecord({ parentTool: T, id: `${T}.build_metahuman`, action: 'build_metahuman', family: F,
-        topics: ['metahuman', 'assemble metahuman', 'build metahuman', 'cinematic character'],
-        summary: 'Run the MetaHuman assembly pipeline, producing the usable character assets.',
-        whenToUse: ['A rigged MetaHuman must be turned into meshes, materials and a Blueprint.'],
-        whenNotToUse: ['The character is not rigged yet; run rig_metahuman.'],
-        inputProps: { characterPath: C.characterPath, pipelineType: C.pipelineType, pipelineQuality: C.pipelineQuality,
-            buildPath: C.buildPath, commonFolderPath: C.commonFolderPath, nameOverride: C.nameOverride },
-        required: ['characterPath'],
-        effect: 'write', behavior: { longRunning: true }, latency: 'long-running', resources: 'high',
-        outputProps: { characterPath: C.characterPath, pipelineType: C.pipelineType },
-        outputRequired: ['characterPath'],
-        exampleInput: { action: 'build_metahuman', characterPath: '/Game/MetaHumans/MH_Neo', pipelineType: 'Cinematic', buildPath: '/Game/MetaHumans' },
-        exampleOutput: { success: true, message: 'MetaHuman assembled', characterPath: '/Game/MetaHumans/MH_Neo', pipelineType: 'Cinematic' } }),
-    buildRecord({ parentTool: T, id: `${T}.export_metahuman`, action: 'export_metahuman', family: F,
-        topics: ['metahuman', 'export metahuman', 'export skeletal mesh', 'export dna'],
-        summary: 'Export a MetaHuman as skeletal meshes, material instances, or DNA assets.',
-        whenToUse: ['The assembled character must become standalone assets for a shot or a DCC round-trip.'],
-        whenNotToUse: ['Use build_metahuman to assemble it in the first place.'],
-        inputProps: { characterPath: C.characterPath, exportType: C.exportType, projectPath: C.projectPath,
-            externalPath: C.externalPath, headMesh: C.headMesh, bodyMesh: C.bodyMesh, fullBodyMesh: C.fullBodyMesh,
-            dnaHead: C.dnaHead, dnaBody: C.dnaBody, applyAsOverrides: C.applyAsOverrides, overwrite: C.overwrite },
-        required: ['characterPath'],
-        effect: 'write', behavior: { longRunning: true }, latency: 'long-running', resources: 'high',
-        outputProps: { characterPath: C.characterPath, exportType: C.exportType, projectPath: C.projectPath,
-            assetsCreated: { type: 'number', description: 'Assets that appeared under projectPath. Zero means the export wrote nothing.' } },
-        outputRequired: ['characterPath', 'exportType'],
-        exampleInput: { action: 'export_metahuman', characterPath: '/Game/MetaHumans/MH_Neo', exportType: 'geometry', projectPath: '/Game/MetaHumans/Exported' },
-        exampleOutput: { success: true, message: 'MetaHuman geometry exported', characterPath: '/Game/MetaHumans/MH_Neo', exportType: 'geometry', projectPath: '/Game/MetaHumans/Exported', assetsCreated: 2 } }),
-];
-//# sourceMappingURL=character-3.data.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-character/character.props.d.ts

@@ -1,3 +0,0 @@
-import type { PropertyMap } from '../properties.js';
-export declare const CHARACTER_P: PropertyMap;
-//# sourceMappingURL=character.props.d.ts.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-character/character.props.js

@@ -1,83 +0,0 @@
-import { str, num, bool } from '../../shared/schema-props.js';
-export const CHARACTER_P = {
-    capsuleRadius: num('Capsule collision radius in world units.'),
-    capsuleHalfHeight: num('Capsule collision half-height in world units.'),
-    animBlueprintPath: str('Canonical /Game Animation Blueprint asset path.'),
-    meshOffset: {
-        type: 'object',
-        description: 'Mesh relative location offset.',
-        properties: { x: { type: 'number' }, y: { type: 'number' }, z: { type: 'number' } },
-        additionalProperties: false,
-    },
-    meshRotation: {
-        type: 'object',
-        description: 'Mesh relative rotation in degrees.',
-        properties: { pitch: { type: 'number' }, yaw: { type: 'number' }, roll: { type: 'number' } },
-        additionalProperties: false,
-    },
-    springArmLength: num('Spring-arm target arm length.'),
-    springArmLagEnabled: bool('Whether spring-arm camera lag is enabled.'),
-    springArmLagSpeed: num('Spring-arm camera lag speed.'),
-    cameraUsePawnControlRotation: bool('Whether the spring arm follows the controller look rotation. The camera under it is always arm-relative.'),
-    walkSpeed: num('Maximum walk speed.'),
-    runSpeed: num('Run speed; ignored when walkSpeed is also supplied.'),
-    crouchSpeed: num('Maximum walk speed while crouched.'),
-    swimSpeed: num('Maximum swim speed.'),
-    flySpeed: num('Maximum fly speed.'),
-    acceleration: num('Maximum acceleration.'),
-    deceleration: num('Walking deceleration.'),
-    brakingDeceleration: num('Braking deceleration while walking.'),
-    groundFriction: num('Ground friction.'),
-    jumpHeight: num('Jump z-velocity.'),
-    jumpHoldTime: num('Maximum jump hold time in seconds.'),
-    maxJumpCount: num('Maximum number of jumps.'),
-    airControl: num('Air control fraction (0-1).'),
-    gravityScale: num('Gravity scale multiplier.'),
-    fallingLateralFriction: num('Lateral friction while falling.'),
-    orientToMovement: bool('Whether the character orients rotation to movement.'),
-    useControllerRotationYaw: bool('Whether controller yaw drives actor rotation.'),
-    useControllerRotationPitch: bool('Whether controller pitch drives actor rotation.'),
-    useControllerRotationRoll: bool('Whether controller roll drives actor rotation.'),
-    rotationRate: num('Rotation rate in degrees per second.'),
-    navAgentRadius: num('Nav agent radius.'),
-    navAgentHeight: num('Nav agent height.'),
-    avoidanceEnabled: bool('Whether RVO avoidance is enabled.'),
-    canCrouch: bool('Whether the character is allowed to crouch.'),
-    crouchedHalfHeight: num('Capsule half-height while crouched.'),
-    characterPath: str('Canonical /Game path of a MetaHuman Character asset.'),
-    rigType: {
-        type: 'string',
-        description: 'Face rig detail to request. JointsAndBlendShapes is required for facial animation.',
-        enum: ['JointsOnly', 'JointsAndBlendShapes'],
-    },
-    blocking: bool('Wait for auto-rigging to finish before answering. Default false: the request is queued on the Epic cloud service and metahuman_status reports canBuild once it lands. True parks the editor until the service answers.'),
-    reportProgress: bool('Emit editor progress notifications during auto-rigging. Default false.'),
-    pipelineType: {
-        type: 'string',
-        description: 'Assembly pipeline. Cinematic is the film-quality path; Optimized and UEFN trade fidelity for runtime cost.',
-        enum: ['Cinematic', 'Optimized', 'UEFN'],
-    },
-    pipelineQuality: {
-        type: 'string',
-        description: 'Quality level. Only meaningful when pipelineType is Optimized or UEFN.',
-        enum: ['Low', 'Medium', 'High', 'Cinematic'],
-    },
-    buildPath: str('Content folder for the assembled assets. Defaults to the palette setting.'),
-    commonFolderPath: str('Content folder for shared MetaHuman assets.'),
-    nameOverride: str('Folder name for the assembled character instead of the asset name.'),
-    exportType: {
-        type: 'string',
-        description: 'Which artifact to export: skeletal meshes, material instances, or DNA.',
-        enum: ['geometry', 'materials', 'dna'],
-    },
-    projectPath: str('Content folder receiving the exported assets.'),
-    externalPath: str('Folder on disk for exported .dna files. DNA export only.'),
-    headMesh: bool('Export the head skeletal mesh. Default true.'),
-    bodyMesh: bool('Export the body skeletal mesh. Default true.'),
-    fullBodyMesh: bool('Export a combined full-body skeletal mesh. Default false.'),
-    dnaHead: bool('Export head DNA. Default true.'),
-    dnaBody: bool('Export body DNA. Default true.'),
-    applyAsOverrides: bool('Apply exported materials back onto the character as overrides. Default true.'),
-    overwrite: bool('Overwrite existing assets instead of creating uniquely-named ones. Default true.'),
-};
-//# sourceMappingURL=character.props.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-character/index.d.ts

@@ -1,4 +0,0 @@
-import type { CapabilityRecordSource } from '../../../model.js';
-export declare const MANAGE_CHARACTER_UNFOLDED_SOURCES: readonly CapabilityRecordSource[];
-export declare const MANAGE_CHARACTER_SOURCES: readonly CapabilityRecordSource[];
-//# sourceMappingURL=index.d.ts.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-character/index.js

@@ -1,12 +0,0 @@
-import { CHARACTER_1 } from './character-1.data.js';
-import { CHARACTER_2 } from './character-2.data.js';
-import { CHARACTER_3 } from './character-3.data.js';
-import { applyFolds } from '../../shared/fold.js';
-import { MANAGE_CHARACTER_FOLDS } from '../../folds/manage-character.folds.js';
-export const MANAGE_CHARACTER_UNFOLDED_SOURCES = [
-    ...CHARACTER_1,
-    ...CHARACTER_2,
-    ...CHARACTER_3,
-];
-export const MANAGE_CHARACTER_SOURCES = applyFolds(MANAGE_CHARACTER_UNFOLDED_SOURCES, MANAGE_CHARACTER_FOLDS, 'manage_character');
-//# sourceMappingURL=index.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-combat/combat-properties.d.ts

@@ -1,88 +0,0 @@
-import type { JsonObject } from '../../../model.js';
-export declare const C: {
-    baseDamage: JsonObject;
-    fireRate: JsonObject;
-    range: JsonObject;
-    spread: JsonObject;
-    weaponMeshPath: JsonObject;
-    projectileClass: JsonObject;
-    projectileSpeed: JsonObject;
-    projectileGravityScale: JsonObject;
-    projectileLifespan: JsonObject;
-    projectileMeshPath: JsonObject;
-    collisionRadius: JsonObject;
-    bounceEnabled: JsonObject;
-    bounceVelocityRatio: JsonObject;
-    homingEnabled: JsonObject;
-    homingAcceleration: JsonObject;
-    hitboxBoneName: JsonObject;
-    hitboxType: JsonObject;
-    hitboxSize: {
-        type: string;
-        description: string;
-        additionalProperties: false;
-        properties: {
-            radius: {
-                type: string;
-                description: string;
-            };
-            halfHeight: {
-                type: string;
-                description: string;
-            };
-            extent: {
-                type: string;
-                description: string;
-                additionalProperties: false;
-                properties: {
-                    x: {
-                        type: string;
-                        description: string;
-                    };
-                    y: {
-                        type: string;
-                        description: string;
-                    };
-                    z: {
-                        type: string;
-                        description: string;
-                    };
-                };
-            };
-        };
-    };
-    isDamageZoneHead: JsonObject;
-    damageMultiplier: JsonObject;
-    attachmentSlots: {
-        type: string;
-        description: string;
-        items: {
-            type: string;
-            additionalProperties: false;
-            properties: {
-                slotName: {
-                    type: string;
-                    description: string;
-                };
-                socketName: {
-                    type: string;
-                    description: string;
-                };
-                allowedTypes: {
-                    type: string;
-                    items: {
-                        type: string;
-                    };
-                    description: string;
-                };
-            };
-        };
-    };
-    combatInfo: {
-        type: string;
-        description: string;
-        additionalProperties: true;
-        'x-unreal-reflection-boundary': true;
-    };
-};
-//# sourceMappingURL=combat-properties.d.ts.map