1681-engine 0.0.0-stage → 0.5.9

package/dist/types/ambient/ColorGrade.d.ts

@@ -0,0 +1,41 @@
+import { type Container } from 'pixi.js';
+import type { Stage } from '../core/Stage.js';
+import { type GradeState } from './grade.js';
+/** Where the sheet goes among its parent's children. */
+export type GradePlacement = 'top' | 'bottom';
+export interface ColorGradeOptions {
+    /** How often (ms) the grade is read again: the hour moves slowly, so not every frame (default 500). */
+    readEveryMs?: number;
+    /** The container the sheet is added to (default the stage's screen layer). */
+    parent?: Container;
+    /**
+     * `'top'` (the default) adds the sheet over everything already in `parent`, so it tints a HUD made before it and
+     * not one made after. `'bottom'` puts it under every child `parent` has or will have: on the screen layer that is
+     * over the world and under every HUD, whatever order they were made in — usually what a grade wants.
+     */
+    placement?: GradePlacement;
+}
+/**
+ * A colour laid over the whole screen in **multiply**, so it tints the world (a marsh mossy, a peak ember, a dead
+ * land pale) without washing the art toward white the way a normal-blend sheet would. One white quad, tinted: no
+ * filter pass, which is what a phone can spare every frame.
+ *
+ * `read` returns the grade now (`gradeAt` from a place's `Grade` and `DayClock`'s night, say); it is asked a few
+ * times a second, and a grade that comes to white is not drawn at all. Give `placement: 'bottom'` to keep it off the
+ * HUD (see `ColorGradeOptions.placement`).
+ */
+export declare class ColorGrade {
+    private readonly stage;
+    private readonly read;
+    private readonly sheet;
+    private readAt;
+    private blank;
+    private readonly every;
+    constructor(stage: Stage, read: () => GradeState | null, options?: ColorGradeOptions);
+    /** Reads the grade again on the next update (the place changed). */
+    invalidate(): void;
+    /** `enabled`: the game's setting, and off under a battery saver — a full-screen blend is a cost on a phone. */
+    update(now: number, enabled?: boolean): void;
+    destroy(): void;
+}
+//# sourceMappingURL=ColorGrade.d.ts.map

package/dist/types/ambient/ColorGrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorGrade.d.ts","sourceRoot":"","sources":["../../../src/ambient/ColorGrade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAEtD,wDAAwD;AACxD,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,QAAQ,CAAC;AAE9C,MAAM,WAAW,iBAAiB;IAChC,uGAAuG;IACvG,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB;;;;OAIG;IACH,SAAS,CAAC,EAAE,cAAc,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,qBAAa,UAAU;IAOnB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAPvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0C;IAChE,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAGZ,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,MAAM,UAAU,GAAG,IAAI,EAC9C,OAAO,GAAE,iBAAsB;IAUjC,oEAAoE;IACpE,UAAU,IAAI,IAAI;IAIlB,+GAA+G;IAC/G,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,UAAO,GAAG,IAAI;IAoBzC,OAAO,IAAI,IAAI;CAGhB"}

package/dist/types/ambient/DayClock.d.ts

@@ -0,0 +1,80 @@
+/**
+ * A time of day read off a wall clock, so every client that agrees on the time (`serverNow`) stands in the same dusk
+ * without a packet between them. Pure: no Pixi, no clock of its own — the caller hands in the time, and what draws
+ * the night (a `LightLayer`, the pixel `NightShade`) or a HUD badge reads what this returns.
+ *
+ * ```ts
+ * const clock = new DayClock({
+ *   periodMs: 2 * 3600_000, // a game day every two real hours
+ *   keys: [
+ *     { at: 0, color: 0x0a1030, alpha: 0.52 },
+ *     { at: 0.3, color: 0xfff0d8, alpha: 0 },
+ *     { at: 0.7, color: 0xffb070, alpha: 0 },
+ *     { at: 0.86, color: 0x0a1030, alpha: 0.52 },
+ *   ],
+ *   phases: [{ id: 'dawn', from: 0.2 }, { id: 'day', from: 0.3 }, { id: 'dusk', from: 0.7 }, { id: 'night', from: 0.8 }],
+ * });
+ * const day = clock.at(serverNow()); // { phase, id, color, alpha, night }
+ * ```
+ *
+ * Phase 0 is midnight and 0.5 noon. Keys are the grade laid over the outdoor world at points of the day, mixed
+ * between neighbours; a key at 0 and one at 1 with the same values make midnight seamless.
+ */
+/** The world's grade at one point of the day: its colour (0xRRGGBB) and how strongly it is laid (0 by day). */
+export interface DayKey {
+    at: number;
+    color: number;
+    alpha: number;
+}
+/** A named part of the day starting at `from` (0..1); the last one runs on through midnight. */
+export interface DayPhase<P extends string = string> {
+    id: P;
+    from: number;
+}
+export interface DayClockOptions<P extends string = string> {
+    /** Real milliseconds a whole game day lasts. */
+    periodMs: number;
+    /** Shifts the day against the wall clock (the same offset on every client keeps them together). */
+    offsetMs?: number;
+    /** At least one key. */
+    keys: readonly DayKey[];
+    /** Optional names for parts of the day; without them `id` is ''. */
+    phases?: readonly DayPhase<P>[];
+}
+export interface DayState<P extends string = string> {
+    /** 0..1 through the game day: 0 midnight, 0.5 noon. */
+    phase: number;
+    /** The part of the day `phase` falls in. */
+    id: P | '';
+    /** The grade over the outdoor world, 0xRRGGBB. */
+    color: number;
+    /** How strongly the grade is laid (0 at full day). */
+    alpha: number;
+    /** 0 by day, 1 at the darkest key: how much lamps matter. */
+    night: number;
+}
+/** `a` taken `t` of the way to `b`, per channel, 0xRRGGBB. */
+export declare function mixRgb(a: number, b: number, t: number): number;
+export declare class DayClock<P extends string = string> {
+    private readonly periodMs;
+    private readonly offsetMs;
+    private readonly keys;
+    private readonly phases;
+    private readonly maxAlpha;
+    /** A phase held still (a debug command, a cut scene at midnight); null follows the clock. */
+    private held;
+    constructor(options: DayClockOptions<P>);
+    /** Holds the day at `phase` (0..1), or lets it run again with null. */
+    hold(phase: number | null): void;
+    /** Where the day stands at wall time `ms` (0..1). */
+    phaseAt(ms: number): number;
+    at(ms: number): DayState<P>;
+}
+/** A day's phase as a 24-hour clock, "HH:MM" (phase 0 is midnight). */
+export declare function clockText(phase: number): string;
+/**
+ * The night's colour pulled toward a place's own (a marsh mossy, a wood blue) as it deepens: `share` of the way at
+ * full night, nothing by day.
+ */
+export declare function tintNight(day: Pick<DayState, 'color' | 'night'>, tint: number | undefined, share?: number): number;
+//# sourceMappingURL=DayClock.d.ts.map

