1681-engine 0.5.8 → 0.5.9

package/dist/ui/rich/richFonts.js

@@ -0,0 +1,105 @@
+import { BitmapFontManager as l, BitmapText as h, TextStyle as f, CanvasTextMetrics as c, Text as m } from "pixi.js";
+import { installLabelFont as u } from "../../core/BitmapLabel.js";
+function a(o) {
+  return `${o.color ?? ""}|${o.bold ? 1 : 0}|${o.italic ? 1 : 0}|${o.size ?? ""}`;
+}
+class x {
+  constructor(t) {
+    this.options = t;
+  }
+  options;
+  styles = /* @__PURE__ */ new Map();
+  metrics = /* @__PURE__ */ new Map();
+  textWidth(t, s) {
+    return c.measureText(t, this.pixiStyle(s), void 0, !1).width;
+  }
+  lineHeight(t) {
+    return this.metricsOf(t).lineHeight;
+  }
+  ascent(t) {
+    return this.metricsOf(t).ascent;
+  }
+  createRun() {
+    return new m({ text: "", style: this.pixiStyle({ bold: !1, italic: !1 }), resolution: this.options.resolution ?? 1 });
+  }
+  updateRun(t, s, i) {
+    const e = t, n = this.pixiStyle(i);
+    e.style !== n && (e.style = n), e.text !== s && (e.text = s);
+  }
+  metricsOf(t) {
+    const s = a(t);
+    let i = this.metrics.get(s);
+    if (!i) {
+      const e = c.measureText("M", this.pixiStyle(t), void 0, !1);
+      i = { lineHeight: e.lineHeight, ascent: e.fontProperties.ascent }, this.metrics.set(s, i);
+    }
+    return i;
+  }
+  pixiStyle(t) {
+    const s = a(t);
+    let i = this.styles.get(s);
+    if (!i) {
+      const e = this.options;
+      i = new f({
+        fontFamily: e.fontFamily,
+        fontSize: t.size ?? e.fontSize,
+        fill: t.color ?? e.color ?? "#ffffff",
+        fontWeight: t.bold ? "bold" : "normal",
+        fontStyle: t.italic ? "italic" : "normal",
+        ...e.stroke ? { stroke: { color: e.stroke, width: e.strokeWidth ?? 1, join: "round" } } : {}
+      }), this.styles.set(s, i);
+    }
+    return i;
+  }
+}
+class d {
+  constructor(t) {
+    this.options = t;
+  }
+  options;
+  styles = /* @__PURE__ */ new Map();
+  metrics = /* @__PURE__ */ new Map();
+  textWidth(t, s) {
+    const i = l.measureText(t, this.pixiStyle(s), !1);
+    return i.width * i.scale;
+  }
+  lineHeight(t) {
+    return this.metricsOf(t).lineHeight;
+  }
+  ascent(t) {
+    return this.metricsOf(t).ascent;
+  }
+  createRun() {
+    return new h({ text: "", style: this.pixiStyle({ bold: !1, italic: !1 }) });
+  }
+  updateRun(t, s, i) {
+    const e = t, n = this.pixiStyle(i);
+    e.style !== n && (e.style = n), e.text !== s && (e.text = s);
+  }
+  metricsOf(t) {
+    const s = this.fontKey(t);
+    let i = this.metrics.get(s);
+    if (!i) {
+      const e = this.pixiStyle(t), n = l.getFont("M", e), r = e.fontSize / n.baseMeasurementFontSize;
+      i = { lineHeight: n.lineHeight * r, ascent: n.fontMetrics.ascent * r }, this.metrics.set(s, i);
+    }
+    return i;
+  }
+  /** Bold and italic do not reach a bitmap font: styles differing only by them share one. */
+  fontKey(t) {
+    return `${t.color ?? ""}|${t.size ?? ""}`;
+  }
+  pixiStyle(t) {
+    const s = this.fontKey(t);
+    let i = this.styles.get(s);
+    if (!i) {
+      const e = this.options, n = t.size ?? e.fontSize, r = u(e.fontFamily, n, t.color ?? e.color ?? "#ffffff", e.stroke ?? "#000000", e.strokeWidth ?? 0, e.resolution ?? 1, e.glyphs ?? "");
+      i = new f({ fontFamily: r, fontSize: n }), this.styles.set(s, i);
+    }
+    return i;
+  }
+}
+export {
+  d as BitmapRichFont,
+  x as CanvasRichFont
+};

package/dist/ui/rich/richLayout.js

@@ -0,0 +1,132 @@
+function W(l, n, o = {}) {
+  const t = O(l, n, o), e = o.wrapWidth, i = [];
+  let s = [], h = 0, y = [], g = !1, x = l[0]?.style ?? { bold: !1, italic: !1 };
+  const w = () => {
+    i.push({ atoms: s, empty: x }), s = [], h = 0, y = [];
+  };
+  for (let c = 0; c < t.length; ) {
+    const f = t[c];
+    if (f.t === "br") {
+      x = f.style, w(), g = !1, c++;
+      continue;
+    }
+    if (f.t === "space") {
+      y.push(f), c++;
+      continue;
+    }
+    const r = [];
+    for (; c < t.length && (t[c].t === "word" || t[c].t === "icon"); ) r.push(t[c++]);
+    const d = b(r);
+    s.length === 0 && g && (y = []), e !== void 0 && s.length > 0 && h + b(y) + d > e + 1e-6 && (w(), g = !0);
+    for (const u of y) s.push(u);
+    if (h += b(y), y = [], e !== void 0 && h + d > e + 1e-6)
+      for (const u of r)
+        for (const p of L(u, n, e, () => h)) {
+          if (p === "break") {
+            w(), g = !0;
+            continue;
+          }
+          s.push(p), h += p.w;
+        }
+    else {
+      for (const u of r) s.push(u);
+      h += d;
+    }
+  }
+  return (s.length > 0 || i.length === 0 || t[t.length - 1]?.t === "br") && w(), N(i, n, o);
+}
+function O(l, n, o) {
+  const t = [];
+  for (const e of l) {
+    if (e.kind === "icon") {
+      const i = n.iconSize(e.key, e.frame), s = I(i.height, n.lineHeight(e.style), o), h = { t: "icon", key: e.key, style: e.style, w: i.width * s, h: i.height * s };
+      e.frame !== void 0 && (h.frame = e.frame), t.push(h);
+      continue;
+    }
+    for (const i of e.text.matchAll(/(\r?\n)|([ \t]+)|([^ \t\r\n]+)/g))
+      i[1] ? t.push({ t: "br", style: e.style }) : i[2] ? t.push({ t: "space", text: i[2], style: e.style, w: n.textWidth(i[2], e.style) }) : t.push({ t: "word", text: i[3], style: e.style, w: n.textWidth(i[3], e.style) });
+  }
+  return t;
+}
+function I(l, n, o) {
+  if (typeof o.iconScale == "number") return o.iconScale;
+  if (l <= 0) return 1;
+  const t = n / l;
+  return o.pixelPerfect ? Math.max(1, Math.floor(t)) : t;
+}
+function* L(l, n, o, t) {
+  if (l.t !== "word") {
+    t() > 0 && t() + l.w > o + 1e-6 && (yield "break"), yield l;
+    return;
+  }
+  const e = Array.from(l.text);
+  let i = 0;
+  for (; i < e.length; ) {
+    let s = i, h = 0;
+    for (; s < e.length; ) {
+      const y = n.textWidth(e.slice(i, s + 1).join(""), l.style);
+      if (t() + y > o + 1e-6 && !(s === i && t() === 0)) break;
+      h = y, s++;
+    }
+    if (s === i) {
+      yield "break";
+      continue;
+    }
+    yield { t: "word", text: e.slice(i, s).join(""), style: l.style, w: h }, i = s, i < e.length && (yield "break");
+  }
+}
+function N(l, n, o) {
+  const t = o.pixelPerfect ? Math.round : (c) => c, e = o.lineSpacing ?? 0, i = (c, f) => n.ascent?.(c) ?? f * 0.8, s = [];
+  let h = 0;
+  for (const c of l) {
+    for (; c.atoms.length > 0 && c.atoms[c.atoms.length - 1].t === "space"; ) c.atoms.pop();
+    const f = v(c.atoms, n);
+    let r = 0, d = 0;
+    const u = [];
+    if (f.length === 0) {
+      const a = n.lineHeight(c.empty);
+      r = -i(c.empty, a), d = r + a;
+    }
+    f.forEach((a, m) => {
+      const E = n.lineHeight(a.style), M = i(a.style, E), k = a.kind === "text" ? -M : -M + (E - a.height) / 2;
+      u[m] = k, (m === 0 || k < r) && (r = k), (m === 0 || k + a.height > d) && (d = k + a.height);
+    });
+    const p = t(-r), P = o.pixelPerfect ? Math.ceil(d - r) : d - r;
+    let S = 0;
+    f.forEach((a, m) => {
+      a.x = S, a.y = h + t(p + u[m]), S += a.width;
+    }), s.push({ y: h, width: S, height: P, baseline: p, items: f }), h += P + e;
+  }
+  const y = s.length === 0 ? 0 : h - e, g = s.reduce((c, f) => Math.max(c, f.width), 0), x = o.wrapWidth ?? g, w = o.align === "center" ? 0.5 : o.align === "right" ? 1 : 0;
+  for (const c of s) {
+    const f = (x - c.width) * w;
+    for (const r of c.items) r.x = t(r.x + f);
+  }
+  return { width: o.pixelPerfect ? Math.ceil(x) : x, height: y, lines: s };
+}
+function v(l, n) {
+  const o = [];
+  for (const t of l) {
+    if (t.t === "icon") {
+      const i = { kind: "icon", key: t.key, style: t.style, x: 0, y: 0, width: t.w, height: t.h };
+      t.frame !== void 0 && (i.frame = t.frame), o.push(i);
+      continue;
+    }
+    const e = o[o.length - 1];
+    e && e.kind === "text" && z(e.style, t.style) ? e.text += t.text : o.push({ kind: "text", text: t.text, style: t.style, x: 0, y: 0, width: 0, height: n.lineHeight(t.style) });
+  }
+  for (const t of o) t.kind === "text" && (t.width = n.textWidth(t.text, t.style));
+  return o;
+}
+function z(l, n) {
+  return l === n || l.color === n.color && l.bold === n.bold && l.italic === n.italic && l.size === n.size;
+}
+function b(l) {
+  let n = 0;
+  for (const o of l) n += o.w;
+  return n;
+}
+export {
+  W as layoutRichText,
+  z as sameStyle
+};

