@adatechnology/game-vehicles-three 0.2.0 → 0.3.0

package/dist/index.global.js

@@ -22,6 +22,7 @@ var GameVehiclesThree = (() => {
   var index_exports = {};
   __export(index_exports, {
     DEFAULT_TEST_VEHICLES: () => DEFAULT_TEST_VEHICLES,
+    DEFAULT_TEST_WRECKS: () => DEFAULT_TEST_WRECKS,
     LITE_CLASSES: () => LITE_CLASSES,
     PAGE_ITEM_ALIASES: () => PAGE_ITEM_ALIASES,
     PAGE_SCENARIO_ALIASES: () => PAGE_SCENARIO_ALIASES,
@@ -30404,46 +30405,79 @@ var GameVehiclesThree = (() => {
       }
       const p = geo.attributes.position;
       const n = p.count;
-      const FN = [];
-      const map = {};
-      const A = new V3();
-      const B = new V3();
-      const C = new V3();
-      const e1 = new V3();
-      const e2 = new V3();
+      const faces = n / 3;
+      const FN = new Float64Array(faces * 3);
+      const map = /* @__PURE__ */ new Map();
+      const RANGE = 65536;
       function key(i) {
-        return Math.round(p.getX(i) * 2e3) + "," + Math.round(p.getY(i) * 2e3) + "," + Math.round(p.getZ(i) * 2e3);
+        const x = Math.round(p.getX(i) * 2e3);
+        const y = Math.round(p.getY(i) * 2e3);
+        const z = Math.round(p.getZ(i) * 2e3);
+        if (Math.abs(x) < RANGE && Math.abs(y) < RANGE && Math.abs(z) < RANGE) return ((x + RANGE) * 131072 + (y + RANGE)) * 131072 + (z + RANGE);
+        return x + "," + y + "," + z;
       }
       const keys = new Array(n);
-      for (let f = 0; f < n / 3; f++) {
-        A.fromBufferAttribute(p, 3 * f);
-        B.fromBufferAttribute(p, 3 * f + 1);
-        C.fromBufferAttribute(p, 3 * f + 2);
-        const nn = new V3().crossVectors(e1.subVectors(C, B), e2.subVectors(A, B));
-        if (nn.lengthSq() > 1e-20) nn.normalize();
-        FN.push(nn);
+      for (let f = 0; f < faces; f++) {
+        const ax = p.getX(3 * f);
+        const ay = p.getY(3 * f);
+        const az = p.getZ(3 * f);
+        const bx = p.getX(3 * f + 1);
+        const by = p.getY(3 * f + 1);
+        const bz = p.getZ(3 * f + 1);
+        const cx = p.getX(3 * f + 2);
+        const cy = p.getY(3 * f + 2);
+        const cz = p.getZ(3 * f + 2);
+        const e1x = cx - bx;
+        const e1y = cy - by;
+        const e1z = cz - bz;
+        const e2x = ax - bx;
+        const e2y = ay - by;
+        const e2z = az - bz;
+        let nx = e1y * e2z - e1z * e2y;
+        let ny = e1z * e2x - e1x * e2z;
+        let nz = e1x * e2y - e1y * e2x;
+        if (nx * nx + ny * ny + nz * nz > 1e-20) {
+          const inv = 1 / (Math.sqrt(nx * nx + ny * ny + nz * nz) || 1);
+          nx *= inv;
+          ny *= inv;
+          nz *= inv;
+        }
+        FN[3 * f] = nx;
+        FN[3 * f + 1] = ny;
+        FN[3 * f + 2] = nz;
         for (let k = 0; k < 3; k++) {
           const kk = key(3 * f + k);
           keys[3 * f + k] = kk;
-          (map[kk] || (map[kk] = [])).push(f);
+          const list2 = map.get(kk);
+          if (list2) list2.push(f);
+          else map.set(kk, [f]);
         }
       }
       const cs = Math.cos(deg * PI / 180);
       const out = new Float32Array(n * 3);
-      const s = new V3();
       for (let i = 0; i < n; i++) {
-        const fi = i / 3 | 0;
-        const list2 = map[keys[i]];
-        s.set(0, 0, 0);
+        const fi = (i / 3 | 0) * 3;
+        const list2 = map.get(keys[i]);
+        let sx = 0;
+        let sy = 0;
+        let sz = 0;
         for (let j = 0; j < list2.length; j++) {
-          const g = FN[list2[j]];
-          if (g.dot(FN[fi]) >= cs) s.add(g);
+          const g = list2[j] * 3;
+          if (FN[g] * FN[fi] + FN[g + 1] * FN[fi + 1] + FN[g + 2] * FN[fi + 2] >= cs) {
+            sx += FN[g];
+            sy += FN[g + 1];
+            sz += FN[g + 2];
+          }
         }
-        if (s.lengthSq() < 1e-20) s.copy(FN[fi]);
-        s.normalize();
-        out[3 * i] = s.x;
-        out[3 * i + 1] = s.y;
-        out[3 * i + 2] = s.z;
+        if (sx * sx + sy * sy + sz * sz < 1e-20) {
+          sx = FN[fi];
+          sy = FN[fi + 1];
+          sz = FN[fi + 2];
+        }
+        const inv = 1 / (Math.sqrt(sx * sx + sy * sy + sz * sz) || 1);
+        out[3 * i] = sx * inv;
+        out[3 * i + 1] = sy * inv;
+        out[3 * i + 2] = sz * inv;
       }
       geo.setAttribute("normal", new THREE.BufferAttribute(out, 3));
       geo.userData.crease = true;
@@ -36061,6 +36095,153 @@ var GameVehiclesThree = (() => {
       return hole;
     }
     const _zr = new THREE.Raycaster();
+    const PROXY_MIN_TRIANGLES = 500;
+    const STROKE_REACH = 0.6;
+    const _pv = new V3();
+    const _pm = new THREE.Matrix4();
+    function decalRegion(c, z) {
+      const B = z.box;
+      const lo = [0, 1, 2].map(function(k) {
+        return I.boxLo(B, k) - STROKE_REACH;
+      });
+      const hi = [0, 1, 2].map(function(k) {
+        return I.boxHi(B, k) + STROKE_REACH;
+      });
+      const a = axisOf(z.dir);
+      const dn = z.dir.clone().normalize();
+      const sg = z.dir.getComponent(a) > 0 ? 1 : -1;
+      const outer = sg > 0 ? I.boxLo(B, a) - 0.6 : I.boxHi(B, a) + 0.6;
+      const far = 0.6 + (I.boxHi(B, a) - I.boxLo(B, a)) + 0.05;
+      for (let i = 0; i < 8; i++) {
+        const p = new V3();
+        p.setComponent(a, outer);
+        [0, 1, 2].filter(function(k) {
+          return k !== a;
+        }).forEach(function(k, j) {
+          p.setComponent(k, i >> j & 1 ? I.boxHi(B, k) : I.boxLo(B, k));
+        });
+        for (let e = 0; e < 2; e++) {
+          const q = e ? p.clone().addScaledVector(dn, far) : p;
+          for (let k = 0; k < 3; k++) {
+            lo[k] = Math.min(lo[k], q.getComponent(k) - 0.05);
+            hi[k] = Math.max(hi[k], q.getComponent(k) + 0.05);
+          }
+        }
+      }
+      return { lo, hi };
+    }
+    function regionCands(c, z, cands) {
+      if (!cands.some(heavy)) return cands;
+      const R = decalRegion(c, z);
+      const Mw = c.vehicle.matrixWorld;
+      return cands.map(function(o) {
+        if (!heavy(o)) return o;
+        if (!o.geometry.boundingSphere) o.geometry.computeBoundingSphere();
+        if (!o.geometry.boundingBox) o.geometry.computeBoundingBox();
+        return proxyIn(o, Mw, R);
+      });
+    }
+    function heavy(o) {
+      const g = o.geometry;
+      const pos = g && g.attributes && g.attributes.position;
+      return o.raycast === THREE.Mesh.prototype.raycast && !o.isSkinnedMesh && !Array.isArray(o.material) && pos && !pos.isInterleavedBufferAttribute && pos.itemSize === 3 && !g.groups.length && !(g.morphAttributes && g.morphAttributes.position) && (g.index ? g.index.count : pos.count) / 3 >= PROXY_MIN_TRIANGLES;
+    }
+    function proxyIn(o, Mw, R) {
+      _pm.copy(o.matrixWorld).invert().multiply(Mw);
+      const lo = [Infinity, Infinity, Infinity];
+      const hi = [-Infinity, -Infinity, -Infinity];
+      for (let i = 0; i < 8; i++) {
+        _pv.set(i & 1 ? R.hi[0] : R.lo[0], i & 2 ? R.hi[1] : R.lo[1], i & 4 ? R.hi[2] : R.lo[2]).applyMatrix4(_pm);
+        for (let k = 0; k < 3; k++) {
+          lo[k] = Math.min(lo[k], _pv.getComponent(k));
+          hi[k] = Math.max(hi[k], _pv.getComponent(k));
+        }
+      }
+      const g = o.geometry;
+      const P = g.attributes.position.array;
+      const ix = g.index ? g.index.array : null;
+      const n = ix ? ix.length : P.length / 3;
+      const keep = new Uint32Array(n - n % 3);
+      let nk = 0;
+      for (let t = 0; t + 2 < n; t += 3) {
+        const a = (ix ? ix[t] : t) * 3;
+        const b = (ix ? ix[t + 1] : t + 1) * 3;
+        const d = (ix ? ix[t + 2] : t + 2) * 3;
+        let out = false;
+        for (let k = 0; k < 3 && !out; k++) {
+          const u = P[a + k];
+          const v = P[b + k];
+          const w = P[d + k];
+          out = Math.max(u, v, w) < lo[k] || Math.min(u, v, w) > hi[k];
+        }
+        if (!out) {
+          keep[nk++] = ix ? ix[t] : t;
+          keep[nk++] = ix ? ix[t + 1] : t + 1;
+          keep[nk++] = ix ? ix[t + 2] : t + 2;
+        }
+      }
+      if (!nk) return null;
+      const kept = keep.slice(0, nk);
+      const box2 = new Float32Array(kept.length / 3 * 6);
+      for (let t = 0, j = 0; t < kept.length; t += 3, j += 6) {
+        const a = kept[t] * 3;
+        const b = kept[t + 1] * 3;
+        const d = kept[t + 2] * 3;
+        for (let k = 0; k < 3; k++) {
+          box2[j + k] = Math.min(P[a + k], P[b + k], P[d + k]);
+          box2[j + 3 + k] = Math.max(P[a + k], P[b + k], P[d + k]);
+        }
+      }
+      const pg = new THREE.BufferGeometry();
+      pg.setAttribute("position", g.attributes.position);
+      pg.setIndex(new THREE.BufferAttribute(new Uint32Array(kept.length), 1));
+      pg.boundingSphere = g.boundingSphere;
+      pg.boundingBox = g.boundingBox;
+      const proxy = new THREE.Mesh(pg, o.material);
+      proxy.layers.mask = o.layers.mask;
+      proxy.proxyOf = o;
+      proxy.kept = kept;
+      proxy.keptBox = box2;
+      return proxy;
+    }
+    function narrowTo(rc, proxy) {
+      const o = proxy.proxyOf;
+      const ray = rc.ray;
+      _pm.copy(o.matrixWorld).invert();
+      _pv.copy(ray.origin).applyMatrix4(_pm);
+      const x0 = _pv.x;
+      const y0 = _pv.y;
+      const z0 = _pv.z;
+      _pv.copy(ray.direction).multiplyScalar(rc.far).add(ray.origin).applyMatrix4(_pm);
+      const lo0 = Math.min(x0, _pv.x) - 1e-4;
+      const lo1 = Math.min(y0, _pv.y) - 1e-4;
+      const lo2 = Math.min(z0, _pv.z) - 1e-4;
+      const hi0 = Math.max(x0, _pv.x) + 1e-4;
+      const hi1 = Math.max(y0, _pv.y) + 1e-4;
+      const hi2 = Math.max(z0, _pv.z) + 1e-4;
+      const K = proxy.kept;
+      const X = proxy.keptBox;
+      const dst = proxy.geometry.index.array;
+      let m = 0;
+      for (let t = 0, j = 0; t < K.length; t += 3, j += 6) {
+        if (X[j + 3] < lo0 || X[j] > hi0 || X[j + 4] < lo1 || X[j + 1] > hi1 || X[j + 5] < lo2 || X[j + 2] > hi2) continue;
+        dst[m++] = K[t];
+        dst[m++] = K[t + 1];
+        dst[m++] = K[t + 2];
+      }
+      proxy.geometry.setDrawRange(0, m);
+    }
+    function castAt(rc, cands) {
+      for (let i = 0; i < cands.length; i++) {
+        const q = cands[i];
+        if (!q.proxyOf) continue;
+        q.matrixWorld.copy(q.proxyOf.matrixWorld);
+        narrowTo(rc, q);
+      }
+      const hits = rc.intersectObjects(cands, false);
+      for (let i = 0; i < hits.length; i++) if (hits[i].object.proxyOf) hits[i].object = hits[i].object.proxyOf;
+      return hits;
+    }
     function zoneCands(c, z, inv, glassToo) {
       const out = [];
       c.vehicle.traverse(function(o) {
@@ -36113,7 +36294,7 @@ var GameVehiclesThree = (() => {
         });
         _zr.set(org.clone().applyMatrix4(Mw), d.clone().transformDirection(Mw));
         _zr.far = 0.6 + (I.boxHi(B, a) - I.boxLo(B, a)) + 0.05;
-        const hits = _zr.intersectObjects(cands, false);
+        const hits = castAt(_zr, cands);
         for (let i = 0; i < hits.length; i++) {
           const h = hits[i];
           if (!h.face) continue;
@@ -36141,7 +36322,7 @@ var GameVehiclesThree = (() => {
         const q = s.p.clone().addScaledVector(t, len * 0.5 * k / M);
         _rt.set(q.clone().addScaledVector(n, 0.08).applyMatrix4(Mw), n.clone().negate().transformDirection(Mw));
         _rt.far = 0.2;
-        const h = _rt.intersectObjects(cands, false).find(function(x) {
+        const h = castAt(_rt, cands).find(function(x) {
           return x.face;
         });
         if (!h) return null;
@@ -36212,6 +36393,7 @@ var GameVehiclesThree = (() => {
       const R = c.rand;
       const need = (spec.fine || 0) + (spec.deep || 0) + (spec.chip || 0) + (spec.rust || 0) + (spec.tear || 0) + (spec.ding || 0) + (spec.soot || 0) + (spec.crater || 0);
       if (!need) return [];
+      cands = regionCands(c, z, cands).filter(Boolean);
       const S = zoneSurf(c, z, need + 2, R, cands);
       let k = 0;
       const ang0 = R() * PI;
@@ -36290,8 +36472,25 @@ var GameVehiclesThree = (() => {
     }
     function subdivIn(geo, rel, B, maxLen) {
       const a = geo.attributes.position.array;
-      const out = [];
-      const v = new V3();
+      let out = new Float32Array(a.length + 4096);
+      let used = 0;
+      const push = function(a0, a1, a2, b0, b1, b2, c0, c1, c2) {
+        if (used + 9 > out.length) {
+          const bigger = new Float32Array(out.length * 2);
+          bigger.set(out);
+          out = bigger;
+        }
+        out[used] = a0;
+        out[used + 1] = a1;
+        out[used + 2] = a2;
+        out[used + 3] = b0;
+        out[used + 4] = b1;
+        out[used + 5] = b2;
+        out[used + 6] = c0;
+        out[used + 7] = c1;
+        out[used + 8] = c2;
+        used += 9;
+      };
       const e = 0.15;
       function d(p, q) {
         return Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
@@ -36305,7 +36504,7 @@ var GameVehiclesThree = (() => {
         const ca = d(C, A);
         const mx = Math.max(ab, bc, ca);
         if (mx <= maxLen || depth > 9) {
-          out.push(A[0], A[1], A[2], Bv[0], Bv[1], Bv[2], C[0], C[1], C[2]);
+          push(A[0], A[1], A[2], Bv[0], Bv[1], Bv[2], C[0], C[1], C[2]);
           return;
         }
         if (mx === ab) {
@@ -36322,31 +36521,26 @@ var GameVehiclesThree = (() => {
           tri(F2, Bv, C, depth + 1);
         }
       }
+      const M = rel.elements;
+      const at = function(x, y, z, k) {
+        const w = 1 / (M[3] * x + M[7] * y + M[11] * z + M[15]);
+        return k === 0 ? (M[0] * x + M[4] * y + M[8] * z + M[12]) * w : k === 1 ? (M[1] * x + M[5] * y + M[9] * z + M[13]) * w : (M[2] * x + M[6] * y + M[10] * z + M[14]) * w;
+      };
+      const lo = [B.x0 - e, B.y0 - e, B.z0 - e];
+      const hi = [B.x1 + e, B.y1 + e, B.z1 + e];
       for (let i = 0; i < a.length; i += 9) {
-        const A = [a[i], a[i + 1], a[i + 2]];
-        const Bv = [a[i + 3], a[i + 4], a[i + 5]];
-        const C = [a[i + 6], a[i + 7], a[i + 8]];
-        let x0 = 1e9;
-        let x1 = -1e9;
-        let y0 = 1e9;
-        let y1 = -1e9;
-        let z0 = 1e9;
-        let z1 = -1e9;
-        [A, Bv, C].forEach(function(p) {
-          v.set(p[0], p[1], p[2]).applyMatrix4(rel);
-          x0 = Math.min(x0, v.x);
-          x1 = Math.max(x1, v.x);
-          y0 = Math.min(y0, v.y);
-          y1 = Math.max(y1, v.y);
-          z0 = Math.min(z0, v.z);
-          z1 = Math.max(z1, v.z);
-        });
-        if (x1 < B.x0 - e || x0 > B.x1 + e || y1 < B.y0 - e || y0 > B.y1 + e || z1 < B.z0 - e || z0 > B.z1 + e)
-          out.push(A[0], A[1], A[2], Bv[0], Bv[1], Bv[2], C[0], C[1], C[2]);
-        else tri(A, Bv, C, 0);
+        let outside = false;
+        for (let k = 0; k < 3 && !outside; k++) {
+          const p = at(a[i], a[i + 1], a[i + 2], k);
+          const q = at(a[i + 3], a[i + 4], a[i + 5], k);
+          const r = at(a[i + 6], a[i + 7], a[i + 8], k);
+          outside = Math.max(p, q, r) < lo[k] || Math.min(p, q, r) > hi[k];
+        }
+        if (outside) push(a[i], a[i + 1], a[i + 2], a[i + 3], a[i + 4], a[i + 5], a[i + 6], a[i + 7], a[i + 8]);
+        else tri([a[i], a[i + 1], a[i + 2]], [a[i + 3], a[i + 4], a[i + 5]], [a[i + 6], a[i + 7], a[i + 8]], 0);
       }
       const g = new THREE.BufferGeometry();
-      g.setAttribute("position", new THREE.Float32BufferAttribute(out, 3));
+      g.setAttribute("position", new THREE.BufferAttribute(out.slice(0, used), 3));
       g.userData.crease = true;
       g.userData.p0 = null;
       return g;
@@ -36369,6 +36563,17 @@ var GameVehiclesThree = (() => {
       });
       return out;
     }
+    function boxInFrame(B, m, tmp) {
+      const r = [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
+      for (let i = 0; i < 8; i++) {
+        tmp.set(i & 1 ? B.x1 : B.x0, i & 2 ? B.y1 : B.y0, i & 4 ? B.z1 : B.z0).applyMatrix4(m);
+        for (let k = 0; k < 3; k++) {
+          r[k] = Math.min(r[k], tmp.getComponent(k) - 1e-4);
+          r[k + 3] = Math.max(r[k + 3], tmp.getComponent(k) + 1e-4);
+        }
+      }
+      return r;
+    }
     function zoneDent(c, z, dents, dirty, opt) {
       opt = opt || {};
       const B = z.box;
@@ -36423,6 +36628,7 @@ var GameVehiclesThree = (() => {
           g = msh.geometry = g.clone();
           msh.userData.zCloned = true;
         }
+        let boundsDue = false;
         const nonIdx = !g.index;
         const onlyPos = Object.keys(g.attributes).every(function(k) {
           return k === "position" || k === "normal";
@@ -36431,15 +36637,17 @@ var GameVehiclesThree = (() => {
           const ng = subdivIn(g, rel, B, opt.sub || 0.075);
           g.dispose();
           g = msh.geometry = ng;
-          ng.computeBoundingSphere();
-          ng.computeBoundingBox();
+          boundsDue = true;
           dirty.add(msh);
         }
         irel.copy(rel).invert();
         const pos = g.attributes.position;
         let changed = false;
+        const near = boxInFrame(B, irel, v);
         for (let i = 0; i < pos.count; i++) {
-          v.fromBufferAttribute(pos, i).applyMatrix4(rel);
+          v.fromBufferAttribute(pos, i);
+          if (v.x < near[0] || v.x > near[3] || v.y < near[1] || v.y > near[4] || v.z < near[2] || v.z > near[5]) continue;
+          v.applyMatrix4(rel);
           const f = field(v);
           if (f <= 1e-5) continue;
           v.addScaledVector(d, f);
@@ -36460,9 +36668,11 @@ var GameVehiclesThree = (() => {
         }
         if (changed) {
           pos.needsUpdate = true;
+          dirty.add(msh);
+        }
+        if (changed || boundsDue) {
           g.computeBoundingSphere();
           g.computeBoundingBox();
-          dirty.add(msh);
         }
       });
       const dset = new Set(c.deform);
@@ -39545,6 +39755,20 @@ var GameVehiclesThree = (() => {
         else kit.applyArmor(c);
       }
       if (zoneState == null && st === "damaged" && kit.config.damagedScenario) zoneState = kit.zoneScenario(c, kit.config.damagedScenario);
+      else if (zoneState && zoneState.scenario != null) {
+        c.scenario = zoneState.scenario;
+        let fromScenario = { health: {}, flags: {} };
+        try {
+          fromScenario = kit.zoneScenario(c, zoneState.scenario);
+        } catch (e) {
+          ;
+          (c.zoneErrors = c.zoneErrors || []).push("scenario: " + (e && e.message));
+        }
+        zoneState = {
+          health: Object.assign({}, fromScenario.health, zoneState.health),
+          flags: Object.assign({}, fromScenario.flags, zoneState.flags)
+        };
+      }
       if (zoneState) kit.applyZones(c, zoneState);
       else {
         c.zoneState = { health: {}, flags: {} };
@@ -41488,7 +41712,7 @@ var GameVehiclesThree = (() => {
     const reset = () => {
       const old = c;
       const parent = old.root.parent;
-      const next = kit.build(old.key, old.state);
+      const next = kit.build(old.key, old.state, old.scenario != null ? { scenario: old.scenario } : void 0);
       if (parent) {
         next.root.position.copy(old.root.position);
         next.root.quaternion.copy(old.root.quaternion);
@@ -41543,7 +41767,8 @@ var GameVehiclesThree = (() => {
   }
   function buildVehicleItem(kit, key, options = {}) {
     const THREE = kit.THREE;
-    const vehicle = options.lod ? kit.build(key, options.state ?? "intact", void 0, { lod: true }) : kit.build(key, options.state ?? "intact");
+    const zoneState = options.scenario != null ? { scenario: options.scenario } : void 0;
+    const vehicle = options.lod ? kit.build(key, options.state ?? "intact", zoneState, { lod: true }) : kit.build(key, options.state ?? "intact", zoneState);
     const m = vehicle.meta;
     const root = new THREE.Group();
     root.name = key;
@@ -41984,6 +42209,7 @@ var GameVehiclesThree = (() => {
     "vehicles_kill_battery",
     "vehicles_rollover",
     "vehicles_melt",
+    "vehicles_burnt_wreck",
     "vehicles_drive_arcade",
     "vehicles_drive_semi"
   ];
@@ -42015,7 +42241,7 @@ var GameVehiclesThree = (() => {
     en: {
       group: "Vehicles",
       name: "Vehicles area",
-      items: { hatch: "Compact hatch", sedan: "Midsize sedan", pickup: "Midsize pickup", sport_bike: "Sport bike", box_truck: "Box truck", city_bus: "City bus", battle_tank: "Battle tank", attack_helicopter: "Attack helicopter" },
+      items: { hatch: "Compact hatch", sedan: "Midsize sedan", pickup: "Midsize pickup", sport_bike: "Sport bike", box_truck: "Box truck", city_bus: "City bus", battle_tank: "Battle tank", attack_helicopter: "Attack helicopter", sedan_burnt: "Burnt sedan", hatch_burnt: "Burnt hatch" },
       controls: { quality: "Quality", paint_by_seed: "Paint by seed", color_seed: "Colour seed", palette: "Palette", driving: "Driving", surface: "Surface" },
       hints: {
         quality: "High: the kit at full detail. Light: fewer segments and no interior (the light mode of the fleet); applies to the vehicles placed from now on",
@@ -42048,7 +42274,8 @@ var GameVehiclesThree = (() => {
         vehicles_rollover: "Vehicles: roll over",
         vehicles_melt: "Vehicles: melt (long fire burns the tyres)",
         vehicles_drive_arcade: "Vehicles: arcade driving down a lane that ends in a wall",
-        vehicles_drive_semi: "Vehicles: semi-simulation braking on dry, wet and mud"
+        vehicles_drive_semi: "Vehicles: semi-simulation braking on dry, wet and mud",
+        vehicles_burnt_wreck: "Vehicles: the burnt sedan comes out of the kit burnt, with the glass gone"
       },
       checks: {
         windshield_holes: "Windshield: {0} hole(s), went through {1:b} (expected: 1, true)",
@@ -42073,13 +42300,15 @@ var GameVehiclesThree = (() => {
         arcade_bounce: "Arcade: the car bounces back at {0} m/s (expected: below 0)",
         arcade_noise: "Arcade: {0} engine noise(s) and {1} crash noise(s) (expected: 1 or more each)",
         semi_order: "Semi: braking from 80 km/h takes dry {0} m, wet {1} m, mud {2} m (expected: dry shorter than wet shorter than mud)",
-        semi_mud: "Semi: a 2WD car on mud {0:on} (expected: bogged on, a bog event)"
+        semi_mud: "Semi: a 2WD car on mud {0:on} (expected: bogged on, a bog event)",
+        wreck_burnt: "Burnt sedan: burnt flag {0:b} (expected: yes)",
+        wreck_glass: "Burnt sedan: {0} glass zone(s), {1} still above 0 (expected: 1 or more, none above 0)"
       }
     },
     "pt-BR": {
       group: "Ve\xEDculos",
       name: "\xC1rea de ve\xEDculos",
-      items: { hatch: "Hatch compacto", sedan: "Sed\xE3 m\xE9dio", pickup: "Picape m\xE9dia", sport_bike: "Moto esportiva", box_truck: "Caminh\xE3o ba\xFA", city_bus: "\xD4nibus urbano", battle_tank: "Tanque de guerra", attack_helicopter: "Helic\xF3ptero de ataque" },
+      items: { hatch: "Hatch compacto", sedan: "Sed\xE3 m\xE9dio", pickup: "Picape m\xE9dia", sport_bike: "Moto esportiva", box_truck: "Caminh\xE3o ba\xFA", city_bus: "\xD4nibus urbano", battle_tank: "Tanque de guerra", attack_helicopter: "Helic\xF3ptero de ataque", sedan_burnt: "Sed\xE3 queimado", hatch_burnt: "Hatch queimado" },
       controls: { quality: "Qualidade", paint_by_seed: "Pintar pela semente", color_seed: "Semente da cor", palette: "Paleta", driving: "Dire\xE7\xE3o", surface: "Piso" },
       hints: {
         quality: "Alta: o kit com todo o detalhe. Leve: menos segmentos e sem interior (o modo leve da frota); vale para os ve\xEDculos postos daqui em diante",
@@ -42112,7 +42341,8 @@ var GameVehiclesThree = (() => {
         vehicles_rollover: "Ve\xEDculos: capotar",
         vehicles_melt: "Ve\xEDculos: derreter (fogo longo queima os pneus)",
         vehicles_drive_arcade: "Ve\xEDculos: dire\xE7\xE3o arcade numa pista que acaba num muro",
-        vehicles_drive_semi: "Ve\xEDculos: frenagem da semissimula\xE7\xE3o no seco, no molhado e na lama"
+        vehicles_drive_semi: "Ve\xEDculos: frenagem da semissimula\xE7\xE3o no seco, no molhado e na lama",
+        vehicles_burnt_wreck: "Ve\xEDculos: o sed\xE3 queimado sai do kit queimado, sem os vidros"
       },
       checks: {
         windshield_holes: "Para-brisa: {0} furo(s), atravessou {1:b} (esperado: 1, sim)",
@@ -42137,7 +42367,9 @@ var GameVehiclesThree = (() => {
         arcade_bounce: "Arcade: o carro volta a {0} m/s (esperado: abaixo de 0)",
         arcade_noise: "Arcade: {0} ru\xEDdo(s) de motor e {1} de batida (esperado: 1 ou mais de cada)",
         semi_order: "Semi: frear de 80 km/h leva no seco {0} m, no molhado {1} m, na lama {2} m (esperado: seco menor que molhado menor que lama)",
-        semi_mud: "Semi: um carro 2WD na lama {0:on} (esperado: atolado, com evento de atolamento)"
+        semi_mud: "Semi: um carro 2WD na lama {0:on} (esperado: atolado, com evento de atolamento)",
+        wreck_burnt: "Sed\xE3 queimado: marca de queimado {0:b} (esperado: sim)",
+        wreck_glass: "Sed\xE3 queimado: {0} zona(s) de vidro, {1} ainda acima de 0 (esperado: 1 ou mais, nenhuma acima de 0)"
       }
     }
   };
@@ -42296,6 +42528,14 @@ var GameVehiclesThree = (() => {
         const t = part(room, v, "tyre_front_left");
         expect(events(room, "melt", v) >= 1 && (t.status === "melted" || t.melt > 0.5), say("tyre_melt", t.status, Math.round(t.melt * 100), events(room, "melt", v)));
       }),
+      // new in the kit: the burnt wreck comes ready from the kit (the fleet's `burnt` scenario built into the vehicle), no damage applied by the area
+      scenario("vehicles_burnt_wreck", ({ room, expect }) => {
+        const c = room.spawn("sedan_burnt", [0, 0, -7], 0).root.userData.vehicle;
+        expect(c.zoneState.flags.burnt === true, say("wreck_burnt", c.zoneState.flags.burnt === true));
+        const glass = c.zones.filter((z) => z.type === "glass");
+        const up = glass.filter((z) => (c.zoneState.health[z.id] ?? 100) > 0);
+        expect(glass.length >= 1 && up.length === 0, say("wreck_glass", glass.length, up.length));
+      }),
       // new in the kit: the drivers, headless (no vehicle is spawned)
       scenario("vehicles_drive_arcade", ({ expect }) => {
         const driver = createArcadeDriver();
@@ -42576,6 +42816,10 @@ var GameVehiclesThree = (() => {
     exhaust: "vehicle_exhaust"
   };
   var defaultSoundIds = { engine: "engine_saw", horn: "horn", crash: "sfx_impact" };
+  var DEFAULT_TEST_WRECKS = [
+    { key: "sedan_burnt", vehicle: "midsize_sedan", scenario: "burnt" },
+    { key: "hatch_burnt", vehicle: "compact_hatch", scenario: "burnt" }
+  ];
 
   // src/test-area/module.ts
   var VEHICLES_AREA_ID = "vehicles_area";
@@ -42589,6 +42833,8 @@ var GameVehiclesThree = (() => {
     const locale = options.locale ?? "pt-BR";
     const text = TEXT[locale] ?? TEXT["pt-BR"];
     const keys = options.vehicles ?? DEFAULT_TEST_VEHICLES;
+    const wrecks = options.wrecks ?? DEFAULT_TEST_WRECKS;
+    const entries = [...keys.map((key) => ({ key, id: itemId(key) })), ...wrecks.map((w) => ({ key: w.vehicle, id: w.key, scenario: w.scenario }))];
     const effectIds = { ...defaultEffectIds, ...options.effects };
     const soundIds = { ...defaultSoundIds, ...options.sounds };
     const settings = { quality: "high", paint: false, seed: 1, palette: "auto", driving: "arcade", surface: "dry_asphalt" };
@@ -42637,17 +42883,17 @@ var GameVehiclesThree = (() => {
       }
       entry.paint.color.set(color2);
     };
-    const item = (key) => ({
-      id: itemId(key),
-      name: text.items[itemId(key)] ?? key,
+    const item = ({ key, id: itemKey, scenario }) => ({
+      id: itemKey,
+      name: text.items[itemKey] ?? key,
       movable: false,
       // the first build of a vehicle takes most of a second
       slow: true,
       build: (THREE) => {
         const kit = kitFor(THREE);
-        const built = buildVehicleItem(kit, key, { lod: settings.quality === "lite" });
+        const built = buildVehicleItem(kit, key, { lod: settings.quality === "lite", ...scenario ? { scenario } : {} });
         built.root.userData.kit = kit;
-        const entry = { root: built.root, key, item: built, index: counter++, helpers: [] };
+        const entry = { root: built.root, key, ...scenario ? { scenario } : {}, item: built, index: counter++, helpers: [] };
         placed.set(built.root.uuid, entry);
         measure(entry);
         paintOf(entry);
@@ -42656,7 +42902,7 @@ var GameVehiclesThree = (() => {
       impl: (root, id) => {
         const r = root;
         const kit = r.userData.kit;
-        const d = createVehicleDestructible(kit, r.userData.vehicle, { id, frame: root, name: text.items[itemId(key)] ?? key });
+        const d = createVehicleDestructible(kit, r.userData.vehicle, { id, frame: root, name: text.items[itemKey] ?? key });
         tapEffects(d);
         r.userData.destructible = d;
         return d;
@@ -42930,7 +43176,7 @@ var GameVehiclesThree = (() => {
       for (const entry of placed.values()) {
         const want = fleetDims(entry.key);
         const got = entry.size;
-        if (!want || !got) continue;
+        if (!want || !got || entry.scenario) continue;
         worst = Math.max(worst, Math.abs(got.length - want.length), Math.abs(got.width - want.width), Math.abs(got.height - want.height));
       }
       return Math.round(worst * 1e3);
@@ -42942,23 +43188,23 @@ var GameVehiclesThree = (() => {
       get placed() {
         return placed;
       },
-      items: () => keys.map(item),
+      items: () => entries.map(item),
       area: () => {
         const gap = 1.6;
         const WIDE = 6;
         const rowOf = (list2, z) => {
           let cursor = 0;
-          const spots = list2.map((key) => {
-            const width = fleetDims(key)?.width ?? 2;
+          const spots = list2.map((entry) => {
+            const width = fleetDims(entry.key)?.width ?? 2;
             const x = cursor + width / 2;
             cursor += width + gap;
-            return { key, x };
+            return { id: entry.id, x };
           });
           return { spots, z, width: Math.max(0, cursor - gap) };
         };
-        const front = rowOf(keys.filter((key) => (fleetDims(key)?.width ?? 2) <= WIDE), 0);
-        const back = rowOf(keys.filter((key) => (fleetDims(key)?.width ?? 2) > WIDE), -16);
-        const placements = [front, back].flatMap((row) => row.spots.map(({ key, x }) => ({ item: itemId(key), position: [x - row.width / 2, 0, row.z], rotationY: 0 })));
+        const front = rowOf(entries.filter((e) => (fleetDims(e.key)?.width ?? 2) <= WIDE), 0);
+        const back = rowOf(entries.filter((e) => (fleetDims(e.key)?.width ?? 2) > WIDE), -16);
+        const placements = [front, back].flatMap((row) => row.spots.map(({ id, x }) => ({ item: id, position: [x - row.width / 2, 0, row.z], rotationY: 0 })));
         return { placements, view: { eye: [0, 5, Math.max(14, front.width * 0.6)], target: [0, 1, -2] } };
       },
       controls: () => {