1681-engine 0.0.0-stage → 0.5.8

package/dist/physics/collidePolygon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collidePolygon.js","sources":["../../src/physics/collidePolygon.ts"],"sourcesContent":["import type { Body } from './Body';\nimport type { Manifold } from './collide';\nimport { FACE_BOTTOM, FACE_LEFT, FACE_RIGHT, FACE_TOP } from './types';\n\n/** Face bits of a box's corners order (`Body.updateBounds`): face 0 is the top, then right, bottom, left. */\nconst BOX_FACE_BITS = [FACE_TOP, FACE_RIGHT, FACE_BOTTOM, FACE_LEFT] as const;\n\n/** A reference face is kept unless the other side's is deeper by more than this (px): no flip-flopping between equals. */\nconst FLIP_TOLERANCE = 0.05;\n\n/**\n * Whether `body` has an internal face (one lying against more solid ground) whose outward normal is (nx, ny): only\n * a merged tile box at no angle has them.\n */\nfunction internalAlong(body: Body, nx: number, ny: number): boolean {\n  if (!body.internalFaces || !body.axisAligned) return false;\n  for (let i = 0; i < 4; i++) {\n    if (body.internalFaces & BOX_FACE_BITS[i]! && body.wnx[i]! * nx + body.wny[i]! * ny > 0.999) return true;\n  }\n  return false;\n}\n\n/** A contact normal from a to b that pushes neither body out of an internal face. */\nfunction normalAllowed(a: Body, b: Body, nx: number, ny: number): boolean {\n  return !internalAlong(a, nx, ny) && !internalAlong(b, -nx, -ny);\n}\n\n/** Separation of `other`'s corners from face `i` of `ref`: the most negative is how deep the deepest corner lies. */\nfunction faceSeparation(ref: Body, i: number, other: Body): number {\n  const nx = ref.wnx[i]!;\n  const ny = ref.wny[i]!;\n  const vx = ref.wx[i]!;\n  const vy = ref.wy[i]!;\n  let min = Infinity;\n  for (let j = 0; j < other.corners; j++) {\n    const d = (other.wx[j]! - vx) * nx + (other.wy[j]! - vy) * ny;\n    if (d < min) min = d;\n  }\n  return min;\n}\n\ninterface Best {\n  sep: number;\n  face: number;\n}\n\n/** The face of `ref` the two are furthest apart along, among the faces whose normal may be used; also the plain SAT maximum. */\nfunction bestFace(ref: Body, other: Body, refIsA: boolean, best: Best): number {\n  let max = -Infinity;\n  best.sep = -Infinity;\n  best.face = -1;\n  for (let i = 0; i < ref.corners; i++) {\n    const s = faceSeparation(ref, i, other);\n    if (s > max) max = s;\n    const nx = refIsA ? ref.wnx[i]! : -ref.wnx[i]!;\n    const ny = refIsA ? ref.wny[i]! : -ref.wny[i]!;\n    const ok = refIsA ? normalAllowed(ref, other, nx, ny) : normalAllowed(other, ref, nx, ny);\n    if (ok && s > best.sep) {\n      best.sep = s;\n      best.face = i;\n    }\n  }\n  return max;\n}\n\nconst bestA: Best = { sep: 0, face: -1 };\nconst bestB: Best = { sep: 0, face: -1 };\nconst clipX = [0, 0];\nconst clipY = [0, 0];\nconst clipId = [0, 0];\n\n/**\n * Two convex shapes (boxes or polygons, turned or not) by the separating axis test, then the incident edge clipped\n * against the reference face's sides (Box2D's manifold), giving one or two points. A normal out of a merged tile box's\n * internal face is never used, so a turned crate slides over the seams of a tile floor like a square one does.\n */\nexport function polygonPolygon(a: Body, b: Body, margin: number, out: Manifold): boolean {\n  const maxA = bestFace(a, b, true, bestA);\n  if (maxA > margin) return false;\n  const maxB = bestFace(b, a, false, bestB);\n  if (maxB > margin) return false;\n  let flip: boolean;\n  if (bestA.face < 0 && bestB.face < 0) {\n    // every axis is an internal face: fall back to the plain shallowest one, as the axis-aligned test does\n    flip = maxB > maxA + FLIP_TOLERANCE;\n    if (!flip) bestA.face = faceOfSeparation(a, b, maxA);\n    else bestB.face = faceOfSeparation(b, a, maxB);\n  } else if (bestA.face < 0) flip = true;\n  else if (bestB.face < 0) flip = false;\n  else flip = bestB.sep > bestA.sep + FLIP_TOLERANCE;\n  const ref = flip ? b : a;\n  const inc = flip ? a : b;\n  const r = flip ? bestB.face : bestA.face;\n  const nrx = ref.wnx[r]!;\n  const nry = ref.wny[r]!;\n  // the incident face: the one of the other body most against the reference normal\n  let k = 0;\n  let minDot = Infinity;\n  for (let j = 0; j < inc.corners; j++) {\n    const d = inc.wnx[j]! * nrx + inc.wny[j]! * nry;\n    if (d < minDot) {\n      minDot = d;\n      k = j;\n    }\n  }\n  const k2 = (k + 1) % inc.corners;\n  clipX[0] = inc.wx[k]!;\n  clipY[0] = inc.wy[k]!;\n  clipId[0] = k;\n  clipX[1] = inc.wx[k2]!;\n  clipY[1] = inc.wy[k2]!;\n  clipId[1] = k2;\n  const r2 = (r + 1) % ref.corners;\n  const r1x = ref.wx[r]!;\n  const r1y = ref.wy[r]!;\n  const r2x = ref.wx[r2]!;\n  const r2y = ref.wy[r2]!;\n  const tl = Math.hypot(r2x - r1x, r2y - r1y);\n  const tx = (r2x - r1x) / tl;\n  const ty = (r2y - r1y) / tl;\n  // keep what lies between the reference face's two side planes\n  if (!clip(-tx, -ty, -(tx * r1x + ty * r1y), 16)) return false;\n  if (!clip(tx, ty, tx * r2x + ty * r2y, 17)) return false;\n  out.nx = flip ? -nrx : nrx;\n  out.ny = flip ? -nry : nry;\n  out.count = 0;\n  out.depth = -Infinity;\n  for (let i = 0; i < 2; i++) {\n    const sep = (clipX[i]! - r1x) * nrx + (clipY[i]! - r1y) * nry;\n    if (sep > margin) continue;\n    const n = out.count++;\n    // halfway between the incident corner and the reference face\n    out.px[n] = clipX[i]! - nrx * sep * 0.5;\n    out.py[n] = clipY[i]! - nry * sep * 0.5;\n    out.pd[n] = -sep;\n    out.id[n] = ((flip ? 1 : 0) << 12) | (r << 6) | clipId[i]!;\n    if (-sep > out.depth) out.depth = -sep;\n  }\n  return out.count > 0;\n}\n\n/** The first face of `ref` whose separation is `sep`. */\nfunction faceOfSeparation(ref: Body, other: Body, sep: number): number {\n  for (let i = 0; i < ref.corners; i++) if (faceSeparation(ref, i, other) === sep) return i;\n  return 0;\n}\n\n/** Clips the two points in `clipX/Y` to the half plane n·p ≤ offset; a cut point gets the feature id `cutId`. */\nfunction clip(nx: number, ny: number, offset: number, cutId: number): boolean {\n  const d0 = nx * clipX[0]! + ny * clipY[0]! - offset;\n  const d1 = nx * clipX[1]! + ny * clipY[1]! - offset;\n  if (d0 > 0 && d1 > 0) return false;\n  if (d0 <= 0 && d1 <= 0) return true;\n  const t = d0 / (d0 - d1);\n  const x = clipX[0]! + (clipX[1]! - clipX[0]!) * t;\n  const y = clipY[0]! + (clipY[1]! - clipY[0]!) * t;\n  if (d0 > 0) {\n    clipX[0] = x;\n    clipY[0] = y;\n    clipId[0] = cutId;\n  } else {\n    clipX[1] = x;\n    clipY[1] = y;\n    clipId[1] = cutId;\n  }\n  return true;\n}\n\n/**\n * A circle against a box or polygon that is turned (or turns): the face the centre lies furthest out of, then that\n * face's middle or one of its corners. `circleIsA` says which way round the pair is, so the normal runs from a to b.\n */\nexport function circlePolygon(circle: Body, radius: number, poly: Body, margin: number, circleIsA: boolean, out: Manifold): boolean {\n  const cx = circle.x;\n  const cy = circle.y;\n  let face = 0;\n  let sep = -Infinity;\n  for (let i = 0; i < poly.corners; i++) {\n    const s = (cx - poly.wx[i]!) * poly.wnx[i]! + (cy - poly.wy[i]!) * poly.wny[i]!;\n    if (s > sep) {\n      sep = s;\n      face = i;\n    }\n  }\n  if (sep > radius + margin) return false;\n  // normal from the polygon to the circle, and the distance from the polygon's surface to the circle's centre\n  let nx = poly.wnx[face]!;\n  let ny = poly.wny[face]!;\n  let dist = sep;\n  let id = face;\n  if (sep > 0) {\n    const f2 = (face + 1) % poly.corners;\n    const v1x = poly.wx[face]!;\n    const v1y = poly.wy[face]!;\n    const v2x = poly.wx[f2]!;\n    const v2y = poly.wy[f2]!;\n    const u1 = (cx - v1x) * (v2x - v1x) + (cy - v1y) * (v2y - v1y);\n    const u2 = (cx - v2x) * (v1x - v2x) + (cy - v2y) * (v1y - v2y);\n    if (u1 <= 0 || u2 <= 0) {\n      const vx = u1 <= 0 ? v1x : v2x;\n      const vy = u1 <= 0 ? v1y : v2y;\n      const d = Math.hypot(cx - vx, cy - vy);\n      if (d > radius + margin) return false;\n      if (d > 1e-9) {\n        nx = (cx - vx) / d;\n        ny = (cy - vy) / d;\n      }\n      dist = d;\n      id = 32 + (u1 <= 0 ? face : f2);\n    }\n  }\n  const depth = radius - dist;\n  out.nx = circleIsA ? -nx : nx;\n  out.ny = circleIsA ? -ny : ny;\n  out.depth = depth;\n  out.count = 1;\n  out.px[0] = cx - nx * (radius - depth / 2);\n  out.py[0] = cy - ny * (radius - depth / 2);\n  out.pd[0] = depth;\n  out.id[0] = id;\n  return true;\n}\n"],"names":["BOX_FACE_BITS","FACE_TOP","FACE_RIGHT","FACE_BOTTOM","FACE_LEFT","FLIP_TOLERANCE","internalAlong","body","nx","ny","i","normalAllowed","a","b","faceSeparation","ref","other","vx","vy","min","j","d","bestFace","refIsA","best","max","bestA","bestB","clipX","clipY","clipId","polygonPolygon","margin","out","maxA","maxB","flip","faceOfSeparation","inc","r","nrx","nry","k","minDot","k2","r2","r1x","r1y","r2x","r2y","tl","tx","ty","clip","sep","n","offset","cutId","d0","d1","t","x","y","circlePolygon","circle","radius","poly","circleIsA","cx","cy","face","s","dist","id","f2","v1x","v1y","v2x","v2y","u1","u2","depth"],"mappings":"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"}

package/dist/physics/contactReport.js

@@ -0,0 +1,14 @@
+function u(n, e, r) {
+  if (n.grounded) return;
+  n.grounded = !0, n.ground = e;
+  const t = n === r.b ? 1 : -1;
+  n.groundNx = r.nx * t, n.groundNy = r.ny * t;
+}
+function o(n) {
+  return { a: n.a, b: n.b, nx: n.nx, ny: n.ny, depth: n.depth, sensor: n.sensor, points: n.points };
+}
+export {
+  o as info,
+  u as setGround
+};
+//# sourceMappingURL=contactReport.js.map

package/dist/physics/contactReport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contactReport.js","sources":["../../src/physics/contactReport.ts"],"sourcesContent":["import type { Body } from './Body';\nimport type { Contact } from './Contact';\nimport type { ContactInfo } from './types';\n\n/** Marks `body` as standing on `ground` through contact `c`; the first ground found in a step wins. */\nexport function setGround(body: Body, ground: Body, c: Contact): void {\n  if (body.grounded) return;\n  body.grounded = true;\n  body.ground = ground;\n  const s = body === c.b ? 1 : -1;\n  body.groundNx = c.nx * s;\n  body.groundNy = c.ny * s;\n}\n\n/** A copy for an event: the contact itself changes on the next step. */\nexport function info(c: Contact): ContactInfo {\n  return { a: c.a, b: c.b, nx: c.nx, ny: c.ny, depth: c.depth, sensor: c.sensor, points: c.points };\n}\n"],"names":["setGround","body","ground","c","s","info"],"mappings":"AAKO,SAASA,EAAUC,GAAYC,GAAcC,GAAkB;AACpE,MAAIF,EAAK,SAAU;AACnB,EAAAA,EAAK,WAAW,IAChBA,EAAK,SAASC;AACd,QAAME,IAAIH,MAASE,EAAE,IAAI,IAAI;AAC7B,EAAAF,EAAK,WAAWE,EAAE,KAAKC,GACvBH,EAAK,WAAWE,EAAE,KAAKC;AACzB;AAGO,SAASC,EAAKF,GAAyB;AAC5C,SAAO,EAAE,GAAGA,EAAE,GAAG,GAAGA,EAAE,GAAG,IAAIA,EAAE,IAAI,IAAIA,EAAE,IAAI,OAAOA,EAAE,OAAO,QAAQA,EAAE,QAAQ,QAAQA,EAAE,OAAA;AAC3F;"}

package/dist/physics/drawColliders.js

@@ -0,0 +1,31 @@
+const a = {
+  static: 4259680,
+  kinematic: 4251903,
+  grounded: 16777056,
+  airborne: 16736352,
+  sleeping: 8421504,
+  sensor: 16736480
+};
+function m(e, n, c = {}, d, o) {
+  const u = { ...a, ...c };
+  for (const r of e.bodies) {
+    const s = d?.(r) ?? f(r, u);
+    if (o && r.corners > 0 && !r.axisAligned) {
+      for (let i = 0; i < r.corners; i++) {
+        const t = (i + 1) % r.corners;
+        o(r.wx[i], r.wy[i], r.wx[t], r.wy[t], s);
+      }
+      continue;
+    }
+    n(r.minX, r.minY, r.maxX - r.minX, r.maxY - r.minY, s), o && r.shape.kind === "circle" && r.rotates && o(r.x, r.y, r.x + r.cos * r.shape.radius, r.y + r.sin * r.shape.radius, s);
+  }
+}
+function f(e, n = a) {
+  return e.sensor ? n.sensor : e.type === "static" ? n.static : e.type === "kinematic" ? n.kinematic : e.awake ? e.grounded ? n.grounded : n.airborne : n.sleeping;
+}
+export {
+  a as COLLIDER_COLORS,
+  f as colliderColor,
+  m as drawColliders
+};
+//# sourceMappingURL=drawColliders.js.map

package/dist/physics/drawColliders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawColliders.js","sources":["../../src/physics/drawColliders.ts"],"sourcesContent":["import type { Body } from './Body';\nimport type { PhysicsWorld } from './PhysicsWorld';\n\n/** Colours `drawColliders` gives each kind of body. */\nexport interface ColliderColors {\n  static: number;\n  kinematic: number;\n  /** A dynamic body standing on something. */\n  grounded: number;\n  /** A dynamic body in the air. */\n  airborne: number;\n  /** A dynamic body asleep (only with `allowSleep`). */\n  sleeping: number;\n  sensor: number;\n}\n\nexport const COLLIDER_COLORS: Readonly<ColliderColors> = {\n  static: 0x40ff60,\n  kinematic: 0x40e0ff,\n  grounded: 0xffff60,\n  airborne: 0xff6060,\n  sleeping: 0x808080,\n  sensor: 0xff60e0,\n};\n\n/**\n * Draws one box in world coordinates. The same shape as `DebugOverlay`'s `BoxDrawer`, written out here so the physics\n * module stays free of anything that draws.\n */\nexport type ColliderBoxDrawer = (x: number, y: number, width: number, height: number, color?: number) => void;\n\n/** Draws one line in world coordinates (`DebugOverlay`'s `LineDrawer`). */\nexport type ColliderLineDrawer = (x0: number, y0: number, x1: number, y1: number, color?: number) => void;\n\n/**\n * Draws every body's bounding box, coloured by what it is: the usual body of a `DebugOverlay`'s `colliders` callback,\n * which otherwise made every game keep a list of its own bodies just to show them.\n *\n * ```ts\n * new DebugOverlay(engine, { colliders: (draw) => drawColliders(physics, draw) });\n * ```\n *\n * `colorOf` picks a game's own colour for a body (a one-way plank, a hazard), or returns undefined for the default.\n * A circle is drawn as its bounding box: the overlay draws boxes, and a box round a circle still shows where it is.\n * Given `line` (the overlay hands it over as its second argument), a turned box or a polygon is drawn as its own\n * outline, and a circle that rotates gets a spoke showing its angle.\n *\n * ```ts\n * new DebugOverlay(engine, { colliders: (draw, line) => drawColliders(physics, draw, {}, undefined, line) });\n * ```\n */\nexport function drawColliders(\n  world: PhysicsWorld,\n  draw: ColliderBoxDrawer,\n  colors: Partial<ColliderColors> = {},\n  colorOf?: (body: Body) => number | undefined,\n  line?: ColliderLineDrawer,\n): void {\n  const c = { ...COLLIDER_COLORS, ...colors };\n  for (const b of world.bodies) {\n    const color = colorOf?.(b) ?? colliderColor(b, c);\n    if (line && b.corners > 0 && !b.axisAligned) {\n      for (let i = 0; i < b.corners; i++) {\n        const j = (i + 1) % b.corners;\n        line(b.wx[i]!, b.wy[i]!, b.wx[j]!, b.wy[j]!, color);\n      }\n      continue;\n    }\n    draw(b.minX, b.minY, b.maxX - b.minX, b.maxY - b.minY, color);\n    if (line && b.shape.kind === 'circle' && b.rotates) line(b.x, b.y, b.x + b.cos * b.shape.radius, b.y + b.sin * b.shape.radius, color);\n  }\n}\n\n/** The default colour of one body. */\nexport function colliderColor(b: Body, c: ColliderColors = COLLIDER_COLORS): number {\n  if (b.sensor) return c.sensor;\n  if (b.type === 'static') return c.static;\n  if (b.type === 'kinematic') return c.kinematic;\n  if (!b.awake) return c.sleeping;\n  return b.grounded ? c.grounded : c.airborne;\n}\n"],"names":["COLLIDER_COLORS","drawColliders","world","draw","colors","colorOf","line","c","b","color","colliderColor","j"],"mappings":"AAgBO,MAAMA,IAA4C;AAAA,EACvD,QAAQ;AAAA,EACR,WAAW;AAAA,EACX,UAAU;AAAA,EACV,UAAU;AAAA,EACV,UAAU;AAAA,EACV,QAAQ;AACV;AA4BO,SAASC,EACdC,GACAC,GACAC,IAAkC,CAAA,GAClCC,GACAC,GACM;AACN,QAAMC,IAAI,EAAE,GAAGP,GAAiB,GAAGI,EAAA;AACnC,aAAWI,KAAKN,EAAM,QAAQ;AAC5B,UAAMO,IAAQJ,IAAUG,CAAC,KAAKE,EAAcF,GAAGD,CAAC;AAChD,QAAID,KAAQE,EAAE,UAAU,KAAK,CAACA,EAAE,aAAa;AAC3C,eAAS,IAAI,GAAG,IAAIA,EAAE,SAAS,KAAK;AAClC,cAAMG,KAAK,IAAI,KAAKH,EAAE;AACtB,QAAAF,EAAKE,EAAE,GAAG,CAAC,GAAIA,EAAE,GAAG,CAAC,GAAIA,EAAE,GAAGG,CAAC,GAAIH,EAAE,GAAGG,CAAC,GAAIF,CAAK;AAAA,MACpD;AACA;AAAA,IACF;AACA,IAAAN,EAAKK,EAAE,MAAMA,EAAE,MAAMA,EAAE,OAAOA,EAAE,MAAMA,EAAE,OAAOA,EAAE,MAAMC,CAAK,GACxDH,KAAQE,EAAE,MAAM,SAAS,YAAYA,EAAE,WAASF,EAAKE,EAAE,GAAGA,EAAE,GAAGA,EAAE,IAAIA,EAAE,MAAMA,EAAE,MAAM,QAAQA,EAAE,IAAIA,EAAE,MAAMA,EAAE,MAAM,QAAQC,CAAK;AAAA,EACtI;AACF;AAGO,SAASC,EAAcF,GAASD,IAAoBP,GAAyB;AAClF,SAAIQ,EAAE,SAAeD,EAAE,SACnBC,EAAE,SAAS,WAAiBD,EAAE,SAC9BC,EAAE,SAAS,cAAoBD,EAAE,YAChCC,EAAE,QACAA,EAAE,WAAWD,EAAE,WAAWA,EAAE,WADdA,EAAE;AAEzB;"}

package/dist/physics/physicsSystem.js

@@ -0,0 +1,8 @@
+import { system as i } from "../ecs/World.js";
+function r(s, t = "physics") {
+  return i(t, "fixed", ({ dt: e }) => s.step(e));
+}
+export {
+  r as physicsSystem
+};
+//# sourceMappingURL=physicsSystem.js.map

package/dist/physics/physicsSystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"physicsSystem.js","sources":["../../src/physics/physicsSystem.ts"],"sourcesContent":["import { system, type System } from '../ecs/World';\nimport type { PhysicsWorld } from './PhysicsWorld';\n\n/** A `fixed` system that steps `physics` once per simulation step, by the loop's own dt. */\nexport function physicsSystem(physics: PhysicsWorld, name = 'physics'): System {\n  return system(name, 'fixed', ({ dt }) => physics.step(dt));\n}\n"],"names":["physicsSystem","physics","name","system","dt"],"mappings":";AAIO,SAASA,EAAcC,GAAuBC,IAAO,WAAmB;AAC7E,SAAOC,EAAOD,GAAM,SAAS,CAAC,EAAE,IAAAE,QAASH,EAAQ,KAAKG,CAAE,CAAC;AAC3D;"}

package/dist/physics/polygon.js

@@ -0,0 +1,80 @@
+const O = 16;
+function M(s) {
+  let t = 0;
+  for (let n = 0; n < s.length; n++) {
+    const o = s[n], r = s[(n + 1) % s.length];
+    t += o.x * r.y - r.x * o.y;
+  }
+  return t;
+}
+function d(s) {
+  const t = E(s);
+  let n = 0, o = 0, r = 0;
+  for (let c = 0; c < t.length; c++) {
+    const e = t[c], l = t[(c + 1) % t.length], y = e.x * l.y - l.x * e.y;
+    r += y, n += (e.x + l.x) * y, o += (e.y + l.y) * y;
+  }
+  if (Math.abs(r) < 1e-9) throw new Error("polygonShape: the points enclose no area");
+  return { x: n / (3 * r), y: o / (3 * r) };
+}
+function m(s) {
+  const t = E(s);
+  if (t.length < 3) throw new Error("polygonShape: needs at least three points not on one line");
+  if (t.length > 16) throw new Error(`polygonShape: at most 16 corners, got ${t.length}`);
+  const n = d(t);
+  return { kind: "polygon", vertices: t.map((o) => ({ x: o.x - n.x, y: o.y - n.y })) };
+}
+function S(s, t) {
+  const n = Math.max(3, Math.min(16, Math.round(s))), o = [];
+  for (let r = 0; r < n; r++) {
+    const c = -Math.PI / 2 + r * 2 * Math.PI / n;
+    o.push({ x: Math.cos(c) * t, y: Math.sin(c) * t });
+  }
+  return m(o);
+}
+function E(s) {
+  const t = s.map((e) => ({ x: e.x, y: e.y })).sort((e, l) => e.x - l.x || e.y - l.y);
+  if (t.length < 3) return t;
+  const n = (e, l, y) => (l.x - e.x) * (y.y - e.y) - (l.y - e.y) * (y.x - e.x), o = [];
+  for (const e of t) {
+    for (; o.length >= 2 && n(o[o.length - 2], o[o.length - 1], e) <= 1e-9; ) o.pop();
+    o.push(e);
+  }
+  const r = [];
+  for (let e = t.length - 1; e >= 0; e--) {
+    const l = t[e];
+    for (; r.length >= 2 && n(r[r.length - 2], r[r.length - 1], l) <= 1e-9; ) r.pop();
+    r.push(l);
+  }
+  const c = o.slice(0, -1).concat(r.slice(0, -1));
+  return M(c) < 0 ? c.reverse() : c;
+}
+const w = /* @__PURE__ */ new WeakMap();
+function _(s) {
+  let t = w.get(s);
+  if (t) return t;
+  const n = s.vertices;
+  if (n.length < 3 || n.length > 16) throw new Error(`Body: a polygon needs 3–16 corners, got ${n.length}`);
+  if (M(n) <= 0) throw new Error("Body: polygon corners must run clockwise on screen (make the shape with polygonShape)");
+  const o = [];
+  let r = 0, c = 0, e = 0, l = 1 / 0;
+  for (let y = 0; y < n.length; y++) {
+    const h = n[y], a = n[(y + 1) % n.length], p = a.x - h.x, g = a.y - h.y, x = Math.hypot(p, g);
+    if (x < 1e-9) throw new Error("Body: a polygon has two corners in one place");
+    const i = { x: g / x, y: -p / x };
+    o.push(i);
+    const u = n[(y + 2) % n.length];
+    if ((u.x - h.x) * i.x + (u.y - h.y) * i.y > 1e-6) throw new Error("Body: a polygon must be convex (make the shape with polygonShape)");
+    const f = h.x * a.y - a.x * h.y;
+    c += f / 2, r += f * (h.x * h.x + h.x * a.x + a.x * a.x + h.y * h.y + h.y * a.y + a.y * a.y) / 12, e = Math.max(e, Math.hypot(h.x, h.y)), l = Math.min(l, h.x * i.x + h.y * i.y);
+  }
+  return t = { vertices: n, normals: o, inertiaPerMass: r / c, radius: e, inradius: l }, w.set(s, t), t;
+}
+export {
+  O as MAX_POLYGON_VERTICES,
+  d as polygonCentroid,
+  _ as polygonData,
+  m as polygonShape,
+  S as regularPolygon
+};
+//# sourceMappingURL=polygon.js.map

package/dist/physics/polygon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon.js","sources":["../../src/physics/polygon.ts"],"sourcesContent":["import type { BoxShape, PolygonShape, Vec2 } from './types';\n\n/** The most corners a polygon shape may have. */\nexport const MAX_POLYGON_VERTICES = 16;\n\n/** Twice the signed area: positive when the points run clockwise on screen (y down), the order shapes are kept in. */\nfunction doubleArea(points: readonly Vec2[]): number {\n  let a = 0;\n  for (let i = 0; i < points.length; i++) {\n    const p = points[i]!;\n    const q = points[(i + 1) % points.length]!;\n    a += p.x * q.y - q.x * p.y;\n  }\n  return a;\n}\n\n/** The centroid of the convex hull of `points`: where to put the body so a `polygonShape(points)` lands on them. */\nexport function polygonCentroid(points: readonly Vec2[]): Vec2 {\n  const hull = convexHull(points);\n  let cx = 0;\n  let cy = 0;\n  let a = 0;\n  for (let i = 0; i < hull.length; i++) {\n    const p = hull[i]!;\n    const q = hull[(i + 1) % hull.length]!;\n    const cross = p.x * q.y - q.x * p.y;\n    a += cross;\n    cx += (p.x + q.x) * cross;\n    cy += (p.y + q.y) * cross;\n  }\n  if (Math.abs(a) < 1e-9) throw new Error('polygonShape: the points enclose no area');\n  return { x: cx / (3 * a), y: cy / (3 * a) };\n}\n\n/**\n * A convex polygon shape from any points: their convex hull, in the order the solver keeps, moved so its centroid is\n * the body's position. Give points round the origin, or anywhere and place the body at `polygonCentroid(points)`.\n */\nexport function polygonShape(points: readonly Vec2[]): PolygonShape {\n  const hull = convexHull(points);\n  if (hull.length < 3) throw new Error('polygonShape: needs at least three points not on one line');\n  if (hull.length > MAX_POLYGON_VERTICES) throw new Error(`polygonShape: at most ${MAX_POLYGON_VERTICES} corners, got ${hull.length}`);\n  const c = polygonCentroid(hull);\n  return { kind: 'polygon', vertices: hull.map((p) => ({ x: p.x - c.x, y: p.y - c.y })) };\n}\n\n/** A regular polygon of `sides` corners on a circle of `radius`, its first corner straight up. */\nexport function regularPolygon(sides: number, radius: number): PolygonShape {\n  const n = Math.max(3, Math.min(MAX_POLYGON_VERTICES, Math.round(sides)));\n  const points: Vec2[] = [];\n  for (let i = 0; i < n; i++) {\n    const t = -Math.PI / 2 + (i * 2 * Math.PI) / n;\n    points.push({ x: Math.cos(t) * radius, y: Math.sin(t) * radius });\n  }\n  return polygonShape(points);\n}\n\n/** Andrew's monotone chain, returned clockwise on screen (positive `doubleArea`), collinear points dropped. */\nfunction convexHull(points: readonly Vec2[]): Vec2[] {\n  const pts = points.map((p) => ({ x: p.x, y: p.y })).sort((a, b) => a.x - b.x || a.y - b.y);\n  if (pts.length < 3) return pts;\n  const cross = (o: Vec2, a: Vec2, b: Vec2) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);\n  const lower: Vec2[] = [];\n  for (const p of pts) {\n    while (lower.length >= 2 && cross(lower[lower.length - 2]!, lower[lower.length - 1]!, p) <= 1e-9) lower.pop();\n    lower.push(p);\n  }\n  const upper: Vec2[] = [];\n  for (let i = pts.length - 1; i >= 0; i--) {\n    const p = pts[i]!;\n    while (upper.length >= 2 && cross(upper[upper.length - 2]!, upper[upper.length - 1]!, p) <= 1e-9) upper.pop();\n    upper.push(p);\n  }\n  const hull = lower.slice(0, -1).concat(upper.slice(0, -1));\n  return doubleArea(hull) < 0 ? hull.reverse() : hull;\n}\n\n/** Local outward normals and the solver's mass terms of a polygon, worked out once per shape object. */\nexport interface PolygonData {\n  readonly vertices: readonly Vec2[];\n  readonly normals: readonly Vec2[];\n  /** Second moment of area about the centroid per unit of area-mass: inertia = mass × this. */\n  readonly inertiaPerMass: number;\n  /** The furthest corner from the centre. */\n  readonly radius: number;\n  /** The nearest face to the centre: how far the body may move in one sub-step without passing through anything. */\n  readonly inradius: number;\n}\n\nconst cache = new WeakMap<PolygonShape, PolygonData>();\n\n/** The data of a polygon shape, checked (convex, in order) the first time it is asked for. */\nexport function polygonData(shape: PolygonShape): PolygonData {\n  let d = cache.get(shape);\n  if (d) return d;\n  const v = shape.vertices;\n  if (v.length < 3 || v.length > MAX_POLYGON_VERTICES) throw new Error(`Body: a polygon needs 3–${MAX_POLYGON_VERTICES} corners, got ${v.length}`);\n  if (doubleArea(v) <= 0) throw new Error('Body: polygon corners must run clockwise on screen (make the shape with polygonShape)');\n  const normals: Vec2[] = [];\n  let inertia = 0;\n  let area = 0;\n  let radius = 0;\n  let inradius = Infinity;\n  for (let i = 0; i < v.length; i++) {\n    const p = v[i]!;\n    const q = v[(i + 1) % v.length]!;\n    const ex = q.x - p.x;\n    const ey = q.y - p.y;\n    const len = Math.hypot(ex, ey);\n    if (len < 1e-9) throw new Error('Body: a polygon has two corners in one place');\n    const n = { x: ey / len, y: -ex / len };\n    normals.push(n);\n    const r = v[(i + 2) % v.length]!;\n    if ((r.x - p.x) * n.x + (r.y - p.y) * n.y > 1e-6) throw new Error('Body: a polygon must be convex (make the shape with polygonShape)');\n    const cross = p.x * q.y - q.x * p.y;\n    area += cross / 2;\n    inertia += (cross * (p.x * p.x + p.x * q.x + q.x * q.x + p.y * p.y + p.y * q.y + q.y * q.y)) / 12;\n    radius = Math.max(radius, Math.hypot(p.x, p.y));\n    inradius = Math.min(inradius, p.x * n.x + p.y * n.y);\n  }\n  d = { vertices: v, normals, inertiaPerMass: inertia / area, radius, inradius };\n  cache.set(shape, d);\n  return d;\n}\n\n/** A box as the four corners the polygon tests use: top-left first, clockwise on screen, so face i is top, right, bottom, left. */\nexport function boxCorners(s: BoxShape): Vec2[] {\n  return [\n    { x: -s.halfWidth, y: -s.halfHeight },\n    { x: s.halfWidth, y: -s.halfHeight },\n    { x: s.halfWidth, y: s.halfHeight },\n    { x: -s.halfWidth, y: s.halfHeight },\n  ];\n}\n"],"names":["MAX_POLYGON_VERTICES","doubleArea","points","a","i","p","q","polygonCentroid","hull","convexHull","cx","cy","cross","polygonShape","c","regularPolygon","sides","radius","t","pts","b","o","lower","upper","cache","polygonData","shape","d","v","normals","inertia","area","inradius","ex","ey","len","n","r"],"mappings":"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"}