package/dist/ui/rich/richMarkup.js

@@ -0,0 +1,67 @@
+const f = Object.freeze({ bold: !1, italic: !1 }), d = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i, h = /^\d+(?:\.\d+)?$/;
+function m(s) {
+  return s.replace(/\[/g, "[[");
+}
+function x(s, c = {}) {
+  const n = [], r = [], u = () => r[r.length - 1]?.style ?? f, o = (l) => {
+    if (!l) return;
+    const i = u(), a = n[n.length - 1];
+    a && a.kind === "text" && a.style === i ? a.text += l : n.push({ kind: "text", text: l, style: i });
+  };
+  let e = 0, t = 0;
+  for (; e < s.length; ) {
+    if (s[e] !== "[") {
+      e++;
+      continue;
+    }
+    if (o(s.slice(t, e)), s[e + 1] === "[") {
+      o("["), e += 2, t = e;
+      continue;
+    }
+    const l = s.indexOf("]", e + 1), i = l < 0 ? null : s.slice(e + 1, l);
+    if (i === null || i.includes("[") || !y(i, r, u(), n, c)) {
+      o("["), e += 1, t = e;
+      continue;
+    }
+    e = l + 1, t = e;
+  }
+  return o(s.slice(t)), n;
+}
+function p(s, c = {}) {
+  let n = "";
+  for (const r of x(s, c)) r.kind === "text" && (n += r.text);
+  return n;
+}
+function y(s, c, n, r, u) {
+  if (s.startsWith("/")) {
+    const l = s.slice(1).trim().toLowerCase();
+    for (let i = c.length - 1; i >= 0; i--)
+      if (c[i].name === l)
+        return c.length = i, !0;
+    return !1;
+  }
+  const o = s.indexOf("="), e = (o < 0 ? s : s.slice(0, o)).trim().toLowerCase(), t = o < 0 ? null : s.slice(o + 1).trim();
+  switch (e) {
+    case "b":
+    case "i":
+      return t !== null ? !1 : (c.push({ name: e, style: { ...n, [e === "b" ? "bold" : "italic"]: !0 } }), !0);
+    case "color": {
+      const l = t === null ? void 0 : d.test(t) ? t : u.colors?.[t];
+      return l ? (c.push({ name: e, style: { ...n, color: l } }), !0) : !1;
+    }
+    case "size":
+      return t === null || !h.test(t) || Number(t) <= 0 ? !1 : (c.push({ name: e, style: { ...n, size: Number(t) } }), !0);
+    case "icon": {
+      if (!t) return !1;
+      const l = t.lastIndexOf(":"), i = l > 0 ? { kind: "icon", key: t.slice(0, l), frame: t.slice(l + 1), style: n } : { kind: "icon", key: t, style: n };
+      return r.push(i), !0;
+    }
+    default:
+      return !1;
+  }
+}
+export {
+  m as escapeRichText,
+  x as parseRichText,
+  p as stripRichText
+};

package/dist/ui.js

@@ -1,85 +1,95 @@
-import { clamp as e, insets as t, snapPx as p, snapRect as m } from "./ui/layout/geometry.js";
-import { stackLayout as i } from "./ui/layout/stack.js";
-import { anchorPosition as l } from "./ui/layout/anchor.js";
+import { clamp as e, insets as t, snapPx as p, snapRect as i } from "./ui/layout/geometry.js";
+import { stackLayout as m } from "./ui/layout/stack.js";
+import { anchorPosition as a } from "./ui/layout/anchor.js";
 import { fitToViewport as s } from "./ui/layout/fitToViewport.js";
-import { placeTooltip as c } from "./ui/layout/placeTooltip.js";
-import { wrapRow as u } from "./ui/layout/wrapRow.js";
-import { listWidth as F } from "./ui/layout/listWidth.js";
-import { FLING_STOP as h, clampScroll as w, maxScroll as D, scrollIntoView as T, stepFling as V } from "./ui/layout/scroll.js";
-import { quantize as P, sliderFraction as A, sliderValueAt as I } from "./ui/layout/slider.js";
-import { drainState as R, setDrainValue as U, stepDrain as W } from "./ui/layout/barDrain.js";
-import { firstFocus as k, linearFocus as y, nextFocus as z } from "./ui/layout/focusNav.js";
-import { UiRoot as E } from "./ui/UiRoot.js";
-import { uiHostOf as N } from "./ui/UiHost.js";
-import { UiPointerGate as q } from "./ui/UiPointerGate.js";
-import { DEFAULT_NAV as H, FocusManager as M } from "./ui/FocusManager.js";
-import { Widget as C, sizeOf as J } from "./ui/Widget.js";
+import { placeTooltip as n } from "./ui/layout/placeTooltip.js";
+import { wrapRow as h } from "./ui/layout/wrapRow.js";
+import { listWidth as S } from "./ui/layout/listWidth.js";
+import { FLING_STOP as F, clampScroll as R, maxScroll as g, scrollIntoView as w, stepFling as D } from "./ui/layout/scroll.js";
+import { quantize as L, sliderFraction as P, sliderValueAt as A } from "./ui/layout/slider.js";
+import { drainState as O, setDrainValue as y, stepDrain as B } from "./ui/layout/barDrain.js";
+import { firstFocus as W, linearFocus as b, nextFocus as k } from "./ui/layout/focusNav.js";
+import { UiRoot as z } from "./ui/UiRoot.js";
+import { uiHostOf as G } from "./ui/UiHost.js";
+import { UiPointerGate as _ } from "./ui/UiPointerGate.js";
+import { DEFAULT_NAV as C, FocusManager as H } from "./ui/FocusManager.js";
+import { Widget as j, sizeOf as J } from "./ui/Widget.js";
 import { Panel as Q } from "./ui/Panel.js";
 import { Label as Y } from "./ui/Label.js";
 import { Button as $ } from "./ui/Button.js";
 import { Bar as ro } from "./ui/Bar.js";
 import { Slider as to } from "./ui/Slider.js";
-import { Toggle as mo } from "./ui/Toggle.js";
-import { Stack as io } from "./ui/Stack.js";
-import { ScrollView as lo } from "./ui/ScrollView.js";
+import { Toggle as io } from "./ui/Toggle.js";
+import { Stack as mo } from "./ui/Stack.js";
+import { ScrollView as ao } from "./ui/ScrollView.js";
 import { List as so } from "./ui/List.js";
-import { Dialog as co } from "./ui/Dialog.js";
-import { DomOverlay as So } from "./ui/dom/DomOverlay.js";
-import { DomWorldAnchors as go } from "./ui/dom/DomWorldAnchors.js";
-import { onScreen as wo, worldToScreen as Do } from "./ui/dom/worldToScreen.js";
-import { createStore as Vo } from "./ui/dom/createStore.js";
-import { InputShield as Po } from "./ui/dom/InputShield.js";
-import { isEditable as Io, isInside as Oo, shouldShield as Ro } from "./ui/dom/shieldDecision.js";
+import { Dialog as no } from "./ui/Dialog.js";
+import { DomOverlay as uo } from "./ui/dom/DomOverlay.js";
+import { DomWorldAnchors as To } from "./ui/dom/DomWorldAnchors.js";
+import { onScreen as Ro, worldToScreen as go } from "./ui/dom/worldToScreen.js";
+import { createStore as Do } from "./ui/dom/createStore.js";
+import { InputShield as Lo } from "./ui/dom/InputShield.js";
+import { isEditable as Ao, isInside as Io, shouldShield as Oo } from "./ui/dom/shieldDecision.js";
+import { RichText as Bo } from "./ui/rich/RichText.js";
+import { BitmapRichFont as Wo, CanvasRichFont as bo } from "./ui/rich/richFonts.js";
+import { escapeRichText as vo, parseRichText as zo, stripRichText as Eo } from "./ui/rich/richMarkup.js";
+import { layoutRichText as No } from "./ui/rich/richLayout.js";
 export {
   ro as Bar,
+  Wo as BitmapRichFont,
   $ as Button,
-  H as DEFAULT_NAV,
-  co as Dialog,
-  So as DomOverlay,
-  go as DomWorldAnchors,
-  h as FLING_STOP,
-  M as FocusManager,
-  Po as InputShield,
+  bo as CanvasRichFont,
+  C as DEFAULT_NAV,
+  no as Dialog,
+  uo as DomOverlay,
+  To as DomWorldAnchors,
+  F as FLING_STOP,
+  H as FocusManager,
+  Lo as InputShield,
   Y as Label,
   so as List,
   Q as Panel,
-  lo as ScrollView,
+  Bo as RichText,
+  ao as ScrollView,
   to as Slider,
-  io as Stack,
-  mo as Toggle,
-  q as UiPointerGate,
-  E as UiRoot,
-  C as Widget,
-  l as anchorPosition,
+  mo as Stack,
+  io as Toggle,
+  _ as UiPointerGate,
+  z as UiRoot,
+  j as Widget,
+  a as anchorPosition,
   e as clamp,
-  w as clampScroll,
-  Vo as createStore,
-  R as drainState,
-  k as firstFocus,
+  R as clampScroll,
+  Do as createStore,
+  O as drainState,
+  vo as escapeRichText,
+  W as firstFocus,
   s as fitToViewport,
   t as insets,
-  Io as isEditable,
-  Oo as isInside,
-  y as linearFocus,
-  F as listWidth,
-  D as maxScroll,
-  z as nextFocus,
-  wo as onScreen,
-  c as placeTooltip,
-  P as quantize,
-  T as scrollIntoView,
-  U as setDrainValue,
-  Ro as shouldShield,
+  Ao as isEditable,
+  Io as isInside,
+  No as layoutRichText,
+  b as linearFocus,
+  S as listWidth,
+  g as maxScroll,
+  k as nextFocus,
+  Ro as onScreen,
+  zo as parseRichText,
+  n as placeTooltip,
+  L as quantize,
+  w as scrollIntoView,
+  y as setDrainValue,
+  Oo as shouldShield,
   J as sizeOf,
-  A as sliderFraction,
-  I as sliderValueAt,
+  P as sliderFraction,
+  A as sliderValueAt,
   p as snapPx,
-  m as snapRect,
-  i as stackLayout,
-  W as stepDrain,
-  V as stepFling,
-  N as uiHostOf,
-  Do as worldToScreen,
-  u as wrapRow
+  i as snapRect,
+  m as stackLayout,
+  B as stepDrain,
+  D as stepFling,
+  Eo as stripRichText,
+  G as uiHostOf,
+  go as worldToScreen,
+  h as wrapRow
 };
-//# sourceMappingURL=ui.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "1681-engine",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "description": "A 2D game engine on PixiJS 8 for any art style: scenes and a fast ECS, a fixed-step loop, asset loading, Tiled maps, sprite animation, input actions, camera follow, audio and deterministic, server-replayable movement, plus Dither, an optional pixel-art module (pixel-perfect effects, dithered lighting).",
   "type": "module",
   "types": "./dist/types/index.d.ts",
@@ -89,9 +89,6 @@
     "LICENSE",
     "CHANGELOG.md"
   ],
