1681-engine 0.0.0-stage → 0.5.8

package/dist/transitions/DitherWipeTransition.js

@@ -0,0 +1,70 @@
+import { Container as b, TilingSprite as y, Texture as z, CanvasSource as C } from "pixi.js";
+import { DITHER_LEVELS as g, wipeLevel as M, ditherCovered as R } from "./ditherMask.js";
+import { tweenDone as S } from "./tweenDone.js";
+let d = null;
+function f() {
+  if (d) return d;
+  d = [];
+  for (let u = 0; u <= g; u++) {
+    const t = document.createElement("canvas");
+    t.width = 4, t.height = 4;
+    const n = t.getContext("2d");
+    n.fillStyle = "#ffffff";
+    for (let o = 0; o < 4; o++) for (let e = 0; e < 4; e++) R(u, e, o) && n.fillRect(e, o, 1, 1);
+    d.push(new z({ source: new C({ resource: t, scaleMode: "nearest" }) }));
+  }
+  return d;
+}
+class L {
+  constructor(t = {}) {
+    this.options = t;
+  }
+  options;
+  bands = [];
+  root = null;
+  stopResize = null;
+  state = { p: 0 };
+  reversed = !1;
+  async cover(t) {
+    this.root = new b(), t.layer.addChild(this.root), this.layout(t), this.stopResize = t.stage.onResize(() => this.layout(t)), this.state.p = 0, this.reversed = !1, await this.run(t, 1);
+  }
+  async reveal(t) {
+    this.root && (this.reversed = !0, await this.run(t, 0));
+  }
+  dispose() {
+    this.stopResize?.(), this.stopResize = null, this.root?.destroy({ children: !0 }), this.root = null, this.bands.length = 0;
+  }
+  run(t, n) {
+    return S(t.stage, {
+      targets: this.state,
+      p: n,
+      duration: this.options.duration ?? 450,
+      ease: "Linear",
+      onUpdate: () => this.paint()
+    });
+  }
+  layout(t) {
+    const n = this.root;
+    for (const h of n.removeChildren()) h.destroy();
+    this.bands.length = 0;
+    const o = Math.max(1, Math.round(this.options.cell ?? t.stage.cameras.main.zoom)), e = o * 4, r = t.stage.width, i = t.stage.height, s = this.options.direction ?? "right", a = s === "left" || s === "right", p = s === "none" ? 0 : a ? r : i, c = s === "none" ? 0 : Math.max(e, Math.ceil(p / 32 / e) * e), v = s === "none" ? 1 : Math.ceil(p / c);
+    for (let h = 0; h < v; h++) {
+      const m = s === "none" || !a ? r : c, w = s === "none" || a ? i : c, l = new y({ texture: f()[0], width: m, height: w });
+      l.tileScale.set(o, o), s !== "none" && (a ? l.x = h * c : l.y = h * c), l.tint = this.options.color ?? 0, n.addChild(l), this.bands.push(l);
+    }
+    this.paint();
+  }
+  paint() {
+    const t = this.options.direction ?? "right", n = t === "none" ? 1 : this.options.softness ?? 0.35, o = f(), e = this.bands.length;
+    for (let r = 0; r < e; r++) {
+      let i = t === "none" ? 0.5 : (r + 0.5) / e;
+      (t === "left" || t === "up") && (i = 1 - i), this.reversed && (i = 1 - i);
+      const s = t === "none" ? Math.round(this.state.p * g) : M(this.state.p, i, n), a = this.bands[r];
+      a.visible = s > 0, a.texture = o[s];
+    }
+  }
+}
+export {
+  L as DitherWipeTransition
+};
+//# sourceMappingURL=DitherWipeTransition.js.map

