1681-engine 0.0.0-stage → 0.5.8

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/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/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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';
+/** 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 } 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;AAE5C,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,MAAM,YAAY,CAAC;AAC3E,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"}

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

@@ -0,0 +1,34 @@
+export interface TransientLight {
+    x: number;
+    y: number;
+    /** Radius at its brightest, world px. */
+    r: number;
+    born: number;
+    /** When it is gone; a carried light's is pushed to `CARRIED_MAX_MS` and brought in by its `end()`. */
+    until: number;
+    /** A light riding a moving thing reads its place every frame. */
+    follow?: () => {
+        x: number;
+        y: number;
+    };
+    /** A flash shrinks as it goes out; a carried light keeps its size. */
+    fades: boolean;
+    /** The colour it lays on what it lights: a fireball's orange, a spell's violet, a blade's white. */
+    color: number;
+}
+/** A flash at (x, y) in `color`: `r` px at once, shrinking to nothing over `ms`. */
+export declare function flashLight(x: number, y: number, r: number, ms: number, color?: number, now?: number): void;
+/** A light that rides `at` until `end()` is called (a shot in flight), and never past `CARRIED_MAX_MS`. */
+export declare function carriedLight(at: () => {
+    x: number;
+    y: number;
+}, r: number, color?: number, now?: number): {
+    end: () => void;
+};
+/** The lights burning at `now`, each with its radius then; spent ones are dropped. None while combat lights are off. */
+export declare function liveLights(now: number): readonly TransientLight[];
+/** The radius `l` burns at `now`: a flash eases out from its full size, a carried light holds it. */
+export declare function lightRadius(l: TransientLight, now: number): number;
+/** A new map: nothing of the last one's fight is left burning. */
+export declare function clearLights(): void;
+//# sourceMappingURL=lights.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lights.d.ts","sourceRoot":"","sources":["../../../src/pixel/lights.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,yCAAyC;IACzC,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,sGAAsG;IACtG,KAAK,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,sEAAsE;IACtE,KAAK,EAAE,OAAO,CAAC;IACf,oGAAoG;IACpG,KAAK,EAAE,MAAM,CAAC;CACf;AASD,oFAAoF;AACpF,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,SAAQ,EAAE,GAAG,SAAoB,GAAG,IAAI,CAGpH;AAKD,2GAA2G;AAC3G,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,SAAQ,EAAE,GAAG,SAAoB,GAAG;IAAE,GAAG,EAAE,MAAM,IAAI,CAAA;CAAE,CAMvI;AAID,wHAAwH;AACxH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,cAAc,EAAE,CAoBjE;AAED,qGAAqG;AACrG,wBAAgB,WAAW,CAAC,CAAC,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAIlE;AAED,kEAAkE;AAClE,wBAAgB,WAAW,IAAI,IAAI,CAElC"}

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

