@phalanx-engine/abilities 0.1.0

package/dist/api/AbilitySystemFacade.js

@@ -0,0 +1,213 @@
+import { FP } from '@phalanx-engine/math';
+import { ActiveEffectsComponent, AttributesComponent, GameplayTagsComponent, getActiveEffectsComponent, getAttributesComponent, getGameplayTagsComponent, } from '../components';
+export const NO_SOURCE_ENTITY_ID = -1;
+export class AbilitySystemFacade {
+    entityManager;
+    registries;
+    runtime;
+    constructor(entityManager, registries, runtime) {
+        this.entityManager = entityManager;
+        this.registries = registries;
+        this.runtime = runtime;
+    }
+    initAttributesForEntity(entityId) {
+        const entity = this.requireEntity(entityId);
+        const existing = getAttributesComponent(entity);
+        if (existing) {
+            return existing;
+        }
+        const attributes = new AttributesComponent(this.registries.attributes.size);
+        const defs = this.registries.attributes.values();
+        for (let index = 0; index < defs.length; index++) {
+            const rawDefault = FP.ToRaw(defs[index].default);
+            attributes.base[index] = rawDefault;
+            attributes.current[index] = rawDefault;
+            attributes.dirty[index] = 1;
+        }
+        entity.addComponent(attributes);
+        this.entityManager.onComponentAdded(entity, attributes.type);
+        return attributes;
+    }
+    getAttribute(entityId, attrId) {
+        const value = this.tryGetAttribute(entityId, attrId);
+        if (!value) {
+            const entity = this.entityManager.getEntity(entityId);
+            if (!entity) {
+                throw new Error(`Entity ${entityId} does not exist`);
+            }
+            if (!getAttributesComponent(entity)) {
+                throw new Error(`Entity ${entityId} does not have AttributesComponent`);
+            }
+            throw new Error(`AttributeRegistry does not contain '${attrId}'`);
+        }
+        return value;
+    }
+    tryGetAttribute(entityId, attrId) {
+        const entity = this.entityManager.getEntity(entityId);
+        if (!entity) {
+            return undefined;
+        }
+        const attributes = getAttributesComponent(entity);
+        if (!attributes) {
+            return undefined;
+        }
+        const index = this.registries.attributes.indexOfOrMinusOne(attrId);
+        if (index === -1) {
+            return undefined;
+        }
+        return {
+            base: FP.FromRaw(attributes.base[index]),
+            current: FP.FromRaw(attributes.current[index]),
+        };
+    }
+    applyEffect(targetEntityId, effectId, sourceEntityId = NO_SOURCE_ENTITY_ID) {
+        const target = this.requireEntity(targetEntityId);
+        if (!this.registries.effects.has(effectId)) {
+            throw new Error(`EffectRegistry does not contain '${effectId}'`);
+        }
+        const activeEffects = this.getOrCreateActiveEffects(target);
+        activeEffects.pendingAdd.push({ defId: effectId, sourceEntityId });
+    }
+    removeEffectsByTag(entityId, grantedTag) {
+        const entity = this.entityManager.getEntity(entityId);
+        if (!entity) {
+            return 0;
+        }
+        const activeEffects = getActiveEffectsComponent(entity);
+        if (!activeEffects) {
+            return 0;
+        }
+        let flagged = 0;
+        for (let i = 0; i < activeEffects.queue.length; i++) {
+            const instance = activeEffects.queue[i];
+            const def = this.registries.effects.tryGet(instance.defId);
+            if (!def || !def.tagsGranted) {
+                continue;
+            }
+            if (def.tagsGranted.indexOf(grantedTag) === -1) {
+                continue;
+            }
+            if (instance.remainingTicks > 0) {
+                instance.remainingTicks = 0;
+                flagged += 1;
+            }
+        }
+        return flagged;
+    }
+    removeEffectsByDefId(entityId, effectId) {
+        const entity = this.entityManager.getEntity(entityId);
+        if (!entity) {
+            return 0;
+        }
+        const activeEffects = getActiveEffectsComponent(entity);
+        if (!activeEffects) {
+            return 0;
+        }
+        let flagged = 0;
+        for (let i = 0; i < activeEffects.queue.length; i++) {
+            const instance = activeEffects.queue[i];
+            if (instance.defId !== effectId) {
+                continue;
+            }
+            if (instance.remainingTicks > 0) {
+                instance.remainingTicks = 0;
+                flagged += 1;
+            }
+        }
+        return flagged;
+    }
+    activateAbility(casterEntityId, abilityId, providedTarget) {
+        if (!this.entityManager.getEntity(casterEntityId)) {
+            return false;
+        }
+        if (!this.registries.abilities.has(abilityId)) {
+            return false;
+        }
+        const snapshotTarget = providedTarget === undefined
+            ? undefined
+            : {
+                entityId: providedTarget.entityId,
+                x: providedTarget.x,
+                z: providedTarget.z,
+            };
+        this.runtime.activationRequests.push({
+            casterEntityId,
+            abilityId,
+            providedTarget: snapshotTarget,
+            enqueueTick: this.runtime.currentTick,
+        });
+        return true;
+    }
+    registerHook(hookId, hook) {
+        this.registries.hooks.register(hookId, hook);
+    }
+    hasTag(entityId, tag) {
+        const entity = this.entityManager.getEntity(entityId);
+        if (!entity) {
+            return false;
+        }
+        const tags = getGameplayTagsComponent(entity);
+        if (!tags) {
+            return false;
+        }
+        return tags.tags.has(tag);
+    }
+    addTag(entityId, tag) {
+        const entity = this.requireEntity(entityId);
+        const tags = this.getOrCreateTags(entity);
+        tags.adHocTags.add(tag);
+        tags.tags.add(tag);
+    }
+    removeTag(entityId, tag) {
+        const entity = this.entityManager.getEntity(entityId);
+        if (!entity) {
+            return false;
+        }
+        const tags = getGameplayTagsComponent(entity);
+        if (!tags) {
+            return false;
+        }
+        const wasAdHoc = tags.adHocTags.delete(tag);
+        if (!wasAdHoc) {
+            return false;
+        }
+        const grantCount = tags.effectGrantCounts.get(tag) ?? 0;
+        if (grantCount === 0) {
+            tags.tags.delete(tag);
+        }
+        return true;
+    }
+    get runtimeInternal() {
+        return this.runtime;
+    }
+    get gameplayCueBufferInternal() {
+        return this.runtime.gameplayCueBuffer;
+    }
+    requireEntity(entityId) {
+        const entity = this.entityManager.getEntity(entityId);
+        if (!entity) {
+            throw new Error(`Entity ${entityId} does not exist`);
+        }
+        return entity;
+    }
+    getOrCreateActiveEffects(entity) {
+        const existing = getActiveEffectsComponent(entity);
+        if (existing) {
+            return existing;
+        }
+        const component = new ActiveEffectsComponent();
+        entity.addComponent(component);
+        this.entityManager.onComponentAdded(entity, component.type);
+        return component;
+    }
+    getOrCreateTags(entity) {
+        const existing = getGameplayTagsComponent(entity);
+        if (existing) {
+            return existing;
+        }
+        const tags = new GameplayTagsComponent();
+        entity.addComponent(tags);
+        this.entityManager.onComponentAdded(entity, tags.type);
+        return tags;
+    }
+}

