@adatechnology/game-vehicles 0.1.12 → 0.3.0

package/dist/index.js

@@ -2,6 +2,9 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
+// src/kit.ts
+import { shapeGeometries } from "@adatechnology/game-shapes-three";
+
 // src/locales/en.json
 var en_default = {
   plate: {
@@ -837,9 +840,11 @@ function installGeometry(kit) {
   const V3 = THREE.Vector3;
   const PI = Math.PI;
   const I = kit._;
+  const lod = kit.lod;
   function roundedBoxGeometry(w, h, d, r) {
     r = Math.max(2e-3, Math.min(r, w * 0.45, h * 0.45, d * 0.45));
-    const nb = 3;
+    if (lod.on && (r < 0.012 || Math.max(w, h, d) < lod.flatBoxEdge || Math.min(w, h, d) < 0.08)) return new THREE.BoxGeometry(w, h, d);
+    const nb = lod.on ? lod.roundingRings : 3;
     const n = 2 * nb + 1;
     const g = new THREE.BoxGeometry(1, 1, 1, n, n, n);
     const p = g.attributes.position;
@@ -884,6 +889,7 @@ function installGeometry(kit) {
     geo.computeVertexNormals();
   }
   function subdivide(geo, maxLen) {
+    if (lod.on) maxLen = maxLen * lod.subdivisionFactor;
     const src = geo.index ? geo.toNonIndexed() : geo;
     const a = src.attributes.position.array;
     const out = [];
@@ -1613,6 +1619,7 @@ function installWarp(kit) {
   const V3 = THREE.Vector3;
   const PI = Math.PI;
   const I = kit._;
+  const lod = kit.lod;
   const { crease } = I;
   function makeWarp(o) {
     function sec(y) {
@@ -1710,6 +1717,7 @@ function installWarp(kit) {
     });
   }
   function resample(st, n) {
+    if (lod.on) n = Math.max(lod.minStations, Math.round(n * lod.stationFraction));
     const out = [];
     const L = st.length;
     function P(i) {
@@ -1741,6 +1749,7 @@ function installWarp(kit) {
   }
   function smoothLoft(st, o) {
     o = o || {};
+    if (lod.on) o = Object.assign({}, o, { seg: Math.max(lod.minLoftSegments, Math.round((o.seg || 24) * lod.loftSegmentFraction)) });
     if (o.smooth) st = resample(st, o.smooth);
     const seg = o.seg || 24;
     const pos = [];
@@ -9755,16 +9764,167 @@ function installUi(kit) {
   kit.ui = { damageMap, bandButtons, legend, healthBar, scenarioButtons, zoneLabel, bandRange, css, injectStyles };
 }
 
+// src/lod.ts
+var defaultLodSettings = {
+  on: false,
+  segmentFraction: 0.5,
+  roundingRings: 1,
+  subdivisionFactor: 2.2,
+  flatBoxEdge: 0.22,
+  minLoftSegments: 14,
+  loftSegmentFraction: 0.45,
+  minStations: 20,
+  stationFraction: 0.55,
+  gridFactor: 2.6,
+  hiddenMaterials: ["seat", "carpet", "headliner", "gauge", "screen", "bay", "hoodLiner", "block", "cover", "radiator", "coolant", "coolantLiq", "washer", "hv", "hose", "leather"]
+};
+function createLod(options) {
+  return { ...defaultLodSettings, ...options || {}, on: false };
+}
+var fewer = (lod, n, min) => Math.max(min, Math.round(n * lod.segmentFraction));
+function wrapThreeForLod(TH, lod) {
+  const T = Object.assign({}, TH);
+  if (TH.SRGBColorSpace) {
+    T.CanvasTexture = class extends TH.CanvasTexture {
+      constructor(a, b, c, d, e, f, g, h, i) {
+        super(a, b, c, d, e, f, g, h, i);
+        this.colorSpace = TH.SRGBColorSpace;
+      }
+    };
+  }
+  T.CylinderGeometry = class extends TH.CylinderGeometry {
+    constructor(rt, rb, h, rs, hs, open, ts, tl) {
+      super(rt, rb, h, lod.on && rs != null ? fewer(lod, rs, 6) : rs, lod.on ? 1 : hs, open, ts, tl);
+    }
+  };
+  T.SphereGeometry = class extends TH.SphereGeometry {
+    constructor(r, ws, hs, ps, pl, ts, tl) {
+      super(r, lod.on && ws != null ? fewer(lod, ws, 8) : ws, lod.on && hs != null ? fewer(lod, hs, 5) : hs, ps, pl, ts, tl);
+    }
+  };
+  T.TorusGeometry = class extends TH.TorusGeometry {
+    constructor(r, tube, rs, ts, arc) {
+      super(r, tube, lod.on && rs != null ? fewer(lod, rs, 4) : rs, lod.on && ts != null ? fewer(lod, ts, 8) : ts, arc);
+    }
+  };
+  T.LatheGeometry = class extends TH.LatheGeometry {
+    constructor(pts, seg, a, b) {
+      super(pts, lod.on && seg != null ? fewer(lod, seg, 10) : seg, a, b);
+    }
+  };
+  T.TubeGeometry = class extends TH.TubeGeometry {
+    constructor(path, ts, r, rs, closed) {
+      if (lod.on) {
+        let len = 1;
+        try {
+          len = path.getLength();
+        } catch (e) {
+        }
+        ts = Math.max(6, Math.min(ts == null ? 64 : ts, Math.ceil(len / 0.14)));
+        rs = r < 0.025 ? 3 : Math.max(4, fewer(lod, rs == null ? 8 : rs, 4));
+      }
+      super(path, ts, r, rs, closed);
+    }
+  };
+  T.ExtrudeGeometry = class extends TH.ExtrudeGeometry {
+    constructor(shape, o) {
+      if (lod.on && o) {
+        o = Object.assign({}, o);
+        if (o.curveSegments) o.curveSegments = fewer(lod, o.curveSegments, 5);
+        if (o.bevelSegments) o.bevelSegments = Math.max(1, Math.round(o.bevelSegments * 0.5));
+      }
+      super(shape, o);
+    }
+  };
+  T.CircleGeometry = class extends TH.CircleGeometry {
+    constructor(r, seg, a, b) {
+      super(r, lod.on && seg != null ? fewer(lod, seg, 8) : seg, a, b);
+    }
+  };
+  T.RingGeometry = class extends TH.RingGeometry {
+    constructor(a, b, ts, ps, c, d) {
+      super(a, b, lod.on && ts != null ? fewer(lod, ts, 8) : ts, ps, c, d);
+    }
+  };
+  return T;
+}
+var INTERIOR_FUNCTIONS = ["interior", "engineBay", "seat", "dashboard", "steeringWheel", "yoke", "busRows"];
+function installLod(kit) {
+  const lod = kit.lod;
+  const meshesOf = (c) => {
+    const set = /* @__PURE__ */ new Set();
+    c.vehicle.traverse((o) => {
+      if (o.isMesh) set.add(o);
+    });
+    return set;
+  };
+  for (const name of INTERIOR_FUNCTIONS) {
+    const original = kit[name];
+    if (typeof original !== "function") continue;
+    kit[name] = function(...args) {
+      const c = args[0];
+      if (!lod.on || !c || !c.vehicle) return original.apply(this, args);
+      const before = meshesOf(c);
+      const result = original.apply(this, args);
+      c.vehicle.traverse((o) => {
+        if (o.isMesh && !before.has(o)) o.userData.skipLite = true;
+      });
+      return result;
+    };
+  }
+  kit.lodHiddenMaterials = function() {
+    const materials = kit.materials;
+    return new Set(lod.hiddenMaterials.map((name) => materials[name]).filter(Boolean));
+  };
+}
+
+// src/damageables.ts
+var defaultDamageableKinds = {
+  door: { material: "metal", part: "door" },
+  hood: { material: "metal", part: "hood" },
+  lid: { material: "metal", part: "lid" },
+  bumper: { material: "metal", part: "bumper" },
+  glass: { material: "glass", part: "window" },
+  "glass:windshield": { material: "glass", part: "windshield" },
+  light: { material: "glass", part: "headlight" },
+  "light:taillight": { material: "glass", part: "taillight" },
+  wheel: { material: "rubber", part: "wheel" },
+  "internal:fuel_tank": { material: "fuel", part: "fuel_tank" }
+};
+function installDamageables(kit) {
+  const THREE = kit.THREE;
+  kit.damageableKinds = { ...defaultDamageableKinds };
+  const kindOf2 = (zone) => {
+    const kinds = kit.damageableKinds;
+    if (zone.type === "internal") return zone.sub ? kinds[`internal:${zone.sub}`] || null : null;
+    return kinds[`${zone.type}:${zone.fxKey}`] || kinds[zone.type] || null;
+  };
+  kit.damageables = function(c, matrix) {
+    const out = [];
+    for (const zone of c.zones || []) {
+      const kind = kindOf2(zone);
+      if (!kind || !zone.box) continue;
+      const b = zone.box;
+      const box = new THREE.Box3(new THREE.Vector3(b.x0, b.y0, b.z0), new THREE.Vector3(b.x1, b.y1, b.z1));
+      if (matrix) box.applyMatrix4(matrix);
+      out.push({ material: kind.material, zone: zone.id, part: kind.part, side: zone.side === 0 ? "center" : zone.side < 0 ? "left" : "right", box });
+    }
+    return out;
+  };
+}
+
 // src/kit.ts
 function createVehicleKit(options) {
   const opts = options || {};
-  const THREE = opts.THREE;
-  if (!THREE || !THREE.Vector3) throw new Error("createVehicleKit: options.THREE (the three.js namespace) is required");
+  if (!opts.THREE || !opts.THREE.Vector3) throw new Error("createVehicleKit: options.THREE (the three.js namespace) is required");
+  const lod = createLod(opts.lod);
+  const THREE = wrapThreeForLod(shapeGeometries(opts.THREE), lod);
   const strings = resolveStrings(opts.locale);
   const t = createTranslate(strings);
   const doc = opts.document || (typeof document !== "undefined" ? document : void 0);
   const kit = {
     THREE,
+    lod,
     V3: THREE.Vector3,
     PI: Math.PI,
     document: doc,
@@ -9836,6 +9996,8 @@ function createVehicleKit(options) {
   installZoneApply(kit);
   installScenarios(kit);
   installUi(kit);
+  installLod(kit);
+  installDamageables(kit);
   const I = kit._;
   const HOOKS = {};
   kit.on = function(ev, fn) {
@@ -9930,9 +10092,18 @@ function createVehicleKit(options) {
     }
   }
   kit.defaultDamage = defaultDamage;
-  kit.build = function(key, state, zoneState) {
+  kit.build = function(key, state, zoneState, options2) {
     const spec = kit.find(key);
     if (!spec) throw new Error("Unknown vehicle: " + key);
+    const lodBefore = lod.on;
+    if (options2 && options2.lod != null) lod.on = !!options2.lod;
+    try {
+      return buildVehicle(spec, key, state, zoneState);
+    } finally {
+      lod.on = lodBefore;
+    }
+  };
+  function buildVehicle(spec, key, state, zoneState) {
     const st = state || "intact";
     const seedKey = spec.seedKey || key;
     const c = new kit.BuildContext(st, strHash(seedKey + (LEGACY_STATES[st] || st)));
@@ -9981,7 +10152,7 @@ function createVehicleKit(options) {
       if (o.isMesh && !(o.material && o.material.transparent)) o.receiveShadow = true;
     });
     return c;
-  };
+  }
   kit.dispose = function(c) {
     const shared = Object.values(I.PARTICLE_GEOMETRIES);
     c.root.traverse(function(o) {
@@ -9998,8 +10169,9 @@ function createVehicleKit(options) {
     assignDeep(strings, resolveStrings(opts.locale));
     return kit;
   };
-  const { THREE: _three, locale: _locale, document: _document, plugins, ...config } = opts;
+  const { THREE: _three, lod: _lod, locale: _locale, document: _document, plugins, ...config } = opts;
   void _three;
+  void _lod;
   void _locale;
   void _document;
   kit.configure(config);
@@ -10007,6 +10179,9 @@ function createVehicleKit(options) {
   return kit;
 }
 
+// src/destructible/impl.ts
+import { ignitionChance, resolveIgnitionRules, sparkTargetFactor } from "@adatechnology/game-contracts";
+
 // src/destructible/model.ts
 var JOINT_RULES = {
   hinge: { strength: 5e3, tools: ["wrench", "screwdriver"], seconds: 3 },
@@ -11119,6 +11294,9 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
   const headless = !!options.headless;
   const seedBase = strHash(`${c.key}|${id}|${options.seed ?? 0}`);
   let rand = rng(seedBase);
+  const ignitionRules = resolveIgnitionRules(options.ignition);
+  const fuelFraction = clamp(options.fuel ?? 1, 0, 1);
+  let igniteRand = rng(strHash(`${c.key}|${id}|ignition|${options.seed ?? 0}`));
   let clock = 0;
   let model;
   let vis = null;
@@ -11186,7 +11364,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
         dents: [],
         holes: [],
         cracks: [],
-        liters: d.contains?.liters,
+        liters: d.contains ? d.role === "fuel_tank" ? d.contains.liters * fuelFraction : d.contains.liters : void 0,
         lost: false,
         status: "intact",
         flat: false,
@@ -11204,6 +11382,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     wasLit = true;
     deadEngine = false;
     rand = rng(seedBase);
+    igniteRand = rng(strHash(`${c.key}|${id}|ignition|${options.seed ?? 0}`));
     steerSign = rand() < 0.5 ? -1 : 1;
     vis = headless ? null : new VehicleVisuals(kit, c, model);
     recomputeGroups();
@@ -11498,8 +11677,19 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
       if (!p.burning && p.temp > AMBIENT) p.temp = Math.max(AMBIENT, p.temp - dt * 6);
     }
     for (const f of flames) heat(centreOf(f.def), 0.8, 500, dt * 0.5, out, 0);
+    fireNearLeak(flames, dt, out);
     thermal(out);
   };
+  const fireNearLeak = (flames, dt, out) => {
+    const tank = tankPart();
+    const leak = tank ? leaks.get(tank.def.id) : void 0;
+    if (!tank || !leak || tank.lost || tank.burning || exploded || leak.fluid !== "fuel" && leak.fluid !== "diesel") return;
+    if (leak.pud?.fire) return light(tank, out);
+    const { radius, chancePerSecond } = ignitionRules.fireNear;
+    if (chancePerSecond <= 0) return;
+    const near = flames.some((f) => f !== tank && distToBox(tank.def, centreOf(f.def)) - Math.max(...f.def.box.size) / 2 <= radius);
+    if (near && igniteRand() < 1 - Math.exp(-chancePerSecond * dt)) light(tank, out);
+  };
   const normalOf = (d, v) => faceNormal(d, v);
   const ballistic = (h, out) => {
     sync();
@@ -11567,10 +11757,21 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
         let amount = through ? E * 0.6 : E * 0.25;
         if (through && (d.role === "battery" || d.role === "alternator")) amount = Math.max(amount, p.hp * 0.65);
         damage(p, amount, "ballistic", h.source, out, worldPoint);
-        if (d.role === "fuel_tank" && E > 1500 && (p.liters ?? 0) > 1) p.temp = Math.max(p.temp, d.ignitionC ?? 260);
+        if (through && d.role === "fuel_tank") rollIgnition(p, h, metal, out);
       }
     }
   };
+  const light = (tank, out) => {
+    tank.temp = Math.max(tank.temp, (tank.def.ignitionC ?? 260) + 1);
+    if ((tank.liters ?? 0) > 0.5) ignite(tank, out);
+  };
+  const rollIgnition = (tank, h, metal, out) => {
+    const d = tank.def;
+    if (!d.contains || tank.burning || (tank.liters ?? 0) <= 0.05) return;
+    const fill = d.contains.liters > 0 ? (tank.liters ?? 0) / d.contains.liters : 0;
+    const chance = ignitionChance(h, { sparkTarget: sparkTargetFactor(d.material, metal, ignitionRules), fill, fluid: d.contains.fluid }, ignitionRules);
+    if (chance > 0 && igniteRand() < chance) light(tank, out);
+  };
   const blunt = (h, out) => {
     sync();
     const M = toFrameMatrix();
@@ -11634,7 +11835,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
         const verdict = kit.blastDamage(c, E / (1 + dist * dist * 4) / 50);
         if (verdict === "explosion") explode(tank, h.source, out);
         else if (verdict === "fire") {
-          tank.temp = Math.max(tank.temp, tank.def.ignitionC ?? 260);
+          light(tank, out);
           startLeak(tank, centreOf(tank.def).setY(tank.def.box.center[1] - tank.def.box.size[1] / 2 + 0.05), 12, out, dir);
         }
       }
@@ -11953,7 +12154,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
 // src/destructible/item.ts
 function buildVehicleItem(kit, key, options = {}) {
   const THREE = kit.THREE;
-  const vehicle = kit.build(key, options.state ?? "intact");
+  const vehicle = options.lod ? kit.build(key, options.state ?? "intact", void 0, { lod: true }) : kit.build(key, options.state ?? "intact");
   const m = vehicle.meta;
   const root = new THREE.Group();
   root.name = key;
@@ -11973,9 +12174,12 @@ export {
   buildVehicleItem,
   buildVehicleModel,
   clamp,
+  createLod,
   createTranslate,
   createVehicleDestructible,
   createVehicleKit,
+  defaultDamageableKinds,
+  defaultLodSettings,
   format,
   hash,
   legacyGlassId,
@@ -11987,6 +12191,7 @@ export {
   resolveStrings,
   rng,
   smooth,
-  strHash
+  strHash,
+  wrapThreeForLod
 };
 //# sourceMappingURL=index.js.map