@jgengine/core 0.5.0 → 0.7.0

package/dist/combat/abilityKit.js

@@ -0,0 +1,129 @@
+const DEFAULT_FLASH_MS = 220;
+function normalizeConfig(config) {
+    return {
+        id: config.id,
+        cooldownMs: Math.max(0, config.cooldownMs),
+        chargesMax: Math.max(1, config.chargesMax ?? 1),
+        resourceCost: Math.max(0, config.resourceCost ?? 0),
+        castType: config.castType ?? "instant",
+        flashMs: Math.max(0, config.flashMs ?? DEFAULT_FLASH_MS),
+    };
+}
+function deriveState(runtime, resourceAvailable) {
+    if (runtime.flashRemainingMs > 0)
+        return "just-cast";
+    if (runtime.charges <= 0)
+        return "cooldown";
+    if (resourceAvailable < runtime.config.resourceCost)
+        return "no-resource";
+    return "ready";
+}
+function snapshotOf(runtime, resourceAvailable) {
+    const { config } = runtime;
+    const state = deriveState(runtime, resourceAvailable);
+    const cooldownFraction = config.cooldownMs <= 0 ? 0 : Math.max(0, Math.min(1, runtime.rechargeRemainingMs / config.cooldownMs));
+    return {
+        id: config.id,
+        state,
+        castType: config.castType,
+        resourceCost: config.resourceCost,
+        charges: runtime.charges,
+        chargesMax: config.chargesMax,
+        cooldownRemainingMs: runtime.rechargeRemainingMs,
+        cooldownFraction,
+        justCast: runtime.flashRemainingMs > 0,
+        ready: runtime.charges > 0 && resourceAvailable >= config.resourceCost,
+    };
+}
+export function createAbilityKit(configs) {
+    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}`);
+        runtimes.set(normalized.id, {
+            config: normalized,
+            charges: normalized.chargesMax,
+            rechargeRemainingMs: 0,
+            flashRemainingMs: 0,
+        });
+        order.push(normalized.id);
+    }
+    function fail(slotId, reason, resourceAvailable) {
+        const runtime = runtimes.get(slotId);
+        return { ok: false, reason, slot: runtime ? snapshotOf(runtime, resourceAvailable) : null };
+    }
+    function evaluate(slotId, resourceAvailable) {
+        const runtime = runtimes.get(slotId);
+        if (runtime === undefined)
+            return fail(slotId, "unknown-slot", resourceAvailable);
+        if (runtime.charges <= 0)
+            return fail(slotId, "cooldown", resourceAvailable);
+        if (resourceAvailable < runtime.config.resourceCost)
+            return fail(slotId, "no-resource", resourceAvailable);
+        return { ok: true, slot: snapshotOf(runtime, resourceAvailable) };
+    }
+    return {
+        slots() {
+            return order.slice();
+        },
+        config(slotId) {
+            return runtimes.get(slotId)?.config ?? null;
+        },
+        state(slotId, resourceAvailable = Number.POSITIVE_INFINITY) {
+            const runtime = runtimes.get(slotId);
+            return runtime === undefined ? null : snapshotOf(runtime, resourceAvailable);
+        },
+        snapshot(resourceAvailable = Number.POSITIVE_INFINITY) {
+            return order.map((slotId) => snapshotOf(runtimes.get(slotId), resourceAvailable));
+        },
+        canCast(slotId, resourceAvailable = Number.POSITIVE_INFINITY) {
+            return evaluate(slotId, resourceAvailable);
+        },
+        cast(slotId, resourceAvailable = Number.POSITIVE_INFINITY) {
+            const result = evaluate(slotId, resourceAvailable);
+            if (!result.ok)
+                return result;
+            const runtime = runtimes.get(slotId);
+            runtime.charges -= 1;
+            if (runtime.rechargeRemainingMs <= 0)
+                runtime.rechargeRemainingMs = runtime.config.cooldownMs;
+            runtime.flashRemainingMs = runtime.config.flashMs;
+            return { ok: true, slot: snapshotOf(runtime, resourceAvailable) };
+        },
+        tick(dtSeconds) {
+            if (dtSeconds <= 0)
+                return;
+            const dtMs = dtSeconds * 1000;
+            for (const runtime of runtimes.values()) {
+                if (runtime.flashRemainingMs > 0)
+                    runtime.flashRemainingMs = Math.max(0, runtime.flashRemainingMs - dtMs);
+                if (runtime.charges >= runtime.config.chargesMax) {
+                    runtime.rechargeRemainingMs = 0;
+                    continue;
+                }
+                if (runtime.config.cooldownMs <= 0) {
+                    runtime.charges = runtime.config.chargesMax;
+                    runtime.rechargeRemainingMs = 0;
+                    continue;
+                }
+                let remaining = runtime.rechargeRemainingMs <= 0 ? runtime.config.cooldownMs : runtime.rechargeRemainingMs;
+                remaining -= dtMs;
+                while (remaining <= 0 && runtime.charges < runtime.config.chargesMax) {
+                    runtime.charges += 1;
+                    remaining += runtime.config.cooldownMs;
+                }
+                runtime.rechargeRemainingMs = runtime.charges >= runtime.config.chargesMax ? 0 : remaining;
+            }
+        },
+        reset(slotId) {
+            const targets = slotId === undefined ? runtimes.values() : [runtimes.get(slotId)].filter((r) => r !== undefined);
+            for (const runtime of targets) {
+                runtime.charges = runtime.config.chargesMax;
+                runtime.rechargeRemainingMs = 0;
+                runtime.flashRemainingMs = 0;
+            }
+        },
+    };
+}

package/dist/combat/animationState.d.ts

@@ -0,0 +1,47 @@
+export type FramePhase = "windup" | "active" | "recovery" | "cancel";
+export interface FrameRange {
+    phase: FramePhase;
+    from: number;
+    to: number;
+}
+export interface AnimationClip {
+    id: string;
+    frames: number;
+    fps: number;
+    ranges: readonly FrameRange[];
+    loop?: boolean;
+}
+export interface AnimationSnapshot {
+    clipId: string;
+    frame: number;
+    elapsedMs: number;
+}
+export interface AnimationTickResult {
+    clipId: string | null;
+    frame: number;
+    entered: readonly FramePhase[];
+    exited: readonly FramePhase[];
+    completed: boolean;
+}
+export declare function clipDurationMs(clip: AnimationClip): number;
+export declare function frameAtMs(clip: AnimationClip, elapsedMs: number): number;
+export declare function phasesAtFrame(clip: AnimationClip, frame: number): FramePhase[];
+export declare function activeRangeAtFrame(clip: AnimationClip, frame: number): FrameRange | null;
+export interface AnimationState {
+    play(clipId: string): void;
+    stop(): void;
+    tick(dtSeconds: number): AnimationTickResult;
+    current(): AnimationSnapshot | null;
+    phases(): readonly FramePhase[];
+    inPhase(phase: FramePhase): boolean;
+    isActive(): boolean;
+    canCancel(): boolean;
+    activeWindowMs(): {
+        from: number;
+        to: number;
+    } | null;
+}
+export interface AnimationStateConfig {
+    clips: readonly AnimationClip[];
+}
+export declare function createAnimationState(config: AnimationStateConfig): AnimationState;

package/dist/combat/animationState.js

@@ -0,0 +1,101 @@
+export function clipDurationMs(clip) {
+    return (clip.frames / clip.fps) * 1000;
+}
+export function frameAtMs(clip, elapsedMs) {
+    const raw = (elapsedMs / 1000) * clip.fps;
+    if (clip.loop === true) {
+        const wrapped = raw % clip.frames;
+        return wrapped < 0 ? wrapped + clip.frames : wrapped;
+    }
+    return Math.min(raw, clip.frames);
+}
+export function phasesAtFrame(clip, frame) {
+    const phases = [];
+    for (const range of clip.ranges) {
+        if (frame >= range.from && frame < range.to && !phases.includes(range.phase)) {
+            phases.push(range.phase);
+        }
+    }
+    return phases;
+}
+export function activeRangeAtFrame(clip, frame) {
+    for (const range of clip.ranges) {
+        if (range.phase === "active" && frame >= range.from && frame < range.to)
+            return range;
+    }
+    return null;
+}
+export function createAnimationState(config) {
+    const clips = new Map(config.clips.map((clip) => [clip.id, clip]));
+    let activeClip = null;
+    let elapsedMs = 0;
+    let lastPhases = [];
+    function frame() {
+        return activeClip === null ? 0 : frameAtMs(activeClip, elapsedMs);
+    }
+    return {
+        play(clipId) {
+            const clip = clips.get(clipId);
+            if (clip === undefined)
+                return;
+            activeClip = clip;
+            elapsedMs = 0;
+            lastPhases = phasesAtFrame(clip, 0);
+        },
+        stop() {
+            activeClip = null;
+            elapsedMs = 0;
+            lastPhases = [];
+        },
+        tick(dtSeconds) {
+            if (activeClip === null) {
+                return { clipId: null, frame: 0, entered: [], exited: [], completed: false };
+            }
+            elapsedMs += dtSeconds * 1000;
+            const clip = activeClip;
+            let completed = false;
+            if (clip.loop !== true && elapsedMs >= clipDurationMs(clip)) {
+                elapsedMs = clipDurationMs(clip);
+                completed = true;
+            }
+            const currentFrame = frameAtMs(clip, elapsedMs);
+            const nowPhases = phasesAtFrame(clip, currentFrame);
+            const entered = nowPhases.filter((p) => !lastPhases.includes(p));
+            const exited = lastPhases.filter((p) => !nowPhases.includes(p));
+            lastPhases = nowPhases;
+            const clipId = clip.id;
+            if (completed) {
+                activeClip = null;
+                elapsedMs = 0;
+                lastPhases = [];
+            }
+            return { clipId, frame: currentFrame, entered, exited, completed };
+        },
+        current() {
+            if (activeClip === null)
+                return null;
+            return { clipId: activeClip.id, frame: frame(), elapsedMs };
+        },
+        phases() {
+            return activeClip === null ? [] : phasesAtFrame(activeClip, frame());
+        },
+        inPhase(phase) {
+            return activeClip !== null && phasesAtFrame(activeClip, frame()).includes(phase);
+        },
+        isActive() {
+            return activeClip !== null && activeRangeAtFrame(activeClip, frame()) !== null;
+        },
+        canCancel() {
+            return activeClip !== null && phasesAtFrame(activeClip, frame()).includes("cancel");
+        },
+        activeWindowMs() {
+            if (activeClip === null)
+                return null;
+            const range = activeRangeAtFrame(activeClip, frame());
+            if (range === null)
+                return null;
+            const perFrameMs = 1000 / activeClip.fps;
+            return { from: range.from * perFrameMs, to: range.to * perFrameMs };
+        },
+    };
+}

package/dist/combat/attackTags.d.ts

@@ -0,0 +1,14 @@
+export type AttackTag = "unblockable" | "thrust" | "sweep" | "grab" | "overhead" | "ranged" | "aerial";
+export interface AttackMeta {
+    tags: readonly AttackTag[];
+    effect?: string;
+    power?: number;
+}
+export declare function attackMeta(tags: readonly AttackTag[], extra?: Omit<AttackMeta, "tags">): AttackMeta;
+export declare function hasTag(meta: AttackMeta, tag: AttackTag): boolean;
+export declare function hasAnyTag(meta: AttackMeta, tags: readonly AttackTag[]): boolean;
+export declare function isBlockable(meta: AttackMeta): boolean;
+export declare function isParryable(meta: AttackMeta): boolean;
+export declare function isDodgeable(meta: AttackMeta): boolean;
+export type CounterMove = "mikiri" | "deflect" | "sidestep";
+export declare function counters(meta: AttackMeta, move: CounterMove): boolean;

package/dist/combat/attackTags.js

@@ -0,0 +1,26 @@
+export function attackMeta(tags, extra) {
+    return { tags, ...extra };
+}
+export function hasTag(meta, tag) {
+    return meta.tags.includes(tag);
+}
+export function hasAnyTag(meta, tags) {
+    return tags.some((tag) => meta.tags.includes(tag));
+}
+export function isBlockable(meta) {
+    return !hasAnyTag(meta, ["unblockable", "grab"]);
+}
+export function isParryable(meta) {
+    return !hasTag(meta, "grab");
+}
+export function isDodgeable(meta) {
+    return !hasTag(meta, "grab");
+}
+const COUNTER_TAGS = {
+    mikiri: "thrust",
+    deflect: "overhead",
+    sidestep: "sweep",
+};
+export function counters(meta, move) {
+    return hasTag(meta, COUNTER_TAGS[move]);
+}

package/dist/combat/breakMeters.d.ts

@@ -0,0 +1,32 @@
+export interface StaggerMeterConfig {
+    max: number;
+    decayPerSecond?: number;
+    decayDelayMs?: number;
+}
+export interface StaggerMeter {
+    add(amount: number): boolean;
+    broke(): boolean;
+    value(): number;
+    fraction(): number;
+    recover(): void;
+    tick(dtSeconds: number): void;
+}
+export declare function createStaggerMeter(config: StaggerMeterConfig): StaggerMeter;
+export interface BuildupMeterConfig {
+    status: string;
+    max: number;
+    durationMs: number;
+    decayPerSecond?: number;
+    decayDelayMs?: number;
+}
+export interface BuildupProc {
+    status: string;
+    durationMs: number;
+}
+export interface BuildupMeter {
+    add(amount: number): BuildupProc | null;
+    value(): number;
+    fraction(): number;
+    tick(dtSeconds: number): void;
+}
+export declare function createBuildupMeter(config: BuildupMeterConfig): BuildupMeter;

package/dist/combat/breakMeters.js

@@ -0,0 +1,51 @@
+import { createAccumulatorMeter } from "../stats/accumulatorMeter.js";
+export function createStaggerMeter(config) {
+    const meter = createAccumulatorMeter({
+        max: config.max,
+        mode: "hold",
+        decayPerSecond: config.decayPerSecond ?? 0,
+        decayDelayMs: config.decayDelayMs ?? 0,
+    });
+    return {
+        add(amount) {
+            return meter.add(amount).fired;
+        },
+        broke() {
+            return meter.broke();
+        },
+        value() {
+            return meter.value();
+        },
+        fraction() {
+            return meter.fraction();
+        },
+        recover() {
+            meter.reset();
+        },
+        tick(dtSeconds) {
+            meter.tick(dtSeconds);
+        },
+    };
+}
+export function createBuildupMeter(config) {
+    const meter = createAccumulatorMeter({
+        max: config.max,
+        mode: "reset",
+        decayPerSecond: config.decayPerSecond ?? 0,
+        decayDelayMs: config.decayDelayMs ?? 0,
+    });
+    return {
+        add(amount) {
+            return meter.add(amount).fired ? { status: config.status, durationMs: config.durationMs } : null;
+        },
+        value() {
+            return meter.value();
+        },
+        fraction() {
+            return meter.fraction();
+        },
+        tick(dtSeconds) {
+            meter.tick(dtSeconds);
+        },
+    };
+}

package/dist/combat/comboString.d.ts

@@ -0,0 +1,35 @@
+import { type AnimationState, type FramePhase } from "./animationState.js";
+export interface ComboStep {
+    id: string;
+    clip: string;
+    cancelInto?: readonly string[];
+    cancelPhases?: readonly FramePhase[];
+    stance?: string;
+}
+export interface ComboString {
+    id: string;
+    entry: string;
+    steps: readonly ComboStep[];
+}
+export declare function stepById(combo: ComboString, stepId: string): ComboStep | null;
+export interface AdvanceComboInput {
+    combo: ComboString;
+    currentStepId: string | null;
+    requestedStepId: string;
+    phases: readonly FramePhase[];
+    stance?: string;
+}
+export type AdvanceComboResult = {
+    accepted: true;
+    step: ComboStep;
+} | {
+    accepted: false;
+    reason: "unknown-step" | "not-chainable" | "wrong-stance" | "window-closed";
+};
+export declare function advanceCombo(input: AdvanceComboInput): AdvanceComboResult;
+export interface ComboRunner {
+    currentStep(): string | null;
+    request(stepId: string, stance?: string): AdvanceComboResult;
+    reset(): void;
+}
+export declare function createComboRunner(combo: ComboString, anim: AnimationState): ComboRunner;

package/dist/combat/comboString.js

@@ -0,0 +1,59 @@
+import {} from "./animationState.js";
+const DEFAULT_CANCEL_PHASES = ["cancel"];
+export function stepById(combo, stepId) {
+    return combo.steps.find((step) => step.id === stepId) ?? null;
+}
+function stanceMatches(step, stance) {
+    return step.stance === undefined || step.stance === stance;
+}
+export function advanceCombo(input) {
+    const { combo, currentStepId, requestedStepId, phases, stance } = input;
+    const requested = stepById(combo, requestedStepId);
+    if (requested === null)
+        return { accepted: false, reason: "unknown-step" };
+    if (currentStepId === null) {
+        if (requestedStepId !== combo.entry)
+            return { accepted: false, reason: "not-chainable" };
+        if (!stanceMatches(requested, stance))
+            return { accepted: false, reason: "wrong-stance" };
+        return { accepted: true, step: requested };
+    }
+    const current = stepById(combo, currentStepId);
+    if (current === null)
+        return { accepted: false, reason: "unknown-step" };
+    if (!(current.cancelInto ?? []).includes(requestedStepId)) {
+        return { accepted: false, reason: "not-chainable" };
+    }
+    if (!stanceMatches(requested, stance))
+        return { accepted: false, reason: "wrong-stance" };
+    const cancelPhases = current.cancelPhases ?? DEFAULT_CANCEL_PHASES;
+    if (!cancelPhases.some((phase) => phases.includes(phase))) {
+        return { accepted: false, reason: "window-closed" };
+    }
+    return { accepted: true, step: requested };
+}
+export function createComboRunner(combo, anim) {
+    let current = null;
+    return {
+        currentStep() {
+            return current;
+        },
+        request(stepId, stance) {
+            const result = advanceCombo({
+                combo,
+                currentStepId: current,
+                requestedStepId: stepId,
+                phases: anim.phases(),
+                stance,
+            });
+            if (result.accepted) {
+                current = result.step.id;
+                anim.play(result.step.clip);
+            }
+            return result;
+        },
+        reset() {
+            current = null;
+        },
+    };
+}

package/dist/combat/death.d.ts

@@ -1,5 +1,6 @@
 import type { DeathReason, GameEvents } from "../game/events.js";
 import type { Drop } from "../game/lootTable.js";
+import type { ScatterOptions } from "../game/worldItem.js";
 import type { EffectVia } from "./effects.js";
 export type DeathReasonKind = DeathReason["kind"];
 export interface OnDeathDropRule {
@@ -15,13 +16,20 @@ export interface OnDeathCommandRule {
         reason: DeathReasonKind;
     };
 }
+export type DropMode = "grant" | "world";
 export interface OnDeathSpec {
     drops?: string | OnDeathDropRule[];
     command?: string | OnDeathCommandRule;
+    /** "grant" (default) puts drops straight into the killer's inventory; "world" scatters them as ground `worldItem`s instead (#32). */
+    dropMode?: DropMode;
+    /** Scatter-offset tuning when `dropMode` is `"world"`; defaults to `DEFAULT_SCATTER` from `game/worldItem`. */
+    scatter?: ScatterOptions;
 }
 export interface NormalizedOnDeath {
     drops: OnDeathDropRule[];
     command: OnDeathCommandRule | null;
+    dropMode: DropMode;
+    scatter?: ScatterOptions;
 }
 export declare function normalizeOnDeath(spec: OnDeathSpec | null | undefined): NormalizedOnDeath;
 export interface DeathIdentity {

package/dist/combat/death.js

@@ -1,9 +1,12 @@
 export function normalizeOnDeath(spec) {
     if (!spec)
-        return { drops: [], command: null };
+        return { drops: [], command: null, dropMode: "grant" };
     const drops = spec.drops === undefined ? [] : typeof spec.drops === "string" ? [{ table: spec.drops }] : spec.drops;
     const command = spec.command === undefined ? null : typeof spec.command === "string" ? { name: spec.command } : spec.command;
-    return { drops, command };
+    const normalized = { drops, command, dropMode: spec.dropMode ?? "grant" };
+    if (spec.scatter !== undefined)
+        normalized.scatter = spec.scatter;
+    return normalized;
 }
 function matchesReason(when, reason) {
     return when === undefined || when.reason === reason.kind;

package/dist/combat/defensiveWindow.d.ts

@@ -0,0 +1,34 @@
+import { type AttackMeta } from "./attackTags.js";
+export type DefenseKind = "parry" | "block" | "dodge";
+export interface DefensiveWindowConfig {
+    kind: DefenseKind;
+    startupMs?: number;
+    activeMs: number;
+    recoveryMs?: number;
+    iframes?: {
+        fromMs: number;
+        toMs: number;
+    };
+}
+export type DefenseOutcome = "parry" | "block" | "iframe" | "hit";
+export interface DefenseResolution {
+    outcome: DefenseOutcome;
+    perfect: boolean;
+}
+export declare function windowActiveAt(config: DefensiveWindowConfig, elapsedMs: number): boolean;
+export declare function iframeActiveAt(config: DefensiveWindowConfig, elapsedMs: number): boolean;
+export declare function totalWindowMs(config: DefensiveWindowConfig): number;
+export interface ResolveDefenseInput {
+    config: DefensiveWindowConfig;
+    elapsedMs: number;
+    attack: AttackMeta;
+}
+export declare function resolveDefense(input: ResolveDefenseInput): DefenseResolution;
+export interface DefensiveWindow {
+    open(nowMs: number): void;
+    close(): void;
+    isOpen(): boolean;
+    evaluate(nowMs: number, attack: AttackMeta): DefenseResolution;
+    isInvulnerable(nowMs: number): boolean;
+}
+export declare function createDefensiveWindow(config: DefensiveWindowConfig): DefensiveWindow;

package/dist/combat/defensiveWindow.js

@@ -0,0 +1,66 @@
+import { isBlockable, isDodgeable, isParryable } from "./attackTags.js";
+export function windowActiveAt(config, elapsedMs) {
+    const start = config.startupMs ?? 0;
+    return elapsedMs >= start && elapsedMs < start + config.activeMs;
+}
+export function iframeActiveAt(config, elapsedMs) {
+    const frames = config.iframes;
+    if (frames === undefined)
+        return false;
+    return elapsedMs >= frames.fromMs && elapsedMs < frames.toMs;
+}
+export function totalWindowMs(config) {
+    return (config.startupMs ?? 0) + config.activeMs + (config.recoveryMs ?? 0);
+}
+export function resolveDefense(input) {
+    const { config, elapsedMs, attack } = input;
+    const inWindow = windowActiveAt(config, elapsedMs);
+    const inIframe = iframeActiveAt(config, elapsedMs);
+    if (config.kind === "dodge") {
+        if (inIframe && isDodgeable(attack))
+            return { outcome: "iframe", perfect: inWindow };
+        return { outcome: "hit", perfect: false };
+    }
+    if (config.kind === "parry") {
+        if (inWindow && isParryable(attack))
+            return { outcome: "parry", perfect: true };
+        if (inIframe && isDodgeable(attack))
+            return { outcome: "iframe", perfect: false };
+        return { outcome: "hit", perfect: false };
+    }
+    if (inWindow && isBlockable(attack))
+        return { outcome: "block", perfect: true };
+    return { outcome: "hit", perfect: false };
+}
+export function createDefensiveWindow(config) {
+    let openedAt = null;
+    function elapsed(nowMs) {
+        if (openedAt === null)
+            return null;
+        const dt = nowMs - openedAt;
+        if (dt < 0 || dt >= totalWindowMs(config))
+            return null;
+        return dt;
+    }
+    return {
+        open(nowMs) {
+            openedAt = nowMs;
+        },
+        close() {
+            openedAt = null;
+        },
+        isOpen() {
+            return openedAt !== null;
+        },
+        evaluate(nowMs, attack) {
+            const dt = elapsed(nowMs);
+            if (dt === null)
+                return { outcome: "hit", perfect: false };
+            return resolveDefense({ config, elapsedMs: dt, attack });
+        },
+        isInvulnerable(nowMs) {
+            const dt = elapsed(nowMs);
+            return dt !== null && iframeActiveAt(config, dt);
+        },
+    };
+}

package/dist/combat/downed.d.ts

@@ -0,0 +1,35 @@
+export type DownedPhase = "alive" | "downed" | "dead";
+export interface DownedConfig {
+    bleedoutSeconds: number;
+    reviveSeconds?: number;
+    reviveHealthFraction?: number;
+    banner?: {
+        expireSeconds: number;
+    };
+}
+export interface DownedEntry {
+    phase: DownedPhase;
+    bleedoutRemaining: number;
+    reviveProgress: number;
+    bannerRemaining: number | null;
+}
+export type DownedEventKind = "downed" | "revived" | "reviving" | "died" | "banner.created" | "banner.expired" | "respawned";
+export interface DownedEvent {
+    kind: DownedEventKind;
+    instanceId: string;
+    reason?: string;
+    reviveHealthFraction?: number;
+}
+export interface DownedState {
+    down(instanceId: string): DownedEvent | null;
+    revive(instanceId: string, dt: number): DownedEvent | null;
+    interruptRevive(instanceId: string): void;
+    finish(instanceId: string, reason?: string): DownedEvent | null;
+    tick(dt: number): DownedEvent[];
+    respawnFromBanner(instanceId: string): DownedEvent | null;
+    phase(instanceId: string): DownedPhase;
+    get(instanceId: string): DownedEntry | null;
+    clear(instanceId: string): void;
+    snapshot(): Record<string, DownedEntry>;
+}
+export declare function createDownedState(config: DownedConfig): DownedState;