package/dist/physics/raycast.js

@@ -0,0 +1,62 @@
+const p = { t: 0, nx: 0, ny: 0 };
+function L(t, r, a, u, m, x, i) {
+  const o = t.shape;
+  if (o.kind === "circle") {
+    const n = r - t.x, e = a - t.y, l = u * u + m * m, X = n * n + e * e - o.radius * o.radius;
+    if (X <= 0 || l === 0) return !1;
+    const M = n * u + e * m, Y = M * M - l * X;
+    if (Y < 0 || M > 0) return !1;
+    const w = (-M - Math.sqrt(Y)) / l;
+    return w < 0 || w > x ? !1 : (i.t = w, i.nx = (n + u * w) / o.radius, i.ny = (e + m * w) / o.radius, !0);
+  }
+  if (!t.axisAligned) return P(t, r, a, u, m, x, i);
+  if (r > t.minX && r < t.maxX && a > t.minY && a < t.maxY) return !1;
+  let c = -1 / 0, s = 1 / 0, h = 0, f = 0;
+  if (u !== 0) {
+    const n = (t.minX - r) / u, e = (t.maxX - r) / u, l = Math.min(n, e);
+    l > c && (c = l, h = u > 0 ? -1 : 1, f = 0), s = Math.min(s, Math.max(n, e));
+  } else if (r < t.minX || r > t.maxX) return !1;
+  if (m !== 0) {
+    const n = (t.minY - a) / m, e = (t.maxY - a) / m, l = Math.min(n, e);
+    l > c && (c = l, h = 0, f = m > 0 ? -1 : 1), s = Math.min(s, Math.max(n, e));
+  } else if (a < t.minY || a > t.maxY) return !1;
+  return c > s || c < 0 || c > x ? !1 : (i.t = c, i.nx = h, i.ny = f, !0);
+}
+function P(t, r, a, u, m, x, i) {
+  let o = 0, c = x, s = -1, h = !0;
+  for (let f = 0; f < t.corners; f++) {
+    const n = t.wnx[f], e = t.wny[f], l = (r - t.wx[f]) * n + (a - t.wy[f]) * e, X = u * n + m * e;
+    if (l > 0 && (h = !1), X === 0) {
+      if (l > 0) return !1;
+      continue;
+    }
+    const M = -l / X;
+    if (X < 0 ? M > o && (o = M, s = f) : M < c && (c = M), o > c) return !1;
+  }
+  return h || s < 0 ? !1 : (i.t = o, i.nx = t.wnx[s], i.ny = t.wny[s], !0);
+}
+let R = 0;
+function v(t, r, a, u, m, x = {}) {
+  const i = t[0];
+  if (!i) return null;
+  const o = x.mask ?? 4294967295, c = ++R, s = u - r, h = m - a, f = i.cellSize;
+  let n = i.cellOf(r), e = i.cellOf(a);
+  const l = i.cellOf(u), X = i.cellOf(m), M = s > 0 ? 1 : s < 0 ? -1 : 0, Y = h > 0 ? 1 : h < 0 ? -1 : 0, w = M !== 0 ? f / Math.abs(s) : 1 / 0, q = Y !== 0 ? f / Math.abs(h) : 1 / 0;
+  let O = M > 0 ? ((n + 1) * f - r) / s : M < 0 ? (n * f - r) / s : 1 / 0, g = Y > 0 ? ((e + 1) * f - a) / h : Y < 0 ? (e * f - a) / h : 1 / 0, S = null, I = 1, z = 0, D = 0, A = Math.abs(l - n) + Math.abs(X - e) + 1;
+  for (; ; ) {
+    for (const C of t) {
+      const N = C.at(n, e);
+      if (N)
+        for (const k of N)
+          k.rayStamp !== c && (k.rayStamp = c, k.layer & o && (k.sensor && !x.includeSensors || x.filter && !x.filter(k) || L(k, r, a, s, h, I, p) && (!S || p.t < I) && (S = k, I = p.t, z = p.nx, D = p.ny)));
+    }
+    if (--A <= 0 || Math.min(O, g) > I) break;
+    O < g ? (n += M, O += w) : (e += Y, g += q);
+  }
+  return S ? { body: S, x: r + s * I, y: a + h * I, nx: z, ny: D, fraction: I } : null;
+}
+export {
+  v as castRay,
+  L as rayShape
+};
+//# sourceMappingURL=raycast.js.map

