@adatechnology/game-vehicles 0.6.2 → 0.6.3

package/dist/index.d.ts

@@ -391,8 +391,11 @@ interface VehicleSpec {
     /** Fuel id (a key of `configure({ fuels })`) or `'electric'` / `'none'`. */
     fuel?: string;
     build?: BuildFunction;
+    /** What the headlights' lenses are made of (default `polycarbonate`, the lens of cars since the 1990s; `glass` on older ones): glass shatters, polycarbonate cracks. */
+    headlightLens?: HeadlightLens;
     [key: string]: any;
 }
+type HeadlightLens = 'glass' | 'polycarbonate';
 /** Builds the geometry of a vehicle into the context. */
 type BuildFunction = (c: VehicleContext, kit: VehicleKit) => void;
 interface VehiclePart {
@@ -999,10 +1002,12 @@ interface VehicleDestructible extends DestructibleImpl {
     crumple(point: Vec3, direction: Vec3, depth: number): void;
 }
 type DriveReport = {
+    /** `rim`: the tyre is torn off and the bare rim is on the road. */
     readonly tyres: ReadonlyArray<{
         readonly x: number;
         readonly z: number;
         readonly health: number;
+        readonly rim: boolean;
     }>;
     readonly brakes: number;
     readonly engine: number;
@@ -1122,4 +1127,4 @@ declare function cabinEnclosure(source: CabinSource, options?: CabinEnclosureOpt
 /** The material of a pane with cracks drawn on it. A host warms its program at load with any texture: the first crack is in the middle of a blast. */
 declare function crackedGlassMaterial(THREE: any, texture: unknown): any;
 
-export { ARMOUR_LEVELS, type ArmourLevel, type ArmourLevelId, type Band, type BandId, type BandIndex, type BandOverride, type BuildFunction, type BuildOptions, type BuildState, type BuildZoneState, CABIN_LEAK, CRASH_RULES, type CabinBox, type CabinEnclosureOptions, type CabinSource, type CrashOptions, type CrashResult, type CrashRules, type CreaseQueue, type CreaseWork, type DamageMapOptions, type DamageZone, type Damageable, type DamageableKind, type DamageableMaterial, type DamageableSide, type DriveReport, 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 ParticleEffectRequest, type ParticleEffects, type ParticleMaterials, 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, armourLevelOf, buildVehicleItem, buildVehicleModel, cabinBoxOf, cabinEnclosure, clamp, crackedGlassMaterial, crashDeltaV, crashVehicle, createCreaseQueue, createLod, createTranslate, createVehicleDestructible, createVehicleKit, defaultDamageableKinds, defaultLodSettings, format, hash, legacyGlassId, legacyLightId, legacyZoneId, listLocales, registerLegacySeeds, registerLocale, resolveStrings, rng, smooth, strHash, swingOf, wrapThreeForLod };
+export { ARMOUR_LEVELS, type ArmourLevel, type ArmourLevelId, type Band, type BandId, type BandIndex, type BandOverride, type BuildFunction, type BuildOptions, type BuildState, type BuildZoneState, CABIN_LEAK, CRASH_RULES, type CabinBox, type CabinEnclosureOptions, type CabinSource, type CrashOptions, type CrashResult, type CrashRules, type CreaseQueue, type CreaseWork, type DamageMapOptions, type DamageZone, type Damageable, type DamageableKind, type DamageableMaterial, type DamageableSide, type DriveReport, type ExplodeOptions, type FlagEffect, type FluidDefinition, type HeadlightLens, 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 ParticleEffectRequest, type ParticleEffects, type ParticleMaterials, 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, armourLevelOf, buildVehicleItem, buildVehicleModel, cabinBoxOf, cabinEnclosure, clamp, crackedGlassMaterial, crashDeltaV, crashVehicle, createCreaseQueue, createLod, createTranslate, createVehicleDestructible, createVehicleKit, defaultDamageableKinds, defaultLodSettings, format, hash, legacyGlassId, legacyLightId, legacyZoneId, listLocales, registerLegacySeeds, registerLocale, resolveStrings, rng, smooth, strHash, swingOf, wrapThreeForLod };

package/dist/index.global.js

@@ -7163,8 +7163,20 @@ var GameVehicles = (() => {
       if (!L || L.broken) return;
       L.broken = true;
       L.lens.forEach(function(m) {
-        m.visible = false;
+        const rim = L.lensMaterial ? glassRim(m.geometry, c.rand) : null;
+        if (!rim) {
+          m.visible = false;
+          return;
+        }
+        m.geometry.dispose();
+        m.geometry = rim;
+        m.material = MATERIALS.glassEdge;
+        m.userData.lensRim = true;
       });
+      if (L.lensMaterial)
+        (L.reflector || []).forEach(function(m) {
+          m.material = MATERIALS.broken;
+        });
       L.inner.forEach(function(m) {
         m.material = MATERIALS.bulbBroken;
       });
@@ -7172,11 +7184,38 @@ var GameVehicles = (() => {
         h.visible = false;
       });
       const p = L.group ? L.group.position.clone() : L.inner[0] ? L.inner[0].position.clone() : new V3();
-      I.burst(c, "lens", c.toEffects(p), 10, { dir: c.dirToEffects(dir.clone().negate()), speed: 1.4, variant: L.tint === "red" ? "red" : "clear" });
-      I.burst(c, "plastic", c.toEffects(p), 2, { dir: c.dirToEffects(dir.clone().negate()), speed: 1 });
+      const glass = L.lensMaterial !== "plastic";
+      I.burst(c, "lens", c.toEffects(p), glass ? 10 : 5, { dir: c.dirToEffects(dir.clone().negate()), speed: glass ? 1.4 : 1.1, variant: L.tint === "red" ? "red" : "clear" });
+      I.burst(c, "plastic", c.toEffects(p), glass ? 2 : 5, { dir: c.dirToEffects(dir.clone().negate()), speed: 1 });
     }
     kit.breakLight = breakLight;
-    Object.assign(I, { glassUV, drawWeb, crackGlass, glassRim, shatterGlass, hitGlass, breakLight });
+    const crazedCache = /* @__PURE__ */ new Map();
+    const CRAZED_OPACITY = 0.6;
+    function crazed(material) {
+      const known = crazedCache.get(material);
+      if (known) return known;
+      const m = I.crackLens(material).clone();
+      m.opacity = Math.max(m.opacity ?? 1, CRAZED_OPACITY);
+      m.transparent = true;
+      m.userData.shared = true;
+      crazedCache.set(material, m);
+      return m;
+    }
+    function crackLight(c, L, dir, pierced) {
+      if (!L || L.broken) return;
+      if (!L.cracked) {
+        L.cracked = true;
+        for (const m of L.lens) if (m.material && !Array.isArray(m.material)) m.material = crazed(m.material);
+      }
+      const p = L.group ? L.group.position.clone() : L.inner[0] ? L.inner[0].position.clone() : new V3();
+      I.burst(c, "lens", c.toEffects(p), 3, { dir: c.dirToEffects(dir.clone().negate()), speed: 0.9, variant: L.tint === "red" ? "red" : "clear" });
+      if (!pierced || L.dark) return;
+      L.dark = true;
+      for (const m of L.inner) m.material = MATERIALS.bulbBroken;
+      for (const h of L.halo ?? []) h.visible = false;
+    }
+    kit.crackLight = crackLight;
+    Object.assign(I, { glassUV, drawWeb, crackGlass, glassRim, shatterGlass, hitGlass, breakLight, crackLight });
   }
 
   // src/impact.ts
@@ -12726,6 +12765,8 @@ var GameVehicles = (() => {
     heli: ["battery", "alternator", "gearbox"]
   };
   var HITCH_CHANCE = { car: 30, truck: 60, bus: 0, tractor: 100, quad: 40, bike: 0, tank: 0, boat: 0, plane: 0, heli: 0 };
+  var GLASS_LENS_HP = 320;
+  var PLASTIC_LENS_HP = 900;
   var STEEL_KG_M2 = 7;
   var ALU_KG_M2 = 3.2;
   var kindOf = (c) => {
@@ -12883,7 +12924,9 @@ var GameVehicles = (() => {
         continue;
       }
       if (role === "light") {
-        add({ id, role, name: label, material: "glass", box: box2, mass: 1.2 + 4 * area3, hp: 320, zoneId: id, visual: true, tags: ["light", ...tags] });
+        const lens = /^head/.test(id) ? spec.headlightLens ?? "polycarbonate" : "acrylic";
+        const glassLens = lens === "glass";
+        add({ id, role, name: label, material: glassLens ? "glass" : "plastic", box: box2, mass: 1.2 + 4 * area3, hp: glassLens ? GLASS_LENS_HP : PLASTIC_LENS_HP, zoneId: id, visual: true, tags: ["light", `lens_${lens}`, ...tags] });
         continue;
       }
       if (role === "bumper") {
@@ -13340,21 +13383,188 @@ var GameVehicles = (() => {
     mesh2.geometry = g;
   }
 
+  // src/destructible/door-open.ts
+  var STRIP_SMOOTH_DEG = 180;
+  var SKIN_BAND = 0.05;
+  var BODY_FACING = 0.5;
+  var FIELDS = 4;
+  var SEAM_THIN = 0.03;
+  var SEAM_AT_EDGE = 0.04;
+  var SEAM_TALL = 0.4;
+  var SLIVER_AREA = 1e-10;
+  function cutStripOverDoor(vehicleKit, params) {
+    const kit = vehicleKit;
+    const strip = params.strip;
+    const toVehicle = params.toVehicle;
+    const { x0, x1 } = params;
+    const THREE = kit.THREE;
+    const at = new THREE.Vector3();
+    const along = (x, y, z) => at.set(x, y, z).applyMatrix4(toVehicle).x;
+    const piece = (tests) => {
+      const mesh2 = new THREE.Mesh(strip.geometry.clone(), strip.material);
+      kit.cutMesh(mesh2, tests, STRIP_SMOOTH_DEG, {});
+      return mesh2;
+    };
+    const over = piece([{ sdf: (x, y, z) => along(x, y, z) - x0 }, { sdf: (x, y, z) => x1 - along(x, y, z) }]);
+    const after = piece([{ sdf: (x, y, z) => along(x, y, z) - x1 }]);
+    kit.cutMesh(strip, [{ sdf: (x, y, z) => x0 - along(x, y, z) }], STRIP_SMOOTH_DEG, {});
+    const joined = joinTriangles(THREE, strip.geometry, after.geometry);
+    strip.geometry.dispose();
+    after.geometry.dispose();
+    strip.geometry = joined;
+    return over;
+  }
+  function joinTriangles(THREE, first, second) {
+    const a = first.index ? first.toNonIndexed() : first;
+    const b = second.index ? second.toNonIndexed() : second;
+    const flags = [...solidTriangles(THREE, a), ...solidTriangles(THREE, b)];
+    const both = new THREE.BufferGeometry();
+    for (const name of Object.keys(a.attributes)) {
+      const p = a.getAttribute(name);
+      const q = b.getAttribute(name);
+      if (!q || q.itemSize !== p.itemSize) continue;
+      const array = new Float32Array(p.array.length + q.array.length);
+      array.set(p.array, 0);
+      array.set(q.array, p.array.length);
+      both.setAttribute(name, new THREE.Float32BufferAttribute(array, p.itemSize));
+    }
+    if (a !== first) a.dispose();
+    if (b !== second) b.dispose();
+    const out = pickTriangles(THREE, both, flags, true) ?? new THREE.BufferGeometry();
+    both.dispose();
+    return out;
+  }
+  function solidTriangles(THREE, geometry) {
+    const pos = geometry.getAttribute("position");
+    const triangle = new THREE.Triangle();
+    const flags = [];
+    for (let t = 0; t * 3 + 2 < pos.count; t++) {
+      triangle.a.fromBufferAttribute(pos, t * 3);
+      triangle.b.fromBufferAttribute(pos, t * 3 + 1);
+      triangle.c.fromBufferAttribute(pos, t * 3 + 2);
+      flags.push(triangle.getArea() > SLIVER_AREA);
+    }
+    return flags;
+  }
+  function splitDoorSkin(three, meshes, toVehicleOf, side2, depth) {
+    const THREE = three;
+    const pieces = meshes;
+    const toVehicle = toVehicleOf;
+    const v = new THREE.Vector3();
+    const corners = [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()];
+    const triangle = new THREE.Triangle();
+    const centres = pieces.map((mesh2) => {
+      const geometry = mesh2.geometry.index ? mesh2.geometry.toNonIndexed() : mesh2.geometry;
+      const matrix = toVehicle(mesh2);
+      const pos = geometry.getAttribute("position");
+      const out = new Float32Array(pos.count / 3 * FIELDS);
+      for (let t = 0; t * 3 + 2 < pos.count; t++) {
+        let y = 0;
+        let across = 0;
+        for (let k = 0; k < 3; k++) {
+          corners[k].fromBufferAttribute(pos, t * 3 + k).applyMatrix4(matrix);
+          y += corners[k].y / 3;
+          across += side2 * corners[k].z / 3;
+        }
+        out[t * FIELDS] = y;
+        out[t * FIELDS + 1] = across;
+        triangle.set(corners[0], corners[1], corners[2]).getNormal(v);
+        out[t * FIELDS + 2] = v.y;
+        out[t * FIELDS + 3] = v.x;
+      }
+      return { geometry, out };
+    });
+    const outer = /* @__PURE__ */ new Map();
+    for (const { out } of centres)
+      for (let t = 0; t * FIELDS < out.length; t++) {
+        const band = Math.floor(out[t * FIELDS] / SKIN_BAND);
+        outer.set(band, Math.max(outer.get(band) ?? -Infinity, out[t * FIELDS + 1]));
+      }
+    const surfaceAt = (y) => {
+      const band = Math.floor(y / SKIN_BAND);
+      return Math.max(outer.get(band - 1) ?? -Infinity, outer.get(band) ?? -Infinity, outer.get(band + 1) ?? -Infinity);
+    };
+    return centres.map(({ geometry, out }, i) => {
+      const near = [];
+      for (let t = 0; t * FIELDS < out.length; t++) {
+        const f = t * FIELDS;
+        const body = out[f + 1] < surfaceAt(out[f]) - depth && (out[f + 2] < -BODY_FACING || Math.abs(out[f + 3]) > BODY_FACING);
+        near.push(!body);
+      }
+      const result = { skin: pickTriangles(THREE, geometry, near, true), deep: pickTriangles(THREE, geometry, near, false) };
+      if (geometry !== pieces[i].geometry) geometry.dispose();
+      return result;
+    });
+  }
+  function leaveDeepSkinOnBody(three, meshes, params) {
+    const THREE = three;
+    const pieces = meshes;
+    const toVehicle = params.toVehicle;
+    const { side: side2, depth } = params;
+    const split = splitDoorSkin(THREE, pieces, (mesh2) => new THREE.Matrix4().multiplyMatrices(toVehicle, mesh2.matrixWorld), side2, depth);
+    split.forEach(({ skin, deep }, i) => {
+      const piece = pieces[i];
+      if (!deep || !skin || !piece.parent) return;
+      const body = new THREE.Mesh(deep, piece.material);
+      body.position.copy(piece.position);
+      body.quaternion.copy(piece.quaternion);
+      body.scale.copy(piece.scale);
+      body.castShadow = piece.castShadow;
+      body.receiveShadow = piece.receiveShadow;
+      piece.parent.add(body);
+      piece.geometry.dispose();
+      piece.geometry = skin;
+    });
+  }
+  function pickTriangles(THREE, geometry, flags, wanted) {
+    const count = flags.filter((flag) => flag === wanted).length;
+    if (!count) return null;
+    const out = new THREE.BufferGeometry();
+    for (const name of Object.keys(geometry.attributes)) {
+      const attribute = geometry.getAttribute(name);
+      const size = attribute.itemSize;
+      const source = attribute.array;
+      const array = new Float32Array(count * 3 * size);
+      let w = 0;
+      flags.forEach((flag, t) => {
+        if (flag !== wanted) return;
+        array.set(source.subarray(t * 3 * size, (t + 1) * 3 * size), w);
+        w += 3 * size;
+      });
+      out.setAttribute(name, new THREE.Float32BufferAttribute(array, size));
+    }
+    out.computeBoundingBox();
+    out.computeBoundingSphere();
+    return out;
+  }
+  function isDoorSeam(three, params) {
+    const THREE = three;
+    const box2 = params.box;
+    const { zone, side: side2, dark } = params;
+    if (!dark || box2.isEmpty()) return false;
+    const size = box2.getSize(new THREE.Vector3());
+    const centre = box2.getCenter(new THREE.Vector3());
+    if (Math.sign(centre.z) !== Math.sign(side2) || size.x > SEAM_THIN || size.z > SEAM_THIN || size.y < (zone.y1 - zone.y0) * SEAM_TALL) return false;
+    if (centre.y < zone.y0 || centre.y > zone.y1) return false;
+    return Math.abs(centre.x - zone.x0) < SEAM_AT_EDGE || Math.abs(centre.x - zone.x1) < SEAM_AT_EDGE;
+  }
+
   // src/destructible/visual.ts
   var HOLE_DECAL_SCALE = 2.4;
   var DOOR_DEPTH = 0.07;
+  var DOOR_SKIN_DEPTH = 0.09;
+  var DOOR_FLOOR_DEPTH = 0.2;
   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.08;
+  var DOOR_STRIP_THIN = 0.13;
   var DOOR_STRIP_NEAR = 0.04;
   var DOOR_STRIP_TALL = 0.22;
-  var STRIP_SMOOTH_DEG = 180;
-  var DOOR_STRIP_VERTICES = 2e4;
+  var DOOR_STRIP_VERTICES = 6e4;
   var DOOR_SILL = 0.25;
-  var DOOR_STRIP_OVER = 0.3;
+  var DOOR_STRIP_OVER = 0.05;
   var DOOR_TOP_OVER_PANE = 0.03;
   var HOLE_TEXTURE_SIZE = 64;
   var LAMINATED_HP = 1e3;
@@ -13463,6 +13673,10 @@ var GameVehicles = (() => {
       __publicField(this, "skins", /* @__PURE__ */ new Map());
       /** How high each door's cut reaches. */
       __publicField(this, "doorTops", /* @__PURE__ */ new Map());
+      /** The shut lines drawn on the body at a door's edges, by line: the doors whose edge it marks. Shown only while all of them are closed. */
+      __publicField(this, "seams", /* @__PURE__ */ new Map());
+      /** Doors and lids standing open now. */
+      __publicField(this, "openNow", /* @__PURE__ */ new Set());
       __publicField(this, "lightsOn", true);
       /** Heavy body meshes whose triangle index is still to build (null once done). */
       __publicField(this, "warming");
@@ -13644,6 +13858,11 @@ var GameVehicles = (() => {
         }
         panel.visible = open && !this.skins.get(id);
         recess.visible = open && !this.skins.get(id);
+        if (open) this.openNow.add(id);
+        else this.openNow.delete(id);
+        this.seams.forEach((doors, seam) => {
+          if (doors.has(id)) seam.visible = ![...doors].some((door) => this.openNow.has(door));
+        });
       };
       const euler = piv.rotation;
       const quaternion = piv.quaternion;
@@ -13686,11 +13905,13 @@ var GameVehicles = (() => {
           const pcs = I.cutPanel(this.c, z, rect, true, dirty, { anyN: true }).map((x) => x.mesh).filter((m) => !!m);
           this.mend(dirty);
           if (pcs.length) {
+            leaveDeepSkinOnBody(this.THREE, pcs, { toVehicle: inv, side: z.side < 0 ? -1 : 1, depth: DOOR_SKIN_DEPTH });
             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);
             const frames = this.framesAround(panes, inv);
-            objs = [...pcs, ...I.followersIn(this.c, z, inv), ...panes, ...seals, ...mirrors, ...frames];
+            const followers = I.followersIn(this.c, z, inv).filter((o) => !this.takeSeam(o, id, z, inv) && !this.inFloor(o, piv, z, inv));
+            objs = [...pcs, ...followers, ...panes, ...seals, ...mirrors, ...frames];
           }
         } else {
           const pcs = this.cutZone(z);
@@ -13718,6 +13939,25 @@ var GameVehicles = (() => {
       this.c.root.updateMatrixWorld(true);
       return objs.length > 0;
     }
+    /** A thin part at the foot of the opening, well inside the skin (a step, a sill trim, a rail on the floor), is the floor's: it does not swing with the door. */
+    inFloor(o, piv, z, inv) {
+      const side2 = z.side < 0 ? -1 : 1;
+      const centre = this.I.localBox(this.c, o, inv).getCenter(new this.THREE.Vector3());
+      const skin = side2 * (piv.position.z - side2 * 0.016);
+      return centre.y < z.box.y0 + DOOR_SILL && side2 * centre.z < skin - DOOR_FLOOR_DEPTH;
+    }
+    /** A shut line drawn at the door's edge stays on the body, hidden while a door it marks stands open; answers whether `o` is one. */
+    takeSeam(o, id, z, inv) {
+      const B = z.box;
+      const box2 = this.I.localBox(this.c, o, inv);
+      const color2 = o.material?.color;
+      const dark = !!color2 && color2.getHSL({ h: 0, s: 0, l: 0 }).l < DOOR_LINER_DARK;
+      if (!o.isMesh || !isDoorSeam(this.THREE, { box: box2, zone: { x0: B.x0, x1: B.x1, y0: B.y0, y1: B.y1 }, side: z.side, dark })) return false;
+      const doors = this.seams.get(o) ?? /* @__PURE__ */ new Set();
+      doors.add(id);
+      this.seams.set(o, doors);
+      return true;
+    }
     /** A door has edges: a band that follows the skin all round closes it to its card and hides where the cut followed the triangles of the shell; the same band, in the same paint as on a real car, lines the opening. */
     doorEdges(piv, z, y1) {
       const THREE = this.THREE;
@@ -13739,13 +13979,15 @@ var GameVehicles = (() => {
         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 band = (lift, path, closed) => {
         const position = [];
         const index = [];
-        loop.forEach(([x, y], i) => {
-          position.push(x, y, heights[i] + side2 * lift, x, y, heights[i] + side2 * (lift - DOOR_DEPTH));
+        path.forEach((at, i) => {
+          const [x, y] = loop[at];
+          position.push(x, y, heights[at] + side2 * lift, x, y, heights[at] + side2 * (lift - DOOR_DEPTH));
+          if (!closed && i === path.length - 1) return;
           const a = i * 2;
-          const b = (i + 1) % loop.length * 2;
+          const b = (i + 1) % path.length * 2;
           index.push(a, a + 1, b, b, a + 1, b + 1);
         });
         const g = new THREE.BufferGeometry();
@@ -13773,8 +14015,11 @@ var GameVehicles = (() => {
       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);
+      const all = loop.map((_, i) => i);
+      const top = 2 * DOOR_EDGE_PIECES;
+      const sides = [...all.slice(3 * DOOR_EDGE_PIECES), ...all.slice(0, top + 1)];
+      const edges = new THREE.Mesh(band(2e-3, all, true), paint);
+      const lining = new THREE.Mesh(band(2e-3, sides, false), paint);
       for (const m of [edges, lining]) {
         m.userData.noFollow = true;
         m.castShadow = false;
@@ -13831,26 +14076,14 @@ var GameVehicles = (() => {
         const box2 = this.I.localBox(this.c, o, inv);
         const size = box2.getSize(new THREE.Vector3());
         const mid = box2.getCenter(new THREE.Vector3());
-        if (Math.sign(mid.z) !== Math.sign(z.side) || size.z > DOOR_STRIP_THIN || size.y > DOOR_STRIP_TALL || Math.min(box2.max.x, x1) - Math.max(box2.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(box2.max.x, x1) - Math.max(box2.min.x, 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);
-        };
-        const over = new THREE.Mesh(o.geometry.clone(), o.material);
+        const over = cutStripOverDoor(this.kit, { strip: o, toVehicle, x0, x1 });
         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);
       }
@@ -14431,11 +14664,18 @@ var GameVehicles = (() => {
         }
       }
     }
+    /** The lens of a light is holed or cracked and stays; `pierced`: a round went through it to the bulb, and the lamp goes dark. */
+    crackLight(p, pierced) {
+      const z = this.zone(p);
+      if (!z) return;
+      for (const L of z.lights) this.kit.crackLight(this.c, L, new this.THREE.Vector3(p.box.center[0] > 0 ? -1 : 1, 0, 0), pierced);
+    }
     /** The lens of a light breaks and its unit stays (damaged) or goes (destroyed). */
     breakLight(p, gone) {
       const z = this.zone(p);
       if (!z) return;
       for (const L of z.lights) {
+        L.lensMaterial = p.material;
         this.kit.breakLight(this.c, L, new this.THREE.Vector3(p.box.center[0] > 0 ? -1 : 1, 0, 0));
         if (gone) {
           if (L.group) L.group.visible = false;
@@ -15081,6 +15321,7 @@ var GameVehicles = (() => {
       wear(p, amount, out);
       syncZone(p);
       if (p.hp <= 0) lose(p, "broken", out, cause);
+      else if (p.def.role === "light") vis?.crackLight(p.def, dtype === "ballistic");
       if (p.def.role === "tyre" && !p.flat && p.hp < p.def.hp * 0.6 && !p.lost) {
         p.flat = true;
         vis?.tyreFlat(p.def, 0.24);
@@ -15893,7 +16134,7 @@ var GameVehicles = (() => {
           if (!list2.length) return 1;
           return Math.min(...list2.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 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), rim: p.lost }));
         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;