@jgengine/core 0.8.0 → 0.9.0

package/dist/cartridge/spec.d.ts

@@ -0,0 +1,188 @@
+import type { SpawnDirectorConfig } from "../ai/spawnDirector.js";
+import type { Curve } from "../game/progression.js";
+import type { ActionCodesMap } from "../input/actionBindings.js";
+import type { GameContext } from "../runtime/gameContext.js";
+export type Leveled = number | {
+    base: number;
+    perLevel: number;
+    min?: number;
+    max?: number;
+} | {
+    table: readonly number[];
+};
+export declare function leveled(value: Leveled, level: number): number;
+export interface CartridgePlayer {
+    kind: string;
+    health: number;
+    walkSpeed: number;
+    spawnAt?: readonly [number, number, number];
+}
+export interface CartridgeEnemy {
+    label: string;
+    health: number;
+    walkSpeed: number;
+    xp: number;
+    contact: {
+        damage: number;
+        intervalSeconds: number;
+    };
+    behavior?: "chase" | "none";
+}
+export interface CartridgeFlow {
+    start?: "auto" | "gate";
+    countdownSeconds?: number;
+    restart?: boolean;
+}
+export interface WeaponCommon {
+    label: string;
+    damage: Leveled;
+    cooldownMs: Leveled;
+    maxLevel: number;
+    fxColor?: string;
+    fxEmissive?: string;
+}
+export type CartridgeWeapon = (WeaponCommon & {
+    kind: "projectile";
+    range: number;
+    speed: number;
+}) | (WeaponCommon & {
+    kind: "orbit";
+    blades: Leveled;
+    radius: Leveled;
+    hitRadius: number;
+    angularSpeed: number;
+}) | (WeaponCommon & {
+    kind: "pulse";
+    radius: Leveled;
+    durationSeconds: number;
+}) | (WeaponCommon & {
+    kind: "custom";
+    fire(ctx: GameContext, run: CartridgeRun, args: WeaponFireArgs): void;
+});
+export interface WeaponFireArgs {
+    weaponId: string;
+    level: number;
+    damage: number;
+    playerId: string;
+    playerPosition: readonly [number, number, number];
+    enemyIds: readonly string[];
+    dt: number;
+}
+export type UpgradeEffect = {
+    kind: "weaponLevel";
+    weapon: string;
+} | {
+    kind: "statBonus";
+    stat: string;
+    amount: number;
+} | {
+    kind: "fieldAdd";
+    field: string;
+    amount: number;
+} | {
+    kind: "fieldMultiply";
+    field: string;
+    factor: number;
+} | {
+    kind: "custom";
+    apply(ctx: GameContext, run: CartridgeRun, stacks: number): void;
+};
+export interface CartridgeUpgrade {
+    id: string;
+    label: string;
+    weight: number;
+    maxStacks: number;
+    effect: UpgradeEffect;
+}
+export interface CartridgeProgression {
+    xp: Curve;
+    maxLevel: number;
+    draft: {
+        choices: number;
+        upgrades: readonly CartridgeUpgrade[];
+    };
+}
+export interface CartridgeSpawning {
+    director: SpawnDirectorConfig;
+    placement: {
+        kind: "ring";
+        radius: number;
+    } | {
+        kind: "custom";
+        position(ctx: GameContext, run: CartridgeRun): readonly [number, number, number];
+    };
+}
+export interface CartridgeXpGems {
+    collectRadius: number;
+    pullSpeed: number;
+    rarityThresholds: readonly (readonly [number, string])[];
+    defaultRarity: string;
+}
+export interface CartridgeRules {
+    win?: {
+        kind: "survive";
+        seconds: number;
+    } | {
+        kind: "custom";
+        check(ctx: GameContext, run: CartridgeRun): boolean;
+    };
+    lose?: {
+        kind: "playerDeath";
+    } | {
+        kind: "custom";
+        check(ctx: GameContext, run: CartridgeRun): boolean;
+    };
+    killLeaderboardStat?: string;
+}
+export interface CartridgeSpec {
+    seed?: string | number;
+    flow?: CartridgeFlow;
+    player: CartridgePlayer;
+    enemies: Record<string, CartridgeEnemy>;
+    combat: {
+        contactRadius: number;
+    };
+    spawning: CartridgeSpawning;
+    weapons: Record<string, CartridgeWeapon>;
+    progression: CartridgeProgression;
+    xpGems: CartridgeXpGems;
+    rules: CartridgeRules;
+    fields?: Record<string, number>;
+    input?: ActionCodesMap;
+    systems?: readonly ((ctx: GameContext, run: CartridgeRun, dt: number) => void)[];
+}
+export interface BoltFx {
+    id: number;
+    weaponId: string;
+    origin: readonly [number, number, number];
+    target: readonly [number, number, number];
+    firedAt: number;
+    travelSeconds: number;
+}
+export interface PulseFx {
+    id: number;
+    weaponId: string;
+    at: readonly [number, number, number];
+    firedAt: number;
+    durationSeconds: number;
+    maxRadius: number;
+}
+export type CartridgePhase = "start" | "countdown" | "playing" | "won" | "lost";
+export interface CartridgeRun {
+    phase: CartridgePhase;
+    playingSeconds: number;
+    countdownRemaining: number;
+    kills: number;
+    weaponLevel(weaponId: string): number;
+    field(name: string): number;
+    pendingOffers: readonly {
+        id: string;
+        label: string;
+    }[] | null;
+    bolts: readonly BoltFx[];
+    pulses: readonly PulseFx[];
+    subscribe(listener: () => void): () => void;
+}
+export declare const WASD_KEYBINDS: ActionCodesMap;
+export declare const XP_GEM_BASE_TYPE = "xp_gem";
+export declare const HIT_EFFECT = "hit";

