@datamoc/mw_games 0.43.0 → 0.45.0

package/dist/simulation/Turns.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Turns.d.ts","sourceRoot":"","sources":["../../src/simulation/Turns.ts"],"names":[],"mappings":"AAAA,yDAAyD;AACzD,MAAM,WAAW,cAAc,CAAC,KAAK;IACpC,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC;IACrB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,SAAS,CAAC,KAAK;IAC/B,SAAS,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC;IACjC,QAAQ,IAAI,OAAO,CAAC;IACpB,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;IAClC,kGAAkG;IAClG,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,MAAM,MAAM,UAAU,CAAC,KAAK,IAC3B;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9G;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC,CAkBhG"}

package/dist/simulation/Turns.js

@@ -1,41 +0,0 @@
-/**
- * Advance automatic actions with an explicit work budget. Input actors are never spent.
- * Rules own actor removal and queue replacement. A returned cost is charged after act(),
- * even if that action ends the game; return null when the action already handled its cost.
- * Reaching the budget returns limit without another peek or action. The caller decides
- * whether to resume, report a stalled simulation, or yield to its host.
- *
- * @example
- * ```ts
- * import { advanceToInput, type TurnRules } from '@datamoc/mw_games/simulation';
- *
- * declare const rules: TurnRules<{ id: string; isPlayer: boolean }>;
- *
- * // runs monster turns automatically, stopping the moment the player needs to act
- * const result = advanceToInput(rules, 1000);
- * if (result.status === 'input') console.log('waiting on', result.actor.id);
- * ```
- */
-export function advanceToInput(rules, budget) {
-    if (!Number.isSafeInteger(budget) || budget < 0)
-        throw new RangeError('Turn budget must be a non-negative safe integer');
-    let steps = 0;
-    while (steps < budget) {
-        if (rules.finished())
-            return { status: 'finished', steps };
-        const actor = rules.scheduler.peek();
-        if (actor === null)
-            return { status: 'empty', steps };
-        if (rules.needsInput(actor))
-            return { status: 'input', actor, steps };
-        const cost = rules.act(actor);
-        if (cost !== null) {
-            if (!Number.isFinite(cost) || cost < 0)
-                throw new RangeError('Action cost must be finite and non-negative, or null');
-            rules.scheduler.spend(cost);
-        }
-        steps++;
-    }
-    return { status: 'limit', steps };
-}
-//# sourceMappingURL=Turns.js.map

package/dist/simulation/Turns.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Turns.js","sourceRoot":"","sources":["../../src/simulation/Turns.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,cAAc,CAAQ,KAAuB,EAAE,MAAc;IAC5E,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC;QAC9C,MAAM,IAAI,UAAU,CAAC,iDAAiD,CAAC,CAAC;IACzE,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,OAAO,KAAK,GAAG,MAAM,EAAE,CAAC;QACvB,IAAI,KAAK,CAAC,QAAQ,EAAE;YAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;QAC3D,MAAM,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACrC,IAAI,KAAK,KAAK,IAAI;YAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;QACtD,IAAI,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC;YAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QACtE,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YACnB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC;gBACrC,MAAM,IAAI,UAAU,CAAC,sDAAsD,CAAC,CAAC;YAC9E,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC7B,CAAC;QACD,KAAK,EAAE,CAAC;IACT,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AACnC,CAAC"}

package/dist/simulation/index.d.ts

