1681-engine 0.0.0-stage → 0.5.8

package/dist/net/lobby/Matchmaker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Matchmaker.js","sources":["../../../src/net/lobby/Matchmaker.ts"],"sourcesContent":["/** A mode the matchmaker fills: `teams` sides of `teamSize` players. */\nexport interface MatchMode {\n  id: string;\n  teams: number;\n  teamSize: number;\n  /** Rating difference allowed at once (default 100), widened by `widenPerSecond` (default 10) up to `maxWindow` (default 600). */\n  window?: number;\n  widenPerSecond?: number;\n  maxWindow?: number;\n}\n\n/** One group waiting together: a player alone, or a party that must not be split. */\nexport interface Ticket {\n  id: string;\n  mode: string;\n  members: readonly number[];\n  /** The group's rating (the game's own: Elo, a level, a power score). */\n  rating: number;\n  /** When it joined the queue (ms): the oldest waits least. */\n  since: number;\n}\n\nexport interface FoundMatch {\n  mode: string;\n  tickets: Ticket[];\n  /** Each team's player ids, in the order the teams are numbered. */\n  teams: number[][];\n}\n\n/**\n * The matchmaking queue, pure: tickets in, matches out, no clock of its own and no sockets. Each `find(now)` takes\n * the oldest ticket of a mode as the anchor, gathers the groups within its rating window (and each within theirs,\n * so a newcomer is not thrown in with veterans because a veteran waited), and fills the teams from the closest\n * ratings first, never splitting a party; the teams are then balanced by rating. A window grows with the wait, so\n * anyone is matched in the end; a ticket nothing fits waits for the next call.\n */\nexport class Matchmaker {\n  private readonly modes = new Map<string, MatchMode>();\n  private readonly tickets = new Map<string, Ticket>();\n\n  constructor(modes: readonly MatchMode[]) {\n    for (const m of modes) {\n      if (!(m.teams >= 1 && m.teamSize >= 1)) throw new Error(`Matchmaker: mode ${m.id} needs at least one team of one`);\n      this.modes.set(m.id, m);\n    }\n  }\n\n  get size(): number {\n    return this.tickets.size;\n  }\n\n  mode(id: string): MatchMode | undefined {\n    return this.modes.get(id);\n  }\n\n  /** Adds a ticket (replacing one of the same id); throws on an unknown mode or a group too big for a team. */\n  add(ticket: Ticket): void {\n    const m = this.modes.get(ticket.mode);\n    if (!m) throw new Error(`Matchmaker: no mode ${ticket.mode}`);\n    if (ticket.members.length < 1 || ticket.members.length > m.teamSize) throw new Error(`Matchmaker: a group of ${ticket.members.length} does not fit a team of ${m.teamSize}`);\n    this.tickets.set(ticket.id, ticket);\n  }\n\n  remove(id: string): Ticket | undefined {\n    const t = this.tickets.get(id);\n    this.tickets.delete(id);\n    return t;\n  }\n\n  get(id: string): Ticket | undefined {\n    return this.tickets.get(id);\n  }\n\n  /** The tickets waiting for a mode, oldest first. */\n  waiting(mode: string): Ticket[] {\n    return [...this.tickets.values()].filter((t) => t.mode === mode).sort((a, b) => a.since - b.since);\n  }\n\n  /** How far a ticket's rating window reaches now. */\n  windowOf(t: Ticket, now: number): number {\n    const m = this.modes.get(t.mode)!;\n    const waited = Math.max(0, now - t.since) / 1000;\n    return Math.min(m.maxWindow ?? 600, (m.window ?? 100) + (m.widenPerSecond ?? 10) * waited);\n  }\n\n  /** Every match that can be made now; their tickets leave the queue. */\n  find(now: number): FoundMatch[] {\n    const out: FoundMatch[] = [];\n    for (const mode of this.modes.values()) {\n      const need = mode.teams * mode.teamSize;\n      let progress = true;\n      while (progress) {\n        progress = false;\n        const queue = this.waiting(mode.id);\n        for (const anchor of queue) {\n          const match = this.tryAnchor(anchor, queue, mode, need, now);\n          if (!match) continue;\n          for (const t of match.tickets) this.tickets.delete(t.id);\n          out.push(match);\n          progress = true;\n          break;\n        }\n      }\n    }\n    return out;\n  }\n\n  private tryAnchor(anchor: Ticket, queue: Ticket[], mode: MatchMode, need: number, now: number): FoundMatch | null {\n    const wa = this.windowOf(anchor, now);\n    const near = queue\n      .filter((t) => t !== anchor && Math.abs(t.rating - anchor.rating) <= Math.min(wa, this.windowOf(t, now)))\n      .sort((a, b) => Math.abs(a.rating - anchor.rating) - Math.abs(b.rating - anchor.rating) || a.since - b.since);\n    const picked = pickGroups([anchor], near, need);\n    if (!picked) return null;\n    const teams = balanceTeams(picked, mode.teams, mode.teamSize);\n    if (!teams) return null;\n    return { mode: mode.id, tickets: picked, teams };\n  }\n}\n\n/** Groups from `pool` (closest first) added to `start` until they hold exactly `need` players; a small search, not greedy, so a party of three is not shut out by two singles taken first. */\nfunction pickGroups(start: Ticket[], pool: Ticket[], need: number): Ticket[] | null {\n  const have = start.reduce((n, t) => n + t.members.length, 0);\n  if (have === need) return start;\n  if (have > need) return null;\n  const chosen: Ticket[] = [];\n  let budget = 2000;\n  const search = (from: number, left: number): boolean => {\n    if (left === 0) return true;\n    if (--budget < 0) return false;\n    for (let i = from; i < pool.length; i++) {\n      const t = pool[i]!;\n      if (t.members.length > left) continue;\n      chosen.push(t);\n      if (search(i + 1, left - t.members.length)) return true;\n      chosen.pop();\n    }\n    return false;\n  };\n  return search(0, need - have) ? [...start, ...chosen] : null;\n}\n\n/**\n * Splits groups into `teams` of exactly `size` players, parties whole, ratings as even as it can: the largest groups\n * first, each into the team with room whose rating total is lowest. Returns null when the sizes cannot be packed.\n */\nexport function balanceTeams(groups: readonly Ticket[], teams: number, size: number): number[][] | null {\n  const sorted = [...groups].sort((a, b) => b.members.length - a.members.length || b.rating - a.rating);\n  const sides = Array.from({ length: teams }, () => ({ ids: [] as number[], weight: 0 }));\n  const place = (i: number): boolean => {\n    if (i === sorted.length) return true;\n    const g = sorted[i]!;\n    const order = [...sides.keys()].sort((a, b) => sides[a]!.weight - sides[b]!.weight || sides[a]!.ids.length - sides[b]!.ids.length);\n    for (const s of order) {\n      const side = sides[s]!;\n      if (side.ids.length + g.members.length > size) continue;\n      side.ids.push(...g.members);\n      side.weight += g.rating * g.members.length;\n      if (place(i + 1)) return true;\n      side.ids.length -= g.members.length;\n      side.weight -= g.rating * g.members.length;\n    }\n    return false;\n  };\n  return place(0) ? sides.map((s) => s.ids) : null;\n}\n"],"names":["Matchmaker","modes","m","id","ticket","mode","a","b","t","now","waited","out","need","progress","queue","anchor","match","wa","near","picked","pickGroups","teams","balanceTeams","start","pool","have","n","chosen","budget","search","from","left","i","groups","size","sorted","sides","place","g","order","s","side"],"mappings":"AAoCO,MAAMA,EAAW;AAAA,EACL,4BAAY,IAAA;AAAA,EACZ,8BAAc,IAAA;AAAA,EAE/B,YAAYC,GAA6B;AACvC,eAAWC,KAAKD,GAAO;AACrB,UAAI,EAAEC,EAAE,SAAS,KAAKA,EAAE,YAAY,GAAI,OAAM,IAAI,MAAM,oBAAoBA,EAAE,EAAE,iCAAiC;AACjH,WAAK,MAAM,IAAIA,EAAE,IAAIA,CAAC;AAAA,IACxB;AAAA,EACF;AAAA,EAEA,IAAI,OAAe;AACjB,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EAEA,KAAKC,GAAmC;AACtC,WAAO,KAAK,MAAM,IAAIA,CAAE;AAAA,EAC1B;AAAA;AAAA,EAGA,IAAIC,GAAsB;AACxB,UAAMF,IAAI,KAAK,MAAM,IAAIE,EAAO,IAAI;AACpC,QAAI,CAACF,EAAG,OAAM,IAAI,MAAM,uBAAuBE,EAAO,IAAI,EAAE;AAC5D,QAAIA,EAAO,QAAQ,SAAS,KAAKA,EAAO,QAAQ,SAASF,EAAE,gBAAgB,IAAI,MAAM,0BAA0BE,EAAO,QAAQ,MAAM,2BAA2BF,EAAE,QAAQ,EAAE;AAC3K,SAAK,QAAQ,IAAIE,EAAO,IAAIA,CAAM;AAAA,EACpC;AAAA,EAEA,OAAOD,GAAgC;AACrC,UAAM,IAAI,KAAK,QAAQ,IAAIA,CAAE;AAC7B,gBAAK,QAAQ,OAAOA,CAAE,GACf;AAAA,EACT;AAAA,EAEA,IAAIA,GAAgC;AAClC,WAAO,KAAK,QAAQ,IAAIA,CAAE;AAAA,EAC5B;AAAA;AAAA,EAGA,QAAQE,GAAwB;AAC9B,WAAO,CAAC,GAAG,KAAK,QAAQ,QAAQ,EAAE,OAAO,CAAC,MAAM,EAAE,SAASA,CAAI,EAAE,KAAK,CAACC,GAAGC,MAAMD,EAAE,QAAQC,EAAE,KAAK;AAAA,EACnG;AAAA;AAAA,EAGA,SAASC,GAAWC,GAAqB;AACvC,UAAMP,IAAI,KAAK,MAAM,IAAIM,EAAE,IAAI,GACzBE,IAAS,KAAK,IAAI,GAAGD,IAAMD,EAAE,KAAK,IAAI;AAC5C,WAAO,KAAK,IAAIN,EAAE,aAAa,MAAMA,EAAE,UAAU,QAAQA,EAAE,kBAAkB,MAAMQ,CAAM;AAAA,EAC3F;AAAA;AAAA,EAGA,KAAKD,GAA2B;AAC9B,UAAME,IAAoB,CAAA;AAC1B,eAAWN,KAAQ,KAAK,MAAM,OAAA,GAAU;AACtC,YAAMO,IAAOP,EAAK,QAAQA,EAAK;AAC/B,UAAIQ,IAAW;AACf,aAAOA,KAAU;AACf,QAAAA,IAAW;AACX,cAAMC,IAAQ,KAAK,QAAQT,EAAK,EAAE;AAClC,mBAAWU,KAAUD,GAAO;AAC1B,gBAAME,IAAQ,KAAK,UAAUD,GAAQD,GAAOT,GAAMO,GAAMH,CAAG;AAC3D,cAAKO,GACL;AAAA,uBAAWR,KAAKQ,EAAM,cAAc,QAAQ,OAAOR,EAAE,EAAE;AACvD,YAAAG,EAAI,KAAKK,CAAK,GACdH,IAAW;AACX;AAAA;AAAA,QACF;AAAA,MACF;AAAA,IACF;AACA,WAAOF;AAAA,EACT;AAAA,EAEQ,UAAUI,GAAgBD,GAAiBT,GAAiBO,GAAcH,GAAgC;AAChH,UAAMQ,IAAK,KAAK,SAASF,GAAQN,CAAG,GAC9BS,IAAOJ,EACV,OAAO,CAACN,MAAMA,MAAMO,KAAU,KAAK,IAAIP,EAAE,SAASO,EAAO,MAAM,KAAK,KAAK,IAAIE,GAAI,KAAK,SAAST,GAAGC,CAAG,CAAC,CAAC,EACvG,KAAK,CAACH,GAAGC,MAAM,KAAK,IAAID,EAAE,SAASS,EAAO,MAAM,IAAI,KAAK,IAAIR,EAAE,SAASQ,EAAO,MAAM,KAAKT,EAAE,QAAQC,EAAE,KAAK,GACxGY,IAASC,EAAW,CAACL,CAAM,GAAGG,GAAMN,CAAI;AAC9C,QAAI,CAACO,EAAQ,QAAO;AACpB,UAAME,IAAQC,EAAaH,GAAQd,EAAK,OAAOA,EAAK,QAAQ;AAC5D,WAAKgB,IACE,EAAE,MAAMhB,EAAK,IAAI,SAASc,GAAQ,OAAAE,EAAA,IADtB;AAAA,EAErB;AACF;AAGA,SAASD,EAAWG,GAAiBC,GAAgBZ,GAA+B;AAClF,QAAMa,IAAOF,EAAM,OAAO,CAACG,GAAGlB,MAAMkB,IAAIlB,EAAE,QAAQ,QAAQ,CAAC;AAC3D,MAAIiB,MAASb,EAAM,QAAOW;AAC1B,MAAIE,IAAOb,EAAM,QAAO;AACxB,QAAMe,IAAmB,CAAA;AACzB,MAAIC,IAAS;AACb,QAAMC,IAAS,CAACC,GAAcC,MAA0B;AACtD,QAAIA,MAAS,EAAG,QAAO;AACvB,QAAI,EAAEH,IAAS,EAAG,QAAO;AACzB,aAASI,IAAIF,GAAME,IAAIR,EAAK,QAAQQ,KAAK;AACvC,YAAMxB,IAAIgB,EAAKQ,CAAC;AAChB,UAAI,EAAAxB,EAAE,QAAQ,SAASuB,IAEvB;AAAA,YADAJ,EAAO,KAAKnB,CAAC,GACTqB,EAAOG,IAAI,GAAGD,IAAOvB,EAAE,QAAQ,MAAM,EAAG,QAAO;AACnD,QAAAmB,EAAO,IAAA;AAAA;AAAA,IACT;AACA,WAAO;AAAA,EACT;AACA,SAAOE,EAAO,GAAGjB,IAAOa,CAAI,IAAI,CAAC,GAAGF,GAAO,GAAGI,CAAM,IAAI;AAC1D;AAMO,SAASL,EAAaW,GAA2BZ,GAAea,GAAiC;AACtG,QAAMC,IAAS,CAAC,GAAGF,CAAM,EAAE,KAAK,CAAC3B,GAAGC,MAAMA,EAAE,QAAQ,SAASD,EAAE,QAAQ,UAAUC,EAAE,SAASD,EAAE,MAAM,GAC9F8B,IAAQ,MAAM,KAAK,EAAE,QAAQf,EAAA,GAAS,OAAO,EAAE,KAAK,CAAA,GAAgB,QAAQ,IAAI,GAChFgB,IAAQ,CAACL,MAAuB;AACpC,QAAIA,MAAMG,EAAO,OAAQ,QAAO;AAChC,UAAMG,IAAIH,EAAOH,CAAC,GACZO,IAAQ,CAAC,GAAGH,EAAM,KAAA,CAAM,EAAE,KAAK,CAAC,GAAG7B,MAAM6B,EAAM,CAAC,EAAG,SAASA,EAAM7B,CAAC,EAAG,UAAU6B,EAAM,CAAC,EAAG,IAAI,SAASA,EAAM7B,CAAC,EAAG,IAAI,MAAM;AACjI,eAAWiC,KAAKD,GAAO;AACrB,YAAME,IAAOL,EAAMI,CAAC;AACpB,UAAI,EAAAC,EAAK,IAAI,SAASH,EAAE,QAAQ,SAASJ,IAGzC;AAAA,YAFAO,EAAK,IAAI,KAAK,GAAGH,EAAE,OAAO,GAC1BG,EAAK,UAAUH,EAAE,SAASA,EAAE,QAAQ,QAChCD,EAAML,IAAI,CAAC,EAAG,QAAO;AACzB,QAAAS,EAAK,IAAI,UAAUH,EAAE,QAAQ,QAC7BG,EAAK,UAAUH,EAAE,SAASA,EAAE,QAAQ;AAAA;AAAA,IACtC;AACA,WAAO;AAAA,EACT;AACA,SAAOD,EAAM,CAAC,IAAID,EAAM,IAAI,CAACI,MAAMA,EAAE,GAAG,IAAI;AAC9C;"}

