@adatechnology/game-destruction-three 0.7.3 → 0.8.1

package/dist/index.global.js

@@ -35,6 +35,24 @@ var GameDestructionThree = (() => {
     specFromObject3D: () => specFromObject3D
   });
 
+  // ../game-contracts/dist/index.js
+  var DEFAULT_BLAST_SHOVE = { coupling: 0.02, maxSpeed: 20, lift: 0.3, minSpeed: 0.3, falloffPower: 2 };
+  function blastShove(blast, target, options = {}) {
+    const o = { ...DEFAULT_BLAST_SHOVE, ...options };
+    const dx = target.position[0] - blast.point[0];
+    const dy = target.position[1] - blast.point[1];
+    const dz = target.position[2] - blast.point[2];
+    const distance = Math.hypot(dx, dy, dz);
+    if (!(blast.radius > 0) || distance > blast.radius) return void 0;
+    const falloff = (1 - distance / blast.radius) ** o.falloffPower;
+    const mass = Math.max(target.mass, 0.05);
+    const speed = Math.min(o.maxSpeed, Math.sqrt(2 * blast.energy * (blast.reach ?? 1) * o.coupling / mass)) * falloff;
+    if (!(speed >= o.minSpeed)) return void 0;
+    const direction = distance > 1e-4 ? [dx / distance, dy / distance + o.lift, dz / distance] : [0, 1, 0];
+    const length = Math.hypot(direction[0], direction[1], direction[2]);
+    return { speed, direction: [direction[0] / length, direction[1] / length, direction[2] / length], distance, falloff };
+  }
+
   // ../game-vfx/dist/index.js
   var __defProp2 = Object.defineProperty;
   var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -3085,6 +3103,17 @@ var GameDestructionThree = (() => {
       ])
     ]
   };
