@adatechnology/game-vehicles 0.4.6 → 0.5.0

package/README.md

@@ -258,6 +258,12 @@ come in `Hit.ignition` (the weapons build them from the core and jacket of the a
 easiest, a full one mostly leaks); diesel takes a spark far worse than petrol. `createVehicleDestructible(kit, vehicle, { fuel: 0.1, ignition: { fillCurve, fireNear, sparkTarget } })`;
 the defaults and every number are `IgnitionRules` of `@adatechnology/game-contracts`.
 
+Cabin and smoke: `cabinEnclosure(car, { frame })` is the cabin (`meta.cabin`, from `kit.interior`) as an `Enclosure` in world space, for the host's
+`EffectSink.enclose`: a shut car keeps the smoke out and seeps only at `CABIN_LEAK` (2 % per second), more with cracked glass. It is open where a door
+or lid stands open (past 6 % of its swing), where a window shattered and where a door, glass, roof or panel was torn off or burnt away; a bullet hole
+lets smoke in at the hole at a rate that grows with its area (a 9 mm hole about 0.2 a second). `null` for a vehicle with no cabin (a bike) or one
+destroyed. `createCabinSmoke()` of `game-vehicles-three` keeps a host told every frame.
+
 ## Português
 
 Motor genérico de veículos procedurais para three.js: carrocerias, vidros, faróis, rodas, interiores, capô e compartimento do motor, **zonas de dano

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ToolKind, JointKind, Vec3, MaterialId, DestructibleImpl, AnimationClipSpec, IgnitionRules } from '@adatechnology/game-contracts';
+import { MaterialId, Vec3, JointKind, ToolKind, DestructibleImpl, AnimationClipSpec, IgnitionRules, ObjectState, Enclosure } from '@adatechnology/game-contracts';
 
 /**
  * Light mode ("lite"): the same vehicles with fewer triangles, for a whole street of them. Port of the `[LOD]` hooks of the team's Frota Leve
@@ -917,4 +917,44 @@ 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 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 };
+/**
+ * The cabin of a vehicle as a closed space for the smoke, dust and steam of the host's effects (`EffectSink.enclose` of the contracts): a shut car
+ * keeps the smoke out. It is open where it is in the real world: a door standing open, a window shattered, a door, glass or roof torn off or burnt
+ * away; a bullet hole lets a little in at a rate that grows with its size, and the gaps of a shut door let a trace in.
+ */
+
+/** The cabin box a vehicle with an interior records (`kit.interior`), in the vehicle's own space: x along it, `z` the inner half width. */
+interface CabinBox {
+    readonly x0: number;
+    readonly x1: number;
+    readonly y0: number;
+    readonly y1: number;
+    readonly z: number;
+}
+/** What the cabin enclosure reads of a vehicle: its parts and their state (any `DestructibleImpl` of a vehicle has these). */
+interface CabinSource {
+    readonly vehicle: VehicleContext;
+    readonly model: VehicleModel;
+    state(): ObjectState;
+}
+interface CabinEnclosureOptions {
+    /** The object the destructible answers in (its `frame` option, where the host placed the vehicle): the holes of `state()` are in its space. Default `vehicle.root`. */
+    readonly frame?: any;
+    /** Gaps of the shut doors and vents, share per second of the smoke pressing on the closed shell (default {@link CABIN_LEAK}). */
+    readonly leak?: number;
+    /** How open a door or lid has to be (share of its full swing) to count as open (default 0.06: ajar). */
+    readonly ajar?: number;
+}
+/** The gaps of a shut car (door seals, the vents, the dash): about 2 % per second of what presses on it seeps in. */
+declare const CABIN_LEAK = 0.02;
+/** The cabin box of a vehicle, or `null` when it has none (a bike, a vehicle with no interior). */
+declare function cabinBoxOf(vehicle: VehicleContext): CabinBox | null;
+/** How far a door or lid stands open, 0 shut to 1 at the end of its clip: the turn of its drawn hinge from rest (the room poses it by the part id). */
+declare function swingOf(vehicle: VehicleContext, partId: string): number;
+/**
+ * The cabin of `source` as an `Enclosure` in world space, or `null` when there is no closed cabin (no interior, the vehicle exploded, every shell
+ * part gone). Call it each frame, or when the vehicle moves or changes, and hand it to `EffectSink.enclose`.
+ */
+declare function cabinEnclosure(source: CabinSource, options?: CabinEnclosureOptions): Enclosure | null;
+
+export { type Band, type BandId, type BandIndex, type BandOverride, type BuildFunction, type BuildOptions, type BuildState, type BuildZoneState, CABIN_LEAK, type CabinBox, type CabinEnclosureOptions, type CabinSource, 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, cabinBoxOf, cabinEnclosure, clamp, 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

@@ -23,12 +23,15 @@ var GameVehicles = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    CABIN_LEAK: () => CABIN_LEAK,
     JOINT_RULES: () => JOINT_RULES,
     LEGACY_STATES: () => LEGACY_STATES,
     LEGACY_ZONE_IDS: () => LEGACY_ZONE_IDS,
     SEED_SALTS: () => SEED_SALTS,
     buildVehicleItem: () => buildVehicleItem,
     buildVehicleModel: () => buildVehicleModel,
+    cabinBoxOf: () => cabinBoxOf,
+    cabinEnclosure: () => cabinEnclosure,
     clamp: () => clamp,
     createLod: () => createLod,
     createTranslate: () => createTranslate,
@@ -48,6 +51,7 @@ var GameVehicles = (() => {
     rng: () => rng,
     smooth: () => smooth,
     strHash: () => strHash,
+    swingOf: () => swingOf,
     wrapThreeForLod: () => wrapThreeForLod
   });
 
@@ -6661,8 +6665,15 @@ var GameVehicles = (() => {
       x.arc(cx, cy, 26 * s, 0, PI * 2);
       x.fill();
     }
+    const NO_CANVAS = new Proxy(function() {
+    }, { get: () => NO_CANVAS, apply: () => NO_CANVAS, set: () => true });
     function crackGlass(c, msh, p, force, sc) {
       const G = msh.userData.glass;
+      if (G.cracksFreed) {
+        drawWeb(NO_CANVAS, 0, 0, sc != null ? sc : 0.6 + force * 0.5, Math.max(0.4, G.aspect || 1), c.rand);
+        G.hits++;
+        return;
+      }
       if (!G.cv) {
         G.cv = document2.createElement("canvas");
         G.cv.width = G.cv.height = 256;
@@ -6745,6 +6756,14 @@ var GameVehicles = (() => {
       const G = msh.userData.glass;
       if (G.broken) return;
       G.broken = true;
+      const freeCracks = function() {
+        if (!G.tex) return;
+        if (msh.material !== MATERIALS.glassEdge && msh.material?.map === G.tex) msh.material.dispose();
+        G.tex.dispose();
+        G.tex = null;
+        G.cv = null;
+        G.cracksFreed = true;
+      };
       const cubesAt = [];
       if (G.outline && G.T !== void 0) {
         const out = G.outline;
@@ -6778,6 +6797,7 @@ var GameVehicles = (() => {
         geo.computeVertexNormals();
         msh.geometry.dispose();
         msh.geometry = geo;
+        freeCracks();
         msh.material = MATERIALS.glassEdge;
         let minx = 1e9;
         let maxx = -1e9;
@@ -6801,8 +6821,12 @@ var GameVehicles = (() => {
         if (rim) {
           msh.geometry.dispose();
           msh.geometry = rim;
+          freeCracks();
           msh.material = MATERIALS.glassEdge;
-        } else msh.visible = false;
+        } else {
+          freeCracks();
+          msh.visible = false;
+        }
         for (let j = 0; j < 36; j++)
           cubesAt.push(
             new V3(
@@ -14496,6 +14520,90 @@ var GameVehicles = (() => {
     root.userData.vehicle = vehicle;
     return { root, vehicle };
   }
+
+  // src/destructible/enclosure.ts
+  var CABIN_LEAK = 0.02;
+  var HOLE_RATE_PER_AREA = 3e3;
+  var CRACK_GAP_PER_METRE = 0.5;
+  var THROUGH = 0.18;
+  var HOLE_PATCH = 0.12;
+  var FULL_SWING = 1.15;
+  var SHELL_ROLES = /* @__PURE__ */ new Set(["door", "glass", "roof", "lid", "panel", "pillar"]);
+  var GONE = /* @__PURE__ */ new Set(["broken", "melted", "ashes"]);
+  function cabinBoxOf(vehicle) {
+    const cabin = vehicle.meta.cabin;
+    if (!cabin || !(cabin.x1 > cabin.x0) || !(cabin.y1 > cabin.y0) || !(cabin.z > 0)) return null;
+    return cabin;
+  }
+  function swingOf(vehicle, partId) {
+    const pivot = vehicle.vehicle?.getObjectByName?.(partId);
+    const q = pivot?.quaternion;
+    if (!q) return 0;
+    const angle = 2 * Math.acos(Math.min(1, Math.abs(q.w)));
+    return Math.min(1, angle / FULL_SWING);
+  }
+  var overlaps = (b, c, margin) => Math.abs(b.center[0] - (c.x0 + c.x1) / 2) <= b.size[0] / 2 + (c.x1 - c.x0) / 2 + margin && Math.abs(b.center[1] - (c.y0 + c.y1) / 2) <= b.size[1] / 2 + (c.y1 - c.y0) / 2 + margin && Math.abs(b.center[2]) <= b.size[2] / 2 + c.z + margin;
+  function cabinEnclosure(source, options = {}) {
+    const c = source.vehicle;
+    const cabin = cabinBoxOf(c);
+    const node = c.vehicle;
+    if (!cabin || !node?.localToWorld) return null;
+    const state = source.state();
+    if (state.destroyed) return null;
+    const V3 = node.position.constructor;
+    const Quat = node.quaternion.constructor;
+    const mid = [(cabin.x0 + cabin.x1) / 2, (cabin.y0 + cabin.y1) / 2, 0];
+    const half = [(cabin.x1 - cabin.x0) / 2, (cabin.y1 - cabin.y0) / 2, cabin.z];
+    const ajar = options.ajar ?? 0.06;
+    const byId = new Map(state.parts.map((p) => [p.id, p]));
+    const mainGroup = state.groups[0] ? new Set(state.groups[0]) : null;
+    const openings = [];
+    let crackLength = 0;
+    const toCabin = (b) => ({
+      center: [b.center[0] - mid[0], b.center[1] - mid[1], b.center[2] - mid[2]],
+      halfSize: [b.size[0] / 2 + THROUGH, b.size[1] / 2 + THROUGH, b.size[2] / 2 + THROUGH]
+    });
+    node.updateWorldMatrix?.(true, false);
+    const frame = options.frame ?? c.root;
+    frame?.updateWorldMatrix?.(true, false);
+    const inverse = node.matrixWorld.clone().invert();
+    for (const def of source.model.parts) {
+      if (!SHELL_ROLES.has(def.role) || !overlaps(def.box, cabin, 0.12)) continue;
+      const part = byId.get(def.id);
+      if (!part) continue;
+      const gone = GONE.has(part.status) || mainGroup !== null && !mainGroup.has(def.id);
+      const swung = (def.role === "door" || def.role === "lid") && swingOf(c, def.id) > ajar;
+      if (gone || swung) {
+        openings.push(toCabin(def.box));
+        continue;
+      }
+      for (const hole of part.holes) {
+        if (!hole.through && def.material !== "glass") continue;
+        const area3 = Math.PI * (hole.diameter / 2) ** 2;
+        const p = new V3(hole.point[0], hole.point[1], hole.point[2]);
+        if (frame?.localToWorld) frame.localToWorld(p);
+        p.applyMatrix4(inverse);
+        openings.push({
+          center: [p.x - mid[0], p.y - mid[1], p.z - mid[2]],
+          halfSize: [HOLE_PATCH, HOLE_PATCH, HOLE_PATCH],
+          // the patch is far bigger than the hole: only a share of what crosses it passes, more for a bigger hole
+          rate: Math.min(4, area3 * HOLE_RATE_PER_AREA)
+        });
+      }
+      for (const crack of part.cracks) crackLength += crack.length;
+    }
+    const center = node.localToWorld(new V3(mid[0], mid[1], mid[2]));
+    const q = node.getWorldQuaternion(new Quat());
+    const scale = node.getWorldScale(new V3());
+    const leak = (options.leak ?? CABIN_LEAK) * (1 + crackLength * CRACK_GAP_PER_METRE);
+    return {
+      center: [center.x, center.y, center.z],
+      halfSize: [half[0] * Math.abs(scale.x), half[1] * Math.abs(scale.y), half[2] * Math.abs(scale.z)],
+      orientation: [q.x, q.y, q.z, q.w],
+      openings: openings.map((o) => ({ ...o, center: [o.center[0] * scale.x, o.center[1] * scale.y, o.center[2] * scale.z], halfSize: [o.halfSize[0] * Math.abs(scale.x), o.halfSize[1] * Math.abs(scale.y), o.halfSize[2] * Math.abs(scale.z)] })),
+      leak
+    };
+  }
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=index.global.js.map