package/dist/net/movement.js

@@ -0,0 +1,83 @@
+import { BODY_HALF_WIDTH as D, BODY_HALF_HEIGHT as M, COLLISION_EPSILON as y, INPUT_FLAG_DASH as x, INPUT_STEP_DT as H } from "./constants.js";
+const u = 0.7071067811865476;
+function W(t, e, o, h, f = {}) {
+  if (h.length !== t * e)
+    throw new Error(`collision string length ${h.length} != ${t}x${e}`);
+  const n = new Uint8Array(t * e);
+  for (let c = 0; c < n.length; c++) n[c] = h.charCodeAt(c) === 49 ? 1 : 0;
+  const { ground: r } = f, s = new Set(f.shotOverTiles ?? []);
+  let l;
+  if (r && r.length === n.length && s.size) {
+    l = new Uint8Array(n.length);
+    for (let c = 0; c < n.length; c++) l[c] = n[c] && s.has(r[c]) ? 1 : 0;
+  }
+  const a = f.bodyHalfWidth ?? D, d = f.bodyHalfHeight ?? M;
+  return l ? { width: t, height: e, tileSize: o, solid: n, shotOver: l, bodyHalfWidth: a, bodyHalfHeight: d } : { width: t, height: e, tileSize: o, solid: n, bodyHalfWidth: a, bodyHalfHeight: d };
+}
+function A(t, e, o) {
+  return i(t, e, o) ? t.shotOver?.[o * t.width + e] !== 1 : !1;
+}
+function C(t, e) {
+  return { x: t, y: e, lastDx: 1, lastDy: 0, dashLeft: 0, dashCd: 0, dashDx: 1, dashDy: 0 };
+}
+function i(t, e, o) {
+  return e < 0 || o < 0 || e >= t.width || o >= t.height ? !0 : t.solid[o * t.width + e] === 1;
+}
+function O(t, e, o) {
+  const h = t.tileSize, f = Math.floor((e - t.bodyHalfWidth) / h), n = Math.floor((e + t.bodyHalfWidth) / h), r = Math.floor((o - t.bodyHalfHeight) / h), s = Math.floor((o + t.bodyHalfHeight) / h);
+  for (let l = r; l <= s; l++)
+    for (let a = f; a <= n; a++)
+      if (i(t, a, l)) return !0;
+  return !1;
+}
+function L(t, e, o, h) {
+  if (h === 0) return e;
+  const f = t.tileSize, n = e + h, r = Math.floor((o - t.bodyHalfHeight) / f), s = Math.floor((o + t.bodyHalfHeight) / f);
+  if (h > 0) {
+    const l = Math.floor((n + t.bodyHalfWidth) / f);
+    for (let a = r; a <= s; a++)
+      if (i(t, l, a)) return l * f - t.bodyHalfWidth - y;
+  } else {
+    const l = Math.floor((n - t.bodyHalfWidth) / f);
+    for (let a = r; a <= s; a++)
+      if (i(t, l, a)) return (l + 1) * f + t.bodyHalfWidth + y;
+  }
+  return n;
+}
+function S(t, e, o, h) {
+  if (h === 0) return o;
+  const f = t.tileSize, n = o + h, r = Math.floor((e - t.bodyHalfWidth) / f), s = Math.floor((e + t.bodyHalfWidth) / f);
+  if (h > 0) {
+    const l = Math.floor((n + t.bodyHalfHeight) / f);
+    for (let a = r; a <= s; a++)
+      if (i(t, a, l)) return l * f - t.bodyHalfHeight - y;
+  } else {
+    const l = Math.floor((n - t.bodyHalfHeight) / f);
+    for (let a = r; a <= s; a++)
+      if (i(t, a, l)) return (l + 1) * f + t.bodyHalfHeight + y;
+  }
+  return n;
+}
+function b(t) {
+  return t > 0 ? 1 : t < 0 ? -1 : 0;
+}
+function _(t, e, o, h) {
+  t.dashCd > 0 && t.dashCd--;
+  const f = t.dashLeft > 0;
+  let n = o.canMove && !f ? b(e[0]) : 0, r = o.canMove && !f ? b(e[1]) : 0;
+  n !== 0 && r !== 0 && (n = n * u, r = r * u), (n !== 0 || r !== 0) && (t.lastDx = n, t.lastDy = r), (e[2] & x) !== 0 && o.canDash && o.canMove && t.dashLeft === 0 && t.dashCd === 0 && (t.dashLeft = o.dashSteps, t.dashCd = o.dashCooldownSteps, t.dashDx = t.lastDx, t.dashDy = t.lastDy);
+  let s, l;
+  t.dashLeft > 0 ? (s = t.dashDx * o.dashSpeed, l = t.dashDy * o.dashSpeed, t.dashLeft--) : (s = n * o.speed, l = r * o.speed), t.x = L(h, t.x, t.y, s * H), t.y = S(h, t.x, t.y, l * H);
+}
+export {
+  u as DIAGONAL,
+  A as blocksShot,
+  O as bodyCollides,
+  W as createCollisionGrid,
+  C as createMover,
+  i as isSolidTile,
+  L as moveX,
+  S as moveY,
+  _ as stepMover
+};
+//# sourceMappingURL=movement.js.map