@@ -0,0 +1,71 @@
+import { PixelGrid, type Color } from './pixel.js';
+/**
+ * Pixel-art 9-slice frames for a UI (windows, buttons, fields, wells), built from one drawn corner so the edge is
+ * whole pixels instead of CSS gradients and blurred shadows. The corner is ASCII, one letter a role; the other three
+ * corners are its mirrors, and on the far side (right and bottom) each role takes its **twin** — a raised frame's lit
+ * rim (H) becomes its dark rim (L), a sunk field's shadowed lip (D) its lit one (d) — so light comes from the up-left
+ * without drawing four corners. A hard shadow (the frame's own silhouette, shifted) can lie under it.
+ *
+ * ```ts
+ * const frame = nineSlice({ corner: FRAME_CORNERS.panel, palette: { K: '#0b1018', H: '#c9a869', L: '#4a3a24',
+ *   M: '#8b6e45', G: '#121820', S: '#3c434b', s: '#161b22', F: '#1d242e', R: '#ffe2a0' }, shadow: [2, 2] });
+ * frame.grid.toCanvas();              // a canvas for a Pixi NineSliceSprite, with frame.insets
+ * frameSvg(frame.grid, 2);            // or an SVG for a CSS border-image, sliced at insets × 2
+ * ```
+ */
+/** Ready corners in the roles the default twins know: K ink, H/L lit/dark rim, M/m rim, G/g gap, S/s bevel, F fill, D/d lip, R rivet. */
+export declare const FRAME_CORNERS: {
+    /** A window: ink, a two-step brass rim, a gap, a lit bevel, a rivet in the corner. */
+    readonly panel: readonly ["..KKKKKK", ".KHHHHHH", "KHHMMMMM", "KHMKGGGG", "KHMGRSSS", "KHMGSFFF", "KHMGSFFF", "KHMGSFFF"];
+    /** A raised button: a two-step bevel, notched. Give it shadow [0, 1]; pressed, offset [0, 1] with the bevel's colours swapped. */
+    readonly button: readonly [".KKKK", "KHHHH", "KHMMM", "KHMFF", "KHMFF"];
+    /** A small raised button. */
+    readonly smallButton: readonly [".KKK", "KHHH", "KHMM", "KHMF"];
+    /** A text field: a hole in the stone, its lip in shadow top-left (D, G) and lit bottom-right (d, g). */
+    readonly field: readonly [".KKKK", "KDDDD", "KDGGG", "KDGFF", "KDGFF"];
+    /** A sunk well (slots, bars' tracks). */
+    readonly well: readonly [".KK", "KDD", "KDF"];
+    /** A list row: a flat slab lit on the top and left. */
+    readonly row: readonly [".KK", "KSS", "KSF"];
+    /** A thin frame: one pixel of rim (toasts, a cast bar). */
+    readonly thin: readonly [".KK", "KHH", "KHF"];
+};
+/** The role each letter takes on the far side; a palette without the twin keeps the letter. */
+export declare const FRAME_TWINS: Readonly<Record<string, string>>;
+export interface NineSliceSpec {
+    /** The top-left corner, square, one letter a role; '.' is nothing. */
+    corner: readonly string[];
+    /** A colour per letter: a packed `Color` or a CSS hex (`#rgb`, `#rrggbb`, `#rrggbbaa` for see-through fills). */
+    palette: Readonly<Record<string, Color | string>>;
+    /** Near-side letter → far-side letter (default `FRAME_TWINS`). */
+    twins?: Readonly<Record<string, string>>;
+    /** The hard shadow's offset in art pixels (default none). */
+    shadow?: readonly [number, number];
+    /** The shadow's colour (default palette `Z`, else black at 55%). */
+    shadowColor?: Color | string;
+    /** Moves the frame inside its canvas (a pressed button sits one pixel lower where its shadow was). */
+    offset?: readonly [number, number];
+    /** Room right and below for the shadow or the offset (default: the shadow). */
+    pad?: readonly [number, number];
+    /** Rows painted over the frame, the frame's full size ('.' leaves it): a tick in a checkbox. */
+    overlay?: readonly string[];
+}
+/** How far in from each side the corners reach: the frame's slice lines, in art pixels. */
+export interface SliceInsets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface NineSlice {
+    grid: PixelGrid;
+    insets: SliceInsets;
+}
+/** Builds the frame: a `(2c + 1 + pad)` square-ish grid and its slice insets. */
+export declare function nineSlice(spec: NineSliceSpec): NineSlice;
+/**
+ * Any pixel grid as an SVG of `scale`-sized squares (`shape-rendering="crispEdges"`), runs of one colour on a row
+ * merged into one rect: what a CSS `border-image` takes, sliced at the insets × `scale`.
+ */
+export declare function frameSvg(grid: PixelGrid, scale?: number): string;
+//# sourceMappingURL=nineSlice.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nineSlice.d.ts","sourceRoot":"","sources":["../../../src/pixel/nineSlice.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,SAAS,EAAiB,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAEtE;;;;;;;;;;;;;GAaG;AAEH,yIAAyI;AACzI,eAAO,MAAM,aAAa;IACxB,sFAAsF;;IAEtF,kIAAkI;;IAElI,6BAA6B;;IAE7B,wGAAwG;;IAExG,yCAAyC;;IAEzC,uDAAuD;;IAEvD,2DAA2D;;CAEP,CAAC;AAEvD,+FAA+F;AAC/F,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAA8C,CAAC;AAExG,MAAM,WAAW,aAAa;IAC5B,sEAAsE;IACtE,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,iHAAiH;IACjH,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC;IAClD,kEAAkE;IAClE,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACzC,6DAA6D;IAC7D,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,oEAAoE;IACpE,WAAW,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAC7B,sGAAsG;IACtG,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,+EAA+E;IAC/E,GAAG,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,gGAAgG;IAChG,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B;AAED,2FAA2F;AAC3F,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,WAAW,CAAC;CACrB;AAoBD,iFAAiF;AACjF,wBAAgB,SAAS,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,CAuBxD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,SAAI,GAAG,MAAM,CAoB3D"}

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