package/dist/types/ambient/DayClock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DayClock.d.ts","sourceRoot":"","sources":["../../../src/ambient/DayClock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,+GAA+G;AAC/G,MAAM,WAAW,MAAM;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,gGAAgG;AAChG,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACjD,EAAE,EAAE,CAAC,CAAC;IACN,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACxD,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,mGAAmG;IACnG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wBAAwB;IACxB,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,oEAAoE;IACpE,MAAM,CAAC,EAAE,SAAS,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;CACjC;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACjD,uDAAuD;IACvD,KAAK,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC;IACX,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;CACf;AAED,8DAA8D;AAC9D,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAG9D;AAED,qBAAa,QAAQ,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAW;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,6FAA6F;IAC7F,OAAO,CAAC,IAAI,CAAuB;gBAEvB,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC;IAWvC,uEAAuE;IACvE,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAIhC,qDAAqD;IACrD,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAM3B,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC;CA0B5B;AAED,uEAAuE;AACvE,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAG/C;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,SAAM,GAAG,MAAM,CAE/G"}

package/dist/types/ambient/WeatherLayer.d.ts

@@ -0,0 +1,78 @@
+import type { ViewRect } from '../core/Camera.js';
+import type { Stage } from '../core/Stage.js';
+import type { WeatherState } from './weather.js';
+/**
+ * How one kind of weather moves:
+ * - `fall`: streaks falling at a slant onto a ground line somewhere in view, half of them leaving a two-frame splash
+ *   (rain);
+ * - `flake`: bits drifting down and swaying as they fall, each on its own phase (snow, ash, petals);
+ * - `bank`: a few wide sprites drifting slowly sideways, laid over the bodies (fog, mist, smoke).
+ */
+export type WeatherMotion = 'fall' | 'flake' | 'bank';
+export interface WeatherLook {
+    motion: WeatherMotion;
+    /** Particles at full strength; fewer show as the weather thins. Keep it in the low hundreds on a phone. */
+    max: number;
+    /** Texture keys, handed out in turn (repeat a key to make it commoner). */
+    keys: readonly string[];
+    /** `fall` only: the splash's two frames. Without them a drop simply vanishes where it lands. */
+    splash?: readonly [string, string];
+    /** World px a second, [lo, hi] each (defaults suit each motion). */
+    vx?: readonly [number, number];
+    vy?: readonly [number, number];
+    /** `flake` only: how far (px) a flake sways either side as it falls (default 4). */
+    sway?: number;
+    /** A screen-wide tint the kind lays over everything (fog is mostly tint), at `tintAlpha` × strength. */
+    tint?: number;
+    tintAlpha?: number;
+}
+export interface WeatherLayerOptions<K extends string> {
+    looks: Readonly<Partial<Record<K, WeatherLook>>>;
+    /** Depth of falling particles in the world layer: over the bodies, under the names (default 900_001). */
+    depth?: number;
+    /** Depth of fog banks (default 900_010). */
+    bankDepth?: number;
+    /** Depth of splashes: with the ground effects, so a body standing in the rain is not splashed over (default 0). */
+    splashDepth?: number;
+    /** Round positions to whole world pixels (default true): pixel art wants it, smooth art may not. */
+    snap?: boolean;
+    /** Where randomness comes from (default `Math.random`); the look of a shower need not be shared between clients. */
+    random?: () => number;
+}
+/**
+ * The weather on screen: a capped pool of particles that lives only inside the camera's view, plus a light screen
+ * tint for the kinds that change the air. Feed it a `WeatherState` each frame (from `weatherAt`, so it fades in and
+ * out exactly when every other client's does); the pool is rebuilt only when the kind changes, and a thinning shower
+ * hides particles rather than freeing them.
+ *
+ * The art is the game's: name texture keys per kind (the pixel module's `paintWeatherArt` paints a set in whole
+ * pixels).
+ */
+export declare class WeatherLayer<K extends string> {
+    private readonly stage;
+    private readonly options;
+    private readonly drops;
+    private kind;
+    private look;
+    private readonly tint;
+    private readonly depth;
+    private readonly bankDepth;
+    private readonly splashDepth;
+    private readonly snap;
+    private readonly random;
+    constructor(stage: Stage, options: WeatherLayerOptions<K>);
+    /**
+     * `now` in ms, `dt` the frame's ms, `view` the camera's world view. `share` (0..1) thins the pool on top of the
+     * weather's own strength (a reduced-effects setting keeps half).
+     */
+    update(now: number, dt: number, view: ViewRect, weather: WeatherState<K>, share?: number): void;
+    private rebuild;
+    private between;
+    private place;
+    private spawn;
+    private stepFall;
+    private stepFlake;
+    private stepBank;
+    destroy(): void;
+}
+//# sourceMappingURL=WeatherLayer.d.ts.map

