@adatechnology/game-destruction-three 0.7.3 → 0.8.1

package/dist/index.js

@@ -3,6 +3,7 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/renderer.ts
+import { blastShove } from "@adatechnology/game-contracts";
 import { createVfx, effectForEvent, EVENT_EFFECTS_MAP } from "@adatechnology/game-vfx";
 import { createVfxRenderer } from "@adatechnology/game-vfx-three";
 
@@ -135,6 +136,7 @@ var FragmentSystem = class {
     const sc = new this.THREE.Vector3(Math.max(5e-3, sz[0]), Math.max(5e-3, sz[1]), Math.max(3e-3, sz[2]));
     mesh.scale.copy(sc);
     mesh.castShadow = true;
+    mesh.userData.destructionDebris = true;
     this.o.scene.add(mesh);
     const live = {
       mesh,
@@ -342,6 +344,7 @@ var GroundSpots = class {
     mesh.position.set(x, y, z);
     mesh.scale.setScalar(1e-3);
     mesh.renderOrder = 1;
+    mesh.userData.destructionDebris = true;
     this.scene.add(mesh);
     this.spots.push({ mesh, kind, home, x, z, radius: 1e-3, target: Math.min(MAX_RADIUS, radius) });
   }
@@ -770,7 +773,12 @@ var RebarCages = class {
 };
 
 // src/spec.ts
-import { guessMaterial, inferJoints } from "@adatechnology/game-destruction";
+import { guessMaterial, inferJoints, MATERIALS, partMass } from "@adatechnology/game-destruction";
+function containsOf(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const v = value;
+  return typeof v.fluid === "string" && typeof v.liters === "number" && v.liters > 0 ? { fluid: v.fluid, liters: v.liters } : void 0;
+}
 function partHintOf(value) {
   if (typeof value === "string") return value ? { id: value } : null;
   if (!value || typeof value !== "object") return null;
@@ -791,11 +799,17 @@ function isMesh(o) {
 function sizeOf(box) {
   return [box.max.x - box.min.x, box.max.y - box.min.y, box.max.z - box.min.z];
 }
+function specFrameInverse(THREE, root) {
+  root.updateMatrixWorld(true);
+  const position = new THREE.Vector3();
+  const quaternion = new THREE.Quaternion();
+  root.matrixWorld.decompose(position, quaternion, new THREE.Vector3());
+  return new THREE.Matrix4().compose(position, quaternion, new THREE.Vector3(1, 1, 1)).invert();
+}
 function specFromObject3D(THREE, root, options = {}) {
   const fallback = options.fallback ?? "plastic";
   const minSize = options.minSize ?? 0.015;
-  root.updateMatrixWorld(true);
-  const inv = root.matrixWorld.clone().invert();
+  const inv = specFrameInverse(THREE, root);
   const entries = [];
   const byKey = /* @__PURE__ */ new Map();
   const visit = (o) => {
@@ -812,8 +826,10 @@ function specFromObject3D(THREE, root, options = {}) {
         const material = options.materialOf?.(o) ?? (typeof ud.destructionMaterial === "string" ? ud.destructionMaterial : void 0) ?? hint?.material ?? guessMaterial(`${o.name} ${matName} ${typeof ud.material === "string" ? ud.material : ""}`) ?? fallback;
         const explicit = hint?.id ?? null;
         const hollow = ud.hollow === true || /hollow/i.test(o.name);
+        const skin = ud.destructionSkin === true;
         const fill = options.fillOf?.(o, material);
         const tags = Array.isArray(ud.destructionTags) ? ud.destructionTags : void 0;
+        const contains = containsOf(ud.destructionContains);
         const existing = explicit ? byKey.get(explicit) : void 0;
         if (existing) {
           const before = sizeOf(existing.box);
@@ -823,9 +839,11 @@ function specFromObject3D(THREE, root, options = {}) {
           existing.meshes.push(o);
           if (ns[0] * ns[1] * ns[2] > bv) existing.material = material;
           existing.hollow = existing.hollow || hollow;
+          existing.skin = existing.skin && skin;
           if (fill !== void 0) existing.fill = fill;
+          if (contains) existing.contains = contains;
         } else {
-          const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box, material, explicitId: explicit, fill, hollow, tags, fixedId: !!explicit, name: o.name, parent: hint?.parent, jointKind: hint?.kind };
+          const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box, material, explicitId: explicit, fill, hollow, skin, tags, fixedId: !!explicit, ...contains ? { contains } : {}, name: o.name, parent: hint?.parent, jointKind: hint?.kind };
           entries.push(e);
           if (explicit) byKey.set(explicit, e);
         }
@@ -844,7 +862,7 @@ function specFromObject3D(THREE, root, options = {}) {
   const largest = (e) => Math.max(...sizeOf(e.box));
   const kept = [];
   const tiny = [];
-  for (const e of entries) (!e.fixedId && largest(e) < minSize ? tiny : kept).push(e);
+  for (const e of entries) (e.skin || !e.fixedId && largest(e) < minSize ? tiny : kept).push(e);
   for (const t of tiny) {
     let best = null;
     let bestV = 0;
@@ -898,11 +916,21 @@ function specFromObject3D(THREE, root, options = {}) {
       part.thickness = Math.max(minSide, 5e-4);
     }
     if (e.tags) part.tags = [...e.tags];
+    if (e.contains) part.contains = { ...e.contains };
     const ao = options.anchorBelow ?? -1;
     if (ao >= 0 && e.box.min.y <= ao) part.anchored = true;
     parts.push(part);
     meshesOf[id] = e.meshes;
   }
+  const knownMass = root.userData?.destructionMass;
+  if (typeof knownMass === "number" && knownMass > 0) {
+    const shares = parts.map((p) => {
+      const material = MATERIALS.find((m) => m.id === p.material);
+      return material ? partMass(p, material) : 0;
+    });
+    const total = shares.reduce((a, b) => a + b, 0);
+    if (total > 0) parts.forEach((p, i) => p.mass = knownMass * shares[i] / total);
+  }
   const spec = { parts };
   if (options.name !== void 0) spec.name = options.name;
   else if (root.name) spec.name = root.name;
@@ -954,6 +982,46 @@ function heatColor(temperatureC) {
   return last[1];
 }
 
+// src/skin-dent.ts
+function shellDisplacementAt(THREE, worldPoint, shells, out) {
+  const triangle = new THREE.Triangle();
+  const corners = [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()];
+  const local = new THREE.Vector3();
+  const closest = new THREE.Vector3();
+  const weights = new THREE.Vector3();
+  const moved = new THREE.Vector3();
+  let nearest = Infinity;
+  out.set(0, 0, 0);
+  let nearestScale = 1;
+  for (const shell of shells) {
+    shell.mesh.updateWorldMatrix(true, false);
+    shell.mesh.worldToLocal(local.copy(worldPoint));
+    const index = shell.mesh.geometry.index;
+    const triangles = index ? index.count / 3 : shell.before.length / 9;
+    for (let t = 0; t < triangles; t++) {
+      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]);
+      triangle.closestPointToPoint(local, closest);
+      const distance = closest.distanceToSquared(local);
+      if (distance >= nearest) continue;
+      nearest = distance;
+      nearestScale = shell.mesh.matrixWorld.getMaxScaleOnAxis() || 1;
+      triangle.getBarycoord(closest, weights);
+      moved.set(0, 0, 0);
+      ids.forEach((id, corner) => {
+        const weight = corner === 0 ? weights.x : corner === 1 ? weights.y : weights.z;
+        moved.x += weight * (shell.after[id * 3] - shell.before[id * 3]);
+        moved.y += weight * (shell.after[id * 3 + 1] - shell.before[id * 3 + 1]);
+        moved.z += weight * (shell.after[id * 3 + 2] - shell.before[id * 3 + 2]);
+      });
+      out.copy(moved).transformDirection(shell.mesh.matrixWorld);
+      out.multiplyScalar(moved.length() * (shell.mesh.matrixWorld.getMaxScaleOnAxis() || 1));
+    }
+  }
+  return Math.sqrt(nearest) * nearestScale;
+}
+
 // src/visual.ts
 var POS_ATTR = "position";
 function positionAttr(geo) {
@@ -986,7 +1054,8 @@ var DecalKit = class {
       depthWrite: false,
       polygonOffset: true,
       polygonOffsetFactor: -4,
-      polygonOffsetUnits: -4
+      polygonOffsetUnits: -4,
+      side: this.THREE.DoubleSide
     }));
   }
   /** Opaque patch in the colour of what shows under a spalled coat. */
@@ -1018,6 +1087,12 @@ var DecalKit = class {
   }
 };
 var tmpV = (THREE) => new THREE.Vector3();
+var MIN_DENT_VERTICES = 10;
+var WIDEN_MARGIN = 1.1;
+var SKIN_FOLLOW = 0.85;
+var SKIN_SLACK = 5e-4;
+var SKIN_LAYER_SLACK = 4;
+var NEAREST_MARGIN = 1.5;
 var Visuals = class {
   constructor(THREE, lowQuality, decalCap) {
     __publicField(this, "THREE", THREE);
@@ -1186,14 +1261,14 @@ var Visuals = class {
    * Push the vertices of the mesh within `dent.radius` of `worldPoint` inwards along `worldNormal` by `depth * (1 - (d/r)^2)^2`.
    * Returns false when nothing was changed (too far, low quality on a heavy mesh, or no editable positions).
    */
-  applyDent(mv, worldPoint, worldNormal, dent) {
+  applyDent(mv, worldPoint, worldNormal, dent, reachWorld = 0) {
     const mesh = mv.mesh;
     if (this.lowQuality && this.vertexCount(mv) > 2e4) return false;
     mesh.updateWorldMatrix(true, false);
     const s = mesh.matrixWorld.getMaxScaleOnAxis() || 1;
     const lp = mesh.worldToLocal(this.a.copy(worldPoint));
     const ln = this.b.copy(worldNormal).transformDirection(this.m4.copy(mesh.matrixWorld).invert()).normalize();
-    const r = dent.radius / s;
+    const r = Math.max(dent.radius, reachWorld) / s;
     const depth = dent.depth / s;
     const geo = mesh.geometry;
     let bb;
@@ -1206,34 +1281,110 @@ var Visuals = class {
     if (!this.ownGeometry(mv)) return false;
     const work = mv.host ? mv.host.work : mv.work;
     const pos = positionAttr(mesh.geometry);
-    const r2 = r * r;
-    let touched = false;
-    const px = lp.x;
-    const py = lp.y;
-    const pz = lp.z;
-    const nx = ln.x;
-    const ny = ln.y;
-    const nz = ln.z;
     const from = mv.range ? mv.range[0] * 3 : 0;
     const to = mv.range ? mv.range[1] * 3 : work.length;
+    const reach = r;
+    const reach2 = reach * reach;
     for (let i = from; i < to; i += 3) {
-      const dx = work[i] - px;
-      const dy = work[i + 1] - py;
-      const dz = work[i + 2] - pz;
+      const dx = work[i] - lp.x;
+      const dy = work[i + 1] - lp.y;
+      const dz = work[i + 2] - lp.z;
       const d2 = dx * dx + dy * dy + dz * dz;
-      if (d2 >= r2) continue;
-      const f = 1 - d2 / r2;
+      if (d2 >= reach2) continue;
+      const f = 1 - d2 / reach2;
       const k = depth * f * f;
-      work[i] -= nx * k;
-      work[i + 1] -= ny * k;
-      work[i + 2] -= nz * k;
-      touched = true;
+      work[i] -= ln.x * k;
+      work[i + 1] -= ln.y * k;
+      work[i + 2] -= ln.z * k;
     }
-    if (!touched) return false;
     mv.touched = true;
     this.writePositions(mv, pos);
     return true;
   }
+  /**
+   * World radius a dent needs on this mesh to reach `MIN_DENT_VERTICES` vertices (the dent's own radius when the mesh is fine enough). A part with several meshes
+   * (a shell and its label) must dent them all with the largest of these, so the skin and the shell follow the same smooth surface and never cross.
+   */
+  dentReach(mv, worldPoint, dent) {
+    const mesh = mv.mesh;
+    mesh.updateWorldMatrix(true, false);
+    const s = mesh.matrixWorld.getMaxScaleOnAxis() || 1;
+    const lp = mesh.worldToLocal(this.a.copy(worldPoint));
+    const source = (mv.host ? mv.host.work : mv.work) ?? positionAttr(mesh.geometry)?.array;
+    if (!source) return dent.radius;
+    let bounds;
+    if (mv.host) bounds = this.localBox(mv, this.lbox);
+    else {
+      if (!mesh.geometry.boundingBox) mesh.geometry.computeBoundingBox();
+      bounds = mesh.geometry.boundingBox;
+    }
+    if (bounds && !bounds.isEmpty() && bounds.distanceToPoint(lp) > dent.radius / s) return dent.radius;
+    const from = mv.range ? mv.range[0] * 3 : 0;
+    const to = mv.range ? mv.range[1] * 3 : source.length;
+    const r2 = (dent.radius / s) ** 2;
+    const distances = [];
+    let inside = 0;
+    for (let i = from; i < to; i += 3) {
+      const dx = source[i] - lp.x;
+      const dy = source[i + 1] - lp.y;
+      const dz = source[i + 2] - lp.z;
+      const d2 = dx * dx + dy * dy + dz * dz;
+      if (d2 < r2) inside++;
+      distances.push(d2);
+    }
+    if (inside >= MIN_DENT_VERTICES || distances.length < MIN_DENT_VERTICES) return dent.radius;
+    distances.sort((x, y) => x - y);
+    const nearest = Math.sqrt(distances[0]);
+    return Math.max(dent.radius, Math.sqrt(distances[MIN_DENT_VERTICES - 1]) * s * WIDEN_MARGIN, nearest * s * NEAREST_MARGIN);
+  }
+  /**
+   * Dent all the meshes of a part. The shells take the dent as `applyDent` gives it; a skin (label, coat: `userData.destructionSkin`) sits a hair above its shell
+   * and moves with the shell's surface instead (see `shellDisplacementAt`), so the shell never shows through it whatever the two meshes' vertex grids are.
+   */
+  applyPartDent(meshes, worldPoint, worldNormal, dent, reachWorld) {
+    const isSkin = (mv) => mv.mesh.userData.destructionSkin === true && !mv.host;
+    const shells = meshes.filter((mv) => !isSkin(mv));
+    const snapshots = [];
+    for (const mv of shells) {
+      const heavy = this.lowQuality && this.vertexCount(mv) > 2e4;
+      const plain = !mv.host && !heavy && this.ownGeometry(mv) && mv.work;
+      const before = plain ? new Float32Array(mv.work) : null;
+      this.applyDent(mv, worldPoint, worldNormal, dent, reachWorld);
+      if (before) snapshots.push({ mesh: mv.mesh, before, after: mv.work });
+    }
+    const displacement = this.t;
+    const vertex = this.a;
+    for (const mv of meshes) {
+      if (!isSkin(mv)) continue;
+      if (snapshots.length === 0) {
+        this.applyDent(mv, worldPoint, worldNormal, dent, reachWorld);
+        continue;
+      }
+      if (!this.ownGeometry(mv)) continue;
+      const work = mv.work;
+      const mesh = mv.mesh;
+      mesh.updateWorldMatrix(true, false);
+      const toLocal = this.m4.copy(mesh.matrixWorld).invert();
+      const scale = mesh.matrixWorld.getMaxScaleOnAxis() || 1;
+      let touched = false;
+      for (let i = 0; i < work.length; i += 3) {
+        vertex.set(work[i], work[i + 1], work[i + 2]).applyMatrix4(mesh.matrixWorld);
+        if (vertex.distanceTo(worldPoint) > reachWorld) continue;
+        const height = shellDisplacementAt(this.THREE, vertex, snapshots, displacement);
+        const length = displacement.length();
+        if (length === 0) continue;
+        const falloff = 1 - (vertex.distanceTo(worldPoint) / reachWorld) ** 2;
+        const smooth = dent.depth * falloff * falloff;
+        const pull = Math.max(0, Math.min(length, smooth) * SKIN_FOLLOW - SKIN_SLACK - height * SKIN_LAYER_SLACK);
+        displacement.transformDirection(toLocal).multiplyScalar(pull / scale);
+        work[i] += displacement.x;
+        work[i + 1] += displacement.y;
+        work[i + 2] += displacement.z;
+        touched = true;
+      }
+      if (touched) this.writePositions(mv, positionAttr(mesh.geometry));
+    }
+  }
   /** Copy `work` (dents) into the geometry, adding the melt sag when the mesh is melting. */
   writePositions(mv, pos) {
     if (mv.host) {
@@ -1280,6 +1431,7 @@ var Visuals = class {
     return { s, pos, quat };
   }
   addDecal(mv, decal) {
+    decal.obj.userData.destructionDebris = true;
     mv.mesh.add(decal.obj);
     mv.decals.push(decal);
     this.decalCount++;
@@ -1296,6 +1448,27 @@ var Visuals = class {
   }
   addHole(mv, worldPoint, worldNormal, diameter) {
     const { s, pos, quat } = this.decalPose(mv.mesh, worldPoint, worldNormal, 25e-4);
+    const work = mv.host ? mv.host.work : mv.work;
+    if (work && mv.touched) {
+      const ln = worldNormal.clone().transformDirection(this.m4.copy(mv.mesh.matrixWorld).invert()).normalize();
+      let minDistSq = Infinity;
+      let nearestDisp = 0;
+      const from = mv.range ? mv.range[0] * 3 : 0;
+      const to = mv.range ? mv.range[1] * 3 : work.length;
+      for (let i = from; i < to; i += 3) {
+        const dx = work[i] - pos.x;
+        const dy = work[i + 1] - pos.y;
+        const dz = work[i + 2] - pos.z;
+        const d2 = dx * dx + dy * dy + dz * dz;
+        if (d2 < minDistSq) {
+          minDistSq = d2;
+          nearestDisp = dx * ln.x + dy * ln.y + dz * ln.z;
+        }
+      }
+      if (minDistSq < (0.06 / s) ** 2 && nearestDisp < 0) {
+        pos.addScaledVector(ln, nearestDisp);
+      }
+    }
     const disc = new this.THREE.Mesh(this.kit.discGeometry(), this.kit.discMaterial());
     disc.position.copy(pos);
     disc.quaternion.copy(quat);
@@ -1767,7 +1940,13 @@ var FLUID_COLORS = {
   gas: 15921906,
   sap: 12098362,
   acid: 10211900,
-  blood: 9046538
+  blood: 9046538,
+  soda: 3808786,
+  coffee: 3875860,
+  beer: 14259516,
+  milk: 16052714,
+  wine: 7016479,
+  juice: 15238923
 };
 var SMOKE_TONES = { white: 15132390, grey: 9079434, black: 2763306 };
 var DEFAULT_SPEED = {
@@ -1864,6 +2043,8 @@ var Renderer = class {
     __publicField(this, "tmpQ");
     __publicField(this, "v1");
     __publicField(this, "v2");
+    // The last warm-up keeps its materials until the next one: a material that does not use lights keeps the program of the lights it was first drawn with, so each warm-up needs materials of its own.
+    __publicField(this, "warmProbes");
     this.world = o.world;
     this.scene = o.scene;
     this.quality = o.quality ?? "medium";
@@ -1961,6 +2142,24 @@ var Renderer = class {
       if (!bound.parts.has(pid)) bound.parts.set(pid, this.makePartVis(objectId, pid, this.world.part(objectId, pid)?.material ?? "", meshes, hosts));
     }
     this.bounds.set(objectId, bound);
+    for (const pv of bound.parts.values()) this.tagPart(pv, objectId);
+  }
+  /**
+   * Label the meshes of a part so a host can go from a raycast hit to the world: `userData.destructionPart` (the part id) and
+   * `userData.destructionObject` (the id of the world object that part belongs to now; a loose piece has an id of its own). Parts drawn by a range
+   * of a merged mesh share that mesh with others and are left alone until they get a mesh of their own. Decals are marked `destructionDebris`.
+   */
+  tagPart(pv, objectId) {
+    for (const mv of pv.meshes) {
+      if (mv.merged && !mv.loose) continue;
+      mv.mesh.traverse((c) => {
+        if (!c.isMesh) return;
+        const ud = c.userData;
+        if (ud.destructionDebris) return;
+        if (partHintOf(ud.destructionPart)?.id !== pv.id) ud.destructionPart = pv.id;
+        ud.destructionObject = objectId;
+      });
+    }
   }
   makePartVis(home, id, material, meshes, hosts) {
     return { id, home, material, meshes: meshes.map((m) => this.visuals.makeMeshVis(m.mesh, home, m.range, hosts)), charApplied: 0, glowApplied: 0, meltApplied: 0, gone: "none" };
@@ -1974,13 +2173,13 @@ var Renderer = class {
       specParts = void 0;
     }
     if (!specParts) return;
-    root.updateMatrixWorld(true);
+    const frame = specFrameInverse(this.THREE, root);
     const e = new this.THREE.Euler();
     const q = new this.THREE.Quaternion();
     for (const m of meshes) {
       this.box.setFromObject(m);
       if (this.box.isEmpty()) continue;
-      const c = root.worldToLocal(this.box.getCenter(this.v1));
+      const c = this.box.getCenter(this.v1).applyMatrix4(frame);
       let best = null;
       let bestVol = Infinity;
       for (const p of specParts) {
@@ -2017,10 +2216,9 @@ var Renderer = class {
   // ----------------------------------------------------------------------------------------------------------------------------------
   // Pieces
   // ----------------------------------------------------------------------------------------------------------------------------------
-  /** Half extents and centre of the box around some meshes, in the local space of `root`. */
+  /** Half extents and centre of the box around some meshes, in the metric frame of `root` (its pose removed, its scale kept). */
   measure(root, meshes) {
-    root.updateMatrixWorld(true);
-    const inv = root.matrixWorld.clone().invert();
+    const inv = specFrameInverse(this.THREE, root);
     const total = new this.THREE.Box3();
     const m4 = new this.THREE.Matrix4();
     const lb = new this.THREE.Box3();
@@ -2095,6 +2293,7 @@ var Renderer = class {
     dt = clamp(dt, 0, 0.1);
     this.time += dt;
     this.drainQueue();
+    for (const b of this.bounds.values()) if (b.soilNode && this.world.state(b.id)?.soil?.status === "yielding") this.onSettle(b.id);
     this.updateActive(dt);
     this.updateLeaks(dt);
     this.pieceSys.update(dt);
@@ -2113,6 +2312,27 @@ var Renderer = class {
       }
     }
   }
+  /**
+   * The ground under an object settled or tilted: its parts are drawn under a node with the soil's offset (`ObjectState.soil.offset`), so the host's
+   * root keeps the pose the host gave and the world keeps getting it from `syncTransform`.
+   */
+  onSettle(objectId) {
+    const b = this.bounds.get(objectId);
+    const soil = this.world.state(objectId)?.soil;
+    if (!b || !soil) return;
+    let node = b.soilNode;
+    if (!node) {
+      node = new this.THREE.Group();
+      node.name = "destruction-soil";
+      for (const c of [...b.root.children]) node.add(c);
+      b.root.add(node);
+      b.soilNode = node;
+    }
+    const { position: p, rotation: q } = soil.offset;
+    node.position.set(p[0], p[1], p[2]);
+    node.quaternion.set(q[0], q[1], q[2], q[3]);
+    node.updateMatrixWorld(true);
+  }
   syncTransforms() {
     for (const b of this.bounds.values()) this.syncOne(b);
   }
@@ -2167,6 +2387,9 @@ var Renderer = class {
       case "detach":
         this.onDetach(ev);
         break;
+      case "settle":
+        this.onSettle(ev.object);
+        break;
       case "collapse":
         this.splitLoose(ev.object);
         this.playEvent({ kind: "collapse" }, this.rootPoint(ev.object));
@@ -2252,13 +2475,39 @@ var Renderer = class {
       }
       case "leak": {
         const key = `${ev.object}|${ev.part}`;
+        const b = this.bounds.get(ev.object);
+        let localPoint;
+        let localDirection;
+        if (b) {
+          b.root.updateWorldMatrix(true, false);
+          const inv = new this.THREE.Matrix4().copy(b.root.matrixWorld).invert();
+          const lp = this.v1.set(ev.point[0], ev.point[1], ev.point[2]).applyMatrix4(inv);
+          const ld = this.v2.set(ev.direction[0], ev.direction[1], ev.direction[2]).transformDirection(inv).normalize();
+          localPoint = [lp.x, lp.y, lp.z];
+          localDirection = [ld.x, ld.y, ld.z];
+        }
         const same = this.leaks.find((l) => l.object === ev.object && l.part === ev.part && Math.hypot(l.point[0] - ev.point[0], l.point[1] - ev.point[1], l.point[2] - ev.point[2]) < 0.03);
         if (same) {
           same.rate = ev.rate;
           same.direction = ev.direction;
+          if (localPoint) same.localPoint = localPoint;
+          if (localDirection) same.localDirection = localDirection;
         } else {
           if (this.leaks.length >= 24) this.leaks.shift();
-          this.leaks.push({ object: ev.object, part: ev.part, fluid: ev.fluid, point: ev.point, direction: ev.direction, rate: ev.rate, pressurized: ev.pressurized, acc: 0 });
+          this.leaks.push({
+            object: ev.object,
+            part: ev.part,
+            fluid: ev.fluid,
+            point: ev.point,
+            direction: ev.direction,
+            rate: ev.rate,
+            pressurized: ev.pressurized,
+            acc: 0,
+            opened: this.world.part(ev.object, ev.part)?.holes.some((h) => h.through) ?? false,
+            localPoint,
+            localDirection,
+            life: 0
+          });
         }
         void key;
         break;
@@ -2335,10 +2584,9 @@ var Renderer = class {
     const def = this.world.materials.get(pv.material);
     const wp = new this.THREE.Vector3(ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]);
     const wn = this.worldDir(b, ev.dent.normal);
-    for (const mv of pv.meshes) {
-      if (!this.visuals.shown(mv)) continue;
-      this.visuals.applyDent(mv, wp, wn, ev.dent);
-    }
+    const shown = pv.meshes.filter((mv) => this.visuals.shown(mv));
+    const reach = shown.reduce((widest, mv) => Math.max(widest, this.visuals.dentReach(mv, wp, ev.dent)), ev.dent.radius);
+    this.visuals.applyPartDent(shown, wp, wn, ev.dent, reach);
     if (def?.tags?.includes("metal")) this.vfx.burst("sparks", ev.worldPoint, [wn.x, wn.y, wn.z], 4 + Math.min(8, ev.dent.depth * 150), 3.2);
     this.sound(impactKey(def), ev.worldPoint, clamp(0.3 + ev.dent.depth * 12, 0.3, 1));
   }
@@ -2534,6 +2782,7 @@ var Renderer = class {
       }
     }
     this.bounds.set(newId, nb);
+    for (const pv of nb.parts.values()) this.tagPart(pv, newId);
     const meshes = this.meshesOf(nb);
     if (meshes.length === 0) return;
     const { half, center } = this.measure(group, meshes);
@@ -2561,24 +2810,40 @@ var Renderer = class {
     const report = options.report;
     const confinement = report?.find((r) => r.blast !== void 0)?.blast?.confinement ?? 1;
     const energy = ev.energy * confinement;
-    for (const pc of this.pieceSys.list) {
+    const reachOf = (objectId) => report?.find((r) => r.object === objectId)?.blast?.shelter ?? 1;
+    const shove = (pc) => {
       this.pieceSys.centerOf(pc, c);
-      const dx = c.x - p[0];
-      const dy = c.y - p[1];
-      const dz = c.z - p[2];
-      const d = Math.hypot(dx, dy, dz);
-      if (d > ev.radius) continue;
-      const fall = (1 - d / ev.radius) ** 2;
-      const reach = report?.find((r) => r.object === pc.objectId)?.blast?.shelter ?? 1;
-      const speed = Math.min(30, Math.sqrt(2 * energy * reach * 0.02 / pc.mass)) * fall;
-      const inv = d > 1e-4 ? 1 / d : 0;
-      const dir = d > 1e-4 ? [dx * inv, dy * inv + 0.3, dz * inv] : [0, 1, 0];
+      const hit = blastShove({ point: p, energy, radius: ev.radius, reach: reachOf(pc.objectId) }, { position: [c.x, c.y, c.z], mass: pc.mass }, this.o.blastShove);
+      if (!hit) return;
       const spread = pc.halfExtents[0];
-      this.pieceSys.impulse(pc, [dir[0] * speed * pc.mass, dir[1] * speed * pc.mass, dir[2] * speed * pc.mass], [c.x + (this.rng() - 0.5) * spread, c.y + spread * 0.5, c.z + (this.rng() - 0.5) * spread]);
-    }
+      const momentum = hit.speed * pc.mass;
+      this.pieceSys.impulse(pc, [hit.direction[0] * momentum, hit.direction[1] * momentum, hit.direction[2] * momentum], [c.x + (this.rng() - 0.5) * spread, c.y + spread * 0.5, c.z + (this.rng() - 0.5) * spread]);
+    };
+    for (const pc of [...this.pieceSys.list]) shove(pc);
+    if (this.o.shoveable) this.loosen(p, ev.radius, energy, reachOf);
     this.fragments.blast(p, ev.radius, Math.min(20, Math.sqrt(energy) * 0.08));
     this.sound("explode", p, clamp(0.5 + ev.radius / 10, 0.5, 1));
   }
+  /** The bound objects without a piece that the host lets a blast move (`shoveable`): the ones it reaches with enough speed become pieces and get the shove. */
+  loosen(point, radius, energy, reachOf) {
+    const shoveable = this.o.shoveable;
+    if (!shoveable) return;
+    for (const b of [...this.bounds.values()]) {
+      if (b.piece || this.pieceSys.get(b.id) || !shoveable(b.id) || !this.world.has(b.id)) continue;
+      const { half, center } = this.measure(b.root, this.meshesOf(b));
+      const world = center.clone().applyQuaternion(b.root.quaternion).add(b.root.position);
+      const mass = this.massOf(b.id);
+      const hit = blastShove({ point, energy, radius, reach: reachOf(b.id) }, { position: [world.x, world.y, world.z], mass }, this.o.blastShove);
+      if (!hit) continue;
+      const piece = this.makePiece(b.id, { mass });
+      const body = this.pieceSys.get(b.id);
+      if (!body) continue;
+      this.o.onLoosened?.(b.id, piece);
+      const spread = half[0];
+      const momentum = hit.speed * mass;
+      this.pieceSys.impulse(body, [hit.direction[0] * momentum, hit.direction[1] * momentum, hit.direction[2] * momentum], [world.x + (this.rng() - 0.5) * spread, world.y + spread * 0.5, world.z + (this.rng() - 0.5) * spread]);
+    }
+  }
   playExplosion(ev, options) {
     const named = options.effect ?? ev.effect;
     const direction = options.direction;
@@ -2678,21 +2943,44 @@ var Renderer = class {
   updateLeaks(dt) {
     for (let i = this.leaks.length - 1; i >= 0; i--) {
       const l = this.leaks[i];
+      const b = this.bounds.get(l.object);
       const ps = this.world.part(l.object, l.part);
-      if (!ps || ps.liters === void 0 || ps.liters <= 0) {
+      if (!b || !ps || ps.liters === void 0 || ps.liters <= 1e-4 || l.opened && !ps.holes.some((h) => h.through)) {
         this.leaks.splice(i, 1);
         continue;
       }
+      l.life = (l.life ?? 0) + dt;
+      if (l.pressurized && l.life > 0.8) l.pressurized = false;
+      if (l.lastLiters !== void 0 && Math.abs(ps.liters - l.lastLiters) < 1e-5) {
+        l.idleSeconds = (l.idleSeconds ?? 0) + dt;
+        if (l.idleSeconds > 0.4) {
+          this.leaks.splice(i, 1);
+          continue;
+        }
+      } else {
+        l.idleSeconds = 0;
+        l.lastLiters = ps.liters;
+      }
+      let pt = l.point;
+      let dir = l.direction;
+      if (l.localPoint && l.localDirection) {
+        b.root.updateWorldMatrix(true, false);
+        const wp = this.v1.set(l.localPoint[0], l.localPoint[1], l.localPoint[2]).applyMatrix4(b.root.matrixWorld);
+        const wd = this.v2.set(l.localDirection[0], l.localDirection[1], l.localDirection[2]).transformDirection(b.root.matrixWorld).normalize();
+        pt = [wp.x, wp.y, wp.z];
+        dir = [wd.x, wd.y, wd.z];
+        l.point = pt;
+        l.direction = dir;
+      }
       l.acc += clamp(20 + l.rate * 400, 15, 120) * dt;
       const color = FLUID_COLORS[l.fluid] ?? 11184810;
-      const d = l.direction;
-      const dl = Math.hypot(d[0], d[1], d[2]) || 1;
+      const dl = Math.hypot(dir[0], dir[1], dir[2]) || 1;
       const sp = l.pressurized ? 2.5 + this.rng() * 1.5 : 0.3 + this.rng() * 0.3;
       while (l.acc >= 1) {
         l.acc -= 1;
-        const vel = [d[0] / dl * sp + (this.rng() - 0.5) * 0.25, d[1] / dl * sp + (this.rng() - 0.5) * 0.25, d[2] / dl * sp + (this.rng() - 0.5) * 0.25];
-        if (l.fluid === "gas") this.vfx.spawn("steam", l.point, vel, { color, size: 0.5, alpha: 0.5 });
-        else this.vfx.spawn("drips", l.point, vel, { color, tag: this.rng() < 0.03 ? this.tagOf(l.object) : 0, owner: this.owner });
+        const vel = [dir[0] / dl * sp + (this.rng() - 0.5) * 0.25, dir[1] / dl * sp + (this.rng() - 0.5) * 0.25, dir[2] / dl * sp + (this.rng() - 0.5) * 0.25];
+        if (l.fluid === "gas") this.vfx.spawn("steam", pt, vel, { color, size: 0.5, alpha: 0.5 });
+        else this.vfx.spawn("drips", pt, vel, { color, tag: this.rng() < 0.03 ? this.tagOf(l.object) : 0, owner: this.owner });
       }
     }
   }
@@ -2730,6 +3018,7 @@ var Renderer = class {
       for (const [pid, pv] of [...b.parts]) {
         if (pv.home !== home) continue;
         this.visuals.restorePart(pv);
+        this.tagPart(pv, home);
         if (b !== homeBound && homeBound) {
           b.parts.delete(pid);
           homeBound.parts.set(pid, pv);
@@ -2771,10 +3060,31 @@ var Renderer = class {
     const { puffs, sparks, glows, chunks } = this.vfx.stats();
     return puffs + sparks + glows + chunks;
   }
+  warmUpProbes() {
+    this.releaseWarmProbes();
+    const { kit } = this.visuals;
+    const T = this.THREE;
+    const geometry = new T.BufferGeometry();
+    geometry.setAttribute("position", new T.BufferAttribute(new Float32Array(6), 3));
+    const materials = [kit.discMaterial().clone(), kit.patchMaterial(8421504).clone(), kit.lineMaterial(0).clone()];
+    const group = new T.Group();
+    group.add(new T.Mesh(kit.discGeometry(), materials[0]), new T.Mesh(kit.discGeometry(), materials[1]), new T.LineSegments(geometry, materials[2]));
+    for (const probe of group.children) probe.frustumCulled = false;
+    this.warmProbes = { group, geometry, materials };
+    return { group, dispose: () => {
+    } };
+  }
+  releaseWarmProbes() {
+    if (!this.warmProbes) return;
+    this.warmProbes.geometry.dispose();
+    for (const material of this.warmProbes.materials) material.dispose();
+    this.warmProbes = void 0;
+  }
   rebarCount() {
     return this.cages.count;
   }
   dispose() {
+    this.releaseWarmProbes();
     if (this.disposed) return;
     this.unsubscribe();
     this.clear();