@@ -0,0 +1,35 @@
+import type { Graphics } from '../core/Graphics.js';
+import type { Stage } from '../core/Stage.js';
+import { type PixelLayer } from './PixelLayer.js';
+import type { Point } from './pixelPaint.js';
+export interface PaintLayerOptions {
+    /** Where the layer stands (world px), read every frame: a caster, a projectile, a fixed point. */
+    at: () => Point;
+    /** How long it plays (ms); its last `fadeMs` dither away instead of popping out. */
+    duration: number;
+    /** Paints one frame `ms` into the effect, in pixels relative to the anchor. */
+    paint: (g: Graphics, ms: number) => void;
+    /**
+     * Its draw order from the anchor's y (`y => y + 45` puts it in front of a body standing there, a negative offset
+     * behind it), or a fixed number (an effect lying on the ground under every body). Default `y + 45`.
+     */
+    depth?: number | ((y: number) => number);
+    /** Returning false removes the layer early (its caster gone, its trap sprung). */
+    alive?: () => boolean;
+    /** Frames a second it is redrawn at (default 12: hand-animated, like the sprites). */
+    fps?: number;
+    /** Paint only every that many frames (an effect thinned out for performance). Default 1. */
+    every?: number;
+    /** The longest fade at the end (ms); it is never more than 30% of the effect. Default 260. */
+    fadeMs?: number;
+    /** Told of the layer as it is made (a game that clears its transient effects on a map change keeps it). */
+    onCreate?: (g: PixelLayer) => void;
+}
+/**
+ * One effect as its own `PixelLayer`, redrawn at `fps` and shown as a single texture: it follows its anchor to the
+ * screen pixel while the art inside stays on the world grid, thins out pixel by pixel over its last frames (ordered
+ * dither, `setCoverage`), is neither painted nor uploaded while its anchor is off the screen by more than it has
+ * reached, and is destroyed when it ends, when `alive` says so, or with the stage's tweens.
+ */
+export declare function paintLayer(stage: Stage, o: PaintLayerOptions): PixelLayer;
+//# sourceMappingURL=paintLayer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paintLayer.d.ts","sourceRoot":"","sources":["../../../src/pixel/paintLayer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAC9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAG1C,MAAM,WAAW,iBAAiB;IAChC,kGAAkG;IAClG,EAAE,EAAE,MAAM,KAAK,CAAC;IAChB,oFAAoF;IACpF,QAAQ,EAAE,MAAM,CAAC;IACjB,+EAA+E;IAC/E,KAAK,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IACzC,kFAAkF;IAClF,KAAK,CAAC,EAAE,MAAM,OAAO,CAAC;IACtB,sFAAsF;IACtF,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,4FAA4F;IAC5F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8FAA8F;IAC9F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2GAA2G;IAC3G,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;CACpC;AAUD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,iBAAiB,GAAG,UAAU,CA0CzE"}

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