package/dist/types/ambient/WeatherLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WeatherLayer.d.ts","sourceRoot":"","sources":["../../../src/ambient/WeatherLayer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAEtD,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,aAAa,CAAC;IACtB,2GAA2G;IAC3G,GAAG,EAAE,MAAM,CAAC;IACZ,2EAA2E;IAC3E,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,gGAAgG;IAChG,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,oEAAoE;IACpE,EAAE,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,EAAE,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,oFAAoF;IACpF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wGAAwG;IACxG,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB,CAAC,CAAC,SAAS,MAAM;IACnD,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACjD,yGAAyG;IACzG,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mHAAmH;IACnH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oGAAoG;IACpG,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,oHAAoH;IACpH,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;CACvB;AAsBD;;;;;;;;GAQG;AACH,qBAAa,YAAY,CAAC,CAAC,SAAS,MAAM;IAYtC,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAZ1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,IAAI,CAAwB;IACpC,OAAO,CAAC,IAAI,CAA0B;IACtC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA0C;IAC/D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;gBAGnB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAWlD;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,SAAI,GAAG,IAAI;IA2B1F,OAAO,CAAC,OAAO;IAkBf,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,KAAK;IAIb,OAAO,CAAC,KAAK;IAyBb,OAAO,CAAC,QAAQ;IAuBhB,OAAO,CAAC,SAAS;IAajB,OAAO,CAAC,QAAQ;IAOhB,OAAO,IAAI,IAAI;CAKhB"}

package/dist/types/ambient/grade.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The pure half of a colour grade: how strong a place's colour is laid at a point of the day, and the multiply colour
+ * that leaves the same result. `ColorGrade` draws it.
+ */
+/** A place's grade: its colour (0xRRGGBB) and how strongly it is laid by day and by night (0..1). */
+export interface Grade {
+    color: number;
+    day: number;
+    night: number;
+}
+export interface GradeState {
+    color: number;
+    alpha: number;
+}
+/**
+ * The grade at `night` (0 by day, 1 at full night, `DayClock`'s `night`), never past `max`: a grade is a light
+ * tint, and one laid too strong washes every sprite toward one colour.
+ */
+export declare function gradeAt(grade: Grade, night: number, max?: number): GradeState;
+/** `color` taken `share` of the way from white: what a multiply sheet of that colour at that opacity leaves. */
+export declare function mixToWhite(color: number, share: number): number;
+//# sourceMappingURL=grade.d.ts.map

package/dist/types/ambient/grade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grade.d.ts","sourceRoot":"","sources":["../../../src/ambient/grade.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,qGAAqG;AACrG,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,SAAO,GAAG,UAAU,CAG3E;AAED,gHAAgH;AAChH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAI/D"}