package/dist/physics/raycast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"raycast.js","sources":["../../src/physics/raycast.ts"],"sourcesContent":["import type { Body } from './Body';\nimport type { SpatialHash } from './SpatialHash';\nimport type { RayHit, RaycastOptions } from './types';\n\n/** Where a ray from (ox, oy) along (dx, dy) — not normalised, t = 1 at its end — first enters a body. */\ninterface ShapeHit {\n  t: number;\n  nx: number;\n  ny: number;\n}\n\nconst scratch: ShapeHit = { t: 0, nx: 0, ny: 0 };\n\n/** A ray starting inside the shape misses it, so a body can cast from its own centre without hitting itself. */\nexport function rayShape(body: Body, ox: number, oy: number, dx: number, dy: number, maxT: number, out: ShapeHit): boolean {\n  const s = body.shape;\n  if (s.kind === 'circle') {\n    const fx = ox - body.x;\n    const fy = oy - body.y;\n    const a = dx * dx + dy * dy;\n    const c = fx * fx + fy * fy - s.radius * s.radius;\n    if (c <= 0 || a === 0) return false;\n    const b = fx * dx + fy * dy;\n    const disc = b * b - a * c;\n    if (disc < 0 || b > 0) return false;\n    const t = (-b - Math.sqrt(disc)) / a;\n    if (t < 0 || t > maxT) return false;\n    out.t = t;\n    out.nx = (fx + dx * t) / s.radius;\n    out.ny = (fy + dy * t) / s.radius;\n    return true;\n  }\n  if (!body.axisAligned) return rayPolygon(body, ox, oy, dx, dy, maxT, out);\n  if (ox > body.minX && ox < body.maxX && oy > body.minY && oy < body.maxY) return false;\n  let tmin = -Infinity;\n  let tmax = Infinity;\n  let nx = 0;\n  let ny = 0;\n  if (dx !== 0) {\n    const t1 = (body.minX - ox) / dx;\n    const t2 = (body.maxX - ox) / dx;\n    const near = Math.min(t1, t2);\n    if (near > tmin) {\n      tmin = near;\n      nx = dx > 0 ? -1 : 1;\n      ny = 0;\n    }\n    tmax = Math.min(tmax, Math.max(t1, t2));\n  } else if (ox < body.minX || ox > body.maxX) return false;\n  if (dy !== 0) {\n    const t1 = (body.minY - oy) / dy;\n    const t2 = (body.maxY - oy) / dy;\n    const near = Math.min(t1, t2);\n    if (near > tmin) {\n      tmin = near;\n      nx = 0;\n      ny = dy > 0 ? -1 : 1;\n    }\n    tmax = Math.min(tmax, Math.max(t1, t2));\n  } else if (oy < body.minY || oy > body.maxY) return false;\n  if (tmin > tmax || tmin < 0 || tmin > maxT) return false;\n  out.t = tmin;\n  out.nx = nx;\n  out.ny = ny;\n  return true;\n}\n\n/** Cyrus–Beck: the ray clipped by each face's half plane of a turned box or a polygon (world corners). */\nfunction rayPolygon(body: Body, ox: number, oy: number, dx: number, dy: number, maxT: number, out: ShapeHit): boolean {\n  let tmin = 0;\n  let tmax = maxT;\n  let face = -1;\n  let inside = true;\n  for (let i = 0; i < body.corners; i++) {\n    const nx = body.wnx[i]!;\n    const ny = body.wny[i]!;\n    // distance of the start outside face i, and how fast the ray closes on it\n    const num = (ox - body.wx[i]!) * nx + (oy - body.wy[i]!) * ny;\n    const den = dx * nx + dy * ny;\n    if (num > 0) inside = false;\n    if (den === 0) {\n      if (num > 0) return false;\n      continue;\n    }\n    const t = -num / den;\n    if (den < 0) {\n      if (t > tmin) {\n        tmin = t;\n        face = i;\n      }\n    } else if (t < tmax) tmax = t;\n    if (tmin > tmax) return false;\n  }\n  if (inside || face < 0) return false;\n  out.t = tmin;\n  out.nx = body.wnx[face]!;\n  out.ny = body.wny[face]!;\n  return true;\n}\n\nlet rayCounter = 0;\n\n/**\n * The first body a segment from (x0, y0) to (x1, y1) meets, walking the broad phase's cells in the ray's order\n * (Amanatides–Woo) and stopping once the next cell lies beyond the best hit so far; a long ray over a large map\n * looks only at the cells it crosses.\n */\nexport function castRay(hashes: readonly SpatialHash[], x0: number, y0: number, x1: number, y1: number, options: RaycastOptions = {}): RayHit | null {\n  const grid = hashes[0];\n  if (!grid) return null;\n  const mask = options.mask ?? 0xffffffff;\n  const stamp = ++rayCounter;\n  const dx = x1 - x0;\n  const dy = y1 - y0;\n  const size = grid.cellSize;\n  let cx = grid.cellOf(x0);\n  let cy = grid.cellOf(y0);\n  const ex = grid.cellOf(x1);\n  const ey = grid.cellOf(y1);\n  const stepX = dx > 0 ? 1 : dx < 0 ? -1 : 0;\n  const stepY = dy > 0 ? 1 : dy < 0 ? -1 : 0;\n  const tDeltaX = stepX !== 0 ? size / Math.abs(dx) : Infinity;\n  const tDeltaY = stepY !== 0 ? size / Math.abs(dy) : Infinity;\n  let tMaxX = stepX > 0 ? ((cx + 1) * size - x0) / dx : stepX < 0 ? (cx * size - x0) / dx : Infinity;\n  let tMaxY = stepY > 0 ? ((cy + 1) * size - y0) / dy : stepY < 0 ? (cy * size - y0) / dy : Infinity;\n  let best: Body | null = null;\n  let bestT = 1;\n  let bestNx = 0;\n  let bestNy = 0;\n  // the cell count bounds the walk even if rounding ever kept it from landing on the end cell exactly\n  let cellsLeft = Math.abs(ex - cx) + Math.abs(ey - cy) + 1;\n  for (;;) {\n    for (const hash of hashes) {\n      const list = hash.at(cx, cy);\n      if (!list) continue;\n      for (const body of list) {\n        if (body.rayStamp === stamp) continue;\n        body.rayStamp = stamp;\n        if (!(body.layer & mask)) continue;\n        if (body.sensor && !options.includeSensors) continue;\n        if (options.filter && !options.filter(body)) continue;\n        if (rayShape(body, x0, y0, dx, dy, bestT, scratch) && (!best || scratch.t < bestT)) {\n          best = body;\n          bestT = scratch.t;\n          bestNx = scratch.nx;\n          bestNy = scratch.ny;\n        }\n      }\n    }\n    if (--cellsLeft <= 0) break;\n    const next = Math.min(tMaxX, tMaxY);\n    if (next > bestT) break;\n    if (tMaxX < tMaxY) {\n      cx += stepX;\n      tMaxX += tDeltaX;\n    } else {\n      cy += stepY;\n      tMaxY += tDeltaY;\n    }\n  }\n  if (!best) return null;\n  return { body: best, x: x0 + dx * bestT, y: y0 + dy * bestT, nx: bestNx, ny: bestNy, fraction: bestT };\n}\n"],"names":["scratch","rayShape","body","ox","oy","dx","dy","maxT","out","s","fx","fy","a","c","b","disc","t","rayPolygon","tmin","tmax","nx","ny","t1","t2","near","face","inside","i","num","den","rayCounter","castRay","hashes","x0","y0","x1","y1","options","grid","mask","stamp","size","cx","cy","ex","ey","stepX","stepY","tDeltaX","tDeltaY","tMaxX","tMaxY","best","bestT","bestNx","bestNy","cellsLeft","hash","list"],"mappings":"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"}