@@ -0,0 +1,58 @@
+/**
+ * The default palette (`PALETTE` from `1681-engine/pixel`): warm fantasy tones, readable on green ground. It is a
+ * starting point, not a rule: a game brings its own colours, and the helpers that use one of these (an outline, a
+ * shadow) take the colour as a parameter.
+ */
+export declare const P: {
+    readonly outline: number;
+    readonly outlineSoft: number;
+    readonly black: number;
+    readonly white: number;
+    readonly offWhite: number;
+    readonly skin: number;
+    readonly skinShade: number;
+    readonly skinTan: number;
+    readonly skinTanShade: number;
+    readonly blush: number;
+    readonly hairBlack: number;
+    readonly hairBrown: number;
+    readonly hairAuburn: number;
+    readonly hairWhite: number;
+    readonly hairGrey: number;
+    readonly red: number;
+    readonly redDark: number;
+    readonly crimson: number;
+    readonly orange: number;
+    readonly gold: number;
+    readonly goldDark: number;
+    readonly yellow: number;
+    readonly green: number;
+    readonly greenDark: number;
+    readonly jade: number;
+    readonly jadeDark: number;
+    readonly teal: number;
+    readonly sky: number;
+    readonly azure: number;
+    readonly blue: number;
+    readonly navy: number;
+    readonly indigo: number;
+    readonly purple: number;
+    readonly pink: number;
+    readonly brown: number;
+    readonly brownDark: number;
+    readonly brownLight: number;
+    readonly tan: number;
+    readonly cream: number;
+    readonly grey: number;
+    readonly greyDark: number;
+    readonly greyLight: number;
+    readonly steel: number;
+    readonly steelDark: number;
+    readonly iron: number;
+    readonly wood: number;
+    readonly woodDark: number;
+    readonly woodLight: number;
+    readonly straw: number;
+    readonly strawDark: number;
+};
+//# sourceMappingURL=palette.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"palette.d.ts","sourceRoot":"","sources":["../../../src/pixel/palette.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDJ,CAAC"}

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

