@phalanx-engine/abilities 0.1.0

package/dist/systems/EffectApplicationSystem.js

@@ -0,0 +1,174 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import { FP } from '@phalanx-engine/math';
+import { AbilitiesComponentType, GameplayTagsComponent, getActiveEffectsComponent, getAttributesComponent, getGameplayTagsComponent, } from '../components';
+import { appendGameplayCueEvents } from '../runtime';
+export class EffectApplicationSystem extends GameSystem {
+    registries;
+    runtime;
+    constructor(registries, runtime) {
+        super();
+        this.registries = registries;
+        this.runtime = runtime;
+    }
+    processTick(tick) {
+        const entities = this.entityManager.queryEntitiesAny(AbilitiesComponentType.AbilitySystem, AbilitiesComponentType.ActiveEffects);
+        const attributeIndexCache = this.attributeIndexCache;
+        attributeIndexCache.clear();
+        for (const entity of entities) {
+            const activeEffects = getActiveEffectsComponent(entity);
+            if (!activeEffects || activeEffects.pendingAdd.length === 0) {
+                continue;
+            }
+            const drained = activeEffects.pendingAdd.splice(0, activeEffects.pendingAdd.length);
+            for (let i = 0; i < drained.length; i++) {
+                this.applyOne(entity, drained[i], attributeIndexCache, tick);
+            }
+        }
+    }
+    attributeIndexCache = new Map();
+    applyOne(entity, pending, attributeIndexCache, tick) {
+        const effectDef = this.registries.effects.tryGet(pending.defId);
+        if (!effectDef) {
+            throw new Error(`EffectRegistry does not contain '${pending.defId}'`);
+        }
+        const tags = this.getOrCreateTags(entity);
+        if (!this.checkTagPredicates(effectDef, tags)) {
+            return;
+        }
+        this.validateEffectOrThrow(effectDef, attributeIndexCache);
+        this.grantTags(effectDef, tags);
+        switch (effectDef.type) {
+            case 'Instant':
+                this.applyInstant(entity, effectDef, attributeIndexCache);
+                appendGameplayCueEvents(this.runtime.gameplayCueBuffer, effectDef.cues, 'OnApplied', tick, pending.sourceEntityId, entity.id);
+                return;
+            case 'Duration':
+            case 'Periodic':
+                this.queueDurational(entity, effectDef, pending, attributeIndexCache, tick);
+                appendGameplayCueEvents(this.runtime.gameplayCueBuffer, effectDef.cues, 'OnApplied', tick, pending.sourceEntityId, entity.id);
+                if (effectDef.type === 'Periodic' &&
+                    effectDef.executePeriodicOnApplication === true) {
+                    this.applyInstant(entity, effectDef, attributeIndexCache);
+                    appendGameplayCueEvents(this.runtime.gameplayCueBuffer, effectDef.cues, 'OnPeriodic', tick, pending.sourceEntityId, entity.id);
+                }
+                return;
+        }
+    }
+    validateEffectOrThrow(effectDef, attributeIndexCache) {
+        if (effectDef.type === 'Duration' || effectDef.type === 'Periodic') {
+            const durationTicks = effectDef.durationTicks;
+            if (durationTicks === undefined || durationTicks <= 0) {
+                throw new Error(`EffectDef '${effectDef.id}' is type '${effectDef.type}' but has invalid durationTicks=${String(durationTicks)}`);
+            }
+        }
+        if (effectDef.type === 'Periodic') {
+            const periodTicks = effectDef.periodTicks;
+            if (periodTicks === undefined || periodTicks <= 0) {
+                throw new Error(`EffectDef '${effectDef.id}' is type 'Periodic' but has invalid periodTicks=${String(periodTicks)}`);
+            }
+        }
+        for (const modifier of effectDef.modifiers) {
+            this.resolveAttributeIndex(modifier.attributeId, attributeIndexCache);
+        }
+    }
+    checkTagPredicates(effectDef, tags) {
+        if (effectDef.tagsRequired) {
+            for (const tag of effectDef.tagsRequired) {
+                if (!tags.tags.has(tag)) {
+                    return false;
+                }
+            }
+        }
+        if (effectDef.tagsBlocked) {
+            for (const tag of effectDef.tagsBlocked) {
+                if (tags.tags.has(tag)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    grantTags(effectDef, tags) {
+        if (!effectDef.tagsGranted) {
+            return;
+        }
+        for (const tag of effectDef.tagsGranted) {
+            const current = tags.effectGrantCounts.get(tag) ?? 0;
+            tags.effectGrantCounts.set(tag, current + 1);
+            tags.tags.add(tag);
+        }
+    }
+    applyInstant(entity, effectDef, attributeIndexCache) {
+        const attributes = getAttributesComponent(entity);
+        if (!attributes) {
+            return;
+        }
+        for (const modifier of effectDef.modifiers) {
+            const index = this.resolveAttributeIndex(modifier.attributeId, attributeIndexCache);
+            const current = FP.FromRaw(attributes.base[index]);
+            const next = applyInstantModifier(current, modifier.op, modifier.magnitude);
+            attributes.base[index] = FP.ToRaw(next);
+            attributes.dirty[index] = 1;
+        }
+    }
+    queueDurational(entity, effectDef, pending, attributeIndexCache, tick) {
+        const activeEffects = getActiveEffectsComponent(entity);
+        if (!activeEffects) {
+            throw new Error('ActiveEffectsComponent missing while draining pendingAdd');
+        }
+        const durationTicksValidated = effectDef.durationTicks;
+        const nextPeriodTick = effectDef.type === 'Periodic' ? tick + effectDef.periodTicks : 0;
+        const instance = {
+            instanceId: this.runtime.instanceIdCounter.next(),
+            defId: effectDef.id,
+            remainingTicks: durationTicksValidated,
+            nextPeriodTick,
+            sourceEntityId: pending.sourceEntityId,
+            enteredOnTick: tick,
+        };
+        activeEffects.queue.push(instance);
+        this.markAttributesDirty(entity, effectDef.modifiers, attributeIndexCache);
+    }
+    markAttributesDirty(entity, modifiers, attributeIndexCache) {
+        if (modifiers.length === 0) {
+            return;
+        }
+        const attributes = getAttributesComponent(entity);
+        if (!attributes) {
+            return;
+        }
+        for (const modifier of modifiers) {
+            const index = this.resolveAttributeIndex(modifier.attributeId, attributeIndexCache);
+            attributes.dirty[index] = 1;
+        }
+    }
+    resolveAttributeIndex(attributeId, attributeIndexCache) {
+        const cached = attributeIndexCache.get(attributeId);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const index = this.registries.attributes.indexOf(attributeId);
+        attributeIndexCache.set(attributeId, index);
+        return index;
+    }
+    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;
+    }
+}
+function applyInstantModifier(value, op, magnitude) {
+    switch (op) {
+        case 'Add':
+            return FP.Add(value, magnitude);
+        case 'Multiply':
+            return FP.Mul(value, magnitude);
+        case 'Override':
+            return magnitude;
+    }
+}

package/dist/systems/EffectTickSystem.d.ts

@@ -0,0 +1,16 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import type { AbilitySystemRegistries } from '../registry';
+import type { AbilitySystemRuntime } from '../runtime';
+export declare class EffectTickSystem extends GameSystem {
+    private readonly registries;
+    private readonly runtime;
+    constructor(registries: AbilitySystemRegistries, runtime: AbilitySystemRuntime);
+    processTick(tick: number): void;
+    private tickEntity;
+    private processExpirations;
+    private firePeriodics;
+    private applyPeriodicPayload;
+    private revokeTags;
+    private markModifiersDirty;
+}
+//# sourceMappingURL=EffectTickSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EffectTickSystem.d.ts","sourceRoot":"","sources":["../../src/systems/EffectTickSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAajD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAE3D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAmCvD,qBAAa,gBAAiB,SAAQ,UAAU;IAE5C,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;IAgB/C,OAAO,CAAC,UAAU;IA4DlB,OAAO,CAAC,kBAAkB;IAuC1B,OAAO,CAAC,aAAa;IAmErB,OAAO,CAAC,oBAAoB;IAgB5B,OAAO,CAAC,UAAU;IA4BlB,OAAO,CAAC,kBAAkB;CAY3B"}

package/dist/systems/EffectTickSystem.js

@@ -0,0 +1,152 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import { FP } from '@phalanx-engine/math';
+import { AbilitiesComponentType, getActiveEffectsComponent, getAttributesComponent, getGameplayTagsComponent, } from '../components';
+import { appendGameplayCueEvents } from '../runtime';
+export class EffectTickSystem extends GameSystem {
+    registries;
+    runtime;
+    constructor(registries, runtime) {
+        super();
+        this.registries = registries;
+        this.runtime = runtime;
+    }
+    processTick(tick) {
+        const entities = this.entityManager.queryEntitiesAny(AbilitiesComponentType.AbilitySystem, AbilitiesComponentType.ActiveEffects);
+        for (const entity of entities) {
+            const activeEffects = getActiveEffectsComponent(entity);
+            if (!activeEffects || activeEffects.queue.length === 0) {
+                continue;
+            }
+            this.tickEntity(entity, activeEffects, tick);
+        }
+    }
+    tickEntity(entity, activeEffects, tick) {
+        const queue = activeEffects.queue;
+        this.firePeriodics(entity, queue, tick);
+        for (let i = 0; i < queue.length; i++) {
+            const instance = queue[i];
+            if (instance.enteredOnTick === tick) {
+                continue;
+            }
+            if (instance.remainingTicks > 0) {
+                instance.remainingTicks -= 1;
+            }
+        }
+        const expired = [];
+        let writeIndex = 0;
+        for (let readIndex = 0; readIndex < queue.length; readIndex++) {
+            const instance = queue[readIndex];
+            if (instance.remainingTicks <= 0) {
+                expired.push(instance);
+                continue;
+            }
+            if (writeIndex !== readIndex) {
+                queue[writeIndex] = instance;
+            }
+            writeIndex += 1;
+        }
+        queue.length = writeIndex;
+        if (expired.length === 0) {
+            return;
+        }
+        this.processExpirations(entity, activeEffects, expired, tick);
+    }
+    processExpirations(entity, activeEffects, expired, tick) {
+        const tags = getGameplayTagsComponent(entity);
+        const attributes = getAttributesComponent(entity);
+        for (const instance of expired) {
+            const effectDef = this.registries.effects.tryGet(instance.defId);
+            if (!effectDef) {
+                throw new Error(`EffectRegistry does not contain '${instance.defId}'`);
+            }
+            this.revokeTags(effectDef, tags, activeEffects.queue);
+            this.markModifiersDirty(effectDef, attributes);
+            appendGameplayCueEvents(this.runtime.gameplayCueBuffer, effectDef.cues, 'OnExpired', tick, instance.sourceEntityId, entity.id);
+        }
+    }
+    firePeriodics(entity, queue, tick) {
+        if (queue.length === 0) {
+            return;
+        }
+        let attributes;
+        for (let i = 0; i < queue.length; i++) {
+            const instance = queue[i];
+            if (instance.enteredOnTick === tick) {
+                continue;
+            }
+            if (instance.remainingTicks <= 0) {
+                continue;
+            }
+            if (tick < instance.nextPeriodTick) {
+                continue;
+            }
+            const effectDef = this.registries.effects.tryGet(instance.defId);
+            if (!effectDef) {
+                throw new Error(`EffectRegistry does not contain '${instance.defId}'`);
+            }
+            if (effectDef.type !== 'Periodic') {
+                continue;
+            }
+            const periodTicks = effectDef.periodTicks;
+            if (periodTicks === undefined || periodTicks <= 0) {
+                throw new Error(`EffectDef '${effectDef.id}' is Periodic but has invalid periodTicks=${String(periodTicks)}`);
+            }
+            if (attributes === undefined) {
+                attributes = getAttributesComponent(entity);
+            }
+            while (tick >= instance.nextPeriodTick) {
+                this.applyPeriodicPayload(effectDef, attributes);
+                appendGameplayCueEvents(this.runtime.gameplayCueBuffer, effectDef.cues, 'OnPeriodic', tick, instance.sourceEntityId, entity.id);
+                instance.nextPeriodTick += periodTicks;
+            }
+        }
+    }
+    applyPeriodicPayload(effectDef, attributes) {
+        if (!attributes || effectDef.modifiers.length === 0) {
+            return;
+        }
+        for (const modifier of effectDef.modifiers) {
+            const index = this.registries.attributes.indexOf(modifier.attributeId);
+            const current = FP.FromRaw(attributes.base[index]);
+            const next = applyPeriodicModifier(current, modifier.op, modifier.magnitude);
+            attributes.base[index] = FP.ToRaw(next);
+            attributes.dirty[index] = 1;
+        }
+    }
+    revokeTags(effectDef, tags, _remainingQueue) {
+        if (!tags || !effectDef.tagsGranted || effectDef.tagsGranted.length === 0) {
+            return;
+        }
+        for (const grantedTag of effectDef.tagsGranted) {
+            const current = tags.effectGrantCounts.get(grantedTag) ?? 0;
+            if (current <= 1) {
+                tags.effectGrantCounts.delete(grantedTag);
+                if (!tags.adHocTags.has(grantedTag)) {
+                    tags.tags.delete(grantedTag);
+                }
+            }
+            else {
+                tags.effectGrantCounts.set(grantedTag, current - 1);
+            }
+        }
+    }
+    markModifiersDirty(effectDef, attributes) {
+        if (!attributes || effectDef.modifiers.length === 0) {
+            return;
+        }
+        for (const modifier of effectDef.modifiers) {
+            const index = this.registries.attributes.indexOf(modifier.attributeId);
+            attributes.dirty[index] = 1;
+        }
+    }
+}
+function applyPeriodicModifier(value, op, magnitude) {
+    switch (op) {
+        case 'Add':
+            return FP.Add(value, magnitude);
+        case 'Multiply':
+            return FP.Mul(value, magnitude);
+        case 'Override':
+            return magnitude;
+    }
+}

package/dist/systems/index.d.ts

@@ -0,0 +1,9 @@
+export { AbilityActivationSystem } from './AbilityActivationSystem';
+export { AbilityHookExecutorSystem } from './AbilityHookExecutorSystem';
+export { AttributeAggregationSystem } from './AttributeAggregationSystem';
+export { CueBufferCleanupSystem } from './CueBufferCleanupSystem';
+export { CueDispatchSystem } from './CueDispatchSystem';
+export { CuePresentationSystem } from './CuePresentationSystem';
+export { EffectApplicationSystem } from './EffectApplicationSystem';
+export { EffectTickSystem } from './EffectTickSystem';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/systems/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/systems/index.js

@@ -0,0 +1,8 @@
+export { AbilityActivationSystem } from './AbilityActivationSystem';
+export { AbilityHookExecutorSystem } from './AbilityHookExecutorSystem';
+export { AttributeAggregationSystem } from './AttributeAggregationSystem';
+export { CueBufferCleanupSystem } from './CueBufferCleanupSystem';
+export { CueDispatchSystem } from './CueDispatchSystem';
+export { CuePresentationSystem } from './CuePresentationSystem';
+export { EffectApplicationSystem } from './EffectApplicationSystem';
+export { EffectTickSystem } from './EffectTickSystem';

package/dist/targeting/TargetResolver.d.ts

@@ -0,0 +1,19 @@
+import type { ProvidedTarget, TargetSpec } from '../types';
+export interface TargetResolutionInput {
+    casterEntityId: number;
+    spec: TargetSpec;
+    providedTarget?: ProvidedTarget;
+}
+export type TargetResolutionResult = {
+    dropped: false;
+    targets: number[];
+} | {
+    dropped: true;
+};
+export declare class TargetResolver {
+    constructor();
+    private static readonly DROPPED;
+    resolve(input: TargetResolutionInput): TargetResolutionResult;
+    private resolveEntityOrigin;
+}
+//# sourceMappingURL=TargetResolver.d.ts.map

package/dist/targeting/TargetResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TargetResolver.d.ts","sourceRoot":"","sources":["../../src/targeting/TargetResolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAgB,UAAU,EAAE,MAAM,UAAU,CAAC;AAMzE,MAAM,WAAW,qBAAqB;IAKpC,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,UAAU,CAAC;IAQjB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAkBD,MAAM,MAAM,sBAAsB,GAC9B;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,GACrC;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,CAAC;AAkBtB,qBAAa,cAAc;;IAOzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAA6C;IAErE,OAAO,CAAC,KAAK,EAAE,qBAAqB,GAAG,sBAAsB;IAyDpE,OAAO,CAAC,mBAAmB;CA2B5B"}

package/dist/targeting/TargetResolver.js

@@ -0,0 +1,45 @@
+export class TargetResolver {
+    constructor() { }
+    static DROPPED = { dropped: true };
+    resolve(input) {
+        const { spec } = input;
+        switch (spec.kind) {
+            case 'Self':
+                return { dropped: false, targets: [input.casterEntityId] };
+            case 'Entity': {
+                const resolved = this.resolveEntityOrigin(input.casterEntityId, spec.origin, input.providedTarget);
+                if (resolved.dropped) {
+                    return TargetResolver.DROPPED;
+                }
+                if (resolved.entityId === undefined) {
+                    return { dropped: false, targets: [] };
+                }
+                return { dropped: false, targets: [resolved.entityId] };
+            }
+            case 'Point': {
+                if (spec.origin.kind === 'Caller') {
+                    const provided = input.providedTarget;
+                    if (!provided || provided.x === undefined || provided.z === undefined) {
+                        return TargetResolver.DROPPED;
+                    }
+                }
+                return { dropped: false, targets: [] };
+            }
+        }
+    }
+    resolveEntityOrigin(casterId, origin, providedTarget) {
+        switch (origin.kind) {
+            case 'Caster':
+                return { dropped: false, entityId: casterId };
+            case 'TargetEntity':
+                return { dropped: false, entityId: origin.entityId };
+            case 'Caller':
+                if (providedTarget?.entityId === undefined) {
+                    return { dropped: true };
+                }
+                return { dropped: false, entityId: providedTarget.entityId };
+            case 'Point':
+                throw new Error("TargetOrigin.kind === 'Point' is not valid for TargetSpec.kind === 'Entity'.");
+        }
+    }
+}

package/dist/targeting/index.d.ts

@@ -0,0 +1,3 @@
+export { TargetResolver } from './TargetResolver';
+export type { TargetResolutionInput, TargetResolutionResult } from './TargetResolver';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/targeting/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,YAAY,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/targeting/index.js

@@ -0,0 +1 @@
+export { TargetResolver } from './TargetResolver';

package/dist/types/AbilityDef.d.ts

@@ -0,0 +1,13 @@
+import type { TargetSpec } from './TargetSpec';
+export interface AbilityDef {
+    id: string;
+    costEffectId?: string;
+    cooldownEffectId?: string;
+    tagsRequired?: string[];
+    activationBlockedTags?: string[];
+    selfEffectIds?: string[];
+    targetEffectIds?: string[];
+    target: TargetSpec;
+    hookId?: string;
+}
+//# sourceMappingURL=AbilityDef.d.ts.map

package/dist/types/AbilityDef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbilityDef.d.ts","sourceRoot":"","sources":["../../src/types/AbilityDef.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/types/AbilityDef.js

@@ -0,0 +1 @@
+export {};

package/dist/types/AbilityHook.d.ts

@@ -0,0 +1,10 @@
+import type { ProvidedTarget } from './TargetSpec';
+export interface AbilityActivationContext {
+    abilityId: string;
+    casterEntityId: number;
+    resolvedTargets: number[];
+    providedTarget?: ProvidedTarget;
+    tick: number;
+}
+export type AbilityHook = (ctx: AbilityActivationContext) => void;
+//# sourceMappingURL=AbilityHook.d.ts.map

package/dist/types/AbilityHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbilityHook.d.ts","sourceRoot":"","sources":["../../src/types/AbilityHook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,wBAAwB,KAAK,IAAI,CAAC"}

package/dist/types/AbilityHook.js

@@ -0,0 +1 @@
+export {};

package/dist/types/ActiveEffectInstance.d.ts

@@ -0,0 +1,9 @@
+export interface ActiveEffectInstance {
+    instanceId: number;
+    defId: string;
+    remainingTicks: number;
+    nextPeriodTick: number;
+    sourceEntityId: number;
+    enteredOnTick: number;
+}
+//# sourceMappingURL=ActiveEffectInstance.d.ts.map

package/dist/types/ActiveEffectInstance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActiveEffectInstance.d.ts","sourceRoot":"","sources":["../../src/types/ActiveEffectInstance.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IAEnC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IASvB,cAAc,EAAE,MAAM,CAAC;IAOvB,cAAc,EAAE,MAAM,CAAC;IAOvB,aAAa,EAAE,MAAM,CAAC;CACvB"}

package/dist/types/ActiveEffectInstance.js

@@ -0,0 +1 @@
+export {};

package/dist/types/AttributeDef.d.ts

@@ -0,0 +1,10 @@
+import type { FixedPoint } from '@phalanx-engine/math';
+export type AttributeClampMode = 'both' | 'min' | 'max' | 'none';
+export interface AttributeDef {
+    id: string;
+    default: FixedPoint;
+    min: FixedPoint;
+    max: FixedPoint;
+    clamp: AttributeClampMode;
+}
+//# sourceMappingURL=AttributeDef.d.ts.map

package/dist/types/AttributeDef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeDef.d.ts","sourceRoot":"","sources":["../../src/types/AttributeDef.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;AAEjE,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,UAAU,CAAC;IACpB,GAAG,EAAE,UAAU,CAAC;IAChB,GAAG,EAAE,UAAU,CAAC;IAChB,KAAK,EAAE,kBAAkB,CAAC;CAC3B"}

package/dist/types/AttributeDef.js

@@ -0,0 +1 @@
+export {};

package/dist/types/CueEvent.d.ts

@@ -0,0 +1,9 @@
+export type CuePhase = 'OnApplied' | 'OnPeriodic' | 'OnExpired';
+export interface CueEvent {
+    tick: number;
+    cueId: string;
+    sourceEntityId: number;
+    targetEntityId: number;
+    phase: CuePhase;
+}
+//# sourceMappingURL=CueEvent.d.ts.map

package/dist/types/CueEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CueEvent.d.ts","sourceRoot":"","sources":["../../src/types/CueEvent.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,WAAW,GAAG,YAAY,GAAG,WAAW,CAAC;AAEhE,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,QAAQ,CAAC;CACjB"}

package/dist/types/CueEvent.js

@@ -0,0 +1 @@
+export {};

package/dist/types/EffectDef.d.ts

@@ -0,0 +1,23 @@
+import type { CuePhase } from './CueEvent';
+import type { Modifier } from './ModifierOp';
+export type EffectType = 'Instant' | 'Duration' | 'Periodic';
+export interface EffectCues {
+    onApplied?: string[];
+    onPeriodic?: string[];
+    onExpired?: string[];
+}
+export type EffectCueSpec = EffectCues | string[];
+export interface EffectDef {
+    id: string;
+    type: EffectType;
+    durationTicks?: number;
+    periodTicks?: number;
+    executePeriodicOnApplication?: boolean;
+    modifiers: Modifier[];
+    tagsGranted?: string[];
+    tagsRequired?: string[];
+    tagsBlocked?: string[];
+    cues?: EffectCueSpec;
+}
+export declare function getCueIdsForPhase(cues: EffectCueSpec | undefined, phase: CuePhase): readonly string[];
+//# sourceMappingURL=EffectDef.d.ts.map

package/dist/types/EffectDef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectDef.d.ts","sourceRoot":"","sources":["../../src/types/EffectDef.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC;AAE7D,MAAM,WAAW,UAAU;IACzB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,MAAM,EAAE,CAAC;AAIlD,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,UAAU,CAAC;IAEjB,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,aAAa,GAAG,SAAS,EAC/B,KAAK,EAAE,QAAQ,GACd,SAAS,MAAM,EAAE,CAenB"}

package/dist/types/EffectDef.js

@@ -0,0 +1,17 @@
+const EMPTY_CUE_IDS = [];
+export function getCueIdsForPhase(cues, phase) {
+    if (!cues) {
+        return EMPTY_CUE_IDS;
+    }
+    if (Array.isArray(cues)) {
+        return phase === 'OnApplied' ? cues : EMPTY_CUE_IDS;
+    }
+    switch (phase) {
+        case 'OnApplied':
+            return cues.onApplied ?? EMPTY_CUE_IDS;
+        case 'OnPeriodic':
+            return cues.onPeriodic ?? EMPTY_CUE_IDS;
+        case 'OnExpired':
+            return cues.onExpired ?? EMPTY_CUE_IDS;
+    }
+}

package/dist/types/ModifierOp.d.ts

@@ -0,0 +1,8 @@
+import type { FixedPoint } from '@phalanx-engine/math';
+export type ModifierOp = 'Add' | 'Multiply' | 'Override';
+export interface Modifier {
+    attributeId: string;
+    op: ModifierOp;
+    magnitude: FixedPoint;
+}
+//# sourceMappingURL=ModifierOp.d.ts.map

package/dist/types/ModifierOp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModifierOp.d.ts","sourceRoot":"","sources":["../../src/types/ModifierOp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,UAAU,GAAG,UAAU,CAAC;AAEzD,MAAM,WAAW,QAAQ;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,EAAE,EAAE,UAAU,CAAC;IACf,SAAS,EAAE,UAAU,CAAC;CACvB"}

package/dist/types/ModifierOp.js

@@ -0,0 +1 @@
+export {};

package/dist/types/TargetSpec.d.ts

@@ -0,0 +1,32 @@
+import type { FixedPoint } from '@phalanx-engine/math';
+export type TargetOrigin = {
+    kind: 'Caster';
+} | {
+    kind: 'TargetEntity';
+    entityId: number;
+} | {
+    kind: 'Point';
+    x: FixedPoint;
+    z: FixedPoint;
+} | {
+    kind: 'Caller';
+};
+export interface TargetFilter {
+    tagsRequired?: string[];
+    tagsBlocked?: string[];
+}
+export type TargetSpec = {
+    kind: 'Self';
+} | {
+    kind: 'Entity';
+    origin: TargetOrigin;
+} | {
+    kind: 'Point';
+    origin: TargetOrigin;
+};
+export interface ProvidedTarget {
+    entityId?: number;
+    x?: FixedPoint;
+    z?: FixedPoint;
+}
+//# sourceMappingURL=TargetSpec.d.ts.map

package/dist/types/TargetSpec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TargetSpec.d.ts","sourceRoot":"","sources":["../../src/types/TargetSpec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,CAAC,EAAE,UAAU,CAAC;IAAC,CAAC,EAAE,UAAU,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEvB,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC;AAE5C,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,CAAC,CAAC,EAAE,UAAU,CAAC;IACf,CAAC,CAAC,EAAE,UAAU,CAAC;CAChB"}

package/dist/types/TargetSpec.js

@@ -0,0 +1 @@
+export {};