-  "engines": {
-    "node": ">=22"
-  },
   "peerDependencies": {
     "pixi.js": "^8.6.0",
     "react": "^19.0.0",

package/dist/1681-engine.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"1681-engine.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/ambient/ColorGrade.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ColorGrade.js","sources":["../../src/ambient/ColorGrade.ts"],"sourcesContent":["import { Sprite, Texture, type Container } from 'pixi.js';\nimport type { Stage } from '../core/Stage';\nimport { mixToWhite, type GradeState } from './grade';\n\n/** Where the sheet goes among its parent's children. */\nexport type GradePlacement = 'top' | 'bottom';\n\nexport interface ColorGradeOptions {\n  /** How often (ms) the grade is read again: the hour moves slowly, so not every frame (default 500). */\n  readEveryMs?: number;\n  /** The container the sheet is added to (default the stage's screen layer). */\n  parent?: Container;\n  /**\n   * `'top'` (the default) adds the sheet over everything already in `parent`, so it tints a HUD made before it and\n   * not one made after. `'bottom'` puts it under every child `parent` has or will have: on the screen layer that is\n   * over the world and under every HUD, whatever order they were made in — usually what a grade wants.\n   */\n  placement?: GradePlacement;\n}\n\n/**\n * A colour laid over the whole screen in **multiply**, so it tints the world (a marsh mossy, a peak ember, a dead\n * land pale) without washing the art toward white the way a normal-blend sheet would. One white quad, tinted: no\n * filter pass, which is what a phone can spare every frame.\n *\n * `read` returns the grade now (`gradeAt` from a place's `Grade` and `DayClock`'s night, say); it is asked a few\n * times a second, and a grade that comes to white is not drawn at all. Give `placement: 'bottom'` to keep it off the\n * HUD (see `ColorGradeOptions.placement`).\n */\nexport class ColorGrade {\n  private readonly sheet = new Sprite({ texture: Texture.WHITE });\n  private readAt = -Infinity;\n  private blank = false;\n  private readonly every: number;\n\n  constructor(\n    private readonly stage: Stage,\n    private readonly read: () => GradeState | null,\n    options: ColorGradeOptions = {},\n  ) {\n    this.every = options.readEveryMs ?? 500;\n    this.sheet.blendMode = 'multiply';\n    this.sheet.visible = false;\n    const parent = options.parent ?? stage.screen;\n    if (options.placement === 'bottom') parent.addChildAt(this.sheet, 0);\n    else parent.addChild(this.sheet);\n  }\n\n  /** Reads the grade again on the next update (the place changed). */\n  invalidate(): void {\n    this.readAt = -Infinity;\n  }\n\n  /** `enabled`: the game's setting, and off under a battery saver — a full-screen blend is a cost on a phone. */\n  update(now: number, enabled = true): void {\n    if (!enabled) {\n      this.sheet.visible = false;\n      this.readAt = -Infinity;\n      return;\n    }\n    if (now - this.readAt >= this.every) {\n      this.readAt = now;\n      const g = this.read();\n      const tint = g ? mixToWhite(g.color, g.alpha) : 0xffffff;\n      this.blank = tint === 0xffffff;\n      this.sheet.tint = tint;\n    }\n    this.sheet.visible = !this.blank;\n    if (this.blank) return;\n    const { width, height } = this.stage;\n    if (this.sheet.width !== width) this.sheet.width = width;\n    if (this.sheet.height !== height) this.sheet.height = height;\n  }\n\n  destroy(): void {\n    this.sheet.destroy();\n  }\n}\n"],"names":["ColorGrade","stage","read","options","parent","Sprite","Texture","now","enabled","g","tint","mixToWhite","width","height"],"mappings":";;AA6BO,MAAMA,EAAW;AAAA,EAMtB,YACmBC,GACAC,GACjBC,IAA6B,CAAA,GAC7B;AAHiB,SAAA,QAAAF,GACA,KAAA,OAAAC,GAGjB,KAAK,QAAQC,EAAQ,eAAe,KACpC,KAAK,MAAM,YAAY,YACvB,KAAK,MAAM,UAAU;AACrB,UAAMC,IAASD,EAAQ,UAAUF,EAAM;AACvC,IAAIE,EAAQ,cAAc,aAAiB,WAAW,KAAK,OAAO,CAAC,IAC9DC,EAAO,SAAS,KAAK,KAAK;AAAA,EACjC;AAAA,EAVmB;AAAA,EACA;AAAA,EAPF,QAAQ,IAAIC,EAAO,EAAE,SAASC,EAAQ,OAAO;AAAA,EACtD,SAAS;AAAA,EACT,QAAQ;AAAA,EACC;AAAA;AAAA,EAgBjB,aAAmB;AACjB,SAAK,SAAS;AAAA,EAChB;AAAA;AAAA,EAGA,OAAOC,GAAaC,IAAU,IAAY;AACxC,QAAI,CAACA,GAAS;AACZ,WAAK,MAAM,UAAU,IACrB,KAAK,SAAS;AACd;AAAA,IACF;AACA,QAAID,IAAM,KAAK,UAAU,KAAK,OAAO;AACnC,WAAK,SAASA;AACd,YAAME,IAAI,KAAK,KAAA,GACTC,IAAOD,IAAIE,EAAWF,EAAE,OAAOA,EAAE,KAAK,IAAI;AAChD,WAAK,QAAQC,MAAS,UACtB,KAAK,MAAM,OAAOA;AAAA,IACpB;AAEA,QADA,KAAK,MAAM,UAAU,CAAC,KAAK,OACvB,KAAK,MAAO;AAChB,UAAM,EAAE,OAAAE,GAAO,QAAAC,EAAA,IAAW,KAAK;AAC/B,IAAI,KAAK,MAAM,UAAUD,MAAO,KAAK,MAAM,QAAQA,IAC/C,KAAK,MAAM,WAAWC,MAAQ,KAAK,MAAM,SAASA;AAAA,EACxD;AAAA,EAEA,UAAgB;AACd,SAAK,MAAM,QAAA;AAAA,EACb;AACF;"}

