@adatechnology/game-destruction 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -117,6 +117,13 @@ interface DestructionWorld {
     ids(): string[];
     /** Move an object (the renderer or physics owns transforms; keep the world in sync so world-space hits land). */
     setTransform(id: string, position: Vec3, rotation: Quat): void;
+    /**
+     * Move a part's collision shape (raycast, hits, blast and joint distance) to an object-local pose; the part's spec is unchanged. Animations are
+     * visual, so a host that plays a clip calls this every frame with `rest + clip offset`. `rotation` is Euler XYZ (radians), default none. For a
+     * registered impl it forwards to the optional `DestructibleImpl.setPartPose` and otherwise only moves the world's raycast shape. Dents and holes
+     * stay in object space.
+     */
+    setPartPose(objectId: string, partId: string, position: Vec3, rotation?: Vec3): void;
     /**
      * Split a loose group into its own object (after a `detach`, when the renderer makes the piece a separate body). The parts move with their
      * state; the new object starts at the old object's transform. Returns the new id.
@@ -139,14 +146,24 @@ interface DestructionWorld {
     disassemble(objectId: string, jointId: string, tool: ToolKind, dt: number): number;
     /** Joints of an object that `tool` can undo now (open joints excluded). */
     workableJoints(objectId: string, tool: ToolKind): JointState[];
-    /** Joint nearest to a world point (for "aim at the screw"). */
-    nearestJoint(objectId: string, point: Vec3, maxDistance?: number): JointState | null;
+    /**
+     * Joint nearest to a world point (for "aim at the screw"). With `tool`, the nearest open-able joint that tool can undo within `maxDistance`
+     * wins; only when none qualifies does it fall back to the nearest joint of any kind.
+     */
+    nearestJoint(objectId: string, point: Vec3, maxDistance?: number, tool?: ToolKind): JointState | null;
     /** Put out fire on a part or the whole object, and cool it by `coolC` (default 200). */
     extinguish(objectId: string, partId?: string, coolC?: number): void;
     /** Advance fire, heat transfer, cooling, melting, leaks and delayed explosions. */
     update(dt: number): DestructionEvent[];
+    /**
+     * The object's LIVE state: the same object the world mutates every update (parts, joints, groups). Treat it as read-only and change the world only
+     * through the API (`hit`, `disassemble`, `setLiters`...). Do not keep it across frames to compare "before" and "after": use `snapshot`.
+     */
     state(id: string): ObjectState | null;
+    /** The part's LIVE state (see `state`): read-only, mutated by the world. */
     part(id: string, partId: string): PartState | null;
+    /** A deep copy of the object's state at this moment: safe to keep, compare and mutate. Null for an unknown id. */
+    snapshot(id: string): ObjectState | null;
     /** Repair an object to its spec (test benches use it for "reset"). */
     reset(id: string): void;
     on(type: DestructionEventType | '*', fn: (event: DestructionEvent) => void): () => void;

package/dist/index.global.js

@@ -1136,7 +1136,7 @@ var GameDestruction = (() => {
     {
       id: "green_wood",
       density: 650,
-      hpPerKg: 120,
+      hpPerKg: 5,
       penetration: 10,
       ductility: 0.5,
       fracture: "splinter",
@@ -1145,7 +1145,8 @@ var GameDestruction = (() => {
         0.2
       ],
       damageScale: {
-        slash: 1.3
+        slash: 1.3,
+        ballistic: 0.1
       },
       hitDebris: "splinters",
       breakDebris: "leaves",
@@ -1458,6 +1459,15 @@ var GameDestruction = (() => {
   var clamp2 = (v, a, b) => Math.max(a, Math.min(b, v));
   var isLost = (p) => p.st.status === "broken" || p.st.status === "melted" || p.st.status === "ashes";
   var clone = (v) => structuredClone(v);
+  var updateBound = (o) => {
+    if (!o.parts.length) return;
+    const c = [0, 0, 0];
+    for (const p of o.parts) for (let k = 0; k < 3; k++) c[k] += p.pos[k] / o.parts.length;
+    let r = 0;
+    for (const p of o.parts) r = Math.max(r, vec.distance(c, p.pos) + p.bound);
+    o.bc = c;
+    o.br = r;
+  };
   var AXIS = { x: 0, y: 1, z: 2 };
   var createDestruction = (options = {}) => {
     const materials = /* @__PURE__ */ new Map();
@@ -1593,6 +1603,7 @@ var GameDestruction = (() => {
           mat,
           st: pst,
           q: quatFromEuler(...ps.rotation ?? [0, 0, 0]),
+          pos: [ps.position[0], ps.position[1], ps.position[2]],
           mass0,
           fuel0,
           area: shapeArea(ps.shape),
@@ -1631,14 +1642,8 @@ var GameDestruction = (() => {
         o.byPart.get(r.b).push(j);
         o.st.joints.push(jst);
       }
-      if (o.parts.length) {
-        const c = [0, 0, 0];
-        for (const p of o.parts) for (let k = 0; k < 3; k++) c[k] += p.spec.position[k] / o.parts.length;
-        let r = 0;
-        for (const p of o.parts) r = Math.max(r, vec.distance(c, p.spec.position) + p.bound);
-        o.bc = c;
-        o.br = r;
-      }
+      for (const [jid, c] of carry?.joints ?? []) if (c.st.open && !o.jointMap.has(jid)) o.st.joints.push(c.st);
+      updateBound(o);
       o.anyAnchor = o.parts.some((p) => p.anchored);
       o.unsup = o.parts.map(() => false);
       solveStructure(o);
@@ -1778,7 +1783,7 @@ var GameDestruction = (() => {
       if (!p) throw new Error(`unknown part "${id}" in object "${o.id}"`);
       return p;
     };
-    const partXf = (o, p) => ({ c: toWorld(o.st.position, o.st.rotation, p.spec.position), q: quat.mul(o.st.rotation, p.q) });
+    const partXf = (o, p) => ({ c: toWorld(o.st.position, o.st.rotation, p.pos), q: quat.mul(o.st.rotation, p.q) });
     const objLocal = (o, w) => toLocal(o.st.position, o.st.rotation, w);
     const objLocalDir = (o, w) => rotateVec(quat.conjugate(o.st.rotation), w);
     const jointWorld = (o, j) => toWorld(o.st.position, o.st.rotation, j.pos);
@@ -1790,14 +1795,14 @@ var GameDestruction = (() => {
       const { c, q } = partXf(o, p);
       return aabbOf(p.spec.shape, c, q);
     };
-    const rayPartRaw = (pos, rot, spec, pq, origin, d) => {
-      const c = toWorld(pos, rot, spec.position);
+    const rayPartRaw = (pos, rot, spec, pq, origin, d, lp = spec.position) => {
+      const c = toWorld(pos, rot, lp);
       const q = quat.mul(rot, pq);
       const qi = quat.conjugate(q);
       const r = rayShape(spec.shape, rotateVec(qi, vec.sub(origin, c)), rotateVec(qi, d));
       return r ? { t0: r.t0, t1: r.t1, n: rotateVec(q, r.n0) } : null;
     };
-    const rayPart = (o, p, origin, d) => rayPartRaw(o.st.position, o.st.rotation, p.spec, p.q, origin, d);
+    const rayPart = (o, p, origin, d) => rayPartRaw(o.st.position, o.st.rotation, p.spec, p.q, origin, d, p.pos);
     const raySphereMiss = (origin, d, c, r, maxDist) => {
       const oc = vec.sub(origin, c);
       const b = vec.dot(oc, d);
@@ -1822,7 +1827,8 @@ var GameDestruction = (() => {
       for (const im of impls.values()) {
         for (const ps of im.impl.describe().parts) {
           if (ignore?.has(`${im.impl.id}\0${ps.id}`)) continue;
-          const r = rayPartRaw(im.position, im.rotation, ps, quatFromEuler(...ps.rotation ?? [0, 0, 0]), origin, d);
+          const ov = im.poses.get(ps.id);
+          const r = rayPartRaw(im.position, im.rotation, ps, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]), origin, d, ov?.pos);
           if (!r || r.t0 < 0 || r.t0 > maxDist) continue;
           if (!best || r.t0 < best.distance) best = { object: im.impl.id, part: ps.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
         }
@@ -1957,11 +1963,29 @@ var GameDestruction = (() => {
       collapseCheck(o, src);
       checkDestroyed(o, src);
     };
-    const wearJoints = (o, p, amount, near, radius = 0.06, src) => {
+    const jointReach = (o, j, point) => {
+      const A = partWorldAabb(o, o.parts[j.ia]), B = partWorldAabb(o, o.parts[j.ib]);
+      let d2 = 0;
+      for (let k = 0; k < 3; k++) {
+        const lo = Math.min(Math.max(A.min[k], B.min[k]), Math.min(A.max[k], B.max[k]));
+        const hi = Math.max(Math.max(A.min[k], B.min[k]), Math.min(A.max[k], B.max[k]));
+        const d = point[k] < lo ? lo - point[k] : point[k] > hi ? point[k] - hi : 0;
+        d2 += d * d;
+      }
+      return Math.sqrt(d2);
+    };
+    const jointReachLimit = (o, j) => {
+      const pa = o.parts[j.ia], pb = o.parts[j.ib];
+      const small = pa.dims[0] * pa.dims[1] * pa.dims[2] <= pb.dims[0] * pb.dims[1] * pb.dims[2] ? pa : pb;
+      return Math.max(0.06, 0.5 * Math.min(small.dims[0], small.dims[1], small.dims[2]));
+    };
+    const wearJoints = (o, p, amount, near, radius = 0.06, src, split = false) => {
       if (amount <= 0) return;
-      for (const j of o.byPart.get(p.spec.id) ?? []) {
+      const mine = (o.byPart.get(p.spec.id) ?? []).filter((j) => !j.st.open);
+      if (split && mine.length) amount /= mine.length;
+      for (const j of mine) {
         if (j.st.open) continue;
-        if (near && vec.distance(jointWorld(o, j), near) > radius) continue;
+        if (near && jointReach(o, j, near) > Math.max(radius, jointReachLimit(o, j))) continue;
         j.st.hp -= amount;
         if (j.st.hp <= 0) {
           j.st.hp = 0;
@@ -2080,7 +2104,7 @@ var GameDestruction = (() => {
         if (mat.fracture !== "shatter") addHole(o, p, entry, n, caliber / 1e3, false, void 0, src);
       } else addHole(o, p, entry, n, caliber / 1e3, false, void 0, src);
       debris(o, p, mat.hitDebris, entry, n, clamp2(Math.round(E / 60) + 2, 2, 14), clamp2(Math.sqrt(E) / 6, 1, 8), src);
-      wearJoints(o, p, E * 0.2, entry, 0.06, src);
+      wearJoints(o, p, (penetrated ? thr : E) * 0.02, void 0, 0, src, true);
       const dmg = applyDamage(o, p, E * DMG_PER_J * scale, "ballistic", entry, d, E * 0.1, 12, src);
       return { penetrated, exitEnergy: penetrated ? E - thr : 0, exitPoint, damage: dmg };
     };
@@ -2155,8 +2179,9 @@ var GameDestruction = (() => {
       }
       for (const im of [...impls.values()]) {
         const inRange = im.impl.describe().parts.some((ps) => {
-          const c = toWorld(im.position, im.rotation, ps.position);
-          const q = quat.mul(im.rotation, quatFromEuler(...ps.rotation ?? [0, 0, 0]));
+          const ov = im.poses.get(ps.id);
+          const c = toWorld(im.position, im.rotation, ov?.pos ?? ps.position);
+          const q = quat.mul(im.rotation, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]));
           return distanceToShape(ps.shape, toLocal(c, q, point)) < radius;
         });
         if (inRange) out.push(implHit(im, { type: "explosive", point, energy, radius, ...src !== void 0 ? { source: src } : {} }));
@@ -2408,7 +2433,7 @@ var GameDestruction = (() => {
     const spread = (sources, dt) => {
       for (const src of sources) {
         if (!src.p.st.burning && !src.p.rt.jet) continue;
-        const sc = toWorld(src.o.st.position, src.o.st.rotation, src.p.spec.position);
+        const sc = toWorld(src.o.st.position, src.o.st.rotation, src.p.pos);
         const A = partWorldAabb(src.o, src.p);
         for (const o of objects.values()) {
           if (o === src.o) continue;
@@ -2454,9 +2479,23 @@ var GameDestruction = (() => {
       register(impl, opts = {}) {
         const id = opts.id ?? impl.id;
         if (taken(id)) throw new Error(`object "${id}" already exists`);
-        impls.set(id, { impl, position: opts.position ?? [0, 0, 0], rotation: opts.rotation ?? [0, 0, 0, 1] });
+        impls.set(id, { impl, position: opts.position ?? [0, 0, 0], rotation: opts.rotation ?? [0, 0, 0, 1], poses: /* @__PURE__ */ new Map() });
         return id;
       },
+      setPartPose(objectId, partId, position, rotation) {
+        const q = quatFromEuler(...rotation ?? [0, 0, 0]);
+        const im = impls.get(objectId);
+        if (im) {
+          im.impl.setPartPose?.(partId, position, rotation);
+          im.poses.set(partId, { pos: [position[0], position[1], position[2]], q });
+          return;
+        }
+        const o = getObj(objectId);
+        const p = getPart(o, partId);
+        p.pos = [position[0], position[1], position[2]];
+        p.q = q;
+        updateBound(o);
+      },
       remove(id) {
         objects.delete(id);
         impls.delete(id);
@@ -2483,9 +2522,12 @@ var GameDestruction = (() => {
         const moved = new Set(names);
         const nid = newId ?? nextId();
         if (objects.has(nid)) throw new Error(`object "${nid}" already exists`);
-        const carryFor = (keep) => ({
+        const carryFor = (keep, keepOpen = () => false) => ({
           parts: new Map(o.parts.filter((p) => keep(p.spec.id)).map((p) => [p.spec.id, { st: p.st, rt: p.rt }])),
-          joints: new Map(o.joints.filter((j) => keep(j.spec.a) && keep(j.spec.b)).map((j) => [j.spec.id, { st: j.st, step: j.step }])),
+          joints: new Map([
+            ...o.joints.filter((j) => keep(j.spec.a) && keep(j.spec.b) || j.st.open && keepOpen(j.spec.a, j.spec.b)).map((j) => [j.spec.id, { st: j.st, step: j.step }]),
+            ...o.st.joints.filter((st) => st.open && !o.jointMap.has(st.id) && keepOpen(st.a, st.b)).map((st) => [st.id, { st, step: 0 }])
+          ]),
           collapsed: [...o.collapsed].filter(keep)
         });
         const sub = (keep) => {
@@ -2497,8 +2539,8 @@ var GameDestruction = (() => {
         const inNew = (pid) => moved.has(pid);
         const inOld = (pid) => !moved.has(pid);
         const pos = o.st.position, rot = o.st.rotation;
-        const fresh = build(sub(inNew), nid, pos, rot, carryFor(inNew));
-        const rest = build(sub(inOld), id, pos, rot, carryFor(inOld));
+        const fresh = build(sub(inNew), nid, pos, rot, carryFor(inNew, (a, b) => inNew(a) && inNew(b)));
+        const rest = build(sub(inOld), id, pos, rot, carryFor(inOld, (a, b) => !(inNew(a) && inNew(b))));
         objects.set(id, rest);
         objects.set(nid, fresh);
         return nid;
@@ -2596,34 +2638,37 @@ var GameDestruction = (() => {
         }
         return getObj(objectId).joints.filter((j) => !j.st.open && j.spec.tools.includes(tool)).map((j) => j.st);
       },
-      nearestJoint(objectId, point, maxDistance = 0.3) {
+      nearestJoint(objectId, point, maxDistance = 0.3, tool) {
         const im = impls.get(objectId);
+        const cands = [];
         if (im) {
-          let best2 = null;
-          let bd2 = maxDistance;
+          const spec = im.impl.describe();
           for (const js of im.impl.state().joints) {
             if (js.open) continue;
             const pos = implJointPos(im, js.a, js.b);
-            const d = pos ? vec.distance(pos, point) : Infinity;
-            if (d <= bd2) {
-              bd2 = d;
-              best2 = js;
-            }
+            const j = (spec.joints ?? []).find((x) => (x.id ?? `${x.a}~${x.b}`) === js.id);
+            cands.push({ st: js, d: pos ? vec.distance(pos, point) : Infinity, ok: !!j && (j.tools ?? JOINT_DEFAULTS[j.kind].tools).includes(tool) });
           }
-          return best2;
-        }
-        const o = getObj(objectId);
-        let best = null;
-        let bd = maxDistance;
-        for (const j of o.joints) {
-          if (j.st.open) continue;
-          const d = vec.distance(jointWorld(o, j), point);
-          if (d <= bd) {
-            bd = d;
-            best = j.st;
+        } else {
+          const o = getObj(objectId);
+          for (const j of o.joints) {
+            if (j.st.open) continue;
+            cands.push({ st: j.st, d: vec.distance(jointWorld(o, j), point), ok: tool ? j.spec.tools.includes(tool) : true });
           }
         }
-        return best;
+        const pick = (only) => {
+          let best = null;
+          let bd = maxDistance;
+          for (const c of cands) {
+            if (only && !c.ok) continue;
+            if (c.d <= bd) {
+              bd = c.d;
+              best = c.st;
+            }
+          }
+          return best;
+        };
+        return (tool ? pick(true) : null) ?? pick(false);
       },
       extinguish(objectId, partId, coolC = 200) {
         const im = impls.get(objectId);
@@ -2666,6 +2711,10 @@ var GameDestruction = (() => {
         }).events;
       },
       state: (id) => objects.get(id)?.st ?? impls.get(id)?.impl.state() ?? null,
+      snapshot: (id) => {
+        const st = objects.get(id)?.st ?? impls.get(id)?.impl.state();
+        return st ? clone(st) : null;
+      },
       part: (id, partId) => objects.get(id)?.byId.get(partId)?.st ?? impls.get(id)?.impl.state().parts.find((p) => p.id === partId) ?? null,
       reset(id) {
         const im = impls.get(id);