package/dist/api/createAbilitySystem.d.ts

@@ -0,0 +1,49 @@
+import type { GameSystem, GameWorld, IAbilitySystem } from '@phalanx-engine/ecs';
+import type { FixedPoint } from '@phalanx-engine/math';
+import { AbilitySystemComponent } from '../components';
+import type { CueConfig } from '../cues';
+import type { GameplayCueBufferView } from '../runtime';
+import type { AbilityHook, ProvidedTarget } from '../types';
+import type { AttributeValue } from './AbilitySystemFacade';
+import type { AbilitySystemDefinitions } from './defineAbilitySystem';
+export type AbilitySystemPipeline = 'full' | 'activation' | 'effects' | 'effects-retain-cues' | 'attributes';
+export type AttributeInitializer = FixedPoint | {
+    base: FixedPoint;
+    current?: FixedPoint;
+};
+export interface InitialEffect {
+    id: string;
+    sourceEntityId?: number;
+}
+export interface AbilitySystemComponentInit {
+    attributes?: Record<string, AttributeInitializer>;
+    abilities?: readonly string[];
+    tags?: readonly string[];
+    effects?: readonly (string | InitialEffect)[];
+}
+export interface CreateAbilitySystemConfig {
+    definitions: AbilitySystemDefinitions;
+    hooks?: Record<string, AbilityHook>;
+    pipeline?: AbilitySystemPipeline;
+    cues?: CueConfig;
+}
+export interface AbilitySystem extends IAbilitySystem {
+    readonly tickSystems: readonly GameSystem[];
+    readonly gameplayCueBuffer: GameplayCueBufferView;
+    readonly instanceIdCounter: number;
+    readonly pendingActivationCount: number;
+    pendingActivationAbilityId(index: number): string | undefined;
+    initComponent(init?: AbilitySystemComponentInit): AbilitySystemComponent;
+    activateAbility(casterEntityId: number, abilityId: string, providedTarget?: ProvidedTarget): boolean;
+    applyEffect(targetEntityId: number, effectId: string, sourceEntityId?: number): void;
+    removeEffectsByTag(entityId: number, grantedTag: string): number;
+    removeEffectsByDefId(entityId: number, effectId: string): number;
+    getAttribute(entityId: number, attrId: string): AttributeValue;
+    tryGetAttribute(entityId: number, attrId: string): AttributeValue | undefined;
+    hasTag(entityId: number, tag: string): boolean;
+    addTag(entityId: number, tag: string): void;
+    removeTag(entityId: number, tag: string): boolean;
+}
+export declare function createAbilitySystem(world: GameWorld, config: CreateAbilitySystemConfig): AbilitySystem;
+export declare const abilityComponentTypes: readonly symbol[];
+//# sourceMappingURL=createAbilitySystem.d.ts.map

