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

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

@@ -1,62 +0,0 @@
-import { str, num } from '../../shared/schema-props.js';
-const tags = (desc) => ({
-    type: 'array',
-    items: { type: 'string' },
-    description: desc,
-});
-const choice = (desc, values) => ({
-    type: 'string',
-    enum: [...values],
-    description: desc,
-});
-export const GAS_P = {
-    componentName: str('AbilitySystemComponent name (defaults to AbilitySystemComponent).'),
-    replicationMode: choice('ASC replication mode.', ['Full', 'Minimal', 'Mixed']),
-    defaultValue: num('Initial value for the added attribute.'),
-    baseValue: num('Base value for the attribute.'),
-    abilityTags: tags('Gameplay tags granted to this ability.'),
-    cancelAbilitiesWithTag: tags('Tags of abilities cancelled when this activates.'),
-    blockAbilitiesWithTag: tags('Tags of abilities blocked while this is active.'),
-    activationRequiredTags: tags('Tags required to activate this ability.'),
-    activationBlockedTags: tags('Tags that block activation of this ability.'),
-    costEffectPath: str('Canonical /Game path to the cost Gameplay Effect.'),
-    cooldownEffectPath: str('Canonical /Game path to the cooldown Gameplay Effect.'),
-    activationPolicy: choice('Net execution policy: where the ability activates.', [
-        'LocalOnly', 'LocalPredicted', 'ServerOnly', 'ServerInitiated',
-    ]),
-    instancingPolicy: choice('How the ability is instanced.', [
-        'NonInstanced', 'InstancedPerActor', 'InstancedPerExecution',
-    ]),
-    durationType: choice('Effect duration type.', ['Instant', 'Infinite', 'HasDuration']),
-    period: num('Period in seconds for periodic effects.'),
-    modifierOperation: choice('Modifier operation applied to the attribute.', [
-        'Add', 'Multiply', 'Divide', 'Override',
-    ]),
-    modifierMagnitude: num('Magnitude of the modifier.'),
-    targetAttribute: str('Target attribute captured by the modifier.'),
-    modifierIndex: num('Zero-based index of the modifier to edit.'),
-    magnitudeCalculationType: choice('How the modifier magnitude is calculated.', [
-        'ScalableFloat', 'AttributeBased', 'SetByCaller', 'CustomCalculationClass',
-    ]),
-    setByCallerTag: str('Gameplay tag keying a SetByCaller magnitude.'),
-    stackingType: choice('Stacking aggregation for the effect.', [
-        'None', 'AggregateBySource', 'AggregateByTarget',
-    ]),
-    stackLimitCount: num('Maximum stack count.'),
-    stackDurationRefreshPolicy: choice('When stack duration refreshes.', [
-        'RefreshOnSuccessfulApplication', 'NeverRefresh',
-    ]),
-    stackPeriodResetPolicy: choice('When the stack period resets.', [
-        'ResetOnSuccessfulApplication', 'NeverReset',
-    ]),
-    stackExpirationPolicy: choice('What happens when a stack expires.', [
-        'ClearEntireStack', 'RemoveSingleStackAndRefreshDuration', 'RefreshDuration',
-    ]),
-    grantedTags: tags('Tags granted while the effect is active.'),
-    applicationRequiredTags: tags('Tags required to apply this effect.'),
-    removalTags: tags('Tags that cause this effect to be removed.'),
-    immunityTags: tags('Tags that make a target immune to this effect.'),
-    setPath: str('Canonical /Game ability set asset path.'),
-    abilityClass: str('GameplayAbility class path; accepted wherever abilityPath is.'),
-};
-//# sourceMappingURL=gas.props.js.map

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

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

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

@@ -1,5 +0,0 @@
-import { MANAGE_GAS_FOLDS } from '../../folds/manage-gas.folds.js';
-import { applyFolds } from '../../shared/fold.js';
-import { GAS_RECORDS } from './gas.data.js';
-export const MANAGE_GAS_SOURCES = applyFolds(GAS_RECORDS, MANAGE_GAS_FOLDS, 'manage_gas');
-//# sourceMappingURL=index.js.map

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

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

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