package/dist/physics/syncToBody.js

@@ -0,0 +1,19 @@
+function s(l, n, c, a = 0, e = 0, g = !1) {
+  let r = n.prevX + (n.x - n.prevX) * c, M = n.prevY + (n.y - n.prevY) * c;
+  if (n.rotates || n.angle !== 0) {
+    let t = n.angle - n.prevAngle;
+    (t > Math.PI || t < -Math.PI) && (t -= Math.round(t / (2 * Math.PI)) * 2 * Math.PI);
+    const h = n.prevAngle + t * c;
+    if (a !== 0 || e !== 0) {
+      const p = Math.cos(h), i = Math.sin(h);
+      r += p * a - i * e, M += i * a + p * e;
+    }
+    l.rotation = h;
+  } else
+    r += a, M += e;
+  l.x = g ? Math.round(r) : r, l.y = g ? Math.round(M) : M;
+}
+export {
+  s as syncToBody
+};
+//# sourceMappingURL=syncToBody.js.map

package/dist/physics/syncToBody.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncToBody.js","sources":["../../src/physics/syncToBody.ts"],"sourcesContent":["import type { Body } from './Body';\n\n/** Anything with a settable position: a Pixi container, a sprite, a plain object. */\nexport interface Positioned {\n  x: number;\n  y: number;\n  /** Set to the body's angle when the body rotates or stands at an angle; left alone otherwise. */\n  rotation?: number;\n}\n\n/**\n * Places `view` where `body` is drawn this frame: between its last two step positions by the loop's `alpha`\n * (`SystemContext.alpha` in a `frame` system), so motion is smooth at any refresh rate even though physics steps\n * at a fixed rate. Pass `round` for pixel art, so the view lands on whole pixels. A body that rotates (or was placed\n * at an angle) turns the view too, by the shorter way between its last two angles; the offset is turned with it.\n */\nexport function syncToBody(view: Positioned, body: Body, alpha: number, offsetX = 0, offsetY = 0, round = false): void {\n  let x = body.prevX + (body.x - body.prevX) * alpha;\n  let y = body.prevY + (body.y - body.prevY) * alpha;\n  if (body.rotates || body.angle !== 0) {\n    let d = body.angle - body.prevAngle;\n    if (d > Math.PI || d < -Math.PI) d -= Math.round(d / (2 * Math.PI)) * 2 * Math.PI;\n    const angle = body.prevAngle + d * alpha;\n    if (offsetX !== 0 || offsetY !== 0) {\n      const c = Math.cos(angle);\n      const s = Math.sin(angle);\n      x += c * offsetX - s * offsetY;\n      y += s * offsetX + c * offsetY;\n    }\n    view.rotation = angle;\n  } else {\n    x += offsetX;\n    y += offsetY;\n  }\n  view.x = round ? Math.round(x) : x;\n  view.y = round ? Math.round(y) : y;\n}\n"],"names":["syncToBody","view","body","alpha","offsetX","offsetY","round","x","y","d","angle","c","s"],"mappings":"AAgBO,SAASA,EAAWC,GAAkBC,GAAYC,GAAeC,IAAU,GAAGC,IAAU,GAAGC,IAAQ,IAAa;AACrH,MAAIC,IAAIL,EAAK,SAASA,EAAK,IAAIA,EAAK,SAASC,GACzCK,IAAIN,EAAK,SAASA,EAAK,IAAIA,EAAK,SAASC;AAC7C,MAAID,EAAK,WAAWA,EAAK,UAAU,GAAG;AACpC,QAAIO,IAAIP,EAAK,QAAQA,EAAK;AAC1B,KAAIO,IAAI,KAAK,MAAMA,IAAI,CAAC,KAAK,QAAIA,KAAK,KAAK,MAAMA,KAAK,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK;AAC/E,UAAMC,IAAQR,EAAK,YAAYO,IAAIN;AACnC,QAAIC,MAAY,KAAKC,MAAY,GAAG;AAClC,YAAMM,IAAI,KAAK,IAAID,CAAK,GAClBE,IAAI,KAAK,IAAIF,CAAK;AACxB,MAAAH,KAAKI,IAAIP,IAAUQ,IAAIP,GACvBG,KAAKI,IAAIR,IAAUO,IAAIN;AAAA,IACzB;AACA,IAAAJ,EAAK,WAAWS;AAAA,EAClB;AACE,IAAAH,KAAKH,GACLI,KAAKH;AAEP,EAAAJ,EAAK,IAAIK,IAAQ,KAAK,MAAMC,CAAC,IAAIA,GACjCN,EAAK,IAAIK,IAAQ,KAAK,MAAME,CAAC,IAAIA;AACnC;"}