package/dist/net/movement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"movement.js","sources":["../../src/net/movement.ts"],"sourcesContent":["import {\n  BODY_HALF_HEIGHT,\n  BODY_HALF_WIDTH,\n  COLLISION_EPSILON,\n  INPUT_FLAG_DASH,\n  INPUT_STEP_DT,\n  type InputStep,\n  type MovementParams,\n} from './constants';\n\n/*\n * Deterministic player movement simulation.\n *\n * The server runs this exact algorithm (or a port of it) as the authority;\n * the client runs it for prediction and replays unacknowledged steps after every snapshot.\n * Keep the operation order identical on both sides so floating point results match bit for bit.\n */\n\n/** 1/sqrt(2), written as a literal so every port uses the exact same double. */\nexport const DIAGONAL = 0.7071067811865476;\n\nexport interface CollisionGrid {\n  readonly width: number;\n  readonly height: number;\n  readonly tileSize: number;\n  /** 1 = solid, row-major. */\n  readonly solid: Uint8Array;\n  /** 1 = a solid tile a shot flies over (`shotOverTiles`), row-major; absent when the ground was not given. */\n  readonly shotOver?: Uint8Array;\n  /** Half the moving body's collision box, px. */\n  readonly bodyHalfWidth: number;\n  readonly bodyHalfHeight: number;\n}\n\nexport interface CollisionGridOptions {\n  /** The tile id of every cell, row-major; needed only for `shotOverTiles`. */\n  ground?: readonly number[];\n  /** Tile ids nothing walks but a shot flies over (water, lava…): solid for bodies, open for shots. */\n  shotOverTiles?: Iterable<number>;\n  /** Half the moving body's collision box, px (default `BODY_HALF_WIDTH` × `BODY_HALF_HEIGHT`, a 10×6 foot box). */\n  bodyHalfWidth?: number;\n  bodyHalfHeight?: number;\n}\n\nexport interface MoverState {\n  x: number;\n  y: number;\n  /** Last non-zero movement direction (normalized), used for dashing while idle. */\n  lastDx: number;\n  lastDy: number;\n  dashLeft: number;\n  dashCd: number;\n  dashDx: number;\n  dashDy: number;\n}\n\n/** A grid from a string of '0'/'1' per cell (row-major, '1' solid). */\nexport function createCollisionGrid(width: number, height: number, tileSize: number, solid: string, options: CollisionGridOptions = {}): CollisionGrid {\n  if (solid.length !== width * height) {\n    throw new Error(`collision string length ${solid.length} != ${width}x${height}`);\n  }\n  const bytes = new Uint8Array(width * height);\n  for (let i = 0; i < bytes.length; i++) bytes[i] = solid.charCodeAt(i) === 49 ? 1 : 0;\n  const { ground } = options;\n  const over = new Set(options.shotOverTiles ?? []);\n  let shotOver: Uint8Array | undefined;\n  if (ground && ground.length === bytes.length && over.size) {\n    shotOver = new Uint8Array(bytes.length);\n    for (let i = 0; i < bytes.length; i++) shotOver[i] = bytes[i] && over.has(ground[i]!) ? 1 : 0;\n  }\n  const bodyHalfWidth = options.bodyHalfWidth ?? BODY_HALF_WIDTH;\n  const bodyHalfHeight = options.bodyHalfHeight ?? BODY_HALF_HEIGHT;\n  return shotOver ? { width, height, tileSize, solid: bytes, shotOver, bodyHalfWidth, bodyHalfHeight } : { width, height, tileSize, solid: bytes, bodyHalfWidth, bodyHalfHeight };\n}\n\n/** Whether a shot in flight stops on this tile: solid, and not ground a shot flies over (`shotOverTiles`). */\nexport function blocksShot(grid: CollisionGrid, tx: number, ty: number): boolean {\n  if (!isSolidTile(grid, tx, ty)) return false;\n  return grid.shotOver?.[ty * grid.width + tx] !== 1;\n}\n\nexport function createMover(x: number, y: number): MoverState {\n  return { x, y, lastDx: 1, lastDy: 0, dashLeft: 0, dashCd: 0, dashDx: 1, dashDy: 0 };\n}\n\nexport function isSolidTile(grid: CollisionGrid, tx: number, ty: number): boolean {\n  if (tx < 0 || ty < 0 || tx >= grid.width || ty >= grid.height) return true;\n  return grid.solid[ty * grid.width + tx] === 1;\n}\n\n/** True if the body box centered at (x, y) overlaps a solid tile. */\nexport function bodyCollides(grid: CollisionGrid, x: number, y: number): boolean {\n  const ts = grid.tileSize;\n  const x0 = Math.floor((x - grid.bodyHalfWidth) / ts);\n  const x1 = Math.floor((x + grid.bodyHalfWidth) / ts);\n  const y0 = Math.floor((y - grid.bodyHalfHeight) / ts);\n  const y1 = Math.floor((y + grid.bodyHalfHeight) / ts);\n  for (let ty = y0; ty <= y1; ty++) {\n    for (let tx = x0; tx <= x1; tx++) {\n      if (isSolidTile(grid, tx, ty)) return true;\n    }\n  }\n  return false;\n}\n\n/** Moves along X by dx, stopping flush against the first solid tile column. */\nexport function moveX(grid: CollisionGrid, x: number, y: number, dx: number): number {\n  if (dx === 0) return x;\n  const ts = grid.tileSize;\n  const nx = x + dx;\n  const y0 = Math.floor((y - grid.bodyHalfHeight) / ts);\n  const y1 = Math.floor((y + grid.bodyHalfHeight) / ts);\n  if (dx > 0) {\n    const tx = Math.floor((nx + grid.bodyHalfWidth) / ts);\n    for (let ty = y0; ty <= y1; ty++) {\n      if (isSolidTile(grid, tx, ty)) return tx * ts - grid.bodyHalfWidth - COLLISION_EPSILON;\n    }\n  } else {\n    const tx = Math.floor((nx - grid.bodyHalfWidth) / ts);\n    for (let ty = y0; ty <= y1; ty++) {\n      if (isSolidTile(grid, tx, ty)) return (tx + 1) * ts + grid.bodyHalfWidth + COLLISION_EPSILON;\n    }\n  }\n  return nx;\n}\n\n/** Moves along Y by dy, stopping flush against the first solid tile row. */\nexport function moveY(grid: CollisionGrid, x: number, y: number, dy: number): number {\n  if (dy === 0) return y;\n  const ts = grid.tileSize;\n  const ny = y + dy;\n  const x0 = Math.floor((x - grid.bodyHalfWidth) / ts);\n  const x1 = Math.floor((x + grid.bodyHalfWidth) / ts);\n  if (dy > 0) {\n    const ty = Math.floor((ny + grid.bodyHalfHeight) / ts);\n    for (let tx = x0; tx <= x1; tx++) {\n      if (isSolidTile(grid, tx, ty)) return ty * ts - grid.bodyHalfHeight - COLLISION_EPSILON;\n    }\n  } else {\n    const ty = Math.floor((ny - grid.bodyHalfHeight) / ts);\n    for (let tx = x0; tx <= x1; tx++) {\n      if (isSolidTile(grid, tx, ty)) return (ty + 1) * ts + grid.bodyHalfHeight + COLLISION_EPSILON;\n    }\n  }\n  return ny;\n}\n\nfunction clampAxis(v: number): number {\n  return v > 0 ? 1 : v < 0 ? -1 : 0;\n}\n\n/** Advances the mover by one fixed input step. Mutates `s`. */\nexport function stepMover(s: MoverState, step: InputStep, p: MovementParams, grid: CollisionGrid): void {\n  if (s.dashCd > 0) s.dashCd--;\n\n  // A dodge roll is committed: while it runs, input neither steers it nor aims the next one.\n  const rolling = s.dashLeft > 0;\n  let mx = p.canMove && !rolling ? clampAxis(step[0]) : 0;\n  let my = p.canMove && !rolling ? clampAxis(step[1]) : 0;\n  if (mx !== 0 && my !== 0) {\n    mx = mx * DIAGONAL;\n    my = my * DIAGONAL;\n  }\n  if (mx !== 0 || my !== 0) {\n    s.lastDx = mx;\n    s.lastDy = my;\n  }\n\n  if ((step[2] & INPUT_FLAG_DASH) !== 0 && p.canDash && p.canMove && s.dashLeft === 0 && s.dashCd === 0) {\n    s.dashLeft = p.dashSteps;\n    s.dashCd = p.dashCooldownSteps;\n    s.dashDx = s.lastDx;\n    s.dashDy = s.lastDy;\n  }\n\n  let vx: number;\n  let vy: number;\n  if (s.dashLeft > 0) {\n    vx = s.dashDx * p.dashSpeed;\n    vy = s.dashDy * p.dashSpeed;\n    s.dashLeft--;\n  } else {\n    vx = mx * p.speed;\n    vy = my * p.speed;\n  }\n\n  s.x = moveX(grid, s.x, s.y, vx * INPUT_STEP_DT);\n  s.y = moveY(grid, s.x, s.y, vy * INPUT_STEP_DT);\n}\n"],"names":["DIAGONAL","createCollisionGrid","width","height","tileSize","solid","options","bytes","i","ground","over","shotOver","bodyHalfWidth","BODY_HALF_WIDTH","bodyHalfHeight","BODY_HALF_HEIGHT","blocksShot","grid","tx","ty","isSolidTile","createMover","x","y","bodyCollides","ts","x0","x1","y0","y1","moveX","dx","nx","COLLISION_EPSILON","moveY","dy","ny","clampAxis","v","stepMover","s","step","p","rolling","mx","my","INPUT_FLAG_DASH","vx","vy","INPUT_STEP_DT"],"mappings":"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"}

package/dist/net/protocol.js

@@ -0,0 +1,11 @@
+function d(a) {
+  return [a.x, a.y, a.lastDx, a.lastDy, a.dashLeft, a.dashCd, a.dashDx, a.dashDy];
+}
+function r(a, s) {
+  return [s.x, s.y, s.lastDx, s.lastDy, s.dashLeft, s.dashCd, s.dashDx, s.dashDy] = a, s;
+}
+export {
+  r as moverFromWire,
+  d as moverToWire
+};
+//# sourceMappingURL=protocol.js.map