@@ -0,0 +1,80 @@
+export type Color = number;
+export declare const CLEAR: Color;
+export declare function rgba(r: number, g: number, b: number, a?: number): Color;
+export declare function hex(s: string): Color;
+export declare function channels(c: Color): [number, number, number, number];
+/** f < 1 darkens, f > 1 lightens toward white. */
+export declare function shade(c: Color, f: number): Color;
+export declare function mix(c1: Color, c2: Color, t: number): Color;
+export declare function withAlpha(c: Color, alpha: number): Color;
+export declare function toCss(c: Color): string;
+export declare function hash2(x: number, y: number, seed?: number): number;
+export declare function mulberry32(seed: number): () => number;
+export declare function valueNoise(x: number, y: number, scale: number, seed: number): number;
+export declare class PixelGrid {
+    readonly w: number;
+    readonly h: number;
+    readonly data: Uint32Array;
+    constructor(w: number, h: number);
+    inBounds(x: number, y: number): boolean;
+    px(x: number, y: number, c: Color): void;
+    get(x: number, y: number): Color;
+    alphaAt(x: number, y: number): number;
+    rect(x: number, y: number, w: number, h: number, c: Color): void;
+    hline(x0: number, x1: number, y: number, c: Color): void;
+    vline(x: number, y0: number, y1: number, c: Color): void;
+    /** Filled ellipse; a pixel is inside when its center lies inside the ellipse. */
+    ellipse(cx: number, cy: number, rx: number, ry: number, c: Color): void;
+    circle(cx: number, cy: number, r: number, c: Color): void;
+    ring(cx: number, cy: number, r: number, thickness: number, c: Color): void;
+    line(x0: number, y0: number, x1: number, y1: number, c: Color, thickness?: number): void;
+    /** Filled polygon (even-odd scanline on pixel centers). */
+    poly(points: [number, number][], c: Color): void;
+    /**
+     * Adds `width` pixels of outline around all opaque pixels, one ring at a time — the same result as calling it
+     * `width` times, but each ring only visits the neighbours of the ring before it instead of the whole grid again.
+     * (A pixel next to ring `k` is always filled by ring `k+1`, so nothing further back can still be waiting.)
+     */
+    outline(c: Color, diagonal?: boolean, width?: number): void;
+    /** Replaces every pixel whose color matches `from`. */
+    recolor(from: Color, to: Color): void;
+    /** Multiplies brightness of opaque pixels matching `pred`. */
+    tint(f: number, pred: (x: number, y: number) => boolean): void;
+    blit(src: PixelGrid, dx: number, dy: number, flipX?: boolean): void;
+    /** Alpha-blends a color onto an existing pixel. */
+    blend(x: number, y: number, c: Color): void;
+    /** Reads a canvas back into a grid (a PNG layer of the paper doll joining the painted ones). */
+    static from(canvas: HTMLCanvasElement): PixelGrid;
+    /** The same picture on a grid `factor` times as fine, each pixel becoming a square block. */
+    upscaled(factor: number): PixelGrid;
+    /** Same size and same pixels. */
+    equals(other: PixelGrid): boolean;
+    /** Cheap hash of the pixels, for grouping identical frames before comparing them. */
+    key(): number;
+    clone(): PixelGrid;
+    toCanvas(): HTMLCanvasElement;
+}
+/**
+ * A grid that stands for one window of a larger picture: it is drawn on in the larger picture's coordinates and
+ * keeps only what falls inside `[x0, x0 + w) × [y0, y0 + h)`. A ground painter can paint a crop of a map into one, so the
+ * login screen does not paint the whole of two maps to show 17 tiles of each. Every drawing method goes through
+ * `px`/`get`/`inBounds`/`blend`; `outline`, `tint` and the whole-grid helpers work in window coordinates.
+ */
+export declare class PixelWindow extends PixelGrid {
+    readonly x0: number;
+    readonly y0: number;
+    constructor(x0: number, y0: number, w: number, h: number);
+    inBounds(x: number, y: number): boolean;
+    px(x: number, y: number, c: Color): void;
+    get(x: number, y: number): Color;
+    blend(x: number, y: number, c: Color): void;
+}
+/**
+ * Packs same-sized frames into rows no wider than `maxWidth`. A browser refuses a canvas past about 16k pixels
+ * on a side and hands back a blank one, and a player sheet of six hundred frames at twice the detail is wider
+ * than that, so it wraps. Readers work the row out from the canvas width.
+ */
+export declare function makeSheet(frames: PixelGrid[], maxWidth?: number): HTMLCanvasElement;
+/** Scales a canvas by an integer factor with nearest-neighbour filtering (for UI icons). */
+export declare function upscale(src: HTMLCanvasElement, factor: number): HTMLCanvasElement;
+//# sourceMappingURL=pixel.d.ts.map

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

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

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

