@adatechnology/game-weapons-three 0.9.0 → 0.10.0

package/README.md

@@ -6,6 +6,8 @@ The muzzle flash, the smoke, the backblast of a launched rocket and the flame je
 
 **Hands.** The weapon in the hands tells the host where the hands go (`host.setHandTargets`, `HandTargets` of `game-contracts`): the right on the pistol grip (the `grip` pivot of the model, else under the receiver), the left on the handguard, on the pump of a pump gun (it moves with the pump), under the right on a handgun, and to the magazine while it is changed; the generic props take the right hand on the `handle` and the left under the `head` of a long gun. Sizes come from the model, the hands shrink with a model drawn small.
 
+**Safety (destravar).** Turning the safety on or off (the `safety` event, B in the test room) plays `safety_on` / `safety_off` on every model: the weapon cants to the right and rises a little toward the eye, the shooting hand slides up its grip so the thumb reaches the lever (`thumb_safety` in `src/data/hand-work.json`; an AK-style rifle's support hand goes over to the big lever on the right, `lever_right`), the lever flicks (when the model draws one, the `safety` part) and the weapon settles. The seconds and radians are `SAFETY_MOTION` of `src/animation/shot-clips.ts`.
+
 **Weapons the gallery did not model.** The melee weapons and tools with no gallery model (the bat, the axe, the machete, the knife, the hammer, the crowbar, the crossbow, the wrench, the extinguisher, the blowtorch...) are drawn with the team's item model of `@adatechnology/game-items-three` (Itens do Vale Cinzento), on the counters and in the hands: `buildItemWeaponModel` lays it along +x, flat, the head at +x, with an empty `handle` where the hand closes. The item is the one with the weapon's id, or the one `registerWeaponItemModel(weaponId, { item, turn, flip })` names (`wrench` → `adjustable_wrench`); `registerWeaponItemModel(id, null)` keeps the low-poly prop. Only a weapon with neither model falls back to the low-poly boxes of its category (`weaponProp`), and the kit's scene check (`tools/kit-audit/scene.mjs`) lists those as pending.
 
 **Reload sounds.** Each step of a reload makes its noise where the clip says: the clips carry `sound` cues (`cue(t, 'sound', { id })`), so the sound follows the animation and scales with the weapon's reload time (`mag_release`, `mag_out`, `mag_insert`, `mag_seat`, `slide_release`, `charging_handle_pull/release`, `bolt_lift/pull/push/lock`, `shell_insert` once per round, `pump_back/forward`, `lever_open/close`, `cylinder_open/eject/close`, `speedloader`, `barrels_open/close`, `belt_cover_open/close`, `belt_insert`, `rocket_load/seat`, `grenade_load`, `breech_open/close`, `tube_drop/seat`). The recipes are data (`src/data/reload-sounds.json`: layers of the game-audio primitives); a profile (`soundProfileOf`: weight light/medium/heavy from the model family, steel or polymer from a list in the data) changes their pitch and level, and `createWeaponAudio(volume, { reloadCues })` replaces or adds recipes. `createWeaponFx({ onSound })` is told at each cue (the test area logs it as a `sound` entry); `WeaponFx.clips` says which reload variant is playing. `tests/reload-sounds.test.ts` checks the cue order of every weapon and kind, one recipe per cue, and the per-round sounds.

package/dist/index.global.js

@@ -19681,6 +19681,23 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     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: rnd2, 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], rnd2)) {
+        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, (rnd2() - 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: rnd2, maxFragments } = inp;
     const [fmin, fmax] = inp.fragmentSize;
@@ -19723,6 +19740,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     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], rnd2)) {
         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] });
@@ -21305,6 +21324,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         0.03,
         0.15
       ],
+      sheet: 1e-3,
       damageScale: {
         slash: 3
       },
@@ -21320,7 +21340,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 15524048
       },
       tags: [
         "fabric",
@@ -23033,7 +23054,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         hit: hitLocal,
         fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
         maxFragments,
-        rnd: rnd2
+        rnd: rnd2,
+        sheet: p.mat.sheet
       });
       const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
       const mass = p.st.mass;
