@phalanx-engine/abilities 0.1.0

package/dist/systems/AbilityActivationSystem.js

@@ -0,0 +1,277 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import { FP } from '@phalanx-engine/math';
+import { ActiveEffectsComponent, getAbilitySystemComponent, getActiveEffectsComponent, getAttributesComponent, getGameplayTagsComponent, } from '../components';
+import { ABILITY_ACTIVATED_EVENT } from '../events';
+import { TargetResolver } from '../targeting';
+export class AbilityActivationSystem extends GameSystem {
+    registries;
+    runtime;
+    inFlightTagsByCaster = new Map();
+    inFlightCostsByCaster = new Map();
+    targetResolver;
+    constructor(registries, runtime) {
+        super();
+        this.registries = registries;
+        this.runtime = runtime;
+    }
+    processTick(tick) {
+        this.runtime.currentTick = tick;
+        this.inFlightTagsByCaster.clear();
+        this.inFlightCostsByCaster.clear();
+        if (this.runtime.resolvedActivationsThisTick.length !== 0) {
+            throw new Error('AbilityActivationSystem: resolvedActivationsThisTick is not empty at start of tick. ' +
+                'Ensure AbilityHookExecutorSystem is registered after AbilityActivationSystem ' +
+                'and EffectApplicationSystem in the system pipeline.');
+        }
+        const pending = this.runtime.activationRequests;
+        if (pending.length === 0) {
+            return;
+        }
+        let readIndex = 0;
+        let writeIndex = 0;
+        try {
+            for (; readIndex < pending.length; readIndex++) {
+                const request = pending[readIndex];
+                if (request.enqueueTick === tick) {
+                    if (writeIndex !== readIndex) {
+                        pending[writeIndex] = request;
+                    }
+                    writeIndex += 1;
+                    continue;
+                }
+                this.processOne(request, tick);
+            }
+        }
+        finally {
+            if (readIndex + 1 < pending.length) {
+                for (let k = readIndex + 1; k < pending.length; k++) {
+                    pending[writeIndex++] = pending[k];
+                }
+            }
+            pending.length = writeIndex;
+        }
+    }
+    processOne(request, tick) {
+        const abilityDef = this.registries.abilities.tryGet(request.abilityId);
+        if (!abilityDef) {
+            throw new Error(`AbilityRegistry does not contain '${request.abilityId}'`);
+        }
+        const caster = this.entityManager.getEntity(request.casterEntityId);
+        if (!caster) {
+            return;
+        }
+        if (!this.canActivate(caster, abilityDef)) {
+            return;
+        }
+        const resolution = this.resolveTargets(caster, abilityDef, request.providedTarget);
+        if (resolution.dropped) {
+            return;
+        }
+        const resolvedTargets = resolution.targets;
+        this.enqueueCasterEffects(caster, abilityDef);
+        if (abilityDef.targetEffectIds && abilityDef.targetEffectIds.length > 0) {
+            for (let i = 0; i < resolvedTargets.length; i++) {
+                const targetEntity = this.entityManager.getEntity(resolvedTargets[i]);
+                if (!targetEntity) {
+                    continue;
+                }
+                for (const effectId of abilityDef.targetEffectIds) {
+                    this.enqueueEffect(targetEntity, effectId, request.casterEntityId);
+                }
+            }
+        }
+        this.recordCooldownInFlight(request.casterEntityId, abilityDef);
+        const record = {
+            abilityId: abilityDef.id,
+            casterEntityId: request.casterEntityId,
+            resolvedTargets,
+            providedTarget: request.providedTarget,
+            hookId: abilityDef.hookId,
+            tick,
+        };
+        this.runtime.resolvedActivationsThisTick.push(record);
+        const event = {
+            abilityId: abilityDef.id,
+            casterEntityId: request.casterEntityId,
+            resolvedTargets,
+            providedTarget: request.providedTarget,
+            tick,
+        };
+        this.eventBus.emit(ABILITY_ACTIVATED_EVENT, event);
+    }
+    canActivate(caster, def) {
+        const casterId = caster.id;
+        const abilitySystem = getAbilitySystemComponent(caster);
+        if (abilitySystem && !abilitySystem.abilities.has(def.id)) {
+            return false;
+        }
+        const tags = getGameplayTagsComponent(caster);
+        const inFlightTags = this.inFlightTagsByCaster.get(casterId);
+        if (def.activationBlockedTags) {
+            for (const tag of def.activationBlockedTags) {
+                if (tags?.tags.has(tag) === true) {
+                    return false;
+                }
+                if (inFlightTags?.has(tag) === true) {
+                    return false;
+                }
+            }
+        }
+        if (def.tagsRequired) {
+            for (const tag of def.tagsRequired) {
+                if (tags?.tags.has(tag) !== true && inFlightTags?.has(tag) !== true) {
+                    return false;
+                }
+            }
+        }
+        if (def.costEffectId !== undefined) {
+            if (!this.canAffordCost(caster, def.costEffectId)) {
+                return false;
+            }
+        }
+        if (def.cooldownEffectId !== undefined) {
+            if (!this.isOffCooldown(caster, def.cooldownEffectId)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    canAffordCost(caster, costEffectId) {
+        const effectDef = this.registries.effects.tryGet(costEffectId);
+        if (!effectDef) {
+            throw new Error(`EffectRegistry does not contain '${costEffectId}'`);
+        }
+        if (effectDef.type !== 'Instant') {
+            throw new Error(`Ability cost effect '${costEffectId}' must be type 'Instant'; got '${effectDef.type}'`);
+        }
+        if (effectDef.modifiers.length === 0) {
+            return true;
+        }
+        const attributes = getAttributesComponent(caster);
+        if (!attributes) {
+            return false;
+        }
+        const inFlightCosts = this.inFlightCostsByCaster.get(caster.id);
+        for (const modifier of effectDef.modifiers) {
+            if (modifier.op !== 'Add') {
+                throw new Error(`Ability cost effect '${costEffectId}' uses unsupported op '${modifier.op}'. ` +
+                    'MVP supports only Instant + Add modifiers for cost.');
+            }
+            const rawMagnitude = FP.ToRaw(modifier.magnitude);
+            if (rawMagnitude >= 0n) {
+                continue;
+            }
+            const attributeIndex = this.registries.attributes.indexOfOrMinusOne(modifier.attributeId);
+            if (attributeIndex === -1) {
+                throw new Error(`Ability cost effect '${costEffectId}' references unknown attribute '${modifier.attributeId}'`);
+            }
+            const currentRaw = attributes.current[attributeIndex];
+            const inFlightDebit = inFlightCosts?.get(modifier.attributeId) ?? 0n;
+            const after = currentRaw - inFlightDebit + rawMagnitude;
+            if (after < 0n) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isOffCooldown(caster, cooldownEffectId) {
+        const effectDef = this.registries.effects.tryGet(cooldownEffectId);
+        if (!effectDef) {
+            throw new Error(`EffectRegistry does not contain '${cooldownEffectId}'`);
+        }
+        if (!effectDef.tagsGranted || effectDef.tagsGranted.length === 0) {
+            throw new Error(`Ability cooldown effect '${cooldownEffectId}' must have at least one tagsGranted entry.`);
+        }
+        const tags = getGameplayTagsComponent(caster);
+        const inFlightTags = this.inFlightTagsByCaster.get(caster.id);
+        for (const tag of effectDef.tagsGranted) {
+            if (tags?.tags.has(tag) === true) {
+                return false;
+            }
+            if (inFlightTags?.has(tag) === true) {
+                return false;
+            }
+        }
+        return true;
+    }
+    enqueueCasterEffects(caster, def) {
+        if (def.costEffectId !== undefined) {
+            this.enqueueEffect(caster, def.costEffectId, caster.id);
+            this.recordCostInFlight(caster.id, def.costEffectId);
+        }
+        if (def.cooldownEffectId !== undefined) {
+            this.enqueueEffect(caster, def.cooldownEffectId, caster.id);
+        }
+        if (def.selfEffectIds) {
+            for (const effectId of def.selfEffectIds) {
+                this.enqueueEffect(caster, effectId, caster.id);
+            }
+        }
+    }
+    enqueueEffect(target, effectId, sourceEntityId) {
+        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 });
+    }
+    getOrCreateActiveEffects(target) {
+        const existing = getActiveEffectsComponent(target);
+        if (existing) {
+            return existing;
+        }
+        const component = new ActiveEffectsComponent();
+        target.addComponent(component);
+        this.entityManager.onComponentAdded(target, component.type);
+        return component;
+    }
+    recordCooldownInFlight(casterId, def) {
+        if (def.cooldownEffectId === undefined) {
+            return;
+        }
+        const effectDef = this.registries.effects.tryGet(def.cooldownEffectId);
+        if (!effectDef || !effectDef.tagsGranted) {
+            return;
+        }
+        let set = this.inFlightTagsByCaster.get(casterId);
+        if (!set) {
+            set = new Set();
+            this.inFlightTagsByCaster.set(casterId, set);
+        }
+        for (const tag of effectDef.tagsGranted) {
+            set.add(tag);
+        }
+    }
+    recordCostInFlight(casterId, costEffectId) {
+        const effectDef = this.registries.effects.tryGet(costEffectId);
+        if (!effectDef) {
+            return;
+        }
+        let map = this.inFlightCostsByCaster.get(casterId);
+        for (const modifier of effectDef.modifiers) {
+            if (modifier.op !== 'Add') {
+                continue;
+            }
+            const rawMagnitude = FP.ToRaw(modifier.magnitude);
+            if (rawMagnitude >= 0n) {
+                continue;
+            }
+            if (!map) {
+                map = new Map();
+                this.inFlightCostsByCaster.set(casterId, map);
+            }
+            const existing = map.get(modifier.attributeId) ?? 0n;
+            map.set(modifier.attributeId, existing + -rawMagnitude);
+        }
+    }
+    resolveTargets(caster, def, providedTarget) {
+        if (this.targetResolver === undefined) {
+            this.targetResolver = new TargetResolver();
+        }
+        return this.targetResolver.resolve({
+            casterEntityId: caster.id,
+            spec: def.target,
+            providedTarget,
+        });
+    }
+}

package/dist/systems/AbilityHookExecutorSystem.d.ts

@@ -0,0 +1,10 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import type { AbilitySystemRegistries } from '../registry';
+import type { AbilitySystemRuntime } from '../runtime';
+export declare class AbilityHookExecutorSystem extends GameSystem {
+    private readonly registries;
+    private readonly runtime;
+    constructor(registries: AbilitySystemRegistries, runtime: AbilitySystemRuntime);
+    processTick(_tick: number): void;
+}
+//# sourceMappingURL=AbilityHookExecutorSystem.d.ts.map

package/dist/systems/AbilityHookExecutorSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbilityHookExecutorSystem.d.ts","sourceRoot":"","sources":["../../src/systems/AbilityHookExecutorSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAiCvD,qBAAa,yBAA0B,SAAQ,UAAU;IAErD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,UAAU,EAAE,uBAAuB,EACnC,OAAO,EAAE,oBAAoB;IAKhC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAkCjD"}

package/dist/systems/AbilityHookExecutorSystem.js

@@ -0,0 +1,35 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+export class AbilityHookExecutorSystem extends GameSystem {
+    registries;
+    runtime;
+    constructor(registries, runtime) {
+        super();
+        this.registries = registries;
+        this.runtime = runtime;
+    }
+    processTick(_tick) {
+        const buffer = this.runtime.resolvedActivationsThisTick;
+        if (buffer.length === 0) {
+            return;
+        }
+        const drained = buffer.splice(0, buffer.length);
+        for (let i = 0; i < drained.length; i++) {
+            const resolved = drained[i];
+            if (resolved.hookId === undefined) {
+                continue;
+            }
+            const hook = this.registries.hooks.tryGet(resolved.hookId);
+            if (!hook) {
+                throw new Error(`AbilityHooksRegistry does not contain '${resolved.hookId}'`);
+            }
+            const ctx = {
+                abilityId: resolved.abilityId,
+                casterEntityId: resolved.casterEntityId,
+                resolvedTargets: resolved.resolvedTargets,
+                providedTarget: resolved.providedTarget,
+                tick: resolved.tick,
+            };
+            hook(ctx);
+        }
+    }
+}

package/dist/systems/AttributeAggregationSystem.d.ts

@@ -0,0 +1,12 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import type { AbilitySystemRegistries } from '../registry';
+export declare class AttributeAggregationSystem extends GameSystem {
+    private readonly registries;
+    private readonly orderedEffectsBuffer;
+    constructor(registries: AbilitySystemRegistries);
+    processTick(_tick: number): void;
+    private takeOrderedEffects;
+    private readonly resolvedEffectDefsBuffer;
+    private resolveEffectDefs;
+}
+//# sourceMappingURL=AttributeAggregationSystem.d.ts.map

package/dist/systems/AttributeAggregationSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeAggregationSystem.d.ts","sourceRoot":"","sources":["../../src/systems/AttributeAggregationSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AASjD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAyB3D,qBAAa,0BAA2B,SAAQ,UAAU;IAGrC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAF9C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA4B;gBAE7B,UAAU,EAAE,uBAAuB;IAIvD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAkEhD,OAAO,CAAC,kBAAkB;IAyB1B,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAmB;IAa5D,OAAO,CAAC,iBAAiB;CAY1B"}

package/dist/systems/AttributeAggregationSystem.js

@@ -0,0 +1,117 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import { FP } from '@phalanx-engine/math';
+import { AbilitiesComponentType, getActiveEffectsComponent, getAttributesComponent, } from '../components';
+export class AttributeAggregationSystem extends GameSystem {
+    registries;
+    orderedEffectsBuffer = [];
+    constructor(registries) {
+        super();
+        this.registries = registries;
+    }
+    processTick(_tick) {
+        const entities = this.entityManager.queryEntitiesAny(AbilitiesComponentType.AbilitySystem, AbilitiesComponentType.Attributes);
+        const attributeDefs = this.registries.attributes.values();
+        for (const entity of entities) {
+            const attributes = getAttributesComponent(entity);
+            if (!attributes) {
+                continue;
+            }
+            if (!hasAnyDirty(attributes.dirty)) {
+                continue;
+            }
+            const activeEffects = getActiveEffectsComponent(entity);
+            const orderedEffects = this.takeOrderedEffects(activeEffects);
+            const resolvedEffectDefs = this.resolveEffectDefs(orderedEffects);
+            for (let attributeIndex = 0; attributeIndex < attributes.dirty.length; attributeIndex++) {
+                if (attributes.dirty[attributeIndex] === 0) {
+                    continue;
+                }
+                const attributeDef = attributeDefs[attributeIndex];
+                if (!attributeDef) {
+                    throw new Error(`AttributeRegistry does not contain index ${attributeIndex}`);
+                }
+                let value = FP.FromRaw(attributes.base[attributeIndex]);
+                for (let i = 0; i < resolvedEffectDefs.length; i++) {
+                    const effectDef = resolvedEffectDefs[i];
+                    for (const modifier of effectDef.modifiers) {
+                        if (modifier.attributeId !== attributeDef.id) {
+                            continue;
+                        }
+                        value = applyModifier(value, modifier.op, modifier.magnitude);
+                    }
+                }
+                const clamped = clampAttribute(value, attributeDef);
+                attributes.current[attributeIndex] = FP.ToRaw(clamped);
+                if (attributeDef.clamp !== 'none') {
+                    attributes.base[attributeIndex] = FP.ToRaw(clampAttribute(FP.FromRaw(attributes.base[attributeIndex]), attributeDef));
+                }
+                attributes.dirty[attributeIndex] = 0;
+            }
+        }
+    }
+    takeOrderedEffects(activeEffects) {
+        const buffer = this.orderedEffectsBuffer;
+        buffer.length = 0;
+        if (!activeEffects) {
+            return buffer;
+        }
+        const queue = activeEffects.queue;
+        let alreadySorted = true;
+        for (let i = 0; i < queue.length; i++) {
+            buffer.push(queue[i]);
+            if (i > 0 && queue[i - 1].instanceId > queue[i].instanceId) {
+                alreadySorted = false;
+            }
+        }
+        if (!alreadySorted) {
+            buffer.sort(byInstanceIdAsc);
+        }
+        return buffer;
+    }
+    resolvedEffectDefsBuffer = [];
+    resolveEffectDefs(orderedEffects) {
+        const buffer = this.resolvedEffectDefsBuffer;
+        buffer.length = 0;
+        for (let i = 0; i < orderedEffects.length; i++) {
+            const def = this.registries.effects.get(orderedEffects[i].defId);
+            if (def.type === 'Periodic') {
+                continue;
+            }
+            buffer.push(def);
+        }
+        return buffer;
+    }
+}
+function byInstanceIdAsc(a, b) {
+    return a.instanceId - b.instanceId;
+}
+function hasAnyDirty(dirty) {
+    for (let i = 0; i < dirty.length; i++) {
+        if (dirty[i] !== 0) {
+            return true;
+        }
+    }
+    return false;
+}
+function applyModifier(value, op, magnitude) {
+    switch (op) {
+        case 'Add':
+            return FP.Add(value, magnitude);
+        case 'Multiply':
+            return FP.Mul(value, magnitude);
+        case 'Override':
+            return magnitude;
+    }
+}
+function clampAttribute(value, def) {
+    switch (def.clamp) {
+        case 'both':
+            return FP.Clamp(value, def.min, def.max);
+        case 'min':
+            return FP.Max(value, def.min);
+        case 'max':
+            return FP.Min(value, def.max);
+        case 'none':
+            return value;
+    }
+}

package/dist/systems/CueBufferCleanupSystem.d.ts

@@ -0,0 +1,8 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import type { AbilitySystemRuntime } from '../runtime';
+export declare class CueBufferCleanupSystem extends GameSystem {
+    private readonly runtime;
+    constructor(runtime: AbilitySystemRuntime);
+    processTick(_tick: number): void;
+}
+//# sourceMappingURL=CueBufferCleanupSystem.d.ts.map

package/dist/systems/CueBufferCleanupSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CueBufferCleanupSystem.d.ts","sourceRoot":"","sources":["../../src/systems/CueBufferCleanupSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAUvD,qBAAa,sBAAuB,SAAQ,UAAU;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,oBAAoB;IAIjD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAGjD"}

package/dist/systems/CueBufferCleanupSystem.js

@@ -0,0 +1,11 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+export class CueBufferCleanupSystem extends GameSystem {
+    runtime;
+    constructor(runtime) {
+        super();
+        this.runtime = runtime;
+    }
+    processTick(_tick) {
+        this.runtime.gameplayCueBuffer.events.length = 0;
+    }
+}

package/dist/systems/CueDispatchSystem.d.ts

@@ -0,0 +1,8 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import type { AbilitySystemRuntime } from '../runtime';
+export declare class CueDispatchSystem extends GameSystem {
+    private readonly runtime;
+    constructor(runtime: AbilitySystemRuntime);
+    processTick(_tick: number): void;
+}
+//# sourceMappingURL=CueDispatchSystem.d.ts.map

package/dist/systems/CueDispatchSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CueDispatchSystem.d.ts","sourceRoot":"","sources":["../../src/systems/CueDispatchSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAWvD,qBAAa,iBAAkB,SAAQ,UAAU;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,oBAAoB;IAIjD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAQjD"}

package/dist/systems/CueDispatchSystem.js

@@ -0,0 +1,17 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import { GAMEPLAY_CUE_EVENT, gameplayCueKey } from '../events';
+export class CueDispatchSystem extends GameSystem {
+    runtime;
+    constructor(runtime) {
+        super();
+        this.runtime = runtime;
+    }
+    processTick(_tick) {
+        const events = this.runtime.gameplayCueBuffer.events;
+        for (let i = 0; i < events.length; i++) {
+            const event = events[i];
+            this.eventBus.emit(GAMEPLAY_CUE_EVENT, event);
+            this.eventBus.emit(gameplayCueKey(event.cueId), event);
+        }
+    }
+}

package/dist/systems/CuePresentationSystem.d.ts

@@ -0,0 +1,14 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import type { IAfterFrame, SystemContext } from '@phalanx-engine/ecs';
+import type { CueConfig } from '../cues';
+export declare class CuePresentationSystem extends GameSystem implements IAfterFrame {
+    private readonly cues;
+    private cueContext;
+    private activeCues;
+    constructor(cues: CueConfig);
+    init(context: SystemContext): void;
+    processTick(_tick: number): void;
+    afterFrame(_alpha: number, deltaTimeSeconds: number): void;
+    dispose(): void;
+}
+//# sourceMappingURL=CuePresentationSystem.d.ts.map

package/dist/systems/CuePresentationSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CuePresentationSystem.d.ts","sourceRoot":"","sources":["../../src/systems/CuePresentationSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGtE,OAAO,KAAK,EAAO,SAAS,EAAc,MAAM,SAAS,CAAC;AAU1D,qBAAa,qBAAsB,SAAQ,UAAW,YAAW,WAAW;IAIvD,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHxC,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,UAAU,CAAa;gBAEK,IAAI,EAAE,SAAS;IAInC,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAsBlC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAEzC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,IAAI;IAajD,OAAO,IAAI,IAAI;CAOhC"}

package/dist/systems/CuePresentationSystem.js

@@ -0,0 +1,50 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import { gameplayCueKey } from '../events';
+export class CuePresentationSystem extends GameSystem {
+    cues;
+    cueContext;
+    activeCues = [];
+    constructor(cues) {
+        super();
+        this.cues = cues;
+    }
+    init(context) {
+        super.init(context);
+        this.cueContext = {
+            entityManager: context.entityManager,
+            eventBus: context.eventBus,
+        };
+        for (const [cueId, factory] of Object.entries(this.cues)) {
+            this.subscribe(gameplayCueKey(cueId), (event) => {
+                const cue = factory();
+                cue.onSpawn(event, this.cueContext);
+                if (cue.isFinished()) {
+                    cue.dispose();
+                }
+                else {
+                    this.activeCues.push(cue);
+                }
+            });
+        }
+    }
+    processTick(_tick) { }
+    afterFrame(_alpha, deltaTimeSeconds) {
+        const cues = this.activeCues;
+        for (let i = cues.length - 1; i >= 0; i--) {
+            const cue = cues[i];
+            cue.update(deltaTimeSeconds);
+            if (cue.isFinished()) {
+                cue.dispose();
+                cues[i] = cues[cues.length - 1];
+                cues.pop();
+            }
+        }
+    }
+    dispose() {
+        for (const cue of this.activeCues) {
+            cue.dispose();
+        }
+        this.activeCues = [];
+        super.dispose();
+    }
+}

package/dist/systems/EffectApplicationSystem.d.ts

@@ -0,0 +1,20 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import type { AbilitySystemRegistries } from '../registry';
+import type { AbilitySystemRuntime } from '../runtime';
+export declare class EffectApplicationSystem extends GameSystem {
+    private readonly registries;
+    private readonly runtime;
+    constructor(registries: AbilitySystemRegistries, runtime: AbilitySystemRuntime);
+    processTick(tick: number): void;
+    private readonly attributeIndexCache;
+    private applyOne;
+    private validateEffectOrThrow;
+    private checkTagPredicates;
+    private grantTags;
+    private applyInstant;
+    private queueDurational;
+    private markAttributesDirty;
+    private resolveAttributeIndex;
+    private getOrCreateTags;
+}
+//# sourceMappingURL=EffectApplicationSystem.d.ts.map

package/dist/systems/EffectApplicationSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectApplicationSystem.d.ts","sourceRoot":"","sources":["../../src/systems/EffectApplicationSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAYjD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAE3D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAiDvD,qBAAa,uBAAwB,SAAQ,UAAU;IAEnD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,UAAU,EAAE,uBAAuB,EACnC,OAAO,EAAE,oBAAoB;IAKhC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAyB/C,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA6B;IAEjE,OAAO,CAAC,QAAQ;IAuFhB,OAAO,CAAC,qBAAqB;IA2B7B,OAAO,CAAC,kBAAkB;IAkB1B,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,YAAY;IAuBpB,OAAO,CAAC,eAAe;IAwCvB,OAAO,CAAC,mBAAmB;IAkB3B,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,eAAe;CAUxB"}