package/dist/types/ambient/weather.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Weather rolled from wall time alone, so two players standing in the same place are rained on together without a
+ * packet between them. Pure and deterministic: the same key, time and table give the same sky on every machine.
+ *
+ * Time is cut into slots; each slot rolls one entry of a weighted list from a hash of the key and the slot number,
+ * and a change of kind fades out at the end of its slot and in at the start of the next. Places can share one sky:
+ * a key listed in a `skies` group takes its kind from the group's roll (so the rain does not stop at a map's edge)
+ * and only its strength from its own list. The kind `'clear'` means no weather and has no strength.
+ *
+ * ```ts
+ * const TABLE: WeatherTable = {
+ *   slotMs: 12 * 60_000,
+ *   fadeMs: 40_000,
+ *   places: { meadow: [{ kind: 'clear', weight: 4 }, { kind: 'rain', weight: 3, intensity: [0.4, 1] }] },
+ * };
+ * const w = weatherAt('meadow', serverNow(), TABLE); // { kind: 'rain', intensity: 0.7 }
+ * ```
+ */
+export interface WeatherEntry<K extends string = string> {
+    kind: K | 'clear';
+    weight: number;
+    /** The strength range rolled for this kind, [lo, hi] in 0..1 (default [1, 1]). */
+    intensity?: readonly [number, number];
+}
+export interface WeatherSky<K extends string = string> {
+    /** The place keys under this sky. */
+    places: readonly string[];
+    entries: readonly WeatherEntry<K>[];
+}
+export interface WeatherTable<K extends string = string> {
+    /** How long one roll of the sky lasts. */
+    slotMs: number;
+    /** How long a change of kind takes to fade out and in. */
+    fadeMs: number;
+    /** Each place's own list; a place with none (a cave) has no weather, even inside a sky. */
+    places: Readonly<Record<string, readonly WeatherEntry<K>[]>>;
+    /** Groups of neighbouring places that share one sky, by group id. */
+    skies?: Readonly<Record<string, WeatherSky<K>>>;
+}
+export interface WeatherState<K extends string = string> {
+    kind: K | 'clear';
+    /** 0..1, already faded round a change of kind; 0 when clear. */
+    intensity: number;
+}
+/** FNV-1a over the text, then an avalanche: a stable number in [0, 1). */
+export declare function hash01(text: string): number;
+/** The weather over place `key` at wall time `ms`. */
+export declare function weatherAt<K extends string>(key: string, ms: number, table: WeatherTable<K>): WeatherState<K>;
+//# sourceMappingURL=weather.d.ts.map

package/dist/types/ambient/weather.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weather.d.ts","sourceRoot":"","sources":["../../../src/ambient/weather.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACrD,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,SAAS,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACnD,qCAAqC;IACrC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,OAAO,EAAE,SAAS,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACrD,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAC;IACf,2FAA2F;IAC3F,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC7D,qEAAqE;IACrE,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACrD,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC;IAClB,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAC;CACnB;AAID,0EAA0E;AAC1E,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAU3C;AAiCD,sDAAsD;AACtD,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAuB5G"}

package/dist/types/anim/AnimStateMachine.d.ts

@@ -0,0 +1,80 @@
+import { Animator, type AnimationClip } from './Animator.js';
+import type { AnimParams, AnimStateMachineOptions } from './animStateTypes.js';
+/**
+ * Chooses which clip an `Animator` plays from named states and the transitions between them, the way an animation
+ * graph in a larger engine does: the game sets parameters (a bool, a number, a one-shot trigger) and the machine
+ * moves between states when a transition's conditions hold, when a clip has played through, or from any state at
+ * all by priority. Frame markers fire events (a footstep on frame 3) for the game to hang sounds and effects on.
+ *
+ * Pure and driven by `update(dt)`, so it runs under node with a fake clock. The definition is compiled into typed
+ * arrays once; an update allocates nothing.
+ *
+ * ```ts
+ * const sm = new AnimStateMachine(sheet.clips, {
+ *   initial: 'idle',
+ *   params: { speed: 0, grounded: true, jump: 'trigger' },
+ *   states: { idle: { clip: 'idle' }, run: { clip: 'run', markers: [{ frame: 2, name: 'step' }] }, jump: { clip: 'jump' } },
+ *   transitions: [
+ *     { from: 'idle', to: 'run', when: { speed: ['>', 0] } },
+ *     { from: 'run', to: 'idle', when: { speed: 0 } },
+ *     { from: '*', to: 'jump', when: { jump: true, grounded: true }, priority: 10 },
+ *   ],
+ * });
+ * sm.onEvent = (name) => name === 'step' && sound.play('step');
+ * sm.set('speed', 3);
+ * sm.update(dt);              // seconds; then show sm.frame
+ * ```
+ */
+export declare class AnimStateMachine<State extends string = string, Clip extends string = string, P extends AnimParams = AnimParams> {
+    /** The animator it drives; read `frame` off it (or off the machine). */
+    readonly animator: Animator<Clip>;
+    /** Fired for every marker playback reaches, the state's first frame's on entering it. */
+    onEvent: ((event: string, state: State, frame: number) => void) | null;
+    /** Fired after each change of state. */
+    onStateChange: ((from: State, to: State) => void) | null;
+    private readonly params;
+    private readonly states;
+    private readonly tr;
+    private readonly keepTriggers;
+    private stateIndex;
+    /** Time played in this state, ms, scaled by speed as the animator scales it. */
+    private time;
+    constructor(clips: Record<Clip, AnimationClip>, options: AnimStateMachineOptions<State, Clip, P>);
+    /** The state playing. */
+    get state(): State;
+    /** The frame to show now (a sheet frame index or name, as the clip lists it). */
+    get frame(): string | number;
+    /** How much of this state's clip has played: 0 at entry, 1 after one pass, 2 after two loops. */
+    get normalizedTime(): number;
+    /** Sets a bool or number parameter. */
+    set(name: keyof P & string, value: boolean | number): this;
+    /** A parameter's value: bools as booleans, triggers as whether they are set. */
+    get(name: keyof P & string): boolean | number;
+    /** Fires a trigger: the next update's transitions see it once. */
+    trigger(name: keyof P & string): this;
+    resetTrigger(name: keyof P & string): this;
+    /** Goes to `state` now, whatever the transitions say (a respawn, a cut scene). */
+    play(state: State): this;
+    /** Back to the initial values of every parameter (triggers cleared). */
+    resetParams(): this;
+    /**
+     * Advances the clip by `dt` seconds, fires the markers it passed, then takes at most one transition (so a chain of
+     * them never runs through several states in one frame). `update(0)` only checks the transitions.
+     */
+    update(dt: number): void;
+    private pick;
+    private holds;
+    private enter;
+    /**
+     * Fires the markers of every frame after `from` up to `to`. The animator skips frames on a long step, so they are
+     * walked rather than only the one landed on; a step long enough to loop the whole clip fires each frame once.
+     */
+    private firePassed;
+    private fire;
+    private applySpeed;
+    private consumeTriggers;
+    private clearTriggers;
+    private paramIndex;
+    private triggerIndex;
+}
+//# sourceMappingURL=AnimStateMachine.d.ts.map