package/dist/physics/tileBodies.js

@@ -0,0 +1,59 @@
+import { Body as m } from "./Body.js";
+import { FACE_TOP as d, FACE_BOTTOM as w, FACE_LEFT as F, FACE_RIGHT as T } from "./types.js";
+function p(n, f, i) {
+  const s = [];
+  let t = /* @__PURE__ */ new Map();
+  for (let o = 0; o < f; o++) {
+    const l = /* @__PURE__ */ new Map();
+    let c = 0;
+    for (; c < n; ) {
+      if (!i(c, o)) {
+        c++;
+        continue;
+      }
+      const e = c;
+      for (; c < n && i(c, o); ) c++;
+      const u = c - 1, r = e * 1048576 + u, a = t.get(r);
+      a ? (a.y1 = o, t.delete(r), l.set(r, a)) : l.set(r, { x0: e, y0: o, x1: u, y1: o });
+    }
+    for (const e of t.values()) s.push(e);
+    t = l;
+  }
+  for (const o of t.values()) s.push(o);
+  return s;
+}
+function E(n, f, i, s, t = {}) {
+  const o = (e, u) => e >= 0 && u >= 0 && e < n && u < f && s(e, u), l = t.originX ?? 0, c = t.originY ?? 0;
+  return p(n, f, o).map((e) => {
+    const u = (e.x1 - e.x0 + 1) * i, r = (e.y1 - e.y0 + 1) * i, a = new m({
+      type: "static",
+      shape: { kind: "box", halfWidth: u / 2, halfHeight: r / 2 },
+      x: l + e.x0 * i + u / 2,
+      y: c + e.y0 * i + r / 2,
+      friction: t.friction,
+      restitution: t.restitution,
+      layer: t.layer,
+      mask: t.mask,
+      userData: t.userData
+    });
+    let y = 0;
+    return x(o, e.x0, e.x1, e.y0 - 1) && (y |= d), x(o, e.x0, e.x1, e.y1 + 1) && (y |= w), h(o, e.x0 - 1, e.y0, e.y1) && (y |= F), h(o, e.x1 + 1, e.y0, e.y1) && (y |= T), a.internalFaces = y, a;
+  });
+}
+function B(n, f = {}) {
+  return E(n.width, n.height, n.tileSize, (i, s) => n.solid[s * n.width + i] === 1, f);
+}
+function x(n, f, i, s) {
+  for (let t = f; t <= i; t++) if (!n(t, s)) return !1;
+  return !0;
+}
+function h(n, f, i, s) {
+  for (let t = i; t <= s; t++) if (!n(f, t)) return !1;
+  return !0;
+}
+export {
+  p as mergeTileRects,
+  E as tileBodies,
+  B as tileBodiesFromGrid
+};
+//# sourceMappingURL=tileBodies.js.map