package/dist/net/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sources":["../../src/net/protocol.ts"],"sourcesContent":["import type { EntityUpdate, InputStep } from './constants';\nimport type { MoverState } from './movement';\n\n/*\n * The engine's netcode messages. JSON, but for snapshots that carry body updates, which travel as one binary frame\n * (`encodeSnapshotFrame`). A game adds its own messages beside these: anything with a `t` the engine does not know\n * is handed to the game untouched.\n */\n\n/** Client → server. */\nexport type ClientMessage =\n  /** Asks to join; `data` is the game's own (a name, a character). */\n  | { t: 'hello'; data?: unknown }\n  /** Input steps `seq`, `seq + 1`, … taken since the last send. */\n  | { t: 'input'; seq: number; steps: InputStep[] }\n  /** A ping carrying the client's own clock, answered by a pong. */\n  | { t: 'ping'; c: number };\n\n/** Server → client. */\nexport type ServerMessage =\n  | { t: 'welcome'; id: number; tick: number; stepRate: number; snapRate: number }\n  | { t: 'pong'; c: number; st: number }\n  | Snapshot;\n\n/** A body's whole mover, so a client can rewind to it exactly: x, y, lastDx, lastDy, dashLeft, dashCd, dashDx, dashDy. */\nexport type MoverWire = [number, number, number, number, number, number, number, number];\n\n/** A body coming into view: its id and the game's own description of it (what it looks like). */\nexport interface SpawnInfo {\n  id: number;\n  data?: unknown;\n}\n\nexport interface Snapshot {\n  t: 'snap';\n  /** The server's step count when it was taken. */\n  tick: number;\n  /** The server's wall time when it was taken (ms since the epoch), for interpolation. */\n  time: number;\n  /** The last input step of this client the server has applied (-1 before any). */\n  ack: number;\n  /** This client's own body, whole, as of `ack`. */\n  me?: MoverWire;\n  /** Bodies that came into view. */\n  sp?: SpawnInfo[];\n  /** Bodies that left view. */\n  rm?: number[];\n  /** Every body in view: [id, x, y, aim, anim, hp, flags]. */\n  up?: EntityUpdate[];\n}\n\nexport function moverToWire(m: MoverState): MoverWire {\n  return [m.x, m.y, m.lastDx, m.lastDy, m.dashLeft, m.dashCd, m.dashDx, m.dashDy];\n}\n\nexport function moverFromWire(w: MoverWire, into: MoverState): MoverState {\n  [into.x, into.y, into.lastDx, into.lastDy, into.dashLeft, into.dashCd, into.dashDx, into.dashDy] = w;\n  return into;\n}\n"],"names":["moverToWire","m","moverFromWire","w","into"],"mappings":"AAmDO,SAASA,EAAYC,GAA0B;AACpD,SAAO,CAACA,EAAE,GAAGA,EAAE,GAAGA,EAAE,QAAQA,EAAE,QAAQA,EAAE,UAAUA,EAAE,QAAQA,EAAE,QAAQA,EAAE,MAAM;AAChF;AAEO,SAASC,EAAcC,GAAcC,GAA8B;AACxE,UAACA,EAAK,GAAGA,EAAK,GAAGA,EAAK,QAAQA,EAAK,QAAQA,EAAK,UAAUA,EAAK,QAAQA,EAAK,QAAQA,EAAK,MAAM,IAAID,GAC5FC;AACT;"}

package/dist/net/serverClock.js

@@ -0,0 +1,22 @@
+const u = 2e3;
+let n = 0, i = 1 / 0, f = 0, r = !1;
+function S() {
+  return Date.now() + n;
+}
+function _() {
+  return n;
+}
+function c(o, e, t = Date.now()) {
+  !Number.isFinite(o) || !Number.isFinite(e) || e < 0 || e > 2e3 || r && e > i && t - f < 6e4 || (n = o + e / 2 - t, i = e, f = t, r = !0);
+}
+function l() {
+  n = 0, i = 1 / 0, f = 0, r = !1;
+}
+export {
+  u as MAX_SAMPLE_RTT_MS,
+  c as noteServerTime,
+  l as resetServerClock,
+  S as serverNow,
+  _ as serverOffset
+};
+//# sourceMappingURL=serverClock.js.map

package/dist/net/serverClock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverClock.js","sources":["../../src/net/serverClock.ts"],"sourcesContent":["/*\n * The server's clock, as this client best knows it. Everything the game reckons from wall time — the time of day,\n * the weather, timetables, daily resets — reads `serverNow()` instead\n * of `Date.now()`, so a phone whose clock is a few minutes off still sees the sky and the resets everyone else sees.\n *\n * The offset comes from timed exchanges: every pong (the server's time when it answered, against the ping's own\n * round trip) and any request that returns the server's time. The sample with the shortest round trip wins, since its\n * midpoint is the tightest guess; a sample older than a minute gives way to the next one so a drifting clock is\n * followed. Until the first one lands this device's own clock stands in (a game clock counting from the server's start must never\n * seed this). An offline game is its own server, so there the offset is zero.\n */\n\n/** A timed sample this old gives way to a new one, even a slower one. */\nconst STALE_MS = 60_000;\n/** A sample whose round trip took longer than this says too little about when the server answered: it is passed over. */\nexport const MAX_SAMPLE_RTT_MS = 2000;\n\nlet offset = 0;\nlet bestRtt = Infinity;\nlet takenAt = 0;\nlet timed = false;\n\n/** Server wall time now, in ms since the epoch. */\nexport function serverNow(): number {\n  return Date.now() + offset;\n}\n\n/** The current estimate of server time minus this device's time, in ms. */\nexport function serverOffset(): number {\n  return offset;\n}\n\n/**\n * A server timestamp `serverMs` taken halfway through an exchange that took `rttMs` to come back: the server's clock\n * then stood at `serverMs + rttMs / 2` of this device's now.\n */\nexport function noteServerTime(serverMs: number, rttMs: number, now = Date.now()): void {\n  if (!Number.isFinite(serverMs) || !Number.isFinite(rttMs) || rttMs < 0 || rttMs > MAX_SAMPLE_RTT_MS) return;\n  if (timed && rttMs > bestRtt && now - takenAt < STALE_MS) return;\n  offset = serverMs + rttMs / 2 - now;\n  bestRtt = rttMs;\n  takenAt = now;\n  timed = true;\n}\n\n/** Back to this device's own clock (offline, or leaving a server). */\nexport function resetServerClock(): void {\n  offset = 0;\n  bestRtt = Infinity;\n  takenAt = 0;\n  timed = false;\n}\n"],"names":["MAX_SAMPLE_RTT_MS","offset","bestRtt","takenAt","timed","serverNow","serverOffset","noteServerTime","serverMs","rttMs","now","resetServerClock"],"mappings":"AAeO,MAAMA,IAAoB;AAEjC,IAAIC,IAAS,GACTC,IAAU,OACVC,IAAU,GACVC,IAAQ;AAGL,SAASC,IAAoB;AAClC,SAAO,KAAK,QAAQJ;AACtB;AAGO,SAASK,IAAuB;AACrC,SAAOL;AACT;AAMO,SAASM,EAAeC,GAAkBC,GAAeC,IAAM,KAAK,OAAa;AACtF,EAAI,CAAC,OAAO,SAASF,CAAQ,KAAK,CAAC,OAAO,SAASC,CAAK,KAAKA,IAAQ,KAAKA,IAAQ,OAC9EL,KAASK,IAAQP,KAAWQ,IAAMP,IAAU,QAChDF,IAASO,IAAWC,IAAQ,IAAIC,GAChCR,IAAUO,GACVN,IAAUO,GACVN,IAAQ;AACV;AAGO,SAASO,IAAyB;AACvC,EAAAV,IAAS,GACTC,IAAU,OACVC,IAAU,GACVC,IAAQ;AACV;"}

package/dist/net/snapshotCodec.js

@@ -0,0 +1,92 @@
+const h = 1, d = 5, b = 16, M = 8, y = 256, c = Math.PI * 2;
+function E(t, n, r) {
+  if (!Number.isFinite(t)) return Number.isNaN(t) ? 0 : t > 0 ? r : n;
+  const e = Math.round(t);
+  return e < n ? n : e > r ? r : e;
+}
+function s(t) {
+  return E(t * 8, -32768, 32767);
+}
+function T(t) {
+  return Number.isFinite(t) ? (Math.round(t * 256 / c) % 256 + 256) % 256 : 0;
+}
+function a(t) {
+  return (t >= 256 / 2 ? t - 256 : t) * c / 256;
+}
+function i(t, n, r) {
+  t.setInt32(n, E(r[0], -2147483648, 2147483647)), t.setInt16(n + 4, s(r[1])), t.setInt16(n + 6, s(r[2])), t.setUint8(n + 8, T(r[3])), t.setUint8(n + 9, E(r[4], 0, 255)), t.setInt32(n + 10, E(r[5], -2147483648, 2147483647)), t.setUint16(n + 14, E(r[6], 0, 65535));
+}
+function D(t, n) {
+  return [
+    t.getInt32(n),
+    t.getInt16(n + 4) / 8,
+    t.getInt16(n + 6) / 8,
+    a(t.getUint8(n + 8)),
+    t.getUint8(n + 9),
+    t.getInt32(n + 10),
+    t.getUint16(n + 14)
+  ];
+}
+function N(t) {
+  const n = new Uint8Array(t.length * 16), r = new DataView(n.buffer);
+  for (let e = 0; e < t.length; e++) i(r, e * 16, t[e]);
+  return n;
+}
+function u(t) {
+  if (t.byteLength % 16 !== 0) throw new Error(`update block of ${t.byteLength} bytes`);
+  const n = new DataView(t.buffer, t.byteOffset, t.byteLength), r = [];
+  for (let e = 0; e < t.byteLength; e += 16) r.push(D(n, e));
+  return r;
+}
+function I(t) {
+  const n = new Array(t.length);
+  for (let r = 0; r < t.length; r++) {
+    const e = t[r];
+    n[r] = [
+      E(e[0], -2147483648, 2147483647) + 0,
+      s(e[1]) / 8 + 0,
+      s(e[2]) / 8 + 0,
+      a(T(e[3])),
+      E(e[4], 0, 255) + 0,
+      E(e[5], -2147483648, 2147483647) + 0,
+      E(e[6], 0, 65535) + 0
+    ];
+  }
+  return n;
+}
+const P = globalThis, R = new P.TextEncoder(), g = new P.TextDecoder();
+function O(t) {
+  const { up: n, ...r } = t, e = R.encode(JSON.stringify(r)), S = n?.length ? n.length : 0, A = new Uint8Array(5 + e.byteLength + S * 16), o = new DataView(A.buffer);
+  o.setUint8(0, 1), o.setUint32(1, e.byteLength), A.set(e, 5);
+  const U = 5 + e.byteLength;
+  for (let _ = 0; _ < S; _++) i(o, U + _ * 16, n[_]);
+  return A;
+}
+function f(t) {
+  const n = t instanceof Uint8Array ? t : new Uint8Array(t);
+  if (n.byteLength < 5) throw new Error("short snapshot frame");
+  const r = new DataView(n.buffer, n.byteOffset, n.byteLength), e = r.getUint8(0);
+  if (e !== 1) throw new Error(`unknown binary frame tag ${e}`);
+  const A = 5 + r.getUint32(1);
+  if (A > n.byteLength) throw new Error("snapshot frame JSON overruns the frame");
+  const o = JSON.parse(g.decode(n.subarray(5, A)));
+  return A < n.byteLength && (o.up = u(n.subarray(A))), o;
+}
+export {
+  d as SNAP_FRAME_HEADER_BYTES,
+  h as SNAP_FRAME_TAG,
+  y as UPDATE_AIM_STEPS,
+  M as UPDATE_POS_SCALE,
+  b as UPDATE_RECORD_BYTES,
+  f as decodeSnapshotFrame,
+  u as decodeUpdates,
+  a as dequantizeAim,
+  O as encodeSnapshotFrame,
+  N as encodeUpdates,
+  T as quantizeAim,
+  s as quantizePos,
+  I as quantizeUpdates,
+  D as readUpdate,
+  i as writeUpdate
+};
+//# sourceMappingURL=snapshotCodec.js.map

