sindicate 0.4.0 → 0.6.0

package/src/systems/combat.js

@@ -0,0 +1,586 @@
+// Combat orchestration: outlaw spawning, fist melee resolution, and bullets.
+import * as THREE from 'three/webgpu';
+import { segmentCapsule, BODY } from './aim.js';
+import { Enemy, foes } from './enemy.js';
+import { alarmTown } from './npc.js';
+import { dist2D, tmpV1 } from '../core/utils.js';
+
+const _prevPos = new THREE.Vector3(); // projectile pre-move position for the wall sweep
+
+// Bare-fist boxing combo — real MoCap Online "PUNCH Starter" clips (retargeted to the Synty rig).
+// Light combo cycles jab → cross → hook; heavy is an uppercut. Idle guard is played from player.js.
+const UNARMED_LIGHT = ['punchJab', 'punchCross', 'punchHook'];
+const UNARMED_HEAVY = ['punchUpper'];
+
+// FINISHERS: a staggered foe this weakened can be executed with F (fists only in the west —
+// gun kills don't need the ceremony). More lenient when it's the last foe standing nearby.
+const FINISH_HP = 0.25;        // health fraction gate
+// A headshot is a hit landing above the collar: metres above the FEET (an entity's position is
+// at ground level). These bodies stand ~1.8m with the shoulders at ~1.4, so 1.5 is the neck.
+const HEAD_Y = 1.5;
+// The body, as the bullets see it: a vertical capsule from the ankles to the crown. Radius is a
+// man's shoulders halved, and generous by a hair — a western is a game about hitting people.
+const BOUNTY = 14;     // the last outlaw's purse, multiplied: clearing the gang is worth doing
+const BODY_LO = 0.25;
+const BODY_HI = 1.78;
+const BODY_R = 0.42;
+const _seg = new THREE.Vector3();   // fallback segment start, when a caller has no previous position
+const FINISH_HP_LAST = 0.35;   // gate when no other hostile is within 10m
+const FINISH_RANGE = 3.0;      // metres, and roughly in front:
+const FINISH_ARC = 1.2;        // radians off player heading
+// A shot fired ANYWHERE is heard: the street empties. Nobody in a western stands in the open
+// looking mildly interested while a gunfight happens — panic, not obliviousness.
+const GUNSHOT_R = 22;
+
+export class Combat {
+  constructor(game) {
+    this.game = game;
+    this.enemies = [];
+    this.projectiles = [];
+    this.spawners = [];
+    this.clips = null;
+  }
+
+  // ---------- spawning ----------
+
+  addSpawner({ type, x, z, count, respawn = 90, leashR = 26, passive = false, tag = '' }) {
+    this.spawners.push({ type, x, z, count, respawn, leashR, passive, tag, alive: [], timer: 0 });
+  }
+
+  async spawn(type, x, z, opts = {}) {
+    const e = new Enemy(this.game, type, this.clips, { x, z, ...opts });
+    await e.load();
+    this.game.scene.add(e.root);
+    this.enemies.push(e);
+    // VAT-back ordinary humanoid enemies (vatRoster.js) IF a roster exists — v1 ships
+    // without VAT, so this nil-guards to "always real". Bosses stay always-real regardless.
+    const def = e.def ?? {};
+    if (!def.boss && this.game.vatRoster) {
+      const bake = {};
+      for (const n of ['idle', 'walk', 'run']) if (e.clipSet?.[n]) bake[n] = e.clipSet[n];
+      if (bake.idle) e.vatProxy = this.game.vatRoster.register(e, { bakeClips: bake, promoteR: 25, demoteR: 30 }) ?? undefined;
+    }
+    return e;
+  }
+
+  async populate(clips) {
+    this.clips = clips;
+    // ONE tracer master, cloned per shot: a thin emissive streak, no texture, no lights —
+    // the same preload-at-boot discipline the arrow master had (no mid-fight geometry builds).
+    const geo = new THREE.BoxGeometry(0.02, 0.02, 0.7); // long axis = +Z (flight direction)
+    const mat = new THREE.MeshBasicMaterial({ color: 0xffe8b0, fog: false });
+    this.tracerMaster = new THREE.Mesh(geo, mat);
+
+    // Outlaw spawners are registered by main.js (the "clear the outlaws" objective owns
+    // placement); anything queued before populate spawns now, on the loading screen —
+    // deferring spawns into live gameplay steals frames (skinned-mesh builds mid-play).
+    for (const s of this.spawners) await this._spawnFrom(s);
+  }
+
+  async _spawnFrom(s) {
+    for (let i = 0; i < s.count; i++) {
+      const a = (i / s.count) * Math.PI * 2;
+      try {
+        const e = await this.spawn(s.type, s.x + Math.sin(a) * 6, s.z + Math.cos(a) * 6, { leashR: s.leashR, passive: s.passive });
+        e.spawner = s; s.alive.push(e);
+      } catch (err) { console.warn('[spawn] failed', s.type, err); }
+    }
+  }
+
+  nearestEnemy(pos, maxDist = 18, exclude = null) {
+    let best = null, bestD = maxDist;
+    for (const e of this.enemies) {
+      if (!e.alive || e === exclude || e.faction === 'ally') continue;
+      const d = dist2D(pos.x, pos.z, e.position.x, e.position.z);
+      if (d < bestD) { best = e; bestD = d; }
+    }
+    return best;
+  }
+
+  // objective API (WESTERN_CONTRACT): main.js polls this / listens for onOutlawsCleared
+  outlawsAlive() {
+    let n = 0;
+    for (const e of this.enemies) if (e.alive && e.type?.startsWith('outlaw')) n++;
+    return n;
+  }
+
+  // ---------- player attacks ----------
+
+  // FINISHER: the cinematic execute on a staggered, weakened foe. The player is locked
+  // (busy) and invulnerable (dodgeT i-frames) for the move; the victim is held in its
+  // stagger with any pending swing cancelled; the killing blow lands on the uppercut's
+  // impact beat and routes through takeDamage so the death-anim fires.
+  executeFinisher() {
+    const e = this.finishTarget, p = this.game.player;
+    if (!e || !e.alive || !p.alive || p.busy) return false;
+    this.finishTarget = null;
+    // square the two up
+    p.heading = Math.atan2(e.position.x - p.position.x, e.position.z - p.position.z);
+    p.root.rotation.y = p.heading;
+    e.faceToward?.(p.position.x, p.position.z);
+    // hold the victim through the blow: stagger persists, pending swing dies
+    e.staggerT = Math.max(e.staggerT, 1.2);
+    e._swing = null;                                   // cancel a pending swing (game-time, enemy.js)
+    e._hitBusyT = 0;                                   // the idle-alias failsafe must not clear the deliberate victim hold
+    // hold the pose too: busy stops the FSM's idle branches overwriting the reel, and the
+    // clamped hit clip keeps the victim reeling until the death anim replaces it
+    e.busy = true;
+    e.animator?.play('hit', { once: true, fade: 0.08 });
+    p.busy = true;
+    p.dodgeT = 1.6;                 // i-frames — nothing interrupts an execution
+    p.comboStep = 0; p.comboWindow = 0;
+    p.attackCooldown = 0.3;
+    this.game.audio?.play('swingHeavy');
+    p.animator.play('punchUpper', {
+      once: true, fade: 0.08, timeScale: 0.9,   // slower = weightier than the combo upper
+      onDone: () => { p.busy = false; p.dodgeT = Math.min(p.dodgeT, 0.1); },
+    });
+    this._finishHit = { t: 0.45, e };            // impact beat ticks in update() on GAME time
+    return true;
+  }
+
+  // the killing blow — runs from update() so pause/dialogue can never race it
+  _finishImpact(e) {
+    const p = this.game.player;
+    if (!p.alive || !e.alive || !this.enemies.includes(e)) return;   // despawn evicted it
+    const shown = Math.ceil(e.health);
+    e.takeDamage(e.health + 1, p.position, { softHit: true });       // no shove — die where you stand
+    this.game.vfx.hit(e.position.clone().setY(e.position.y + 1.1));
+    const bdir = p.position.clone().sub(e.position).setY(0).normalize().multiplyScalar(0.5); bdir.y = 1.1;
+    this.game.vfx.blood(e.position.clone().setY(e.position.y + 1.2), bdir, 2);
+    this.game.hitstopT = Math.max(this.game.hitstopT ?? 0, 0.22);    // the big crunch (kills are 0.13)
+    this.game.shake(0.75);
+    this.game.audio?.play('hit');
+    this.game.ui?.showDamage(e, shown);
+  }
+
+  // ONE fist-vs-body test. `e` is anything with the SHOOTABLE-PEOPLE contract — an outlaw, or a
+  // townsman who was standing in the wrong place. Returns true if the punch landed.
+  // (opts.attacker is what tells a civilian whose crime this was: npc.js reads it.)
+  _meleeHit(e, dmg, heavy, range, arc) {
+    const p = this.game.player;
+    const d = dist2D(p.position.x, p.position.z, e.position.x, e.position.z);
+    if (d > range) return false;
+    const ang = Math.atan2(e.position.x - p.position.x, e.position.z - p.position.z);
+    let da = Math.abs(ang - p.heading) % (Math.PI * 2);
+    if (da > Math.PI) da = Math.PI * 2 - da;
+    if (da > arc) return false;
+    if (this.game.world.losBlocked(p.position, e.position)) return false;   // no hitting through walls
+    e.provoke?.();                                     // an outlaw turns on you; a townsman has no fight in him
+    // light hits barely displace (perpetual bounce-out was half of "they never hit me");
+    // heavies still bowl them
+    e.takeDamage(dmg, p.position, { knockback: heavy ? 0.4 : 0.05, power: heavy ? 1 : 0, attacker: p });
+    this.game.vfx.hit(e.position.clone().setY(e.position.y + 1.1));
+    // blood squirts UP and back toward the attacker (the camera) so it's visible, not
+    // hidden behind the foe
+    const bdir = p.position.clone().sub(e.position).setY(0).normalize().multiplyScalar(0.5); bdir.y = 1.0;
+    this.game.vfx.blood(e.position.clone().setY(e.position.y + 1.2), bdir, 1);
+    // hit-stop: a breath on connect, a longer one on the killing blow
+    this.game.hitstopT = Math.max(this.game.hitstopT ?? 0, !e.alive ? 0.13 : heavy ? 0.09 : 0.045);
+    this.game.ui?.showDamage(e, Math.round(dmg));
+    return true;
+  }
+
+  playerMelee(heavy) {
+    const p = this.game.player;
+    // Combat magnetism: face the nearest enemy in reach so a stationary combo
+    // keeps landing. Without this, the first swing connects but knockback nudges
+    // the target off the fixed swing arc and the follow-ups whiff.
+    // ENEMIES ONLY — magnetism must never snap a punch onto a bystander mid-gunfight. If you want
+    // to hit a townsman you have to actually be facing him; the arc test below does the rest.
+    let aim = p.lockTarget?.alive ? p.lockTarget : null;
+    if (!aim) {
+      let bestD = 3.2;
+      for (const e of this.enemies) {
+        if (!e.alive || e.faction === 'ally') continue;
+        const d = dist2D(p.position.x, p.position.z, e.position.x, e.position.z);
+        if (d < bestD) { bestD = d; aim = e; }
+      }
+    }
+    if (aim) {
+      p.heading = Math.atan2(aim.position.x - p.position.x, aim.position.z - p.position.z);
+      p.root.rotation.y = p.heading;
+    }
+    const combo = heavy ? UNARMED_HEAVY : UNARMED_LIGHT;
+    const step = Math.min(p.comboStep, combo.length - 1);
+    const anim = combo[step];
+
+    p.busy = true;
+    p.comboStep = (step + 1) % combo.length;
+    p.comboWindow = 1.1;
+    p.attackCooldown = heavy ? 0.25 : 0.12;
+    this.game.audio?.play(heavy ? 'swingHeavy' : 'swing');
+
+    p.animator.play(anim, {
+      once: true, fade: 0.07, timeScale: heavy ? 1.2 : 1.5,
+      onDone: () => { p.busy = false; }, // start-trim comes from CLIP_TIMING
+    });
+
+    // damage window mid-swing — combo steps B/C start mid-clip, so their window comes
+    // sooner. GAME time: the wall-clock version silently ATE the hit if a menu opened
+    // mid-swing, and desynced from the animation under hit-stop (audit m45)
+    const delay = heavy ? 450 : (step === 0 ? 280 : 200);
+    this.game.after(delay / 1000, () => {
+      if (!p.alive) return;
+      const dmg = (p.fistDamage ?? 8) * (heavy ? 1.6 : 1);
+      const range = 1.7, arc = 1.5;
+      let hitAny = false;
+      for (const e of this.enemies) {
+        if (!e.alive || e.faction === 'ally') continue;
+        if (this._meleeHit(e, dmg, heavy, range, arc)) hitAny = true;
+      }
+      // ...AND THE TOWNSFOLK. A fist that passes through a barman is not a fist. They take the
+      // punch on the same terms as an outlaw (npc.js: he cries out and he runs), and the arc keeps
+      // its full sweep — a heavy swing that catches two men catches two men.
+      // The coach crew are NOT in here: a man on the box is 1.6m up and a fare is behind a wooden
+      // wall, and the coach is a COLLIDER, not world BVH — so losBlocked can't stop the punch and
+      // you'd be knocking fares out through the side of a moving stagecoach. Shoot them.
+      // ...EXCEPT THE CHILDREN. `noTarget` is a property of the entity (npc.js), honoured at every
+      // place a body is gathered. The fist passes through.
+      for (const n of this.game.npcs ?? []) {
+        if (!n.alive || n.noTarget) continue;
+        if (this._meleeHit(n, dmg, heavy, range, arc)) hitAny = true;
+      }
+      // smashables share the swing arc — crates/barrels/bottles break on any hit
+      if (this.game.smashables?.tryMelee(p.position, p.heading, range, arc)) hitAny = true;
+      if (hitAny) {
+        this.game.audio?.play('hit');
+        this.game.shake(0.3);
+      } else {
+        this.game.audio?.play('whoosh');
+      }
+    });
+  }
+
+  // ---------- bullets ----------
+
+  // The pinned gunfire API (WESTERN_CONTRACT): from/dir are Vector3 (dir normalized,
+  // INCLUDES pitch — the player fires down the camera ray). Straight flight, no gravity;
+  // lifetime = range/speed; per-frame world BVH sweep (tunnel-proof at 90m/s); flesh hits
+  // bleed + provoke, world hits kick dirt. `shooter` is skipped by its own bullet.
+  fireBullet({ from, dir, damage, speed = 90, range = 80, friendly = true, shooter = null, alarm = true }) {
+    const obj = this.tracerMaster
+      ? this.tracerMaster.clone()
+      : new THREE.Mesh(new THREE.BoxGeometry(0.02, 0.02, 0.7), new THREE.MeshBasicMaterial({ color: 0xffe8b0, fog: false }));
+    obj.position.copy(from);
+    obj.lookAt(from.clone().add(dir));
+    this.game.scene.add(obj);
+    this.projectiles.push({
+      obj, dir: dir.clone().normalize(), speed, damage, friendly, shooter,
+      kind: 'bullet', age: 0, ttl: range / Math.max(speed, 1),
+    });
+    // THE TOWN HEARS IT. Whoever fired — you, an outlaw — a gunshot scatters the street (npc.js).
+    // An EVENT, not a per-frame cost: ~13 townsfolk once per round fired.
+    //
+    // ...BUT NOT THE WARM-UP SHOT. main.js's warmUpFX fires one round from (0, -800, 0) to compile
+    // the projectile pipeline behind the loading screen — and alarmTown measures in 2D (dist2D, y
+    // ignored), so a bullet EIGHT HUNDRED METRES BELOW THE MAP still reads as x=0, z=0: the middle
+    // of Dustwater's crossroads. Seven townsfolk heard a gunshot during the loading screen and were
+    // still running when the game handed you the reins. `alarm: false` is the honest fix — moving
+    // the warm-up shot sideways would only hide it until someone moved it back.
+    if (alarm) alarmTown(this.game, from.x, from.z, GUNSHOT_R, 3);
+  }
+
+  // legacy entry point — the gun state machine (player.js) calls fireBullet with the
+  // camera ray; this flat-fire wrapper survives for anything still wired to it.
+  playerShoot() {
+    const p = this.game.player;
+    const dir = new THREE.Vector3(Math.sin(p.heading), 0, Math.cos(p.heading));
+    this.fireBullet({
+      from: p.position.clone().add(new THREE.Vector3(0, 1.45, 0)).addScaledVector(dir, 0.3),
+      dir, damage: 16,
+    });
+  }
+
+  // bullet met the world: dirt/wood/stone all share the dust kick v1; the whine is rationed
+  _worldImpact(pr) {
+    this.game.vfx?.playFx?.('impact_dirt', { pos: pr.obj.position, scale: 1 });
+    if (Math.random() < 0.3) this.game.audio?.play('ricochet');
+  }
+
+  // ONE BULLET-VS-BODY TEST, for every kind of body there is: the outlaws (combat.enemies), the
+  // townsfolk (game.npcs) and the men on the coach (coach.crew). They all keep the same contract —
+  // a .position AT THE FEET, .alive, .maxHealth, .takeDamage — so there is no reason for this to
+  // exist three times, and every reason for it not to: the headshot branch lived inside the enemy
+  // loop, so the first pass at shootable civilians gave the town bodies you could not shoot in the
+  // head. One helper, three lists. Returns true if the round landed and the bullet dies here.
+  //
+  // opts.attacker is who fired: a civilian reads it to know whose crime this was (npc.js), because
+  // an outlaw's stray round through a barman is not the player's murder.
+  _bulletHit(pr, e, from = null) {
+    // WHERE THE ROUND CROSSES HIM — one shared body model and one intersection test (aim.js), the
+    // same one the reticle and the aim use. When these were separate copies they disagreed, and the
+    // disagreement was invisible: green light, bang, nothing falls.
+    const p1 = from ?? _seg.copy(pr.obj.position).addScaledVector(pr.dir, -pr.speed * (1 / 60));
+    const cross = segmentCapsule(p1, pr.obj.position, e.position);
+    if (!cross) return false;
+    const impactY = e.position.y + cross.hitY;
+    const by = pr.shooter ?? this.game.player;
+    e.provoke?.();                                   // an outlaw turns on you; a townsman has no provoke
+    // WHERE you hit him matters. The body was ONE sphere at chest height, so a round through the
+    // hat and a round through the belly did exactly the same thing. A bullet in the head ends a
+    // man: no damage arithmetic, no health bar, no second shot.
+    // HEAD_Y is measured from the FEET (e.position is at ground) — these bodies stand ~1.8m,
+    // shoulders ~1.4, so anything landing above 1.5 went in above the collar. A SEATED man is
+    // folded up and has no feet on any ground, so the coach publishes the datum his feet WOULD be
+    // on if he stood up (seatedRider.js) — which is the only reason this same line works on him.
+    const hitY = cross.hitY;
+    if (hitY >= BODY.head) {
+      const at = e.position.clone().setY(e.position.y + 1.62);
+      e.takeDamage(e.maxHealth * 10, by.position, { knockback: 0.35, attacker: by });
+      this.game.ui?.showDamage(e, 'HEADSHOT');
+      this.game.vfx.hit(at);
+      this.game.vfx.blood(at, pr.dir.clone().setY(pr.dir.y + 0.5), 2.6);   // it makes a mess
+      this.game.audio?.play('hit');
+      this.game.shakeT = Math.max(this.game.shakeT ?? 0, 0.12);
+    } else {
+      e.takeDamage(pr.damage, by.position, { knockback: 0.15, attacker: by });
+      this.game.ui?.showDamage(e, Math.round(pr.damage));
+      this.game.vfx.hit(e.position.clone().setY(e.position.y + 1.1));
+      this._fleshImpact(pr, e);
+      this.game.audio?.play('hit');
+    }
+    // THE RETICLE GOES RED — but only for the man holding the gun. An outlaw's round finding a
+    // townsman is not YOUR hit and must not be reported as one; at 40m in bright desert the blood
+    // spray is four pixels and the mark is the only honest answer to "did I connect?".
+    if (by === this.game.player) {
+      this.game.ui?.hitMark(!e.alive);
+      // WHAT THE COUNTY KNOWS ABOUT YOU. Every man you put down is one the next one has heard about,
+      // and the men they send after that are better shots (enemy.js, AIM). It is the only progression
+      // this game keeps, and it is kept HERE because this is the one place a death by your hand is
+      // certain — the loot, the crime and the objective systems all watch different halves of it.
+      if (!e.alive) this.playerKills = (this.playerKills ?? 0) + 1;
+    }
+    return true;
+  }
+
+  // bullet met flesh — blood jet along the bullet's line, pool sometimes
+  _fleshImpact(pr, victim) {
+    const at = victim.position.clone().setY(victim.position.y + 1.1);
+    this.game.vfx.blood(at, pr.dir.clone().setY(pr.dir.y + 0.4), 1.5);
+    if (Math.random() < 0.4) {
+      const gy = this.game.world.groundAt(victim.position.x, victim.position.z);
+      this.game.vfx.bloodDecal({ x: victim.position.x, y: gy, z: victim.position.z });
+    }
+  }
+
+  // ---------- frame update ----------
+
+  update(dt) {
+    const p = this.game.player;
+
+    // ATTACK DIRECTOR (AC ring): of the melee enemies engaging the player, only the
+    // closest TWO hold an attack token — they close in and swing; the rest prowl the
+    // ring (enemy.js _circle) until a token frees up. Turns "mob pile-on" into the
+    // circling pressure fight. Re-dealt 4x/sec — cheap, and tokens naturally rotate as
+    // staggers/kills reshuffle distance order.
+    this._tokenT = (this._tokenT ?? 0) - dt;
+    if (this._tokenT <= 0) {
+      this._tokenT = 0.25;
+      const engaged = [];
+      for (const e of this.enemies) {
+        if (!e.alive || e.def.ranged) continue;
+        if (e.state !== 'chase' && e.state !== 'attack') continue;
+        const d = Math.hypot(e.position.x - p.position.x, e.position.z - p.position.z);
+        if (d < 9) engaged.push([d, e]);
+        else e._token = undefined;   // out of the fight — no ring behaviour
+      }
+      engaged.sort((a, b) => a[0] - b[0]);
+      engaged.forEach(([, e], i) => { e._token = i < 2; });
+    }
+
+    // FINISHER TARGET: the nearest staggered, weakened, un-bossy foe close in front of
+    // the player, fists only. main.js shows 'F — Finish'; player.js consumes F. Lock-on
+    // wins ties; a short grace latch stops the prompt strobing when staggerT expires
+    // between the glance and the press.
+    this.finishTarget = null;
+    const pFree = p.alive && !p.busy && p.weapon === 'fists' && !p.riding?.mounted;
+    if (pFree) {
+      let hostiles = 0;
+      for (const e of this.enemies) {
+        if (e.alive && foes(e.faction, 'player')
+          && Math.hypot(e.position.x - p.position.x, e.position.z - p.position.z) < 10) hostiles++;
+      }
+      const hpGate = hostiles <= 1 ? FINISH_HP_LAST : FINISH_HP;
+      const geom = (e, slack = 0) => {                 // close + in front + visible
+        const d = dist2D(p.position.x, p.position.z, e.position.x, e.position.z);
+        if (d > FINISH_RANGE + slack) return Infinity;
+        const ang = Math.atan2(e.position.x - p.position.x, e.position.z - p.position.z);
+        let da = Math.abs(ang - p.heading) % (Math.PI * 2);
+        if (da > Math.PI) da = Math.PI * 2 - da;
+        if (da > FINISH_ARC + slack * 0.15) return Infinity;
+        if (this.game.world.losBlocked(p.position, e.position)) return Infinity;
+        return d;
+      };
+      const eligible = (e) => e.alive && foes(e.faction, 'player') && !e.def.boss && !e.def.phase2
+        && e.staggerT > 0 && e.health / e.maxHealth < hpGate;
+      let bestD = Infinity;
+      for (const e of this.enemies) {
+        if (!eligible(e)) continue;
+        const d = geom(e);
+        if (d < bestD) { bestD = d; this.finishTarget = e; }
+      }
+      // the locked-on foe outranks nearest-eligible (matches every other attack here)
+      const lk = p.lockTarget;
+      if (lk && lk !== this.finishTarget && eligible(lk) && geom(lk) < Infinity) this.finishTarget = lk;
+      if (this.finishTarget) {
+        this._finishGrace = { e: this.finishTarget, t: 0.4 };
+        this.game.hint?.('finisher', 'F — finish a staggered, weakened foe.');
+      } else if (this._finishGrace) {
+        // stagger just lapsed but the foe's still dying on its feet — honour the prompt briefly
+        const g = this._finishGrace; g.t -= dt;
+        const e = g.e;
+        if (g.t > 0 && e.alive && foes(e.faction, 'player') && !e.def.boss && !e.def.phase2
+          && e.health / e.maxHealth < hpGate && geom(e, 0.5) < Infinity) this.finishTarget = e;
+        else this._finishGrace = null;
+      }
+    } else { this._finishGrace = null; }
+
+    // finisher impact beat: game-time, not wall-clock — it pauses with the menu and can
+    // never land after the victim was evicted (setTimeout could do both)
+    if (this._finishHit) {
+      this._finishHit.t -= dt;
+      if (this._finishHit.t <= 0) { const fh = this._finishHit; this._finishHit = null; this._finishImpact(fh.e); }
+    }
+
+    // enemies
+    for (let i = this.enemies.length - 1; i >= 0; i--) {
+      const e = this.enemies[i];
+      e.update(dt);
+      e.applyDescentSmoothing(dt);
+      // HE HAD MONEY ON HIM. Dropped ONCE, the moment he goes down — not when the body is evicted
+      // (that is 6 seconds later and, for a pooled lawman, never happens at all), and not every
+      // frame he is lying there. The civilians and the coach crew were paying out from the day the
+      // system landed; the outlaws — the men the game actually asks you to shoot — never did,
+      // because nobody wired the one list that matters.
+      if (!e.alive && !e._looted) {
+        e._looted = true;
+        // THE LAST MAN CARRIES THE TAKINGS. Kill the fourth of the four and he is holding what the
+        // gang stole — so the job pays, and it pays AT the moment the job is finished rather than
+        // as a number that appears in a corner of the screen. You have to walk over and pick it up,
+        // standing where you shot him, which is the difference between being paid and being
+        // congratulated. (Guarded on `objective` so it can't fire for the ordinary hostiles.)
+        const last = e.objective && !this.enemies.some((o) => o !== e && o.alive && o.objective);
+        this.game.loot?.dropFor?.(e.type ?? 'outlaw', e.position, last ? BOUNTY : 1);
+        if (last) this.game.ui?.toast?.('The gang is finished. He was carrying their takings.');
+      }
+      // EVICTION, AND WHO IS EXEMPT FROM IT. Pulling a skinned mesh out of the scene evicts its
+      // render objects AND their pipelines from r184's cache, and the four objective outlaws have
+      // always paid that (once, in town, where you are standing over them). A wilderness camp
+      // must not: `noEvict` bodies lie in the dirt where they fell, resident for life, costing one
+      // distanceTo a frame past the cull. It is also better fiction — a cleared camp looks cleared.
+      if (e.dead && !e.noEvict) {
+        this.game.vatRoster?.release(e.vatProxy);
+        this.game.scene.remove(e.root);
+        e.spawner?.alive.splice(e.spawner.alive.indexOf(e), 1);
+        this.enemies.splice(i, 1);
+      }
+    }
+
+    // respawns. spawn() is async and only pushes to s.alive in .then(), so s.alive.length
+    // lags behind in-flight spawns — without counting pending ones, several respawns fire
+    // before any resolves and the spawner overshoots s.count (a slow enemy leak).
+    for (const s of this.spawners) {
+      if (!s.respawn) continue;
+      if (s.alive.length + (s.pending ?? 0) < s.count) {
+        s.timer += dt;
+        if (s.timer > s.respawn && dist2D(p.position.x, p.position.z, s.x, s.z) > 50) {
+          s.timer = 0;
+          s.pending = (s.pending ?? 0) + 1;
+          const a = Math.random() * Math.PI * 2;
+          this.spawn(s.type, s.x + Math.sin(a) * 5, s.z + Math.cos(a) * 5, { leashR: s.leashR }).then((e) => {
+            e.spawner = s;
+            s.alive.push(e);
+            s.pending--;
+          });
+        }
+      }
+    }
+
+    // The coach crew are children of a MOVING coach, and main.js ticks combat BEFORE the coaches —
+    // so without this every round is tested against where the driver was last frame. Only when
+    // there is actually a round in the air; two sines and twelve position writes.
+    if (this.projectiles.length) this.game.coaches?.syncRiders?.();
+
+    // bullets — straight flight, no gravity; expiry from range/speed
+    for (let i = this.projectiles.length - 1; i >= 0; i--) {
+      const pr = this.projectiles[i];
+      pr.age += dt;
+      _prevPos.copy(pr.obj.position);
+      pr.obj.position.addScaledVector(pr.dir, pr.speed * dt);
+      let dead = pr.age > pr.ttl;   // ranged out — vanish quietly, no impact
+      let struck = false;           // world hit → dust + ricochet
+
+      const ground = this.game.world.groundAt(pr.obj.position.x, pr.obj.position.z);
+      if (!dead && pr.obj.position.y < ground + 0.05) { dead = struck = true; }
+
+      // buildings/rocks stop shots: sweep this frame's movement segment against the world
+      // BVH (the same geometry moveCapsule collides with) — tunnel-proof at bullet speed,
+      // and genuinely 3D so a shot over a roof misses. Trees/fences live in the 2D collider
+      // list instead (alt-gate so high shots clear them).
+      if (!dead && this.game.world.segmentBlocked(_prevPos, pr.obj.position)) dead = struck = true;
+      const alt = pr.obj.position.y - ground;
+      if (!dead && alt < 7) {
+        const c = this.game.world.collide(pr.obj.position.x, pr.obj.position.z, 0.25, alt, pr.obj.position.y);
+        if (Math.abs(c.x - pr.obj.position.x) + Math.abs(c.z - pr.obj.position.z) > 1e-6) dead = struck = true;
+      }
+
+      if (!dead && pr.friendly) {
+        // THE OUTLAWS.
+        for (const e of this.enemies) {
+          if (!e.alive || e === pr.shooter || e.faction === 'ally') continue;
+          if (this._bulletHit(pr, e, _prevPos)) { dead = true; break; }
+        }
+        // THE TOWNSFOLK. Bullets used to pass straight through them — you could empty a revolver
+        // into a barman and he carried on polishing the glass. They live in game.npcs, not in
+        // this.enemies, which is exactly why they were never tested.
+        // ...AND NOT THE CHILDREN. `noTarget` (npc.js): the round passes clean through. There is
+        // no damage arithmetic here to get wrong, because there is no code path from a bullet to a
+        // child's health at all.
+        if (!dead) {
+          for (const n of this.game.npcs ?? []) {
+            if (!n.alive || n === pr.shooter || n.noTarget) continue;
+            if (this._bulletHit(pr, n, _prevPos)) { dead = true; break; }
+          }
+        }
+        // THE MEN ON THE COACH — driver, guard, and whoever is actually riding today (coach.crew
+        // is only the visible ones: a fare who isn't aboard must not stop a bullet).
+        if (!dead) {
+          for (const c of this.game.coaches?.coaches ?? []) {
+            for (const r of c.crew) {
+              if (!r.alive) continue;
+              if (this._bulletHit(pr, r, _prevPos)) { dead = true; break; }
+            }
+            if (dead) break;
+          }
+        }
+        // bullets smash props they fly into (bottles on the saloon rail)
+        if (!dead && this.game.smashables?.tryPoint(pr.obj.position, 0.75, pr.dir)) dead = true;
+        // THE COUNTY'S GAME. Deer and wolf are VAT herd instances, not entities — hunting.js owns
+        // the sphere test, the death take, and the carcass the round leaves behind.
+        if (!dead && this.game.hunting?.bulletHit(pr, _prevPos)) dead = true;
+      } else if (!dead && p.alive && pr.obj.position.distanceTo(tmpV1.copy(p.position).setY(p.position.y + 1.2)) < 0.9) {
+        p.takeDamage(pr.damage, pr.shooter?.position ?? pr.obj.position);
+        this._fleshImpact(pr, p);
+        dead = true;
+      } else if (!dead && !pr.friendly) {
+        // hostile shots also strike allies, should any ever exist
+        for (const e of this.enemies) {
+          if (!e.alive || e.faction !== 'ally') continue;
+          if (pr.obj.position.distanceTo(tmpV1.copy(e.position).setY(e.position.y + 1.1)) < 0.9) {
+            e.takeDamage(pr.damage, pr.obj.position);
+            this._fleshImpact(pr, e);
+            dead = true;
+            break;
+          }
+        }
+      }
+
+      if (dead) {
+        if (struck) this._worldImpact(pr);
+        this.game.scene.remove(pr.obj);
+        this.projectiles.splice(i, 1);
+      }
+    }
+  }
+}