@adatechnology/game-destruction 0.8.1 → 0.9.0

package/dist/index.d.ts

@@ -62,6 +62,11 @@ interface MaterialDef {
     fracture: FractureStyle;
     /** Fragment size range in metres (default `[0.04, 0.2]`). */
     fragmentSize?: [number, number];
+    /**
+     * Thickness of one sheet, in metres, for a material that comes in sheets (paper). A `tear` part much thicker than a sheet is a stack of them (a book,
+     * a ream, a magazine) and comes apart as thin loose scraps (`Fragment.inner` for the pages) instead of slabs as thick as the part.
+     */
+    sheet?: number;
     /** Damage multipliers per damage type (default 1); `shelter` multiplies the resistance the material adds between a blast and a target (`blast.shelter`). */
     damageScale?: Partial<Record<DamageType | 'shelter', number>>;
     /** Debris emitted on a hit that does not break the part. */
@@ -79,6 +84,8 @@ interface MaterialDef {
         glows?: boolean;
         /** Transparent (glass): cracks are drawn as a star on the surface. */
         transparent?: boolean;
+        /** Colour of the inside, for the inner fragments and the hit debris (the pages of a book under its cover); default the colour of the part. */
+        innerColor?: number;
     };
     /** Free tags, e.g. `metal`, `organic`, `conductive`. */
     tags?: string[];

package/dist/index.global.js

@@ -450,6 +450,23 @@ var GameDestruction = (() => {
     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 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;
@@ -492,6 +509,8 @@ var GameDestruction = (() => {
     }
     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] });
@@ -2137,6 +2156,7 @@ var GameDestruction = (() => {
         0.03,
         0.15
       ],
+      sheet: 1e-3,
       damageScale: {
         slash: 3
       },
@@ -2152,7 +2172,8 @@ var GameDestruction = (() => {
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 15524048
       },
       tags: [
         "fabric",
@@ -4028,7 +4049,8 @@ var GameDestruction = (() => {
         hit: hitLocal,
         fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
         maxFragments,
-        rnd
+        rnd,
+        sheet: p.mat.sheet
       });
       const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
       const mass = p.st.mass;
@@ -4052,7 +4074,8 @@ var GameDestruction = (() => {
           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;