package/dist/net/snapshotCodec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotCodec.js","sources":["../../src/net/snapshotCodec.ts"],"sourcesContent":["import type { EntityUpdate } from './constants';\n\n/** Any snapshot whose `up` block travels as binary records; the rest is JSON. */\nexport interface SnapshotLike {\n  up?: EntityUpdate[];\n}\n\n/**\n * Binary wire form of a snapshot's `up` block. A server in another language must write the same bytes.\n *\n * A snapshot that carries no updates is still one text frame of JSON. A snapshot that does is one **binary** WebSocket\n * frame, big-endian throughout:\n *\n * ```\n *   u8   SNAP_FRAME_TAG\n *   u32  L, the byte length of the JSON that follows\n *   L    UTF-8 JSON of the snapshot with `up` left out\n *   n × UPDATE_RECORD_BYTES, one record per EntityUpdate, n = (frame length - 5 - L) / 16\n * ```\n *\n * One record (16 bytes), the `[id, x, y, aim, anim, hp, flags]` tuple:\n *\n * | off | type  | field                                                                              |\n * |-----|-------|------------------------------------------------------------------------------------|\n * | 0   | i32   | id                                                                                 |\n * | 4   | i16   | x in 1/UPDATE_POS_SCALE px, clamped to [-32768, 32767] (−4096 … 4095.875 px)          |\n * | 6   | i16   | y, the same                                                                        |\n * | 8   | u8    | aim in 1/UPDATE_AIM_STEPS of a turn, wrapped; read back in [-π, π)                     |\n * | 9   | u8    | anim (ANIM), clamped to 0..255                                                     |\n * | 10  | i32   | hp (big bodies go past 65535)                                                      |\n * | 14  | u16   | flags (ENTITY_FLAG, nine bits used today), clamped to 0..65535                      |\n *\n * Quantisation error: position ≤ 1/16 px, aim ≤ π/256 rad. The position range holds maps up to 4096 px a side.\n * Each record is written once per actor state version on the server and shared by every viewer.\n */\nexport const SNAP_FRAME_TAG = 1;\n/** Tag byte + the u32 JSON length. */\nexport const SNAP_FRAME_HEADER_BYTES = 5;\nexport const UPDATE_RECORD_BYTES = 16;\nexport const UPDATE_POS_SCALE = 8;\nexport const UPDATE_AIM_STEPS = 256;\n\nconst TURN = Math.PI * 2;\n\nfunction clampInt(v: number, lo: number, hi: number): number {\n  if (!Number.isFinite(v)) return Number.isNaN(v) ? 0 : v > 0 ? hi : lo;\n  const r = Math.round(v);\n  return r < lo ? lo : r > hi ? hi : r;\n}\n\n/** World px → the i16 on the wire. */\nexport function quantizePos(v: number): number {\n  return clampInt(v * UPDATE_POS_SCALE, -32768, 32767);\n}\n\n/** Radians → the u8 on the wire (wrapped, so any angle is accepted). */\nexport function quantizeAim(a: number): number {\n  if (!Number.isFinite(a)) return 0;\n  const s = Math.round((a * UPDATE_AIM_STEPS) / TURN);\n  return ((s % UPDATE_AIM_STEPS) + UPDATE_AIM_STEPS) % UPDATE_AIM_STEPS;\n}\n\nexport function dequantizeAim(b: number): number {\n  return ((b >= UPDATE_AIM_STEPS / 2 ? b - UPDATE_AIM_STEPS : b) * TURN) / UPDATE_AIM_STEPS;\n}\n\nexport function writeUpdate(view: DataView, off: number, u: EntityUpdate): void {\n  view.setInt32(off, clampInt(u[0], -0x80000000, 0x7fffffff));\n  view.setInt16(off + 4, quantizePos(u[1]));\n  view.setInt16(off + 6, quantizePos(u[2]));\n  view.setUint8(off + 8, quantizeAim(u[3]));\n  view.setUint8(off + 9, clampInt(u[4], 0, 255));\n  view.setInt32(off + 10, clampInt(u[5], -0x80000000, 0x7fffffff));\n  view.setUint16(off + 14, clampInt(u[6], 0, 0xffff));\n}\n\nexport function readUpdate(view: DataView, off: number): EntityUpdate {\n  return [\n    view.getInt32(off),\n    view.getInt16(off + 4) / UPDATE_POS_SCALE,\n    view.getInt16(off + 6) / UPDATE_POS_SCALE,\n    dequantizeAim(view.getUint8(off + 8)),\n    view.getUint8(off + 9),\n    view.getInt32(off + 10),\n    view.getUint16(off + 14),\n  ];\n}\n\nexport function encodeUpdates(ups: readonly EntityUpdate[]): Uint8Array {\n  const out = new Uint8Array(ups.length * UPDATE_RECORD_BYTES);\n  const view = new DataView(out.buffer);\n  for (let i = 0; i < ups.length; i++) writeUpdate(view, i * UPDATE_RECORD_BYTES, ups[i]!);\n  return out;\n}\n\nexport function decodeUpdates(bytes: Uint8Array): EntityUpdate[] {\n  if (bytes.byteLength % UPDATE_RECORD_BYTES !== 0) throw new Error(`update block of ${bytes.byteLength} bytes`);\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  const out: EntityUpdate[] = [];\n  for (let off = 0; off < bytes.byteLength; off += UPDATE_RECORD_BYTES) out.push(readUpdate(view, off));\n  return out;\n}\n\n/** The updates exactly as a client reads them off the wire: what a local simulation sends, so it quantises like the server. */\nexport function quantizeUpdates(ups: readonly EntityUpdate[]): EntityUpdate[] {\n  // Same numbers as decodeUpdates(encodeUpdates(ups)) without the byte round trip (`+ 0` turns -0 into 0, as a read does).\n  const out: EntityUpdate[] = new Array(ups.length);\n  for (let i = 0; i < ups.length; i++) {\n    const u = ups[i]!;\n    out[i] = [\n      clampInt(u[0], -0x80000000, 0x7fffffff) + 0,\n      quantizePos(u[1]) / UPDATE_POS_SCALE + 0,\n      quantizePos(u[2]) / UPDATE_POS_SCALE + 0,\n      dequantizeAim(quantizeAim(u[3])),\n      clampInt(u[4], 0, 255) + 0,\n      clampInt(u[5], -0x80000000, 0x7fffffff) + 0,\n      clampInt(u[6], 0, 0xffff) + 0,\n    ];\n  }\n  return out;\n}\n\ninterface TextCodecs {\n  TextEncoder: new () => { encode(s: string): Uint8Array };\n  TextDecoder: new () => { decode(b: Uint8Array): string };\n}\n// the protocol builds without DOM types; browsers and Node both have these\nconst text = globalThis as unknown as TextCodecs;\nconst encoder = new text.TextEncoder();\nconst decoder = new text.TextDecoder();\n\n/** A snapshot as the server frames it: binary when it carries updates (see the layout above). */\nexport function encodeSnapshotFrame<S extends SnapshotLike>(snap: S): Uint8Array {\n  const { up, ...rest } = snap;\n  const json = encoder.encode(JSON.stringify(rest));\n  const records = up?.length ? up.length : 0;\n  const out = new Uint8Array(SNAP_FRAME_HEADER_BYTES + json.byteLength + records * UPDATE_RECORD_BYTES);\n  const view = new DataView(out.buffer);\n  view.setUint8(0, SNAP_FRAME_TAG);\n  view.setUint32(1, json.byteLength);\n  out.set(json, SNAP_FRAME_HEADER_BYTES);\n  const base = SNAP_FRAME_HEADER_BYTES + json.byteLength;\n  for (let i = 0; i < records; i++) writeUpdate(view, base + i * UPDATE_RECORD_BYTES, up![i]!);\n  return out;\n}\n\n/** Reads a binary snapshot frame back into the same object a text frame parses to. */\nexport function decodeSnapshotFrame<S extends SnapshotLike>(frame: ArrayBuffer | Uint8Array): S {\n  const bytes = frame instanceof Uint8Array ? frame : new Uint8Array(frame);\n  if (bytes.byteLength < SNAP_FRAME_HEADER_BYTES) throw new Error('short snapshot frame');\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  const tag = view.getUint8(0);\n  if (tag !== SNAP_FRAME_TAG) throw new Error(`unknown binary frame tag ${tag}`);\n  const len = view.getUint32(1);\n  const base = SNAP_FRAME_HEADER_BYTES + len;\n  if (base > bytes.byteLength) throw new Error('snapshot frame JSON overruns the frame');\n  const snap = JSON.parse(decoder.decode(bytes.subarray(SNAP_FRAME_HEADER_BYTES, base))) as S;\n  if (base < bytes.byteLength) snap.up = decodeUpdates(bytes.subarray(base));\n  return snap;\n}\n"],"names":["SNAP_FRAME_TAG","SNAP_FRAME_HEADER_BYTES","UPDATE_RECORD_BYTES","UPDATE_POS_SCALE","UPDATE_AIM_STEPS","TURN","clampInt","v","lo","hi","r","quantizePos","quantizeAim","a","dequantizeAim","b","writeUpdate","view","off","u","readUpdate","encodeUpdates","ups","out","i","decodeUpdates","bytes","quantizeUpdates","text","encoder","decoder","encodeSnapshotFrame","snap","up","rest","json","records","base","decodeSnapshotFrame","frame","tag"],"mappings":"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"}

package/dist/parallax/Parallax.js

@@ -0,0 +1,32 @@
+import { Container as r } from "pixi.js";
+import { ParallaxLayer as s } from "./ParallaxLayer.js";
+class d {
+  view = new r({ sortableChildren: !0 });
+  list = [];
+  constructor(t = {}) {
+    this.view.zIndex = t.depth ?? -1e3;
+  }
+  get layers() {
+    return this.list;
+  }
+  /** Adds a layer (built here from options, or one made before); later layers draw in front unless a `depth` says. */
+  add(t) {
+    const i = t instanceof s ? t : new s(t);
+    return i.depth === void 0 && (i.view.zIndex = this.list.length), this.list.push(i), this.view.addChild(i.view), i;
+  }
+  /** Takes a layer out and destroys it. */
+  remove(t) {
+    const i = this.list.indexOf(t);
+    i < 0 || (this.list.splice(i, 1), t.destroy());
+  }
+  update(t, i) {
+    for (let e = 0; e < this.list.length; e++) this.list[e].update(t, i);
+  }
+  destroy() {
+    this.list.length = 0, this.view.destroy({ children: !0 });
+  }
+}
+export {
+  d as Parallax
+};
+//# sourceMappingURL=Parallax.js.map

package/dist/parallax/Parallax.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Parallax.js","sources":["../../src/parallax/Parallax.ts"],"sourcesContent":["import { Container } from 'pixi.js';\nimport { ParallaxLayer, type ParallaxCamera, type ParallaxLayerOptions } from './ParallaxLayer';\n\nexport interface ParallaxOptions {\n  /**\n   * Where the whole parallax sorts among the world layer's children (its `zIndex`, default -1000): below the level,\n   * so every layer stays behind it. A foreground layer (factor above 1) belongs in a second `Parallax` with a depth\n   * above the level's.\n   */\n  depth?: number;\n}\n\n/**\n * Layers of scenery behind (or before) the world, each scrolling at its own share of the camera's speed. Add `view`\n * to the world layer — a scene's `root` — and call `update(camera, dtMs)` once a frame after the camera moved, so\n * the layers sit where this frame's view is:\n *\n * ```ts\n * const sky = new Parallax();\n * sky.add({ texture: clouds, factorX: 0.1, repeatX: true, speedX: -6 });\n * sky.add({ display: hills, factorX: 0.5, factorY: 1 });\n * this.root.addChild(sky.view);\n * // each frame\n * sky.update(stage.cameras.main, dt * 1000);\n * ```\n */\nexport class Parallax {\n  readonly view = new Container({ sortableChildren: true });\n  private readonly list: ParallaxLayer[] = [];\n\n  constructor(options: ParallaxOptions = {}) {\n    this.view.zIndex = options.depth ?? -1000;\n  }\n\n  get layers(): readonly ParallaxLayer[] {\n    return this.list;\n  }\n\n  /** Adds a layer (built here from options, or one made before); later layers draw in front unless a `depth` says. */\n  add(layer: ParallaxLayer | ParallaxLayerOptions): ParallaxLayer {\n    const made = layer instanceof ParallaxLayer ? layer : new ParallaxLayer(layer);\n    if (made.depth === undefined) made.view.zIndex = this.list.length;\n    this.list.push(made);\n    this.view.addChild(made.view);\n    return made;\n  }\n\n  /** Takes a layer out and destroys it. */\n  remove(layer: ParallaxLayer): void {\n    const i = this.list.indexOf(layer);\n    if (i < 0) return;\n    this.list.splice(i, 1);\n    layer.destroy();\n  }\n\n  update(camera: ParallaxCamera, dtMs: number): void {\n    for (let i = 0; i < this.list.length; i++) this.list[i]!.update(camera, dtMs);\n  }\n\n  destroy(): void {\n    this.list.length = 0;\n    this.view.destroy({ children: true });\n  }\n}\n"],"names":["Parallax","Container","options","layer","made","ParallaxLayer","camera","dtMs","i"],"mappings":";;AA0BO,MAAMA,EAAS;AAAA,EACX,OAAO,IAAIC,EAAU,EAAE,kBAAkB,IAAM;AAAA,EACvC,OAAwB,CAAA;AAAA,EAEzC,YAAYC,IAA2B,IAAI;AACzC,SAAK,KAAK,SAASA,EAAQ,SAAS;AAAA,EACtC;AAAA,EAEA,IAAI,SAAmC;AACrC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,IAAIC,GAA4D;AAC9D,UAAMC,IAAOD,aAAiBE,IAAgBF,IAAQ,IAAIE,EAAcF,CAAK;AAC7E,WAAIC,EAAK,UAAU,aAAgB,KAAK,SAAS,KAAK,KAAK,SAC3D,KAAK,KAAK,KAAKA,CAAI,GACnB,KAAK,KAAK,SAASA,EAAK,IAAI,GACrBA;AAAA,EACT;AAAA;AAAA,EAGA,OAAOD,GAA4B;AACjC,UAAM,IAAI,KAAK,KAAK,QAAQA,CAAK;AACjC,IAAI,IAAI,MACR,KAAK,KAAK,OAAO,GAAG,CAAC,GACrBA,EAAM,QAAA;AAAA,EACR;AAAA,EAEA,OAAOG,GAAwBC,GAAoB;AACjD,aAASC,IAAI,GAAGA,IAAI,KAAK,KAAK,QAAQA,IAAK,MAAK,KAAKA,CAAC,EAAG,OAAOF,GAAQC,CAAI;AAAA,EAC9E;AAAA,EAEA,UAAgB;AACd,SAAK,KAAK,SAAS,GACnB,KAAK,KAAK,QAAQ,EAAE,UAAU,IAAM;AAAA,EACtC;AACF;"}

package/dist/parallax/ParallaxLayer.js

@@ -0,0 +1,70 @@
+import { Container as u, TilingSprite as X, Sprite as Y } from "pixi.js";
+import { wrap as f, placeAxis as a } from "./parallaxMath.js";
+class g {
+  view = new u();
+  factorX;
+  factorY;
+  offsetX;
+  offsetY;
+  speedX;
+  speedY;
+  snap;
+  cull;
+  /** The depth it was given, if any (a `Parallax` numbers the others in the order they were added). */
+  depth;
+  repeatX;
+  repeatY;
+  tiling = null;
+  tileW = 0;
+  tileH = 0;
+  /** The content's local bounds, measured once: reading bounds every frame walks the whole display tree. */
+  boundsX = 0;
+  boundsY = 0;
+  boundsW = 0;
+  boundsH = 0;
+  driftX = 0;
+  driftY = 0;
+  // scratch, so a frame allocates nothing
+  input = { scroll: 0, view: 0, factor: 0, offset: 0, repeat: !1, tile: 0, contentStart: 0, contentSize: 0, snap: !1 };
+  px = { position: 0, size: 0, phase: 0, visible: !0 };
+  py = { position: 0, size: 0, phase: 0, visible: !0 };
+  constructor(t) {
+    const { texture: e, display: s } = t;
+    if (!e == !s) throw new Error("ParallaxLayer: give exactly one of `texture` and `display`");
+    this.factorX = t.factorX ?? 0.5, this.factorY = t.factorY ?? this.factorX, this.offsetX = t.offsetX ?? 0, this.offsetY = t.offsetY ?? 0, this.speedX = t.speedX ?? 0, this.speedY = t.speedY ?? 0, this.snap = t.snap, this.cull = t.cull ?? !0, this.repeatX = e !== void 0 && t.repeatX === !0, this.repeatY = e !== void 0 && t.repeatY === !0, this.depth = t.depth, t.depth !== void 0 && (this.view.zIndex = t.depth), e ? (this.tileW = e.width, this.tileH = e.height, this.repeatX || this.repeatY ? (this.tiling = new X({ texture: e, width: e.width, height: e.height }), this.view.addChild(this.tiling)) : this.view.addChild(new Y(e))) : s && this.view.addChild(s), this.remeasure();
+  }
+  /** Measures the content again, after it was redrawn larger or smaller (culling reads the measured size). */
+  remeasure() {
+    if (this.tiling) {
+      this.boundsX = 0, this.boundsY = 0, this.boundsW = this.tileW, this.boundsH = this.tileH;
+      return;
+    }
+    const t = this.view.getLocalBounds();
+    this.boundsX = t.x, this.boundsY = t.y, this.boundsW = t.width, this.boundsH = t.height;
+  }
+  /** Places the layer for this frame; `dtMs` advances the drift. */
+  update(t, e) {
+    const s = e / 1e3;
+    this.driftX += this.speedX * s, this.driftY += this.speedY * s, this.repeatX && (this.driftX = f(this.driftX, this.tileW)), this.repeatY && (this.driftY = f(this.driftY, this.tileH));
+    const p = this.snap ?? t.roundPixels === !0, d = t.zoom > 0 ? t.zoom : 1, i = this.input;
+    i.snap = p, i.scroll = t.scrollX, i.view = t.width / d, i.factor = this.factorX, i.offset = this.offsetX + this.driftX, i.repeat = this.repeatX, i.tile = this.tileW, i.contentStart = this.boundsX, i.contentSize = this.boundsW;
+    const r = a(this.px, i);
+    i.scroll = t.scrollY, i.view = t.height / d, i.factor = this.factorY, i.offset = this.offsetY + this.driftY, i.repeat = this.repeatY, i.tile = this.tileH, i.contentStart = this.boundsY, i.contentSize = this.boundsH;
+    const o = a(this.py, i);
+    this.view.position.set(r.position, o.position);
+    const h = this.tiling;
+    if (h) {
+      const l = this.repeatX ? r.size : this.tileW, n = this.repeatY ? o.size : this.tileH;
+      (h.width !== l || h.height !== n) && h.setSize(l, n), h.tilePosition.set(r.phase, o.phase);
+    }
+    const c = t.width > 0 && t.height > 0;
+    this.view.visible = !this.cull || !c || r.visible && o.visible;
+  }
+  destroy() {
+    this.view.destroy({ children: !0 });
+  }
+}
+export {
+  g as ParallaxLayer
+};
+//# sourceMappingURL=ParallaxLayer.js.map

package/dist/parallax/ParallaxLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParallaxLayer.js","sources":["../../src/parallax/ParallaxLayer.ts"],"sourcesContent":["import { Container, Sprite, TilingSprite, type Texture } from 'pixi.js';\nimport { placeAxis, wrap, type AxisInput, type AxisPlacement } from './parallaxMath';\n\n/** What a parallax layer reads off the camera each frame; the engine's `Camera` has all of it. */\nexport interface ParallaxCamera {\n  readonly scrollX: number;\n  readonly scrollY: number;\n  readonly width: number;\n  readonly height: number;\n  readonly zoom: number;\n  /** Set on a pixel-perfect engine: a layer then lands on whole world pixels unless told otherwise. */\n  readonly roundPixels?: boolean;\n}\n\nexport interface ParallaxLayerOptions {\n  /**\n   * A texture to draw, repeated along the axes `repeatX` / `repeatY` name (one tiling sprite, as wide as the view\n   * whatever the level's length). Give either this or `display`.\n   */\n  texture?: Texture;\n  /** Anything already drawn (a sprite, a `Graphics`, a container of them), drawn once and never repeated. */\n  display?: Container;\n  /** Share of the camera's horizontal travel the layer moves on screen: 0 fixed to the screen, 1 with the world (default 0.5). */\n  factorX?: number;\n  /** The same vertically (default: `factorX`). */\n  factorY?: number;\n  /** Repeat the texture left and right forever (a `texture` layer only). */\n  repeatX?: boolean;\n  /** Repeat the texture up and down forever (a `texture` layer only). */\n  repeatY?: boolean;\n  /** World px added to the layer's position, e.g. where on the level a row of hills stands. */\n  offsetX?: number;\n  offsetY?: number;\n  /** Drift, world px a second, on top of the parallax (clouds). */\n  speedX?: number;\n  speedY?: number;\n  /** Land on whole world pixels (default: the camera's `roundPixels`, i.e. a pixel-perfect engine). */\n  snap?: boolean;\n  /** Hide the layer while none of it is in view (default true). Repeated layers always fill the view. */\n  cull?: boolean;\n  /** Order among the parallax's layers: lower draws further back (default: the order they were added in). */\n  depth?: number;\n}\n\n/**\n * One layer of a `Parallax`: a texture or a display object that scrolls at a share of the camera's speed, optionally\n * repeated and drifting. `view` goes into the world layer (the parallax adds it), so the camera's zoom and pixel\n * rounding apply to it like to any world object; the layer only moves it.\n */\nexport class ParallaxLayer {\n  readonly view = new Container();\n  factorX: number;\n  factorY: number;\n  offsetX: number;\n  offsetY: number;\n  speedX: number;\n  speedY: number;\n  snap: boolean | undefined;\n  cull: boolean;\n  /** The depth it was given, if any (a `Parallax` numbers the others in the order they were added). */\n  readonly depth: number | undefined;\n  private readonly repeatX: boolean;\n  private readonly repeatY: boolean;\n  private readonly tiling: TilingSprite | null = null;\n  private readonly tileW: number = 0;\n  private readonly tileH: number = 0;\n  /** The content's local bounds, measured once: reading bounds every frame walks the whole display tree. */\n  private boundsX = 0;\n  private boundsY = 0;\n  private boundsW = 0;\n  private boundsH = 0;\n  private driftX = 0;\n  private driftY = 0;\n  // scratch, so a frame allocates nothing\n  private readonly input: AxisInput = { scroll: 0, view: 0, factor: 0, offset: 0, repeat: false, tile: 0, contentStart: 0, contentSize: 0, snap: false };\n  private readonly px: AxisPlacement = { position: 0, size: 0, phase: 0, visible: true };\n  private readonly py: AxisPlacement = { position: 0, size: 0, phase: 0, visible: true };\n\n  constructor(options: ParallaxLayerOptions) {\n    const { texture, display } = options;\n    if (!texture === !display) throw new Error('ParallaxLayer: give exactly one of `texture` and `display`');\n    this.factorX = options.factorX ?? 0.5;\n    this.factorY = options.factorY ?? this.factorX;\n    this.offsetX = options.offsetX ?? 0;\n    this.offsetY = options.offsetY ?? 0;\n    this.speedX = options.speedX ?? 0;\n    this.speedY = options.speedY ?? 0;\n    this.snap = options.snap;\n    this.cull = options.cull ?? true;\n    this.repeatX = texture !== undefined && options.repeatX === true;\n    this.repeatY = texture !== undefined && options.repeatY === true;\n    this.depth = options.depth;\n    if (options.depth !== undefined) this.view.zIndex = options.depth;\n    if (texture) {\n      this.tileW = texture.width;\n      this.tileH = texture.height;\n      if (this.repeatX || this.repeatY) {\n        this.tiling = new TilingSprite({ texture, width: texture.width, height: texture.height });\n        this.view.addChild(this.tiling);\n      } else this.view.addChild(new Sprite(texture));\n    } else if (display) this.view.addChild(display);\n    this.remeasure();\n  }\n\n  /** Measures the content again, after it was redrawn larger or smaller (culling reads the measured size). */\n  remeasure(): void {\n    if (this.tiling) {\n      this.boundsX = 0;\n      this.boundsY = 0;\n      this.boundsW = this.tileW;\n      this.boundsH = this.tileH;\n      return;\n    }\n    const b = this.view.getLocalBounds();\n    this.boundsX = b.x;\n    this.boundsY = b.y;\n    this.boundsW = b.width;\n    this.boundsH = b.height;\n  }\n\n  /** Places the layer for this frame; `dtMs` advances the drift. */\n  update(camera: ParallaxCamera, dtMs: number): void {\n    const seconds = dtMs / 1000;\n    this.driftX += this.speedX * seconds;\n    this.driftY += this.speedY * seconds;\n    // a repeating drift only matters within one tile: kept there, it never grows until the floats lose pixels\n    if (this.repeatX) this.driftX = wrap(this.driftX, this.tileW);\n    if (this.repeatY) this.driftY = wrap(this.driftY, this.tileH);\n    const snap = this.snap ?? camera.roundPixels === true;\n    const zoom = camera.zoom > 0 ? camera.zoom : 1;\n    const a = this.input;\n    a.snap = snap;\n    a.scroll = camera.scrollX;\n    a.view = camera.width / zoom;\n    a.factor = this.factorX;\n    a.offset = this.offsetX + this.driftX;\n    a.repeat = this.repeatX;\n    a.tile = this.tileW;\n    a.contentStart = this.boundsX;\n    a.contentSize = this.boundsW;\n    const x = placeAxis(this.px, a);\n    a.scroll = camera.scrollY;\n    a.view = camera.height / zoom;\n    a.factor = this.factorY;\n    a.offset = this.offsetY + this.driftY;\n    a.repeat = this.repeatY;\n    a.tile = this.tileH;\n    a.contentStart = this.boundsY;\n    a.contentSize = this.boundsH;\n    const y = placeAxis(this.py, a);\n    this.view.position.set(x.position, y.position);\n    const tiling = this.tiling;\n    if (tiling) {\n      const w = this.repeatX ? x.size : this.tileW;\n      const h = this.repeatY ? y.size : this.tileH;\n      // resized only when the view's size changed: a resize marks the sprite's geometry dirty for the renderer\n      if (tiling.width !== w || tiling.height !== h) tiling.setSize(w, h);\n      tiling.tilePosition.set(x.phase, y.phase);\n    }\n    // a camera that has no size yet (before the first resize) shows everything rather than nothing\n    const sized = camera.width > 0 && camera.height > 0;\n    this.view.visible = !this.cull || !sized || (x.visible && y.visible);\n  }\n\n  destroy(): void {\n    this.view.destroy({ children: true });\n  }\n}\n"],"names":["ParallaxLayer","Container","options","texture","display","TilingSprite","Sprite","b","camera","dtMs","seconds","wrap","snap","zoom","a","x","placeAxis","y","tiling","w","h","sized"],"mappings":"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"}

package/dist/parallax/parallaxMath.js

@@ -0,0 +1,27 @@
+function l(n, e, i = 0) {
+  return n * (1 - e) + i;
+}
+function s(n, e) {
+  if (!(e > 0)) return 0;
+  const i = n % e;
+  return i < 0 ? i + e : i + 0;
+}
+function c(n, e, i, r, t = 0) {
+  return n < i + r + t && n + e > i - t;
+}
+function o(n, e) {
+  let i = l(e.scroll, e.factor, e.offset);
+  if (e.snap && (i = Math.round(i)), e.repeat && e.tile > 0) {
+    const r = e.snap ? Math.floor(e.scroll) : e.scroll;
+    n.position = r, n.size = Math.ceil(e.view) + 1, n.phase = s(i - r, e.tile), n.visible = !0;
+  } else
+    n.position = i, n.size = e.contentSize, n.phase = 0, n.visible = c(i + e.contentStart, e.contentSize, e.scroll, e.view);
+  return n;
+}
+export {
+  l as parallaxOrigin,
+  o as placeAxis,
+  c as spanVisible,
+  s as wrap
+};
+//# sourceMappingURL=parallaxMath.js.map

package/dist/parallax/parallaxMath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallaxMath.js","sources":["../../src/parallax/parallaxMath.ts"],"sourcesContent":["/**\n * The arithmetic of parallax, apart from anything that draws so it can be tested under node. One axis at a time:\n * the same functions serve x and y.\n */\n\n/**\n * The world position a layer is drawn at so that, on screen, it moves `factor` times as far as the camera: 0 stays\n * fixed to the screen (a sky at infinity), 1 moves with the world, 0.5 at half speed, above 1 faster (a foreground).\n * The layer lives in the world layer, so the camera's zoom scales it like everything else.\n */\nexport function parallaxOrigin(scroll: number, factor: number, offset = 0): number {\n  return scroll * (1 - factor) + offset;\n}\n\n/** `value` brought into [0, size): where a repeating pattern stands within one tile. 0 for an empty tile. */\nexport function wrap(value: number, size: number): number {\n  if (!(size > 0)) return 0;\n  const r = value % size;\n  // `+ 0` turns the -0 a negative multiple leaves into 0, which a tile position compares equal to anyway\n  return r < 0 ? r + size : r + 0;\n}\n\n/** Whether a span [start, start + size) overlaps the view [viewStart, viewStart + viewSize), `margin` px wider. */\nexport function spanVisible(start: number, size: number, viewStart: number, viewSize: number, margin = 0): boolean {\n  return start < viewStart + viewSize + margin && start + size > viewStart - margin;\n}\n\n/** Where one axis of a layer goes this frame; written into a caller's object so a frame allocates nothing. */\nexport interface AxisPlacement {\n  /** The layer's world position on this axis. */\n  position: number;\n  /** For a repeated axis, how long the tiled strip is (it covers the view); otherwise the content's own size. */\n  size: number;\n  /** For a repeated axis, the pattern's offset inside the strip (a tiling sprite's tile position), in [0, tile). */\n  phase: number;\n  /** For an axis that does not repeat, whether the content reaches into the view at all. */\n  visible: boolean;\n}\n\nexport interface AxisInput {\n  /** The camera's scroll on this axis (the world coordinate at the screen's edge). */\n  scroll: number;\n  /** How much of the world the view shows on this axis: the screen's size over the camera's zoom. */\n  view: number;\n  factor: number;\n  /** Fixed offset plus whatever auto-scroll has added. */\n  offset: number;\n  repeat: boolean;\n  /** One tile's size on this axis (repeated axes). */\n  tile: number;\n  /** Where the content's bounds begin from the layer's position, and how long they are (axes that do not repeat). */\n  contentStart: number;\n  contentSize: number;\n  /** Land on whole world pixels. */\n  snap: boolean;\n}\n\n/**\n * Places one axis. A repeated axis is a strip laid over the view, starting at the view's edge (floored to a whole\n * pixel when snapping), whose pattern is shifted so its tiles stand where the parallax puts them: the strip never\n * grows with the level, however long it is. An axis that does not repeat sits at its parallax origin and is visible\n * only while its content overlaps the view.\n */\nexport function placeAxis(out: AxisPlacement, a: AxisInput): AxisPlacement {\n  let origin = parallaxOrigin(a.scroll, a.factor, a.offset);\n  if (a.snap) origin = Math.round(origin);\n  if (a.repeat && a.tile > 0) {\n    const start = a.snap ? Math.floor(a.scroll) : a.scroll;\n    out.position = start;\n    // one pixel more than the view, for the part of a pixel the floor gave back\n    out.size = Math.ceil(a.view) + 1;\n    out.phase = wrap(origin - start, a.tile);\n    out.visible = true;\n  } else {\n    out.position = origin;\n    out.size = a.contentSize;\n    out.phase = 0;\n    out.visible = spanVisible(origin + a.contentStart, a.contentSize, a.scroll, a.view);\n  }\n  return out;\n}\n"],"names":["parallaxOrigin","scroll","factor","offset","wrap","value","size","r","spanVisible","start","viewStart","viewSize","margin","placeAxis","out","a","origin"],"mappings":"AAUO,SAASA,EAAeC,GAAgBC,GAAgBC,IAAS,GAAW;AACjF,SAAOF,KAAU,IAAIC,KAAUC;AACjC;AAGO,SAASC,EAAKC,GAAeC,GAAsB;AACxD,MAAI,EAAEA,IAAO,GAAI,QAAO;AACxB,QAAMC,IAAIF,IAAQC;AAElB,SAAOC,IAAI,IAAIA,IAAID,IAAOC,IAAI;AAChC;AAGO,SAASC,EAAYC,GAAeH,GAAcI,GAAmBC,GAAkBC,IAAS,GAAY;AACjH,SAAOH,IAAQC,IAAYC,IAAWC,KAAUH,IAAQH,IAAOI,IAAYE;AAC7E;AAsCO,SAASC,EAAUC,GAAoBC,GAA6B;AACzE,MAAIC,IAAShB,EAAee,EAAE,QAAQA,EAAE,QAAQA,EAAE,MAAM;AAExD,MADIA,EAAE,SAAMC,IAAS,KAAK,MAAMA,CAAM,IAClCD,EAAE,UAAUA,EAAE,OAAO,GAAG;AAC1B,UAAMN,IAAQM,EAAE,OAAO,KAAK,MAAMA,EAAE,MAAM,IAAIA,EAAE;AAChD,IAAAD,EAAI,WAAWL,GAEfK,EAAI,OAAO,KAAK,KAAKC,EAAE,IAAI,IAAI,GAC/BD,EAAI,QAAQV,EAAKY,IAASP,GAAOM,EAAE,IAAI,GACvCD,EAAI,UAAU;AAAA,EAChB;AACE,IAAAA,EAAI,WAAWE,GACfF,EAAI,OAAOC,EAAE,aACbD,EAAI,QAAQ,GACZA,EAAI,UAAUN,EAAYQ,IAASD,EAAE,cAAcA,EAAE,aAAaA,EAAE,QAAQA,EAAE,IAAI;AAEpF,SAAOD;AACT;"}

package/dist/particles/Emitter.js

@@ -0,0 +1,108 @@
+import { ParticleContainer as M, Particle as b } from "pixi.js";
+import { engineSettings as P } from "../settings.js";
+import { inView as v } from "../fx/viewCull.js";
+import { particleBudget as C } from "./ParticleBudget.js";
+import { ParticleSim as I } from "./ParticleSim.js";
+import { sampleCurve as w, sampleColor as S } from "./particleCurves.js";
+import { scaleCount as z, dueParticles as F, spreadAngle as X, sampleRange as y } from "./particleSampling.js";
+class R {
+  view;
+  x = 0;
+  y = 0;
+  /** Continuous emission on or off (bursts work either way). */
+  emitting = !1;
+  sim;
+  pool = [];
+  budget;
+  random;
+  opts;
+  carry = 0;
+  destroyed = !1;
+  /** Set by the last `update`: whether the emitter's point was near the screen. */
+  near = !0;
+  constructor(t) {
+    this.opts = t, this.sim = new I(t.capacity ?? 256), this.budget = t.budget ?? C, this.random = t.random ?? Math.random, this.view = new M({
+      texture: t.texture,
+      dynamicProperties: { position: !0, rotation: !0, vertex: !0, color: !0, uvs: !1 }
+    }), this.view.blendMode = t.blend === "add" ? "add" : "normal";
+  }
+  /** Particles alive now. */
+  get live() {
+    return this.sim.count;
+  }
+  setPosition(t, n) {
+    return this.x = t, this.y = n, this;
+  }
+  start() {
+    return this.emitting = !0, this;
+  }
+  /** Stops emitting; the particles in the air live out their lives. */
+  stop() {
+    return this.emitting = !1, this.carry = 0, this;
+  }
+  /** `count` particles at once, at the emitter or at (x, y). Thinned under reduced effects; skipped off screen. */
+  burst(t, n = this.x, s = this.y) {
+    this.destroyed || !this.near || this.emit(z(t, this.thin(), this.random()), n, s);
+  }
+  /** Advances by `dt` seconds. Pass the camera to skip spawning and drawing while everything is off screen. */
+  update(t, n) {
+    if (this.destroyed) return;
+    const s = this.opts.cullMargin ?? 64;
+    this.near = n ? v(n, this.x, this.y, s) : !0;
+    const e = this.opts.rate ?? 0;
+    if (this.emitting && e > 0 && this.near) {
+      const i = F(e * this.thin(), t, this.carry), d = Math.floor(i);
+      this.carry = i - d, d > 0 && this.emit(d, this.x, this.y);
+    } else this.carry = 0;
+    const a = this.opts, r = this.sim.step(t, a.gravityX ?? 0, a.gravityY ?? 0, a.drag ?? 0);
+    r > 0 && this.budget.give(r), this.draw(n, s);
+  }
+  /** Every particle gone at once (a scene change, a cancelled effect). */
+  clear() {
+    this.budget.give(this.sim.clear()), this.draw(void 0, 0);
+  }
+  destroy() {
+    this.destroyed || (this.clear(), this.destroyed = !0, this.pool.length = 0, this.view.destroy());
+  }
+  thin() {
+    const t = P.getState();
+    return t.reducedFx || t.batterySaver ? this.opts.thinFactor ?? 0.35 : 1;
+  }
+  emit(t, n, s) {
+    const e = this.sim, a = this.budget.take(Math.min(t, e.capacity - e.count)), r = this.opts, i = this.random, d = r.angle ?? -Math.PI / 2, f = r.spread ?? Math.PI;
+    for (let l = 0; l < a; l++) {
+      let o = n, h = s;
+      const c = r.area;
+      if (c && "radius" in c) {
+        const g = Math.sqrt(i()) * c.radius, u = i() * Math.PI * 2;
+        o += Math.cos(u) * g, h += Math.sin(u) * g;
+      } else c && (o += (i() - 0.5) * c.width, h += (i() - 0.5) * c.height);
+      const p = X(d, f, i()), m = y(r.speed ?? [40, 80], i());
+      e.spawn(o, h, Math.cos(p) * m, Math.sin(p) * m, y(r.lifetime ?? 1, i()), y(r.rotation ?? 0, i()), y(r.spin ?? 0, i()), i());
+    }
+  }
+  draw(t, n) {
+    const s = this.sim, e = this.view.particleChildren;
+    if (e.length !== s.count) {
+      for (; e.length < s.count; ) e.push(this.pool.pop() ?? new b({ texture: this.opts.texture, anchorX: 0.5, anchorY: 0.5 }));
+      for (; e.length > s.count; ) this.pool.push(e.pop());
+      this.view.update();
+    }
+    const a = this.opts, r = a.size ?? 1, i = a.alpha ?? Y, d = a.tint ?? 16777215, f = a.sizeVariance ?? 0;
+    let l = s.count === 0;
+    for (let o = 0; o < s.count; o++) {
+      const h = e[o], c = s.progress(o), p = s.x[o], m = s.y[o];
+      h.x = p, h.y = m, h.rotation = s.rot[o];
+      const g = w(r, c) * (1 + (s.seed[o] * 2 - 1) * f);
+      h.scaleX = g, h.scaleY = g;
+      const u = S(d, c), x = Math.min(1, Math.max(0, w(i, c)));
+      h.color = ((u & 255) << 16 | u & 65280 | u >> 16 & 255) + ((x * 255 | 0) << 24), !l && (!t || v(t, p, m, n)) && (l = !0);
+    }
+    this.view.visible = l && s.count > 0;
+  }
+}
+const Y = { start: 1, end: 0 };
+export {
+  R as Emitter
+};
+//# sourceMappingURL=Emitter.js.map