@@ -23057,7 +23079,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           velocity: [dv[0] * k, dv[1] * k + 0.5 * rnd2(), dv[2] * k],
           angularVelocity: [(rnd2() - 0.5) * 12, (rnd2() - 0.5) * 12, (rnd2() - 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;
@@ -37811,6 +37834,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     /** Closure of the fingers on a grip and on a forend (0 open, 1 closed). */
     closed: 0.9,
     forend: 0.6,
+    /** How far the shooting hand slides on its grip so the thumb reaches the safety lever. */
+    thumbReach: 0.02,
     /** How fast the supporting hand goes to the magazine and back, per second. */
     magRate: 7,
     /** The hands shrink with the tool: a tool drawn at scale `s` takes hands at `s ** handScaleExponent`. */
@@ -48497,9 +48522,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     );
     return [misfire, ...stopped];
   }
+  var SAFETY_MOTION = { cant: 0.22, lift: 0.012, in: 0.14, flickAt: 0.16, flick: 0.1, outAt: 0.32, out: 0.16, lever: 0.6 };
   function safetyClips(context) {
-    if (!context.parts.safety) return [];
-    return [composeClip("safety_on", [turn("safety", "z", 0, 0.12, 0, -0.6)]), composeClip("safety_off", [turn("safety", "z", 0, 0.12, -0.6, 0)]), composeClip("mode", [turn("safety", "z", 0, 0.07, 0, 0.4), turn("safety", "z", 0.07, 0.07, 0.4, 0)])];
+    const { cant, lift, in: rise, flickAt, flick, outAt, out, lever } = SAFETY_MOTION;
+    const carry = () => [turn(ROOT, "x", 0, rise, 0, cant), move(ROOT, "y", 0, rise, 0, lift), turn(ROOT, "x", outAt, out, cant, 0), move(ROOT, "y", outAt, out, lift, 0)];
+    const flickTo = (from, to) => context.parts.safety ? [turn("safety", "z", flickAt, flick, from, to)] : [];
+    const clips = [composeClip("safety_on", [...carry(), ...flickTo(0, -lever)]), composeClip("safety_off", [...carry(), ...flickTo(-lever, 0)])];
+    if (context.parts.safety) clips.push(composeClip("mode", [turn("safety", "z", 0, 0.07, 0, 0.4), turn("safety", "z", 0.07, 0.07, 0.4, 0)]));
+    return clips;
   }
   var drawClip = () => composeClip("draw", [move(ROOT, "y", 0, 0.35, -0.1, 0), turn(ROOT, "z", 0, 0.35, -0.6, 0)]);
 
@@ -58270,8 +58300,169 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         hand: "L",
         anchor: "cylinder_side",
         merge: 1