@@ -1,25 +0,0 @@
-export { advanceToInput } from './Turns.ts';
-export { TrainingEnvironment, runRollouts, runRolloutsAsync, imitationFromReplay, runSeededEpisode, } from './Training.ts';
-export type { TrainingRules, TrainingFrame, TrainingSnapshot, TrainingCheckpoint, TrainingTransition, TrainingFactory, RolloutOptions, RolloutEpisode, ImitationSample, ImitationResult, SeededRun, } from './Training.ts';
-export type { ScheduledTurns, TurnRules, TurnResult } from './Turns.ts';
-export { runScenario } from './Scenario.ts';
-export type { SimulationStatus, SimulationStep, SimulationRule, Scenario, ScenarioResult } from './Scenario.ts';
-export { Campaign } from './Campaign.ts';
-export type { CampaignOutcome, CampaignLevel, CampaignLevelResult, CampaignSnapshot } from './Campaign.ts';
-export { runHeadlessScenario } from './Harness.ts';
-export type { HeadlessScenario, HeadlessScenarioResult } from './Harness.ts';
-export { SimulationRuntime, validateSimulationReplay } from './Runtime.ts';
-export type { SimulationContext, SimulationOutcome, SimulationReplayMismatch, SimulationReplayResult, SimulationRuntimeHistoryOptions, SimulationRuntimeRule, SimulationSnapshot, } from './Runtime.ts';
-export { EventPresentation } from './EventPresentation.ts';
-export type { EventPresentationOptions } from './EventPresentation.ts';
-export { CampaignSave } from './CampaignSave.ts';
-export type { CampaignSaveState, CampaignSaveParts } from './CampaignSave.ts';
-/**
- * Re-exported from `roguelike` (its own home - it also drives FOV/pathfinding turn order
- * with nothing to do with simulation state or events): `SimulationRuntime` already needs one
- * on every construction, so a game building a simulation-first game need not import a second
- * module just to get the class its own runtime is built around.
- */
-export { Scheduler } from '../roguelike/Scheduler.ts';
-export type { Actor, SchedulerSnapshot } from '../roguelike/Scheduler.ts';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/simulation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EACN,mBAAmB,EACnB,WAAW,EACX,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,GAChB,MAAM,eAAe,CAAC;AACvB,YAAY,EACX,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,cAAc,EACd,eAAe,EACf,eAAe,EACf,SAAS,GACT,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAChH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC3G,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAC3E,YAAY,EACX,iBAAiB,EACjB,iBAAiB,EACjB,wBAAwB,EACxB,sBAAsB,EACtB,+BAA+B,EAC/B,qBAAqB,EACrB,kBAAkB,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,YAAY,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE9E;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,YAAY,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/simulation/index.js

@@ -1,16 +0,0 @@
-export { advanceToInput } from './Turns.js';
-export { TrainingEnvironment, runRollouts, runRolloutsAsync, imitationFromReplay, runSeededEpisode, } from './Training.js';
-export { runScenario } from './Scenario.js';
-export { Campaign } from './Campaign.js';
-export { runHeadlessScenario } from './Harness.js';
-export { SimulationRuntime, validateSimulationReplay } from './Runtime.js';
-export { EventPresentation } from './EventPresentation.js';
-export { CampaignSave } from './CampaignSave.js';
-/**
- * Re-exported from `roguelike` (its own home - it also drives FOV/pathfinding turn order
- * with nothing to do with simulation state or events): `SimulationRuntime` already needs one
- * on every construction, so a game building a simulation-first game need not import a second
- * module just to get the class its own runtime is built around.
- */
-export { Scheduler } from '../roguelike/Scheduler.js';
-//# sourceMappingURL=index.js.map

package/dist/simulation/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/simulation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EACN,mBAAmB,EACnB,WAAW,EACX,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,GAChB,MAAM,eAAe,CAAC;AAevB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAU3E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/skeleton/index.d.ts

