1681-engine 0.0.0-stage → 0.5.8

package/dist/particles/Emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Emitter.js","sources":["../../src/particles/Emitter.ts"],"sourcesContent":["import { Particle, ParticleContainer, type IParticle, type Texture } from 'pixi.js';\nimport { engineSettings } from '../settings';\nimport { inView, type CameraLike } from '../fx/viewCull';\nimport { ParticleBudget, particleBudget } from './ParticleBudget';\nimport { ParticleSim } from './ParticleSim';\nimport { sampleColor, sampleCurve, type ColorCurve, type Curve } from './particleCurves';\nimport { dueParticles, sampleRange, scaleCount, spreadAngle, type Range } from './particleSampling';\n\n/** Where a new particle appears round the emitter: a disc, or a box centred on it. */\nexport type SpawnArea = { readonly radius: number } | { readonly width: number; readonly height: number };\n\nexport interface EmitterOptions {\n  /** Every particle's texture. One emitter draws one texture (a frame of an atlas works: they share a source). */\n  texture: Texture;\n  /** Particles this emitter may hold at once (default 256). */\n  capacity?: number;\n  /** Particles a second while emitting (default 0: bursts only). */\n  rate?: number;\n  /** Seconds a particle lives (default 1). */\n  lifetime?: Range;\n  /** Starting speed, px/s (default [40, 80]). */\n  speed?: Range;\n  /** Direction of travel in radians (default -π/2, up the screen) and how far either way it may turn (default π). */\n  angle?: number;\n  spread?: number;\n  /** Px/s² added to velocity (default none). */\n  gravityX?: number;\n  gravityY?: number;\n  /** Share of speed lost per second (default 0). */\n  drag?: number;\n  /** Scale of the texture over life (default 1), and how much each particle's size may differ (0–1, default 0). */\n  size?: Curve;\n  sizeVariance?: number;\n  /** Opacity over life (default fading from 1 to 0). */\n  alpha?: Curve;\n  /** Tint over life, `0xrrggbb` (default white). */\n  tint?: ColorCurve;\n  /** Starting rotation and spin, radians and radians/s (default 0). */\n  rotation?: Range;\n  spin?: Range;\n  /** 'add' for glows, sparks and fire; 'normal' for smoke and debris (default 'normal'). */\n  blend?: 'normal' | 'add';\n  /** Where particles appear round the emitter (default its exact point). */\n  area?: SpawnArea;\n  /** World px beyond the screen within which the emitter still spawns and draws (default 64). */\n  cullMargin?: number;\n  /** Share of particles kept under reduced effects or the battery saver (default 0.35). */\n  thinFactor?: number;\n  /** The budget shared with other emitters (default the engine-wide `particleBudget`). */\n  budget?: ParticleBudget;\n  /** Random source (default `Math.random`); a seeded one makes an emitter replayable. */\n  random?: () => number;\n}\n\n/**\n * A source of smooth sprite particles for any art style: sparks, smoke, dust, magic. Particles live in world\n * coordinates, so moving the emitter (`x`, `y`) trails new ones behind it instead of dragging the old ones along.\n *\n * Drawn by one Pixi `ParticleContainer` (`view`): add it to a scene's `root`, and call `update(dt, camera)` once a\n * frame. Particle objects are pooled and their colour is written straight into Pixi's packed field, so a steady\n * emitter allocates nothing per frame. Spawning asks the shared `ParticleBudget` first, and off-screen emitters\n * neither spawn nor draw.\n */\nexport class Emitter {\n  readonly view: ParticleContainer;\n  x = 0;\n  y = 0;\n  /** Continuous emission on or off (bursts work either way). */\n  emitting = false;\n  private readonly sim: ParticleSim;\n  private readonly pool: IParticle[] = [];\n  private readonly budget: ParticleBudget;\n  private readonly random: () => number;\n  private readonly opts: EmitterOptions;\n  private carry = 0;\n  private destroyed = false;\n  /** Set by the last `update`: whether the emitter's point was near the screen. */\n  private near = true;\n\n  constructor(options: EmitterOptions) {\n    this.opts = options;\n    this.sim = new ParticleSim(options.capacity ?? 256);\n    this.budget = options.budget ?? particleBudget;\n    this.random = options.random ?? Math.random;\n    this.view = new ParticleContainer({\n      texture: options.texture,\n      dynamicProperties: { position: true, rotation: true, vertex: true, color: true, uvs: false },\n    });\n    this.view.blendMode = options.blend === 'add' ? 'add' : 'normal';\n  }\n\n  /** Particles alive now. */\n  get live(): number {\n    return this.sim.count;\n  }\n\n  setPosition(x: number, y: number): this {\n    this.x = x;\n    this.y = y;\n    return this;\n  }\n\n  start(): this {\n    this.emitting = true;\n    return this;\n  }\n\n  /** Stops emitting; the particles in the air live out their lives. */\n  stop(): this {\n    this.emitting = false;\n    this.carry = 0;\n    return this;\n  }\n\n  /** `count` particles at once, at the emitter or at (x, y). Thinned under reduced effects; skipped off screen. */\n  burst(count: number, x = this.x, y = this.y): void {\n    if (this.destroyed || !this.near) return;\n    this.emit(scaleCount(count, this.thin(), this.random()), x, y);\n  }\n\n  /** Advances by `dt` seconds. Pass the camera to skip spawning and drawing while everything is off screen. */\n  update(dt: number, camera?: CameraLike): void {\n    if (this.destroyed) return;\n    const margin = this.opts.cullMargin ?? 64;\n    this.near = camera ? inView(camera, this.x, this.y, margin) : true;\n    const rate = this.opts.rate ?? 0;\n    if (this.emitting && rate > 0 && this.near) {\n      const due = dueParticles(rate * this.thin(), dt, this.carry);\n      const n = Math.floor(due);\n      this.carry = due - n;\n      if (n > 0) this.emit(n, this.x, this.y);\n    } else this.carry = 0;\n    const o = this.opts;\n    const died = this.sim.step(dt, o.gravityX ?? 0, o.gravityY ?? 0, o.drag ?? 0);\n    if (died > 0) this.budget.give(died);\n    this.draw(camera, margin);\n  }\n\n  /** Every particle gone at once (a scene change, a cancelled effect). */\n  clear(): void {\n    this.budget.give(this.sim.clear());\n    this.draw(undefined, 0);\n  }\n\n  destroy(): void {\n    if (this.destroyed) return;\n    this.clear();\n    this.destroyed = true;\n    this.pool.length = 0;\n    this.view.destroy();\n  }\n\n  private thin(): number {\n    const s = engineSettings.getState();\n    return s.reducedFx || s.batterySaver ? (this.opts.thinFactor ?? 0.35) : 1;\n  }\n\n  private emit(n: number, x: number, y: number): void {\n    const sim = this.sim;\n    const granted = this.budget.take(Math.min(n, sim.capacity - sim.count));\n    const o = this.opts;\n    const r = this.random;\n    const base = o.angle ?? -Math.PI / 2;\n    const spread = o.spread ?? Math.PI;\n    for (let k = 0; k < granted; k++) {\n      let px = x;\n      let py = y;\n      const area = o.area;\n      if (area && 'radius' in area) {\n        // the square root spreads them evenly over the disc instead of crowding the centre\n        const d = Math.sqrt(r()) * area.radius;\n        const a = r() * Math.PI * 2;\n        px += Math.cos(a) * d;\n        py += Math.sin(a) * d;\n      } else if (area) {\n        px += (r() - 0.5) * area.width;\n        py += (r() - 0.5) * area.height;\n      }\n      const a = spreadAngle(base, spread, r());\n      const v = sampleRange(o.speed ?? [40, 80], r());\n      sim.spawn(px, py, Math.cos(a) * v, Math.sin(a) * v, sampleRange(o.lifetime ?? 1, r()), sampleRange(o.rotation ?? 0, r()), sampleRange(o.spin ?? 0, r()), r());\n    }\n  }\n\n  private draw(camera: CameraLike | undefined, margin: number): void {\n    const sim = this.sim;\n    const list = this.view.particleChildren;\n    if (list.length !== sim.count) {\n      while (list.length < sim.count) list.push(this.pool.pop() ?? new Particle({ texture: this.opts.texture, anchorX: 0.5, anchorY: 0.5 }));\n      while (list.length > sim.count) this.pool.push(list.pop()!);\n      this.view.update();\n    }\n    const o = this.opts;\n    const size = o.size ?? 1;\n    const alpha = o.alpha ?? FADE_OUT;\n    const tint = o.tint ?? 0xffffff;\n    const variance = o.sizeVariance ?? 0;\n    let anyIn = sim.count === 0;\n    for (let i = 0; i < sim.count; i++) {\n      const p = list[i]!;\n      const t = sim.progress(i);\n      const x = sim.x[i]!;\n      const y = sim.y[i]!;\n      p.x = x;\n      p.y = y;\n      p.rotation = sim.rot[i]!;\n      const s = sampleCurve(size, t) * (1 + (sim.seed[i]! * 2 - 1) * variance);\n      p.scaleX = s;\n      p.scaleY = s;\n      const c = sampleColor(tint, t);\n      const al = Math.min(1, Math.max(0, sampleCurve(alpha, t)));\n      // Pixi's packed field (BGR plus alpha in the top byte), written directly: the tint setter parses a colour each time\n      p.color = (((c & 0xff) << 16) | (c & 0xff00) | ((c >> 16) & 0xff)) + (((al * 255) | 0) << 24);\n      if (!anyIn && (!camera || inView(camera, x, y, margin))) anyIn = true;\n    }\n    this.view.visible = anyIn && sim.count > 0;\n  }\n}\n\nconst FADE_OUT: Curve = { start: 1, end: 0 };\n"],"names":["Emitter","options","ParticleSim","particleBudget","ParticleContainer","x","y","count","scaleCount","dt","camera","margin","inView","rate","due","dueParticles","n","o","died","s","engineSettings","sim","granted","r","base","spread","k","px","py","area","d","a","spreadAngle","v","sampleRange","list","Particle","size","alpha","FADE_OUT","tint","variance","anyIn","i","p","t","sampleCurve","c","sampleColor","al"],"mappings":"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"}

package/dist/particles/ParticleBudget.js

@@ -0,0 +1,32 @@
+import { engineSettings as i } from "../settings.js";
+class s {
+  constructor(t = 4e3, e = 0.35) {
+    this.limit = t, this.thinFactor = e;
+  }
+  limit;
+  thinFactor;
+  used = 0;
+  /** The limit as the settings stand now. */
+  get effectiveLimit() {
+    const t = i.getState();
+    return t.reducedFx || t.batterySaver ? Math.floor(this.limit * this.thinFactor) : this.limit;
+  }
+  get live() {
+    return this.used;
+  }
+  /** Reserves up to `n` particles and returns how many were granted (0 when the budget is spent). */
+  take(t) {
+    const e = Math.max(0, Math.min(t, this.effectiveLimit - this.used));
+    return this.used += e, e;
+  }
+  /** Returns `n` particles that died or were cleared. */
+  give(t) {
+    this.used = Math.max(0, this.used - t);
+  }
+}
+const a = new s();
+export {
+  s as ParticleBudget,
+  a as particleBudget
+};
+//# sourceMappingURL=ParticleBudget.js.map

package/dist/particles/ParticleBudget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleBudget.js","sources":["../../src/particles/ParticleBudget.ts"],"sourcesContent":["import { engineSettings } from '../settings';\n\n/**\n * Particles alive across every emitter that shares this budget. An emitter asks before it spawns and gives back as\n * its particles die, so a crowd of emitters at once costs no more than `limit`: ten explosions in one frame share the\n * budget instead of adding up to a frame the GPU cannot finish. Under reduced effects or the battery saver the limit\n * shrinks by `thinFactor`.\n */\nexport class ParticleBudget {\n  private used = 0;\n\n  constructor(\n    /** Particles alive at once, for every emitter together. */\n    public limit = 4000,\n    /** The share of `limit` left under reduced effects or the battery saver. */\n    public thinFactor = 0.35,\n  ) {}\n\n  /** The limit as the settings stand now. */\n  get effectiveLimit(): number {\n    const s = engineSettings.getState();\n    return s.reducedFx || s.batterySaver ? Math.floor(this.limit * this.thinFactor) : this.limit;\n  }\n\n  get live(): number {\n    return this.used;\n  }\n\n  /** Reserves up to `n` particles and returns how many were granted (0 when the budget is spent). */\n  take(n: number): number {\n    const granted = Math.max(0, Math.min(n, this.effectiveLimit - this.used));\n    this.used += granted;\n    return granted;\n  }\n\n  /** Returns `n` particles that died or were cleared. */\n  give(n: number): void {\n    this.used = Math.max(0, this.used - n);\n  }\n}\n\n/** The budget every emitter shares unless it is handed its own. */\nexport const particleBudget = new ParticleBudget();\n"],"names":["ParticleBudget","limit","thinFactor","s","engineSettings","n","granted","particleBudget"],"mappings":";AAQO,MAAMA,EAAe;AAAA,EAG1B,YAESC,IAAQ,KAERC,IAAa,MACpB;AAHO,SAAA,QAAAD,GAEA,KAAA,aAAAC;AAAA,EACN;AAAA,EAHM;AAAA,EAEA;AAAA,EAND,OAAO;AAAA;AAAA,EAUf,IAAI,iBAAyB;AAC3B,UAAMC,IAAIC,EAAe,SAAA;AACzB,WAAOD,EAAE,aAAaA,EAAE,eAAe,KAAK,MAAM,KAAK,QAAQ,KAAK,UAAU,IAAI,KAAK;AAAA,EACzF;AAAA,EAEA,IAAI,OAAe;AACjB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,KAAKE,GAAmB;AACtB,UAAMC,IAAU,KAAK,IAAI,GAAG,KAAK,IAAID,GAAG,KAAK,iBAAiB,KAAK,IAAI,CAAC;AACxE,gBAAK,QAAQC,GACNA;AAAA,EACT;AAAA;AAAA,EAGA,KAAKD,GAAiB;AACpB,SAAK,OAAO,KAAK,IAAI,GAAG,KAAK,OAAOA,CAAC;AAAA,EACvC;AACF;AAGO,MAAME,IAAiB,IAAIP,EAAA;"}

package/dist/particles/ParticleSim.js

@@ -0,0 +1,60 @@
+class y {
+  constructor(t) {
+    this.capacity = t, this.x = new Float32Array(t), this.y = new Float32Array(t), this.vx = new Float32Array(t), this.vy = new Float32Array(t), this.age = new Float32Array(t), this.life = new Float32Array(t), this.rot = new Float32Array(t), this.spin = new Float32Array(t), this.seed = new Float32Array(t);
+  }
+  capacity;
+  x;
+  y;
+  vx;
+  vy;
+  age;
+  life;
+  rot;
+  spin;
+  /** A random draw per particle (0–1), fixed for its life: size variance, flicker phase. */
+  seed;
+  count = 0;
+  /** Adds a particle; returns its index, or -1 when the sim is full. `life` is in seconds. */
+  spawn(t, i, l, r, e, n, s, o) {
+    if (this.count >= this.capacity) return -1;
+    const h = this.count++;
+    return this.x[h] = t, this.y[h] = i, this.vx[h] = l, this.vy[h] = r, this.age[h] = 0, this.life[h] = e > 0 ? e : 1e-3, this.rot[h] = n, this.spin[h] = s, this.seed[h] = o, h;
+  }
+  /**
+   * Advances every particle by `dt` seconds: gravity (px/s²) added to velocity, then drag, then position. Drag is
+   * the share of speed lost per second, applied as `exp(-drag × dt)` so it is the same at any frame rate. Returns how
+   * many particles died this step.
+   */
+  step(t, i, l, r) {
+    const e = r > 0 ? Math.exp(-r * t) : 1;
+    let n = 0, s = 0;
+    for (; s < this.count; ) {
+      const o = this.age[s] + t;
+      if (o >= this.life[s]) {
+        this.removeAt(s), n++;
+        continue;
+      }
+      this.age[s] = o;
+      const h = (this.vx[s] + i * t) * e, a = (this.vy[s] + l * t) * e;
+      this.vx[s] = h, this.vy[s] = a, this.x[s] = this.x[s] + h * t, this.y[s] = this.y[s] + a * t, this.rot[s] = this.rot[s] + this.spin[s] * t, s++;
+    }
+    return n;
+  }
+  /** The share of its life particle `i` has lived (0–1). */
+  progress(t) {
+    return this.age[t] / this.life[t];
+  }
+  /** Every particle gone; returns how many there were. */
+  clear() {
+    const t = this.count;
+    return this.count = 0, t;
+  }
+  removeAt(t) {
+    const i = --this.count;
+    t !== i && (this.x[t] = this.x[i], this.y[t] = this.y[i], this.vx[t] = this.vx[i], this.vy[t] = this.vy[i], this.age[t] = this.age[i], this.life[t] = this.life[i], this.rot[t] = this.rot[i], this.spin[t] = this.spin[i], this.seed[t] = this.seed[i]);
+  }
+}
+export {
+  y as ParticleSim
+};
+//# sourceMappingURL=ParticleSim.js.map

package/dist/particles/ParticleSim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleSim.js","sources":["../../src/particles/ParticleSim.ts"],"sourcesContent":["/**\n * The particles of one emitter as flat typed arrays (structure of arrays): position, velocity, age and lifetime,\n * rotation and spin, and a per-particle random draw the curves can use. Pure, no Pixi: the emitter draws what this\n * holds, and tests step it under node.\n *\n * Live particles are packed at indices `0 … count - 1`. A particle that dies is replaced by the last live one, so a\n * step never leaves holes and never allocates; the order of particles is therefore not stable, which drawing does\n * not need (every live index is written again each frame).\n */\nexport class ParticleSim {\n  readonly x: Float32Array;\n  readonly y: Float32Array;\n  readonly vx: Float32Array;\n  readonly vy: Float32Array;\n  readonly age: Float32Array;\n  readonly life: Float32Array;\n  readonly rot: Float32Array;\n  readonly spin: Float32Array;\n  /** A random draw per particle (0–1), fixed for its life: size variance, flicker phase. */\n  readonly seed: Float32Array;\n  count = 0;\n\n  constructor(readonly capacity: number) {\n    this.x = new Float32Array(capacity);\n    this.y = new Float32Array(capacity);\n    this.vx = new Float32Array(capacity);\n    this.vy = new Float32Array(capacity);\n    this.age = new Float32Array(capacity);\n    this.life = new Float32Array(capacity);\n    this.rot = new Float32Array(capacity);\n    this.spin = new Float32Array(capacity);\n    this.seed = new Float32Array(capacity);\n  }\n\n  /** Adds a particle; returns its index, or -1 when the sim is full. `life` is in seconds. */\n  spawn(x: number, y: number, vx: number, vy: number, life: number, rot: number, spin: number, seed: number): number {\n    if (this.count >= this.capacity) return -1;\n    const i = this.count++;\n    this.x[i] = x;\n    this.y[i] = y;\n    this.vx[i] = vx;\n    this.vy[i] = vy;\n    this.age[i] = 0;\n    this.life[i] = life > 0 ? life : 1e-3;\n    this.rot[i] = rot;\n    this.spin[i] = spin;\n    this.seed[i] = seed;\n    return i;\n  }\n\n  /**\n   * Advances every particle by `dt` seconds: gravity (px/s²) added to velocity, then drag, then position. Drag is\n   * the share of speed lost per second, applied as `exp(-drag × dt)` so it is the same at any frame rate. Returns how\n   * many particles died this step.\n   */\n  step(dt: number, gravityX: number, gravityY: number, drag: number): number {\n    const damp = drag > 0 ? Math.exp(-drag * dt) : 1;\n    let died = 0;\n    let i = 0;\n    while (i < this.count) {\n      const age = this.age[i]! + dt;\n      if (age >= this.life[i]!) {\n        this.removeAt(i);\n        died++;\n        continue; // the particle moved into `i` has not stepped yet\n      }\n      this.age[i] = age;\n      const vx = (this.vx[i]! + gravityX * dt) * damp;\n      const vy = (this.vy[i]! + gravityY * dt) * damp;\n      this.vx[i] = vx;\n      this.vy[i] = vy;\n      this.x[i] = this.x[i]! + vx * dt;\n      this.y[i] = this.y[i]! + vy * dt;\n      this.rot[i] = this.rot[i]! + this.spin[i]! * dt;\n      i++;\n    }\n    return died;\n  }\n\n  /** The share of its life particle `i` has lived (0–1). */\n  progress(i: number): number {\n    return this.age[i]! / this.life[i]!;\n  }\n\n  /** Every particle gone; returns how many there were. */\n  clear(): number {\n    const n = this.count;\n    this.count = 0;\n    return n;\n  }\n\n  private removeAt(i: number): void {\n    const last = --this.count;\n    if (i === last) return;\n    this.x[i] = this.x[last]!;\n    this.y[i] = this.y[last]!;\n    this.vx[i] = this.vx[last]!;\n    this.vy[i] = this.vy[last]!;\n    this.age[i] = this.age[last]!;\n    this.life[i] = this.life[last]!;\n    this.rot[i] = this.rot[last]!;\n    this.spin[i] = this.spin[last]!;\n    this.seed[i] = this.seed[last]!;\n  }\n}\n"],"names":["ParticleSim","capacity","x","y","vx","vy","life","rot","spin","seed","i","dt","gravityX","gravityY","drag","damp","died","age","n","last"],"mappings":"AASO,MAAMA,EAAY;AAAA,EAavB,YAAqBC,GAAkB;AAAlB,SAAA,WAAAA,GACnB,KAAK,IAAI,IAAI,aAAaA,CAAQ,GAClC,KAAK,IAAI,IAAI,aAAaA,CAAQ,GAClC,KAAK,KAAK,IAAI,aAAaA,CAAQ,GACnC,KAAK,KAAK,IAAI,aAAaA,CAAQ,GACnC,KAAK,MAAM,IAAI,aAAaA,CAAQ,GACpC,KAAK,OAAO,IAAI,aAAaA,CAAQ,GACrC,KAAK,MAAM,IAAI,aAAaA,CAAQ,GACpC,KAAK,OAAO,IAAI,aAAaA,CAAQ,GACrC,KAAK,OAAO,IAAI,aAAaA,CAAQ;AAAA,EACvC;AAAA,EAVqB;AAAA,EAZZ;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACT,QAAQ;AAAA;AAAA,EAeR,MAAMC,GAAWC,GAAWC,GAAYC,GAAYC,GAAcC,GAAaC,GAAcC,GAAsB;AACjH,QAAI,KAAK,SAAS,KAAK,SAAU,QAAO;AACxC,UAAMC,IAAI,KAAK;AACf,gBAAK,EAAEA,CAAC,IAAIR,GACZ,KAAK,EAAEQ,CAAC,IAAIP,GACZ,KAAK,GAAGO,CAAC,IAAIN,GACb,KAAK,GAAGM,CAAC,IAAIL,GACb,KAAK,IAAIK,CAAC,IAAI,GACd,KAAK,KAAKA,CAAC,IAAIJ,IAAO,IAAIA,IAAO,MACjC,KAAK,IAAII,CAAC,IAAIH,GACd,KAAK,KAAKG,CAAC,IAAIF,GACf,KAAK,KAAKE,CAAC,IAAID,GACRC;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,KAAKC,GAAYC,GAAkBC,GAAkBC,GAAsB;AACzE,UAAMC,IAAOD,IAAO,IAAI,KAAK,IAAI,CAACA,IAAOH,CAAE,IAAI;AAC/C,QAAIK,IAAO,GACPN,IAAI;AACR,WAAOA,IAAI,KAAK,SAAO;AACrB,YAAMO,IAAM,KAAK,IAAIP,CAAC,IAAKC;AAC3B,UAAIM,KAAO,KAAK,KAAKP,CAAC,GAAI;AACxB,aAAK,SAASA,CAAC,GACfM;AACA;AAAA,MACF;AACA,WAAK,IAAIN,CAAC,IAAIO;AACd,YAAMb,KAAM,KAAK,GAAGM,CAAC,IAAKE,IAAWD,KAAMI,GACrCV,KAAM,KAAK,GAAGK,CAAC,IAAKG,IAAWF,KAAMI;AAC3C,WAAK,GAAGL,CAAC,IAAIN,GACb,KAAK,GAAGM,CAAC,IAAIL,GACb,KAAK,EAAEK,CAAC,IAAI,KAAK,EAAEA,CAAC,IAAKN,IAAKO,GAC9B,KAAK,EAAED,CAAC,IAAI,KAAK,EAAEA,CAAC,IAAKL,IAAKM,GAC9B,KAAK,IAAID,CAAC,IAAI,KAAK,IAAIA,CAAC,IAAK,KAAK,KAAKA,CAAC,IAAKC,GAC7CD;AAAA,IACF;AACA,WAAOM;AAAA,EACT;AAAA;AAAA,EAGA,SAASN,GAAmB;AAC1B,WAAO,KAAK,IAAIA,CAAC,IAAK,KAAK,KAAKA,CAAC;AAAA,EACnC;AAAA;AAAA,EAGA,QAAgB;AACd,UAAMQ,IAAI,KAAK;AACf,gBAAK,QAAQ,GACNA;AAAA,EACT;AAAA,EAEQ,SAASR,GAAiB;AAChC,UAAMS,IAAO,EAAE,KAAK;AACpB,IAAIT,MAAMS,MACV,KAAK,EAAET,CAAC,IAAI,KAAK,EAAES,CAAI,GACvB,KAAK,EAAET,CAAC,IAAI,KAAK,EAAES,CAAI,GACvB,KAAK,GAAGT,CAAC,IAAI,KAAK,GAAGS,CAAI,GACzB,KAAK,GAAGT,CAAC,IAAI,KAAK,GAAGS,CAAI,GACzB,KAAK,IAAIT,CAAC,IAAI,KAAK,IAAIS,CAAI,GAC3B,KAAK,KAAKT,CAAC,IAAI,KAAK,KAAKS,CAAI,GAC7B,KAAK,IAAIT,CAAC,IAAI,KAAK,IAAIS,CAAI,GAC3B,KAAK,KAAKT,CAAC,IAAI,KAAK,KAAKS,CAAI,GAC7B,KAAK,KAAKT,CAAC,IAAI,KAAK,KAAKS,CAAI;AAAA,EAC/B;AACF;"}

package/dist/particles/particleCurves.js

@@ -0,0 +1,48 @@
+function u(n, t) {
+  if (typeof n == "number") return n;
+  if (!p(n)) return n.start + (n.end - n.start) * l(t);
+  const f = n.length;
+  if (f === 0) return 0;
+  const i = n[0];
+  if (t <= i[0]) return i[1];
+  for (let r = 1; r < f; r++) {
+    const o = n[r];
+    if (t <= o[0]) {
+      const s = n[r - 1], e = o[0] - s[0];
+      return e <= 0 ? o[1] : s[1] + (o[1] - s[1]) * ((t - s[0]) / e);
+    }
+  }
+  return n[f - 1][1];
+}
+function d(n, t) {
+  if (typeof n == "number") return n;
+  if (!p(n)) return a(n.start, n.end, l(t));
+  const f = n.length;
+  if (f === 0) return 16777215;
+  const i = n[0];
+  if (t <= i[0]) return i[1];
+  for (let r = 1; r < f; r++) {
+    const o = n[r];
+    if (t <= o[0]) {
+      const s = n[r - 1], e = o[0] - s[0];
+      return e <= 0 ? o[1] : a(s[1], o[1], (t - s[0]) / e);
+    }
+  }
+  return n[f - 1][1];
+}
+function a(n, t, f) {
+  const i = l(f), r = Math.round((n >> 16 & 255) + ((t >> 16 & 255) - (n >> 16 & 255)) * i), o = Math.round((n >> 8 & 255) + ((t >> 8 & 255) - (n >> 8 & 255)) * i), s = Math.round((n & 255) + ((t & 255) - (n & 255)) * i);
+  return r << 16 | o << 8 | s;
+}
+function p(n) {
+  return Array.isArray(n);
+}
+function l(n) {
+  return n < 0 ? 0 : n > 1 ? 1 : n;
+}
+export {
+  a as lerpColor,
+  d as sampleColor,
+  u as sampleCurve
+};
+//# sourceMappingURL=particleCurves.js.map

package/dist/particles/particleCurves.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"particleCurves.js","sources":["../../src/particles/particleCurves.ts"],"sourcesContent":["/**\n * Values that change over a particle's life, sampled at `t` from 0 (born) to 1 (gone). A curve is one of:\n *\n * - a number: the same the whole life;\n * - `{ start, end }`: a straight line between the two;\n * - keyframes `[[t, value], …]` sorted by `t`: straight lines between them, held flat before the first and after\n *   the last (a puff that swells fast then fades slowly is three keys, not a custom function).\n *\n * Pure and allocation-free: an emitter samples three curves per particle per frame.\n */\nexport type Curve = number | { readonly start: number; readonly end: number } | readonly (readonly [t: number, value: number])[];\n\n/** The same three shapes for colours (`0xrrggbb`), blended channel by channel. */\nexport type ColorCurve = Curve;\n\nexport function sampleCurve(curve: Curve, t: number): number {\n  if (typeof curve === 'number') return curve;\n  if (!isKeys(curve)) return curve.start + (curve.end - curve.start) * clamp01(t);\n  const n = curve.length;\n  if (n === 0) return 0;\n  const first = curve[0]!;\n  if (t <= first[0]) return first[1];\n  for (let i = 1; i < n; i++) {\n    const b = curve[i]!;\n    if (t <= b[0]) {\n      const a = curve[i - 1]!;\n      const span = b[0] - a[0];\n      return span <= 0 ? b[1] : a[1] + (b[1] - a[1]) * ((t - a[0]) / span);\n    }\n  }\n  return curve[n - 1]![1];\n}\n\nexport function sampleColor(curve: ColorCurve, t: number): number {\n  if (typeof curve === 'number') return curve;\n  if (!isKeys(curve)) return lerpColor(curve.start, curve.end, clamp01(t));\n  const n = curve.length;\n  if (n === 0) return 0xffffff;\n  const first = curve[0]!;\n  if (t <= first[0]) return first[1];\n  for (let i = 1; i < n; i++) {\n    const b = curve[i]!;\n    if (t <= b[0]) {\n      const a = curve[i - 1]!;\n      const span = b[0] - a[0];\n      return span <= 0 ? b[1] : lerpColor(a[1], b[1], (t - a[0]) / span);\n    }\n  }\n  return curve[n - 1]![1];\n}\n\n/** Two `0xrrggbb` colours mixed per channel, each channel rounded to a whole value. */\nexport function lerpColor(a: number, b: number, t: number): number {\n  const k = clamp01(t);\n  const r = Math.round(((a >> 16) & 0xff) + (((b >> 16) & 0xff) - ((a >> 16) & 0xff)) * k);\n  const g = Math.round(((a >> 8) & 0xff) + (((b >> 8) & 0xff) - ((a >> 8) & 0xff)) * k);\n  const bl = Math.round((a & 0xff) + ((b & 0xff) - (a & 0xff)) * k);\n  return (r << 16) | (g << 8) | bl;\n}\n\nfunction isKeys(c: Exclude<Curve, number>): c is readonly (readonly [number, number])[] {\n  return Array.isArray(c);\n}\n\nfunction clamp01(t: number): number {\n  return t < 0 ? 0 : t > 1 ? 1 : t;\n}\n"],"names":["sampleCurve","curve","isKeys","clamp01","n","first","i","b","a","span","sampleColor","lerpColor","t","k","g","bl","c"],"mappings":"AAeO,SAASA,EAAYC,GAAc,GAAmB;AAC3D,MAAI,OAAOA,KAAU,SAAU,QAAOA;AACtC,MAAI,CAACC,EAAOD,CAAK,EAAG,QAAOA,EAAM,SAASA,EAAM,MAAMA,EAAM,SAASE,EAAQ,CAAC;AAC9E,QAAMC,IAAIH,EAAM;AAChB,MAAIG,MAAM,EAAG,QAAO;AACpB,QAAMC,IAAQJ,EAAM,CAAC;AACrB,MAAI,KAAKI,EAAM,CAAC,EAAG,QAAOA,EAAM,CAAC;AACjC,WAASC,IAAI,GAAGA,IAAIF,GAAGE,KAAK;AAC1B,UAAMC,IAAIN,EAAMK,CAAC;AACjB,QAAI,KAAKC,EAAE,CAAC,GAAG;AACb,YAAMC,IAAIP,EAAMK,IAAI,CAAC,GACfG,IAAOF,EAAE,CAAC,IAAIC,EAAE,CAAC;AACvB,aAAOC,KAAQ,IAAIF,EAAE,CAAC,IAAIC,EAAE,CAAC,KAAKD,EAAE,CAAC,IAAIC,EAAE,CAAC,OAAO,IAAIA,EAAE,CAAC,KAAKC;AAAA,IACjE;AAAA,EACF;AACA,SAAOR,EAAMG,IAAI,CAAC,EAAG,CAAC;AACxB;AAEO,SAASM,EAAYT,GAAmB,GAAmB;AAChE,MAAI,OAAOA,KAAU,SAAU,QAAOA;AACtC,MAAI,CAACC,EAAOD,CAAK,EAAG,QAAOU,EAAUV,EAAM,OAAOA,EAAM,KAAKE,EAAQ,CAAC,CAAC;AACvE,QAAMC,IAAIH,EAAM;AAChB,MAAIG,MAAM,EAAG,QAAO;AACpB,QAAMC,IAAQJ,EAAM,CAAC;AACrB,MAAI,KAAKI,EAAM,CAAC,EAAG,QAAOA,EAAM,CAAC;AACjC,WAASC,IAAI,GAAGA,IAAIF,GAAGE,KAAK;AAC1B,UAAMC,IAAIN,EAAMK,CAAC;AACjB,QAAI,KAAKC,EAAE,CAAC,GAAG;AACb,YAAMC,IAAIP,EAAMK,IAAI,CAAC,GACfG,IAAOF,EAAE,CAAC,IAAIC,EAAE,CAAC;AACvB,aAAOC,KAAQ,IAAIF,EAAE,CAAC,IAAII,EAAUH,EAAE,CAAC,GAAGD,EAAE,CAAC,IAAI,IAAIC,EAAE,CAAC,KAAKC,CAAI;AAAA,IACnE;AAAA,EACF;AACA,SAAOR,EAAMG,IAAI,CAAC,EAAG,CAAC;AACxB;AAGO,SAASO,EAAUH,GAAWD,GAAWK,GAAmB;AACjE,QAAMC,IAAIV,EAAQS,CAAC,GACb,IAAI,KAAK,OAAQJ,KAAK,KAAM,SAAWD,KAAK,KAAM,QAAUC,KAAK,KAAM,QAASK,CAAC,GACjFC,IAAI,KAAK,OAAQN,KAAK,IAAK,SAAWD,KAAK,IAAK,QAAUC,KAAK,IAAK,QAASK,CAAC,GAC9EE,IAAK,KAAK,OAAOP,IAAI,SAAUD,IAAI,QAASC,IAAI,QAASK,CAAC;AAChE,SAAQ,KAAK,KAAOC,KAAK,IAAKC;AAChC;AAEA,SAASb,EAAOc,GAAwE;AACtF,SAAO,MAAM,QAAQA,CAAC;AACxB;AAEA,SAASb,EAAQS,GAAmB;AAClC,SAAOA,IAAI,IAAI,IAAIA,IAAI,IAAI,IAAIA;AACjC;"}

package/dist/particles/particleSampling.js

@@ -0,0 +1,30 @@
+function o(n, e) {
+  return typeof n == "number" ? n : n[0] + (n[1] - n[0]) * e;
+}
+function i(n, e, t) {
+  return n + (t * 2 - 1) * e;
+}
+function l(n, e, t) {
+  return !(n > 0) || !(e > 0) ? t : t + n * e;
+}
+function f(n, e, t) {
+  if (e >= 1) return n;
+  const u = n * Math.max(0, e), r = Math.floor(u);
+  return r + (t < u - r ? 1 : 0);
+}
+function s(n) {
+  let e = n >>> 0;
+  return () => {
+    e = e + 1831565813 >>> 0;
+    let t = e;
+    return t = Math.imul(t ^ t >>> 15, t | 1), t ^= t + Math.imul(t ^ t >>> 7, t | 61), ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+export {
+  l as dueParticles,
+  o as sampleRange,
+  f as scaleCount,
+  s as seededRandom,
+  i as spreadAngle
+};
+//# sourceMappingURL=particleSampling.js.map

package/dist/particles/particleSampling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"particleSampling.js","sources":["../../src/particles/particleSampling.ts"],"sourcesContent":["/** A number picked at random between two (inclusive of the first), or a fixed one. */\nexport type Range = number | readonly [min: number, max: number];\n\n/** A value of `range` for one random draw `r` in [0, 1). */\nexport function sampleRange(range: Range, r: number): number {\n  if (typeof range === 'number') return range;\n  return range[0] + (range[1] - range[0]) * r;\n}\n\n/** `base` turned by up to `spread` either way: `r` 0 gives `base - spread`, 0.5 gives `base`. */\nexport function spreadAngle(base: number, spread: number, r: number): number {\n  return base + (r * 2 - 1) * spread;\n}\n\n/**\n * Whole particles due after `dt` seconds at `rate` a second, given the fraction `carry` left over from before. Kept\n * as a fraction rather than rounded each frame, or 30 a second at 144 fps (0.21 a frame) would emit none at all.\n * Returns the count in the integer part and the new carry in the fraction: `n = Math.floor(v)`, `carry = v - n`.\n */\nexport function dueParticles(rate: number, dt: number, carry: number): number {\n  if (!(rate > 0) || !(dt > 0)) return carry;\n  return carry + rate * dt;\n}\n\n/**\n * `n` scaled by `factor` (reduced effects), rounded at random so a burst of 3 at 0.35 still gives one particle about\n * every time rather than never: the expected count stays `n × factor`.\n */\nexport function scaleCount(n: number, factor: number, r: number): number {\n  if (factor >= 1) return n;\n  const v = n * Math.max(0, factor);\n  const whole = Math.floor(v);\n  return whole + (r < v - whole ? 1 : 0);\n}\n\n/** A small seedable generator (mulberry32) for tests and replays; the emitter takes any `() => number`. */\nexport function seededRandom(seed: number): () => number {\n  let s = seed >>> 0;\n  return () => {\n    s = (s + 0x6d2b79f5) >>> 0;\n    let t = s;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n"],"names":["sampleRange","range","r","spreadAngle","base","spread","dueParticles","rate","dt","carry","scaleCount","factor","v","whole","seededRandom","seed","s"],"mappings":"AAIO,SAASA,EAAYC,GAAcC,GAAmB;AAC3D,SAAI,OAAOD,KAAU,WAAiBA,IAC/BA,EAAM,CAAC,KAAKA,EAAM,CAAC,IAAIA,EAAM,CAAC,KAAKC;AAC5C;AAGO,SAASC,EAAYC,GAAcC,GAAgBH,GAAmB;AAC3E,SAAOE,KAAQF,IAAI,IAAI,KAAKG;AAC9B;AAOO,SAASC,EAAaC,GAAcC,GAAYC,GAAuB;AAC5E,SAAI,EAAEF,IAAO,MAAM,EAAEC,IAAK,KAAWC,IAC9BA,IAAQF,IAAOC;AACxB;AAMO,SAASE,EAAW,GAAWC,GAAgBT,GAAmB;AACvE,MAAIS,KAAU,EAAG,QAAO;AACxB,QAAMC,IAAI,IAAI,KAAK,IAAI,GAAGD,CAAM,GAC1BE,IAAQ,KAAK,MAAMD,CAAC;AAC1B,SAAOC,KAASX,IAAIU,IAAIC,IAAQ,IAAI;AACtC;AAGO,SAASC,EAAaC,GAA4B;AACvD,MAAIC,IAAID,MAAS;AACjB,SAAO,MAAM;AACX,IAAAC,IAAKA,IAAI,eAAgB;AACzB,QAAI,IAAIA;AACR,eAAI,KAAK,KAAK,IAAK,MAAM,IAAK,IAAI,CAAC,GACnC,KAAK,IAAI,KAAK,KAAK,IAAK,MAAM,GAAI,IAAI,EAAE,KAC/B,IAAK,MAAM,QAAS,KAAK;AAAA,EACpC;AACF;"}

package/dist/physics/Body.js

@@ -0,0 +1,202 @@
+import { MAX_POLYGON_VERTICES as l, polygonData as c } from "./polygon.js";
+let f = 1;
+class p {
+  id = f++;
+  type;
+  shape;
+  x;
+  y;
+  /** Position at the start of the last world step: draw at `prev + (current - prev) × alpha`. */
+  prevX;
+  prevY;
+  vx;
+  vy;
+  /** Radians, clockwise on screen. */
+  angle;
+  /** Angle at the start of the last world step, for drawing between steps like `prevX`. */
+  prevAngle;
+  /** Radians per second. */
+  angularVelocity;
+  /** Contacts and torques turn it (`BodyOptions.rotates`). */
+  rotates;
+  /** Turning lost per second, as a share. */
+  angularDamping;
+  /** Torque gathered for the next step, cleared after it. */
+  torque = 0;
+  /** Moment of inertia about the centre (mass × px²); infinite for a body that does not rotate. */
+  inertia;
+  invInertia;
+  /** Force gathered for the next step (px·mass/s²), cleared after it. */
+  fx = 0;
+  fy = 0;
+  mass;
+  invMass;
+  restitution;
+  friction;
+  linearDamping;
+  gravityScale;
+  sensor;
+  layer;
+  mask;
+  userData;
+  /** Box faces lying against more solid ground (`FACE_*` bits): never a contact normal, so seams do not snag. */
+  internalFaces = 0;
+  /** A sleeping body is not integrated and is treated as immovable until something wakes it. */
+  awake = !0;
+  /** Seconds spent below the world's sleep speed. */
+  restTime = 0;
+  /** Standing on something: a solid contact whose normal points up at this body (refreshed every step). */
+  grounded = !1;
+  /** What it stands on, while grounded. */
+  ground = null;
+  groundNx = 0;
+  groundNy = 0;
+  // bounds, refreshed by `updateBounds`
+  minX = 0;
+  minY = 0;
+  maxX = 0;
+  maxY = 0;
+  /** @internal cosine and sine of `angle`, refreshed by `updateBounds`. */
+  cos = 1;
+  sin = 0;
+  /** @internal corners and outward face normals in world space (boxes and polygons), refreshed by `updateBounds`. */
+  wx = new Float64Array(l);
+  wy = new Float64Array(l);
+  wnx = new Float64Array(l);
+  wny = new Float64Array(l);
+  /** @internal how many of the above are in use (0 for a circle). */
+  corners = 0;
+  /** @internal set by the world that holds it. */
+  inWorld = !1;
+  /** @internal last ray that tested this body, so a ray crossing many cells tests it once. */
+  rayStamp = 0;
+  constructor(t) {
+    this.type = t.type ?? "dynamic", this.shape = t.shape, this.x = this.prevX = t.x ?? 0, this.y = this.prevY = t.y ?? 0, this.vx = t.vx ?? 0, this.vy = t.vy ?? 0, this.angle = this.prevAngle = t.angle ?? 0, this.angularVelocity = t.angularVelocity ?? 0, this.angularDamping = t.angularDamping ?? 0.05;
+    const i = t.mass ?? 1;
+    if (this.type === "dynamic" && !(i > 0)) throw new Error(`Body: a dynamic body needs a positive mass, got ${i}`);
+    this.mass = this.type === "dynamic" ? i : 1 / 0, this.invMass = this.type === "dynamic" ? 1 / i : 0, this.rotates = t.rotates === !0 && this.type !== "static";
+    const s = this.rotates && this.type === "dynamic";
+    this.inertia = s ? i * w(this.shape) : 1 / 0, this.invInertia = s ? 1 / this.inertia : 0, this.restitution = t.restitution ?? 0, this.friction = t.friction ?? 0.5, this.linearDamping = t.linearDamping ?? 0, this.gravityScale = t.gravityScale ?? 1, this.sensor = t.sensor ?? !1, this.layer = t.layer ?? 1, this.mask = t.mask ?? 4294967295, this.userData = t.userData, this.updateBounds();
+  }
+  get isDynamic() {
+    return this.type === "dynamic";
+  }
+  get isStatic() {
+    return this.type === "static";
+  }
+  /** Moves by itself this step: an awake dynamic body or any kinematic one. */
+  get moving() {
+    return this.type === "kinematic" || this.type === "dynamic" && this.awake;
+  }
+  /** Inverse mass as the solver sees it: a sleeping body holds still like ground. */
+  get solverInvMass() {
+    return this.awake ? this.invMass : 0;
+  }
+  /** The smallest half size of the shape: how far it may move in one sub-step without passing through anything. */
+  get minHalfExtent() {
+    const t = this.shape;
+    return t.kind === "circle" ? t.radius : t.kind === "box" ? Math.min(t.halfWidth, t.halfHeight) : c(t).inradius;
+  }
+  /** The furthest the shape reaches from the centre: how far a corner sweeps as the body turns. */
+  get maxExtent() {
+    const t = this.shape;
+    return t.kind === "circle" ? t.radius : t.kind === "box" ? Math.hypot(t.halfWidth, t.halfHeight) : c(t).radius;
+  }
+  /** A box at no angle: the cheap axis-aligned tests apply to it. */
+  get axisAligned() {
+    return this.shape.kind === "box" && this.angle === 0;
+  }
+  updateBounds() {
+    const t = this.shape;
+    if (t.kind === "circle") {
+      this.cos = Math.cos(this.angle), this.sin = Math.sin(this.angle), this.corners = 0, this.minX = this.x - t.radius, this.maxX = this.x + t.radius, this.minY = this.y - t.radius, this.maxY = this.y + t.radius;
+      return;
+    }
+    if (t.kind === "box" && this.angle === 0) {
+      this.cos = 1, this.sin = 0, this.setBoxCorners(t.halfWidth, t.halfHeight), this.minX = this.x - t.halfWidth, this.maxX = this.x + t.halfWidth, this.minY = this.y - t.halfHeight, this.maxY = this.y + t.halfHeight;
+      return;
+    }
+    const i = this.cos = Math.cos(this.angle), s = this.sin = Math.sin(this.angle);
+    if (t.kind === "box") this.setBoxCorners(t.halfWidth, t.halfHeight);
+    else {
+      const h = c(t);
+      this.corners = h.vertices.length;
+      for (let n = 0; n < h.vertices.length; n++)
+        this.wx[n] = h.vertices[n].x, this.wy[n] = h.vertices[n].y, this.wnx[n] = h.normals[n].x, this.wny[n] = h.normals[n].y;
+    }
+    let e = 1 / 0, o = 1 / 0, u = -1 / 0, x = -1 / 0;
+    for (let h = 0; h < this.corners; h++) {
+      const n = this.wx[h], d = this.wy[h], r = this.x + i * n - s * d, y = this.y + s * n + i * d;
+      this.wx[h] = r, this.wy[h] = y;
+      const g = this.wnx[h], m = this.wny[h];
+      this.wnx[h] = i * g - s * m, this.wny[h] = s * g + i * m, r < e && (e = r), r > u && (u = r), y < o && (o = y), y > x && (x = y);
+    }
+    this.minX = e, this.maxX = u, this.minY = o, this.maxY = x;
+  }
+  /** Box corners in local space (top, right, bottom, left faces), or in world space when the box sits at no angle. */
+  setBoxCorners(t, i) {
+    const s = this.angle === 0 ? this.x : 0, e = this.angle === 0 ? this.y : 0;
+    this.corners = 4, this.wx[0] = s - t, this.wy[0] = e - i, this.wx[1] = s + t, this.wy[1] = e - i, this.wx[2] = s + t, this.wy[2] = e + i, this.wx[3] = s - t, this.wy[3] = e + i, this.wnx[0] = 0, this.wny[0] = -1, this.wnx[1] = 1, this.wny[1] = 0, this.wnx[2] = 0, this.wny[2] = 1, this.wnx[3] = -1, this.wny[3] = 0;
+  }
+  wake() {
+    this.type !== "static" && (this.awake = !0, this.restTime = 0);
+  }
+  setVelocity(t, i) {
+    this.vx = t, this.vy = i, this.wake();
+  }
+  /**
+   * An instant change of momentum (a jump, a hit): velocity changes by `impulse / mass`. Given a world point
+   * (`px`, `py`) off the centre, a body that rotates is also set turning.
+   */
+  applyImpulse(t, i, s, e) {
+    this.type === "dynamic" && (this.vx += t * this.invMass, this.vy += i * this.invMass, s !== void 0 && e !== void 0 && (this.angularVelocity += ((s - this.x) * i - (e - this.y) * t) * this.invInertia), this.wake());
+  }
+  /** A force held for the next step (thrust, wind); it is cleared once the step has used it. At a world point, it also turns the body. */
+  applyForce(t, i, s, e) {
+    this.type === "dynamic" && (this.fx += t, this.fy += i, s !== void 0 && e !== void 0 && (this.torque += (s - this.x) * i - (e - this.y) * t), this.wake());
+  }
+  /** A turning force held for the next step (mass × px² / s², clockwise on screen when positive). */
+  applyTorque(t) {
+    this.type !== "dynamic" || !this.rotates || (this.torque += t, this.wake());
+  }
+  /** An instant change of spin: angular velocity changes by `impulse / inertia`. */
+  applyAngularImpulse(t) {
+    this.type === "dynamic" && (this.angularVelocity += t * this.invInertia, this.wake());
+  }
+  /** Sets the spin (a kinematic body turns at it; a dynamic one that rotates starts at it). */
+  setAngularVelocity(t) {
+    this.angularVelocity = t, this.wake();
+  }
+  /** Velocity of the body's material at a world point: its own plus what its spin adds there. */
+  velocityAt(t, i) {
+    const s = this.angularVelocity;
+    return { x: this.vx - s * (i - this.y), y: this.vy + s * (t - this.x) };
+  }
+  /**
+   * Puts the body somewhere without sweeping it there; the drawn position jumps too (no interpolation across it).
+   * A static body moved this way must be followed by `PhysicsWorld.staticsChanged()`.
+   */
+  setPosition(t, i, s = this.angle) {
+    this.x = this.prevX = t, this.y = this.prevY = i, this.angle = this.prevAngle = s, this.updateBounds(), this.wake();
+  }
+  /** Turns the body to `angle` without sweeping it there (like `setPosition`). */
+  setAngle(t) {
+    this.setPosition(this.x, this.y, t);
+  }
+  /** A world point in the body's own frame (before its turn). */
+  toLocal(t, i) {
+    const s = t - this.x, e = i - this.y;
+    return { x: this.cos * s + this.sin * e, y: -this.sin * s + this.cos * e };
+  }
+  /** A point of the body's own frame in the world. */
+  toWorld(t, i) {
+    return { x: this.x + this.cos * t - this.sin * i, y: this.y + this.sin * t + this.cos * i };
+  }
+}
+function w(a) {
+  return a.kind === "circle" ? a.radius * a.radius / 2 : a.kind === "box" ? ((2 * a.halfWidth) ** 2 + (2 * a.halfHeight) ** 2) / 12 : c(a).inertiaPerMass;
+}
+export {
+  p as Body
+};
+//# sourceMappingURL=Body.js.map

package/dist/physics/Body.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Body.js","sources":["../../src/physics/Body.ts"],"sourcesContent":["import { MAX_POLYGON_VERTICES, polygonData } from './polygon';\nimport type { BodyOptions, BodyType, Shape } from './types';\n\nlet nextBodyId = 1;\n\n/**\n * A rigid body: plain data and a few helpers, no drawing. Positions are the shape's centre in world pixels, y down;\n * velocities are px per second. Create bodies with `PhysicsWorld.add`, which also wakes them and puts them in the\n * broad phase.\n */\nexport class Body {\n  readonly id = nextBodyId++;\n  readonly type: BodyType;\n  shape: Shape;\n  x: number;\n  y: number;\n  /** Position at the start of the last world step: draw at `prev + (current - prev) × alpha`. */\n  prevX: number;\n  prevY: number;\n  vx: number;\n  vy: number;\n  /** Radians, clockwise on screen. */\n  angle: number;\n  /** Angle at the start of the last world step, for drawing between steps like `prevX`. */\n  prevAngle: number;\n  /** Radians per second. */\n  angularVelocity: number;\n  /** Contacts and torques turn it (`BodyOptions.rotates`). */\n  readonly rotates: boolean;\n  /** Turning lost per second, as a share. */\n  angularDamping: number;\n  /** Torque gathered for the next step, cleared after it. */\n  torque = 0;\n  /** Moment of inertia about the centre (mass × px²); infinite for a body that does not rotate. */\n  readonly inertia: number;\n  readonly invInertia: number;\n  /** Force gathered for the next step (px·mass/s²), cleared after it. */\n  fx = 0;\n  fy = 0;\n  readonly mass: number;\n  readonly invMass: number;\n  restitution: number;\n  friction: number;\n  linearDamping: number;\n  gravityScale: number;\n  readonly sensor: boolean;\n  layer: number;\n  mask: number;\n  userData: unknown;\n  /** Box faces lying against more solid ground (`FACE_*` bits): never a contact normal, so seams do not snag. */\n  internalFaces = 0;\n\n  /** A sleeping body is not integrated and is treated as immovable until something wakes it. */\n  awake = true;\n  /** Seconds spent below the world's sleep speed. */\n  restTime = 0;\n  /** Standing on something: a solid contact whose normal points up at this body (refreshed every step). */\n  grounded = false;\n  /** What it stands on, while grounded. */\n  ground: Body | null = null;\n  groundNx = 0;\n  groundNy = 0;\n\n  // bounds, refreshed by `updateBounds`\n  minX = 0;\n  minY = 0;\n  maxX = 0;\n  maxY = 0;\n\n  /** @internal cosine and sine of `angle`, refreshed by `updateBounds`. */\n  cos = 1;\n  sin = 0;\n  /** @internal corners and outward face normals in world space (boxes and polygons), refreshed by `updateBounds`. */\n  readonly wx = new Float64Array(MAX_POLYGON_VERTICES);\n  readonly wy = new Float64Array(MAX_POLYGON_VERTICES);\n  readonly wnx = new Float64Array(MAX_POLYGON_VERTICES);\n  readonly wny = new Float64Array(MAX_POLYGON_VERTICES);\n  /** @internal how many of the above are in use (0 for a circle). */\n  corners = 0;\n\n  /** @internal set by the world that holds it. */\n  inWorld = false;\n  /** @internal last ray that tested this body, so a ray crossing many cells tests it once. */\n  rayStamp = 0;\n\n  constructor(options: BodyOptions) {\n    this.type = options.type ?? 'dynamic';\n    this.shape = options.shape;\n    this.x = this.prevX = options.x ?? 0;\n    this.y = this.prevY = options.y ?? 0;\n    this.vx = options.vx ?? 0;\n    this.vy = options.vy ?? 0;\n    this.angle = this.prevAngle = options.angle ?? 0;\n    this.angularVelocity = options.angularVelocity ?? 0;\n    this.angularDamping = options.angularDamping ?? 0.05;\n    const mass = options.mass ?? 1;\n    if (this.type === 'dynamic' && !(mass > 0)) throw new Error(`Body: a dynamic body needs a positive mass, got ${mass}`);\n    this.mass = this.type === 'dynamic' ? mass : Infinity;\n    this.invMass = this.type === 'dynamic' ? 1 / mass : 0;\n    this.rotates = options.rotates === true && this.type !== 'static';\n    const turns = this.rotates && this.type === 'dynamic';\n    this.inertia = turns ? mass * inertiaPerMass(this.shape) : Infinity;\n    this.invInertia = turns ? 1 / this.inertia : 0;\n    this.restitution = options.restitution ?? 0;\n    this.friction = options.friction ?? 0.5;\n    this.linearDamping = options.linearDamping ?? 0;\n    this.gravityScale = options.gravityScale ?? 1;\n    this.sensor = options.sensor ?? false;\n    this.layer = options.layer ?? 1;\n    this.mask = options.mask ?? 0xffffffff;\n    this.userData = options.userData;\n    this.updateBounds();\n  }\n\n  get isDynamic(): boolean {\n    return this.type === 'dynamic';\n  }\n\n  get isStatic(): boolean {\n    return this.type === 'static';\n  }\n\n  /** Moves by itself this step: an awake dynamic body or any kinematic one. */\n  get moving(): boolean {\n    return this.type === 'kinematic' || (this.type === 'dynamic' && this.awake);\n  }\n\n  /** Inverse mass as the solver sees it: a sleeping body holds still like ground. */\n  get solverInvMass(): number {\n    return this.awake ? this.invMass : 0;\n  }\n\n  /** The smallest half size of the shape: how far it may move in one sub-step without passing through anything. */\n  get minHalfExtent(): number {\n    const s = this.shape;\n    if (s.kind === 'circle') return s.radius;\n    if (s.kind === 'box') return Math.min(s.halfWidth, s.halfHeight);\n    return polygonData(s).inradius;\n  }\n\n  /** The furthest the shape reaches from the centre: how far a corner sweeps as the body turns. */\n  get maxExtent(): number {\n    const s = this.shape;\n    if (s.kind === 'circle') return s.radius;\n    if (s.kind === 'box') return Math.hypot(s.halfWidth, s.halfHeight);\n    return polygonData(s).radius;\n  }\n\n  /** A box at no angle: the cheap axis-aligned tests apply to it. */\n  get axisAligned(): boolean {\n    return this.shape.kind === 'box' && this.angle === 0;\n  }\n\n  updateBounds(): void {\n    const s = this.shape;\n    if (s.kind === 'circle') {\n      this.cos = Math.cos(this.angle);\n      this.sin = Math.sin(this.angle);\n      this.corners = 0;\n      this.minX = this.x - s.radius;\n      this.maxX = this.x + s.radius;\n      this.minY = this.y - s.radius;\n      this.maxY = this.y + s.radius;\n      return;\n    }\n    if (s.kind === 'box' && this.angle === 0) {\n      this.cos = 1;\n      this.sin = 0;\n      this.setBoxCorners(s.halfWidth, s.halfHeight);\n      this.minX = this.x - s.halfWidth;\n      this.maxX = this.x + s.halfWidth;\n      this.minY = this.y - s.halfHeight;\n      this.maxY = this.y + s.halfHeight;\n      return;\n    }\n    const c = (this.cos = Math.cos(this.angle));\n    const n = (this.sin = Math.sin(this.angle));\n    if (s.kind === 'box') this.setBoxCorners(s.halfWidth, s.halfHeight);\n    else {\n      const d = polygonData(s);\n      this.corners = d.vertices.length;\n      for (let i = 0; i < d.vertices.length; i++) {\n        this.wx[i] = d.vertices[i]!.x;\n        this.wy[i] = d.vertices[i]!.y;\n        this.wnx[i] = d.normals[i]!.x;\n        this.wny[i] = d.normals[i]!.y;\n      }\n    }\n    let minX = Infinity;\n    let minY = Infinity;\n    let maxX = -Infinity;\n    let maxY = -Infinity;\n    for (let i = 0; i < this.corners; i++) {\n      const lx = this.wx[i]!;\n      const ly = this.wy[i]!;\n      const x = this.x + c * lx - n * ly;\n      const y = this.y + n * lx + c * ly;\n      this.wx[i] = x;\n      this.wy[i] = y;\n      const nx = this.wnx[i]!;\n      const ny = this.wny[i]!;\n      this.wnx[i] = c * nx - n * ny;\n      this.wny[i] = n * nx + c * ny;\n      if (x < minX) minX = x;\n      if (x > maxX) maxX = x;\n      if (y < minY) minY = y;\n      if (y > maxY) maxY = y;\n    }\n    this.minX = minX;\n    this.maxX = maxX;\n    this.minY = minY;\n    this.maxY = maxY;\n  }\n\n  /** Box corners in local space (top, right, bottom, left faces), or in world space when the box sits at no angle. */\n  private setBoxCorners(hw: number, hh: number): void {\n    const ox = this.angle === 0 ? this.x : 0;\n    const oy = this.angle === 0 ? this.y : 0;\n    this.corners = 4;\n    this.wx[0] = ox - hw;\n    this.wy[0] = oy - hh;\n    this.wx[1] = ox + hw;\n    this.wy[1] = oy - hh;\n    this.wx[2] = ox + hw;\n    this.wy[2] = oy + hh;\n    this.wx[3] = ox - hw;\n    this.wy[3] = oy + hh;\n    this.wnx[0] = 0;\n    this.wny[0] = -1;\n    this.wnx[1] = 1;\n    this.wny[1] = 0;\n    this.wnx[2] = 0;\n    this.wny[2] = 1;\n    this.wnx[3] = -1;\n    this.wny[3] = 0;\n  }\n\n  wake(): void {\n    if (this.type === 'static') return;\n    this.awake = true;\n    this.restTime = 0;\n  }\n\n  setVelocity(vx: number, vy: number): void {\n    this.vx = vx;\n    this.vy = vy;\n    this.wake();\n  }\n\n  /**\n   * An instant change of momentum (a jump, a hit): velocity changes by `impulse / mass`. Given a world point\n   * (`px`, `py`) off the centre, a body that rotates is also set turning.\n   */\n  applyImpulse(ix: number, iy: number, px?: number, py?: number): void {\n    if (this.type !== 'dynamic') return;\n    this.vx += ix * this.invMass;\n    this.vy += iy * this.invMass;\n    if (px !== undefined && py !== undefined) this.angularVelocity += ((px - this.x) * iy - (py - this.y) * ix) * this.invInertia;\n    this.wake();\n  }\n\n  /** A force held for the next step (thrust, wind); it is cleared once the step has used it. At a world point, it also turns the body. */\n  applyForce(fx: number, fy: number, px?: number, py?: number): void {\n    if (this.type !== 'dynamic') return;\n    this.fx += fx;\n    this.fy += fy;\n    if (px !== undefined && py !== undefined) this.torque += (px - this.x) * fy - (py - this.y) * fx;\n    this.wake();\n  }\n\n  /** A turning force held for the next step (mass × px² / s², clockwise on screen when positive). */\n  applyTorque(torque: number): void {\n    if (this.type !== 'dynamic' || !this.rotates) return;\n    this.torque += torque;\n    this.wake();\n  }\n\n  /** An instant change of spin: angular velocity changes by `impulse / inertia`. */\n  applyAngularImpulse(impulse: number): void {\n    if (this.type !== 'dynamic') return;\n    this.angularVelocity += impulse * this.invInertia;\n    this.wake();\n  }\n\n  /** Sets the spin (a kinematic body turns at it; a dynamic one that rotates starts at it). */\n  setAngularVelocity(w: number): void {\n    this.angularVelocity = w;\n    this.wake();\n  }\n\n  /** Velocity of the body's material at a world point: its own plus what its spin adds there. */\n  velocityAt(px: number, py: number): { x: number; y: number } {\n    const w = this.angularVelocity;\n    return { x: this.vx - w * (py - this.y), y: this.vy + w * (px - this.x) };\n  }\n\n  /**\n   * Puts the body somewhere without sweeping it there; the drawn position jumps too (no interpolation across it).\n   * A static body moved this way must be followed by `PhysicsWorld.staticsChanged()`.\n   */\n  setPosition(x: number, y: number, angle = this.angle): void {\n    this.x = this.prevX = x;\n    this.y = this.prevY = y;\n    this.angle = this.prevAngle = angle;\n    this.updateBounds();\n    this.wake();\n  }\n\n  /** Turns the body to `angle` without sweeping it there (like `setPosition`). */\n  setAngle(angle: number): void {\n    this.setPosition(this.x, this.y, angle);\n  }\n\n  /** A world point in the body's own frame (before its turn). */\n  toLocal(px: number, py: number): { x: number; y: number } {\n    const dx = px - this.x;\n    const dy = py - this.y;\n    return { x: this.cos * dx + this.sin * dy, y: -this.sin * dx + this.cos * dy };\n  }\n\n  /** A point of the body's own frame in the world. */\n  toWorld(lx: number, ly: number): { x: number; y: number } {\n    return { x: this.x + this.cos * lx - this.sin * ly, y: this.y + this.sin * lx + this.cos * ly };\n  }\n}\n\n/** Moment of inertia per unit of mass about the centre: a solid disc, a solid box, a solid polygon. */\nfunction inertiaPerMass(s: Shape): number {\n  if (s.kind === 'circle') return (s.radius * s.radius) / 2;\n  if (s.kind === 'box') return ((2 * s.halfWidth) ** 2 + (2 * s.halfHeight) ** 2) / 12;\n  return polygonData(s).inertiaPerMass;\n}\n"],"names":["nextBodyId","Body","MAX_POLYGON_VERTICES","options","mass","turns","inertiaPerMass","s","polygonData","c","n","d","i","minX","minY","maxX","maxY","lx","ly","x","nx","ny","hw","hh","ox","oy","vx","vy","ix","iy","px","py","fx","fy","torque","impulse","w","y","angle","dx","dy"],"mappings":"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"}

package/dist/physics/BroadPhase.js

@@ -0,0 +1,56 @@
+import { SpatialHash as h } from "./SpatialHash.js";
+class y {
+  constructor(i, s) {
+    this.margin = s, this.statics = new h(i), this.movers = new h(i);
+  }
+  margin;
+  statics;
+  movers;
+  staticsDirty = !0;
+  markStaticsDirty() {
+    this.staticsDirty = !0;
+  }
+  /** Re-lists every body; statics only if they changed. Bounds must be current. */
+  rebuild(i) {
+    if (this.staticsDirty) {
+      this.statics.clear();
+      for (const s of i) s.isStatic && this.statics.insert(s, this.margin);
+      this.staticsDirty = !1;
+    }
+    this.movers.clear();
+    for (const s of i) s.isStatic || this.movers.insert(s, this.margin);
+  }
+  /**
+   * Calls `visit` once for every pair whose bounds (grown by the margin) overlap and in which at least one body
+   * moves. A pair sharing several cells is visited only from the cell holding the corner of their overlap, which
+   * needs no set of pairs seen.
+   */
+  pairs(i, s) {
+    const o = this.margin, r = this.movers;
+    for (const t of i) {
+      if (!t.moving || !t.inWorld) continue;
+      const m = r.cellOf(t.minX - o), l = r.cellOf(t.maxX + o), x = r.cellOf(t.minY - o), g = r.cellOf(t.maxY + o);
+      for (let a = x; a <= g; a++)
+        for (let c = m; c <= l; c++) {
+          const f = this.movers.at(c, a);
+          if (f)
+            for (const n of f)
+              n === t || n.moving && n.id < t.id || this.owns(t, n, c, a) && s(t, n);
+          const e = this.statics.at(c, a);
+          if (e)
+            for (const n of e) this.owns(t, n, c, a) && s(t, n);
+        }
+    }
+  }
+  /** The pair overlaps and (cx, cy) is the cell of its overlap's top-left corner. */
+  owns(i, s, o, r) {
+    const t = this.margin;
+    if (i.maxX + t < s.minX - t || s.maxX + t < i.minX - t || i.maxY + t < s.minY - t || s.maxY + t < i.minY - t) return !1;
+    const m = this.movers;
+    return m.cellOf(Math.max(i.minX, s.minX) - t) === o && m.cellOf(Math.max(i.minY, s.minY) - t) === r;
+  }
+}
+export {
+  y as BroadPhase
+};
+//# sourceMappingURL=BroadPhase.js.map

package/dist/physics/BroadPhase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BroadPhase.js","sources":["../../src/physics/BroadPhase.ts"],"sourcesContent":["import type { Body } from './Body';\nimport { SpatialHash } from './SpatialHash';\n\n/**\n * Two spatial hashes: static bodies, rebuilt only when they change (a level's ground is thousands of tiles merged\n * into a few hundred boxes and never moves), and everything else, rebuilt every sub-step. Pairs are found from the\n * moving side only: two sleeping or static bodies are never tested against each other.\n */\nexport class BroadPhase {\n  readonly statics: SpatialHash;\n  readonly movers: SpatialHash;\n  private staticsDirty = true;\n\n  constructor(\n    cellSize: number,\n    private readonly margin: number,\n  ) {\n    this.statics = new SpatialHash(cellSize);\n    this.movers = new SpatialHash(cellSize);\n  }\n\n  markStaticsDirty(): void {\n    this.staticsDirty = true;\n  }\n\n  /** Re-lists every body; statics only if they changed. Bounds must be current. */\n  rebuild(bodies: readonly Body[]): void {\n    if (this.staticsDirty) {\n      this.statics.clear();\n      for (const b of bodies) if (b.isStatic) this.statics.insert(b, this.margin);\n      this.staticsDirty = false;\n    }\n    this.movers.clear();\n    for (const b of bodies) if (!b.isStatic) this.movers.insert(b, this.margin);\n  }\n\n  /**\n   * Calls `visit` once for every pair whose bounds (grown by the margin) overlap and in which at least one body\n   * moves. A pair sharing several cells is visited only from the cell holding the corner of their overlap, which\n   * needs no set of pairs seen.\n   */\n  pairs(bodies: readonly Body[], visit: (a: Body, b: Body) => void): void {\n    const m = this.margin;\n    const hash = this.movers;\n    for (const a of bodies) {\n      if (!a.moving || !a.inWorld) continue;\n      const x0 = hash.cellOf(a.minX - m);\n      const x1 = hash.cellOf(a.maxX + m);\n      const y0 = hash.cellOf(a.minY - m);\n      const y1 = hash.cellOf(a.maxY + m);\n      for (let cy = y0; cy <= y1; cy++) {\n        for (let cx = x0; cx <= x1; cx++) {\n          const near = this.movers.at(cx, cy);\n          if (near) {\n            for (const b of near) {\n              // two moving bodies meet from the lower id's side only\n              if (b === a || (b.moving && b.id < a.id)) continue;\n              if (this.owns(a, b, cx, cy)) visit(a, b);\n            }\n          }\n          const ground = this.statics.at(cx, cy);\n          if (ground) for (const b of ground) if (this.owns(a, b, cx, cy)) visit(a, b);\n        }\n      }\n    }\n  }\n\n  /** The pair overlaps and (cx, cy) is the cell of its overlap's top-left corner. */\n  private owns(a: Body, b: Body, cx: number, cy: number): boolean {\n    const m = this.margin;\n    if (a.maxX + m < b.minX - m || b.maxX + m < a.minX - m || a.maxY + m < b.minY - m || b.maxY + m < a.minY - m) return false;\n    const hash = this.movers;\n    return hash.cellOf(Math.max(a.minX, b.minX) - m) === cx && hash.cellOf(Math.max(a.minY, b.minY) - m) === cy;\n  }\n}\n"],"names":["BroadPhase","cellSize","margin","SpatialHash","bodies","b","visit","m","hash","a","x0","x1","y0","y1","cy","cx","near","ground"],"mappings":";AAQO,MAAMA,EAAW;AAAA,EAKtB,YACEC,GACiBC,GACjB;AADiB,SAAA,SAAAA,GAEjB,KAAK,UAAU,IAAIC,EAAYF,CAAQ,GACvC,KAAK,SAAS,IAAIE,EAAYF,CAAQ;AAAA,EACxC;AAAA,EAJmB;AAAA,EANV;AAAA,EACA;AAAA,EACD,eAAe;AAAA,EAUvB,mBAAyB;AACvB,SAAK,eAAe;AAAA,EACtB;AAAA;AAAA,EAGA,QAAQG,GAA+B;AACrC,QAAI,KAAK,cAAc;AACrB,WAAK,QAAQ,MAAA;AACb,iBAAWC,KAAKD,EAAQ,CAAIC,EAAE,iBAAe,QAAQ,OAAOA,GAAG,KAAK,MAAM;AAC1E,WAAK,eAAe;AAAA,IACtB;AACA,SAAK,OAAO,MAAA;AACZ,eAAWA,KAAKD,EAAQ,CAAKC,EAAE,YAAU,KAAK,OAAO,OAAOA,GAAG,KAAK,MAAM;AAAA,EAC5E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAMD,GAAyBE,GAAyC;AACtE,UAAMC,IAAI,KAAK,QACTC,IAAO,KAAK;AAClB,eAAWC,KAAKL,GAAQ;AACtB,UAAI,CAACK,EAAE,UAAU,CAACA,EAAE,QAAS;AAC7B,YAAMC,IAAKF,EAAK,OAAOC,EAAE,OAAOF,CAAC,GAC3BI,IAAKH,EAAK,OAAOC,EAAE,OAAOF,CAAC,GAC3BK,IAAKJ,EAAK,OAAOC,EAAE,OAAOF,CAAC,GAC3BM,IAAKL,EAAK,OAAOC,EAAE,OAAOF,CAAC;AACjC,eAASO,IAAKF,GAAIE,KAAMD,GAAIC;AAC1B,iBAASC,IAAKL,GAAIK,KAAMJ,GAAII,KAAM;AAChC,gBAAMC,IAAO,KAAK,OAAO,GAAGD,GAAID,CAAE;AAClC,cAAIE;AACF,uBAAWX,KAAKW;AAEd,cAAIX,MAAMI,KAAMJ,EAAE,UAAUA,EAAE,KAAKI,EAAE,MACjC,KAAK,KAAKA,GAAGJ,GAAGU,GAAID,CAAE,KAAGR,EAAMG,GAAGJ,CAAC;AAG3C,gBAAMY,IAAS,KAAK,QAAQ,GAAGF,GAAID,CAAE;AACrC,cAAIG;AAAQ,uBAAWZ,KAAKY,EAAQ,CAAI,KAAK,KAAKR,GAAGJ,GAAGU,GAAID,CAAE,KAAGR,EAAMG,GAAGJ,CAAC;AAAA,QAC7E;AAAA,IAEJ;AAAA,EACF;AAAA;AAAA,EAGQ,KAAKI,GAASJ,GAASU,GAAYD,GAAqB;AAC9D,UAAMP,IAAI,KAAK;AACf,QAAIE,EAAE,OAAOF,IAAIF,EAAE,OAAOE,KAAKF,EAAE,OAAOE,IAAIE,EAAE,OAAOF,KAAKE,EAAE,OAAOF,IAAIF,EAAE,OAAOE,KAAKF,EAAE,OAAOE,IAAIE,EAAE,OAAOF,EAAG,QAAO;AACrH,UAAMC,IAAO,KAAK;AAClB,WAAOA,EAAK,OAAO,KAAK,IAAIC,EAAE,MAAMJ,EAAE,IAAI,IAAIE,CAAC,MAAMQ,KAAMP,EAAK,OAAO,KAAK,IAAIC,EAAE,MAAMJ,EAAE,IAAI,IAAIE,CAAC,MAAMO;AAAA,EAC3G;AACF;"}

package/dist/physics/Contact.js

@@ -0,0 +1,76 @@
+class n {
+  /** World position when measured, and the depth there (px, < 0 a gap). */
+  x = 0;
+  y = 0;
+  depth = 0;
+  /** Which corners or faces made it: matched from step to step to carry the impulses over. */
+  id = 0;
+  /** Accumulated normal and friction impulses. */
+  jn = 0;
+  jt = 0;
+  /** Per sub-step solver terms. */
+  massN = 0;
+  massT = 0;
+  target = 0;
+  /** Offsets from each body's centre, refreshed every sub-step. */
+  rax = 0;
+  ray = 0;
+  rbx = 0;
+  rby = 0;
+  /** The point in each body's own frame when measured, so position correction can track its depth as they move and turn. */
+  lax = 0;
+  lay = 0;
+  lbx = 0;
+  lby = 0;
+}
+class o {
+  constructor(s, t, e) {
+    this.a = s, this.b = t, this.key = e;
+  }
+  a;
+  b;
+  key;
+  nx = 0;
+  ny = 1;
+  depth = 0;
+  /** One or two points; only the first `count` are in use. */
+  pts = [new n(), new n()];
+  count = 0;
+  mu = 0;
+  /** Solved this sub-step (false when the pre-solve hook turned it off). */
+  enabled = !0;
+  /** The world step and sub-step that last found it. */
+  seenStep = -1;
+  seenSub = -1;
+  /** Reported as touching (a `begin` went out and no `end` yet). */
+  reported = !1;
+  get sensor() {
+    return this.a.sensor || this.b.sensor;
+  }
+  /** Where the two touch, world px. */
+  get points() {
+    const s = [];
+    for (let t = 0; t < this.count; t++) s.push({ x: this.pts[t].x, y: this.pts[t].y });
+    return s;
+  }
+  /** Accumulated normal impulse over the points: how hard the pair pressed together on the last sub-step. */
+  get normalImpulse() {
+    let s = 0;
+    for (let t = 0; t < this.count; t++) s += this.pts[t].jn;
+    return s;
+  }
+  /** The other body of the pair. */
+  other(s) {
+    return s === this.a ? this.b : this.a;
+  }
+  /** A stable number for the pair, whichever order it is asked in. */
+  static keyOf(s, t) {
+    const e = s.id < t.id ? s.id : t.id, r = s.id < t.id ? t.id : s.id;
+    return e * 67108864 + r;
+  }
+}
+export {
+  o as Contact,
+  n as ContactPoint
+};
+//# sourceMappingURL=Contact.js.map