package/dist/ambient/DayClock.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DayClock.js","sources":["../../src/ambient/DayClock.ts"],"sourcesContent":["/**\n * A time of day read off a wall clock, so every client that agrees on the time (`serverNow`) stands in the same dusk\n * without a packet between them. Pure: no Pixi, no clock of its own — the caller hands in the time, and what draws\n * the night (a `LightLayer`, the pixel `NightShade`) or a HUD badge reads what this returns.\n *\n * ```ts\n * const clock = new DayClock({\n *   periodMs: 2 * 3600_000, // a game day every two real hours\n *   keys: [\n *     { at: 0, color: 0x0a1030, alpha: 0.52 },\n *     { at: 0.3, color: 0xfff0d8, alpha: 0 },\n *     { at: 0.7, color: 0xffb070, alpha: 0 },\n *     { at: 0.86, color: 0x0a1030, alpha: 0.52 },\n *   ],\n *   phases: [{ id: 'dawn', from: 0.2 }, { id: 'day', from: 0.3 }, { id: 'dusk', from: 0.7 }, { id: 'night', from: 0.8 }],\n * });\n * const day = clock.at(serverNow()); // { phase, id, color, alpha, night }\n * ```\n *\n * Phase 0 is midnight and 0.5 noon. Keys are the grade laid over the outdoor world at points of the day, mixed\n * between neighbours; a key at 0 and one at 1 with the same values make midnight seamless.\n */\n\n/** The world's grade at one point of the day: its colour (0xRRGGBB) and how strongly it is laid (0 by day). */\nexport interface DayKey {\n  at: number;\n  color: number;\n  alpha: number;\n}\n\n/** A named part of the day starting at `from` (0..1); the last one runs on through midnight. */\nexport interface DayPhase<P extends string = string> {\n  id: P;\n  from: number;\n}\n\nexport interface DayClockOptions<P extends string = string> {\n  /** Real milliseconds a whole game day lasts. */\n  periodMs: number;\n  /** Shifts the day against the wall clock (the same offset on every client keeps them together). */\n  offsetMs?: number;\n  /** At least one key. */\n  keys: readonly DayKey[];\n  /** Optional names for parts of the day; without them `id` is ''. */\n  phases?: readonly DayPhase<P>[];\n}\n\nexport interface DayState<P extends string = string> {\n  /** 0..1 through the game day: 0 midnight, 0.5 noon. */\n  phase: number;\n  /** The part of the day `phase` falls in. */\n  id: P | '';\n  /** The grade over the outdoor world, 0xRRGGBB. */\n  color: number;\n  /** How strongly the grade is laid (0 at full day). */\n  alpha: number;\n  /** 0 by day, 1 at the darkest key: how much lamps matter. */\n  night: number;\n}\n\n/** `a` taken `t` of the way to `b`, per channel, 0xRRGGBB. */\nexport function mixRgb(a: number, b: number, t: number): number {\n  const ch = (s: number) => Math.round(((a >> s) & 255) * (1 - t) + ((b >> s) & 255) * t);\n  return (ch(16) << 16) | (ch(8) << 8) | ch(0);\n}\n\nexport class DayClock<P extends string = string> {\n  private readonly periodMs: number;\n  private readonly offsetMs: number;\n  private readonly keys: DayKey[];\n  private readonly phases: DayPhase<P>[];\n  private readonly maxAlpha: number;\n  /** A phase held still (a debug command, a cut scene at midnight); null follows the clock. */\n  private held: number | null = null;\n\n  constructor(options: DayClockOptions<P>) {\n    if (!(options.periodMs > 0)) throw new Error('DayClock: periodMs must be above 0');\n    if (!options.keys.length) throw new Error('DayClock: at least one key');\n    this.periodMs = options.periodMs;\n    this.offsetMs = options.offsetMs ?? 0;\n    this.keys = [...options.keys].sort((a, b) => a.at - b.at);\n    this.phases = [...(options.phases ?? [])].sort((a, b) => a.from - b.from);\n    // a clock whose darkest key is barely dark still reaches night 1 there, and one with no dark never divides by 0\n    this.maxAlpha = Math.max(0.01, ...this.keys.map((k) => k.alpha));\n  }\n\n  /** Holds the day at `phase` (0..1), or lets it run again with null. */\n  hold(phase: number | null): void {\n    this.held = phase === null ? null : ((phase % 1) + 1) % 1;\n  }\n\n  /** Where the day stands at wall time `ms` (0..1). */\n  phaseAt(ms: number): number {\n    if (this.held !== null) return this.held;\n    const p = this.periodMs;\n    return ((((ms + this.offsetMs) % p) + p) % p) / p;\n  }\n\n  at(ms: number): DayState<P> {\n    const phase = this.phaseAt(ms);\n    const keys = this.keys;\n    let key = keys[0]!;\n    let color = key.color;\n    let alpha = key.alpha;\n    // past the last key it holds; before the first it holds the first\n    if (phase >= keys[keys.length - 1]!.at) {\n      key = keys[keys.length - 1]!;\n      color = key.color;\n      alpha = key.alpha;\n    }\n    for (let i = 0; i < keys.length - 1; i++) {\n      const a = keys[i]!;\n      const b = keys[i + 1]!;\n      if (phase < a.at || phase > b.at) continue;\n      const t = b.at > a.at ? (phase - a.at) / (b.at - a.at) : 0;\n      color = mixRgb(a.color, b.color, t);\n      alpha = a.alpha + (b.alpha - a.alpha) * t;\n      break;\n    }\n    // the stretch before the first `from` belongs to the last phase: night runs through midnight\n    let id: P | '' = this.phases.length ? this.phases[this.phases.length - 1]!.id : '';\n    for (const ph of this.phases) if (phase >= ph.from) id = ph.id;\n    return { phase, id, color, alpha, night: Math.min(1, alpha / this.maxAlpha) };\n  }\n}\n\n/** A day's phase as a 24-hour clock, \"HH:MM\" (phase 0 is midnight). */\nexport function clockText(phase: number): string {\n  const minutes = Math.floor((((phase % 1) + 1) % 1) * 24 * 60);\n  return `${String(Math.floor(minutes / 60)).padStart(2, '0')}:${String(minutes % 60).padStart(2, '0')}`;\n}\n\n/**\n * The night's colour pulled toward a place's own (a marsh mossy, a wood blue) as it deepens: `share` of the way at\n * full night, nothing by day.\n */\nexport function tintNight(day: Pick<DayState, 'color' | 'night'>, tint: number | undefined, share = 0.6): number {\n  return tint === undefined ? day.color : mixRgb(day.color, tint, day.night * share);\n}\n"],"names":["mixRgb","a","b","ch","s","DayClock","options","k","phase","ms","p","keys","key","color","alpha","i","t","id","ph","clockText","minutes","tintNight","day","tint","share"],"mappings":"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"}

package/dist/ambient/WeatherLayer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"WeatherLayer.js","sources":["../../src/ambient/WeatherLayer.ts"],"sourcesContent":["import { Sprite, Texture } from 'pixi.js';\nimport type { ViewRect } from '../core/Camera';\nimport type { Image } from '../core/Image';\nimport type { Stage } from '../core/Stage';\nimport type { WeatherState } from './weather';\n\n/**\n * How one kind of weather moves:\n * - `fall`: streaks falling at a slant onto a ground line somewhere in view, half of them leaving a two-frame splash\n *   (rain);\n * - `flake`: bits drifting down and swaying as they fall, each on its own phase (snow, ash, petals);\n * - `bank`: a few wide sprites drifting slowly sideways, laid over the bodies (fog, mist, smoke).\n */\nexport type WeatherMotion = 'fall' | 'flake' | 'bank';\n\nexport interface WeatherLook {\n  motion: WeatherMotion;\n  /** Particles at full strength; fewer show as the weather thins. Keep it in the low hundreds on a phone. */\n  max: number;\n  /** Texture keys, handed out in turn (repeat a key to make it commoner). */\n  keys: readonly string[];\n  /** `fall` only: the splash's two frames. Without them a drop simply vanishes where it lands. */\n  splash?: readonly [string, string];\n  /** World px a second, [lo, hi] each (defaults suit each motion). */\n  vx?: readonly [number, number];\n  vy?: readonly [number, number];\n  /** `flake` only: how far (px) a flake sways either side as it falls (default 4). */\n  sway?: number;\n  /** A screen-wide tint the kind lays over everything (fog is mostly tint), at `tintAlpha` × strength. */\n  tint?: number;\n  tintAlpha?: number;\n}\n\nexport interface WeatherLayerOptions<K extends string> {\n  looks: Readonly<Partial<Record<K, WeatherLook>>>;\n  /** Depth of falling particles in the world layer: over the bodies, under the names (default 900_001). */\n  depth?: number;\n  /** Depth of fog banks (default 900_010). */\n  bankDepth?: number;\n  /** Depth of splashes: with the ground effects, so a body standing in the rain is not splashed over (default 0). */\n  splashDepth?: number;\n  /** Round positions to whole world pixels (default true): pixel art wants it, smooth art may not. */\n  snap?: boolean;\n  /** Where randomness comes from (default `Math.random`); the look of a shower need not be shared between clients. */\n  random?: () => number;\n}\n\ninterface Drop {\n  img: Image;\n  key: string;\n  x: number;\n  y: number;\n  vx: number;\n  vy: number;\n  /** `fall`: the ground line it lands on. `flake`: its sway's phase. */\n  ground: number;\n  /** `fall`: when its splash began (0 while it still falls). */\n  splashAt: number;\n}\n\nconst SPLASH_MS = 80;\nconst DEFAULT_V: Record<WeatherMotion, { vx: readonly [number, number]; vy: readonly [number, number] }> = {\n  fall: { vx: [-48, -38], vy: [250, 320] },\n  flake: { vx: [4, 12], vy: [14, 30] },\n  bank: { vx: [3, 8], vy: [0, 0] },\n};\n\n/**\n * The weather on screen: a capped pool of particles that lives only inside the camera's view, plus a light screen\n * tint for the kinds that change the air. Feed it a `WeatherState` each frame (from `weatherAt`, so it fades in and\n * out exactly when every other client's does); the pool is rebuilt only when the kind changes, and a thinning shower\n * hides particles rather than freeing them.\n *\n * The art is the game's: name texture keys per kind (the pixel module's `paintWeatherArt` paints a set in whole\n * pixels).\n */\nexport class WeatherLayer<K extends string> {\n  private readonly drops: Drop[] = [];\n  private kind: K | 'clear' = 'clear';\n  private look: WeatherLook | undefined;\n  private readonly tint = new Sprite({ texture: Texture.WHITE });\n  private readonly depth: number;\n  private readonly bankDepth: number;\n  private readonly splashDepth: number;\n  private readonly snap: boolean;\n  private readonly random: () => number;\n\n  constructor(\n    private readonly stage: Stage,\n    private readonly options: WeatherLayerOptions<K>,\n  ) {\n    this.depth = options.depth ?? 900_001;\n    this.bankDepth = options.bankDepth ?? 900_010;\n    this.splashDepth = options.splashDepth ?? 0;\n    this.snap = options.snap ?? true;\n    this.random = options.random ?? Math.random;\n    this.tint.visible = false;\n    stage.screen.addChild(this.tint);\n  }\n\n  /**\n   * `now` in ms, `dt` the frame's ms, `view` the camera's world view. `share` (0..1) thins the pool on top of the\n   * weather's own strength (a reduced-effects setting keeps half).\n   */\n  update(now: number, dt: number, view: ViewRect, weather: WeatherState<K>, share = 1): void {\n    if (weather.kind !== this.kind) this.rebuild(weather.kind, view);\n    const look = this.look;\n    const tintAlpha = (look?.tintAlpha ?? 0) * weather.intensity;\n    this.tint.visible = tintAlpha > 0.004;\n    if (this.tint.visible) {\n      this.tint.tint = look?.tint ?? 0xffffff;\n      this.tint.alpha = tintAlpha;\n      this.tint.width = this.stage.width;\n      this.tint.height = this.stage.height;\n    }\n    if (!look) return;\n    const active = Math.round(this.drops.length * weather.intensity * Math.max(0, Math.min(1, share)));\n    const s = dt / 1000;\n    for (let i = 0; i < this.drops.length; i++) {\n      const d = this.drops[i]!;\n      if (i >= active) {\n        if (d.img.visible) d.img.setVisible(false);\n        continue;\n      }\n      if (!d.img.visible) this.spawn(d, look, view, false);\n      if (look.motion === 'fall') this.stepFall(d, look, now, s, view);\n      else if (look.motion === 'bank') this.stepBank(d, look, s, view, weather.intensity);\n      else this.stepFlake(d, look, now, s, view);\n    }\n  }\n\n  private rebuild(kind: K | 'clear', view: ViewRect): void {\n    for (const d of this.drops) d.img.destroy();\n    this.drops.length = 0;\n    this.kind = kind;\n    this.look = kind === 'clear' ? undefined : this.options.looks[kind];\n    const look = this.look;\n    if (!look || !look.keys.length) return;\n    for (let i = 0; i < look.max; i++) {\n      const key = look.keys[i % look.keys.length]!;\n      const img = this.stage.add.image(0, 0, key).setOrigin(0, 0).setVisible(false);\n      const d: Drop = { img, key, x: 0, y: 0, vx: 0, vy: 0, ground: 0, splashAt: 0 };\n      this.drops.push(d);\n      // the first fill is spread over the whole view, so a shower starting does not arrive as one falling sheet\n      this.spawn(d, look, view, true);\n      img.setVisible(false);\n    }\n  }\n\n  private between(r: readonly [number, number]): number {\n    return r[0] + (r[1] - r[0]) * this.random();\n  }\n\n  private place(d: Drop): void {\n    d.img.setPosition(this.snap ? Math.round(d.x) : d.x, this.snap ? Math.round(d.y) : d.y);\n  }\n\n  private spawn(d: Drop, look: WeatherLook, view: ViewRect, anywhere: boolean): void {\n    const r = this.random;\n    const v = DEFAULT_V[look.motion];\n    const x = view.x - 30 + r() * (view.width + 60);\n    d.vx = this.between(look.vx ?? v.vx);\n    d.vy = this.between(look.vy ?? v.vy);\n    if (look.motion === 'fall') {\n      d.ground = view.y + r() * (view.height + 12);\n      d.y = anywhere ? view.y - 10 + r() * (d.ground - view.y + 10) : d.ground - 30 - r() * view.height;\n      d.x = x;\n      d.splashAt = 0;\n      d.img.setTexture(d.key).setDepth(this.depth).setAlpha(1);\n    } else if (look.motion === 'bank') {\n      d.x = anywhere ? x : view.x - d.img.width;\n      d.y = view.y + r() * view.height;\n      d.img.setDepth(this.bankDepth);\n    } else {\n      d.x = x;\n      d.y = anywhere ? view.y + r() * view.height : view.y - 4 - r() * 20;\n      d.ground = r() * Math.PI * 2;\n      d.img.setDepth(this.depth);\n    }\n    d.img.setVisible(true);\n  }\n\n  private stepFall(d: Drop, look: WeatherLook, now: number, s: number, view: ViewRect): void {\n    if (d.splashAt) {\n      const t = now - d.splashAt;\n      if (t > SPLASH_MS * 2) this.spawn(d, look, view, false);\n      else if (t > SPLASH_MS && look.splash) d.img.setTexture(look.splash[1]);\n      return;\n    }\n    d.x += d.vx * s;\n    d.y += d.vy * s;\n    if (d.y >= d.ground) {\n      // every other drop splashes on the ground it hit; the rest vanish into it\n      if (look.splash && this.random() < 0.5) {\n        d.splashAt = now;\n        d.img.setTexture(look.splash[0]).setDepth(this.splashDepth);\n        d.x -= d.img.width / 2;\n        d.y = d.ground - 1;\n        this.place(d);\n      } else this.spawn(d, look, view, false);\n      return;\n    }\n    this.place(d);\n  }\n\n  private stepFlake(d: Drop, look: WeatherLook, now: number, s: number, view: ViewRect): void {\n    d.x += d.vx * s;\n    d.y += d.vy * s;\n    if (d.y > view.bottom + 4 || d.x > view.right + 30 || d.x < view.x - 40) {\n      this.spawn(d, look, view, false);\n      return;\n    }\n    // the sway is added at draw time, so it never drifts the flake off its line\n    const sway = Math.sin(now / 900 + d.ground) * (look.sway ?? 4);\n    const x = d.x + sway;\n    d.img.setPosition(this.snap ? Math.round(x) : x, this.snap ? Math.round(d.y) : d.y);\n  }\n\n  private stepBank(d: Drop, look: WeatherLook, s: number, view: ViewRect, intensity: number): void {\n    d.x += d.vx * s;\n    if (d.x > view.right + 10 || d.y < view.y - 20 || d.y > view.bottom + 10) this.spawn(d, look, view, d.x <= view.right + 10);\n    d.img.setAlpha(0.35 + 0.5 * intensity);\n    this.place(d);\n  }\n\n  destroy(): void {\n    for (const d of this.drops) d.img.destroy();\n    this.drops.length = 0;\n    this.tint.destroy();\n  }\n}\n"],"names":["SPLASH_MS","DEFAULT_V","WeatherLayer","stage","options","Sprite","Texture","now","dt","view","weather","share","look","tintAlpha","active","s","i","d","kind","key","img","r","anywhere","v","x","t","sway","intensity"],"mappings":"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"}

package/dist/ambient/grade.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"grade.js","sources":["../../src/ambient/grade.ts"],"sourcesContent":["/**\n * 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\n * that leaves the same result. `ColorGrade` draws it.\n */\n\n/** A place's grade: its colour (0xRRGGBB) and how strongly it is laid by day and by night (0..1). */\nexport interface Grade {\n  color: number;\n  day: number;\n  night: number;\n}\n\nexport interface GradeState {\n  color: number;\n  alpha: number;\n}\n\n/**\n * The grade at `night` (0 by day, 1 at full night, `DayClock`'s `night`), never past `max`: a grade is a light\n * tint, and one laid too strong washes every sprite toward one colour.\n */\nexport function gradeAt(grade: Grade, night: number, max = 0.14): GradeState {\n  const n = Math.max(0, Math.min(1, night));\n  return { color: grade.color, alpha: Math.max(0, Math.min(max, grade.day + (grade.night - grade.day) * n)) };\n}\n\n/** `color` taken `share` of the way from white: what a multiply sheet of that colour at that opacity leaves. */\nexport function mixToWhite(color: number, share: number): number {\n  const s = Math.max(0, Math.min(1, share));\n  const ch = (shift: number) => Math.round(255 - (255 - ((color >> shift) & 255)) * s) << shift;\n  return ch(16) | ch(8) | ch(0);\n}\n"],"names":["gradeAt","grade","night","max","mixToWhite","color","share","s","ch","shift"],"mappings":"AAqBO,SAASA,EAAQC,GAAcC,GAAeC,IAAM,MAAkB;AAC3E,QAAM,IAAI,KAAK,IAAI,GAAG,KAAK,IAAI,GAAGD,CAAK,CAAC;AACxC,SAAO,EAAE,OAAOD,EAAM,OAAO,OAAO,KAAK,IAAI,GAAG,KAAK,IAAIE,GAAKF,EAAM,OAAOA,EAAM,QAAQA,EAAM,OAAO,CAAC,CAAC,EAAA;AAC1G;AAGO,SAASG,EAAWC,GAAeC,GAAuB;AAC/D,QAAMC,IAAI,KAAK,IAAI,GAAG,KAAK,IAAI,GAAGD,CAAK,CAAC,GAClCE,IAAK,CAACC,MAAkB,KAAK,MAAM,OAAO,OAAQJ,KAASI,IAAS,QAAQF,CAAC,KAAKE;AACxF,SAAOD,EAAG,EAAE,IAAIA,EAAG,CAAC,IAAIA,EAAG,CAAC;AAC9B;"}