@@ -0,0 +1,43 @@
+import type { Graphics } from '../core/Graphics.js';
+export type Point = {
+    x: number;
+    y: number;
+};
+export declare const WHITE = 16774358;
+export declare const snap: (n: number) => number;
+/** A `size`-px square (1 by default: one art pixel) on the world grid, graded into the world palette. */
+export declare function dot(g: Graphics, x: number, y: number, color: number, size?: number): void;
+/** A horizontal run of `w` px from (x, y), one pixel tall; drawn pixel by pixel while a dither fade or outline is on. */
+export declare function hline(g: Graphics, x: number, y: number, w: number, color: number): void;
+/** Paints `draw` with a dark 1px outline round everything it drew, like the outline on character and prop sprites. */
+export declare function outlined(g: Graphics, outline: number, draw: () => void): void;
+/**
+ * A line `width` px thick built from 1px rows: the row on one side is lit, the far row deep, and a long stroke tapers
+ * to the deep tone at both ends and catches a glint a third of the way along.
+ */
+export declare function stroke(g: Graphics, a: Point, b: Point, color: number, width?: number): void;
+/** A broken ellipse of radius `r` in the ground's 2:1 perspective, lit on the near side, turning with `phase`. */
+export declare function ring(g: Graphics, r: number, color: number, phase?: number, cy?: number): void;
+/** A faceted gem: light left face, base right face, deep lower tip and a glint on top once it is big enough. */
+export declare function diamond(g: Graphics, x: number, y: number, r: number, color: number): void;
+export declare function shards(g: Graphics, t: number, r: number, color: number, inward?: boolean): void;
+/** A filled stepped disc of radius `r` (smoke, gas, puddles), in the ground's 2:1 perspective when `flat`. */
+export declare function blob(g: Graphics, x: number, y: number, r: number, color: number, flat?: boolean): void;
+/** A droplet thrown from (x, y) with velocity (vx, vy) px/s under gravity, `ms` after it left; null once it lands. */
+export declare function drop(x: number, y: number, vx: number, vy: number, ms: number, ground?: number): Point | null;
+/** A pixel X, `r` from its centre to a tip. */
+export declare function xMark(g: Graphics, x: number, y: number, r: number, color: number): void;
+/** A dash streak from `a` to `b`: a dark body with a bright core, eaten away from the start as `t` goes 0 to 1. */
+export declare function dashStreak(g: Graphics, a: Point, b: Point, t: number, edge: number, core: number): void;
+/**
+ * A puff of smoke or gas: a small stepped disc whose rim is dithered (every other pixel) so it reads soft, with a
+ * lighter cap on its upper left. Solid discs the same size read as boulders or bushes.
+ */
+export declare function puffBlob(g: Graphics, x: number, y: number, r: number, body: number, light: number, frame?: number, opacity?: number): void;
+/** An arc of dots on an ellipse from angle `a0` to `a1` (flat: in the ground's 2:1 perspective), `thick` rows deep. */
+export declare function arc(g: Graphics, x: number, y: number, r: number, a0: number, a1: number, color: number, flat?: boolean, thick?: number): void;
+/** Pale stepped dust puffs kicked up around (x, y) and settling over `t` 0..1. */
+export declare function dust(g: Graphics, x: number, y: number, t: number, spread?: number, color?: number): void;
+/** Pixel chunks flung out of (x, y) under gravity (rock, splinters): `ms` after the blow. */
+export declare function debris(g: Graphics, x: number, y: number, count: number, speed: number, ms: number, colors: number[]): void;
+//# sourceMappingURL=pixelPaint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pixelPaint.d.ts","sourceRoot":"","sources":["../../../src/pixel/pixelPaint.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAUjD,MAAM,MAAM,KAAK,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC7C,eAAO,MAAM,KAAK,WAAW,CAAC;AAC9B,eAAO,MAAM,IAAI,GAAI,GAAG,MAAM,WAAkB,CAAC;AAEjD,yGAAyG;AACzG,wBAAgB,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,SAAI,GAAG,IAAI,CAepF;AAmCD,yHAAyH;AACzH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAcvF;AAED,sHAAsH;AACtH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI,CAO7E;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,IAAI,CAkBtF;AAED,kHAAkH;AAClH,wBAAgB,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,EAAE,EAAE,SAAI,GAAG,IAAI,CAiBnF;AAED,gHAAgH;AAChH,wBAAgB,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAiBzF;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,UAAQ,GAAG,IAAI,CAM7F;AAED,8GAA8G;AAC9G,wBAAgB,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,IAAI,CAYpG;AAED,sHAAsH;AACtH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,SAAQ,GAAG,KAAK,GAAG,IAAI,CAI3G;AAED,+CAA+C;AAC/C,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAGvF;AAED,mHAAmH;AACnH,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAIvG;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,EAAE,OAAO,SAAM,GAAG,IAAI,CAwClI;AAED,uHAAuH;AACvH,wBAAgB,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,UAAO,EAAE,KAAK,SAAI,GAAG,IAAI,CAiBrI;AAED,kFAAkF;AAClF,wBAAgB,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,SAAK,EAAE,KAAK,SAAW,GAAG,IAAI,CAMtG;AAED,6FAA6F;AAC7F,wBAAgB,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAgB1H"}

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

