@adatechnology/game-weapons-three 0.10.4 → 0.11.1

package/dist/index.js

@@ -1511,6 +1511,83 @@ var createLaserRaycast = (THREE, scene, camera, options = {}) => {
   };
 };
 
+// src/fx/body-hold.ts
+var BODY_HOLD = {
+  /** With no body to lend the frame: the pocket of the right shoulder from the eye, in the eye's yaw frame (right, up, back). */
+  eyeToPocket: [0.2, -0.275, 0.17],
+  /** A shouldered gun's bore runs this far above the shoulder pocket (the cheek on the comb). */
+  boreAbove: 0.05,
+  /** A handgun's (or a short two-hand gun's) grip: toward the middle of the chest, a little low, at the reach of bent arms. */
+  handgunGrip: [-0.15, -0.04, -0.42],
+  /** A one-hand tool's grip: low in front of the body, the elbow bent. */
+  toolGrip: [0.02, -0.34, -0.3],
+  /** A tool at least this long, held by two hands, is shouldered (its stock in the pocket). */
+  shoulderedFrom: 0.55,
+  /** The farthest a shouldered gun's grip sits ahead of the pocket; a launcher whose grip is farther slides back, its tube behind the shoulder. */
+  shoulderGripMax: 0.42,
+  /** The nearest a shouldered gun's grip sits ahead of the pocket; a gun with no stock (a pistol grip at its rear) slides forward, its grip not behind the eye. */
+  shoulderGripMin: 0.25,
+  /** Where such a grip is brought to, ahead of the pocket. */
+  shoulderGripTo: 0.34,
+  /** The farthest apart two hands hold a long gun (a support hand past it slides back along the gun, toward the grip). */
+  supportSpan: 0.5,
+  /** How much of the aim's pitch a tool held low in one hand follows. */
+  toolPitch: 0.5
+};
+var scratch = { a: null, b: null, euler: null };
+var placeOnBody = (placement) => {
+  const { THREE, hand, holder, frame } = placement;
+  scratch.a ?? (scratch.a = new THREE.Vector3());
+  scratch.b ?? (scratch.b = new THREE.Vector3());
+  holder.scale.setScalar(1);
+  hand.position.set(...frame.position);
+  hand.quaternion.set(...frame.quaternion);
+  const shouldered = !placement.handgun && placement.left !== null && placement.lengthMetres >= BODY_HOLD.shoulderedFrom;
+  if (shouldered) {
+    holder.position.set(0, BODY_HOLD.boreAbove, placement.rear);
+    hand.updateMatrixWorld(true);
+    if (!placement.right) return;
+    const grip2 = hand.worldToLocal(placement.right.part.localToWorld(scratch.a.copy(placement.right.offset)));
+    if (-grip2.z <= BODY_HOLD.shoulderGripMax && -grip2.z >= BODY_HOLD.shoulderGripMin) return;
+    holder.position.z += -grip2.z - BODY_HOLD.shoulderGripTo;
+    hand.updateMatrixWorld(true);
+    return;
+  }
+  scratch.euler ?? (scratch.euler = new THREE.Euler());
+  const turn2 = scratch.euler.setFromQuaternion(hand.quaternion, "YXZ");
+  hand.quaternion.setFromEuler(turn2.set(turn2.x * BODY_HOLD.toolPitch, turn2.y, 0, "YXZ"));
+  holder.position.set(0, 0, 0);
+  hand.updateMatrixWorld(true);
+  if (!placement.right) return;
+  const grip = placement.handgun || placement.left ? BODY_HOLD.handgunGrip : BODY_HOLD.toolGrip;
+  const want = scratch.a.set(grip[0], grip[1], grip[2]).applyQuaternion(hand.quaternion).add(hand.position);
+  const now = placement.right.part.localToWorld(scratch.b.copy(placement.right.offset));
+  hand.position.add(want.sub(now));
+  hand.updateMatrixWorld(true);
+};
+var limitSupportSpan = (targets) => {
+  const right = targets.R?.position;
+  const left = targets.L?.position;
+  if (!right || !left || !targets.L) return targets;
+  const span = Math.hypot(left[0] - right[0], left[1] - right[1], left[2] - right[2]);
+  if (span <= BODY_HOLD.supportSpan) return targets;
+  const k = BODY_HOLD.supportSpan / span;
+  const position = [right[0] + (left[0] - right[0]) * k, right[1] + (left[1] - right[1]) * k, right[2] + (left[2] - right[2]) * k];
+  return { ...targets, L: { ...targets.L, position } };
+};
+var createEyeFrame = (THREE, camera) => {
+  const frame = { position: [0, 0, 0], quaternion: [0, 0, 0, 1] };
+  const turn2 = new THREE.Euler(0, 0, 0, "YXZ");
+  const pocket = new THREE.Vector3();
+  return () => {
+    turn2.setFromQuaternion(camera.quaternion, "YXZ");
+    pocket.set(...BODY_HOLD.eyeToPocket).applyEuler(turn2.set(0, turn2.y, 0)).add(camera.position);
+    frame.position = [pocket.x, pocket.y, pocket.z];
+    frame.quaternion = [camera.quaternion.x, camera.quaternion.y, camera.quaternion.z, camera.quaternion.w];
+    return frame;
+  };
+};
+
 // src/fx/hand-hold.ts
 var HAND_HOLD = {
   /** Half the width of a pistol grip, the palm sits this far (plus the palm) off its middle. */
@@ -1539,9 +1616,7 @@ var HAND_HOLD = {
   /** 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`. */
-  handScaleExponent: 0.55
+  magRate: 7
 };
 var handFrame = (THREE, x, y) => {
   const ax = x.clone().normalize();
@@ -1631,7 +1706,8 @@ function holdOfModel(THREE, model, holderScale) {
     right,
     left,
     leftMagazine,
-    scale: holderScale ** HAND_HOLD.handScaleExponent,
+    // the hands at the tool's scale: a tool drawn smaller than the hands looks like a toy in them
+    scale: holderScale,
     grip: HAND_HOLD.closed,
     gripLeft: HAND_HOLD.forend
   };
@@ -1646,7 +1722,7 @@ function holdOfProp(THREE, group, category, scale) {
   const long = head && ["smg", "carbine", "rifle", "sniper", "shotgun", "crossbow", "flame"].includes(category);
   const headSize = head ? size(head) : null;
   const left = long && head && headSize ? { part: group, offset: head.position.clone().add(V(THREE, -headSize.x * 0.15, -headSize.y / 2 - HAND_HOLD.palm, 0)), quaternion: forendFrame(THREE) } : null;
-  return { right, left, leftMagazine: null, scale: scale ** HAND_HOLD.handScaleExponent, grip: HAND_HOLD.closed, gripLeft: HAND_HOLD.forend };
+  return { right, left, leftMagazine: null, scale, grip: HAND_HOLD.closed, gripLeft: HAND_HOLD.forend };
 }
 
 // src/props.ts
@@ -4943,7 +5019,6 @@ var FALLBACK_ENERGY = 300;
 var MAX_CASINGS = 120;
 var MAX_MAGAZINES = 12;
 var LIFETIME_S = 25;
-var HAND_OFFSET = [0.2, -0.2, -0.42];
 var GRAVITY = 9.81;
 function createBoxFx(options) {
   const { THREE, scene, camera, arsenal, groundAt } = options;
@@ -4965,6 +5040,10 @@ function createBoxFx(options) {
   let dip = 0;
   let reloading = false;
   const v = new THREE.Vector3();
+  const v2 = new THREE.Vector3();
+  const eyeFrame = createEyeFrame(THREE, camera);
+  let rear = 0;
+  let lengthMetres = 0;
   const q = new THREE.Quaternion();
   const q2 = new THREE.Quaternion();
   const pointForward = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI / 2);
@@ -4976,13 +5055,17 @@ function createBoxFx(options) {
     if (!def || BODY_ACTIONS.has(def.id)) return;
     model = buildWeaponModel(THREE, def);
     const length = new THREE.Box3().setFromObject(model).getSize(v).x;
-    model.scale.setScalar(length > 0.8 ? 0.55 : length > 0.4 ? 0.75 : 1);
+    rear = new THREE.Box3().setFromObject(model).min.x;
+    lengthMetres = length;
     model.quaternion.copy(pointForward);
     hand.add(model);
     inHand = def.id;
-    hold = holdOfProp(THREE, model, def.category, model.scale.x);
+    hold = holdOfProp(THREE, model, def.category, 1);
+  };
+  const handPoint = (x, y, z, out) => {
+    if (!model) return out.set(x, y, z).applyQuaternion(camera.quaternion).add(camera.position);
+    return out.set(x, y, z).applyQuaternion(camera.quaternion).add(model.getWorldPosition(v2));
   };
-  const handPoint = (x, y, z, out) => out.set(HAND_OFFSET[0] + x, HAND_OFFSET[1] + y, HAND_OFFSET[2] + z).applyQuaternion(camera.quaternion).add(camera.position);
   const throwBody = (kind, mesh, from, velocity, radius) => {
     if (!(kind === "casing" ? layers.casings : layers.magazines)) {
       mesh.geometry.dispose();
@@ -5093,10 +5176,12 @@ function createBoxFx(options) {
     update(dt) {
       kick *= Math.exp(-dt * 14);
       dip += ((reloading ? 1 : 0) - dip) * Math.min(1, dt * 8);
-      if (inHand) {
-        handPoint(0, -0.12 * dip, 0.05 * kick, hand.position);
+      if (inHand && model) {
+        const handgun = def?.category === "pistol" || def?.category === "revolver";
+        placeOnBody({ THREE, hand, holder: model, frame: options.bodyHold?.() ?? eyeFrame(), rear, lengthMetres, handgun, right: hold?.right ?? null, left: hold?.left ?? null });
+        hand.position.add(v.set(0, -0.12 * dip, 0.05 * kick).applyQuaternion(camera.quaternion));
         q.setFromEuler(new THREE.Euler(0.14 * kick - 0.25 * dip, 0, 0.6 * dip));
-        hand.quaternion.copy(camera.quaternion).multiply(q);
+        hand.quaternion.multiply(q);
       }
       for (const body of [...bodies]) {
         stepBody(body, dt);
@@ -6181,6 +6266,14 @@ function createEffects(THREE, sink, random) {
 
 // src/fx/heavy.ts
 var PI12 = Math.PI;
+var ROCKET_LIGHT_NAME = "rocket-light";
+var rocketsInFlight = /* @__PURE__ */ new WeakMap();
+function createRocketLight(THREE) {
+  const light = new THREE.PointLight(16751168, 0, 2.5);
+  light.name = ROCKET_LIGHT_NAME;
+  light.position.set(0, -50, 0);
+  return light;
+}
 var flameMaterials = (kit) => {
   const { THREE } = kit;
   return [
@@ -6210,8 +6303,9 @@ function launchRocket(context, flyRound = true) {
   exhaust.rotation.z = PI12 / 2;
   exhaust.position.x = -0.08;
   rocket.add(exhaust);
-  const light = new THREE.PointLight(16751168, 3, 2.5);
-  rocket.add(light);
+  const light = context.rocketLight;
+  light.intensity = 3;
+  rocketsInFlight.set(light, (rocketsInFlight.get(light) ?? 0) + 1);
   context.every(
     1.6,
     (progress, dt) => {
@@ -6219,6 +6313,7 @@ function launchRocket(context, flyRound = true) {
       const distance = 1.2 * flight + (flight > 0.25 ? 9 * (flight - 0.25) ** 2 : 0);
       rocket.position.copy(muzzle).addScaledVector(forward, distance);
       rocket.rotation.x += 0.25 * dt * 60;
+      light.position.copy(rocket.position);
       exhaust.scale.set(1, 0.6 + random() * 0.8, 1);
       if (random() < 0.9) context.effects.smoke(rocket.position.clone().addScaledVector(forward, -0.12), new THREE.Vector3((random() - 0.5) * 0.1, 0.05, (random() - 0.5) * 0.1), 0.02 + random() * 0.015, 2.2, 0.5);
     },
@@ -6226,7 +6321,11 @@ function launchRocket(context, flyRound = true) {
       rocket.removeFromParent();
       exhaust.geometry.dispose();
       exhaust.material.dispose();
-      light.dispose();
+      const remaining = (rocketsInFlight.get(light) ?? 1) - 1;
+      rocketsInFlight.set(light, remaining);
+      if (remaining > 0) return;
+      light.intensity = 0;
+      light.position.set(0, -50, 0);
     }
   );
 }
@@ -7045,11 +7144,9 @@ function workWeights(works, running) {
 
 // src/fx/viewmodel.ts
 var PI14 = Math.PI;
-var HAND_OFFSET2 = [0.2, -0.2, -0.42];
-var HANDGUN_OFFSET = [0.1, -0.12, -0.44];
 var HEAT_DISPLAY_MAX_FALLBACK = 120;
-var WALL_PULL = { margin: 0.03, max: 0.7, rate: 14, probe: 3 };
-var HAND_IN_VIEW = { floor: -0.88, max: 0.18, rate: 10 };
+var WALL_PULL = { margin: 0.03, max: 1.2, rate: 14, probe: 3 };
+var HAND_IN_VIEW = { floor: -0.88, max: 0.3, rate: 10 };
 var LAUNCH_VOLUME = 0.6;
 var fittedOf2 = (parts) => parts.map((part) => ({ id: part.id, mount: part.mount, ...part.integral ? { integral: true } : {}, ...part.on === void 0 ? {} : { on: part.on } }));
 var collapsedStockPose = (move2) => {
@@ -7079,6 +7176,8 @@ function createViewmodel(options) {
   const hand = new THREE.Group();
   hand.name = VIEWMODEL_NODE_NAME;
   scene.add(hand);
+  const rocketLight = createRocketLight(THREE);
+  scene.add(rocketLight);
   const holder = new THREE.Group();
   holder.quaternion.setFromAxisAngle(new THREE.Vector3(0, 1, 0), PI14 / 2);
   hand.add(holder);
@@ -7135,7 +7234,8 @@ function createViewmodel(options) {
     positionOf: (part) => worldPositionOf(current, part, new THREE.Vector3()),
     orientation: () => current.model.root.getWorldQuaternion(new THREE.Quaternion()),
     every: (seconds, step, done) => void tasks.push({ delay: 0, seconds, elapsed: 0, step, done }),
-    groundAt
+    groundAt,
+    rocketLight
   });
   const equip = (weapon) => {
     const def = arsenal.weapons.get(weapon);
@@ -7148,14 +7248,11 @@ function createViewmodel(options) {
     reach = 0;
     pull = 0;
     lift = 0;
-    handHeight = 0;
-    handDepth = 0;
     rigStock(THREE, model, def);
     rigUnderbarrel(THREE, model, def);
-    const length = new THREE.Box3().setFromObject(model.root).getSize(new THREE.Vector3()).x;
-    const scale = length > 0.8 ? 0.55 : length > 0.4 ? 0.75 : 1;
-    holder.scale.setScalar(scale);
-    holder.position.set(0, 0, Math.min(0.25, 0.25 * length * scale));
+    const modelBox = new THREE.Box3().setFromObject(model.root);
+    const length = modelBox.getSize(new THREE.Vector3()).x;
+    modelRear = modelBox.min.x;
     holder.add(model.root);
     const caliber = caliberOf(arsenal, def);
     const dims = caliber?.cartridge;
@@ -7167,7 +7264,7 @@ function createViewmodel(options) {
       def,
       caliber,
       model,
-      holderScale: scale,
+      holderScale: 1,
       lengthMetres: length,
       caseType: caliber?.caseType ?? "rifle",
       soundProfile: soundProfileOf(weapon, model.parts.family),
@@ -7197,7 +7294,7 @@ function createViewmodel(options) {
     applyCondition(kit, model, condition);
     lastAmmo = options.tool?.().ammo ?? 0;
     hand.updateMatrixWorld(true);
-    hold = holdOfModel(THREE, model, scale);
+    hold = holdOfModel(THREE, model, 1);
     hold = { ...hold, works: handWorkOf(THREE, model, weapon, hold.right) };
     triggerRest = model.parts.trigger?.rotation.z ?? 0;
     lastShot = -Infinity;
@@ -7217,8 +7314,6 @@ function createViewmodel(options) {
   let reach = 0;
   let pull = 0;
   let lift = 0;
-  let handHeight = 0;
-  let handDepth = 0;
   const ahead = new THREE.Vector3();
   const up = new THREE.Vector3();
   const seen = new THREE.Vector3();
@@ -7231,23 +7326,35 @@ function createViewmodel(options) {
     for (const x of [bounds.min.x, bounds.max.x]) for (const y of [bounds.min.y, bounds.max.y]) for (const z of [bounds.min.z, bounds.max.z]) farthest = Math.max(farthest, corner.set(x, y, z).sub(camera.position).dot(ahead));
     return farthest;
   };
+  let modelRear = 0;
+  const eyeFrame = createEyeFrame(THREE, camera);
+  const liftToKeepInView = () => {
+    if (!hold || !session || !("fov" in camera)) return 0;
+    const tanHalf = Math.tan((camera.fov ?? 70) * PI14 / 360);
+    eyeTurn.copy(camera.quaternion).invert();
+    const rest = targetsOf(THREE, hold, session.model.root.getWorldQuaternion(rootQuaternion), 0);
+    let needed = 0;
+    for (const [anchor, pose] of [[hold.right, rest.R], [hold.left, rest.L]]) {
+      if (!anchor || !pose || anchor.part !== session.model.root) continue;
+      seen.set(...pose.position).sub(camera.position).applyQuaternion(eyeTurn);
+      if (-seen.z > 0.05) needed = Math.max(needed, HAND_IN_VIEW.floor * -seen.z * tanHalf - seen.y);
+    }
+    return Math.max(0, Math.min(HAND_IN_VIEW.max, needed));
+  };
   const place = (dt = 0) => {
-    const family = session?.model.parts.family;
-    const [x, y, z] = family === "pistol" || family === "revolver" ? HANDGUN_OFFSET : HAND_OFFSET2;
-    hand.position.set(x, y, z).applyQuaternion(camera.quaternion).add(camera.position);
-    hand.quaternion.copy(camera.quaternion);
-    if (session && handDepth > 0.05 && "fov" in camera) {
-      const tanHalf = Math.tan((camera.fov ?? 70) * PI14 / 360);
-      const want2 = Math.max(0, Math.min(HAND_IN_VIEW.max, lift + (HAND_IN_VIEW.floor - handHeight) * tanHalf * handDepth));
-      lift += (want2 - lift) * Math.min(1, dt * HAND_IN_VIEW.rate);
-      if (lift > 1e-4) hand.position.addScaledVector(up.set(0, 1, 0).applyQuaternion(camera.quaternion), lift);
-    }
+    if (!session) return;
+    const family = session.model.parts.family;
+    session.holderScale = 1;
+    placeOnBody({ THREE, hand, holder, frame: options.bodyHold?.() ?? eyeFrame(), rear: modelRear, lengthMetres: session.lengthMetres, handgun: family === "pistol" || family === "revolver", right: hold?.right ?? null, left: hold?.left ?? null });
     hand.updateMatrixWorld(true);
-    if (!options.contact || !session) return;
+    lift += (liftToKeepInView() - lift) * Math.min(1, dt * HAND_IN_VIEW.rate);
+    if (lift > 1e-4) hand.position.addScaledVector(up.set(0, 1, 0).applyQuaternion(camera.quaternion), lift);
+    hand.updateMatrixWorld(true);
+    if (!options.contact) return;
     ahead.set(0, 0, -1).applyQuaternion(camera.quaternion);
     if (reach === 0) reach = Math.max(0.01, measureReach(session));
     const free = options.contact(camera.position, ahead, WALL_PULL.probe);
-    const want = free === null ? 0 : Math.max(0, Math.min(WALL_PULL.max, reach + WALL_PULL.margin - free));
+    const want = free === null ? 0 : Math.max(0, Math.min(Math.max(WALL_PULL.max, session.lengthMetres * session.holderScale), reach + WALL_PULL.margin - free));
     pull += (want - pull) * Math.min(1, dt * WALL_PULL.rate);
     if (pull < 1e-4) return;
     hand.position.addScaledVector(ahead, -pull);
@@ -7357,12 +7464,7 @@ function createViewmodel(options) {
       const targets = targetsOf(THREE, hold, session.model.root.getWorldQuaternion(rootQuaternion), magazineHand, hold.works ? workWeights(hold.works, player?.running ?? []) : void 0);
       const trigger = session.model.parts.trigger;
       if (trigger) targets.fingers = { index: indexCurl(trigger.rotation.z - triggerRest, clock - lastShot) };
-      if (targets.R && "fov" in camera) {
-        seen.set(...targets.R.position).sub(camera.position).applyQuaternion(eyeTurn.copy(camera.quaternion).invert());
-        handDepth = -seen.z;
-        handHeight = handDepth > 0.05 ? seen.y / handDepth / Math.tan((camera.fov ?? 70) * PI14 / 360) : 0;
-      }
-      return targets;
+      return limitSupportSpan(targets);
     },
     get inHand() {
       return session?.id ?? null;
@@ -7381,6 +7483,8 @@ function createViewmodel(options) {
       particles.dispose();
       ownVfx?.dispose();
       hand.removeFromParent();
+      rocketLight.removeFromParent();
+      rocketLight.dispose();
     }
   };
 }
@@ -7405,6 +7509,7 @@ function createWeaponFx(options) {
     ...options.attachmentModels ? { attachmentModels: options.attachmentModels } : {},
     ...options.raycast ? { raycast: options.raycast } : {},
     ...options.contact ? { contact: options.contact } : {},
+    ...options.bodyHold ? { bodyHold: options.bodyHold } : {},
     ...options.effects ? { effects: options.effects } : {},
     ...options.flyRocket === void 0 ? {} : { flyRocket: options.flyRocket }
   });
@@ -8686,6 +8791,7 @@ function createWeaponsTestModule(options = {}) {
         raycast: createLaserRaycast(lent.THREE, lent.scene, lent.camera),
         // the weapon against a wall asks as often as the laser, on the clock of the simulation (so a fast-forwarded room measures as often per frame)
         contact: createLaserRaycast(lent.THREE, lent.scene, lent.camera, { now: () => simulatedMs }),
+        ...lent.holdFrame ? { bodyHold: () => lent.holdFrame?.() ?? null } : {},
         ...lent.effects ? { effects: lent.effects } : {},
         ...options.attachmentModels ? { attachmentModels: options.attachmentModels } : {},
         ...options.condition ? { condition: options.condition } : {},
@@ -9505,7 +9611,7 @@ function pushScenario(all, bench, mode) {
       };
       for (const { kind, item } of PUSH_KINDS) PUSH_LAYOUT[kind].forEach(([distance, degrees]) => lay(kind, item, bearing(centre, distance, degrees)));
       if (mode === "grenade") {
-        lay("zombie", "zombie_walker", bearing(centre, 3.4, -34));
+        lay("zombie", "zombie_walker", bearing(centre, 3.4, -130));
         lay("survivor", "person_police_officer", bearing(centre, 7.5, 78));
         lay("camp_table", "camp_table", bearing(centre, 3, 90));
       }
@@ -9548,7 +9654,7 @@ function pushScenario(all, bench, mode) {
         const outward = ((now[0] - from[0]) * (from[0] - blast.point[0]) + (now[2] - from[2]) * (from[2] - blast.point[2])) / away;
         return { ...body, distance, outward, moved: flat(now, from) };
       });
-      const torn = (row) => PUSH_KINDS.some((entry) => entry.kind === row.kind) && partsOf(row.objectId) < (partsBefore.get(row.objectId) ?? 0);
+      const torn = (row) => (PUSH_KINDS.some((entry) => entry.kind === row.kind) || HEAVY_ITEMS.includes(row.kind)) && partsOf(row.objectId) < (partsBefore.get(row.objectId) ?? 0);
       const reached = rows.filter((row) => row.distance < blast.radius * 0.85 && !torn(row));
       const movedAway = reached.filter((row) => row.outward >= MOVED);
       const least = reached.length === 0 ? 0 : Math.min(...reached.map((row) => row.outward));
@@ -9561,9 +9667,9 @@ function pushScenario(all, bench, mode) {
         expect(near.outward > far.outward, fillText2(text.push_falloff, { what: things[kind] ?? kind, near: near.outward.toFixed(2), nearDistance: near.distance.toFixed(1), far: far.outward.toFixed(2), farDistance: far.distance.toFixed(1) }), { near: near.outward, far: far.outward });
       }
       for (const row of reached.filter((entry) => entry.kind === "zombie" || entry.kind === "survivor")) {
-        expect(row.outward >= MOVED, fillText2(text.push_person, { who: things[row.kind] ?? row.kind, distance: row.distance.toFixed(1), moved: row.outward.toFixed(2) }), { row });
+        expect(row.outward >= MOVED, fillText2(text.push_person, { who: things[row.kind] ?? row.kind, distance: row.distance.toFixed(1), moved: row.outward.toFixed(2) }), { row: { kind: row.kind, distance: row.distance, outward: row.outward } });
       }
-      const table = reached.find((row) => HEAVY_ITEMS.includes(row.kind));
+      const table = rows.find((row) => HEAVY_ITEMS.includes(row.kind) && row.distance < blast.radius * 0.85);
       if (table) expect(table.moved >= MOVED, fillText2(text.push_heavy, { what: things[table.itemId] ?? table.itemId, moved: table.moved.toFixed(2) }), { table });
     }
   };