+  var FUEL_LEAK_ONLY = {
+    id: "fuel_leak_only",
+    pageId: "vazamento",
+    team: "vehicles",
+    budget: { particles: 200, lights: 0 },
+    loop: 11,
+    view: FUEL_LEAK.view,
+    setup: FUEL_LEAK.setup,
+    timeline: [decal(POOL[0], 0, POOL[2], 2.2, 2040368, { grow: 3, life: 60, ar: 0.6, fluid: "oil" })],
+    tick: [emit("drip", "normal", 12, { p: TANK, box: [0.05, 0, 0.05], sp: 0, life: 1, size: 0.03, c0: 5921402, a: 0.9, g: 9.8, fi: 0, gnd: 1 })]
+  };
   var CAR_EXPLOSION = {
     id: "car_explosion",
     pageId: "explosao",
@@ -3438,6 +3467,8 @@ var GameDestructionThree = (() => {
   ];
   var PI = Math.PI;
   var SMOKE = { color: 9079430, width: 10, height: 8, gravity: -0.08, drag: 2.2, growth: 2.1 };
+  var DEFAULT_SMOKE = { puffs: 2, radius: 0.01, opacity: 0.14, life: 0.7, drift: 0.2, rise: 0.06, growth: 2.1, flash: 1 };
+  var DEFAULT_SPREAD = { drift: 0.1, rise: 0.04, side: 0.06 };
   var FLASH_SECONDS = 0.055;
   var FLASH_RAMP = [0.6, 0.9];
   var FLASH_OPACITY = 0.95;
@@ -3445,8 +3476,10 @@ var GameDestructionThree = (() => {
   var FLAME_ADDITIVE = 3;
   var ORIGIN2 = [0, 0, 0];
   var SIZE = variable("size");
+  var FLASH_SCALE = variable("flash");
+  var fallback = (name, defaultValue) => ite(ne(variable(name), void 0), variable(name), defaultValue);
   var wide = (width) => mul(sub(rand(), 0.5), width);
-  var puff2 = (point, velocity, world, radius, life, opacity) => mesh({
+  var puff2 = (point, velocity, world, radius, life, opacity, growth = SMOKE.growth) => mesh({
     shape: "sphere",
     p: point,
     v: velocity,
@@ -3461,7 +3494,7 @@ var GameDestructionThree = (() => {
     lit: true,
     g: SMOKE.gravity,
     drag: SMOKE.drag,
-    grow: SMOKE.growth
+    grow: growth
   });
   var flameBit = (point, velocity, world, radius, life) => [
     set("bitPoint", point),
@@ -3494,37 +3527,55 @@ var GameDestructionThree = (() => {
     id: "viewmodel_muzzle_flash",
     pageId: "event:viewmodel_muzzle_flash",
     team: "weapons",
-    budget: { particles: 12, lights: 1 },
+    budget: { particles: 14, lights: 1 },
     loop: 0.1,
+    setup: [
+      set("size", fallback("size", 1)),
+      set("puffs", fallback("puffs", DEFAULT_SMOKE.puffs)),
+      set("radius", fallback("radius", DEFAULT_SMOKE.radius)),
+      set("opacity", fallback("opacity", DEFAULT_SMOKE.opacity)),
+      set("life", fallback("life", DEFAULT_SMOKE.life)),
+      set("drift", fallback("drift", DEFAULT_SMOKE.drift)),
+      set("rise", fallback("rise", DEFAULT_SMOKE.rise)),
+      set("growth", fallback("growth", DEFAULT_SMOKE.growth)),
+      set("flash", fallback("flash", DEFAULT_SMOKE.flash)),
+      set("driftSpread", fallback("driftSpread", DEFAULT_SPREAD.drift)),
+      set("riseSpread", fallback("riseSpread", DEFAULT_SPREAD.rise)),
+      set("sideSpread", fallback("sideSpread", DEFAULT_SPREAD.side)),
+      set("lifeSpread", ite(ne(variable("lifeSpread"), void 0), variable("lifeSpread"), mul(variable("life"), 0.3)))
+    ],
     timeline: [
       set("angles", []),
       repeat(4, append("angles", add(div(mul(INDEX, PI), 2), mul(rand(), 0.6)))),
       set("roll", mul(rand(), PI)),
-      flash(ORIGIN2, 16756832, mul(4, SIZE), FLASH_SECONDS, mul(2, SIZE), true, true),
-      flashPiece("cone_open", mul(0.013, SIZE), mul(0.085, SIZE), 10, [mul(0.042, SIZE), 0, 0], [0, 0, -PI / 2], 16757575),
-      repeat(
-        4,
-        set("angle", pick(variable("angles"), INDEX)),
-        flashPiece(
-          "cone",
-          mul(5e-3, SIZE),
-          mul(0.04, SIZE),
-          6,
-          [mul(0.012, SIZE), mul(cos(variable("angle")), 0.016, SIZE), mul(sin(variable("angle")), 0.016, SIZE)],
-          [variable("angle"), 0, -PI / 2],
-          16757575
-        )
-      ),
-      flashPiece("sphere", mul(0.016, SIZE), void 0, 12, [mul(8e-3, SIZE), 0, 0], [0, 0, 0], 16773568),
+      when(gt(FLASH_SCALE, 0), [
+        flash(ORIGIN2, 16756832, mul(4, SIZE, FLASH_SCALE), FLASH_SECONDS, mul(2, SIZE, FLASH_SCALE), true, true),
+        flashPiece("cone_open", mul(0.013, SIZE, FLASH_SCALE), mul(0.085, SIZE, FLASH_SCALE), 10, [mul(0.042, SIZE, FLASH_SCALE), 0, 0], [0, 0, -PI / 2], 16757575),
+        repeat(
+          4,
+          set("angle", pick(variable("angles"), INDEX)),
+          flashPiece(
+            "cone",
+            mul(5e-3, SIZE, FLASH_SCALE),
+            mul(0.04, SIZE, FLASH_SCALE),
+            6,
+            [mul(0.012, SIZE, FLASH_SCALE), mul(cos(variable("angle")), 0.016, SIZE, FLASH_SCALE), mul(sin(variable("angle")), 0.016, SIZE, FLASH_SCALE)],
+            [variable("angle"), 0, -PI / 2],
+            16757575
+          )
+        ),
+        flashPiece("sphere", mul(0.016, SIZE, FLASH_SCALE), void 0, 12, [mul(8e-3, SIZE, FLASH_SCALE), 0, 0], [0, 0, 0], 16773568)
+      ]),
       repeat(
-        6,
+        variable("puffs"),
         puff2(
           ORIGIN2,
-          [add(0.15, mul(rand(), 0.35)), add(0.03, mul(rand(), 0.12)), mul(sub(rand(), 0.5), 0.14)],
+          [add(variable("drift"), mul(rand(), variable("driftSpread"))), add(variable("rise"), mul(rand(), variable("riseSpread"))), mul(sub(rand(), 0.5), variable("sideSpread"))],
           [0, 0, 0],
-          mul(0.013, SIZE),
-          add(1.3, mul(rand(), 0.6)),
-          0.45
+          mul(variable("radius"), SIZE),
+          add(variable("life"), mul(rand(), variable("lifeSpread"))),
+          variable("opacity"),
+          variable("growth")
         )
       )
     ]
@@ -3578,8 +3629,10 @@ var GameDestructionThree = (() => {
     aliasOf(ENGINE_SMOKE, "vehicle_fire", { params: { id: "condition", options: ["100", "60", "30", "10"], default: 3 }, loop: 12 }),
     /** The exhaust of a car under way: `engine_smoke` in the best condition, for half a second so a moving car asks again. */
     aliasOf(ENGINE_SMOKE, "vehicle_exhaust", { params: { id: "condition", options: ["100", "60", "30", "10"], default: 0 }, loop: 0.5 }),
-    /** A hole in the tank: the page's own petrol leak (drips, pool, sparks, fire running to the tank). */
-    aliasOf(FUEL_LEAK, "vehicle_leak", {})
+    /** A hole in the tank: the page's petrol leak without the fire and the blast (the pool and the drips). A normal bullet does only this. */
+    aliasOf(FUEL_LEAK_ONLY, "vehicle_leak", {}),
+    /** The leak caught fire (an incendiary or tracer round, a spark, a fire near): the page's whole sequence, the fire running along the pool to the tank and the blast. */
+    aliasOf(FUEL_LEAK, "vehicle_leak_ignited", {})
   ];
   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]));
@@ -7752,6 +7805,79 @@ void main(){
       }
     };
   }
+  var SPHERE_DEFAULT_WIDTH = 8;
+  var SPHERE_DEFAULT_HEIGHT = 6;
+  function geometryOf(THREE, particle) {
+    switch (particle.shape) {
+      case "cone":
+        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, false);
+      case "cone_open":
+        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, true);
+      case "sphere":
+        return new THREE.SphereGeometry(particle.radius, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
+      case "icosahedron":
+        return new THREE.IcosahedronGeometry(particle.radius, particle.segments);
+    }
+  }
+  function materialOf(THREE, particle) {
+    if (particle.lit) return new THREE.MeshStandardMaterial({ color: particle.color, roughness: 1, metalness: 0, transparent: true, opacity: particle.opacity, depthWrite: false });
+    return new THREE.MeshBasicMaterial({ color: particle.color, transparent: true, opacity: particle.opacity, depthWrite: false, ...particle.additive ? { blending: THREE.AdditiveBlending } : {} });
+  }
+  function createMeshLayerProbes(THREE) {
+    const geometry = new THREE.BoxGeometry(1e-3, 1e-3, 1e-3);
+    return [{ lit: true, additive: false }, { lit: false, additive: false }, { lit: false, additive: true }].map(
+      (kind) => new THREE.Mesh(geometry, materialOf(THREE, { ...kind, color: 8421504, opacity: 0.5 }))
+    );
+  }
+  function createMeshLayer(THREE, pool) {
+    const group = new THREE.Group();
+    group.name = "workshop-meshes";
+    const drawn = /* @__PURE__ */ new Map();
+    const frame = new THREE.Quaternion();
+    const euler = new THREE.Euler();
+    const turn = new THREE.Quaternion();
+    const offset = new THREE.Vector3();
+    function release(mesh2) {
+      mesh2.removeFromParent();
+      mesh2.geometry.dispose();
+      mesh2.material.dispose();
+    }
+    return {
+      group,
+      sync() {
+        const live = /* @__PURE__ */ new Set();
+        for (const particle of pool.particles) {
+          live.add(particle.id);
+          let mesh2 = drawn.get(particle.id);
+          if (!mesh2) {
+            mesh2 = new THREE.Mesh(geometryOf(THREE, particle), materialOf(THREE, particle));
+            mesh2.frustumCulled = false;
+            mesh2.renderOrder = particle.additive ? 5 : 3;
+            drawn.set(particle.id, mesh2);
+            group.add(mesh2);
+          }
+          frame.set(particle.frame[0], particle.frame[1], particle.frame[2], particle.frame[3]);
+          offset.set(particle.at[0], particle.at[1], particle.at[2]).multiplyScalar(particle.scale).applyQuaternion(frame);
+          mesh2.position.set(particle.x + offset.x, particle.y + offset.y, particle.z + offset.z);
+          turn.setFromEuler(euler.set(particle.rx, particle.ry, particle.rz));
+          mesh2.quaternion.copy(frame).multiply(turn);
+          mesh2.scale.setScalar(particle.scale);
+          mesh2.material.opacity = particle.opacity;
+        }
+        for (const [id, mesh2] of drawn) {
+          if (live.has(id)) continue;
+          release(mesh2);
+          drawn.delete(id);
+        }
+        return pool.count;
+      },
+      dispose() {
+        for (const mesh2 of drawn.values()) release(mesh2);
+        drawn.clear();
+        group.removeFromParent();
+      }
+    };
+  }
   var clamp5 = (value, min2, max2) => value < min2 ? min2 : value > max2 ? max2 : value;
   function layer(container, name, blend) {
     const element = container.ownerDocument.createElement("div");
@@ -7921,73 +8047,6 @@ void main() {
       }
     };
   }
-  var SPHERE_DEFAULT_WIDTH = 8;
-  var SPHERE_DEFAULT_HEIGHT = 6;
-  function geometryOf(THREE, particle) {
-    switch (particle.shape) {
-      case "cone":
-        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, false);
-      case "cone_open":
-        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, true);
-      case "sphere":
-        return new THREE.SphereGeometry(particle.radius, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
-      case "icosahedron":
-        return new THREE.IcosahedronGeometry(particle.radius, particle.segments);
-    }
-  }
-  function materialOf(THREE, particle) {
-    if (particle.lit) return new THREE.MeshStandardMaterial({ color: particle.color, roughness: 1, metalness: 0, transparent: true, opacity: particle.opacity, depthWrite: false });
-    return new THREE.MeshBasicMaterial({ color: particle.color, transparent: true, opacity: particle.opacity, depthWrite: false, ...particle.additive ? { blending: THREE.AdditiveBlending } : {} });
-  }
-  function createMeshLayer(THREE, pool) {
-    const group = new THREE.Group();
-    group.name = "workshop-meshes";
-    const drawn = /* @__PURE__ */ new Map();
-    const frame = new THREE.Quaternion();
-    const euler = new THREE.Euler();
-    const turn = new THREE.Quaternion();
-    const offset = new THREE.Vector3();
-    function release(mesh2) {
-      mesh2.removeFromParent();
-      mesh2.geometry.dispose();
-      mesh2.material.dispose();
-    }
-    return {
-      group,
-      sync() {
-        const live = /* @__PURE__ */ new Set();
-        for (const particle of pool.particles) {
-          live.add(particle.id);
-          let mesh2 = drawn.get(particle.id);
-          if (!mesh2) {
-            mesh2 = new THREE.Mesh(geometryOf(THREE, particle), materialOf(THREE, particle));
-            mesh2.frustumCulled = false;
-            mesh2.renderOrder = particle.additive ? 5 : 3;
-            drawn.set(particle.id, mesh2);
-            group.add(mesh2);
-          }
-          frame.set(particle.frame[0], particle.frame[1], particle.frame[2], particle.frame[3]);
-          offset.set(particle.at[0], particle.at[1], particle.at[2]).multiplyScalar(particle.scale).applyQuaternion(frame);
-          mesh2.position.set(particle.x + offset.x, particle.y + offset.y, particle.z + offset.z);
-          turn.setFromEuler(euler.set(particle.rx, particle.ry, particle.rz));
-          mesh2.quaternion.copy(frame).multiply(turn);
-          mesh2.scale.setScalar(particle.scale);
-          mesh2.material.opacity = particle.opacity;
-        }
-        for (const [id, mesh2] of drawn) {
-          if (live.has(id)) continue;
-          release(mesh2);
-          drawn.delete(id);
-        }
-        return pool.count;
-      },
-      dispose() {
-        for (const mesh2 of drawn.values()) release(mesh2);
-        drawn.clear();
-        group.removeFromParent();
-      }
-    };
-  }
   var WORKSHOP_SPRITE_VERTEX = `attribute float size;attribute float alpha;attribute vec3 pcol;varying vec3 vC;varying float vA;uniform float uScale;
 void main(){vC=pcol;vA=alpha;vec4 mv=modelViewMatrix*vec4(position,1.);gl_PointSize=clamp(size*uScale/-mv.z,1.,512.);gl_Position=projectionMatrix*mv;}`;
   var WORKSHOP_SPRITE_FRAGMENT = `uniform float uSoft;varying vec3 vC;varying float vA;
@@ -8352,6 +8411,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const requested = options.vfx;
     const world = isWorld(requested) ? requested : createVfx({ profile: options.quality ?? "medium", reducedMotion, ...requested });
     const pools = world.pools();
+    let anchors;
+    const releaseAnchors = () => {
+      if (!anchors) return;
+      anchors.meshes[0]?.geometry.dispose();
+      for (const mesh2 of anchors.meshes) mesh2.material.dispose();
+      anchors = void 0;
+    };
     const root = new THREE.Group();
     options.scene.add(root);
     const direction = new THREE.Vector3(...options.lightDirection ?? LAB_LIGHT_DIRECTION).normalize();
@@ -8468,6 +8534,16 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         syncAll();
         overlay?.update(screenNow());
       },
+      warmUpProbes() {
+        releaseAnchors();
+        const meshes = createMeshLayerProbes(THREE);
+        for (const mesh2 of meshes) mesh2.frustumCulled = false;
+        const group = new THREE.Group();
+        group.add(...meshes);
+        anchors = { meshes, group };
+        return { group, dispose: () => {
+        } };
+      },
       applyCamera() {
         const shake = screenNow().shake;
         if (reducedMotion || !(shake > SHAKE_FLOOR)) return () => {
@@ -8486,6 +8562,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       },
       screen: screenNow,
       dispose() {
+        releaseAnchors();
         stopMarks();
         overlay?.dispose();
         workshopLayers?.dispose();
@@ -8627,6 +8704,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const sc = new this.THREE.Vector3(Math.max(5e-3, sz[0]), Math.max(5e-3, sz[1]), Math.max(3e-3, sz[2]));
       mesh2.scale.copy(sc);
       mesh2.castShadow = true;
+      mesh2.userData.destructionDebris = true;
       this.o.scene.add(mesh2);
       const live = {
         mesh: mesh2,
@@ -8834,6 +8912,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       mesh2.position.set(x, y, z);
       mesh2.scale.setScalar(1e-3);
       mesh2.renderOrder = 1;
+      mesh2.userData.destructionDebris = true;
       this.scene.add(mesh2);
       this.spots.push({ mesh: mesh2, kind, home, x, z, radius: 1e-3, target: Math.min(MAX_RADIUS, radius) });
     }
@@ -9344,12 +9423,68 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
     return { min: [center[0] - hx, center[1] - hy, center[2] - hz], max: [center[0] + hx, center[1] + hy, center[2] + hz] };
   };
+  var FLEXURE_DEFAULTS = {
+    enabled: true,
+    roles: ["beam", "slab", "roof", "stair"],
+    scope: "rebar",
+    crackFactor: 1.5,
+    rebarYieldMPa: 500,
+    cover: 0.03,
+    neutralAxisLimit: 0.45,
+    failRotationDeg: 10,
+    loadFactor: 0.64,
+    massFactor: 0.5,
+    tntJoules: 4184e3,
+    impulse: 200,
+    reflection: 2,
+    reflectionNear: 4,
+    nearScaled: 0.5
+  };
+  var FLEXURAL_ROLES = FLEXURE_DEFAULTS.roles;
+  var SOIL_DEFAULTS = {
+    safety: 3,
+    pileSafety: 2,
+    rigidity: 0.82,
+    influence: 2,
+    imperfection: 1 / 200,
+    cells: 4,
+    sinkRate: 0.05,
+    tiltRate: 1.5,
+    pileElasticGPa: 25,
+    footingWidth: 0.6
+  };
+  var WIND_DEFAULTS = {
+    speed: 40,
+    direction: [1, 0, 0],
+    terrain: "III",
+    class: "auto",
+    topography: 1,
+    statistical: 1,
+    drag: 1.3,
+    damping: 0.016,
+    airDensity: 1.226,
+    minHeight: 5,
+    bandHeight: 3,
+    stiffnessFactor: 0.8,
+    beamFactor: 0.4,
+    flange: 0.1,
+    driftLimit: 1 / 500,
+    loadFactor: 1.4,
+    chord: false,
+    meanRatio: 0.69,
+    gustFactor: { A: 1, B: 0.98, C: 0.95 },
+    gust: { components: 400, maxHz: 2, scale: 1200, seed: 1 },
+    peakDecay: 60,
+    tuning: "den-hartog"
+  };
   var materials_default = [
     {
       id: "steel",
       density: 7850,
       hpPerKg: 400,
       penetration: 110,
+      penetrationClass: "steel",
+      penetrationScale: 1.3,
       ductility: 0.9,
       fracture: "none",
       damageScale: {
@@ -9379,6 +9514,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       density: 7200,
       hpPerKg: 150,
       penetration: 160,
+      penetrationClass: "steel",
+      penetrationScale: 1,
       ductility: 0.2,
       fracture: "snap",
       fragmentSize: [
@@ -9412,6 +9549,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       density: 2700,
       hpPerKg: 250,
       penetration: 60,
+      penetrationClass: "steel",
+      penetrationScale: 3,
       ductility: 0.85,
       fracture: "none",
       damageScale: {
@@ -9440,6 +9579,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       density: 8960,
       hpPerKg: 300,
       penetration: 70,
+      penetrationClass: "steel",
+      penetrationScale: 1.5,
       ductility: 0.95,
       fracture: "none",
       damageScale: {
@@ -9468,6 +9609,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       density: 500,
       hpPerKg: 90,
       penetration: 9,
+      penetrationClass: "wood",
+      penetrationScale: 1.5,
       ductility: 0.35,
       fracture: "splinter",
       fragmentSize: [
@@ -9504,6 +9647,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       density: 750,
       hpPerKg: 140,
       penetration: 14,
+      penetrationClass: "wood",
+      penetrationScale: 1,
       ductility: 0.3,
       fracture: "splinter",
       fragmentSize: [
@@ -9539,6 +9684,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       density: 600,
       hpPerKg: 70,
       penetration: 7,
+      penetrationClass: "wood",
+      penetrationScale: 2,
       ductility: 0.3,
       fracture: "snap",
       fragmentSize: [
@@ -9574,6 +9721,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       density: 750,
       hpPerKg: 45,
       penetration: 6,
+      penetrationClass: "wood",
+      penetrationScale: 2.5,
       ductility: 0.15,
       fracture: "snap",
       fragmentSize: [
@@ -9702,6 +9851,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       density: 2300,
       hpPerKg: 14,
       penetration: 18,
+      penetrationClass: "concrete",
+      penetrationScale: 1,
       ductility: 0.03,
       fracture: "crumble",
       fragmentSize: [
@@ -9721,13 +9872,20 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         "masonry",
         "brittle"
       ],
-      compressive: 444e3
+      compressive: 444e3,
+      strength: {
+        compressiveMPa: 25,
+        tensileMPa: 2.56,
+        elasticGPa: 28
+      }
     },
     {
       id: "brick",
       density: 1900,
       hpPerKg: 12,
       penetration: 14,
+      penetrationClass: "brick",
+      penetrationScale: 1,
       ductility: 0.05,
       fracture: "crumble",
       fragmentSize: [
@@ -9744,13 +9902,20 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         "masonry",
         "brittle"
       ],
-      compressive: 4e4
+      compressive: 4e4,
+      strength: {
+        compressiveMPa: 2.35,
+        tensileMPa: 0.1,
+        elasticGPa: 2.35
+      }
     },
     {
       id: "plaster",
       density: 850,
       hpPerKg: 18,
       penetration: 3,
+      penetrationClass: "brick",
+      penetrationScale: 3,
       ductility: 0.05,
       fracture: "crumble",
       fragmentSize: [
@@ -9774,6 +9939,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       density: 2700,
       hpPerKg: 25,
       penetration: 25,
+      penetrationClass: "concrete",
+      penetrationScale: 0.9,
       ductility: 0.03,
       fracture: "crumble",
       fragmentSize: [
@@ -10037,6 +10204,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       density: 650,
       hpPerKg: 5,
       penetration: 10,
+      penetrationClass: "wood",
+      penetrationScale: 1.2,
       ductility: 0.5,
       fracture: "splinter",
       fragmentSize: [
@@ -10288,6 +10457,12 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     for (const [key, id] of HINTS) if (n.includes(key)) return id;
     return void 0;
   };
+  var partVolume = (shape) => {
+    if (shape.kind === "box") return shape.size[0] * shape.size[1] * shape.size[2];
+    if (shape.kind === "cylinder") return Math.PI * shape.radius * shape.radius * shape.height;
+    return 4 / 3 * Math.PI * shape.radius ** 3;
+  };
+  var partMass = (part, material) => part.mass ?? material.density * partVolume(part.shape) * (part.fill ?? 1);
   var partThickness = (part) => {
     const dims = shapeDims(part.shape);
     const min2 = Math.min(dims[0], dims[1], dims[2]);
@@ -10315,6 +10490,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   };
 
   // src/spec.ts
+  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;
@@ -10335,11 +10515,17 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   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 fallback2 = 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) => {
@@ -10353,11 +10539,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const matName = mats[0]?.name ?? "";
           const ud = o.userData ?? {};
           const hint = partHintOf(ud.destructionPart);
-          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 material = options.materialOf?.(o) ?? (typeof ud.destructionMaterial === "string" ? ud.destructionMaterial : void 0) ?? hint?.material ?? guessMaterial(`${o.name} ${matName} ${typeof ud.material === "string" ? ud.material : ""}`) ?? fallback2;
           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);
@@ -10367,9 +10555,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
             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);
           }
@@ -10388,7 +10578,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     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;
@@ -10442,11 +10632,21 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         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 = MATERIALS2.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;
@@ -10498,6 +10698,46 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     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 local2 = 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(local2.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(local2, closest);
+        const distance = closest.distanceToSquared(local2);
+        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) {
@@ -10530,7 +10770,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         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. */
@@ -10562,6 +10803,12 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
   };
   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);
@@ -10730,14 +10977,14 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
      * 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 mesh2 = mv.mesh;
       if (this.lowQuality && this.vertexCount(mv) > 2e4) return false;
       mesh2.updateWorldMatrix(true, false);
       const s = mesh2.matrixWorld.getMaxScaleOnAxis() || 1;
       const lp = mesh2.worldToLocal(this.a.copy(worldPoint));
       const ln = this.b.copy(worldNormal).transformDirection(this.m4.copy(mesh2.matrixWorld).invert()).normalize();
-      const r = dent.radius / s;
+      const r = Math.max(dent.radius, reachWorld) / s;
       const depth = dent.depth / s;
       const geo = mesh2.geometry;
       let bb;
@@ -10750,34 +10997,110 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (!this.ownGeometry(mv)) return false;
       const work = mv.host ? mv.host.work : mv.work;
       const pos = positionAttr(mesh2.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 mesh2 = mv.mesh;
+      mesh2.updateWorldMatrix(true, false);
+      const s = mesh2.matrixWorld.getMaxScaleOnAxis() || 1;
+      const lp = mesh2.worldToLocal(this.a.copy(worldPoint));
+      const source = (mv.host ? mv.host.work : mv.work) ?? positionAttr(mesh2.geometry)?.array;
+      if (!source) return dent.radius;
+      let bounds;
+      if (mv.host) bounds = this.localBox(mv, this.lbox);
+      else {
+        if (!mesh2.geometry.boundingBox) mesh2.geometry.computeBoundingBox();
+        bounds = mesh2.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 mesh2 = mv.mesh;
+        mesh2.updateWorldMatrix(true, false);
+        const toLocal = this.m4.copy(mesh2.matrixWorld).invert();
+        const scale = mesh2.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(mesh2.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(mesh2.geometry));
+      }
+    }
     /** Copy `work` (dents) into the geometry, adding the melt sag when the mesh is melting. */
     writePositions(mv, pos) {
       if (mv.host) {
@@ -10824,6 +11147,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       return { s, pos, quat: quat2 };
     }
     addDecal(mv, decal2) {
+      decal2.obj.userData.destructionDebris = true;
       mv.mesh.add(decal2.obj);
       mv.decals.push(decal2);
       this.decalCount++;
@@ -10840,6 +11164,27 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
     addHole(mv, worldPoint, worldNormal, diameter) {
       const { s, pos, quat: quat2 } = 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(quat2);
@@ -11311,7 +11656,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     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 = {
@@ -11408,6 +11759,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __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";
@@ -11505,6 +11858,24 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         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" };
@@ -11518,13 +11889,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         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) {
@@ -11561,10 +11932,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     // ----------------------------------------------------------------------------------------------------------------------------------
     // 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();
@@ -11639,6 +12009,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       dt = clamp6(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);
@@ -11657,6 +12028,27 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         }
       }
     }
+    /**
+     * 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);
     }
@@ -11711,6 +12103,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         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));
@@ -11796,13 +12191,39 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         }
         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;
@@ -11879,10 +12300,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       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, clamp6(0.3 + ev.dent.depth * 12, 0.3, 1));
     }
@@ -12078,6 +12498,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         }
       }
       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);
@@ -12105,24 +12526,40 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       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, clamp6(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;
@@ -12222,21 +12659,44 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     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 += clamp6(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 });
         }
       }
     }
@@ -12274,6 +12734,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         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);
@@ -12315,10 +12776,31 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       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();