@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-W65JIRI4.mjs

@@ -0,0 +1,1182 @@
+import { STARTER_CATALOGUE, fcos, fsin, fatan2 } from './chunk-TJCAE7RC.mjs';
+import { SeededRandom } from './chunk-22BD3RHN.mjs';
+import { Vec3, Quat } from './chunk-XPG3N5CF.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/kit/controls/common.ts
+var DEGREES_TO_RADIANS = Math.PI / 180, REFERENCE_FPS = 60, BUTTON_PRIMARY = 1, BUTTON_SECONDARY = 2, BUTTON_MIDDLE = 4, DEFAULT_CONTROL_FOV = 60, DEFAULT_CONTROL_ASPECT = 1, UP = new Vec3(0, 1, 0), RIGHT = new Vec3(1, 0, 0);
+function frameDamping(factor, dt) {
+  return factor >= 1 ? 1 : factor <= 0 ? 0 : 1 - Math.pow(1 - factor, dt * (60));
+}
+function clamp(value, lo, hi) {
+  return value < lo ? lo : value > hi ? hi : value;
+}
+var CameraPose = class {
+  constructor(transforms, camera) {
+    this.position = new Vec3();
+    this.rotation = new Quat();
+    this.transforms = transforms, this.camera = camera, this.read();
+  }
+  read() {
+    this.transforms.position(this.camera, this.position), this.transforms.rotation(this.camera, this.rotation);
+  }
+  write() {
+    let p = this.position;
+    this.transforms.setPosition(this.camera, p.x, p.y, p.z), this.transforms.setRotationQuat(this.camera, this.rotation);
+  }
+  axis(index, out) {
+    return out.set(index === 0 ? 1 : 0, index === 1 ? 1 : 0, index === 2 ? 1 : 0), this.rotation.rotate(out);
+  }
+  forward(out) {
+    return out.set(0, 0, -1), this.rotation.rotate(out);
+  }
+};
+function yawPitchFrom(rotation, scratch, out) {
+  scratch.set(0, 0, -1), rotation.rotate(scratch), out[0] = Math.atan2(-scratch.x, -scratch.z), out[1] = Math.asin(clamp(scratch.y, -1, 1));
+}
+function setYawPitch(out, yaw, pitch, scratch) {
+  return out.setAxisAngle(UP, yaw), scratch.setAxisAngle(RIGHT, pitch), out.multiply(out, scratch);
+}
+
+// src/game/kit/crowd/crowd.ts
+var MAX_VOTE_CHOICES = 16, MAX_VOTE_INDEX = 255, CROWD_VOTE_BYTES = 3, CROWD_VOTE_TAG = 86, NO_VOTE_WINNER = -1, CHEER_FULL = 1, VotePoll = class {
+  constructor(vote, stepsPerSecond) {
+    this.vote = vote;
+    this.stepsPerSecond = stepsPerSecond;
+    this.ballots = /* @__PURE__ */ new Map();
+    this.closesAt = Number.NEGATIVE_INFINITY;
+    this.openedAt = Number.NEGATIVE_INFINITY;
+    if (vote.choices.length < 2 || vote.choices.length > (16))
+      throw new GameError("invalid_argument", `a vote has 2 to ${(16)} choices`);
+    this.tally = new Uint32Array(vote.choices.length);
+  }
+  get voters() {
+    return this.ballots.size;
+  }
+  open(tick) {
+    this.ballots.clear(), this.tally.fill(0), this.openedAt = tick, this.closesAt = tick + Math.max(1, Math.round(this.vote.seconds * this.stepsPerSecond));
+  }
+  isOpen(tick) {
+    return tick >= this.openedAt && tick < this.closesAt;
+  }
+  remaining(tick) {
+    return this.isOpen(tick) ? (this.closesAt - tick) / this.stepsPerSecond : 0;
+  }
+  cast(watcher, choice, tick) {
+    if (!this.isOpen(tick)) return "closed";
+    if (!Number.isInteger(choice) || choice < 0 || choice >= this.tally.length) return "invalid";
+    let before = this.ballots.get(watcher);
+    return before === choice ? "same" : (this.ballots.set(watcher, choice), this.tally[choice]++, before === void 0 ? "counted" : (this.tally[before]--, "changed"));
+  }
+  winner() {
+    let best = (-1), most = 0;
+    for (let i = 0; i < this.tally.length; i++)
+      this.tally[i] > most && (most = this.tally[i], best = i);
+    return best;
+  }
+  share(choice) {
+    return this.ballots.size === 0 ? 0 : this.tally[choice] / this.ballots.size;
+  }
+}, CheerMeter = class {
+  constructor(cheer) {
+    this.cheer = cheer;
+    this.level = 0;
+  }
+  get value() {
+    return this.level;
+  }
+  tap(count = 1) {
+    return !this.cheer.on || !(count > 0) ? this.level : (this.level = Math.min((1), this.level + count * this.cheer.perTap), this.level);
+  }
+  step(seconds) {
+    return this.level = Math.max(0, this.level - this.cheer.drainPerSecond * seconds), this.level;
+  }
+};
+function giftMoments(doc, gift) {
+  let out = [];
+  for (let entry of doc.gifts) entry.gift === gift && out.push(entry.moment);
+  return out;
+}
+function votesOpenedBy(doc, moment) {
+  let out = [];
+  for (let i = 0; i < doc.votes.length; i++) doc.votes[i].opensOn === moment && out.push(i);
+  return out;
+}
+function encodeVote(out, vote, choice) {
+  if (!Number.isInteger(vote) || vote < 0 || vote > (255) || !Number.isInteger(choice) || choice < 0 || choice >= (16))
+    throw new GameError(
+      "invalid_argument",
+      `a vote is 0 to ${(255)} with a choice under ${(16)}`
+    );
+  return out[0] = (86), out[1] = vote, out[2] = choice, (3);
+}
+function decodeVote(payload, length, out) {
+  return length !== (3) || payload[0] !== (86) ? false : (out[0] = payload[1], out[1] = payload[2], true);
+}
+
+// src/game/kit/things/flat.ts
+var DEFAULT_PART_SIZE = [0.2, 0.2, 0.2], DEFAULT_PART_RADIUS = 0.1, DEFAULT_PART_LENGTH = 0.2;
+function flatPart(part) {
+  let shape = part.shape, size = shape.kind === "box" || shape.kind === "rounded" ? shape.size : DEFAULT_PART_SIZE, radius = shape.kind === "box" ? (0.1) : shape.radius, length = shape.kind === "cylinder" ? shape.height : shape.kind === "tube" ? shape.length : (0.2);
+  return {
+    shape: shape.kind,
+    size,
+    radius,
+    length,
+    at: part.at,
+    turn: part.turn,
+    material: part.material,
+    combine: part.combine,
+    mirror: part.mirror
+  };
+}
+function shapeOfFlat(flat) {
+  switch (flat.shape) {
+    case "box":
+      return { kind: "box", size: flat.size };
+    case "rounded":
+      return { kind: "rounded", size: flat.size, radius: flat.radius };
+    case "sphere":
+      return { kind: "sphere", radius: flat.radius };
+    case "cylinder":
+      return { kind: "cylinder", radius: flat.radius, height: flat.length };
+    case "tube":
+      return { kind: "tube", radius: flat.radius, length: flat.length };
+  }
+}
+function partOfFlat(id, name, flat) {
+  return {
+    id,
+    name,
+    shape: shapeOfFlat(flat),
+    at: flat.at,
+    turn: flat.turn,
+    material: flat.material,
+    combine: flat.combine,
+    mirror: flat.mirror
+  };
+}
+
+// src/game/kit/things/materials.ts
+function material(id, label, density, friction, restitution, look, rest = {}) {
+  return {
+    id,
+    label,
+    density,
+    friction,
+    restitution,
+    look: { roughness: 0.6, metalness: 0, opacity: 1, ...look },
+    species: rest.species ?? null,
+    fluid: rest.fluid ?? null,
+    burns: rest.burns ?? false,
+    conductsHeat: rest.conductsHeat ?? false,
+    breaks: rest.breaks ?? "never"
+  };
+}
+var THING_MATERIALS = [
+  material(
+    "iroko_wood",
+    "Iroko wood",
+    650,
+    0.5,
+    0.25,
+    { color: 9067059, roughness: 0.7 },
+    { species: "wood", burns: true, breaks: "splinters" }
+  ),
+  material(
+    "pine_wood",
+    "Pine wood",
+    500,
+    0.5,
+    0.25,
+    { color: 13146978, roughness: 0.75 },
+    { species: "wood", burns: true, breaks: "splinters" }
+  ),
+  material(
+    "copper",
+    "Copper",
+    8960,
+    0.4,
+    0.2,
+    { color: 13138251, roughness: 0.3, metalness: 1 },
+    { species: "Cu", conductsHeat: true, breaks: "dents" }
+  ),
+  material(
+    "steel",
+    "Steel",
+    7850,
+    0.45,
+    0.25,
+    { color: 10133928, roughness: 0.35, metalness: 1 },
+    { species: "steel", conductsHeat: true, breaks: "dents" }
+  ),
+  material(
+    "iron",
+    "Iron",
+    7874,
+    0.5,
+    0.2,
+    { color: 6250339, roughness: 0.55, metalness: 1 },
+    { species: "Fe", conductsHeat: true, breaks: "dents" }
+  ),
+  material(
+    "aluminium",
+    "Aluminium",
+    2700,
+    0.4,
+    0.25,
+    { color: 13093841, roughness: 0.35, metalness: 1 },
+    { species: "Al", conductsHeat: true, breaks: "dents" }
+  ),
+  material(
+    "gold",
+    "Gold",
+    19300,
+    0.35,
+    0.15,
+    { color: 14199099, roughness: 0.25, metalness: 1 },
+    { species: "Au", conductsHeat: true, breaks: "dents" }
+  ),
+  material(
+    "rubber",
+    "Rubber",
+    1100,
+    0.9,
+    0.8,
+    { color: 2829099, roughness: 0.9 },
+    { species: "plastic", burns: true }
+  ),
+  material(
+    "plastic",
+    "Plastic",
+    950,
+    0.4,
+    0.4,
+    { color: 15262940, roughness: 0.45 },
+    { species: "plastic", burns: true, breaks: "shatters" }
+  ),
+  material(
+    "glass",
+    "Glass",
+    2500,
+    0.3,
+    0.3,
+    { color: 14216944, roughness: 0.05, opacity: 0.35 },
+    { breaks: "shatters" }
+  ),
+  material(
+    "stone",
+    "Stone",
+    2600,
+    0.7,
+    0.15,
+    { color: 9209728, roughness: 0.9 },
+    { breaks: "shatters" }
+  ),
+  material(
+    "brick",
+    "Brick",
+    1900,
+    0.75,
+    0.1,
+    { color: 10835003, roughness: 0.9 },
+    { breaks: "shatters" }
+  ),
+  material(
+    "bone",
+    "Bone",
+    1900,
+    0.5,
+    0.3,
+    { color: 15327695, roughness: 0.6 },
+    { breaks: "splinters" }
+  ),
+  material(
+    "cloth",
+    "Cloth",
+    300,
+    0.8,
+    0.05,
+    { color: 11745850, roughness: 1 },
+    { burns: true, breaks: "tears" }
+  ),
+  material(
+    "paper",
+    "Paper",
+    700,
+    0.6,
+    0.05,
+    { color: 15986662, roughness: 1 },
+    { burns: true, breaks: "tears" }
+  ),
+  material(
+    "ice",
+    "Ice",
+    917,
+    0.05,
+    0.1,
+    { color: 13625589, roughness: 0.1, opacity: 0.8 },
+    { species: "H2O", breaks: "shatters" }
+  ),
+  material(
+    "jelly",
+    "Jelly",
+    1050,
+    0.6,
+    0.6,
+    { color: 14698063, roughness: 0.2, opacity: 0.85 },
+    { fluid: "jelly" }
+  ),
+  material(
+    "water",
+    "Water",
+    1e3,
+    0.02,
+    0,
+    { color: 3903446, roughness: 0.05, opacity: 0.6 },
+    { species: "H2O", fluid: "water" }
+  ),
+  material("sand", "Sand", 1600, 0.7, 0.05, { color: 14268793, roughness: 1 }, { fluid: "sand" }),
+  material("snow", "Snow", 300, 0.3, 0.05, { color: 16054266, roughness: 0.9 }, { fluid: "snow" }),
+  material("mud", "Mud", 1700, 0.8, 0.02, { color: 6047280, roughness: 1 }, { fluid: "mud" })
+], DEFAULT_THING_MATERIAL = "plastic", BY_ID = new Map(THING_MATERIALS.map((entry) => [entry.id, entry]));
+function thingMaterial(id) {
+  return BY_ID.get(id) ?? BY_ID.get(DEFAULT_THING_MATERIAL);
+}
+function thingMaterialIds() {
+  return THING_MATERIALS.map((entry) => entry.id);
+}
+var BREAK_ORDER = ["shatters", "splinters", "tears", "dents"];
+function thingBreaks(materialIds) {
+  let kinds = new Set(materialIds.map((id) => thingMaterial(id).breaks));
+  return BREAK_ORDER.find((kind) => kinds.has(kind)) ?? "never";
+}
+
+// src/game/kit/things/csg.ts
+var CSG_EPSILON = 1e-5;
+var CsgPlane = class _CsgPlane {
+  constructor(normal, w) {
+    this.normal = normal;
+    this.w = w;
+  }
+  static through(a, b, c) {
+    let ux = b[0] - a[0], uy = b[1] - a[1], uz = b[2] - a[2], vx = c[0] - a[0], vy = c[1] - a[1], vz = c[2] - a[2], nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx, length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    if (length < 1e-5 * 1e-5) return null;
+    let normal = [nx / length, ny / length, nz / length];
+    return new _CsgPlane(normal, normal[0] * a[0] + normal[1] * a[1] + normal[2] * a[2]);
+  }
+  flipped() {
+    return new _CsgPlane([-this.normal[0], -this.normal[1], -this.normal[2]], -this.w);
+  }
+  distance(p) {
+    return this.normal[0] * p[0] + this.normal[1] * p[1] + this.normal[2] * p[2] - this.w;
+  }
+  split(polygon, coplanarFront, coplanarBack, front, back) {
+    let kind = 0, kinds = [];
+    for (let vertex2 of polygon.vertices) {
+      let t = this.distance(vertex2.p), type = t < -1e-5 ? 2 : t > 1e-5 ? 1 : 0;
+      kind |= type, kinds.push(type);
+    }
+    if (kind === 0) {
+      (this.normal[0] * polygon.plane.normal[0] + this.normal[1] * polygon.plane.normal[1] + this.normal[2] * polygon.plane.normal[2] > 0 ? coplanarFront : coplanarBack).push(polygon);
+      return;
+    }
+    if (kind === 1) {
+      front.push(polygon);
+      return;
+    }
+    if (kind === 2) {
+      back.push(polygon);
+      return;
+    }
+    let f = [], b = [], count = polygon.vertices.length;
+    for (let i = 0; i < count; i++) {
+      let j = (i + 1) % count, ti = kinds[i], tj = kinds[j], vi = polygon.vertices[i], vj = polygon.vertices[j];
+      if (ti !== 2 && f.push(vi), ti !== 1 && b.push(vi), (ti | tj) === 3) {
+        let t = (this.w - (this.normal[0] * vi.p[0] + this.normal[1] * vi.p[1] + this.normal[2] * vi.p[2])) / (this.normal[0] * (vj.p[0] - vi.p[0]) + this.normal[1] * (vj.p[1] - vi.p[1]) + this.normal[2] * (vj.p[2] - vi.p[2])), v = lerpVertex(vi, vj, t);
+        f.push(v), b.push(v);
+      }
+    }
+    f.length >= 3 && front.push(new CsgPolygon(f, polygon.shared, polygon.plane)), b.length >= 3 && back.push(new CsgPolygon(b, polygon.shared, polygon.plane));
+  }
+};
+function lerpVertex(a, b, t) {
+  let nx = a.n[0] + (b.n[0] - a.n[0]) * t, ny = a.n[1] + (b.n[1] - a.n[1]) * t, nz = a.n[2] + (b.n[2] - a.n[2]) * t, length = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+  return {
+    p: [
+      a.p[0] + (b.p[0] - a.p[0]) * t,
+      a.p[1] + (b.p[1] - a.p[1]) * t,
+      a.p[2] + (b.p[2] - a.p[2]) * t
+    ],
+    n: [nx / length, ny / length, nz / length]
+  };
+}
+var CsgPolygon = class _CsgPolygon {
+  constructor(vertices, shared, plane) {
+    this.vertices = vertices;
+    this.shared = shared;
+    this.plane = plane;
+  }
+  static of(vertices, shared) {
+    if (vertices.length < 3) return null;
+    let plane = CsgPlane.through(vertices[0].p, vertices[1].p, vertices[2].p);
+    return plane === null ? null : new _CsgPolygon(vertices, shared, plane);
+  }
+  flipped() {
+    let vertices = [];
+    for (let i = this.vertices.length - 1; i >= 0; i--) {
+      let v = this.vertices[i];
+      vertices.push({ p: v.p, n: [-v.n[0], -v.n[1], -v.n[2]] });
+    }
+    return new _CsgPolygon(vertices, this.shared, this.plane.flipped());
+  }
+}, CsgNode = class _CsgNode {
+  constructor() {
+    this.plane = null;
+    this.front = null;
+    this.back = null;
+    this.polygons = [];
+  }
+  invert() {
+    let stack = [this];
+    for (; stack.length > 0; ) {
+      let node = stack.pop();
+      node.polygons = node.polygons.map((polygon) => polygon.flipped()), node.plane !== null && (node.plane = node.plane.flipped());
+      let front = node.front;
+      node.front = node.back, node.back = front, node.front !== null && stack.push(node.front), node.back !== null && stack.push(node.back);
+    }
+  }
+  clipPolygons(polygons) {
+    let out = [], stack = [{ node: this, polygons }];
+    for (; stack.length > 0; ) {
+      let { node, polygons: list } = stack.pop();
+      if (node.plane === null) {
+        for (let polygon of list) out.push(polygon);
+        continue;
+      }
+      let front = [], back = [];
+      for (let polygon of list) node.plane.split(polygon, front, back, front, back);
+      if (node.front !== null) stack.push({ node: node.front, polygons: front });
+      else for (let polygon of front) out.push(polygon);
+      node.back !== null && stack.push({ node: node.back, polygons: back });
+    }
+    return out;
+  }
+  clipTo(other) {
+    let stack = [this];
+    for (; stack.length > 0; ) {
+      let node = stack.pop();
+      node.polygons = other.clipPolygons(node.polygons), node.front !== null && stack.push(node.front), node.back !== null && stack.push(node.back);
+    }
+  }
+  allPolygons() {
+    let out = [], stack = [this];
+    for (; stack.length > 0; ) {
+      let node = stack.pop();
+      for (let polygon of node.polygons) out.push(polygon);
+      node.back !== null && stack.push(node.back), node.front !== null && stack.push(node.front);
+    }
+    return out;
+  }
+  build(polygons) {
+    let stack = [{ node: this, polygons }];
+    for (; stack.length > 0; ) {
+      let { node, polygons: list } = stack.pop();
+      if (list.length === 0) continue;
+      node.plane === null && (node.plane = list[0].plane);
+      let front = [], back = [];
+      for (let polygon of list)
+        node.plane.split(polygon, node.polygons, node.polygons, front, back);
+      front.length > 0 && (node.front ?? (node.front = new _CsgNode()), stack.push({ node: node.front, polygons: front })), back.length > 0 && (node.back ?? (node.back = new _CsgNode()), stack.push({ node: node.back, polygons: back }));
+    }
+  }
+};
+function tree(polygons) {
+  let node = new CsgNode();
+  return node.build(polygons), node;
+}
+function csg(a, b, operation) {
+  if (a.length === 0) return operation === "union" ? [...b] : [];
+  if (b.length === 0) return operation === "intersect" ? [] : [...a];
+  let x = tree(a), y = tree(b);
+  return operation === "union" ? (x.clipTo(y), y.clipTo(x), y.invert(), y.clipTo(x), y.invert(), x.build(y.allPolygons()), x.allPolygons()) : operation === "subtract" ? (x.invert(), x.clipTo(y), y.clipTo(x), y.invert(), y.clipTo(x), y.invert(), x.build(y.allPolygons()), x.invert(), x.allPolygons()) : (x.invert(), y.clipTo(x), y.invert(), x.clipTo(y), y.clipTo(x), x.build(y.allPolygons()), x.invert(), x.allPolygons());
+}
+
+// src/game/kit/things/shapes.ts
+var THING_SHAPE_KINDS = [
+  "box",
+  "sphere",
+  "cylinder",
+  "tube",
+  "rounded"
+], TWO_PI = 2 * Math.PI, PI = Math.PI, DEGREES = Math.PI / 180, MIN_SEGMENTS = 3;
+function rotationMatrix(turn) {
+  let [x, y, z] = [turn[0] * DEGREES, turn[1] * DEGREES, turn[2] * DEGREES], cx = fcos(x), sx = fsin(x), cy = fcos(y), sy = fsin(y), cz = fcos(z), sz = fsin(z);
+  return [
+    cy * cz,
+    -cy * sz,
+    sy,
+    cx * sz + sx * sy * cz,
+    cx * cz - sx * sy * sz,
+    -sx * cy,
+    sx * sz - cx * sy * cz,
+    sx * cz + cx * sy * sz,
+    cx * cy
+  ];
+}
+function transform(v, m, at, mirror) {
+  let p = v.p, n = v.n, px = m[0] * p[0] + m[1] * p[1] + m[2] * p[2] + at[0], py = m[3] * p[0] + m[4] * p[1] + m[5] * p[2] + at[1], pz = m[6] * p[0] + m[7] * p[1] + m[8] * p[2] + at[2], nx = m[0] * n[0] + m[1] * n[1] + m[2] * n[2], ny = m[3] * n[0] + m[4] * n[1] + m[5] * n[2], nz = m[6] * n[0] + m[7] * n[1] + m[8] * n[2];
+  return mirror === 0 ? (px = -px, nx = -nx) : mirror === 1 ? (py = -py, ny = -ny) : mirror === 2 && (pz = -pz, nz = -nz), { p: [px, py, pz], n: [nx, ny, nz] };
+}
+function emit(out, vertices, shared, placement, m) {
+  let placed = vertices.map((v) => transform(v, m, placement.at, placement.mirror));
+  placement.mirror >= 0 && placed.reverse();
+  let polygon = CsgPolygon.of(placed, shared);
+  polygon !== null && out.push(polygon);
+}
+function vertex(px, py, pz, nx, ny, nz) {
+  return { p: [px, py, pz], n: [nx, ny, nz] };
+}
+function box(size) {
+  let [hx, hy, hz] = [size[0] / 2, size[1] / 2, size[2] / 2];
+  return [
+    [
+      [1, 0, 0],
+      [
+        [hx, -hy, -hz],
+        [hx, hy, -hz],
+        [hx, hy, hz],
+        [hx, -hy, hz]
+      ]
+    ],
+    [
+      [-1, 0, 0],
+      [
+        [-hx, -hy, hz],
+        [-hx, hy, hz],
+        [-hx, hy, -hz],
+        [-hx, -hy, -hz]
+      ]
+    ],
+    [
+      [0, 1, 0],
+      [
+        [-hx, hy, -hz],
+        [-hx, hy, hz],
+        [hx, hy, hz],
+        [hx, hy, -hz]
+      ]
+    ],
+    [
+      [0, -1, 0],
+      [
+        [-hx, -hy, hz],
+        [-hx, -hy, -hz],
+        [hx, -hy, -hz],
+        [hx, -hy, hz]
+      ]
+    ],
+    [
+      [0, 0, 1],
+      [
+        [-hx, -hy, hz],
+        [hx, -hy, hz],
+        [hx, hy, hz],
+        [-hx, hy, hz]
+      ]
+    ],
+    [
+      [0, 0, -1],
+      [
+        [hx, -hy, -hz],
+        [-hx, -hy, -hz],
+        [-hx, hy, -hz],
+        [hx, hy, -hz]
+      ]
+    ]
+  ].map(
+    ([n, corners]) => corners.map((c) => vertex(c[0], c[1], c[2], n[0], n[1], n[2]))
+  );
+}
+function sphere(radius, segments) {
+  let rings = Math.max(2, segments >> 1), point = (i, j) => {
+    let theta = j / segments * TWO_PI, phi = i / rings * PI, nx = fcos(theta) * fsin(phi), ny = fcos(phi), nz = fsin(theta) * fsin(phi);
+    return vertex(nx * radius, ny * radius, nz * radius, nx, ny, nz);
+  }, out = [];
+  for (let i = 0; i < rings; i++)
+    for (let j = 0; j < segments; j++) {
+      let quad = [point(i, j), point(i + 1, j), point(i + 1, j + 1), point(i, j + 1)];
+      i === 0 ? quad.splice(0, 1) : i === rings - 1 && quad.splice(1, 1), out.push(quad);
+    }
+  return out.map((face) => face.reverse());
+}
+function cylinder(radius, height, segments) {
+  let half = height / 2, out = [], top = [], bottom = [];
+  for (let j = 0; j < segments; j++) {
+    let a = j / segments * TWO_PI, b = (j + 1) / segments * TWO_PI, ca = fcos(a), sa = fsin(a), cb = fcos(b), sb = fsin(b);
+    out.push([
+      vertex(ca * radius, -half, sa * radius, ca, 0, sa),
+      vertex(ca * radius, half, sa * radius, ca, 0, sa),
+      vertex(cb * radius, half, sb * radius, cb, 0, sb),
+      vertex(cb * radius, -half, sb * radius, cb, 0, sb)
+    ]), top.push(vertex(ca * radius, half, sa * radius, 0, 1, 0)), bottom.push(vertex(ca * radius, -half, sa * radius, 0, -1, 0));
+  }
+  return out.push(top.reverse()), out.push(bottom), out;
+}
+function rounded(size, radius, segments) {
+  let h = [size[0] / 2, size[1] / 2, size[2] / 2], r = Math.max(0, Math.min(radius, h[0], h[1], h[2])), steps = Math.max(2, segments >> 1), map = (x, y, z) => {
+    let ix = Math.min(Math.max(x, -h[0] + r), h[0] - r), iy = Math.min(Math.max(y, -h[1] + r), h[1] - r), iz = Math.min(Math.max(z, -h[2] + r), h[2] - r), dx = x - ix, dy = y - iy, dz = z - iz, length = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (length === 0 || r === 0) return vertex(x, y, z, 0, 0, 0);
+    let nx = dx / length, ny = dy / length, nz = dz / length;
+    return vertex(ix + nx * r, iy + ny * r, iz + nz * r, nx, ny, nz);
+  }, out = [], axes = [
+    [0, 1, 2, 1],
+    [0, 1, 2, -1],
+    [1, 2, 0, 1],
+    [1, 2, 0, -1],
+    [2, 0, 1, 1],
+    [2, 0, 1, -1]
+  ];
+  for (let [u, v, w, sign] of axes)
+    for (let i = 0; i < steps; i++)
+      for (let j = 0; j < steps; j++) {
+        let corner = (a, b) => {
+          let p = [0, 0, 0];
+          return p[u] = -h[u] + 2 * h[u] * a / steps, p[v] = -h[v] + 2 * h[v] * b / steps, p[w] = sign * h[w], map(p[0], p[1], p[2]);
+        }, quad = [corner(i, j), corner(i + 1, j), corner(i + 1, j + 1), corner(i, j + 1)];
+        out.push(sign > 0 ? quad : quad.reverse());
+      }
+  return out;
+}
+function shapeFaces(shape, segments) {
+  let s = Math.max((3), Math.floor(segments));
+  switch (shape.kind) {
+    case "box":
+      return box(shape.size);
+    case "sphere":
+      return sphere(shape.radius, s);
+    case "cylinder":
+      return cylinder(shape.radius, shape.height, s);
+    case "tube":
+      return cylinder(shape.radius, shape.length, s).map(
+        (face) => face.map((v) => vertex(v.p[1], -v.p[0], v.p[2], v.n[1], -v.n[0], v.n[2]))
+      );
+    case "rounded":
+      return rounded(shape.size, shape.radius, s);
+  }
+}
+function shapePolygons(shape, placement, shared, segments) {
+  let m = rotationMatrix(placement.turn), out = [];
+  for (let face of shapeFaces(shape, segments)) emit(out, face, shared, placement, m);
+  return out;
+}
+function shapeRadius(shape) {
+  switch (shape.kind) {
+    case "box":
+    case "rounded":
+      return Math.hypot(shape.size[0], shape.size[1], shape.size[2]) / 2;
+    case "sphere":
+      return shape.radius;
+    case "cylinder":
+      return Math.hypot(shape.radius, shape.height / 2);
+    case "tube":
+      return Math.hypot(shape.radius, shape.length / 2);
+  }
+}
+
+// src/game/kit/things/thing.ts
+var THING_COMBINES = ["join", "cut", "overlap"], THING_MIRRORS = ["none", "x", "y", "z"], THING_EFFECTS = [
+  "fire",
+  "smoke",
+  "steam",
+  "sparks",
+  "confetti",
+  "water",
+  "rain",
+  "break",
+  "sound"
+], CLOSE_SEGMENTS = 32, MIDDLE_SEGMENTS = 12, SMALL_PART_SHARE = 0.08, LIGHT_TRIANGLES = 4e3, MEDIUM_TRIANGLES = 16e3, EFFECT_TRIANGLE_COST = 1e3, MAX_THING_PARTS = 64, OPERATION = {
+  join: "union",
+  cut: "subtract",
+  overlap: "intersect"
+}, MIRROR_AXIS = { none: -1, x: 0, y: 1, z: 2 }, DEGREES2 = Math.PI / 180, CARD_TRIANGLES = 2, TETRA = 6, QUARTER = 4, ThingError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "ThingError";
+  }
+};
+function partPolygons(part, shared, segments) {
+  let placement = { at: part.at, turn: part.turn, mirror: -1 }, own = shapePolygons(part.shape, placement, shared, segments), axis = MIRROR_AXIS[part.mirror];
+  return axis < 0 ? own : csg(
+    own,
+    shapePolygons(part.shape, { ...placement, mirror: axis }, shared, segments),
+    "union"
+  );
+}
+function fold(parts, materials, segments) {
+  let solid = [];
+  for (let part of parts)
+    solid = csg(
+      solid,
+      partPolygons(part, materials.indexOf(part.material), segments),
+      OPERATION[part.combine]
+    );
+  return solid;
+}
+function meshOf(polygons, materials) {
+  let positions = [], normals = [], indices = [], groups = [];
+  for (let m = 0; m < materials.length; m++) {
+    let start = indices.length;
+    for (let polygon of polygons) {
+      if (polygon.shared !== m) continue;
+      let base = positions.length / 3;
+      for (let v of polygon.vertices)
+        positions.push(v.p[0], v.p[1], v.p[2]), normals.push(v.n[0], v.n[1], v.n[2]);
+      for (let i = 1; i < polygon.vertices.length - 1; i++)
+        indices.push(base, base + i, base + i + 1);
+    }
+    indices.length > start && groups.push({ material: materials[m], start, count: indices.length - start });
+  }
+  return {
+    positions: Float32Array.from(positions),
+    normals: Float32Array.from(normals),
+    indices: Uint32Array.from(indices),
+    groups,
+    triangles: indices.length / 3
+  };
+}
+function cardMesh(min, max, material2) {
+  let cx = (min[0] + max[0]) / 2, z = (min[2] + max[2]) / 2, half = Math.max(max[0] - min[0], max[2] - min[2]) / 2, positions = Float32Array.from([
+    cx - half,
+    min[1],
+    z,
+    cx + half,
+    min[1],
+    z,
+    cx + half,
+    max[1],
+    z,
+    cx - half,
+    max[1],
+    z
+  ]), normals = Float32Array.from([0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1]);
+  return {
+    positions,
+    normals,
+    indices: Uint32Array.from([0, 1, 2, 0, 2, 3]),
+    groups: [{ material: material2, start: 0, count: (2) * 3 }],
+    triangles: (2)
+  };
+}
+function boundsOf(mesh) {
+  let min = [1 / 0, 1 / 0, 1 / 0], max = [-1 / 0, -1 / 0, -1 / 0], p = mesh.positions;
+  for (let i = 0; i < p.length; i += 3)
+    for (let a = 0; a < 3; a++)
+      p[i + a] < min[a] && (min[a] = p[i + a]), p[i + a] > max[a] && (max[a] = p[i + a]);
+  return p.length === 0 ? { min: [0, 0, 0], max: [0, 0, 0] } : { min: [min[0], min[1], min[2]], max: [max[0], max[1], max[2]] };
+}
+function massOf(mesh) {
+  let p = mesh.positions, index = mesh.indices, volume = 0, cx = 0, cy = 0, cz = 0, mass = 0;
+  for (let group of mesh.groups) {
+    let density = thingMaterial(group.material).density;
+    for (let t = group.start; t < group.start + group.count; t += 3) {
+      let a = index[t] * 3, b = index[t + 1] * 3, c = index[t + 2] * 3, v = (p[a] * (p[b + 1] * p[c + 2] - p[b + 2] * p[c + 1]) - p[a + 1] * (p[b] * p[c + 2] - p[b + 2] * p[c]) + p[a + 2] * (p[b] * p[c + 1] - p[b + 1] * p[c])) / (6);
+      volume += v, mass += v * density, cx += v * (p[a] + p[b] + p[c]) / (4), cy += v * (p[a + 1] + p[b + 1] + p[c + 1]) / (4), cz += v * (p[a + 2] + p[b + 2] + p[c + 2]) / (4);
+    }
+  }
+  return Math.abs(volume) < Number.EPSILON ? { volume: 0, mass: 0, centre: [0, 0, 0] } : { volume, mass: Math.max(0, mass), centre: [cx / volume, cy / volume, cz / volume] };
+}
+function primitive(shape) {
+  switch (shape.kind) {
+    case "box":
+      return {
+        shape: {
+          kind: "cuboid",
+          halfExtents: [shape.size[0] / 2, shape.size[1] / 2, shape.size[2] / 2]
+        },
+        tube: false
+      };
+    case "rounded":
+      return {
+        shape: {
+          kind: "round_cuboid",
+          halfExtents: [
+            Math.max(0, shape.size[0] / 2 - shape.radius),
+            Math.max(0, shape.size[1] / 2 - shape.radius),
+            Math.max(0, shape.size[2] / 2 - shape.radius)
+          ],
+          border: shape.radius
+        },
+        tube: false
+      };
+    case "sphere":
+      return { shape: { kind: "ball", radius: shape.radius }, tube: false };
+    case "cylinder":
+      return {
+        shape: { kind: "cylinder", halfHeight: shape.height / 2, radius: shape.radius },
+        tube: false
+      };
+    case "tube":
+      return {
+        shape: { kind: "cylinder", halfHeight: shape.length / 2, radius: shape.radius },
+        tube: true
+      };
+  }
+}
+function quaternion(turn, tube) {
+  let hx = turn[0] * DEGREES2 / 2, hy = turn[1] * DEGREES2 / 2, hz = turn[2] * DEGREES2 / 2, sx = fsin(hx), cx = fcos(hx), sy = fsin(hy), cy = fcos(hy), sz = fsin(hz), cz = fcos(hz), q = [
+    sx * cy * cz + cx * sy * sz,
+    cx * sy * cz - sx * cy * sz,
+    cx * cy * sz + sx * sy * cz,
+    cx * cy * cz - sx * sy * sz
+  ];
+  if (!tube) return q;
+  let t = Math.SQRT1_2;
+  return [(q[0] - q[1]) * t, (q[0] + q[1]) * t, (q[2] - q[3]) * t, (q[3] + q[2]) * t];
+}
+function colliderOf(thing) {
+  let parts = [];
+  for (let part of thing.parts) {
+    if (part.combine !== "join") continue;
+    let { shape, tube } = primitive(part.shape), rotation = quaternion(part.turn, tube);
+    parts.push({ shape, offset: part.at, rotation });
+    let axis = MIRROR_AXIS[part.mirror];
+    if (axis !== -1) {
+      let offset = [part.at[0], part.at[1], part.at[2]];
+      offset[axis] = -offset[axis];
+      let mirrored = [
+        -rotation[0],
+        -rotation[1],
+        -rotation[2],
+        rotation[3]
+      ];
+      mirrored[axis] = rotation[axis], parts.push({ shape, offset, rotation: mirrored });
+    }
+  }
+  return { kind: "compound", parts };
+}
+function phoneCost(triangles, effects) {
+  let total = triangles + effects * (1e3);
+  return total <= (4e3) ? "light" : total <= (16e3) ? "medium" : "heavy";
+}
+function compileThing(thing) {
+  if (thing.parts.length === 0) throw new ThingError("a thing needs at least one part");
+  if (thing.parts.length > (64))
+    throw new ThingError(`a thing holds at most ${(64)} parts`);
+  let materials = [...new Set(thing.parts.map((part) => part.material))], close = meshOf(fold(thing.parts, materials, (32)), materials), bounds = boundsOf(close), extent = Math.hypot(
+    bounds.max[0] - bounds.min[0],
+    bounds.max[1] - bounds.min[1],
+    bounds.max[2] - bounds.min[2]
+  ) / 2, kept = thing.parts.filter(
+    (part) => part.combine !== "join" || shapeRadius(part.shape) >= extent * (0.08)
+  ), dropped = thing.parts.filter((part) => !kept.includes(part)).map((part) => part.name), middle = meshOf(
+    fold(kept.length > 0 ? kept : thing.parts, materials, (12)),
+    materials
+  ), far = cardMesh(bounds.min, bounds.max, close.groups[0]?.material ?? materials[0]);
+  return {
+    levels: [
+      { name: "close", mesh: close, dropped: [] },
+      { name: "middle", mesh: middle, dropped },
+      { name: "far", mesh: far, dropped: thing.parts.map((part) => part.name) }
+    ],
+    mass: massOf(close),
+    collider: colliderOf(thing),
+    bounds,
+    cost: phoneCost(close.triangles, thing.effects.length),
+    effects: thing.effects
+  };
+}
+
+// src/game/kit/places/grid.ts
+var CELL_SOLID = 1, CELL_ROAD = 2, CELL_TAKEN = 4, DEFAULT_CELL = 0.5, OccupancyGrid = class {
+  constructor(size, cell = (0.5)) {
+    this.size = size;
+    this.cell = cell;
+    this.columns = Math.max(1, Math.ceil(size[0] / cell)), this.rows = Math.max(1, Math.ceil(size[1] / cell)), this.cells = new Uint8Array(this.columns * this.rows);
+  }
+  index(x, z) {
+    let c = Math.floor(x / this.cell), r = Math.floor(z / this.cell);
+    return c < 0 || r < 0 || c >= this.columns || r >= this.rows ? -1 : r * this.columns + c;
+  }
+  at(x, z) {
+    let i = this.index(x, z);
+    return i < 0 ? (1) : this.cells[i];
+  }
+  centre(i) {
+    return [
+      (i % this.columns + 0.5) * this.cell,
+      (Math.floor(i / this.columns) + 0.5) * this.cell
+    ];
+  }
+  forRect(at, footprint, yaw, visit) {
+    let c = fcos(yaw), s = fsin(yaw), hx = footprint[0] / 2, hz = footprint[1] / 2, reach = Math.hypot(hx, hz), c0 = Math.max(0, Math.floor((at[0] - reach) / this.cell)), c1 = Math.min(this.columns - 1, Math.floor((at[0] + reach) / this.cell)), r0 = Math.max(0, Math.floor((at[1] - reach) / this.cell)), r1 = Math.min(this.rows - 1, Math.floor((at[1] + reach) / this.cell));
+    for (let r = r0; r <= r1; r++)
+      for (let col = c0; col <= c1; col++) {
+        let dx = (col + 0.5) * this.cell - at[0], dz = (r + 0.5) * this.cell - at[1], lx = dx * c - dz * s, lz = dx * s + dz * c;
+        if (Math.abs(lx) <= hx && Math.abs(lz) <= hz && !visit(r * this.columns + col))
+          return false;
+      }
+    return true;
+  }
+  mark(at, footprint, yaw, flags) {
+    this.forRect(at, footprint, yaw, (i) => (this.cells[i] |= flags, true));
+  }
+  clear(at, footprint, yaw, blocking) {
+    return at[0] >= 0 && at[1] >= 0 && at[0] <= this.size[0] && at[1] <= this.size[1] && this.forRect(at, footprint, yaw, (i) => (this.cells[i] & blocking) === 0);
+  }
+  markRoad(road) {
+    let half = road.width / 2;
+    for (let i = 0; i + 1 < road.points.length; i++) {
+      let a = road.points[i], b = road.points[i + 1], length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+      if (length === 0) continue;
+      let yaw = fatan2(b[0] - a[0], b[1] - a[1]);
+      this.mark(
+        [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2],
+        [road.width, length + half],
+        yaw,
+        (2)
+      );
+    }
+  }
+}, NO_FOOTPRINT = [0.5, 0.5];
+function footprintOf(catalogue, kind) {
+  let meta = catalogue[kind];
+  return meta === void 0 ? { footprint: NO_FOOTPRINT, solid: true } : { footprint: meta.footprint, solid: meta.solid };
+}
+function markPlacement(grid, catalogue, placement) {
+  let { footprint, solid } = footprintOf(catalogue, placement.kind);
+  grid.mark(placement.at, footprint, placement.yaw, solid ? (1) | (4) : (4));
+}
+function gridOf(doc, catalogue, placements, cell = (0.5)) {
+  let grid = new OccupancyGrid(doc.size, cell);
+  for (let road of doc.roads) grid.markRoad(road);
+  for (let placement of placements) markPlacement(grid, catalogue, placement);
+  return grid;
+}
+
+// src/game/kit/places/brushes.ts
+var SCATTER_ATTEMPTS = 12, TWO_PI2 = 2 * Math.PI, PEOPLE_FOOTPRINT = [0.5, 0.5];
+function scatter(stroke, grid, catalogue) {
+  if (stroke.kinds.length === 0 || stroke.count <= 0) return [];
+  let random = new SeededRandom(stroke.seed), blocking = stroke.layer === "props" ? (1) | (4) | (2) : (1), out = [], spacing2 = stroke.spacing * stroke.spacing, attempts = stroke.count * (12);
+  for (let attempt = 0; attempt < attempts && out.length < stroke.count; attempt++) {
+    let angle = random.float() * TWO_PI2, distance = Math.sqrt(random.float()) * stroke.radius, at = [
+      stroke.at[0] + fcos(angle) * distance,
+      stroke.at[1] + fsin(angle) * distance
+    ], kind = stroke.kinds[random.int(0, stroke.kinds.length - 1)], yaw = random.float() * TWO_PI2;
+    if (out.some((placed) => (placed.at[0] - at[0]) ** 2 + (placed.at[1] - at[1]) ** 2 < spacing2))
+      continue;
+    let footprint = stroke.layer === "crowds" ? PEOPLE_FOOTPRINT : footprintOf(catalogue, kind).footprint;
+    if (!grid.clear(at, footprint, yaw, blocking)) continue;
+    let placement = { kind, at, yaw };
+    stroke.layer === "props" ? markPlacement(grid, catalogue, placement) : grid.mark(at, PEOPLE_FOOTPRINT, yaw, (4)), out.push(placement);
+  }
+  return out;
+}
+function simplifyStroke(points, tolerance) {
+  if (points.length <= 2) return [...points];
+  let keep = new Uint8Array(points.length);
+  keep[0] = 1, keep[points.length - 1] = 1;
+  let stack = [[0, points.length - 1]];
+  for (; stack.length > 0; ) {
+    let [first, last] = stack.pop(), a = points[first], b = points[last], dx = b[0] - a[0], dz = b[1] - a[1], length = Math.hypot(dx, dz), worst = -1, worstDistance = tolerance;
+    for (let i = first + 1; i < last; i++) {
+      let p = points[i], distance = length === 0 ? Math.hypot(p[0] - a[0], p[1] - a[1]) : Math.abs(dz * p[0] - dx * p[1] + b[0] * a[1] - b[1] * a[0]) / length;
+      distance > worstDistance && (worstDistance = distance, worst = i);
+    }
+    worst < 0 || (keep[worst] = 1, stack.push([first, worst], [worst, last]));
+  }
+  return points.filter((_, i) => keep[i] === 1);
+}
+function applyGround(terrain, strokes) {
+  let touched = 0;
+  for (let stroke of strokes)
+    touched += terrain.sculpt(
+      stroke.op,
+      stroke.at[0],
+      stroke.at[1],
+      stroke.radius,
+      stroke.strength,
+      stroke.target ?? Number.NaN,
+      stroke.layer
+    );
+  return touched;
+}
+
+// src/game/kit/places/checks.ts
+var SHOP_TAG = "shop", UNREACHED = 0, REACHED = 1;
+function walkFrom(grid, starts) {
+  let reached = new Uint8Array(grid.cells.length), queue = new Int32Array(grid.cells.length), head = 0, tail = 0, visit = (i) => {
+    i < 0 || reached[i] !== (0) || (grid.cells[i] & (1)) !== 0 || (reached[i] = (1), queue[tail++] = i);
+  };
+  for (let start of starts) visit(grid.index(start[0], start[1]));
+  if (starts.length === 0) {
+    for (let c = 0; c < grid.columns; c++)
+      visit(c), visit((grid.rows - 1) * grid.columns + c);
+    for (let r = 0; r < grid.rows; r++)
+      visit(r * grid.columns), visit(r * grid.columns + grid.columns - 1);
+  }
+  for (; head < tail; ) {
+    let i = queue[head++], c = i % grid.columns;
+    c > 0 && visit(i - 1), c < grid.columns - 1 && visit(i + 1), i >= grid.columns && visit(i - grid.columns), i + grid.columns < grid.cells.length && visit(i + grid.columns);
+  }
+  return reached;
+}
+function reachable(grid, reached, catalogue, placement) {
+  let { footprint } = footprintOf(catalogue, placement.kind), around = [footprint[0] + grid.cell * 2, footprint[1] + grid.cell * 2], found = false;
+  return grid.forRect(placement.at, around, placement.yaw, (i) => (reached[i] === (1) && (found = true), !found)), found;
+}
+function checkWorld(doc, grid, catalogue, placements) {
+  let reached = walkFrom(
+    grid,
+    doc.gates.filter((gate) => (grid.at(gate[0], gate[1]) & (1)) === 0)
+  ), shops = [];
+  placements.forEach((placement, index) => {
+    catalogue[placement.kind]?.tags.includes(SHOP_TAG) && !reachable(grid, reached, catalogue, placement) && shops.push(index);
+  });
+  let gates = [];
+  doc.gates.forEach((gate, index) => {
+    (grid.at(gate[0], gate[1]) & (1)) !== 0 && gates.push(index);
+  });
+  let outside = [];
+  return placements.forEach((placement, index) => {
+    (placement.at[0] < 0 || placement.at[1] < 0 || placement.at[0] > doc.size[0] || placement.at[1] > doc.size[1]) && outside.push(index);
+  }), [
+    {
+      id: "reachable",
+      ok: shops.length === 0,
+      summary: shops.length === 0 ? "Every stall can be reached on foot" : `${shops.length} ${shops.length === 1 ? "stall cannot" : "stalls cannot"} be reached on foot`,
+      offenders: shops
+    },
+    {
+      id: "gates",
+      ok: gates.length === 0,
+      summary: gates.length === 0 ? "Nothing blocks the gates" : `${gates.length} ${gates.length === 1 ? "gate is" : "gates are"} blocked`,
+      offenders: gates
+    },
+    {
+      id: "inside",
+      ok: outside.length === 0,
+      summary: outside.length === 0 ? "Everything sits inside the place" : `${outside.length} ${outside.length === 1 ? "thing sits" : "things sit"} outside the place`,
+      offenders: outside
+    }
+  ];
+}
+
+// src/game/kit/places/weight.ts
+var LAYER_COST = {
+  ground: 40,
+  roads: 20,
+  buildings: 300,
+  props: 60,
+  crowds: 120,
+  lights: 80,
+  sounds: 10
+}, GROUND_AREA_UNIT = 1e3, TIER_BUDGET = {
+  low: 3e4,
+  mid: 8e4,
+  high: 2e5
+}, LIGHT_SHARE = 0.6, FIT_HEADROOM = 0.95, NO_CAPS = {};
+function layerCounts(doc, scattered) {
+  return {
+    ground: Math.ceil(doc.size[0] * doc.size[1] / (1e3)),
+    roads: doc.roads.reduce((sum, road) => sum + Math.max(0, road.points.length - 1), 0),
+    buildings: doc.buildings.length,
+    props: doc.props.length + scattered.props,
+    crowds: doc.crowds.reduce((sum, area) => sum + area.count, 0) + scattered.crowds,
+    lights: doc.lights.length,
+    sounds: doc.sounds.length
+  };
+}
+function verdict(total, tier) {
+  let budget = TIER_BUDGET[tier];
+  return total <= budget * (0.6) ? "light" : total <= budget ? "fine" : "heavy";
+}
+function peopleOn(people, caps, tier) {
+  let cap = caps[tier];
+  return cap == null ? people : Math.max(0, Math.min(people, Math.floor(cap)));
+}
+function worldWeight(counts, caps = NO_CAPS) {
+  let layers = Object.keys(LAYER_COST).map((layer) => ({
+    layer,
+    count: counts[layer],
+    cost: counts[layer] * LAYER_COST[layer],
+    share: 0
+  })), total = layers.reduce((sum, entry) => sum + entry.cost, 0), without = total - counts.crowds * LAYER_COST.crowds, people = (tier) => peopleOn(counts.crowds, caps, tier), at = (tier) => without + people(tier) * LAYER_COST.crowds;
+  return {
+    total,
+    layers: layers.map((entry) => ({ ...entry, share: total === 0 ? 0 : entry.cost / total })).sort((a, b) => b.cost - a.cost),
+    tiers: {
+      low: verdict(at("low"), "low"),
+      mid: verdict(at("mid"), "mid"),
+      high: verdict(at("high"), "high")
+    },
+    tierTotals: { low: at("low"), mid: at("mid"), high: at("high") },
+    tierPeople: { low: people("low"), mid: people("mid"), high: people("high") }
+  };
+}
+function lighten(weight, tier, layer = "crowds") {
+  let budget = TIER_BUDGET[tier] * (0.95), total = weight.tierTotals[tier];
+  if (total <= TIER_BUDGET[tier]) return null;
+  let entry = weight.layers.find((candidate) => candidate.layer === layer);
+  if (entry === void 0) return null;
+  let shown = layer === "crowds" ? weight.tierPeople[tier] : entry.count;
+  if (shown === 0) return null;
+  let others = total - shown * LAYER_COST[layer];
+  if (others > TIER_BUDGET[tier]) return null;
+  let to = Math.max(0, Math.floor((budget - others) / LAYER_COST[layer]));
+  return to >= shown ? null : { tier, layer, from: shown, to };
+}
+var TIER_ORDER = ["low", "mid", "high"], HEAVY_LAYERS_SHOWN = 3;
+function heavyWithoutPeople(weight, tier) {
+  let withoutPeople = weight.tierTotals[tier] - weight.tierPeople[tier] * LAYER_COST.crowds, budget = TIER_BUDGET[tier];
+  if (withoutPeople <= budget) return null;
+  let layers = [], left = withoutPeople;
+  for (let entry of weight.layers)
+    if (!(entry.layer === "crowds" || entry.cost <= 0) && (layers.push(entry), left -= entry.cost, left <= budget || layers.length === (3)))
+      break;
+  return { tier, withoutPeople, budget, layers };
+}
+function fewerPeople(weight, caps = NO_CAPS) {
+  let next = { ...caps }, fixes = [], stillHeavy = [];
+  for (let tier of TIER_ORDER) {
+    if (weight.tiers[tier] !== "heavy") continue;
+    let heavy = heavyWithoutPeople(weight, tier);
+    if (heavy !== null) {
+      stillHeavy.push(heavy);
+      continue;
+    }
+    let fix = lighten(weight, tier);
+    fix !== null && (next[tier] = fix.to, fixes.push(fix));
+  }
+  return fixes.length === 0 && stillHeavy.length === 0 ? null : { caps: next, fixes, stillHeavy };
+}
+
+// src/game/kit/places/world.ts
+function buildWorld(doc, catalogue = STARTER_CATALOGUE, cell = (0.5)) {
+  let fixed = [...doc.buildings, ...doc.props], grid = gridOf(doc, catalogue, fixed, cell), scatteredProps = [];
+  for (let stroke of doc.scatters)
+    stroke.layer === "props" && scatteredProps.push(...scatter(stroke, grid, catalogue));
+  let people = [];
+  for (let stroke of doc.scatters)
+    stroke.layer === "crowds" && people.push(...scatter(stroke, grid, catalogue));
+  let placements = [...fixed, ...scatteredProps];
+  return {
+    placements,
+    people,
+    grid,
+    weight: worldWeight(
+      layerCounts(doc, { props: scatteredProps.length, crowds: people.length }),
+      doc.crowdCaps
+    ),
+    checks: checkWorld(doc, grid, catalogue, placements)
+  };
+}
+function peopleForTier(built, doc, tier) {
+  let all = built.people, keep = peopleOn(all.length, doc.crowdCaps ?? {}, tier);
+  if (keep >= all.length) return all;
+  let out = [];
+  for (let i = 0; i < keep; i++) out.push(all[Math.floor(i * all.length / keep)]);
+  return out;
+}
+
+export { BUTTON_MIDDLE, BUTTON_PRIMARY, BUTTON_SECONDARY, CELL_ROAD, CELL_SOLID, CELL_TAKEN, CLOSE_SEGMENTS, CROWD_VOTE_BYTES, CROWD_VOTE_TAG, CSG_EPSILON, CameraPose, CheerMeter, CsgPlane, CsgPolygon, DEFAULT_CELL, DEFAULT_CONTROL_ASPECT, DEFAULT_CONTROL_FOV, DEFAULT_PART_LENGTH, DEFAULT_PART_RADIUS, DEFAULT_PART_SIZE, DEFAULT_THING_MATERIAL, DEGREES_TO_RADIANS, EFFECT_TRIANGLE_COST, FIT_HEADROOM, GROUND_AREA_UNIT, LAYER_COST, LIGHT_SHARE, LIGHT_TRIANGLES, MAX_THING_PARTS, MAX_VOTE_CHOICES, MAX_VOTE_INDEX, MEDIUM_TRIANGLES, MIDDLE_SEGMENTS, NO_VOTE_WINNER, OccupancyGrid, SCATTER_ATTEMPTS, SHOP_TAG, SMALL_PART_SHARE, THING_COMBINES, THING_EFFECTS, THING_MATERIALS, THING_MIRRORS, THING_SHAPE_KINDS, TIER_BUDGET, ThingError, UP, VotePoll, applyGround, buildWorld, checkWorld, clamp, colliderOf, compileThing, csg, decodeVote, encodeVote, fewerPeople, flatPart, footprintOf, frameDamping, giftMoments, gridOf, heavyWithoutPeople, layerCounts, lighten, markPlacement, massOf, partOfFlat, peopleForTier, peopleOn, phoneCost, rotationMatrix, scatter, setYawPitch, shapeFaces, shapeOfFlat, shapePolygons, shapeRadius, simplifyStroke, thingBreaks, thingMaterial, thingMaterialIds, verdict, votesOpenedBy, walkFrom, worldWeight, yawPitchFrom };