@adatechnology/game-destruction 0.8.2 → 0.10.0

package/dist/index.js

@@ -340,6 +340,62 @@ var frame = (ax, ay, az, angle = 0) => {
   return angle === 0 ? q : quat.mul(q, quat.fromAxisAngle([0, 0, 1], angle));
 };
 var clamp = (v, a, b) => Math.max(a, Math.min(b, v));
+var splinterBox = (inp, box, limit = inp.maxFragments) => {
+  const { rnd } = inp;
+  const dims = box.s;
+  const [fmin, fmax] = inp.fragmentSize;
+  const g = inp.grain ?? [0, 1, 2].sort((a2, b2) => dims[b2] - dims[a2])[0];
+  const [a, b] = [0, 1, 2].filter((i) => i !== g);
+  const w = Math.max(fmin * 1.5, 0.01);
+  const c = clamp(Math.round(dims[a] * dims[b] / (w * w)), 3, Math.max(3, Math.floor(limit / 2)));
+  const maxLen = fmax * 4;
+  const cells = bsp(box, c, [a, b], rnd);
+  const pieces = [];
+  for (const cell of cells) {
+    const extra = rnd() < 0.4 ? 1 : 0;
+    const k = Math.max(1, Math.ceil(dims[g] / maxLen)) + extra;
+    for (const p of bsp(cell, k, [g], rnd)) pieces.push(p);
+  }
+  return pieces.slice(0, limit).map((p) => ({ center: p.c, size: [p.s[g], p.s[a], p.s[b]], q: frame(g, a, b), shape: "splinter", weight: p.s[0] * p.s[1] * p.s[2] }));
+};
+var severAt = (inp, root, at, gap) => {
+  const dims = root.s;
+  const L = [0, 1, 2].sort((x, y) => dims[y] - dims[x])[0];
+  const half = dims[L] / 2;
+  const lo = clamp(at - gap / 2, -half, half), hi = clamp(at + gap / 2, -half, half);
+  const out = [];
+  const stub = (from, to) => {
+    if (to - from < 0.02) return;
+    const c = [root.c[0], root.c[1], root.c[2]], sz = [dims[0], dims[1], dims[2]];
+    c[L] = (from + to) / 2;
+    sz[L] = to - from;
+    out.push({ center: c, size: sz, q: quat.identity(), shape: "slab", weight: sz[0] * sz[1] * sz[2] });
+  };
+  stub(-half, lo);
+  stub(hi, half);
+  const band = { c: [root.c[0], root.c[1], root.c[2]], s: [dims[0], dims[1], dims[2]] };
+  band.c[L] = (lo + hi) / 2;
+  band.s[L] = Math.max(hi - lo, 0.01);
+  for (const p of splinterBox(inp, band, Math.max(3, inp.maxFragments - out.length))) out.push(p);
+  return out;
+};
+var tearStack = (inp, root, t, u, v, n, sheet) => {
+  const { dims, rnd, maxFragments } = inp;
+  const layers = clamp(Math.ceil(dims[t] / STACK_LAYER), 2, 4);
+  const per = clamp(n, 3, Math.max(3, Math.floor(maxFragments / layers)));
+  const out = [];
+  for (let k = 0; k < layers; k++) {
+    const off = -dims[t] / 2 + (k + 0.5) * dims[t] / layers;
+    for (const b of bsp(root, per, [u, v], rnd)) {
+      if (out.length >= maxFragments) return out;
+      const c = [b.c[0], b.c[1], b.c[2]];
+      c[t] = off;
+      out.push({ center: c, size: [b.s[u], b.s[v], sheet], q: frame(u, v, t, (rnd() - 0.5) * 0.8), shape: "scrap", weight: b.s[u] * b.s[v], inner: out.length % 4 !== 0 });
+    }
+  }
+  return out;
+};
+var STACK_LAYER = 0.012;
 var planFragments = (inp) => {
   const { style, dims, rnd, maxFragments } = inp;
   const [fmin, fmax] = inp.fragmentSize;
@@ -361,27 +417,14 @@ var planFragments = (inp) => {
     return out;
   }
   if (style === "splinter") {
-    const g = inp.grain ?? [0, 1, 2].sort((a2, b2) => dims[b2] - dims[a2])[0];
-    const [a, b] = [0, 1, 2].filter((i) => i !== g);
-    const w = Math.max(fmin * 1.5, 0.01);
-    const c = clamp(Math.round(dims[a] * dims[b] / (w * w)), 3, Math.max(3, Math.floor(maxFragments / 2)));
-    const maxLen = fmax * 4;
-    const cells = bsp(root, c, [a, b], rnd);
-    const pieces = [];
-    for (const cell of cells) {
-      let list = [cell];
-      const extra = rnd() < 0.4 ? 1 : 0;
-      const k = Math.max(1, Math.ceil(dims[g] / maxLen)) + extra;
-      list = bsp(cell, k, [g], rnd);
-      for (const p of list) pieces.push(p);
-    }
-    for (const p of pieces.slice(0, maxFragments)) {
-      out.push({ center: p.c, size: [p.s[g], p.s[a], p.s[b]], q: frame(g, a, b), shape: "splinter", weight: p.s[0] * p.s[1] * p.s[2] });
-    }
+    if (inp.cut) return severAt(inp, root, inp.cut.at, inp.cut.gap);
+    for (const p of splinterBox(inp, root)) out.push(p);
     return out;
   }
   if (style === "tear") {
     const n2 = clamp(Math.round(dims[u] * dims[v] / (mean * mean)), 3, maxFragments);
+    const sheet = inp.sheet ?? 0;
+    if (sheet > 0 && dims[t] > sheet * 4) return tearStack(inp, root, t, u, v, n2, sheet);
     const th2 = Math.min(inp.thickness, dims[t]);
     for (const b of bsp(root, n2, [u, v], rnd)) {
       out.push({ center: [b.c[0], b.c[1], b.c[2]], size: [b.s[u], b.s[v], th2], q: frame(u, v, t), shape: "scrap", weight: b.s[u] * b.s[v] });
@@ -2027,6 +2070,7 @@ var materials_default = [
       0.03,
       0.15
     ],
+    sheet: 1e-3,
     damageScale: {
       slash: 3
     },
@@ -2042,7 +2086,8 @@ var materials_default = [
       smoke: "grey"
     },
     visual: {
-      charColor: 1709072
+      charColor: 1709072,
+      innerColor: 15524048
     },
     tags: [
       "fabric",
@@ -2436,9 +2481,14 @@ var BREACH_BLAST_FACTOR = 6;
 var BREACH_AREA = 0.25;
 var BREACH_BLAST_REACH = 0.12;
 var RESIDUAL_CAPACITY = 0.15;
+var SEVER_BAND = 0.1;
+var SEVER_ASPECT = 3;
+var SEVER_BALLISTIC = 2;
 var SUPPORT_TOLERANCE = 0.05;
 var UNIT_FRAGMENT_FACTOR = 4;
 var BREACH_GRID_CAP = 4096;
+var CHIP_ENERGY = 200;
+var CHIP_SPLASH = 0.5;
 var CUT_SLICE = 1;
 var cutFactorOf = (shape) => clamp2(Math.max(...shapeDims(shape)) / CUT_SLICE, 1, 50);
 var clamp2 = (v, a, b) => Math.max(a, Math.min(b, v));
@@ -2482,6 +2532,7 @@ var createDestruction = (options = {}) => {
   let windCfg = windOpts ? resolveWind(windOpts) : null;
   const ignitionRules = resolveIgnitionRules(options.ignition);
   const breachBlastFactor = options.breach?.blastFactor ?? BREACH_BLAST_FACTOR;
+  const chipEnergy = options.breach?.chipEnergy ?? CHIP_ENERGY;
   const rng = createRng(options.seed ?? 1);
   const rnd = () => rng.next();
   let time = 0;
@@ -2855,41 +2906,68 @@ var createDestruction = (options = {}) => {
     markDamaged(p);
     if (p.rt.hinge >= flexure.failRotationDeg * Math.PI / 180) hingeDrop(o, p, src);
   };
+  const freeSpan = (p, supports) => {
+    if (supports.length === 0) return Infinity;
+    const d = p.dims;
+    const L = [0, 1, 2].sort((a, b) => d[b] - d[a])[0];
+    const spans = supports.map((k) => contactBox(p, k)).map(([lo, hi]) => [lo[L], hi[L]]);
+    let far = 0;
+    for (let i = 0; i <= 16; i++) {
+      const x = (i / 16 - 0.5) * d[L];
+      let near = Infinity;
+      for (const [lo, hi] of spans) near = Math.min(near, Math.max(lo - x, x - hi, 0));
+      far = Math.max(far, near);
+    }
+    return 2 * far;
+  };
   const solveStructure = (o) => {
     o.maxStress = 0;
     if (!o.hasStructure) return;
     const parts = o.parts;
     const n = parts.length;
     const dist = new Array(n).fill(-1);
-    const queue = [];
     const ok = (i) => parts[i].structural && !isLost(parts[i]);
     const isPartition = (i) => parts[i].spec.structure?.role === "partition";
-    for (let i = 0; i < n; i++) if (ok(i) && parts[i].anchored) {
-      dist[i] = 0;
-      queue.push(i);
-    }
-    for (let h = 0; h < queue.length; h++) {
-      const s = queue[h];
-      if (isPartition(s)) continue;
-      for (const j of o.byPart.get(parts[s].spec.id)) {
-        if (j.st.open || !j.bears) continue;
-        const r = j.ia === s ? j.ib : j.ia;
-        if (dist[r] >= 0 || !ok(r) || restsOn(o, j, r) !== s) continue;
-        dist[r] = dist[s] + 1;
-        queue.push(r);
+    const out = /* @__PURE__ */ new Set();
+    let queue = [];
+    let lowerOf = /* @__PURE__ */ new Map();
+    for (; ; ) {
+      dist.fill(-1);
+      queue = [];
+      for (let i = 0; i < n; i++) if (ok(i) && !out.has(i) && parts[i].anchored) {
+        dist[i] = 0;
+        queue.push(i);
       }
-    }
-    const incoming = new Array(n).fill(0);
-    const lowerOf = /* @__PURE__ */ new Map();
-    for (const i of queue) {
-      const lower = [];
-      for (const j of o.byPart.get(parts[i].spec.id)) {
-        if (j.st.open || !j.bears) continue;
-        const k = restsOn(o, j, i);
-        if (k >= 0 && dist[k] >= 0 && dist[k] < dist[i] && !isPartition(k)) lower.push(k);
+      for (let h = 0; h < queue.length; h++) {
+        const s = queue[h];
+        if (isPartition(s)) continue;
+        for (const j of o.byPart.get(parts[s].spec.id)) {
+          if (j.st.open || !j.bears) continue;
+          const r = j.ia === s ? j.ib : j.ia;
+          if (dist[r] >= 0 || !ok(r) || out.has(r) || restsOn(o, j, r) !== s) continue;
+          dist[r] = dist[s] + 1;
+          queue.push(r);
+        }
+      }
+      lowerOf = /* @__PURE__ */ new Map();
+      let dropped = false;
+      for (const i of queue) {
+        const lower = [];
+        for (const j of o.byPart.get(parts[i].spec.id)) {
+          if (j.st.open || !j.bears) continue;
+          const k = restsOn(o, j, i);
+          if (k >= 0 && dist[k] >= 0 && dist[k] < dist[i] && !isPartition(k)) lower.push(k);
+        }
+        lowerOf.set(i, lower);
+        const max = parts[i].spec.structure?.maxSpan;
+        if (max !== void 0 && !parts[i].anchored && freeSpan(parts[i], lower.map((k) => parts[k])) > max) {
+          out.add(i);
+          dropped = true;
+        }
       }
-      lowerOf.set(i, lower);
+      if (!dropped) break;
     }
+    const incoming = new Array(n).fill(0);
     const bending = new Array(n).fill(0);
     const through = parts.map(() => []);
     const pass = (k, at, mass) => {
@@ -3401,6 +3479,7 @@ var createDestruction = (options = {}) => {
         const r = rayPart(o, p, origin, d);
         if (!r || r.t0 < 0 || r.t0 > maxDist) continue;
         if (p.st.opening && insideOpening(o, p, vec.madd(origin, d, r.t0))) continue;
+        if (p.st.chipped && insideChip(p, objLocal(o, vec.madd(origin, d, r.t0)))) continue;
         if (!best || r.t0 < best.distance) best = { object: o.id, part: p.spec.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
       }
     }
@@ -3664,6 +3743,62 @@ var createDestruction = (options = {}) => {
     if (total < (p.spec.breach?.area ?? BREACH_AREA)) return;
     openBreach(o, p, [sum[0] / total, sum[1] / total, sum[2] / total], total, energy, dir, src);
   };
+  const unitGrids = /* @__PURE__ */ new WeakMap();
+  const gridOf = (p) => {
+    let grid = unitGrids.get(p);
+    if (!grid) unitGrids.set(p, grid = unitGrid(p.dims, p.thin, unitsOf(p), BREACH_GRID_CAP));
+    return grid;
+  };
+  const insideChip = (p, objectPoint) => {
+    const cells = p.st.chipped;
+    if (!cells?.length) return false;
+    const [u, v] = planeAxes(p.thin);
+    const lp = toLocal(p.pos, p.q, objectPoint);
+    return cells.some((c) => Math.abs(lp[u] - c.center[u]) <= c.size[u] / 2 && Math.abs(lp[v] - c.center[v]) <= c.size[v] / 2);
+  };
+  const chipUnits = (o, p, wp, energy, dir, radius, src) => {
+    var _a, _b;
+    if (!p.spec.units || p.spec.reinforcement || !p.staged || chipEnergy <= 0 || energy <= 0 || p.st.stripped || isLost(p) || (p.st.stage ?? 0) >= 2) return;
+    const [u, v] = planeAxes(p.thin);
+    const lp = toLocal(p.pos, p.q, objLocal(o, wp));
+    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;
+      const gap = Math.hypot(Math.max(0, Math.abs(lp[u] - cell.center[u]) - cell.size[u] / 2), Math.max(0, Math.abs(lp[v] - cell.center[v]) - cell.size[v] / 2));
+      if (gap > radius) continue;
+      const share = gap === 0 ? 1 : CHIP_SPLASH * (1 - gap / radius);
+      const total = (worn[i] ?? 0) + energy * share;
+      const mass = p.mat.density * cell.size[0] * cell.size[1] * cell.size[2];
+      if (total < chipEnergy * mass) {
+        worn[i] = total;
+        continue;
+      }
+      worn[i] = -1;
+      out.push(cell);
+    }
+    if (out.length === 0) return;
+    const { c, q } = partXf(o, p);
+    const chipped = (_b = p.st).chipped ?? (_b.chipped = []);
+    const holes = localHolesOf(p);
+    for (const cell of out) {
+      const mass = Math.min(p.st.mass, p.mat.density * cell.size[0] * cell.size[1] * cell.size[2]);
+      const center = toWorld(c, q, cell.center);
+      const speed = clamp2(Math.sqrt(2 * energy * 0.05 / Math.max(mass, 0.05)), 0.5, 6);
+      const fragments = cellFragments(o, p, [cell], wp, dir, speed, mass, `c${chipped.length}_`);
+      p.st.holes = p.st.holes.filter((_, k) => marksInBox(cell.center, cell.size, void 0, [holes[k]]).length === 0);
+      chipped.push({ center: [cell.center[0], cell.center[1], cell.center[2]], size: [cell.size[0], cell.size[1], cell.size[2]] });
+      p.st.mass = Math.max(0, p.st.mass - mass);
+      p.rt.removed = (p.rt.removed ?? 0) + mass;
+      markDamaged(p);
+      setStage(o, p, 1, {}, src);
+      emit({ ...base(o, src), type: "chip", part: p.spec.id, center, size: [cell.size[0], cell.size[1], cell.size[2]], rotation: q, fragments });
+      debris(o, p, p.mat.breakDebris, center, vec.scale(dir ?? [0, 1, 0], -1), 6, 2, src);
+    }
+    for (const cell of out) addBreach(o, p, toWorld(c, q, cell.center), cell.size[u] * cell.size[v], energy, dir, src);
+  };
   const openBreach = (o, p, center, total, energy, dir, src) => {
     const [u, v] = planeAxes(p.thin);
     const radius = clamp2(Math.sqrt(total / Math.PI), Math.sqrt((p.spec.breach?.area ?? BREACH_AREA) / Math.PI), breachRadius);
@@ -3675,7 +3810,8 @@ var createDestruction = (options = {}) => {
       failPart(o, p, worldCenter, dir, energy, 12, src);
       return;
     }
-    const cells = cellsWithin(unitGrid(p.dims, p.thin, unitsOf(p), BREACH_GRID_CAP), p.thin, lc, radius);
+    const worn = p.rt.chips;
+    const cells = cellsWithin(gridOf(p).filter((_, i) => worn?.[i] !== -1), p.thin, lc, radius);
     const removed = p.st.mass * cells.reduce((sum, cell) => sum + cell.size[u] * cell.size[v], 0) / (p.dims[u] * p.dims[v]);
     const speed = clamp2(Math.sqrt(2 * energy * 0.1 / Math.max(removed, 0.05)), 0.5, 8);
     const fragments = cellFragments(o, p, cells, worldCenter, dir, speed, removed, "b");
@@ -3759,6 +3895,8 @@ var createDestruction = (options = {}) => {
     const grain = p.spec.grain ? AXIS[p.spec.grain] : void 0;
     const hitLocal = toLocal(c, q, hitW);
     const unitPlan = p.spec.units ? unitFragmentPlan(p, maxFragments * UNIT_FRAGMENT_FACTOR) : [];
+    const axis = style === "splinter" ? severAxis(p) : -1;
+    const cutAt = axis < 0 ? void 0 : p.rt.cutAt ?? (origin ? hitLocal[axis] : void 0);
     const plan = unitPlan.length > 0 ? unitPlan : planFragments({
       style,
       dims: p.dims,
@@ -3767,7 +3905,9 @@ var createDestruction = (options = {}) => {
       hit: hitLocal,
       fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
       maxFragments,
-      rnd
+      rnd,
+      sheet: p.mat.sheet,
+      ...cutAt !== void 0 ? { cut: { at: cutAt, gap: SEVER_BAND } } : {}
     });
     const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
     const mass = p.st.mass;
@@ -3791,7 +3931,8 @@ var createDestruction = (options = {}) => {
         velocity: [dv[0] * k, dv[1] * k + 0.5 * rnd(), dv[2] * k],
         angularVelocity: [(rnd() - 0.5) * 12, (rnd() - 0.5) * 12, (rnd() - 0.5) * 12],
         mass: mass * f.weight / totW,
-        ...marks.length > 0 ? { marks } : {}
+        ...marks.length > 0 ? { marks } : {},
+        ...f.inner ? { inner: true } : {}
       };
     });
     const reinforcement = p.spec.reinforcement;
@@ -3825,10 +3966,33 @@ var createDestruction = (options = {}) => {
     emit({ ...base(o, src), type: "primed", part: p.spec.id, point: partXf(o, p).c, trigger, delay });
   };
   const CHAIN_TRIGGER_OF = { ballistic: "shot", explosive: "explosion" };
+  const severAxis = (p) => {
+    if (p.mat.fracture !== "splinter" || p.spec.shape.kind !== "box") return -1;
+    const d = p.dims;
+    const order = [0, 1, 2].sort((a, b) => d[b] - d[a]);
+    return d[order[0]] >= SEVER_ASPECT * d[order[1]] && d[order[0]] >= 3 * SEVER_BAND ? order[0] : -1;
+  };
+  const bandOf = (o, p, axis, origin) => {
+    const { c, q } = partXf(o, p);
+    const along = toLocal(c, q, origin)[axis];
+    const L = p.dims[axis];
+    return clamp2(Math.floor((along + L / 2) / SEVER_BAND), 0, Math.ceil(L / SEVER_BAND) - 1);
+  };
   const applyDamage = (o, p, amount, type, origin, dir, fragEnergy, cap, src) => {
+    var _a;
     if (isLost(p) || amount <= 0) return 0;
     const prev = p.st.hp;
     p.st.hp -= amount;
+    const axis = origin && type !== "fire" && type !== "heat" ? severAxis(p) : -1;
+    if (axis >= 0 && p.st.hp > 0) {
+      const band = bandOf(o, p, axis, origin);
+      const cuts = (_a = p.rt).cuts ?? (_a.cuts = {});
+      cuts[band] = (cuts[band] ?? 0) + amount * (type === "ballistic" ? SEVER_BALLISTIC : 1);
+      if (cuts[band] >= p.st.maxHp * SEVER_BAND / p.dims[axis]) {
+        p.rt.cutAt = -p.dims[axis] / 2 + (band + 0.5) * SEVER_BAND;
+        p.st.hp = 0;
+      }
+    }
     markDamaged(p);
     const trigger = CHAIN_TRIGGER_OF[type];
     const chained = trigger !== void 0 && chainDelayOf(p.spec, trigger) !== void 0;
@@ -3867,7 +4031,7 @@ var createDestruction = (options = {}) => {
   const ballistic = (o, p, entry, n, d, E, caliber, pathLen, src, round = {}) => {
     const mat = p.mat;
     const piercing = round.piercing ?? 1;
-    if (p.st.stripped || p.st.opening && insideOpening(o, p, objLocal(o, entry))) {
+    if (p.st.stripped || p.st.opening && insideOpening(o, p, objLocal(o, entry)) || insideChip(p, objLocal(o, entry))) {
       return { penetrated: true, exitEnergy: E, exitPoint: vec.madd(entry, d, Math.min(pathLen, p.thickness)), damage: 0 };
     }
     const sin = Math.min(1, Math.abs(vec.dot(d, n)));
@@ -3926,6 +4090,7 @@ var createDestruction = (options = {}) => {
     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, (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);
+    chipUnits(o, p, entry, penetrated ? Math.min(E, Math.max(thr, E * 0.5)) : E, d, Math.max(0.05, caliber / 1e3 * 8), src);
     return { penetrated, exitEnergy: penetrated ? penMm !== void 0 ? E * (1 - thr / Ep) : E - thr / (hard ? piercing : 1) : 0, exitPoint, damage: dmg };
   };
   const melee = (o, p, kind, E, point, n, d, contactR, src) => {
@@ -3953,6 +4118,7 @@ var createDestruction = (options = {}) => {
     const scale = mat.damageScale?.[kind] ?? 1;
     const done = applyDamage(o, p, Ec * DMG_PER_J * scale * (kind === "slash" ? p.cutFactor : 1), kind, point, d, E * 0.1, 12, src);
     addBreach(o, p, point, breachAreaOf(p, done, false), E, d, src);
+    if (kind === "blunt") chipUnits(o, p, point, E, d, Math.max(contactR, 0.03), src);
     return done;
   };
   const blastPart = (o, p, point, energy, radius, src, res, reachAt) => {
@@ -5444,6 +5610,7 @@ var locales = {
       sway: "sway",
       spall: "plaster came off",
       stage: "damage stage",
+      chip: "brick knocked out",
       expose: "rebar bare",
       body: "body",
       blast: "blast",
@@ -5534,6 +5701,7 @@ var locales = {
       sway: "balan\xE7o",
       spall: "reboco soltou",
       stage: "est\xE1gio de dano",
+      chip: "tijolo arrancado",
       expose: "vergalh\xE3o \xE0 mostra",
       body: "corpo",
       blast: "explos\xE3o",