@adatechnology/game-destruction 0.18.2 → 0.19.0

package/dist/index.js

@@ -3024,23 +3024,42 @@ var penetrationOf = (mat, table) => {
   const v = table[mat.penetrationClass ?? mat.id] ?? table[mat.id];
   return v === void 0 ? void 0 : v * (mat.penetrationScale ?? 1);
 };
-var capacityScale = (p) => {
+var BURIED_BLAST_REACH = 0.5;
+var GIVE_AT_CUT_HP = 0.5;
+var capacityScale = (p, borne, through) => {
   const residual = p.spec.reinforcement?.residualCapacity ?? RESIDUAL_CAPACITY;
   if (p.st.stripped) return residual;
-  const kept = Math.min(p.rt.removed ? 1 - p.rt.removed / p.mass0 : 1, 1 - sectionLoss(p));
+  const kept = Math.min(p.rt.removed ? 1 - p.rt.removed / p.mass0 : 1, sectionKept(p, residual, borne, through));
   return Math.max(p.spec.reinforcement ? residual : 0.05, kept);
 };
-var sectionLoss = (p) => {
+var sectionKept = (p, residual, borne, through) => {
+  let kept = 1;
+  forEachSection(p, borne, (c, along, gone) => {
+    const share = through?.(c.center, along) ?? 1;
+    if (share <= 0) return;
+    kept = Math.min(kept, Math.max(p.spec.reinforcement ? residual : 0, 1 - gone) / share);
+  });
+  return kept;
+};
+var sectionLoss = (p, borne) => {
+  let worst = 0;
+  forEachSection(p, borne, (_c, _along, gone) => {
+    worst = Math.max(worst, gone);
+  });
+  return Math.min(1, worst);
+};
+var forEachSection = (p, borne, visit) => {
   const cells = p.st.chipped;
-  if (!cells?.length) return 0;
+  if (!cells?.length) return;
   const [u, v] = planeAxes(p.thin);
   const role = p.spec.structure?.role;
   const up = rotateVec(p.q, [0, 0, 0].map((_, k) => k === v ? 1 : 0));
   const upright = Math.abs(up[1]) > 0.7 ? v : Math.abs(rotateVec(p.q, [0, 0, 0].map((_, k) => k === u ? 1 : 0))[1]) > 0.7 ? u : -1;
   const along = (role === "wall" || role === "partition" || role === "column") && upright >= 0 ? upright : p.dims[u] >= p.dims[v] ? u : v;
   const across = along === u ? v : u;
-  let worst = 0;
+  const lying = along !== upright || upright < 0;
   for (const c of cells) {
+    if (lying && borne?.(c.center, along)) continue;
     const spans = [];
     for (const d of cells) if (Math.abs(d.center[along] - c.center[along]) < d.size[along] / 2 + 1e-6) spans.push([d.center[across] - d.size[across] / 2, d.center[across] + d.size[across] / 2]);
     spans.sort((a, b) => a[0] - b[0]);
@@ -3050,9 +3069,8 @@ var sectionLoss = (p) => {
       gone += b - Math.max(a, end);
       end = b;
     }
-    worst = Math.max(worst, gone / Math.max(p.dims[across], 1e-6));
+    visit(c, along, Math.min(1, gone / Math.max(p.dims[across], 1e-6)));
   }
-  return Math.min(1, worst);
 };
 var isLost = (p) => p.st.status === "broken" || p.st.status === "melted" || p.st.status === "ashes";
 var clone = (v) => structuredClone(v);
@@ -3363,6 +3381,26 @@ var createDestruction = (options = {}) => {
     byTouching.set(support, { version: poseVersion, box });
     return box;
   };
+  const throughOf = (p) => {
+    const load = p.st.load ?? 0;
+    if (load <= 0) return void 0;
+    const above = Math.max(0, load - p.st.mass);
+    const up = rotateVec(p.q, [0, 1, 0]);
+    return (local, along) => {
+      const axis = [0, 0, 0];
+      axis[along] = 1;
+      const sign = Math.sign(rotateVec(p.q, axis)[1]);
+      if (Math.abs(up[1]) < 0.7 && Math.abs(rotateVec(p.q, axis)[1]) < 0.7) return 1;
+      const half = p.dims[along] / 2;
+      const share = clamp2((half - sign * local[along]) / Math.max(p.dims[along], 1e-6), 0, 1);
+      return (above + p.st.mass * share) / load;
+    };
+  };
+  const borneOn = (p, supports) => {
+    if (supports.length === 0) return void 0;
+    const boxes = supports.map((support) => contactBox(p, support));
+    return (local, along) => boxes.some(([lo, hi]) => local[along] >= lo[along] - SUPPORT_TOLERANCE && local[along] <= hi[along] + SUPPORT_TOLERANCE);
+  };
   const measureContact = (p, support) => {
     const A = aabbOf(p.spec.shape, p.pos, p.q), B = aabbOf(support.spec.shape, support.pos, support.q);
     const lo = [0, 0, 0], hi = [0, 0, 0];
@@ -3570,7 +3608,7 @@ var createDestruction = (options = {}) => {
         o.unsup[i] = o.anyAnchor && !isLost(p) && !p.orphan;
         continue;
       }
-      p.st.stress = p.st.load * structureSafety / (p.cap * capacityScale(p));
+      p.st.stress = p.st.load * structureSafety / (p.cap * capacityScale(p, borneOn(p, (lowerOf.get(i) ?? []).map((k) => parts[k])), throughOf(p)));
       if (p.bend) {
         p.bendLoad = p.st.mass + bending[i];
         const bent = restFlexure(o, p, lowerOf.get(i) ?? []);
@@ -4660,6 +4698,27 @@ var createDestruction = (options = {}) => {
     debris(o, p, p.mat.breakDebris, center, [0, -1, 0], 6, 1, src);
     return loose.length;
   };
+  const giveAtCut = (o, p, src) => {
+    if (!p.spec.reinforcement || !p.spec.units || !p.st.chipped?.length || sectionLoss(p) <= 0) return false;
+    const opened = [];
+    for (const j of o.byPart.get(p.spec.id) ?? []) {
+      if (j.st.open) continue;
+      const onIt = j.bears === "a_on_b" && j.spec.b === p.spec.id || j.bears === "b_on_a" && j.spec.a === p.spec.id;
+      if (!onIt) continue;
+      j.st.open = true;
+      j.st.openedBy = "break";
+      opened.push(j);
+    }
+    if (opened.length === 0) return false;
+    p.st.hp = Math.max(p.st.hp, p.st.maxHp * GIVE_AT_CUT_HP);
+    markDamaged(p);
+    solveStructure(o);
+    recomputeGroups(o);
+    detachEvents(o, opened, "break", src);
+    exposeRebar(o, p, src);
+    collapseCheck(o, src);
+    return true;
+  };
   const stripPart = (o, p, reinforcement, src) => {
     const bars = rebarBars(p.dims, p.thin, reinforcement.spacing);
     p.st.stripped = true;
@@ -4717,6 +4776,7 @@ var createDestruction = (options = {}) => {
       hingeDrop(o, p, src);
       return;
     }
+    if (!force && giveAtCut(o, p, src)) return;
     const ex = p.spec.explodes;
     const style = force ?? (p.snap ? "snap" : p.mat.fracture === "none" ? "snap" : p.mat.fracture);
     const { c, q } = partXf(o, p);
@@ -5063,7 +5123,9 @@ var createDestruction = (options = {}) => {
       const dx = local[0] - p.pos[0];
       const dy = local[1] - p.pos[1];
       const dz = local[2] - p.pos[2];
-      if (dx * dx + dy * dy + dz * dz < reach * reach) near.push(p);
+      if (dx * dx + dy * dy + dz * dz >= reach * reach) continue;
+      if (p.spec.anchored && p.spec.structure?.role === "foundation" && distToPart(o, p, point) > BURIED_BLAST_REACH) continue;
+      near.push(p);
     }
     blastProbe.partsTested += o.parts.length;
     blastProbe.partsNear += near.length;