package/dist/physics/tileBodies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tileBodies.js","sources":["../../src/physics/tileBodies.ts"],"sourcesContent":["import type { CollisionGrid } from '../net/movement';\nimport { Body } from './Body';\nimport { FACE_BOTTOM, FACE_LEFT, FACE_RIGHT, FACE_TOP } from './types';\n\nexport interface TileBodiesOptions {\n  /** World position of tile (0, 0)'s top-left corner (default 0, 0). */\n  originX?: number;\n  originY?: number;\n  friction?: number;\n  restitution?: number;\n  layer?: number;\n  mask?: number;\n  userData?: unknown;\n}\n\n/** A rectangle of solid tiles, in tiles, both ends inclusive. */\nexport interface TileRect {\n  x0: number;\n  y0: number;\n  x1: number;\n  y1: number;\n}\n\n/**\n * Covers the solid cells of a tile grid with as few rectangles as a cheap greedy pass finds: runs along each row,\n * then a run is grown downwards while the row below has exactly the same run. A floor becomes one box and a wall\n * one tall box, so a body sliding along either crosses no seam to snag on.\n */\nexport function mergeTileRects(width: number, height: number, solid: (tx: number, ty: number) => boolean): TileRect[] {\n  const done: TileRect[] = [];\n  /** Rectangles still growing, by the run they end in (\"x0,x1\"). */\n  let open = new Map<number, TileRect>();\n  for (let ty = 0; ty < height; ty++) {\n    const next = new Map<number, TileRect>();\n    let tx = 0;\n    while (tx < width) {\n      if (!solid(tx, ty)) {\n        tx++;\n        continue;\n      }\n      const x0 = tx;\n      while (tx < width && solid(tx, ty)) tx++;\n      const x1 = tx - 1;\n      const key = x0 * 0x100000 + x1;\n      const above = open.get(key);\n      if (above) {\n        above.y1 = ty;\n        open.delete(key);\n        next.set(key, above);\n      } else next.set(key, { x0, y0: ty, x1, y1: ty });\n    }\n    for (const r of open.values()) done.push(r);\n    open = next;\n  }\n  for (const r of open.values()) done.push(r);\n  return done;\n}\n\n/**\n * Static boxes for the solid tiles of a grid, ready for `PhysicsWorld.add`. Each box marks the faces that lie\n * wholly against more solid tiles as internal, so a body is never pushed out through a face that is inside the\n * ground (the seam between a floor and the wall standing on it).\n *\n * Outside the grid counts as open, so the edges of the map collide like any other face.\n */\nexport function tileBodies(width: number, height: number, tileSize: number, solid: (tx: number, ty: number) => boolean, options: TileBodiesOptions = {}): Body[] {\n  const inside = (tx: number, ty: number): boolean => tx >= 0 && ty >= 0 && tx < width && ty < height && solid(tx, ty);\n  const ox = options.originX ?? 0;\n  const oy = options.originY ?? 0;\n  return mergeTileRects(width, height, inside).map((r) => {\n    const w = (r.x1 - r.x0 + 1) * tileSize;\n    const h = (r.y1 - r.y0 + 1) * tileSize;\n    const body = new Body({\n      type: 'static',\n      shape: { kind: 'box', halfWidth: w / 2, halfHeight: h / 2 },\n      x: ox + r.x0 * tileSize + w / 2,\n      y: oy + r.y0 * tileSize + h / 2,\n      friction: options.friction,\n      restitution: options.restitution,\n      layer: options.layer,\n      mask: options.mask,\n      userData: options.userData,\n    });\n    let faces = 0;\n    if (rowSolid(inside, r.x0, r.x1, r.y0 - 1)) faces |= FACE_TOP;\n    if (rowSolid(inside, r.x0, r.x1, r.y1 + 1)) faces |= FACE_BOTTOM;\n    if (columnSolid(inside, r.x0 - 1, r.y0, r.y1)) faces |= FACE_LEFT;\n    if (columnSolid(inside, r.x1 + 1, r.y0, r.y1)) faces |= FACE_RIGHT;\n    body.internalFaces = faces;\n    return body;\n  });\n}\n\n/** `tileBodies` for the engine's `CollisionGrid` (from `createCollisionGrid` or a Tiled map's `collisionFromTiled`). */\nexport function tileBodiesFromGrid(grid: CollisionGrid, options: TileBodiesOptions = {}): Body[] {\n  return tileBodies(grid.width, grid.height, grid.tileSize, (tx, ty) => grid.solid[ty * grid.width + tx] === 1, options);\n}\n\nfunction rowSolid(solid: (tx: number, ty: number) => boolean, x0: number, x1: number, ty: number): boolean {\n  for (let tx = x0; tx <= x1; tx++) if (!solid(tx, ty)) return false;\n  return true;\n}\n\nfunction columnSolid(solid: (tx: number, ty: number) => boolean, tx: number, y0: number, y1: number): boolean {\n  for (let ty = y0; ty <= y1; ty++) if (!solid(tx, ty)) return false;\n  return true;\n}\n"],"names":["mergeTileRects","width","height","solid","done","open","ty","next","tx","x0","x1","key","above","r","tileBodies","tileSize","options","inside","ox","oy","w","h","body","Body","faces","rowSolid","FACE_TOP","FACE_BOTTOM","columnSolid","FACE_LEFT","FACE_RIGHT","tileBodiesFromGrid","grid","y0","y1"],"mappings":"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"}