package/dist/types/anim/AnimStateMachine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimStateMachine.d.ts","sourceRoot":"","sources":["../../../src/anim/AnimStateMachine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAiB1D,OAAO,KAAK,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,gBAAgB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,EAAE,IAAI,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,SAAS,UAAU,GAAG,UAAU;IAC1H,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;IAClC,yFAAyF;IACzF,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,IAAI,CAAQ;IAC9E,wCAAwC;IACxC,aAAa,EAAE,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,IAAI,CAAQ;IAEhE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAsB;IACzC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAU;IACvC,OAAO,CAAC,UAAU,CAAS;IAC3B,gFAAgF;IAChF,OAAO,CAAC,IAAI,CAAK;gBAEL,KAAK,EAAE,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC,EAAE,OAAO,EAAE,uBAAuB,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IAWhG,yBAAyB;IACzB,IAAI,KAAK,IAAI,KAAK,CAEjB;IAED,iFAAiF;IACjF,IAAI,KAAK,IAAI,MAAM,GAAG,MAAM,CAE3B;IAED,iGAAiG;IACjG,IAAI,cAAc,IAAI,MAAM,CAE3B;IAED,uCAAuC;IACvC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI;IAO1D,gFAAgF;IAChF,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM;IAM7C,kEAAkE;IAClE,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI;IAKrC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI;IAK1C,kFAAkF;IAClF,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAOxB,wEAAwE;IACxE,WAAW,IAAI,IAAI;IAKnB;;;OAGG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAqBxB,OAAO,CAAC,IAAI;IAcZ,OAAO,CAAC,KAAK;IAqBb,OAAO,CAAC,KAAK;IAWb;;;OAGG;IACH,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,IAAI;IAOZ,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,YAAY;CAKrB"}

package/dist/types/anim/Animator.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Frame animation of one sprite: which clip plays, which frame it is on. Pure state, advanced by time; a system copies
+ * `frame` onto the sprite (`animationSystem`).
+ *
+ * ```ts
+ * const clips = { idle: { frames: [0, 1], fps: 2 }, walk: { frames: [2, 3, 4, 5], fps: 10 }, die: { frames: [6, 7, 8], fps: 8, loop: false } };
+ * const a = new Animator(clips, 'idle');
+ * a.play('walk');          // switching to the clip already playing keeps its place
+ * a.update(dt);            // seconds
+ * sprite.setFrame(a.frame);
+ * ```
+ */
+export interface AnimationClip {
+    /** Frame names or indices of the sprite sheet, in order. */
+    frames: readonly (string | number)[];
+    /** Frames per second (default 10). Pixel art usually wants 8–12. */
+    fps?: number;
+    /** Start over at the end (default true); otherwise hold the last frame and report it finished. */
+    loop?: boolean;
+    /** Per-frame lengths in ms, overriding `fps` (a held key pose, a quick smear). */
+    durations?: readonly number[];
+}
+export type AnimationClips = Record<string, AnimationClip>;
+export declare class Animator<Name extends string = string> {
+    private readonly clips;
+    private clip;
+    private index;
+    private elapsed;
+    private ended;
+    private name;
+    /** Called when a clip that does not loop reaches its last frame. */
+    onComplete: ((clip: Name) => void) | null;
+    /** Playback speed multiplier (1 normal, 0 paused). */
+    speed: number;
+    constructor(clips: Record<Name, AnimationClip>, initial: NoInfer<Name>);
+    /** The clip playing. */
+    get current(): Name;
+    /** The frame to show now. */
+    get frame(): string | number;
+    /** Which frame of the clip (0-based). */
+    get frameIndex(): number;
+    /** A non-looping clip has reached its last frame. */
+    get finished(): boolean;
+    /** Plays `name`. The clip already playing keeps its place unless `restart`. */
+    play(name: Name, restart?: boolean): this;
+    /** Advances by `dt` seconds; returns true when the frame changed. */
+    update(dt: number): boolean;
+    private lengthOf;
+}
+//# sourceMappingURL=Animator.d.ts.map