@@ -1,212 +0,0 @@
-/**
- * Skeletal pose math, renderer-free: a bone tree, keyframed clips, and layered blending.
- *
- * The pose half of a skeletal puppet (roadmap 399), as pure data and arithmetic so it loads
- * headless and tests without a renderer - the same split every other module draws. A bone
- * is a name, a parent name, a length and a local rotation; a pose is one rotation per bone,
- * with optional per-bone translations and scales riding the same timeline; resolving a pose
- * walks the tree so rotating an arm, a leg or a head is one number on one bone and the rest
- * of the body follows. Clips are keyframed poses over time - plain data a game authors in
- * JSON, never code, and never a borrowed game's animation data - with interpolation,
- * looping, a playback rate and a crossfade between clips. Additive layers (aim on top of
- * walk, hurt on top of idle) mix by priority, so a game composes motion instead of
- * authoring every combination as its own clip.
- *
- * @example
- * ```ts
- * import * as Skeleton from '@datamoc/mw_games/skeleton';
- *
- * const puppet = Skeleton.create([
- *   { name: 'body' },
- *   { name: 'arm', parent: 'body', length: 12 },
- * ]);
- * const mixer = Skeleton.createMixer(puppet, { id: 'idle', duration: 2, loop: true, frames: [
- *   { time: 0, rotations: {} },
- *   { time: 1, rotations: { arm: 90 } },
- * ] });
- * Skeleton.advance(mixer, 1); // the arm swings up over one second
- * const pose = Skeleton.advance(mixer, 1); // the arm swings up over one second
- * const arm = Skeleton.resolve(puppet, pose)[1]; // world x, y and angle per bone
- * ```
- */
-export interface Bone {
-    /** unique within one skeleton */
-    name: string;
-    /** the parent bone's name; the roots have none */
-    parent?: string;
-    /** how far the bone reaches from its base, world units */
-    length?: number;
-    /** the bone's own offset from its parent's tip, before any pose */
-    origin?: {
-        x: number;
-        y: number;
-    };
-    /** the bone's rest rotation, degrees */
-    rotation?: number;
-    /** absolute local-angle bounds, degrees; out-of-range poses fail at sample time */
-    limits?: {
-        min: number;
-        max: number;
-    };
-}
-export interface SkeletonBones {
-    bones: readonly Bone[];
-}
-/** one rotation per bone name, degrees; a bone left out keeps its rest rotation */
-export type Pose = Readonly<Record<string, number>>;
-/** a full pose: rotations plus optional per-bone translations and scales */
-export interface TransformPose {
-    rotations: Pose;
-    translations?: Record<string, {
-        x: number;
-        y: number;
-    }>;
-    scales?: Record<string, {
-        x: number;
-        y: number;
-    }>;
-}
-/** a 2D affine matrix, row-major */
-export interface AffineMatrix {
-    a: number;
-    b: number;
-    c: number;
-    d: number;
-}
-export interface Keyframe {
-    /** seconds into the clip */
-    time: number;
-    rotations: Pose;
-    translations?: Record<string, {
-        x: number;
-        y: number;
-    }>;
-    scales?: Record<string, {
-        x: number;
-        y: number;
-    }>;
-}
-export interface Clip {
-    id: string;
-    /** seconds; a looping clip wraps at it, a one-shot holds its last frame */
-    duration: number;
-    loop?: boolean;
-    /** ascending by time; the first needs no time 0 entry, the last needs no duration entry */
-    frames: readonly Keyframe[];
-}
-/** a clip in motion: its playhead and rate */
-export interface Playback {
-    clip: Clip;
-    time: number;
-    /** multiplied per advance; negative plays backwards, 0 freezes */
-    rate: number;
-}
-export interface Layer {
-    playback: Playback;
-    /** 0..1, how far this layer's pose displaces the pose beneath it */
-    weight: number;
-    /** layers apply in ascending priority; same-priority layers keep their given order */
-    priority: number;
-}
-export interface Mixer {
-    skeleton: SkeletonBones;
-    /** the base motion, always present */
-    base: Playback;
-    /** additive layers over the base */
-    layers: Layer[];
-    /** while set, the previous base fades out as the new one fades in */
-    crossfade?: {
-        from: Playback;
-        remaining: number;
-        duration: number;
-    };
-}
-export interface BoneTransform {
-    name: string;
-    /** the bone's base in world space */
-    x: number;
-    y: number;
-    /** the bone's angle in world space, degrees */
-    angle: number;
-    /** the bone's world scale, composed down the chain */
-    scaleX: number;
-    scaleY: number;
-    /** the bone's world matrix: its rotation times its scale */
-    matrix: AffineMatrix;
-    /** the bone's tip in world space, `length` along its angle */
-    tipX: number;
-    tipY: number;
-}
-/** names in dependency order: every bone after its parent, so resolution is one pass */
-export declare function boneOrder(skeleton: SkeletonBones): string[];
-/** create a skeleton, refusing duplicate names, cycles and invalid joint limits by name */
-export declare function create(bones: readonly Bone[]): SkeletonBones;
-/**
- * A pose through the tree: each bone starts at its parent's tip plus its origin and
- * translation, transformed by the parent's rotation and scale, and reaches along its
- * own rotation and composed scale. Translations ride in the bone's rest frame; scales
- * multiply down the chain, so a scaled parent carries its children with it.
- */
-export declare function resolve(skeleton: SkeletonBones, pose?: Pose | TransformPose): BoneTransform[];
-/** the rotations a clip shows at `time`, interpolated, looped or held, validated */
-export declare function samplePose(clip: Clip, time: number, skeleton?: SkeletonBones): Record<string, number>;
-/** Sample every channel with the same timeline as rotations: holds the first frame
- * before it, the last past the end of a one-shot, and wraps a looping clip.
- * @example
- * ```ts
- * import { sampleTransformPose } from '@datamoc/mw_games/skeleton';
- * const pose = sampleTransformPose({ id: 'idle', duration: 1, frames: [{ time: 0, rotations: {} }] }, 0.5);
- * ```
- */
-export declare function sampleTransformPose(clip: Clip, time: number, skeleton?: SkeletonBones): TransformPose;
-/** move a playback's playhead, wrapping a looping clip and clamping a one-shot */
-export declare function advancePlayback(playback: Playback, dt: number): Playback;
-/** a mixer over a skeleton: one base clip, any number of weighted layers */
-export declare function createMixer(skeleton: SkeletonBones, base: Clip, rate?: number): Mixer;
-/** crossfade: the current base fades out over `duration` seconds as the new one fades in */
-export declare function crossfadeTo(mixer: Mixer, clip: Clip, duration?: number, rate?: number): void;
-/** mix poses by layer priority: each layer displaces what is beneath it by its weight */
-export declare function mixPoses(base: Pose, layers: ReadonlyArray<{
-    pose: Pose;
-    weight: number;
-    priority: number;
-}>): Record<string, number>;
-/**
- * One tick: advance every playback, sample the base (crossfaded when a fade is running),
- * layer the additive poses over it, and return the pose. Call `resolve` on the result when
- * the world transforms are what the drawing side needs.
- */
-export declare function advance(mixer: Mixer, dt: number): Record<string, number>;
-/** Advance all clip channels together, including crossfades and priority layers.
- * @example
- * ```ts
- * import { create, createMixer, advancePose } from '@datamoc/mw_games/skeleton';
- * const mixer = createMixer(create([{ name: 'body' }]), { id: 'bob', duration: 1,
- * frames: [{ time: 0, rotations: {}, translations: { body: { x: 0, y: 4 } } }] });
- * const pose = advancePose(mixer, 0.1);
- * ```
- */
-export declare function advancePose(mixer: Mixer, dt: number): TransformPose;
-/** Refuse non-finite rotations and absolute local angles outside a joint's bounds.
- * @example
- * ```ts
- * import { create, validatePose } from '@datamoc/mw_games/skeleton';
- * validatePose(create([{ name: 'knee', limits: { min: -120, max: 0 } }]), { knee: -30 });
- * ```
- */
-export declare function validatePose(skeleton: SkeletonBones, pose: Pose): void;
-/** Solve a connected two-bone chain toward a world target without stretching.
- * Positive bend rotates the second bone clockwise in screen coordinates. Origins on the
- * second bone must be zero; the solver accepts rotation-only poses.
- * @example
- * ```ts
- * import { create, solveTwoBoneIK } from '@datamoc/mw_games/skeleton';
- * const rig = create([{ name: 'upper', length: 10 }, { name: 'lower', parent: 'upper', length: 10 }]);
- * const pose = solveTwoBoneIK(rig, 'upper', 'lower', { x: 10, y: 10 });
- * ```
- */
-export declare function solveTwoBoneIK(skeleton: SkeletonBones, first: string, second: string, target: {
-    x: number;
-    y: number;
-}, bend?: 1 | -1, pose?: Pose): Record<string, number>;
-//# sourceMappingURL=index.d.ts.map

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

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

