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

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

@@ -1,70 +0,0 @@
-import { str, num, bool } from '../../shared/schema-props.js';
-const choice = (values, description) => ({
-    type: 'string',
-    enum: [...values],
-    description,
-});
-export const C = {
-    baseDamage: num('Base damage per shot.'),
-    fireRate: num('Rate of fire in rounds per minute.'),
-    range: num('Effective weapon range in world units.'),
-    spread: num('Base spread cone in degrees.'),
-    weaponMeshPath: str('Canonical /Game weapon static or skeletal mesh path.'),
-    projectileClass: str('Class path of the projectile the weapon spawns.'),
-    projectileSpeed: num('Projectile launch/travel speed.'),
-    projectileGravityScale: num('Gravity scale applied to the projectile.'),
-    projectileLifespan: num('Projectile lifetime in seconds.'),
-    projectileMeshPath: str('Canonical /Game projectile mesh path.'),
-    collisionRadius: num('Projectile collision sphere radius.'),
-    bounceEnabled: bool('Enable projectile bouncing on impact.'),
-    bounceVelocityRatio: num('Fraction of velocity retained on bounce (0-1).'),
-    homingEnabled: bool('Enable homing behaviour.'),
-    homingAcceleration: num('Homing turn acceleration.'),
-    hitboxBoneName: str('Bone the hitbox is attached to.'),
-    hitboxType: choice(['Capsule', 'Box', 'Sphere'], 'Hitbox collision shape.'),
-    hitboxSize: {
-        type: 'object',
-        description: 'Hitbox dimensions: extent for Box, radius/halfHeight for Sphere and Capsule.',
-        additionalProperties: false,
-        properties: {
-            radius: { type: 'number', description: 'Sphere or capsule radius.' },
-            halfHeight: { type: 'number', description: 'Capsule half height.' },
-            extent: {
-                type: 'object',
-                description: 'Box half extent.',
-                additionalProperties: false,
-                properties: {
-                    x: { type: 'number', description: 'Half extent along X.' },
-                    y: { type: 'number', description: 'Half extent along Y.' },
-                    z: { type: 'number', description: 'Half extent along Z.' },
-                },
-            },
-        },
-    },
-    isDamageZoneHead: bool('Mark this hitbox as a headshot zone.'),
-    damageMultiplier: num('Damage multiplier applied for this hitbox.'),
-    attachmentSlots: {
-        type: 'array',
-        description: 'Attachment slot definitions created on the weapon.',
-        items: {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-                slotName: { type: 'string', description: 'Slot identifier.' },
-                socketName: { type: 'string', description: 'Socket the attachment binds to.' },
-                allowedTypes: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Attachment types accepted by this slot.',
-                },
-            },
-        },
-    },
-    combatInfo: {
-        type: 'object',
-        description: 'Combat configuration read back from the Blueprint.',
-        additionalProperties: true,
-        'x-unreal-reflection-boundary': true,
-    },
-};
-//# sourceMappingURL=combat-properties.js.map

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

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

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