package/dist/cartridge/spec.js

@@ -0,0 +1,19 @@
+export function leveled(value, level) {
+    if (typeof value === "number")
+        return value;
+    if ("table" in value) {
+        const index = Math.min(value.table.length - 1, Math.max(0, level - 1));
+        return value.table[index] ?? 0;
+    }
+    const raw = value.base + value.perLevel * (level - 1);
+    const floored = value.min === undefined ? raw : Math.max(value.min, raw);
+    return value.max === undefined ? floored : Math.min(value.max, floored);
+}
+export const WASD_KEYBINDS = {
+    moveForward: ["KeyW"],
+    moveBack: ["KeyS"],
+    moveLeft: ["KeyA"],
+    moveRight: ["KeyD"],
+};
+export const XP_GEM_BASE_TYPE = "xp_gem";
+export const HIT_EFFECT = "hit";

package/dist/cartridge/validate.d.ts

@@ -0,0 +1,2 @@
+import { type CartridgeSpec } from "./spec.js";
+export declare function validateCartridge(spec: CartridgeSpec): string[];

package/dist/cartridge/validate.js

@@ -0,0 +1,78 @@
+import { leveled } from "./spec.js";
+export function validateCartridge(spec) {
+    const problems = [];
+    const enemyIds = new Set(Object.keys(spec.enemies));
+    const weaponIds = new Set(Object.keys(spec.weapons));
+    if (spec.player.health <= 0)
+        problems.push(`player "${spec.player.kind}": health must be positive`);
+    if (spec.player.walkSpeed <= 0)
+        problems.push(`player "${spec.player.kind}": walkSpeed must be positive`);
+    if (enemyIds.has(spec.player.kind))
+        problems.push(`player kind "${spec.player.kind}" collides with an enemy id`);
+    if (spec.flow?.countdownSeconds !== undefined && spec.flow.countdownSeconds < 0) {
+        problems.push("flow.countdownSeconds must not be negative");
+    }
+    for (const [id, enemy] of Object.entries(spec.enemies)) {
+        if (enemy.health <= 0)
+            problems.push(`enemy "${id}": health must be positive`);
+        if (enemy.walkSpeed <= 0)
+            problems.push(`enemy "${id}": walkSpeed must be positive`);
+        if (enemy.xp <= 0)
+            problems.push(`enemy "${id}": xp must be positive`);
+        if (enemy.contact.damage <= 0)
+            problems.push(`enemy "${id}": contact.damage must be positive`);
+        if (enemy.contact.intervalSeconds <= 0)
+            problems.push(`enemy "${id}": contact.intervalSeconds must be positive`);
+    }
+    for (const wave of spec.spawning.director.waves) {
+        for (const entry of wave.entries) {
+            if (!enemyIds.has(entry.id))
+                problems.push(`spawning wave references unknown enemy "${entry.id}"`);
+        }
+    }
+    for (const [id, weapon] of Object.entries(spec.weapons)) {
+        for (let level = 1; level <= weapon.maxLevel; level += 1) {
+            if (leveled(weapon.damage, level) <= 0)
+                problems.push(`weapon "${id}": damage at level ${level} must be positive`);
+            if (leveled(weapon.cooldownMs, level) <= 0)
+                problems.push(`weapon "${id}": cooldownMs at level ${level} must be positive`);
+        }
+    }
+    const seenUpgrades = new Set();
+    for (const upgrade of spec.progression.draft.upgrades) {
+        if (seenUpgrades.has(upgrade.id))
+            problems.push(`upgrade "${upgrade.id}": duplicate id`);
+        seenUpgrades.add(upgrade.id);
+        if (upgrade.maxStacks <= 0)
+            problems.push(`upgrade "${upgrade.id}": maxStacks must be positive`);
+        const effect = upgrade.effect;
+        if (effect.kind === "weaponLevel") {
+            if (!weaponIds.has(effect.weapon)) {
+                problems.push(`upgrade "${upgrade.id}": references unknown weapon "${effect.weapon}"`);
+            }
+            else {
+                const weapon = spec.weapons[effect.weapon];
+                if (1 + upgrade.maxStacks > weapon.maxLevel) {
+                    problems.push(`upgrade "${upgrade.id}": maxStacks ${upgrade.maxStacks} exceeds weapon "${effect.weapon}" maxLevel ${weapon.maxLevel}`);
+                }
+            }
+        }
+        if ((effect.kind === "fieldAdd" || effect.kind === "fieldMultiply") && spec.fields?.[effect.field] === undefined) {
+            problems.push(`upgrade "${upgrade.id}": references undeclared field "${effect.field}"`);
+        }
+    }
+    if (spec.progression.draft.choices <= 0)
+        problems.push("progression.draft.choices must be positive");
+    if (spec.progression.maxLevel <= 1)
+        problems.push("progression.maxLevel must exceed 1");
+    const thresholds = spec.xpGems.rarityThresholds;
+    for (let i = 1; i < thresholds.length; i += 1) {
+        if (thresholds[i][0] >= thresholds[i - 1][0]) {
+            problems.push("xpGems.rarityThresholds must be sorted by descending value");
+        }
+    }
+    if (spec.rules.win?.kind === "survive" && spec.rules.win.seconds <= 0) {
+        problems.push("rules.win.seconds must be positive");
+    }
+    return problems;
+}

