1681-engine 0.0.0-stage → 0.5.8

package/dist/pixel/Darkness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Darkness.js","sources":["../../src/pixel/Darkness.ts"],"sourcesContent":["import { Container, RenderTexture, Sprite, Texture } from 'pixi.js';\nimport { TILE_SIZE } from '../net/constants';\nimport type { Stage } from '../core/Stage';\nimport { lightRadius, liveLights } from './lights';\nimport { isTouchUi } from '../platform/touch';\n\n/**\n * The dark underground, and the lights that are cut out of it.\n *\n * The obvious way to do this — a black sheet with glowing blobs added on top — is what makes a dungeon look\n * like it is standing in fog: adding light to black gives grey, so the floor inside the \"light\" is a washed-out\n * haze rather than lit stone. What reads as light is the opposite operation. The sheet of night and the lamps\n * are drawn into a texture of their own, the lamps **erasing** the night rather than adding to it, and that\n * texture is laid over the world. Inside a lamp there is simply no night left, so the art underneath shows at\n * its own colour; outside one there is nothing but black. That is the whole trick.\n *\n * It lives in screen space because the hole has to stay under the torch as the camera moves, and a texture the\n * size of the window is far cheaper than one the size of the map.\n */\n/** How often a flicker alone redraws the sheet (≈15 a second): a torch's wobble does not need 60. */\nconst FLICKER_MS = 66;\n/** The least time between two redraws on a phone (≈30 a second, what the phones run at by default). */\nconst PHONE_MS = 33;\n/** World pixels of night drawn past each edge of the window: room for a shake and for a phone's held redraw. */\nconst MARGIN = 8;\n\n/*\n * Lit the way pixel art lights a room: the night is drawn one texel to one **world** pixel, lined up\n * with the camera so its texels sit exactly on the art's pixels, and every light's falloff is a few levels of alpha\n * blended by an ordered (Bayer 4×4) dither in those world pixels — far off a stipple, close a solid fill — instead of\n * a smooth gradient laid over pixel art (which read as fog) or hard rings (which read as a target). A torch's\n * flicker is its radius stepping a whole pixel, not a sprite scaled by fractions.\n */\n\n/** How a light falls off with `d`, a share of its radius: a bright core and a long thinning tail. */\nconst holeAt = (d: number): number => Math.min(1, Math.pow(Math.max(0, 1 - d * d), 1.5) * 1.15);\n/** The colour a light lays on what it lights: strongest at the heart, gone well before its edge. */\nconst washAt = (d: number): number => Math.pow(Math.max(0, 1 - d), 2);\n/** Alpha levels the dither blends between: the hole's and the colour's. */\nconst HOLE_LEVELS = 4;\nconst WASH_LEVELS = 3;\n/** How strongly a light colours what it lights, before the night's own depth weighs it. */\nconst WASH_ALPHA = 0.3;\n/** A light's height over its width: the ground is seen at a slant, so a pool of light is an ellipse. */\nconst SQUASH = 0.85;\n/** A plain light's colour (a lamp nobody named one for, the light a body carries): warm, as flame is. */\nexport const WARM_LIGHT = 0xffc27a;\n\nconst BAYER = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5].map((v) => (v + 0.5) / 16);\n\n/**\n * Radii are painted at every second pixel up to 24 and every eighth above, so a shrinking flash reuses a few textures\n * (each new one is a canvas and an upload; one per pixel made the first flashes hitch).\n */\nconst bucket = (r: number): number => (r <= 24 ? Math.max(2, Math.round(r / 2) * 2) : Math.round(r / 8) * 8);\n/** Every bucket a light can take, painted ahead one per task (`warm`), so no flash pays for its texture. */\nconst BUCKETS = [...new Set(Array.from({ length: 160 }, (_, r) => bucket(r + 1)))];\n/** How often transient lights alone redraw the sheet (≈30 a second): a flash fading needs no more. */\nconst FLASH_MS = 33;\n\nconst textures = new Map<string, Texture>();\n\nlet warming = false;\n\n/** Paints every falloff ahead, one a task, so the first flashes find theirs made. */\nfunction warm(): void {\n  if (warming) return;\n  warming = true;\n  const todo = BUCKETS.flatMap((r) => [['hole', r], ['wash', r]] as const);\n  const next = () => {\n    const item = todo.shift();\n    if (!item) return;\n    falloff(item[0], item[1]);\n    setTimeout(next, 0);\n  };\n  setTimeout(next, 0);\n}\n\n/** One falloff at radius `r` world px, one texel a world pixel, dithered in place. */\nfunction falloff(kind: 'hole' | 'wash', r: number): Texture {\n  const key = `${kind}${r}`;\n  const cached = textures.get(key);\n  if (cached) return cached;\n  const w = r * 2;\n  const h = Math.max(2, Math.round(r * 2 * SQUASH));\n  const levels = kind === 'hole' ? HOLE_LEVELS : WASH_LEVELS;\n  const curve = kind === 'hole' ? holeAt : washAt;\n  const canvas = document.createElement('canvas');\n  canvas.width = w;\n  canvas.height = h;\n  // a browser out of canvas memory (iOS) gives no context: no light this time, and the next asks again\n  const ctx = canvas.getContext('2d');\n  if (!ctx) return Texture.EMPTY;\n  const img = ctx.createImageData(w, h);\n  for (let y = 0; y < h; y++)\n    for (let x = 0; x < w; x++) {\n      const d = Math.hypot((x + 0.5 - w / 2) / r, (y + 0.5 - h / 2) / (r * SQUASH));\n      if (d >= 1) continue;\n      const v = Math.min(levels, Math.floor(curve(d) * levels + BAYER[(y % 4) * 4 + (x % 4)]!)) / levels;\n      const i = (y * w + x) * 4;\n      img.data[i] = img.data[i + 1] = img.data[i + 2] = 255;\n      img.data[i + 3] = Math.round(v * 255);\n    }\n  ctx.putImageData(img, 0, 0);\n  const texture = Texture.from(canvas);\n  texture.source.scaleMode = 'nearest';\n  textures.set(key, texture);\n  return texture;\n}\n\n/** A light's two marks on the night: the hole it erases, and the colour it lays over what shows through. */\ninterface LightSprites {\n  hole: Sprite;\n  wash: Sprite;\n}\n\nexport class Darkness {\n  private readonly scratch = new Container();\n  private readonly sheet: Sprite;\n  /** Every hole is erased before any colour is laid, or a later hole would wipe an earlier light's colour away. */\n  private readonly holes = new Container();\n  private readonly washes = new Container();\n  private readonly lamps: { sprites: LightSprites; x: number; y: number; r: number; flicker: number }[] = [];\n  /** The transient lights (`lights.ts`), reused frame to frame. */\n  private readonly flashes: LightSprites[] = [];\n  private rt: RenderTexture;\n  /**\n   * On the screen layer, laid over the world with its exact transform by the camera (`Camera.follow`), shake included:\n   * the night is drawn in world pixels round the unshaken camera and only this layer moves with a shake, so a shaking\n   * screen does not redraw the night every frame.\n   */\n  private readonly layer = new Container();\n  private readonly view: Sprite;\n  /** The light the player carries: the only one that follows them, and the last one they lose. */\n  private readonly carried: LightSprites;\n  private readonly unsubscribeResize: () => void;\n  /** Lamps that flicker: while one does (or the player carries a light) every frame differs. */\n  private flickering = 0;\n  /** Something other than the camera changed what the night looks like (a lamp added, dimmed, the window resized). */\n  private dirty = true;\n  /** What the last drawn frame was drawn from: the texture, the camera's texel and the shade. */\n  private drawn = '';\n  /** The carried light's place at the last redraw (it follows the body). */\n  private carriedAt = '';\n  /** When the sheet was last redrawn. */\n  private drawnAt = -Infinity;\n  /** The world pixel the night's top-left texel stands on. */\n  private ox = 0;\n  private oy = 0;\n  /** The night texture's size in world pixels, and the zoom it was made for. */\n  private rtKey = '';\n  /** The lamps' colour turned down (`setLampsDimmed`). */\n  private dimLamps = false;\n  /** A phone redraws the night at most `PHONE_MS` apart, whatever moves (`isTouchUi`). */\n  private readonly phone = isTouchUi();\n\n  constructor(\n    private readonly stage: Stage,\n    private color: number,\n    private alpha: number,\n  ) {\n    // a flat sheet of night over the whole window: one white pixel, tinted and stretched\n    this.sheet = new Sprite({ texture: Texture.WHITE });\n    this.scratch.addChild(this.sheet, this.holes, this.washes);\n    this.carried = this.light(0xfff0dc);\n\n    this.rt = RenderTexture.create({ width: 1, height: 1 });\n    this.view = new Sprite({ texture: this.rt });\n    this.layer.addChild(this.view);\n    stage.screen.addChild(this.layer);\n    stage.cameras.main.follow(this.layer);\n    this.unsubscribeResize = stage.onResize(() => (this.dirty = true));\n    warm();\n  }\n\n  /** A hole and its colour, added to the night's layers. */\n  private light(color: number): LightSprites {\n    const hole = new Sprite({ texture: falloff('hole', 8) });\n    hole.blendMode = 'erase';\n    this.holes.addChild(hole);\n    const wash = new Sprite({ texture: falloff('wash', 8) });\n    wash.tint = color;\n    this.washes.addChild(wash);\n    return { hole, wash };\n  }\n\n  /** A lamp fixed in the world: a torch on a wall, the seep in its chamber, a crystal in a seam, in its own colour. */\n  addLamp(x: number, y: number, radius: number, flicker = 0, color = WARM_LIGHT): void {\n    this.lamps.push({ sprites: this.light(color), x, y, r: radius, flicker });\n    if (flicker) this.flickering++;\n    this.dirty = true;\n  }\n\n  /**\n   * Changes how dark and what colour the sheet is (the outdoor night, `NightShade`, deepens and lifts with the\n   * world clock). A sheet with no alpha left is neither drawn nor redrawn, so a map at noon pays nothing for its night.\n   */\n  setShade(color: number, alpha: number): void {\n    this.color = color;\n    this.alpha = alpha;\n    this.layer.visible = alpha > 0.004;\n  }\n\n  /**\n   * Dimmed lamps lay only `LAMP_DIM` of their colour on the dark (a \"fewer ambient lights\" setting). The holes they\n   * cut stay as wide, so a dark place is still seen by them.\n   */\n  setLampsDimmed(dim: boolean): void {\n    if (dim === this.dimLamps) return;\n    this.dimLamps = dim;\n    this.dirty = true;\n  }\n\n  /**\n   * The night's own texture, one texel a world pixel and `MARGIN` to spare on each side (a shake, or a camera that\n   * moved while a phone waits for its next redraw, never shows its edge), remade when the window or the zoom changes:\n   * at zoom 2 or 3 it is a quarter or a ninth of the screen's pixels. True when it was remade.\n   */\n  private fit(w: number, h: number, zoom: number): boolean {\n    const tw = Math.ceil(w / zoom) + MARGIN * 2;\n    const th = Math.ceil(h / zoom) + MARGIN * 2;\n    const key = `${tw},${th},${zoom}`;\n    if (key === this.rtKey) return false;\n    this.rtKey = key;\n    this.rt.destroy(true);\n    this.rt = RenderTexture.create({ width: tw, height: th });\n    this.rt.source.scaleMode = 'nearest';\n    this.view.texture = this.rt;\n    return true;\n  }\n\n  /** Redraws the night with this frame's holes in it, when anything in it changed. `px`/`py` is where the player stands. */\n  update(now: number, px: number, py: number, carriedRadius: number): void {\n    if (!this.layer.visible) return;\n    const cam = this.stage.cameras.main;\n    const zoom = cam.zoom || 1;\n    const remade = this.fit(this.stage.width, this.stage.height, zoom);\n    // the texel grid follows the camera (never its shake) in whole world pixels\n    const ox = Math.floor(cam.scrollX) - MARGIN;\n    const oy = Math.floor(cam.scrollY) - MARGIN;\n    const key = `${ox},${oy},${this.rtKey},${this.color},${this.alpha}`;\n    const lights = liveLights(now);\n    const carriedAt = carriedRadius > 0 ? `${Math.round(px)},${Math.round(py)},${Math.round(carriedRadius)}` : '';\n    // the light a body carries goes where it goes; a fight's flashes fade (`FLASH_MS`), torches wobble (`FLICKER_MS`)\n    const since = now - this.drawnAt;\n    const due =\n      this.dirty ||\n      key !== this.drawn ||\n      carriedAt !== this.carriedAt ||\n      (lights.length > 0 && since >= FLASH_MS) ||\n      ((carriedRadius > 0 || this.flickering > 0) && since >= FLICKER_MS);\n    if (!due) return;\n    // a phone holds every redraw `PHONE_MS` apart (redrawing the night at 60 a second runs it hot); the night stays\n    // pinned to the world meanwhile, and only a camera about to show the texture's edge cannot wait\n    const edge = Math.abs(ox - this.ox) >= MARGIN - 1 || Math.abs(oy - this.oy) >= MARGIN - 1;\n    if (this.phone && since < PHONE_MS && !remade && !edge) return;\n    this.dirty = false;\n    this.drawn = key;\n    this.carriedAt = carriedAt;\n    this.drawnAt = now;\n    this.ox = ox;\n    this.oy = oy;\n    this.view.position.set(ox, oy);\n    this.sheet.width = this.rt.width;\n    this.sheet.height = this.rt.height;\n    this.sheet.position.set(0, 0);\n    this.sheet.tint = this.color;\n    this.sheet.alpha = this.alpha;\n\n    // the colour a light lays shows as much as the night is deep: a dungeon's lamps colour their stone fully, a dusk\n    // street's only a little\n    const wash = WASH_ALPHA * Math.min(1, this.alpha * 1.4);\n    if (carriedRadius <= 0) this.hide(this.carried);\n    else this.place(this.carried, px, py - 6, carriedRadius * (1 + Math.sin(now / 260) * 0.03 + Math.sin(now / 90) * 0.015), wash * 0.5);\n    const lampWash = this.dimLamps ? wash * LAMP_DIM : wash;\n    for (const l of this.lamps) {\n      // torchlight is never still: each one wobbles on its own phase so a corridor of them does not pulse as one,\n      // and its colour breathes with it\n      const wobble = l.flicker ? 1 + Math.sin(now / 190 + l.flicker) * 0.05 + Math.sin(now / 71 + l.flicker) * 0.03 : 1;\n      this.place(l.sprites, l.x, l.y, l.r * wobble, lampWash * (l.flicker ? 0.9 + (wobble - 1) * 2 : 1));\n    }\n    while (this.flashes.length < lights.length) this.flashes.push(this.light(WARM_LIGHT));\n    for (let i = 0; i < this.flashes.length; i++) {\n      const l = lights[i];\n      const f = this.flashes[i]!;\n      if (!l) {\n        this.hide(f);\n        continue;\n      }\n      f.wash.tint = l.color;\n      // a flash colours what it lights more than a lamp does: it is the brightest thing in the room for its moment\n      this.place(f, l.x, l.y, lightRadius(l, now), Math.min(0.6, wash * 1.6));\n    }\n\n    this.stage.app.renderer.render({ container: this.scratch, target: this.rt, clear: true });\n  }\n\n  private hide(l: LightSprites): void {\n    l.hole.visible = false;\n    l.wash.visible = false;\n  }\n\n  /** Lays light `l` at world (wx, wy), `r` px across its radius, in the night's world-pixel grid. */\n  private place(l: LightSprites, wx: number, wy: number, r: number, wash: number): void {\n    const R = bucket(r);\n    const cx = Math.round(wx) - this.ox;\n    const cy = Math.round(wy) - this.oy;\n    // a light wholly off the texture cannot be seen, so it is not drawn\n    if (r < 1 || cx < -R || cy < -R || cx > this.rt.width + R || cy > this.rt.height + R) {\n      this.hide(l);\n      return;\n    }\n    l.hole.texture = falloff('hole', R);\n    l.wash.texture = falloff('wash', R);\n    for (const sprite of [l.hole, l.wash]) {\n      sprite.visible = true;\n      sprite.position.set(cx - R, cy - Math.round(R * SQUASH));\n    }\n    l.wash.alpha = wash;\n    l.wash.visible = wash > 0.01;\n  }\n\n  destroy(): void {\n    this.unsubscribeResize();\n    this.stage.cameras.main.unfollow(this.layer);\n    this.layer.destroy({ children: true });\n    this.rt.destroy(true);\n    this.scratch.destroy({ children: true, context: true });\n  }\n}\n\n/** What is left of a lamp's glow and colour while lamps are dimmed (`setLampsDimmed`). */\nexport const LAMP_DIM = 0.35;\n\n/** World units of light the player carries underground — about five tiles of certainty in any direction. */\nexport const CARRIED_LIGHT = TILE_SIZE * 5;\n"],"names":["FLICKER_MS","PHONE_MS","MARGIN","holeAt","d","washAt","HOLE_LEVELS","WASH_LEVELS","WASH_ALPHA","SQUASH","WARM_LIGHT","BAYER","v","bucket","r","BUCKETS","_","FLASH_MS","textures","warming","warm","todo","next","item","falloff","kind","key","cached","w","h","levels","curve","canvas","ctx","Texture","img","y","x","i","texture","Darkness","stage","color","alpha","Sprite","RenderTexture","Container","isTouchUi","hole","wash","radius","flicker","dim","zoom","tw","th","now","px","py","carriedRadius","cam","remade","ox","oy","lights","liveLights","carriedAt","since","edge","lampWash","LAMP_DIM","l","wobble","f","lightRadius","wx","wy","R","cx","cy","sprite","CARRIED_LIGHT","TILE_SIZE"],"mappings":"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"}

package/dist/pixel/DitherVignette.js

@@ -0,0 +1,57 @@
+import { Sprite as x, Texture as g } from "pixi.js";
+import { vignetteMask as M } from "./vignetteMask.js";
+const o = /* @__PURE__ */ new Map(), k = 12;
+function w(d, t, e = 1, h = 0.55) {
+  const i = Math.max(1, Math.ceil(d)), s = Math.max(1, Math.ceil(t)), m = `${i}x${s}|${e.toFixed(2)}|${h}`, l = o.get(m);
+  if (l) return l;
+  const r = document.createElement("canvas");
+  r.width = i, r.height = s;
+  const n = r.getContext("2d");
+  if (!n) return g.EMPTY;
+  const f = M(i, s, e, h), u = n.createImageData(i, s);
+  for (let a = 0; a < f.length; a++) f[a] && u.data.fill(255, a * 4, a * 4 + 4);
+  n.putImageData(u, 0, 0);
+  const c = g.from(r);
+  if (c.source.scaleMode = "nearest", o.size >= k) {
+    for (const a of o.values()) a.destroy(!0);
+    o.clear();
+  }
+  return o.set(m, c), c;
+}
+class y {
+  constructor(t, e = {}) {
+    this.stage = t, this.from = e.from ?? 0.55, this.edge.tint = e.color ?? 0, this.edge.visible = !1, t.screen.addChild(this.edge), this.making = setTimeout(() => {
+      this.making = null, this.make();
+    }, 0);
+  }
+  stage;
+  edge = new x();
+  madeFor = "";
+  making = null;
+  from;
+  setColor(t) {
+    this.edge.tint = t;
+  }
+  make() {
+    if (this.edge.destroyed) return;
+    const t = Math.max(1, this.stage.cameras.main.zoom), e = this.stage.width / t, h = this.stage.height / t, i = `${Math.ceil(e)}x${Math.ceil(h)}`;
+    if (i === this.madeFor) return;
+    const s = w(e, h, 1, this.from);
+    this.edge.texture = s, s !== g.EMPTY && (this.madeFor = i);
+  }
+  /** Shows the edge at `alpha` (0..1); call each frame it shows. */
+  show(t) {
+    this.edge.visible = t > 0, this.edge.visible && (this.make(), this.edge.alpha = t, this.edge.width = this.stage.width, this.edge.height = this.stage.height);
+  }
+  hide() {
+    this.edge.visible = !1;
+  }
+  destroy() {
+    this.making && clearTimeout(this.making), this.edge.destroy();
+  }
+}
+export {
+  y as DitherVignette,
+  w as ditherVignette
+};
+//# sourceMappingURL=DitherVignette.js.map

package/dist/pixel/DitherVignette.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DitherVignette.js","sources":["../../src/pixel/DitherVignette.ts"],"sourcesContent":["import { Sprite, Texture } from 'pixi.js';\nimport type { Stage } from '../core/Stage';\nimport { vignetteMask } from './vignetteMask';\n\nconst CACHE = new Map<string, Texture>();\n/** Each texture is a whole screen's worth of pixels: keep only a few sizes. */\nconst CACHE_MAX = 12;\n\n/**\n * A white dithered edge for a screen of `w`×`h` world pixels, one texel a world pixel and scaled up `'nearest'`;\n * the sprite that draws it tints it. Made once per size and strength. Returns `Texture.EMPTY` when the browser has\n * no canvas memory to spare (iOS), so the caller asks again later.\n */\nexport function ditherVignette(w: number, h: number, strength = 1, from = 0.55): Texture {\n  const tw = Math.max(1, Math.ceil(w));\n  const th = Math.max(1, Math.ceil(h));\n  const key = `${tw}x${th}|${strength.toFixed(2)}|${from}`;\n  const hit = CACHE.get(key);\n  if (hit) return hit;\n  const canvas = document.createElement('canvas');\n  canvas.width = tw;\n  canvas.height = th;\n  const ctx = canvas.getContext('2d');\n  if (!ctx) return Texture.EMPTY;\n  const mask = vignetteMask(tw, th, strength, from);\n  const img = ctx.createImageData(tw, th);\n  for (let i = 0; i < mask.length; i++) if (mask[i]) img.data.fill(255, i * 4, i * 4 + 4);\n  ctx.putImageData(img, 0, 0);\n  const texture = Texture.from(canvas);\n  texture.source.scaleMode = 'nearest';\n  if (CACHE.size >= CACHE_MAX) {\n    for (const t of CACHE.values()) t.destroy(true);\n    CACHE.clear();\n  }\n  CACHE.set(key, texture);\n  return texture;\n}\n\nexport interface DitherVignetteOptions {\n  /** The edge's colour (default black). */\n  color?: number;\n  /** How far from the centre toward a corner the edge begins, 0..1 (default 0.55). */\n  from?: number;\n}\n\n/**\n * A dithered pixel edge round the screen, on the screen layer: a darkened border, or tinted red and beaten with\n * `heartbeat` while a player is low on health. The texture is made at full strength, off the frame that first needs\n * it (a full-screen dither is a few ms on a phone), and remade only when the window or the zoom changes; `show`\n * changes how much of it shows.\n */\nexport class DitherVignette {\n  private readonly edge = new Sprite();\n  private madeFor = '';\n  private making: ReturnType<typeof setTimeout> | null = null;\n  private readonly from: number;\n\n  constructor(\n    private readonly stage: Stage,\n    options: DitherVignetteOptions = {},\n  ) {\n    this.from = options.from ?? 0.55;\n    this.edge.tint = options.color ?? 0x000000;\n    this.edge.visible = false;\n    stage.screen.addChild(this.edge);\n    this.making = setTimeout(() => {\n      this.making = null;\n      this.make();\n    }, 0);\n  }\n\n  setColor(color: number): void {\n    this.edge.tint = color;\n  }\n\n  private make(): void {\n    if (this.edge.destroyed) return;\n    const z = Math.max(1, this.stage.cameras.main.zoom);\n    const w = this.stage.width / z;\n    const h = this.stage.height / z;\n    const key = `${Math.ceil(w)}x${Math.ceil(h)}`;\n    if (key === this.madeFor) return;\n    const tex = ditherVignette(w, h, 1, this.from);\n    this.edge.texture = tex;\n    // an empty texture leaves the size unmarked, so the next call asks again\n    if (tex !== Texture.EMPTY) this.madeFor = key;\n  }\n\n  /** Shows the edge at `alpha` (0..1); call each frame it shows. */\n  show(alpha: number): void {\n    this.edge.visible = alpha > 0;\n    if (!this.edge.visible) return;\n    this.make();\n    this.edge.alpha = alpha;\n    this.edge.width = this.stage.width;\n    this.edge.height = this.stage.height;\n  }\n\n  hide(): void {\n    this.edge.visible = false;\n  }\n\n  destroy(): void {\n    if (this.making) clearTimeout(this.making);\n    this.edge.destroy();\n  }\n}\n"],"names":["CACHE","CACHE_MAX","ditherVignette","w","h","strength","from","tw","th","key","hit","canvas","ctx","Texture","mask","vignetteMask","img","i","texture","t","DitherVignette","stage","options","Sprite","color","z","tex","alpha"],"mappings":";;AAIA,MAAMA,wBAAY,IAAA,GAEZC,IAAY;AAOX,SAASC,EAAeC,GAAWC,GAAWC,IAAW,GAAGC,IAAO,MAAe;AACvF,QAAMC,IAAK,KAAK,IAAI,GAAG,KAAK,KAAKJ,CAAC,CAAC,GAC7BK,IAAK,KAAK,IAAI,GAAG,KAAK,KAAKJ,CAAC,CAAC,GAC7BK,IAAM,GAAGF,CAAE,IAAIC,CAAE,IAAIH,EAAS,QAAQ,CAAC,CAAC,IAAIC,CAAI,IAChDI,IAAMV,EAAM,IAAIS,CAAG;AACzB,MAAIC,EAAK,QAAOA;AAChB,QAAMC,IAAS,SAAS,cAAc,QAAQ;AAC9C,EAAAA,EAAO,QAAQJ,GACfI,EAAO,SAASH;AAChB,QAAMI,IAAMD,EAAO,WAAW,IAAI;AAClC,MAAI,CAACC,EAAK,QAAOC,EAAQ;AACzB,QAAMC,IAAOC,EAAaR,GAAIC,GAAIH,GAAUC,CAAI,GAC1CU,IAAMJ,EAAI,gBAAgBL,GAAIC,CAAE;AACtC,WAASS,IAAI,GAAGA,IAAIH,EAAK,QAAQG,KAASH,EAAKG,CAAC,KAAGD,EAAI,KAAK,KAAK,KAAKC,IAAI,GAAGA,IAAI,IAAI,CAAC;AACtF,EAAAL,EAAI,aAAaI,GAAK,GAAG,CAAC;AAC1B,QAAME,IAAUL,EAAQ,KAAKF,CAAM;AAEnC,MADAO,EAAQ,OAAO,YAAY,WACvBlB,EAAM,QAAQC,GAAW;AAC3B,eAAWkB,KAAKnB,EAAM,OAAA,EAAU,CAAAmB,EAAE,QAAQ,EAAI;AAC9C,IAAAnB,EAAM,MAAA;AAAA,EACR;AACA,SAAAA,EAAM,IAAIS,GAAKS,CAAO,GACfA;AACT;AAeO,MAAME,EAAe;AAAA,EAM1B,YACmBC,GACjBC,IAAiC,IACjC;AAFiB,SAAA,QAAAD,GAGjB,KAAK,OAAOC,EAAQ,QAAQ,MAC5B,KAAK,KAAK,OAAOA,EAAQ,SAAS,GAClC,KAAK,KAAK,UAAU,IACpBD,EAAM,OAAO,SAAS,KAAK,IAAI,GAC/B,KAAK,SAAS,WAAW,MAAM;AAC7B,WAAK,SAAS,MACd,KAAK,KAAA;AAAA,IACP,GAAG,CAAC;AAAA,EACN;AAAA,EAXmB;AAAA,EANF,OAAO,IAAIE,EAAA;AAAA,EACpB,UAAU;AAAA,EACV,SAA+C;AAAA,EACtC;AAAA,EAgBjB,SAASC,GAAqB;AAC5B,SAAK,KAAK,OAAOA;AAAA,EACnB;AAAA,EAEQ,OAAa;AACnB,QAAI,KAAK,KAAK,UAAW;AACzB,UAAMC,IAAI,KAAK,IAAI,GAAG,KAAK,MAAM,QAAQ,KAAK,IAAI,GAC5CtB,IAAI,KAAK,MAAM,QAAQsB,GACvB,IAAI,KAAK,MAAM,SAASA,GACxBhB,IAAM,GAAG,KAAK,KAAKN,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC;AAC3C,QAAIM,MAAQ,KAAK,QAAS;AAC1B,UAAMiB,IAAMxB,EAAeC,GAAG,GAAG,GAAG,KAAK,IAAI;AAC7C,SAAK,KAAK,UAAUuB,GAEhBA,MAAQb,EAAQ,UAAO,KAAK,UAAUJ;AAAA,EAC5C;AAAA;AAAA,EAGA,KAAKkB,GAAqB;AAExB,IADA,KAAK,KAAK,UAAUA,IAAQ,GACvB,KAAK,KAAK,YACf,KAAK,KAAA,GACL,KAAK,KAAK,QAAQA,GAClB,KAAK,KAAK,QAAQ,KAAK,MAAM,OAC7B,KAAK,KAAK,SAAS,KAAK,MAAM;AAAA,EAChC;AAAA,EAEA,OAAa;AACX,SAAK,KAAK,UAAU;AAAA,EACtB;AAAA,EAEA,UAAgB;AACd,IAAI,KAAK,UAAQ,aAAa,KAAK,MAAM,GACzC,KAAK,KAAK,QAAA;AAAA,EACZ;AACF;"}

package/dist/pixel/Evaporation.js

@@ -0,0 +1,85 @@
+import { addPixelLayer as E } from "./PixelLayer.js";
+import { engineSettings as P } from "../settings.js";
+import { ramp as I } from "./pixelTone.js";
+const A = 1e3 / 12, _ = 1400, B = 150, D = 420, R = 16, p = { budget: 500, body: 60, big: 160 };
+class G {
+  constructor(t, r) {
+    this.scene = t, this.track = r;
+  }
+  scene;
+  track;
+  clouds = [];
+  live = 0;
+  play(t, r, n) {
+    const m = P.getState(), c = m.reducedFx || m.batterySaver, f = Math.min(t.pixels.length, r ? c ? p.big : D : c ? p.body : B), e = Math.min(f, Math.max(R, (c ? p.budget : _) - this.live));
+    if (e <= 0) return;
+    const y = Math.max(1, Math.round(Math.abs(t.scaleY))), M = E(this.scene);
+    this.track(M);
+    const a = {
+      g: M,
+      x: Math.round(t.x),
+      y: Math.round(t.y),
+      born: n,
+      end: n,
+      size: y,
+      n: e,
+      frame: -1,
+      x0: new Float32Array(e),
+      y0: new Float32Array(e),
+      delay: new Float32Array(e),
+      life: new Float32Array(e),
+      vx: new Float32Array(e),
+      vy: new Float32Array(e),
+      phase: new Float32Array(e),
+      color: new Uint32Array(e)
+    };
+    let h = 0, d = -1 / 0, i = 1;
+    const o = t.pixels;
+    for (let l = 0; l < o.length; l++)
+      h = Math.min(h, o.dy[l]), d = Math.max(d, o.dy[l]), i = Math.max(i, Math.abs(o.dx[l] * t.scaleX));
+    const x = Math.max(1, d - h), u = r ? 520 : 260, F = r ? 900 : 620, g = e / o.length;
+    let s = 0;
+    for (let l = 0; l < o.length && s < e; l++) {
+      if (g < 1 && Math.random() > g && o.length - l > e - s) continue;
+      const v = o.dy[l], b = o.dx[l] * t.scaleX, k = v * Math.abs(t.scaleY), w = (v - h) / x;
+      a.x0[s] = b, a.y0[s] = k, a.delay[s] = w * u * 0.6 + Math.random() * u * 0.4, a.life[s] = F * (0.6 + Math.random() * 0.6), a.vx[s] = b / i * 5 + (Math.random() - 0.5) * 10, a.vy[s] = -(10 + Math.random() * 16) * (r ? 1.3 : 1), a.phase[s] = Math.random() * Math.PI * 2, a.color[s] = o.color[l], a.end = Math.max(a.end, n + a.delay[s] + a.life[s]), s++;
+    }
+    a.n = s, this.live += a.n, this.clouds.push(a), this.draw(a, n);
+  }
+  update(t) {
+    for (let r = this.clouds.length - 1; r >= 0; r--) {
+      const n = this.clouds[r];
+      if (!n.g.active || t >= n.end) {
+        n.g.active && n.g.destroy(), this.live -= n.n, this.clouds.splice(r, 1);
+        continue;
+      }
+      this.draw(n, t);
+    }
+  }
+  draw(t, r) {
+    const n = Math.floor((r - t.born) / A);
+    if (n === t.frame) return;
+    t.frame = n;
+    const m = n * A, c = t.g;
+    c.clear(), c.setPosition(t.x, t.y).setDepth(t.y + 2);
+    const f = t.size;
+    for (let e = 0; e < t.n; e++) {
+      const y = m - t.delay[e];
+      let M = t.x0[e], a = t.y0[e], h = t.color[e], d = 1;
+      if (y > 0) {
+        const i = y / t.life[e];
+        if (i >= 1) continue;
+        const o = y / 1e3;
+        M += t.vx[e] * o + Math.sin(t.phase[e] + o * 9) * i * 1.5, a += t.vy[e] * o - 22 * o * o;
+        const x = I(h);
+        h = i < 0.3 ? h : i < 0.6 ? x.light : x.hi, d = i < 0.55 ? 1 : i < 0.8 ? 0.66 : 0.33;
+      }
+      c.rect(Math.round(M), Math.round(a), f, f, h, d);
+    }
+    c.present();
+  }
+}
+export {
+  G as Evaporation
+};
+//# sourceMappingURL=Evaporation.js.map

package/dist/pixel/Evaporation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Evaporation.js","sources":["../../src/pixel/Evaporation.ts"],"sourcesContent":["import { addPixelLayer, type PixelLayer } from './PixelLayer';\nimport type { Stage } from '../core/Stage';\nimport { engineSettings } from '../settings';\nimport type { WorldObject } from '../core/types';\nimport { ramp } from './pixelTone';\nimport type { PackedPixels } from './spritePixels';\n\n/** What a dying body hands over: its feet in the world, how it was drawn, and the pixels of its last frame. */\nexport interface DeathPixels {\n  x: number;\n  y: number;\n  /** World pixels per sprite pixel (the body's `scale`), negative when the body faced left. */\n  scaleX: number;\n  scaleY: number;\n  pixels: PackedPixels;\n}\n\nconst FRAME_MS = 1000 / 12;\n/** Pixels in flight across every cloud at once: a crowd dying together shares this, it never adds to it. */\nconst BUDGET = 1400;\nconst PER_BODY = 150;\nconst PER_BIG = 420;\n/** Even a body dying into a full budget leaves a few of its pixels, or it would just blink out. */\nconst MIN_PER_BODY = 16;\n/** The same three under reduced effects or the battery saver. */\nconst THIN = { budget: 500, body: 60, big: 160 };\n\ninterface Cloud {\n  g: PixelLayer;\n  x: number;\n  y: number;\n  born: number;\n  end: number;\n  size: number;\n  n: number;\n  /** Per particle: start offset, release delay, lifetime, drift speed, wobble phase. */\n  x0: Float32Array;\n  y0: Float32Array;\n  delay: Float32Array;\n  life: Float32Array;\n  vx: Float32Array;\n  vy: Float32Array;\n  phase: Float32Array;\n  color: Uint32Array;\n  frame: number;\n}\n\n/**\n * A dead body evaporating: it breaks into its own pixels, which let go top rows first, rise, scatter a little and\n * give out, while the body itself is hidden by the caller. Every particle is one whole world pixel in a colour read\n * off the body's last frame, painted at 12 fps like every other effect; it pales up its own ramp as it rises and\n * steps its alpha down instead of melting, so it stays pixel art the whole way. A cloud is one `PixelLayer` (a pooled\n * texture) rather than a Graphics of up to 1,400 rects.\n */\nexport class Evaporation {\n  private readonly clouds: Cloud[] = [];\n  private live = 0;\n\n  constructor(\n    private readonly scene: Stage,\n    private readonly track: (object: WorldObject) => void,\n  ) {}\n\n  play(d: DeathPixels, big: boolean, now: number): void {\n    const s = engineSettings.getState();\n    const thin = s.reducedFx || s.batterySaver;\n    const want = Math.min(d.pixels.length, big ? (thin ? THIN.big : PER_BIG) : thin ? THIN.body : PER_BODY);\n    const n = Math.min(want, Math.max(MIN_PER_BODY, (thin ? THIN.budget : BUDGET) - this.live));\n    if (n <= 0) return;\n    const size = Math.max(1, Math.round(Math.abs(d.scaleY)));\n    const g = addPixelLayer(this.scene);\n    this.track(g);\n    const c: Cloud = {\n      g, x: Math.round(d.x), y: Math.round(d.y), born: now, end: now, size, n, frame: -1,\n      x0: new Float32Array(n), y0: new Float32Array(n), delay: new Float32Array(n), life: new Float32Array(n),\n      vx: new Float32Array(n), vy: new Float32Array(n), phase: new Float32Array(n), color: new Uint32Array(n),\n    };\n    let top = 0;\n    let bottom = -Infinity;\n    let halfW = 1;\n    const px = d.pixels;\n    for (let k = 0; k < px.length; k++) {\n      top = Math.min(top, px.dy[k]!);\n      bottom = Math.max(bottom, px.dy[k]!);\n      halfW = Math.max(halfW, Math.abs(px.dx[k]! * d.scaleX));\n    }\n    const height = Math.max(1, bottom - top);\n    const spread = big ? 520 : 260;\n    const lifeMs = big ? 900 : 620;\n    // a random subset when the body has more pixels than its share; every pixel otherwise\n    const keep = n / px.length;\n    let i = 0;\n    for (let k = 0; k < px.length && i < n; k++) {\n      if (keep < 1 && Math.random() > keep && px.length - k > n - i) continue;\n      const pdy = px.dy[k]!;\n      const x = px.dx[k]! * d.scaleX;\n      const y = pdy * Math.abs(d.scaleY);\n      const fromTop = (pdy - top) / height;\n      c.x0[i] = x;\n      c.y0[i] = y;\n      // the top lets go first and the feet last, so the body dissolves upwards\n      c.delay[i] = fromTop * spread * 0.6 + Math.random() * spread * 0.4;\n      c.life[i] = lifeMs * (0.6 + Math.random() * 0.6);\n      c.vx[i] = (x / halfW) * 5 + (Math.random() - 0.5) * 10;\n      c.vy[i] = -(10 + Math.random() * 16) * (big ? 1.3 : 1);\n      c.phase[i] = Math.random() * Math.PI * 2;\n      c.color[i] = px.color[k]!;\n      c.end = Math.max(c.end, now + c.delay[i]! + c.life[i]!);\n      i++;\n    }\n    c.n = i;\n    this.live += c.n;\n    this.clouds.push(c);\n    this.draw(c, now);\n  }\n\n  update(now: number): void {\n    for (let k = this.clouds.length - 1; k >= 0; k--) {\n      const c = this.clouds[k]!;\n      if (!c.g.active || now >= c.end) {\n        if (c.g.active) c.g.destroy();\n        this.live -= c.n;\n        this.clouds.splice(k, 1);\n        continue;\n      }\n      this.draw(c, now);\n    }\n  }\n\n  private draw(c: Cloud, now: number): void {\n    const frame = Math.floor((now - c.born) / FRAME_MS);\n    if (frame === c.frame) return;\n    c.frame = frame;\n    const ms = frame * FRAME_MS;\n    const g = c.g;\n    g.clear();\n    g.setPosition(c.x, c.y).setDepth(c.y + 2);\n    const s = c.size;\n    for (let i = 0; i < c.n; i++) {\n      const t = ms - c.delay[i]!;\n      let x = c.x0[i]!;\n      let y = c.y0[i]!;\n      let color = c.color[i]!;\n      let alpha = 1;\n      if (t > 0) {\n        const k = t / c.life[i]!;\n        if (k >= 1) continue;\n        const sec = t / 1000;\n        // rises faster as it goes, and sways as it rises\n        x += c.vx[i]! * sec + Math.sin(c.phase[i]! + sec * 9) * k * 1.5;\n        y += c.vy[i]! * sec - 22 * sec * sec;\n        const r = ramp(color);\n        color = k < 0.3 ? color : k < 0.6 ? r.light : r.hi;\n        alpha = k < 0.55 ? 1 : k < 0.8 ? 0.66 : 0.33;\n      }\n      g.rect(Math.round(x), Math.round(y), s, s, color, alpha);\n    }\n    g.present();\n  }\n}\n"],"names":["FRAME_MS","BUDGET","PER_BODY","PER_BIG","MIN_PER_BODY","THIN","Evaporation","scene","track","d","big","now","s","engineSettings","thin","want","n","size","g","addPixelLayer","c","top","bottom","halfW","px","k","height","spread","lifeMs","keep","i","pdy","x","y","fromTop","frame","ms","t","color","alpha","sec","r","ramp"],"mappings":"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"}

package/dist/pixel/NightShade.js

@@ -0,0 +1,34 @@
+import { tintNight as e } from "../ambient/DayClock.js";
+import { Darkness as h } from "./Darkness.js";
+class p {
+  constructor(a, t) {
+    this.options = t, this.dark = new h(a, 0, 0), this.dark.setShade(0, 0), this.lampScale = t.lampScale ?? 1.6, this.carried = t.carriedLight ?? 64, this.carriedFrom = Math.min(0.99, t.carriedFrom ?? 0.55);
+  }
+  options;
+  dark;
+  lampScale;
+  carried;
+  carriedFrom;
+  /** A light the place glows with, `glowSize` the diameter of the glow drawn for it: by night it is what is seen by. */
+  addLight(a, t, r, s, i = 0) {
+    this.dark.addLamp(a, t, r / 2 * this.lampScale, i, s);
+  }
+  /** Lamps colour the dark less (a "fewer ambient lights" setting); their holes stay as wide. */
+  setLampsDimmed(a) {
+    this.dark.setLampsDimmed(a);
+  }
+  /** `now` the frame's ms, `wallMs` the shared wall time the clock reads (`serverNow()`), `px`/`py` the player. */
+  update(a, t, r, s) {
+    const i = this.options.clock.at(t);
+    this.dark.setShade(e(i, this.options.tint, this.options.tintShare), i.alpha);
+    const d = this.carriedFrom;
+    this.dark.update(a, r, s, Math.max(0, (i.night - d) / (1 - d)) * this.carried);
+  }
+  destroy() {
+    this.dark.destroy();
+  }
+}
+export {
+  p as NightShade
+};
+//# sourceMappingURL=NightShade.js.map

package/dist/pixel/NightShade.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NightShade.js","sources":["../../src/pixel/NightShade.ts"],"sourcesContent":["import type { Stage } from '../core/Stage';\nimport { tintNight, type DayClock } from '../ambient/DayClock';\nimport { Darkness } from './Darkness';\n\nexport interface NightShadeOptions {\n  /** The day the night follows. */\n  clock: DayClock;\n  /** This place's own night colour, pulled in as the night deepens (`tintNight`); none keeps the clock's. */\n  tint?: number;\n  /** How far the tint takes over at full night (default 0.6). */\n  tintShare?: number;\n  /** A lamp's hole in the night against the glow it is drawn with (default 1.6: the light reaches past the glow). */\n  lampScale?: number;\n  /** The radius (world px) of the light a body carries at full night; 0 for none (default 64). */\n  carriedLight?: number;\n  /** The night share below which nothing is carried (default 0.55): at dusk a hole round the feet reads as a spotlight. */\n  carriedFrom?: number;\n}\n\n/**\n * The outdoor night: a `DayClock`'s grade laid over the world as a dithered `Darkness`, deepening at dusk and lifting\n * at dawn, with every lamp, window and fire burning a hole in it — the same erase trick an underground is lit by,\n * only with a sheet whose colour and depth follow the clock. A place under no sky (a cave) builds a `Darkness` of its\n * own instead; at noon the sheet has no alpha and costs nothing.\n */\nexport class NightShade {\n  private readonly dark: Darkness;\n  private readonly lampScale: number;\n  private readonly carried: number;\n  private readonly carriedFrom: number;\n\n  constructor(\n    stage: Stage,\n    private readonly options: NightShadeOptions,\n  ) {\n    this.dark = new Darkness(stage, 0x000000, 0);\n    this.dark.setShade(0, 0);\n    this.lampScale = options.lampScale ?? 1.6;\n    this.carried = options.carriedLight ?? 64;\n    this.carriedFrom = Math.min(0.99, options.carriedFrom ?? 0.55);\n  }\n\n  /** A light the place glows with, `glowSize` the diameter of the glow drawn for it: by night it is what is seen by. */\n  addLight(x: number, y: number, glowSize: number, color?: number, flicker = 0): void {\n    this.dark.addLamp(x, y, (glowSize / 2) * this.lampScale, flicker, color);\n  }\n\n  /** Lamps colour the dark less (a \"fewer ambient lights\" setting); their holes stay as wide. */\n  setLampsDimmed(dim: boolean): void {\n    this.dark.setLampsDimmed(dim);\n  }\n\n  /** `now` the frame's ms, `wallMs` the shared wall time the clock reads (`serverNow()`), `px`/`py` the player. */\n  update(now: number, wallMs: number, px: number, py: number): void {\n    const day = this.options.clock.at(wallMs);\n    this.dark.setShade(tintNight(day, this.options.tint, this.options.tintShare), day.alpha);\n    const from = this.carriedFrom;\n    this.dark.update(now, px, py, Math.max(0, (day.night - from) / (1 - from)) * this.carried);\n  }\n\n  destroy(): void {\n    this.dark.destroy();\n  }\n}\n"],"names":["NightShade","stage","options","Darkness","x","y","glowSize","color","flicker","dim","now","wallMs","px","py","day","tintNight","from"],"mappings":";;AAyBO,MAAMA,EAAW;AAAA,EAMtB,YACEC,GACiBC,GACjB;AADiB,SAAA,UAAAA,GAEjB,KAAK,OAAO,IAAIC,EAASF,GAAO,GAAU,CAAC,GAC3C,KAAK,KAAK,SAAS,GAAG,CAAC,GACvB,KAAK,YAAYC,EAAQ,aAAa,KACtC,KAAK,UAAUA,EAAQ,gBAAgB,IACvC,KAAK,cAAc,KAAK,IAAI,MAAMA,EAAQ,eAAe,IAAI;AAAA,EAC/D;AAAA,EAPmB;AAAA,EAPF;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAcjB,SAASE,GAAWC,GAAWC,GAAkBC,GAAgBC,IAAU,GAAS;AAClF,SAAK,KAAK,QAAQJ,GAAGC,GAAIC,IAAW,IAAK,KAAK,WAAWE,GAASD,CAAK;AAAA,EACzE;AAAA;AAAA,EAGA,eAAeE,GAAoB;AACjC,SAAK,KAAK,eAAeA,CAAG;AAAA,EAC9B;AAAA;AAAA,EAGA,OAAOC,GAAaC,GAAgBC,GAAYC,GAAkB;AAChE,UAAMC,IAAM,KAAK,QAAQ,MAAM,GAAGH,CAAM;AACxC,SAAK,KAAK,SAASI,EAAUD,GAAK,KAAK,QAAQ,MAAM,KAAK,QAAQ,SAAS,GAAGA,EAAI,KAAK;AACvF,UAAME,IAAO,KAAK;AAClB,SAAK,KAAK,OAAON,GAAKE,GAAIC,GAAI,KAAK,IAAI,IAAIC,EAAI,QAAQE,MAAS,IAAIA,EAAK,IAAI,KAAK,OAAO;AAAA,EAC3F;AAAA,EAEA,UAAgB;AACd,SAAK,KAAK,QAAA;AAAA,EACZ;AACF;"}

package/dist/pixel/PixelLayer.js

@@ -0,0 +1,211 @@
+import { Sprite as R, Texture as Y, BufferImageSource as B } from "pixi.js";
+import { Graphics as C } from "../core/Graphics.js";
+import { patchPixi as D } from "../core/pixiPatches.js";
+D();
+const W = 1024, U = [16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024], G = 24, K = 24 * 1024 * 1024, j = 60, m = /* @__PURE__ */ new Map();
+let S = 0, E = 0;
+const L = (n) => {
+  for (const t of U) if (t >= n) return t;
+  return Math.ceil(n / 256) * 256;
+}, F = (n, t) => n * 4096 + t;
+function q(n, t) {
+  let i = m.get(F(n, t));
+  if (!i?.length) {
+    let o = 1 / 0;
+    for (const [c, a] of m) {
+      if (!a.length) continue;
+      const p = Math.floor(c / 4096), f = c % 4096, g = p * f;
+      p >= n && f >= t && g <= n * t * 2 && g < o && (o = g, i = a);
+    }
+  }
+  const s = i?.pop();
+  if (s)
+    return S -= s.pixels.byteLength, s;
+  E++;
+  const e = new Uint8Array(n * t * 4), l = new B({
+    resource: e,
+    width: n,
+    height: t,
+    format: "rgba8unorm",
+    alphaMode: "premultiplied-alpha",
+    scaleMode: "nearest"
+  });
+  return { pixels: e, words: new Uint32Array(e.buffer), source: l, texture: new Y({ source: l }), capW: n, capH: t };
+}
+function z(n) {
+  const t = F(n.capW, n.capH);
+  let i = m.get(t);
+  if (i || m.set(t, i = []), i.length >= G || S + n.pixels.byteLength > K) {
+    n.texture.destroy(!0);
+    return;
+  }
+  i.push(n), S += n.pixels.byteLength;
+}
+function $(n) {
+  return n.add.existing(new J());
+}
+class J extends C {
+  /** This frame's rects: x, y, w, h, colour, alpha — six numbers each. */
+  rects = [];
+  /** Staged solid runs not yet committed: x, y, w, colour — four numbers each; later ones win. */
+  staged = [];
+  ink = 16777215;
+  inkAlpha = 1;
+  sprite = new R(Y.EMPTY);
+  surface = null;
+  /** Where the buffer's first pixel sits in the layer, as of the last `present`. */
+  originX = 0;
+  originY = 0;
+  /** The last frame's size, and how many presents in a row it stayed well inside a quarter of the buffer. */
+  lastW = 0;
+  lastH = 0;
+  small = 0;
+  constructor() {
+    super(), this.sprite.visible = !1, this.addChild(this.sprite);
+  }
+  /** Textures made, spent buffers waiting in the pool and their bytes (the leak tools read it). */
+  static stats() {
+    let t = 0;
+    for (const i of m.values()) t += i.length;
+    return { made: E, pooled: t, pooledBytes: S };
+  }
+  /** Lets every pooled buffer go (the world changed map): the next map's effects start a pool of their own. */
+  static drainPool() {
+    for (const t of m.values()) for (const i of t) i.texture.destroy(!0);
+    m.clear(), S = 0;
+  }
+  fillStyle(t, i = 1) {
+    return this.ink = t, this.inkAlpha = i, super.fillStyle(t, i);
+  }
+  fillRect(t, i, s, e) {
+    const l = Math.round(t), o = Math.round(i), c = Math.round(t + s) - l, a = Math.round(i + e) - o;
+    return c > 0 && a > 0 && this.inkAlpha > 0 && this.rects.push(l, o, c, a, this.ink, this.inkAlpha), this;
+  }
+  /** `fillStyle` + `fillRect` on whole pixels in one call, leaving the fill style alone (a hot loop's way in). */
+  rect(t, i, s, e, l, o = 1) {
+    s > 0 && e > 0 && o > 0 && Number.isFinite(t) && Number.isFinite(i) && Number.isFinite(s) && Number.isFinite(e) && this.rects.push(t, i, s, e, l, o);
+  }
+  /**
+   * A solid run of `w` whole pixels at (x, y) in `color`, held until `commit` lays every staged run in the order given
+   * (the later winning where they cross), after whatever was drawn before the commit. What `pixelTone`'s batch writes
+   * instead of filing each pixel in a map and sorting it into rects.
+   */
+  stage(t, i, s, e) {
+    Number.isFinite(t) && Number.isFinite(i) && Number.isFinite(s) && this.staged.push(t, i, s, e);
+  }
+  /** Lays the staged runs, as opaque rects, after everything drawn so far. */
+  commit() {
+    const t = this.staged, i = t.length;
+    if (i === 0) return;
+    const s = this.rects;
+    for (let e = 0; e < i; e += 4) s.push(t[e], t[e + 1], t[e + 2], 1, t[e + 3], 1);
+    t.length = 0;
+  }
+  clear() {
+    return this.rects.length = 0, this.staged.length = 0, super.clear();
+  }
+  /** How far the last frame reached from the layer's origin, in world pixels (0 when nothing showed). */
+  reach() {
+    return this.sprite.visible ? Math.max(Math.abs(this.originX), Math.abs(this.originY), Math.abs(this.originX + this.lastW), Math.abs(this.originY + this.lastH)) : 0;
+  }
+  /** Writes this frame's rects into the texture and shows it; call once the frame is painted. */
+  present() {
+    this.commit();
+    const t = this.rects;
+    if (t.length === 0) {
+      this.sprite.visible = !1;
+      return;
+    }
+    let i = 1 / 0, s = 1 / 0, e = -1 / 0, l = -1 / 0;
+    for (let r = 0; r < t.length; r += 6)
+      t[r] < i && (i = t[r]), t[r + 1] < s && (s = t[r + 1]), t[r] + t[r + 2] > e && (e = t[r] + t[r + 2]), t[r + 1] + t[r + 3] > l && (l = t[r + 1] + t[r + 3]);
+    const o = e - i, c = l - s;
+    if (o > W || c > W) {
+      this.sprite.visible = !1;
+      const r = t.length;
+      for (let u = 0; u < r; u += 6)
+        super.fillStyle(t[u + 4], t[u + 5]), super.fillRect(t[u], t[u + 1], t[u + 2], t[u + 3]);
+      return;
+    }
+    const a = this.fit(o, c), { words: p, pixels: f, capW: g } = a;
+    p.fill(0);
+    for (let r = 0; r < t.length; r += 6) {
+      const u = t[r] - i, y = t[r + 1] - s, M = t[r + 2], v = t[r + 3], P = t[r + 4], x = t[r + 5], k = P >> 16 & 255, A = P >> 8 & 255, H = P & 255;
+      if (x >= 1) {
+        const d = (4278190080 | H << 16 | A << 8 | k) >>> 0;
+        if (M === 1 && v === 1) {
+          p[y * g + u] = d;
+          continue;
+        }
+        for (let h = y; h < y + v; h++) {
+          const b = h * g + u;
+          if (M < 8) for (let X = b, _ = b + M; X < _; X++) p[X] = d;
+          else p.fill(d, b, b + M);
+        }
+        continue;
+      }
+      const w = 1 - x, I = k * x, N = A * x, O = H * x, T = 255 * x;
+      for (let d = y; d < y + v; d++)
+        for (let h = (d * g + u) * 4, b = h + M * 4; h < b; h += 4)
+          f[h] = I + f[h] * w, f[h + 1] = N + f[h + 1] * w, f[h + 2] = O + f[h + 2] * w, f[h + 3] = T + f[h + 3] * w;
+    }
+    a.source.update(), this.sprite.texture = a.texture, this.sprite.position.set(i, s), this.sprite.visible = !0, this.originX = i, this.originY = s, this.lastW = o, this.lastH = c;
+  }
+  /**
+   * Shows `other`'s last frame instead of painting one: its texture, placed where it placed it. A frame shared by
+   * several bodies (the same aura on two bodies) is painted once and shown by each of their layers.
+   */
+  mirror(t) {
+    const i = t.surface;
+    if (!i || !t.sprite.visible) {
+      this.hideMirror();
+      return;
+    }
+    this.sprite.texture = i.texture, this.sprite.position.set(t.originX, t.originY), this.sprite.visible = !0, this.originX = t.originX, this.originY = t.originY, this.lastW = t.lastW, this.lastH = t.lastH;
+  }
+  /** Shows nothing and lets go of the texture a `mirror` showed. */
+  hideMirror() {
+    this.sprite.visible = !1, this.sprite.texture = this.surface?.texture ?? Y.EMPTY;
+  }
+  /** The premultiplied [r, g, b, a] last presented at layer pixel (x, y); zeros where nothing was (tests read it). */
+  pixelAt(t, i) {
+    const s = this.surface, e = s?.capW ?? 0, l = s?.capH ?? 0;
+    if (this.sprite.width !== e || this.sprite.height !== l) throw new Error("PixelLayer sprite is scaled");
+    const o = t - this.originX, c = i - this.originY;
+    if (!s || !this.sprite.visible || o < 0 || c < 0 || o >= e || c >= l) return [0, 0, 0, 0];
+    const a = (c * e + o) * 4;
+    return [s.pixels[a], s.pixels[a + 1], s.pixels[a + 2], s.pixels[a + 3]];
+  }
+  /** The buffer's size (tests read it). */
+  capacity() {
+    return { w: this.surface?.capW ?? 0, h: this.surface?.capH ?? 0 };
+  }
+  /**
+   * A buffer at least `w` × `h`: grown a size class at a time and kept while it fits, traded back to the pool for a
+   * smaller one only once the frames have stayed well inside it for `SHRINK_AFTER` presents (a long-lived layer — an
+   * aura, a status mark — that once swelled would otherwise hold and upload its largest buffer for good).
+   */
+  fit(t, i) {
+    const s = this.surface;
+    if (s && t <= s.capW && i <= s.capH) {
+      const a = s.capW * s.capH >= 16384 && t * 4 <= s.capW && i * 4 <= s.capH;
+      if (this.small = a ? this.small + 1 : 0, this.small < j) return s;
+    }
+    this.small = 0;
+    const e = !!s && (t > s.capW || i > s.capH), l = L(Math.max(1, t, e ? s.capW : 0)), o = L(Math.max(1, i, e ? s.capH : 0));
+    this.dropSurface();
+    const c = q(l, o);
+    return this.surface = c, this.sprite.texture = c.texture, c;
+  }
+  dropSurface() {
+    this.sprite.texture = Y.EMPTY, this.surface && z(this.surface), this.surface = null;
+  }
+  destroy() {
+    this.destroyed || (this.dropSurface(), super.destroy());
+  }
+}
+export {
+  J as PixelLayer,
+  $ as addPixelLayer
+};
+//# sourceMappingURL=PixelLayer.js.map

package/dist/pixel/PixelLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PixelLayer.js","sources":["../../src/pixel/PixelLayer.ts"],"sourcesContent":["import { BufferImageSource, Sprite, Texture } from 'pixi.js';\nimport { Graphics } from '../core/Graphics';\nimport { patchPixi } from '../core/pixiPatches';\nimport type { Stage } from '../core/Stage';\n\npatchPixi();\n\n/** Larger than this a frame is laid as rects after all: a texture that size is no saving. */\nconst MAX_SIDE = 1024;\n/**\n * The sides a buffer is made in, each about a third to a half over the last: a layer that swells frame by frame\n * crosses a handful of them, not one every 32 px, and a spent buffer fits the next layer of its class (`POOL`).\n */\nconst SIDES = [16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024];\n/** Spent buffers kept per size class, and in all, for the next layers to take instead of making a texture. */\nconst POOL_PER_CLASS = 24;\nconst POOL_MAX_BYTES = 24 * 1024 * 1024;\n/** A layer whose frames have stayed this many presents well inside a quarter of its buffer trades it for a smaller one. */\nconst SHRINK_AFTER = 60;\n\n/** One buffer, the texture over it, and its size: what a layer holds and the pool keeps. */\ninterface Surface {\n  pixels: Uint8Array;\n  words: Uint32Array;\n  source: BufferImageSource;\n  texture: Texture;\n  capW: number;\n  capH: number;\n}\n\nconst POOL = new Map<number, Surface[]>();\nlet pooledBytes = 0;\n/** Textures made since boot (`PixelLayer.stats`): the pool is working when this stops climbing. */\nlet made = 0;\n\nconst sideFor = (n: number): number => {\n  for (const s of SIDES) if (s >= n) return s;\n  return Math.ceil(n / 256) * 256;\n};\nconst classOf = (w: number, h: number) => w * 4096 + h;\n\nfunction takeSurface(capW: number, capH: number): Surface {\n  // the exact class, else the smallest pooled one that holds it within twice its area: a 48×24 frame takes a spent\n  // 48×32 rather than making a texture of its own\n  let list = POOL.get(classOf(capW, capH));\n  if (!list?.length) {\n    let best = Infinity;\n    for (const [k, l] of POOL) {\n      if (!l.length) continue;\n      const w = Math.floor(k / 4096);\n      const h = k % 4096;\n      const area = w * h;\n      if (w >= capW && h >= capH && area <= capW * capH * 2 && area < best) {\n        best = area;\n        list = l;\n      }\n    }\n  }\n  const hit = list?.pop();\n  if (hit) {\n    pooledBytes -= hit.pixels.byteLength;\n    return hit;\n  }\n  made++;\n  const pixels = new Uint8Array(capW * capH * 4);\n  const source = new BufferImageSource({\n    resource: pixels,\n    width: capW,\n    height: capH,\n    format: 'rgba8unorm',\n    alphaMode: 'premultiplied-alpha',\n    scaleMode: 'nearest',\n  });\n  return { pixels, words: new Uint32Array(pixels.buffer), source, texture: new Texture({ source }), capW, capH };\n}\n\nfunction giveSurface(s: Surface): void {\n  const key = classOf(s.capW, s.capH);\n  let list = POOL.get(key);\n  if (!list) POOL.set(key, (list = []));\n  if (list.length >= POOL_PER_CLASS || pooledBytes + s.pixels.byteLength > POOL_MAX_BYTES) {\n    s.texture.destroy(true);\n    return;\n  }\n  list.push(s);\n  pooledBytes += s.pixels.byteLength;\n}\n\n/**\n * A `Graphics` for the pixel effects: every `fillRect` of a frame is written into a small RGBA buffer\n * and shown as **one** sprite, instead of becoming a rect Pixi must tessellate, batch and upload. An effect's frame is\n * hundreds to thousands of one-pixel runs (a poison cloud, a status mark round every body in a pack), and as rects they\n * were most of a fight's CPU on a phone (profiled). The pixels are the same: whole\n * world pixels, a translucent fill blended over what was painted before it in the same frame, as a Graphics did.\n *\n * Paint between `clear()` and `present()`; anything other than `fillStyle`/`fillRect` still draws through the\n * Graphics underneath, so a painter using another shape keeps working. Solid pixels may also be **staged**\n * (`stage`, from `pixelTone`'s batch) and laid in one go by `commit`, which is what a batch's flush does.\n *\n * Buffers and their textures are pooled by size class (a texture per effect ran to ~114 a second in a busy fight,\n * and each one stayed in Pixi's batch tables), so a destroyed layer hands its texture\n * to the next one; `PixelLayer.drainPool` lets them all go when the map changes.\n */\n/** A new `PixelLayer` on the stage's world layer. */\nexport function addPixelLayer(stage: Stage): PixelLayer {\n  return stage.add.existing(new PixelLayer());\n}\n\nexport class PixelLayer extends Graphics {\n  /** This frame's rects: x, y, w, h, colour, alpha — six numbers each. */\n  private readonly rects: number[] = [];\n  /** Staged solid runs not yet committed: x, y, w, colour — four numbers each; later ones win. */\n  private readonly staged: number[] = [];\n  private ink = 0xffffff;\n  private inkAlpha = 1;\n  private readonly sprite = new Sprite(Texture.EMPTY);\n  private surface: Surface | null = null;\n  /** Where the buffer's first pixel sits in the layer, as of the last `present`. */\n  private originX = 0;\n  private originY = 0;\n  /** The last frame's size, and how many presents in a row it stayed well inside a quarter of the buffer. */\n  private lastW = 0;\n  private lastH = 0;\n  private small = 0;\n\n  constructor() {\n    super();\n    this.sprite.visible = false;\n    this.addChild(this.sprite);\n  }\n\n  /** Textures made, spent buffers waiting in the pool and their bytes (the leak tools read it). */\n  static stats(): { made: number; pooled: number; pooledBytes: number } {\n    let pooled = 0;\n    for (const l of POOL.values()) pooled += l.length;\n    return { made, pooled, pooledBytes };\n  }\n\n  /** Lets every pooled buffer go (the world changed map): the next map's effects start a pool of their own. */\n  static drainPool(): void {\n    for (const list of POOL.values()) for (const s of list) s.texture.destroy(true);\n    POOL.clear();\n    pooledBytes = 0;\n  }\n\n  override fillStyle(color: number, alpha = 1): this {\n    this.ink = color;\n    this.inkAlpha = alpha;\n    return super.fillStyle(color, alpha);\n  }\n\n  override fillRect(x: number, y: number, w: number, h: number): this {\n    const x0 = Math.round(x);\n    const y0 = Math.round(y);\n    const rw = Math.round(x + w) - x0;\n    const rh = Math.round(y + h) - y0;\n    if (rw > 0 && rh > 0 && this.inkAlpha > 0) this.rects.push(x0, y0, rw, rh, this.ink, this.inkAlpha);\n    return this;\n  }\n\n  /** `fillStyle` + `fillRect` on whole pixels in one call, leaving the fill style alone (a hot loop's way in). */\n  rect(x: number, y: number, w: number, h: number, color: number, alpha = 1): void {\n    // a coordinate off to Infinity or NaN would make the frame's box endless (`present`), so it is dropped here\n    if (w > 0 && h > 0 && alpha > 0 && Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(w) && Number.isFinite(h)) this.rects.push(x, y, w, h, color, alpha);\n  }\n\n  /**\n   * A solid run of `w` whole pixels at (x, y) in `color`, held until `commit` lays every staged run in the order given\n   * (the later winning where they cross), after whatever was drawn before the commit. What `pixelTone`'s batch writes\n   * instead of filing each pixel in a map and sorting it into rects.\n   */\n  stage(x: number, y: number, w: number, color: number): void {\n    if (Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(w)) this.staged.push(x, y, w, color);\n  }\n\n  /** Lays the staged runs, as opaque rects, after everything drawn so far. */\n  commit(): void {\n    const s = this.staged;\n    const n = s.length;\n    if (n === 0) return;\n    const r = this.rects;\n    for (let i = 0; i < n; i += 4) r.push(s[i]!, s[i + 1]!, s[i + 2]!, 1, s[i + 3]!, 1);\n    s.length = 0;\n  }\n\n  override clear(): this {\n    this.rects.length = 0;\n    this.staged.length = 0;\n    return super.clear();\n  }\n\n  /** How far the last frame reached from the layer's origin, in world pixels (0 when nothing showed). */\n  reach(): number {\n    if (!this.sprite.visible) return 0;\n    return Math.max(Math.abs(this.originX), Math.abs(this.originY), Math.abs(this.originX + this.lastW), Math.abs(this.originY + this.lastH));\n  }\n\n  /** Writes this frame's rects into the texture and shows it; call once the frame is painted. */\n  present(): void {\n    this.commit();\n    const r = this.rects;\n    if (r.length === 0) {\n      this.sprite.visible = false;\n      return;\n    }\n    let minX = Infinity;\n    let minY = Infinity;\n    let maxX = -Infinity;\n    let maxY = -Infinity;\n    for (let i = 0; i < r.length; i += 6) {\n      if (r[i]! < minX) minX = r[i]!;\n      if (r[i + 1]! < minY) minY = r[i + 1]!;\n      if (r[i]! + r[i + 2]! > maxX) maxX = r[i]! + r[i + 2]!;\n      if (r[i + 1]! + r[i + 3]! > maxY) maxY = r[i + 1]! + r[i + 3]!;\n    }\n    const w = maxX - minX;\n    const h = maxY - minY;\n    if (w > MAX_SIDE || h > MAX_SIDE) {\n      this.sprite.visible = false;\n      // the Graphics' own fillRect, never chained off `super.fillStyle(…)`: that returns `this`, so `.fillRect` was this\n      // class's, which pushed every rect back onto `r` while it was walked — the loop never ended and grew the array to\n      // a gigabyte (a body evaporating far across the screen froze PCs for seconds and killed mobile web views)\n      const n = r.length;\n      for (let i = 0; i < n; i += 6) {\n        super.fillStyle(r[i + 4]!, r[i + 5]!);\n        super.fillRect(r[i]!, r[i + 1]!, r[i + 2]!, r[i + 3]!);\n      }\n      return;\n    }\n    const surface = this.fit(w, h);\n    const { words, pixels, capW: cap } = surface;\n    // the whole buffer: the sprite always shows all of it at one texel a world pixel. Cropping the texture's frame to\n    // this frame's size instead stretched it to the old size (a Pixi sprite is sized by `orig`), and an effect that\n    // shrank — a falling column — came down as blocks blown up several times over\n    words.fill(0);\n    for (let i = 0; i < r.length; i += 6) {\n      const x0 = r[i]! - minX;\n      const y0 = r[i + 1]! - minY;\n      const rw = r[i + 2]!;\n      const rh = r[i + 3]!;\n      const c = r[i + 4]!;\n      const a = r[i + 5]!;\n      const cr = (c >> 16) & 255;\n      const cg = (c >> 8) & 255;\n      const cb = c & 255;\n      if (a >= 1) {\n        // little-endian RGBA bytes, opaque: no blend\n        const word = (0xff000000 | (cb << 16) | (cg << 8) | cr) >>> 0;\n        if (rw === 1 && rh === 1) {\n          words[y0 * cap + x0] = word;\n          continue;\n        }\n        for (let y = y0; y < y0 + rh; y++) {\n          const row = y * cap + x0;\n          if (rw < 8) for (let p = row, end = row + rw; p < end; p++) words[p] = word;\n          else words.fill(word, row, row + rw);\n        }\n        continue;\n      }\n      // premultiplied source-over, what a translucent Graphics fill did over the pixels under it\n      const keep = 1 - a;\n      const pr = cr * a;\n      const pg = cg * a;\n      const pb = cb * a;\n      const pa = 255 * a;\n      for (let y = y0; y < y0 + rh; y++) {\n        for (let p = (y * cap + x0) * 4, end = p + rw * 4; p < end; p += 4) {\n          pixels[p] = pr + pixels[p]! * keep;\n          pixels[p + 1] = pg + pixels[p + 1]! * keep;\n          pixels[p + 2] = pb + pixels[p + 2]! * keep;\n          pixels[p + 3] = pa + pixels[p + 3]! * keep;\n        }\n      }\n    }\n    surface.source.update();\n    this.sprite.texture = surface.texture;\n    this.sprite.position.set(minX, minY);\n    this.sprite.visible = true;\n    this.originX = minX;\n    this.originY = minY;\n    this.lastW = w;\n    this.lastH = h;\n  }\n\n  /**\n   * Shows `other`'s last frame instead of painting one: its texture, placed where it placed it. A frame shared by\n   * several bodies (the same aura on two bodies) is painted once and shown by each of their layers.\n   */\n  mirror(other: PixelLayer): void {\n    const s = other.surface;\n    if (!s || !other.sprite.visible) {\n      this.hideMirror();\n      return;\n    }\n    this.sprite.texture = s.texture;\n    this.sprite.position.set(other.originX, other.originY);\n    this.sprite.visible = true;\n    this.originX = other.originX;\n    this.originY = other.originY;\n    this.lastW = other.lastW;\n    this.lastH = other.lastH;\n  }\n\n  /** Shows nothing and lets go of the texture a `mirror` showed. */\n  hideMirror(): void {\n    this.sprite.visible = false;\n    this.sprite.texture = this.surface?.texture ?? Texture.EMPTY;\n  }\n\n  /** The premultiplied [r, g, b, a] last presented at layer pixel (x, y); zeros where nothing was (tests read it). */\n  pixelAt(x: number, y: number): [number, number, number, number] {\n    const s = this.surface;\n    const capW = s?.capW ?? 0;\n    const capH = s?.capH ?? 0;\n    // the sprite must show the buffer one texel to a world pixel, or every pixel read here lands somewhere else\n    if (this.sprite.width !== capW || this.sprite.height !== capH) throw new Error('PixelLayer sprite is scaled');\n    const px = x - this.originX;\n    const py = y - this.originY;\n    if (!s || !this.sprite.visible || px < 0 || py < 0 || px >= capW || py >= capH) return [0, 0, 0, 0];\n    const p = (py * capW + px) * 4;\n    return [s.pixels[p]!, s.pixels[p + 1]!, s.pixels[p + 2]!, s.pixels[p + 3]!];\n  }\n\n  /** The buffer's size (tests read it). */\n  capacity(): { w: number; h: number } {\n    return { w: this.surface?.capW ?? 0, h: this.surface?.capH ?? 0 };\n  }\n\n  /**\n   * A buffer at least `w` × `h`: grown a size class at a time and kept while it fits, traded back to the pool for a\n   * smaller one only once the frames have stayed well inside it for `SHRINK_AFTER` presents (a long-lived layer — an\n   * aura, a status mark — that once swelled would otherwise hold and upload its largest buffer for good).\n   */\n  private fit(w: number, h: number): Surface {\n    const s = this.surface;\n    if (s && w <= s.capW && h <= s.capH) {\n      const roomy = s.capW * s.capH >= 128 * 128 && w * 4 <= s.capW && h * 4 <= s.capH;\n      this.small = roomy ? this.small + 1 : 0;\n      if (this.small < SHRINK_AFTER) return s;\n    }\n    this.small = 0;\n    // growing keeps the larger side it had, so a frame that swells one way and then the other is not traded each time\n    const grow = !!s && (w > s.capW || h > s.capH);\n    const capW = sideFor(Math.max(1, w, grow ? s!.capW : 0));\n    const capH = sideFor(Math.max(1, h, grow ? s!.capH : 0));\n    this.dropSurface();\n    const next = takeSurface(capW, capH);\n    this.surface = next;\n    this.sprite.texture = next.texture;\n    return next;\n  }\n\n  private dropSurface(): void {\n    this.sprite.texture = Texture.EMPTY;\n    if (this.surface) giveSurface(this.surface);\n    this.surface = null;\n  }\n\n  override destroy(): void {\n    if (this.destroyed) return;\n    this.dropSurface();\n    super.destroy();\n  }\n}\n"],"names":["patchPixi","MAX_SIDE","SIDES","POOL_PER_CLASS","POOL_MAX_BYTES","SHRINK_AFTER","POOL","pooledBytes","made","sideFor","s","classOf","w","h","takeSurface","capW","capH","list","best","k","l","area","hit","pixels","source","BufferImageSource","Texture","giveSurface","key","addPixelLayer","stage","PixelLayer","Graphics","Sprite","pooled","color","alpha","x","y","x0","y0","rw","rh","n","r","i","minX","minY","maxX","maxY","surface","words","cap","c","a","cr","cg","cb","word","row","p","end","keep","pr","pg","pb","pa","other","px","py","roomy","grow","next"],"mappings":";;;AAKAA,EAAA;AAGA,MAAMC,IAAW,MAKXC,IAAQ,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,GAEnEC,IAAiB,IACjBC,IAAiB,KAAK,OAAO,MAE7BC,IAAe,IAYfC,wBAAW,IAAA;AACjB,IAAIC,IAAc,GAEdC,IAAO;AAEX,MAAMC,IAAU,CAAC,MAAsB;AACrC,aAAWC,KAAKR,EAAO,KAAIQ,KAAK,EAAG,QAAOA;AAC1C,SAAO,KAAK,KAAK,IAAI,GAAG,IAAI;AAC9B,GACMC,IAAU,CAACC,GAAWC,MAAcD,IAAI,OAAOC;AAErD,SAASC,EAAYC,GAAcC,GAAuB;AAGxD,MAAIC,IAAOX,EAAK,IAAIK,EAAQI,GAAMC,CAAI,CAAC;AACvC,MAAI,CAACC,GAAM,QAAQ;AACjB,QAAIC,IAAO;AACX,eAAW,CAACC,GAAGC,CAAC,KAAKd,GAAM;AACzB,UAAI,CAACc,EAAE,OAAQ;AACf,YAAMR,IAAI,KAAK,MAAMO,IAAI,IAAI,GACvBN,IAAIM,IAAI,MACRE,IAAOT,IAAIC;AACjB,MAAID,KAAKG,KAAQF,KAAKG,KAAQK,KAAQN,IAAOC,IAAO,KAAKK,IAAOH,MAC9DA,IAAOG,GACPJ,IAAOG;AAAA,IAEX;AAAA,EACF;AACA,QAAME,IAAML,GAAM,IAAA;AAClB,MAAIK;AACF,WAAAf,KAAee,EAAI,OAAO,YACnBA;AAET,EAAAd;AACA,QAAMe,IAAS,IAAI,WAAWR,IAAOC,IAAO,CAAC,GACvCQ,IAAS,IAAIC,EAAkB;AAAA,IACnC,UAAUF;AAAA,IACV,OAAOR;AAAA,IACP,QAAQC;AAAA,IACR,QAAQ;AAAA,IACR,WAAW;AAAA,IACX,WAAW;AAAA,EAAA,CACZ;AACD,SAAO,EAAE,QAAAO,GAAQ,OAAO,IAAI,YAAYA,EAAO,MAAM,GAAG,QAAAC,GAAQ,SAAS,IAAIE,EAAQ,EAAE,QAAAF,GAAQ,GAAG,MAAAT,GAAM,MAAAC,EAAA;AAC1G;AAEA,SAASW,EAAYjB,GAAkB;AACrC,QAAMkB,IAAMjB,EAAQD,EAAE,MAAMA,EAAE,IAAI;AAClC,MAAIO,IAAOX,EAAK,IAAIsB,CAAG;AAEvB,MADKX,KAAMX,EAAK,IAAIsB,GAAMX,IAAO,EAAG,GAChCA,EAAK,UAAUd,KAAkBI,IAAcG,EAAE,OAAO,aAAaN,GAAgB;AACvF,IAAAM,EAAE,QAAQ,QAAQ,EAAI;AACtB;AAAA,EACF;AACA,EAAAO,EAAK,KAAKP,CAAC,GACXH,KAAeG,EAAE,OAAO;AAC1B;AAkBO,SAASmB,EAAcC,GAA0B;AACtD,SAAOA,EAAM,IAAI,SAAS,IAAIC,GAAY;AAC5C;AAEO,MAAMA,UAAmBC,EAAS;AAAA;AAAA,EAEtB,QAAkB,CAAA;AAAA;AAAA,EAElB,SAAmB,CAAA;AAAA,EAC5B,MAAM;AAAA,EACN,WAAW;AAAA,EACF,SAAS,IAAIC,EAAOP,EAAQ,KAAK;AAAA,EAC1C,UAA0B;AAAA;AAAA,EAE1B,UAAU;AAAA,EACV,UAAU;AAAA;AAAA,EAEV,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,QAAQ;AAAA,EAEhB,cAAc;AACZ,UAAA,GACA,KAAK,OAAO,UAAU,IACtB,KAAK,SAAS,KAAK,MAAM;AAAA,EAC3B;AAAA;AAAA,EAGA,OAAO,QAA+D;AACpE,QAAIQ,IAAS;AACb,eAAWd,KAAKd,EAAK,OAAA,QAAoBc,EAAE;AAC3C,WAAO,EAAE,MAAAZ,GAAM,QAAA0B,GAAQ,aAAA3B,EAAA;AAAA,EACzB;AAAA;AAAA,EAGA,OAAO,YAAkB;AACvB,eAAWU,KAAQX,EAAK,OAAA,EAAU,YAAWI,KAAKO,EAAM,CAAAP,EAAE,QAAQ,QAAQ,EAAI;AAC9E,IAAAJ,EAAK,MAAA,GACLC,IAAc;AAAA,EAChB;AAAA,EAES,UAAU4B,GAAeC,IAAQ,GAAS;AACjD,gBAAK,MAAMD,GACX,KAAK,WAAWC,GACT,MAAM,UAAUD,GAAOC,CAAK;AAAA,EACrC;AAAA,EAES,SAASC,GAAWC,GAAW1B,GAAWC,GAAiB;AAClE,UAAM0B,IAAK,KAAK,MAAMF,CAAC,GACjBG,IAAK,KAAK,MAAMF,CAAC,GACjBG,IAAK,KAAK,MAAMJ,IAAIzB,CAAC,IAAI2B,GACzBG,IAAK,KAAK,MAAMJ,IAAIzB,CAAC,IAAI2B;AAC/B,WAAIC,IAAK,KAAKC,IAAK,KAAK,KAAK,WAAW,KAAG,KAAK,MAAM,KAAKH,GAAIC,GAAIC,GAAIC,GAAI,KAAK,KAAK,KAAK,QAAQ,GAC3F;AAAA,EACT;AAAA;AAAA,EAGA,KAAKL,GAAWC,GAAW1B,GAAWC,GAAWsB,GAAeC,IAAQ,GAAS;AAE/E,IAAIxB,IAAI,KAAKC,IAAI,KAAKuB,IAAQ,KAAK,OAAO,SAASC,CAAC,KAAK,OAAO,SAASC,CAAC,KAAK,OAAO,SAAS1B,CAAC,KAAK,OAAO,SAASC,CAAC,KAAG,KAAK,MAAM,KAAKwB,GAAGC,GAAG1B,GAAGC,GAAGsB,GAAOC,CAAK;AAAA,EACnK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAMC,GAAWC,GAAW1B,GAAWuB,GAAqB;AAC1D,IAAI,OAAO,SAASE,CAAC,KAAK,OAAO,SAASC,CAAC,KAAK,OAAO,SAAS1B,CAAC,KAAG,KAAK,OAAO,KAAKyB,GAAGC,GAAG1B,GAAGuB,CAAK;AAAA,EACrG;AAAA;AAAA,EAGA,SAAe;AACb,UAAMzB,IAAI,KAAK,QACTiC,IAAIjC,EAAE;AACZ,QAAIiC,MAAM,EAAG;AACb,UAAMC,IAAI,KAAK;AACf,aAASC,IAAI,GAAGA,IAAIF,GAAGE,KAAK,EAAG,CAAAD,EAAE,KAAKlC,EAAEmC,CAAC,GAAInC,EAAEmC,IAAI,CAAC,GAAInC,EAAEmC,IAAI,CAAC,GAAI,GAAGnC,EAAEmC,IAAI,CAAC,GAAI,CAAC;AAClF,IAAAnC,EAAE,SAAS;AAAA,EACb;AAAA,EAES,QAAc;AACrB,gBAAK,MAAM,SAAS,GACpB,KAAK,OAAO,SAAS,GACd,MAAM,MAAA;AAAA,EACf;AAAA;AAAA,EAGA,QAAgB;AACd,WAAK,KAAK,OAAO,UACV,KAAK,IAAI,KAAK,IAAI,KAAK,OAAO,GAAG,KAAK,IAAI,KAAK,OAAO,GAAG,KAAK,IAAI,KAAK,UAAU,KAAK,KAAK,GAAG,KAAK,IAAI,KAAK,UAAU,KAAK,KAAK,CAAC,IADvG;AAAA,EAEnC;AAAA;AAAA,EAGA,UAAgB;AACd,SAAK,OAAA;AACL,UAAMkC,IAAI,KAAK;AACf,QAAIA,EAAE,WAAW,GAAG;AAClB,WAAK,OAAO,UAAU;AACtB;AAAA,IACF;AACA,QAAIE,IAAO,OACPC,IAAO,OACPC,IAAO,QACPC,IAAO;AACX,aAASJ,IAAI,GAAGA,IAAID,EAAE,QAAQC,KAAK;AACjC,MAAID,EAAEC,CAAC,IAAKC,MAAMA,IAAOF,EAAEC,CAAC,IACxBD,EAAEC,IAAI,CAAC,IAAKE,MAAMA,IAAOH,EAAEC,IAAI,CAAC,IAChCD,EAAEC,CAAC,IAAKD,EAAEC,IAAI,CAAC,IAAKG,MAAMA,IAAOJ,EAAEC,CAAC,IAAKD,EAAEC,IAAI,CAAC,IAChDD,EAAEC,IAAI,CAAC,IAAKD,EAAEC,IAAI,CAAC,IAAKI,MAAMA,IAAOL,EAAEC,IAAI,CAAC,IAAKD,EAAEC,IAAI,CAAC;AAE9D,UAAMjC,IAAIoC,IAAOF,GACXjC,IAAIoC,IAAOF;AACjB,QAAInC,IAAIX,KAAYY,IAAIZ,GAAU;AAChC,WAAK,OAAO,UAAU;AAItB,YAAM0C,IAAIC,EAAE;AACZ,eAASC,IAAI,GAAGA,IAAIF,GAAGE,KAAK;AAC1B,cAAM,UAAUD,EAAEC,IAAI,CAAC,GAAID,EAAEC,IAAI,CAAC,CAAE,GACpC,MAAM,SAASD,EAAEC,CAAC,GAAID,EAAEC,IAAI,CAAC,GAAID,EAAEC,IAAI,CAAC,GAAID,EAAEC,IAAI,CAAC,CAAE;AAEvD;AAAA,IACF;AACA,UAAMK,IAAU,KAAK,IAAItC,GAAGC,CAAC,GACvB,EAAE,OAAAsC,GAAO,QAAA5B,GAAQ,MAAM6B,MAAQF;AAIrC,IAAAC,EAAM,KAAK,CAAC;AACZ,aAASN,IAAI,GAAGA,IAAID,EAAE,QAAQC,KAAK,GAAG;AACpC,YAAMN,IAAKK,EAAEC,CAAC,IAAKC,GACbN,IAAKI,EAAEC,IAAI,CAAC,IAAKE,GACjBN,IAAKG,EAAEC,IAAI,CAAC,GACZH,IAAKE,EAAEC,IAAI,CAAC,GACZQ,IAAIT,EAAEC,IAAI,CAAC,GACXS,IAAIV,EAAEC,IAAI,CAAC,GACXU,IAAMF,KAAK,KAAM,KACjBG,IAAMH,KAAK,IAAK,KAChBI,IAAKJ,IAAI;AACf,UAAIC,KAAK,GAAG;AAEV,cAAMI,KAAQ,aAAcD,KAAM,KAAOD,KAAM,IAAKD,OAAQ;AAC5D,YAAId,MAAO,KAAKC,MAAO,GAAG;AACxB,UAAAS,EAAMX,IAAKY,IAAMb,CAAE,IAAImB;AACvB;AAAA,QACF;AACA,iBAASpB,IAAIE,GAAIF,IAAIE,IAAKE,GAAIJ,KAAK;AACjC,gBAAMqB,IAAMrB,IAAIc,IAAMb;AACtB,cAAIE,IAAK,EAAG,UAASmB,IAAID,GAAKE,IAAMF,IAAMlB,GAAImB,IAAIC,GAAKD,IAAK,CAAAT,EAAMS,CAAC,IAAIF;AAAA,cAClE,CAAAP,EAAM,KAAKO,GAAMC,GAAKA,IAAMlB,CAAE;AAAA,QACrC;AACA;AAAA,MACF;AAEA,YAAMqB,IAAO,IAAIR,GACXS,IAAKR,IAAKD,GACVU,IAAKR,IAAKF,GACVW,IAAKR,IAAKH,GACVY,IAAK,MAAMZ;AACjB,eAAShB,IAAIE,GAAIF,IAAIE,IAAKE,GAAIJ;AAC5B,iBAASsB,KAAKtB,IAAIc,IAAMb,KAAM,GAAGsB,IAAMD,IAAInB,IAAK,GAAGmB,IAAIC,GAAKD,KAAK;AAC/D,UAAArC,EAAOqC,CAAC,IAAIG,IAAKxC,EAAOqC,CAAC,IAAKE,GAC9BvC,EAAOqC,IAAI,CAAC,IAAII,IAAKzC,EAAOqC,IAAI,CAAC,IAAKE,GACtCvC,EAAOqC,IAAI,CAAC,IAAIK,IAAK1C,EAAOqC,IAAI,CAAC,IAAKE,GACtCvC,EAAOqC,IAAI,CAAC,IAAIM,IAAK3C,EAAOqC,IAAI,CAAC,IAAKE;AAAA,IAG5C;AACA,IAAAZ,EAAQ,OAAO,OAAA,GACf,KAAK,OAAO,UAAUA,EAAQ,SAC9B,KAAK,OAAO,SAAS,IAAIJ,GAAMC,CAAI,GACnC,KAAK,OAAO,UAAU,IACtB,KAAK,UAAUD,GACf,KAAK,UAAUC,GACf,KAAK,QAAQnC,GACb,KAAK,QAAQC;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAOsD,GAAyB;AAC9B,UAAMzD,IAAIyD,EAAM;AAChB,QAAI,CAACzD,KAAK,CAACyD,EAAM,OAAO,SAAS;AAC/B,WAAK,WAAA;AACL;AAAA,IACF;AACA,SAAK,OAAO,UAAUzD,EAAE,SACxB,KAAK,OAAO,SAAS,IAAIyD,EAAM,SAASA,EAAM,OAAO,GACrD,KAAK,OAAO,UAAU,IACtB,KAAK,UAAUA,EAAM,SACrB,KAAK,UAAUA,EAAM,SACrB,KAAK,QAAQA,EAAM,OACnB,KAAK,QAAQA,EAAM;AAAA,EACrB;AAAA;AAAA,EAGA,aAAmB;AACjB,SAAK,OAAO,UAAU,IACtB,KAAK,OAAO,UAAU,KAAK,SAAS,WAAWzC,EAAQ;AAAA,EACzD;AAAA;AAAA,EAGA,QAAQW,GAAWC,GAA6C;AAC9D,UAAM,IAAI,KAAK,SACTvB,IAAO,GAAG,QAAQ,GAClBC,IAAO,GAAG,QAAQ;AAExB,QAAI,KAAK,OAAO,UAAUD,KAAQ,KAAK,OAAO,WAAWC,EAAM,OAAM,IAAI,MAAM,6BAA6B;AAC5G,UAAMoD,IAAK/B,IAAI,KAAK,SACdgC,IAAK/B,IAAI,KAAK;AACpB,QAAI,CAAC,KAAK,CAAC,KAAK,OAAO,WAAW8B,IAAK,KAAKC,IAAK,KAAKD,KAAMrD,KAAQsD,KAAMrD,EAAM,QAAO,CAAC,GAAG,GAAG,GAAG,CAAC;AAClG,UAAM4C,KAAKS,IAAKtD,IAAOqD,KAAM;AAC7B,WAAO,CAAC,EAAE,OAAOR,CAAC,GAAI,EAAE,OAAOA,IAAI,CAAC,GAAI,EAAE,OAAOA,IAAI,CAAC,GAAI,EAAE,OAAOA,IAAI,CAAC,CAAE;AAAA,EAC5E;AAAA;AAAA,EAGA,WAAqC;AACnC,WAAO,EAAE,GAAG,KAAK,SAAS,QAAQ,GAAG,GAAG,KAAK,SAAS,QAAQ,EAAA;AAAA,EAChE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOQ,IAAIhD,GAAWC,GAAoB;AACzC,UAAM,IAAI,KAAK;AACf,QAAI,KAAKD,KAAK,EAAE,QAAQC,KAAK,EAAE,MAAM;AACnC,YAAMyD,IAAQ,EAAE,OAAO,EAAE,QAAQ,SAAa1D,IAAI,KAAK,EAAE,QAAQC,IAAI,KAAK,EAAE;AAE5E,UADA,KAAK,QAAQyD,IAAQ,KAAK,QAAQ,IAAI,GAClC,KAAK,QAAQjE,EAAc,QAAO;AAAA,IACxC;AACA,SAAK,QAAQ;AAEb,UAAMkE,IAAO,CAAC,CAAC,MAAM3D,IAAI,EAAE,QAAQC,IAAI,EAAE,OACnCE,IAAON,EAAQ,KAAK,IAAI,GAAGG,GAAG2D,IAAO,EAAG,OAAO,CAAC,CAAC,GACjDvD,IAAOP,EAAQ,KAAK,IAAI,GAAGI,GAAG0D,IAAO,EAAG,OAAO,CAAC,CAAC;AACvD,SAAK,YAAA;AACL,UAAMC,IAAO1D,EAAYC,GAAMC,CAAI;AACnC,gBAAK,UAAUwD,GACf,KAAK,OAAO,UAAUA,EAAK,SACpBA;AAAA,EACT;AAAA,EAEQ,cAAoB;AAC1B,SAAK,OAAO,UAAU9C,EAAQ,OAC1B,KAAK,WAASC,EAAY,KAAK,OAAO,GAC1C,KAAK,UAAU;AAAA,EACjB;AAAA,EAES,UAAgB;AACvB,IAAI,KAAK,cACT,KAAK,YAAA,GACL,MAAM,QAAA;AAAA,EACR;AACF;"}

package/dist/pixel/SwayProp.js

@@ -0,0 +1,75 @@
+import { Sprite as b, Texture as m, Rectangle as I } from "pixi.js";
+import { buildRig as M, gustAt as R, swayOffset as S } from "./swayRig.js";
+const g = /* @__PURE__ */ new WeakMap();
+function v(r, t) {
+  let s = g.get(r.source);
+  s || g.set(r.source, s = /* @__PURE__ */ new Map());
+  const h = r.frame, o = `${h.x + t.x},${h.y + t.y},${t.w},${t.h}`;
+  let i = s.get(o);
+  return i || s.set(o, i = new m({ source: r.source, frame: new I(h.x + t.x, h.y + t.y, t.w, t.h) })), i;
+}
+function $(r) {
+  const s = r.source.resource?.getContext?.("2d");
+  if (!s) return;
+  const { x: h, y: o, width: i, height: c } = r.frame, e = s.getImageData(h, o, i, c).data, n = [];
+  for (let u = 0; u < c; u++) {
+    let p = -1, d = -1;
+    for (let f = 0; f < i; f++)
+      e[(u * i + f) * 4 + 3] > 0 && (p < 0 && (p = f), d = f);
+    n.push(p < 0 ? 0 : d - p + 1);
+  }
+  return n;
+}
+class k {
+  constructor(t, s, h = {}) {
+    this.img = t, this.def = s, this.phase = h.phase ?? 0, this.speed = s.speed * (h.pace ?? 1), this.shown = t.visible, this.alpha = t.alpha;
+    const o = t.texture, i = o.frame.width, c = o.frame.height, e = t.parent, n = h.rig ?? (i >= 2 && c >= 2 ? M(s, i, c, s.mode === "crown" ? h.rowWidths ?? $(o) : void 0, h.variant ?? 0) : null);
+    if (this.active = !!n && !!e && n.pieces.length > 0 && n.strips.length > 0, !this.active || !n || !e) return;
+    const u = t.anchor.x * i, p = t.anchor.y * c, d = Math.round(t.x - u), f = Math.round(t.y - p), [w, ...y] = n.pieces;
+    t.texture = v(o, w), t.anchor.set((u - w.x) / w.w, (p - w.y) / w.h);
+    const x = (a) => {
+      const l = new b(v(o, a));
+      return l.position.set(d + a.x, f + a.y), l.zIndex = t.zIndex, l.visible = t.visible, l.alpha = t.alpha, e.addChild(l), this.parts.push(l), l;
+    };
+    for (const a of y) x(a);
+    for (const a of n.strips) this.strips.push({ sprite: x(a.rect), homeX: d + a.rect.x, weight: a.weight, lag: a.lag, offset: 0 });
+  }
+  img;
+  def;
+  parts = [];
+  strips = [];
+  phase;
+  speed;
+  shown;
+  alpha;
+  /** False when the frame is too small or the rig has nothing to move: `update` then does nothing. */
+  active;
+  /** `tSec` seconds of any steady clock; `enabled` false stands everything still (an ambient-effects setting). */
+  update(t, s, h = !0) {
+    if (!this.active) return;
+    const o = this.img.visible;
+    if (o !== this.shown) {
+      this.shown = o;
+      for (const e of this.parts) e.visible = o;
+    }
+    if (!o) return;
+    if (this.img.alpha !== this.alpha) {
+      this.alpha = this.img.alpha;
+      for (const e of this.parts) e.alpha = this.alpha;
+    }
+    const i = !h || s.wind <= 0, c = i ? 0 : R(t, this.img.x, s.gustSeconds, s.gustPx);
+    for (const e of this.strips) {
+      const n = i ? 0 : S(t, this.speed, this.phase, e.lag, this.def.amp, s.wind, c, e.weight, s.minReach ?? 0);
+      n !== e.offset && (e.offset = n, e.sprite.x = e.homeX + n);
+    }
+  }
+  destroy() {
+    for (const t of this.parts) t.destroy();
+    this.parts.length = 0, this.strips.length = 0;
+  }
+}
+export {
+  k as SwayProp,
+  $ as opaqueRowWidths
+};
+//# sourceMappingURL=SwayProp.js.map