package/dist/types/anim/Animator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Animator.d.ts","sourceRoot":"","sources":["../../../src/anim/Animator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B,4DAA4D;IAC5D,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IACrC,oEAAoE;IACpE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,kGAAkG;IAClG,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,kFAAkF;IAClF,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAE3D,qBAAa,QAAQ,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM;IAY9C,OAAO,CAAC,QAAQ,CAAC,KAAK;IAXxB,OAAO,CAAC,IAAI,CAAgB;IAC5B,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,IAAI,CAAO;IACnB,oEAAoE;IACpE,UAAU,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC,GAAG,IAAI,CAAQ;IACjD,sDAAsD;IACtD,KAAK,SAAK;gBAGS,KAAK,EAAE,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC,EACnD,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC;IASxB,wBAAwB;IACxB,IAAI,OAAO,IAAI,IAAI,CAElB;IAED,6BAA6B;IAC7B,IAAI,KAAK,IAAI,MAAM,GAAG,MAAM,CAE3B;IAED,yCAAyC;IACzC,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,qDAAqD;IACrD,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,+EAA+E;IAC/E,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,UAAQ,GAAG,IAAI;IAavC,qEAAqE;IACrE,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAqB3B,OAAO,CAAC,QAAQ;CAIjB"}

package/dist/types/anim/animStateCompile.d.ts

@@ -0,0 +1,52 @@
+import type { AnimationClip } from './Animator.js';
+import type { AnimParams, AnimStateMachineOptions } from './animStateTypes.js';
+export declare const PARAM_BOOL = 0;
+export declare const PARAM_NUMBER = 1;
+export declare const PARAM_TRIGGER = 2;
+export declare const OP_EQ = 0;
+export declare const OP_NE = 1;
+export declare const OP_GT = 2;
+export declare const OP_GE = 3;
+export declare const OP_LT = 4;
+export declare const OP_LE = 5;
+export interface CompiledParams {
+    names: string[];
+    index: Map<string, number>;
+    kinds: Uint8Array;
+    values: Float64Array;
+    initial: Float64Array;
+}
+export interface CompiledStates {
+    names: string[];
+    index: Map<string, number>;
+    clips: string[];
+    speeds: Float64Array;
+    /** Index of the speed parameter, or -1. */
+    speedParams: Int32Array;
+    /** Total length of each state's clip in ms, at speed 1. */
+    lengths: Float64Array;
+    frameCounts: Int32Array;
+    /** Per state, per clip frame: the event names fired there (undefined: none). */
+    markers: (readonly (readonly string[] | undefined)[])[];
+    /** Per state: transition indices to try, best first. */
+    candidates: Int32Array[];
+}
+export interface CompiledTransitions {
+    to: Int32Array;
+    anyState: Uint8Array;
+    self: Uint8Array;
+    onEnd: Uint8Array;
+    /** -1: none. */
+    exitTime: Float64Array;
+    condStart: Int32Array;
+    condEnd: Int32Array;
+    condParam: Int32Array;
+    condOp: Uint8Array;
+    condValue: Float64Array;
+}
+/** The length of a clip in ms, frame by frame exactly as `Animator` times it. */
+export declare function clipLength(clip: AnimationClip): number;
+export declare function compileParams(decl: AnimParams): CompiledParams;
+export declare function compileStates(options: AnimStateMachineOptions<string, string, AnimParams>, clips: Record<string, AnimationClip>, params: CompiledParams): CompiledStates;
+export declare function compileTransitions(options: AnimStateMachineOptions<string, string, AnimParams>, states: CompiledStates, params: CompiledParams): CompiledTransitions;
+//# sourceMappingURL=animStateCompile.d.ts.map

package/dist/types/anim/animStateCompile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animStateCompile.d.ts","sourceRoot":"","sources":["../../../src/anim/animStateCompile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAiB,UAAU,EAAE,uBAAuB,EAAa,MAAM,kBAAkB,CAAC;AAQtG,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,aAAa,IAAI,CAAC;AAE/B,eAAO,MAAM,KAAK,IAAI,CAAC;AACvB,eAAO,MAAM,KAAK,IAAI,CAAC;AACvB,eAAO,MAAM,KAAK,IAAI,CAAC;AACvB,eAAO,MAAM,KAAK,IAAI,CAAC;AACvB,eAAO,MAAM,KAAK,IAAI,CAAC;AACvB,eAAO,MAAM,KAAK,IAAI,CAAC;AAIvB,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3B,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,YAAY,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,YAAY,CAAC;IACrB,2CAA2C;IAC3C,WAAW,EAAE,UAAU,CAAC;IACxB,2DAA2D;IAC3D,OAAO,EAAE,YAAY,CAAC;IACtB,WAAW,EAAE,UAAU,CAAC;IACxB,gFAAgF;IAChF,OAAO,EAAE,CAAC,SAAS,CAAC,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC;IACxD,wDAAwD;IACxD,UAAU,EAAE,UAAU,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,UAAU,CAAC;IACf,QAAQ,EAAE,UAAU,CAAC;IACrB,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,UAAU,CAAC;IAClB,gBAAgB;IAChB,QAAQ,EAAE,YAAY,CAAC;IACvB,SAAS,EAAE,UAAU,CAAC;IACtB,OAAO,EAAE,UAAU,CAAC;IACpB,SAAS,EAAE,UAAU,CAAC;IACtB,MAAM,EAAE,UAAU,CAAC;IACnB,SAAS,EAAE,YAAY,CAAC;CACzB;AAED,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAItD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,cAAc,CAgB9D;AAED,wBAAgB,aAAa,CAC3B,OAAO,EAAE,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,EAC5D,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,EACpC,MAAM,EAAE,cAAc,GACrB,cAAc,CAiChB;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,EAC5D,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,GACrB,mBAAmB,CAmDrB"}