package/dist/combat/abilityKit.d.ts

@@ -7,6 +7,16 @@ export interface AbilitySlotConfig {
     resourceCost?: number;
     castType?: AbilityCastType;
     flashMs?: number;
+    /** Shared cooldown groups this slot participates in — ids declared in `AbilityKitOptions.groups`. */
+    groups?: readonly string[];
+}
+/** A cooldown shared across every member slot: casting any member starts it, and no member can cast while it runs. One group that every slot joins is an MMO global cooldown. */
+export interface AbilityCooldownGroup {
+    id: string;
+    cooldownMs: number;
+}
+export interface AbilityKitOptions {
+    groups?: readonly AbilityCooldownGroup[];
 }
 export interface AbilitySlotSnapshot {
     id: string;
@@ -15,12 +25,15 @@ export interface AbilitySlotSnapshot {
     resourceCost: number;
     charges: number;
     chargesMax: number;
+    /** Max of the slot's own recharge and any blocking group cooldown. */
     cooldownRemainingMs: number;
     cooldownFraction: number;
+    /** Remaining ms on the slowest of the slot's shared cooldown groups; 0 when unblocked. */
+    groupRemainingMs: number;
     justCast: boolean;
     ready: boolean;
 }
-export type AbilityCastReason = "unknown-slot" | "cooldown" | "no-resource";
+export type AbilityCastReason = "unknown-slot" | "cooldown" | "group-cooldown" | "no-resource";
 export interface AbilitySlotRetune {
     cooldownMs?: number;
     resourceCost?: number;
@@ -41,7 +54,9 @@ export interface AbilityKit {
     canCast(slotId: string, resourceAvailable?: number): AbilityCastResult;
     cast(slotId: string, resourceAvailable?: number): AbilityCastResult;
     tick(dtSeconds: number): void;
+    /** Remaining ms on a shared cooldown group; 0 when ready, null for an unknown group. */
+    groupRemaining(groupId: string): number | null;
     reset(slotId?: string): void;
     retuneSlot(slotId: string, patch: AbilitySlotRetune): boolean;
 }
-export declare function createAbilityKit(configs: readonly AbilitySlotConfig[]): AbilityKit;
+export declare function createAbilityKit(configs: readonly AbilitySlotConfig[], options?: AbilityKitOptions): AbilityKit;

package/dist/combat/abilityKit.js

@@ -7,21 +7,24 @@ function normalizeConfig(config) {
         resourceCost: Math.max(0, config.resourceCost ?? 0),
         castType: config.castType ?? "instant",
         flashMs: Math.max(0, config.flashMs ?? DEFAULT_FLASH_MS),
+        groups: config.groups ?? [],
     };
 }
-function deriveState(runtime, resourceAvailable) {
+function deriveState(runtime, resourceAvailable, group) {
     if (runtime.flashRemainingMs > 0)
         return "just-cast";
     if (runtime.charges <= 0)
         return "cooldown";
+    if (group.remainingMs > 0)
+        return "cooldown";
     if (resourceAvailable < runtime.config.resourceCost)
         return "no-resource";
     return "ready";
 }
-function snapshotOf(runtime, resourceAvailable) {
+function snapshotOf(runtime, resourceAvailable, group) {
     const { config } = runtime;
-    const state = deriveState(runtime, resourceAvailable);
-    const cooldownFraction = config.cooldownMs <= 0 ? 0 : Math.max(0, Math.min(1, runtime.rechargeRemainingMs / config.cooldownMs));
+    const state = deriveState(runtime, resourceAvailable, group);
+    const ownFraction = config.cooldownMs <= 0 ? 0 : Math.max(0, Math.min(1, runtime.rechargeRemainingMs / config.cooldownMs));
     return {
         id: config.id,
         state,
@@ -29,19 +32,33 @@ function snapshotOf(runtime, resourceAvailable) {
         resourceCost: config.resourceCost,
         charges: runtime.charges,
         chargesMax: config.chargesMax,
-        cooldownRemainingMs: runtime.rechargeRemainingMs,
-        cooldownFraction,
+        cooldownRemainingMs: Math.max(runtime.rechargeRemainingMs, group.remainingMs),
+        cooldownFraction: Math.max(ownFraction, group.fraction),
+        groupRemainingMs: group.remainingMs,
         justCast: runtime.flashRemainingMs > 0,
-        ready: runtime.charges > 0 && resourceAvailable >= config.resourceCost,
+        ready: runtime.charges > 0 && group.remainingMs <= 0 && resourceAvailable >= config.resourceCost,
     };
 }
-export function createAbilityKit(configs) {
+export function createAbilityKit(configs, options = {}) {
+    const groupCooldowns = new Map();
+    const groupRemaining = new Map();
+    for (const group of options.groups ?? []) {
+        if (groupCooldowns.has(group.id))
+            throw new Error(`duplicate cooldown group: ${group.id}`);
+        groupCooldowns.set(group.id, Math.max(0, group.cooldownMs));
+        groupRemaining.set(group.id, 0);
+    }
     const runtimes = new Map();
     const order = [];
     for (const config of configs) {
         const normalized = normalizeConfig(config);
         if (runtimes.has(normalized.id))
             throw new Error(`duplicate ability slot: ${normalized.id}`);
+        for (const groupId of normalized.groups) {
+            if (!groupCooldowns.has(groupId)) {
+                throw new Error(`ability slot "${normalized.id}" references unknown cooldown group "${groupId}"`);
+            }
+        }
         runtimes.set(normalized.id, {
             config: normalized,
             charges: normalized.chargesMax,
@@ -50,9 +67,22 @@ export function createAbilityKit(configs) {
         });
         order.push(normalized.id);
     }
+    function groupBlockOf(runtime) {
+        let remainingMs = 0;
+        let fraction = 0;
+        for (const groupId of runtime.config.groups) {
+            const remaining = groupRemaining.get(groupId) ?? 0;
+            if (remaining <= remainingMs)
+                continue;
+            remainingMs = remaining;
+            const cooldownMs = groupCooldowns.get(groupId) ?? 0;
+            fraction = cooldownMs <= 0 ? 0 : Math.max(0, Math.min(1, remaining / cooldownMs));
+        }
+        return { remainingMs, fraction };
+    }
     function fail(slotId, reason, resourceAvailable) {
         const runtime = runtimes.get(slotId);
-        return { ok: false, reason, slot: runtime ? snapshotOf(runtime, resourceAvailable) : null };
+        return { ok: false, reason, slot: runtime ? snapshotOf(runtime, resourceAvailable, groupBlockOf(runtime)) : null };
     }
     function evaluate(slotId, resourceAvailable) {
         const runtime = runtimes.get(slotId);
@@ -60,9 +90,11 @@ export function createAbilityKit(configs) {
             return fail(slotId, "unknown-slot", resourceAvailable);
         if (runtime.charges <= 0)
             return fail(slotId, "cooldown", resourceAvailable);
+        if (groupBlockOf(runtime).remainingMs > 0)
+            return fail(slotId, "group-cooldown", resourceAvailable);
         if (resourceAvailable < runtime.config.resourceCost)
             return fail(slotId, "no-resource", resourceAvailable);
-        return { ok: true, slot: snapshotOf(runtime, resourceAvailable) };
+        return { ok: true, slot: snapshotOf(runtime, resourceAvailable, groupBlockOf(runtime)) };
     }
     return {
         slots() {
@@ -73,10 +105,13 @@ export function createAbilityKit(configs) {
         },
         state(slotId, resourceAvailable = Number.POSITIVE_INFINITY) {
             const runtime = runtimes.get(slotId);
-            return runtime === undefined ? null : snapshotOf(runtime, resourceAvailable);
+            return runtime === undefined ? null : snapshotOf(runtime, resourceAvailable, groupBlockOf(runtime));
         },
         snapshot(resourceAvailable = Number.POSITIVE_INFINITY) {
-            return order.map((slotId) => snapshotOf(runtimes.get(slotId), resourceAvailable));
+            return order.map((slotId) => {
+                const runtime = runtimes.get(slotId);
+                return snapshotOf(runtime, resourceAvailable, groupBlockOf(runtime));
+            });
         },
         canCast(slotId, resourceAvailable = Number.POSITIVE_INFINITY) {
             return evaluate(slotId, resourceAvailable);
@@ -90,12 +125,19 @@ export function createAbilityKit(configs) {
             if (runtime.rechargeRemainingMs <= 0)
                 runtime.rechargeRemainingMs = runtime.config.cooldownMs;
             runtime.flashRemainingMs = runtime.config.flashMs;
-            return { ok: true, slot: snapshotOf(runtime, resourceAvailable) };
+            for (const groupId of runtime.config.groups) {
+                groupRemaining.set(groupId, groupCooldowns.get(groupId) ?? 0);
+            }
+            return { ok: true, slot: snapshotOf(runtime, resourceAvailable, groupBlockOf(runtime)) };
         },
         tick(dtSeconds) {
             if (dtSeconds <= 0)
                 return;
             const dtMs = dtSeconds * 1000;
+            for (const [groupId, remaining] of groupRemaining) {
+                if (remaining > 0)
+                    groupRemaining.set(groupId, Math.max(0, remaining - dtMs));
+            }
             for (const runtime of runtimes.values()) {
                 if (runtime.flashRemainingMs > 0)
                     runtime.flashRemainingMs = Math.max(0, runtime.flashRemainingMs - dtMs);
@@ -117,6 +159,9 @@ export function createAbilityKit(configs) {
                 runtime.rechargeRemainingMs = runtime.charges >= runtime.config.chargesMax ? 0 : remaining;
             }
         },
+        groupRemaining(groupId) {
+            return groupCooldowns.has(groupId) ? groupRemaining.get(groupId) ?? 0 : null;
+        },
         reset(slotId) {
             const targets = slotId === undefined ? runtimes.values() : [runtimes.get(slotId)].filter((r) => r !== undefined);
             for (const runtime of targets) {
@@ -124,6 +169,10 @@ export function createAbilityKit(configs) {
                 runtime.rechargeRemainingMs = 0;
                 runtime.flashRemainingMs = 0;
             }
+            if (slotId === undefined) {
+                for (const groupId of groupRemaining.keys())
+                    groupRemaining.set(groupId, 0);
+            }
         },
         retuneSlot(slotId, patch) {
             const runtime = runtimes.get(slotId);

package/dist/combat/castRunner.d.ts

@@ -0,0 +1,40 @@
+export interface CastConfig {
+    abilityId: string;
+    castTimeMs: number;
+    /** Total movement distance tolerated before the cast auto-interrupts; default `0.04`. `Infinity` allows casting on the move. */
+    moveTolerance?: number;
+}
+export interface CastBarSnapshot {
+    abilityId: string;
+    castTimeMs: number;
+    elapsedMs: number;
+    remainingMs: number;
+    /** Fill fraction in `[0, 1]` for the cast bar. */
+    fraction: number;
+}
+export type CastInterruptReason = "moved" | "cancelled" | "replaced";
+export type CastEvent = {
+    kind: "completed";
+    abilityId: string;
+} | {
+    kind: "interrupted";
+    abilityId: string;
+    reason: CastInterruptReason;
+};
+/**
+ * Per-entity cast-time state machine — begin, tick with game-time `dt` plus how far the caster
+ * moved, and act on the returned event. The runner owns timing and move-interruption only; the
+ * caller spends resources, starts cooldowns, and executes the ability when `completed` fires
+ * (compose with `abilityKit` — check readiness before `begin`, `cast` on completion).
+ */
+export interface CastRunner {
+    /** Start a cast; `false` while one is already in flight (interrupt or let it finish first). */
+    begin(config: CastConfig): boolean;
+    casting(): boolean;
+    state(): CastBarSnapshot | null;
+    /** Interrupt the in-flight cast now; returns the interruption event, or `null` when idle. */
+    interrupt(reason?: CastInterruptReason): CastEvent | null;
+    /** Advance by `dtSeconds`; `movedDistance` accumulates toward the config's `moveTolerance`. */
+    tick(dtSeconds: number, movedDistance?: number): CastEvent | null;
+}
+export declare function createCastRunner(): CastRunner;

package/dist/combat/castRunner.js

@@ -0,0 +1,56 @@
+const DEFAULT_MOVE_TOLERANCE = 0.04;
+export function createCastRunner() {
+    let active = null;
+    function snapshot() {
+        if (active === null)
+            return null;
+        const fraction = active.castTimeMs <= 0 ? 1 : Math.min(1, active.elapsedMs / active.castTimeMs);
+        return {
+            abilityId: active.abilityId,
+            castTimeMs: active.castTimeMs,
+            elapsedMs: active.elapsedMs,
+            remainingMs: Math.max(0, active.castTimeMs - active.elapsedMs),
+            fraction,
+        };
+    }
+    return {
+        begin(config) {
+            if (active !== null)
+                return false;
+            active = {
+                abilityId: config.abilityId,
+                castTimeMs: Math.max(0, config.castTimeMs),
+                moveTolerance: config.moveTolerance ?? DEFAULT_MOVE_TOLERANCE,
+                elapsedMs: 0,
+                movedTotal: 0,
+            };
+            return true;
+        },
+        casting: () => active !== null,
+        state: snapshot,
+        interrupt(reason = "cancelled") {
+            if (active === null)
+                return null;
+            const abilityId = active.abilityId;
+            active = null;
+            return { kind: "interrupted", abilityId, reason };
+        },
+        tick(dtSeconds, movedDistance = 0) {
+            if (active === null)
+                return null;
+            active.movedTotal += Math.max(0, movedDistance);
+            if (active.movedTotal > active.moveTolerance) {
+                const abilityId = active.abilityId;
+                active = null;
+                return { kind: "interrupted", abilityId, reason: "moved" };
+            }
+            active.elapsedMs += Math.max(0, dtSeconds) * 1000;
+            if (active.elapsedMs >= active.castTimeMs) {
+                const abilityId = active.abilityId;
+                active = null;
+                return { kind: "completed", abilityId };
+            }
+            return null;
+        },
+    };
+}

package/dist/combat/comboPoints.d.ts

@@ -0,0 +1,14 @@
+export interface ComboPointsConfig {
+    max: number;
+    expireAfterSeconds?: number;
+}
+export interface ComboPoints {
+    points(): number;
+    gain(amount?: number): number;
+    spend(amount: number): boolean;
+    spendAll(): number;
+    tick(dtSeconds: number): void;
+    expiresIn(): number | null;
+    clear(): void;
+}
+export declare function createComboPoints(config: ComboPointsConfig): ComboPoints;

package/dist/combat/comboPoints.js

@@ -0,0 +1,52 @@
+export function createComboPoints(config) {
+    const max = config.max;
+    const expireAfterSeconds = config.expireAfterSeconds;
+    let current = 0;
+    let remaining = null;
+    return {
+        points() {
+            return current;
+        },
+        gain(amount = 1) {
+            if (amount <= 0)
+                return current;
+            current = Math.min(max, current + amount);
+            remaining = expireAfterSeconds !== undefined ? expireAfterSeconds : null;
+            return current;
+        },
+        spend(amount) {
+            if (amount <= 0)
+                return true;
+            if (amount > current)
+                return false;
+            current -= amount;
+            if (current <= 0)
+                remaining = null;
+            return true;
+        },
+        spendAll() {
+            const spent = current;
+            current = 0;
+            remaining = null;
+            return spent;
+        },
+        tick(dtSeconds) {
+            if (dtSeconds <= 0 || remaining === null)
+                return;
+            remaining -= dtSeconds;
+            if (remaining <= 0) {
+                current = 0;
+                remaining = null;
+            }
+        },
+        expiresIn() {
+            if (current <= 0 || remaining === null)
+                return null;
+            return remaining;
+        },
+        clear() {
+            current = 0;
+            remaining = null;
+        },
+    };
+}

package/dist/combat/defensiveWindow.d.ts

@@ -27,7 +27,7 @@ export declare function resolveDefense(input: ResolveDefenseInput): DefenseResol
 export interface DefensiveWindow {
     open(nowMs: number): void;
     close(): void;
-    isOpen(): boolean;
+    isOpen(nowMs: number): boolean;
     evaluate(nowMs: number, attack: AttackMeta): DefenseResolution;
     isInvulnerable(nowMs: number): boolean;
 }