package/dist/api/createAbilitySystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAbilitySystem.d.ts","sourceRoot":"","sources":["../../src/api/createAbilitySystem.ts"],"names":[],"mappings":"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"}

package/dist/api/createAbilitySystem.js

@@ -0,0 +1,205 @@
+import { FP } from '@phalanx-engine/math';
+import { AbilitiesComponentType, AbilitySystemComponent, } from '../components';
+import { AbilityActivationSystem, AbilityHookExecutorSystem, AttributeAggregationSystem, CueBufferCleanupSystem, CueDispatchSystem, CuePresentationSystem, EffectApplicationSystem, EffectTickSystem, } from '../systems';
+import { createAbilitySystemRegistries } from '../registry';
+import { createAbilitySystemRuntime } from '../runtime';
+import { AbilitySystemFacade, NO_SOURCE_ENTITY_ID } from './AbilitySystemFacade';
+export function createAbilitySystem(world, config) {
+    const registries = createAbilitySystemRegistries();
+    registerDefinitions(registries, config.definitions);
+    const runtime = createAbilitySystemRuntime();
+    const facade = new AbilitySystemFacade(world.entityManager, registries, runtime);
+    if (config.hooks) {
+        for (const [hookId, hook] of Object.entries(config.hooks)) {
+            facade.registerHook(hookId, hook);
+        }
+    }
+    world.entityManager.registerComponentTypes(abilityComponentTypes);
+    const cues = config.cues ?? {};
+    const abilitySystem = new AbilitySystemImpl(registries, runtime, facade, config.pipeline ?? 'full', cues);
+    world.context.abilities = abilitySystem;
+    return abilitySystem;
+}
+export const abilityComponentTypes = [
+    AbilitiesComponentType.AbilitySystem,
+    AbilitiesComponentType.Attributes,
+    AbilitiesComponentType.ActiveEffects,
+    AbilitiesComponentType.GameplayTags,
+];
+class AbilitySystemImpl {
+    registries;
+    runtime;
+    facade;
+    tickSystems;
+    gameplayCueBuffer;
+    get instanceIdCounter() {
+        return this.runtime.instanceIdCounter.current;
+    }
+    get pendingActivationCount() {
+        return this.runtime.activationRequests.length;
+    }
+    pendingActivationAbilityId(index) {
+        return this.runtime.activationRequests[index]?.abilityId;
+    }
+    constructor(registries, runtime, facade, pipeline, cues) {
+        this.registries = registries;
+        this.runtime = runtime;
+        this.facade = facade;
+        this.gameplayCueBuffer = facade.gameplayCueBufferInternal;
+        this.tickSystems = buildTickSystems(registries, runtime, pipeline, cues);
+    }
+    initComponent(init = {}) {
+        const component = new AbilitySystemComponent(this.registries.attributes.size);
+        this.seedAttributes(component, init.attributes);
+        this.seedAbilities(component, init.abilities);
+        this.seedTags(component, init.tags);
+        this.seedEffects(component, init.effects);
+        return component;
+    }
+    activateAbility(casterEntityId, abilityId, providedTarget) {
+        return this.facade.activateAbility(casterEntityId, abilityId, providedTarget);
+    }
+    applyEffect(targetEntityId, effectId, sourceEntityId = NO_SOURCE_ENTITY_ID) {
+        this.facade.applyEffect(targetEntityId, effectId, sourceEntityId);
+    }
+    removeEffectsByTag(entityId, grantedTag) {
+        return this.facade.removeEffectsByTag(entityId, grantedTag);
+    }
+    removeEffectsByDefId(entityId, effectId) {
+        return this.facade.removeEffectsByDefId(entityId, effectId);
+    }
+    getAttribute(entityId, attrId) {
+        return this.facade.getAttribute(entityId, attrId);
+    }
+    tryGetAttribute(entityId, attrId) {
+        return this.facade.tryGetAttribute(entityId, attrId);
+    }
+    hasTag(entityId, tag) {
+        return this.facade.hasTag(entityId, tag);
+    }
+    addTag(entityId, tag) {
+        this.facade.addTag(entityId, tag);
+    }
+    removeTag(entityId, tag) {
+        return this.facade.removeTag(entityId, tag);
+    }
+    seedAttributes(component, overrides) {
+        const defs = this.registries.attributes.values();
+        for (let index = 0; index < defs.length; index++) {
+            const rawDefault = FP.ToRaw(defs[index].default);
+            component.attributes.base[index] = rawDefault;
+            component.attributes.current[index] = rawDefault;
+            component.attributes.dirty[index] = 1;
+        }
+        if (!overrides) {
+            return;
+        }
+        for (const [attributeId, value] of Object.entries(overrides)) {
+            const index = this.registries.attributes.indexOf(attributeId);
+            const base = isAttributeValuePair(value) ? value.base : value;
+            const current = isAttributeValuePair(value) ? value.current ?? value.base : value;
+            component.attributes.base[index] = FP.ToRaw(base);
+            component.attributes.current[index] = FP.ToRaw(current);
+            component.attributes.dirty[index] = 1;
+        }
+    }
+    seedAbilities(component, abilities) {
+        if (!abilities) {
+            return;
+        }
+        for (const abilityId of abilities) {
+            if (!this.registries.abilities.has(abilityId)) {
+                throw new Error(`AbilityRegistry does not contain '${abilityId}'`);
+            }
+            component.abilities.add(abilityId);
+        }
+    }
+    seedTags(component, tags) {
+        if (!tags) {
+            return;
+        }
+        for (const tag of tags) {
+            component.tags.adHocTags.add(tag);
+            component.tags.tags.add(tag);
+        }
+    }
+    seedEffects(component, effects) {
+        if (!effects) {
+            return;
+        }
+        for (const entry of effects) {
+            const effectId = typeof entry === 'string' ? entry : entry.id;
+            if (!this.registries.effects.has(effectId)) {
+                throw new Error(`EffectRegistry does not contain '${effectId}'`);
+            }
+            component.activeEffects.pendingAdd.push({
+                defId: effectId,
+                sourceEntityId: typeof entry === 'string'
+                    ? NO_SOURCE_ENTITY_ID
+                    : entry.sourceEntityId ?? NO_SOURCE_ENTITY_ID,
+            });
+        }
+    }
+}
+function registerDefinitions(registries, definitions) {
+    for (const attribute of definitions.attributes) {
+        registries.attributes.register(attribute);
+    }
+    for (const effect of definitions.effects ?? []) {
+        registries.effects.register(effect);
+    }
+    for (const ability of definitions.abilities ?? []) {
+        registries.abilities.register(ability);
+    }
+}
+function isAttributeValuePair(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'base' in value &&
+        !('precision' in value));
+}
+function buildTickSystems(registries, runtime, pipeline, cues) {
+    const effectApplication = new EffectApplicationSystem(registries, runtime);
+    const effectTick = new EffectTickSystem(registries, runtime);
+    const aggregation = new AttributeAggregationSystem(registries);
+    const cueCleanup = new CueBufferCleanupSystem(runtime);
+    const hasCues = Object.keys(cues).length > 0;
+    if (pipeline === 'effects-retain-cues' &&
+        !hasCues &&
+        process.env.NODE_ENV !== 'production') {
+        console.warn('[phalanx-abilities] pipeline "effects-retain-cues" with no cues registered: ' +
+            'the cue buffer is retained for manual inspection but nothing dispatches it.');
+    }
+    const systems = (() => {
+        switch (pipeline) {
+            case 'attributes':
+                return [aggregation];
+            case 'effects':
+            case 'effects-retain-cues': {
+                const base = [effectApplication, effectTick, aggregation];
+                if (hasCues) {
+                    base.push(new CueDispatchSystem(runtime));
+                }
+                if (pipeline === 'effects') {
+                    base.push(cueCleanup);
+                }
+                return base;
+            }
+            case 'activation':
+            case 'full':
+                return [
+                    new AbilityActivationSystem(registries, runtime),
+                    effectApplication,
+                    new AbilityHookExecutorSystem(registries, runtime),
+                    effectTick,
+                    aggregation,
+                    ...(hasCues ? [new CueDispatchSystem(runtime)] : []),
+                    cueCleanup,
+                ];
+        }
+    })();
+    if (hasCues) {
+        systems.push(new CuePresentationSystem(cues));
+    }
+    return systems;
+}