package/dist/ambient/weather.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"weather.js","sources":["../../src/ambient/weather.ts"],"sourcesContent":["/**\n * Weather rolled from wall time alone, so two players standing in the same place are rained on together without a\n * packet between them. Pure and deterministic: the same key, time and table give the same sky on every machine.\n *\n * Time is cut into slots; each slot rolls one entry of a weighted list from a hash of the key and the slot number,\n * 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:\n * 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)\n * and only its strength from its own list. The kind `'clear'` means no weather and has no strength.\n *\n * ```ts\n * const TABLE: WeatherTable = {\n *   slotMs: 12 * 60_000,\n *   fadeMs: 40_000,\n *   places: { meadow: [{ kind: 'clear', weight: 4 }, { kind: 'rain', weight: 3, intensity: [0.4, 1] }] },\n * };\n * const w = weatherAt('meadow', serverNow(), TABLE); // { kind: 'rain', intensity: 0.7 }\n * ```\n */\n\nexport interface WeatherEntry<K extends string = string> {\n  kind: K | 'clear';\n  weight: number;\n  /** The strength range rolled for this kind, [lo, hi] in 0..1 (default [1, 1]). */\n  intensity?: readonly [number, number];\n}\n\nexport interface WeatherSky<K extends string = string> {\n  /** The place keys under this sky. */\n  places: readonly string[];\n  entries: readonly WeatherEntry<K>[];\n}\n\nexport interface WeatherTable<K extends string = string> {\n  /** How long one roll of the sky lasts. */\n  slotMs: number;\n  /** How long a change of kind takes to fade out and in. */\n  fadeMs: number;\n  /** Each place's own list; a place with none (a cave) has no weather, even inside a sky. */\n  places: Readonly<Record<string, readonly WeatherEntry<K>[]>>;\n  /** Groups of neighbouring places that share one sky, by group id. */\n  skies?: Readonly<Record<string, WeatherSky<K>>>;\n}\n\nexport interface WeatherState<K extends string = string> {\n  kind: K | 'clear';\n  /** 0..1, already faded round a change of kind; 0 when clear. */\n  intensity: number;\n}\n\nconst CLEAR: WeatherState<never> = { kind: 'clear', intensity: 0 };\n\n/** FNV-1a over the text, then an avalanche: a stable number in [0, 1). */\nexport function hash01(text: string): number {\n  let h = 0x811c9dc5;\n  for (let i = 0; i < text.length; i++) {\n    h ^= text.charCodeAt(i);\n    h = Math.imul(h, 0x01000193);\n  }\n  h ^= h >>> 16;\n  h = Math.imul(h, 0x85ebca6b);\n  h ^= h >>> 13;\n  return (h >>> 0) / 4294967296;\n}\n\n/** The sky group each place belongs to, worked out once per table. */\nconst SKY_OF = new WeakMap<object, Map<string, string>>();\n\nfunction skyOf(table: WeatherTable<string>, key: string): string | undefined {\n  if (!table.skies) return undefined;\n  let map = SKY_OF.get(table);\n  if (!map) {\n    map = new Map();\n    for (const [id, sky] of Object.entries(table.skies)) for (const p of sky.places) map.set(p, id);\n    SKY_OF.set(table, map);\n  }\n  return map.get(key);\n}\n\nfunction roll<K extends string>(seed: string, entries: readonly WeatherEntry<K>[], slot: number): WeatherState<K> {\n  const total = entries.reduce((s, e) => s + e.weight, 0);\n  if (total <= 0) return CLEAR;\n  let r = hash01(`${seed}:${slot}`) * total;\n  let pick = entries[entries.length - 1]!;\n  for (const e of entries) {\n    r -= e.weight;\n    if (r < 0) {\n      pick = e;\n      break;\n    }\n  }\n  if (pick.kind === 'clear') return CLEAR;\n  const [lo, hi] = pick.intensity ?? [1, 1];\n  return { kind: pick.kind, intensity: lo + (hi - lo) * hash01(`${seed}:${slot}:i`) };\n}\n\n/** The weather over place `key` at wall time `ms`. */\nexport function weatherAt<K extends string>(key: string, ms: number, table: WeatherTable<K>): WeatherState<K> {\n  const own = table.places[key] ?? [];\n  if (!own.length) return CLEAR;\n  const group = skyOf(table, key);\n  const seed = group === undefined ? key : `sky:${group}`;\n  const entries = group === undefined ? own : table.skies![group]!.entries;\n  if (!entries.length) return CLEAR;\n  const slot = Math.floor(ms / table.slotMs);\n  let now = roll(seed, entries, slot);\n  if (now.kind === 'clear') return now;\n  // a shared sky's kind at the strength this place feels it: its own range for that kind when its list has one\n  if (group !== undefined) {\n    const range = own.find((e) => e.kind === now.kind)?.intensity;\n    if (range) now = { kind: now.kind, intensity: range[0] + (range[1] - range[0]) * hash01(`${seed}:${slot}:i`) };\n  }\n  const into = ms - slot * table.slotMs;\n  const left = table.slotMs - into;\n  let fade = 1;\n  if (table.fadeMs > 0) {\n    if (roll(seed, entries, slot - 1).kind !== now.kind) fade = Math.min(fade, into / table.fadeMs);\n    if (roll(seed, entries, slot + 1).kind !== now.kind) fade = Math.min(fade, left / table.fadeMs);\n  }\n  return { kind: now.kind, intensity: now.intensity * Math.max(0, Math.min(1, fade)) };\n}\n"],"names":["CLEAR","hash01","text","h","i","SKY_OF","skyOf","table","key","map","id","sky","p","roll","seed","entries","slot","total","s","e","r","pick","lo","hi","weatherAt","ms","own","group","now","range","into","left","fade"],"mappings":"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"}

