@adatechnology/game-test-room 0.19.1 → 0.20.0

package/dist/index.global.js

@@ -605,9 +605,9 @@ var GameTestRoom = (() => {
     const tz = 2 * (qx * v[1] - qy * v[0]);
     return [v[0] + qw * tx + (qy * tz - qz * ty), v[1] + qw * ty + (qz * tx - qx * tz), v[2] + qw * tz + (qx * ty - qy * tx)];
   };
-  var toLocal = (position, rotation, p) => rotateVec([-rotation[0], -rotation[1], -rotation[2], rotation[3]], [p[0] - position[0], p[1] - position[1], p[2] - position[2]]);
-  var toWorld = (position, rotation, p) => {
-    const r = rotateVec(rotation, p);
+  var toLocal = (position, rotation2, p) => rotateVec([-rotation2[0], -rotation2[1], -rotation2[2], rotation2[3]], [p[0] - position[0], p[1] - position[1], p[2] - position[2]]);
+  var toWorld = (position, rotation2, p) => {
+    const r = rotateVec(rotation2, p);
     return [r[0] + position[0], r[1] + position[1], r[2] + position[2]];
   };
   var shapeDims = (s) => {
@@ -1012,8 +1012,8 @@ var GameTestRoom = (() => {
   };
   var cellsOutside = (cells, thin, point, radius) => cells.filter((c) => planeDistance(c, thin, point) > radius);
   var MAX_MARKS_PER_FRAGMENT = 12;
-  var marksInBox = (center, size, rotation, holes) => {
-    const inverse = rotation ? quat.conjugate(rotation) : void 0;
+  var marksInBox = (center, size, rotation2, holes) => {
+    const inverse = rotation2 ? quat.conjugate(rotation2) : void 0;
     const marks = [];
     for (const hole of holes) {
       const offset = [hole.point[0] - center[0], hole.point[1] - center[1], hole.point[2] - center[2]];
@@ -3602,8 +3602,8 @@ var GameTestRoom = (() => {
       }
       solveStructure(o);
       if (peak <= sec.steel) return;
-      const rotation = (elasticEnergy(peak, L, EI, flexure.loadFactor) - elasticEnergy(sec.steel, L, EI, flexure.loadFactor)) / (2 * sec.steel);
-      p.rt.hinge = (p.rt.hinge ?? 0) + rotation;
+      const rotation2 = (elasticEnergy(peak, L, EI, flexure.loadFactor) - elasticEnergy(sec.steel, L, EI, flexure.loadFactor)) / (2 * sec.steel);
+      p.rt.hinge = (p.rt.hinge ?? 0) + rotation2;
       markDamaged(p);
       if (p.rt.hinge >= flexure.failRotationDeg * Math.PI / 180) hingeDrop(o, p, src);
     };
@@ -4305,8 +4305,8 @@ var GameTestRoom = (() => {
     const detachEvents = (o, opened, by, src) => {
       for (const j of opened) emit2({ ...base(o, src), type: "detach", joint: j.spec.id, parts: [j.spec.a, j.spec.b], by, groups: o.st.groups.map((g) => [...g]) });
     };
-    const slideOffResting = (o, rotation) => {
-      const upY = 1 - 2 * (rotation[0] * rotation[0] + rotation[2] * rotation[2]);
+    const slideOffResting = (o, rotation2) => {
+      const upY = 1 - 2 * (rotation2[0] * rotation2[0] + rotation2[2] * rotation2[2]);
       if (upY >= RESTING_HOLD_COS) return;
       const opened = o.joints.filter((j) => j.spec.kind === "resting" && !j.st.open);
       if (opened.length === 0) return;
@@ -5729,11 +5729,11 @@ var GameTestRoom = (() => {
         impls.set(id, { impl, position: opts.position ?? [0, 0, 0], rotation: opts.rotation ?? [0, 0, 0, 1], poses: /* @__PURE__ */ new Map() });
         return id;
       },
-      setPartPose(objectId, partId, position, rotation) {
-        const q = quatFromEuler(...rotation ?? [0, 0, 0]);
+      setPartPose(objectId, partId, position, rotation2) {
+        const q = quatFromEuler(...rotation2 ?? [0, 0, 0]);
         const im = impls.get(objectId);
         if (im) {
-          im.impl.setPartPose?.(partId, position, rotation);
+          im.impl.setPartPose?.(partId, position, rotation2);
           im.poses.set(partId, { pos: [position[0], position[1], position[2]], q });
           return;
         }
@@ -5750,17 +5750,17 @@ var GameTestRoom = (() => {
       },
       has: (id) => taken(id),
       ids: () => [...objects.keys(), ...impls.keys()],
-      setTransform(id, position, rotation) {
+      setTransform(id, position, rotation2) {
         const im = impls.get(id);
         if (im) {
           im.position = [position[0], position[1], position[2]];
-          im.rotation = [rotation[0], rotation[1], rotation[2], rotation[3]];
+          im.rotation = [rotation2[0], rotation2[1], rotation2[2], rotation2[3]];
           return;
         }
         const o = getObj(id);
-        o.base = { pos: [position[0], position[1], position[2]], rot: [rotation[0], rotation[1], rotation[2], rotation[3]] };
+        o.base = { pos: [position[0], position[1], position[2]], rot: [rotation2[0], rotation2[1], rotation2[2], rotation2[3]] };
         applySoilPose(o);
-        slideOffResting(o, rotation);
+        slideOffResting(o, rotation2);
       },
       splitGroup(id, group, newId) {
         if (impls.has(id)) throw new Error(`object "${id}" is a registered DestructibleImpl and cannot be split; its module owns its pieces`);
@@ -9166,11 +9166,231 @@ var GameTestRoom = (() => {
       glow.outIntensity = glow.i * Math.pow(1 - age, glow.curve) * flicker;
     }
   }
+  var LEHMER_MULTIPLIER = 16807;
+  var LEHMER_MODULUS = 2147483647;
+  var HASH_MIX = 2654435761;
+  function normalizeLehmerSeed(seed) {
+    const whole = Math.floor(Math.abs(seed)) % (LEHMER_MODULUS - 1);
+    return whole === 0 ? 1 : whole;
+  }
+  function lehmer(seed) {
+    let state = normalizeLehmerSeed(seed);
+    const next = () => {
+      state = state * LEHMER_MULTIPLIER % LEHMER_MODULUS;
+      return (state - 1) / (LEHMER_MODULUS - 1);
+    };
+    return {
+      next,
+      between: (min2, max2) => min2 + (max2 - min2) * next(),
+      direction(out) {
+        const up = next() * 2 - 1;
+        const angle = next() * Math.PI * 2;
+        const ring2 = Math.sqrt(1 - up * up);
+        out.x = ring2 * Math.cos(angle);
+        out.y = up;
+        out.z = ring2 * Math.sin(angle);
+        return out;
+      },
+      get state() {
+        return state;
+      }
+    };
+  }
+  function mixEventSeed(eventSeed) {
+    let mixed = Math.imul((eventSeed | 0) ^ HASH_MIX, 2246822507);
+    mixed ^= mixed >>> 13;
+    mixed = Math.imul(mixed, 3266489909);
+    mixed ^= mixed >>> 16;
+    return (mixed >>> 0) % (LEHMER_MODULUS - 1) + 1;
+  }
+  function streamFor2(eventSeed) {
+    return lehmer(mixEventSeed(eventSeed));
+  }
+  var SKIN = 5e-3;
+  var MAX_PAD = 0.45;
+  function rotation(q) {
+    const [x, y, z, w] = q ?? [0, 0, 0, 1];
+    const n = Math.hypot(x, y, z, w) || 1;
+    const qx = x / n;
+    const qy = y / n;
+    const qz = z / n;
+    const qw = w / n;
+    return new Float64Array([
+      1 - 2 * (qy * qy + qz * qz),
+      2 * (qx * qy - qz * qw),
+      2 * (qx * qz + qy * qw),
+      2 * (qx * qy + qz * qw),
+      1 - 2 * (qx * qx + qz * qz),
+      2 * (qy * qz - qx * qw),
+      2 * (qx * qz - qy * qw),
+      2 * (qy * qz + qx * qw),
+      1 - 2 * (qx * qx + qy * qy)
+    ]);
+  }
+  var Enclosures = class {
+    constructor(seed = 20973) {
+      __publicField(this, "spaces", /* @__PURE__ */ new Map());
+      __publicField(this, "list", []);
+      __publicField(this, "random");
+      __publicField(this, "out", { x: 0, y: 0, z: 0, nx: 0, ny: 0, nz: 0 });
+      __publicField(this, "l0", new Float64Array(3));
+      __publicField(this, "l1", new Float64Array(3));
+      __publicField(this, "q", new Float64Array(3));
+      this.random = lehmer(seed);
+    }
+    get empty() {
+      return this.list.length === 0;
+    }
+    get size() {
+      return this.list.length;
+    }
+    /** Declares, moves or (with `null`) ends the space `id`. */
+    set(id, enclosure) {
+      if (!enclosure) {
+        if (this.spaces.delete(id)) this.list = [...this.spaces.values()];
+        return;
+      }
+      const [hx, hy, hz] = enclosure.halfSize;
+      const space = {
+        cx: enclosure.center[0],
+        cy: enclosure.center[1],
+        cz: enclosure.center[2],
+        hx: Math.abs(hx),
+        hy: Math.abs(hy),
+        hz: Math.abs(hz),
+        r: rotation(enclosure.orientation),
+        radius: Math.hypot(hx, hy, hz),
+        openings: enclosure.openings ?? [],
+        leak: Math.max(0, enclosure.leak ?? 0)
+      };
+      const old = this.spaces.get(id);
+      this.spaces.set(id, space);
+      const at3 = old ? this.list.indexOf(old) : -1;
+      if (at3 >= 0) this.list[at3] = space;
+      else this.list.push(space);
+    }
+    get(id) {
+      const s = this.spaces.get(id);
+      if (!s) return void 0;
+      return { center: [s.cx, s.cy, s.cz], halfSize: [s.hx, s.hy, s.hz], openings: s.openings, leak: s.leak };
+    }
+    ids() {
+      return [...this.spaces.keys()];
+    }
+    clear() {
+      this.spaces.clear();
+      this.list = [];
+    }
+    /** Whether a point is inside any space (on the inside of its walls). */
+    inside(x, y, z) {
+      for (const s of this.list) {
+        this.toLocal(s, x, y, z, this.l0);
+        if (Math.abs(this.l0[0]) <= s.hx && Math.abs(this.l0[1]) <= s.hy && Math.abs(this.l0[2]) <= s.hz) return true;
+      }
+      return false;
+    }
+    toLocal(s, x, y, z, out) {
+      const dx = x - s.cx;
+      const dy = y - s.cy;
+      const dz = z - s.cz;
+      const r = s.r;
+      out[0] = r[0] * dx + r[3] * dy + r[6] * dz;
+      out[1] = r[1] * dx + r[4] * dy + r[7] * dz;
+      out[2] = r[2] * dx + r[5] * dy + r[8] * dz;
+    }
+    /** Passes at `rate` per second. */
+    chance(rate, dt) {
+      return rate > 0 && this.random.next() < 1 - Math.exp(-rate * dt);
+    }
+    /** The opening the wall point `q` (local) is in lets it through now. */
+    through(s, q, dt) {
+      for (const o of s.openings) {
+        if (Math.abs(q[0] - o.center[0]) > o.halfSize[0] || Math.abs(q[1] - o.center[1]) > o.halfSize[1] || Math.abs(q[2] - o.center[2]) > o.halfSize[2]) continue;
+        if (o.rate === void 0 || this.chance(o.rate, dt)) return true;
+      }
+      return this.chance(s.leak, dt);
+    }
+    confine(x0, y0, z0, x1, y1, z1, pad2, dt) {
+      const list = this.list;
+      if (list.length === 0) return false;
+      const p = Math.min(Math.max(0, pad2), MAX_PAD);
+      const l0 = this.l0;
+      const l1 = this.l1;
+      const q = this.q;
+      for (const s of list) {
+        const reach = s.radius + p + 0.05;
+        const dx = x1 - s.cx;
+        const dy = y1 - s.cy;
+        const dz = z1 - s.cz;
+        if (dx * dx + dy * dy + dz * dz > reach * reach) {
+          const ex = x0 - s.cx;
+          const ey = y0 - s.cy;
+          const ez = z0 - s.cz;
+          if (ex * ex + ey * ey + ez * ez > reach * reach) continue;
+        }
+        this.toLocal(s, x0, y0, z0, l0);
+        this.toLocal(s, x1, y1, z1, l1);
+        const h = [s.hx, s.hy, s.hz];
+        const in0 = Math.abs(l0[0]) <= s.hx && Math.abs(l0[1]) <= s.hy && Math.abs(l0[2]) <= s.hz;
+        let axis2 = 0;
+        let sign = 1;
+        if (in0) {
+          if (Math.abs(l1[0]) <= s.hx && Math.abs(l1[1]) <= s.hy && Math.abs(l1[2]) <= s.hz) continue;
+          for (let a = 0; a < 3; a++) q[a] = Math.min(h[a], Math.max(-h[a], l1[a]));
+          if (this.through(s, q, dt)) continue;
+          let worst = -Infinity;
+          for (let a = 0; a < 3; a++) {
+            const over = Math.abs(l1[a]) - h[a];
+            if (over > worst) {
+              worst = over;
+              axis2 = a;
+            }
+          }
+          sign = l1[axis2] < 0 ? -1 : 1;
+          for (let a = 0; a < 3; a++) l1[a] = Math.min(h[a] - SKIN, Math.max(-(h[a] - SKIN), l1[a]));
+          sign = -sign;
+        } else {
+          const padded0 = Math.abs(l0[0]) <= s.hx + p && Math.abs(l0[1]) <= s.hy + p && Math.abs(l0[2]) <= s.hz + p;
+          const bound = padded0 ? 0 : p;
+          if (!(Math.abs(l1[0]) <= s.hx + bound && Math.abs(l1[1]) <= s.hy + bound && Math.abs(l1[2]) <= s.hz + bound)) continue;
+          for (let a = 0; a < 3; a++) q[a] = Math.min(h[a], Math.max(-h[a], l1[a]));
+          if (this.through(s, q, dt)) continue;
+          let worst = -Infinity;
+          for (let a = 0; a < 3; a++) {
+            const over = Math.abs(l0[a]) - (h[a] + bound);
+            if (over > worst) {
+              worst = over;
+              axis2 = a;
+            }
+          }
+          sign = l0[axis2] < 0 ? -1 : 1;
+          l1[axis2] = sign * (h[axis2] + bound + SKIN);
+        }
+        const r = s.r;
+        const out = this.out;
+        out.x = s.cx + r[0] * l1[0] + r[1] * l1[1] + r[2] * l1[2];
+        out.y = s.cy + r[3] * l1[0] + r[4] * l1[1] + r[5] * l1[2];
+        out.z = s.cz + r[6] * l1[0] + r[7] * l1[1] + r[8] * l1[2];
+        out.nx = r[axis2] * sign;
+        out.ny = r[3 + axis2] * sign;
+        out.nz = r[6 + axis2] * sign;
+        return true;
+      }
+      return false;
+    }
+  };
+  function slideAlong(out, vx2, vy2, vz2) {
+    const into = vx2 * out.nx + vy2 * out.ny + vz2 * out.nz;
+    if (into >= 0) return [vx2, vy2, vz2];
+    return [vx2 - into * out.nx, vy2 - into * out.ny, vz2 - into * out.nz];
+  }
   var FLOOR_FRACTION = 0.4;
   var FLOOR_BOUNCE = -0.2;
   var ARRIVAL_FRAME = 30;
   var ARRIVAL_BASE = 0.3;
   var GROWTH_CAP_SECONDS = 3.5;
+  var CARRIED_KINDS = [true, true, false, true, false];
+  var PAD_OF_SIZE = 0.35;
   function createPuffPool(capacity) {
     const placeholder = { next: () => 0, between: (min2) => min2, direction: (out) => out, state: 0 };
     return new OrderedPool(capacity, () => ({
@@ -9265,13 +9485,24 @@ var GameTestRoom = (() => {
       if (puff3.vy < 0) puff3.vy *= FLOOR_BOUNCE;
     }
   }
-  function updatePuffs(pool, dt, wind) {
+  function updatePuffs(pool, dt, wind, confiner) {
     pool.compact(ageOrKeep2, dt);
+    const confining = confiner !== void 0 && !confiner.empty;
     for (const puff3 of pool.items) {
       const age = puff3.t / puff3.life;
       const heat = puff3.h0 > 0 ? puff3.h0 * Math.pow(Math.max(0, 1 - puff3.t / puff3.hl), 1.25) : 0;
+      const x0 = puff3.x;
+      const y0 = puff3.y;
+      const z0 = puff3.z;
       if (puff3.ring) moveOnRing(puff3, puff3.ring, wind);
       else moveFree(puff3, dt, age, heat, wind);
+      if (confining && CARRIED_KINDS[puff3.kind] && confiner.confine(x0, y0, z0, puff3.x, puff3.y, puff3.z, puff3.size * PAD_OF_SIZE, dt)) {
+        const out = confiner.out;
+        puff3.x = out.x;
+        puff3.y = out.y;
+        puff3.z = out.z;
+        [puff3.vx, puff3.vy, puff3.vz] = slideAlong(out, puff3.vx, puff3.vy, puff3.vz);
+      }
       const size = puff3.s0 + (puff3.s1 - puff3.s0) * (1 - Math.exp(-puff3.t * puff3.gk)) + puff3.sg * Math.min(puff3.t, GROWTH_CAP_SECONDS);
       puff3.size = size * Math.min(1, puff3.t * ARRIVAL_FRAME + ARRIVAL_BASE);
       puff3.age = age;
@@ -9797,10 +10028,10 @@ var GameTestRoom = (() => {
       ])
     ]
   };
-  function localToWorld(translation, rotation, local2) {
+  function localToWorld(translation, rotation2, local2) {
     const [x, y, z] = local2;
-    const [a, c, e] = [Math.cos(rotation[0]), Math.cos(rotation[1]), Math.cos(rotation[2])];
-    const [b, d, f] = [Math.sin(rotation[0]), Math.sin(rotation[1]), Math.sin(rotation[2])];
+    const [a, c, e] = [Math.cos(rotation2[0]), Math.cos(rotation2[1]), Math.cos(rotation2[2])];
+    const [b, d, f] = [Math.sin(rotation2[0]), Math.sin(rotation2[1]), Math.sin(rotation2[2])];
     const [ae, af, be, bf] = [a * e, a * f, b * e, b * f];
     return [
       c * e * x + -c * f * y + d * z + translation[0],
@@ -11463,46 +11694,6 @@ var GameTestRoom = (() => {
   var ALL_EFFECTS = [BLOOD_HIT, HEADSHOT, DISMEMBER, BLOATER_CLOUD, SCREAMER_SHRIEK, CORPSE_DECAY, REANIMATION, EYES_IN_FOG, MUZZLE_FLASH, IMPACT_BY_MATERIAL, PENETRATION, CASINGS_AND_MAGAZINE, MOLOTOV, GRENADE, EXPLOSIVE_BARREL, SHOPFRONT_GLASS, DOOR_STAGES, BUILDING_COLLAPSE, BLOCK_WALL, METAL_DOOR_EFFECT, IRON_RAILING, WOODEN_FENCE, HIT_POINT_BREAKAGE, PRESSURE_CYLINDERS, BUILDING_FIRE, RAIN_AND_PUDDLES, FOG_AND_ASH, SCRAPING_SPARKS, ENGINE_SMOKE, FUEL_LEAK, CAR_EXPLOSION, WINDSHIELD, HEADLIGHTS_IN_RAIN, DAMAGE_AND_BITE, INFECTION_PHASES, PANIC, BLOATER_BLINDNESS, CAMPFIRE, COUGH_AND_BREATH];
   var WORKSHOP_EFFECTS = Object.fromEntries(ALL_EFFECTS.map((effect) => [effect.id, effect]));
   var GAME_EFFECTS = { ...WORKSHOP_EFFECTS, ...Object.fromEntries([...EVENT_EFFECTS, ...VIEWMODEL_EFFECTS, ...VEHICLE_EFFECTS].map((effect) => [effect.id, effect])) };
-  var LEHMER_MULTIPLIER = 16807;
-  var LEHMER_MODULUS = 2147483647;
-  var HASH_MIX = 2654435761;
-  function normalizeLehmerSeed(seed) {
-    const whole = Math.floor(Math.abs(seed)) % (LEHMER_MODULUS - 1);
-    return whole === 0 ? 1 : whole;
-  }
-  function lehmer(seed) {
-    let state = normalizeLehmerSeed(seed);
-    const next = () => {
-      state = state * LEHMER_MULTIPLIER % LEHMER_MODULUS;
-      return (state - 1) / (LEHMER_MODULUS - 1);
-    };
-    return {
-      next,
-      between: (min2, max2) => min2 + (max2 - min2) * next(),
-      direction(out) {
-        const up = next() * 2 - 1;
-        const angle = next() * Math.PI * 2;
-        const ring2 = Math.sqrt(1 - up * up);
-        out.x = ring2 * Math.cos(angle);
-        out.y = up;
-        out.z = ring2 * Math.sin(angle);
-        return out;
-      },
-      get state() {
-        return state;
-      }
-    };
-  }
-  function mixEventSeed(eventSeed) {
-    let mixed = Math.imul((eventSeed | 0) ^ HASH_MIX, 2246822507);
-    mixed ^= mixed >>> 13;
-    mixed = Math.imul(mixed, 3266489909);
-    mixed ^= mixed >>> 16;
-    return (mixed >>> 0) % (LEHMER_MODULUS - 1) + 1;
-  }
-  function streamFor2(eventSeed) {
-    return lehmer(mixEventSeed(eventSeed));
-  }
   var TABLE = {
     concrete: { dust: 9078138, chip: 7236195, spark: 2 },
     metal: { dust: 0, chip: 0, spark: 18 },
@@ -12806,8 +12997,8 @@ var GameTestRoom = (() => {
   function addScorch(store, random, x, z, radius) {
     const variant = Math.floor(random.next() * SCORCH_VARIANTS);
     const lift = 0.03 + nextLift(store) * 1e-3;
-    const rotation = random.next() * 6;
-    store.add({ kind: "scorch", x, z, radius, variant, lift, rotation });
+    const rotation2 = random.next() * 6;
+    store.add({ kind: "scorch", x, z, radius, variant, lift, rotation: rotation2 });
   }
   function addRimRocks(store, ground, random, x, z, radius) {
     const count = Math.round(6 + radius * 7);
@@ -12836,8 +13027,8 @@ var GameTestRoom = (() => {
   function addCrater(store, ground, random, spec) {
     ground?.dent(random, spec.x, spec.z, spec.radius, spec.depth);
     if (!spec.marks) return;
-    const rotation = random.next() * 6;
-    store.add({ kind: "dirt", x: spec.x, z: spec.z, radius: spec.radius * 1.02, lift: 0.045, rotation });
+    const rotation2 = random.next() * 6;
+    store.add({ kind: "dirt", x: spec.x, z: spec.z, radius: spec.radius * 1.02, lift: 0.045, rotation: rotation2 });
     addRimRocks(store, ground, random, spec.x, spec.z, spec.radius);
   }
   function addBloodSplat(store, ground, random, spec) {
@@ -13393,6 +13584,7 @@ var GameTestRoom = (() => {
     state.gas = Math.max(0, state.gas - dt / DECAY.gasSeconds);
     state.beat *= Math.exp(-DECAY.beat * dt);
   }
+  var PAD_OF_SIZE2 = 0.35;
   var clamp4 = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
   var lerp4 = (a, b, t) => a + (b - a) * t;
   function rgb(hex) {
@@ -13552,9 +13744,20 @@ var GameTestRoom = (() => {
           vy2 *= k;
           vz2 *= k;
         }
-        const x = this.position[i3] + vx2 * dt;
+        let x = this.position[i3] + vx2 * dt;
         let y = this.position[i3 + 1] + vy2 * dt;
-        const z = this.position[i3 + 2] + vz2 * dt;
+        let z = this.position[i3 + 2] + vz2 * dt;
+        const confiner = host.confiner;
+        if (def.carried && confiner && !confiner.empty) {
+          const pad2 = this.size0[i] * lerp4(1, def.grow, t) * PAD_OF_SIZE2;
+          if (confiner.confine(this.position[i3], this.position[i3 + 1], this.position[i3 + 2], x, y, z, pad2, dt)) {
+            const out = confiner.out;
+            x = out.x;
+            y = out.y;
+            z = out.z;
+            [vx2, vy2, vz2] = slideAlong(out, vx2, vy2, vz2);
+          }
+        }
         if (def.ground !== "none") {
           const own = this.floor[i];
           const gy = Number.isNaN(own) ? host.groundAt(x, z) + 5e-3 : own;
@@ -13640,7 +13843,8 @@ var GameTestRoom = (() => {
       alpha: 0.35,
       fadeIn: 0.15,
       cone: 0.6,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     sparks: {
       id: "sparks",
@@ -13684,7 +13888,8 @@ var GameTestRoom = (() => {
       alpha: 0.4,
       fadeIn: 0.1,
       cone: 0.4,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     shards: {
       id: "shards",
@@ -13842,7 +14047,8 @@ var GameTestRoom = (() => {
       fadeIn: 0.1,
       cone: 0.5,
       ground: "stop",
-      flutter: 0.6
+      flutter: 0.6,
+      carried: true
     },
     steam: {
       id: "steam",
@@ -13864,7 +14070,8 @@ var GameTestRoom = (() => {
       alpha: 0.35,
       fadeIn: 0.15,
       cone: 0.6,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     flash: {
       id: "flash",
@@ -14005,7 +14212,8 @@ var GameTestRoom = (() => {
       const host = {
         groundAt: this.options.groundAt,
         gravity: this.options.gravity,
-        land: (owner, x, y, z, color, tag) => this.listeners.get(owner)?.(x, y, z, color, tag)
+        land: (owner, x, y, z, color, tag) => this.listeners.get(owner)?.(x, y, z, color, tag),
+        ...this.options.confiner ? { confiner: this.options.confiner } : {}
       };
       if (this.additive.live > 0 || this.additive.drawCount > 0) this.additive.update(dt, host);
       if (this.normal.live > 0 || this.normal.drawCount > 0) this.normal.update(dt, host);
@@ -14211,8 +14419,8 @@ var GameTestRoom = (() => {
      * Takes away the marks inside a box: world `center`, `half` extents along the axes of the world `rotation` (a quaternion, x y z w; none means the
      * world axes). The surface they were on is gone (a brick came out of a wall with its bullet holes). Returns how many went.
      */
-    clearInside(center, half, rotation = [0, 0, 0, 1]) {
-      const qx = -rotation[0], qy = -rotation[1], qz = -rotation[2], qw = rotation[3];
+    clearInside(center, half, rotation2 = [0, 0, 0, 1]) {
+      const qx = -rotation2[0], qy = -rotation2[1], qz = -rotation2[2], qw = rotation2[3];
       let gone = 0;
       for (const decal2 of this.decals) {
         if (!decal2.on) continue;
@@ -14333,10 +14541,14 @@ var GameTestRoom = (() => {
   var DEFAULT_FADE_IN = 0.1;
   var FLOATS_PER_VECTOR = 3;
   var BYTE_MAX2 = 255;
+  var CARRIED_GRAVITY = 3;
+  var PAD_OF_SIZE3 = 0.35;
   var SpritePool = class {
-    constructor(capacity, context) {
+    /** `carried`: the normal-blend pool (smoke, dust, steam), whose light sprites go round the closed spaces; the additive one (flames, sparks) does not. */
+    constructor(capacity, context, carried = false) {
       __publicField(this, "capacity", capacity);
       __publicField(this, "context", context);
+      __publicField(this, "carried", carried);
       __publicField(this, "count", 0);
       __publicField(this, "position");
       __publicField(this, "velocity");
@@ -14436,6 +14648,7 @@ var GameTestRoom = (() => {
     }
     update(dt, leaveDecal) {
       const { position, velocity } = this;
+      const confiner = this.context.confiner;
       for (let index = this.count - 1; index >= 0; index--) {
         this.life[index] -= dt;
         if (this.life[index] <= 0) {
@@ -14449,9 +14662,25 @@ var GameTestRoom = (() => {
         velocity[offset] *= factor;
         velocity[offset + 1] *= factor;
         velocity[offset + 2] *= factor;
+        const x0 = position[offset];
+        const y0 = position[offset + 1];
+        const z0 = position[offset + 2];
         position[offset] += velocity[offset] * dt;
         position[offset + 1] += velocity[offset + 1] * dt;
         position[offset + 2] += velocity[offset + 2] * dt;
+        if (this.carried && confiner && !confiner.empty && Math.abs(this.gravity[index]) < CARRIED_GRAVITY) {
+          const size = this.startSize[index] * (1 + (this.growth[index] - 1) * age);
+          if (confiner.confine(x0, y0, z0, position[offset], position[offset + 1], position[offset + 2], size * PAD_OF_SIZE3, dt)) {
+            const out = confiner.out;
+            position[offset] = out.x;
+            position[offset + 1] = out.y;
+            position[offset + 2] = out.z;
+            const [vx2, vy2, vz2] = slideAlong(out, velocity[offset], velocity[offset + 1], velocity[offset + 2]);
+            velocity[offset] = vx2;
+            velocity[offset + 1] = vy2;
+            velocity[offset + 2] = vz2;
+          }
+        }
         const mode = this.groundMode[index];
         if (mode) {
           const groundHeight = this.context.groundAt(position[offset], position[offset + 2]);
@@ -14728,9 +14957,9 @@ var GameTestRoom = (() => {
       __publicField(this, "placement");
       __publicField(this, "accumulators", /* @__PURE__ */ new Map());
       const profile = options.profile ?? PROFILES.high;
-      this.context = { random: options.random, groundAt: options.groundAt ?? workshopGround, quality: { level: 0, mult: 1 }, trace: options.trace };
+      this.context = { random: options.random, groundAt: options.groundAt ?? workshopGround, quality: { level: 0, mult: 1 }, trace: options.trace, ...options.confiner ? { confiner: options.confiner } : {} };
       this.add = new SpritePool(profile.sprites.add, this.context);
-      this.normal = new SpritePool(profile.sprites.normal, this.context);
+      this.normal = new SpritePool(profile.sprites.normal, this.context, true);
       this.streaks = new StreakPool(profile.streaks, this.context);
       this.debris = new DebrisPool(this.context);
       this.decals = new DecalPool(this.context);
@@ -14918,12 +15147,14 @@ var GameTestRoom = (() => {
     const groundAt = options.groundAt ?? (ground ? (x, z) => ground.heightAt(x, z) : () => 0);
     const handles = { next: 0, events: 0 };
     const low = options.profile === "low";
+    const enclosures = new Enclosures(20973 + (options.seed ?? 0));
     const spriteSystem = new SpriteKindSystem({
       capacity: options.sprites?.capacity ?? (low ? 1250 : 2500),
       density: options.sprites?.density ?? (low ? 0.6 : 1),
       seed: 2654435761 + (options.seed ?? 0),
       groundAt,
       gravity: options.gravity ?? DEFAULT_GRAVITY,
+      confiner: enclosures,
       ...options.sprites?.kinds ? { kinds: options.sprites.kinds } : {}
     });
     const core = {
@@ -14973,7 +15204,7 @@ var GameTestRoom = (() => {
       return [camera2.x, camera2.y, camera2.z];
     }, forward: (local2) => [local2[0] ?? 0, local2[1] ?? 0, local2[2] ?? 0] };
     function workshop() {
-      return engine ?? (engine = new WorkshopEngine({ random: sharedRandom, profile, groundAt }));
+      return engine ?? (engine = new WorkshopEngine({ random: sharedRandom, profile, groundAt, confiner: enclosures }));
     }
     function effectPlayer() {
       return player ?? (player = createEffectPlayer({ engine: workshop(), effects, view }));
@@ -15032,6 +15263,10 @@ var GameTestRoom = (() => {
           puff3.vz += dz * strength;
         }
       },
+      enclose(id, enclosure) {
+        enclosures.set(id, enclosure);
+      },
+      enclosures: () => enclosures,
       stop(handle) {
         player?.stop(handle);
         const fires = core.fires;
@@ -15059,7 +15294,7 @@ var GameTestRoom = (() => {
         core.clock.time += dt;
         core.schedule.update(core.clock.time);
         updateRings(core.rings, dt);
-        updatePuffs(core.puffs, dt, wind);
+        updatePuffs(core.puffs, dt, wind, enclosures);
         updateSparks(core.sparks, { dt, groundAt });
         updateGlows(core.glows, dt);
         updateShocks(core.shocks, core.puffs.items, dt);
@@ -16459,6 +16694,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         });
       },
       stop: (handle) => world.stop(handle),
+      // a module's closed space (a shut car's cabin): the world's smoke, dust and steam go round it
+      enclose: (id, enclosure) => world.enclose(id, enclosure),
       configure(settings) {
         const band = settings.lod_band;
         if (typeof band === "string" && band in LOD_BANDS) world.forceLod(LOD_BANDS[band] ?? null);
@@ -18389,8 +18626,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
      * Takes away the decals of a mesh that sit inside a box (world `center`, `half` extents along the axes of the world `rotation`): the surface they
      * marked is gone (a unit came out of the wall with its bullet holes and spalls).
      */
-    clearDecals(mv, center, half, rotation) {
-      const inv = rotation.clone().invert();
+    clearDecals(mv, center, half, rotation2) {
+      const inv = rotation2.clone().invert();
       const p = new this.THREE.Vector3();
       for (let i = mv.decals.length - 1; i >= 0; i--) {
         const d = mv.decals[i];
@@ -19820,8 +20057,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const T = this.THREE;
       const center = new T.Vector3(ev.center[0], ev.center[1], ev.center[2]);
       const half = new T.Vector3(ev.size[0] / 2 + CHIP_DECAL_EDGE, ev.size[1] / 2 + CHIP_DECAL_EDGE, ev.size[2] / 2 + CHIP_DECAL_EDGE);
-      const rotation = new T.Quaternion(ev.rotation[0], ev.rotation[1], ev.rotation[2], ev.rotation[3]);
-      for (const part of this.bounds.get(ev.object)?.parts.values() ?? []) for (const mv of part.meshes) this.visuals.clearDecals(mv, center, half, rotation);
+      const rotation2 = new T.Quaternion(ev.rotation[0], ev.rotation[1], ev.rotation[2], ev.rotation[3]);
+      for (const part of this.bounds.get(ev.object)?.parts.values() ?? []) for (const mv of part.meshes) this.visuals.clearDecals(mv, center, half, rotation2);
       this.vfx.peekWorkshop()?.decals.clearInside(ev.center, [half.x, half.y, half.z], ev.rotation);
       this.vfx.burst("dust", ev.center, [0, 1, 0], 8, 0.8, { color });
       this.sound(impactKey(def), ev.center, 0.7);
@@ -36139,11 +36376,11 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         for (const key2 of Object.keys(c.streams)) endStreamKey(c, key2);
         containers.delete(id);
       },
-      setTransform(id, position, rotation, velocity) {
+      setTransform(id, position, rotation2, velocity) {
         const c = containers.get(id);
         if (!c) return;
         c.position = copy3(position);
-        c.rotation = [...rotation];
+        c.rotation = [...rotation2];
         if (velocity) c.velocity = copy3(velocity);
         refreshLevel(c);
       },
@@ -37065,10 +37302,10 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       const hand = getHandTransform();
       const p = pose();
       const position = add2(hand.position, quatRotate(hand.rotation, p.position));
-      const rotation = quatMultiply(hand.rotation, quatFromEuler2(p.rotation[0], p.rotation[1], p.rotation[2]));
+      const rotation2 = quatMultiply(hand.rotation, quatFromEuler2(p.rotation[0], p.rotation[1], p.rotation[2]));
       const velocity = lastPos && dt > 0 ? [(position[0] - lastPos[0]) / dt, (position[1] - lastPos[1]) / dt, (position[2] - lastPos[2]) / dt] : void 0;
       lastPos = position;
-      world.setTransform(containerId, position, rotation, velocity);
+      world.setTransform(containerId, position, rotation2, velocity);
     };
     const player = {
       def,
@@ -39097,7 +39334,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     const direction = new THREE.Vector3();
     const location = new THREE.Vector3();
     const scale2 = new THREE.Vector3();
-    const rotation = new THREE.Quaternion();
+    const rotation2 = new THREE.Quaternion();
     const matrix = new THREE.Matrix4();
     return {
       drops,
@@ -39117,9 +39354,9 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
           const o = i * 3;
           const speed = Math.hypot(velocity[o], velocity[o + 1], velocity[o + 2]);
           direction.set(velocity[o], velocity[o + 1], velocity[o + 2]).normalize();
-          rotation.setFromUnitVectors(up, direction);
+          rotation2.setFromUnitVectors(up, direction);
           const size = radius[i] * METRES_PER_MM;
-          matrix.compose(location.set(position[o], position[o + 1], position[o + 2]), rotation, scale2.set(size, size * (1 + Math.min(MAX_STRETCH, speed * STRETCH_PER_SPEED)), size));
+          matrix.compose(location.set(position[o], position[o + 1], position[o + 2]), rotation2, scale2.set(size, size * (1 + Math.min(MAX_STRETCH, speed * STRETCH_PER_SPEED)), size));
           drops.setMatrixAt(i, matrix);
           drawn++;
         }
@@ -42661,7 +42898,7 @@ void main(){
   var NEAR_OPEN_LEAF = 0.9;
   var BODY_HEIGHT = 1.8;
   var HAND_REST = [0.22, -0.42, -0.32];
-  var SKIN = 0.01;
+  var SKIN2 = 0.01;
   var HANDLE_INSET = 0.06;
   var STANDOFF2 = 0.55;
   var DRAWER_TRAVEL = 0.3;
@@ -42805,7 +43042,7 @@ void main(){
         const o = outs[0];
         return [o[1] * (o[0] + PLAYER_RADIUS), o[2] * (o[0] + PLAYER_RADIUS)];
       }
-      const push = PLAYER_RADIUS - d + SKIN;
+      const push = PLAYER_RADIUS - d + SKIN2;
       return [dx / d * push, dz / d * push];
     };
     const isFree = (u, from, to) => {
@@ -42815,7 +43052,7 @@ void main(){
       options.pose(objectId, leaf2.part, leaf2.clip, to);
       obj.updateMatrixWorld(true);
       box2.setFromObject(obj);
-      box2.expandByScalar(-SKIN);
+      box2.expandByScalar(-SKIN2);
       let by = null;
       if (Math.max(Math.abs(box2.min.x), Math.abs(box2.max.x), Math.abs(box2.min.z), Math.abs(box2.max.z)) > arena.limit) by = "wall";
       else
@@ -42833,7 +43070,7 @@ void main(){
         const dir = [tmp.x - centre.x, tmp.y - centre.y, tmp.z - centre.z];
         const len = Math.hypot(dir[0], dir[1], dir[2]);
         if (len > 1e-5) {
-          const hit = world.sweepBox({ min: [before.min.x + SKIN, before.min.y + FLOOR_GAP, before.min.z + SKIN], max: [before.max.x - SKIN, before.max.y - SKIN, before.max.z - SKIN] }, dir, len * 2, { ignore: objectId, spacing: 0.12 });
+          const hit = world.sweepBox({ min: [before.min.x + SKIN2, before.min.y + FLOOR_GAP, before.min.z + SKIN2], max: [before.max.x - SKIN2, before.max.y - SKIN2, before.max.z - SKIN2] }, dir, len * 2, { ignore: objectId, spacing: 0.12 });
           if (hit && hit.normal[1] < 0.7) by = hit.object;
         }
       }
@@ -43121,6 +43358,7 @@ void main(){
       debris: "chips",
       color: [0.05, 0.05, 0.055],
       pattern: "asphalt",
+      crack: { reach: 0.6, width: 8e-3, thresholdJoules: 800 },
       hits: {
         ballistic: { specificEnergy: 3e7, aspect: 0.2, minRadius: 0.03 },
         blunt: { specificEnergy: 1e8, aspect: 0.1, thresholdJoules: 400 },
@@ -43134,6 +43372,8 @@ void main(){
       debris: "chips",
       color: [0.33, 0.33, 0.31],
       pattern: "concrete",
+      crack: { reach: 1, width: 6e-3, thresholdJoules: 300 },
+      breach: { joulesPerCubedThickness: 24e8, radiusOverThickness: 1.5 },
       hits: {
         ballistic: { specificEnergy: 15e7, aspect: 0.14, minRadius: 0.018 },
         blunt: { specificEnergy: 3e8, aspect: 0.08, thresholdJoules: 800 },
@@ -43160,6 +43400,7 @@ void main(){
       debris: "shards",
       color: [0.72, 0.7, 0.66],
       pattern: "tile",
+      crack: { reach: 0.5, width: 2e-3, thresholdJoules: 40 },
       hits: {
         ballistic: { specificEnergy: 8e6, aspect: 0.1, minRadius: 0.05 },
         blunt: { specificEnergy: 1e7, aspect: 0.08, thresholdJoules: 80, minRadius: 0.06 },
@@ -43186,6 +43427,7 @@ void main(){
       debris: "chips",
       color: [0.23, 0.22, 0.2],
       pattern: "stone",
+      crack: { reach: 0.5, width: 4e-3, thresholdJoules: 1e3 },
       hits: {
         ballistic: { specificEnergy: 25e7, aspect: 0.12, minRadius: 0.015 },
         blunt: { specificEnergy: 5e8, aspect: 0.08, thresholdJoules: 1500 },
@@ -43208,6 +43450,91 @@ void main(){
   ];
   var DEFAULT_BAR_YIELD_JOULES = 24e5;
   var DEFAULT_PROFILE = "concrete_slab";
+  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 CRACK_REFERENCE_JOULES = 1e6;
+  var MERGE_SHARE = 0.35;
+  var HAIRLINE = 15e-4;
+  var MIN_RAYS = 4;
+  var MAX_RAYS = 11;
+  var SEGMENTS2 = 4;
+  var BRANCH_CHANCE = 0.45;
+  function createCrackStore() {
+    const list = [];
+    let version = 0;
+    let nextId = 1;
+    let born = 0;
+    return {
+      list,
+      get version() {
+        return version;
+      },
+      add(spec, max2) {
+        version++;
+        const near = list.find((crack2) => Math.hypot(crack2.x - spec.x, crack2.z - spec.z) < crack2.reach * MERGE_SHARE);
+        if (near) {
+          near.reach = Math.max(near.reach, spec.reach) + Math.min(near.reach, spec.reach) * 0.25;
+          near.width = Math.max(near.width, spec.width) * 1.1;
+          near.rays = Math.min(MAX_RAYS, near.rays + 1);
+          return near;
+        }
+        if (list.length >= max2) list.shift();
+        const rays = MIN_RAYS + Math.floor(createRandom(spec.seed)() * (MAX_RAYS - MIN_RAYS - 2));
+        const crack = { id: nextId++, x: spec.x, z: spec.z, reach: spec.reach, width: Math.max(HAIRLINE, spec.width), rays, seed: spec.seed, material: spec.material, born: born++ };
+        list.push(crack);
+        return crack;
+      },
+      clear() {
+        list.length = 0;
+        version++;
+      },
+      load(cracks) {
+        list.length = 0;
+        for (const crack of cracks) {
+          list.push({ ...crack });
+          nextId = Math.max(nextId, crack.id + 1);
+          born = Math.max(born, crack.born + 1);
+        }
+        version++;
+      }
+    };
+  }
+  function crackLines(crack) {
+    const random = createRandom(crack.seed);
+    const segments = [];
+    const widthAt = (distance4) => Math.max(HAIRLINE, crack.width * (1 - distance4 / crack.reach));
+    for (let ray = 0; ray < crack.rays; ray++) {
+      let angle = ray / crack.rays * Math.PI * 2 + (random() - 0.5) * 0.6;
+      const length3 = crack.reach * (0.45 + 0.55 * random());
+      let x = crack.x;
+      let z = crack.z;
+      let run = 0;
+      for (let segment = 0; segment < SEGMENTS2; segment++) {
+        const step = length3 / SEGMENTS2 * (0.75 + 0.5 * random());
+        angle += (random() - 0.5) * 0.5;
+        const nx = x + Math.cos(angle) * step;
+        const nz = z + Math.sin(angle) * step;
+        segments.push({ x0: x, z0: z, x1: nx, z1: nz, w0: widthAt(run), w1: widthAt(run + step) });
+        if (segment > 0 && random() < BRANCH_CHANCE) {
+          const side = angle + (random() < 0.5 ? -1 : 1) * (0.45 + random() * 0.5);
+          const branch = step * (0.5 + 0.6 * random());
+          const w = widthAt(run + step) * 0.6;
+          segments.push({ x0: nx, z0: nz, x1: nx + Math.cos(side) * branch, z1: nz + Math.sin(side) * branch, w0: Math.max(HAIRLINE, w), w1: HAIRLINE });
+        }
+        run += step;
+        x = nx;
+        z = nz;
+      }
+    }
+    return segments;
+  }
   var REST_SPEED2 = 0.6;
   var RESTITUTION2 = 0.25;
   var FRICTION = 0.55;
@@ -43385,15 +43712,6 @@ void main(){
       }
     };
   }
-  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,
@@ -43402,7 +43720,8 @@ void main(){
     maxDebris: 400,
     maxDebrisPerBlow: 36,
     maxSlideCellsPerFrame: 2500,
-    maxBurningCells: 300
+    maxBurningCells: 300,
+    maxCracks: 120
   };
   var GRAVITY5 = 9.81;
   var FINE_CELLS = 1.5;
@@ -43479,6 +43798,7 @@ void main(){
     const mixed = new Uint8Array(chunksX * chunksZ);
     const dirty = /* @__PURE__ */ new Set();
     const marks = createMarkStore2(budget);
+    const cracks = createCrackStore();
     const debrisStore = createDebrisStore(() => budget.maxDebris);
     const sliding = /* @__PURE__ */ new Set();
     const burning = /* @__PURE__ */ new Map();
@@ -43655,6 +43975,7 @@ void main(){
       let depth = start.depth;
       let radius = 0;
       let carved = 0;
+      let breached = false;
       const firstMaterial = materials.get(start.material);
       if (start.loose <= 0) {
         for (; ; ) {
@@ -43666,6 +43987,19 @@ void main(){
           const response = material.hits[blow3];
           if (!response || energy < (response.thresholdJoules ?? 0)) break;
           const bars = layer2.stratum.reinforcement;
+          const breach = blow3 === "explosive" ? material.breach : void 0;
+          const breachJoules = breach ? breach.joulesPerCubedThickness * layer2.stratum.thickness ** 3 : Infinity;
+          if (breach && depth <= layer2.top + 1e-6 && energy >= breachJoules) {
+            const takenRadius2 = layer2.stratum.thickness * breach.radiusOverThickness * Math.cbrt(energy / breachJoules);
+            const takenVolume2 = Math.PI * takenRadius2 * takenRadius2 * room / 2;
+            energy -= breachJoules;
+            depth += room;
+            carved += room;
+            breached = true;
+            radius = Math.max(radius, takenRadius2);
+            removed.push({ material: material.id, volume: takenVolume2 });
+            continue;
+          }
           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;
@@ -43693,8 +44027,10 @@ void main(){
           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 };
+      let collapsed = loadBars(blow3, spec.energy, x, z, profile);
+      const crack = crackAround(blow3, spec.energy, x, z, start.loose > 0 ? void 0 : firstMaterial);
+      const extra = { ...crack ? { crack } : {}, ...breached ? { breached } : {} };
+      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, ...extra };
       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;
@@ -43712,8 +44048,16 @@ void main(){
         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;
       }
+      if (breached) collapsed = loadBars(blow3, spec.energy, x, z, profile) || collapsed;
       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 };
+      return { point, radius, depth: carved, totalDepth: after2.depth, removed, exposed: after2.material, atLimit: after2.remaining <= 1e-4, rebarExposed: rebarShowing(profile, after2.depth), collapsed, fine, ...extra };
+    }
+    function crackAround(blow3, energy, x, z, material) {
+      const response = material?.crack;
+      if (!material || !response || energy < response.thresholdJoules) return void 0;
+      if (blow3 === "slash") return void 0;
+      const scale2 = Math.cbrt(energy / CRACK_REFERENCE_JOULES);
+      return cracks.add({ x, z, reach: response.reach * scale2, width: response.width * scale2, material: material.id, seed: Math.floor(random() * 2 ** 31) }, budget.maxCracks);
     }
     function loadBars(blow3, energy, x, z, profile) {
       const bars = profile.strata.find((stratum) => stratum.reinforcement);
@@ -43954,6 +44298,7 @@ void main(){
       barBend.fill(0);
       touched.fill(0);
       marks.clear();
+      cracks.clear();
       debrisStore.clear();
       sliding.clear();
       burning.clear();
@@ -44005,6 +44350,9 @@ void main(){
         updateSlides();
         updateFire(dt);
       },
+      get dirtyChunkCount() {
+        return dirty.size;
+      },
       drainDirtyChunks(max2 = budget.maxDirtyChunksPerFrame) {
         const taken = [];
         for (const index of dirty) {
@@ -44016,6 +44364,10 @@ void main(){
       },
       chunk,
       marks: () => marks.list,
+      cracks: () => cracks.list,
+      get cracksVersion() {
+        return cracks.version;
+      },
       debris: () => debrisStore.list,
       burningPoints: () => [...burning.keys()].map((key2) => {
         const cellRow = Math.floor(key2 / 65536);
@@ -44028,7 +44380,7 @@ void main(){
       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 })) };
+        return { layout: currentLayout, dug: sparse(dug), loose: sparse(loose), scorch: sparse(scorch), barBend: sparse(barBend), marks: marks.list.map((mark) => ({ ...mark })), cracks: cracks.list.map((crack) => ({ ...crack })) };
       },
       load(snapshot) {
         currentLayout = snapshot.layout;
@@ -44038,6 +44390,7 @@ void main(){
         fillSparse(scorch, snapshot.scorch);
         fillSparse(barBend, snapshot.barBend ?? []);
         marks.load(snapshot.marks);
+        cracks.load(snapshot.cracks ?? []);
         for (let chunkIndex = 0; chunkIndex < touched.length; chunkIndex++) markChunk(chunkIndex);
       }
     };
@@ -44382,7 +44735,7 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
     mesh2.renderOrder = 1;
     mesh2.setColorAt(0, new THREE.Color(1, 1, 1));
     const matrix = new THREE.Matrix4();
-    const rotation = new THREE.Matrix4();
+    const rotation2 = new THREE.Matrix4();
     const scale2 = new THREE.Matrix4();
     const colour = new THREE.Color();
     let seen = "";
@@ -44403,9 +44756,9 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
         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);
+          rotation2.makeRotationY(mark.id * 2.399);
           scale2.makeScale(size, 1, size);
-          matrix.multiplyMatrices(rotation, scale2);
+          matrix.multiplyMatrices(rotation2, 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;
@@ -44469,6 +44822,92 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       }
     };
   }
+  var CRACK_LIFT = 4e-3;
+  var MAX_CRACK_QUADS = 8192;
+  var CRACK_SHADE = 0.22;
+  var DARK_SURFACE = 0.1;
+  var DUST_LIFT = 2;
+  var DUST_GREY = 0.12;
+  function createCrackLayer(THREE, terrain) {
+    const positions = new Float32Array(MAX_CRACK_QUADS * 4 * 3);
+    const colours = new Float32Array(MAX_CRACK_QUADS * 4 * 3);
+    const indices = new Uint32Array(MAX_CRACK_QUADS * 6);
+    for (let quad = 0; quad < MAX_CRACK_QUADS; quad++) {
+      const first = quad * 4;
+      indices.set([first, first + 2, first + 1, first + 1, first + 2, first + 3], quad * 6);
+    }
+    const geometry = new THREE.BufferGeometry();
+    const position = new THREE.BufferAttribute(positions, 3);
+    const colour = new THREE.BufferAttribute(colours, 3);
+    position.setUsage(THREE.DynamicDrawUsage);
+    colour.setUsage(THREE.DynamicDrawUsage);
+    geometry.setAttribute("position", position);
+    geometry.setAttribute("color", colour);
+    geometry.setIndex(new THREE.BufferAttribute(indices, 1));
+    geometry.setDrawRange(0, 0);
+    const material = new THREE.MeshBasicMaterial({ vertexColors: true, transparent: true, opacity: 0.9, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -3, polygonOffsetUnits: -3 });
+    const mesh2 = new THREE.Mesh(geometry, material);
+    mesh2.name = "terrain-cracks";
+    mesh2.frustumCulled = false;
+    mesh2.renderOrder = 2;
+    let seen = -1;
+    let groundMoved = false;
+    const stopListening = terrain.onDeform(() => {
+      groundMoved = true;
+    });
+    const lift = (x, z) => terrain.heightAt(x, z) + CRACK_LIFT;
+    return {
+      mesh: mesh2,
+      sync() {
+        const cracks = terrain.cracks();
+        if (seen === terrain.cracksVersion && !(groundMoved && cracks.length > 0)) return;
+        seen = terrain.cracksVersion;
+        groundMoved = false;
+        let quad = 0;
+        for (let n = cracks.length - 1; n >= 0 && quad < MAX_CRACK_QUADS; n--) {
+          const crack = cracks[n];
+          const tone = terrain.material(crack.material).color;
+          const dark = tone[0] * 0.3 + tone[1] * 0.59 + tone[2] * 0.11 < DARK_SURFACE;
+          const k = dark ? DUST_LIFT : CRACK_SHADE;
+          const r = dark ? Math.min(1, tone[0] * k + DUST_GREY) : tone[0] * k;
+          const g = dark ? Math.min(1, tone[1] * k + DUST_GREY) : tone[1] * k;
+          const b = dark ? Math.min(1, tone[2] * k + DUST_GREY) : tone[2] * k;
+          for (const s of crackLines(crack)) {
+            if (quad >= MAX_CRACK_QUADS) break;
+            if (!terrain.contains(s.x0, s.z0) || !terrain.contains(s.x1, s.z1)) continue;
+            const length3 = Math.hypot(s.x1 - s.x0, s.z1 - s.z0);
+            if (length3 < 1e-5) continue;
+            const ax = -(s.z1 - s.z0) / length3;
+            const az = (s.x1 - s.x0) / length3;
+            const corners = [
+              [s.x0 + ax * s.w0 * 0.5, s.z0 + az * s.w0 * 0.5],
+              [s.x0 - ax * s.w0 * 0.5, s.z0 - az * s.w0 * 0.5],
+              [s.x1 + ax * s.w1 * 0.5, s.z1 + az * s.w1 * 0.5],
+              [s.x1 - ax * s.w1 * 0.5, s.z1 - az * s.w1 * 0.5]
+            ];
+            corners.forEach(([x, z], corner) => {
+              const at3 = (quad * 4 + corner) * 3;
+              positions[at3] = x;
+              positions[at3 + 1] = lift(x, z);
+              positions[at3 + 2] = z;
+              colours[at3] = r;
+              colours[at3 + 1] = g;
+              colours[at3 + 2] = b;
+            });
+            quad++;
+          }
+        }
+        position.needsUpdate = true;
+        colour.needsUpdate = true;
+        geometry.setDrawRange(0, quad * 6);
+      },
+      dispose() {
+        stopListening();
+        geometry.dispose();
+        material.dispose();
+      }
+    };
+  }
   var BAR_RADIUS = 6e-3;
   var EXPOSED_MARGIN = 2e-3;
   var MAX_SAG = 0.07;
@@ -44583,7 +45022,8 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
     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);
+    const cracks = createCrackLayer(THREE, terrain);
+    group.add(marks.mesh, cracks.mesh, debris2.mesh);
     let pristineStale = true;
     let pristineBuilt = false;
     let pristineCount = 0;
@@ -44669,7 +45109,8 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
     return {
       group,
       sync(camera2) {
-        const limit = firstSync ? Infinity : void 0;
+        const laidAnew = terrain.dirtyChunkCount >= terrain.chunksX * terrain.chunksZ;
+        const limit = firstSync || laidAnew ? Infinity : void 0;
         firstSync = false;
         for (const chunk of terrain.drainDirtyChunks(limit)) {
           if (chunk.pristine) {
@@ -44690,9 +45131,10 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
           }
         }
         marks.sync(camera2);
+        cracks.sync();
         debris2.sync();
       },
-      stats: () => ({ chunkMeshes: drawn.size, pristineChunks: pristineCount, marksDrawn: marks.mesh.count, debrisDrawn: debris2.mesh.count }),
+      stats: () => ({ chunkMeshes: drawn.size, pristineChunks: pristineCount, marksDrawn: marks.mesh.count, debrisDrawn: debris2.mesh.count, crackQuads: cracks.mesh.geometry.drawRange.count / 6 }),
       dispose() {
         for (const index of [...drawn.keys()]) drop(index);
         for (const geometry of spareGeometries) geometry.dispose();
@@ -44700,11 +45142,19 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
         surface.dispose();
         rebarMaterial.dispose();
         marks.dispose();
+        cracks.dispose();
         debris2.dispose();
         group.removeFromParent();
       }
     };
   }
+  var PROFILE_NAMES = {
+    en: { lawn: "Lawn", dirt: "Dirt", sand: "Sand", road: "Asphalt road", concrete_slab: "Concrete slab", suspended_slab: "Slab over a void", tile_floor: "Tile floor", wood_floor: "Wood floor", stone_paving: "Stone paving" },
+    "pt-BR": { lawn: "Grama", dirt: "Terra", sand: "Areia", road: "Asfalto", concrete_slab: "Laje de concreto", suspended_slab: "Laje sobre v\xE3o", tile_floor: "Piso cer\xE2mico", wood_floor: "Assoalho", stone_paving: "Cal\xE7amento de pedra" }
+  };
+  function terrainProfileName(profileId, localeId) {
+    return (PROFILE_NAMES[localeId] ?? PROFILE_NAMES.en)[profileId] ?? profileId;
+  }
   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;
@@ -45087,6 +45537,8 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       "ins.damage": "Marks",
       "ins.damage_counts": "{dents}, {holes}, {cracks}",
       "ins.mass": "Mass",
+      "ins.dug": "Dug",
+      "ins.dig_limit": "Ground left to dig",
       "ins.load": "Load",
       "ins.stress": "Stress",
       "ins.joints": "Joints",
@@ -45435,6 +45887,8 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       "ins.damage": "Marcas",
       "ins.damage_counts": "{dents}, {holes}, {cracks}",
       "ins.mass": "Massa",
+      "ins.dug": "Escavado",
+      "ins.dig_limit": "Ch\xE3o at\xE9 o limite",
       "ins.load": "Carga",
       "ins.stress": "Tens\xE3o",
       "ins.joints": "Juntas",
@@ -46322,6 +46776,15 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
         insp.appendChild(mk3("div", void 0, t("ui.aim_at_something")));
         return;
       }
+      if (i.ground) {
+        const g = i.ground;
+        insp.appendChild(mk3("div", "t", `${i.object} \u203A ${g.surface}`));
+        insp.appendChild(row(t("ins.material"), g.material));
+        insp.appendChild(row(t("ins.dug"), `${num(g.dug * 100, 0)} cm`));
+        insp.appendChild(row(t("ins.dig_limit"), `${num(g.remaining, 2)} m`));
+        if (g.scorch > 0.01) insp.appendChild(row(t("ins.char"), `${num(g.scorch * 100, 0)} %`));
+        return;
+      }
       if (i.thumbnail) insp.appendChild(thumb(i.thumbnail, i.thumbnailCredit));
       insp.appendChild(mk3("div", "t", `${i.object} \u203A ${i.part}`));
       insp.appendChild(row(t("ins.material"), i.material));
@@ -48680,9 +49143,36 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       if (!leaf2) return void 0;
       return t(leaf2.locked ? "hud.door_hint_locked" : leaf2.open ? "hud.door_hint_close" : "hud.door_hint_open");
     };
+    const groundInspect = (r) => {
+      const onFloor = terrain.raycast(aimO, aimD, r.distance + 3);
+      const [x, , z] = onFloor?.point ?? r.point;
+      const column = terrain.columnAt(x, z);
+      const materialName = S.text[`material.${column.material}`] ?? dStrings.materialNames[column.material] ?? column.material;
+      return {
+        object: t("ground.name"),
+        objectId: GROUND_ID2,
+        part: column.profile,
+        material: materialName,
+        status: "",
+        hp: 0,
+        maxHp: 0,
+        temperature: 0,
+        burning: false,
+        char: column.scorch,
+        melt: 0,
+        dents: 0,
+        holes: 0,
+        cracks: 0,
+        mass: 0,
+        joints: [],
+        distance: onFloor?.distance ?? r.distance,
+        ground: { surface: terrainProfileName(column.profile, locale), material: materialName, dug: column.depth, remaining: column.remaining, scorch: column.scorch }
+      };
+    };
     const inspectInfo = () => {
       const r = inspectTarget();
       if (!r) return null;
+      if (r.object === GROUND_ID2) return groundInspect(r);
       const st = world.state(r.object);
       const p = world.part(r.object, r.part);
       if (!st || !p) return null;