package/dist/api/defineAbility.d.ts

@@ -0,0 +1,3 @@
+import type { AbilityDef } from '../types';
+export declare function defineAbility(def: AbilityDef): AbilityDef;
+//# sourceMappingURL=defineAbility.d.ts.map

package/dist/api/defineAbility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineAbility.d.ts","sourceRoot":"","sources":["../../src/api/defineAbility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,wBAAgB,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU,CAQzD"}

package/dist/api/defineAbility.js

@@ -0,0 +1,9 @@
+export function defineAbility(def) {
+    return {
+        ...def,
+        tagsRequired: def.tagsRequired ? [...def.tagsRequired] : undefined,
+        activationBlockedTags: def.activationBlockedTags ? [...def.activationBlockedTags] : undefined,
+        selfEffectIds: def.selfEffectIds ? [...def.selfEffectIds] : undefined,
+        targetEffectIds: def.targetEffectIds ? [...def.targetEffectIds] : undefined,
+    };
+}

package/dist/api/defineAbilitySystem.d.ts

@@ -0,0 +1,8 @@
+import type { AbilityDef, AttributeDef, EffectDef } from '../types';
+export interface AbilitySystemDefinitions {
+    attributes: readonly AttributeDef[];
+    effects?: readonly EffectDef[];
+    abilities?: readonly AbilityDef[];
+}
+export declare function defineAbilitySystem(definitions: AbilitySystemDefinitions): AbilitySystemDefinitions;
+//# sourceMappingURL=defineAbilitySystem.d.ts.map