+      },
+      {
+        family: "pistol",
+        clips: [
+          "safety_on",
+          "safety_off"
+        ],
+        hand: "R",
+        anchor: "thumb_safety",
+        whole: true,
+        lead: 0.3,
+        tail: 0.3
+      },
+      {
+        family: "revolver",
+        clips: [
+          "safety_on",
+          "safety_off"
+        ],
+        hand: "R",
+        anchor: "thumb_safety",
+        whole: true,
+        lead: 0.3,
+        tail: 0.3
+      },
+      {
+        family: "rifle",
+        clips: [
+          "safety_on",
+          "safety_off"
+        ],
+        hand: "R",
+        anchor: "thumb_safety",
+        whole: true,
+        lead: 0.3,
+        tail: 0.3,
+        style: "ar"
+      },
+      {
+        family: "p90",
+        clips: [
+          "safety_on",
+          "safety_off"
+        ],
+        hand: "R",
+        anchor: "thumb_safety",
+        whole: true,
+        lead: 0.3,
+        tail: 0.3
+      },
+      {
+        family: "pump",
+        clips: [
+          "safety_on",
+          "safety_off"
+        ],
+        hand: "R",
+        anchor: "thumb_safety",
+        whole: true,
+        lead: 0.3,
+        tail: 0.3
+      },
+      {
+        family: "semi12",
+        clips: [
+          "safety_on",
+          "safety_off"
+        ],
+        hand: "R",
+        anchor: "thumb_safety",
+        whole: true,
+        lead: 0.3,
+        tail: 0.3
+      },
+      {
+        family: "semiint",
+        clips: [
+          "safety_on",
+          "safety_off"
+        ],
+        hand: "R",
+        anchor: "thumb_safety",
+        whole: true,
+        lead: 0.3,
+        tail: 0.3
+      },
+      {
+        family: "break",
+        clips: [
+          "safety_on",
+          "safety_off"
+        ],
+        hand: "R",
+        anchor: "thumb_safety",
+        whole: true,
+        lead: 0.3,
+        tail: 0.3
+      },
+      {
+        family: "bolt",
+        clips: [
+          "safety_on",
+          "safety_off"
+        ],
+        hand: "R",
+        anchor: "thumb_safety",
+        whole: true,
+        lead: 0.3,
+        tail: 0.3
+      },
+      {
+        family: "boltmag",
+        clips: [
+          "safety_on",
+          "safety_off"
+        ],
+        hand: "R",
+        anchor: "thumb_safety",
+        whole: true,
+        lead: 0.3,
+        tail: 0.3
+      },
+      {
+        family: "lever",
+        clips: [
+          "safety_on",
+          "safety_off"
+        ],
+        hand: "R",
+        anchor: "thumb_safety",
+        whole: true,
+        lead: 0.3,
+        tail: 0.3
+      },
+      {
+        family: "belt",
+        clips: [
+          "safety_on",
+          "safety_off"
+        ],
+        hand: "R",
+        anchor: "thumb_safety",
+        whole: true,
+        lead: 0.3,
+        tail: 0.3
+      },
+      {
+        family: "rifle",
+        clips: [
+          "safety_on",
+          "safety_off"
+        ],
+        hand: "L",
+        anchor: "lever_right",
+        style: "ak",
+        whole: true,
+        lead: 0.3,
+        tail: 0.3
       }
-    ]
+    ],
+    safety: {
+      comment: "Safety on and off (B): the shooting hand slides up its grip so the thumb flicks the lever while the clip cants the weapon; an AK-style rifle (akCharge) has its big lever on the right, pushed by the support hand over the top."
+    }
   };
 
   // src/fx/hand-work.ts
@@ -58299,6 +58490,18 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         if (!right || !parts.slide) return null;
         return { part: right.part, offset: right.offset.clone().add(V2(THREE, 0, 0.012, 0)), quaternion: right.quaternion };
       }
+      if (kind === "thumb_safety") {
+        if (!right) return null;
+        const toward2 = parts.safety ? right.part.worldToLocal(parts.safety.getWorldPosition(V2(THREE, 0, 0, 0))).sub(right.offset) : V2(THREE, 0, HAND_HOLD.thumbReach, 0);
+        return { part: right.part, offset: right.offset.clone().add(toward2.clampLength(0, HAND_HOLD.thumbReach)), quaternion: right.quaternion };
+      }
+      if (kind === "lever_right") {
+        const receiver = parts.bolt ?? parts.boltHandle;
+        if (!receiver) return null;
+        const b2 = boxIn(THREE, root, receiver);
+        const x = parts.trigger ? root.worldToLocal(parts.trigger.getWorldPosition(V2(THREE, 0, 0, 0))).x : b2.min.x;
+        return anchorAt(receiver, V2(THREE, x, b2.getCenter(V2(THREE, 0, 0, 0)).y, b2.max.z + palm), handFrame(THREE, V2(THREE, 1, 0, 0), V2(THREE, 0, 0, 1)));
+      }
       if (!part) return null;
       const b = boxIn(THREE, root, part);
       const c = b.getCenter(V2(THREE, 0, 0, 0));