package/dist/physics/types.js

@@ -0,0 +1,8 @@
+const o = 1, t = 2, E = 4, F = 8;
+export {
+  F as FACE_BOTTOM,
+  o as FACE_LEFT,
+  t as FACE_RIGHT,
+  E as FACE_TOP
+};
+//# sourceMappingURL=types.js.map

package/dist/physics/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":["../../src/physics/types.ts"],"sourcesContent":["import type { Body } from './Body';\n\n/**\n * The shapes a body may have, each centred on the body's position. A body turns only when it is made with\n * `rotates: true`; a platformer's bodies need no rotation, and a body that never turns keeps the cheap axis-aligned\n * tests and the steadiest stacks.\n */\nexport type Shape = CircleShape | BoxShape | PolygonShape;\n\nexport interface CircleShape {\n  readonly kind: 'circle';\n  radius: number;\n}\n\nexport interface BoxShape {\n  readonly kind: 'box';\n  halfWidth: number;\n  halfHeight: number;\n}\n\n/** A point or a vector in world or body pixels, y down. */\nexport interface Vec2 {\n  x: number;\n  y: number;\n}\n\n/**\n * A convex polygon, its vertices relative to the body's position, which must be the polygon's centroid (make one with\n * `polygonShape`, which orders the points and moves them there). Up to `MAX_POLYGON_VERTICES` corners.\n */\nexport interface PolygonShape {\n  readonly kind: 'polygon';\n  readonly vertices: readonly Vec2[];\n}\n\n/**\n * - `dynamic`: moved by gravity, forces and contacts;\n * - `static`: never moves (ground, walls); cheapest, kept in a broad phase of its own;\n * - `kinematic`: moved only by its velocity (a moving platform), pushes dynamic bodies and is never pushed.\n */\nexport type BodyType = 'dynamic' | 'static' | 'kinematic';\n\nexport interface BodyOptions {\n  type?: BodyType;\n  shape: Shape;\n  x?: number;\n  y?: number;\n  vx?: number;\n  vy?: number;\n  /**\n   * Whether contacts and torques turn the body (default false). A body that does not rotate may still be placed at an\n   * `angle`, and keeps it.\n   */\n  rotates?: boolean;\n  /** Radians, clockwise on screen (y grows downwards). */\n  angle?: number;\n  /** Radians per second. */\n  angularVelocity?: number;\n  /** Turning lost per second, as a share (default 0.05): a rolling ball slows down without rolling friction. */\n  angularDamping?: number;\n  /** Mass of a dynamic body (default 1). Ignored for static and kinematic bodies, whose mass is infinite. */\n  mass?: number;\n  /** Bounce, 0–1 (default 0). A pair bounces by the larger of its two. */\n  restitution?: number;\n  /** Coulomb friction coefficient (default 0.5). A pair uses the geometric mean of its two. */\n  friction?: number;\n  /** Velocity lost per second, as a share (default 0): air drag. */\n  linearDamping?: number;\n  /** Multiplies the world's gravity for this body (default 1; 0 floats). */\n  gravityScale?: number;\n  /** A sensor reports overlaps (contact events) but is never pushed and pushes nothing. */\n  sensor?: boolean;\n  /** Category bits this body is in (default 1). */\n  layer?: number;\n  /** Category bits this body collides with (default all). A pair collides when each one's layer is in the other's mask. */\n  mask?: number;\n  /** Anything the game wants to find again from a contact or a ray hit (an entity id, an object). */\n  userData?: unknown;\n}\n\n/** Faces of a box that lie against more solid ground (bits), never used as a contact normal. */\nexport const FACE_LEFT = 1;\nexport const FACE_RIGHT = 2;\nexport const FACE_TOP = 4;\nexport const FACE_BOTTOM = 8;\n\n/** A contact as events and queries report it. The normal points from `a` towards `b`; y grows downwards. */\nexport interface ContactInfo {\n  readonly a: Body;\n  readonly b: Body;\n  readonly nx: number;\n  readonly ny: number;\n  /** Overlap along the normal, px (slightly negative while resting just apart). */\n  readonly depth: number;\n  /** Either body is a sensor: reported, never resolved. */\n  readonly sensor: boolean;\n  /** Where the two touch, world px: one or two points (two where an edge lies along an edge). */\n  readonly points: readonly Vec2[];\n}\n\nexport interface PhysicsEvents {\n  /** Two bodies started touching (or a sensor started overlapping). Emitted after the step. */\n  begin: ContactInfo;\n  /** Two bodies stopped touching, or one of them was removed. Emitted after the step. */\n  end: ContactInfo;\n}\n\nexport interface RayHit {\n  body: Body;\n  /** Where the ray met the body. */\n  x: number;\n  y: number;\n  /** Surface normal there, pointing back towards the ray's start. */\n  nx: number;\n  ny: number;\n  /** Share of the ray's length at the hit, 0–1. */\n  fraction: number;\n}\n\nexport interface RaycastOptions {\n  /** Only bodies whose layer shares a bit with this (default all). */\n  mask?: number;\n  /** Sensors are skipped unless this is true. */\n  includeSensors?: boolean;\n  /** Skip bodies this returns false for (the caster itself, say). */\n  filter?: (body: Body) => boolean;\n}\n"],"names":["FACE_LEFT","FACE_RIGHT","FACE_TOP","FACE_BOTTOM"],"mappings":"AAiFO,MAAMA,IAAY,GACZC,IAAa,GACbC,IAAW,GACXC,IAAc;"}

package/dist/pixel/Darkness.js

