@adatechnology/game-vehicles 0.6.0 → 0.6.2

package/dist/index.js

@@ -3188,6 +3188,7 @@ function installInterior(kit) {
 }
 
 // src/hood.ts
+var HOOD_LIFT = 8e-3;
 function installHood(kit) {
   const THREE = kit.THREE;
   const V3 = THREE.Vector3;
@@ -3210,7 +3211,7 @@ function installHood(kit) {
     for (let i = 0; i < p.count; i++) {
       p.setX(i, cx + (p.getX(i) - cx) * sx);
       p.setZ(i, p.getZ(i) * sz);
-      p.setY(i, p.getY(i) + 8e-3);
+      p.setY(i, p.getY(i) + HOOD_LIFT);
     }
     geo.translate(-hx, -hy, 0);
     const under = geo.clone();
@@ -3239,7 +3240,8 @@ function installHood(kit) {
       yMin: bb.min.y,
       zw: bb.max.z,
       label: o.label,
-      noLatch: !!o.noLatch
+      noLatch: !!o.noLatch,
+      lift: HOOD_LIFT
     };
     c.part("hood", { key: "hood" }, piv, new V3((hx + bb.max.x) / 2, hy, 0), 0.9);
     return c.hood;
@@ -4675,6 +4677,14 @@ function installParticles(kit) {
 }
 
 // src/fluids.ts
+var PUDDLE_COLORS = {
+  coolant: 3123279,
+  brake_fluid: 12093738,
+  transmission_fluid: 10099746,
+  power_steering_fluid: 9054768,
+  washer_fluid: 2977744,
+  battery_acid: 14211272
+};
 function installFluids(kit) {
   const THREE = kit.THREE;
   const V3 = THREE.Vector3;
@@ -4894,6 +4904,13 @@ function installFluids(kit) {
       transparent: true,
       opacity: 0.9,
       depthWrite: false
+    }) : PUDDLE_COLORS[kind] ? new THREE.MeshStandardMaterial({
+      color: PUDDLE_COLORS[kind],
+      roughness: 0.05,
+      metalness: 0.1,
+      transparent: true,
+      opacity: 0.7,
+      depthWrite: false
     }) : new THREE.MeshStandardMaterial({
       color: 0,
       roughness: 0.03,
@@ -5739,12 +5756,36 @@ function installImpact(kit) {
         if (g.userData.crease && c.smoothLater) c.smoothLater(msh);
         else if (g.userData.crease) crease(g, 42);
         else g.computeVertexNormals();
-        g.computeBoundingBox();
         const sphere = g.boundingSphere ?? (g.boundingSphere = new THREE.Sphere());
-        g.boundingBox.getCenter(sphere.center);
-        let far2 = 0;
-        for (let i = 0; i < pos.count; i++) far2 = Math.max(far2, sphere.center.distanceToSquared(v.fromBufferAttribute(pos, i)));
-        sphere.radius = Math.sqrt(far2);
+        if (pos.isInterleavedBufferAttribute || pos.normalized || Object.keys(g.morphAttributes).length > 0) {
+          g.computeBoundingBox();
+          g.boundingBox.getCenter(sphere.center);
+          let far2 = 0;
+          for (let i = 0; i < pos.count; i++) far2 = Math.max(far2, sphere.center.distanceToSquared(v.fromBufferAttribute(pos, i)));
+          sphere.radius = Math.sqrt(far2);
+        } else {
+          const box2 = g.boundingBox ?? (g.boundingBox = new THREE.Box3());
+          let x0 = Infinity, y0 = Infinity, z0 = Infinity, x1 = -Infinity, y1 = -Infinity, z1 = -Infinity;
+          for (let i = 0; i < pos.count * 3; i += 3) {
+            const x = arr[i], y = arr[i + 1], z = arr[i + 2];
+            if (x < x0) x0 = x;
+            if (y < y0) y0 = y;
+            if (z < z0) z0 = z;
+            if (x > x1) x1 = x;
+            if (y > y1) y1 = y;
+            if (z > z1) z1 = z;
+          }
+          box2.min.set(x0, y0, z0);
+          box2.max.set(x1, y1, z1);
+          box2.getCenter(sphere.center);
+          const cx = sphere.center.x, cy = sphere.center.y, cz = sphere.center.z;
+          let far2 = 0;
+          for (let i = 0; i < pos.count * 3; i += 3) {
+            const dx = cx - arr[i], dy = cy - arr[i + 1], dz = cz - arr[i + 2];
+            far2 = Math.max(far2, dx * dx + dy * dy + dz * dz);
+          }
+          sphere.radius = Math.sqrt(far2);
+        }
       }
     });
     const dset = new Set(c.deform);
@@ -6148,7 +6189,8 @@ function installExplosion(kit) {
       const G = gm2.userData.glass;
       if (!G || G.broken || !gm2.visible || !gm2.parent) return;
       if (G.type === "laminated") {
-        G.type = "tempered";
+        for (let k2 = 0; k2 < 3; k2++) I.crackGlass(c, gm2, I.glassPt ? I.glassPt(c, gm2, c.rand) : gm2.position.clone(), 1.2);
+        return;
       }
       I.shatterGlass(c, gm2, 1.4, new V3(0, 1, 0));
     });
@@ -6159,19 +6201,6 @@ function installExplosion(kit) {
       fling(c, c.hood.piv, new V3(rv(1, 3), rv(6, 8.5), rv(-1.5, 1.5)), new V3(rv(-4, 4), rv(-2, 2), rv(3, 7)));
       c.hood = null;
     }
-    const W = m.width || 1.6;
-    const gh = m.glasshouse;
-    if (m.kind === "car" && gh) {
-      ;
-      [1, -1].forEach(function(sd) {
-        const dh = Math.max(0.35, (m.belt || 1) - (m.clearance || 0.3) - 0.08);
-        const dx = gh.fb - 0.55;
-        const door = c.roundBox(0.95, dh, 0.045, 0.03, c.paint(m.color || "#777"), dx, (m.clearance || 0.3) + dh / 2 + 0.04, sd * (W / 2 + 0.01));
-        const hole = c.roundBox(0.9, dh * 0.95, 0.02, 0.02, MATERIALS.dark, dx, (m.clearance || 0.3) + dh / 2 + 0.04, sd * (W / 2 - 0.01));
-        hole.userData.noFollow = true;
-        fling(c, door, c.dirToEffects(new V3(rv(-1, 1), rv(3.5, 6), sd * rv(4, 6.5))), new V3(rv(-5, 5), rv(-4, 4), rv(-5, 5)));
-      });
-    }
     if (m.rearBumper && m.rearBumper.parent)
       fling(
         c,
@@ -6179,20 +6208,6 @@ function installExplosion(kit) {
         c.dirToEffects(new V3(rv(-5, -3), rv(4, 6), rv(-1, 1))),
         new V3(rv(-3, 3), rv(-6, 6), rv(-3, 3))
       );
-    if (c.wheels.length) {
-      const wi = Math.floor(c.rand() * c.wheels.length);
-      const wh = c.wheels[wi];
-      c.wheels.splice(wi, 1);
-      c.parts.forEach(function(p) {
-        if (p.obj === wh) p.done = true;
-      });
-      fling(
-        c,
-        wh,
-        c.dirToEffects(new V3(rv(-2, 2), rv(5, 7.5), (wh.position.z >= 0 ? 1 : -1) * rv(3, 5))),
-        new V3(rv(-8, 8), rv(-3, 3), rv(-8, 8))
-      );
-    }
     burnAll(c);
     c.emitters = c.emitters.filter(function(e) {
       return e.kind === "exhaust" ? false : true;
@@ -10987,6 +11002,17 @@ function createVehicleKit(options) {
   return kit;
 }
 
+// src/destructible/armour.ts
+var ARMOUR_LEVELS = {
+  IIIA: { glassStops: 1700, glassHp: 6e3, glassTakes: 0.25, steel: 8 },
+  III: { glassStops: 3600, glassHp: 9e3, glassTakes: 0.25, steel: 30 }
+};
+function armourLevelOf(meta, option) {
+  if (option !== void 0) return option;
+  if (meta.armor === "IIIA" || meta.armor === "III") return meta.armor;
+  return meta.armored || meta.bullet ? "III" : null;
+}
+
 // src/destructible/impl.ts
 import { ignitionChance, resolveIgnitionRules, sparkTargetFactor } from "@adatechnology/game-contracts";
 
@@ -11033,6 +11059,12 @@ var boxOf = (z) => ({
   center: [(z.box.x0 + z.box.x1) / 2, (z.box.y0 + z.box.y1) / 2, (z.box.z0 + z.box.z1) / 2],
   size: [Math.max(0.02, z.box.x1 - z.box.x0), Math.max(0.02, z.box.y1 - z.box.y0), Math.max(0.02, z.box.z1 - z.box.z0)]
 });
+var PART_FLUIDS = {
+  gearbox: { fluid: "transmission_fluid", liters: 6 },
+  brakes: { fluid: "brake_fluid", liters: 0.6 },
+  steering: { fluid: "power_steering_fluid", liters: 1 },
+  battery: { fluid: "battery_acid", liters: 3 }
+};
 var skinOf = (kind) => kind === "plane" || kind === "heli" || kind === "boat" ? "aluminium" : "steel";
 var isFender = (id) => /^fender/.test(id);
 var roleOfZone = (z) => {
@@ -11090,7 +11122,8 @@ function buildVehicleModel(kit, c, options = {}) {
   const spec = c.spec;
   const t = kit.t;
   const skin = skinOf(kind);
-  const armour = m.armored || m.bullet ? 12 : 1;
+  const armoured = options.armour ?? null;
+  const armour = armoured ? 12 : 1;
   const mass = vehicleMass(c);
   const W = m.width ?? 1.7;
   const F = m.front ?? 2;
@@ -11156,8 +11189,8 @@ function buildVehicleModel(kit, c, options = {}) {
     }
     if (role === "glass") {
       const glass = (z.glass ?? [])[0];
-      const laminated = glass?.userData?.glass?.type === "laminated" || m.bullet;
-      add({ id, role, name: label, material: "glass", box, mass: 10 * area, hp: laminated ? 4e3 : 450, zoneId: id, visual: false, tags: ["glass", ...tags] });
+      const laminated = glass?.userData?.glass?.type === "laminated" || !!armoured;
+      add({ id, role, name: label, material: "glass", box, mass: 10 * area, hp: armoured ? armoured.glassHp : laminated ? 4e3 : 450, zoneId: id, visual: false, tags: ["glass", ...tags] });
       continue;
     }
     if (role === "light") {
@@ -11195,7 +11228,7 @@ function buildVehicleModel(kit, c, options = {}) {
         zoneId: id,
         visual: false,
         contains: { fluid: diesel ? "diesel" : "fuel", liters },
-        explodes: diesel ? void 0 : { energy: 12e5 * (liters / 55), radius: 5 + liters / 30, atC: 320 },
+        explodes: diesel ? void 0 : { energy: 12e5 * (liters / 55), radius: 5 + liters / 30, atC: 320, effect: "car_fuel_tank" },
         ignitionC: diesel ? 330 : 260,
         tags: ["fuel_tank", ...tags]
       });
@@ -11231,8 +11264,8 @@ function buildVehicleModel(kit, c, options = {}) {
     if (claimed.has(pane)) continue;
     const G = pane.userData.glass;
     const bb = paneBox(c, pane, inverse);
-    const laminated = G?.type === "laminated" || m.bullet;
-    add({ id: `pane_${G?.key ?? "glass"}`, role: "glass", name: String(G?.label ?? G?.key ?? "glass"), material: "glass", box: bb, mass: 10 * areaOf(bb.size), hp: laminated ? 4e3 : 450, panes: [pane], visual: false, tags: ["glass"] });
+    const laminated = G?.type === "laminated" || !!armoured;
+    add({ id: `pane_${G?.key ?? "glass"}`, role: "glass", name: String(G?.label ?? G?.key ?? "glass"), material: "glass", box: bb, mass: 10 * areaOf(bb.size), hp: armoured ? armoured.glassHp : laminated ? 4e3 : 450, panes: [pane], visual: false, tags: ["glass"] });
   }
   if (!hubZone) {
     const h = Math.max(0.15, belt - clearance);
@@ -11288,7 +11321,7 @@ function buildVehicleModel(kit, c, options = {}) {
       visual: false,
       mechanical: true,
       contains: { fluid: diesel ? "diesel" : "fuel", liters },
-      explodes: diesel ? void 0 : { energy: 12e5 * (liters / 55), radius: 5 + liters / 30, atC: 320 },
+      explodes: diesel ? void 0 : { energy: 12e5 * (liters / 55), radius: 5 + liters / 30, atC: 320, effect: "car_fuel_tank" },
       ignitionC: diesel ? 330 : 260,
       tags: ["fuel_tank"]
     });
@@ -11565,38 +11598,121 @@ function buildVehicleModel(kit, c, options = {}) {
     }
   }
   void has;
+  for (const part of parts) {
+    const fluid = PART_FLUIDS[part.role];
+    if (fluid && !part.contains && !(kind === "bike" && part.role === "steering")) part.contains = { ...fluid };
+  }
   return { parts, joints, hub: hubId, hitch };
 }
 
+// src/destructible/subdivide-near.ts
+var SUBDIVIDE_DEPTH = 12;
+function subdivideNear(THREE, params) {
+  const { mesh, maxLen, near } = params;
+  const src = mesh.geometry.index ? mesh.geometry.toNonIndexed() : mesh.geometry;
+  const a = src.attributes.position.array;
+  const toWorld = mesh.matrixWorld;
+  const out = [];
+  const mid = (p, q) => [(p[0] + q[0]) / 2, (p[1] + q[1]) / 2, (p[2] + q[2]) / 2];
+  const split = (A, B, C, depth) => {
+    const ab = Math.hypot(A[0] - B[0], A[1] - B[1], A[2] - B[2]);
+    const bc = Math.hypot(B[0] - C[0], B[1] - C[1], B[2] - C[2]);
+    const ca = Math.hypot(C[0] - A[0], C[1] - A[1], C[2] - A[2]);
+    const longest = Math.max(ab, bc, ca);
+    if (longest <= maxLen || depth > SUBDIVIDE_DEPTH) {
+      out.push(...A, ...B, ...C);
+      return;
+    }
+    if (longest === ab) {
+      const D = mid(A, B);
+      split(A, D, C, depth + 1);
+      split(D, B, C, depth + 1);
+    } else if (longest === bc) {
+      const E = mid(B, C);
+      split(A, B, E, depth + 1);
+      split(A, E, C, depth + 1);
+    } else {
+      const F = mid(C, A);
+      split(A, B, F, depth + 1);
+      split(F, B, C, depth + 1);
+    }
+  };
+  for (let i = 0; i < a.length; i += 9) {
+    const A = [a[i], a[i + 1], a[i + 2]];
+    const B = [a[i + 3], a[i + 4], a[i + 5]];
+    const C = [a[i + 6], a[i + 7], a[i + 8]];
+    const corners = [A, B, C].map((p) => new THREE.Vector3(p[0], p[1], p[2]).applyMatrix4(toWorld));
+    if (near(corners)) split(A, B, C, 0);
+    else out.push(...A, ...B, ...C);
+  }
+  const g = new THREE.BufferGeometry();
+  g.setAttribute("position", new THREE.Float32BufferAttribute(out, 3));
+  mesh.geometry.dispose();
+  mesh.geometry = g;
+}
+
 // src/destructible/visual.ts
 var HOLE_DECAL_SCALE = 2.4;
 var DOOR_DEPTH = 0.07;
-var DOOR_EDGE_PIECES = 16;
+var DOOR_EDGE_PIECES = 8;
+var DOOR_EDGE_REACH = 0.08;
 var DOOR_CARD_COLOR = "#3b3e42";
 var DOOR_LINER_COLOR = "#5a5e64";
 var DOOR_LINER_DARK = 0.15;
-var DOOR_STRIP_THIN = 0.05;
+var DOOR_STRIP_THIN = 0.08;
 var DOOR_STRIP_NEAR = 0.04;
+var DOOR_STRIP_TALL = 0.22;
+var STRIP_SMOOTH_DEG = 180;
+var DOOR_STRIP_VERTICES = 2e4;
+var DOOR_SILL = 0.25;
 var DOOR_STRIP_OVER = 0.3;
 var DOOR_TOP_OVER_PANE = 0.03;
-var DOOR_STRIP_SUB = 0.02;
 var HOLE_TEXTURE_SIZE = 64;
+var LAMINATED_HP = 1e3;
+var HOOD_SINK = 2e-3;
+var HOOD_GAP_CLOSED = 0.016;
 var DOOR_HANDLE_INSET = 0.12;
 var DOOR_HANDLE_MIN = 0.07;
 var DOOR_HANDLE_MAX = 0.24;
 var DOOR_HANDLE_THIN = 0.07;
-var DOOR_HANDLE_OUTSIDE = 0.1;
+var DOOR_HANDLE_OUTSIDE = 0.15;
 var PANE_SEAT_OUT = 0.05;
 var PANE_SEAT_IN = -0.05;
 var PANE_SEAT_REACH = 0.14;
 var PANE_SEAT_SAMPLES = 24;
 var PANE_SEAT_LIFT = 4e-3;
 var PANE_FRAME_NEAR = 0.07;
+var PANE_MIN_SLOPE = 0.01;
+var PANE_EDGE_BAND = 0.03;
+var PANE_REACH_STEP = 0.01;
+var PANE_REACH_MAX = 0.25;
+var COWL_UNDER_GLASS = 0;
+var COWL_NEAR_PANE = 0.08;
+var COWL_PLATE = 0.06;
+var COWL_DASH = 0.5;
+var COWL_DEEP = 0.3;
+var WINDOW_FRAME_NEAR = 0.06;
+var WINDOW_FRAME_SPAN = 0.6;
+var DASHBOARD_COLOR = "#121314";
+var COWL_CUT_SUB = 0.1;
+var COWL_CUT_MARGIN = 0.08;
+var SKIN_UNDER_PANE = 0.025;
+var SKIN_EDGE_KEPT = 0.06;
+var SIDE_PANE_FACING = 0.6;
+var COWL_LONG = 0.8;
+var PANE_BAR_VERTICES = 48;
+var PANE_BAR_LENGTH = 0.3;
+var PANE_BORDER = 0.03;
+var PANE_BORDER_LIFT = 3e-3;
 var DRAWN_MIRROR_SIZE = 0.3;
 var DRAWN_MIRROR_REACH = 0.4;
 var DRAWN_MIRROR_MOUNT = 0.2;
 var MIRROR_GLASS_FIT = 0.76;
+var MIRROR_GLASS_PROUD = 1e-3;
+var MIRROR_FACE_DEPTH = 0.012;
 var MIRROR_GLASS_THIN = 0.04;
+var DEFAULT_WHEEL_RADIUS = 0.3;
+var SIDEWALL_SHARE = 0.3;
 var MIRROR_GLASS_MIN = 0.05;
 var MIRROR_GLASS_COLOR = "#59636a";
 var HOLE_RIM = { steel: "#b7bcc0", aluminium: "#d3d6d8", plastic: "#d9d6cc", rubber: "#141414", glass: "#eef3f5" };
@@ -11683,6 +11799,7 @@ var VehicleVisuals = class {
     this.hood = this.nameHood();
     this.seatPanes();
     this.seatDoorHandles();
+    this.seatHood();
     this.warming = c.deform.filter((msh) => msh.geometry && msh.geometry.attributes.position && msh.geometry.attributes.position.count >= 1500);
     if (!this.warming.length) this.warming = null;
     for (const p of model.parts) {
@@ -11883,7 +12000,8 @@ var VehicleVisuals = class {
           const panes = I.windowsOver(this.c, z, inv);
           const seals = panes.map((g) => I.paneSeals.get(g)).filter((s) => !!s);
           const mirrors = this.mirrorsOn(z);
-          objs = [...pcs, ...this.doorCards(pcs, z), ...I.followersIn(this.c, z, inv), ...panes, ...seals, ...mirrors];
+          const frames = this.framesAround(panes, inv);
+          objs = [...pcs, ...I.followersIn(this.c, z, inv), ...panes, ...seals, ...mirrors, ...frames];
         }
       } else {
         const pcs = this.cutZone(z);
@@ -11928,7 +12046,10 @@ var VehicleVisuals = class {
     run(x1, y0, x1, y1);
     run(x1, y1, x0, y1);
     run(x0, y1, x0, y0);
-    const heights = loop.map(([x, y]) => this.surface("z", side2, B, [[x, y]]) ?? flat);
+    const heights = loop.map(([x, y]) => {
+      const at = this.surface("z", side2, B, [[x, y]]);
+      return at != null && Math.abs(at - flat) < DOOR_EDGE_REACH ? at : flat;
+    });
     const band = (lift) => {
       const position = [];
       const index = [];
@@ -11946,6 +12067,23 @@ var VehicleVisuals = class {
     };
     const paint = this.paint().clone();
     paint.side = THREE.DoubleSide;
+    const cardPosition = [];
+    const mid = loop.reduce((acc, [x, y], i) => [acc[0] + x, acc[1] + y, acc[2] + heights[i]], [0, 0, 0]).map((v) => v / loop.length);
+    const cardZ = (z2) => z2 - side2 * DOOR_DEPTH;
+    loop.forEach(([x, y], i) => {
+      const j = (i + 1) % loop.length;
+      cardPosition.push(mid[0], mid[1], cardZ(mid[2]), x, y, cardZ(heights[i]), loop[j][0], loop[j][1], cardZ(heights[j]));
+    });
+    const cardGeometry = new THREE.BufferGeometry();
+    cardGeometry.setAttribute("position", new THREE.Float32BufferAttribute(cardPosition, 3));
+    cardGeometry.computeVertexNormals();
+    const cardMaterial = this.I.makeMaterial(DOOR_CARD_COLOR, { roughness: 0.85 }).clone();
+    cardMaterial.side = THREE.DoubleSide;
+    const card = new THREE.Mesh(cardGeometry, cardMaterial);
+    card.userData.noFollow = true;
+    card.castShadow = false;
+    this.c.vehicle.add(card);
+    piv.attach(card);
     const edges = new THREE.Mesh(band(2e-3), paint);
     const lining = new THREE.Mesh(band(2e-3), paint);
     for (const m of [edges, lining]) {
@@ -11955,6 +12093,17 @@ var VehicleVisuals = class {
     }
     piv.attach(edges);
   }
+  /** The frame the model draws round a door's window (a dark strip over the glass) goes with the door: left behind it hangs in the air over the opening. */
+  framesAround(panes, inv) {
+    const THREE = this.THREE;
+    const boxes = panes.map((g) => this.I.localBox(this.c, g, inv).expandByScalar(WINDOW_FRAME_NEAR));
+    return this.c.vehicle.children.filter((o) => {
+      if (!o.isMesh || !o.visible || o.userData.glass || o.userData.decal || this.c.deform?.includes(o)) return false;
+      const box = this.I.localBox(this.c, o, inv);
+      if (box.isEmpty()) return false;
+      return boxes.some((b) => b.containsBox(box) && box.getSize(new THREE.Vector3()).x > b.getSize(new THREE.Vector3()).x * WINDOW_FRAME_SPAN);
+    });
+  }
   /** A front door carries the mirror drawn at its corner. */
   mirrorsOn(z) {
     if (!z.mirror) return [];
@@ -11980,45 +12129,42 @@ var VehicleVisuals = class {
     const B = z.box;
     const x0 = B.x0 + 0.03;
     const x1 = B.x1 - 0.03;
-    const y0 = B.y0 - DOOR_STRIP_NEAR;
-    const y1 = B.y1 + DOOR_STRIP_NEAR;
+    const y0 = B.y0 + DOOR_SILL;
+    const glassTop = (I) => {
+      let top = -Infinity;
+      for (const g of I.windowsOver(this.c, z, inv)) top = Math.max(top, I.localBox(this.c, g, inv).max.y);
+      return top;
+    };
+    const y1 = Math.max(B.y1, glassTop(this.I)) + DOOR_STRIP_NEAR;
     const deform = this.c.deform ?? [];
     for (const o of [...this.c.vehicle.children]) {
-      if (!o.isMesh || o === piv || deform.includes(o) || o.userData.glass || o.userData.decal || !o.visible) continue;
+      if (!o.isMesh || o === piv || o.userData.glass || o.userData.decal || !o.visible || deform.includes(o) && o.geometry.attributes.position.count > DOOR_STRIP_VERTICES) continue;
       const box = this.I.localBox(this.c, o, inv);
       const size = box.getSize(new THREE.Vector3());
       const mid = box.getCenter(new THREE.Vector3());
-      if (Math.sign(mid.z) !== Math.sign(z.side) || size.z > DOOR_STRIP_THIN || size.y > DOOR_STRIP_THIN || Math.min(box.max.x, x1) - Math.max(box.min.x, x0) < (x1 - x0) * DOOR_STRIP_OVER || mid.y < y0 || mid.y > y1) continue;
+      if (Math.sign(mid.z) !== Math.sign(z.side) || size.z > DOOR_STRIP_THIN || size.y > DOOR_STRIP_TALL || Math.min(box.max.x, x1) - Math.max(box.min.x, x0) < (x1 - x0) * DOOR_STRIP_OVER || mid.y < y0 || mid.y > y1) continue;
       const toVehicle = new THREE.Matrix4().multiplyMatrices(inv, o.matrixWorld);
       const v = new THREE.Vector3();
       const sdf = (x, y, zz) => {
         v.set(x, y, zz).applyMatrix4(toVehicle);
         return Math.max(x0 - v.x, v.x - x1);
       };
-      this.kit.cutMesh(o, [{ sdf }], 42, { sub: DOOR_STRIP_SUB });
-      const from = Math.max(box.min.x, x0);
-      const to = Math.min(box.max.x, x1);
-      const piece = this.box(to - from, size.y, size.z, o.material, (from + to) / 2, mid.y, mid.z);
-      piece.userData.noFollow = true;
-      piv.attach(piece);
-    }
-  }
-  /** The inside of a door: its skin brought in by the depth of the door, in the trim's dark plastic, so the open door is a door and not one sheet of paint. */
-  doorCards(skins, z) {
-    const cardMaterial = this.I.makeMaterial(DOOR_CARD_COLOR, { roughness: 0.8 });
-    return skins.map((skin) => {
-      const card = new this.THREE.Mesh(skin.geometry, cardMaterial);
-      card.position.copy(skin.position);
-      card.quaternion.copy(skin.quaternion);
-      card.scale.copy(skin.scale);
-      const side2 = z.side < 0 ? -1 : 1;
-      const inward = -side2 * DOOR_DEPTH;
-      card.position.z += inward;
-      card.userData.noFollow = true;
-      card.castShadow = false;
-      this.c.vehicle.add(card);
-      return card;
-    });
+      const over = new THREE.Mesh(o.geometry.clone(), o.material);
+      over.position.copy(o.position);
+      over.quaternion.copy(o.quaternion);
+      over.scale.copy(o.scale);
+      this.c.vehicle.add(over);
+      over.updateMatrixWorld(true);
+      const overToVehicle = new THREE.Matrix4().multiplyMatrices(inv, over.matrixWorld);
+      const w = new THREE.Vector3();
+      this.kit.cutMesh(over, [{ sdf: (x, y, zz) => {
+        w.set(x, y, zz).applyMatrix4(overToVehicle);
+        return -Math.max(x0 - w.x, w.x - x1);
+      } }], STRIP_SMOOTH_DEG, {});
+      this.kit.cutMesh(o, [{ sdf }], STRIP_SMOOTH_DEG, {});
+      over.userData.noFollow = true;
+      piv.attach(over);
+    }
   }
   mend(dirty) {
     dirty.forEach((msh) => {
@@ -12043,14 +12189,58 @@ var VehicleVisuals = class {
     ray.layers.enableAll();
     for (const pane of c.glass) {
       if (pane.userData.glass?.outline) continue;
-      const seat = this.paneSeat(pane, shell, ray);
+      const local = this.shellAround(pane, shell);
+      if (!local) continue;
+      const seat = this.paneSeat(pane, [local], ray);
       if (!seat) continue;
       const near = c.vehicle.children.filter((o) => o.isMesh && o !== pane && !o.userData.glass && !shell.includes(o) && this.onPane(o, pane, seat));
       for (const m of [pane, ...near]) this.movePane(m, seat);
-      const past = this.shellPast(pane, shell, ray, seat.normal);
+      const past = this.shellPast(pane, [local], ray, seat.normal);
       if (past > 0) for (const m of [pane, ...near]) this.movePane(m, { normal: seat.normal, samples: [{ at: seat.samples[0].at, by: past }] });
+      this.reachShellBelow(pane, local, ray, seat.normal);
+      this.paneBorder(pane, near, seat);
+      this.keepUnderPane(pane, seat.normal);
+      const across = new this.THREE.Vector3(0, 0, 1).transformDirection(this.c.vehicle.matrixWorld);
+      if (Math.abs(seat.normal.dot(across)) < SIDE_PANE_FACING) {
+        for (const body of shell) if (body.parent === this.c.vehicle) this.cutUnderPane(body, pane, seat.normal, SKIN_UNDER_PANE, SKIN_EDGE_KEPT);
+      }
     }
   }
+  /** Only the triangles of the shell around a pane, in world space: seating casts many rays and the whole hull has too many triangles for each. */
+  shellAround(pane, shell) {
+    const THREE = this.THREE;
+    const box = new THREE.Box3().setFromObject(pane).expandByScalar(PANE_SEAT_REACH + PANE_SEAT_OUT);
+    const out = [];
+    const a = new THREE.Vector3();
+    const b = new THREE.Vector3();
+    const d = new THREE.Vector3();
+    const tri = new THREE.Box3();
+    for (const mesh of shell) {
+      const pos = mesh.geometry.attributes.position;
+      const idx = mesh.geometry.index;
+      const count = idx ? idx.count : pos.count;
+      const e = mesh.matrixWorld.elements;
+      const world = (v, i) => {
+        const x = pos.getX(i);
+        const y = pos.getY(i);
+        const z = pos.getZ(i);
+        v.set(e[0] * x + e[4] * y + e[8] * z + e[12], e[1] * x + e[5] * y + e[9] * z + e[13], e[2] * x + e[6] * y + e[10] * z + e[14]);
+      };
+      for (let f = 0; f + 2 < count; f += 3) {
+        world(a, idx ? idx.getX(f) : f);
+        world(b, idx ? idx.getX(f + 1) : f + 1);
+        world(d, idx ? idx.getX(f + 2) : f + 2);
+        tri.makeEmpty().expandByPoint(a).expandByPoint(b).expandByPoint(d);
+        if (tri.intersectsBox(box)) out.push(a.x, a.y, a.z, b.x, b.y, b.z, d.x, d.y, d.z);
+      }
+    }
+    if (!out.length) return null;
+    const g = new THREE.BufferGeometry();
+    g.setAttribute("position", new THREE.Float32BufferAttribute(out, 3));
+    const proxy = new THREE.Mesh(g, new THREE.MeshBasicMaterial({ side: THREE.DoubleSide }));
+    proxy.updateMatrixWorld(true);
+    return proxy;
+  }
   /** The outward normal of a pane and how far the shell is at each sampled point (world). */
   paneSeat(pane, shell, ray) {
     const THREE = this.THREE;
@@ -12097,6 +12287,193 @@ var VehicleVisuals = class {
     }
     return samples.length >= 3 ? { normal, samples } : null;
   }
+  /** The lower edge of a pane comes down to the shell: left short, the dashboard shows through the slit as a black bar under the glass. */
+  reachShellBelow(pane, shell, ray, normal) {
+    const THREE = this.THREE;
+    const down = new THREE.Vector3(0, -1, 0).applyQuaternion(this.c.root.getWorldQuaternion(new THREE.Quaternion()));
+    down.addScaledVector(normal, -down.dot(normal));
+    if (down.lengthSq() < PANE_MIN_SLOPE) return;
+    down.normalize();
+    const g = pane.geometry;
+    const pos = g.attributes.position;
+    const v = new THREE.Vector3();
+    let lowest = -Infinity;
+    for (let i = 0; i < pos.count; i++) lowest = Math.max(lowest, v.fromBufferAttribute(pos, i).applyMatrix4(pane.matrixWorld).dot(down));
+    const edge = [];
+    const mid = new THREE.Vector3();
+    for (let i = 0; i < pos.count; i++) {
+      v.fromBufferAttribute(pos, i).applyMatrix4(pane.matrixWorld);
+      if (v.dot(down) > lowest - PANE_EDGE_BAND) {
+        edge.push(i);
+        mid.add(v);
+      }
+    }
+    if (!edge.length) return;
+    mid.divideScalar(edge.length);
+    let reach = 0;
+    for (let d = PANE_REACH_STEP; d <= PANE_REACH_MAX; d += PANE_REACH_STEP) {
+      const at = mid.clone().addScaledVector(down, d).addScaledVector(normal, PANE_SEAT_REACH);
+      ray.set(at, normal.clone().negate());
+      ray.far = PANE_SEAT_REACH * 2;
+      if (ray.intersectObject(shell, false)[0]) {
+        reach = d + PANE_REACH_STEP;
+        break;
+      }
+    }
+    if (!reach) return;
+    const inverse = pane.matrixWorld.clone().invert();
+    for (const i of edge) {
+      v.fromBufferAttribute(pos, i).applyMatrix4(pane.matrixWorld).addScaledVector(down, reach).applyMatrix4(inverse);
+      pos.setXYZ(i, v.x, v.y, v.z);
+    }
+    pos.needsUpdate = true;
+    g.computeBoundingBox();
+    g.computeBoundingSphere();
+  }
+  /** The plate drawn right under a windshield stays only outside the glass, in the body's paint: under the glass it would show inside the cabin. */
+  keepUnderPane(pane, normal) {
+    const THREE = this.THREE;
+    const paneBox2 = new THREE.Box3().setFromObject(pane).expandByScalar(COWL_NEAR_PANE);
+    const pos = pane.geometry.attributes.position;
+    const centre = new THREE.Vector3();
+    const v = new THREE.Vector3();
+    for (let i = 0; i < pos.count; i++) centre.add(v.fromBufferAttribute(pos, i).applyMatrix4(pane.matrixWorld));
+    centre.divideScalar(pos.count);
+    const plane = centre.dot(normal);
+    for (const o of this.c.vehicle.children) {
+      if (!o.isMesh || o === pane || o.userData.glass || this.c.deform?.includes(o)) continue;
+      const box = new THREE.Box3().setFromObject(o);
+      const size = box.getSize(new THREE.Vector3());
+      if (o.geometry.attributes.position.count <= PANE_BAR_VERTICES || size.y > COWL_DASH || Math.max(size.x, size.z) < COWL_LONG || Math.min(size.x, size.z) < COWL_DEEP || !paneBox2.intersectsBox(box)) continue;
+      if (box.getCenter(new THREE.Vector3()).dot(normal) - plane >= COWL_UNDER_GLASS) continue;
+      if (size.y >= COWL_PLATE) {
+        o.material = this.I.makeMaterial(DASHBOARD_COLOR, { roughness: 1, metalness: 0 });
+        continue;
+      }
+      o.material = this.paint();
+      this.cutUnderPane(o, pane, normal);
+    }
+  }
+  /** Cuts away the part of a mesh that lies under a pane (behind its plane, inside its outline seen along its normal). */
+  cutUnderPane(mesh, pane, normal, behind = -Infinity, inset = 0) {
+    const THREE = this.THREE;
+    const outline = this.paneOutline(pane, normal);
+    if (outline.length < 3) return;
+    const u = new THREE.Vector3(0, 1, 0).cross(normal);
+    if (u.lengthSq() < 1e-4) u.set(1, 0, 0);
+    u.normalize();
+    const w = normal.clone().cross(u);
+    const cx = outline.reduce((sum, p) => sum + p.dot(u), 0) / outline.length;
+    const cy = outline.reduce((sum, p) => sum + p.dot(w), 0) / outline.length;
+    const poly = outline.map((p) => {
+      const x = p.dot(u);
+      const y = p.dot(w);
+      const d = Math.hypot(x - cx, y - cy) || 1;
+      const k = Math.max(0, d - inset) / d;
+      return [cx + (x - cx) * k, cy + (y - cy) * k];
+    });
+    const plane = outline.reduce((sum, p) => sum + p.dot(normal), 0) / outline.length;
+    const inside = (x, y) => {
+      let hit = false;
+      for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+        const [xi, yi] = poly[i];
+        const [xj, yj] = poly[j];
+        if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) hit = !hit;
+      }
+      return hit;
+    };
+    const v = new THREE.Vector3();
+    const toWorld = mesh.matrixWorld;
+    mesh.updateMatrixWorld(true);
+    const xs = poly.map((p) => p[0]);
+    const ys = poly.map((p) => p[1]);
+    const [x0, x1, y0, y1] = [Math.min(...xs) - COWL_CUT_MARGIN, Math.max(...xs) + COWL_CUT_MARGIN, Math.min(...ys) - COWL_CUT_MARGIN, Math.max(...ys) + COWL_CUT_MARGIN];
+    subdivideNear(THREE, { mesh, maxLen: COWL_CUT_SUB, near: (corners) => {
+      const us = corners.map((c) => c.dot(u));
+      const ws = corners.map((c) => c.dot(w));
+      return Math.max(...us) >= x0 && Math.min(...us) <= x1 && Math.max(...ws) >= y0 && Math.min(...ws) <= y1;
+    } });
+    this.kit.cutMesh(
+      mesh,
+      [
+        {
+          sdf: (x, y, z) => {
+            v.set(x, y, z).applyMatrix4(toWorld);
+            return inside(v.dot(u), v.dot(w)) && plane - v.dot(normal) > behind ? -1 : 1;
+          }
+        }
+      ],
+      42,
+      {}
+    );
+  }
+  /** The straight bars drawn round a quad pane stand off its edges: they give way to a thin dark band that lies on the glass, as on a bonded windshield. */
+  paneBorder(pane, near, seat) {
+    const THREE = this.THREE;
+    const bars = near.filter((o) => {
+      if (o.geometry.attributes.position.count > PANE_BAR_VERTICES) return false;
+      const size = new THREE.Box3().setFromObject(o).getSize(new THREE.Vector3());
+      return Math.max(size.x, size.y, size.z) > PANE_BAR_LENGTH;
+    });
+    if (!bars.length) return;
+    const outline = this.paneOutline(pane, seat.normal);
+    if (outline.length < 3) return;
+    const centre = new THREE.Vector3();
+    for (const p of outline) centre.add(p);
+    centre.divideScalar(outline.length);
+    const position = [];
+    const toVehicle = this.I.worldInverseOf(this.c);
+    const put = (p) => {
+      const q = p.clone().addScaledVector(seat.normal, PANE_BORDER_LIFT).applyMatrix4(toVehicle);
+      position.push(q.x, q.y, q.z);
+    };
+    const inward = (p) => p.clone().add(centre.clone().sub(p).normalize().multiplyScalar(PANE_BORDER));
+    outline.forEach((a, i) => {
+      const b = outline[(i + 1) % outline.length];
+      const c = inward(b);
+      const d = inward(a);
+      for (const p of [a, b, c, a, c, d]) put(p);
+    });
+    if (!position.length) return;
+    for (const o of bars) o.visible = false;
+    const band = new THREE.BufferGeometry();
+    band.setAttribute("position", new THREE.Float32BufferAttribute(position, 3));
+    band.computeVertexNormals();
+    const material = this.I.MATERIALS.dark.clone();
+    material.side = THREE.DoubleSide;
+    const mesh = new THREE.Mesh(band, material);
+    mesh.userData.noFollow = true;
+    mesh.castShadow = false;
+    mesh.raycast = () => {
+    };
+    this.c.vehicle.add(mesh);
+  }
+  /** The outline of a pane, the convex hull of its vertices seen along its normal, in world space. */
+  paneOutline(pane, normal) {
+    const THREE = this.THREE;
+    const pos = pane.geometry.attributes.position;
+    const u = new THREE.Vector3(0, 1, 0).cross(normal);
+    if (u.lengthSq() < 1e-4) u.set(1, 0, 0);
+    u.normalize();
+    const w = normal.clone().cross(u);
+    const points = [];
+    for (let i = 0; i < pos.count; i++) {
+      const p = new THREE.Vector3().fromBufferAttribute(pos, i).applyMatrix4(pane.matrixWorld);
+      points.push({ x: p.dot(u), y: p.dot(w), p });
+    }
+    points.sort((a, b) => a.x - b.x || a.y - b.y);
+    const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+    const half = (list) => {
+      const out = [];
+      for (const q of list) {
+        while (out.length >= 2 && cross(out[out.length - 2], out[out.length - 1], q) <= 0) out.pop();
+        out.push(q);
+      }
+      out.pop();
+      return out;
+    };
+    return [...half(points), ...half([...points].reverse())].map((q) => q.p);
+  }
   /** How far the shell still stands past a seated pane, over its triangles. */
   shellPast(pane, shell, ray, normal) {
     const THREE = this.THREE;
@@ -12149,11 +12526,25 @@ var VehicleVisuals = class {
     g.computeBoundingSphere();
     mesh.geometry = g;
   }
+  /** A closed hood is flush with the fenders beside it: the height it was drawn with to keep clear of the hull goes, the hull has its hole. */
+  seatHood() {
+    const hood = this.c.hood;
+    if (!hood?.lift) return;
+    const THREE = this.THREE;
+    const box = new THREE.Box3().setFromObject(hood.piv).getSize(new THREE.Vector3());
+    for (const part of hood.piv.children) {
+      part.position.y -= hood.lift + HOOD_SINK;
+      part.scale.multiply(new THREE.Vector3(1 + HOOD_GAP_CLOSED / Math.max(0.3, box.x), 1, 1 + HOOD_GAP_CLOSED / Math.max(0.3, box.z)));
+    }
+  }
   /** A handle is at the free edge of its door, the end away from the hinge. */
   seatDoorHandles() {
     const THREE = this.THREE;
     const c = this.c;
     const inv = this.I.worldInverseOf(c);
+    const bodyBox = new THREE.Box3();
+    for (const o of c.deform) if (o.isMesh && !o.userData.glass && c.paints?.has(o.material)) bodyBox.union(this.I.localBox(c, o, inv));
+    const outerHalf = Math.max(Math.abs(bodyBox.min.z), Math.abs(bodyBox.max.z));
     for (const p of this.model.parts) {
       if (p.role !== "door") continue;
       const z = this.zone(p);
@@ -12167,8 +12558,7 @@ var VehicleVisuals = class {
         const at = box.getCenter(new THREE.Vector3());
         const isHandle = size.x > DOOR_HANDLE_MIN && size.x < DOOR_HANDLE_MAX && size.y < DOOR_HANDLE_THIN && size.z < DOOR_HANDLE_THIN;
         if (!isHandle || Math.sign(at.z) !== Math.sign(z.side) || at.x < B.x0 || at.x > B.x1 || at.y < B.y0 || at.y > B.y1) continue;
-        const here = this.surface("z", z.side < 0 ? -1 : 1, B, [[at.x, at.y]]);
-        if (here != null && Math.abs(here - at.z) > DOOR_HANDLE_OUTSIDE) continue;
+        if (Math.abs(at.z) < outerHalf - DOOR_HANDLE_OUTSIDE) continue;
         const skin = this.surface("z", z.side < 0 ? -1 : 1, B, [[free, at.y]]);
         o.position.x += free - at.x;
         if (skin != null) o.position.z += skin + (z.side < 0 ? -1 : 1) * (size.z / 2) - at.z;
@@ -12177,7 +12567,7 @@ var VehicleVisuals = class {
     c.root.updateMatrixWorld(true);
   }
   /** The glass of a drawn mirror sits inside its rounded housing, without corners standing past it. */
-  seatMirrorGlass(glass) {
+  seatMirrorGlass(glass, drawn) {
     const g = glass.geometry.clone();
     g.computeBoundingBox();
     const mid = g.boundingBox.getCenter(new this.THREE.Vector3());
@@ -12185,6 +12575,37 @@ var VehicleVisuals = class {
     g.scale(MIRROR_GLASS_FIT, MIRROR_GLASS_FIT, MIRROR_GLASS_FIT);
     g.translate(mid.x, mid.y, mid.z);
     glass.geometry = g;
+    const THREE = this.THREE;
+    const volumeOf = (o) => {
+      const size = new THREE.Box3().setFromObject(o).getSize(new THREE.Vector3());
+      return size.x * size.y * size.z;
+    };
+    const housing = drawn.filter((o) => o !== glass && o.isMesh && o.geometry).sort((a, b) => volumeOf(b) - volumeOf(a))[0];
+    if (housing) {
+      this.c.root.updateMatrixWorld(true);
+      const inv = this.I.worldInverseOf(this.c);
+      glass.updateMatrixWorld(true);
+      const gb = this.I.localBox(this.c, glass, inv);
+      const hb = this.I.localBox(this.c, housing, inv);
+      const side2 = hb.getCenter(new THREE.Vector3()).x > gb.getCenter(new THREE.Vector3()).x ? -1 : 1;
+      const face = side2 < 0 ? hb.min.x + MIRROR_FACE_DEPTH : hb.max.x - MIRROR_FACE_DEPTH;
+      const shape = housing.geometry.clone();
+      const pos = shape.attributes.position;
+      const toVehicle = new THREE.Matrix4().multiplyMatrices(inv, housing.matrixWorld);
+      const back = toVehicle.clone().invert();
+      const v = new THREE.Vector3();
+      for (let i = 0; i < pos.count; i++) {
+        v.fromBufferAttribute(pos, i).applyMatrix4(toVehicle);
+        if ((v.x - face) * side2 <= 0) continue;
+        v.x = face;
+        v.applyMatrix4(back);
+        pos.setXYZ(i, v.x, v.y, v.z);
+      }
+      shape.computeVertexNormals();
+      housing.geometry = shape;
+      const outer = side2 < 0 ? gb.min.x : gb.max.x;
+      glass.position.x += face + side2 * MIRROR_GLASS_PROUD - outer;
+    }
     glass.material = this.I.makeMaterial(MIRROR_GLASS_COLOR, { metalness: 0.95, roughness: 0.12 });
   }
   /** The mirror the model already draws around where the part says, if it draws one. */
@@ -12209,7 +12630,11 @@ var VehicleVisuals = class {
       for (const o of drawn) {
         if (!o.isMesh || o.material !== this.I.MATERIALS.chrome) continue;
         const size = new this.THREE.Box3().setFromObject(o).getSize(new this.THREE.Vector3());
-        if (size.x < MIRROR_GLASS_THIN && size.y > MIRROR_GLASS_MIN && size.z > MIRROR_GLASS_MIN) this.seatMirrorGlass(o);
+        const [thin, mid] = size.toArray().sort((a, b) => a - b);
+        if (thin < MIRROR_GLASS_THIN && mid > MIRROR_GLASS_MIN) {
+          this.seatMirrorGlass(o, drawn);
+          o.userData.mirrorGlass = true;
+        }
       }
       this.extra.set(p.id, drawn);
       return;
@@ -12221,14 +12646,26 @@ var VehicleVisuals = class {
     g.name = `obj_${p.id}`;
     g.position.set(cx, cy, cz);
     this.c.vehicle.add(g);
-    this.box(0.05, 0.04, 0.1, mats.dark, 0, -0.04, -s * 0.07, g);
-    const housing = this.box(0.1, 0.12, 0.05, mats.plastic ?? mats.dark, 0, 0, s * 0.02, g);
+    this.box(0.05, 0.035, 0.05, mats.dark, 0, -0.04, -s * 0.06, g);
+    const housing = this.box(0.08, 0.11, 0.125, mats.plastic ?? mats.dark, 0, 0, s * 0.0225, g);
     housing.userData.mirrorHousing = true;
-    const glass = this.box(0.095, 0.1, 6e-3, mats.chrome ?? mats.dark, 0, 0, s * 0.048, g);
+    const glass = this.box(6e-3, 0.095, 0.115, mats.chrome ?? mats.dark, -0.043, 0, s * 0.0225, g);
     glass.userData.mirrorGlass = true;
     g.userData.rigid = true;
     this.extra.set(p.id, [g]);
   }
+  /** A round through the mirror shatters its glass: the shards drop out of the housing, which stays on with the hole. Returns whether there was glass to break. */
+  shatterMirror(id) {
+    let broke = false;
+    for (const o of this.extra.get(id) ?? []) {
+      o.traverse((m) => {
+        if (!m.userData.mirrorGlass || !m.visible) return;
+        m.visible = false;
+        broke = true;
+      });
+    }
+    return broke;
+  }
   makeBattery(p) {
     const mats = this.I.MATERIALS;
     const g = new this.THREE.Group();
@@ -12274,6 +12711,11 @@ var VehicleVisuals = class {
     if (carrier) carrier.attach(m);
   }
   /** The door or lid a hinge group stands for. */
+  /** The part a separately drawn piece stands for (a mirror on the door, a battery under the hood), so a shot at it lands on that part. */
+  extraIdOf(o) {
+    for (const [id, objs] of this.extra) if (objs.includes(o)) return id;
+    return void 0;
+  }
   plateIdOf(o) {
     return o.userData.plateOf;
   }
@@ -12330,6 +12772,7 @@ var VehicleVisuals = class {
         best = g;
       }
     }
+    if (p.hp > LAMINATED_HP && best.userData.glass) best.userData.glass.type = "laminated";
     this.kit.hitGlass(this.c, best, pt, new V3(...dir), force);
     return !!best.userData.glass?.broken;
   }
@@ -12351,6 +12794,17 @@ var VehicleVisuals = class {
     if (!z) return;
     for (const w of z.wheels) if (w.parent) this.I.flattenTire(w, k);
   }
+  /** A tyre driven flat until it tore apart: the rubber is gone and the bare rim shows. */
+  tyreTornOff(p) {
+    const z = this.zone(p);
+    if (!z) return;
+    for (const w of z.wheels) {
+      if (!w.parent || w.userData.tornOff) continue;
+      w.userData.tornOff = true;
+      for (const m of this.I.tireMeshes(w)) m.visible = false;
+      w.position.y -= (w.userData.r ?? DEFAULT_WHEEL_RADIUS) * SIDEWALL_SHARE;
+    }
+  }
   /** Burning rubber: the tyre sags and goes black as it melts. */
   tyreMelt(p, melt) {
     const z = this.zone(p);
@@ -12674,6 +13128,41 @@ var BLUNT = { steel: 0.8, aluminium: 1, glass: 1.5, plastic: 1.2, rubber: 0.3 };
 var SHIELDED = /* @__PURE__ */ new Set(["engine", "gearbox", "frame", "radiator", "fuel_tank", "oil_pan", "battery", "alternator", "brakes", "steering", "shocks"]);
 var AMBIENT = 20;
 var FLAME = 700;
+var STEEL_MM = { panel: 0.8, door: 1.6, hood: 0.8, lid: 0.8, roof: 0.8, fender: 0.8, pillar: 2, frame: 4, rim: 3, engine: 40, gearbox: 25, fuel_tank: 1, radiator: 1, battery: 2, brakes: 10, steering: 8, shocks: 6, oil_pan: 2, alternator: 4, hitch: 8, other: 2 };
+var ARMOUR_STEEL_MM = { IIIA: 4, III: 7 };
+var SOFT_LEAD = 0.8;
+var TYRE_FLAT_HEALTH = 0.1;
+var TYRE_BURST_JOULES = 1500;
+var TYRE_BURST_CALIBER = 12;
+var TYRE_LEAK_PER_MM2 = 26e-5;
+var FLAT_TYRE_LIFE_M = 1500;
+var FLAT_TYRE_TOWN_SPEED = 8;
+var RUN_FLAT_LIFE_M = 8e4;
+var RUN_FLAT_SPEED = 22;
+var TYRE_RUNFLAT_HEALTH = 0.6;
+var CRUMPLE_BASE_M = 0.04;
+var CRUMPLE_PER_FORCE_M = 0.15;
+var CRUMPLE_MIN_FORCE = 0.3;
+var CRUMPLE_MAX_FORCE = 1.4;
+var RIM_HEALTH = 0.05;
+var RIM_GRIND_PER_M = 4e-4;
+var TYRE_FLAT_SAG = 0.24;
+var TYRE_FLAT_AIR = 0.2;
+var BRAKE_FLUID_NEEDED = 0.6;
+var BRAKE_NO_FLUID = 0.15;
+var ENGINE_WORKING_C = 90;
+var ENGINE_SETTLE_S = 30;
+var ENGINE_HEATING = 0.5;
+var ENGINE_STEAM_C = 120;
+var ENGINE_SEIZE_C = 150;
+var COOLANT_NEEDED = 0.4;
+var OIL_NEEDED = 0.3;
+var OIL_WEAR = 4e-3;
+var ENGINE_SEIZE_HP = 0.2;
+var EXPANDED_HOLE = 1.6;
+var MIN_SPENT = 0.08;
+var WELDED = /* @__PURE__ */ new Set(["roof", "pillar", "frame", "panel"]);
+var CRUMPLES = /* @__PURE__ */ new Set(["door", "hood", "lid", "fender", "bumper"]);
 var FRACTURE = { glass: "shatter", plastic: "snap", rubber: "tear", steel: "none", aluminium: "none" };
 var add3 = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
 var r3 = (v) => [Math.round(v[0] * 1e5) / 1e5, Math.round(v[1] * 1e5) / 1e5, Math.round(v[2] * 1e5) / 1e5];
@@ -12685,6 +13174,8 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
   let c = vehicleCtx;
   const id = options.id ?? c.key;
   const headless = !!options.headless;
+  const armourId = armourLevelOf(c.meta, options.armour);
+  const armourLevel = armourId ? { ...ARMOUR_LEVELS[armourId], ...options.armourLevels?.[armourId] } : null;
   const seedBase = strHash(`${c.key}|${id}|${options.seed ?? 0}`);
   let rand = rng(seedBase);
   const ignitionRules = resolveIgnitionRules(options.ignition);
@@ -12742,7 +13233,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     return d.ignitionC ? 1 : 0;
   };
   const setup = () => {
-    model = buildVehicleModel(kit, c, { hitch: options.hitch });
+    model = buildVehicleModel(kit, c, { hitch: options.hitch, armour: armourLevel });
     ps.clear();
     for (const d of model.parts) {
       const kg = burnKg(d);
@@ -12762,6 +13253,8 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
         lost: false,
         status: "intact",
         flat: false,
+        air: 1,
+        airLoss: 0,
         fireLoss: 0
       });
     }
@@ -12862,7 +13355,8 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
           vis.breakLight(d, true);
           break;
         case "tyre":
-          vis.tyreFlat(d, 0.34);
+          if (status === "broken") vis.tyreTornOff(d);
+          else vis.tyreFlat(d, 0.34);
           break;
         case "mirror":
         case "bumper":
@@ -12892,7 +13386,8 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
   const damage = (p, amount, dtype, source, out, cause) => {
     if (p.lost || !(amount > 0)) return;
     const before = p.hp;
-    p.hp = Math.max(0, p.hp - amount);
+    const crumples = dtype === "blunt" && CRUMPLES.has(p.def.role) && (p.def.material === "steel" || p.def.material === "aluminium");
+    p.hp = Math.max(WELDED.has(p.def.role) || crumples ? 1 : 0, p.hp - amount);
     out.push(ev({ type: "damage", part: p.def.id, amount: r2(before - p.hp), hp: r2(p.hp), damageType: dtype, ...source ? { source } : {} }));
     wear(p, amount, out);
     syncZone(p);
@@ -12935,11 +13430,22 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     const p = v.clone().applyMatrix4(M);
     return [p.x, p.y, p.z];
   };
-  const armour = () => c.meta.armored || c.meta.bullet ? 30 : 1;
+  const armour = () => armourLevel?.steel ?? 1;
+  const steelMm = (d) => {
+    const base = STEEL_MM[d.role] ?? STEEL_MM.panel;
+    return d.material === "steel" || d.material === "aluminium" ? base * (armourLevel ? ARMOUR_STEEL_MM[armourId === "III" ? "III" : "IIIA"] / STEEL_MM.panel : 1) : base;
+  };
+  const goesThrough = (h, d, p, energy, res) => {
+    const piercing = h.piercing ?? 1;
+    const metal = d.material === "steel" || d.material === "aluminium";
+    const mm = h.penetration?.steel;
+    if (metal && mm != null) return mm >= steelMm(d) * (p.dents.length > 3 ? 0.9 : 1);
+    return energy * (metal || d.material === "glass" ? piercing : 1) >= res;
+  };
   const resist = (d, p) => {
     let base = RESIST[d.material] ?? 100;
     if (d.material === "glass" && d.hp > 1e3) base = 120;
-    if (d.material === "glass" && c.meta.bullet) base *= 30;
+    if (d.material === "glass" && armourLevel) base = armourLevel.glassStops;
     const k = ROLE_RESIST[d.role] ?? 1;
     const arm = d.material === "steel" || d.material === "aluminium" ? armour() : 1;
     return base * k * arm * (p.dents.length > 3 ? 0.9 : 1);
@@ -12962,7 +13468,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
       if (vis) {
         const pos = new V3(d.box.center[0], Math.max(0.2, (c.meta.clearance ?? 0.3) * 0.8), d.box.center[2]);
         if (fluid === "coolant") kit.addEmitter(c, new V3(d.box.center[0], d.box.center[1] + 0.2, d.box.center[2]), "white", { rate: 5, s: 0.8 });
-        else if ((c.meta.kind ?? "car") !== "boat") l.pud = I.puddle(c, fluidKind(fluid), pos, fluid === "oil" ? 0.8 : 1.1);
+        if ((c.meta.kind ?? "car") !== "boat") l.pud = I.puddle(c, fluidKind(fluid), pos, fluid === "oil" ? 0.8 : fluid === "brake_fluid" ? 0.4 : 1.1);
       }
     }
     const out3 = dirToWorld(new V3(dirLocal.x * 0.5, dirLocal.y * 0.5 - 0.6, dirLocal.z * 0.5));
@@ -12999,7 +13505,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     exploded = true;
     const d = tank.def;
     const spec = d.explodes ?? { energy: 8e5, radius: 5, atC: 320 };
-    out.push(ev({ type: "explode", part: d.id, point: toWorld(d.box.center), energy: spec.energy, radius: spec.radius }));
+    out.push(ev({ type: "explode", part: d.id, point: toWorld(d.box.center), energy: spec.energy, radius: spec.radius, ..."effect" in spec && spec.effect !== void 0 ? { effect: spec.effect } : {} }));
     tank.liters = 0;
     leaks.delete(d.id);
     if (vis) kit.explode(c, { delay: 0.6 });
@@ -13099,7 +13605,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     const dir = dirToLocal(h.direction ?? [0, 0, -1]).normalize();
     const n = h.normal ? dirToLocal(h.normal).normalize() : normalOf(d, v);
     const res = resist(d, p);
-    const through = E >= res;
+    const through = goesThrough(h, d, p, E, res);
     const cosInc = Math.abs(dir.dot(n));
     const metal = d.material === "steel" || d.material === "aluminium";
     const worldPoint = toWorld(v);
@@ -13110,13 +13616,21 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
       vis?.spark([v.x, v.y, v.z], [refl.x, refl.y, refl.z], 6);
       return;
     }
-    const holeDiam = Math.max(6e-3, cal / 1e3 * (d.material === "glass" ? 1.4 : 1));
+    const opens = (h.piercing ?? 1) < SOFT_LEAD ? EXPANDED_HOLE : 1;
+    const holeDiam = Math.max(6e-3, cal / 1e3 * (d.material === "glass" ? 1.4 : 1) * opens);
+    const energyLeft = () => {
+      const metal2 = d.material === "steel" || d.material === "aluminium";
+      const mm = h.penetration?.steel;
+      const spent = metal2 && mm ? clamp(steelMm(d) / mm, MIN_SPENT, 1) : clamp(res / Math.max(E, 1), MIN_SPENT, 1);
+      return E * (1 - spent);
+    };
     const push = (hole) => {
       if (!hole) return;
       const hp = { point: r3(fromVehicle(v, M)), normal: r3(fromVehicle(n, new THREE.Matrix4().extractRotation(M))), diameter: r2(holeDiam), through };
       p.holes.push(hp);
-      out.push(ev({ type: "hole", part: d.id, hole: hp, worldPoint, ...through ? { exitPoint: add3(worldPoint, r3(dirToWorld(dir.clone().multiplyScalar(Math.max(0.02, Math.min(d.box.size[0], d.box.size[1], d.box.size[2])))))) } : {} }));
+      out.push(ev({ type: "hole", part: d.id, hole: hp, worldPoint, ...through ? { energyLeft: r2(energyLeft()) } : {}, ...through ? { exitPoint: add3(worldPoint, r3(dirToWorld(dir.clone().multiplyScalar(Math.max(0.02, Math.min(d.box.size[0], d.box.size[1], d.box.size[2])))))) } : {} }));
       vis?.holeDecal([v.x, v.y, v.z], [n.x, n.y, n.z], holeDiam, d);
+      if (d.role === "mirror") vis?.shatterMirror(d.id);
       startLeak(p, v, cal, out, dir);
     };
     switch (d.material) {
@@ -13129,7 +13643,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
           const crack = { point: r3(fromVehicle(v, M)), normal: r3(fromVehicle(n, new THREE.Matrix4().extractRotation(M))), length: r2(0.15 + force * 0.35), rays: 6 + Math.round(force * 6) };
           p.cracks.push(crack);
           out.push(ev({ type: "crack", part: d.id, crack, worldPoint }));
-          damage(p, E * 0.5, "ballistic", h.source, out, worldPoint);
+          damage(p, E * (armourLevel && !through ? armourLevel.glassTakes : 0.5), "ballistic", h.source, out, worldPoint);
         } else damage(p, laminated ? E * 0.5 : p.hp, "ballistic", h.source, out, worldPoint);
         break;
       }
@@ -13137,8 +13651,8 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
         push(through);
         damage(p, E * 0.4, "ballistic", h.source, out, worldPoint);
         if (through && !p.lost && !p.flat) {
-          p.flat = true;
-          vis?.tyreFlat(d, 0.24);
+          if (E >= TYRE_BURST_JOULES || cal >= TYRE_BURST_CALIBER) deflate(p, 1);
+          else p.airLoss += TYRE_LEAK_PER_MM2 * Math.PI * (cal / 2) ** 2;
         }
         break;
       }
@@ -13254,7 +13768,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     const electric = c.spec.fuel === "electric";
     const tank = tankPart();
     const fuel = tank ? tank.liters ?? 0 : electric ? 1 : 1;
-    const engineOk = sound("engine") && !exploded && fuel > 0.05;
+    const engineOk = sound("engine") && !exploded && !seized && fuel > 0.05;
     const powered = sound("battery") && sound("alternator");
     const gearOk = sound("gearbox");
     const brakes = [...ps.values()].find((p) => p.def.role === "brakes");
@@ -13414,9 +13928,12 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
   const state = () => stateCache ?? (stateCache = buildState());
   const isSimulating = () => {
     if (leaks.size > 0) return true;
-    for (const p of ps.values()) if (!p.lost && (p.burning || p.temp > AMBIENT)) return true;
+    for (const p of ps.values()) if (!p.lost && (p.burning || p.temp > AMBIENT || p.airLoss > 0 && p.air > 0)) return true;
     return false;
   };
+  let engineHeat = ENGINE_WORKING_C;
+  let seized = false;
+  let steaming = false;
   const surfaceRays = new THREE.Raycaster();
   surfaceRays.layers.enableAll();
   surfaceRays.camera = new THREE.PerspectiveCamera();
@@ -13440,14 +13957,24 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     if (pane) return ps.get(pane) ?? null;
     for (let q = o; q && q !== c.vehicle; q = q.parent) {
       if (vis?.plateIdOf(q)) return ps.get(vis.plateIdOf(q)) ?? null;
+      const piece = vis?.extraIdOf(q);
+      if (piece) return ps.get(piece) ?? null;
     }
     return locate(v, 0.08, (p) => p.def.role === "glass");
   };
+  const surfaceMeshes = [];
+  const collectSurfaces = (o) => {
+    if (!o.visible || o.userData.decal || o.userData.ghost || o.userData.noSurfaceRay) return;
+    if (o.isMesh) surfaceMeshes.push(o);
+    for (const child of o.children) collectSurfaces(child);
+  };
   const surfaceRay = (ray) => {
     sync();
     surfaceRays.set(new V3(ray.origin[0], ray.origin[1], ray.origin[2]), new V3(ray.direction[0], ray.direction[1], ray.direction[2]));
     surfaceRays.far = ray.maxDistance;
-    for (const h of surfaceRays.intersectObject(c.vehicle, true)) {
+    surfaceMeshes.length = 0;
+    for (const child of c.vehicle.children) collectSurfaces(child);
+    for (const h of surfaceRays.intersectObjects(surfaceMeshes, false)) {
       if (!h.face || !isDrawnSurface(h.object)) continue;
       const p = partOfSurface(h.object, c.vehicle.worldToLocal(h.point.clone()));
       if (!p || p.lost || ray.ignored?.(p.def.id)) continue;
@@ -13481,7 +14008,29 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     applyEffects();
     return out;
   };
+  const runFlat = armourId != null;
+  const tyreHealth = (p) => {
+    if (p.lost) return RIM_HEALTH;
+    if (p.flat) return runFlat ? TYRE_RUNFLAT_HEALTH : TYRE_FLAT_HEALTH;
+    return Math.min(p.hp / p.def.hp, 0.2 + 0.8 * p.air);
+  };
+  const tyreOf = (rim) => {
+    let best;
+    let bestD = Infinity;
+    for (const p of ps.values()) {
+      if (p.def.role !== "tyre") continue;
+      const d = Math.hypot(p.def.box.center[0] - rim.def.box.center[0], p.def.box.center[2] - rim.def.box.center[2]);
+      if (d < bestD) [best, bestD] = [p, d];
+    }
+    return best;
+  };
+  const deflate = (p, share) => {
+    p.air = Math.max(0, p.air - share);
+    vis?.tyreFlat(p.def, TYRE_FLAT_SAG * (1 - p.air));
+    if (p.air <= TYRE_FLAT_AIR) p.flat = true;
+  };
   const update = (dt) => {
+    for (const p of ps.values()) if (p.airLoss > 0 && p.air > 0 && !p.lost) deflate(p, p.airLoss * dt);
     clock += dt;
     const out = queue;
     queue = [];
@@ -13597,6 +14146,70 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     partName: (pid) => ps.get(pid)?.def.name ?? pid,
     status: computeStatus,
     animations: () => createVehicleClips(model, vis, kit, c),
+    crumple: (point, direction, depth) => {
+      if (!vis || depth <= 0) return;
+      sync();
+      const force = clamp((depth - CRUMPLE_BASE_M) / CRUMPLE_PER_FORCE_M, CRUMPLE_MIN_FORCE, CRUMPLE_MAX_FORCE);
+      kit.impact(c, toLocal(point), dirToLocal(direction).normalize(), force, { maxDepth: depth });
+      stateCache = void 0;
+    },
+    rollFlat: (meters, speed) => {
+      for (const p of ps.values()) {
+        if (p.def.role !== "tyre" || !p.flat || p.lost) continue;
+        const life = runFlat ? RUN_FLAT_LIFE_M * Math.min(1, RUN_FLAT_SPEED / Math.max(speed, 1)) : FLAT_TYRE_LIFE_M * clamp(FLAT_TYRE_TOWN_SPEED / Math.max(speed, 1), 0.2, 1.5);
+        p.hp = Math.max(0, p.hp - p.def.hp * meters / life);
+        if (p.hp > 0) continue;
+        const at = toWorld(p.def.box.center);
+        lose(p, "broken", queue, at);
+        queue.push(ev({ type: "debris", part: p.def.id, kind: "fibers", point: at, normal: [0, 1, 0], count: 12, speed: Math.max(2, speed * 0.5) }));
+      }
+      let grinding = 0;
+      for (const rim of ps.values()) {
+        if (rim.def.role !== "rim" || rim.lost || !tyreOf(rim)?.lost) continue;
+        grinding += 1;
+        rim.hp = Math.max(1, rim.hp - rim.def.hp * RIM_GRIND_PER_M * meters);
+        const [x, y, z] = rim.def.box.center;
+        queue.push(ev({ type: "debris", part: rim.def.id, kind: "sparks", point: toWorld([x, y - rim.def.box.size[1] / 2, z]), normal: [0, 1, 0], count: Math.min(30, Math.ceil(4 + speed)), speed: Math.max(2, speed * 0.4) }));
+      }
+      stateCache = void 0;
+      return grinding;
+    },
+    runEngine: (seconds, load) => {
+      const engine = [...ps.values()].find((p) => p.def.role === "engine");
+      if (!engine || engine.lost || seized) return engineHeat;
+      const share = (fluid) => {
+        const list = [...ps.values()].filter((p) => p.def.contains?.fluid === fluid);
+        return list.length ? Math.min(...list.map((p) => (p.liters ?? 0) / p.def.contains.liters)) : 1;
+      };
+      const coolant = share("coolant");
+      const oil = share("oil");
+      const work = 0.4 + 0.6 * clamp(load, 0, 1);
+      if (coolant < COOLANT_NEEDED) engineHeat += (COOLANT_NEEDED - coolant) / COOLANT_NEEDED * ENGINE_HEATING * work * seconds;
+      else engineHeat += (ENGINE_WORKING_C - engineHeat) * Math.min(1, seconds / ENGINE_SETTLE_S);
+      if (oil < OIL_NEEDED) engine.hp = Math.max(0, engine.hp - engine.def.hp * OIL_WEAR * work * seconds * ((OIL_NEEDED - oil) / OIL_NEEDED));
+      if (engineHeat >= ENGINE_STEAM_C && vis && !steaming) {
+        steaming = true;
+        kit.addEmitter(c, new V3(engine.def.box.center[0], engine.def.box.center[1] + 0.4, 0), "white", { rate: 8, s: 1 });
+      }
+      if (engineHeat >= ENGINE_SEIZE_C || engine.hp <= engine.def.hp * ENGINE_SEIZE_HP) {
+        seized = true;
+        queue.push(ev({ type: "damage", part: engine.def.id, amount: 0, hp: r2(engine.hp), damageType: "heat" }));
+      }
+      stateCache = void 0;
+      return engineHeat;
+    },
+    driveReport: () => {
+      const health = (role) => {
+        const list = [...ps.values()].filter((p) => p.def.role === role);
+        if (!list.length) return 1;
+        return Math.min(...list.map((p) => p.lost || !attached(p.def.id) ? 0 : p.hp / p.def.hp));
+      };
+      const tyres = [...ps.values()].filter((p) => p.def.role === "tyre").map((p) => ({ x: p.def.box.center[0], z: p.def.box.center[2], health: tyreHealth(p) }));
+      const status = computeStatus();
+      const brakeSystem = [...ps.values()].find((p) => p.def.role === "brakes" && p.def.contains);
+      const fluidLeft = brakeSystem ? clamp((brakeSystem.liters ?? 0) / brakeSystem.def.contains.liters / BRAKE_FLUID_NEEDED, 0, 1) : 1;
+      return { tyres, brakes: Math.min(1, 1 / status.brakeFactor) * (BRAKE_NO_FLUID + (1 - BRAKE_NO_FLUID) * fluidLeft), engine: status.canStart ? health("engine") : 0, suspension: health("shocks") };
+    },
     partWorldCenter: (pid) => {
       sync();
       const d = ps.get(pid)?.def;
@@ -13681,6 +14294,34 @@ function createCreaseQueue() {
   };
 }
 
+// src/destructible/crash.ts
+var CRASH_RULES = { energyToDamage: 0.3, hitSpacing: 0.6, minSpeed: 1.5, rows: [0, 0.3], crushPerMs: 0.035, maxCrush: 0.6 };
+function crashDeltaV(speed, massKg, otherMassKg) {
+  if (!Number.isFinite(otherMassKg)) return speed;
+  return speed * otherMassKg / (massKg + otherMassKg);
+}
+function crashVehicle(d, crash) {
+  const rules = { ...CRASH_RULES, ...crash.rules };
+  const deltaV = crashDeltaV(crash.speed, crash.massKg, crash.otherMassKg);
+  const energy = 0.5 * crash.massKg * deltaV * deltaV;
+  if (crash.speed < rules.minSpeed) return { deltaV, energy, events: [] };
+  const [dx, , dz] = crash.direction;
+  const length = Math.hypot(dx, dz) || 1;
+  const across = [-dz / length, 0, dx / length];
+  const hits = Math.max(1, Math.round(crash.contactWidth / rules.hitSpacing));
+  const each = energy * rules.energyToDamage / (hits * rules.rows.length);
+  const events = [];
+  for (const up of rules.rows)
+    for (let i = 0; i < hits; i++) {
+      const offset = hits === 1 ? 0 : (i / (hits - 1) - 0.5) * crash.contactWidth;
+      const point = [crash.point[0] + across[0] * offset, crash.point[1] + up, crash.point[2] + across[2] * offset];
+      events.push(...d.hit({ type: "blunt", point, direction: [dx / length, 0, dz / length], energy: each, radius: rules.hitSpacing / 2, ...crash.source ? { source: crash.source } : {} }));
+    }
+  const crush = Math.min(rules.maxCrush, deltaV * rules.crushPerMs);
+  d.crumple(crash.point, [dx / length, 0, dz / length], crush);
+  return { deltaV, energy, events };
+}
+
 // src/destructible/enclosure.ts
 var CABIN_LEAK = 0.02;
 var HOLE_RATE_PER_AREA = 3e3;
@@ -13765,17 +14406,22 @@ function cabinEnclosure(source, options = {}) {
   };
 }
 export {
+  ARMOUR_LEVELS,
   CABIN_LEAK,
+  CRASH_RULES,
   JOINT_RULES,
   LEGACY_STATES,
   LEGACY_ZONE_IDS,
   SEED_SALTS,
+  armourLevelOf,
   buildVehicleItem,
   buildVehicleModel,
   cabinBoxOf,
   cabinEnclosure,
   clamp,
   crackedGlassMaterial,
+  crashDeltaV,
+  crashVehicle,
   createCreaseQueue,
   createLod,
   createTranslate,