@adatechnology/game-vehicles 0.3.0 → 0.4.0

package/README.md

@@ -64,6 +64,9 @@ scene.remove(c.root); kit.dispose(c)
 const hurt = kit.build('meteor', 'intact', state)
 scene.add(hurt.root)
 
+// ...or name a registered scenario and build it in one call (explicit health / flags given alongside win)
+const wreck = kit.build('meteor', 'intact', { scenario: 'burnt' })
+
 // 4. animate (particles, fluids, hood, rollover, explosions)
 kit.tick(hurt, dt)
 ```
@@ -89,7 +92,7 @@ and a band decided by the health:
 | 3 | `destroyed` | 1 to 25 | Heavy deformation, parts fall off |
 | 4 | `torn_off` | 0 | The part is gone |
 
-Bands only change the look when the band changes; `kit.build(key, state, zoneState)` rebuilds the vehicle and reapplies every zone.
+Bands only change the look when the band changes; `kit.build(key, state, zoneState)` rebuilds the vehicle and reapplies every zone. `zoneState` may also carry `scenario: 'id or name'`: the scenario is computed on the vehicle being built (no probe build) and any `health` / `flags` given with it are merged on top. An unknown scenario damages nothing, like `zoneScenario`.
 
 **Content packs.** A pack is a plugin: `{ name, configure, install(kit) }`. `configure` accepts everything in the configuration table below and
 `install` can call `kit.register(...)`, `kit.scenario(...)`, `kit.defineFluid(...)`, `kit.on(...)` and so on. The engine never imports a pack.
@@ -139,7 +142,7 @@ created with, so `kit.t('mypack.some.key')` reads from it, with English as the f
 | Area | Methods |
 |---|---|
 | Registry | `register(spec, build)`, `find(key)`, `fleet`, `configure`, `plugin`, `on`/`hook`, `scenario`, `defineFluid` |
-| Lifecycle | `build(key, state?, zoneState?)`, `dispose(c)`, `tick(c, dt)`, `settle(c, seconds)`, `defaultDamage(c)` |
+| Lifecycle | `build(key, state?, zoneState?)` (`zoneState.scenario` runs a scenario), `dispose(c)`, `tick(c, dt)`, `settle(c, seconds)`, `defaultDamage(c)` |
 | Zones | `bandOf(health)`, `zonesOf(c)`, `applyZones(c, state)`, `zoneScenario(c, id)`, `zoneOverall(c)`, `zoneAt(c, point)`, `zoneDamageAt(c, point, dir, force)`, `zonePoint(c, zone)`, `zoneEffect(zone, health?)`, `zoneOwner` |
 | Events | `impact(c, point, dir, force, options?)`, `zoneImpact(c, side, force)` (side: `front`, `rear`, `left`, `right` or `rolled`), `explode(c, options?)`, `blastDamage(c, amount)`, `roll(c, side?)`, `setHood(c, open)` |
 | Fluids and particles | `splat`, `puddle`, `wipe(c, mode)` (`wiper` or `rain`), `spawn`, `burst`, `addEmitter` |
@@ -175,6 +178,7 @@ kit.scenario({
 })
 const result = kit.zoneScenario(c, 'front') // { health, flags, scenario }
 const hurt = kit.build('meteor', 'intact', result)
+const same = kit.build('meteor', 'intact', { scenario: 'front' }) // the two steps in one call
 ```
 
 `x` has `c`, `meta`, `front`, `rear`, `length`, `width`, `clearance`, `top`, `rand()`, `set(zone, health)`, `flags`, `health`, `center` (of the zone

package/dist/index.d.ts

@@ -337,6 +337,8 @@ interface VehicleContext {
     meta: VehicleMeta;
     zones: DamageZone[];
     zoneState: ZoneState;
+    /** The scenario the vehicle was built in (`kit.build(key, state, { scenario })`), so a rebuild keeps it. */
+    scenario?: string;
     /** Deterministic random generator seeded from the vehicle key and state. */
     rand: () => number;
     parts: VehiclePart[];
@@ -418,6 +420,11 @@ interface ZoneState {
     health: Record<string, number>;
     flags: Record<string, boolean>;
 }
+/** The zone-state argument of `kit.build`: a `ZoneState` plus an optional scenario to compute on the vehicle being built. */
+interface BuildZoneState extends Partial<ZoneState> {
+    /** Id or name of a registered scenario (e.g. the fleet's `burnt`); explicit `health` / `flags` override its result. */
+    scenario?: string;
+}
 interface ScenarioResult {
     health: Record<string, number>;
     flags: Record<string, boolean>;
@@ -662,7 +669,7 @@ interface VehicleKit {
     defineFluid(key: string, def: FluidDefinition): FluidDefinition;
     on(event: string, fn: (...args: any[]) => void): VehicleKit;
     hook(event: string, ...args: any[]): void;
-    build(key: string, state?: BuildState, zoneState?: Partial<ZoneState>, options?: BuildOptions): VehicleContext;
+    build(key: string, state?: BuildState, zoneState?: BuildZoneState, options?: BuildOptions): VehicleContext;
     /** The damageable parts of a built vehicle as boxes (optionally in the frame of `matrix`). */
     damageables(c: VehicleContext, matrix?: ThreeObject): Damageable[];
     dispose(c: VehicleContext): void;
@@ -894,6 +901,8 @@ interface VehicleItemOptions {
     state?: BuildState;
     /** Build in the light mode of the kit (`kit.lod`): fewer segments and no interior, for crowds and for budgets. Default off. */
     lod?: boolean;
+    /** A registered damage scenario (id or name, e.g. the fleet's `burnt`) built into the vehicle, through `kit.build(key, state, { scenario })`. */
+    scenario?: string;
 }
 interface VehicleItem {
     /** Add this to the scene: origin at the centre of the footprint on the floor, front facing +z. */
@@ -908,4 +917,4 @@ interface VehicleItem {
  */
 declare function buildVehicleItem(kit: VehicleKit, key: string, options?: VehicleItemOptions): VehicleItem;
 
-export { type Band, type BandId, type BandIndex, type BandOverride, type BuildFunction, type BuildOptions, type BuildState, type DamageMapOptions, type DamageZone, type Damageable, type DamageableKind, type DamageableMaterial, type DamageableSide, type ExplodeOptions, type FlagEffect, type FluidDefinition, type ImpactOptions, JOINT_RULES, type JointDef, type KitConfiguration, type KitInternals, type KitTexts, LEGACY_STATES, LEGACY_ZONE_IDS, type LocalBox, type LocaleStrings, type LodSettings, type OverallHealth, type PartDef, type PartLabel, type PartRole, type PartialLocaleStrings, type Plugin, type ResolvedConfiguration, SEED_SALTS, type ScenarioContext, type ScenarioDefinition, type ScenarioResult, type SplatOptions, type ThreeObject, type ThreeVector, type Translate, type UiHelpers, type VehicleContext, type VehicleDestructible, type VehicleDestructibleOptions, type VehicleItem, type VehicleItemOptions, type VehicleKit, type VehicleKitOptions, type VehicleMeta, type VehicleModel, type VehiclePart, type VehicleSpec, type VehicleStatus, type ZoneDamageEntry, type ZoneEffect, type ZoneState, buildVehicleItem, buildVehicleModel, clamp, createLod, createTranslate, createVehicleDestructible, createVehicleKit, defaultDamageableKinds, defaultLodSettings, format, hash, legacyGlassId, legacyLightId, legacyZoneId, listLocales, registerLegacySeeds, registerLocale, resolveStrings, rng, smooth, strHash, wrapThreeForLod };
+export { type Band, type BandId, type BandIndex, type BandOverride, type BuildFunction, type BuildOptions, type BuildState, type BuildZoneState, type DamageMapOptions, type DamageZone, type Damageable, type DamageableKind, type DamageableMaterial, type DamageableSide, type ExplodeOptions, type FlagEffect, type FluidDefinition, type ImpactOptions, JOINT_RULES, type JointDef, type KitConfiguration, type KitInternals, type KitTexts, LEGACY_STATES, LEGACY_ZONE_IDS, type LocalBox, type LocaleStrings, type LodSettings, type OverallHealth, type PartDef, type PartLabel, type PartRole, type PartialLocaleStrings, type Plugin, type ResolvedConfiguration, SEED_SALTS, type ScenarioContext, type ScenarioDefinition, type ScenarioResult, type SplatOptions, type ThreeObject, type ThreeVector, type Translate, type UiHelpers, type VehicleContext, type VehicleDestructible, type VehicleDestructibleOptions, type VehicleItem, type VehicleItemOptions, type VehicleKit, type VehicleKitOptions, type VehicleMeta, type VehicleModel, type VehiclePart, type VehicleSpec, type VehicleStatus, type ZoneDamageEntry, type ZoneEffect, type ZoneState, buildVehicleItem, buildVehicleModel, clamp, createLod, createTranslate, createVehicleDestructible, createVehicleKit, defaultDamageableKinds, defaultLodSettings, format, hash, legacyGlassId, legacyLightId, legacyZoneId, listLocales, registerLegacySeeds, registerLocale, resolveStrings, rng, smooth, strHash, wrapThreeForLod };

package/dist/index.global.js

@@ -2501,46 +2501,79 @@ var GameVehicles = (() => {
       }
       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;
@@ -8198,6 +8231,153 @@ var GameVehicles = (() => {
       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) {
@@ -8250,7 +8430,7 @@ var GameVehicles = (() => {
         });
         _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;
@@ -8278,7 +8458,7 @@ var GameVehicles = (() => {
         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;
@@ -8349,6 +8529,7 @@ var GameVehicles = (() => {
       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;
@@ -8429,8 +8610,25 @@ var GameVehicles = (() => {
     }
     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]);
@@ -8444,7 +8642,7 @@ var GameVehicles = (() => {
         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) {
@@ -8461,31 +8659,26 @@ var GameVehicles = (() => {
           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;
@@ -8508,6 +8701,17 @@ var GameVehicles = (() => {
       });
       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;
@@ -8562,6 +8766,7 @@ var GameVehicles = (() => {
           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";
@@ -8570,15 +8775,17 @@ var GameVehicles = (() => {
           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);
@@ -8599,9 +8806,11 @@ var GameVehicles = (() => {
         }
         if (changed) {
           pos.needsUpdate = true;
+          dirty.add(msh);
+        }
+        if (changed || boundsDue) {
           g.computeBoundingSphere();
           g.computeBoundingBox();
-          dirty.add(msh);
         }
       });
       const dset = new Set(c.deform);
@@ -11704,6 +11913,20 @@ var GameVehicles = (() => {
         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: {} };
@@ -13702,7 +13925,7 @@ var GameVehicles = (() => {
     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);
@@ -13759,7 +13982,8 @@ var GameVehicles = (() => {
   // src/destructible/item.ts
   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;