package/dist/anim/AnimStateMachine.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AnimStateMachine.js","sources":["../../src/anim/AnimStateMachine.ts"],"sourcesContent":["import { Animator, type AnimationClip } from './Animator';\nimport {\n  OP_EQ,\n  OP_GE,\n  OP_GT,\n  OP_LE,\n  OP_LT,\n  OP_NE,\n  PARAM_BOOL,\n  PARAM_TRIGGER,\n  compileParams,\n  compileStates,\n  compileTransitions,\n  type CompiledParams,\n  type CompiledStates,\n  type CompiledTransitions,\n} from './animStateCompile';\nimport type { AnimParams, AnimStateMachineOptions } from './animStateTypes';\n\n/**\n * Chooses which clip an `Animator` plays from named states and the transitions between them, the way an animation\n * graph in a larger engine does: the game sets parameters (a bool, a number, a one-shot trigger) and the machine\n * moves between states when a transition's conditions hold, when a clip has played through, or from any state at\n * all by priority. Frame markers fire events (a footstep on frame 3) for the game to hang sounds and effects on.\n *\n * Pure and driven by `update(dt)`, so it runs under node with a fake clock. The definition is compiled into typed\n * arrays once; an update allocates nothing.\n *\n * ```ts\n * const sm = new AnimStateMachine(sheet.clips, {\n *   initial: 'idle',\n *   params: { speed: 0, grounded: true, jump: 'trigger' },\n *   states: { idle: { clip: 'idle' }, run: { clip: 'run', markers: [{ frame: 2, name: 'step' }] }, jump: { clip: 'jump' } },\n *   transitions: [\n *     { from: 'idle', to: 'run', when: { speed: ['>', 0] } },\n *     { from: 'run', to: 'idle', when: { speed: 0 } },\n *     { from: '*', to: 'jump', when: { jump: true, grounded: true }, priority: 10 },\n *   ],\n * });\n * sm.onEvent = (name) => name === 'step' && sound.play('step');\n * sm.set('speed', 3);\n * sm.update(dt);              // seconds; then show sm.frame\n * ```\n */\nexport class AnimStateMachine<State extends string = string, Clip extends string = string, P extends AnimParams = AnimParams> {\n  /** The animator it drives; read `frame` off it (or off the machine). */\n  readonly animator: Animator<Clip>;\n  /** Fired for every marker playback reaches, the state's first frame's on entering it. */\n  onEvent: ((event: string, state: State, frame: number) => void) | null = null;\n  /** Fired after each change of state. */\n  onStateChange: ((from: State, to: State) => void) | null = null;\n\n  private readonly params: CompiledParams;\n  private readonly states: CompiledStates;\n  private readonly tr: CompiledTransitions;\n  private readonly keepTriggers: boolean;\n  private stateIndex: number;\n  /** Time played in this state, ms, scaled by speed as the animator scales it. */\n  private time = 0;\n\n  constructor(clips: Record<Clip, AnimationClip>, options: AnimStateMachineOptions<State, Clip, P>) {\n    const opts = options as unknown as AnimStateMachineOptions<string, string, AnimParams>;\n    this.params = compileParams(options.params ?? {});\n    this.states = compileStates(opts, clips, this.params);\n    this.tr = compileTransitions(opts, this.states, this.params);\n    this.keepTriggers = options.keepTriggers === true;\n    this.stateIndex = this.states.index.get(options.initial)!;\n    this.animator = new Animator(clips, this.states.clips[this.stateIndex] as Clip);\n    this.applySpeed();\n  }\n\n  /** The state playing. */\n  get state(): State {\n    return this.states.names[this.stateIndex] as State;\n  }\n\n  /** The frame to show now (a sheet frame index or name, as the clip lists it). */\n  get frame(): string | number {\n    return this.animator.frame;\n  }\n\n  /** How much of this state's clip has played: 0 at entry, 1 after one pass, 2 after two loops. */\n  get normalizedTime(): number {\n    return this.time / this.states.lengths[this.stateIndex]!;\n  }\n\n  /** Sets a bool or number parameter. */\n  set(name: keyof P & string, value: boolean | number): this {\n    const i = this.paramIndex(name);\n    if (this.params.kinds[i] === PARAM_TRIGGER) throw new Error(`AnimStateMachine: \"${name}\" is a trigger; use trigger()`);\n    this.params.values[i] = typeof value === 'boolean' ? (value ? 1 : 0) : value;\n    return this;\n  }\n\n  /** A parameter's value: bools as booleans, triggers as whether they are set. */\n  get(name: keyof P & string): boolean | number {\n    const i = this.paramIndex(name);\n    const v = this.params.values[i]!;\n    return this.params.kinds[i] === PARAM_BOOL || this.params.kinds[i] === PARAM_TRIGGER ? v !== 0 : v;\n  }\n\n  /** Fires a trigger: the next update's transitions see it once. */\n  trigger(name: keyof P & string): this {\n    this.params.values[this.triggerIndex(name)] = 1;\n    return this;\n  }\n\n  resetTrigger(name: keyof P & string): this {\n    this.params.values[this.triggerIndex(name)] = 0;\n    return this;\n  }\n\n  /** Goes to `state` now, whatever the transitions say (a respawn, a cut scene). */\n  play(state: State): this {\n    const i = this.states.index.get(state);\n    if (i === undefined) throw new Error(`AnimStateMachine: no state \"${state}\"`);\n    this.enter(i);\n    return this;\n  }\n\n  /** Back to the initial values of every parameter (triggers cleared). */\n  resetParams(): this {\n    this.params.values.set(this.params.initial);\n    return this;\n  }\n\n  /**\n   * Advances the clip by `dt` seconds, fires the markers it passed, then takes at most one transition (so a chain of\n   * them never runs through several states in one frame). `update(0)` only checks the transitions.\n   */\n  update(dt: number): void {\n    const s = this.stateIndex;\n    this.applySpeed();\n    const a = this.animator;\n    const before = a.frameIndex;\n    const wasFinished = a.finished;\n    a.update(dt);\n    if (dt > 0 && a.speed > 0) {\n      const delta = dt * 1000 * a.speed;\n      this.time += delta;\n      if (!wasFinished) this.firePassed(s, before, a.frameIndex, delta);\n    }\n    // a marker's listener may have changed state: the transitions are the state's now playing\n    const t = this.pick(this.stateIndex);\n    if (t >= 0) {\n      this.consumeTriggers(t);\n      this.enter(this.tr.to[t]!);\n    }\n    if (!this.keepTriggers) this.clearTriggers();\n  }\n\n  private pick(s: number): number {\n    const cands = this.states.candidates[s]!;\n    const tr = this.tr;\n    const ended = this.animator.finished || this.time >= this.states.lengths[s]!;\n    for (let k = 0; k < cands.length; k++) {\n      const t = cands[k]!;\n      if (tr.to[t] === s && tr.anyState[t] && !tr.self[t]) continue;\n      if (tr.onEnd[t] && !ended) continue;\n      if (tr.exitTime[t]! >= 0 && this.normalizedTime < tr.exitTime[t]!) continue;\n      if (this.holds(t)) return t;\n    }\n    return -1;\n  }\n\n  private holds(t: number): boolean {\n    const tr = this.tr;\n    const values = this.params.values;\n    for (let c = tr.condStart[t]!; c < tr.condEnd[t]!; c++) {\n      const v = values[tr.condParam[c]!]!;\n      const want = tr.condValue[c]!;\n      let ok: boolean;\n      switch (tr.condOp[c]) {\n        case OP_EQ: ok = v === want; break;\n        case OP_NE: ok = v !== want; break;\n        case OP_GT: ok = v > want; break;\n        case OP_GE: ok = v >= want; break;\n        case OP_LT: ok = v < want; break;\n        case OP_LE: ok = v <= want; break;\n        default: ok = false;\n      }\n      if (!ok) return false;\n    }\n    return true;\n  }\n\n  private enter(i: number): void {\n    const from = this.stateIndex;\n    this.stateIndex = i;\n    this.time = 0;\n    this.animator.play(this.states.clips[i] as Clip, true);\n    this.applySpeed();\n    this.onStateChange?.(this.states.names[from] as State, this.states.names[i] as State);\n    // a marker on the first frame (a jump's whoosh) belongs to entering the state\n    this.fire(i, 0);\n  }\n\n  /**\n   * Fires the markers of every frame after `from` up to `to`. The animator skips frames on a long step, so they are\n   * walked rather than only the one landed on; a step long enough to loop the whole clip fires each frame once.\n   */\n  private firePassed(s: number, from: number, to: number, deltaMs: number): void {\n    const n = this.states.frameCounts[s]!;\n    let steps = (to - from + n) % n;\n    if (steps === 0 && deltaMs >= this.states.lengths[s]!) steps = n;\n    for (let k = 1; k <= steps; k++) {\n      this.fire(s, (from + k) % n);\n      if (this.stateIndex !== s) return; // a listener changed state: the rest belong to a clip no longer playing\n    }\n  }\n\n  private fire(s: number, frame: number): void {\n    const names = this.states.markers[s]![frame];\n    if (!names || !this.onEvent) return;\n    const state = this.states.names[s] as State;\n    for (let i = 0; i < names.length; i++) this.onEvent(names[i]!, state, frame);\n  }\n\n  private applySpeed(): void {\n    const s = this.stateIndex;\n    const p = this.states.speedParams[s]!;\n    this.animator.speed = this.states.speeds[s]! * (p >= 0 ? Math.abs(this.params.values[p]!) : 1);\n  }\n\n  private consumeTriggers(t: number): void {\n    const tr = this.tr;\n    for (let c = tr.condStart[t]!; c < tr.condEnd[t]!; c++) {\n      if (this.params.kinds[tr.condParam[c]!] === PARAM_TRIGGER) this.params.values[tr.condParam[c]!] = 0;\n    }\n  }\n\n  private clearTriggers(): void {\n    const { kinds, values } = this.params;\n    for (let i = 0; i < kinds.length; i++) if (kinds[i] === PARAM_TRIGGER) values[i] = 0;\n  }\n\n  private paramIndex(name: string): number {\n    const i = this.params.index.get(name);\n    if (i === undefined) throw new Error(`AnimStateMachine: no parameter \"${name}\"`);\n    return i;\n  }\n\n  private triggerIndex(name: string): number {\n    const i = this.paramIndex(name);\n    if (this.params.kinds[i] !== PARAM_TRIGGER) throw new Error(`AnimStateMachine: \"${name}\" is not a trigger`);\n    return i;\n  }\n}\n"],"names":["AnimStateMachine","clips","options","opts","compileParams","compileStates","compileTransitions","Animator","name","value","i","PARAM_TRIGGER","v","PARAM_BOOL","state","dt","a","before","wasFinished","delta","t","s","cands","tr","ended","k","values","c","want","ok","OP_EQ","OP_NE","OP_GT","OP_GE","OP_LT","OP_LE","from","to","deltaMs","n","steps","frame","names","p","kinds"],"mappings":"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"}

package/dist/anim/Animator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Animator.js","sources":["../../src/anim/Animator.ts"],"sourcesContent":["/**\n * Frame animation of one sprite: which clip plays, which frame it is on. Pure state, advanced by time; a system copies\n * `frame` onto the sprite (`animationSystem`).\n *\n * ```ts\n * const clips = { idle: { frames: [0, 1], fps: 2 }, walk: { frames: [2, 3, 4, 5], fps: 10 }, die: { frames: [6, 7, 8], fps: 8, loop: false } };\n * const a = new Animator(clips, 'idle');\n * a.play('walk');          // switching to the clip already playing keeps its place\n * a.update(dt);            // seconds\n * sprite.setFrame(a.frame);\n * ```\n */\nexport interface AnimationClip {\n  /** Frame names or indices of the sprite sheet, in order. */\n  frames: readonly (string | number)[];\n  /** Frames per second (default 10). Pixel art usually wants 8–12. */\n  fps?: number;\n  /** Start over at the end (default true); otherwise hold the last frame and report it finished. */\n  loop?: boolean;\n  /** Per-frame lengths in ms, overriding `fps` (a held key pose, a quick smear). */\n  durations?: readonly number[];\n}\n\nexport type AnimationClips = Record<string, AnimationClip>;\n\nexport class Animator<Name extends string = string> {\n  private clip: AnimationClip;\n  private index = 0;\n  private elapsed = 0;\n  private ended = false;\n  private name: Name;\n  /** Called when a clip that does not loop reaches its last frame. */\n  onComplete: ((clip: Name) => void) | null = null;\n  /** Playback speed multiplier (1 normal, 0 paused). */\n  speed = 1;\n\n  constructor(\n    private readonly clips: Record<Name, AnimationClip>,\n    initial: NoInfer<Name>,\n  ) {\n    const clip = clips[initial];\n    if (!clip) throw new Error(`Animator: no clip \"${initial}\"`);\n    if (clip.frames.length === 0) throw new Error(`Animator: clip \"${initial}\" has no frames`);\n    this.clip = clip;\n    this.name = initial;\n  }\n\n  /** The clip playing. */\n  get current(): Name {\n    return this.name;\n  }\n\n  /** The frame to show now. */\n  get frame(): string | number {\n    return this.clip.frames[this.index]!;\n  }\n\n  /** Which frame of the clip (0-based). */\n  get frameIndex(): number {\n    return this.index;\n  }\n\n  /** A non-looping clip has reached its last frame. */\n  get finished(): boolean {\n    return this.ended;\n  }\n\n  /** Plays `name`. The clip already playing keeps its place unless `restart`. */\n  play(name: Name, restart = false): this {\n    if (name === this.name && !restart) return this;\n    const clip = this.clips[name];\n    if (!clip) throw new Error(`Animator: no clip \"${name}\"`);\n    if (clip.frames.length === 0) throw new Error(`Animator: clip \"${name}\" has no frames`);\n    this.clip = clip;\n    this.name = name;\n    this.index = 0;\n    this.elapsed = 0;\n    this.ended = false;\n    return this;\n  }\n\n  /** Advances by `dt` seconds; returns true when the frame changed. */\n  update(dt: number): boolean {\n    if (this.ended || !(dt > 0) || this.speed <= 0) return false;\n    this.elapsed += dt * 1000 * this.speed;\n    const before = this.index;\n    const n = this.clip.frames.length;\n    for (let len = this.lengthOf(this.index); this.elapsed >= len; len = this.lengthOf(this.index)) {\n      this.elapsed -= len;\n      if (this.index < n - 1) {\n        this.index++;\n      } else if (this.clip.loop !== false) {\n        this.index = 0;\n      } else {\n        this.ended = true;\n        this.elapsed = 0;\n        this.onComplete?.(this.name);\n        break;\n      }\n    }\n    return this.index !== before;\n  }\n\n  private lengthOf(i: number): number {\n    const ms = this.clip.durations?.[i] ?? 1000 / (this.clip.fps ?? 10);\n    return Math.max(1, ms);\n  }\n}\n"],"names":["Animator","clips","initial","clip","name","restart","dt","before","n","len","i","ms"],"mappings":"AAyBO,MAAMA,EAAuC;AAAA,EAWlD,YACmBC,GACjBC,GACA;AAFiB,SAAA,QAAAD;AAGjB,UAAME,IAAOF,EAAMC,CAAO;AAC1B,QAAI,CAACC,EAAM,OAAM,IAAI,MAAM,sBAAsBD,CAAO,GAAG;AAC3D,QAAIC,EAAK,OAAO,WAAW,SAAS,IAAI,MAAM,mBAAmBD,CAAO,iBAAiB;AACzF,SAAK,OAAOC,GACZ,KAAK,OAAOD;AAAA,EACd;AAAA,EARmB;AAAA,EAXX;AAAA,EACA,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,QAAQ;AAAA,EACR;AAAA;AAAA,EAER,aAA4C;AAAA;AAAA,EAE5C,QAAQ;AAAA;AAAA,EAcR,IAAI,UAAgB;AAClB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,IAAI,QAAyB;AAC3B,WAAO,KAAK,KAAK,OAAO,KAAK,KAAK;AAAA,EACpC;AAAA;AAAA,EAGA,IAAI,aAAqB;AACvB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,IAAI,WAAoB;AACtB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,KAAKE,GAAYC,IAAU,IAAa;AACtC,QAAID,MAAS,KAAK,QAAQ,CAACC,EAAS,QAAO;AAC3C,UAAMF,IAAO,KAAK,MAAMC,CAAI;AAC5B,QAAI,CAACD,EAAM,OAAM,IAAI,MAAM,sBAAsBC,CAAI,GAAG;AACxD,QAAID,EAAK,OAAO,WAAW,SAAS,IAAI,MAAM,mBAAmBC,CAAI,iBAAiB;AACtF,gBAAK,OAAOD,GACZ,KAAK,OAAOC,GACZ,KAAK,QAAQ,GACb,KAAK,UAAU,GACf,KAAK,QAAQ,IACN;AAAA,EACT;AAAA;AAAA,EAGA,OAAOE,GAAqB;AAC1B,QAAI,KAAK,SAAS,EAAEA,IAAK,MAAM,KAAK,SAAS,EAAG,QAAO;AACvD,SAAK,WAAWA,IAAK,MAAO,KAAK;AACjC,UAAMC,IAAS,KAAK,OACdC,IAAI,KAAK,KAAK,OAAO;AAC3B,aAASC,IAAM,KAAK,SAAS,KAAK,KAAK,GAAG,KAAK,WAAWA,GAAKA,IAAM,KAAK,SAAS,KAAK,KAAK;AAE3F,UADA,KAAK,WAAWA,GACZ,KAAK,QAAQD,IAAI;AACnB,aAAK;AAAA,eACI,KAAK,KAAK,SAAS;AAC5B,aAAK,QAAQ;AAAA,WACR;AACL,aAAK,QAAQ,IACb,KAAK,UAAU,GACf,KAAK,aAAa,KAAK,IAAI;AAC3B;AAAA,MACF;AAEF,WAAO,KAAK,UAAUD;AAAA,EACxB;AAAA,EAEQ,SAASG,GAAmB;AAClC,UAAMC,IAAK,KAAK,KAAK,YAAYD,CAAC,KAAK,OAAQ,KAAK,KAAK,OAAO;AAChE,WAAO,KAAK,IAAI,GAAGC,CAAE;AAAA,EACvB;AACF;"}