@@ -0,0 +1,51 @@
+import type { Graphics } from '../core/Graphics.js';
+import { PixelLayer } from './PixelLayer.js';
+export interface Ramp {
+    /** Darkest: under-shade and outline pixels. */
+    shade: number;
+    deep: number;
+    base: number;
+    light: number;
+    /** Near-white glint. */
+    hi: number;
+}
+/** Gives these colours ramps picked by hand (darkest `shade` … brightest `hi`); a colour registered again is replaced. */
+export declare function registerHandRamps(ramps: Iterable<readonly [number, Omit<Ramp, 'base'>]> | Record<number, Omit<Ramp, 'base'>>): void;
+export declare function ramp(color: number): Ramp;
+/** The formula's five tones for any colour: shadows cool and desaturate, highlights warm. */
+export declare function derivedRamp(color: number): Ramp;
+/**
+ * The colour a pixel is actually painted with: effects are authored in bright, saturated colours, and this pulls them
+ * into the world's palette (muted earth, grass and wood) — saturation down by a quarter, near-whites toned down and
+ * warmed, so an effect sits in the scene instead of glowing on top of it. Glints keep most of their lift.
+ */
+export declare function grade(color: number): number;
+export declare function capturing(): Map<number, number> | null;
+export declare function beginOutline(): void;
+export declare function endOutline(g: Graphics, outline: number): void;
+/**
+ * Lays pixels (keyed by `key`, each with its colour already graded) row by row, one rect for every run of one colour:
+ * the same pixels as one rect each, at a fraction of the rects (single-pixel rects ran to 5,000–9,000 a frame for one
+ * big ring or smoke, enough to be felt as lag).
+ */
+export declare function fillRuns(g: Graphics, pixels: Map<number, number>): void;
+export declare function beginBatch(g: Graphics): void;
+export declare function endBatch(): void;
+/**
+ * Where a solid pixel painted on `g` goes while its batch is open: the layer's staging, the batch's map, or nowhere
+ * (paint it now). `stagePixel` writes into whichever it is.
+ */
+export declare function batchFor(g: Graphics): Map<number, number> | PixelLayer | null;
+/** Writes a solid run of `w` pixels at (x, y) into what `batchFor` returned. */
+export declare function stageRun(held: Map<number, number> | PixelLayer, x: number, y: number, w: number, color: number): void;
+/** Lays what the batch holds now, so a translucent fill that follows lies over it. */
+export declare function flushBatch(): void;
+/** The key `capturing()` and `fillRuns` file a world pixel under. */
+export declare function pixelKey(x: number, y: number): number;
+export declare function record(x: number, y: number, color: number): void;
+export declare function setCoverage(value: number): void;
+/** The current dither fade (1 while nothing fades), for translucent fills that fade with their layer. */
+export declare function currentCoverage(): number;
+/** Whether the world pixel at (x, y) is dropped by the current dither fade. */
+export declare function dithered(x: number, y: number): boolean;
+//# sourceMappingURL=pixelTone.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pixelTone.d.ts","sourceRoot":"","sources":["../../../src/pixel/pixelTone.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAQ1C,MAAM,WAAW,IAAI;IACnB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,EAAE,EAAE,MAAM,CAAC;CACZ;AAgDD,0HAA0H;AAC1H,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAGnI;AAED,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAExC;AAED,6FAA6F;AAC7F,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAe/C;AAID;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ3C;AAUD,wBAAgB,SAAS,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAEtD;AAKD,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAiB7D;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAOvE;AAkBD,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,GAAG,IAAI,CAU5C;AAED,wBAAgB,QAAQ,IAAI,IAAI,CAM/B;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,QAAQ,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,UAAU,GAAG,IAAI,CAG7E;AAED,gFAAgF;AAChF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAMrH;AAED,sFAAsF;AACtF,wBAAgB,UAAU,IAAI,IAAI,CASjC;AA+BD,qEAAqE;AACrE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAEhE;AAOD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED,yGAAyG;AACzG,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED,+EAA+E;AAC/E,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAKtD"}