package/dist/types/anim/animStateSystem.d.ts

@@ -0,0 +1,10 @@
+import { type ComponentType, type System } from '../ecs/World.js';
+import type { AnimStateMachine } from './AnimStateMachine.js';
+/** An entity's animation state machine. Give an entity this instead of `AnimationComponent`: the machine owns its animator. */
+export declare const AnimStateComponent: ComponentType<AnimStateMachine>;
+/**
+ * Updates every `AnimStateMachine` each frame and shows its frame on the entity's sprite (only when it changed).
+ * Add it after the systems that set the machines' parameters, so a change shows the same frame.
+ */
+export declare function animStateSystem(name?: string): System;
+//# sourceMappingURL=animStateSystem.d.ts.map

package/dist/types/anim/animStateSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animStateSystem.d.ts","sourceRoot":"","sources":["../../../src/anim/animStateSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AAExF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,+HAA+H;AAC/H,eAAO,MAAM,kBAAkB,EAAE,aAAa,CAAC,gBAAgB,CAAkD,CAAC;AAElH;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,SAAe,GAAG,MAAM,CAQ3D"}

package/dist/types/anim/animStateTypes.d.ts

@@ -0,0 +1,50 @@
+import type { ClipMarker } from './asepriteTypes.js';
+/** A parameter's declaration, by its starting value: a bool, a number, or the word 'trigger' (a one-shot flag). */
+export type AnimParamDecl = boolean | number | 'trigger';
+export type AnimParams = Record<string, AnimParamDecl>;
+export type CompareOp = '==' | '!=' | '>' | '>=' | '<' | '<=';
+/**
+ * What a transition asks of one parameter: a bool or number to equal, `[op, number]` to compare a number, and for a
+ * trigger `true` (it was fired) or `false` (it was not).
+ */
+export type AnimCondition = boolean | number | readonly [CompareOp, number];
+export interface AnimStateDef<Clip extends string> {
+    /** The clip this state plays, entered from its first frame. */
+    clip: Clip;
+    /** Playback speed (default 1). */
+    speed?: number;
+    /** A number parameter the speed is multiplied by (its size: a run cadence that follows the body's speed). */
+    speedParam?: string;
+    /** Events fired as playback reaches frames of the clip (positions in the clip, 0-based). */
+    markers?: readonly ClipMarker[];
+}
+export interface AnimTransition<State extends string, P extends AnimParams> {
+    /** The state it leaves, several, or '*' for any state (an any-state transition). */
+    from: State | '*' | readonly State[];
+    to: State;
+    /** Every condition must hold. Triggers it names are used up when it is taken. */
+    when?: {
+        readonly [K in keyof P]?: AnimCondition;
+    };
+    /** Only once the clip has played through once (a non-looping clip has finished, a looping one has looped). */
+    onEnd?: boolean;
+    /** Only once this share of the clip has played (0.5 is half way; 2 is two loops). */
+    exitTime?: number;
+    /** Checked before lower ones; ties in the order written. Default 0. */
+    priority?: number;
+    /** An any-state transition may re-enter the state it is already in (default false: it would restart every update). */
+    self?: boolean;
+}
+export interface AnimStateMachineOptions<State extends string, Clip extends string, P extends AnimParams> {
+    initial: NoInfer<State>;
+    states: Record<State, AnimStateDef<Clip>>;
+    params?: P;
+    transitions?: readonly AnimTransition<NoInfer<State>, NoInfer<P>>[];
+    /**
+     * Keep a trigger no transition used until one does (default false: cleared at the end of every update). Off by
+     * default because a press that changed nothing now — a jump pressed in mid-air — should not play out later, on
+     * landing.
+     */
+    keepTriggers?: boolean;
+}
+//# sourceMappingURL=animStateTypes.d.ts.map