package/dist/transitions/DitherWipeTransition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DitherWipeTransition.js","sources":["../../src/transitions/DitherWipeTransition.ts"],"sourcesContent":["import { CanvasSource, Container, Texture, TilingSprite } from 'pixi.js';\nimport type { Transition, TransitionContext } from './Transition';\nimport { DITHER_LEVELS, ditherCovered, wipeLevel } from './ditherMask';\nimport { tweenDone } from './tweenDone';\n\nexport interface DitherWipeOptions {\n  /** `0xrrggbb` (default black). */\n  color?: number;\n  /** Ms for each half (default 450). */\n  duration?: number;\n  /** The way the wipe travels, or 'none' for the whole screen dissolving at once (default 'right'). */\n  direction?: 'left' | 'right' | 'up' | 'down' | 'none';\n  /** Screen pixels per dither cell (default the main camera's zoom, so a cell is one world pixel). */\n  cell?: number;\n  /** Share of the screen the dithered edge spans (default 0.35). */\n  softness?: number;\n}\n\n/** One 4×4 tile per dither level, white on clear, shared by every wipe (17 tiny textures for the page's life). */\nlet patterns: Texture[] | null = null;\n\nfunction patternTextures(): Texture[] {\n  if (patterns) return patterns;\n  patterns = [];\n  for (let level = 0; level <= DITHER_LEVELS; level++) {\n    const canvas = document.createElement('canvas');\n    canvas.width = 4;\n    canvas.height = 4;\n    const g = canvas.getContext('2d')!;\n    g.fillStyle = '#ffffff';\n    for (let y = 0; y < 4; y++) for (let x = 0; x < 4; x++) if (ditherCovered(level, x, y)) g.fillRect(x, y, 1, 1);\n    patterns.push(new Texture({ source: new CanvasSource({ resource: canvas, scaleMode: 'nearest' }) }));\n  }\n  return patterns;\n}\n\n/**\n * A pixel-friendly wipe: the screen fills with an ordered-dither pattern whose density sweeps across it, in hard\n * whole cells rather than a smooth gradient. The screen is cut into bands along the direction of travel, each a\n * tiling sprite of one dither level, so a frame costs a texture swap per band rather than a rect per cell (a\n * 1080p screen at 2-px cells is half a million cells). Bands are whole tiles wide so the pattern runs on unbroken.\n */\nexport class DitherWipeTransition implements Transition {\n  private readonly bands: TilingSprite[] = [];\n  private root: Container | null = null;\n  private stopResize: (() => void) | null = null;\n  private readonly state = { p: 0 };\n  private reversed = false;\n\n  constructor(private readonly options: DitherWipeOptions = {}) {}\n\n  async cover(ctx: TransitionContext): Promise<void> {\n    this.root = new Container();\n    ctx.layer.addChild(this.root);\n    this.layout(ctx);\n    this.stopResize = ctx.stage.onResize(() => this.layout(ctx));\n    this.state.p = 0;\n    this.reversed = false;\n    await this.run(ctx, 1);\n  }\n\n  async reveal(ctx: TransitionContext): Promise<void> {\n    if (!this.root) return;\n    // the covered part retreats the way the wipe came in, so the sweep reads as one motion across the swap\n    this.reversed = true;\n    await this.run(ctx, 0);\n  }\n\n  dispose(): void {\n    this.stopResize?.();\n    this.stopResize = null;\n    this.root?.destroy({ children: true });\n    this.root = null;\n    this.bands.length = 0;\n  }\n\n  private run(ctx: TransitionContext, to: number): Promise<void> {\n    return tweenDone(ctx.stage, {\n      targets: this.state,\n      p: to,\n      duration: this.options.duration ?? 450,\n      ease: 'Linear',\n      onUpdate: () => this.paint(),\n    });\n  }\n\n  private layout(ctx: TransitionContext): void {\n    const root = this.root!;\n    for (const b of root.removeChildren()) b.destroy();\n    this.bands.length = 0;\n    const cell = Math.max(1, Math.round(this.options.cell ?? ctx.stage.cameras.main.zoom));\n    const tile = cell * 4;\n    const w = ctx.stage.width;\n    const h = ctx.stage.height;\n    const dir = this.options.direction ?? 'right';\n    const horizontal = dir === 'left' || dir === 'right';\n    const span = dir === 'none' ? 0 : horizontal ? w : h;\n    // about 32 bands across, each a whole number of tiles\n    const bandSize = dir === 'none' ? 0 : Math.max(tile, Math.ceil(span / 32 / tile) * tile);\n    const count = dir === 'none' ? 1 : Math.ceil(span / bandSize);\n    for (let i = 0; i < count; i++) {\n      const bw = dir === 'none' || !horizontal ? w : bandSize;\n      const bh = dir === 'none' || horizontal ? h : bandSize;\n      const s = new TilingSprite({ texture: patternTextures()[0]!, width: bw, height: bh });\n      s.tileScale.set(cell, cell);\n      if (dir !== 'none') {\n        if (horizontal) s.x = i * bandSize;\n        else s.y = i * bandSize;\n      }\n      s.tint = this.options.color ?? 0x000000;\n      root.addChild(s);\n      this.bands.push(s);\n    }\n    this.paint();\n  }\n\n  private paint(): void {\n    const dir = this.options.direction ?? 'right';\n    const soft = dir === 'none' ? 1 : (this.options.softness ?? 0.35);\n    const textures = patternTextures();\n    const n = this.bands.length;\n    for (let i = 0; i < n; i++) {\n      let u = dir === 'none' ? 0.5 : (i + 0.5) / n;\n      if (dir === 'left' || dir === 'up') u = 1 - u;\n      if (this.reversed) u = 1 - u;\n      const level = dir === 'none' ? Math.round(this.state.p * DITHER_LEVELS) : wipeLevel(this.state.p, u, soft);\n      const band = this.bands[i]!;\n      band.visible = level > 0;\n      band.texture = textures[level]!;\n    }\n  }\n}\n"],"names":["patterns","patternTextures","level","DITHER_LEVELS","canvas","g","y","x","ditherCovered","Texture","CanvasSource","DitherWipeTransition","options","ctx","Container","to","tweenDone","root","b","cell","tile","w","h","dir","horizontal","span","bandSize","count","i","bw","bh","s","TilingSprite","soft","textures","n","u","wipeLevel","band"],"mappings":"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"}

package/dist/transitions/FadeTransition.js

@@ -0,0 +1,34 @@
+import { Sprite as o, Texture as a } from "pixi.js";
+import { tweenDone as i } from "./tweenDone.js";
+class l {
+  constructor(t = {}) {
+    this.options = t;
+  }
+  options;
+  sheet = null;
+  stopResize = null;
+  async cover(t) {
+    const e = new o(a.WHITE);
+    e.tint = this.options.color ?? 0, e.alpha = 0, this.sheet = e, t.layer.addChild(e);
+    const s = () => {
+      e.width = t.stage.width, e.height = t.stage.height;
+    };
+    s(), this.stopResize = t.stage.onResize(s), await i(t.stage, { targets: e, alpha: 1, duration: this.options.duration ?? 300, ease: "Sine.InOut" });
+  }
+  async reveal(t) {
+    this.sheet && await i(t.stage, {
+      targets: this.sheet,
+      alpha: 0,
+      delay: this.options.hold ?? 0,
+      duration: this.options.duration ?? 300,
+      ease: "Sine.InOut"
+    });
+  }
+  dispose() {
+    this.stopResize?.(), this.stopResize = null, this.sheet?.destroy(), this.sheet = null;
+  }
+}
+export {
+  l as FadeTransition
+};
+//# sourceMappingURL=FadeTransition.js.map

package/dist/transitions/FadeTransition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FadeTransition.js","sources":["../../src/transitions/FadeTransition.ts"],"sourcesContent":["import { Sprite, Texture } from 'pixi.js';\nimport type { Transition, TransitionContext } from './Transition';\nimport { tweenDone } from './tweenDone';\n\nexport interface FadeOptions {\n  /** `0xrrggbb` (default black). */\n  color?: number;\n  /** Ms for each half (default 300). */\n  duration?: number;\n  /** Ms to rest fully covered before revealing (default 0). */\n  hold?: number;\n}\n\n/** Fades to a colour, swaps the scene, fades back. */\nexport class FadeTransition implements Transition {\n  private sheet: Sprite | null = null;\n  private stopResize: (() => void) | null = null;\n\n  constructor(private readonly options: FadeOptions = {}) {}\n\n  async cover(ctx: TransitionContext): Promise<void> {\n    const sheet = new Sprite(Texture.WHITE);\n    sheet.tint = this.options.color ?? 0x000000;\n    sheet.alpha = 0;\n    this.sheet = sheet;\n    ctx.layer.addChild(sheet);\n    const fit = () => {\n      sheet.width = ctx.stage.width;\n      sheet.height = ctx.stage.height;\n    };\n    fit();\n    this.stopResize = ctx.stage.onResize(fit);\n    await tweenDone(ctx.stage, { targets: sheet, alpha: 1, duration: this.options.duration ?? 300, ease: 'Sine.InOut' });\n  }\n\n  async reveal(ctx: TransitionContext): Promise<void> {\n    if (!this.sheet) return;\n    await tweenDone(ctx.stage, {\n      targets: this.sheet,\n      alpha: 0,\n      delay: this.options.hold ?? 0,\n      duration: this.options.duration ?? 300,\n      ease: 'Sine.InOut',\n    });\n  }\n\n  dispose(): void {\n    this.stopResize?.();\n    this.stopResize = null;\n    this.sheet?.destroy();\n    this.sheet = null;\n  }\n}\n"],"names":["FadeTransition","options","ctx","sheet","Sprite","Texture","fit","tweenDone"],"mappings":";;AAcO,MAAMA,EAAqC;AAAA,EAIhD,YAA6BC,IAAuB,IAAI;AAA3B,SAAA,UAAAA;AAAA,EAA4B;AAAA,EAA5B;AAAA,EAHrB,QAAuB;AAAA,EACvB,aAAkC;AAAA,EAI1C,MAAM,MAAMC,GAAuC;AACjD,UAAMC,IAAQ,IAAIC,EAAOC,EAAQ,KAAK;AACtC,IAAAF,EAAM,OAAO,KAAK,QAAQ,SAAS,GACnCA,EAAM,QAAQ,GACd,KAAK,QAAQA,GACbD,EAAI,MAAM,SAASC,CAAK;AACxB,UAAMG,IAAM,MAAM;AAChB,MAAAH,EAAM,QAAQD,EAAI,MAAM,OACxBC,EAAM,SAASD,EAAI,MAAM;AAAA,IAC3B;AACA,IAAAI,EAAA,GACA,KAAK,aAAaJ,EAAI,MAAM,SAASI,CAAG,GACxC,MAAMC,EAAUL,EAAI,OAAO,EAAE,SAASC,GAAO,OAAO,GAAG,UAAU,KAAK,QAAQ,YAAY,KAAK,MAAM,cAAc;AAAA,EACrH;AAAA,EAEA,MAAM,OAAOD,GAAuC;AAClD,IAAK,KAAK,SACV,MAAMK,EAAUL,EAAI,OAAO;AAAA,MACzB,SAAS,KAAK;AAAA,MACd,OAAO;AAAA,MACP,OAAO,KAAK,QAAQ,QAAQ;AAAA,MAC5B,UAAU,KAAK,QAAQ,YAAY;AAAA,MACnC,MAAM;AAAA,IAAA,CACP;AAAA,EACH;AAAA,EAEA,UAAgB;AACd,SAAK,aAAA,GACL,KAAK,aAAa,MAClB,KAAK,OAAO,QAAA,GACZ,KAAK,QAAQ;AAAA,EACf;AACF;"}

package/dist/transitions/Letterbox.js

@@ -0,0 +1,42 @@
+import { Container as h, Sprite as i, Texture as o } from "pixi.js";
+import { tweenDone as r } from "./tweenDone.js";
+class l {
+  constructor(t, s = {}) {
+    this.stage = t, this.options = s;
+    for (const e of [this.top, this.bottom]) e.tint = s.color ?? 0;
+    this.view.addChild(this.top, this.bottom), this.view.visible = !1, t.screen.addChild(this.view), this.stopResize = t.onResize(() => this.layout()), this.layout();
+  }
+  stage;
+  options;
+  view = new h();
+  top = new i(o.WHITE);
+  bottom = new i(o.WHITE);
+  /** 0 hidden, 1 fully in. */
+  state = { k: 0 };
+  stopResize;
+  /** Whether the bars are (partly) in. */
+  get shown() {
+    return this.state.k > 0;
+  }
+  /** Slides the bars in over `ms` (0: at once). */
+  show(t = 400) {
+    return this.to(1, t);
+  }
+  hide(t = 400) {
+    return this.to(0, t);
+  }
+  destroy() {
+    this.stage.tweens.killTweensOf(this.state), this.stopResize(), this.view.destroy({ children: !0 });
+  }
+  to(t, s) {
+    return this.stage.tweens.killTweensOf(this.state), s <= 0 ? (this.state.k = t, this.layout(), Promise.resolve()) : r(this.stage, { targets: this.state, k: t, duration: s, ease: "Sine.InOut", onUpdate: () => this.layout() });
+  }
+  layout() {
+    const t = this.stage.width, s = this.stage.height, e = Math.round(s * (this.options.share ?? 0.12) * this.state.k);
+    this.view.visible = e > 0, this.top.width = t, this.top.height = e, this.bottom.width = t, this.bottom.height = e, this.bottom.y = s - e;
+  }
+}
+export {
+  l as Letterbox
+};
+//# sourceMappingURL=Letterbox.js.map

package/dist/transitions/Letterbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Letterbox.js","sources":["../../src/transitions/Letterbox.ts"],"sourcesContent":["import { Container, Sprite, Texture } from 'pixi.js';\nimport type { Stage } from '../core/Stage';\nimport { tweenDone } from './tweenDone';\n\nexport interface LetterboxOptions {\n  /** Each bar's height as a share of the screen's (default 0.12). */\n  share?: number;\n  /** `0xrrggbb` (default black). */\n  color?: number;\n}\n\n/**\n * Cinema bars for a cut scene: two bars slide in from the top and bottom of the screen and back out. They live on\n * the stage's screen layer, above what was there when they were made; a HUD added later draws over them, so hide it\n * for the scene. Bar heights are whole screen pixels at every step of the slide.\n */\nexport class Letterbox {\n  readonly view = new Container();\n  private readonly top = new Sprite(Texture.WHITE);\n  private readonly bottom = new Sprite(Texture.WHITE);\n  /** 0 hidden, 1 fully in. */\n  private readonly state = { k: 0 };\n  private readonly stopResize: () => void;\n\n  constructor(\n    private readonly stage: Stage,\n    private readonly options: LetterboxOptions = {},\n  ) {\n    for (const bar of [this.top, this.bottom]) bar.tint = options.color ?? 0x000000;\n    this.view.addChild(this.top, this.bottom);\n    this.view.visible = false;\n    stage.screen.addChild(this.view);\n    this.stopResize = stage.onResize(() => this.layout());\n    this.layout();\n  }\n\n  /** Whether the bars are (partly) in. */\n  get shown(): boolean {\n    return this.state.k > 0;\n  }\n\n  /** Slides the bars in over `ms` (0: at once). */\n  show(ms = 400): Promise<void> {\n    return this.to(1, ms);\n  }\n\n  hide(ms = 400): Promise<void> {\n    return this.to(0, ms);\n  }\n\n  destroy(): void {\n    this.stage.tweens.killTweensOf(this.state);\n    this.stopResize();\n    this.view.destroy({ children: true });\n  }\n\n  private to(k: number, ms: number): Promise<void> {\n    this.stage.tweens.killTweensOf(this.state);\n    if (ms <= 0) {\n      this.state.k = k;\n      this.layout();\n      return Promise.resolve();\n    }\n    return tweenDone(this.stage, { targets: this.state, k, duration: ms, ease: 'Sine.InOut', onUpdate: () => this.layout() });\n  }\n\n  private layout(): void {\n    const w = this.stage.width;\n    const h = this.stage.height;\n    const bar = Math.round(h * (this.options.share ?? 0.12) * this.state.k);\n    this.view.visible = bar > 0;\n    this.top.width = w;\n    this.top.height = bar;\n    this.bottom.width = w;\n    this.bottom.height = bar;\n    this.bottom.y = h - bar;\n  }\n}\n"],"names":["Letterbox","stage","options","bar","Container","Sprite","Texture","ms","k","tweenDone","w","h"],"mappings":";;AAgBO,MAAMA,EAAU;AAAA,EAQrB,YACmBC,GACAC,IAA4B,IAC7C;AAFiB,SAAA,QAAAD,GACA,KAAA,UAAAC;AAEjB,eAAWC,KAAO,CAAC,KAAK,KAAK,KAAK,MAAM,EAAG,CAAAA,EAAI,OAAOD,EAAQ,SAAS;AACvE,SAAK,KAAK,SAAS,KAAK,KAAK,KAAK,MAAM,GACxC,KAAK,KAAK,UAAU,IACpBD,EAAM,OAAO,SAAS,KAAK,IAAI,GAC/B,KAAK,aAAaA,EAAM,SAAS,MAAM,KAAK,QAAQ,GACpD,KAAK,OAAA;AAAA,EACP;AAAA,EATmB;AAAA,EACA;AAAA,EATV,OAAO,IAAIG,EAAA;AAAA,EACH,MAAM,IAAIC,EAAOC,EAAQ,KAAK;AAAA,EAC9B,SAAS,IAAID,EAAOC,EAAQ,KAAK;AAAA;AAAA,EAEjC,QAAQ,EAAE,GAAG,EAAA;AAAA,EACb;AAAA;AAAA,EAejB,IAAI,QAAiB;AACnB,WAAO,KAAK,MAAM,IAAI;AAAA,EACxB;AAAA;AAAA,EAGA,KAAKC,IAAK,KAAoB;AAC5B,WAAO,KAAK,GAAG,GAAGA,CAAE;AAAA,EACtB;AAAA,EAEA,KAAKA,IAAK,KAAoB;AAC5B,WAAO,KAAK,GAAG,GAAGA,CAAE;AAAA,EACtB;AAAA,EAEA,UAAgB;AACd,SAAK,MAAM,OAAO,aAAa,KAAK,KAAK,GACzC,KAAK,WAAA,GACL,KAAK,KAAK,QAAQ,EAAE,UAAU,IAAM;AAAA,EACtC;AAAA,EAEQ,GAAGC,GAAWD,GAA2B;AAE/C,WADA,KAAK,MAAM,OAAO,aAAa,KAAK,KAAK,GACrCA,KAAM,KACR,KAAK,MAAM,IAAIC,GACf,KAAK,OAAA,GACE,QAAQ,QAAA,KAEVC,EAAU,KAAK,OAAO,EAAE,SAAS,KAAK,OAAO,GAAAD,GAAG,UAAUD,GAAI,MAAM,cAAc,UAAU,MAAM,KAAK,OAAA,GAAU;AAAA,EAC1H;AAAA,EAEQ,SAAe;AACrB,UAAMG,IAAI,KAAK,MAAM,OACfC,IAAI,KAAK,MAAM,QACfR,IAAM,KAAK,MAAMQ,KAAK,KAAK,QAAQ,SAAS,QAAQ,KAAK,MAAM,CAAC;AACtE,SAAK,KAAK,UAAUR,IAAM,GAC1B,KAAK,IAAI,QAAQO,GACjB,KAAK,IAAI,SAASP,GAClB,KAAK,OAAO,QAAQO,GACpB,KAAK,OAAO,SAASP,GACrB,KAAK,OAAO,IAAIQ,IAAIR;AAAA,EACtB;AACF;"}

package/dist/transitions/ditherMask.js

@@ -0,0 +1,15 @@
+const s = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5], f = 16;
+function a(t, n, o) {
+  return s[(o & 3) * 4 + (n & 3)] < t;
+}
+function i(t, n, o) {
+  const r = Math.max(1e-3, o), e = (t * (1 + r) - n) / r, c = e <= 0 ? 0 : e >= 1 ? 1 : e;
+  return Math.round(c * f);
+}
+export {
+  s as BAYER4,
+  f as DITHER_LEVELS,
+  a as ditherCovered,
+  i as wipeLevel
+};
+//# sourceMappingURL=ditherMask.js.map

package/dist/transitions/ditherMask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ditherMask.js","sources":["../../src/transitions/ditherMask.ts"],"sourcesContent":["/** The 4×4 ordered-dither (Bayer) matrix, thresholds 0–15 row by row. */\nexport const BAYER4: readonly number[] = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];\n\n/** Dither levels from empty (0) to solid (16): a level n covers the n cells of the 4×4 tile with the lowest thresholds. */\nexport const DITHER_LEVELS = 16;\n\n/** Whether cell (x, y) of a tiled 4×4 pattern is covered at `level` (0–16). */\nexport function ditherCovered(level: number, x: number, y: number): boolean {\n  return BAYER4[(y & 3) * 4 + (x & 3)]! < level;\n}\n\n/**\n * The dither level of one band of a wipe. `progress` 0–1 runs the wipe; `position` 0–1 is the band's centre along\n * the direction of travel; `softness` (0–1) is how much of the screen the dithered edge spans. At progress 0 every\n * band is empty, at 1 every band is solid, and in between the edge sweeps across with its gradient in dither steps.\n */\nexport function wipeLevel(progress: number, position: number, softness: number): number {\n  const soft = Math.max(1e-3, softness);\n  const front = progress * (1 + soft);\n  const local = (front - position) / soft;\n  const k = local <= 0 ? 0 : local >= 1 ? 1 : local;\n  return Math.round(k * DITHER_LEVELS);\n}\n"],"names":["BAYER4","DITHER_LEVELS","ditherCovered","level","x","y","wipeLevel","progress","position","softness","soft","local","k"],"mappings":"AACO,MAAMA,IAA4B,CAAC,GAAG,GAAG,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,IAAI,CAAC,GAGjFC,IAAgB;AAGtB,SAASC,EAAcC,GAAeC,GAAWC,GAAoB;AAC1E,SAAOL,GAAQK,IAAI,KAAK,KAAKD,IAAI,EAAE,IAAKD;AAC1C;AAOO,SAASG,EAAUC,GAAkBC,GAAkBC,GAA0B;AACtF,QAAMC,IAAO,KAAK,IAAI,MAAMD,CAAQ,GAE9BE,KADQJ,KAAY,IAAIG,KACPF,KAAYE,GAC7BE,IAAID,KAAS,IAAI,IAAIA,KAAS,IAAI,IAAIA;AAC5C,SAAO,KAAK,MAAMC,IAAIX,CAAa;AACrC;"}

