@adatechnology/game-destruction 0.1.0 → 0.1.1

package/dist/index.js

@@ -1088,7 +1088,7 @@ var materials_default = [
   {
     id: "green_wood",
     density: 650,
-    hpPerKg: 120,
+    hpPerKg: 5,
     penetration: 10,
     ductility: 0.5,
     fracture: "splinter",
@@ -1097,7 +1097,8 @@ var materials_default = [
       0.2
     ],
     damageScale: {
-      slash: 1.3
+      slash: 1.3,
+      ballistic: 0.1
     },
     hitDebris: "splinters",
     breakDebris: "leaves",
@@ -1410,6 +1411,15 @@ var FLAMMABLE_FLUIDS = ["gas", "fuel"];
 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();
@@ -1545,6 +1555,7 @@ var createDestruction = (options = {}) => {
         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),
@@ -1583,14 +1594,8 @@ var createDestruction = (options = {}) => {
       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);
@@ -1730,7 +1735,7 @@ var createDestruction = (options = {}) => {
     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);
@@ -1742,14 +1747,14 @@ var createDestruction = (options = {}) => {
     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);
@@ -1774,7 +1779,8 @@ var createDestruction = (options = {}) => {
     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 };
       }
@@ -1909,11 +1915,29 @@ var createDestruction = (options = {}) => {
     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;
@@ -2032,7 +2056,7 @@ var createDestruction = (options = {}) => {
       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 };
   };
@@ -2107,8 +2131,9 @@ var createDestruction = (options = {}) => {
     }
     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 } : {} }));
@@ -2360,7 +2385,7 @@ var createDestruction = (options = {}) => {
   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;
@@ -2406,9 +2431,23 @@ var createDestruction = (options = {}) => {
     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);
@@ -2435,9 +2474,12 @@ var createDestruction = (options = {}) => {
       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) => {
@@ -2449,8 +2491,8 @@ var createDestruction = (options = {}) => {
       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;
@@ -2548,34 +2590,37 @@ var createDestruction = (options = {}) => {
       }
       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);
@@ -2618,6 +2663,10 @@ var createDestruction = (options = {}) => {
       }).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);