@adatechnology/game-test-room 0.15.0 → 0.16.0

package/dist/index.global.js

@@ -482,6 +482,13 @@ var GameTestRoom = (() => {
     node.userData[KIT_ORIGIN_KEY] = { ...origin };
     return object;
   }
+  function kitOriginOf(object) {
+    for (let node = object; node; node = node.parent) {
+      const origin = node.userData?.[KIT_ORIGIN_KEY];
+      if (origin && typeof origin.owner === "string") return origin;
+    }
+    return null;
+  }
 
   // ../game-destruction/dist/index.js
   var FIRE_PRIME_C = 300;
@@ -812,6 +819,45 @@ var GameTestRoom = (() => {
     return angle === 0 ? q : quat.mul(q, quat.fromAxisAngle([0, 0, 1], angle));
   };
   var clamp = (v, a, b) => Math.max(a, Math.min(b, v));
+  var splinterBox = (inp, box2, limit = inp.maxFragments) => {
+    const { rnd: rnd2 } = inp;
+    const dims = box2.s;
+    const [fmin, fmax] = inp.fragmentSize;
+    const g = inp.grain ?? [0, 1, 2].sort((a2, b2) => dims[b2] - dims[a2])[0];
+    const [a, b] = [0, 1, 2].filter((i) => i !== g);
+    const w = Math.max(fmin * 1.5, 0.01);
+    const c = clamp(Math.round(dims[a] * dims[b] / (w * w)), 3, Math.max(3, Math.floor(limit / 2)));
+    const maxLen = fmax * 4;
+    const cells = bsp(box2, c, [a, b], rnd2);
+    const pieces = [];
+    for (const cell of cells) {
+      const extra = rnd2() < 0.4 ? 1 : 0;
+      const k = Math.max(1, Math.ceil(dims[g] / maxLen)) + extra;
+      for (const p of bsp(cell, k, [g], rnd2)) pieces.push(p);
+    }
+    return pieces.slice(0, limit).map((p) => ({ center: p.c, size: [p.s[g], p.s[a], p.s[b]], q: frame(g, a, b), shape: "splinter", weight: p.s[0] * p.s[1] * p.s[2] }));
+  };
+  var severAt = (inp, root, at3, gap) => {
+    const dims = root.s;
+    const L = [0, 1, 2].sort((x, y) => dims[y] - dims[x])[0];
+    const half = dims[L] / 2;
+    const lo = clamp(at3 - gap / 2, -half, half), hi = clamp(at3 + gap / 2, -half, half);
+    const out = [];
+    const stub = (from, to) => {
+      if (to - from < 0.02) return;
+      const c = [root.c[0], root.c[1], root.c[2]], sz = [dims[0], dims[1], dims[2]];
+      c[L] = (from + to) / 2;
+      sz[L] = to - from;
+      out.push({ center: c, size: sz, q: quat.identity(), shape: "slab", weight: sz[0] * sz[1] * sz[2] });
+    };
+    stub(-half, lo);
+    stub(hi, half);
+    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);
+    return out;
+  };
   var tearStack = (inp, root, t, u, v, n, sheet) => {
     const { dims, rnd: rnd2, maxFragments } = inp;
     const layers = clamp(Math.ceil(dims[t] / STACK_LAYER), 2, 4);
@@ -850,23 +896,8 @@ var GameTestRoom = (() => {
       return out;
     }
     if (style === "splinter") {
-      const g = inp.grain ?? [0, 1, 2].sort((a2, b2) => dims[b2] - dims[a2])[0];
-      const [a, b] = [0, 1, 2].filter((i) => i !== g);
-      const w = Math.max(fmin * 1.5, 0.01);
-      const c = clamp(Math.round(dims[a] * dims[b] / (w * w)), 3, Math.max(3, Math.floor(maxFragments / 2)));
-      const maxLen = fmax * 4;
-      const cells = bsp(root, c, [a, b], rnd2);
-      const pieces = [];
-      for (const cell of cells) {
-        let list = [cell];
-        const extra = rnd2() < 0.4 ? 1 : 0;
-        const k = Math.max(1, Math.ceil(dims[g] / maxLen)) + extra;
-        list = bsp(cell, k, [g], rnd2);
-        for (const p of list) pieces.push(p);
-      }
-      for (const p of pieces.slice(0, maxFragments)) {
-        out.push({ center: p.c, size: [p.s[g], p.s[a], p.s[b]], q: frame(g, a, b), shape: "splinter", weight: p.s[0] * p.s[1] * p.s[2] });
-      }
+      if (inp.cut) return severAt(inp, root, inp.cut.at, inp.cut.gap);
+      for (const p of splinterBox(inp, root)) out.push(p);
       return out;
     }
     if (style === "tear") {
@@ -2849,9 +2880,14 @@ var GameTestRoom = (() => {
   var BREACH_AREA = 0.25;
   var BREACH_BLAST_REACH = 0.12;
   var RESIDUAL_CAPACITY = 0.15;
+  var SEVER_BAND = 0.1;
+  var SEVER_ASPECT = 3;
+  var SEVER_BALLISTIC = 2;
   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 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));
@@ -2895,6 +2931,7 @@ var GameTestRoom = (() => {
     let windCfg = windOpts ? resolveWind(windOpts) : null;
     const ignitionRules = resolveIgnitionRules(options.ignition);
     const breachBlastFactor = options.breach?.blastFactor ?? BREACH_BLAST_FACTOR;
+    const chipEnergy = options.breach?.chipEnergy ?? CHIP_ENERGY;
     const rng = createRng(options.seed ?? 1);
     const rnd2 = () => rng.next();
     let time = 0;
@@ -3268,41 +3305,68 @@ var GameTestRoom = (() => {
       markDamaged(p);
       if (p.rt.hinge >= flexure.failRotationDeg * Math.PI / 180) hingeDrop(o, p, src);
     };
+    const freeSpan = (p, supports) => {
+      if (supports.length === 0) return Infinity;
+      const d = p.dims;
+      const L = [0, 1, 2].sort((a, b) => d[b] - d[a])[0];
+      const spans = supports.map((k) => contactBox(p, k)).map(([lo, hi]) => [lo[L], hi[L]]);
+      let far = 0;
+      for (let i = 0; i <= 16; i++) {
+        const x = (i / 16 - 0.5) * d[L];
+        let near = Infinity;
+        for (const [lo, hi] of spans) near = Math.min(near, Math.max(lo - x, x - hi, 0));
+        far = Math.max(far, near);
+      }
+      return 2 * far;
+    };
     const solveStructure = (o) => {
       o.maxStress = 0;
       if (!o.hasStructure) return;
       const parts = o.parts;
       const n = parts.length;
       const dist = new Array(n).fill(-1);
-      const queue = [];
       const ok = (i) => parts[i].structural && !isLost(parts[i]);
       const isPartition = (i) => parts[i].spec.structure?.role === "partition";
-      for (let i = 0; i < n; i++) if (ok(i) && parts[i].anchored) {
-        dist[i] = 0;
-        queue.push(i);
-      }
-      for (let h = 0; h < queue.length; h++) {
-        const s = queue[h];
-        if (isPartition(s)) continue;
-        for (const j of o.byPart.get(parts[s].spec.id)) {
-          if (j.st.open || !j.bears) continue;
-          const r = j.ia === s ? j.ib : j.ia;
-          if (dist[r] >= 0 || !ok(r) || restsOn(o, j, r) !== s) continue;
-          dist[r] = dist[s] + 1;
-          queue.push(r);
+      const out = /* @__PURE__ */ new Set();
+      let queue = [];
+      let lowerOf = /* @__PURE__ */ new Map();
+      for (; ; ) {
+        dist.fill(-1);
+        queue = [];
+        for (let i = 0; i < n; i++) if (ok(i) && !out.has(i) && parts[i].anchored) {
+          dist[i] = 0;
+          queue.push(i);
+        }
+        for (let h = 0; h < queue.length; h++) {
+          const s = queue[h];
+          if (isPartition(s)) continue;
+          for (const j of o.byPart.get(parts[s].spec.id)) {
+            if (j.st.open || !j.bears) continue;
+            const r = j.ia === s ? j.ib : j.ia;
+            if (dist[r] >= 0 || !ok(r) || out.has(r) || restsOn(o, j, r) !== s) continue;
+            dist[r] = dist[s] + 1;
+            queue.push(r);
+          }
         }
-      }
-      const incoming = new Array(n).fill(0);
-      const lowerOf = /* @__PURE__ */ new Map();
-      for (const i of queue) {
-        const lower = [];
-        for (const j of o.byPart.get(parts[i].spec.id)) {
-          if (j.st.open || !j.bears) continue;
-          const k = restsOn(o, j, i);
-          if (k >= 0 && dist[k] >= 0 && dist[k] < dist[i] && !isPartition(k)) lower.push(k);
+        lowerOf = /* @__PURE__ */ new Map();
+        let dropped = false;
+        for (const i of queue) {
+          const lower = [];
+          for (const j of o.byPart.get(parts[i].spec.id)) {
+            if (j.st.open || !j.bears) continue;
+            const k = restsOn(o, j, i);
+            if (k >= 0 && dist[k] >= 0 && dist[k] < dist[i] && !isPartition(k)) lower.push(k);
+          }
+          lowerOf.set(i, lower);
+          const max2 = parts[i].spec.structure?.maxSpan;
+          if (max2 !== void 0 && !parts[i].anchored && freeSpan(parts[i], lower.map((k) => parts[k])) > max2) {
+            out.add(i);
+            dropped = true;
+          }
         }
-        lowerOf.set(i, lower);
+        if (!dropped) break;
       }
+      const incoming = new Array(n).fill(0);
       const bending = new Array(n).fill(0);
       const through = parts.map(() => []);
       const pass = (k, at3, mass) => {
@@ -3814,6 +3878,7 @@ var GameTestRoom = (() => {
           const r = rayPart(o, p, origin, d);
           if (!r || r.t0 < 0 || r.t0 > maxDist) continue;
           if (p.st.opening && insideOpening(o, p, vec.madd(origin, d, r.t0))) continue;
+          if (p.st.chipped && insideChip(p, objLocal(o, vec.madd(origin, d, r.t0)))) continue;
           if (!best || r.t0 < best.distance) best = { object: o.id, part: p.spec.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
         }
       }
@@ -4077,6 +4142,62 @@ var GameTestRoom = (() => {
       if (total < (p.spec.breach?.area ?? BREACH_AREA)) return;
       openBreach(o, p, [sum2[0] / total, sum2[1] / total, sum2[2] / total], total, energy, dir, src);
     };
+    const unitGrids = /* @__PURE__ */ new WeakMap();
+    const gridOf = (p) => {
+      let grid = unitGrids.get(p);
+      if (!grid) unitGrids.set(p, grid = unitGrid(p.dims, p.thin, unitsOf(p), BREACH_GRID_CAP));
+      return grid;
+    };
+    const insideChip = (p, objectPoint) => {
+      const cells = p.st.chipped;
+      if (!cells?.length) return false;
+      const [u, v] = planeAxes(p.thin);
+      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) => {
+      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;
+      const [u, v] = planeAxes(p.thin);
+      const lp = toLocal(p.pos, p.q, objLocal(o, wp));
+      const grid = gridOf(p);
+      const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      const out = [];
+      for (let i = 0; i < grid.length; i++) {
+        const cell = grid[i];
+        if (worn[i] === -1) continue;
+        const gap = Math.hypot(Math.max(0, Math.abs(lp[u] - cell.center[u]) - cell.size[u] / 2), Math.max(0, Math.abs(lp[v] - cell.center[v]) - cell.size[v] / 2));
+        if (gap > radius) continue;
+        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) {
+          worn[i] = total;
+          continue;
+        }
+        worn[i] = -1;
+        out.push(cell);
+      }
+      if (out.length === 0) return;
+      const { c, q } = partXf(o, p);
+      const chipped = (_b = p.st).chipped ?? (_b.chipped = []);
+      const holes = localHolesOf(p);
+      for (const cell of out) {
+        const mass = Math.min(p.st.mass, p.mat.density * cell.size[0] * cell.size[1] * cell.size[2]);
+        const center = toWorld(c, q, cell.center);
+        const speed = clamp2(Math.sqrt(2 * energy * 0.05 / Math.max(mass, 0.05)), 0.5, 6);
+        const fragments = cellFragments(o, p, [cell], wp, dir, speed, mass, `c${chipped.length}_`);
+        p.st.holes = p.st.holes.filter((_, k) => marksInBox(cell.center, cell.size, void 0, [holes[k]]).length === 0);
+        chipped.push({ center: [cell.center[0], cell.center[1], cell.center[2]], size: [cell.size[0], cell.size[1], cell.size[2]] });
+        p.st.mass = Math.max(0, p.st.mass - mass);
+        p.rt.removed = (p.rt.removed ?? 0) + mass;
+        markDamaged(p);
+        setStage(o, p, 1, {}, src);
+        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);
+      }
+      for (const cell of out) addBreach(o, p, toWorld(c, q, cell.center), cell.size[u] * cell.size[v], energy, dir, src);
+    };
     const openBreach = (o, p, center, total, energy, dir, src) => {
       const [u, v] = planeAxes(p.thin);
       const radius = clamp2(Math.sqrt(total / Math.PI), Math.sqrt((p.spec.breach?.area ?? BREACH_AREA) / Math.PI), breachRadius);
@@ -4088,7 +4209,8 @@ var GameTestRoom = (() => {
         failPart(o, p, worldCenter, dir, energy, 12, src);
         return;
       }
-      const cells = cellsWithin(unitGrid(p.dims, p.thin, unitsOf(p), BREACH_GRID_CAP), p.thin, lc, radius);
+      const worn = p.rt.chips;
+      const cells = cellsWithin(gridOf(p).filter((_, i) => worn?.[i] !== -1), p.thin, lc, radius);
       const removed = p.st.mass * cells.reduce((sum2, cell) => sum2 + cell.size[u] * cell.size[v], 0) / (p.dims[u] * p.dims[v]);
       const speed = clamp2(Math.sqrt(2 * energy * 0.1 / Math.max(removed, 0.05)), 0.5, 8);
       const fragments = cellFragments(o, p, cells, worldCenter, dir, speed, removed, "b");
@@ -4172,6 +4294,8 @@ 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 cutAt = axis2 < 0 ? void 0 : p.rt.cutAt ?? (origin ? hitLocal[axis2] : void 0);
       const plan = unitPlan.length > 0 ? unitPlan : planFragments({
         style,
         dims: p.dims,
@@ -4181,7 +4305,8 @@ var GameTestRoom = (() => {
         fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
         maxFragments,
         rnd: rnd2,
-        sheet: p.mat.sheet
+        sheet: p.mat.sheet,
+        ...cutAt !== void 0 ? { cut: { at: cutAt, gap: SEVER_BAND } } : {}
       });
       const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
       const mass = p.st.mass;
@@ -4240,10 +4365,33 @@ var GameTestRoom = (() => {
       emit2({ ...base(o, src), type: "primed", part: p.spec.id, point: partXf(o, p).c, trigger, delay });
     };
     const CHAIN_TRIGGER_OF = { ballistic: "shot", explosive: "explosion" };
+    const severAxis = (p) => {
+      if (p.mat.fracture !== "splinter" || 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;
+    };
+    const bandOf = (o, p, axis2, origin) => {
+      const { c, q } = partXf(o, p);
+      const along = toLocal(c, q, origin)[axis2];
+      const L = p.dims[axis2];
+      return clamp2(Math.floor((along + L / 2) / SEVER_BAND), 0, Math.ceil(L / SEVER_BAND) - 1);
+    };
     const applyDamage = (o, p, amount, type, origin, dir, fragEnergy, cap, src) => {
+      var _a;
       if (isLost(p) || amount <= 0) return 0;
       const prev = p.st.hp;
       p.st.hp -= amount;
+      const axis2 = origin && type !== "fire" && type !== "heat" ? severAxis(p) : -1;
+      if (axis2 >= 0 && p.st.hp > 0) {
+        const band = bandOf(o, p, axis2, origin);
+        const cuts = (_a = p.rt).cuts ?? (_a.cuts = {});
+        cuts[band] = (cuts[band] ?? 0) + amount * (type === "ballistic" ? SEVER_BALLISTIC : 1);
+        if (cuts[band] >= p.st.maxHp * SEVER_BAND / p.dims[axis2]) {
+          p.rt.cutAt = -p.dims[axis2] / 2 + (band + 0.5) * SEVER_BAND;
+          p.st.hp = 0;
+        }
+      }
       markDamaged(p);
       const trigger = CHAIN_TRIGGER_OF[type];
       const chained = trigger !== void 0 && chainDelayOf(p.spec, trigger) !== void 0;
@@ -4282,7 +4430,7 @@ var GameTestRoom = (() => {
     const ballistic2 = (o, p, entry, n, d, E, caliber, pathLen, src, round2 = {}) => {
       const mat = p.mat;
       const piercing = round2.piercing ?? 1;
-      if (p.st.stripped || p.st.opening && insideOpening(o, p, objLocal(o, entry))) {
+      if (p.st.stripped || p.st.opening && insideOpening(o, p, objLocal(o, entry)) || insideChip(p, objLocal(o, entry))) {
         return { penetrated: true, exitEnergy: E, exitPoint: vec.madd(entry, d, Math.min(pathLen, p.thickness)), damage: 0 };
       }
       const sin2 = Math.min(1, Math.abs(vec.dot(d, n)));
@@ -4341,6 +4489,7 @@ var GameTestRoom = (() => {
       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);
       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) => {
@@ -4368,6 +4517,7 @@ 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);
       return done;
     };
     const blastPart = (o, p, point, energy, radius, src, res, reachAt) => {
@@ -5517,6 +5667,7 @@ var GameTestRoom = (() => {
         sway: "sway",
         spall: "plaster came off",
         stage: "damage stage",
+        chip: "brick knocked out",
         expose: "rebar bare",
         body: "body",
         blast: "blast",
@@ -5607,6 +5758,7 @@ var GameTestRoom = (() => {
         sway: "balan\xE7o",
         spall: "reboco soltou",
         stage: "est\xE1gio de dano",
+        chip: "tijolo arrancado",
         expose: "vergalh\xE3o \xE0 mostra",
         body: "corpo",
         blast: "explos\xE3o",
@@ -17648,6 +17800,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
   };
   var rendererCount = 0;
+  var COLLAPSE_CLOUD_KG = 1e3;
   var IMPACT_TAGS = ["metal", "glass", "wood"];
   var GLOW_FROM_C = 430;
   var QUEUE_CAP = 4e3;
@@ -18107,10 +18260,14 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         case "settle":
           this.onSettle(ev.object);
           break;
-        case "collapse":
+        case "collapse": {
+          const root = this.bounds.get(ev.object)?.root;
+          const furniture = !!root && kitOriginOf(root)?.kind === "furniture";
           this.splitLoose(ev.object);
-          this.playEvent({ kind: "collapse" }, this.rootPoint(ev.object));
+          if (!furniture || ev.mass >= COLLAPSE_CLOUD_KG) this.playEvent({ kind: "collapse" }, this.rootPoint(ev.object));
+          else this.vfx.burst("dust", this.rootPoint(ev.object), [0, 1, 0], clamp6(Math.round(ev.mass / 4), 4, 24), 0.8);
           break;
+        }
         case "disassemble_progress": {
           const k = `unscrew:${ev.joint}`;
           if (this.time - (this.throttles.get(k) ?? -1) > 0.25) {
@@ -18140,6 +18297,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         case "stage":
           this.onStage(ev);
           break;
+        case "chip":
+          this.onChip(ev);
+          break;
         case "expose":
           this.cages.set(`${ev.object}|${ev.part}`, ev.bars);
           if (ev.bars.length > 0) {
@@ -18396,6 +18556,19 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (!played) this.vfx.burst("dust", ev.opening.center, [0, 1, 0], 14, 1.2, { color });
       this.sound(impactKey(def), ev.opening.center, 0.8);
     }
+    /**
+     * A unit came out of a wall of units: the unit flies as a fragment with a puff of its dust. The gap itself is the drawing's (the house renderer redraws
+     * the wall as its courses without that unit); a part drawn as one box keeps its box.
+     */
+    onChip(ev) {
+      const pv = this.partVis(ev.object, ev.part);
+      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);
+      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);
+    }
     onFracture(ev) {
       const b = this.bounds.get(ev.object);
       const pv = b?.parts.get(ev.part);
@@ -38191,7 +38364,7 @@ void main(){
       if (!position) throw new Error(`game-test-room: scenery "${id}" is new, so it needs a position`);
       merged.set(id, { ...obj, position });
     }
-    return [...merged.entries()].map(([id, o]) => ({ id, spec: o.spec, position: o.position, rotationY: o.rotationY ?? 0, colors: o.colors, build: o.build, label: o.label, top: o.top, spout: o.spout }));
+    return [...merged.entries()].map(([id, o]) => ({ id, spec: o.spec, position: o.position, rotationY: o.rotationY ?? 0, colors: o.colors, build: o.build, follow: o.follow, label: o.label, top: o.top, spout: o.spout, free: o.free }));
   }
   function createArena(THREE, size, scene2, scenery, tapOption) {
     const group = markKitOrigin(new THREE.Group(), { owner: "game-test-room", kind: "room" });
@@ -40424,6 +40597,9 @@ void main(){
       "act.strike.leg": "{weapon}: {clip} with the {leg} leg begins, impact in {seconds} s",
       "leg.left": "left",
       "leg.right": "right",
+      "act.strike.hand": "{weapon}: {clip} with the {hand} hand begins, impact in {seconds} s",
+      "hand.left": "left",
+      "hand.right": "right",
       "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",
@@ -40455,6 +40631,7 @@ void main(){
       "loading.open_area": "Opening {area}\u2026",
       "loading.spawn": "Building {name}\u2026",
       "act.loosened": "{name} was heavy but free: the blast moved it",
+      "act.shoved": "{name} stands free: the shots moved it",
       "act.impact": "{name} hit {where} at {speed} m/s: {energy} J of blunt damage",
       "act.use_item": "{name}: {use}",
       "act.tap.on": "Tap opened",
@@ -40731,6 +40908,9 @@ void main(){
       "act.strike.leg": "{weapon}: {clip} com a perna {leg} come\xE7a, impacto em {seconds} s",
       "leg.left": "esquerda",
       "leg.right": "direita",
+      "act.strike.hand": "{weapon}: {clip} com a m\xE3o {hand} come\xE7a, impacto em {seconds} s",
+      "hand.left": "esquerda",
+      "hand.right": "direita",
       "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",
@@ -40762,6 +40942,7 @@ void main(){
       "loading.open_area": "Abrindo {area}\u2026",
       "loading.spawn": "Montando {name}\u2026",
       "act.loosened": "{name} \xE9 pesado mas estava solto: a explos\xE3o o moveu",
+      "act.shoved": "{name} estava solto no ch\xE3o: os tiros o moveram",
       "act.impact": "{name} bateu em {where} a {speed} m/s: {energy} J de dano de impacto",
       "act.use_item": "{name}: {use}",
       "act.tap.on": "Abriu a torneira",
@@ -41225,7 +41406,7 @@ void main(){
     relay.type = "button";
     relay.onclick = () => table.relay();
     trials.appendChild(relay);
-    element.append(head, search, found, sub4, list, trials);
+    element.append(head, search, found, sub4, trials, list);
     const groups = () => {
       const keep = select.value;
       select.textContent = "";
@@ -41872,6 +42053,7 @@ void main(){
 
   // src/room.ts
   var FIXED_DT = 1 / 60;
+  var SHOVE_SPEED = 0.04;
   var METRICS_INTERVAL_S = 0.25;
   var CARRY_NEAR = 0.62;
   var CARRY_PALM = 0.012;
@@ -42234,7 +42416,9 @@ void main(){
         scene2.add(root);
         root.updateMatrixWorld(true);
         world.add(structuredCloneSpec(o.spec), { id: o.id, position: o.position, ...o.rotationY ? { rotation: [0, Math.sin(o.rotationY / 2), 0, Math.cos(o.rotationY / 2)] } : {} });
-        registerEntry(o.id, o.id, root, o.spec, o.label ?? S.text[`arena.${o.id}`] ?? o.id, void 0, void 0, true, false);
+        const e = registerEntry(o.id, o.id, root, o.spec, o.label ?? S.text[`arena.${o.id}`] ?? o.id, void 0, void 0, true, false);
+        if (o.free) e.free = true;
+        e.follower = o.follow?.(root, world, o.id) || null;
       }
     };
     addArena();
@@ -42329,6 +42513,7 @@ void main(){
         renderer.unbind(id);
       } catch {
       }
+      e.follower?.dispose?.();
       if (world.has(id)) world.remove(id);
       e.so.root.removeFromParent();
       letGo(e.so.root);
@@ -42363,6 +42548,7 @@ void main(){
       for (const e of entries.values()) {
         world.reset(e.so.objectId);
         renderer.restore(e.so.objectId);
+        e.follower?.restore?.();
       }
       renderer.clear();
       vfx.world.clear();
@@ -42384,6 +42570,7 @@ void main(){
         if (heldEntry === e) continue;
         world.reset(e.so.objectId);
         renderer.restore(e.so.objectId);
+        e.follower?.restore?.();
         if (e.containerId) {
           const c = fluids.container(e.containerId);
           const f = e.item?.fluid?.container;
@@ -42687,6 +42874,19 @@ void main(){
       if (!rendererPieces.has(objectId)) return;
       renderer.impulse(objectId, [dir[0] * momentum, dir[1] * momentum, dir[2] * momentum], point);
     };
+    const shoveFree = (pushes) => {
+      for (const [objectId, push] 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;
+        const piece = renderer.makePiece(objectId, { mass });
+        e.piece = piece;
+        rendererPieces.set(objectId, piece);
+        action("loosened", t("act.shoved", { name: e.name }), { objectId, itemId: e.so.itemId });
+        renderer.impulse(objectId, push.impulse, push.point);
+      }
+    };
     const fireShots = (shots, recoil) => {
       if (shots.length === 0) return;
       const w = toolName();
@@ -42696,6 +42896,7 @@ void main(){
       let hits = 0;
       let first = null;
       let energy = 0;
+      const pushes = /* @__PURE__ */ new Map();
       withoutHeld(() => {
         for (const s of shots) {
           energy = Math.max(energy, s.energy);
@@ -42707,11 +42908,16 @@ void main(){
             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);
-            pushPiece(r0.object, s.direction, 2 * s.energy / speed, r0.point);
+            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);
           }
           if (shots.length <= 3 || rnd2() < 0.34) tracer(m, end3);
         }
       });
+      shoveFree(pushes);
       player.kick(recoil[0], recoil[1]);
       const f = first;
       const d = f ? num(f.distance, 1) : "";
@@ -42803,16 +43009,25 @@ void main(){
     let strikes = [];
     const kickLeg = options.kickLeg ?? "alternate";
     let nextLeg = "right";
+    const punchHand = options.punchHand ?? "alternate";
+    const punchTools = new Set(options.punchTools ?? ["hand", "fists"]);
+    let nextHand = "right";
     const strikeUse = (u, id = toolId) => {
       const clip = strikeClips[id];
       const leg = id === "kick" ? kickLeg === "alternate" ? nextLeg : kickLeg : void 0;
-      const seconds = clip === void 0 ? null : avatar?.strike?.(clip, leg ? { leg } : void 0) ?? null;
+      const 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 (clip === void 0 || seconds === null) {
         meleeUse(u, id);
         return;
       }
-      action("strike", t(leg ? "act.strike.leg" : "act.strike", { weapon: toolName(id), clip, seconds: num(seconds, 2), leg: leg ? t(`leg.${leg}`) : "" }), { data: { weapon: id, clip, impactIn: seconds, ...leg ? { leg } : {} } });
+      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 } : {} }
+      });
       strikes.push({
         key: id,
         remaining: seconds,