@adatechnology/game-floorplan-structure 2.1.3 → 2.1.5

package/dist/index.global.js

@@ -2541,6 +2541,26 @@ var GameFloorplanStructure = (() => {
 
   // ../game-contracts/dist/index.js
   var DEFAULT_BLAST_IMPULSE = { bodyArea: 0.7, lift: 0.15, minSpeed: 0.3, tntPerJoule: 0.24 / 2e5 };
+  var NEAREST = 0.3;
+  function sideOnImpulse(tnt, distance2) {
+    if (!(tnt > 0)) return 0;
+    const w3 = Math.cbrt(tnt);
+    const z = Math.max(distance2, NEAREST) / w3;
+    const scaled = 0.067 * Math.sqrt(1 + (z / 0.23) ** 4) / (z * z * Math.cbrt(1 + (z / 1.55) ** 3));
+    return scaled * w3 * 100;
+  }
+  var ATMOSPHERE = 101325;
+  function sideOnOverpressure(tnt, distance2) {
+    if (!(tnt > 0)) return 0;
+    const z = Math.max(distance2, NEAREST) / Math.cbrt(tnt);
+    const ratio = 808 * (1 + (z / 4.5) ** 2) / (Math.sqrt(1 + (z / 0.048) ** 2) * Math.sqrt(1 + (z / 0.32) ** 2) * Math.sqrt(1 + (z / 1.35) ** 2));
+    return ratio * ATMOSPHERE;
+  }
+  function bodyImpulse(tnt, distance2) {
+    if (!(tnt > 0)) return 0;
+    const z = Math.max(distance2, NEAREST) / Math.cbrt(tnt);
+    return sideOnImpulse(tnt, distance2) * (2 + 4 / (1 + z * z));
+  }
   var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
   var DEFAULT_IGNITION_RULES = {
     fillCurve: [
@@ -5545,9 +5565,15 @@ var GameFloorplanStructure = (() => {
   var BREACH_AREA = 0.25;
   var BREACH_BLAST_REACH = 0.12;
   var MEMBER_CUT_REACH = 0.5;
+  var FAR_MEMBER_HP_FLOOR = 0.25;
   var BLAST_REFERENCE_RESISTANCE = 200 * 1900 * 0.13;
   var BLAST_EDGE_RAGGED = 0.3;
   var BLAST_EDGE_LOOSE = 1.35;
+  var PANEL_PRESSURE = 7e4;
+  var PANEL_IMPULSE = 150;
+  var PANEL_PI = 6e6;
+  var PANEL_POINTS = [[0, 0], [-0.3, 0], [0.3, 0], [0, -0.3], [0, 0.3]];
+  var PANEL_POINTS_LOADED = 4;
   var BLAST_EDGE_WEAR = 0.6;
   var RESIDUAL_CAPACITY = 0.15;
   var SEVER_BAND = 0.1;
@@ -5572,23 +5598,42 @@ var GameFloorplanStructure = (() => {
     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]);
@@ -5598,9 +5643,8 @@ var GameFloorplanStructure = (() => {
         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);
@@ -5911,6 +5955,26 @@ var GameFloorplanStructure = (() => {
       byTouching.set(support, { version: poseVersion, box: box2 });
       return box2;
     };
+    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 = clamp22((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];
@@ -6118,7 +6182,7 @@ var GameFloorplanStructure = (() => {
           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) ?? []);
@@ -7103,7 +7167,7 @@ var GameFloorplanStructure = (() => {
       return BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3) * clamp22(Math.cbrt(BLAST_REFERENCE_RESISTANCE / resistance), 0.3, 2);
     };
     const blastUnits = (o, p, wp, energy, dist, src) => {
-      var _a, _b;
+      var _a;
       if (!p.staged || p.st.stripped || isLost(p) || chipEnergy <= 0) return false;
       const reach = blastReachOf(p, energy);
       if (dist >= reach) return false;
@@ -7133,6 +7197,62 @@ var GameFloorplanStructure = (() => {
         }
       }
       if (out.length === 0) return false;
+      return knockOutUnits(o, p, wp, energy, out, src);
+    };
+    const blastPanel = (o, p, point, energy, src) => {
+      var _a;
+      if (!p.staged || p.st.stripped || isLost(p) || !p.spec.units || p.spec.units.mortar === p.spec.material || p.spec.reinforcement) return false;
+      const [u, v] = planeAxes(p.thin);
+      const lp = toLocal(p.pos, p.q, objLocal(o, point));
+      const half = p.dims[u] / 2;
+      const posts = [];
+      for (const m of o.parts) {
+        if (m === p || !m.spec.reinforcement || isLost(m) || m.spec.shape.kind !== "box") continue;
+        const mp = toLocal(p.pos, p.q, m.pos);
+        if (Math.abs(mp[p.thin]) > p.dims[p.thin] + 0.15 || Math.abs(mp[u]) > half + 0.15 || m.dims[v] < p.dims[v] * 0.5) continue;
+        posts.push(mp[u]);
+      }
+      let from = -half, to = half;
+      for (const x of posts) {
+        if (x <= lp[u] && x > from) from = x;
+        if (x >= lp[u] && x < to) to = x;
+      }
+      if (to - from < 0.2) return false;
+      const tnt = energy * DEFAULT_BLAST_IMPULSE.tntPerJoule;
+      const centre2 = objLocal(o, point);
+      const span = to - from, height = p.dims[v];
+      let loaded = 0;
+      for (const [fu, fv] of PANEL_POINTS) {
+        const at2 = [0, 0, 0];
+        at2[u] = (from + to) / 2 + fu * span;
+        at2[v] = fv * height;
+        at2[p.thin] = Math.sign(lp[p.thin]) * p.dims[p.thin] / 2;
+        const r = vec.distance(toWorld(p.pos, p.q, at2), centre2);
+        const side = sideOnOverpressure(tnt, r);
+        const reflected = 2 * side + 6 * side * side / (side + 7 * 101325);
+        const impulse = bodyImpulse(tnt, r);
+        if (reflected > PANEL_PRESSURE && impulse > PANEL_IMPULSE && (reflected - PANEL_PRESSURE) * (impulse - PANEL_IMPULSE) >= PANEL_PI) loaded++;
+      }
+      if (loaded < PANEL_POINTS_LOADED) return false;
+      const grid = gridOf(p);
+      const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      const out = [];
+      for (let i = 0; i < grid.length; i++) {
+        const cell = grid[i];
+        if (worn[i] === -1) continue;
+        if (cell.center[u] - cell.size[u] / 2 >= from - 1e-6 && cell.center[u] + cell.size[u] / 2 <= to + 1e-6) out.push(i);
+      }
+      if (out.length === 0) return false;
+      for (const i of out) worn[i] = -1;
+      return knockOutUnits(o, p, point, energy, out, src);
+    };
+    const knockOutUnits = (o, p, wp, energy, out, src) => {
+      var _a, _b;
+      const [u, v] = planeAxes(p.thin);
+      const op = p.st.opening ? toLocal(p.pos, p.q, p.st.opening.center) : null;
+      const grid = gridOf(p);
+      const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      for (const i of out) worn[i] = -1;
       const loose = unsupportedCells(grid, p.thin, p.dims, (i) => worn[i] !== -1 && !(op && p.st.opening && Math.hypot(grid[i].center[u] - op[u], grid[i].center[v] - op[v]) <= p.st.opening.radius));
       for (const i of loose) worn[i] = -1;
       const blown = out.map((i) => grid[i]), fallen = loose.map((i) => grid[i]);
@@ -7208,6 +7328,27 @@ var GameFloorplanStructure = (() => {
       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;
@@ -7265,6 +7406,7 @@ var GameFloorplanStructure = (() => {
         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);
@@ -7593,12 +7735,15 @@ var GameFloorplanStructure = (() => {
         return reach;
       }
       if (Ein > 20 && p.layers.length > 0) spallOuter(o, p, wp, faceOf(o, p, wn), wn, clamp22(0.05 + Math.sqrt(Ein) * 2e-3, 0.05, 0.4), src);
-      const dealt = applyDamage(o, p, amount, "explosive", point, null, Ein * 0.3, 40, src);
+      const breachReach = BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3);
+      const farMember = Boolean(p.spec.reinforcement && p.spec.units) && dist > MEMBER_CUT_REACH * breachReach;
+      const dealt = farMember ? applyDamage(o, p, Math.min(amount, Math.max(0, p.st.hp - p.st.maxHp * FAR_MEMBER_HP_FLOOR)), "explosive", null, null, Ein * 0.3, 40, src) : applyDamage(o, p, amount, "explosive", point, null, Ein * 0.3, 40, src);
       res.damage += dealt;
       if (p.bend && flexure.enabled) bendByBlast(o, p, point, energy, radius, reach, src);
-      const breachReach = BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3);
-      if (p.spec.units && p.spec.units.mortar !== p.spec.material) blastUnits(o, p, wp, energy, dist, src);
-      else if (p.spec.reinforcement && p.spec.units && dist > MEMBER_CUT_REACH * breachReach) blastUnits(o, p, wp, energy, dist, src);
+      if (p.spec.units && p.spec.units.mortar !== p.spec.material) {
+        blastPanel(o, p, point, energy, src);
+        if (!isLost(p)) blastUnits(o, p, wp, energy, dist, src);
+      } else if (farMember) blastUnits(o, p, wp, energy, dist, src);
       else if (dist <= breachReach) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
       return reach;
     };
@@ -7611,7 +7756,9 @@ var GameFloorplanStructure = (() => {
         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;