package/dist/api/defineAbilitySystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineAbilitySystem.d.ts","sourceRoot":"","sources":["../../src/api/defineAbilitySystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAEpE,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,SAAS,YAAY,EAAE,CAAC;IACpC,OAAO,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IAC/B,SAAS,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CACnC;AAED,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,wBAAwB,GACpC,wBAAwB,CAM1B"}

package/dist/api/defineAbilitySystem.js

@@ -0,0 +1,7 @@
+export function defineAbilitySystem(definitions) {
+    return {
+        attributes: [...definitions.attributes],
+        effects: definitions.effects ? [...definitions.effects] : undefined,
+        abilities: definitions.abilities ? [...definitions.abilities] : undefined,
+    };
+}

package/dist/api/defineAttribute.d.ts

@@ -0,0 +1,3 @@
+import type { AttributeDef } from '../types';
+export declare function defineAttribute(def: AttributeDef): AttributeDef;
+//# sourceMappingURL=defineAttribute.d.ts.map

package/dist/api/defineAttribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineAttribute.d.ts","sourceRoot":"","sources":["../../src/api/defineAttribute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,wBAAgB,eAAe,CAAC,GAAG,EAAE,YAAY,GAAG,YAAY,CAE/D"}

package/dist/api/defineAttribute.js