@@ -1,8 +0,0 @@
-import { INTERACTION_RECORDS } from './interaction.data.js';
-import { applyFolds } from '../../shared/fold.js';
-import { MANAGE_INTERACTION_FOLDS } from '../../folds/manage-interaction.folds.js';
-export const MANAGE_INTERACTION_UNFOLDED_SOURCES = [
-    ...INTERACTION_RECORDS,
-];
-export const MANAGE_INTERACTION_SOURCES = applyFolds(MANAGE_INTERACTION_UNFOLDED_SOURCES, MANAGE_INTERACTION_FOLDS, 'manage_interaction');
-//# sourceMappingURL=index.js.map

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

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

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

@@ -1,253 +0,0 @@
-import { NP, interactionRecord } from './schema.js';
-export const INTERACTION_RECORDS = [
-    interactionRecord({
-        action: 'configure_chest_properties',
-        summary: 'Configure persistent chest properties.',
-        whenToUse: ['An existing chest needs its locked state, lid open angle, open time or loot table path changed; fields left out keep their value.'],
-        whenNotToUse: [
-            'The Blueprint does not exist yet or lacks the components its create step adds (use manage_interaction.create_interactable).',
-            'One placed actor needs its own values, not the Blueprint default (use control_actor.set_blueprint_variables).',
-        ],
-        inputProps: {
-            chestPath: NP.chestPath,
-            locked: NP.locked,
-            openAngle: NP.openAngle,
-            openTime: NP.openTime,
-            lootTablePath: NP.lootTablePath,
-        },
-        required: ['chestPath'],
-        exampleInput: {
-            action: 'configure_chest_properties',
-            chestPath: '/Game/Interactables/BP_Chest',
-            locked: false,
-            openAngle: 90,
-        },
-    }),
-    interactionRecord({
-        action: 'configure_door_properties',
-        summary: 'Configure persistent door properties.',
-        whenToUse: ['An existing door needs a new open angle, open time or locked state; fields left out keep their value.'],
-        whenNotToUse: [
-            'The Blueprint does not exist yet or lacks the components its create step adds (use manage_interaction.create_interactable).',
-            'One placed actor needs its own values, not the Blueprint default (use control_actor.set_blueprint_variables).',
-        ],
-        inputProps: {
-            doorPath: NP.doorPath,
-            openAngle: NP.openAngle,
-            openTime: NP.openTime,
-            locked: NP.locked,
-        },
-        required: ['doorPath'],
-        exampleInput: {
-            action: 'configure_door_properties',
-            doorPath: '/Game/Interactables/BP_Door',
-            openAngle: 90,
-            openTime: 0.5,
-        },
-    }),
-    interactionRecord({
-        action: 'configure_interaction_trace',
-        summary: 'Configure persistent interaction trace data.',
-        whenToUse: [
-            'The trigger of an interactable Blueprint must be resized: every sphere gets radius traceDistance, every box gets extent traceDistance by traceRadius.',
-            'Give traceDistance, traceRadius and traceType together, since an omitted one resets to 200, 50 or sphere; traceType only stores a name.',
-        ],
-        whenNotToUse: [
-            'The Blueprint has no sphere or box component to resize (add one with manage_interaction.create_interactable, kind=component).',
-            'Only one of several sphere or box components should change, since every one is resized (use blueprint.edit_scs).',
-        ],
-        inputProps: {
-            blueprintPath: NP.blueprintPath,
-            traceType: NP.traceType,
-            traceDistance: NP.traceDistance,
-            traceRadius: NP.traceRadius,
-        },
-        required: ['blueprintPath'],
-        exampleInput: {
-            action: 'configure_interaction_trace',
-            blueprintPath: '/Game/Blueprints/BP_Player',
-            traceType: 'sphere',
-            traceDistance: 200,
-        },
-    }),
-    interactionRecord({
-        action: 'configure_switch_properties',
-        summary: 'Configure persistent switch properties.',
-        whenToUse: ['An existing switch needs a different type, a toggle-back rule or a reset delay; fields left out keep their value.'],
-        whenNotToUse: [
-            'The Blueprint does not exist yet or lacks the components its create step adds (use manage_interaction.create_interactable).',
-            'One placed actor needs its own values, not the Blueprint default (use control_actor.set_blueprint_variables).',
-        ],
-        inputProps: {
-            switchPath: NP.switchPath,
-            switchType: NP.switchType,
-            canToggle: NP.canToggle,
-            resetTime: NP.resetTime,
-        },
-        required: ['switchPath'],
-        exampleInput: {
-            action: 'configure_switch_properties',
-            switchPath: '/Game/Interactables/BP_Switch',
-            switchType: 'button',
-            canToggle: true,
-        },
-    }),
-    interactionRecord({
-        action: 'create_chest_actor',
-        summary: 'Create a chest actor Blueprint asset.',
-        whenToUse: ['A chest Blueprint is needed with a base mesh, a lid mesh on a pivot, a trigger sphere and an optional locked state.'],
-        whenNotToUse: [
-            'An actor must be placed in the level from an existing Blueprint (use control_actor.spawn).',
-            'An existing door, chest or switch only needs new settings (use manage_interaction.configure_interactable).',
-        ],
-        inputProps: { name: NP.name, folder: NP.folder, locked: NP.locked },
-        required: ['name'],
-        exampleInput: {
-            action: 'create_chest_actor',
-            name: 'BP_Chest',
-            folder: '/Game/Interactables',
-            locked: false,
-        },
-    }),
-    interactionRecord({
-        action: 'create_door_actor',
-        topics: ['door', 'new door', 'door actor', 'openable door', 'door that opens'],
-        summary: 'Create a door actor Blueprint asset.',
-        whenToUse: ['A door Blueprint is needed with a pivot, a door mesh and a trigger box, plus open-angle, timing, lock and key variables.'],
-        whenNotToUse: [
-            'An actor must be placed in the level from an existing Blueprint (use control_actor.spawn).',
-            'An existing door, chest or switch only needs new settings (use manage_interaction.configure_interactable).',
-        ],
-        inputProps: {
-            name: NP.name,
-            folder: NP.folder,
-            openAngle: NP.openAngle,
-            openTime: NP.openTime,
-            autoClose: NP.autoClose,
-            autoCloseDelay: NP.autoCloseDelay,
-            requiresKey: NP.requiresKey,
-            locked: NP.locked,
-        },
-        required: ['name'],
-        exampleInput: {
-            action: 'create_door_actor',
-            name: 'BP_Door',
-            folder: '/Game/Interactables',
-            openAngle: 90,
-            autoClose: true,
-        },
-    }),
-    interactionRecord({
-        action: 'create_interactable_interface',
-        summary: 'Create an interactable Blueprint interface asset.',
-        whenToUse: ['A Blueprint interface is needed that defines Interact, CanInteract and GetInteractionPrompt for actors to implement.'],
-        whenNotToUse: ['A normal actor Blueprint is needed, not an interface (use blueprint.create).'],
-        inputProps: { name: NP.name, folder: NP.folder },
-        required: ['name'],
-        exampleInput: {
-            action: 'create_interactable_interface',
-            name: 'BPI_Interactable',
-            folder: '/Game/Interfaces',
-        },
-    }),
-    interactionRecord({
-        action: 'create_interaction_component',
-        summary: 'Add an interaction component to a Blueprint asset.',
-        whenToUse: ['An existing Blueprint, such as a player, needs a named overlap sphere whose radius is the interaction range.'],
-        whenNotToUse: ['A component other than an overlap sphere is needed (use blueprint.edit_scs).'],
-        inputProps: {
-            blueprintPath: NP.blueprintPath,
-            componentName: NP.componentName,
-            traceDistance: NP.traceDistance,
-        },
-        required: ['blueprintPath'],
-        exampleInput: {
-            action: 'create_interaction_component',
-            blueprintPath: '/Game/Blueprints/BP_Player',
-            componentName: 'InteractionComponent',
-            traceDistance: 200,
-        },
-    }),
-    interactionRecord({
-        action: 'create_lever_actor',
-        summary: 'Create a lever actor Blueprint asset.',
-        whenToUse: ['A switch, button or lever needs an actor Blueprint with mesh parts and an overlap sphere as its trigger.'],
-        whenNotToUse: [
-            'An actor must be placed in the level from an existing Blueprint (use control_actor.spawn).',
-            'Switch type, toggle and reset settings must be editable later, which only a switch Blueprint allows.',
-        ],
-        inputProps: { name: NP.name, folder: NP.folder },
-        required: ['name'],
-        exampleInput: { action: 'create_lever_actor', name: 'BP_Lever', folder: '/Game/Interactables' },
-    }),
-    interactionRecord({
-        action: 'create_switch_actor',
-        summary: 'Create a switch actor Blueprint asset.',
-        whenToUse: ['A switch, button or lever needs an actor Blueprint with mesh parts and an overlap sphere as its trigger.'],
-        whenNotToUse: [
-            'An actor must be placed in the level from an existing Blueprint (use control_actor.spawn).',
-            'An existing door, chest or switch only needs new settings (use manage_interaction.configure_interactable).',
-        ],
-        inputProps: { name: NP.name, folder: NP.folder, switchType: NP.switchType },
-        required: ['name'],
-        exampleInput: {
-            action: 'create_switch_actor',
-            name: 'BP_Switch',
-            folder: '/Game/Interactables',
-            switchType: 'button',
-        },
-    }),
-    interactionRecord({
-        action: 'create_trigger_actor',
-        summary: 'Create a trigger actor Blueprint asset.',
-        whenToUse: ['A reusable overlap-volume Blueprint is needed with a box, sphere or capsule as its root shape.'],
-        whenNotToUse: [
-            'An actor must be placed in the level from an existing Blueprint (use control_actor.spawn).',
-            'A single trigger volume is wanted in the level with no Blueprint asset (use manage_level_structure.create_volume).',
-        ],
-        inputProps: { name: NP.name, folder: NP.folder, triggerShape: NP.triggerShape },
-        required: ['name'],
-        exampleInput: {
-            action: 'create_trigger_actor',
-            name: 'BP_Trigger',
-            folder: '/Game/Triggers',
-            triggerShape: 'box',
-        },
-    }),
-    interactionRecord({
-        action: 'get_interaction_info',
-        summary: 'Read a door, switch, chest, trigger or other interaction Blueprint: its components and editable property defaults. With actorName, an editor-world actor\'s name and class only.',
-        topics: ['door settings', 'switch and chest', 'trigger properties', 'interactable defaults'],
-        whenToUse: [
-            'The components and default values of a door, switch, chest or trigger Blueprint must be checked, for example after configuring it.',
-            'The class of a named actor in the level must be confirmed.',
-        ],
-        whenNotToUse: [
-            'The components or properties of a placed actor are needed (use inspect.inspect_object).',
-            'Functions, events, graph node counts or component transforms of a Blueprint are needed (use inspect.get_blueprint_details).',
-        ],
-        read: true,
-        outputProps: {
-            assetType: { type: 'string', description: 'Resolved kind: Blueprint, Actor, Door, Switch, Chest or Trigger.' },
-            blueprintName: { type: 'string', description: 'Blueprint asset name, when the target resolved to a Blueprint.' },
-            blueprintPath: NP.blueprintPath,
-            actorName: NP.actorName,
-            actorClass: { type: 'string', description: 'Class name of the resolved editor-world actor.' },
-            doorPath: NP.doorPath,
-            switchPath: NP.switchPath,
-            chestPath: NP.chestPath,
-            triggerPath: NP.triggerPath,
-        },
-        inputProps: {
-            blueprintPath: NP.blueprintPath,
-            actorName: NP.actorName,
-            doorPath: NP.doorPath,
-            switchPath: NP.switchPath,
-            chestPath: NP.chestPath,
-            triggerPath: NP.triggerPath,
-        },
-        requiredOneOf: ['blueprintPath', 'actorName', 'doorPath', 'switchPath', 'chestPath', 'triggerPath'],
-        exampleInput: { action: 'get_interaction_info', blueprintPath: '/Game/Blueprints/BP_Player' },
-    }),
-];
-//# sourceMappingURL=interaction.data.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-interaction/schema.d.ts

