@adatechnology/game-test-room 0.16.0 → 0.17.0

package/dist/index.global.js

@@ -855,7 +855,9 @@ var GameTestRoom = (() => {
     const band = { c: [root.c[0], root.c[1], root.c[2]], s: [dims[0], dims[1], dims[2]] };
     band.c[L] = (lo + hi) / 2;
     band.s[L] = Math.max(hi - lo, 0.01);
-    for (const p of splinterBox(inp, band, Math.max(3, inp.maxFragments - out.length))) out.push(p);
+    if (inp.style === "snap") {
+      for (const b of bsp(band, Math.max(3, Math.min(6, inp.maxFragments - out.length)), [0, 1, 2], inp.rnd)) out.push({ center: b.c, size: b.s, q: quat.identity(), shape: "chunk", weight: b.s[0] * b.s[1] * b.s[2] });
+    } else for (const p of splinterBox(inp, band, Math.max(3, inp.maxFragments - out.length))) out.push(p);
     return out;
   };
   var tearStack = (inp, root, t, u, v, n, sheet) => {
@@ -886,6 +888,7 @@ var GameTestRoom = (() => {
     const t = sorted[0];
     const [u, v] = [sorted[1], sorted[2]].sort((a, b) => a - b);
     if (style === "snap") {
+      if (inp.cut) return severAt(inp, root, inp.cut.at, inp.cut.gap);
       const n2 = Math.min(maxFragments, 2 + Math.floor(rnd2() * 3));
       for (const b of bsp(root, n2, [0, 1, 2], rnd2)) out.push({ center: b.c, size: b.s, q: idq, shape: "slab", weight: b.s[0] * b.s[1] * b.s[2] });
       return out;
@@ -1059,6 +1062,27 @@ var GameTestRoom = (() => {
     for (const x of spread(dims[u], COVER, spacing, MAX_BARS_PER_DIRECTION)) out.push(bar(v, dims[v] / 2 - 0.02, [[u, x], [thin, 0]]));
     return out;
   };
+  var clipBarsToBox = (bars, u, v, center, size) => {
+    const out = [];
+    for (const [a, b] of bars) {
+      const axis2 = a[u] !== b[u] ? u : v;
+      const other = axis2 === u ? v : u;
+      if (Math.abs(a[other] - center[other]) > size[other] / 2) continue;
+      const lo = Math.max(Math.min(a[axis2], b[axis2]), center[axis2] - size[axis2] / 2), hi = Math.min(Math.max(a[axis2], b[axis2]), center[axis2] + size[axis2] / 2);
+      if (hi - lo < 1e-6) continue;
+      const p = [a[0], a[1], a[2]], q = [b[0], b[1], b[2]];
+      p[axis2] = lo;
+      q[axis2] = hi;
+      out.push([p, q]);
+    }
+    return out;
+  };
+  var bendBar = ([a, b], thin, bow, i) => {
+    const length3 = Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+    const m = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2];
+    m[thin] += (i % 2 === 0 ? 1 : -1) * bow * length3;
+    return [[a, m], [m, b]];
+  };
   var clipBarsToDisc = (bars, u, v, center, radius) => {
     const out = [];
     for (const [a, b] of bars) {
@@ -1969,14 +1993,21 @@ var GameTestRoom = (() => {
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 14730131
       },
       tags: [
         "wood",
         "organic",
         "flammable"
       ],
-      compressive: 1e5
+      compressive: 1e5,
+      hits: {
+        blunt: {
+          tear: "splinters",
+          tearJoules: 60
+        }
+      }
     },
     {
       id: "wood_hard",
@@ -2006,14 +2037,21 @@ var GameTestRoom = (() => {
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 13213802
       },
       tags: [
         "wood",
         "organic",
         "flammable"
       ],
-      compressive: 15e4
+      compressive: 15e4,
+      hits: {
+        blunt: {
+          tear: "splinters",
+          tearJoules: 150
+        }
+      }
     },
     {
       id: "plywood",
@@ -2043,14 +2081,24 @@ var GameTestRoom = (() => {
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 14862234
       },
       tags: [
         "wood",
         "organic",
         "flammable"
       ],
-      compressive: 6e4
+      compressive: 6e4,
+      hits: {
+        ballistic: {
+          tear: "splinters"
+        },
+        blunt: {
+          tear: "splinters",
+          tearJoules: 80
+        }
+      }
     },
     {
       id: "mdf",
@@ -2077,14 +2125,25 @@ var GameTestRoom = (() => {
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 12096362
       },
       tags: [
         "wood",
         "organic",
         "flammable"
       ],
-      compressive: 3e4
+      compressive: 3e4,
+      hits: {
+        ballistic: {
+          tear: "lumps",
+          tearJoules: 120
+        },
+        blunt: {
+          tear: "lumps",
+          tearJoules: 20
+        }
+      }
     },
     {
       id: "glass",
@@ -2198,6 +2257,17 @@ var GameTestRoom = (() => {
       damageScale: {
         explosive: 1.2
       },
+      hits: {
+        ballistic: {
+          unitJoules: 500,
+          floor: 900,
+          crater: true
+        },
+        blunt: {
+          unitJoules: 1500,
+          floor: 60
+        }
+      },
       hitDebris: "chips",
       breakDebris: "dust",
       thermal: {
@@ -2566,7 +2636,8 @@ var GameTestRoom = (() => {
         smoke: "white"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 14207126
       },
       tags: [
         "plant",
@@ -2574,7 +2645,12 @@ var GameTestRoom = (() => {
         "organic",
         "flammable"
       ],
-      compressive: 6e4
+      compressive: 6e4,
+      hits: {
+        blunt: {
+          tear: "none"
+        }
+      }
     },
     {
       id: "cactus",
@@ -2689,6 +2765,130 @@ var GameTestRoom = (() => {
         "masonry"
       ],
       compressive: 2e4
+    },
+    {
+      id: "asphalt",
+      density: 2350,
+      hpPerKg: 10,
+      penetration: 14,
+      penetrationClass: "concrete",
+      penetrationScale: 0.8,
+      ductility: 0.1,
+      fracture: "crumble",
+      fragmentSize: [
+        0.03,
+        0.15
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2,
+        ignitionC: 400,
+        burnRate: 2e-3,
+        smoke: "black"
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 3e4
+    },
+    {
+      id: "sand",
+      density: 1600,
+      hpPerKg: 2,
+      penetration: 6,
+      ductility: 0.4,
+      fracture: "crumble",
+      fragmentSize: [
+        0.01,
+        0.04
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2
+      },
+      tags: [
+        "soil"
+      ],
+      compressive: 1e4
+    },
+    {
+      id: "gravel",
+      density: 1800,
+      hpPerKg: 3,
+      penetration: 8,
+      ductility: 0.3,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.06
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2
+      },
+      tags: [
+        "soil",
+        "masonry"
+      ],
+      compressive: 2e4
+    },
+    {
+      id: "turf",
+      density: 900,
+      hpPerKg: 3,
+      penetration: 4,
+      ductility: 0.5,
+      fracture: "crumble",
+      fragmentSize: [
+        0.03,
+        0.1
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 1.5,
+        ignitionC: 250,
+        burnRate: 0.03,
+        smoke: "white"
+      },
+      tags: [
+        "soil",
+        "organic"
+      ],
+      compressive: 15e3
+    },
+    {
+      id: "mortar",
+      density: 1900,
+      hpPerKg: 10,
+      penetration: 12,
+      penetrationClass: "concrete",
+      penetrationScale: 1.2,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.08
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 1e5
     }
   ];
   var material_hints_default = {
@@ -2867,6 +3067,32 @@ var GameTestRoom = (() => {
     return (1 + 4 * (0.3 - ductility) / 0.3) * Math.min(25, Math.max(1, (0.02 / Math.max(thickness, 1e-4)) ** 2));
   };
   var THIN_SHEET_DISHING = 5e-3;
+  var SWEEP_BACK = 0.01;
+  function sweepOrigins(box2, d, spacing) {
+    const origins = [];
+    const line = (from, to) => {
+      const n = Math.max(1, Math.ceil((to - from) / spacing));
+      return Array.from({ length: n + 1 }, (_, i) => from + (to - from) * i / n);
+    };
+    for (const axis2 of [0, 1, 2]) {
+      if (Math.abs(d[axis2]) < 1e-3) continue;
+      const lead = d[axis2] > 0 ? box2.max[axis2] - SWEEP_BACK : box2.min[axis2] + SWEEP_BACK;
+      const u = (axis2 + 1) % 3;
+      const v = (axis2 + 2) % 3;
+      for (const a of line(box2.min[u], box2.max[u])) {
+        for (const b of line(box2.min[v], box2.max[v])) {
+          const point = [0, 0, 0];
+          point[axis2] = lead;
+          point[u] = a;
+          point[v] = b;
+          origins.push(point);
+        }
+      }
+    }
+    return origins;
+  }
+  var THIN_SHEET_CRUSH = 5e-4;
+  var THIN_SHEET_CONTACT = 0.025;
   var DMG_PER_J = 0.02;
   var BLAST_COUPLING = 0.1;
   var SHELTER_DEFAULTS = { k: 2800, brokenTransmission: 0.5, minPath: 5e-3 };
@@ -2883,11 +3109,14 @@ var GameTestRoom = (() => {
   var SEVER_BAND = 0.1;
   var SEVER_ASPECT = 3;
   var SEVER_BALLISTIC = 2;
+  var TEAR_JOULES = 150;
+  var tears = 0;
   var SUPPORT_TOLERANCE = 0.05;
   var UNIT_FRAGMENT_FACTOR = 4;
   var BREACH_GRID_CAP = 4096;
   var CHIP_ENERGY = 200;
   var CHIP_SPLASH = 0.5;
+  var BAR_BOW = 0.08;
   var CUT_SLICE = 1;
   var cutFactorOf = (shape) => clamp2(Math.max(...shapeDims(shape)) / CUT_SLICE, 1, 50);
   var clamp2 = (v, a, b) => Math.max(a, Math.min(b, v));
@@ -2897,8 +3126,24 @@ var GameTestRoom = (() => {
     return v === void 0 ? void 0 : v * (mat.penetrationScale ?? 1);
   };
   var capacityScale = (p) => {
-    if (p.st.stripped) return p.spec.reinforcement?.residualCapacity ?? RESIDUAL_CAPACITY;
-    return p.rt.removed ? Math.max(0.05, 1 - p.rt.removed / p.mass0) : 1;
+    const residual = p.spec.reinforcement?.residualCapacity ?? RESIDUAL_CAPACITY;
+    if (p.st.stripped) return residual;
+    const kept = Math.min(p.rt.removed ? 1 - p.rt.removed / p.mass0 : 1, 1 - sectionLoss(p));
+    return Math.max(p.spec.reinforcement ? residual : 0.05, kept);
+  };
+  var sectionLoss = (p) => {
+    const cells = p.st.chipped;
+    if (!cells?.length) return 0;
+    const [u, v] = planeAxes(p.thin);
+    const along = p.dims[u] >= p.dims[v] ? u : v;
+    const across = along === u ? v : u;
+    let worst = 0;
+    for (const c of cells) {
+      let gone = 0;
+      for (const d of cells) if (Math.abs(d.center[along] - c.center[along]) < d.size[along] / 2 + 1e-6) gone += d.size[across];
+      worst = Math.max(worst, gone / Math.max(p.dims[across], 1e-6));
+    }
+    return Math.min(1, worst);
   };
   var isLost = (p) => p.st.status === "broken" || p.st.status === "melted" || p.st.status === "ashes";
   var clone = (v) => structuredClone(v);
@@ -4079,6 +4324,12 @@ var GameTestRoom = (() => {
       debris2(o, p, layer2.mat.hitDebris, wp, normal, 5, 2, src);
       setStage(o, p, 1, {}, src);
     };
+    const crater = (o, p, wp, normal, radius, src) => {
+      markDamaged(p);
+      emit2({ ...base(o, src), type: "spall", part: p.spec.id, layer: -1, point: wp, area: Math.PI * radius * radius });
+      debris2(o, p, p.mat.breakDebris, wp, normal, 6, 1.5, src);
+      setStage(o, p, 1, {}, src);
+    };
     const insideOpening = (o, p, objectPoint) => {
       const op = p.st.opening;
       if (!op) return false;
@@ -4155,9 +4406,13 @@ var GameTestRoom = (() => {
       const lp = toLocal(p.pos, p.q, objectPoint);
       return cells.some((c) => Math.abs(lp[u] - c.center[u]) <= c.size[u] / 2 && Math.abs(lp[v] - c.center[v]) <= c.size[v] / 2);
     };
-    const chipUnits = (o, p, wp, energy, dir, radius, src) => {
+    const chipUnits = (o, p, kind, wp, hitEnergy, dir, radius, src) => {
       var _a, _b;
-      if (!p.spec.units || p.spec.reinforcement || !p.staged || chipEnergy <= 0 || energy <= 0 || p.st.stripped || isLost(p) || (p.st.stage ?? 0) >= 2) return;
+      if (!p.spec.units || !p.staged || chipEnergy <= 0 || p.st.stripped || isLost(p) || (p.st.stage ?? 0) >= 2) return;
+      const rule = p.mat.hits?.[kind];
+      const perKg = rule?.unitJoules ?? chipEnergy;
+      const energy = hitEnergy - (rule?.floor ?? 0);
+      if (perKg <= 0 || energy <= 0) return;
       const [u, v] = planeAxes(p.thin);
       const lp = toLocal(p.pos, p.q, objLocal(o, wp));
       const grid = gridOf(p);
@@ -4171,7 +4426,7 @@ var GameTestRoom = (() => {
         const share = gap === 0 ? 1 : CHIP_SPLASH * (1 - gap / radius);
         const total = (worn[i] ?? 0) + energy * share;
         const mass = p.mat.density * cell.size[0] * cell.size[1] * cell.size[2];
-        if (total < chipEnergy * mass) {
+        if (total < perKg * mass) {
           worn[i] = total;
           continue;
         }
@@ -4196,7 +4451,32 @@ var GameTestRoom = (() => {
         emit2({ ...base(o, src), type: "chip", part: p.spec.id, center, size: [cell.size[0], cell.size[1], cell.size[2]], rotation: q, fragments });
         debris2(o, p, p.mat.breakDebris, center, vec.scale(dir ?? [0, 1, 0], -1), 6, 2, src);
       }
+      if (p.spec.reinforcement) exposeRebar(o, p, src);
       for (const cell of out) addBreach(o, p, toWorld(c, q, cell.center), cell.size[u] * cell.size[v], energy, dir, src);
+      if (p.structural && !isLost(p)) {
+        solveStructure(o);
+        collapseCheck(o, src);
+      }
+    };
+    const exposeRebar = (o, p, src) => {
+      const r = p.spec.reinforcement;
+      if (!r) return;
+      const [u, v] = planeAxes(p.thin);
+      const all = rebarBars(p.dims, p.thin, r.spacing);
+      let bars;
+      if (p.st.stripped) bars = all;
+      else {
+        bars = [];
+        for (const cell of p.st.chipped ?? []) bars.push(...clipBarsToBox(all, u, v, cell.center, cell.size));
+        const op = p.st.opening;
+        if (op) {
+          const lc = toLocal(p.pos, p.q, op.center);
+          bars.push(...clipBarsToDisc(all, u, v, [lc[u], lc[v]], op.radius + 0.05));
+        }
+      }
+      const bow = clamp2(((p.st.stress ?? 0) - 1) / 0.5, 0, 1);
+      if (bow > 0) bars = bars.flatMap((bar2, i) => bendBar(bar2, p.thin, bow * BAR_BOW, i));
+      emit2({ ...base(o, src), type: "expose", part: p.spec.id, bars: worldBars(o, p, bars) });
     };
     const openBreach = (o, p, center, total, energy, dir, src) => {
       const [u, v] = planeAxes(p.thin);
@@ -4224,10 +4504,7 @@ var GameTestRoom = (() => {
       setStage(o, p, 2, { opening: { center: worldCenter, radius }, fragments }, src);
       debris2(o, p, p.mat.breakDebris, worldCenter, vec.scale(dir ?? [0, 1, 0], -1), 14, 3, src);
       const reinforcement = p.spec.reinforcement;
-      if (reinforcement) {
-        const bars = worldBars(o, p, clipBarsToDisc(rebarBars(p.dims, p.thin, reinforcement.spacing), u, v, [lc[u], lc[v]], radius + 0.05));
-        if (bars.length > 0) emit2({ ...base(o, src), type: "expose", part: p.spec.id, bars });
-      }
+      if (reinforcement) exposeRebar(o, p, src);
       if (p.structural) solveStructure(o);
     };
     const stripPart = (o, p, reinforcement, src) => {
@@ -4239,8 +4516,8 @@ var GameTestRoom = (() => {
       p.st.burning = false;
       p.rt.jet = false;
       markDamaged(p);
-      emit2({ ...base(o, src), type: "expose", part: p.spec.id, bars: worldBars(o, p, bars) });
       solveStructure(o);
+      exposeRebar(o, p, src);
       collapseCheck(o, src);
     };
     const unitFragmentPlan = (p, cap) => {
@@ -4294,7 +4571,7 @@ var GameTestRoom = (() => {
       const grain = p.spec.grain ? AXIS[p.spec.grain] : void 0;
       const hitLocal = toLocal(c, q, hitW);
       const unitPlan = p.spec.units ? unitFragmentPlan(p, maxFragments * UNIT_FRAGMENT_FACTOR) : [];
-      const axis2 = style === "splinter" ? severAxis(p) : -1;
+      const axis2 = style === "splinter" || style === "snap" ? severAxis(p) : -1;
       const cutAt = axis2 < 0 ? void 0 : p.rt.cutAt ?? (origin ? hitLocal[axis2] : void 0);
       const plan = unitPlan.length > 0 ? unitPlan : planFragments({
         style,
@@ -4366,7 +4643,7 @@ var GameTestRoom = (() => {
     };
     const CHAIN_TRIGGER_OF = { ballistic: "shot", explosive: "explosion" };
     const severAxis = (p) => {
-      if (p.mat.fracture !== "splinter" || p.spec.shape.kind !== "box") return -1;
+      if (p.mat.fracture !== "splinter" && p.mat.fracture !== "snap" || p.spec.shape.kind !== "box") return -1;
       const d = p.dims;
       const order = [0, 1, 2].sort((a, b) => d[b] - d[a]);
       return d[order[0]] >= SEVER_ASPECT * d[order[1]] && d[order[0]] >= 3 * SEVER_BAND ? order[0] : -1;
@@ -4427,6 +4704,49 @@ var GameTestRoom = (() => {
         }
       }
     };
+    const tearOf = (mat, kind) => {
+      const h = mat.hits?.[kind];
+      const tear = h?.tear ?? (kind === "ballistic" && mat.penetrationClass === "wood" ? "splinters" : "none");
+      return { tear, joules: h?.tearJoules ?? TEAR_JOULES };
+    };
+    const tearAt = (o, p, kind, entry, exit, d, E, scale2, src) => {
+      const { tear, joules } = tearOf(p.mat, kind);
+      if (tear === "none") return;
+      const shot = kind === "ballistic";
+      const n = shot ? exit ? clamp2(Math.round(E / joules), 1, 7) : 1 : clamp2(Math.floor(E / joules), 0, 5);
+      if (n === 0) return;
+      const fibre = tear === "lumps";
+      const { q } = partXf(o, p);
+      const along = (p.spec.grain ? AXIS[p.spec.grain] : void 0) ?? [0, 1, 2].sort((a, b) => p.dims[b] - p.dims[a])[0];
+      const fragments = [];
+      for (let i = 0; i < n; i++) {
+        const back = !exit || i % 3 === 2;
+        const len = scale2 * (fibre ? 1.2 + 1.2 * rnd2() : 3 + 4 * rnd2()), w = scale2 * (0.8 + 0.8 * rnd2()), t = scale2 * (fibre ? 0.7 + 0.6 * rnd2() : 0.4 + 0.4 * rnd2());
+        const size = [w, w, w];
+        size[along] = len;
+        size[(along + 1) % 3] = w;
+        size[(along + 2) % 3] = t;
+        const spread3 = [(rnd2() - 0.5) * 0.8, (rnd2() - 0.2) * 0.8, (rnd2() - 0.5) * 0.8];
+        const speed = shot ? back ? 1.5 + 2 * rnd2() : 2 + 4 * rnd2() : 0.8 + 1.2 * rnd2();
+        const v = vec.scale(vec.normalize(vec.add(back ? vec.scale(d, -1) : d, spread3)), speed);
+        const mass = size[0] * size[1] * size[2] * p.mat.density;
+        fragments.push({
+          id: `${p.spec.id}#t${tears++}-${i}`,
+          part: p.spec.id,
+          material: p.spec.material,
+          shape: fibre ? "chunk" : "splinter",
+          center: back || !exit ? vec.madd(entry, d, -0.01) : vec.madd(exit, d, 0.01),
+          size,
+          rotation: q,
+          velocity: v,
+          inner: true,
+          angularVelocity: [(rnd2() - 0.5) * 30, (rnd2() - 0.5) * 30, (rnd2() - 0.5) * 30],
+          mass
+        });
+      }
+      const patch = [scale2 * 4, scale2 * 4, scale2 * 4];
+      emit2({ ...base(o, src), type: "chip", part: p.spec.id, center: exit ?? entry, size: patch, rotation: q, fragments });
+    };
     const ballistic2 = (o, p, entry, n, d, E, caliber, pathLen, src, round2 = {}) => {
       const mat = p.mat;
       const piercing = round2.piercing ?? 1;
@@ -4455,6 +4775,7 @@ var GameTestRoom = (() => {
         return { penetrated: false, exitEnergy: 0, damage: dmg2 };
       }
       if (p.layers.length > 0) spallOuter(o, p, entry, face, n, Math.max(0.03, caliber / 1e3 * 4), src);
+      else if (mat.hits?.ballistic?.crater) crater(o, p, entry, n, clamp2(0.02 + Math.sqrt(E) * 15e-4, 0.02, 0.15), src);
       const brittle = mat.ductility < 0.3;
       const ratio = Ep / Math.max(thr, 1e-6);
       const crackLen = clamp2(0.03 + ratio * 0.2, 0.03, 0.8);
@@ -4488,8 +4809,10 @@ var GameTestRoom = (() => {
       } else addHole(o, p, entry, n, caliber / 1e3, false, void 0, src);
       debris2(o, p, mat.hitDebris, entry, n, clamp2(Math.round(E / 60) + 2, 2, 14), clamp2(Math.sqrt(E) / 6, 1, 8), src);
       wearJoints(o, p, (penetrated ? thr : E) * 0.02, void 0, 0, src, true);
-      const dmg = applyDamage(o, p, E * DMG_PER_J * scale2, "ballistic", entry, d, E * 0.1, 12, src);
-      chipUnits(o, p, entry, penetrated ? Math.min(E, Math.max(thr, E * 0.5)) : E, d, Math.max(0.05, caliber / 1e3 * 8), src);
+      const absorbed = penetrated && mat.ductility >= 0.5 && mat.fracture !== "tear" ? Math.min(E, thr) : E;
+      const dmg = applyDamage(o, p, absorbed * DMG_PER_J * scale2, "ballistic", entry, d, absorbed * 0.1, 12, src);
+      if (!isLost(p)) tearAt(o, p, "ballistic", entry, penetrated ? exitPoint : void 0, d, E, caliber / 1e3, src);
+      chipUnits(o, p, "ballistic", entry, penetrated ? Math.min(E, Math.max(thr, E * 0.5)) : E, d, Math.max(0.05, caliber / 1e3 * 8), src);
       return { penetrated, exitEnergy: penetrated ? penMm !== void 0 ? E * (1 - thr / Ep) : E - thr / (hard ? piercing : 1) : 0, exitPoint, damage: dmg };
     };
     const melee = (o, p, kind, E, point, n, d, contactR, src) => {
@@ -4497,14 +4820,20 @@ var GameTestRoom = (() => {
       const thrMm = mat.penetration * p.thickness * 1e3;
       const fragile = kind === "blunt" ? fragility(mat.ductility, p.thickness) : 1;
       const Ec = E * fragile;
+      const sheet = mat.ductility >= 0.5 && p.thickness <= THIN_SHEET_CRUSH;
+      const fold2 = sheet ? Math.min(4, Math.sqrt(1e-3 / p.thickness)) : 1;
+      const patch = sheet ? Math.min(contactR, THIN_SHEET_CONTACT) : contactR;
       if (E > 0) {
         if (kind === "blunt") {
-          if (mat.ductility >= 0.5) addDent(o, p, point, n, Math.max(contactR, 0.015), clamp2(E * 1e-4, 1e-3, 0.06), src);
+          if (mat.ductility >= 0.5) addDent(o, p, point, n, Math.max(patch, 0.015), clamp2(E * 1e-4 * fold2, 1e-3, sheet ? Math.min(0.06, Math.min(...p.dims) * 0.45) : 0.06), src);
           else if (mat.ductility < 0.3) {
             if (Ec >= 5) addCrack(o, p, point, n, clamp2(0.04 + Math.min(Ec, E * 6) * 8e-4, 0.04, 0.6), src);
           } else if (E >= thrMm * 0.2) addDent(o, p, point, n, Math.max(contactR, 0.015), clamp2(E * 6e-5, 1e-3, 0.04), src);
         } else if (mat.fracture === "tear") {
           addHole(o, p, point, n, clamp2(0.02 + E * 5e-4, 0.02, 0.3), true, void 0, src);
+        } else if (mat.ductility >= 0.3 && E >= thrMm) {
+          addHole(o, p, point, n, clamp2(contactR, 0.01, 0.08), true, void 0, src);
+          if (sheet) addDent(o, p, point, n, Math.max(patch * 0.6, 0.01), clamp2(E * 4e-5 * fold2, 5e-4, 0.02), src);
         } else if (mat.ductility >= 0.5) {
           addDent(o, p, point, n, Math.max(contactR, 0.01), clamp2(E * 4e-5, 5e-4, 0.02), src);
         }
@@ -4517,7 +4846,8 @@ var GameTestRoom = (() => {
       const scale2 = mat.damageScale?.[kind] ?? 1;
       const done = applyDamage(o, p, Ec * DMG_PER_J * scale2 * (kind === "slash" ? p.cutFactor : 1), kind, point, d, E * 0.1, 12, src);
       addBreach(o, p, point, breachAreaOf(p, done, false), E, d, src);
-      if (kind === "blunt") chipUnits(o, p, point, E, d, Math.max(contactR, 0.03), src);
+      if (kind === "blunt") chipUnits(o, p, "blunt", point, E, d, Math.max(contactR, 0.03), src);
+      if (E > 0 && !isLost(p)) tearAt(o, p, kind, point, void 0, d, E, clamp2(contactR * 0.2, 6e-3, 0.02), src);
       return done;
     };
     const blastPart = (o, p, point, energy, radius, src, res, reachAt) => {
@@ -5096,6 +5426,7 @@ var GameTestRoom = (() => {
             if (p.rt.stressT <= 0) {
               p.rt.stressT = 0.5;
               emit2({ ...base(o), type: "stress", part: p.spec.id, stress, load: p.st.load ?? 0 });
+              if (p.spec.reinforcement && (p.st.stripped || p.st.chipped?.length || p.st.opening)) exposeRebar(o, p);
             }
             applyDamage(o, p, overloadRate(stress) * p.st.maxHp * dt, "blunt", null, null, 5, 3);
           } else if (stress > 0.8 && p.mat.ductility < 0.3 && p.rt.stressT <= 0 && p.st.cracks.length < 6) {
@@ -5312,6 +5643,18 @@ var GameTestRoom = (() => {
         const r = raycastInternal(origin, direction, maxDistance);
         return r ? { object: r.object, part: r.part, point: r.point, normal: r.normal, distance: r.distance } : null;
       },
+      sweepBox(box2, direction, distance4, options2 = {}) {
+        const d = vec.normalize(direction);
+        const ignored = options2.ignore === void 0 ? void 0 : objects.get(options2.ignore);
+        const ignore = ignored ? new Set(ignored.parts.map((p) => `${ignored.id}\0${p.spec.id}`)) : void 0;
+        let best = null;
+        for (const origin of sweepOrigins(box2, d, options2.spacing ?? 0.2)) {
+          const r = raycastInternal(origin, d, distance4 + SWEEP_BACK, ignore);
+          if (!r || best && r.distance >= best.distance) continue;
+          best = { object: r.object, part: r.part, point: r.point, normal: r.normal, distance: Math.max(0, r.distance - SWEEP_BACK) };
+        }
+        return best;
+      },
       shoot(origin, direction, energy, caliber, source, round2) {
         const extras = typeof round2 === "number" ? { piercing: round2 } : round2 ?? {};
         return withCollapses(run(() => {
@@ -5614,7 +5957,12 @@ var GameTestRoom = (() => {
         cactus: "cactus",
         flesh_fruit: "fruit",
         wax: "wax",
-        soil: "soil"
+        soil: "soil",
+        asphalt: "asphalt",
+        sand: "sand",
+        gravel: "gravel",
+        turf: "turf",
+        mortar: "mortar"
       },
       partStatus: { intact: "intact", damaged: "damaged", collapsed: "collapsed", broken: "broken", melted: "melted", ashes: "ashes" },
       jointKinds: {
@@ -5705,7 +6053,12 @@ var GameTestRoom = (() => {
         cactus: "cacto",
         flesh_fruit: "fruta",
         wax: "cera",
-        soil: "terra"
+        soil: "terra",
+        asphalt: "asfalto",
+        sand: "areia",
+        gravel: "brita",
+        turf: "grama",
+        mortar: "argamassa"
       },
       partStatus: { intact: "intacto", damaged: "danificado", collapsed: "desabado", broken: "quebrado", melted: "derretido", ashes: "cinzas" },
       jointKinds: {
@@ -14499,77 +14852,6 @@ var GameTestRoom = (() => {
     const key = event.stage !== void 0 ? String(event.stage) : event.material;
     return key === void 0 ? void 0 : entry[key];
   }
-  var DEFAULT_SIZE2 = 60;
-  var DEFAULT_SEGMENTS = 180;
-  var MAX_DEPTH = 3;
-  var RIM_REACH = 1.45;
-  var REACH_FACTOR = 1.5;
-  function createGroundField(options = {}) {
-    const size = options.size ?? DEFAULT_SIZE2;
-    const segments = options.segments ?? DEFAULT_SEGMENTS;
-    const stride = segments + 1;
-    const cellSize = size / segments;
-    const origin = -size / 2;
-    const heights = new Float32Array(stride * stride);
-    let version = 0;
-    function heightAt(x, z) {
-      const fx = (x - origin) / cellSize;
-      const fz = (z - origin) / cellSize;
-      if (fx < 0 || fz < 0 || fx >= segments || fz >= segments) return 0;
-      const column = fx | 0;
-      const row = fz | 0;
-      const tx = fx - column;
-      const tz = fz - row;
-      const index = row * stride + column;
-      return (heights[index] * (1 - tx) + heights[index + 1] * tx) * (1 - tz) + (heights[index + stride] * (1 - tx) + heights[index + stride + 1] * tx) * tz;
-    }
-    function dent(random, x, z, radius, depth) {
-      const reach = radius * REACH_FACTOR;
-      const column0 = Math.max(0, Math.floor((x - reach - origin) / cellSize));
-      const column1 = Math.min(segments, Math.ceil((x + reach - origin) / cellSize));
-      const row0 = Math.max(0, Math.floor((z - reach - origin) / cellSize));
-      const row1 = Math.min(segments, Math.ceil((z + reach - origin) / cellSize));
-      const phaseA = random.next() * 6;
-      const phaseB = random.next() * 6;
-      for (let row = row0; row <= row1; row++) {
-        for (let column = column0; column <= column1; column++) {
-          const px = origin + column * cellSize;
-          const pz = origin + row * cellSize;
-          const distance4 = Math.hypot(px - x, pz - z);
-          const angle = Math.atan2(pz - z, px - x);
-          const q = distance4 / (radius * (1 + 0.13 * Math.sin(angle * 5 + phaseA) + 0.07 * Math.sin(angle * 11 + phaseB)));
-          let change = 0;
-          if (q < 1) change = -depth * (1 - q * q) * (0.85 + random.next() * 0.3);
-          else if (q < RIM_REACH) {
-            const k = (q - 1) / 0.45;
-            change = depth * 0.3 * Math.sin(k * Math.PI) * (1 - k * 0.3) * (0.6 + random.next() * 0.8);
-          }
-          if (!change) continue;
-          const index = row * stride + column;
-          heights[index] = Math.max(-MAX_DEPTH, heights[index] + change);
-        }
-      }
-      version++;
-    }
-    function reset() {
-      heights.fill(0);
-      version++;
-    }
-    return {
-      size,
-      segments,
-      stride,
-      cellSize,
-      origin,
-      heights,
-      get version() {
-        return version;
-      },
-      heightAt,
-      dent,
-      reset
-    };
-  }
 
   // ../game-vfx-three/dist/index.js
   var GLOW_VERTEX = `attribute vec4 aP;attribute vec4 aC;varying vec2 vU;varying vec4 vC;
@@ -15854,40 +16136,47 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     };
   }
   var LIGHT_BUDGET = EVENT_BUDGET.blastLights + EVENT_BUDGET.fireLights;
-  var DEFAULT_TEXTURE_METRES = 17;
-  function createGroundPatch(THREE, options) {
-    const field = options.field;
-    const metres = options.textureMetres ?? DEFAULT_TEXTURE_METRES;
-    const geometry = new THREE.PlaneGeometry(field.size, field.size, field.segments, field.segments).rotateX(-Math.PI / 2);
-    const position = geometry.attributes.position;
-    const uv = geometry.attributes.uv;
-    for (let index = 0; index < position.count; index++) uv.setXY(index, position.getX(index) / metres, position.getZ(index) / metres);
-    const material = options.material ?? new THREE.MeshStandardMaterial({ color: 2829359, roughness: 0.93, flatShading: true });
-    const mesh2 = new THREE.Mesh(geometry, material);
-    mesh2.receiveShadow = true;
-    let version = -1;
-    function sync() {
-      if (field.version === version) return false;
-      version = field.version;
-      for (let index = 0; index < position.count; index++) position.setY(index, field.heights[index]);
-      position.needsUpdate = true;
-      geometry.computeBoundingSphere();
-      return true;
-    }
-    return {
-      mesh: mesh2,
-      sync,
-      dispose() {
-        geometry.dispose();
-        if (!options.material) material.dispose();
-      }
-    };
-  }
 
   // ../game-destruction-three/dist/index.js
   var __defProp3 = Object.defineProperty;
   var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var SLICE_LENGTH = 0.12;
+  var MAX_SLICES = 12;
+  var SNUG_RATIO = 1.1;
+  function pushFittedBoxes(local2, matrix, out) {
+    const e = matrix.elements;
+    const sizes = [0, 1, 2].map((k) => k === 0 ? local2.max.x - local2.min.x : k === 1 ? local2.max.y - local2.min.y : local2.max.z - local2.min.z);
+    const lengths = [0, 1, 2].map((k) => sizes[k] * Math.hypot(e[k * 4], e[k * 4 + 1], e[k * 4 + 2]));
+    const longest = lengths.indexOf(Math.max(...lengths));
+    const whole = worldBoxOf(local2, matrix, longest, 0, 1);
+    const span = (whole[3] - whole[0]) * (whole[4] - whole[1]) * (whole[5] - whole[2]);
+    const volume = lengths[0] * lengths[1] * lengths[2];
+    const slices = span <= volume * SNUG_RATIO ? 1 : Math.min(MAX_SLICES, Math.ceil(lengths[longest] / SLICE_LENGTH));
+    if (slices <= 1) {
+      out.push(...whole);
+      return;
+    }
+    for (let i = 0; i < slices; i++) out.push(...worldBoxOf(local2, matrix, longest, i / slices, (i + 1) / slices));
+  }
+  function worldBoxOf(local2, matrix, axis2, from, to) {
+    const e = matrix.elements;
+    const low = [local2.min.x, local2.min.y, local2.min.z];
+    const high = [local2.max.x, local2.max.y, local2.max.z];
+    const start = low[axis2];
+    const size = high[axis2] - start;
+    low[axis2] = start + size * from;
+    high[axis2] = start + size * to;
+    const box2 = [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
+    for (const x of [low[0], high[0]]) for (const y of [low[1], high[1]]) for (const z of [low[2], high[2]]) {
+      for (let k = 0; k < 3; k++) {
+        const v = e[k] * x + e[k + 4] * y + e[k + 8] * z + e[k + 12];
+        box2[k] = Math.min(box2[k], v);
+        box2[k + 3] = Math.max(box2[k + 3], v);
+      }
+    }
+    return box2;
+  }
   function createRng3(seed) {
     let a = seed >>> 0;
     return () => {
@@ -15926,12 +16215,19 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var SHEET_MAX = 4e-3;
   var SHEET_AIR = 2.5;
   var SHEET_SWAY = 3;
+  var BIG_LENGTH = 0.2;
+  var BIG_WIDTH = 0.03;
+  var isBig = (size) => {
+    const [, middle, longest] = [...size].sort((a, b) => a - b);
+    return longest >= BIG_LENGTH && middle >= BIG_WIDTH;
+  };
   var FragmentSystem = class {
     constructor(THREE, o) {
       __publicField2(this, "THREE", THREE);
       __publicField2(this, "o", o);
       __publicField2(this, "list", []);
       __publicField2(this, "box");
+      __publicField2(this, "unitBox", { min: { x: -0.5, y: -0.5, z: -0.5 }, max: { x: 0.5, y: 0.5, z: 0.5 } });
       __publicField2(this, "shardGeos", []);
       __publicField2(this, "materials", /* @__PURE__ */ new Map());
       __publicField2(this, "q");
@@ -15940,6 +16236,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField2(this, "v");
       __publicField2(this, "w");
       __publicField2(this, "rng", createRng3(1374496523));
+      __publicField2(this, "tick", 0);
       __publicField2(this, "markGeometry", null);
       __publicField2(this, "markMaterial", null);
       this.box = new THREE.BoxGeometry(1, 1, 1);
@@ -16007,8 +16304,28 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         mesh2.add(disc);
       }
     }
-    /** Create the mesh of a fragment and start its motion. `maxAllowed` is the live budget. */
+    /**
+     * Create the mesh of a fragment and start its motion. `maxAllowed` is the live budget: over it the oldest fragment still showing fades out to make room, and a burst
+     * bigger than the budget (every live fragment was made in this same frame) does not make the rest at all, so a blast never builds a thousand meshes only to fade them
+     * out. Returns null when the fragment was not made.
+     */
     spawn(f, material, home, maxAllowed) {
+      if (this.list.length >= maxAllowed) {
+        let alive = 0;
+        let oldest;
+        let oldestSmall;
+        for (const l of this.list) {
+          if (l.dying) continue;
+          alive++;
+          oldest ?? (oldest = l);
+          if (!l.body) oldestSmall ?? (oldestSmall = l);
+        }
+        oldest = oldestSmall ?? oldest;
+        if (alive >= maxAllowed) {
+          if (!oldest || oldest.born === this.tick) return null;
+          oldest.dying = true;
+        }
+      }
       const geo = f.shape === "shard" ? this.shardGeometry(hashString(f.id)) : this.box;
       const mesh2 = new this.THREE.Mesh(geo, material);
       mesh2.position.set(f.center[0], f.center[1], f.center[2]);
@@ -16032,19 +16349,42 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         rest: 0,
         fade: 1,
         dying: false,
-        air: f.shape === "scrap" && sz[2] <= SHEET_MAX ? SHEET_AIR : 0
+        air: f.shape === "scrap" && sz[2] <= SHEET_MAX ? SHEET_AIR : 0,
+        body: null,
+        born: this.tick
       };
-      this.list.push(live);
-      let alive = this.list.reduce((n, l) => n + (l.dying ? 0 : 1), 0);
-      for (let i = 0; i < this.list.length && alive > maxAllowed; i++) {
-        if (!this.list[i].dying) {
-          this.list[i].dying = true;
-          alive--;
-        }
+      if (f.shape !== "shard" && isBig(f.size)) {
+        live.body = {
+          mass: f.mass,
+          push: (x, z) => {
+            live.vel.x = x;
+            live.vel.z = z;
+            live.vel.y = Math.max(live.vel.y, 0.3);
+            live.asleep = false;
+            live.rest = 0;
+          }
+        };
       }
+      this.list.push(live);
       this.addMarks(mesh2, f);
       return mesh2;
     }
+    /** The boxes of the big fragments around (x, z). */
+    solidsNear(x, z, radius, found) {
+      const boxes = [];
+      for (const f of this.list) {
+        if (!f.body || f.dying) continue;
+        const reach = f.half.length() + radius;
+        if (Math.abs(f.mesh.position.x - x) > reach || Math.abs(f.mesh.position.z - z) > reach) continue;
+        f.mesh.updateMatrixWorld();
+        boxes.length = 0;
+        pushFittedBoxes(this.unitBox, f.mesh.matrixWorld, boxes);
+        for (let i = 0; i < boxes.length; i += 6) {
+          if (x < boxes[i] - radius || x > boxes[i + 3] + radius || z < boxes[i + 2] - radius || z > boxes[i + 5] + radius) continue;
+          found(f.home, [boxes[i], boxes[i + 1], boxes[i + 2]], [boxes[i + 3], boxes[i + 4], boxes[i + 5]], f.body);
+        }
+      }
+    }
     /** Add velocity to every fragment within `radius` of a point (blasts). */
     blast(point, radius, speed) {
       for (const f of this.list) {
@@ -16060,7 +16400,16 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         f.rest = 0;
       }
     }
+    /** What lies inside the disc looks at the ground again: it was dug or heaped under it. */
+    wakeRegion(x, z, radius) {
+      for (const f of this.list) {
+        if (!f.asleep || Math.hypot(f.mesh.position.x - x, f.mesh.position.z - z) > radius) continue;
+        f.asleep = false;
+        f.rest = 0;
+      }
+    }
     update(dt) {
+      this.tick++;
       const g = this.o.gravity;
       for (let i = this.list.length - 1; i >= 0; i--) {
         const f = this.list[i];
@@ -16075,7 +16424,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         }
         if (f.asleep) {
           f.rest += dt;
-          if (this.o.life > 0 && f.rest > this.o.life) f.dying = true;
+          if (this.o.life > 0 && f.rest > this.o.life && !f.body) f.dying = true;
           continue;
         }
         this.step(f, dt, g);
@@ -16149,7 +16498,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       let small = 0;
       for (let i = 1; i < 3; i++) if (half[i] < half[small]) small = i;
       let axis2 = small;
-      if (Math.abs(up[small]) < 0.35) {
+      if (Math.abs(up[small]) < 0.35 && !f.body) {
         axis2 = 0;
         for (let i = 1; i < 3; i++) if (Math.abs(up[i]) > Math.abs(up[axis2])) axis2 = i;
       }
@@ -16271,6 +16620,30 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var SLOP = 2e-3;
   var NARROW = 0.3;
   var TOPPLE = 3;
+  var TIP_ACCELERATION = 30;
+  var TIP_LYING = 0.25;
+  var TIP_SECONDS = 3;
+  var STEP = 0.03;
+  var boxTopAt = (s, x, z) => {
+    const e = s.e;
+    const dx = x - s.c[0], dz = z - s.c[2];
+    let t0 = -Infinity, t1 = Infinity;
+    for (let k = 0; k < 3; k++) {
+      const p = e[k * 4] * dx + e[k * 4 + 2] * dz;
+      const d = e[k * 4 + 1];
+      const h = s.half[k];
+      if (Math.abs(d) < 1e-9) {
+        if (Math.abs(p) > h) return -Infinity;
+        continue;
+      }
+      let a = (-h - p) / d, b = (h - p) / d;
+      if (a > b) [a, b] = [b, a];
+      t0 = Math.max(t0, a);
+      t1 = Math.min(t1, b);
+      if (t0 > t1) return -Infinity;
+    }
+    return s.c[1] + t1;
+  };
   var PieceSystem = class {
     constructor(THREE, o) {
       __publicField2(this, "THREE", THREE);
@@ -16282,6 +16655,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField2(this, "dq");
       __publicField2(this, "m");
       __publicField2(this, "ax");
+      __publicField2(this, "solids", []);
       this.p = new THREE.Vector3();
       this.q = new THREE.Quaternion();
       this.dq = new THREE.Quaternion();
@@ -16291,6 +16665,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     get(objectId) {
       return this.list.find((b) => b.objectId === objectId) ?? null;
     }
+    /** Sets a piece falling over, about the world axes x and z (a unit axis): its feet are thinner than the box that stands for it, so the box alone would hold it up. */
+    tip(body, x, z) {
+      body.tipping = { x, z, seconds: TIP_SECONDS };
+      body.sleeping = false;
+    }
     create(objectId, root, halfExtents, localCenter, mass, velocity, angular) {
       const existing = this.get(objectId);
       if (existing) {
@@ -16304,6 +16683,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       const body = {
         objectId,
+        tipping: null,
         root,
         velocity: velocity ? [...velocity] : [0, 0, 0],
         angularVelocity: angular ? [...angular] : [0, 0, 0],
@@ -16373,8 +16753,21 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const lz = (e[8] * x + e[9] * y + e[10] * z) * iz;
       return [e[0] * lx + e[4] * ly + e[8] * lz, e[1] * lx + e[5] * ly + e[9] * lz, e[2] * lx + e[6] * ly + e[10] * lz];
     }
+    /** What lies inside the disc looks at the ground again: it was dug or heaped under it. */
+    wakeRegion(x, z, radius) {
+      for (const b of this.list) {
+        if (!b.sleeping || b.held || Math.hypot(b.root.position.x - x, b.root.position.z - z) > radius) continue;
+        b.sleeping = false;
+        b.still = 0;
+      }
+    }
     update(dt) {
       this.time += dt;
+      this.solids = this.list.map((body) => {
+        const c = this.centerOf(body, new this.THREE.Vector3());
+        const h = body.halfExtents;
+        return { body, c: [c.x, c.y, c.z], e: [...new this.THREE.Matrix4().makeRotationFromQuaternion(body.root.quaternion).elements], half: h, r: Math.hypot(h[0], h[1], h[2]) };
+      });
       for (const b of this.list) {
         if (b.held) {
           b.velocity = [0, 0, 0];
@@ -16388,6 +16781,17 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       this.separate(dt);
     }
+    /** Where a corner of `self` at `(x, y, z)` lands: the ground, the top of another piece or of something fixed under it. */
+    supportAt(self, x, y, z, step) {
+      let top = this.o.groundAt(x, z);
+      for (const s of this.solids) {
+        if (s.body === self || s.body.held || Math.abs(x - s.c[0]) > s.r || Math.abs(z - s.c[2]) > s.r) continue;
+        const t = boxTopAt(s, x, z);
+        if (t > top && t <= y + step) top = t;
+      }
+      const fixed2 = this.o.staticTopAt?.(x, z, y, step) ?? -Infinity;
+      return Math.max(top, fixed2);
+    }
     integrate(b, dt) {
       const c = this.centerOf(b, this.p);
       const pos = [c.x, c.y, c.z];
@@ -16426,8 +16830,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const sy = i & 2 ? hy : -hy;
           const sz = i & 4 ? hz : -hz;
           const r = [e[0] * sx + e[4] * sy + e[8] * sz, e[1] * sx + e[5] * sy + e[9] * sz, e[2] * sx + e[6] * sy + e[10] * sz];
-          const gy = this.o.groundAt(pos[0] + r[0], pos[2] + r[2]);
-          const pen = gy - (pos[1] + r[1]);
+          const cy = pos[1] + r[1];
+          const gy = this.supportAt(b, pos[0] + r[0], cy, pos[2] + r[2], STEP + Math.max(0, -v[1]) * h * 2);
+          const pen = gy - cy;
           if (pen > -SLOP) {
             rs.push(r);
             if (pen > maxPen) maxPen = pen;
@@ -16450,7 +16855,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           }
           const lx = pos[0] + sx / rs.length;
           const lz = pos[2] + sz / rs.length;
-          landPoint = [lx, this.o.groundAt(lx, lz), lz];
+          landPoint = [lx, pos[1] - Math.max(...rs.map((r) => -r[1])), lz];
         }
         for (let it = 0; it < 4; it++) {
           for (const r of rs) {
@@ -16503,6 +16908,15 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const wx = x1 - x0;
         const wz = z1 - z0;
         unstable = Math.min(wx, wz) < NARROW * height || x0 > 0 || x1 < 0 || z0 > 0 || z1 < 0;
+        if (b.tipping) {
+          b.tipping.seconds -= h;
+          if (height < TIP_LYING || b.tipping.seconds <= 0) b.tipping = null;
+          else {
+            w[0] += b.tipping.x * TIP_ACCELERATION * h;
+            w[2] += b.tipping.z * TIP_ACCELERATION * h;
+            unstable = true;
+          }
+        }
         if (unstable) {
           const dirX = x0 + x1 > 0 ? -1 : 1;
           const dirZ = z0 + z1 > 0 ? -1 : 1;
@@ -16539,6 +16953,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         b.still = 0;
       }
     }
+    /** Half the height of the box of a piece as it is turned now. */
+    halfHeight(b) {
+      const e = this.m.makeRotationFromQuaternion(b.root.quaternion).elements;
+      return Math.abs(e[1]) * b.halfExtents[0] + Math.abs(e[5]) * b.halfExtents[1] + Math.abs(e[9]) * b.halfExtents[2];
+    }
     /** Push overlapping pieces apart (horizontal bounding circles), gently, so they do not interpenetrate forever. */
     separate(dt) {
       const n = this.list.length;
@@ -16557,6 +16976,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           this.centerOf(a, ca);
           this.centerOf(b, cb);
           if (Math.abs(ca.y - cb.y) > ra + rb) continue;
+          if (Math.abs(ca.y - cb.y) >= (this.halfHeight(a) + this.halfHeight(b)) * 0.9) continue;
           const rh = (Math.max(a.halfExtents[0], a.halfExtents[2]) + Math.max(b.halfExtents[0], b.halfExtents[2])) * 0.8;
           let dx = cb.x - ca.x;
           let dz = cb.z - ca.z;
@@ -16712,6 +17132,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const fill = options.fillOf?.(o, material);
           const tags = Array.isArray(ud.destructionTags) ? ud.destructionTags : void 0;
           const contains = containsOf(ud.destructionContains);
+          const thickness = typeof ud.destructionThickness === "number" && ud.destructionThickness > 0 ? ud.destructionThickness : void 0;
           const existing = explicit ? byKey.get(explicit) : void 0;
           if (existing) {
             const before = sizeOf(existing.box);
@@ -16724,8 +17145,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
             existing.skin = existing.skin && skin;
             if (fill !== void 0) existing.fill = fill;
             if (contains) existing.contains = contains;
+            if (thickness !== void 0) existing.thickness = Math.min(existing.thickness ?? thickness, thickness);
           } else {
-            const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box: box2, material, explicitId: explicit, fill, hollow, skin, tags, fixedId: !!explicit, ...contains ? { contains } : {}, name: o.name, parent: hint?.parent, jointKind: hint?.kind };
+            const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box: box2, material, explicitId: explicit, fill, hollow, skin, tags, fixedId: !!explicit, ...contains ? { contains } : {}, ...thickness !== void 0 ? { thickness } : {}, name: o.name, parent: hint?.parent, jointKind: hint?.kind };
             entries.push(e);
             if (explicit) byKey.set(explicit, e);
           }
@@ -16793,7 +17215,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const minSide = Math.min(...size);
       if (e.fill !== void 0) part.fill = e.fill;
       else if (e.hollow) part.fill = 0.05;
-      if (minSide < 0.01 && METAL.test(e.material)) {
+      if (e.thickness !== void 0) part.thickness = e.thickness;
+      else if (minSide < 0.01 && METAL.test(e.material)) {
         part.fill = e.fill ?? 1;
         part.thickness = Math.max(minSide, 5e-4);
       }
@@ -16880,9 +17303,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const ids = [0, 1, 2].map((corner) => index ? index.getX(t * 3 + corner) : t * 3 + corner);
         ids.forEach((id, corner) => corners[corner].set(shell.before[id * 3], shell.before[id * 3 + 1], shell.before[id * 3 + 2]));
         triangle.set(corners[0], corners[1], corners[2]);
+        if (triangle.getArea() <= 1e-14) continue;
         triangle.closestPointToPoint(local2, closest);
         const distance4 = closest.distanceToSquared(local2);
-        if (distance4 >= nearest) continue;
+        if (!(distance4 < nearest)) continue;
         nearest = distance4;
         nearestScale = shell.mesh.matrixWorld.getMaxScaleOnAxis() || 1;
         triangle.getBarycoord(closest, weights);
@@ -17058,6 +17482,20 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       return out;
     }
     /** Box of the part in world space. */
+    /** Appends the boxes that follow the mesh in the world (`pushFittedBoxes`) to `out`. */
+    fittedBoxes(mv, out) {
+      const box2 = new this.THREE.Box3();
+      if (mv.host) this.localBox(mv, box2);
+      else {
+        const geometry = mv.mesh.geometry;
+        if (!geometry.boundingBox) geometry.computeBoundingBox();
+        if (geometry.boundingBox) box2.copy(geometry.boundingBox);
+        else box2.makeEmpty();
+      }
+      if (box2.isEmpty()) return;
+      mv.mesh.updateWorldMatrix(true, false);
+      pushFittedBoxes(box2, mv.mesh.matrixWorld, out);
+    }
     worldBox(mv, out) {
       if (!mv.host) return out.setFromObject(mv.mesh);
       this.localBox(mv, out);
@@ -17804,6 +18242,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var IMPACT_TAGS = ["metal", "glass", "wood"];
   var GLOW_FROM_C = 430;
   var QUEUE_CAP = 4e3;
+  var STATIC_REFRESH = 0.5;
+  var STATIC_SPAN = 3;
+  var FEET_BAND = 0.03;
+  var TIP_MIN_HEIGHT = 0.3;
+  var TIP_NARROW = 0.3;
   var FIRE_CEILING_SECONDS = 3600;
   var GENERIC_REFERENCE_RADIUS = 15;
   var PRIMED_FIRE_RADIUS = 0.2;
@@ -17848,6 +18291,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     if (def.fracture === "tear") return "impact_soft";
     return def.fracture === "none" ? "impact_metal" : "impact_wood";
   }
+  var dragSoundKey = (def) => impactKey(def).replace("impact_", "drag_");
   function fractureKey(def, style) {
     switch (style) {
       case "shatter":
@@ -17889,6 +18333,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField2(this, "autoSplit");
       __publicField2(this, "maxFragments");
       __publicField2(this, "bounds", /* @__PURE__ */ new Map());
+      __publicField2(this, "staticBoxes", /* @__PURE__ */ new Map());
+      __publicField2(this, "staticDirty", /* @__PURE__ */ new Set());
+      __publicField2(this, "staticAll", true);
+      __publicField2(this, "pieceBoxes", /* @__PURE__ */ new WeakMap());
+      __publicField2(this, "staticAt", 0);
       __publicField2(this, "queue", []);
       __publicField2(this, "unsubscribe");
       __publicField2(this, "visuals");
@@ -17946,6 +18395,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.cages = new RebarCages(THREE, o.scene);
       this.pieceSys = new PieceSystem(THREE, {
         groundAt: this.groundAt,
+        staticTopAt: (x, z, y, step) => this.staticTopAt(x, z, y, step),
         gravity: this.gravity,
         scene: o.scene,
         onHardLanding: (p, point, speed) => this.hardLanding(p, point, speed)
@@ -17958,6 +18408,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     // Binding
     // ----------------------------------------------------------------------------------------------------------------------------------
     bind(objectId, root, options = {}) {
+      this.staticDirty.add(objectId);
       if (this.bounds.has(objectId)) this.unbind(objectId);
       const state = this.world.state(objectId);
       const partIds = new Set((state?.parts ?? []).map((p) => p.id));
@@ -18077,6 +18528,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
     }
     unbind(objectId) {
+      this.staticDirty.add(objectId);
       const b = this.bounds.get(objectId);
       if (!b) return;
       this.restore(objectId);
@@ -18116,6 +18568,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       return m > 0 ? m : 5;
     }
     makePiece(objectId, options = {}) {
+      this.staticDirty.add(objectId);
       const b = this.bounds.get(objectId);
       if (!b) throw new Error(`game-destruction-three: object "${objectId}" is not bound`);
       if (b.root.parent && b.root.parent !== this.scene) this.scene.attach(b.root);
@@ -18228,7 +18681,100 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     // ----------------------------------------------------------------------------------------------------------------------------------
     // Events
     // ----------------------------------------------------------------------------------------------------------------------------------
+    /**
+     * The highest top of a bound object that is not a piece under (x, z) a corner at height `y` can land on (at most `step` above it). The world boxes
+     * of their drawn meshes are kept until an event or a moved root changes them; parts drawn inside a merged mesh and meshes wider than `STATIC_SPAN`
+     * are left out (walls, floors, roofs: the terrain under them is the host's `groundAt`).
+     */
+    staticTopAt(x, z, y, step) {
+      let top = -Infinity;
+      for (const a of this.staticNow().values()) {
+        if (a.length === 0 || x < a[0] || x > a[3] || z < a[2] || z > a[5]) continue;
+        for (let i = 6; i < a.length; i += 6) {
+          if (x < a[i] || x > a[i + 3] || z < a[i + 2] || z > a[i + 5]) continue;
+          const t = a[i + 4];
+          if (t > top && t <= y + step) top = t;
+        }
+      }
+      return top;
+    }
+    /** The boxes of the fixed objects (per object: the box around them all, then each one), each object measured again when an event touched it (all of them every `STATIC_REFRESH` s). */
+    staticNow() {
+      if (this.time - this.staticAt > STATIC_REFRESH) {
+        this.staticAt = this.time;
+        this.staticAll = true;
+      }
+      if (!this.staticAll && this.staticDirty.size === 0) return this.staticBoxes;
+      const box2 = new this.THREE.Box3();
+      const measure = (b) => {
+        if (b.piece || this.pieceSys.get(b.id)) {
+          this.staticBoxes.delete(b.id);
+          return;
+        }
+        const out = [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
+        for (const mv of this.meshesOf(b)) {
+          if (mv.host || mv.loose || !this.visuals.shown(mv)) continue;
+          this.visuals.worldBox(mv, box2);
+          if (box2.isEmpty() || box2.max.x - box2.min.x > STATIC_SPAN || box2.max.z - box2.min.z > STATIC_SPAN) continue;
+          this.visuals.fittedBoxes(mv, out);
+          for (let k = 0; k < 3; k++) {
+            out[k] = Math.min(out[k], box2.min.getComponent(k));
+            out[k + 3] = Math.max(out[k + 3], box2.max.getComponent(k));
+          }
+        }
+        this.staticBoxes.set(b.id, out.length > 6 ? out : []);
+      };
+      if (this.staticAll) {
+        this.staticBoxes.clear();
+        for (const b of this.bounds.values()) measure(b);
+      } else {
+        for (const id of this.staticDirty) {
+          const b = this.bounds.get(id);
+          if (b) measure(b);
+          else this.staticBoxes.delete(id);
+        }
+      }
+      this.staticAll = false;
+      this.staticDirty.clear();
+      return this.staticBoxes;
+    }
+    /** The boxes of a piece's drawn meshes, measured once per frame. */
+    pieceBoxesOf(pc) {
+      const cached = this.pieceBoxes.get(pc);
+      if (cached && cached.at === this.time) return cached.boxes;
+      const boxes = [];
+      const b = this.bounds.get(pc.objectId);
+      if (b) {
+        for (const mv of this.meshesOf(b)) {
+          if (this.visuals.shown(mv)) this.visuals.fittedBoxes(mv, boxes);
+        }
+      }
+      this.pieceBoxes.set(pc, { at: this.time, boxes });
+      return boxes;
+    }
+    solidsNear(x, z, radius) {
+      const found = [];
+      const scan = (a, id, piece, from) => {
+        if (from > 0 && (a.length === 0 || x < a[0] - radius || x > a[3] + radius || z < a[2] - radius || z > a[5] + radius)) return;
+        for (let i = from; i < a.length; i += 6) {
+          if (x < a[i] - radius || x > a[i + 3] + radius || z < a[i + 2] - radius || z > a[i + 5] + radius) continue;
+          found.push({ objectId: id, min: [a[i], a[i + 1], a[i + 2]], max: [a[i + 3], a[i + 4], a[i + 5]], piece });
+        }
+      };
+      for (const [id, a] of this.staticNow()) scan(a, id, null, 6);
+      const c = this.v1;
+      for (const pc of this.pieceSys.list) {
+        if (pc.held) continue;
+        this.pieceSys.centerOf(pc, c);
+        const reach = Math.hypot(pc.halfExtents[0], pc.halfExtents[1], pc.halfExtents[2]) + radius;
+        if (Math.abs(c.x - x) > reach || Math.abs(c.z - z) > reach) continue;
+        scan(this.pieceBoxesOf(pc), pc.objectId, pc, 0);
+      }
+      this.fragments.solidsNear(x, z, radius, (home, min2, max2, loose) => found.push({ objectId: home, min: min2, max: max2, piece: null, loose }));
+      return found;
+    }
     apply(ev) {
+      this.staticDirty.add(ev.object);
       switch (ev.type) {
         case "damage":
           if (ev.damageType === "heat" || ev.damageType === "fire" || ev.damageType === "explosive") this.activate(ev.object, ev.part);
@@ -18565,7 +19111,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const def = pv ? this.world.materials.get(pv.material) : void 0;
       const color = (pv ? this.partColor(pv, def) : null) ?? fallbackColor(pv?.material ?? "", def);
       const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
-      for (const fr of ev.fragments) this.fragments.spawn(fr, this.fragments.materialFor(fr.material, fallbackColor(fr.material, def), false), ev.object, maxAlive);
+      for (const fr of ev.fragments) {
+        const fdef = this.world.materials.get(fr.material);
+        const tone2 = fr.inner && fdef?.visual?.innerColor !== void 0 ? fdef.visual.innerColor : fdef === def ? color : fallbackColor(fr.material, fdef);
+        this.fragments.spawn(fr, this.fragments.materialFor(fr.material, tone2, false), ev.object, maxAlive);
+      }
       if (!this.playEvent({ kind: "spall", material: this.impactMaterial(def) }, ev.center)) this.vfx.burst("dust", ev.center, [0, 1, 0], 6, 0.8, { color });
       this.sound(impactKey(def), ev.center, 0.7);
     }
@@ -18646,6 +19196,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         this.pieceSys.setCenter(old, center);
         old.mass = Math.max(0.05, this.massOf(objectId));
         old.sleeping = false;
+      } else if (kitOriginOf(b.root)?.kind === "furniture") {
+        this.makePiece(objectId);
+        this.tipIfTopHeavy(b);
       }
     }
     /** The renderer side of `splitGroup`: a new group holding the meshes of the new object, made a piece. */
@@ -18692,8 +19245,32 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       const piece = this.pieceSys.create(newId, group, half, center, this.massOf(newId), vel, ang);
       nb.piece = piece;
+      if (kitOriginOf(from.root)?.kind === "furniture") this.tipIfTopHeavy(nb);
       this.o.onPiece?.(piece);
     }
+    /**
+     * A piece of furniture standing on feet too close for its height (a board on two legs in a line, a lone leg) does not stay up: the box of a piece hides that its weight is up
+     * high and its feet are thin, so it gets the start of the fall, across the line of its feet.
+     */
+    tipIfTopHeavy(b) {
+      const piece = b.piece;
+      if (!piece) return;
+      const box2 = new this.THREE.Box3();
+      const boxes = this.meshesOf(b).filter((mv) => this.visuals.shown(mv)).map((mv) => this.visuals.worldBox(mv, new this.THREE.Box3()));
+      if (boxes.length === 0) return;
+      for (const one of boxes) box2.union(one);
+      const height = box2.max.y - box2.min.y;
+      const feet = new this.THREE.Box3();
+      for (const one of boxes) if (one.min.y < box2.min.y + FEET_BAND) feet.union(one);
+      const spanX = feet.max.x - feet.min.x;
+      const spanZ = feet.max.z - feet.min.z;
+      if (height < TIP_MIN_HEIGHT || Math.min(spanX, spanZ) >= TIP_NARROW * height) return;
+      const across = spanX <= spanZ ? 0 : 2;
+      const lean = across === 0 ? box2.min.x + box2.max.x - feet.min.x - feet.max.x : box2.min.z + box2.max.z - feet.min.z - feet.max.z;
+      const away = lean < 0 ? -1 : 1;
+      if (across === 0) this.pieceSys.tip(piece, 0, -away);
+      else this.pieceSys.tip(piece, away, 0);
+    }
     onExplode(ev, options = {}) {
       const p = ev.point;
       if (options.visual !== false) this.playExplosion(ev, options);
@@ -18944,6 +19521,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.vfx.sprites().clear();
       this.ownVfx?.world.clear();
     }
+    wakeRegion(x, z, radius) {
+      this.fragments.wakeRegion(x, z, radius);
+      this.pieceSys.wakeRegion(x, z, radius);
+    }
     stats() {
       return { fragments: this.fragments.count, particles: this.vfx.sprites().live + this.ownedVfxParticles(), pieces: this.pieceSys.list.length, decals: this.visuals.decalCount + this.ground.count };
     }
@@ -19054,7 +19635,15 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     volume: 0,
     sources: ["cena:L1316 fire loop (silent in the page: its gain is never raised)", "sdk: the level while burning"]
   };
-  var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, EXPLOSION_BOOM], loops: [BURN_LOOP] };
+  var drag = (id, layers) => ({ ...sceneRecipe(id, layers, ""), sources: ["sdk: a base dragged on a floor, one grain per stretch"] });
+  var DRAG_SOUNDS = [
+    drag("drag_wood", [sceneNoise({ type: "bandpass", f: 380, q: 1.4, d: 0.28, vol: 0.5 }), sceneNoise({ type: "bandpass", f: [900, 1300], q: 3, d: 0.08, vol: 0.14 })]),
+    drag("drag_metal", [sceneNoise({ type: "bandpass", f: 1500, q: 4, d: 0.26, vol: 0.32 }), sceneTone({ f: [880, 1240], f2: 760, d: 0.18, vol: 0.05 })]),
+    drag("drag_glass", [sceneNoise({ type: "bandpass", f: 2600, q: 5, d: 0.2, vol: 0.22 })]),
+    drag("drag_masonry", [sceneNoise({ type: "bandpass", f: 260, q: 0.9, d: 0.3, vol: 0.62 }), ...sceneMany(3, () => sceneNoise({ type: "bandpass", f: [600, 1200], q: 2, d: 0.04, vol: 0.14, delay: [0, 0.2] }))]),
+    drag("drag_soft", [sceneNoise({ type: "lowpass", f: 420, d: 0.28, vol: 0.3 })])
+  ];
+  var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, ...DRAG_SOUNDS, EXPLOSION_BOOM], loops: [BURN_LOOP] };
   var DESTRUCTION_SOUND_KEYS = {
     art_scene: {
       impact_metal: { sound: "clang" },
@@ -19062,6 +19651,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       impact_glass: { sound: "ping" },
       impact_masonry: { sound: "chip" },
       impact_soft: { sound: "thud" },
+      drag_wood: { sound: "drag_wood" },
+      drag_metal: { sound: "drag_metal" },
+      drag_glass: { sound: "drag_glass" },
+      drag_masonry: { sound: "drag_masonry" },
+      drag_soft: { sound: "drag_soft" },
       shatter_glass: { sound: "glass_shatter" },
       crumble: { sound: "crumble" },
       splinter: { sound: "crack" },
@@ -32987,9 +33581,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const speed = load && load.speed !== cal.muzzleSpeed ? weaponSpeed(a, cal) * (load.speed / cal.muzzleSpeed) : weaponSpeed(a, cal);
       const grams = load ? load.grams : cal.bulletGrams;
       const energy = 0.5 * (grams / 1e3) * speed * speed;
-      const drag = cal.dragPer100m ?? 0.1;
+      const drag2 = cal.dragPer100m ?? 0.1;
       const energyAt = (distance22) => {
-        const f = Math.pow(1 - drag, Math.max(0, distance22) / 100);
+        const f = Math.pow(1 - drag2, Math.max(0, distance22) / 100);
         return energy * f * f;
       };
       const bloomNow = this.extraAt(t);
@@ -35734,10 +36328,10 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
           previous[1] = position[offset + 1];
           previous[2] = position[offset + 2];
           velocity[offset + 1] -= GRAVITY23 * dt;
-          const drag = 1 - dt * AIR_DRAG;
-          velocity[offset] *= drag;
-          velocity[offset + 1] *= drag;
-          velocity[offset + 2] *= drag;
+          const drag2 = 1 - dt * AIR_DRAG;
+          velocity[offset] *= drag2;
+          velocity[offset + 1] *= drag2;
+          velocity[offset + 2] *= drag2;
           point[0] = position[offset] + velocity[offset] * dt;
           point[1] = position[offset + 1] + velocity[offset + 1] * dt;
           point[2] = position[offset + 2] + velocity[offset + 2] * dt;
@@ -35966,12 +36560,12 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   }
   function updateDrags(drags, context, layout, launch, dt) {
     const random = context.random;
-    for (const drag of drags) {
-      if (drag.done) continue;
-      drag.elapsed += dt;
-      const progress = Math.min(1, drag.elapsed / drag.duration);
-      const here = drag.path(progress);
-      const ahead = drag.path(Math.min(1, progress + 0.01));
+    for (const drag2 of drags) {
+      if (drag2.done) continue;
+      drag2.elapsed += dt;
+      const progress = Math.min(1, drag2.elapsed / drag2.duration);
+      const here = drag2.path(progress);
+      const ahead = drag2.path(Math.min(1, progress + 0.01));
       let directionColumn = ahead.column - here.column;
       let directionRow = ahead.row - here.row;
       const length22 = Math.hypot(directionColumn, directionRow) || 1;
@@ -35980,24 +36574,24 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       const sideColumn = -directionRow;
       const sideRow = directionColumn;
       const load = Math.pow(1 - progress, 1.3);
-      for (let offset = -drag.width; offset <= drag.width; offset += 0.5) {
-        const across = offset / drag.width;
-        const stripe = drag.stripes[Math.round((offset + drag.width) * 2)];
+      for (let offset = -drag2.width; offset <= drag2.width; offset += 0.5) {
+        const across = offset / drag2.width;
+        const stripe = drag2.stripes[Math.round((offset + drag2.width) * 2)];
         const edge = 1 - across * across;
-        const amount = drag.amount * load * (0.25 + 0.75 * stripe) * edge;
+        const amount = drag2.amount * load * (0.25 + 0.75 * stripe) * edge;
         if (load < 0.45 && random() > load * 2.2) continue;
         depositCell(context, Math.round(here.row + sideRow * offset), Math.round(here.column + sideColumn * offset), amount * dt * 30);
       }
-      if (drag.hand && random() < dt * 14 * load + 0.02) {
+      if (drag2.hand && random() < dt * 14 * load + 0.02) {
         const world = layout.cellToWorld(here.row, here.column);
-        const origin = [world[0] + (random() - 0.5) * 0.06, drag.hand.height + random() * 0.3, world[2] + (random() - 0.5) * 0.06];
-        const velocity = [directionColumn * drag.hand.speed, 0 * drag.hand.speed, directionRow * drag.hand.speed];
+        const origin = [world[0] + (random() - 0.5) * 0.06, drag2.hand.height + random() * 0.3, world[2] + (random() - 0.5) * 0.06];
+        const velocity = [directionColumn * drag2.hand.speed, 0 * drag2.hand.speed, directionRow * drag2.hand.speed];
         velocity[0] += (random() - 0.5) * 0.3;
         velocity[1] += 0.2;
         velocity[2] += (random() - 0.5) * 0.3;
         launch(origin, velocity, 2 + random() * 2.2);
       }
-      if (progress >= 1) drag.done = true;
+      if (progress >= 1) drag2.done = true;
     }
   }
   var DEFAULT_STEP_RATE = 180;
@@ -36676,6 +37270,12 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     return count;
   };
   var INSET = 0.985;
+  var narrowMouth = (state) => {
+    const shape = state.shape;
+    if (!shape || state.lipRadius === void 0) return false;
+    const inner = shape.kind === "cylinder" ? shape.radius : Math.min(shape.size[0], shape.size[2]) / 2;
+    return state.lipRadius < inner * 0.5;
+  };
   var LiquidBody = class {
     constructor(THREE, containerId, object, offset) {
       __publicField5(this, "THREE", THREE);
@@ -36738,7 +37338,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         this.vertices = 0;
         return;
       }
-      if (state.closed && this.isShellOpaque()) {
+      if ((state.closed || narrowMouth(state)) && this.isShellOpaque()) {
         if (this.mesh) this.mesh.visible = false;
         this.vertices = 0;
         return;
@@ -36768,12 +37368,15 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         }
       } else this.steamAcc = 0;
     }
-    /** Every mesh of the bound object (the liquid itself aside) is drawn with an opaque material. */
+    /**
+     * Every mesh of the bound object (the liquid itself aside) is drawn with an opaque material. The marks drawn on its surface (bullet holes, scorches: the
+     * `userData.destructionDebris` meshes of `game-destruction-three`) are see-through discs on the shell, not windows into it.
+     */
     isShellOpaque() {
       let opaque = true;
       this.object.traverse((child) => {
         const mesh2 = child;
-        if (!opaque || !mesh2.isMesh || child === this.mesh) return;
+        if (!opaque || !mesh2.isMesh || child === this.mesh || child.userData?.destructionDebris === true) return;
         const materials = Array.isArray(mesh2.material) ? mesh2.material : [mesh2.material];
         if (materials.some((material) => material.transparent || material.opacity < 1)) opaque = false;
       });
@@ -37815,7 +38418,7 @@ void main(){
       this.film.update({ dt, dryingSeconds });
       const bounds = this.film.simulator.bounds;
       const launched = this.film.drops.launched;
-      const busy = launched !== this.launched || this.film.drip !== void 0 || this.film.sources.length > 0 || this.film.drags.some((drag) => !drag.done) || this.dropsInFlight();
+      const busy = launched !== this.launched || this.film.drip !== void 0 || this.film.sources.length > 0 || this.film.drags.some((drag2) => !drag2.done) || this.dropsInFlight();
       this.launched = launched;
       const current = bounds.lastRow < 0 ? null : { firstRow: bounds.firstRow, lastRow: bounds.lastRow, firstColumn: bounds.firstColumn, lastColumn: bounds.lastColumn };
       const rect = this.union(this.previous, current);
@@ -38384,14 +38987,6 @@ void main(){
     sc.far = 40;
     sun.shadow.bias = -6e-4;
     group.add(sun);
-    const floor2 = new THREE.Mesh(new THREE.PlaneGeometry(size * 2, size * 2), new THREE.MeshStandardMaterial({ color: 9342602, roughness: 0.95 }));
-    floor2.rotation.x = -Math.PI / 2;
-    floor2.receiveShadow = true;
-    floor2.name = "floor";
-    group.add(floor2);
-    const grid = new THREE.GridHelper(size * 2, size * 2, 5000274, 7829371);
-    grid.position.y = 4e-3;
-    group.add(grid);
     const sceneryObjects = resolveScenery(scenery);
     const wallObject = sceneryObjects.find((o) => o.id === WALL_ID);
     const wallZ = wallObject ? wallObject.position[2] : DEFAULT_WALL_Z;
@@ -38430,16 +39025,23 @@ void main(){
     const surfaces = [{ id: "floor", point: [0, 0, 0], normal: [0, 1, 0], halfSize: [size, size], porosity: 0.05 }];
     for (const o of sceneryObjects) {
       if (!o.top) continue;
-      const b = specBounds(THREE, o.spec, o.position, o.rotationY, { onlyPart: o.top.part });
-      if (!b) continue;
+      const boards = (o.top.parts ?? []).flatMap((part) => {
+        const f = specBounds(THREE, o.spec, o.position, o.rotationY, { onlyPart: part });
+        return f ? [{ part, minX: f.minX, maxX: f.maxX, minZ: f.minZ, maxZ: f.maxZ }] : [];
+      });
+      const whole = specBounds(THREE, o.spec, o.position, o.rotationY, { onlyPart: o.top.part });
+      if (!whole) continue;
+      const b = boards.length === 0 ? whole : { minX: Math.min(...boards.map((f) => f.minX)), maxX: Math.max(...boards.map((f) => f.maxX)), minZ: Math.min(...boards.map((f) => f.minZ)), maxZ: Math.max(...boards.map((f) => f.maxZ)) };
       const top = o.position[1] + o.top.y;
-      tops.push({ id: o.id, topPart: o.top.part, minX: b.minX, maxX: b.maxX, minZ: b.minZ, maxZ: b.maxZ, top });
+      tops.push({ id: o.id, topPart: o.top.part, minX: b.minX, maxX: b.maxX, minZ: b.minZ, maxZ: b.maxZ, top, ...boards.length > 0 ? { boards } : {} });
       surfaces.push({ id: o.id, point: [(b.minX + b.maxX) / 2, top, (b.minZ + b.maxZ) / 2], normal: [0, 1, 0], halfSize: [(b.maxX - b.minX) / 2, (b.maxZ - b.minZ) / 2], porosity: 0.3 });
     }
     const colliders = [];
+    const colliderIds = [];
     for (const o of sceneryObjects) {
       const b = specBounds(THREE, o.spec, o.position, o.rotationY, { minHeight: 0.1 });
       if (!b) continue;
+      colliderIds.push(o.id);
       colliders.push(o.id === WALL_ID ? [-size, b.minZ - 1, size, b.maxZ + 0.1] : [b.minX, b.minZ, b.maxX, b.maxZ]);
     }
     let tapSpout = null;
@@ -38480,6 +39082,7 @@ void main(){
         }
         tapSpout = [cx + 0.3, y + 0.5, cz];
         colliders.push([postX - 0.05, cz - 0.1, postX + 0.05, cz + 0.1]);
+        colliderIds.push(null);
       }
     }
     return {
@@ -38487,6 +39090,7 @@ void main(){
       objects: sceneryObjects,
       surfaces,
       colliders,
+      colliderIds,
       playerStart,
       wallZ,
       tops,
@@ -40132,13 +40736,19 @@ void main(){
   // src/player.ts
   var EYE = 1.7;
   var PLAYER_RADIUS = 0.3;
+  var FOOT = 0.5;
   var WALK = 3.4;
   var CROUCH_DROP = 0.55;
   var CROUCH_WALK = 1.7;
   var CROUCH_RATE = 9;
+  var BEND_RATE = 7;
+  var CLEAR_SHARES = [1, 0.75, 0.5, 0.25];
+  var CROUCH_TAP = 0.25;
   var RUN = 6.2;
   var JUMP = 4.6;
   var GRAVITY4 = 13;
+  var FLOOR_CLIMB_SPEED = 3;
+  var FLOOR_FALL_SPEED = 6;
   var LOOK = 22e-4;
   function createPlayer(THREE, o) {
     const cam = o.camera;
@@ -40147,6 +40757,8 @@ void main(){
     let y = 0;
     let eye = EYE;
     let crouch = 0;
+    let bend = 0;
+    let bendTarget = 0;
     let vy2 = 0;
     let walked = 0;
     let running = false;
@@ -40155,33 +40767,79 @@ void main(){
     const keys = /* @__PURE__ */ new Set();
     const crouchKeys = o.crouchKeys ?? ["KeyC"];
     const isCrouchHeld = () => crouchKeys.some((code) => keys.has(code));
+    let crouchLatched = false;
+    let crouchPress = null;
+    const isCrouched = () => crouchLatched || isCrouchHeld();
+    const pressCrouch = (code) => {
+      if (crouchKeys.includes(code) && !isCrouchHeld()) crouchPress = { held: 0, latched: crouchLatched };
+    };
+    const releaseCrouch = (code) => {
+      if (!crouchKeys.includes(code) || !crouchPress || isCrouchHeld()) return;
+      crouchLatched = crouchPress.held < CROUCH_TAP ? !crouchPress.latched : false;
+      crouchPress = null;
+    };
     const euler = new THREE.Euler(0, 0, 0, "YXZ");
+    const floorHere = () => o.floorAt?.(px.x, px.z) ?? 0;
+    let floorLevel = 0;
+    const followFloor = (dt) => {
+      const gap = floorHere() - floorLevel;
+      const reach = (gap > 0 ? FLOOR_CLIMB_SPEED : FLOOR_FALL_SPEED) * dt;
+      floorLevel += Math.max(-reach, Math.min(reach, gap));
+    };
     const apply = () => {
       euler.set(pitch, yaw, 0, "YXZ");
       cam.quaternion.setFromEuler(euler);
-      cam.position.set(px.x, eye + y - CROUCH_DROP * crouch, px.z);
+      cam.position.set(px.x, eye + floorLevel + y - CROUCH_DROP * crouch - bend, px.z);
       cam.updateMatrixWorld(true);
     };
     apply();
-    const blocked = (x, z) => {
-      if (Math.abs(x) > o.limit - PLAYER_RADIUS || Math.abs(z) > o.limit - PLAYER_RADIUS) return true;
-      for (const c of o.colliders) if (x > c[0] - PLAYER_RADIUS && x < c[2] + PLAYER_RADIUS && z > c[1] - PLAYER_RADIUS && z < c[3] + PLAYER_RADIUS) return true;
+    const outside = (x, z) => Math.abs(x) > o.limit - PLAYER_RADIUS || Math.abs(z) > o.limit - PLAYER_RADIUS;
+    const blocked = (x, z, radius = PLAYER_RADIUS) => {
+      if (outside(x, z)) return true;
+      for (const c of o.colliders) if (x > c[0] - radius && x < c[2] + radius && z > c[1] - radius && z < c[3] + radius) return true;
       if (o.blockers) {
-        for (const blocked2 of o.blockers) if (blocked2(x, z, PLAYER_RADIUS)) return true;
+        for (const isBlocked2 of o.blockers) if (isBlocked2(x, z, radius)) return true;
       }
-      return false;
+      return o.footing ? o.footing(x, z, radius, y).blocked : false;
+    };
+    const clearRadius = () => {
+      for (const share of CLEAR_SHARES) if (!blocked(px.x, px.z, PLAYER_RADIUS * share)) return PLAYER_RADIUS * share;
+      return null;
     };
+    const wish = { x: 0, z: 0 };
     const move = (dx, dz) => {
-      if (!blocked(px.x + dx, px.z)) px.x += dx;
-      if (!blocked(px.x, px.z + dz)) px.z += dz;
+      wish.x += dx;
+      wish.z += dz;
+      const radius = clearRadius();
+      const free = (x, z) => radius === null ? !outside(x, z) : !blocked(x, z, radius);
+      const steps = Math.max(1, Math.ceil(Math.hypot(dx, dz) / (PLAYER_RADIUS / 3)));
+      const sx = dx / steps;
+      const sz = dz / steps;
+      for (let i = 0; i < steps; i++) {
+        if (free(px.x + sx, px.z)) px.x += sx;
+        if (free(px.x, px.z + sz)) px.z += sz;
+      }
+    };
+    const walkKeys = () => {
+      const f = (keys.has("KeyW") || keys.has("ArrowUp") ? 1 : 0) - (keys.has("KeyS") || keys.has("ArrowDown") ? 1 : 0);
+      const r = (keys.has("KeyD") || keys.has("ArrowRight") ? 1 : 0) - (keys.has("KeyA") || keys.has("ArrowLeft") ? 1 : 0);
+      if (!f && !r) return [0, 0];
+      const len = Math.hypot(f, r);
+      return [(-Math.sin(yaw) * f + Math.cos(yaw) * r) / len, (-Math.cos(yaw) * f - Math.sin(yaw) * r) / len];
     };
     let dragging = false;
     let moved = 0;
     let downAt = 0;
     let useStarted = false;
     let holdTimer = null;
+    let walkHeld = false;
+    let lookLimit = null;
     const look = (dx, dy) => {
       yaw -= dx * LOOK;
+      if (lookLimit) {
+        const off = Math.atan2(Math.sin(yaw - lookLimit.yaw), Math.cos(yaw - lookLimit.yaw));
+        yaw = lookLimit.yaw + Math.max(-lookLimit.range, Math.min(lookLimit.range, off));
+      }
       pitch = Math.max(-1.5, Math.min(1.5, pitch - dy * LOOK));
     };
     const onLockChange = () => {
@@ -40273,16 +40931,23 @@ void main(){
       if (isControlHeld || e.altKey && locked) {
         if (!/^F\d+$/.test(e.code)) e.preventDefault();
       }
-      if (!e.repeat) keys.add(e.code);
+      if (!e.repeat) {
+        pressCrouch(e.code);
+        keys.add(e.code);
+      }
       o.hooks.key(e.code, true, e);
     };
     const onKeyUp = (e) => {
       keys.delete(e.code);
+      releaseCrouch(e.code);
       if (typing(e)) return;
       o.hooks.key(e.code, false, e);
     };
     const onContext = (e) => e.preventDefault();
-    const onBlur = () => keys.clear();
+    const onBlur = () => {
+      keys.clear();
+      crouchPress = null;
+    };
     const onBeforeUnload = (e) => {
       if (!locked && !keys.has("ControlLeft") && !keys.has("ControlRight")) return;
       e.preventDefault();
@@ -40299,6 +40964,21 @@ void main(){
     window.addEventListener("blur", onBlur);
     window.addEventListener("beforeunload", onBeforeUnload);
     return {
+      get walkIntent() {
+        return walkKeys();
+      },
+      canStand(x, z) {
+        return !blocked(x, z);
+      },
+      setWalkHeld(held) {
+        walkHeld = held;
+      },
+      setBend(metres) {
+        bendTarget = metres;
+      },
+      setLookLimit(limit) {
+        lookLimit = limit;
+      },
       get yaw() {
         return yaw;
       },
@@ -40315,10 +40995,10 @@ void main(){
         return px.z;
       },
       get feet() {
-        return y;
+        return floorLevel + y;
       },
       get position() {
-        return [px.x, y, px.z];
+        return [px.x, floorLevel + y, px.z];
       },
       get speed() {
         return walked;
@@ -40327,49 +41007,43 @@ void main(){
         return running;
       },
       get crouching() {
-        return isCrouchHeld();
+        return isCrouched();
       },
       keys,
       update(dt) {
-        const crouched = isCrouchHeld();
+        if (crouchPress) crouchPress.held += dt;
+        const crouched = isCrouched();
         crouch += ((crouched ? 1 : 0) - crouch) * Math.min(1, dt * CROUCH_RATE);
         if (!crouched && crouch < 1e-3) crouch = 0;
-        const run = !crouched && (keys.has("ShiftLeft") || keys.has("ShiftRight"));
+        bend += (bendTarget - bend) * Math.min(1, dt * BEND_RATE);
+        const run = !crouched && !walkHeld && (keys.has("ShiftLeft") || keys.has("ShiftRight"));
         const fromX = px.x;
         const fromZ = px.z;
         const speed = crouched ? CROUCH_WALK : run ? RUN : WALK;
-        let f = 0;
-        let r = 0;
-        if (keys.has("KeyW") || keys.has("ArrowUp")) f += 1;
-        if (keys.has("KeyS") || keys.has("ArrowDown")) f -= 1;
-        if (keys.has("KeyD") || keys.has("ArrowRight")) r += 1;
-        if (keys.has("KeyA") || keys.has("ArrowLeft")) r -= 1;
-        if ((f || r || keys.has("Space")) && eye !== EYE) eye = EYE;
-        if (f || r) {
-          const len = Math.hypot(f, r);
-          const fx = -Math.sin(yaw);
-          const fz = -Math.cos(yaw);
-          const rx = Math.cos(yaw);
-          const rz = -Math.sin(yaw);
-          move((fx * f + rx * r) / len * speed * dt, (fz * f + rz * r) / len * speed * dt);
-        }
+        const [walkX, walkZ] = walkKeys();
+        if ((walkX || walkZ || keys.has("Space")) && eye !== EYE) eye = EYE;
+        if ((walkX || walkZ) && !walkHeld) move(walkX * speed * dt, walkZ * speed * dt);
         walked = dt > 0 ? Math.hypot(px.x - fromX, px.z - fromZ) / dt : 0;
         running = run && walked > 0;
-        if (y <= 0 && keys.has("Space")) vy2 = JUMP;
-        if (y > 0 || vy2 > 0) {
+        const floor2 = Math.max(floorHere(), o.footing?.(px.x, px.z, PLAYER_RADIUS * FOOT, y).floor ?? -Infinity);
+        if (y < floor2 && vy2 <= 0) y = floor2;
+        if (y <= floor2 && keys.has("Space") && !walkHeld) vy2 = JUMP;
+        if (y > floor2 || vy2 > 0) {
           vy2 -= GRAVITY4 * dt;
           y += vy2 * dt;
-          if (y <= 0) {
-            y = 0;
+          if (y <= floor2) {
+            y = floor2;
             vy2 = 0;
           }
         }
+        followFloor(dt);
         apply();
       },
       setPose(position, yw, pt2) {
         px.x = position[0];
         px.z = position[2];
-        eye = position[1];
+        floorLevel = floorHere();
+        eye = position[1] - floorLevel;
         y = 0;
         vy2 = 0;
         yaw = yw;
@@ -40379,7 +41053,8 @@ void main(){
       look(position, target) {
         px.x = position[0];
         px.z = position[2];
-        eye = position[1];
+        floorLevel = floorHere();
+        eye = position[1] - floorLevel;
         y = 0;
         vy2 = 0;
         const dx = target[0] - position[0];
@@ -40398,6 +41073,12 @@ void main(){
         move(dx, dz);
         apply();
       },
+      takeWish() {
+        const out = [wish.x, wish.z];
+        wish.x = 0;
+        wish.z = 0;
+        return out;
+      },
       walk(forward, right) {
         move(-Math.sin(yaw) * forward + Math.cos(yaw) * right, -Math.cos(yaw) * forward - Math.sin(yaw) * right);
         apply();
@@ -40419,6 +41100,1882 @@ void main(){
     };
   }
 
+  // ../game-player/dist/index.js
+  var FURNITURE_PUSH_DEFAULTS = {
+    forceN: 500,
+    gravity: 9.81,
+    frictionByMaterial: { wood_soft: 0.4, wood_hard: 0.4, mdf: 0.4, plywood: 0.4, steel: 0.35, aluminium: 0.35, cast_iron: 0.4, copper: 0.35, plastic: 0.35, rubber: 0.8, fabric: 0.45, foam: 0.5, ceramic: 0.5, glass: 0.3, tempered_glass: 0.3, brick: 0.6, concrete: 0.65 },
+    defaultFriction: 0.45,
+    gripSeconds: { base: 0.4, perKg: 0.015, max: 2.5 },
+    speed: { max: 1.8, min: 0.35 },
+    tapSeconds: 0.2,
+    strainHoldSeconds: 0.25
+  };
+  var frictionOf = (target, rules) => (target.material !== void 0 ? rules.frictionByMaterial[target.material] : void 0) ?? rules.defaultFriction;
+  var loadShare = (target, rules) => frictionOf(target, rules) * target.massKg * rules.gravity / rules.forceN;
+  var gripSecondsFor = (massKg, rules = FURNITURE_PUSH_DEFAULTS) => Math.min(rules.gripSeconds.max, rules.gripSeconds.base + rules.gripSeconds.perKg * Math.max(0, massKg));
+  var canPush = (target, rules = FURNITURE_PUSH_DEFAULTS) => loadShare(target, rules) <= 1;
+  var pushSpeedFor = (target, rules = FURNITURE_PUSH_DEFAULTS) => {
+    const share = loadShare(target, rules);
+    return share > 1 ? 0 : rules.speed.max + (rules.speed.min - rules.speed.max) * share;
+  };
+  var STILL = { dx: 0, dz: 0, engaged: false, hitObstacle: false };
+  function createFurniturePush(overrides = {}) {
+    const rules = { ...FURNITURE_PUSH_DEFAULTS, ...overrides };
+    let phase = "idle";
+    let target = { massKg: 0 };
+    let held = 0;
+    let gripSeconds = 1;
+    let speed = 0;
+    let block = null;
+    let refused = 0;
+    let wasRefused = false;
+    const walkWith = (dt, input) => {
+      refused = Math.max(0, refused - dt);
+      if (block === "too_heavy") return STILL;
+      const [x, z] = input.walk;
+      if (x === 0 && z === 0 || dt <= 0) {
+        if (refused === 0) {
+          phase = "push";
+          block = null;
+          wasRefused = false;
+        }
+        return STILL;
+      }
+      const dx = x * speed * dt;
+      const dz = z * speed * dt;
+      if (input.isFree(dx, dz)) {
+        if (refused === 0) {
+          phase = "push";
+          block = null;
+        }
+        wasRefused = false;
+        return { dx, dz, engaged: false, hitObstacle: false };
+      }
+      const hitObstacle = !wasRefused;
+      wasRefused = true;
+      refused = rules.strainHoldSeconds;
+      phase = "strain";
+      block = "obstacle";
+      return { dx: 0, dz: 0, engaged: false, hitObstacle };
+    };
+    return {
+      get phase() {
+        return phase;
+      },
+      get progress() {
+        return phase === "idle" ? 0 : Math.min(1, held / gripSeconds);
+      },
+      get block() {
+        return block;
+      },
+      get heldSeconds() {
+        return held;
+      },
+      get isTap() {
+        return phase === "grip" && held < rules.tapSeconds;
+      },
+      begin(next) {
+        target = next;
+        phase = "grip";
+        held = 0;
+        block = null;
+        refused = 0;
+        wasRefused = false;
+        gripSeconds = gripSecondsFor(next.massKg, rules);
+        speed = pushSpeedFor(next, rules);
+      },
+      release() {
+        phase = "idle";
+        held = 0;
+        block = null;
+      },
+      update(dt, input) {
+        if (phase === "idle") return STILL;
+        held += dt;
+        if (phase !== "grip") return walkWith(dt, input);
+        if (held < gripSeconds) return STILL;
+        if (canPush(target, rules)) phase = "push";
+        else {
+          phase = "strain";
+          block = "too_heavy";
+        }
+        return { ...STILL, engaged: true };
+      }
+    };
+  }
+  var FRAME = 1 / 30;
+
+  // src/furniture-push.ts
+  var PUSH_REACH = 1.1;
+  var STANDOFF = 0.58;
+  var LOW_TOP = 0.95;
+  var LOW_STANDOFF = 0.42;
+  var LOW_HAND_ON_TOP = 0.07;
+  var LOW_EYE_OVER_TOP = 0.62;
+  var MAX_BEND = 0.8;
+  var STANDING_EYE = 1.7;
+  var APPROACH_SPEED = 1.2;
+  var MAX_BASE_HEIGHT = 0.12;
+  var FLOOR_CLEARANCE = 0.06;
+  var SWEEP_SKIN = 0.015;
+  var HAND_SPREAD = 0.2;
+  var HAND_TOP = 1.35;
+  var HAND_UNDER_TOP = 0.05;
+  var LOOK_RANGE = 0.9;
+  var DRAG_GRAIN_METRES = 0.3;
+  var RING_DELAY_S = 0.1;
+  function contactOf(box2, player) {
+    const x = Math.max(box2.min[0] ?? 0, Math.min(box2.max[0] ?? 0, player.x));
+    const z = Math.max(box2.min[2] ?? 0, Math.min(box2.max[2] ?? 0, player.z));
+    const dx = x - player.x;
+    const dz = z - player.z;
+    const distance4 = Math.hypot(dx, dz);
+    if (distance4 < 1e-3) return { contact: [x, z], into: [-Math.sin(player.yaw), -Math.cos(player.yaw)], distance: 0 };
+    return { contact: [x, z], into: [dx / distance4, dz / distance4], distance: distance4 };
+  }
+  function createRoomPush(options) {
+    const { THREE, player, world, arena, blockers } = options;
+    const control = createFurniturePush(options.rules);
+    const box3 = new THREE.Box3();
+    let leaning = null;
+    let scriptedWalk = null;
+    let dragged = 0;
+    const event = (type, lean) => options.onEvent({ type, objectId: lean.target.objectId, name: lean.target.name, massKg: lean.massKg });
+    const standsClear = (lean, dx, dz) => {
+      const minX = lean.min[0] + dx;
+      const maxX = lean.max[0] + dx;
+      const minZ = lean.min[2] + dz;
+      const maxZ = lean.max[2] + dz;
+      if (Math.max(Math.abs(minX), Math.abs(maxX)) > arena.limit || Math.max(Math.abs(minZ), Math.abs(maxZ)) > arena.limit) return false;
+      for (const c of arena.colliders) {
+        if (lean.max[0] > c[0] && lean.min[0] < c[2] && lean.max[2] > c[1] && lean.min[2] < c[3]) continue;
+        if (maxX > c[0] && minX < c[2] && maxZ > c[1] && minZ < c[3]) return false;
+      }
+      if (blockers.size === 0) return true;
+      const midX = (minX + maxX) / 2;
+      const midZ = (minZ + maxZ) / 2;
+      for (const [x, z] of [[minX, minZ], [maxX, minZ], [minX, maxZ], [maxX, maxZ], [midX, minZ], [midX, maxZ], [minX, midZ], [maxX, midZ]]) {
+        for (const isBlocked2 of blockers) if (isBlocked2(x, z, 0)) return false;
+      }
+      return true;
+    };
+    const isFree = (lean, dx, dz) => {
+      if (!standsClear(lean, dx, dz) || !player.canStand(player.x + dx, player.z + dz)) return false;
+      const distance4 = Math.hypot(dx, dz);
+      const box2 = { min: [lean.min[0], lean.min[1] + FLOOR_CLEARANCE, lean.min[2]], max: [lean.max[0], lean.max[1], lean.max[2]] };
+      return world.sweepBox(box2, [dx / distance4, 0, dz / distance4], distance4 + SWEEP_SKIN, { ignore: lean.target.objectId }) === null;
+    };
+    const release = () => {
+      const lean = leaning;
+      if (!lean) return;
+      leaning = null;
+      if (lean.piece) {
+        lean.piece.held = false;
+        lean.piece.sleeping = false;
+        lean.piece.velocity = [0, 0, 0];
+      }
+      control.release();
+      player.setWalkHeld(false);
+      player.setBend(0);
+      player.setLookLimit(null);
+      options.ring(null);
+      event("release", lean);
+    };
+    const approach = (lean, dt) => {
+      const off = Math.hypot(lean.contact[0] - player.x, lean.contact[1] - player.z) - (lean.isLow ? LOW_STANDOFF : STANDOFF);
+      const move = Math.sign(off) * Math.min(Math.abs(off), APPROACH_SPEED * dt);
+      if (move !== 0) player.moveBy(lean.into[0] * move, lean.into[1] * move);
+    };
+    const moveWith = (lean, dx, dz) => {
+      lean.target.root.position.x += dx;
+      lean.target.root.position.z += dz;
+      lean.target.root.updateMatrixWorld(true);
+      player.moveBy(dx, dz);
+      lean.min[0] += dx;
+      lean.max[0] += dx;
+      lean.min[2] += dz;
+      lean.max[2] += dz;
+      lean.contact[0] += dx;
+      lean.contact[1] += dz;
+      dragged += Math.hypot(dx, dz);
+      if (dragged < DRAG_GRAIN_METRES) return;
+      dragged = 0;
+      options.dragSound(lean.target.objectId, [lean.contact[0], lean.min[1], lean.contact[1]], 0.3 + 0.5 * Math.min(1, lean.massKg / 100));
+    };
+    return {
+      get active() {
+        return leaning !== null;
+      },
+      get state() {
+        return leaning ? { objectId: leaning.target.objectId, phase: control.phase, progress: control.progress, block: control.block, massKg: leaning.massKg } : null;
+      },
+      get isBent() {
+        return leaning?.isLow ?? false;
+      },
+      get avatarState() {
+        return leaning && control.phase !== "idle" ? { phase: control.phase, progress: control.progress } : null;
+      },
+      begin() {
+        if (leaning) return true;
+        const target = options.pick();
+        if (!target || !world.has(target.objectId)) return false;
+        box3.setFromObject(target.root);
+        if (box3.min.y > player.feet + MAX_BASE_HEIGHT) return false;
+        const min2 = [box3.min.x, box3.min.y, box3.min.z];
+        const max2 = [box3.max.x, box3.max.y, box3.max.z];
+        const { contact, into, distance: distance4 } = contactOf({ min: min2, max: max2 }, player);
+        if (distance4 > PUSH_REACH) return false;
+        const massKg = options.massOf(target.objectId);
+        const material = options.materialOf(target.objectId);
+        const isLow = max2[1] - player.feet < LOW_TOP;
+        const side = new THREE.Vector3(-into[1], 0, into[0]);
+        const way = new THREE.Vector3(into[0], 0, into[1]);
+        const up = new THREE.Vector3(0, 1, 0);
+        const basis = isLow ? new THREE.Matrix4().makeBasis(way, up, side) : new THREE.Matrix4().makeBasis(up, way.clone().negate(), side);
+        const palm = new THREE.Quaternion().setFromRotationMatrix(basis);
+        leaning = { target, massKg, piece: target.piece, min: min2, max: max2, contact, into, isLow, palm: [palm.x, palm.y, palm.z, palm.w] };
+        if (target.piece) target.piece.held = true;
+        control.begin(material === void 0 ? { massKg } : { massKg, material });
+        dragged = 0;
+        player.setWalkHeld(true);
+        if (isLow) player.setBend(Math.min(MAX_BEND, Math.max(0, STANDING_EYE - (max2[1] - player.feet + LOW_EYE_OVER_TOP))));
+        player.setLookLimit({ yaw: Math.atan2(-into[0], -into[1]), range: LOOK_RANGE });
+        event("grip", leaning);
+        return true;
+      },
+      end() {
+        if (!leaning) return false;
+        const tap = control.isTap;
+        release();
+        return tap;
+      },
+      setWalk(walk) {
+        scriptedWalk = walk;
+      },
+      step(dt) {
+        const lean = leaning;
+        if (!lean) return;
+        if (!world.has(lean.target.objectId)) {
+          release();
+          return;
+        }
+        const gripping = control.phase === "grip";
+        if (gripping) approach(lean, dt);
+        const result2 = control.update(dt, { walk: scriptedWalk ?? player.walkIntent, isFree: (dx, dz) => isFree(lean, dx, dz) });
+        if (result2.engaged) {
+          if (control.block !== "too_heavy") {
+            lean.piece ?? (lean.piece = options.makePiece(lean.target.objectId));
+            lean.piece.held = true;
+          }
+          event(control.block === "too_heavy" ? "too_heavy" : "engaged", lean);
+        }
+        if (result2.hitObstacle) {
+          options.hitSound(lean.target.objectId, [lean.contact[0], lean.min[1] + 0.3, lean.contact[1]]);
+          event("obstacle", lean);
+        }
+        if (result2.dx !== 0 || result2.dz !== 0) moveWith(lean, result2.dx, result2.dz);
+        options.ring(control.phase === "grip" && control.heldSeconds >= RING_DELAY_S ? control.progress : null);
+      },
+      handTargets() {
+        const lean = leaning;
+        if (!lean) return null;
+        const strain = control.phase === "strain";
+        const y = lean.isLow ? lean.max[1] + 0.01 : Math.min(HAND_TOP, lean.max[1] - HAND_UNDER_TOP);
+        const shake = strain ? Math.sin(performance.now() * 0.045) * 6e-3 : 0;
+        const inset = lean.isLow ? -LOW_HAND_ON_TOP + shake : (strain ? 0.05 : 0.02) + shake;
+        const px = lean.contact[0] - lean.into[0] * inset;
+        const pz = lean.contact[1] - lean.into[1] * inset;
+        const sideX = -lean.into[1] * HAND_SPREAD;
+        const sideZ = lean.into[0] * HAND_SPREAD;
+        const grip = 0.05 + 0.2 * control.progress;
+        return {
+          R: { position: [px + sideX, y, pz + sideZ], quaternion: lean.palm },
+          L: { position: [px - sideX, y, pz - sideZ], quaternion: lean.palm },
+          grip,
+          gripL: grip
+        };
+      }
+    };
+  }
+
+  // ../game-terrain/dist/index.js
+  var TERRAIN_MATERIALS = [
+    {
+      id: "turf",
+      debris: "clods",
+      rimShare: 0.25,
+      reposeDegrees: 55,
+      color: [0.09, 0.2, 0.04],
+      pattern: "grass",
+      hits: {
+        ballistic: { specificEnergy: 3e6, aspect: 0.6 },
+        blunt: { specificEnergy: 2e6, aspect: 0.2, thresholdJoules: 60 },
+        slash: { specificEnergy: 3e5, aspect: 0.5 },
+        explosive: { specificEnergy: 3e6, aspect: 0.45 }
+      },
+      fire: { maxScorch: 1, scorchPerSecond: 0.45, flammable: true }
+    },
+    {
+      id: "soil",
+      debris: "clods",
+      rimShare: 0.35,
+      reposeDegrees: 40,
+      color: [0.2, 0.12, 0.06],
+      pattern: "soil",
+      hits: {
+        ballistic: { specificEnergy: 4e6, aspect: 0.6 },
+        blunt: { specificEnergy: 2e6, aspect: 0.2, thresholdJoules: 60 },
+        slash: { specificEnergy: 3e5, aspect: 0.5 },
+        explosive: { specificEnergy: 4e6, aspect: 0.45 }
+      },
+      fire: { maxScorch: 0.6, scorchPerSecond: 0.15 }
+    },
+    {
+      id: "sand",
+      debris: "dust",
+      rimShare: 0.5,
+      reposeDegrees: 33,
+      color: [0.62, 0.5, 0.3],
+      pattern: "sand",
+      hits: {
+        ballistic: { specificEnergy: 25e5, aspect: 0.5 },
+        blunt: { specificEnergy: 1e6, aspect: 0.2, thresholdJoules: 30 },
+        slash: { specificEnergy: 15e4, aspect: 0.5 },
+        explosive: { specificEnergy: 3e6, aspect: 0.35 }
+      },
+      fire: { maxScorch: 0.2, scorchPerSecond: 0.05 }
+    },
+    {
+      id: "gravel",
+      debris: "chips",
+      rimShare: 0.3,
+      reposeDegrees: 38,
+      color: [0.27, 0.25, 0.22],
+      pattern: "stone",
+      hits: {
+        ballistic: { specificEnergy: 8e6, aspect: 0.4 },
+        blunt: { specificEnergy: 8e6, aspect: 0.2, thresholdJoules: 200 },
+        slash: { specificEnergy: 3e7, aspect: 0.3, thresholdJoules: 400 },
+        explosive: { specificEnergy: 1e7, aspect: 0.35 }
+      },
+      fire: { maxScorch: 0.3, scorchPerSecond: 0.06 }
+    },
+    {
+      id: "asphalt",
+      debris: "chips",
+      color: [0.05, 0.05, 0.055],
+      pattern: "asphalt",
+      hits: {
+        ballistic: { specificEnergy: 3e7, aspect: 0.2, minRadius: 0.03 },
+        blunt: { specificEnergy: 1e8, aspect: 0.1, thresholdJoules: 400 },
+        slash: { specificEnergy: 3e8, aspect: 0.2, thresholdJoules: 400 },
+        explosive: { specificEnergy: 2e8, aspect: 0.12 }
+      },
+      fire: { maxScorch: 0.85, scorchPerSecond: 0.1, burnsAway: 5e-5 }
+    },
+    {
+      id: "concrete",
+      debris: "chips",
+      color: [0.33, 0.33, 0.31],
+      pattern: "concrete",
+      hits: {
+        ballistic: { specificEnergy: 15e7, aspect: 0.14, minRadius: 0.018 },
+        blunt: { specificEnergy: 3e8, aspect: 0.08, thresholdJoules: 800 },
+        slash: { specificEnergy: 1e9, aspect: 0.2, thresholdJoules: 800 },
+        explosive: { specificEnergy: 27e8, aspect: 0.12 }
+      },
+      fire: { maxScorch: 0.45, scorchPerSecond: 0.08 }
+    },
+    {
+      id: "mortar",
+      debris: "chips",
+      color: [0.42, 0.4, 0.36],
+      pattern: "plain",
+      hits: {
+        ballistic: { specificEnergy: 4e7, aspect: 0.2 },
+        blunt: { specificEnergy: 8e7, aspect: 0.1, thresholdJoules: 300 },
+        slash: { specificEnergy: 3e8, aspect: 0.2, thresholdJoules: 300 },
+        explosive: { specificEnergy: 8e8, aspect: 0.14 }
+      },
+      fire: { maxScorch: 0.45, scorchPerSecond: 0.08 }
+    },
+    {
+      id: "ceramic",
+      debris: "shards",
+      color: [0.72, 0.7, 0.66],
+      pattern: "tile",
+      hits: {
+        ballistic: { specificEnergy: 8e6, aspect: 0.1, minRadius: 0.05 },
+        blunt: { specificEnergy: 1e7, aspect: 0.08, thresholdJoules: 80, minRadius: 0.06 },
+        slash: { specificEnergy: 2e8, aspect: 0.1, thresholdJoules: 200, minRadius: 0.03 },
+        explosive: { specificEnergy: 1e8, aspect: 0.03, minRadius: 0.12 }
+      },
+      fire: { maxScorch: 0.5, scorchPerSecond: 0.08 }
+    },
+    {
+      id: "wood_hard",
+      debris: "splinters",
+      color: [0.3, 0.16, 0.07],
+      pattern: "planks",
+      hits: {
+        ballistic: { specificEnergy: 25e6, aspect: 0.35, minRadius: 0.012 },
+        blunt: { specificEnergy: 8e7, aspect: 0.1, thresholdJoules: 120 },
+        slash: { specificEnergy: 15e6, aspect: 0.4, thresholdJoules: 15 },
+        explosive: { specificEnergy: 2e8, aspect: 0.1, minRadius: 0.1 }
+      },
+      fire: { maxScorch: 1, scorchPerSecond: 0.2, burnsAway: 12e-4, flammable: true }
+    },
+    {
+      id: "stone",
+      debris: "chips",
+      color: [0.23, 0.22, 0.2],
+      pattern: "stone",
+      hits: {
+        ballistic: { specificEnergy: 25e7, aspect: 0.12, minRadius: 0.015 },
+        blunt: { specificEnergy: 5e8, aspect: 0.08, thresholdJoules: 1500 },
+        slash: { specificEnergy: 2e9, aspect: 0.2, thresholdJoules: 1500 },
+        explosive: { specificEnergy: 4e9, aspect: 0.14 }
+      },
+      fire: { maxScorch: 0.4, scorchPerSecond: 0.06 }
+    }
+  ];
+  var TERRAIN_PROFILES = [
+    { id: "lawn", strata: [{ material: "turf", thickness: 0.05 }, { material: "soil", thickness: 1.5 }, { material: "stone", thickness: 0.5 }] },
+    { id: "dirt", strata: [{ material: "soil", thickness: 1.8 }, { material: "stone", thickness: 0.5 }] },
+    { id: "sand", strata: [{ material: "sand", thickness: 2.5 }] },
+    { id: "road", strata: [{ material: "asphalt", thickness: 0.05 }, { material: "gravel", thickness: 0.25 }, { material: "soil", thickness: 1.5 }] },
+    { id: "concrete_slab", strata: [{ material: "concrete", thickness: 0.12, reinforcement: { material: "steel", cover: 0.03, spacing: 0.15, resistance: 4 } }] },
+    { id: "suspended_slab", drop: 3, strata: [{ material: "concrete", thickness: 0.12, reinforcement: { material: "steel", cover: 0.03, spacing: 0.15, resistance: 4 } }] },
+    { id: "tile_floor", strata: [{ material: "ceramic", thickness: 8e-3 }, { material: "mortar", thickness: 0.03 }, { material: "concrete", thickness: 0.1, reinforcement: { material: "steel", cover: 0.03, spacing: 0.15, resistance: 4 } }] },
+    { id: "wood_floor", strata: [{ material: "wood_hard", thickness: 0.022 }, { material: "mortar", thickness: 0.03 }, { material: "concrete", thickness: 0.1, reinforcement: { material: "steel", cover: 0.03, spacing: 0.15, resistance: 4 } }] },
+    { id: "stone_paving", strata: [{ material: "stone", thickness: 0.08 }, { material: "gravel", thickness: 0.2 }, { material: "soil", thickness: 1.2 }] }
+  ];
+  var DEFAULT_BAR_YIELD_JOULES = 24e5;
+  var DEFAULT_PROFILE = "concrete_slab";
+  var REST_SPEED2 = 0.6;
+  var RESTITUTION2 = 0.25;
+  var FRICTION = 0.55;
+  var MAX_BOUNCES = 2;
+  var REST_GAP = 0.01;
+  function createDebrisStore(max2) {
+    const list = [];
+    let serial = 0;
+    function makeRoom() {
+      if (list.length < max2()) return;
+      let at3 = 0;
+      let oldest = Infinity;
+      let oldestResting = -1;
+      let restingBorn = Infinity;
+      list.forEach((piece, index) => {
+        if (piece.born < oldest) {
+          oldest = piece.born;
+          at3 = index;
+        }
+        if (piece.atRest && piece.born < restingBorn) {
+          restingBorn = piece.born;
+          oldestResting = index;
+        }
+      });
+      list.splice(oldestResting >= 0 ? oldestResting : at3, 1);
+    }
+    return {
+      list,
+      throwPiece(spec) {
+        makeRoom();
+        list.push({ ...spec, id: ++serial, born: serial, atRest: false, bounces: 0 });
+      },
+      update(dt, world) {
+        for (let i = list.length - 1; i >= 0; i--) {
+          const piece = list[i];
+          if (piece.atRest) {
+            const under = world.heightAt(piece.position[0], piece.position[2]) + piece.radius * 0.6;
+            if (piece.position[1] > under + REST_GAP) piece.atRest = false;
+            else if (piece.position[1] < under - REST_GAP) piece.position[1] = under;
+            if (piece.atRest) continue;
+          }
+          const { position, velocity } = piece;
+          velocity[1] -= world.gravity * dt;
+          position[0] += velocity[0] * dt;
+          position[1] += velocity[1] * dt;
+          position[2] += velocity[2] * dt;
+          const ground = world.heightAt(position[0], position[2]) + piece.radius * 0.6;
+          if (position[1] > ground) continue;
+          position[1] = ground;
+          const speed = Math.hypot(velocity[0], velocity[1], velocity[2]);
+          if (speed < REST_SPEED2 || piece.bounces >= MAX_BOUNCES) {
+            piece.atRest = true;
+            if (world.settle(piece)) list.splice(i, 1);
+            continue;
+          }
+          piece.bounces++;
+          velocity[1] = Math.abs(velocity[1]) * RESTITUTION2;
+          velocity[0] *= FRICTION;
+          velocity[2] *= FRICTION;
+        }
+      },
+      clear() {
+        list.length = 0;
+      }
+    };
+  }
+  var SAME_HOLE = 0.75;
+  function createMarkStore2(budget) {
+    const list = [];
+    const areas = /* @__PURE__ */ new Map();
+    let serial = 0;
+    let version = 0;
+    const areaKey = (x, z) => Math.floor(x / budget.markAreaSize) * 100003 + Math.floor(z / budget.markAreaSize);
+    function detach(mark) {
+      const key = areaKey(mark.x, mark.z);
+      const area = areas.get(key);
+      if (area) {
+        const at22 = area.indexOf(mark);
+        if (at22 >= 0) area.splice(at22, 1);
+        if (area.length === 0) areas.delete(key);
+      }
+      const at3 = list.indexOf(mark);
+      if (at3 >= 0) list.splice(at3, 1);
+      version++;
+    }
+    function attach(mark) {
+      const key = areaKey(mark.x, mark.z);
+      const area = areas.get(key);
+      if (area) area.push(mark);
+      else areas.set(key, [mark]);
+      list.push(mark);
+      version++;
+    }
+    function mergeClosestPair(area) {
+      let bestA = area[0];
+      let bestB = area[1];
+      let best = Infinity;
+      for (let i = 0; i < area.length; i++) {
+        for (let j = i + 1; j < area.length; j++) {
+          const distance4 = Math.hypot(area[i].x - area[j].x, area[i].z - area[j].z);
+          if (distance4 < best) {
+            best = distance4;
+            bestA = area[i];
+            bestB = area[j];
+          }
+        }
+      }
+      const weight = bestA.radius ** 2 + bestB.radius ** 2;
+      const shareB = weight > 0 ? bestB.radius ** 2 / weight : 0.5;
+      detach(bestB);
+      bestA.x += (bestB.x - bestA.x) * shareB;
+      bestA.z += (bestB.z - bestA.z) * shareB;
+      bestA.radius = Math.sqrt(weight);
+      bestA.depth = Math.max(bestA.depth, bestB.depth);
+      bestA.count += bestB.count;
+      version++;
+    }
+    return {
+      list,
+      add(spec) {
+        const mark = { ...spec, id: ++serial, count: 1, born: serial };
+        attach(mark);
+        const area = areas.get(areaKey(mark.x, mark.z));
+        if (area.length > budget.maxMarksPerArea) mergeClosestPair(area);
+        if (list.length > budget.maxMarks) detach(list.reduce((oldest, candidate) => candidate.born < oldest.born ? candidate : oldest));
+        return mark;
+      },
+      near(x, z, radius) {
+        let found;
+        let best = Infinity;
+        const reach = Math.ceil((radius + 0.5) / budget.markAreaSize);
+        const baseX = Math.floor(x / budget.markAreaSize);
+        const baseZ = Math.floor(z / budget.markAreaSize);
+        for (let dx = -reach; dx <= reach; dx++) {
+          for (let dz = -reach; dz <= reach; dz++) {
+            for (const mark of areas.get((baseX + dx) * 100003 + baseZ + dz) ?? []) {
+              const distance4 = Math.hypot(mark.x - x, mark.z - z);
+              if (distance4 < best && distance4 < Math.max(mark.radius, radius) * SAME_HOLE) {
+                best = distance4;
+                found = mark;
+              }
+            }
+          }
+        }
+        return found;
+      },
+      depthAt(x, z) {
+        let depth = 0;
+        for (const mark of areas.get(areaKey(x, z)) ?? []) {
+          const distance4 = Math.hypot(mark.x - x, mark.z - z);
+          if (distance4 < mark.radius) depth = Math.max(depth, mark.depth * (1 - (distance4 / mark.radius) ** 2));
+        }
+        return depth;
+      },
+      remove: detach,
+      removeInside(x, z, radius) {
+        for (const mark of [...list]) if (Math.hypot(mark.x - x, mark.z - z) + mark.radius * 0.5 < radius) detach(mark);
+      },
+      clear() {
+        list.length = 0;
+        areas.clear();
+        version++;
+      },
+      load(marks) {
+        this.clear();
+        for (const mark of marks) {
+          attach({ ...mark });
+          serial = Math.max(serial, mark.id);
+        }
+      },
+      get version() {
+        return version;
+      }
+    };
+  }
+  function createRandom(seed) {
+    let state = seed | 0;
+    return () => {
+      state = state + 1831565813 | 0;
+      let mixed = Math.imul(state ^ state >>> 15, 1 | state);
+      mixed = mixed + Math.imul(mixed ^ mixed >>> 7, 61 | mixed) ^ mixed;
+      return ((mixed ^ mixed >>> 14) >>> 0) / 4294967296;
+    };
+  }
+  var DEFAULT_TERRAIN_BUDGET = {
+    markAreaSize: 2,
+    maxMarksPerArea: 24,
+    maxMarks: 800,
+    maxDirtyChunksPerFrame: 6,
+    maxDebris: 400,
+    maxDebrisPerBlow: 36,
+    maxSlideCellsPerFrame: 2500,
+    maxBurningCells: 300
+  };
+  var GRAVITY5 = 9.81;
+  var FINE_CELLS = 1.5;
+  var FINE_DEPTH_CELLS = 0.4;
+  var RIGID_WIDENING = 2.5;
+  var COLLAPSE_DEPTH_SHARE = 0.75;
+  var COLLAPSE_SPREAD_BEND = 0.5;
+  var RIM_REACH = 1.45;
+  var FLAME_MINIMUM = 200;
+  var FLAME_REACH = 0.6;
+  var BLAST_HEIGHT_REACH = 0.35;
+  var THROW_SHARE = 0.02;
+  var FIRE_CELL = 0.5;
+  var FIRE_SECONDS = 7;
+  var FIRE_SPREAD_PER_SECOND = 0.35;
+  var SLIDE_SHARE = 0.4;
+  var SLIDE_EPSILON = 2e-3;
+  var PIECE_RADIUS = { clods: 0.045, chips: 0.022, shards: 0.028, splinters: 0.02, dust: 0.012 };
+  var MAX_PIECE_SPEED = { explosive: 14, ballistic: 5, blunt: 2.5, slash: 1.5 };
+  var clampIndex = (value, max2) => Math.max(0, Math.min(max2, value));
+  var sparse = (array) => {
+    const entries = [];
+    array.forEach((value, index) => {
+      if (value !== 0) entries.push([index, value]);
+    });
+    return entries;
+  };
+  var fillSparse = (array, entries) => {
+    array.fill(0);
+    for (const [index, value] of entries) array[index] = value;
+  };
+  function stratumAtDepth(profile, depth) {
+    let top = 0;
+    for (let index2 = 0; index2 < profile.strata.length; index2++) {
+      const stratum2 = profile.strata[index2];
+      if (depth < top + stratum2.thickness - 1e-6) return { index: index2, stratum: stratum2, top };
+      top += stratum2.thickness;
+    }
+    const index = profile.strata.length - 1;
+    const stratum = profile.strata[index];
+    return { index, stratum, top: top - stratum.thickness };
+  }
+  var totalThickness = (profile) => profile.strata.reduce((sum2, stratum) => sum2 + stratum.thickness, 0);
+  function createTerrain(options) {
+    const [x0, z0, x1, z1] = options.bounds;
+    const cellSize = options.cellSize ?? 0.1;
+    const chunkCells = options.chunkCells ?? 32;
+    const columns = Math.max(1, Math.ceil((x1 - x0) / cellSize));
+    const rows = Math.max(1, Math.ceil((z1 - z0) / cellSize));
+    const stride = columns + 1;
+    const vertexCount = stride * (rows + 1);
+    const chunksX = Math.ceil(columns / chunkCells);
+    const chunksZ = Math.ceil(rows / chunkCells);
+    const budget = { ...DEFAULT_TERRAIN_BUDGET, ...options.budget };
+    const gravity = options.gravity ?? GRAVITY5;
+    const materials = new Map([...TERRAIN_MATERIALS, ...options.materials ?? []].map((material) => [material.id, material]));
+    const profileMap = new Map([...TERRAIN_PROFILES, ...options.profiles ?? []].map((profile) => [profile.id, profile]));
+    const profileList = [...profileMap.values()];
+    for (const profile of profileList) {
+      for (const stratum of profile.strata) if (!materials.has(stratum.material)) throw new Error(`game-terrain: profile "${profile.id}" uses material "${stratum.material}", which has no ground behaviour`);
+    }
+    const indexOfProfile = new Map(profileList.map((profile, index) => [profile.id, index]));
+    const maxDepthOf = profileList.map(totalThickness);
+    const base = new Float32Array(vertexCount);
+    if (options.baseHeight) {
+      for (let row = 0; row <= rows; row++) for (let column = 0; column <= columns; column++) base[row * stride + column] = options.baseHeight(x0 + column * cellSize, z0 + row * cellSize);
+    }
+    const dug = new Float32Array(vertexCount);
+    const loose = new Float32Array(vertexCount);
+    const scorch = new Float32Array(vertexCount);
+    const barBend = new Float32Array(vertexCount);
+    const profileIndex = new Uint8Array(vertexCount);
+    const touched = new Uint8Array(chunksX * chunksZ);
+    const mixed = new Uint8Array(chunksX * chunksZ);
+    const dirty = /* @__PURE__ */ new Set();
+    const marks = createMarkStore2(budget);
+    const debrisStore = createDebrisStore(() => budget.maxDebris);
+    const sliding = /* @__PURE__ */ new Set();
+    const burning = /* @__PURE__ */ new Map();
+    const random = createRandom(options.seed ?? 1);
+    let currentLayout = options.layout ?? { surface: DEFAULT_PROFILE };
+    const deformListeners = /* @__PURE__ */ new Set();
+    const emitDeform = (x, z, radius) => {
+      for (const listener of deformListeners) listener({ x, z, radius });
+    };
+    const chunkOfVertex = (column, row) => Math.min(chunksZ - 1, Math.floor(row / chunkCells)) * chunksX + Math.min(chunksX - 1, Math.floor(column / chunkCells));
+    function touchVertex(column, row) {
+      const chunk2 = chunkOfVertex(column, row);
+      touched[chunk2] = 1;
+      dirty.add(chunk2);
+      if (column % chunkCells === 0 && column > 0) markChunk(chunk2 - 1);
+      if (row % chunkCells === 0 && row > 0) markChunk(chunk2 - chunksX);
+      if (column % chunkCells === 0 && row % chunkCells === 0 && column > 0 && row > 0) markChunk(chunk2 - chunksX - 1);
+    }
+    function markChunk(chunk2) {
+      touched[chunk2] = 1;
+      dirty.add(chunk2);
+    }
+    const profileId = (id) => indexOfProfile.get(id) ?? indexOfProfile.get(DEFAULT_PROFILE) ?? 0;
+    function applyLayout(layout) {
+      currentLayout = layout;
+      profileIndex.fill(profileId(layout.surface));
+      for (const zone of layout.zones ?? []) {
+        const index = profileId(zone.surface);
+        const [zx0, zz0, zx1, zz1] = zone.rect;
+        const column0 = clampIndex(Math.round((zx0 - x0) / cellSize), columns);
+        const column1 = clampIndex(Math.round((zx1 - x0) / cellSize), columns);
+        const row0 = clampIndex(Math.round((zz0 - z0) / cellSize), rows);
+        const row1 = clampIndex(Math.round((zz1 - z0) / cellSize), rows);
+        for (let row = row0; row <= row1; row++) profileIndex.fill(index, row * stride + column0, row * stride + column1 + 1);
+      }
+      for (let chunkZ = 0; chunkZ < chunksZ; chunkZ++) {
+        for (let chunkX = 0; chunkX < chunksX; chunkX++) {
+          const chunk2 = chunkZ * chunksX + chunkX;
+          const first = profileIndex[chunkZ * chunkCells * stride + chunkX * chunkCells];
+          let isMixed = 0;
+          const lastRow = Math.min(rows, (chunkZ + 1) * chunkCells);
+          const lastColumn = Math.min(columns, (chunkX + 1) * chunkCells);
+          for (let row = chunkZ * chunkCells; row <= lastRow && !isMixed; row++) {
+            for (let column = chunkX * chunkCells; column <= lastColumn; column++) {
+              if (profileIndex[row * stride + column] !== first) {
+                isMixed = 1;
+                break;
+              }
+            }
+          }
+          mixed[chunk2] = isMixed;
+          dirty.add(chunk2);
+        }
+      }
+    }
+    const vertexHeight = (column, row) => {
+      const index = row * stride + column;
+      return base[index] - dug[index] + loose[index];
+    };
+    const contains = (x, z) => x >= x0 && x <= x1 && z >= z0 && z <= z1;
+    function heightAt(x, z) {
+      if (!contains(x, z)) return options.baseHeight?.(x, z) ?? 0;
+      const fx = Math.max(0, Math.min(columns - 1e-6, (x - x0) / cellSize));
+      const fz = Math.max(0, Math.min(rows - 1e-6, (z - z0) / cellSize));
+      const column = fx | 0;
+      const row = fz | 0;
+      const tx = fx - column;
+      const tz = fz - row;
+      const index = row * stride + column;
+      const h = (i) => base[i] - dug[i] + loose[i];
+      return (h(index) * (1 - tx) + h(index + 1) * tx) * (1 - tz) + (h(index + stride) * (1 - tx) + h(index + stride + 1) * tx) * tz;
+    }
+    const vertexOf = (x, z) => {
+      const column = clampIndex(Math.round((x - x0) / cellSize), columns);
+      const row = clampIndex(Math.round((z - z0) / cellSize), rows);
+      return { column, row, index: row * stride + column };
+    };
+    function vertexMaterial(column, row) {
+      const index = row * stride + column;
+      return materials.get(stratumAtDepth(profileList[profileIndex[index]], dug[index]).stratum.material);
+    }
+    function columnAt(x, z) {
+      const { index } = vertexOf(x, z);
+      const which = profileIndex[index];
+      const profile = profileList[which];
+      const depth = Math.min(maxDepthOf[which], dug[index] + marks.depthAt(x, z));
+      const layer2 = stratumAtDepth(profile, depth);
+      return { profile: profile.id, material: layer2.stratum.material, stratum: layer2.index, depth, remaining: maxDepthOf[which] - depth, scorch: scorch[index], loose: loose[index] };
+    }
+    function removeFromVertex(index, amount) {
+      const fromLoose = Math.min(loose[index], amount);
+      loose[index] = loose[index] - fromLoose;
+      const fromColumn = Math.min(maxDepthOf[profileIndex[index]] - dug[index], amount - fromLoose);
+      if (fromColumn > 0) dug[index] = dug[index] + fromColumn;
+      return fromLoose + Math.max(0, fromColumn);
+    }
+    function addToVertex(index, amount, fillsColumn) {
+      const filled = fillsColumn ? Math.min(dug[index], amount) : 0;
+      dug[index] = dug[index] - filled;
+      loose[index] = loose[index] + amount - filled;
+    }
+    const isSoftExposed = (index) => materials.get(stratumAtDepth(profileList[profileIndex[index]], dug[index]).stratum.material).reposeDegrees !== void 0;
+    function stampBowl(x, z, radius, depth, rimVolume) {
+      const reach = radius * RIM_REACH;
+      const column0 = clampIndex(Math.floor((x - reach - x0) / cellSize), columns);
+      const column1 = clampIndex(Math.ceil((x + reach - x0) / cellSize), columns);
+      const row0 = clampIndex(Math.floor((z - reach - z0) / cellSize), rows);
+      const row1 = clampIndex(Math.ceil((z + reach - z0) / cellSize), rows);
+      const phaseA = random() * 6.283;
+      const phaseB = random() * 6.283;
+      const shapeOf2 = (px, pz) => {
+        const angle = Math.atan2(pz - z, px - x);
+        return Math.hypot(px - x, pz - z) / (radius * (1 + 0.12 * Math.sin(angle * 5 + phaseA) + 0.06 * Math.sin(angle * 11 + phaseB)));
+      };
+      let rimWeight = 0;
+      if (rimVolume > 0) {
+        for (let row = row0; row <= row1; row++) {
+          for (let column = column0; column <= column1; column++) {
+            const q = shapeOf2(x0 + column * cellSize, z0 + row * cellSize);
+            if (q >= 1 && q < RIM_REACH) rimWeight += Math.sin((q - 1) / (RIM_REACH - 1) * Math.PI);
+          }
+        }
+      }
+      const cellArea = cellSize * cellSize;
+      for (let row = row0; row <= row1; row++) {
+        for (let column = column0; column <= column1; column++) {
+          const q = shapeOf2(x0 + column * cellSize, z0 + row * cellSize);
+          const index = row * stride + column;
+          if (q < 1) {
+            removeFromVertex(index, depth * (1 - q * q) * (0.92 + random() * 0.16));
+            sliding.add(index);
+            touchVertex(column, row);
+          } else if (q < RIM_REACH && rimWeight > 0) {
+            loose[index] = loose[index] + rimVolume * Math.sin((q - 1) / (RIM_REACH - 1) * Math.PI) / (rimWeight * cellArea);
+            sliding.add(index);
+            touchVertex(column, row);
+          }
+        }
+      }
+      marks.removeInside(x, z, radius);
+      emitDeform(x, z, reach);
+    }
+    function throwPieces(spec) {
+      const radius = PIECE_RADIUS[spec.material.debris];
+      const pieceVolume = 4 / 3 * Math.PI * radius ** 3;
+      const count = Math.min(spec.quota, Math.max(1, Math.round(spec.volume / pieceVolume)));
+      const mass = Math.max(1e-3, spec.volume * 1500);
+      const launch = Math.min(MAX_PIECE_SPEED[spec.blow], Math.sqrt(2 * spec.energy * THROW_SHARE / mass));
+      for (let i = 0; i < count; i++) {
+        const angle = random() * 6.283;
+        const out = spec.bowlRadius * Math.sqrt(random()) * 0.8;
+        const speed = launch * (0.5 + random() * 0.7);
+        const spread2 = 0.35 + random() * 0.65;
+        const backX = spec.direction ? -(spec.direction[0] ?? 0) * 0.4 : 0;
+        const backZ = spec.direction ? -(spec.direction[2] ?? 0) * 0.4 : 0;
+        debrisStore.throwPiece({
+          material: spec.material.id,
+          kind: spec.material.debris,
+          radius: radius * (0.6 + random() * 0.9),
+          position: [spec.x + Math.cos(angle) * out, spec.y + 0.03, spec.z + Math.sin(angle) * out],
+          velocity: [(Math.cos(angle) * spread2 + backX) * speed, (0.6 + random() * 0.7) * speed, (Math.sin(angle) * spread2 + backZ) * speed],
+          spin: [(random() - 0.5) * 14, (random() - 0.5) * 14, (random() - 0.5) * 14]
+        });
+      }
+    }
+    function strike(blow3, spec) {
+      const { x, z } = spec;
+      const start = columnAt(x, z);
+      const profile = profileMap.get(start.profile);
+      const removed = [];
+      const point = [x, heightAt(x, z), z];
+      let energy = spec.energy;
+      let depth = start.depth;
+      let radius = 0;
+      let carved = 0;
+      const firstMaterial = materials.get(start.material);
+      if (start.loose <= 0) {
+        for (; ; ) {
+          const layer2 = stratumAtDepth(profile, depth);
+          const bottom = layer2.top + layer2.stratum.thickness;
+          const room = bottom - depth;
+          if (room <= 1e-6) break;
+          const material = materials.get(layer2.stratum.material);
+          const response = material.hits[blow3];
+          if (!response || energy < (response.thresholdJoules ?? 0)) break;
+          const bars = layer2.stratum.reinforcement;
+          const pastCover = bars !== void 0 && depth - layer2.top >= bars.cover - 1e-6;
+          const specificEnergy = response.specificEnergy * (pastCover ? bars.resistance : 1);
+          const limit = bars && !pastCover ? Math.min(room, layer2.top + bars.cover - depth) : room;
+          const volume = energy / specificEnergy;
+          const wanted = Math.cbrt(2 * volume / (Math.PI * response.aspect));
+          const wantedDepth = wanted * response.aspect;
+          const takenDepth = Math.min(wantedDepth, limit);
+          const takenRadius = takenDepth < wantedDepth ? takenDepth / response.aspect : wanted;
+          const takenVolume = Math.PI * takenRadius * takenRadius * takenDepth / 2;
+          energy -= takenVolume * specificEnergy;
+          depth += takenDepth;
+          carved += takenDepth;
+          radius = Math.max(radius, takenRadius, response.minRadius ?? 0, spec.contactRadius ?? 0);
+          const last = removed[removed.length - 1];
+          if (last?.material === material.id) last.volume += takenVolume;
+          else removed.push({ material: material.id, volume: takenVolume });
+          if (energy <= 1e-6 || takenDepth >= wantedDepth - 1e-9) break;
+        }
+      } else {
+        const response = firstMaterial.hits[blow3];
+        if (response && energy >= (response.thresholdJoules ?? 0)) {
+          const volume = energy / response.specificEnergy;
+          radius = Math.cbrt(2 * volume / (Math.PI * response.aspect));
+          carved = radius * response.aspect;
+          removed.push({ material: firstMaterial.id, volume });
+        }
+      }
+      const collapsed = loadBars(blow3, spec.energy, x, z, profile);
+      if (radius <= 0) return { point, radius: 0, depth: 0, totalDepth: columnAt(x, z).depth, removed: [], exposed: start.material, atLimit: start.remaining <= 1e-6, rebarExposed: rebarShowing(profile, start.depth), collapsed, fine: true };
+      if (firstMaterial.reposeDegrees === void 0 && start.loose <= 0) radius *= 1 + RIGID_WIDENING * (start.depth / maxDepthOfProfile(profile));
+      const volumeTotal = removed.reduce((sum2, entry) => sum2 + entry.volume, 0);
+      const fine = radius < cellSize * FINE_CELLS;
+      if (fine) depositMark({ x, z, radius, depth: carved, blow: blow3, profile, cap: maxDepthOfProfile(profile) });
+      else {
+        const rimShare = materials.get(removed[0].material).rimShare ?? 0;
+        stampBowl(x, z, radius, carved, volumeTotal * rimShare);
+      }
+      let quota = budget.maxDebrisPerBlow;
+      for (const entry of removed) {
+        const material = materials.get(entry.material);
+        const thrown = entry.volume * (1 - (fine ? 0 : material.rimShare ?? 0));
+        if (thrown <= 0 || quota <= 0) continue;
+        const share = Math.max(1, Math.round(quota * entry.volume / volumeTotal));
+        throwPieces({ x, y: point[1], z, volume: thrown, material, energy: spec.energy * (entry.volume / volumeTotal), direction: spec.direction, quota: share, bowlRadius: radius, blow: blow3 });
+        quota -= share;
+      }
+      const after2 = columnAt(x, z);
+      return { point, radius, depth: carved, totalDepth: after2.depth, removed, exposed: after2.material, atLimit: after2.remaining <= 1e-4, rebarExposed: rebarShowing(profile, after2.depth), collapsed, fine };
+    }
+    function loadBars(blow3, energy, x, z, profile) {
+      const bars = profile.strata.find((stratum) => stratum.reinforcement);
+      if (!bars?.reinforcement) return false;
+      const response = materials.get(bars.material).hits[blow3];
+      if (!response || energy < (response.thresholdJoules ?? 0)) return false;
+      const yieldJoules = bars.reinforcement.yieldJoules ?? DEFAULT_BAR_YIELD_JOULES;
+      let cover = bars.reinforcement.cover;
+      for (const stratum of profile.strata) {
+        if (stratum === bars) break;
+        cover += stratum.thickness;
+      }
+      const reach = Math.max(cellSize * FINE_CELLS, Math.cbrt(2 * energy / response.specificEnergy / (Math.PI * response.aspect)) * (1 + RIGID_WIDENING));
+      const column0 = clampIndex(Math.floor((x - reach - x0) / cellSize), columns);
+      const column1 = clampIndex(Math.ceil((x + reach - x0) / cellSize), columns);
+      const row0 = clampIndex(Math.floor((z - reach - z0) / cellSize), rows);
+      const row1 = clampIndex(Math.ceil((z + reach - z0) / cellSize), rows);
+      const limit = maxDepthOfProfile(profile);
+      let collapsed = false;
+      for (let row = row0; row <= row1; row++) {
+        for (let column = column0; column <= column1; column++) {
+          const index = row * stride + column;
+          if (dug[index] < cover) continue;
+          const q = Math.hypot(x0 + column * cellSize - x, z0 + row * cellSize - z) / reach;
+          if (q >= 1) continue;
+          barBend[index] = barBend[index] + energy / yieldJoules * (1 - q * q);
+          touchVertex(column, row);
+          if (barBend[index] >= 1 && profile.drop !== void 0 && dug[index] >= limit * COLLAPSE_DEPTH_SHARE && dug[index] < limit + profile.drop) {
+            dug[index] = limit + profile.drop;
+            collapsed = true;
+          }
+        }
+      }
+      if (collapsed) emitDeform(x, z, reach);
+      if (collapsed && profile.drop !== void 0) {
+        for (let row = row0; row <= row1; row++) {
+          for (let column = column0; column <= column1; column++) {
+            const index = row * stride + column;
+            if (barBend[index] >= COLLAPSE_SPREAD_BEND && dug[index] < limit + profile.drop) {
+              dug[index] = limit + profile.drop;
+              touchVertex(column, row);
+            }
+          }
+        }
+      }
+      return collapsed;
+    }
+    const maxDepthOfProfile = (profile) => maxDepthOf[indexOfProfile.get(profile.id)];
+    function rebarShowing(profile, depth) {
+      const layer2 = stratumAtDepth(profile, depth);
+      return layer2.stratum.reinforcement !== void 0 && depth - layer2.top >= layer2.stratum.reinforcement.cover - 1e-6;
+    }
+    function depositMark(spec) {
+      const { x, z, radius, depth, blow: blow3, profile, cap } = spec;
+      const dugHere = dug[vertexOf(x, z).index];
+      const existing = marks.near(x, z, radius);
+      let mark;
+      if (existing) {
+        existing.radius = Math.hypot(existing.radius, radius);
+        existing.depth = Math.min(cap - dugHere, existing.depth + depth);
+        existing.count++;
+        existing.blow = blow3;
+        mark = existing;
+      } else {
+        mark = marks.add({ x, z, radius, depth: Math.min(cap - dugHere, depth), blow: blow3, material: "" });
+      }
+      mark.material = stratumAtDepth(profile, dugHere + mark.depth - 1e-6).stratum.material;
+      if (mark.radius >= cellSize * FINE_CELLS || mark.depth >= cellSize * FINE_DEPTH_CELLS) {
+        const bowlRadius = Math.max(mark.radius, cellSize * FINE_CELLS);
+        const bowlDepth = mark.depth;
+        marks.remove(mark);
+        stampBowl(mark.x, mark.z, bowlRadius, bowlDepth, 0);
+      }
+    }
+    function burn(spec) {
+      if (spec.temperature < FLAME_MINIMUM) return;
+      const column0 = clampIndex(Math.floor((spec.x - spec.radius - x0) / cellSize), columns);
+      const column1 = clampIndex(Math.ceil((spec.x + spec.radius - x0) / cellSize), columns);
+      const row0 = clampIndex(Math.floor((spec.z - spec.radius - z0) / cellSize), rows);
+      const row1 = clampIndex(Math.ceil((spec.z + spec.radius - z0) / cellSize), rows);
+      for (let row = row0; row <= row1; row++) {
+        for (let column = column0; column <= column1; column++) {
+          if (Math.hypot(x0 + column * cellSize - spec.x, z0 + row * cellSize - spec.z) > spec.radius) continue;
+          burnVertex(column, row, spec.seconds);
+        }
+      }
+    }
+    function burnVertex(column, row, seconds) {
+      const index = row * stride + column;
+      const material = vertexMaterial(column, row);
+      const response = material.fire;
+      if (!response) return;
+      const before = scorch[index];
+      scorch[index] = Math.max(before, Math.min(response.maxScorch, before + response.scorchPerSecond * seconds));
+      if (response.burnsAway) removeFromVertex(index, response.burnsAway * seconds);
+      if (scorch[index] !== before || response.burnsAway) touchVertex(column, row);
+      if (response.flammable) ignite(x0 + column * cellSize, z0 + row * cellSize);
+    }
+    const fireKey = (x, z) => Math.floor((z - z0) / FIRE_CELL) * 65536 + Math.floor((x - x0) / FIRE_CELL);
+    function ignite(x, z) {
+      const key = fireKey(x, z);
+      if (burning.has(key) || burning.size >= budget.maxBurningCells) return;
+      const index = vertexOf(x, z).index;
+      if (scorch[index] >= 1) return;
+      burning.set(key, FIRE_SECONDS);
+    }
+    function updateFire(dt) {
+      for (const [key, remaining] of [...burning]) {
+        const cellRow = Math.floor(key / 65536);
+        const cellColumn = key - cellRow * 65536;
+        const x = x0 + (cellColumn + 0.5) * FIRE_CELL;
+        const z = z0 + (cellRow + 0.5) * FIRE_CELL;
+        burn({ x, z, radius: FIRE_CELL * 0.75, temperature: 600, seconds: dt });
+        if (random() < FIRE_SPREAD_PER_SECOND * dt) {
+          const angle = Math.floor(random() * 4) * (Math.PI / 2);
+          const nextX = x + Math.cos(angle) * FIRE_CELL;
+          const nextZ = z + Math.sin(angle) * FIRE_CELL;
+          if (contains(nextX, nextZ)) {
+            const { column, row, index } = vertexOf(nextX, nextZ);
+            if (vertexMaterial(column, row).fire?.flammable && scorch[index] < 1) ignite(nextX, nextZ);
+          }
+        }
+        if (remaining - dt <= 0) burning.delete(key);
+        else burning.set(key, remaining - dt);
+      }
+    }
+    function updateSlides() {
+      if (sliding.size === 0) return;
+      let budgetLeft = budget.maxSlideCellsPerFrame;
+      let minX = Infinity;
+      let minZ = Infinity;
+      let maxX = -Infinity;
+      let maxZ = -Infinity;
+      for (const index of sliding) {
+        if (budgetLeft-- <= 0) break;
+        sliding.delete(index);
+        const column = index % stride;
+        const row = (index - column) / stride;
+        if (!isSoftExposed(index)) continue;
+        const material = vertexMaterial(column, row);
+        const slope = Math.tan((material.reposeDegrees ?? 90) * Math.PI / 180) * cellSize;
+        const height = vertexHeight(column, row);
+        const neighbours = [[column - 1, row], [column + 1, row], [column, row - 1], [column, row + 1]];
+        for (const [nextColumn, nextRow] of neighbours) {
+          if (nextColumn < 0 || nextRow < 0 || nextColumn > columns || nextRow > rows) continue;
+          const excess = height - vertexHeight(nextColumn, nextRow) - slope;
+          if (excess <= SLIDE_EPSILON) continue;
+          const moved = removeFromVertex(index, excess * SLIDE_SHARE);
+          if (moved <= 0) continue;
+          const next = nextRow * stride + nextColumn;
+          addToVertex(next, moved, isSoftExposed(next));
+          sliding.add(index);
+          sliding.add(next);
+          touchVertex(column, row);
+          touchVertex(nextColumn, nextRow);
+          const px = x0 + column * cellSize;
+          const pz = z0 + row * cellSize;
+          minX = Math.min(minX, px);
+          maxX = Math.max(maxX, px);
+          minZ = Math.min(minZ, pz);
+          maxZ = Math.max(maxZ, pz);
+        }
+      }
+      if (minX <= maxX) emitDeform((minX + maxX) / 2, (minZ + maxZ) / 2, Math.hypot(maxX - minX, maxZ - minZ) / 2 + cellSize * 2);
+    }
+    function settle(piece) {
+      const material = materials.get(piece.material);
+      if (!material || material.reposeDegrees === void 0) return false;
+      if (!contains(piece.position[0], piece.position[2])) return true;
+      const { index, column, row } = vertexOf(piece.position[0], piece.position[2]);
+      addToVertex(index, 4 / 3 * Math.PI * piece.radius ** 3 / (cellSize * cellSize), false);
+      sliding.add(index);
+      touchVertex(column, row);
+      return true;
+    }
+    function applyHit(hit) {
+      const [x, y, z] = hit.point;
+      switch (hit.type) {
+        case "ballistic":
+        case "blunt":
+        case "slash": {
+          if (!hit.energy) return null;
+          const contactRadius = hit.type === "blunt" ? hit.radius : void 0;
+          return strike(hit.type, { x, z, energy: hit.energy, ...hit.direction ? { direction: hit.direction } : {}, ...contactRadius !== void 0 ? { contactRadius } : {} });
+        }
+        case "explosive": {
+          if (!hit.energy) return null;
+          const above2 = Math.max(0, y - heightAt(x, z));
+          const reach = (hit.radius ?? 1) * BLAST_HEIGHT_REACH;
+          if (above2 >= reach) return null;
+          return strike("explosive", { x, z, energy: hit.energy * (1 - above2 / reach) ** 2 });
+        }
+        case "fire":
+        case "heat":
+          if (y - heightAt(x, z) > (hit.radius ?? 0.2) + FLAME_REACH) return null;
+          burn({ x, z, radius: hit.radius ?? 0.2, temperature: hit.temperature ?? 0, seconds: hit.duration ?? 0.016 });
+          return null;
+        default:
+          return null;
+      }
+    }
+    function raycast(origin, direction, maxDistance) {
+      const [ox = 0, oy = 0, oz = 0] = origin;
+      const [dx = 0, dy = 0, dz = 0] = direction;
+      const step = cellSize * 0.75;
+      let previous = 0;
+      for (let t = 0; t <= maxDistance; t += step) {
+        const x = ox + dx * t;
+        const z = oz + dz * t;
+        if (contains(x, z) && oy + dy * t <= heightAt(x, z)) {
+          let low = previous;
+          let high = t;
+          for (let i = 0; i < 6; i++) {
+            const middle = (low + high) / 2;
+            if (oy + dy * middle <= heightAt(ox + dx * middle, oz + dz * middle)) high = middle;
+            else low = middle;
+          }
+          const px = ox + dx * high;
+          const pz = oz + dz * high;
+          const gx = heightAt(px + cellSize, pz) - heightAt(px - cellSize, pz);
+          const gz = heightAt(px, pz + cellSize) - heightAt(px, pz - cellSize);
+          const length3 = Math.hypot(gx, 2 * cellSize, gz);
+          return { point: [px, oy + dy * high, pz], distance: high, normal: [-gx / length3, 2 * cellSize / length3, -gz / length3] };
+        }
+        previous = t;
+      }
+      return null;
+    }
+    function chunk(index) {
+      const chunkZ = Math.floor(index / chunksX);
+      const chunkX = index - chunkZ * chunksX;
+      return { index, column: chunkX * chunkCells, row: chunkZ * chunkCells, cells: chunkCells, pristine: !touched[index] && !mixed[index] && !options.baseHeight };
+    }
+    function reset() {
+      dug.fill(0);
+      loose.fill(0);
+      scorch.fill(0);
+      barBend.fill(0);
+      touched.fill(0);
+      marks.clear();
+      debrisStore.clear();
+      sliding.clear();
+      burning.clear();
+      applyLayout(currentLayout);
+    }
+    applyLayout(currentLayout);
+    return {
+      bounds: options.bounds,
+      cellSize,
+      columns,
+      rows,
+      stride,
+      chunkCells,
+      chunksX,
+      chunksZ,
+      budget,
+      dug,
+      loose,
+      scorch,
+      barBend,
+      profileIndex,
+      profileList,
+      material: (id) => {
+        const material = materials.get(id);
+        if (!material) throw new Error(`game-terrain: unknown material "${id}"`);
+        return material;
+      },
+      layout: () => currentLayout,
+      setLayout(layout) {
+        currentLayout = layout;
+        reset();
+      },
+      heightAt,
+      vertexHeight,
+      vertexMaterial,
+      columnAt,
+      contains,
+      raycast,
+      strike,
+      burn,
+      applyHit,
+      onDeform(listener) {
+        deformListeners.add(listener);
+        return () => deformListeners.delete(listener);
+      },
+      update(dt) {
+        debrisStore.update(dt, { heightAt, gravity, settle });
+        updateSlides();
+        updateFire(dt);
+      },
+      drainDirtyChunks(max2 = budget.maxDirtyChunksPerFrame) {
+        const taken = [];
+        for (const index of dirty) {
+          if (taken.length >= max2) break;
+          dirty.delete(index);
+          taken.push(chunk(index));
+        }
+        return taken;
+      },
+      chunk,
+      marks: () => marks.list,
+      debris: () => debrisStore.list,
+      burningPoints: () => [...burning.keys()].map((key) => {
+        const cellRow = Math.floor(key / 65536);
+        const cellColumn = key - cellRow * 65536;
+        return [x0 + (cellColumn + 0.5) * FIRE_CELL, z0 + (cellRow + 0.5) * FIRE_CELL];
+      }),
+      get marksVersion() {
+        return marks.version;
+      },
+      stats: () => ({ marks: marks.list.length, debris: debrisStore.list.length, debrisMoving: debrisStore.list.filter((piece) => !piece.atRest).length, dirtyChunks: dirty.size, burning: burning.size }),
+      reset,
+      serialize() {
+        return { layout: currentLayout, dug: sparse(dug), loose: sparse(loose), scorch: sparse(scorch), barBend: sparse(barBend), marks: marks.list.map((mark) => ({ ...mark })) };
+      },
+      load(snapshot) {
+        currentLayout = snapshot.layout;
+        reset();
+        fillSparse(dug, snapshot.dug);
+        fillSparse(loose, snapshot.loose);
+        fillSparse(scorch, snapshot.scorch);
+        fillSparse(barBend, snapshot.barBend ?? []);
+        marks.load(snapshot.marks);
+        for (let chunkIndex = 0; chunkIndex < touched.length; chunkIndex++) markChunk(chunkIndex);
+      }
+    };
+  }
+  var PART_ID = "ground";
+  var PART_DEPTH = 3;
+  var RAY_BACKOFF = 1;
+  function createTerrainImpl(terrain, options) {
+    const { id } = options;
+    const [x0, z0, x1, z1] = terrain.bounds;
+    const spec = () => ({
+      name: options.name ?? "Ground",
+      parts: [
+        {
+          id: PART_ID,
+          material: terrain.columnAt((x0 + x1) / 2, (z0 + z1) / 2).material,
+          shape: { kind: "box", size: [x1 - x0, PART_DEPTH, z1 - z0] },
+          position: [(x0 + x1) / 2, -PART_DEPTH / 2, (z0 + z1) / 2],
+          hp: 1e12,
+          anchored: true,
+          tags: ["terrain"]
+        }
+      ],
+      joints: []
+    });
+    const resolve2 = (hit) => {
+      if (hit.type !== "ballistic" && hit.type !== "blunt" && hit.type !== "slash") return hit;
+      if (!hit.direction) return { ...hit, point: [hit.point[0], terrain.heightAt(hit.point[0], hit.point[2]), hit.point[2]] };
+      const [dx, dy, dz] = hit.direction;
+      const from = [hit.point[0] - dx * RAY_BACKOFF, hit.point[1] - dy * RAY_BACKOFF, hit.point[2] - dz * RAY_BACKOFF];
+      const onGround = terrain.raycast(from, hit.direction, RAY_BACKOFF + PART_DEPTH);
+      return onGround ? { ...hit, point: onGround.point } : hit;
+    };
+    return {
+      id,
+      ...options.name ? { name: options.name } : {},
+      describe: spec,
+      hit(hit) {
+        const landed = resolve2(hit);
+        const result2 = terrain.applyHit(landed);
+        if (!result2 || result2.radius <= 0) return [];
+        options.onBlow?.(result2, landed);
+        return [{ type: "damage", object: id, time: 0, part: PART_ID, amount: 0, hp: 1e12, damageType: hit.type, ...hit.source ? { source: hit.source } : {} }];
+      },
+      update(dt) {
+        terrain.update(dt);
+        return [];
+      },
+      state() {
+        return {
+          id,
+          position: [0, 0, 0],
+          rotation: [0, 0, 0, 1],
+          parts: [],
+          joints: [],
+          groups: [[PART_ID]],
+          destroyed: false
+        };
+      },
+      reset: () => terrain.reset(),
+      serialize: () => terrain.serialize(),
+      load: (data) => terrain.load(data)
+    };
+  }
+  var TERRAIN_PATTERNS = ["plain", "grass", "soil", "sand", "asphalt", "concrete", "tile", "planks", "stone"];
+
+  // ../game-terrain-three/dist/index.js
+  var patternIndex = (pattern) => Math.max(0, TERRAIN_PATTERNS.indexOf(pattern ?? "plain"));
+  var SURFACE_GLSL = (
+    /* glsl */
+    `
+float tsHash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+float tsNoise(vec2 p) {
+  vec2 i = floor(p); vec2 f = fract(p); f = f * f * (3.0 - 2.0 * f);
+  return mix(mix(tsHash(i), tsHash(i + vec2(1.0, 0.0)), f.x), mix(tsHash(i + vec2(0.0, 1.0)), tsHash(i + vec2(1.0, 1.0)), f.x), f.y);
+}
+float tsFbm(vec2 p) { return tsNoise(p) * 0.55 + tsNoise(p * 2.3 + 7.1) * 0.3 + tsNoise(p * 5.1 + 3.3) * 0.15; }
+float tsLine(float value, float period, float width) { float d = abs(fract(value / period + 0.5) - 0.5) * period; return 1.0 - smoothstep(width * 0.6, width, d); }
+vec3 terrainSurface(vec3 base, vec2 xz, float kind) {
+  float k = floor(kind + 0.5);
+  if (k < 0.5) return base * (0.86 + 0.28 * tsFbm(xz * 9.0));
+  if (k < 1.5) {
+    float blades = tsNoise(xz * vec2(70.0, 55.0)) * 0.6 + tsNoise(xz * 22.0) * 0.4;
+    float patches = tsFbm(xz * 1.3);
+    return base * (0.55 + 0.8 * blades) * mix(vec3(1.25, 1.05, 0.7), vec3(0.8, 1.1, 0.85), patches);
+  }
+  if (k < 2.5) return base * (0.6 + 0.75 * tsFbm(xz * 6.0)) * (0.82 + 0.36 * tsNoise(xz * 48.0));
+  if (k < 3.5) return base * (0.88 + 0.12 * sin(xz.x * 22.0 + tsFbm(xz * 2.0) * 9.0)) * (0.92 + 0.16 * tsNoise(xz * 90.0));
+  if (k < 4.5) { float grain = tsNoise(xz * 120.0); return base * (0.55 + 1.1 * grain * grain) * (0.85 + 0.3 * tsFbm(xz * 0.8)); }
+  if (k < 5.5) {
+    float joint = max(tsLine(xz.x, 3.0, 0.012), tsLine(xz.y, 3.0, 0.012));
+    return base * (0.82 + 0.3 * tsFbm(xz * 3.5)) * (0.94 + 0.12 * tsNoise(xz * 130.0)) * (1.0 - 0.6 * joint);
+  }
+  if (k < 6.5) {
+    vec2 cell = floor(xz / 0.6);
+    float grout = max(tsLine(xz.x, 0.6, 0.006), tsLine(xz.y, 0.6, 0.006));
+    return mix(base * (0.93 + 0.14 * tsHash(cell)) * (0.97 + 0.06 * tsFbm(xz * 7.0)), vec3(0.14, 0.13, 0.12), grout);
+  }
+  if (k < 7.5) {
+    float row = floor(xz.y / 0.14);
+    float along = xz.x + tsHash(vec2(row, 3.0)) * 2.4;
+    float seam = max(tsLine(xz.y, 0.14, 0.004), tsLine(along, 2.4, 0.004));
+    float grain = tsNoise(vec2(along * 3.0, xz.y * 70.0)) * 0.6 + tsNoise(vec2(along * 11.0, xz.y * 180.0)) * 0.4;
+    return base * (0.72 + 0.56 * tsHash(vec2(row, floor(along / 2.4)))) * (0.75 + 0.5 * grain) * (1.0 - 0.75 * seam);
+  }
+  vec2 cell = floor(xz / 0.22);
+  float seams = max(tsLine(xz.x, 0.22, 0.012), tsLine(xz.y, 0.22, 0.012));
+  return base * (0.7 + 0.6 * tsHash(cell)) * (0.85 + 0.3 * tsFbm(xz * 16.0)) * (1.0 - 0.55 * seams);
+}
+`
+  );
+  function createSurfaceMaterial(THREE) {
+    const material = new THREE.MeshStandardMaterial({ roughness: 0.95, metalness: 0 });
+    material.onBeforeCompile = (shader) => {
+      shader.vertexShader = shader.vertexShader.replace("#include <common>", "#include <common>\nattribute float aPattern;\nattribute vec3 aBase;\nattribute vec2 aShade;\nflat varying float vPattern;\nflat varying vec3 vBase;\nvarying vec2 vShade;\nvarying vec2 vGroundXZ;").replace("#include <begin_vertex>", "#include <begin_vertex>\nvPattern = aPattern;\nvBase = aBase;\nvShade = aShade;\nvGroundXZ = position.xz;");
+      shader.fragmentShader = shader.fragmentShader.replace("#include <common>", `#include <common>
+flat varying float vPattern;
+flat varying vec3 vBase;
+varying vec2 vShade;
+varying vec2 vGroundXZ;
+${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment>\ndiffuseColor.rgb = mix(terrainSurface(vBase, vGroundXZ, vPattern), vec3(0.012, 0.011, 0.01), vShade.y) * vShade.x;");
+    };
+    material.customProgramCacheKey = () => "game-terrain-surface";
+    return material;
+  }
+  var DEPTH_SHADE = 1.6;
+  var MIN_DEPTH_LIGHT = 0.55;
+  var LOOSE_VISIBLE = 4e-3;
+  var THIN_SKIN = 0.1;
+  var SKIRT_QUADS = 4;
+  var BROKEN_DEPTH = 4e-3;
+  var BROKEN_TONE = 0.62;
+  function vertexLook(terrain, column, row, base, shade) {
+    const index = row * terrain.stride + column;
+    let material = terrain.vertexMaterial(column, row);
+    if (terrain.loose[index] > LOOSE_VISIBLE) {
+      const profile = terrain.profileList[terrain.profileIndex[index]];
+      const first = profile.strata[0];
+      material = terrain.material(first.thickness < THIN_SKIN && profile.strata[1] ? profile.strata[1].material : first.material);
+    }
+    const broken = material.pattern === "concrete" && terrain.dug[index] > BROKEN_DEPTH;
+    const tone = broken ? BROKEN_TONE : 1;
+    base[0] = material.color[0] * tone;
+    base[1] = material.color[1] * tone;
+    base[2] = material.color[2] * tone;
+    shade[0] = Math.max(MIN_DEPTH_LIGHT, 1 - terrain.dug[index] / DEPTH_SHADE);
+    shade[1] = terrain.scorch[index];
+    return patternIndex(broken ? "soil" : material.pattern);
+  }
+  function buildChunkGeometry(THREE, terrain, chunk, step) {
+    const [x0, z0] = terrain.bounds;
+    const { cellSize, columns, rows } = terrain;
+    const lastColumn = Math.min(columns, chunk.column + chunk.cells);
+    const lastRow = Math.min(rows, chunk.row + chunk.cells);
+    const across = Math.ceil((lastColumn - chunk.column) / step) + 1;
+    const down = Math.ceil((lastRow - chunk.row) / step) + 1;
+    const positions = new Float32Array(across * down * 3);
+    const normals = new Float32Array(across * down * 3);
+    const bases = new Float32Array(across * down * 3);
+    const shades = new Float32Array(across * down * 2);
+    const patterns = new Float32Array(across * down);
+    const base = [0, 0, 0];
+    const shade = [1, 0];
+    let at3 = 0;
+    for (let j = 0; j < down; j++) {
+      const row = Math.min(lastRow, chunk.row + j * step);
+      for (let i = 0; i < across; i++) {
+        const column = Math.min(lastColumn, chunk.column + i * step);
+        const height = terrain.vertexHeight(column, row);
+        positions[at3 * 3] = x0 + column * cellSize;
+        positions[at3 * 3 + 1] = height;
+        positions[at3 * 3 + 2] = z0 + row * cellSize;
+        const left = terrain.vertexHeight(Math.max(0, column - 1), row);
+        const right = terrain.vertexHeight(Math.min(columns, column + 1), row);
+        const back = terrain.vertexHeight(column, Math.max(0, row - 1));
+        const front = terrain.vertexHeight(column, Math.min(rows, row + 1));
+        const nx = left - right;
+        const ny = 2 * cellSize;
+        const nz = back - front;
+        const length3 = Math.hypot(nx, ny, nz);
+        normals[at3 * 3] = nx / length3;
+        normals[at3 * 3 + 1] = ny / length3;
+        normals[at3 * 3 + 2] = nz / length3;
+        patterns[at3] = vertexLook(terrain, column, row, base, shade);
+        bases.set(base, at3 * 3);
+        shades.set(shade, at3 * 2);
+        at3++;
+      }
+    }
+    const indices = new Uint32Array((across - 1) * (down - 1) * 6);
+    let cursor = 0;
+    for (let j = 0; j < down - 1; j++) {
+      for (let i = 0; i < across - 1; i++) {
+        const a = j * across + i;
+        const b = a + 1;
+        const c = a + across;
+        const d = c + 1;
+        indices[cursor++] = a;
+        indices[cursor++] = c;
+        indices[cursor++] = b;
+        indices[cursor++] = c;
+        indices[cursor++] = d;
+        indices[cursor++] = b;
+      }
+    }
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
+    geometry.setAttribute("normal", new THREE.BufferAttribute(normals, 3));
+    geometry.setAttribute("aBase", new THREE.BufferAttribute(bases, 3));
+    geometry.setAttribute("aShade", new THREE.BufferAttribute(shades, 2));
+    geometry.setAttribute("aPattern", new THREE.BufferAttribute(patterns, 1));
+    geometry.setIndex(new THREE.BufferAttribute(indices, 1));
+    return geometry;
+  }
+  function buildPristineGeometry(THREE, terrain, chunks, skirt) {
+    const [x0, z0] = terrain.bounds;
+    const { cellSize, columns, rows } = terrain;
+    const [, , x1, z1] = terrain.bounds;
+    const quads = chunks.length + SKIRT_QUADS;
+    const positions = new Float32Array(quads * 12);
+    const normals = new Float32Array(quads * 12);
+    const bases = new Float32Array(quads * 12);
+    const shades = new Float32Array(quads * 8);
+    const patterns = new Float32Array(quads * 4);
+    const indices = new Uint32Array(quads * 6);
+    const base = [0, 0, 0];
+    const shade = [1, 0];
+    chunks.forEach((chunk, n) => {
+      const lastColumn = Math.min(columns, chunk.column + chunk.cells);
+      const lastRow = Math.min(rows, chunk.row + chunk.cells);
+      const corners = [[chunk.column, chunk.row], [lastColumn, chunk.row], [chunk.column, lastRow], [lastColumn, lastRow]];
+      const pattern = vertexLook(terrain, chunk.column, chunk.row, base, shade);
+      corners.forEach(([column, row], corner) => {
+        const at3 = n * 4 + corner;
+        positions[at3 * 3] = x0 + column * cellSize;
+        positions[at3 * 3 + 1] = terrain.vertexHeight(column, row);
+        positions[at3 * 3 + 2] = z0 + row * cellSize;
+        normals[at3 * 3 + 1] = 1;
+        bases.set(base, at3 * 3);
+        shades.set(shade, at3 * 2);
+        patterns[at3] = pattern;
+      });
+      const first = n * 4;
+      indices.set([first, first + 2, first + 1, first + 2, first + 3, first + 1], n * 6);
+    });
+    const surface = terrain.material(terrain.profileList.find((profile) => profile.id === terrain.layout().surface)?.strata[0]?.material ?? terrain.profileList[terrain.profileIndex[0]].strata[0].material);
+    const rects = [
+      [x0 - skirt, z0 - skirt, x1 + skirt, z0],
+      [x0 - skirt, z1, x1 + skirt, z1 + skirt],
+      [x0 - skirt, z0, x0, z1],
+      [x1, z0, x1 + skirt, z1]
+    ];
+    rects.forEach(([ax, az, bx, bz], r) => {
+      const n = chunks.length + r;
+      const corners = [[ax, az], [bx, az], [ax, bz], [bx, bz]];
+      corners.forEach(([x, z], corner) => {
+        const at3 = n * 4 + corner;
+        positions[at3 * 3] = x;
+        positions[at3 * 3 + 2] = z;
+        normals[at3 * 3 + 1] = 1;
+        bases.set(surface.color, at3 * 3);
+        shades[at3 * 2] = 1;
+        patterns[at3] = patternIndex(surface.pattern);
+      });
+      const first = n * 4;
+      indices.set([first, first + 2, first + 1, first + 2, first + 3, first + 1], n * 6);
+    });
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
+    geometry.setAttribute("normal", new THREE.BufferAttribute(normals, 3));
+    geometry.setAttribute("aBase", new THREE.BufferAttribute(bases, 3));
+    geometry.setAttribute("aShade", new THREE.BufferAttribute(shades, 2));
+    geometry.setAttribute("aPattern", new THREE.BufferAttribute(patterns, 1));
+    geometry.setIndex(new THREE.BufferAttribute(indices, 1));
+    return geometry;
+  }
+  var MARK_LIFT = 6e-3;
+  var MARK_REACH = 1.5;
+  var MARK_TEXTURE_SIZE = 64;
+  var MARK_DARKEN = 0.85;
+  var PIECE_SHAPE = { clods: [1, 0.85, 1], chips: [1, 0.6, 0.8], shards: [1.3, 0.2, 1], splinters: [0.3, 0.25, 2.4], dust: [1, 0.8, 1] };
+  function createMarkTexture(THREE) {
+    const size = MARK_TEXTURE_SIZE;
+    const data = new Uint8Array(size * size * 4);
+    for (let y = 0; y < size; y++) {
+      for (let x = 0; x < size; x++) {
+        const u = (x + 0.5) / size - 0.5;
+        const v = (y + 0.5) / size - 0.5;
+        const angle = Math.atan2(v, u);
+        const lobes = 0.86 + 0.09 * Math.sin(angle * 5) + 0.05 * Math.sin(angle * 13 + 1);
+        const q = Math.hypot(u, v) / (0.5 * lobes);
+        const shade = q < 0.55 ? 0.42 + q * 0.5 : 0.7 + (q - 0.55) * 0.8;
+        const at3 = (y * size + x) * 4;
+        data[at3] = data[at3 + 1] = data[at3 + 2] = Math.round(Math.min(1, shade) * 255);
+        data[at3 + 3] = q < 0.8 ? 255 : q < 1 ? Math.round((1 - (q - 0.8) / 0.2) * 255) : 0;
+      }
+    }
+    const texture = new THREE.DataTexture(data, size, size, THREE.RGBAFormat);
+    texture.magFilter = THREE.LinearFilter;
+    texture.minFilter = THREE.LinearFilter;
+    texture.needsUpdate = true;
+    return texture;
+  }
+  function createMarkLayer2(THREE, terrain, drawDistance) {
+    const geometry = new THREE.PlaneGeometry(1, 1);
+    geometry.rotateX(-Math.PI / 2);
+    const texture = createMarkTexture(THREE);
+    const material = new THREE.MeshStandardMaterial({ map: texture, transparent: true, depthWrite: false, roughness: 1, polygonOffset: true, polygonOffsetFactor: -2, polygonOffsetUnits: -2 });
+    const mesh2 = new THREE.InstancedMesh(geometry, material, terrain.budget.maxMarks);
+    mesh2.name = "terrain-marks";
+    mesh2.count = 0;
+    mesh2.frustumCulled = false;
+    mesh2.receiveShadow = true;
+    mesh2.renderOrder = 1;
+    const matrix = new THREE.Matrix4();
+    const rotation = new THREE.Matrix4();
+    const scale2 = new THREE.Matrix4();
+    const colour = new THREE.Color();
+    let seen = "";
+    let cameraX = Infinity;
+    let cameraZ = Infinity;
+    return {
+      mesh: mesh2,
+      sync(camera2) {
+        const marks = terrain.marks();
+        let blows = 0;
+        for (const mark of marks) blows += mark.count;
+        const stamp = `${terrain.marksVersion}:${blows}`;
+        if (stamp === seen && Math.hypot(camera2.x - cameraX, camera2.z - cameraZ) < 5) return;
+        seen = stamp;
+        cameraX = camera2.x;
+        cameraZ = camera2.z;
+        let count = 0;
+        for (const mark of marks) {
+          if (Math.hypot(mark.x - camera2.x, mark.z - camera2.z) > drawDistance) continue;
+          const size = mark.radius * 2 * MARK_REACH;
+          rotation.makeRotationY(mark.id * 2.399);
+          scale2.makeScale(size, 1, size);
+          matrix.multiplyMatrices(rotation, scale2);
+          matrix.setPosition(mark.x, terrain.heightAt(mark.x, mark.z) + MARK_LIFT, mark.z);
+          mesh2.setMatrixAt(count, matrix);
+          const [r, g, b] = terrain.material(mark.material).color;
+          colour.setRGB(r * MARK_DARKEN + 0.04, g * MARK_DARKEN + 0.04, b * MARK_DARKEN + 0.04);
+          mesh2.setColorAt(count, colour);
+          count++;
+        }
+        mesh2.count = count;
+        mesh2.instanceMatrix.needsUpdate = true;
+        if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
+      },
+      dispose() {
+        geometry.dispose();
+        material.dispose();
+        texture.dispose();
+        mesh2.removeFromParent();
+      }
+    };
+  }
+  function createDebrisLayer(THREE, terrain) {
+    const geometry = new THREE.IcosahedronGeometry(1, 0);
+    const material = new THREE.MeshStandardMaterial({ roughness: 0.95, flatShading: true });
+    const mesh2 = new THREE.InstancedMesh(geometry, material, terrain.budget.maxDebris);
+    mesh2.name = "terrain-debris";
+    mesh2.count = 0;
+    mesh2.castShadow = true;
+    mesh2.frustumCulled = false;
+    const matrix = new THREE.Matrix4();
+    const position = new THREE.Vector3();
+    const scale2 = new THREE.Vector3();
+    const quaternion = new THREE.Quaternion();
+    const euler = new THREE.Euler();
+    const colour = new THREE.Color();
+    return {
+      mesh: mesh2,
+      sync() {
+        const pieces = terrain.debris();
+        let count = 0;
+        for (const piece of pieces) {
+          const [x, y, z] = piece.position;
+          const travelled = x * 1.7 + z * 1.3 + y;
+          euler.set(piece.spin[0] * travelled * 0.2 + piece.id, piece.spin[1] * travelled * 0.2, piece.spin[2] * travelled * 0.2);
+          const shape = PIECE_SHAPE[piece.kind];
+          scale2.set(shape[0] * piece.radius, shape[1] * piece.radius, shape[2] * piece.radius);
+          matrix.compose(position.set(x, y, z), quaternion.setFromEuler(euler), scale2);
+          mesh2.setMatrixAt(count, matrix);
+          const [r, g, b] = terrain.material(piece.material).color;
+          const tone = 0.85 + piece.id * 37 % 30 / 100;
+          mesh2.setColorAt(count, colour.setRGB(r * tone, g * tone, b * tone));
+          count++;
+        }
+        mesh2.count = count;
+        mesh2.instanceMatrix.needsUpdate = true;
+        if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
+      },
+      dispose() {
+        geometry.dispose();
+        material.dispose();
+        mesh2.removeFromParent();
+      }
+    };
+  }
+  var BAR_RADIUS = 6e-3;
+  var EXPOSED_MARGIN = 2e-3;
+  var MAX_SAG = 0.07;
+  function buildRebarGeometry(THREE, terrain, chunk) {
+    const [x0, z0] = terrain.bounds;
+    const { cellSize, columns, rows, stride } = terrain;
+    const lastColumn = Math.min(columns, chunk.column + chunk.cells);
+    const lastRow = Math.min(rows, chunk.row + chunk.cells);
+    const boxes = [];
+    const coverOf = (index) => {
+      let top = 0;
+      for (const stratum of terrain.profileList[terrain.profileIndex[index]].strata) {
+        if (stratum.reinforcement) return { depth: top + stratum.reinforcement.cover, spacing: stratum.reinforcement.spacing };
+        top += stratum.thickness;
+      }
+      return null;
+    };
+    const showing = (index, depth) => {
+      const profile = terrain.profileList[terrain.profileIndex[index]];
+      const limit = profile.strata.reduce((sum2, stratum) => sum2 + stratum.thickness, 0);
+      return terrain.dug[index] > depth + EXPOSED_MARGIN && terrain.dug[index] <= limit + EXPOSED_MARGIN;
+    };
+    const onBar = (coordinate, spacing) => Math.floor(coordinate / spacing) !== Math.floor((coordinate + cellSize) / spacing);
+    const addBox = (ax, az, bx, bz, y) => {
+      boxes.push(Math.min(ax, bx) - BAR_RADIUS, y - BAR_RADIUS, Math.min(az, bz) - BAR_RADIUS, Math.max(ax, bx) + BAR_RADIUS, y + BAR_RADIUS, Math.max(az, bz) + BAR_RADIUS);
+    };
+    for (let row = chunk.row; row <= lastRow; row++) {
+      for (let column = chunk.column; column <= lastColumn; column++) {
+        const index = row * stride + column;
+        const cover = coverOf(index);
+        if (!cover || !showing(index, cover.depth)) continue;
+        const x = x0 + column * cellSize;
+        const z = z0 + row * cellSize;
+        const y = -cover.depth - BAR_RADIUS - Math.min(1, terrain.barBend[index]) * MAX_SAG;
+        if (onBar(z, cover.spacing) && column < lastColumn && showing(index + 1, cover.depth)) addBox(x, z, x + cellSize, z, y);
+        if (onBar(x, cover.spacing) && row < lastRow && showing(index + stride, cover.depth)) addBox(x, z, x, z + cellSize, y);
+      }
+    }
+    if (boxes.length === 0) return null;
+    const count = boxes.length / 6;
+    const positions = new Float32Array(count * 24 * 3);
+    const normals = new Float32Array(count * 24 * 3);
+    const indices = new Uint32Array(count * 36);
+    const FACES2 = [
+      [[0, 4, 2, 0, 4, 5, 3, 4, 5, 3, 4, 2], [0, 1, 0]],
+      [[0, 1, 5, 0, 1, 2, 3, 1, 2, 3, 1, 5], [0, -1, 0]],
+      [[0, 1, 5, 3, 1, 5, 3, 4, 5, 0, 4, 5], [0, 0, 1]],
+      [[3, 1, 2, 0, 1, 2, 0, 4, 2, 3, 4, 2], [0, 0, -1]],
+      [[3, 1, 5, 3, 1, 2, 3, 4, 2, 3, 4, 5], [1, 0, 0]],
+      [[0, 1, 2, 0, 1, 5, 0, 4, 5, 0, 4, 2], [-1, 0, 0]]
+    ];
+    let vertex = 0;
+    let cursor = 0;
+    for (let n = 0; n < count; n++) {
+      const box2 = boxes.slice(n * 6, n * 6 + 6);
+      for (const [corners, normal] of FACES2) {
+        const first = vertex;
+        for (let c = 0; c < 4; c++) {
+          positions[vertex * 3] = box2[corners[c * 3]];
+          positions[vertex * 3 + 1] = box2[corners[c * 3 + 1]];
+          positions[vertex * 3 + 2] = box2[corners[c * 3 + 2]];
+          normals.set(normal, vertex * 3);
+          vertex++;
+        }
+        indices.set([first, first + 1, first + 2, first, first + 2, first + 3], cursor);
+        cursor += 6;
+      }
+    }
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
+    geometry.setAttribute("normal", new THREE.BufferAttribute(normals, 3));
+    geometry.setIndex(new THREE.BufferAttribute(indices, 1));
+    return geometry;
+  }
+  var DEFAULT_LOD_DISTANCE = 30;
+  var DEFAULT_MARK_DISTANCE = 45;
+  var DEFAULT_SKIRT = 300;
+  var LOD_CHECK_METRES = 4;
+  var REBAR_COLOUR = 4863272;
+  function createTerrainRenderer(THREE, options) {
+    const { terrain } = options;
+    const lodDistance = options.lodDistance ?? DEFAULT_LOD_DISTANCE;
+    const skirt = options.skirt ?? DEFAULT_SKIRT;
+    const group = markKitOrigin(new THREE.Group(), { owner: "game-terrain-three", kind: "ground" });
+    group.name = "floor";
+    const surface = createSurfaceMaterial(THREE);
+    const rebarMaterial = new THREE.MeshStandardMaterial({ color: REBAR_COLOUR, roughness: 0.75, metalness: 0.35 });
+    const pristineMesh = new THREE.Mesh(new THREE.BufferGeometry(), surface);
+    pristineMesh.receiveShadow = true;
+    pristineMesh.name = "terrain-pristine";
+    pristineMesh.frustumCulled = false;
+    group.add(pristineMesh);
+    const drawn = /* @__PURE__ */ new Map();
+    const marks = createMarkLayer2(THREE, terrain, options.markDistance ?? DEFAULT_MARK_DISTANCE);
+    const debris2 = createDebrisLayer(THREE, terrain);
+    group.add(marks.mesh, debris2.mesh);
+    let pristineStale = true;
+    let pristineCount = 0;
+    let lodX = Infinity;
+    let lodZ = Infinity;
+    let firstSync = true;
+    const distanceTo = (chunk, camera2) => {
+      const half = chunk.cells * terrain.cellSize / 2;
+      const centreX = terrain.bounds[0] + chunk.column * terrain.cellSize + half;
+      const centreZ = terrain.bounds[1] + chunk.row * terrain.cellSize + half;
+      return Math.hypot(centreX - camera2.x, centreZ - camera2.z);
+    };
+    const stepFor = (distance4) => distance4 > lodDistance * 2 ? 4 : distance4 > lodDistance ? 2 : 1;
+    function drop(index) {
+      const entry = drawn.get(index);
+      if (!entry) return;
+      group.remove(entry.mesh);
+      entry.mesh.geometry.dispose();
+      if (entry.rebar) {
+        group.remove(entry.rebar);
+        entry.rebar.geometry.dispose();
+      }
+      drawn.delete(index);
+    }
+    function draw2(chunk, camera2) {
+      drop(chunk.index);
+      const step = stepFor(distanceTo(chunk, camera2));
+      const mesh2 = new THREE.Mesh(buildChunkGeometry(THREE, terrain, chunk, step), surface);
+      mesh2.receiveShadow = true;
+      group.add(mesh2);
+      const bars = buildRebarGeometry(THREE, terrain, chunk);
+      let rebar = null;
+      if (bars) {
+        rebar = new THREE.Mesh(bars, rebarMaterial);
+        rebar.castShadow = true;
+        group.add(rebar);
+      }
+      drawn.set(chunk.index, { mesh: mesh2, rebar, step });
+    }
+    function rebuildPristine() {
+      const chunks = [];
+      for (let index = 0; index < terrain.chunksX * terrain.chunksZ; index++) {
+        const chunk = terrain.chunk(index);
+        if (chunk.pristine) chunks.push(chunk);
+      }
+      pristineMesh.geometry.dispose();
+      pristineMesh.geometry = buildPristineGeometry(THREE, terrain, chunks, skirt);
+      pristineCount = chunks.length;
+      pristineStale = false;
+    }
+    return {
+      group,
+      sync(camera2) {
+        const limit = firstSync ? Infinity : void 0;
+        firstSync = false;
+        for (const chunk of terrain.drainDirtyChunks(limit)) {
+          if (chunk.pristine) {
+            if (drawn.has(chunk.index)) drop(chunk.index);
+            pristineStale = true;
+          } else {
+            if (!drawn.has(chunk.index)) pristineStale = true;
+            draw2(chunk, camera2);
+          }
+        }
+        if (pristineStale) rebuildPristine();
+        if (Math.hypot(camera2.x - lodX, camera2.z - lodZ) > LOD_CHECK_METRES) {
+          lodX = camera2.x;
+          lodZ = camera2.z;
+          for (const [index, entry] of drawn) {
+            const chunk = terrain.chunk(index);
+            if (stepFor(distanceTo(chunk, camera2)) !== entry.step) draw2(chunk, camera2);
+          }
+        }
+        marks.sync(camera2);
+        debris2.sync();
+      },
+      stats: () => ({ chunkMeshes: drawn.size, pristineChunks: pristineCount, marksDrawn: marks.mesh.count, debrisDrawn: debris2.mesh.count }),
+      dispose() {
+        for (const index of [...drawn.keys()]) drop(index);
+        pristineMesh.geometry.dispose();
+        surface.dispose();
+        rebarMaterial.dispose();
+        marks.dispose();
+        debris2.dispose();
+        group.removeFromParent();
+      }
+    };
+  }
+  var TERRAIN_STRIPS = ["dirt", "lawn", "sand", "road", "concrete_slab", "suspended_slab", "wood_floor", "tile_floor", "stone_paving"];
+  var STRIP_WIDTH = 3;
+  var STRIP_Z0 = 4;
+  var STRIP_Z1 = 13;
+  var stripRect = (index) => {
+    const x0 = (index - TERRAIN_STRIPS.length / 2) * STRIP_WIDTH;
+    return [x0, STRIP_Z0, x0 + STRIP_WIDTH, STRIP_Z1];
+  };
+  var TERRAIN_AREA_GROUND = {
+    surface: "concrete_slab",
+    zones: TERRAIN_STRIPS.map((surface, index) => ({ rect: stripRect(index), surface }))
+  };
+
   // src/avatar.ts
   var DEFAULT_STRIKE_CLIPS = { hand: "punch_right", fists: "punch_right", shove: "shove_two_hands", kick: "front_kick" };
   var DEFAULT_HAND_STANCES = { fists: "fists" };
@@ -40600,6 +43157,8 @@ void main(){
       "act.strike.hand": "{weapon}: {clip} with the {hand} hand begins, impact in {seconds} s",
       "hand.left": "left",
       "hand.right": "right",
+      "act.combo.on": "{name}: on (each blow follows the sequence)",
+      "act.combo.off": "{name}: off",
       "act.flame.hit": "{weapon}: flame at {temp} \xB0C on {where}",
       "act.flame.air": "{weapon}: flame, nothing in range",
       "act.heat.hit": "{weapon}: heating {where} at {temp} \xB0C",
@@ -40623,8 +43182,10 @@ void main(){
       "act.extinguish.hit": "{weapon}: foam on {what}",
       "act.extinguish.air": "{weapon}: foam, nothing in range",
       "act.grab": "Grabbed {name} ({kg} kg)",
+      "act.bump": "Pushed {name} ({kg} kg) walking into it",
       "act.drop": "Dropped {name}",
       "act.throw": "Threw {name} at {speed} m/s",
+      "ground.name": "Ground",
       "act.landing": "{name} landed at {speed} m/s: {energy} J",
       "act.bench_failed": "{name} failed: {error}",
       "loading.working": "Working\u2026",
@@ -40658,6 +43219,14 @@ void main(){
       "hud.nothing_to_grab": "Nothing to grab here",
       "hud.cannot_grab": "{name} cannot be picked up",
       "hud.too_heavy": "{name} is too heavy ({kg} kg)",
+      "hud.push_on": "Pushing {name}: W pushes, S pulls, let go of E to stop",
+      "hud.push_too_heavy": "{name} does not budge ({kg} kg)",
+      "hud.push_blocked": "{name} is stuck: there is something in the way",
+      "act.push_grip": "leans on {name} ({kg} kg)",
+      "act.push_engaged": "starts pushing {name} ({kg} kg)",
+      "act.push_too_heavy": "strains against {name}: {kg} kg is too much",
+      "act.push_obstacle": "{name} hits something and locks",
+      "act.push_release": "lets go of {name}",
       "hud.empty_container": "{name} is empty",
       "hud.refused": "Wrong tool for the {kind}",
       "hud.drop": "drop",
@@ -40665,7 +43234,7 @@ void main(){
       "hud.throw": "throw",
       "hud.tilt": "tilt (hold)",
       "hud.equip": "equip {weapon}",
-      "ui.help": "Click: look \xB7 WASD: walk \xB7 Shift: run \xB7 C: crouch \xB7 Space: jump \xB7 1-0 / wheel: tool \xB7 LMB: use (bare hands: punch) \xB7 E: grab/drop \xB7 G or RMB: throw \xB7 R: reload \xB7 Q: fire mode \xB7 X: clear a jam \xB7 B: safety \xB7 Y: detonate charges set down \xB7 Tab: panels \xB7 Esc: free the mouse",
+      "ui.help": "Click: look \xB7 WASD: walk \xB7 Shift: run \xB7 C: crouch (tap stays, hold while pressed) \xB7 Space: jump \xB7 1-0 / wheel: tool \xB7 LMB: use (bare hands: punch) \xB7 E: grab/drop (hold against furniture: push) \xB7 G or RMB: throw \xB7 R: reload \xB7 Q: fire mode \xB7 X: clear a jam \xB7 B: safety \xB7 Y: detonate charges set down \xB7 K: kick \xB7 N: strike combo on/off \xB7 Tab: panels \xB7 Esc: free the mouse",
       "ui.help.camera": "V: 1st/3rd person (Shift+V: kick)",
       "camera.first": "1st person",
       "camera.third": "3rd person",
@@ -40712,6 +43281,7 @@ void main(){
       "ui.slow": "Slow motion 0.25\xD7",
       "ui.fast": "Time \xD710",
       "ui.tap": "Tap",
+      "ui.kick": "Kick",
       "ui.fullscreen": "Full screen",
       "ui.fullscreen.hint": "Full screen opened from here keeps the whole keyboard in the game, Ctrl+W included (F11 does not)",
       "ui.blast.shelter": "Shelter",
@@ -40911,6 +43481,8 @@ void main(){
       "act.strike.hand": "{weapon}: {clip} com a m\xE3o {hand} come\xE7a, impacto em {seconds} s",
       "hand.left": "esquerda",
       "hand.right": "direita",
+      "act.combo.on": "{name}: ligada (cada golpe segue a sequ\xEAncia)",
+      "act.combo.off": "{name}: desligada",
       "act.flame.hit": "{weapon}: chama a {temp} \xB0C em {where}",
       "act.flame.air": "{weapon}: chama, nada ao alcance",
       "act.heat.hit": "{weapon}: esquentando {where} a {temp} \xB0C",
@@ -40934,8 +43506,10 @@ void main(){
       "act.extinguish.hit": "{weapon}: espuma em {what}",
       "act.extinguish.air": "{weapon}: espuma, nada ao alcance",
       "act.grab": "Pegou {name} ({kg} kg)",
+      "act.bump": "Empurrou {name} ({kg} kg) ao esbarrar",
       "act.drop": "Soltou {name}",
       "act.throw": "Arremessou {name} a {speed} m/s",
+      "ground.name": "Ch\xE3o",
       "act.landing": "{name} caiu a {speed} m/s: {energy} J",
       "act.bench_failed": "{name} falhou: {error}",
       "loading.working": "Trabalhando\u2026",
@@ -40969,6 +43543,14 @@ void main(){
       "hud.nothing_to_grab": "Nada para pegar aqui",
       "hud.cannot_grab": "{name} n\xE3o d\xE1 para pegar",
       "hud.too_heavy": "{name} \xE9 pesado demais ({kg} kg)",
+      "hud.push_on": "Empurrando {name}: W empurra, S puxa, solte o E para parar",
+      "hud.push_too_heavy": "{name} n\xE3o se mexe ({kg} kg)",
+      "hud.push_blocked": "{name} travou: tem algo no caminho",
+      "act.push_grip": "encosta em {name} ({kg} kg)",
+      "act.push_engaged": "come\xE7a a empurrar {name} ({kg} kg)",
+      "act.push_too_heavy": "faz for\xE7a contra {name}: {kg} kg \xE9 demais",
+      "act.push_obstacle": "{name} bate em algo e trava",
+      "act.push_release": "solta {name}",
       "hud.empty_container": "{name} est\xE1 vazio",
       "hud.refused": "Ferramenta errada para {kind}",
       "hud.drop": "soltar",
@@ -40976,7 +43558,7 @@ void main(){
       "hud.throw": "arremessar",
       "hud.tilt": "inclinar (segurar)",
       "hud.equip": "equipar {weapon}",
-      "ui.help": "Clique: olhar \xB7 WASD: andar \xB7 Shift: correr \xB7 C: agachar \xB7 Espa\xE7o: pular \xB7 1-0 / roda: ferramenta \xB7 bot\xE3o esquerdo: usar (m\xE3o livre: soco) \xB7 E: pegar/soltar \xB7 G ou bot\xE3o direito: arremessar \xB7 R: recarregar \xB7 Q: modo de tiro \xB7 X: destravar \xB7 B: trava \xB7 Y: detonar cargas postas \xB7 Tab: pain\xE9is \xB7 Esc: soltar o mouse",
+      "ui.help": "Clique: olhar \xB7 WASD: andar \xB7 Shift: correr \xB7 C: agachar (toque fixa, segurar s\xF3 enquanto aperta) \xB7 Espa\xE7o: pular \xB7 1-0 / roda: ferramenta \xB7 bot\xE3o esquerdo: usar (m\xE3o livre: soco) \xB7 E: pegar/soltar (segurar encostado no m\xF3vel: empurrar) \xB7 G ou bot\xE3o direito: arremessar \xB7 R: recarregar \xB7 Q: modo de tiro \xB7 X: destravar \xB7 B: trava \xB7 Y: detonar cargas postas \xB7 K: chute \xB7 N: liga/desliga a sequ\xEAncia de golpes \xB7 Tab: pain\xE9is \xB7 Esc: soltar o mouse",
       "ui.help.camera": "V: 1\xAA/3\xAA pessoa (Shift+V: chute)",
       "camera.first": "1\xAA pessoa",
       "camera.third": "3\xAA pessoa",
@@ -41023,6 +43605,7 @@ void main(){
       "ui.slow": "C\xE2mera lenta 0,25\xD7",
       "ui.fast": "Tempo \xD710",
       "ui.tap": "Torneira",
+      "ui.kick": "Chute",
       "ui.fullscreen": "Tela cheia",
       "ui.fullscreen.hint": "A tela cheia aberta por aqui segura o teclado todo no jogo, inclusive Ctrl+W (o F11 n\xE3o)",
       "ui.blast.shelter": "Abrigo",
@@ -41489,6 +44072,8 @@ void main(){
 .tr-cross{position:absolute;left:50%;top:50%;width:18px;height:18px;margin:-9px 0 0 -9px}
 .tr-cross:before,.tr-cross:after{content:"";position:absolute;background:#fff;opacity:.85;box-shadow:0 0 2px #000}
 .tr-cross:before{left:8px;top:0;width:2px;height:18px}.tr-cross:after{top:8px;left:0;height:2px;width:18px}
+.tr-ring{position:absolute;left:50%;top:50%;width:64px;height:64px;margin:-32px 0 0 -32px;transform:rotate(-90deg);display:none;pointer-events:none;filter:drop-shadow(0 0 2px #000)}
+.tr-ring circle{fill:none;stroke-width:5}.tr-ring .tr-ring-bg{stroke:rgba(255,255,255,.25)}.tr-ring .tr-ring-fill{stroke:#ffd166;stroke-linecap:round}
 .tr-cross i{position:absolute;left:6px;top:6px;width:6px;height:6px;background:#0b0c0e;border-radius:50%;z-index:1}
 .tr-top{position:absolute;top:8px;left:50%;transform:translateX(-50%);text-align:center;max-width:46vw}
 .tr-tool{display:inline-block;background:rgba(10,12,16,.72);padding:4px 12px;border-radius:6px;font-size:14px;font-weight:600}
@@ -41592,6 +44177,22 @@ void main(){
     o.container.appendChild(root);
     const cross5 = mk3("div", "tr-cross");
     cross5.appendChild(mk3("i"));
+    const ring2 = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+    ring2.setAttribute("class", "tr-ring");
+    ring2.setAttribute("viewBox", "0 0 64 64");
+    const ringCircle = (className) => {
+      const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");
+      circle.setAttribute("class", className);
+      circle.setAttribute("cx", "32");
+      circle.setAttribute("cy", "32");
+      circle.setAttribute("r", "27");
+      ring2.appendChild(circle);
+      return circle;
+    };
+    ringCircle("tr-ring-bg");
+    const ringFill = ringCircle("tr-ring-fill");
+    const RING_LENGTH = 2 * Math.PI * 27;
+    ringFill.style.strokeDasharray = String(RING_LENGTH);
     const top = mk3("div", "tr-top");
     const toolBox = mk3("div", "tr-tool");
     const status = mk3("div", "tr-status");
@@ -41793,6 +44394,8 @@ void main(){
       o.onFast(fast);
     });
     const tapBtn = ctl(t("ui.tap"), () => o.onTap());
+    const comboBtn = o.combo ? ctl(`${o.combo.label} (N)`, () => o.combo.onToggle()) : null;
+    if (o.kick) ctl(o.kick.label, () => o.kick.onKick());
     const fullscreenBtn = ctl(t("ui.fullscreen"), () => void toggleFullscreen());
     fullscreenBtn.title = t("ui.fullscreen.hint");
     const blastBtns = ["shelter", "fragmentHits", "confinement"].map((key) => ({ key, b: ctl(t(`ui.blast.${key}`), () => o.onBlast(key)) }));
@@ -41875,7 +44478,7 @@ void main(){
       o.onResize();
     };
     toggle.onclick = togglePanels;
-    root.append(cross5, top, bottom, help, left, right, toggle);
+    root.append(cross5, ring2, top, bottom, help, left, right, toggle);
     const bar2 = (value, max2, cls) => {
       const b = mk3("div", `tr-bar ${cls}`);
       const i = mk3("i");
@@ -41956,6 +44559,10 @@ void main(){
     let lastInspect = "";
     let hudPage = 0;
     const api = {
+      holdRing(value) {
+        ring2.style.display = value === null ? "none" : "block";
+        if (value !== null) ringFill.style.strokeDashoffset = String(RING_LENGTH * (1 - value));
+      },
       hud(s) {
         toolBox.textContent = "";
         toolBox.append(document.createTextNode(s.toolName));
@@ -42004,6 +44611,7 @@ void main(){
         }
         slotsEl.forEach((b, i) => b.classList.toggle("on", i === s.slot));
         tapBtn.classList.toggle("on", s.tap);
+        comboBtn?.classList.toggle("on", !!s.combo);
         for (const { key: key2, b } of blastBtns) b.classList.toggle("on", s.blast[key2]);
         count.textContent = t("ui.objects", { n: s.objects });
         const ak = JSON.stringify(s.animations);
@@ -42053,6 +44661,18 @@ void main(){
 
   // src/room.ts
   var FIXED_DT = 1 / 60;
+  var SOLID_SPAN = 3;
+  var STEP_UP = 0.45;
+  var BODY_HEIGHT = 1.75;
+  var KICK_MASS = 6;
+  var KICK_HEIGHT = 0.6;
+  var GROUND_ID2 = "room_ground";
+  var TERRAIN_CELL = 0.1;
+  var TERRAIN_MAX_CELLS = 1e3;
+  var GROUND_BURST_MAX = 28;
+  var GROUND_BURST_PER_METRE = 30;
+  var GROUND_DUST_RADIUS = 0.2;
+  var GROUND_FIRE_EVERY = 0.3;
   var SHOVE_SPEED = 0.04;
   var METRICS_INTERVAL_S = 0.25;
   var CARRY_NEAR = 0.62;
@@ -42113,10 +44733,12 @@ void main(){
     const ownWorld = !options.world;
     const world = options.world ?? createDestruction({ seed: 1, ...options.worldOptions, materials: [...options.worldOptions?.materials ?? []] });
     const pristineWorld = ownWorld ? world.serialize() : null;
-    const topOk = (t2) => {
-      const p = world.part(t2.id, t2.topPart);
-      return !!p && p.status !== "broken" && p.status !== "melted" && p.status !== "ashes";
+    const partStands = (object, part) => {
+      const p = world.part(object, part);
+      return !!p && p.status !== "broken" && p.status !== "melted" && p.status !== "ashes" && !renderer.piece(object);
     };
+    const topOk = (t2) => t2.boards ? t2.boards.some((b) => partStands(t2.id, b.part)) : partStands(t2.id, t2.topPart);
+    const topHolds = (t2, x, z) => t2.boards ? t2.boards.some((b) => x > b.minX && x < b.maxX && z > b.minZ && z < b.maxZ && partStands(t2.id, b.part)) : topOk(t2);
     const restingTops = [];
     const restingTopAt = (x, z) => {
       let top = 0;
@@ -42125,10 +44747,18 @@ void main(){
     };
     const sceneryTopAt = (x, z) => {
       let top = 0;
-      for (const t2 of arena.tops) if (t2.top > top && x > t2.minX && x < t2.maxX && z > t2.minZ && z < t2.maxZ && topOk(t2)) top = t2.top;
+      for (const t2 of arena.tops) if (t2.top > top && x > t2.minX && x < t2.maxX && z > t2.minZ && z < t2.maxZ && topHolds(t2, x, z)) top = t2.top;
       return top;
     };
-    const groundAt = (x, z) => Math.max(sceneryTopAt(x, z), restingTopAt(x, z));
+    const defaultGround = options.ground ?? { surface: DEFAULT_PROFILE };
+    const terrain = createTerrain({ bounds: [-arenaSize, -arenaSize, arenaSize, arenaSize], cellSize: Math.max(TERRAIN_CELL, 2 * arenaSize / TERRAIN_MAX_CELLS), layout: defaultGround, ...options.terrainBudget ? { budget: options.terrainBudget } : {} });
+    const terrainView = createTerrainRenderer(THREE, { terrain });
+    arena.group.add(terrainView.group);
+    const groundAt = (x, z) => {
+      const top = Math.max(sceneryTopAt(x, z), restingTopAt(x, z));
+      const floor2 = terrain.heightAt(x, z);
+      return top > 0 ? Math.max(top, floor2) : floor2;
+    };
     const ownFluids = !options.fluids;
     const fluids = options.fluids ?? createFluids({ seed: 1, locale, liquids: options.liquids, groundAt });
     const pristineFluids = ownFluids ? fluids.serialize() : null;
@@ -42149,13 +44779,6 @@ void main(){
       destructionSound?.onSound(key, point, volume);
       options.onSound?.(key, point, volume);
     };
-    const craterField = options.craters ? createGroundField() : void 0;
-    const craterPatch = craterField ? createGroundPatch(THREE, { field: craterField, material: new THREE.MeshStandardMaterial({ color: 9342602, roughness: 0.95 }) }) : void 0;
-    if (craterPatch) {
-      const floor2 = arena.group.getObjectByName("floor");
-      if (floor2) floor2.visible = false;
-      scene2.add(craterPatch.mesh);
-    }
     const vfx = createVfxRenderer(THREE, {
       scene: scene2,
       camera: camera2,
@@ -42164,8 +44787,7 @@ void main(){
       pointScale,
       vfx: createVfx({
         profile: quality,
-        groundAt: (x, z) => groundAt(x, z) + (craterField?.heightAt(x, z) ?? 0),
-        ...craterField ? { ground: craterField } : {}
+        groundAt
       })
     });
     const renderer = createDestructionRenderer(THREE, {
@@ -42186,6 +44808,7 @@ void main(){
         const e = entries.get(objectId);
         if (!e) return;
         e.piece = piece;
+        leaveFootprint(objectId);
         rendererPieces.set(objectId, piece);
         action("loosened", t("act.loosened", { name: e.name }), { objectId, itemId: e.so.itemId });
       },
@@ -42210,6 +44833,31 @@ void main(){
         if (best) splitOf.set(piece.objectId, best);
       }
     });
+    const showGroundBlow = (result2) => {
+      const material = terrain.material(result2.removed[0]?.material ?? result2.exposed);
+      const def = world.materials.get(material.id);
+      const size = Math.min(GROUND_BURST_MAX, Math.ceil(result2.radius * GROUND_BURST_PER_METRE));
+      renderer.emit(material.debris === "clods" ? "dust" : material.debris, result2.point, [0, 1, 0], Math.max(2, size), Math.min(4, 1 + result2.radius * 4));
+      if (result2.radius > GROUND_DUST_RADIUS) renderer.emit("dust", result2.point, [0, 1, 0], size, 1.4);
+      playSound(impactKey(def), result2.point, Math.min(1, 0.25 + result2.radius));
+    };
+    terrain.onDeform((region) => renderer.wakeRegion(region.x, region.z, region.radius));
+    const groundImpl = createTerrainImpl(terrain, { id: GROUND_ID2, name: t("ground.name"), onBlow: showGroundBlow });
+    const registerGround = () => {
+      if (!world.has(GROUND_ID2)) world.register(groundImpl, { id: GROUND_ID2 });
+    };
+    registerGround();
+    let groundFireClock = 0;
+    const showGroundFire = (dt) => {
+      groundFireClock += dt;
+      if (groundFireClock < GROUND_FIRE_EVERY) return;
+      groundFireClock = 0;
+      for (const [x, z] of terrain.burningPoints()) {
+        const y = terrain.heightAt(x, z);
+        renderer.emit("fire", [x, y + 0.05, z], [0, 1, 0], 3, 1.6);
+        if (rnd2() < 0.25) renderer.emit("smoke", [x, y + 0.2, z], [0, 1, 0], 1, 1);
+      }
+    };
     const fluidView = createFluidRenderer(THREE, { scene: scene2, fluids, quality, pointScale, vfx: vfx.world });
     const filmRandom = createFilmLcg(1);
     const film = createFilmManager(THREE, {
@@ -42344,12 +44992,79 @@ void main(){
     let useHeld = false;
     let useFirst = false;
     const blockers = /* @__PURE__ */ new Set();
+    const drawnScenery = (i) => {
+      const c = arena.colliders[i];
+      return arena.colliderIds[i] !== null && c[2] - c[0] <= SOLID_SPAN && c[3] - c[1] <= SOLID_SPAN;
+    };
+    const standingColliders = [];
+    const standingIds = [];
+    const footprintsWithBody = /* @__PURE__ */ new Set();
+    const standFootprints = () => {
+      standingColliders.length = 0;
+      standingIds.length = 0;
+      footprintsWithBody.clear();
+      arena.colliders.forEach((collider, i) => {
+        if (drawnScenery(i)) return;
+        standingColliders.push(collider);
+        standingIds.push(arena.colliderIds[i] ?? null);
+      });
+    };
+    standFootprints();
+    const leaveFootprint = (objectId) => {
+      const i = standingIds.indexOf(objectId);
+      if (i < 0) return;
+      standingIds.splice(i, 1);
+      standingColliders.splice(i, 1);
+      footprintsWithBody.add(objectId);
+    };
+    const footing = (x, z, radius, feet) => {
+      let floor2 = -Infinity;
+      let blocked = false;
+      for (const s of renderer.solidsNear(x, z, radius)) {
+        if ((s.piece?.mass ?? s.loose?.mass ?? Infinity) < KICK_MASS) continue;
+        const dx = Math.max(s.min[0] - x, 0, x - s.max[0]);
+        const dz = Math.max(s.min[2] - z, 0, z - s.max[2]);
+        if (dx * dx + dz * dz > radius * radius) continue;
+        if (s.max[1] <= feet + STEP_UP) floor2 = Math.max(floor2, s.max[1]);
+        else if (s.min[1] < feet + BODY_HEIGHT) blocked = true;
+      }
+      return { floor: floor2, blocked };
+    };
+    const kickFrom = { x: 0, z: 0 };
+    const kickLight = (dt) => {
+      const x = player.x;
+      const z = player.z;
+      const speed = dt > 0 ? Math.hypot(x - kickFrom.x, z - kickFrom.z) / dt : 0;
+      kickFrom.x = x;
+      kickFrom.z = z;
+      if (speed < 0.2 || speed > 20) return;
+      const kicked = /* @__PURE__ */ new Set();
+      for (const s of renderer.solidsNear(x, z, PLAYER_RADIUS)) {
+        const pc = s.piece;
+        const body = pc ?? s.loose;
+        if (!body || body.mass >= KICK_MASS || kicked.has(body) || s.min[1] > player.feet + KICK_HEIGHT) continue;
+        kicked.add(body);
+        const cx = (s.min[0] + s.max[0]) / 2 - x;
+        const cz = (s.min[2] + s.max[2]) / 2 - z;
+        const d = Math.hypot(cx, cz) || 1;
+        const v = speed * 1.2;
+        if (!pc) {
+          s.loose?.push(cx / d * v, cz / d * v);
+          continue;
+        }
+        if (pc.velocity[0] * cx + pc.velocity[2] * cz >= v * d) continue;
+        pc.velocity = [cx / d * v, Math.max(pc.velocity[1], 0.6), cz / d * v];
+        pc.sleeping = false;
+      }
+    };
     const player = createPlayer(THREE, {
       camera: camera2,
       dom,
-      colliders: arena.colliders,
+      colliders: standingColliders,
+      footing: (x, z, radius, feet) => footing(x, z, radius, feet),
       blockers,
       limit: arenaSize,
+      floorAt: terrain.heightAt,
       start: arena.playerStart,
       crouchKeys: options.crouch?.keys,
       hooks: {
@@ -42373,6 +45088,68 @@ void main(){
     let counter = 0;
     let slot = 0;
     const maxCarry = options.maxCarryKg ?? 60;
+    const PUSH_AHEAD = 0.6;
+    const heaviestMaterial = (id) => {
+      let best;
+      for (const p of world.state(id)?.parts ?? []) if (p.status !== "broken" && (!best || p.mass > best.mass)) best = { mass: p.mass, material: p.material };
+      return best?.material;
+    };
+    const leanedOn = () => {
+      const fx = -Math.sin(player.yaw);
+      const fz = -Math.cos(player.yaw);
+      let best = null;
+      let bestDistance = PUSH_REACH;
+      for (const e of entries.values()) {
+        if (e.arena || !e.piece && !e.free) continue;
+        const b = bodyBox(e);
+        if (!b) continue;
+        const dx = Math.max(b.minX, Math.min(b.maxX, player.x)) - player.x;
+        const dz = Math.max(b.minZ, Math.min(b.maxZ, player.z)) - player.z;
+        const distance4 = Math.hypot(dx, dz);
+        if (distance4 >= bestDistance || distance4 > 1e-3 && (dx * fx + dz * fz) / distance4 < PUSH_AHEAD) continue;
+        best = e;
+        bestDistance = distance4;
+      }
+      return best ? { objectId: best.so.objectId, root: best.so.root, name: nameOf(best.so.objectId), piece: best.piece ?? null } : null;
+    };
+    const push = createRoomPush({
+      THREE,
+      player,
+      world,
+      arena: { limit: arenaSize, colliders: standingColliders },
+      blockers,
+      ...options.push ? { rules: options.push } : {},
+      pick: () => {
+        if (heldPiece || tool.def.category !== "hand" && toolId !== "fists") return null;
+        aim();
+        const r = rayWorld([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]], 3.2);
+        const aimed = r ? rendererPieces.get(r.object)?.root ?? (entries.get(r.object)?.free ? entries.get(r.object)?.so.root : void 0) : void 0;
+        if (r && aimed) return { objectId: r.object, root: aimed, name: nameOf(r.object), piece: rendererPieces.get(r.object) ?? null };
+        return leanedOn();
+      },
+      massOf: (objectId) => massOfObject(objectId),
+      materialOf: heaviestMaterial,
+      makePiece: (objectId) => {
+        const piece = renderer.makePiece(objectId, { mass: Math.max(0.2, massOfObject(objectId)) });
+        const e = entries.get(objectId);
+        if (e) e.piece = piece;
+        rendererPieces.set(objectId, piece);
+        leaveFootprint(objectId);
+        return piece;
+      },
+      dragSound: (objectId, point, volume) => playSound(dragSoundKey(world.materials.get(heaviestMaterial(objectId) ?? "")), point, volume),
+      hitSound: (objectId, point) => playSound(impactKey(world.materials.get(heaviestMaterial(objectId) ?? "")), point, 0.5),
+      onEvent: (ev) => {
+        const vars = { name: ev.name, kg: num(ev.massKg, 0) };
+        action(`push_${ev.type}`, t(`act.push_${ev.type}`, vars), { objectId: ev.objectId, itemId: entryOf(ev.objectId)?.so.itemId, data: { massKg: Math.round(ev.massKg * 10) / 10 } });
+        fire("push", ev);
+        if (ev.type === "engaged") say(t("hud.push_on", vars));
+        else if (ev.type === "too_heavy") say(t("hud.push_too_heavy", vars));
+        else if (ev.type === "obstacle") say(t("hud.push_blocked", vars));
+      },
+      ring: (value) => ui?.holdRing(value)
+    });
+    let pushByKey = false;
     const massOfObject = (id) => {
       const st = world.state(id);
       let m = 0;
@@ -42440,6 +45217,45 @@ void main(){
       Object.defineProperty(holder, "visible", { get: () => built.visible, set: (v) => void (built.visible = v), configurable: true });
       return holder;
     };
+    const sceneryObjects = /* @__PURE__ */ new Map();
+    const placeScenery = (objectId, item, position, rotationY) => {
+      const root = buildRoot(item);
+      root.position.set(position[0], position[1], position[2]);
+      root.rotation.y = rotationY;
+      root.name = item.id;
+      scene2.add(root);
+      root.updateMatrixWorld(true);
+      const own = item.impl?.(root, objectId);
+      const { spec, parts } = own ? { spec: structuredCloneSpec(own.describe()), parts: void 0 } : resolveSpec(item, root);
+      root.updateMatrixWorld(true);
+      const q = root.getWorldQuaternion(tmpQ);
+      if (own) world.register(own, { id: objectId, position, rotation: [q.x, q.y, q.z, q.w] });
+      else world.add(spec, { id: objectId, position, rotation: [q.x, q.y, q.z, q.w] });
+      const e = registerEntry(objectId, item.id, root, spec, item.name, parts, item, true, false);
+      fire("spawn", e.so);
+      return e;
+    };
+    const restoreScenery = () => {
+      for (const [objectId, o] of sceneryObjects) if (!entries.has(objectId)) placeScenery(objectId, o.item, o.position, o.rotationY);
+    };
+    const addScenery = (itemId, position, rotationY = 0) => {
+      const item = catalogMap.get(itemId);
+      if (!item) return null;
+      const objectId = `${item.id}_scenery_${sceneryObjects.size + 1}`;
+      sceneryObjects.set(objectId, { item, position: [position[0], position[1], position[2]], rotationY });
+      const e = placeScenery(objectId, item, position, rotationY);
+      action("spawn", t("act.spawn", { name: item.name, x: num(position[0], 1), z: num(position[2], 1) }), { objectId, itemId: item.id, data: { position, movable: false, scenery: true } });
+      return {
+        objectId,
+        get root() {
+          return entries.get(objectId)?.so.root ?? e.so.root;
+        },
+        remove() {
+          sceneryObjects.delete(objectId);
+          removeEntry(objectId);
+        }
+      };
+    };
     const spawn2 = (itemId, position, rotationY) => {
       const item = catalogMap.get(itemId);
       if (!item) throw new Error(`game-test-room: unknown item "${itemId}"`);
@@ -42491,6 +45307,77 @@ void main(){
       fire("spawn", e.so);
       return e.so;
     };
+    const STEP_OVER = STEP_UP;
+    const HEADROOM = 1.9;
+    const PUSH_WALK_N = 250;
+    const PUSH_RUN_N = 450;
+    const FLOOR_FRICTION = 0.5;
+    const bodyBoxes = /* @__PURE__ */ new Map();
+    const bodyBounds = new THREE.Box3();
+    let frameStamp = 0;
+    const bodyBox = (e) => {
+      const id = e.so.objectId;
+      const known = bodyBoxes.get(id);
+      if (known && (known.stamp === frameStamp || !e.piece || e.piece.sleeping)) return known;
+      if (!e.so.root.parent || world.state(id)?.destroyed) {
+        bodyBoxes.delete(id);
+        return null;
+      }
+      bodyBounds.setFromObject(e.so.root);
+      if (bodyBounds.isEmpty()) return null;
+      const box2 = { minX: bodyBounds.min.x, maxX: bodyBounds.max.x, minZ: bodyBounds.min.z, maxZ: bodyBounds.max.z, base: bodyBounds.min.y, top: bodyBounds.max.y, stamp: frameStamp };
+      bodyBoxes.set(id, box2);
+      return box2;
+    };
+    const footPos = new THREE.Vector3();
+    const inTheWay = (e, x, z, r) => {
+      if (e.arena && !footprintsWithBody.has(e.so.objectId) || e.piece && e.piece.held) return null;
+      const ud = e.so.root.userData;
+      if ("collider" in ud && !ud.collider?.kind) return null;
+      const b = bodyBox(e);
+      if (!b || b.base > player.feet + HEADROOM) return null;
+      const c = ud.collider;
+      if (c?.kind === "cylinder" && c.radius != null) {
+        e.so.root.getWorldPosition(footPos);
+        const reach = c.radius + r;
+        return (x - footPos.x) ** 2 + (z - footPos.z) ** 2 < reach * reach ? { ...b, top: Math.min(b.top, footPos.y + (c.height ?? b.top - footPos.y)) } : null;
+      }
+      return x > b.minX - r && x < b.maxX + r && z > b.minZ - r && z < b.maxZ + r ? b : null;
+    };
+    blockers.add((x, z, r) => {
+      for (const e of entries.values()) {
+        const b = inTheWay(e, x, z, r);
+        if (b && b.top - b.base >= STEP_OVER) return true;
+      }
+      return false;
+    });
+    const pushByPlayer = (dt) => {
+      const [wx, wz] = player.takeWish();
+      const len = Math.hypot(wx, wz);
+      if (dt <= 0 || len < 1e-6) return;
+      const dx = wx / len;
+      const dz = wz / len;
+      const speed = len / dt;
+      const force = player.running ? PUSH_RUN_N : PUSH_WALK_N;
+      const ax = player.x + dx * (Math.min(len, 0.5) + 0.03);
+      const az = player.z + dz * (Math.min(len, 0.5) + 0.03);
+      for (const e of entries.values()) {
+        const piece = e.piece;
+        if (!piece) continue;
+        const b = inTheWay(e, ax, az, PLAYER_RADIUS);
+        if (!b) continue;
+        const grip = FLOOR_FRICTION * piece.mass * 9.81;
+        if (force <= grip) continue;
+        const along = piece.velocity[0] * dx + piece.velocity[2] * dz;
+        const impulse = Math.min(piece.mass * Math.max(0, speed - along), (force - grip) * dt);
+        if (impulse <= 1e-4) continue;
+        const y = (b.base + Math.max(b.base, Math.min(b.top, player.feet + 1.4))) / 2;
+        const point = [Math.max(b.minX, Math.min(b.maxX, player.x)), y, Math.max(b.minZ, Math.min(b.maxZ, player.z))];
+        piece.sleeping = false;
+        renderer.impulse(e.so.objectId, [dx * impulse, 0, dz * impulse], point);
+        log.coalesce(`bump:${e.so.objectId}`, { channel: "action", type: "bump", text: t("act.bump", { name: e.name, kg: num(piece.mass, 1) }), objectId: e.so.objectId, itemId: e.so.itemId, data: { massKg: Math.round(piece.mass * 10) / 10, pushN: force } }, 1);
+      }
+    };
     const massGuess = (spec) => {
       let m = 0;
       for (const p of spec.parts) {
@@ -42543,6 +45430,7 @@ void main(){
       explosives.clear();
       fireZones.length = 0;
       burningStains.length = 0;
+      terrain.setLayout(defaultGround);
       for (const id of [...entries.keys()]) if (!entries.get(id)?.arena) removeEntry(id);
       clearLoose();
       for (const e of entries.values()) {
@@ -42580,6 +45468,8 @@ void main(){
       action("reset", t("act.reset"));
     };
     const hardReset = () => {
+      pushByKey = false;
+      push.end();
       clearEverything();
       for (const id of [...entries.keys()]) removeEntry(id);
       tools.clear();
@@ -42587,6 +45477,7 @@ void main(){
       if (pristineWorld) {
         for (const id of world.ids()) world.remove(id);
         world.load(pristineWorld);
+        registerGround();
       }
       if (pristineFluids) {
         fluids.load(pristineFluids);
@@ -42600,6 +45491,7 @@ void main(){
       prevVy.clear();
       lastImpact.clear();
       addArena();
+      standFootprints();
       timeScale = 1;
       fastForward = false;
       walkPlan = null;
@@ -42664,10 +45556,11 @@ void main(){
       }
       feetPrev = [x, z];
       avatarState.running = !player.crouching && (player.keys.has("ShiftLeft") || player.keys.has("ShiftRight"));
-      avatarState.crouch = crouchForced || player.crouching;
+      avatarState.crouch = crouchForced || player.crouching || push.isBent;
       avatarState.armed = armedForced ?? tool.def.action.kind === "firearm";
       avatarState.pitch = player.pitch;
       avatarState.holding = heldPiece !== null;
+      avatarState.push = push.avatarState;
       avatarState.itemUse = useItemPlayer ? { id: useItemName, ...useItemPlayer.pose() } : heldPiece && heldTilt > 0.01 ? { id: "tilt", position: [0.2, -0.1, -0.38], rotation: [-heldTilt, 0, 0] } : null;
       avatar.root.position.set(x, player.feet, z);
       avatar.root.rotation.set(0, player.yaw + Math.PI, 0);
@@ -42683,11 +45576,11 @@ void main(){
     const stepFirstPerson = (dt) => {
       const arms = avatar?.firstPerson;
       if (!arms) return;
-      const targets = handSource?.() ?? carriedHand;
+      const targets = push.handTargets() ?? handSource?.() ?? carriedHand;
       const state = {
         camera: camera2,
         targets,
-        stance: handStances[toolId] ?? (targets ? "hold" : "relaxed"),
+        stance: push.active ? "hold" : handStances[toolId] ?? (targets ? "hold" : "relaxed"),
         speed: avatarState.speed,
         running: avatarState.running,
         crouch: avatarState.crouch,
@@ -42708,6 +45601,19 @@ void main(){
         camera2.updateMatrixWorld(true);
       };
     };
+    const KICK_HIP = 0.9;
+    const KICK_DROP = 0.35;
+    const legAim = () => {
+      aim();
+      const low = aimO[1] < player.feet + KICK_HIP;
+      const pitch = Math.max(-0.9, Math.min(0.1, player.pitch - (low ? 0 : KICK_DROP)));
+      aimO[0] = player.x;
+      aimO[1] = Math.min(player.feet + KICK_HIP, aimO[1]);
+      aimO[2] = player.z;
+      aimD[0] = -Math.sin(player.yaw) * Math.cos(pitch);
+      aimD[1] = Math.sin(pitch);
+      aimD[2] = -Math.cos(player.yaw) * Math.cos(pitch);
+    };
     const aim = () => {
       camera2.updateMatrixWorld(true);
       camera2.getWorldPosition(tmpV2);
@@ -42874,17 +45780,51 @@ void main(){
       if (!rendererPieces.has(objectId)) return;
       renderer.impulse(objectId, [dir[0] * momentum, dir[1] * momentum, dir[2] * momentum], point);
     };
+    const shotRay = new THREE.Raycaster();
+    const LIQUID_SLOWING = 0.25;
+    const SHOT_GRIP = 0.3;
+    const shotPush = (s, objectId, results, fallback2) => {
+      const e = entries.get(objectId);
+      const speed = Math.max(80, s.speed);
+      const onIt = results.filter((r) => r.object === objectId);
+      const last = onIt[onIt.length - 1];
+      let kept = last && last.penetrated ? Math.sqrt(Math.max(0, Math.min(1, last.exitEnergy / Math.max(s.energy, 1e-6)))) : 0;
+      let point = fallback2;
+      let inward = [s.direction[0], s.direction[1], s.direction[2]];
+      if (e) {
+        shotRay.set(new THREE.Vector3(...s.origin), new THREE.Vector3(...s.direction).normalize());
+        shotRay.far = 60;
+        shotRay.camera = camera2;
+        const hit = shotRay.intersectObject(e.so.root, true).find((h) => h.object.isMesh && !h.object.userData.destructionDebris && h.face);
+        if (hit?.face) {
+          point = [hit.point.x, hit.point.y, hit.point.z];
+          const n = hit.face.normal.clone().transformDirection(hit.object.matrixWorld);
+          if (n.x * s.direction[0] + n.y * s.direction[1] + n.z * s.direction[2] > 0) n.negate();
+          inward = [-n.x, -n.y, -n.z];
+        }
+        const c = kept > 0 && e.containerId ? fluids.container(e.containerId) : null;
+        if (c && c.liters > 1e-4) {
+          const size = new THREE.Box3().setFromObject(e.so.root).getSize(new THREE.Vector3());
+          kept *= Math.exp(-(Math.min(size.x, size.z) * 0.9) / LIQUID_SLOWING);
+        }
+      }
+      const momentum = 2 * s.energy / speed * (1 - kept);
+      const along = s.direction[0] * inward[0] + s.direction[1] * inward[1] + s.direction[2] * inward[2];
+      const impulse = [0, 1, 2].map((k) => momentum * (along * inward[k] + SHOT_GRIP * (s.direction[k] - along * inward[k])));
+      return { impulse, point };
+    };
     const shoveFree = (pushes) => {
-      for (const [objectId, push] of pushes) {
+      for (const [objectId, push2] of pushes) {
         const e = entries.get(objectId);
         if (!e || e.piece || !e.free) continue;
         const mass = Math.max(0.2, massOfObject(objectId));
-        if (Math.hypot(...push.impulse) / mass < SHOVE_SPEED) continue;
+        if (Math.hypot(...push2.impulse) / mass < SHOVE_SPEED) continue;
         const piece = renderer.makePiece(objectId, { mass });
         e.piece = piece;
         rendererPieces.set(objectId, piece);
+        leaveFootprint(objectId);
         action("loosened", t("act.shoved", { name: e.name }), { objectId, itemId: e.so.itemId });
-        renderer.impulse(objectId, push.impulse, push.point);
+        renderer.impulse(objectId, push2.impulse, push2.point);
       }
     };
     const fireShots = (shots, recoil) => {
@@ -42907,12 +45847,11 @@ void main(){
             hits++;
             end3 = r0.point;
             if (!first) first = { object: r0.object, part: r0.part, point: r0.point, normal: [0, 1, 0], distance: dist3(s.origin, r0.point) };
-            const speed = Math.max(80, s.speed);
-            const momentum = 2 * s.energy / speed;
-            pushPiece(r0.object, s.direction, momentum, r0.point);
-            const push = pushes.get(r0.object) ?? { impulse: [0, 0, 0], point: r0.point };
-            for (let k = 0; k < 3; k++) push.impulse[k] += s.direction[k] * momentum;
-            pushes.set(r0.object, push);
+            const blow3 = shotPush(s, r0.object, results, r0.point);
+            if (rendererPieces.has(r0.object)) renderer.impulse(r0.object, blow3.impulse, blow3.point);
+            const push2 = pushes.get(r0.object) ?? { impulse: [0, 0, 0], point: blow3.point };
+            for (let k = 0; k < 3; k++) push2.impulse[k] += blow3.impulse[k];
+            pushes.set(r0.object, push2);
           }
           if (shots.length <= 3 || rnd2() < 0.34) tracer(m, end3);
         }
@@ -42990,8 +45929,22 @@ void main(){
         1
       );
     };
-    const meleeUse = (u, id = toolId) => {
+    const kickHeights = options.kickHeights ?? [0.25, 0.35, 0.45, 0.55, 0.65, 0.75, 0.85];
+    const footRay = (u) => {
+      const flat = Math.hypot(u.direction[0], u.direction[2]);
+      const direction = flat > 1e-6 ? [u.direction[0] / flat, 0, u.direction[2] / flat] : [-Math.sin(player.yaw), 0, -Math.cos(player.yaw)];
+      const feet = player.position;
+      let best = null;
+      for (const height2 of kickHeights) {
+        const origin = [feet[0], feet[1] + height2, feet[2]];
+        const hit = rayWorld(origin, direction, u.reach);
+        if (hit && (!best || hit.distance < best.distance)) best = { origin, distance: hit.distance };
+      }
+      return best ? { ...u, origin: best.origin, direction } : u;
+    };
+    const meleeUse = (use, id = toolId) => {
       const w = toolName(id);
+      const u = id === "kick" ? footRay(use) : use;
       const r = rayWorld(u.origin, u.direction, u.reach);
       if (!r) {
         action("melee", t("act.melee.miss", { weapon: w }), { data: { weapon: id } });
@@ -43012,27 +45965,49 @@ void main(){
     const punchHand = options.punchHand ?? "alternate";
     const punchTools = new Set(options.punchTools ?? ["hand", "fists"]);
     let nextHand = "right";
+    const combo = options.strikeCombo;
+    let comboOn = !!combo && options.strikeComboOn === true;
+    let comboNext = 0;
+    let comboAt = -Infinity;
+    const setStrikeCombo = (on) => {
+      if (!combo || on === comboOn) return;
+      comboOn = on;
+      comboNext = 0;
+      const name = combo.name?.[locale] ?? combo.id;
+      action("combo", t(on ? "act.combo.on" : "act.combo.off", { name }), { data: { combo: combo.id, on } });
+      say(t(on ? "act.combo.on" : "act.combo.off", { name }));
+    };
     const strikeUse = (u, id = toolId) => {
-      const clip = strikeClips[id];
+      const stepIndex = comboOn && combo?.tools.includes(id) && combo.steps.length > 0 ? simTime - comboAt > combo.reset ? 0 : comboNext : null;
+      const step2 = stepIndex === null ? void 0 : combo.steps[stepIndex];
+      const clip = step2 ? step2.clip : strikeClips[id];
       const leg = id === "kick" ? kickLeg === "alternate" ? nextLeg : kickLeg : void 0;
-      const hand = punchTools.has(id) ? punchHand === "alternate" ? nextHand : punchHand : void 0;
+      const hand = step2 ? step2.hand : punchTools.has(id) ? punchHand === "alternate" ? nextHand : punchHand : void 0;
       const side = leg ? { leg } : hand ? { hand } : void 0;
       const seconds = clip === void 0 ? null : avatar?.strike?.(clip, side) ?? null;
       if (leg && seconds !== null && kickLeg === "alternate") nextLeg = leg === "right" ? "left" : "right";
-      if (hand && seconds !== null && punchHand === "alternate") nextHand = hand === "right" ? "left" : "right";
+      if (!step2 && hand && seconds !== null && punchHand === "alternate") nextHand = hand === "right" ? "left" : "right";
+      if (step2 && stepIndex !== null) {
+        comboNext = (stepIndex + 1) % combo.steps.length;
+        comboAt = simTime;
+      }
       if (clip === void 0 || seconds === null) {
-        meleeUse(u, id);
+        if (leg) {
+          legAim();
+          meleeUse({ ...u, origin: [aimO[0], aimO[1], aimO[2]], direction: [aimD[0], aimD[1], aimD[2]] }, id);
+        } else meleeUse(u, id);
         return;
       }
       const text = leg ? "act.strike.leg" : hand ? "act.strike.hand" : "act.strike";
       action("strike", t(text, { weapon: toolName(id), clip, seconds: num(seconds, 2), leg: leg ? t(`leg.${leg}`) : "", hand: hand ? t(`hand.${hand}`) : "" }), {
-        data: { weapon: id, clip, impactIn: seconds, ...leg ? { leg } : {}, ...hand ? { hand } : {} }
+        data: { weapon: id, clip, impactIn: seconds, ...leg ? { leg } : {}, ...hand ? { hand } : {}, ...step2 ? { combo: combo.id, step: stepIndex } : {} }
       });
       strikes.push({
         key: id,
         remaining: seconds,
         land: () => {
-          aim();
+          if (leg) legAim();
+          else aim();
           meleeUse({ ...u, origin: [aimO[0], aimO[1], aimO[2]], direction: [aimD[0], aimD[1], aimD[2]] }, id);
         }
       });
@@ -43218,12 +46193,14 @@ void main(){
       if (res) applyUses(res, 0);
     };
     const kick = () => {
-      if (!arsenal.weapons.has("kick") || strikes.some((strike) => strike.key === "kick")) return;
+      if (!arsenal.weapons.has("kick") || strikes.some((strike) => strike.key === "kick")) return false;
       aim();
       const res = toolState("kick").trigger([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]], 0, false, "player");
-      if (res.status !== "ok") return;
+      if (res.status !== "ok") return false;
       for (const u of res.uses) if (u.kind === "melee") strikeUse(u, "kick");
+      return true;
     };
+    const kickKeys = options.kick?.keys ?? ["KeyK"];
     const setTool = (id) => {
       if (!arsenal.weapons.has(id)) throw new Error(`game-test-room: unknown weapon "${id}"`);
       releaseTrigger();
@@ -43271,6 +46248,7 @@ void main(){
       else useTool(FIXED_DT, false);
     };
     const grab = () => {
+      if (push.active) return false;
       if (heldPiece) {
         const name = heldName;
         releaseHeld();
@@ -43486,7 +46464,7 @@ void main(){
         const reach = Math.max(size.x, size.y, size.z) * 0.5;
         const origin = [centre.x + dir[0] * (reach + 0.02), centre.y + dir[1] * (reach + 0.02), centre.z + dir[2] * (reach + 0.02)];
         const r = withoutHeld(() => world.raycast(origin, dir, speed * FIXED_DT * 2 + 0.06));
-        if (!r || r.object === piece.objectId) return;
+        if (!r || r.object === piece.objectId || r.object === GROUND_ID2) return;
         const energy = 0.5 * piece.mass * speed * speed;
         lastImpact.set(piece.objectId, simTime);
         world.hitPart(r.object, r.part, { type: "blunt", point: r.point, direction: dir, energy, radius: 0.08, source: "thrown" });
@@ -43499,12 +46477,21 @@ void main(){
           data: { energyJ: Math.round(energy), speedMs: Math.round(speed * 10) / 10, target: r.object, targetPart: r.part }
         });
       };
+      const strikeGroundWith = (piece, energy) => {
+        const box2 = tmpBox.setFromObject(piece.root);
+        const centre = box2.getCenter(tmpV2);
+        const size = box2.getSize(tmpV22);
+        if (sceneryTopAt(centre.x, centre.z) > 0 || restingTopAt(centre.x, centre.z) > 0) return;
+        const result2 = terrain.strike("blunt", { x: centre.x, z: centre.z, energy, contactRadius: Math.max(size.x, size.z) / 2 });
+        if (result2.radius > 0) showGroundBlow(result2);
+      };
       const land = (piece) => {
         const vy2 = piece.velocity[1];
         const prev = prevVy.get(piece.objectId) ?? 0;
         prevVy.set(piece.objectId, vy2);
         if (piece.held || prev > -MIN_LANDING_LOG || vy2 < prev + 2 || !world.has(piece.objectId)) return;
         const energy = 0.5 * piece.mass * prev * prev;
+        strikeGroundWith(piece, energy);
         action("landing", t("act.landing", { name: nameOf(piece.objectId), speed: num(-prev, 1), energy: num(energy, energy < 100 ? 1 : 0) }), {
           objectId: piece.objectId,
           itemId: entryOf(piece.objectId)?.so.itemId,
@@ -43525,6 +46512,10 @@ void main(){
     const onKey = (code, down, e) => {
       if (!down) {
         if (code === "KeyZ") tiltKey = 0;
+        if (code === "KeyE" && pushByKey) {
+          pushByKey = false;
+          if (push.end()) grab();
+        }
         return;
       }
       const digit = /^Digit(\d)$/.exec(code);
@@ -43535,9 +46526,15 @@ void main(){
         if (idx < loadout.length) setTool(loadout[idx]);
         return;
       }
+      if (kickKeys.includes(code) && !e.ctrlKey && !e.metaKey) {
+        kick();
+        return;
+      }
       switch (code) {
         case "KeyE":
-          grab();
+          if (e.repeat) break;
+          pushByKey = !heldPiece && push.begin();
+          if (!pushByKey) grab();
           break;
         case "KeyG":
           throwHeld();
@@ -43580,6 +46577,9 @@ void main(){
         case "KeyY":
           explosives.detonateCharges();
           break;
+        case "KeyN":
+          setStrikeCombo(!comboOn);
+          break;
         case "KeyH": {
           const w = (heldEntry ?? entryOf(inspectTarget()?.object ?? ""))?.item?.weapon;
           if (w) equip(w);
@@ -43708,8 +46708,9 @@ void main(){
       }
       syncLiters();
       renderer.update(dt);
+      terrainView.sync(camera2.position);
+      showGroundFire(dt);
       vfx.update(dt);
-      craterPatch?.sync();
       updateImpacts();
       fluidView.update(dt);
       filmBridge.update(dt);
@@ -43733,12 +46734,21 @@ void main(){
     };
     const update = (dt) => {
       if (!ownsLoop) roomMetrics.frame(dt);
+      frameStamp++;
       player.update(dt);
+      if (pushByKey && !player.keys.has("KeyE")) {
+        pushByKey = false;
+        push.end();
+      }
+      push.step(paused ? 0 : dt);
+      if (!paused) kickLight(dt);
+      if (!paused) pushByPlayer(dt);
+      else player.takeWish();
       stepAvatar(paused ? 0 : dt);
       if (tiltKey || heldTilt > 0) {
         heldTilt = Math.max(0, Math.min(2.4, heldTilt + (tiltKey ? 2.2 : -3) * dt));
       }
-      if ((useHeld || useFirst) && !paused) {
+      if ((useHeld || useFirst) && !paused && !push.active) {
         if (tool.def.category === "hand") {
           if (useFirst) handUse();
         } else if (useHeld) useTool(dt, !useFirst);
@@ -43780,6 +46790,7 @@ void main(){
         timeScale,
         fast: fastForward,
         tap: isTapOn(),
+        combo: combo ? comboOn : null,
         blast: { shelter: blastOn("shelter"), fragmentHits: blastOn("fragmentHits"), confinement: blastOn("confinement") },
         quality: qualityName,
         camera: avatar ? cameraMode : null,
@@ -44055,6 +47066,9 @@ void main(){
       onClear(listener) {
         clearListeners.add(listener);
         return () => clearListeners.delete(listener);
+      },
+      addObject(itemId, place) {
+        return addScenery(itemId, place.position, place.rotationY);
       }
     };
     let sendingInitial = false;
@@ -44209,6 +47223,7 @@ void main(){
       const n = Math.max(1, Math.round(seconds / dt));
       for (let i = 0; i < n; i++) {
         player.update(0);
+        push.step(dt);
         followHeld(dt);
         stepSim(dt);
       }
@@ -44251,6 +47266,7 @@ void main(){
       } finally {
         scenarioRunning = false;
         paused = wasPaused;
+        restoreScenery();
       }
       return report;
     };
@@ -44284,6 +47300,7 @@ void main(){
     const openArea = (area) => {
       clear();
       const mod2 = [...modules.values()].find((m) => m.id === area || m.group === area);
+      if (mod2?.ground) terrain.setLayout(mod2.ground);
       const label = mod2?.group ?? S.groups[area] ?? area;
       ui?.showGroup(label);
       activeBench = mod2 && benches.has(mod2.id) ? mod2.id : lastBench();
@@ -44450,7 +47467,13 @@ void main(){
       setFastForward(on) {
         fastForward = on;
       },
+      setStrikeCombo,
+      kick,
+      get strikeCombo() {
+        return combo ? comboOn : null;
+      },
       equip,
+      terrain,
       openArea,
       modules: () => [...modules.values()].map((m) => ({ id: m.id, name: m.name, group: m.group, hasArea: typeof m.area === "function" })),
       openAreaAsync: (area) => loading.busy(t("loading.open_area", { area: areaLabel(area) }), () => openArea(area)),
@@ -44502,6 +47525,12 @@ void main(){
         debugView.updateProjectionMatrix();
         debugView.updateMatrixWorld(true);
       },
+      get playerPosition() {
+        return player.position;
+      },
+      push: { begin: () => push.begin(), end: () => push.end(), setWalk: (walk) => push.setWalk(walk), get state() {
+        return push.state;
+      } },
       setCameraMode,
       get cameraMode() {
         return cameraMode;
@@ -44523,7 +47552,6 @@ void main(){
         loading.dispose();
         renderer.dispose();
         vfx.dispose();
-        craterPatch?.dispose();
         fluidView.dispose();
         filmBridge.dispose();
         film.dispose();
@@ -44601,6 +47629,8 @@ void main(){
           setTool(loadout[index]);
         },
         onTap: () => toggleTap(),
+        ...combo ? { combo: { label: combo.name?.[locale] ?? combo.id, onToggle: () => setStrikeCombo(!comboOn) } } : {},
+        ...arsenal.weapons.has("kick") ? { kick: { label: `${t("ui.kick")} (${kickKeys.map((key) => key.replace(/^Key/, "")).join("/")})`, onKick: () => void kick() } } : {},
         onBlast: (key) => toggleBlast(key),
         onPlay: (objectId, clipId) => {
           playAnimation(clipId, objectId);