@@ -0,0 +1,3 @@
+export function defineAttribute(def) {
+    return { ...def };
+}

package/dist/api/defineEffect.d.ts

@@ -0,0 +1,6 @@
+import type { EffectDef, Modifier } from '../types';
+export type EffectDefInput = Omit<EffectDef, 'modifiers'> & {
+    modifiers?: Modifier[];
+};
+export declare function defineEffect(def: EffectDefInput): EffectDef;
+//# sourceMappingURL=defineEffect.d.ts.map

package/dist/api/defineEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineEffect.d.ts","sourceRoot":"","sources":["../../src/api/defineEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,SAAS,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEnE,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,GAAG;IAC1D,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;CACxB,CAAC;AAEF,wBAAgB,YAAY,CAAC,GAAG,EAAE,cAAc,GAAG,SAAS,CAS3D"}

package/dist/api/defineEffect.js

@@ -0,0 +1,23 @@
+export function defineEffect(def) {
+    return {
+        ...def,
+        modifiers: def.modifiers ? [...def.modifiers] : [],
+        tagsGranted: def.tagsGranted ? [...def.tagsGranted] : undefined,
+        tagsRequired: def.tagsRequired ? [...def.tagsRequired] : undefined,
+        tagsBlocked: def.tagsBlocked ? [...def.tagsBlocked] : undefined,
+        cues: cloneEffectCueSpec(def.cues),
+    };
+}
+function cloneEffectCueSpec(cues) {
+    if (!cues) {
+        return undefined;
+    }
+    if (Array.isArray(cues)) {
+        return [...cues];
+    }
+    return {
+        onApplied: cues.onApplied ? [...cues.onApplied] : undefined,
+        onPeriodic: cues.onPeriodic ? [...cues.onPeriodic] : undefined,
+        onExpired: cues.onExpired ? [...cues.onExpired] : undefined,
+    };
+}

package/dist/api/index.d.ts

@@ -0,0 +1,11 @@
+export { defineAbility } from './defineAbility';
+export { defineAttribute } from './defineAttribute';
+export { defineAbilitySystem } from './defineAbilitySystem';
+export { defineEffect } from './defineEffect';
+export { createAbilitySystem, abilityComponentTypes } from './createAbilitySystem';
+export { AbilitySystemFacade, NO_SOURCE_ENTITY_ID } from './AbilitySystemFacade';
+export type { AttributeValue } from './AbilitySystemFacade';
+export type { AbilitySystem, AbilitySystemComponentInit, AbilitySystemPipeline, AttributeInitializer, CreateAbilitySystemConfig, InitialEffect, } from './createAbilitySystem';
+export type { AbilitySystemDefinitions } from './defineAbilitySystem';
+export type { EffectDefInput } from './defineEffect';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnF,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjF,YAAY,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,YAAY,EACV,aAAa,EACb,0BAA0B,EAC1B,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EACzB,aAAa,GACd,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/api/index.js

@@ -0,0 +1,6 @@
+export { defineAbility } from './defineAbility';
+export { defineAttribute } from './defineAttribute';
+export { defineAbilitySystem } from './defineAbilitySystem';
+export { defineEffect } from './defineEffect';
+export { createAbilitySystem, abilityComponentTypes } from './createAbilitySystem';
+export { AbilitySystemFacade, NO_SOURCE_ENTITY_ID } from './AbilitySystemFacade';

package/dist/components/AbilitiesComponentType.d.ts

@@ -0,0 +1,7 @@
+export declare const AbilitiesComponentType: {
+    AbilitySystem: symbol;
+    Attributes: symbol;
+    ActiveEffects: symbol;
+    GameplayTags: symbol;
+};
+//# sourceMappingURL=AbilitiesComponentType.d.ts.map