@@ -0,0 +1,166 @@
+import { Sprite as g, Texture as v, RenderTexture as S, Container as x } from "pixi.js";
+import { TILE_SIZE as H } from "../net/constants.js";
+import { liveLights as k, lightRadius as R } from "./lights.js";
+import { isTouchUi as D } from "../platform/touch.js";
+const K = 66, W = 33, M = 8, z = (h) => Math.min(1, Math.pow(Math.max(0, 1 - h * h), 1.5) * 1.15), P = (h) => Math.pow(Math.max(0, 1 - h), 2), G = 4, U = 3, Y = 0.3, E = 0.85, $ = 16761466, B = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5].map((h) => (h + 0.5) / 16), _ = (h) => h <= 24 ? Math.max(2, Math.round(h / 2) * 2) : Math.round(h / 8) * 8, F = [...new Set(Array.from({ length: 160 }, (h, t) => _(t + 1)))], N = 33, I = /* @__PURE__ */ new Map();
+let T = !1;
+function O() {
+  if (T) return;
+  T = !0;
+  const h = F.flatMap((s) => [["hole", s], ["wash", s]]), t = () => {
+    const s = h.shift();
+    s && (y(s[0], s[1]), setTimeout(t, 0));
+  };
+  setTimeout(t, 0);
+}
+function y(h, t) {
+  const s = `${h}${t}`, i = I.get(s);
+  if (i) return i;
+  const e = t * 2, a = Math.max(2, Math.round(t * 2 * E)), r = h === "hole" ? G : U, p = h === "hole" ? z : P, o = document.createElement("canvas");
+  o.width = e, o.height = a;
+  const c = o.getContext("2d");
+  if (!c) return v.EMPTY;
+  const u = c.createImageData(e, a);
+  for (let f = 0; f < a; f++)
+    for (let l = 0; l < e; l++) {
+      const A = Math.hypot((l + 0.5 - e / 2) / t, (f + 0.5 - a / 2) / (t * E));
+      if (A >= 1) continue;
+      const L = Math.min(r, Math.floor(p(A) * r + B[f % 4 * 4 + l % 4])) / r, d = (f * e + l) * 4;
+      u.data[d] = u.data[d + 1] = u.data[d + 2] = 255, u.data[d + 3] = Math.round(L * 255);
+    }
+  c.putImageData(u, 0, 0);
+  const w = v.from(o);
+  return w.source.scaleMode = "nearest", I.set(s, w), w;
+}
+class q {
+  constructor(t, s, i) {
+    this.stage = t, this.color = s, this.alpha = i, this.sheet = new g({ texture: v.WHITE }), this.scratch.addChild(this.sheet, this.holes, this.washes), this.carried = this.light(16773340), this.rt = S.create({ width: 1, height: 1 }), this.view = new g({ texture: this.rt }), this.layer.addChild(this.view), t.screen.addChild(this.layer), t.cameras.main.follow(this.layer), this.unsubscribeResize = t.onResize(() => this.dirty = !0), O();
+  }
+  stage;
+  color;
+  alpha;
+  scratch = new x();
+  sheet;
+  /** Every hole is erased before any colour is laid, or a later hole would wipe an earlier light's colour away. */
+  holes = new x();
+  washes = new x();
+  lamps = [];
+  /** The transient lights (`lights.ts`), reused frame to frame. */
+  flashes = [];
+  rt;
+  /**
+   * On the screen layer, laid over the world with its exact transform by the camera (`Camera.follow`), shake included:
+   * the night is drawn in world pixels round the unshaken camera and only this layer moves with a shake, so a shaking
+   * screen does not redraw the night every frame.
+   */
+  layer = new x();
+  view;
+  /** The light the player carries: the only one that follows them, and the last one they lose. */
+  carried;
+  unsubscribeResize;
+  /** Lamps that flicker: while one does (or the player carries a light) every frame differs. */
+  flickering = 0;
+  /** Something other than the camera changed what the night looks like (a lamp added, dimmed, the window resized). */
+  dirty = !0;
+  /** What the last drawn frame was drawn from: the texture, the camera's texel and the shade. */
+  drawn = "";
+  /** The carried light's place at the last redraw (it follows the body). */
+  carriedAt = "";
+  /** When the sheet was last redrawn. */
+  drawnAt = -1 / 0;
+  /** The world pixel the night's top-left texel stands on. */
+  ox = 0;
+  oy = 0;
+  /** The night texture's size in world pixels, and the zoom it was made for. */
+  rtKey = "";
+  /** The lamps' colour turned down (`setLampsDimmed`). */
+  dimLamps = !1;
+  /** A phone redraws the night at most `PHONE_MS` apart, whatever moves (`isTouchUi`). */
+  phone = D();
+  /** A hole and its colour, added to the night's layers. */
+  light(t) {
+    const s = new g({ texture: y("hole", 8) });
+    s.blendMode = "erase", this.holes.addChild(s);
+    const i = new g({ texture: y("wash", 8) });
+    return i.tint = t, this.washes.addChild(i), { hole: s, wash: i };
+  }
+  /** A lamp fixed in the world: a torch on a wall, the seep in its chamber, a crystal in a seam, in its own colour. */
+  addLamp(t, s, i, e = 0, a = $) {
+    this.lamps.push({ sprites: this.light(a), x: t, y: s, r: i, flicker: e }), e && this.flickering++, this.dirty = !0;
+  }
+  /**
+   * Changes how dark and what colour the sheet is (the outdoor night, `NightShade`, deepens and lifts with the
+   * world clock). A sheet with no alpha left is neither drawn nor redrawn, so a map at noon pays nothing for its night.
+   */
+  setShade(t, s) {
+    this.color = t, this.alpha = s, this.layer.visible = s > 4e-3;
+  }
+  /**
+   * Dimmed lamps lay only `LAMP_DIM` of their colour on the dark (a "fewer ambient lights" setting). The holes they
+   * cut stay as wide, so a dark place is still seen by them.
+   */
+  setLampsDimmed(t) {
+    t !== this.dimLamps && (this.dimLamps = t, this.dirty = !0);
+  }
+  /**
+   * The night's own texture, one texel a world pixel and `MARGIN` to spare on each side (a shake, or a camera that
+   * moved while a phone waits for its next redraw, never shows its edge), remade when the window or the zoom changes:
+   * at zoom 2 or 3 it is a quarter or a ninth of the screen's pixels. True when it was remade.
+   */
+  fit(t, s, i) {
+    const e = Math.ceil(t / i) + M * 2, a = Math.ceil(s / i) + M * 2, r = `${e},${a},${i}`;
+    return r === this.rtKey ? !1 : (this.rtKey = r, this.rt.destroy(!0), this.rt = S.create({ width: e, height: a }), this.rt.source.scaleMode = "nearest", this.view.texture = this.rt, !0);
+  }
+  /** Redraws the night with this frame's holes in it, when anything in it changed. `px`/`py` is where the player stands. */
+  update(t, s, i, e) {
+    if (!this.layer.visible) return;
+    const a = this.stage.cameras.main, r = a.zoom || 1, p = this.fit(this.stage.width, this.stage.height, r), o = Math.floor(a.scrollX) - M, c = Math.floor(a.scrollY) - M, u = `${o},${c},${this.rtKey},${this.color},${this.alpha}`, w = k(t), f = e > 0 ? `${Math.round(s)},${Math.round(i)},${Math.round(e)}` : "", l = t - this.drawnAt;
+    if (!(this.dirty || u !== this.drawn || f !== this.carriedAt || w.length > 0 && l >= N || (e > 0 || this.flickering > 0) && l >= K)) return;
+    const L = Math.abs(o - this.ox) >= M - 1 || Math.abs(c - this.oy) >= M - 1;
+    if (this.phone && l < W && !p && !L) return;
+    this.dirty = !1, this.drawn = u, this.carriedAt = f, this.drawnAt = t, this.ox = o, this.oy = c, this.view.position.set(o, c), this.sheet.width = this.rt.width, this.sheet.height = this.rt.height, this.sheet.position.set(0, 0), this.sheet.tint = this.color, this.sheet.alpha = this.alpha;
+    const d = Y * Math.min(1, this.alpha * 1.4);
+    e <= 0 ? this.hide(this.carried) : this.place(this.carried, s, i - 6, e * (1 + Math.sin(t / 260) * 0.03 + Math.sin(t / 90) * 0.015), d * 0.5);
+    const C = this.dimLamps ? d * V : d;
+    for (const n of this.lamps) {
+      const m = n.flicker ? 1 + Math.sin(t / 190 + n.flicker) * 0.05 + Math.sin(t / 71 + n.flicker) * 0.03 : 1;
+      this.place(n.sprites, n.x, n.y, n.r * m, C * (n.flicker ? 0.9 + (m - 1) * 2 : 1));
+    }
+    for (; this.flashes.length < w.length; ) this.flashes.push(this.light($));
+    for (let n = 0; n < this.flashes.length; n++) {
+      const m = w[n], b = this.flashes[n];
+      if (!m) {
+        this.hide(b);
+        continue;
+      }
+      b.wash.tint = m.color, this.place(b, m.x, m.y, R(m, t), Math.min(0.6, d * 1.6));
+    }
+    this.stage.app.renderer.render({ container: this.scratch, target: this.rt, clear: !0 });
+  }
+  hide(t) {
+    t.hole.visible = !1, t.wash.visible = !1;
+  }
+  /** Lays light `l` at world (wx, wy), `r` px across its radius, in the night's world-pixel grid. */
+  place(t, s, i, e, a) {
+    const r = _(e), p = Math.round(s) - this.ox, o = Math.round(i) - this.oy;
+    if (e < 1 || p < -r || o < -r || p > this.rt.width + r || o > this.rt.height + r) {
+      this.hide(t);
+      return;
+    }
+    t.hole.texture = y("hole", r), t.wash.texture = y("wash", r);
+    for (const c of [t.hole, t.wash])
+      c.visible = !0, c.position.set(p - r, o - Math.round(r * E));
+    t.wash.alpha = a, t.wash.visible = a > 0.01;
+  }
+  destroy() {
+    this.unsubscribeResize(), this.stage.cameras.main.unfollow(this.layer), this.layer.destroy({ children: !0 }), this.rt.destroy(!0), this.scratch.destroy({ children: !0, context: !0 });
+  }
+}
+const V = 0.35, J = H * 5;
+export {
+  J as CARRIED_LIGHT,
+  q as Darkness,
+  V as LAMP_DIM,
+  $ as WARM_LIGHT
+};
+//# sourceMappingURL=Darkness.js.map