package/dist/skeleton/index.js

@@ -1,325 +0,0 @@
-/**
- * Skeletal pose math, renderer-free: a bone tree, keyframed clips, and layered blending.
- *
- * The pose half of a skeletal puppet (roadmap 399), as pure data and arithmetic so it loads
- * headless and tests without a renderer - the same split every other module draws. A bone
- * is a name, a parent name, a length and a local rotation; a pose is one rotation per bone,
- * with optional per-bone translations and scales riding the same timeline; resolving a pose
- * walks the tree so rotating an arm, a leg or a head is one number on one bone and the rest
- * of the body follows. Clips are keyframed poses over time - plain data a game authors in
- * JSON, never code, and never a borrowed game's animation data - with interpolation,
- * looping, a playback rate and a crossfade between clips. Additive layers (aim on top of
- * walk, hurt on top of idle) mix by priority, so a game composes motion instead of
- * authoring every combination as its own clip.
- *
- * @example
- * ```ts
- * import * as Skeleton from '@datamoc/mw_games/skeleton';
- *
- * const puppet = Skeleton.create([
- *   { name: 'body' },
- *   { name: 'arm', parent: 'body', length: 12 },
- * ]);
- * const mixer = Skeleton.createMixer(puppet, { id: 'idle', duration: 2, loop: true, frames: [
- *   { time: 0, rotations: {} },
- *   { time: 1, rotations: { arm: 90 } },
- * ] });
- * Skeleton.advance(mixer, 1); // the arm swings up over one second
- * const pose = Skeleton.advance(mixer, 1); // the arm swings up over one second
- * const arm = Skeleton.resolve(puppet, pose)[1]; // world x, y and angle per bone
- * ```
- */
-/** names in dependency order: every bone after its parent, so resolution is one pass */
-export function boneOrder(skeleton) {
-    const byName = new Map(skeleton.bones.map((bone) => [bone.name, bone]));
-    const order = [];
-    const placed = new Set();
-    const placing = new Set();
-    const visit = (bone) => {
-        if (placed.has(bone.name))
-            return;
-        if (placing.has(bone.name))
-            throw new Error(`skeleton cycle involving ${bone.name}`);
-        if (bone.parent && !byName.has(bone.parent))
-            throw new Error(`skeleton bone ${bone.name} names no parent ${bone.parent}`);
-        if (bone.parent) {
-            placing.add(bone.name);
-            const parent = byName.get(bone.parent);
-            if (parent)
-                visit(parent);
-            placing.delete(bone.name);
-        }
-        if (!placed.has(bone.name)) {
-            placed.add(bone.name);
-            order.push(bone.name);
-        }
-    };
-    for (const bone of skeleton.bones)
-        visit(bone);
-    return order;
-}
-/** create a skeleton, refusing duplicate names, cycles and invalid joint limits by name */
-export function create(bones) {
-    const names = new Set();
-    for (const bone of bones) {
-        if (names.has(bone.name))
-            throw new Error(`duplicate skeleton bone ${bone.name}`);
-        names.add(bone.name);
-        if (bone.limits && !(bone.limits.min <= bone.limits.max))
-            throw new Error(`invalid joint limits for bone ${bone.name}`);
-    }
-    const order = boneOrder({ bones });
-    //boneOrder throws on a missing parent, which is also what a cycle surfaces as here
-    for (const bone of bones)
-        if (bone.parent && order.indexOf(bone.parent) >= order.indexOf(bone.name))
-            throw new Error(`skeleton bone ${bone.name} cannot precede its parent ${bone.parent}`);
-    return { bones };
-}
-/**
- * A pose through the tree: each bone starts at its parent's tip plus its origin and
- * translation, transformed by the parent's rotation and scale, and reaches along its
- * own rotation and composed scale. Translations ride in the bone's rest frame; scales
- * multiply down the chain, so a scaled parent carries its children with it.
- */
-export function resolve(skeleton, pose = {}) {
-    const rotations = typeof pose.rotations === 'object' ? pose.rotations : pose;
-    const translations = pose.translations ?? {};
-    const scales = pose.scales ?? {};
-    const byName = new Map(skeleton.bones.map((bone) => [bone.name, bone]));
-    const world = new Map();
-    for (const name of boneOrder(skeleton)) {
-        const bone = byName.get(name);
-        if (!bone)
-            throw new Error(`skeleton bone ${name} went missing`);
-        const parent = bone.parent ? world.get(bone.parent) : undefined;
-        const rotation = (bone.rotation ?? 0) + (rotations[name] ?? 0);
-        const angle = (parent ? parent.angle : 0) + rotation;
-        const scale = scales[name] ?? { x: 1, y: 1 };
-        const scaleX = (parent ? parent.scaleX : 1) * scale.x;
-        const scaleY = (parent ? parent.scaleY : 1) * scale.y;
-        const radians = (angle * Math.PI) / 180;
-        const matrix = {
-            a: Math.cos(radians) * scaleX,
-            b: Math.sin(radians) * scaleX,
-            c: -Math.sin(radians) * scaleY,
-            d: Math.cos(radians) * scaleY,
-        };
-        const parentMatrix = parent
-            ? { a: parent.matrix.a, b: parent.matrix.b, c: parent.matrix.c, d: parent.matrix.d }
-            : { a: 1, b: 0, c: 0, d: 1 };
-        const originX = bone.origin?.x ?? 0;
-        const originY = bone.origin?.y ?? 0;
-        const localX = originX + (translations[name]?.x ?? 0);
-        const localY = originY + (translations[name]?.y ?? 0);
-        const x = (parent ? parent.tipX : 0) + parentMatrix.a * localX + parentMatrix.c * localY;
-        const y = (parent ? parent.tipY : 0) + parentMatrix.b * localX + parentMatrix.d * localY;
-        for (const value of [matrix.a, matrix.b, matrix.c, matrix.d])
-            if (!Number.isFinite(value))
-                throw new Error(`invalid transform for bone ${name}`);
-        world.set(name, {
-            name,
-            x,
-            y,
-            angle,
-            scaleX,
-            scaleY,
-            matrix,
-            tipX: x + matrix.a * (bone.length ?? 0),
-            tipY: y + matrix.b * (bone.length ?? 0),
-        });
-    }
-    return [...world.values()];
-}
-/** the rotations a clip shows at `time`, interpolated, looped or held, validated */
-export function samplePose(clip, time, skeleton) {
-    const result = { ...sampleTransformPose(clip, time, skeleton).rotations };
-    return result;
-}
-/** Sample every channel with the same timeline as rotations: holds the first frame
- * before it, the last past the end of a one-shot, and wraps a looping clip.
- * @example
- * ```ts
- * import { sampleTransformPose } from '@datamoc/mw_games/skeleton';
- * const pose = sampleTransformPose({ id: 'idle', duration: 1, frames: [{ time: 0, rotations: {} }] }, 0.5);
- * ```
- */
-export function sampleTransformPose(clip, time, skeleton) {
-    const frames = clip.frames;
-    if (!frames.length) {
-        if (skeleton)
-            validatePose(skeleton, {});
-        return { rotations: {} };
-    }
-    const clock = clip.loop && clip.duration > 0 ? ((time % clip.duration) + clip.duration) % clip.duration : time;
-    let pose = frames[0];
-    if (!clip.loop && clock >= clip.duration)
-        pose = frames[frames.length - 1];
-    else if (clock >= frames[0].time) {
-        pose = frames[frames.length - 1];
-        for (let i = 1; i < frames.length; i++) {
-            if (clock < frames[i].time) {
-                const span = frames[i].time - frames[i - 1].time;
-                pose = blendTransforms(frames[i - 1], frames[i], span > 0 ? (clock - frames[i - 1].time) / span : 0, true);
-                break;
-            }
-        }
-    }
-    const result = blendTransforms(pose, pose, 0, true);
-    if (skeleton)
-        validatePose(skeleton, result.rotations);
-    return result;
-}
-/** move a playback's playhead, wrapping a looping clip and clamping a one-shot */
-export function advancePlayback(playback, dt) {
-    const clip = playback.clip;
-    let time = playback.time + dt * playback.rate;
-    if (clip.loop && clip.duration > 0) {
-        time = time % clip.duration;
-        if (time < 0)
-            time += clip.duration;
-    }
-    else {
-        time = Math.max(0, Math.min(clip.duration, time));
-    }
-    return { clip, time, rate: playback.rate };
-}
-/** a mixer over a skeleton: one base clip, any number of weighted layers */
-export function createMixer(skeleton, base, rate = 1) {
-    return { skeleton, base: { clip: base, time: 0, rate }, layers: [] };
-}
-/** crossfade: the current base fades out over `duration` seconds as the new one fades in */
-export function crossfadeTo(mixer, clip, duration = 0.25, rate = mixer.base.rate) {
-    if (duration <= 0) {
-        mixer.base = { clip, time: 0, rate };
-        mixer.crossfade = undefined;
-        return;
-    }
-    mixer.crossfade = { from: mixer.base, remaining: duration, duration };
-    mixer.base = { clip, time: 0, rate };
-}
-/** mix poses by layer priority: each layer displaces what is beneath it by its weight */
-export function mixPoses(base, layers) {
-    let mixed = { rotations: base };
-    for (const layer of [...layers].sort((a, b) => a.priority - b.priority)) {
-        const weight = Math.max(0, Math.min(1, layer.weight));
-        if (weight)
-            mixed = blendTransforms(mixed, { rotations: layer.pose }, weight, false);
-    }
-    return { ...mixed.rotations };
-}
-/**
- * One tick: advance every playback, sample the base (crossfaded when a fade is running),
- * layer the additive poses over it, and return the pose. Call `resolve` on the result when
- * the world transforms are what the drawing side needs.
- */
-export function advance(mixer, dt) {
-    return { ...advancePose(mixer, dt).rotations };
-}
-/** Advance all clip channels together, including crossfades and priority layers.
- * @example
- * ```ts
- * import { create, createMixer, advancePose } from '@datamoc/mw_games/skeleton';
- * const mixer = createMixer(create([{ name: 'body' }]), { id: 'bob', duration: 1,
- * frames: [{ time: 0, rotations: {}, translations: { body: { x: 0, y: 4 } } }] });
- * const pose = advancePose(mixer, 0.1);
- * ```
- */
-export function advancePose(mixer, dt) {
-    mixer.base = advancePlayback(mixer.base, dt);
-    for (const layer of mixer.layers)
-        layer.playback = advancePlayback(layer.playback, dt);
-    let pose = sampleTransformPose(mixer.base.clip, mixer.base.time, mixer.skeleton);
-    if (mixer.crossfade) {
-        const fade = mixer.crossfade;
-        fade.from = advancePlayback(fade.from, dt);
-        fade.remaining = Math.max(0, fade.remaining - dt);
-        const outgoing = sampleTransformPose(fade.from.clip, fade.from.time, mixer.skeleton);
-        const t = fade.duration > 0 ? 1 - fade.remaining / fade.duration : 1;
-        pose = blendTransforms(outgoing, pose, t, true);
-        if (fade.remaining === 0)
-            mixer.crossfade = undefined;
-    }
-    for (const layer of [...mixer.layers].sort((a, b) => a.priority - b.priority))
-        pose = blendTransforms(pose, sampleTransformPose(layer.playback.clip, layer.playback.time, mixer.skeleton), Math.max(0, Math.min(1, layer.weight)), false);
-    return pose;
-}
-function blendTransforms(from, to, weight, union) {
-    const rotations = { ...from.rotations };
-    for (const name of new Set([...Object.keys(to.rotations), ...(union ? Object.keys(from.rotations) : [])]))
-        rotations[name] = (from.rotations[name] ?? 0) * (1 - weight) + (to.rotations[name] ?? 0) * weight;
-    const result = { rotations };
-    for (const channel of ['translations', 'scales']) {
-        const a = from[channel] ?? {};
-        const b = to[channel] ?? {};
-        const fallback = channel === 'scales' ? 1 : 0;
-        const values = { ...a };
-        for (const name of new Set([...Object.keys(b), ...(union ? Object.keys(a) : [])])) {
-            values[name] = {
-                x: (a[name]?.x ?? fallback) * (1 - weight) + (b[name]?.x ?? fallback) * weight,
-                y: (a[name]?.y ?? fallback) * (1 - weight) + (b[name]?.y ?? fallback) * weight,
-            };
-        }
-        if (Object.keys(values).length)
-            result[channel] = values;
-    }
-    return result;
-}
-/** Refuse non-finite rotations and absolute local angles outside a joint's bounds.
- * @example
- * ```ts
- * import { create, validatePose } from '@datamoc/mw_games/skeleton';
- * validatePose(create([{ name: 'knee', limits: { min: -120, max: 0 } }]), { knee: -30 });
- * ```
- */
-export function validatePose(skeleton, pose) {
-    for (const bone of skeleton.bones) {
-        const angle = (bone.rotation ?? 0) + (pose[bone.name] ?? 0);
-        if (!Number.isFinite(angle))
-            throw new Error(`invalid rotation for bone ${bone.name}`);
-        if (bone.limits && (angle < bone.limits.min || angle > bone.limits.max))
-            throw new Error(`joint limit for bone ${bone.name}: ${angle} outside [${bone.limits.min}, ${bone.limits.max}]`);
-    }
-}
-/** Solve a connected two-bone chain toward a world target without stretching.
- * Positive bend rotates the second bone clockwise in screen coordinates. Origins on the
- * second bone must be zero; the solver accepts rotation-only poses.
- * @example
- * ```ts
- * import { create, solveTwoBoneIK } from '@datamoc/mw_games/skeleton';
- * const rig = create([{ name: 'upper', length: 10 }, { name: 'lower', parent: 'upper', length: 10 }]);
- * const pose = solveTwoBoneIK(rig, 'upper', 'lower', { x: 10, y: 10 });
- * ```
- */
-export function solveTwoBoneIK(skeleton, first, second, target, bend = 1, pose = {}) {
-    const upper = skeleton.bones.find((b) => b.name === first);
-    const lower = skeleton.bones.find((b) => b.name === second);
-    if (!upper || !lower || lower.parent !== first)
-        throw new Error(`IK chain ${first}/${second} must be connected`);
-    if ((lower.origin?.x ?? 0) !== 0 || (lower.origin?.y ?? 0) !== 0)
-        throw new Error(`IK bone ${second} needs a zero origin`);
-    const a = upper.length ?? 0, b = lower.length ?? 0;
-    if (!(a > 0 && b > 0) || !Number.isFinite(a + b))
-        throw new Error(`IK chain ${first}/${second} needs positive finite lengths`);
-    if (!Number.isFinite(target.x) || !Number.isFinite(target.y) || (bend !== 1 && bend !== -1))
-        throw new Error(`invalid IK target or bend for ${first}/${second}`);
-    const transforms = resolve(skeleton, pose);
-    const base = transforms.find((bone) => bone.name === first);
-    if (!base)
-        throw new Error(`IK chain ${first}/${second} resolves no base`);
-    const dx = target.x - base.x, dy = target.y - base.y;
-    const distance = Math.hypot(dx, dy);
-    if (distance > a + b + 1e-9 || distance < Math.abs(a - b) - 1e-9)
-        throw new Error(`unreachable IK target for ${first}/${second}`);
-    const elbow = bend * Math.acos(Math.max(-1, Math.min(1, (distance * distance - a * a - b * b) / (2 * a * b))));
-    const shoulder = Math.atan2(dy, dx) - Math.atan2(b * Math.sin(elbow), a + b * Math.cos(elbow));
-    const upperParent = upper.parent ? transforms.find((bone) => bone.name === upper.parent) : undefined;
-    const parentAngle = upperParent ? upperParent.angle : 0;
-    const result = {
-        ...pose,
-        [first]: (shoulder * 180) / Math.PI - parentAngle - (upper.rotation ?? 0),
-        [second]: (elbow * 180) / Math.PI - (lower.rotation ?? 0),
-    };
-    validatePose(skeleton, result);
-    return result;
-}
-//# sourceMappingURL=index.js.map