1681-engine 0.0.0-stage → 0.5.9

package/dist/types/physics/types.d.ts

@@ -0,0 +1,116 @@
+import type { Body } from './Body.js';
+/**
+ * The shapes a body may have, each centred on the body's position. A body turns only when it is made with
+ * `rotates: true`; a platformer's bodies need no rotation, and a body that never turns keeps the cheap axis-aligned
+ * tests and the steadiest stacks.
+ */
+export type Shape = CircleShape | BoxShape | PolygonShape;
+export interface CircleShape {
+    readonly kind: 'circle';
+    radius: number;
+}
+export interface BoxShape {
+    readonly kind: 'box';
+    halfWidth: number;
+    halfHeight: number;
+}
+/** A point or a vector in world or body pixels, y down. */
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+/**
+ * A convex polygon, its vertices relative to the body's position, which must be the polygon's centroid (make one with
+ * `polygonShape`, which orders the points and moves them there). Up to `MAX_POLYGON_VERTICES` corners.
+ */
+export interface PolygonShape {
+    readonly kind: 'polygon';
+    readonly vertices: readonly Vec2[];
+}
+/**
+ * - `dynamic`: moved by gravity, forces and contacts;
+ * - `static`: never moves (ground, walls); cheapest, kept in a broad phase of its own;
+ * - `kinematic`: moved only by its velocity (a moving platform), pushes dynamic bodies and is never pushed.
+ */
+export type BodyType = 'dynamic' | 'static' | 'kinematic';
+export interface BodyOptions {
+    type?: BodyType;
+    shape: Shape;
+    x?: number;
+    y?: number;
+    vx?: number;
+    vy?: number;
+    /**
+     * Whether contacts and torques turn the body (default false). A body that does not rotate may still be placed at an
+     * `angle`, and keeps it.
+     */
+    rotates?: boolean;
+    /** Radians, clockwise on screen (y grows downwards). */
+    angle?: number;
+    /** Radians per second. */
+    angularVelocity?: number;
+    /** Turning lost per second, as a share (default 0.05): a rolling ball slows down without rolling friction. */
+    angularDamping?: number;
+    /** Mass of a dynamic body (default 1). Ignored for static and kinematic bodies, whose mass is infinite. */
+    mass?: number;
+    /** Bounce, 0–1 (default 0). A pair bounces by the larger of its two. */
+    restitution?: number;
+    /** Coulomb friction coefficient (default 0.5). A pair uses the geometric mean of its two. */
+    friction?: number;
+    /** Velocity lost per second, as a share (default 0): air drag. */
+    linearDamping?: number;
+    /** Multiplies the world's gravity for this body (default 1; 0 floats). */
+    gravityScale?: number;
+    /** A sensor reports overlaps (contact events) but is never pushed and pushes nothing. */
+    sensor?: boolean;
+    /** Category bits this body is in (default 1). */
+    layer?: number;
+    /** Category bits this body collides with (default all). A pair collides when each one's layer is in the other's mask. */
+    mask?: number;
+    /** Anything the game wants to find again from a contact or a ray hit (an entity id, an object). */
+    userData?: unknown;
+}
+/** Faces of a box that lie against more solid ground (bits), never used as a contact normal. */
+export declare const FACE_LEFT = 1;
+export declare const FACE_RIGHT = 2;
+export declare const FACE_TOP = 4;
+export declare const FACE_BOTTOM = 8;
+/** A contact as events and queries report it. The normal points from `a` towards `b`; y grows downwards. */
+export interface ContactInfo {
+    readonly a: Body;
+    readonly b: Body;
+    readonly nx: number;
+    readonly ny: number;
+    /** Overlap along the normal, px (slightly negative while resting just apart). */
+    readonly depth: number;
+    /** Either body is a sensor: reported, never resolved. */
+    readonly sensor: boolean;
+    /** Where the two touch, world px: one or two points (two where an edge lies along an edge). */
+    readonly points: readonly Vec2[];
+}
+export interface PhysicsEvents {
+    /** Two bodies started touching (or a sensor started overlapping). Emitted after the step. */
+    begin: ContactInfo;
+    /** Two bodies stopped touching, or one of them was removed. Emitted after the step. */
+    end: ContactInfo;
+}
+export interface RayHit {
+    body: Body;
+    /** Where the ray met the body. */
+    x: number;
+    y: number;
+    /** Surface normal there, pointing back towards the ray's start. */
+    nx: number;
+    ny: number;
+    /** Share of the ray's length at the hit, 0–1. */
+    fraction: number;
+}
+export interface RaycastOptions {
+    /** Only bodies whose layer shares a bit with this (default all). */
+    mask?: number;
+    /** Sensors are skipped unless this is true. */
+    includeSensors?: boolean;
+    /** Skip bodies this returns false for (the caster itself, say). */
+    filter?: (body: Body) => boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/types/pixel/Darkness.d.ts

@@ -0,0 +1,90 @@
+import type { Stage } from '../core/Stage.js';
+/** A plain light's colour (a lamp nobody named one for, the light a body carries): warm, as flame is. */
+export declare const WARM_LIGHT = 16761466;
+export declare class Darkness {
+    private readonly stage;
+    private color;
+    private alpha;
+    private readonly scratch;
+    private readonly sheet;
+    /** Every hole is erased before any colour is laid, or a later hole would wipe an earlier light's colour away. */
+    private readonly holes;
+    private readonly washes;
+    private readonly lamps;
+    /** The transient lights (`lights.ts`), reused frame to frame. */
+    private readonly flashes;
+    private rt;
+    /**
+     * On the screen layer, laid over the world with its exact transform by the camera (`Camera.follow`), shake included:
+     * the night is drawn in world pixels round the unshaken camera and only this layer moves with a shake, so a shaking
+     * screen does not redraw the night every frame.
+     */
+    private readonly layer;
+    private readonly view;
+    /** The light the player carries: the only one that follows them, and the last one they lose. */
+    private readonly carried;
+    private readonly unsubscribeResize;
+    /** Lamps that flicker: while one does (or the player carries a light) every frame differs. */
+    private flickering;
+    /** Something other than the camera changed what the night looks like (a lamp added, dimmed, the window resized). */
+    private dirty;
+    /** What the last drawn frame was drawn from: the texture, the camera's texel and the shade. */
+    private drawn;
+    /** The carried light's place at the last redraw (it follows the body). */
+    private carriedAt;
+    /** When the sheet was last redrawn. */
+    private drawnAt;
+    /** The world pixel the night's top-left texel stands on. */
+    private ox;
+    private oy;
+    /** The night texture's size in world pixels, and the zoom it was made for. */
+    private rtKey;
+    /** The lamps' colour turned down (`setLampsDimmed`). */
+    private dimLamps;
+    /** A phone redraws the night at most `PHONE_MS` apart, whatever moves (`isTouchUi`). */
+    private readonly phone;
+    /** The radius `update` uses when it is given none (`DarknessOptions.carriedLight`). */
+    readonly carriedLight: number;
+    constructor(stage: Stage, color: number, alpha: number, options?: DarknessOptions);
+    /** A hole and its colour, added to the night's layers. */
+    private light;
+    /** A lamp fixed in the world: a torch on a wall, the seep in its chamber, a crystal in a seam, in its own colour. */
+    addLamp(x: number, y: number, radius: number, flicker?: number, color?: number): void;
+    /**
+     * Changes how dark and what colour the sheet is (the outdoor night, `NightShade`, deepens and lifts with the
+     * world clock). A sheet with no alpha left is neither drawn nor redrawn, so a map at noon pays nothing for its night.
+     */
+    setShade(color: number, alpha: number): void;
+    /**
+     * Dimmed lamps lay only `LAMP_DIM` of their colour on the dark (a "fewer ambient lights" setting). The holes they
+     * cut stay as wide, so a dark place is still seen by them.
+     */
+    setLampsDimmed(dim: boolean): void;
+    /**
+     * The night's own texture, one texel a world pixel and `MARGIN` to spare on each side (a shake, or a camera that
+     * moved while a phone waits for its next redraw, never shows its edge), remade when the window or the zoom changes:
+     * at zoom 2 or 3 it is a quarter or a ninth of the screen's pixels. True when it was remade.
+     */
+    private fit;
+    /**
+     * Redraws the night with this frame's holes in it, when anything in it changed. `px`/`py` is where the player stands;
+     * `carriedRadius` is the light they carry (default the `carriedLight` option, 0 for none).
+     */
+    update(now: number, px: number, py: number, carriedRadius?: number): void;
+    private hide;
+    /** Lays light `l` at world (wx, wy), `r` px across its radius, in the night's world-pixel grid. */
+    private place;
+    destroy(): void;
+}
+/** What is left of a lamp's glow and colour while lamps are dimmed (`setLampsDimmed`). */
+export declare const LAMP_DIM = 0.35;
+/**
+ * The default radius of light the player carries underground, world px: five 16-px tiles of certainty in any
+ * direction. A game with other tiles passes its own as `DarknessOptions.carriedLight`.
+ */
+export declare const CARRIED_LIGHT = 80;
+export interface DarknessOptions {
+    /** The light the player carries when `update` is given no radius, world px (default `CARRIED_LIGHT`, 80). */
+    carriedLight?: number;
+}
+//# sourceMappingURL=Darkness.d.ts.map

package/dist/types/pixel/Darkness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Darkness.d.ts","sourceRoot":"","sources":["../../../src/pixel/Darkness.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AA2C3C,yGAAyG;AACzG,eAAO,MAAM,UAAU,WAAW,CAAC;AAsEnC,qBAAa,QAAQ;IA4CjB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,KAAK;IA7Cf,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,iHAAiH;IACjH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqF;IAC3G,iEAAiE;IACjE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,EAAE,CAAgB;IAC1B;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,gGAAgG;IAChG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAa;IAC/C,8FAA8F;IAC9F,OAAO,CAAC,UAAU,CAAK;IACvB,oHAAoH;IACpH,OAAO,CAAC,KAAK,CAAQ;IACrB,+FAA+F;IAC/F,OAAO,CAAC,KAAK,CAAM;IACnB,0EAA0E;IAC1E,OAAO,CAAC,SAAS,CAAM;IACvB,uCAAuC;IACvC,OAAO,CAAC,OAAO,CAAa;IAC5B,4DAA4D;IAC5D,OAAO,CAAC,EAAE,CAAK;IACf,OAAO,CAAC,EAAE,CAAK;IACf,8EAA8E;IAC9E,OAAO,CAAC,KAAK,CAAM;IACnB,wDAAwD;IACxD,OAAO,CAAC,QAAQ,CAAS;IACzB,wFAAwF;IACxF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IAErC,uFAAuF;IACvF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;gBAGX,KAAK,EAAE,KAAK,EACrB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACrB,OAAO,GAAE,eAAoB;IAiB/B,0DAA0D;IAC1D,OAAO,CAAC,KAAK;IAUb,qHAAqH;IACrH,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,SAAI,EAAE,KAAK,SAAa,GAAG,IAAI;IAMpF;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAM5C;;;OAGG;IACH,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAMlC;;;;OAIG;IACH,OAAO,CAAC,GAAG;IAaX;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,aAAa,SAAoB,GAAG,IAAI;IAiEpF,OAAO,CAAC,IAAI;IAKZ,mGAAmG;IACnG,OAAO,CAAC,KAAK;IAmBb,OAAO,IAAI,IAAI;CAOhB;AAED,0FAA0F;AAC1F,eAAO,MAAM,QAAQ,OAAO,CAAC;AAE7B;;;GAGG;AACH,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC,MAAM,WAAW,eAAe;IAC9B,6GAA6G;IAC7G,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB"}

package/dist/types/pixel/DitherVignette.d.ts

@@ -0,0 +1,35 @@
+import { Texture } from 'pixi.js';
+import type { Stage } from '../core/Stage.js';
+/**
+ * A white dithered edge for a screen of `w`×`h` world pixels, one texel a world pixel and scaled up `'nearest'`;
+ * the sprite that draws it tints it. Made once per size and strength. Returns `Texture.EMPTY` when the browser has
+ * no canvas memory to spare (iOS), so the caller asks again later.
+ */
+export declare function ditherVignette(w: number, h: number, strength?: number, from?: number): Texture;
+export interface DitherVignetteOptions {
+    /** The edge's colour (default black). */
+    color?: number;
+    /** How far from the centre toward a corner the edge begins, 0..1 (default 0.55). */
+    from?: number;
+}
+/**
+ * A dithered pixel edge round the screen, on the screen layer: a darkened border, or tinted red and beaten with
+ * `heartbeat` while a player is low on health. The texture is made at full strength, off the frame that first needs
+ * it (a full-screen dither is a few ms on a phone), and remade only when the window or the zoom changes; `show`
+ * changes how much of it shows.
+ */
+export declare class DitherVignette {
+    private readonly stage;
+    private readonly edge;
+    private madeFor;
+    private making;
+    private readonly from;
+    constructor(stage: Stage, options?: DitherVignetteOptions);
+    setColor(color: number): void;
+    private make;
+    /** Shows the edge at `alpha` (0..1); call each frame it shows. */
+    show(alpha: number): void;
+    hide(): void;
+    destroy(): void;
+}
+//# sourceMappingURL=DitherVignette.d.ts.map

package/dist/types/pixel/DitherVignette.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DitherVignette.d.ts","sourceRoot":"","sources":["../../../src/pixel/DitherVignette.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,OAAO,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAO3C;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,SAAI,EAAE,IAAI,SAAO,GAAG,OAAO,CAuBvF;AAED,MAAM,WAAW,qBAAqB;IACpC,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oFAAoF;IACpF,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,qBAAa,cAAc;IAOvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IANxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;IACrC,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,MAAM,CAA8C;IAC5D,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;gBAGX,KAAK,EAAE,KAAK,EAC7B,OAAO,GAAE,qBAA0B;IAYrC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI7B,OAAO,CAAC,IAAI;IAaZ,kEAAkE;IAClE,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IASzB,IAAI,IAAI,IAAI;IAIZ,OAAO,IAAI,IAAI;CAIhB"}

package/dist/types/pixel/Evaporation.d.ts

@@ -0,0 +1,30 @@
+import type { Stage } from '../core/Stage.js';
+import type { WorldObject } from '../core/types.js';
+import type { PackedPixels } from './spritePixels.js';
+/** What a dying body hands over: its feet in the world, how it was drawn, and the pixels of its last frame. */
+export interface DeathPixels {
+    x: number;
+    y: number;
+    /** World pixels per sprite pixel (the body's `scale`), negative when the body faced left. */
+    scaleX: number;
+    scaleY: number;
+    pixels: PackedPixels;
+}
+/**
+ * A dead body evaporating: it breaks into its own pixels, which let go top rows first, rise, scatter a little and
+ * give out, while the body itself is hidden by the caller. Every particle is one whole world pixel in a colour read
+ * off the body's last frame, painted at 12 fps like every other effect; it pales up its own ramp as it rises and
+ * steps its alpha down instead of melting, so it stays pixel art the whole way. A cloud is one `PixelLayer` (a pooled
+ * texture) rather than a Graphics of up to 1,400 rects.
+ */
+export declare class Evaporation {
+    private readonly scene;
+    private readonly track;
+    private readonly clouds;
+    private live;
+    constructor(scene: Stage, track: (object: WorldObject) => void);
+    play(d: DeathPixels, big: boolean, now: number): void;
+    update(now: number): void;
+    private draw;
+}
+//# sourceMappingURL=Evaporation.d.ts.map

package/dist/types/pixel/Evaporation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Evaporation.d.ts","sourceRoot":"","sources":["../../../src/pixel/Evaporation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,+GAA+G;AAC/G,MAAM,WAAW,WAAW;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,6FAA6F;IAC7F,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,YAAY,CAAC;CACtB;AAgCD;;;;;;GAMG;AACH,qBAAa,WAAW;IAKpB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;IALxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,IAAI,CAAK;gBAGE,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI;IAGvD,IAAI,CAAC,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAqDrD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAazB,OAAO,CAAC,IAAI;CA8Bb"}

package/dist/types/pixel/NightShade.d.ts

@@ -0,0 +1,38 @@
+import type { Stage } from '../core/Stage.js';
+import { type DayClock } from '../ambient/DayClock.js';
+export interface NightShadeOptions {
+    /** The day the night follows. */
+    clock: DayClock;
+    /** This place's own night colour, pulled in as the night deepens (`tintNight`); none keeps the clock's. */
+    tint?: number;
+    /** How far the tint takes over at full night (default 0.6). */
+    tintShare?: number;
+    /** A lamp's hole in the night against the glow it is drawn with (default 1.6: the light reaches past the glow). */
+    lampScale?: number;
+    /** The radius (world px) of the light a body carries at full night; 0 for none (default 64). */
+    carriedLight?: number;
+    /** The night share below which nothing is carried (default 0.55): at dusk a hole round the feet reads as a spotlight. */
+    carriedFrom?: number;
+}
+/**
+ * The outdoor night: a `DayClock`'s grade laid over the world as a dithered `Darkness`, deepening at dusk and lifting
+ * at dawn, with every lamp, window and fire burning a hole in it — the same erase trick an underground is lit by,
+ * only with a sheet whose colour and depth follow the clock. A place under no sky (a cave) builds a `Darkness` of its
+ * own instead; at noon the sheet has no alpha and costs nothing.
+ */
+export declare class NightShade {
+    private readonly options;
+    private readonly dark;
+    private readonly lampScale;
+    private readonly carried;
+    private readonly carriedFrom;
+    constructor(stage: Stage, options: NightShadeOptions);
+    /** A light the place glows with, `glowSize` the diameter of the glow drawn for it: by night it is what is seen by. */
+    addLight(x: number, y: number, glowSize: number, color?: number, flicker?: number): void;
+    /** Lamps colour the dark less (a "fewer ambient lights" setting); their holes stay as wide. */
+    setLampsDimmed(dim: boolean): void;
+    /** `now` the frame's ms, `wallMs` the shared wall time the clock reads (`serverNow()`), `px`/`py` the player. */
+    update(now: number, wallMs: number, px: number, py: number): void;
+    destroy(): void;
+}
+//# sourceMappingURL=NightShade.d.ts.map

package/dist/types/pixel/NightShade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NightShade.d.ts","sourceRoot":"","sources":["../../../src/pixel/NightShade.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAG/D,MAAM,WAAW,iBAAiB;IAChC,iCAAiC;IACjC,KAAK,EAAE,QAAQ,CAAC;IAChB,2GAA2G;IAC3G,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mHAAmH;IACnH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gGAAgG;IAChG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yHAAyH;IACzH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;GAKG;AACH,qBAAa,UAAU;IAQnB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAW;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;gBAGnC,KAAK,EAAE,KAAK,EACK,OAAO,EAAE,iBAAiB;IAS7C,sHAAsH;IACtH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,SAAI,GAAG,IAAI;IAInF,+FAA+F;IAC/F,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAIlC,iHAAiH;IACjH,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAOjE,OAAO,IAAI,IAAI;CAGhB"}

package/dist/types/pixel/PixelLayer.d.ts

@@ -0,0 +1,85 @@
+import { Graphics } from '../core/Graphics.js';
+import type { Stage } from '../core/Stage.js';
+/**
+ * A `Graphics` for the pixel effects: every `fillRect` of a frame is written into a small RGBA buffer
+ * and shown as **one** sprite, instead of becoming a rect Pixi must tessellate, batch and upload. An effect's frame is
+ * hundreds to thousands of one-pixel runs (a poison cloud, a status mark round every body in a pack), and as rects they
+ * were most of a fight's CPU on a phone (profiled). The pixels are the same: whole
+ * world pixels, a translucent fill blended over what was painted before it in the same frame, as a Graphics did.
+ *
+ * Paint between `clear()` and `present()`; anything other than `fillStyle`/`fillRect` still draws through the
+ * Graphics underneath, so a painter using another shape keeps working. Solid pixels may also be **staged**
+ * (`stage`, from `pixelTone`'s batch) and laid in one go by `commit`, which is what a batch's flush does.
+ *
+ * Buffers and their textures are pooled by size class (a texture per effect ran to ~114 a second in a busy fight,
+ * and each one stayed in Pixi's batch tables), so a destroyed layer hands its texture
+ * to the next one; `PixelLayer.drainPool` lets them all go when the map changes.
+ */
+/** A new `PixelLayer` on the stage's world layer. */
+export declare function addPixelLayer(stage: Stage): PixelLayer;
+export declare class PixelLayer extends Graphics {
+    /** This frame's rects: x, y, w, h, colour, alpha — six numbers each. */
+    private readonly rects;
+    /** Staged solid runs not yet committed: x, y, w, colour — four numbers each; later ones win. */
+    private readonly staged;
+    private ink;
+    private inkAlpha;
+    private readonly sprite;
+    private surface;
+    /** Where the buffer's first pixel sits in the layer, as of the last `present`. */
+    private originX;
+    private originY;
+    /** The last frame's size, and how many presents in a row it stayed well inside a quarter of the buffer. */
+    private lastW;
+    private lastH;
+    private small;
+    constructor();
+    /** Textures made, spent buffers waiting in the pool and their bytes (the leak tools read it). */
+    static stats(): {
+        made: number;
+        pooled: number;
+        pooledBytes: number;
+    };
+    /** Lets every pooled buffer go (the world changed map): the next map's effects start a pool of their own. */
+    static drainPool(): void;
+    fillStyle(color: number, alpha?: number): this;
+    fillRect(x: number, y: number, w: number, h: number): this;
+    /** `fillStyle` + `fillRect` on whole pixels in one call, leaving the fill style alone (a hot loop's way in). */
+    rect(x: number, y: number, w: number, h: number, color: number, alpha?: number): void;
+    /**
+     * A solid run of `w` whole pixels at (x, y) in `color`, held until `commit` lays every staged run in the order given
+     * (the later winning where they cross), after whatever was drawn before the commit. What `pixelTone`'s batch writes
+     * instead of filing each pixel in a map and sorting it into rects.
+     */
+    stage(x: number, y: number, w: number, color: number): void;
+    /** Lays the staged runs, as opaque rects, after everything drawn so far. */
+    commit(): void;
+    clear(): this;
+    /** How far the last frame reached from the layer's origin, in world pixels (0 when nothing showed). */
+    reach(): number;
+    /** Writes this frame's rects into the texture and shows it; call once the frame is painted. */
+    present(): void;
+    /**
+     * Shows `other`'s last frame instead of painting one: its texture, placed where it placed it. A frame shared by
+     * several bodies (the same aura on two bodies) is painted once and shown by each of their layers.
+     */
+    mirror(other: PixelLayer): void;
+    /** Shows nothing and lets go of the texture a `mirror` showed. */
+    hideMirror(): void;
+    /** The premultiplied [r, g, b, a] last presented at layer pixel (x, y); zeros where nothing was (tests read it). */
+    pixelAt(x: number, y: number): [number, number, number, number];
+    /** The buffer's size (tests read it). */
+    capacity(): {
+        w: number;
+        h: number;
+    };
+    /**
+     * A buffer at least `w` × `h`: grown a size class at a time and kept while it fits, traded back to the pool for a
+     * smaller one only once the frames have stayed well inside it for `SHRINK_AFTER` presents (a long-lived layer — an
+     * aura, a status mark — that once swelled would otherwise hold and upload its largest buffer for good).
+     */
+    private fit;
+    private dropSurface;
+    destroy(): void;
+}
+//# sourceMappingURL=PixelLayer.d.ts.map

package/dist/types/pixel/PixelLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PixelLayer.d.ts","sourceRoot":"","sources":["../../../src/pixel/PixelLayer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAqF3C;;;;;;;;;;;;;;GAcG;AACH,qDAAqD;AACrD,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAEtD;AAED,qBAAa,UAAW,SAAQ,QAAQ;IACtC,wEAAwE;IACxE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,gGAAgG;IAChG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,GAAG,CAAY;IACvB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,OAAO,CAAwB;IACvC,kFAAkF;IAClF,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,2GAA2G;IAC3G,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,KAAK,CAAK;;IAQlB,iGAAiG;IACjG,MAAM,CAAC,KAAK,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE;IAMrE,6GAA6G;IAC7G,MAAM,CAAC,SAAS,IAAI,IAAI;IAMf,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,IAAI;IAMzC,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IASnE,gHAAgH;IAChH,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,IAAI;IAKhF;;;;OAIG;IACH,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAI3D,4EAA4E;IAC5E,MAAM,IAAI,IAAI;IASL,KAAK,IAAI,IAAI;IAMtB,uGAAuG;IACvG,KAAK,IAAI,MAAM;IAKf,+FAA+F;IAC/F,OAAO,IAAI,IAAI;IAsFf;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAe/B,kEAAkE;IAClE,UAAU,IAAI,IAAI;IAKlB,oHAAoH;IACpH,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAa/D,yCAAyC;IACzC,QAAQ,IAAI;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE;IAIpC;;;;OAIG;IACH,OAAO,CAAC,GAAG;IAmBX,OAAO,CAAC,WAAW;IAMV,OAAO,IAAI,IAAI;CAKzB"}

package/dist/types/pixel/PixelMarks.d.ts

@@ -0,0 +1,68 @@
+import type { Stage } from '../core/Stage.js';
+/** A mark's look: the bright stroke, the rim/edge tone, the dark pixels round it, and a fill for discs. */
+export interface MarkTone {
+    light: number;
+    rim: number;
+    dark: number;
+    fill: number;
+}
+export interface PixelMarksOptions<T extends string> {
+    /** The looks marks are drawn in, by name (`aim`, `cancel`, `lock`…); every mark names one. */
+    tones: Record<T, MarkTone>;
+    /** Depth of every mark (default 0): usually just over the effects that lie on the ground. */
+    depth?: number;
+    /** Headings a chevron is painted for (default 32, 11.25° apart): each is painted once per size and tone. */
+    headings?: number;
+    /** World pixels between two chevrons of an aim line (default 10). */
+    spacing?: number;
+    /** How fast the chevrons creep along a line, px per ms (default 0.02), so it reads as a direction. */
+    creep?: number;
+    /** Opacity of a disc's fill (default 0.28). */
+    fillAlpha?: number;
+}
+/**
+ * Aim and target marks in the world's own pixels: rings, discs and ground ellipses painted once per size and tone and
+ * only moved after that, and aim lines as a row of chevrons from a pool — a chevron is repainted only when its heading,
+ * size or tone changes. Lines are chevrons, never a solid lane: a solid line of world pixels at most angles is a
+ * staircase and reads as broken, while each chevron is crisp at any angle. The drawing side of `AimGesture` and
+ * `TargetLock`. Each frame: `begin`, place what the frame needs, then `end`, which hides whatever was shown last frame
+ * and not this one.
+ */
+export declare class PixelMarks<T extends string = string> {
+    private readonly stage;
+    private readonly tones;
+    private readonly depth;
+    private readonly headings;
+    private readonly spacing;
+    private readonly creep;
+    private readonly fillAlpha;
+    private readonly cache;
+    private readonly pool;
+    private used;
+    private shown;
+    private next;
+    constructor(stage: Stage, options: PixelMarksOptions<T>);
+    begin(): void;
+    /** A ring of radius `r` round (x, y): the bright line with dark pixels just inside and outside it. */
+    ring(x: number, y: number, r: number, tone: T): void;
+    /** A filled disc of radius `r` with a bright rim and a cross at its middle: where a skill aimed at a spot lands. */
+    disc(x: number, y: number, r: number, tone: T): void;
+    /** A ring on the ground in three-quarter view, `rx` wide and `ry` deep, centred on (x, y) — a body's feet. */
+    groundRing(x: number, y: number, rx: number, ry: number, tone: T): void;
+    /**
+     * An aim line from (x, y) along `angle`, from `start` to `end` px out: chevrons `size` px across every `spacing`,
+     * creeping forward with `now`, and a larger one at the end.
+     */
+    chevrons(now: number, x: number, y: number, angle: number, start: number, end: number, size: number, tone: T): void;
+    /**
+     * One still chevron `dist` px out from (x, y) along `angle`: the way the next blow goes. Unlike `chevrons` it does
+     * not creep, so an arrow always under the feet does not keep catching the eye.
+     */
+    pointer(x: number, y: number, angle: number, dist: number, size: number, tone: T): void;
+    end(): void;
+    destroy(): void;
+    private heading;
+    private chevron;
+    private place;
+}
+//# sourceMappingURL=PixelMarks.d.ts.map

package/dist/types/pixel/PixelMarks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PixelMarks.d.ts","sourceRoot":"","sources":["../../../src/pixel/PixelMarks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAG3C,2GAA2G;AAC3G,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,MAAM;IACjD,8FAA8F;IAC9F,KAAK,EAAE,MAAM,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IAC3B,6FAA6F;IAC7F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4GAA4G;IAC5G,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sGAAsG;IACtG,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAOD;;;;;;;GAOG;AACH,qBAAa,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAc7C,OAAO,CAAC,QAAQ,CAAC,KAAK;IAbxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsB;IAC5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA+B;IACrD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsC;IAC3D,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,IAAI,CAAuB;gBAGhB,KAAK,EAAE,KAAK,EAC7B,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAU/B,KAAK,IAAI,IAAI;IAMb,sGAAsG;IACtG,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI;IAUpD,oHAAoH;IACpH,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI;IAYpD,8GAA8G;IAC9G,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI;IAYvE;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI;IAWnH;;;OAGG;IACH,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI;IAKvF,GAAG,IAAI,IAAI;IASX,OAAO,IAAI,IAAI;IASf,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,OAAO;IAmBf,OAAO,CAAC,KAAK;CAWd"}

package/dist/types/pixel/SwayProp.d.ts

@@ -0,0 +1,52 @@
+import { Texture } from 'pixi.js';
+import type { Image } from '../core/Image.js';
+import { type SwayDef, type SwayRig } from './swayRig.js';
+/**
+ * The opaque width of each row of a frame, read once off its canvas (a `crown` finds its trunk in them); undefined
+ * when the source is not a 2D canvas. The atlas pages are canvases kept on the CPU, so this costs no GPU read-back.
+ */
+export declare function opaqueRowWidths(frame: Texture): number[] | undefined;
+export interface SwayPropOptions {
+    /** Which `tufts` list to read (default 0). */
+    variant?: number;
+    /** This prop's place in the cycle, 0..1 (`tileHash` of its tile keeps it from one visit to the next). */
+    phase?: number;
+    /** Its pace against the def's `speed` (default 1): a little apart per prop, so a wood never sways in step. */
+    pace?: number;
+    /** Row widths for a `crown` (default: read off the frame with `opaqueRowWidths`). */
+    rowWidths?: readonly number[];
+    /** A rig already built for this frame (props of one frame share one). */
+    rig?: SwayRig;
+}
+export interface SwayWind {
+    /** 0 still … 1 a full wind. */
+    wind: number;
+    /** A gust's period (s) and wavelength across the world (px); see `gustAt`. */
+    gustSeconds: number;
+    gustPx: number;
+    /** The least reach while any wind blows (`swayOffset`). */
+    minReach?: number;
+}
+/**
+ * One sprite swaying in the wind, in whole world pixels. The placed image becomes the rig's first (largest) still
+ * piece — so whatever culls, fades or sorts it keeps working — and the other pieces and the strips are sprites beside
+ * it in the same parent, at its depth, following its visibility and alpha. A strip's sprite is moved only when its
+ * whole-pixel offset changes.
+ */
+export declare class SwayProp {
+    private readonly img;
+    private readonly def;
+    private readonly parts;
+    private readonly strips;
+    private readonly phase;
+    private readonly speed;
+    private shown;
+    private alpha;
+    /** False when the frame is too small or the rig has nothing to move: `update` then does nothing. */
+    readonly active: boolean;
+    constructor(img: Image, def: SwayDef, options?: SwayPropOptions);
+    /** `tSec` seconds of any steady clock; `enabled` false stands everything still (an ambient-effects setting). */
+    update(tSec: number, air: SwayWind, enabled?: boolean): void;
+    destroy(): void;
+}
+//# sourceMappingURL=SwayProp.d.ts.map

package/dist/types/pixel/SwayProp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwayProp.d.ts","sourceRoot":"","sources":["../../../src/pixel/SwayProp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,OAAO,EAAsB,MAAM,SAAS,CAAC;AACzE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAA2C,KAAK,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAehG;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,GAAG,SAAS,CAkBpE;AAED,MAAM,WAAW,eAAe;IAC9B,8CAA8C;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yGAAyG;IACzG,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8GAA8G;IAC9G,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qFAAqF;IACrF,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,yEAAyE;IACzE,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,QAAQ;IACvB,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,qBAAa,QAAQ;IAWjB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAXtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwF;IAC/G,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,KAAK,CAAU;IACvB,OAAO,CAAC,KAAK,CAAS;IACtB,oGAAoG;IACpG,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;gBAGN,GAAG,EAAE,KAAK,EACV,GAAG,EAAE,OAAO,EAC7B,OAAO,GAAE,eAAoB;IAmC/B,gHAAgH;IAChH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,UAAO,GAAG,IAAI;IAsBzD,OAAO,IAAI,IAAI;CAKhB"}

package/dist/types/pixel/aimPixels.d.ts

@@ -0,0 +1,23 @@
+export type PixelPoint = readonly [number, number];
+/** One horizontal run of pixels: row y, from x0 to x1 inclusive. */
+export type PixelRun = readonly [number, number, number];
+/** The outline of a circle of radius `r` round (0, 0), each pixel once (midpoint algorithm, 8-way symmetric). */
+export declare function ringPixels(r: number): PixelPoint[];
+/** A filled disc of radius `r` round (0, 0), one run per row. */
+export declare function discRuns(r: number): PixelRun[];
+/**
+ * The outline of an ellipse `rx` wide and `ry` deep round (0, 0), each pixel once (midpoint algorithm) — a circle on
+ * the ground as a three-quarter view shows it, so a body can stand in the middle of it.
+ */
+export declare function ellipsePixels(rx: number, ry: number): PixelPoint[];
+/**
+ * A chevron (›) pointing along `angle`, its arms `size` px out from the line either side, round (0, 0): the bright
+ * stroke and the dark pixels that rim it. A row of these, evenly spaced, is how an aim line is drawn: each one is
+ * crisp at any angle, and with no continuous edge between them there is no staircase to see — a solid line of world
+ * pixels at, say, 20° is one, and read as broken.
+ */
+export declare function chevronPixels(angle: number, size: number): {
+    lit: PixelPoint[];
+    rim: PixelPoint[];
+};
+//# sourceMappingURL=aimPixels.d.ts.map

package/dist/types/pixel/aimPixels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aimPixels.d.ts","sourceRoot":"","sources":["../../../src/pixel/aimPixels.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,UAAU,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AACnD,oEAAoE;AACpE,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAEzD,iHAAiH;AACjH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,EAAE,CAuBlD;AAED,iEAAiE;AACjE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,QAAQ,EAAE,CAQ9C;AAGD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,EAAE,CA8ClE;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG;IAAE,GAAG,EAAE,UAAU,EAAE,CAAC;IAAC,GAAG,EAAE,UAAU,EAAE,CAAA;CAAE,CA+BnG"}

package/dist/types/pixel/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Dither, 1681 Engine's pixel-art module: `import { … } from '1681-engine/pixel'`.
+ *
+ * Everything here works on the world's own pixel grid: rects batched into one texture, shapes shaded by hue-shifted
+ * ramps and faded by ordered dither, dithered lighting, bodies that evaporate into their own pixels. Start the engine
+ * with `pixelPerfect: true` so textures stay sharp and the camera lands on whole pixels.
+ */
+export { PixelLayer, addPixelLayer } from './PixelLayer.js';
+export { PixelGrid, PixelWindow, CLEAR, rgba, hex, channels, shade, mix, withAlpha, toCss, hash2, mulberry32, valueNoise, makeSheet, upscale, type Color, } from './pixel.js';
+export { P as PALETTE } from './palette.js';
+export { art, litOutline, groundShadow, shadeBox, type PropArt } from './propKit.js';
+export { ramp, rampTones, hueShade, outlineOf, registerMaterial, MATERIALS, RAMP_FACTOR_SET, type Material, type BuiltinMaterial, type MaterialLight, type RampFactors, type Ramp, } from './ramp.js';
+export { selectiveOutline } from './selout.js';
+export { ringPixels, discRuns, ellipsePixels, chevronPixels, type PixelPoint, type PixelRun } from './aimPixels.js';
+export { PixelMarks, type MarkTone, type PixelMarksOptions } from './PixelMarks.js';
+/** Pixel shapes on the 1-px world grid: `pixelPaint.ring(g, …)`, `pixelPaint.arc(g, …)`… */
+export * as pixelPaint from './pixelPaint.js';
+/** Colour ramps, grading, dithering and batching under `pixelPaint`. */
+export * as pixelTone from './pixelTone.js';
+export { registerHandRamps } from './pixelTone.js';
+export { paintLayer, type PaintLayerOptions } from './paintLayer.js';
+export { Evaporation, type DeathPixels } from './Evaporation.js';
+export { spritePixels, NO_PIXELS, PackedPixels, type SpritePixel } from './spritePixels.js';
+export { Darkness, WARM_LIGHT, LAMP_DIM, CARRIED_LIGHT, type DarknessOptions } from './Darkness.js';
+export { flashLight, carriedLight, liveLights, clearLights, type TransientLight } from './lights.js';
+export { NightShade, type NightShadeOptions } from './NightShade.js';
+export { paintWeatherArt, mistPixels, WEATHER_COLORS, type WeatherColors, type WeatherPixel } from './weatherArt.js';
+export { buildRig, trunkPivot, complement, tileHash, gustAt, swayOffset, type SwayDef, type SwayMode, type TuftRect, type SwayRig, type SwayStrip, type Rect as SwayRect } from './swayRig.js';
+export { SwayProp, opaqueRowWidths, type SwayPropOptions, type SwayWind } from './SwayProp.js';
+export { vignetteMask, heartbeat } from './vignetteMask.js';
+export { DitherVignette, ditherVignette, type DitherVignetteOptions } from './DitherVignette.js';
+export { nineSlice, frameSvg, FRAME_CORNERS, FRAME_TWINS, type NineSliceSpec, type NineSlice, type SliceInsets } from './nineSlice.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/pixel/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pixel/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EACL,SAAS,EACT,WAAW,EACX,KAAK,EACL,IAAI,EACJ,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,SAAS,EACT,KAAK,EACL,KAAK,EACL,UAAU,EACV,UAAU,EACV,SAAS,EACT,OAAO,EACP,KAAK,KAAK,GACX,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,CAAC,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAClF,OAAO,EACL,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,SAAS,EACT,gBAAgB,EAChB,SAAS,EACT,eAAe,EACf,KAAK,QAAQ,EACb,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,IAAI,GACV,MAAM,QAAQ,CAAC;AAChB,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,aAAa,EAAE,aAAa,EAAE,KAAK,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjH,OAAO,EAAE,UAAU,EAAE,KAAK,QAAQ,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjF,4FAA4F;AAC5F,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,wEAAwE;AACxE,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEzF,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AACjG,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC;AAClG,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,cAAc,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAClH,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,KAAK,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,IAAI,IAAI,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC5L,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,KAAK,eAAe,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,KAAK,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAC9F,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,KAAK,aAAa,EAAE,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC"}