@@ -1,92 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { P } from '../properties.js';
-import { C } from './combat-properties.js';
-const T = 'manage_combat';
-const F = 'combat';
-const WEAPON = '/Game/BP_Rifle';
-const PROJECTILE = '/Game/BP_Bullet';
-export const COMBAT_RECORDS = [
-    buildRecord({ parentTool: T, id: `${T}.create_weapon_blueprint`, action: 'create_weapon_blueprint', family: F,
-        topics: ['weapon', 'gun', 'weapon blueprint', 'firearm', 'new weapon'],
-        summary: 'Create a weapon Blueprint asset with its base stats.', whenToUse: ['A new weapon actor must be authored.'], whenNotToUse: ['Use create_projectile_blueprint for the projectile it fires.'],
-        inputProps: { name: P.name, path: P.path, baseDamage: C.baseDamage, fireRate: C.fireRate, range: C.range, spread: C.spread, weaponMeshPath: { type: 'string', description: 'Static mesh assigned to the new WeaponMesh component; a path that does not load fails the call.' } }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        outputProps: { blueprintPath: P.blueprintPath, baseDamage: C.baseDamage, fireRate: C.fireRate }, outputRequired: ['blueprintPath'],
-        exampleInput: { action: 'create_weapon_blueprint', name: 'BP_Rifle', path: '/Game/Weapons', baseDamage: 37, fireRate: 480 }, exampleOutput: { success: true, message: 'Weapon Blueprint created', blueprintPath: WEAPON, baseDamage: 37, fireRate: 480 } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_weapon_mesh`, action: 'configure_weapon_mesh', family: F,
-        summary: 'Assign the weapon static mesh (the WeaponMesh component, created when missing).', whenToUse: ['The weapon mesh must change.'], whenNotToUse: ['Use configure_weapon_sockets for attach points.'],
-        inputProps: { blueprintPath: P.blueprintPath, weaponMeshPath: C.weaponMeshPath }, required: ['blueprintPath', 'weaponMeshPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        outputProps: { meshPath: P.meshPath }, outputRequired: [],
-        exampleInput: { action: 'configure_weapon_mesh', blueprintPath: WEAPON, weaponMeshPath: '/Engine/BasicShapes/Cube.Cube' }, exampleOutput: { success: true, message: 'Weapon mesh configured', meshPath: '/Engine/BasicShapes/Cube.Cube' } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_projectile`, action: 'configure_projectile', family: F,
-        summary: 'Point the weapon at a projectile class and launch speed.', whenToUse: ['The weapon spawns projectiles.'], whenNotToUse: ['Use configure_hitscan for instant hits.'],
-        inputProps: { blueprintPath: P.blueprintPath, projectileClass: C.projectileClass, projectileSpeed: C.projectileSpeed }, required: ['blueprintPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        outputProps: { projectileSpeed: C.projectileSpeed }, outputRequired: [],
-        exampleInput: { action: 'configure_projectile', blueprintPath: WEAPON, projectileClass: '/Script/Engine.Actor', projectileSpeed: 4500 }, exampleOutput: { success: true, message: 'Projectile configured', projectileSpeed: 4500 } }),
-    buildRecord({ parentTool: T, id: `${T}.create_projectile_blueprint`, action: 'create_projectile_blueprint', family: F,
-        summary: 'Create a projectile Blueprint with movement and collision.', whenToUse: ['A projectile actor must be authored.'], whenNotToUse: ['Use create_weapon_blueprint for the weapon that fires it.'],
-        inputProps: { name: P.name, path: P.path, projectileSpeed: C.projectileSpeed, projectileGravityScale: C.projectileGravityScale, collisionRadius: C.collisionRadius, projectileMeshPath: C.projectileMeshPath }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        outputProps: { blueprintPath: P.blueprintPath, projectileMeshPath: C.projectileMeshPath }, outputRequired: ['blueprintPath'],
-        exampleInput: { action: 'create_projectile_blueprint', name: 'BP_Bullet', path: '/Game/Weapons', projectileSpeed: 6000, projectileGravityScale: 0, collisionRadius: 8 }, exampleOutput: { success: true, message: 'Projectile Blueprint created', blueprintPath: PROJECTILE } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_projectile_movement`, action: 'configure_projectile_movement', family: F,
-        summary: 'Configure projectile speed, gravity scale and lifespan.', whenToUse: ['Projectile flight must change.'], whenNotToUse: ['Use configure_projectile_collision for impact response.'],
-        inputProps: { blueprintPath: P.blueprintPath, projectileSpeed: C.projectileSpeed, projectileGravityScale: C.projectileGravityScale, projectileLifespan: C.projectileLifespan }, required: ['blueprintPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_projectile_movement', blueprintPath: PROJECTILE, projectileSpeed: 6500, projectileGravityScale: 0.5, projectileLifespan: 4 } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_projectile_collision`, action: 'configure_projectile_collision', family: F,
-        summary: 'Configure projectile collision radius and bounce response.', whenToUse: ['Impact or bounce behaviour must change.'], whenNotToUse: ['Use configure_projectile_movement for flight.'],
-        inputProps: { blueprintPath: P.blueprintPath, collisionRadius: C.collisionRadius, bounceEnabled: C.bounceEnabled, bounceVelocityRatio: C.bounceVelocityRatio }, required: ['blueprintPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_projectile_collision', blueprintPath: PROJECTILE, collisionRadius: 12, bounceEnabled: true, bounceVelocityRatio: 0.5 } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_projectile_homing`, action: 'configure_projectile_homing', family: F,
-        summary: 'Configure projectile homing and its turn acceleration.', whenToUse: ['The projectile should track a target.'], whenNotToUse: ['Use configure_projectile_movement for ballistic flight.'],
-        inputProps: { blueprintPath: P.blueprintPath, homingEnabled: C.homingEnabled, homingAcceleration: C.homingAcceleration }, required: ['blueprintPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_projectile_homing', blueprintPath: PROJECTILE, homingEnabled: true, homingAcceleration: 15000 } }),
-    buildRecord({ parentTool: T, id: `${T}.create_damage_type`, action: 'create_damage_type', family: F,
-        summary: 'Create a DamageType Blueprint asset.', whenToUse: ['A custom damage classification is needed.'], whenNotToUse: ['Use configure_damage_execution to tune multipliers.'],
-        inputProps: { name: P.name, path: P.path }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'low',
-        outputProps: { damageTypePath: P.damageTypePath }, outputRequired: ['damageTypePath'],
-        exampleInput: { action: 'create_damage_type', name: 'DT_Fire', path: '/Game/Damage' }, exampleOutput: { success: true, message: 'DamageType created', damageTypePath: '/Game/Damage/DT_Fire.DT_Fire' } }),
-    buildRecord({ parentTool: T, id: `${T}.setup_hitbox_component`, action: 'setup_hitbox_component', family: F,
-        summary: 'Add a shaped hitbox component, optionally bound to a bone of the Blueprint skeletal mesh.', whenToUse: ['A per-bone damage volume is needed.'], whenNotToUse: ['Use configure_hit_detection to retune an existing hitbox.'],
-        inputProps: { blueprintPath: P.blueprintPath, hitboxBoneName: { type: 'string', description: 'Bone of the Blueprint skeletal mesh (an SCS SkeletalMeshComponent or an inherited one such as a Character mesh) the hitbox attaches to; fails when the Blueprint has no skeletal mesh.' }, hitboxType: C.hitboxType, hitboxSize: C.hitboxSize, isDamageZoneHead: C.isDamageZoneHead, damageMultiplier: C.damageMultiplier }, required: ['blueprintPath'],
-        effect: 'write', latency: 'interactive', resources: 'low',
-        outputProps: { hitboxType: C.hitboxType, hitboxSize: C.hitboxSize }, outputRequired: [],
-        exampleInput: { action: 'setup_hitbox_component', blueprintPath: WEAPON, hitboxBoneName: 'spine_03', hitboxType: 'Box', hitboxSize: { extent: { x: 12, y: 18, z: 22 } }, isDamageZoneHead: true, damageMultiplier: 2 }, exampleOutput: { success: true, message: 'Hitbox component set up', hitboxType: 'Box' } }),
-    buildRecord({ parentTool: T, id: `${T}.setup_attachment_system`, action: 'setup_attachment_system', family: F,
-        summary: 'Create attachment slots and their scene components.', whenToUse: ['Modular optics or grips are needed.'], whenNotToUse: ['Use setup_weapon_switching to swap whole weapons.'],
-        inputProps: { blueprintPath: P.blueprintPath, attachmentSlots: C.attachmentSlots }, required: ['blueprintPath'],
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        outputProps: { attachmentSlots: C.attachmentSlots }, outputRequired: [],
-        exampleInput: { action: 'setup_attachment_system', blueprintPath: WEAPON, attachmentSlots: [{ slotName: 'Optic', socketName: 'OpticSocket', allowedTypes: ['Scope'] }] } }),
-    buildRecord({ parentTool: T, id: `${T}.get_combat_info`, action: 'get_combat_info', family: F,
-        summary: 'Read combat configuration back from a Blueprint.', whenToUse: ['Inspect an authored weapon or projectile.'], whenNotToUse: ['Mutating an asset; use the configure actions.'],
-        inputProps: { blueprintPath: P.blueprintPath }, required: ['blueprintPath'],
-        effect: 'read', latency: 'instant', resources: 'low',
-        outputProps: { combatInfo: C.combatInfo }, outputRequired: [],
-        exampleInput: { action: 'get_combat_info', blueprintPath: WEAPON }, exampleOutput: { success: true, message: 'Combat info', combatInfo: { parentClass: 'Actor', hasWeaponMesh: true } } }),
-    buildRecord({ parentTool: T, id: `${T}.setup_damage_type`, action: 'setup_damage_type', family: F,
-        summary: 'Create a DamageType Blueprint and return its path.', whenToUse: ['A damage class is needed by name and folder.'], whenNotToUse: ['Use configure_damage_execution to tune multipliers.'],
-        inputProps: { name: P.name, path: P.path }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'low',
-        outputProps: { damageTypePath: P.damageTypePath }, outputRequired: ['damageTypePath'],
-        exampleInput: { action: 'setup_damage_type', name: 'DT_Ice', path: '/Game/Damage' }, exampleOutput: { success: true, message: 'Damage type set up', damageTypePath: '/Game/Damage/DT_Ice.DT_Ice' } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_hit_detection`, action: 'configure_hit_detection', family: F,
-        summary: 'Retune hitbox shape and damage multiplier on a Blueprint.', whenToUse: ['An existing hitbox must change shape or scaling.'], whenNotToUse: ['Use setup_hitbox_component to add a bone-bound volume.'],
-        inputProps: { blueprintPath: P.blueprintPath, hitboxType: C.hitboxType, damageMultiplier: C.damageMultiplier }, required: ['blueprintPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        outputProps: { hitboxType: C.hitboxType }, outputRequired: [],
-        exampleInput: { action: 'configure_hit_detection', blueprintPath: WEAPON, hitboxType: 'Sphere', damageMultiplier: 1.5 }, exampleOutput: { success: true, message: 'Hit detection configured', hitboxType: 'Sphere' } }),
-    buildRecord({ parentTool: T, id: `${T}.get_combat_stats`, action: 'get_combat_stats', family: F,
-        summary: 'Read combat stats back from a Blueprint.', whenToUse: ['Inspect authored weapon stats.'], whenNotToUse: ['Use set_weapon_stats to change them.'],
-        inputProps: { blueprintPath: P.blueprintPath }, required: ['blueprintPath'],
-        effect: 'read', latency: 'instant', resources: 'low',
-        outputProps: { combatInfo: C.combatInfo }, outputRequired: [],
-        exampleInput: { action: 'get_combat_stats', blueprintPath: WEAPON }, exampleOutput: { success: true, message: 'Combat stats', combatInfo: { parentClass: 'Actor', baseDamage: 45 } } }),
-];
-//# sourceMappingURL=combat.data.js.map

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

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

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

@@ -1,8 +0,0 @@
-import { COMBAT_RECORDS } from './combat.data.js';
-import { applyFolds } from '../../shared/fold.js';
-import { MANAGE_COMBAT_FOLDS } from '../../folds/manage-combat.folds.js';
-export const MANAGE_COMBAT_UNFOLDED_SOURCES = [
-    ...COMBAT_RECORDS,
-];
-export const MANAGE_COMBAT_SOURCES = applyFolds(MANAGE_COMBAT_UNFOLDED_SOURCES, MANAGE_COMBAT_FOLDS, 'manage_combat');
-//# sourceMappingURL=index.js.map

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

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

package/dist/tools/catalog/capabilities/records/gameplay/manage-effect/effect-properties.js

@@ -1,67 +0,0 @@
-import { str, num, bool, vec3 } from '../../shared/schema-props.js';
-export const E = {
-    scale: { description: 'Scale of the spawned system: one uniform number, or [x, y, z] (an {x, y, z} object is accepted). Default 1.' },
-    templateEmitterPath: str('Niagara emitter asset the authored system starts from; defaults to the engine template for the effect kind. Ignored when systemPath names an existing system.'),
-    fromNode: str('Source node: its GUID, name or title.'),
-    fromPin: str('Output pin name (or display name) on the source node.'),
-    toNode: str('Destination node: its GUID, name or title.'),
-    toPin: str('Input pin name (or display name) on the destination node.'),
-    thickness: num('Line thickness of the debug shape (default 2).'),
-    boxSize: vec3('Box half extents as [x, y, z] for shapeType box (default the radius on every axis).'),
-    endLocation: vec3('End point as [x, y, z] for line, arrow and cylinder shapes.'),
-    direction: vec3('Direction as [x, y, z] for a cone (default up).'),
-    length: num('Cone length (default twice the radius).'),
-    angle: num('Cone half angle in degrees (default 45).'),
-    halfHeight: num('Capsule half height (default the radius).'),
-    systemPath: str('Canonical /Game Niagara System asset path.'),
-    systemName: str('Runtime Niagara system/component name on the target actor.'),
-    system: str('Niagara system path; alias normalized to systemPath.'),
-    emitterName: str('Emitter name within the target Niagara system.'),
-    emitter: str('Emitter name; alias normalized to emitterName.'),
-    emitterProperties: {
-        type: 'object',
-        additionalProperties: true,
-        description: 'Emitter settings to change: enabled (boolean) turns the emitter on or off; moduleEnabled ({ModuleName: boolean}, names as get_niagara_info lists them) turns stack modules on or off, so a template module that works against the values set (a size curve, wind) can be switched off. Any other key is refused. Module inputs are set with set_parameter_value.',
-        'x-unreal-reflection-boundary': true,
-    },
-    savePath: str('Canonical /Game directory for the created asset.'),
-    scriptType: str('Which script the graph edit works in: Spawn (default) or Update. With emitterName that is the particle spawn or particle update stack of that emitter; without it, the system spawn or update script.'),
-    modulePath: str('Canonical /Niagara module script path to insert.'),
-    nodeId: str('Niagara graph node identifier.'),
-    targetNodeId: str('Niagara graph node the dynamic input is attached to.'),
-    autoConnect: bool('Whether inserted pins are auto-connected.'),
-    dynamicInputScriptPath: str('Canonical /Niagara dynamic input script path.'),
-    inputName: str('Module input name receiving the dynamic input.'),
-    replaceExisting: bool('Whether an existing dynamic input is replaced.'),
-    parameterName: str('Niagara parameter name.'),
-    parameterType: str('Niagara parameter type (Float, Vector, Color or LinearColor, ...).'),
-    parameterValue: { description: 'Niagara parameter value (any type).' },
-    sourceBinding: str('Data source the parameter binds to.'),
-    forceType: str('Force module type (Gravity, Drag, Wind, Curl, Vortex, PointAttraction).'),
-    velocityMode: str('Velocity module mode (Linear, Cone, FromPoint).'),
-    color: { description: 'Color as an {r, g, b, a} object or an [r, g, b, a] array: 0 to 255 channels for debug_shape, 0 to 1 for a light.' },
-    materialPath: str('Canonical /Game material asset path for the renderer; its Niagara sprite or ribbon usage flag is set and the material saved, so the renderer never falls back to the default material.'),
-    meshPath: str('Canonical /Game static mesh for the mesh renderer; its materials get their Niagara mesh-particle usage flag set and saved, so the particles never fall back to the default material.'),
-    lightRadius: num('Multiplier on each particle\'s light radius (the renderer RadiusScale, engine default 1). Left unchanged when omitted.'),
-    eventName: str('Niagara event name.'),
-    eventType: str('Niagara event generator type (Location, Death, Collision).'),
-    eventSpawnCount: num('Particles spawned per received event.'),
-    spawnOnEvent: bool('Whether the receiver spawns particles on each event.'),
-    stageName: str('Simulation stage name.'),
-    stageIterationSource: str('Simulation stage iteration source.'),
-    deterministicEnabled: bool('Whether deterministic GPU simulation is enabled.'),
-    fixedBoundsEnabled: bool('Whether fixed system bounds are enabled.'),
-    attachToActor: str('Name of the actor the spawned system attaches to.'),
-    reset: bool('Whether the effect restarts from its initial state.'),
-    deltaTime: num('Seconds per step (default 0.1); steps of about a frame (0.02) simulate the way the game does.'),
-    steps: num('Steps to run (default 1): the system ages steps x deltaTime seconds.'),
-    filter: str('Actor name prefix selecting which transient effects are cleaned up.'),
-    preset: str('Particle preset name or canonical /Game particle asset path.'),
-    shapeType: str('Debug shape type (Sphere, Box, Line, Capsule).'),
-    intensity: num('Light intensity.'),
-    lightType: str('Dynamic light type: Point (the default, and what any other value gives), Spot, Directional or Rect, in any case; there is no sky light here.'),
-    density: num('Volumetric fog density.'),
-    scattering: num('Volumetric fog scattering distribution.'),
-    extinction: num('Volumetric fog extinction scale.'),
-};
-//# sourceMappingURL=effect-properties.js.map

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

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