package/dist/components/AbilitiesComponentType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbilitiesComponentType.d.ts","sourceRoot":"","sources":["../../src/components/AbilitiesComponentType.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB;;;;;CAKjC,CAAC"}

package/dist/components/AbilitiesComponentType.js

@@ -0,0 +1,7 @@
+import { createComponentTypeRegistry } from '@phalanx-engine/ecs';
+export const AbilitiesComponentType = createComponentTypeRegistry({
+    AbilitySystem: 'phalanx-abilities:AbilitySystem',
+    Attributes: 'phalanx-abilities:Attributes',
+    ActiveEffects: 'phalanx-abilities:ActiveEffects',
+    GameplayTags: 'phalanx-abilities:GameplayTags',
+});

package/dist/components/AbilitySystemComponent.d.ts

@@ -0,0 +1,17 @@
+import type { Entity, IComponent } from '@phalanx-engine/ecs';
+import { ActiveEffectsComponent } from './ActiveEffectsComponent';
+import { AttributesComponent } from './AttributesComponent';
+import { GameplayTagsComponent } from './GameplayTagsComponent';
+export declare class AbilitySystemComponent implements IComponent {
+    readonly type: symbol;
+    readonly attributes: AttributesComponent;
+    readonly activeEffects: ActiveEffectsComponent;
+    readonly tags: GameplayTagsComponent;
+    readonly abilities: Set<string>;
+    constructor(attributeCount: number);
+}
+export declare function getAbilitySystemComponent(entity: Entity): AbilitySystemComponent | undefined;
+export declare function getAttributesComponent(entity: Entity): AttributesComponent | undefined;
+export declare function getActiveEffectsComponent(entity: Entity): ActiveEffectsComponent | undefined;
+export declare function getGameplayTagsComponent(entity: Entity): GameplayTagsComponent | undefined;
+//# sourceMappingURL=AbilitySystemComponent.d.ts.map

package/dist/components/AbilitySystemComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbilitySystemComponent.d.ts","sourceRoot":"","sources":["../../src/components/AbilitySystemComponent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAQhE,qBAAa,sBAAuB,YAAW,UAAU;IACvD,SAAgB,IAAI,SAAwC;IAC5D,SAAgB,UAAU,EAAE,mBAAmB,CAAC;IAChD,SAAgB,aAAa,EAAE,sBAAsB,CAAC;IACtD,SAAgB,IAAI,EAAE,qBAAqB,CAAC;IAC5C,SAAgB,SAAS,cAAqB;gBAE3B,cAAc,EAAE,MAAM;CAK1C;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS,CAE5F;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAKtF;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS,CAK5F;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS,CAK1F"}

package/dist/components/AbilitySystemComponent.js

@@ -0,0 +1,31 @@
+import { AbilitiesComponentType } from './AbilitiesComponentType';
+import { ActiveEffectsComponent } from './ActiveEffectsComponent';
+import { AttributesComponent } from './AttributesComponent';
+import { GameplayTagsComponent } from './GameplayTagsComponent';
+export class AbilitySystemComponent {
+    type = AbilitiesComponentType.AbilitySystem;
+    attributes;
+    activeEffects;
+    tags;
+    abilities = new Set();
+    constructor(attributeCount) {
+        this.attributes = new AttributesComponent(attributeCount);
+        this.activeEffects = new ActiveEffectsComponent();
+        this.tags = new GameplayTagsComponent();
+    }
+}
+export function getAbilitySystemComponent(entity) {
+    return entity.getComponent(AbilitiesComponentType.AbilitySystem);
+}
+export function getAttributesComponent(entity) {
+    return (getAbilitySystemComponent(entity)?.attributes ??
+        entity.getComponent(AbilitiesComponentType.Attributes));
+}
+export function getActiveEffectsComponent(entity) {
+    return (getAbilitySystemComponent(entity)?.activeEffects ??
+        entity.getComponent(AbilitiesComponentType.ActiveEffects));
+}
+export function getGameplayTagsComponent(entity) {
+    return (getAbilitySystemComponent(entity)?.tags ??
+        entity.getComponent(AbilitiesComponentType.GameplayTags));
+}