package/dist/types/anim/animStateTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animStateTypes.d.ts","sourceRoot":"","sources":["../../../src/anim/animStateTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,mHAAmH;AACnH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;AACzD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAEvD,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,CAAC;AAE9D;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;AAE5E,MAAM,WAAW,YAAY,CAAC,IAAI,SAAS,MAAM;IAC/C,+DAA+D;IAC/D,IAAI,EAAE,IAAI,CAAC;IACX,kCAAkC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6GAA6G;IAC7G,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4FAA4F;IAC5F,OAAO,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CACjC;AAED,MAAM,WAAW,cAAc,CAAC,KAAK,SAAS,MAAM,EAAE,CAAC,SAAS,UAAU;IACxE,oFAAoF;IACpF,IAAI,EAAE,KAAK,GAAG,GAAG,GAAG,SAAS,KAAK,EAAE,CAAC;IACrC,EAAE,EAAE,KAAK,CAAC;IACV,iFAAiF;IACjF,IAAI,CAAC,EAAE;QAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,aAAa;KAAE,CAAC;IACnD,8GAA8G;IAC9G,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sHAAsH;IACtH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,uBAAuB,CAAC,KAAK,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,EAAE,CAAC,SAAS,UAAU;IACtG,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC,KAAK,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;IAC1C,MAAM,CAAC,EAAE,CAAC,CAAC;IACX,WAAW,CAAC,EAAE,SAAS,cAAc,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACpE;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB"}

package/dist/types/anim/animationSystem.d.ts

@@ -0,0 +1,13 @@
+import type { Image } from '../core/Image.js';
+import { type ComponentType, type System } from '../ecs/World.js';
+import type { Animator } from './Animator.js';
+/** The engine's sprite component: the `Image` an entity is drawn as. */
+export declare const SpriteComponent: ComponentType<Image>;
+/** The engine's animation component: the `Animator` choosing the sprite's frame. */
+export declare const AnimationComponent: ComponentType<Animator>;
+/**
+ * Advances every `Animator` each frame and shows its frame on the entity's sprite (only when it changed, so an idle
+ * crowd costs no texture swaps).
+ */
+export declare function animationSystem(name?: string): System;
+//# sourceMappingURL=animationSystem.d.ts.map

package/dist/types/anim/animationSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animationSystem.d.ts","sourceRoot":"","sources":["../../../src/anim/animationSystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAA2B,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AACxF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,wEAAwE;AACxE,eAAO,MAAM,eAAe,EAAE,aAAa,CAAC,KAAK,CAAoC,CAAC;AAEtF,oFAAoF;AACpF,eAAO,MAAM,kBAAkB,EAAE,aAAa,CAAC,QAAQ,CAA0C,CAAC;AAElG;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,SAAc,GAAG,MAAM,CAO1D"}

package/dist/types/anim/asepriteSlices.d.ts

@@ -0,0 +1,19 @@
+import type { AsepriteSheet, AsepriteSlice, AsepriteSliceKey } from './asepriteTypes.js';
+/** A slice by name, or undefined. */
+export declare function sliceNamed(sheet: AsepriteSheet, name: string): AsepriteSlice | undefined;
+/**
+ * The key of `slice` in effect on sprite frame `frame`: Aseprite keys a slice on the frame it changes and holds it
+ * until the next key, so the last key at or before the frame. Before the first key the slice is not there (undefined).
+ */
+export declare function sliceAt(slice: AsepriteSlice, frame?: number): AsepriteSliceKey | undefined;
+/**
+ * The 9-slice borders of a key with a centre — how far in from each edge the stretchable middle starts — in the shape
+ * Pixi's `NineSliceSprite` and `Texture.defaultBorders` take. Undefined for a key with no centre.
+ */
+export declare function sliceBorders(key: AsepriteSliceKey): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+} | undefined;
+//# sourceMappingURL=asepriteSlices.d.ts.map

package/dist/types/anim/asepriteSlices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asepriteSlices.d.ts","sourceRoot":"","sources":["../../../src/anim/asepriteSlices.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEtF,qCAAqC;AACrC,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAExF;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,SAAI,GAAG,gBAAgB,GAAG,SAAS,CAOrF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,gBAAgB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAI5H"}

package/dist/types/anim/asepriteTags.d.ts

@@ -0,0 +1,16 @@
+import type { AsepriteDirection } from './asepriteTypes.js';
+/** Aseprite's direction name, or forward for anything unknown (older files write none). */
+export declare function tagDirection(raw: string | undefined): AsepriteDirection;
+/** Aseprite writes the repeat count as a string; absent, 0 or nonsense is forever. */
+export declare function tagRepeat(raw: string | number | undefined): number;
+/**
+ * The sheet frames a tag plays, in playing order, unrolled so the engine's `Animator` (which only ever plays a list
+ * forward) shows exactly what Aseprite's own player shows.
+ *
+ * - forever (`repeat` 0): forward and reverse are one pass, looped; a ping-pong is one round trip without its two
+ *   ends doubled (a b c d c b, then a again), so a loop never stutters on the turn.
+ * - `repeat` n: n passes, played once. A ping-pong counts each pass in one direction as one, as Aseprite does, and two
+ *   passes share their turning frame (repeat 2 of a b c is a b c b a).
+ */
+export declare function tagFrames(from: number, to: number, direction: AsepriteDirection, repeat: number): number[];
+//# sourceMappingURL=asepriteTags.d.ts.map