@@ -1,18 +0,0 @@
-import type { CapabilityRecordSource, JsonObject } from '../../../model.js';
-import type { PropertyMap } from '../properties.js';
-export declare const NP: PropertyMap;
-export interface InteractionActionSpec {
-    readonly action: string;
-    readonly summary: string;
-    readonly topics?: readonly string[];
-    readonly inputProps: PropertyMap;
-    readonly required?: readonly string[];
-    readonly requiredOneOf?: readonly string[];
-    readonly exampleInput: JsonObject;
-    readonly read?: boolean;
-    readonly outputProps?: PropertyMap;
-    readonly whenToUse?: readonly string[];
-    readonly whenNotToUse?: readonly string[];
-}
-export declare function interactionRecord(spec: InteractionActionSpec): CapabilityRecordSource;
-//# sourceMappingURL=schema.d.ts.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-interaction/schema.js

@@ -1,52 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { P } from '../properties.js';
-import { str, num, bool } from '../../shared/schema-props.js';
-export const NP = {
-    name: P.name,
-    blueprintPath: P.blueprintPath,
-    actorName: P.actorName,
-    lootTablePath: P.lootTablePath,
-    folder: str('Canonical /Game folder that receives the created asset.'),
-    componentName: str('Name for the component added to the Blueprint.'),
-    traceDistance: num('Interaction trace distance in world units.'),
-    traceType: str('Free-text name stored in the TraceType Name variable of the Blueprint (default sphere). It does not choose or change a trace shape: the shape comes from the sphere and box components, which traceDistance and traceRadius resize.'),
-    traceRadius: num('Cross-section of each box component in world units (default 50): a box gets extent traceDistance by traceRadius. Sphere components ignore it.'),
-    openAngle: num('Open angle in degrees.'),
-    openTime: num('Open animation duration in seconds.'),
-    autoClose: bool('Whether the door closes automatically.'),
-    autoCloseDelay: num('Delay in seconds before the door auto-closes.'),
-    requiresKey: bool('Whether opening requires a key.'),
-    doorPath: str('Canonical /Game door actor Blueprint asset path.'),
-    locked: bool('Whether the interactable starts locked.'),
-    switchType: str('Switch type (button, lever, or pressure_plate).'),
-    switchPath: str('Canonical /Game switch actor Blueprint asset path.'),
-    canToggle: bool('Whether the switch can toggle back off.'),
-    resetTime: num('Switch reset delay in seconds.'),
-    chestPath: str('Canonical /Game chest actor Blueprint asset path.'),
-    triggerShape: str('Trigger volume shape (box, sphere, or capsule).'),
-    triggerPath: str('Canonical /Game trigger actor Blueprint asset path.'),
-};
-export function interactionRecord(spec) {
-    return buildRecord({
-        parentTool: 'manage_interaction',
-        id: `manage_interaction.${spec.action}`,
-        action: spec.action,
-        family: 'interaction',
-        summary: spec.summary,
-        topics: spec.topics,
-        whenToUse: [...(spec.whenToUse ?? [])],
-        whenNotToUse: [...(spec.whenNotToUse ?? [])],
-        inputProps: { ...spec.inputProps },
-        required: [...(spec.required ?? [])],
-        requiredOneOf: spec.requiredOneOf,
-        outputProps: { assetPath: P.assetPath, ...(spec.outputProps ?? {}) },
-        outputRequired: [],
-        effect: spec.read === true ? 'read' : 'write',
-        latency: 'interactive',
-        resources: 'medium',
-        editorStates: ['edit'],
-        exampleInput: spec.exampleInput,
-        exampleOutput: { success: true, message: `${spec.action} handled` },
-    });
-}
-//# sourceMappingURL=schema.js.map

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

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

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

@@ -1,8 +0,0 @@
-import { INVENTORY_RECORDS } from './inventory.data.js';
-import { applyFolds } from '../../shared/fold.js';
-import { MANAGE_INVENTORY_FOLDS } from '../../folds/manage-inventory.folds.js';
-export const MANAGE_INVENTORY_UNFOLDED_SOURCES = [
-    ...INVENTORY_RECORDS,
-];
-export const MANAGE_INVENTORY_SOURCES = applyFolds(MANAGE_INVENTORY_UNFOLDED_SOURCES, MANAGE_INVENTORY_FOLDS, 'manage_inventory');
-//# sourceMappingURL=index.js.map

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

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