package/dist/transitions/transitionTo.js

@@ -0,0 +1,28 @@
+import { Container as l } from "pixi.js";
+const c = /* @__PURE__ */ new WeakMap();
+function f(t, a, e, s = "replace") {
+  const o = (c.get(t) ?? Promise.resolve()).then(() => i(t, a, e, s)), p = o.catch(() => {
+  });
+  return c.set(t, p), p.then(() => {
+    c.get(t) === p && c.delete(t);
+  }), o;
+}
+async function i(t, a, e, s) {
+  const r = new l();
+  t.app.stage.addChild(r);
+  const o = { stage: t.stage, app: t.app, layer: r };
+  try {
+    if (await e.cover(o), s === "pop") await t.scenes.pop();
+    else {
+      if (!a) throw new Error(`transitionTo: '${s}' needs a scene`);
+      await (s === "push" ? t.scenes.push(a) : t.scenes.replace(a));
+    }
+    await e.reveal(o);
+  } finally {
+    e.dispose(), r.destroy({ children: !0 });
+  }
+}
+export {
+  f as transitionTo
+};
+//# sourceMappingURL=transitionTo.js.map

package/dist/transitions/transitionTo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transitionTo.js","sources":["../../src/transitions/transitionTo.ts"],"sourcesContent":["import { Container } from 'pixi.js';\nimport type { Engine } from '../engine/Engine';\nimport type { Scene } from '../engine/Scene';\nimport type { Transition, TransitionContext } from './Transition';\n\n/** How the scene stack changes under the transition. */\nexport type TransitionMode = 'replace' | 'push' | 'pop';\n\n/** Transitions running per engine, so a second one waits for the first instead of drawing over it. */\nconst running = new WeakMap<Engine, Promise<void>>();\n\n/**\n * Changes scene behind a transition: covers the screen, runs `engine.scenes.replace(next)` (or `push`, or `pop`, for\n * which `next` is ignored) — waiting out an async `onEnter` while covered — then reveals. Resolves when the reveal\n * ends. The overlay is removed and the transition disposed even when the scene change throws, which is re-thrown.\n *\n * ```ts\n * await transitionTo(engine, new Level2(), new FadeTransition({ duration: 250 }));\n * ```\n */\nexport function transitionTo(engine: Engine, next: Scene | null, transition: Transition, mode: TransitionMode = 'replace'): Promise<void> {\n  const before = running.get(engine) ?? Promise.resolve();\n  const job = before.then(() => run(engine, next, transition, mode));\n  const tail = job.catch(() => undefined);\n  running.set(engine, tail);\n  void tail.then(() => {\n    if (running.get(engine) === tail) running.delete(engine);\n  });\n  return job;\n}\n\nasync function run(engine: Engine, next: Scene | null, transition: Transition, mode: TransitionMode): Promise<void> {\n  const layer = new Container();\n  // over the screen layer, so it covers every scene's HUD too, including the HUD the next scene is about to add\n  engine.app.stage.addChild(layer);\n  const ctx: TransitionContext = { stage: engine.stage, app: engine.app, layer };\n  try {\n    await transition.cover(ctx);\n    if (mode === 'pop') await engine.scenes.pop();\n    else {\n      if (!next) throw new Error(`transitionTo: '${mode}' needs a scene`);\n      await (mode === 'push' ? engine.scenes.push(next) : engine.scenes.replace(next));\n    }\n    await transition.reveal(ctx);\n  } finally {\n    transition.dispose();\n    layer.destroy({ children: true });\n  }\n}\n"],"names":["running","transitionTo","engine","next","transition","mode","job","run","tail","layer","Container","ctx"],"mappings":";AASA,MAAMA,wBAAc,QAAA;AAWb,SAASC,EAAaC,GAAgBC,GAAoBC,GAAwBC,IAAuB,WAA0B;AAExI,QAAMC,KADSN,EAAQ,IAAIE,CAAM,KAAK,QAAQ,QAAA,GAC3B,KAAK,MAAMK,EAAIL,GAAQC,GAAMC,GAAYC,CAAI,CAAC,GAC3DG,IAAOF,EAAI,MAAM,MAAA;AAAA,GAAe;AACtC,SAAAN,EAAQ,IAAIE,GAAQM,CAAI,GACnBA,EAAK,KAAK,MAAM;AACnB,IAAIR,EAAQ,IAAIE,CAAM,MAAMM,KAAMR,EAAQ,OAAOE,CAAM;AAAA,EACzD,CAAC,GACMI;AACT;AAEA,eAAeC,EAAIL,GAAgBC,GAAoBC,GAAwBC,GAAqC;AAClH,QAAMI,IAAQ,IAAIC,EAAA;AAElB,EAAAR,EAAO,IAAI,MAAM,SAASO,CAAK;AAC/B,QAAME,IAAyB,EAAE,OAAOT,EAAO,OAAO,KAAKA,EAAO,KAAK,OAAAO,EAAA;AACvE,MAAI;AAEF,QADA,MAAML,EAAW,MAAMO,CAAG,GACtBN,MAAS,MAAO,OAAMH,EAAO,OAAO,IAAA;AAAA,SACnC;AACH,UAAI,CAACC,EAAM,OAAM,IAAI,MAAM,kBAAkBE,CAAI,iBAAiB;AAClE,aAAOA,MAAS,SAASH,EAAO,OAAO,KAAKC,CAAI,IAAID,EAAO,OAAO,QAAQC,CAAI;AAAA,IAChF;AACA,UAAMC,EAAW,OAAOO,CAAG;AAAA,EAC7B,UAAA;AACE,IAAAP,EAAW,QAAA,GACXK,EAAM,QAAQ,EAAE,UAAU,GAAA,CAAM;AAAA,EAClC;AACF;"}

package/dist/transitions/tweenDone.js

@@ -0,0 +1,15 @@
+function r(n, e) {
+  return new Promise((o) => {
+    const t = e.onComplete;
+    n.tweens.add({
+      ...e,
+      onComplete: () => {
+        t?.(), o();
+      }
+    });
+  });
+}
+export {
+  r as tweenDone
+};
+//# sourceMappingURL=tweenDone.js.map

package/dist/transitions/tweenDone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tweenDone.js","sources":["../../src/transitions/tweenDone.ts"],"sourcesContent":["import type { Stage } from '../core/Stage';\nimport type { TweenConfig } from '../core/Tweener';\n\n/** Runs a tween on the stage and resolves when it completes: the awaitable form transitions are built from. */\nexport function tweenDone(stage: Stage, config: TweenConfig): Promise<void> {\n  return new Promise((resolve) => {\n    const done = config.onComplete;\n    stage.tweens.add({\n      ...config,\n      onComplete: () => {\n        done?.();\n        resolve();\n      },\n    });\n  });\n}\n"],"names":["tweenDone","stage","config","resolve","done"],"mappings":"AAIO,SAASA,EAAUC,GAAcC,GAAoC;AAC1E,SAAO,IAAI,QAAQ,CAACC,MAAY;AAC9B,UAAMC,IAAOF,EAAO;AACpB,IAAAD,EAAM,OAAO,IAAI;AAAA,MACf,GAAGC;AAAA,MACH,YAAY,MAAM;AAChB,QAAAE,IAAA,GACAD,EAAA;AAAA,MACF;AAAA,IAAA,CACD;AAAA,EACH,CAAC;AACH;"}

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"}