Blame for sim.js

// Turfbreak simulation: operators with real 3D bodies (feet height, gravity, jump, mantling onto cover, crouch,
// slide, sprint, aim-down-sights), hitscan rays in 3D with head and body hitboxes (headshot multipliers), a sidearm
// slot, bots that take cover, crouch behind low walls, peek and shoot only along a real line of sight, charges, zones
// (Turf = Domination), killstreaks (Recon Drone, Sentry, Skyfall Strike), scoring and a 30 Hz history of the whole
// match for kill-cams from the killer's eyes and the "play of the match" replay. Pure and deterministic for a seed +
// inputs (fixed 60 Hz steps), no DOM, no three.js.
// Mature tone, no gore: a tagged-out operator breaks into sparks and redeploys at the crew's spawn.
// (c) 2026 CyberMax. All rights reserved.
import { rng, WEAPONS, WEAPON_IDS, ARMS, PERK_IDS, STREAKS, TEAMS, BODY, collide, collide3, groundAt, mantleTarget, rayHit3, los3, dir3, rayBody, field, steer, inBox } from './core.js';

export const DT = 1 / 60;
export const HS = 13; // floats per operator per history frame
// Movement feel (see FEEL.md): linear ground acceleration and friction, Quake-style air control that keeps momentum,
// a snappy 1.25 m jump with coyote time and a jump buffer, and a sprint-slide you can hop out of.
const GRAV = 20, JUMP = 7.05, WALK = 6.4, ACC_G = 70, FRIC = 64, ACC_A = 22, COYOTE = 0.1, JBUF = 0.12;
const SLIDE_V = 10.8, SLIDE_T = 0.75, SLIDE_FRIC = 5.5, SLIDE_CD = 0.9;
/** Spawn protection (s): no damage, bots ignore you; it ends early the moment you fire. */
export const PROT = 2.0;
const lerp = (a, b, t) => a + (b - a) * t;
const approach = (v, t, step) => (v < t ? Math.min(t, v + step) : Math.max(t, v - step));
const CALLSIGNS = ['RAZOR', 'VANTA', 'NOMAD', 'HEX', 'KILO', 'RUNE', 'SABLE', 'ONYX', 'DRIFT', 'VOLT', 'ASH', 'CIPHER', 'MOTH', 'FLINT', 'JINX', 'NOVA', 'RIFT', 'STATIC', 'WRAITH', 'BISHOP', 'ECHO', 'GRIT', 'HAVOC', 'LYNX'];

const angDiff = (a, b) => { let d = b - a; while (d > Math.PI) d -= 2 * Math.PI; while (d < -Math.PI) d += 2 * Math.PI; return d; };
/** Eye position of an operator (world). */
export const eyeOf = (e) => [e.x, e.y + BODY.eye + (BODY.eyeC - BODY.eye) * e.crouch, e.z];
const chestOf = (e) => [e.x, e.y + 1.05 - 0.32 * e.crouch, e.z];
const headOf = (e) => [e.x, e.y + BODY.head + (BODY.headC - BODY.head) * e.crouch, e.z];
/** The weapon an operator holds right now. */
export const armOf = (e) => ARMS[e.slot === 1 ? 'p9' : e.weapon];

/**
 * opts: { map, seed, mode: 'turf'|'showdown', you: {name, weapon, perk, skin}, hard, size (per team), time (s), target,
 *   skill (0..1, how sharp the bots against you are; 0.5 = normal, hard = 1), rookie (first match ever: one enemy
 *   walks straight to the middle zone so the new player meets an easy first fight) }
 */
export function createMatch(opts) {
  const { map } = opts;
  const R = rng((opts.seed || 1) ^ 0x9E3779B9);
  const mode = opts.mode || 'turf';
  const size = opts.size || (mode === 'showdown' ? 3 : 4);
  const skill = opts.hard ? 1 : Math.max(0, Math.min(1, opts.skill != null ? opts.skill : 0.5));
  const G = {
    map, mode, R, t: 0, tick: 0, over: false, winner: -1, hard: !!opts.hard, skill,
    time: opts.time || (mode === 'showdown' ? 60 : 180), left: 0, target: opts.target || 200,
    score: [0, 0], rounds: [0, 0], round: 1, roundOver: 0, toWin: 4,
    zones: map.zones.map((z) => ({ ...z, owner: -1, prog: 0, contest: false, n: [0, 0] })),
    ents: [], charges: [], strikes: [], sentries: [], recon: [0, 0], events: [], hist: [], histEv: [], feed: [],
    you: null, lastKill: null, cover: coverSpots(map),
  };
  G.left = G.time;
  const used = new Set(); const names = CALLSIGNS.slice();
  const pickName = () => { let n; do { n = names[Math.floor(R() * names.length)]; } while (used.has(n) && used.size < names.length); used.add(n); return n; };
  if (opts.you) used.add(opts.you.name);
  let id = 0;
  for (const team of [0, 1]) for (let k = 0; k < size; k++) {
    const isYou = team === 0 && k === 0 && !!opts.you;
    const w = isYou ? (opts.you.weapon || 'vk9') : WEAPON_IDS[Math.floor(R() * WEAPON_IDS.length)];
    const perk = isYou ? (opts.you.perk || 'plated') : PERK_IDS[Math.floor(R() * PERK_IDS.length)];
    const e = {
      id: id++, team, bot: !isYou, you: isYou, name: isYou ? opts.you.name : pickName(), skin: isYou ? (opts.you.skin || 0) : Math.floor(R() * 3),
      weapon: w, perk, x: 0, y: 0, z: 0, vx: 0, vy: 0, vz: 0, yaw: 0, pitch: 0, crouch: 0, ground: true, sprint: false, ads: 0,
      hp: 100, maxHp: 100, alive: true, respawn: 0, spawnT: 0, slot: 0, mags: [WEAPONS[w].mag, ARMS.p9.mag], bloom: 0,
      ammo: WEAPONS[w].mag, reload: 0, cd: 0, firing: 0, dash: 0, dashCd: 0, nades: 2, lastHit: -9, lastFire: -9, lastHitBy: -1, trig: false,
      streak: 0, bestStreak: 0, kills: 0, deaths: 0, caps: 0, assists: 0, heads: 0, score: 0, dmgBy: {}, owned: [],
      ai: { zone: null, target: null, react: 0, err: 0, errP: 0, strafe: 1, strafeT: 0, think: 0, retreat: 0, nadeT: 2 + R() * 4, wander: 0, cover: null, coverT: 0, peekT: 0, lostT: 0, lastSeen: null, burst: 0 },
      killer: null, moving: 0, kick: 0, revealT: 0, slide: 0, slideCd: 0, airT: 0, jumpBuf: 0, jumped: false, prot: 0,
      // bots against you get the match skill; your own teammates are never worse than normal
      skill: !opts.you ? skill : team === 0 ? Math.max(skill, 0.55) : skill,
    };
    G.ents.push(e);
    if (isYou) G.you = e;
  }
  if (opts.you && opts.rookie) { // first match: the nearest enemy heads straight for B, a little slower on the trigger
    const r = G.ents.find((e) => e.team === 1); r.skill = Math.min(r.skill, 0.05); r.ai.zone = G.zones[1]; r.ai.think = 9; r.rookie = true;
  }
  for (const e of G.ents) spawn(G, e, true);
  return G;
}

/** Candidate cover spots: points hugging every box tall enough to hide a crouched body, on its four sides. */
function coverSpots(map) {
  const out = [];
  for (const o of map.obstacles) {
    if (o.h < 1.0 || Math.abs(o.x) > 46 || Math.abs(o.z) > 50 || o.kind === 'wall' || o.kind === 'lamp') continue;
    const low = o.h < 1.7;
    const pts = [];
    for (const s of [-1, 1]) {
      for (const f of (o.w > 4 ? [-0.3, 0.3] : [0])) pts.push([o.x + f * o.w, o.z + s * (o.d / 2 + 0.75)]);
      for (const f of (o.d > 4 ? [-0.3, 0.3] : [0])) pts.push([o.x + s * (o.w / 2 + 0.75), o.z + f * o.d]);
    }
    for (const [x, z] of pts) {
      if (Math.abs(x) > 45 || Math.abs(z) > 49) continue;
      if (map.obstacles.some((q) => inBox(q, x, z, 0.5))) continue;
      out.push({ x, z, low, o });
    }
  }
  return out;
}

function spawn(G, e, first) {
  const pts = G.map.spawns[e.team]; const k = G.ents.filter((o) => o.team === e.team).indexOf(e);
  let p = pts[k % pts.length];
  if (!first) { // redeploy at the spawn point farthest from every living enemy (no spawn-camping)
    let best = -1;
    for (const q of pts) { let near = 1e9; for (const o of G.ents) if (o.team !== e.team && o.alive) near = Math.min(near, Math.hypot(o.x - q.x, o.z - q.z)); near += G.R() * 3; if (near > best) { best = near; p = q; } }
  }
  e.x = p.x + (G.R() - 0.5) * 2; e.z = p.z + (G.R() - 0.5) * 1.5; e.yaw = p.yaw; e.pitch = 0; e.vx = e.vz = e.vy = 0; e.y = 0; e.ground = true; e.crouch = 0;
  e.maxHp = e.perk === 'plated' ? 130 : 100; e.hp = e.maxHp; e.alive = true; e.spawnT = G.t; e.prot = G.t + PROT; e.dmgBy = {};
  e.slot = 0; e.mags = [WEAPONS[e.weapon].mag, ARMS.p9.mag]; e.ammo = e.mags[0]; e.reload = 0; e.cd = 0.3; e.nades = 2; e.streak = 0; e.dash = 0; e.dashCd = 0; e.bloom = 0; e.ads = 0;
  e.slide = 0; e.slideCd = 0; e.airT = 0; e.jumpBuf = 0; e.jumped = false;
  const keepZone = first && e.rookie;
  e.ai.target = null; e.ai.react = 0; if (!keepZone) { e.ai.zone = null; e.ai.think = 0; } e.ai.cover = null; e.ai.lastSeen = null;
}

const ev = (G, e) => { e.tick = G.tick; G.events.push(e); G.histEv.push(e); };

/** Can `m` see operator `o`? (eye to head or chest, real 3D line of sight) */
function sees(G, m, o) {
  const a = eyeOf(m); const h = headOf(o); if (los3(G.map, a[0], a[1], a[2], h[0], h[1], h[2])) return 'head';
  const c = chestOf(o); if (los3(G.map, a[0], a[1], a[2], c[0], c[1], c[2])) return 'chest';
  return null;
}

export const canSee = (G, m, o) => !!sees(G, m, o);
/** Is enemy `o` visible to team `team`? (line of sight from any alive teammate, a fresh shot, or the recon drone) */
export function spotted(G, team, o) {
  if (!o.alive) return false;
  if (G.recon[team] > 0 && o.perk !== 'ghost') return true;
  if (G.t - o.lastFire < 0.7) return true;
  for (const m of G.ents) if (m.team === team && m.alive && Math.hypot(m.x - o.x, m.z - o.z) < 48 && sees(G, m, o)) return true;
  return false;
}

/** Current spread (radians, half-angle) of an operator's weapon: hip vs aimed, moving, airborne, crouched, bloom. */
export function spreadOf(e) {
  const W = armOf(e); const mv = Math.hypot(e.vx, e.vz);
  if (W.id === 'breach') return W.spread * (1 - 0.35 * e.ads) + e.bloom;
  // the first aimed shot from a steady stance goes exactly where the crosshair / dot is
  if (e.ads > 0.95 && mv < 1 && e.ground && e.bloom < 0.002) return 0;
  const s = W.spread * (1 - 0.88 * e.ads) * (mv > 1 ? 1 + 0.6 * Math.min(1, mv / WALK) : 0.8) * (e.ground ? 1 : 2.2) * (1 - 0.22 * e.crouch);
  return s + e.bloom * (1 - 0.5 * e.ads);
}

/** What the operator's crosshair is on: { ent, dist, head } for the first enemy along the exact view ray, else null. */
export function aimTarget(G, e, maxD = 80) {
  const o = eyeOf(e); const d = dir3(e.yaw, e.pitch);
  const wall = rayHit3(G.map, o[0], o[1], o[2], o[0] + d[0] * maxD, o[1] + d[1] * maxD, o[2] + d[2] * maxD).f * maxD;
  let best = null;
  for (const q of G.ents) { if (q.team === e.team || !q.alive) continue; const h = rayBody(o, d, q.x, q.y, q.z, q.crouch); if (h && h.t < wall && (!best || h.t < best.dist)) best = { ent: q, dist: h.t, head: h.head }; }
  return best;
}

// ---------------------------------------------------------------- shooting
function fire(G, e) {
  const W = armOf(e);
  e.cd = W.cd; e.ammo -= 1; e.mags[e.slot] = e.ammo; e.lastFire = G.t; e.firing = 0.08; e.kick = W.kick; e.prot = 0; // firing ends spawn protection
  const o = eyeOf(e); const sp = spreadOf(e);
  for (let p = 0; p < W.pellets; p++) {
    // spread: uniform in a cone; bots add their aim error
    const a = G.R() * Math.PI * 2, r = Math.sqrt(G.R()) * sp;
    const yaw = e.yaw + Math.cos(a) * r + (e.bot ? e.ai.err : 0), pitch = e.pitch + Math.sin(a) * r + (e.bot ? e.ai.errP : 0);
    const d = dir3(yaw, pitch); const L = W.range * 2.4;
    const wh = rayHit3(G.map, o[0], o[1], o[2], o[0] + d[0] * L, o[1] + d[1] * L, o[2] + d[2] * L); let best = wh.f * L; let hit = null, head = false;
    for (const q of G.ents) {
      if (q.team === e.team || !q.alive) continue;
      const h = rayBody(o, d, q.x, q.y, q.z, q.crouch);
      if (h && h.t < best) { best = h.t; hit = q; head = h.head; }
    }
    let hitS = null;
    for (const s of G.sentries) {
      if (s.team === e.team || s.hp <= 0) continue;
      const h = rayBody(o, d, s.x, 0, s.z, 0.55); if (h && h.t < best) { best = h.t; hit = null; head = false; hitS = s; }
    }
    const x1 = o[0] + d[0] * best, y1 = o[1] + d[1] * best, z1 = o[2] + d[2] * best;
    ev(G, { k: 'shot', from: e.id, w: W.id, x0: o[0], y0: o[1] - 0.12, z0: o[2], x1, y1, z1, hit: hit ? hit.id : hitS ? -2 : -1, hs: head, nx: hit || hitS ? 0 : wh.nx, ny: hit || hitS ? 0 : wh.ny, nz: hit || hitS ? 0 : wh.nz, team: e.team, world: !hit && !hitS && wh.f < 1 });
    if (hit) {
      const fall = W.id === 'breach' ? Math.max(0.3, 1 - best / W.range) : best > W.range ? 0.72 : best > W.range * 0.7 ? 0.86 : 1;
      // bots ease off a human while the match skill is low (new players), full damage from skill 1
      const easy = e.bot && hit.you ? lerp(0.55, 1, Math.min(1, e.skill * 1.6)) : 1;
      damage(G, hit, W.dmg * fall * (head ? W.hs : 1) * easy, e, W.id, head, [x1, y1, z1]);
    } else if (hitS) { hitS.hp -= W.dmg; if (hitS.hp <= 0) ev(G, { k: 'boom', x: hitS.x, y: 0.8, z: hitS.z, r: 2, small: true }); }
  }
  e.bloom = Math.min(W.spread * 2.5 + 0.03, e.bloom + W.bloom);
  if (e.ammo <= 0) startReload(e);
}
function startReload(e) { const W = armOf(e); if (e.reload > 0 || e.ammo >= W.mag) return; e.reload = W.reload * (e.perk === 'quick' ? 0.7 : 1); e.reloadMax = e.reload; }

function damage(G, o, dmg, by, weapon, head = false, at = null) {
  if (!o.alive || G.t < o.prot) return; // spawn protection
  o.hp -= dmg; o.lastHit = G.t; o.lastHitBy = by.id; o.dmgBy[by.id] = (o.dmgBy[by.id] || 0) + dmg;
  ev(G, { k: 'hit', id: o.id, by: by.id, dmg, x: o.x, z: o.z, y: at ? at[1] : o.y + 1, hx: at ? at[0] : o.x, hz: at ? at[2] : o.z, fx: by.x, fz: by.z, hs: head, you: by.you });
  if (o.bot && by.team !== o.team && (o.ai.target == null || G.ents[o.ai.target] && !G.ents[o.ai.target].alive)) { o.ai.target = by.id; o.ai.react = lerp(0.6, 0.2, o.skill); o.ai.lastSeen = { x: by.x, z: by.z, t: G.t }; }
  if (o.hp <= 0) kill(G, o, by, weapon, head);
}

function kill(G, o, by, weapon, head = false) {
  o.alive = false; o.hp = 0; o.deaths++; o.streak = 0; o.respawn = G.mode === 'showdown' ? 1e9 : 4.2; o.killer = by.id;
  by.kills++; by.streak++; by.bestStreak = Math.max(by.bestStreak, by.streak); by.score += 100;
  if (head) { by.heads++; by.score += 25; }
  const inZone = G.zones.find((z) => Math.hypot(o.x - z.x, o.z - z.z) < z.r + 1 && z.owner === by.team);
  if (inZone) by.score += 50;
  for (const [aid, d] of Object.entries(o.dmgBy)) { const a = G.ents[aid]; if (a && a !== by && a.team === by.team && d >= 35) { a.assists++; a.score += 50; } }
  const recent = G.feed.filter((f) => f.by === by.id && G.t - f.t < 4).length;
  const multi = recent + 1;
  if (multi >= 2) by.score += 50 * (multi - 1);
  G.feed.push({ t: G.t, by: by.id, victim: o.id, w: weapon, multi, hs: head });
  G.lastKill = { tick: G.tick, by: by.id, victim: o.id, w: weapon, multi, team: by.team, hs: head };
  ev(G, { k: 'kill', by: by.id, victim: o.id, w: weapon, x: o.x, y: o.y, z: o.z, multi, streak: by.streak, team: by.team, hs: head, fx: by.x, fz: by.z });
  // killstreaks (per life)
  const s = STREAKS.find((k) => k.at === by.streak);
  if (s && by.alive) { by.owned.push(s.id); ev(G, { k: 'streak', id: by.id, s: s.id }); if (by.bot || s.id === 'recon') useStreak(G, by, s.id); }
}

// ---------------------------------------------------------------- killstreaks
export function useStreak(G, e, id = null) {
  const sid = id || e.owned[e.owned.length - 1]; if (!sid) return false;
  const i = e.owned.lastIndexOf(sid); if (i < 0) return false; e.owned.splice(i, 1);
  if (sid === 'recon') { G.recon[e.team] = 12; ev(G, { k: 'recon', team: e.team, id: e.id }); }
  if (sid === 'sentry') { const s = { team: e.team, by: e.id, x: e.x + Math.cos(e.yaw) * 1.2, z: e.z + Math.sin(e.yaw) * 1.2, yaw: e.yaw, hp: 140, life: 22, cd: 0, firing: 0 }; [s.x, s.z] = collide(G.map, s.x, s.z, 0.7); G.sentries.push(s); ev(G, { k: 'sentry', team: e.team, x: s.x, z: s.z, id: e.id }); }
  if (sid === 'skyfall') {
    let a = e.yaw;
    if (e.bot) { // aim at the crowd
      let best = 0; for (const o of G.ents) if (o.team !== e.team && o.alive) { const n = G.ents.filter((p) => p.team === o.team && p.alive && Math.hypot(p.x - o.x, p.z - o.z) < 8).length; if (n > best) { best = n; a = Math.atan2(o.z - e.z, o.x - e.x); } }
    }
    const pts = []; for (let k = 0; k < 7; k++) { const d = 7 + k * 4.4; pts.push({ x: e.x + Math.cos(a) * d, z: e.z + Math.sin(a) * d, t: 1.6 + k * 0.17 }); }
    G.strikes.push({ team: e.team, by: e.id, pts, t: 0 });
    ev(G, { k: 'skyfall', team: e.team, id: e.id, pts: pts.map((p) => [p.x, p.z]) });
  }
  return true;
}

function explode(G, x, z, r, dmg, by, weapon, y = 0.3) {
  ev(G, { k: 'boom', x, y, z, r, by: by ? by.id : -1, w: weapon });
  for (const o of G.ents) {
    if (!o.alive || (by && o.team === by.team && o !== by)) continue;
    const d = Math.hypot(o.x - x, o.z - z, (o.y + 0.9 - y) * 0.6); if (d > r) continue;
    if (!los3(G.map, x, y + 0.4, z, o.x, o.y + 1.0, o.z) && !los3(G.map, x, y + 0.4, z, o.x, o.y + 1.5, o.z)) continue;
    damage(G, o, dmg * (1 - (d / r) * 0.6) * (o === by ? 0.4 : 1), by, weapon);
  }
}

// ---------------------------------------------------------------- bots
const PREF = { breach: 6, lancer: 24, wasp: 10, vk9: 15 };
function think(G, e) {
  const A = e.ai;
  // target: an enemy this bot can actually see (3D line of sight, in its field of view or very close / just fired)
  let tgt = A.target != null ? G.ents[A.target] : null;
  if (tgt && (!tgt.alive || G.t < tgt.prot || Math.hypot(tgt.x - e.x, tgt.z - e.z) > 52)) { tgt = null; A.target = null; }
  if (tgt) { if (sees(G, e, tgt)) { A.lastSeen = { x: tgt.x, z: tgt.z, t: G.t }; A.lostT = 0; } else { A.lostT += 1 / 15; if (A.lostT > 1.4) { tgt = null; A.target = null; } } }
  if (!tgt) {
    let bd = 44;
    for (const o of G.ents) {
      if (o.team === e.team || !o.alive || G.t < o.prot) continue; const d = Math.hypot(o.x - e.x, o.z - e.z);
      if (d >= bd) continue;
      const fov = Math.abs(angDiff(e.yaw, Math.atan2(o.z - e.z, o.x - e.x))) < 1.25;
      const noticed = G.recon[e.team] > 0 || fov || d < 7 || G.t - o.lastFire < 0.6;
      if (noticed && sees(G, e, o)) { bd = d; tgt = o; }
    }
    if (tgt) {
      A.target = tgt.id; A.lastSeen = { x: tgt.x, z: tgt.z, t: G.t }; A.lostT = 0;
      // reaction time and first-aim error follow the bot's skill (0 = rookie lobby, 0.5 = normal, 1 = Veteran)
      const k = e.skill;
      A.react = lerp(0.82, 0.22, k) + G.R() * lerp(0.3, 0.1, k) + (tgt.crouch > 0.5 ? 0.1 : 0) + (tgt.you && k < 0.3 ? 0.12 : 0);
      A.err = (G.R() - 0.5) * lerp(0.46, 0.14, k); A.errP = (G.R() - 0.5) * lerp(0.22, 0.07, k);
    }
  }
  // objective: a zone we don't hold (nearest), sometimes hold one we do
  if (!A.zone || A.think <= 0) {
    A.think = 2 + G.R() * 2;
    const zs = G.zones.slice().sort((a, b) => Math.hypot(a.x - e.x, a.z - e.z) - Math.hypot(b.x - e.x, b.z - e.z));
    const want = zs.filter((z) => z.owner !== e.team);
    A.zone = G.mode === 'showdown' ? G.zones[1] : (want.length && G.R() < 0.82 ? want[Math.min(want.length - 1, G.R() < 0.7 ? 0 : 1)] : zs[Math.floor(G.R() * zs.length)]);
    A.wander = G.R() * Math.PI * 2;
  }
  return tgt;
}

/** The nearest cover spot that blocks the threat's view of a (crouched) body there, and that we can walk to. */
function findCover(G, e, th) {
  let best = null, bd = 13;
  const te = eyeOf(th);
  for (const c of G.cover) {
    const d = Math.hypot(c.x - e.x, c.z - e.z); if (d > bd) continue;
    // the box must sit between the spot and the threat
    if ((c.o.x - c.x) * (th.x - c.x) + (c.o.z - c.z) * (th.z - c.z) <= 0) continue;
    const y = groundAt(G.map, c.x, c.z, 0);
    if (los3(G.map, te[0], te[1], te[2], c.x, y + (c.low ? 0.95 : 1.4), c.z)) continue;
    if (G.ents.some((m) => m !== e && m.alive && m.ai.cover === c)) continue;
    bd = d; best = c;
  }
  return best;
}

function botStep(G, e, dt) {
  const A = e.ai; const W = armOf(e);
  A.think -= dt; A.strafeT -= dt; A.nadeT -= dt; A.coverT -= dt; A.peekT -= dt;
  const tgt = (G.tick + e.id) % 4 === 0 || A.target == null ? think(G, e) : (A.target != null ? G.ents[A.target] : null);
  let mx = 0, mz = 0, fire = false, crouch = false, jump = false;
  const hurt = e.hp < e.maxHp * 0.45 && G.t - e.lastHit < 2.5;
  // switch to the sidearm when the main weapon is empty in a fight at close range, back when safe
  if (tgt && e.slot === 0 && e.ammo === 0 && Math.hypot(tgt.x - e.x, tgt.z - e.z) < 12 && e.mags[1] > 0) setSlot(e, 1);
  else if (!tgt && e.slot === 1 && e.reload <= 0) setSlot(e, 0);
  // want cover? (hurt, reloading or under fire from a target we can't beat in the open)
  if (tgt && !A.cover && A.coverT <= 0 && (hurt || e.reload > 0 || (G.t - e.lastHit < 0.6 && G.R() < 0.35))) {
    A.cover = findCover(G, e, tgt); A.coverT = A.cover ? 4 + G.R() * 2 : 1.5; A.peekT = 1.2 + G.R() * 1.4;
  }
  if (A.cover && (A.coverT <= 0 || !tgt && G.R() < 0.01)) { A.cover = null; A.coverT = 2.5 + G.R() * 2; }
  let lookAt = null;
  if (tgt) {
    const seen = A.lostT === 0;
    const aimP = seen ? (sees(G, e, tgt) === 'head' && G.R() < 0.4 ? headOf(tgt) : chestOf(tgt)) : [A.lastSeen.x, 1.2, A.lastSeen.z];
    const dx = aimP[0] - e.x, dz = aimP[2] - e.z; const d = Math.hypot(dx, dz);
    const eye = eyeOf(e); const wantY = Math.atan2(dz, dx), wantP = Math.atan2(aimP[1] - eye[1], d);
    const k = Math.min(1, dt * lerp(4.5, 13, e.skill)); const settle = lerp(0.45, 1.7, e.skill);
    e.yaw += angDiff(e.yaw, wantY + A.err) * k; e.pitch += (wantP + A.errP - e.pitch) * k;
    A.err *= Math.exp(-dt * settle); A.errP *= Math.exp(-dt * settle);
    A.react -= dt;
    const onTarget = Math.abs(angDiff(e.yaw, wantY)) < 0.22 && Math.abs(e.pitch - wantP) < 0.2;
    // fire in bursts (auto weapons) when it can see the target
    if (A.react <= 0 && seen && d < W.range * 1.5 && onTarget) {
      if (A.burst <= 0) A.burst = W.auto ? 0.35 + G.R() * 0.5 : 0.15; fire = true;
    }
    if (A.burst > 0) { A.burst -= dt; if (A.burst <= 0) { A.react = W.auto ? 0.12 + G.R() * 0.22 : 0.05; } }
    if (A.cover) {
      // move to cover, crouch behind low cover, reload there, then peek out (stand / strafe) to shoot
      const c = A.cover; const cd = Math.hypot(c.x - e.x, c.z - e.z);
      if (cd > 0.6) { const f = field(G.map.nav, c.x, c.z); const [sx, sz] = steer(G.map.nav, f, e.x, e.z); if (sx || sz) { mx = sx; mz = sz; } else { mx = (c.x - e.x) / cd; mz = (c.z - e.z) / cd; } fire = fire && cd < 4; }
      else {
        const peeking = A.peekT < 0 && A.peekT > -1.1 && e.reload <= 0 && !hurt;
        if (A.peekT < -1.1) A.peekT = 0.9 + G.R() * 1.6;
        if (c.low) crouch = !peeking; else if (peeking) { const ux = dx / (d || 1), uz = dz / (d || 1); mx = -uz * A.strafe * 0.9; mz = ux * A.strafe * 0.9; }
        if (!peeking) fire = false;
        if (e.reload <= 0 && e.ammo < W.mag * 0.5 && !peeking) startReload(e);
      }
    } else {
      if (A.strafeT <= 0) { A.strafe = G.R() < 0.5 ? -1 : 1; A.strafeT = 0.5 + G.R() * 1.0; if (G.R() < 0.12 && e.ground) jump = true; if (G.R() < 0.2) A.crouchT = 0.6; }
      const pref = PREF[W.id] || 12;
      const toward = !seen ? 1 : d > pref + 3 ? 1 : d < pref - 4 ? -0.8 : 0;
      const ux = dx / (d || 1), uz = dz / (d || 1);
      if (seen) { mx = ux * toward + -uz * A.strafe * 0.85; mz = uz * toward + ux * A.strafe * 0.85; }
      else { const f = field(G.map.nav, A.lastSeen.x, A.lastSeen.z); const [sx, sz] = steer(G.map.nav, f, e.x, e.z); mx = sx; mz = sz; }
      if ((A.crouchT || 0) > 0) { A.crouchT -= dt; crouch = true; }
      if (A.retreat > 0) { mx = -ux; mz = -uz; }
    }
    // charge at a target hiding behind cover
    if (A.nadeT <= 0 && e.nades > 0 && d > 7 && d < 15 && (!seen || tgt.crouch > 0.5) && G.R() < 0.5) { throwCharge(G, e, tgt.x + (G.R() - 0.5) * 2, tgt.z + (G.R() - 0.5) * 2); A.nadeT = 6 + G.R() * 8; }
    if (G.t - e.lastHit < 0.3 && e.dashCd <= 0 && G.R() < 0.06 && !A.cover) e.dash = 0.3;
    if (e.reload <= 0 && e.ammo === 0) startReload(e);
  } else {
    if (e.reload <= 0 && e.ammo < armOf(e).mag * 0.6) startReload(e);
    const z = A.zone; let gx = z.x, gz = z.z;
    const inZone = Math.hypot(e.x - z.x, e.z - z.z) < z.r - 0.5;
    if (inZone) { A.wander += dt * 0.6; gx = z.x + Math.cos(A.wander + e.id) * z.r * 0.5; gz = z.z + Math.sin(A.wander + e.id) * z.r * 0.5; }
    if (A.retreat > 0) { const sp = G.map.spawns[e.team][0]; gx = sp.x; gz = sp.z; }
    // heard a shot or got hit from somewhere: turn to look
    if (G.t - e.lastHit < 1.2 && e.lastHitBy >= 0) { const b = G.ents[e.lastHitBy]; lookAt = [b.x, b.z]; }
    const f = field(G.map.nav, gx, gz); const [sx, sz] = steer(G.map.nav, f, e.x, e.z);
    const dd = Math.hypot(gx - e.x, gz - e.z);
    if (sx || sz) { mx = sx; mz = sz; } else if (dd > 0.6) { mx = (gx - e.x) / dd; mz = (gz - e.z) / dd; }
    const la = lookAt ? Math.atan2(lookAt[1] - e.z, lookAt[0] - e.x) : (mx || mz) ? Math.atan2(mz, mx) : e.yaw;
    e.yaw += angDiff(e.yaw, la) * Math.min(1, dt * 6); e.pitch += (0 - e.pitch) * Math.min(1, dt * 4);
  }
  if (e.hp < e.maxHp * 0.3 && G.t - e.lastHit < 2 && G.R() < 0.02 && !A.cover) A.retreat = 2.5;
  A.retreat -= dt;
  return { mx, mz, fire, crouch, jump };
}
function setSlot(e, s) { if (e.slot === s) return; e.mags[e.slot] = e.ammo; e.slot = s; e.ammo = e.mags[s]; e.reload = 0; e.cd = Math.max(e.cd, 0.32); e.bloom = 0; }

// ---------------------------------------------------------------- charges
function throwCharge(G, e, tx, tz) {
  if (e.nades <= 0) return; e.nades--;
  let dx = tx - e.x, dz = tz - e.z; const d = Math.hypot(dx, dz) || 1; const L = Math.min(16, d); dx /= d; dz /= d;
  // stop at walls (anything taller than a thrown arc clears)
  const f = rayHit3(G.map, e.x, e.y + 1.6, e.z, e.x + dx * L, e.y + 1.6, e.z + dz * L).f; const land = Math.max(1, L * f - 0.6);
  const lx = e.x + dx * land, lz = e.z + dz * land;
  G.charges.push({ by: e.id, team: e.team, x0: e.x, z0: e.z, y0: e.y + 1.5, x: lx, z: lz, y: groundAt(G.map, lx, lz, 9, 0.1), t: 0, fuse: 1.15, fly: 0.55 });
  ev(G, { k: 'throw', id: e.id });
}

// ---------------------------------------------------------------- the step
/**
 * input (for your operator): { mx, mz (world move, |m| <= 1), yaw, pitch (absolute view), fire, ads, sprint, crouch,
 *   jump, slot (0 main | 1 sidearm), dash, nade, streak, reload }. Legacy top-down aim (ax, az) still works.
 */
export function step(G, input = {}) {
  const dt = DT; G.events.length = 0; if (G.over) return G;
  G.t += dt; G.tick++;
  if (G.roundOver > 0) { G.roundOver -= dt; if (G.roundOver <= 0) nextRound(G); record(G); return G; }
  G.left = Math.max(0, G.left - dt);
  G.recon[0] = Math.max(0, G.recon[0] - dt); G.recon[1] = Math.max(0, G.recon[1] - dt);
  for (const e of G.ents) {
    e.firing = Math.max(0, e.firing - dt); e.kick = Math.max(0, e.kick - dt * 6);
    if (!e.alive) { e.respawn -= dt; if (e.respawn <= 0 && G.mode === 'turf') { spawn(G, e); ev(G, { k: 'spawn', id: e.id }); } continue; }
    let mx = 0, mz = 0, wantFire = false, ads = false, sprint = false, crouch = false, jump = false, slide = false;
    if (e.bot) { const b = botStep(G, e, dt); mx = b.mx; mz = b.mz; wantFire = b.fire; crouch = b.crouch; jump = b.jump; ads = b.fire && armOf(e).id === 'lancer'; }
    else {
      mx = input.mx || 0; mz = input.mz || 0; const l = Math.hypot(mx, mz); if (l > 1) { mx /= l; mz /= l; }
      if (input.ax != null) e.yaw = Math.atan2(input.az - e.z, input.ax - e.x); else if (input.yaw != null) e.yaw = input.yaw;
      if (input.pitch != null) e.pitch = Math.max(-1.45, Math.min(1.45, input.pitch));
      wantFire = !!input.fire; ads = !!input.ads; sprint = !!input.sprint; crouch = !!input.crouch; jump = !!input.jump; slide = !!input.slide;
      if (input.slot != null) setSlot(e, input.slot ? 1 : 0);
      if (input.dash && e.dashCd <= 0) e.dash = 0.32;
      if (input.nade && e.nades > 0 && G.charges.filter((c) => c.by === e.id).length === 0) {
        if (input.ax != null) throwCharge(G, e, input.ax, input.az);
        else { const L = Math.max(4, Math.min(16, 9 + e.pitch * 18)); throwCharge(G, e, e.x + Math.cos(e.yaw) * L, e.z + Math.sin(e.yaw) * L); }
      }
      if (input.streak) useStreak(G, e);
      if (input.reload) startReload(e);
    }
    const W = armOf(e);
    // slide: sprint (or run fast) + crouch on the ground -> a burst of speed that glides out over 0.75 s
    const hv = Math.hypot(e.vx, e.vz);
    if (slide && e.ground && e.slideCd <= 0 && e.slide <= 0 && hv > 4.5) {
      const ux = e.vx / hv, uz = e.vz / hv; const v0 = Math.max(hv, SLIDE_V * W.speed);
      e.vx = ux * v0; e.vz = uz * v0; e.slide = SLIDE_T; e.slideCd = SLIDE_CD + SLIDE_T; ev(G, { k: 'slide', id: e.id });
    }
    e.slideCd = Math.max(0, e.slideCd - dt);
    // stance (linear, so crouch and aim-down-sights take a fixed, predictable time)
    e.crouch = approach(e.crouch, crouch || e.dash > 0 || e.slide > 0 ? 1 : 0, dt / 0.11);
    e.ads = approach(e.ads, ads && e.reload <= 0 && e.dash <= 0 && e.slide <= 0 ? 1 : 0, dt / (W.adsT || 0.16));
    // sprint only forward-ish, never while firing or aiming
    const fwd = mx * Math.cos(e.yaw) + mz * Math.sin(e.yaw);
    e.sprint = sprint && fwd > 0.5 && !wantFire && e.ads < 0.3 && e.crouch < 0.5 && e.slide <= 0;
    // movement
    let sp = WALK * W.speed * (wantFire && W.id === 'lancer' ? 0.8 : 1) * (e.sprint ? 1.34 : 1) * (1 - 0.45 * e.crouch) * (1 - 0.3 * e.ads);
    if (e.dash > 0) { if (e.dashCd <= 0) { e.dashCd = e.perk === 'quick' ? 2.2 : 3.2; ev(G, { k: 'dash', id: e.id }); } e.dash -= dt; sp = 13.5; if (!(mx || mz)) { mx = Math.cos(e.yaw); mz = Math.sin(e.yaw); } }
    e.dashCd = Math.max(0, e.dashCd - dt);
    const tvx = mx * sp, tvz = mz * sp;
    if (e.dash > 0) { const a = Math.min(1, 40 * dt); e.vx += (tvx - e.vx) * a; e.vz += (tvz - e.vz) * a; }
    else if (e.slide > 0 && e.ground) { // glide: low friction, a little steering, never faster
      e.slide -= dt; const v = Math.hypot(e.vx, e.vz); const nv = Math.max(0, v - SLIDE_FRIC * dt);
      if (mx || mz) { e.vx += mx * 9 * dt; e.vz += mz * 9 * dt; }
      const v2 = Math.hypot(e.vx, e.vz) || 1; e.vx *= nv / v2; e.vz *= nv / v2;
      if (nv < 3.2) e.slide = 0;
    } else if (e.ground) { // linear acceleration towards the wished velocity (friction when there is no input)
      let dvx = tvx - e.vx, dvz = tvz - e.vz; const dl = Math.hypot(dvx, dvz); const step = (mx || mz ? ACC_G : FRIC) * dt;
      if (dl > step) { dvx *= step / dl; dvz *= step / dl; } e.vx += dvx; e.vz += dvz;
    } else if (mx || mz) { // air control: steer freely, keep the momentum you had (slide-hops stay fast)
      const cur = Math.hypot(e.vx, e.vz); e.vx += mx * ACC_A * dt; e.vz += mz * ACC_A * dt;
      const cap = Math.max(cur, sp), now = Math.hypot(e.vx, e.vz); if (now > cap) { e.vx *= cap / now; e.vz *= cap / now; }
    }
    if (e.slide > 0 && !e.ground) e.slide = Math.max(0, e.slide - dt);
    // jump (with coyote time after leaving a ledge and a short buffer before landing), gravity, mantle, steps
    e.airT = e.ground ? 0 : e.airT + dt; if (jump) e.jumpBuf = JBUF; else e.jumpBuf = Math.max(0, e.jumpBuf - dt);
    const canJump = (e.ground || (e.airT < COYOTE && e.vy <= 0 && !e.jumped)) && (e.crouch < 0.6 || e.slide > 0);
    let jumpedNow = false;
    if (e.jumpBuf > 0 && canJump) { e.vy = JUMP; e.ground = false; e.jumped = true; e.jumpBuf = 0; e.slide = 0; jumpedNow = true; ev(G, { k: 'jump', id: e.id }); }
    const nx = e.x + e.vx * dt, nz = e.z + e.vz * dt;
    if (!e.ground || jumpedNow) {
      const m = mantleTarget(G.map, nx, nz, e.y + 0.05);
      if (m && e.vy < 3.2 && (mx || mz) && (Math.hypot(mx, mz) > 0.3)) { e.y = m.h; e.vy = 0; e.ground = true; e.jumped = false; ev(G, { k: 'mantle', id: e.id }); }
    }
    [e.x, e.z] = collide3(G.map, nx, nz, e.y, 0.45);
    // the part of the velocity pointing into what we hit is removed (the push direction is the contact normal); the
    // part along the surface is kept, so you slide along walls and around poles and corners instead of sticking
    { const px = e.x - nx, pz = e.z - nz, pl = Math.hypot(px, pz);
      if (pl > 1e-7) { const ux = px / pl, uz = pz / pl; const vn = e.vx * ux + e.vz * uz; if (vn < 0) { e.vx -= vn * ux; e.vz -= vn * uz; } } }
    const g = groundAt(G.map, e.x, e.z, e.y);
    if (e.ground && e.y > g + 0.01) { if (e.y - g <= BODY.step + 0.01 && e.vy <= 0) e.y = g; else e.ground = false; }
    if (!e.ground) { e.vy -= GRAV * dt; e.y += e.vy * dt; if (e.y <= g) { if (e.vy < -7.4) ev(G, { k: 'land', id: e.id, v: e.vy }); e.y = g; e.vy = 0; e.ground = true; e.jumped = false; } }
    else if (e.y < g) e.y = g;
    e.moving = Math.hypot(e.vx, e.vz);
    // weapon
    e.cd -= dt; e.bloom = Math.max(0, e.bloom - dt * (W.bloom * 9 + 0.02));
    const trigger = wantFire && (W.auto || !e.trig); e.trig = wantFire;
    if (e.reload > 0) { e.reload -= dt; if (e.reload <= 0) { e.ammo = W.mag; e.mags[e.slot] = e.ammo; ev(G, { k: 'reloaded', id: e.id }); } }
    else if (trigger && e.cd <= 0 && e.ammo > 0 && G.t - e.spawnT > 0.3 && !e.sprint) fire(G, e);
    else if (wantFire && e.ammo <= 0 && e.reload <= 0) startReload(e);
    // regen
    if (G.t - e.lastHit > 3.6 && e.hp < e.maxHp) e.hp = Math.min(e.maxHp, e.hp + 34 * dt);
  }
  // charges
  for (const c of G.charges) { c.t += dt; if (c.t >= c.fuse && !c.done) { c.done = true; explode(G, c.x, c.z, 4.4, 96, G.ents[c.by], 'charge', (c.y || 0) + 0.2); } }
  G.charges = G.charges.filter((c) => !c.done);
  // skyfall
  for (const s of G.strikes) { s.t += dt; for (const p of s.pts) if (!p.done && s.t >= p.t) { p.done = true; explode(G, p.x, p.z, 4.8, 130, G.ents[s.by], 'skyfall'); } }
  G.strikes = G.strikes.filter((s) => s.pts.some((p) => !p.done));
  // sentries
  for (const s of G.sentries) {
    s.life -= dt; s.cd -= dt; s.firing = Math.max(0, s.firing - dt); if (s.hp <= 0 || s.life <= 0) continue;
    let tgt = null, bd = 20;
    for (const o of G.ents) if (o.team !== s.team && o.alive) { const d = Math.hypot(o.x - s.x, o.z - s.z); const c = chestOf(o); if (d < bd && los3(G.map, s.x, 0.9, s.z, c[0], c[1], c[2])) { bd = d; tgt = o; } }
    if (tgt) {
      const want = Math.atan2(tgt.z - s.z, tgt.x - s.x); s.yaw += angDiff(s.yaw, want) * Math.min(1, dt * 8);
      if (s.cd <= 0 && Math.abs(angDiff(s.yaw, want)) < 0.2) {
        s.cd = 0.13; s.firing = 0.06; const c = chestOf(tgt); const p = Math.atan2(c[1] - 0.9, bd);
        const d = dir3(s.yaw + (G.R() - 0.5) * 0.08, p + (G.R() - 0.5) * 0.06); const o = [s.x + d[0] * 0.6, 0.9, s.z + d[2] * 0.6];
        let best = 22 * rayHit3(G.map, o[0], o[1], o[2], o[0] + d[0] * 22, o[1] + d[1] * 22, o[2] + d[2] * 22).f; let hit = null;
        for (const q of G.ents) { if (q.team === s.team || !q.alive) continue; const h = rayBody(o, d, q.x, q.y, q.z, q.crouch); if (h && h.t < best) { best = h.t; hit = q; } }
        ev(G, { k: 'shot', from: -1, w: 'sentry', x0: o[0], y0: o[1], z0: o[2], x1: o[0] + d[0] * best, y1: o[1] + d[1] * best, z1: o[2] + d[2] * best, hit: hit ? hit.id : -1, team: s.team, nx: 0, ny: 0, nz: 0 });
        if (hit) damage(G, hit, 10, G.ents[s.by], 'sentry');
      }
    }
  }
  G.sentries = G.sentries.filter((s) => s.hp > 0 && s.life > 0);
  // zones
  for (const z of G.zones) {
    z.n = [0, 0];
    if (G.mode === 'showdown' && z.id !== 'B') continue;
    for (const e of G.ents) if (e.alive && Math.hypot(e.x - z.x, e.z - z.z) < z.r && e.y < 3) z.n[e.team]++;
    z.contest = z.n[0] > 0 && z.n[1] > 0;
    if (z.contest) continue;
    const t = z.n[0] > 0 ? 0 : z.n[1] > 0 ? 1 : -1; if (t < 0) continue;
    const dir = t === 0 ? 1 : -1; const rate = 0.3 * Math.min(3, z.n[t]) ** 0.6;
    const before = z.prog; z.prog = Math.max(-1, Math.min(1, z.prog + dir * rate * dt));
    if (z.owner !== t && Math.sign(before) !== Math.sign(z.prog) && z.owner !== -1 && Math.abs(before) > 0) { z.owner = -1; ev(G, { k: 'neutral', zone: z.id }); }
    if (Math.abs(z.prog) >= 1 && z.owner !== t) {
      z.owner = t; ev(G, { k: 'cap', zone: z.id, team: t });
      for (const e of G.ents) if (e.alive && e.team === t && Math.hypot(e.x - z.x, e.z - z.z) < z.r) { e.caps++; e.score += 150; }
      if (G.mode === 'showdown') { endRound(G, t); break; }
    }
  }
  // scoring
  if (G.mode === 'turf') {
    for (const z of G.zones) if (z.owner >= 0) G.score[z.owner] += dt;
    for (const e of G.ents) if (e.alive) for (const z of G.zones) if (z.owner === e.team && Math.hypot(e.x - z.x, e.z - z.z) < z.r) e.score += 10 * dt;
    if (G.score[0] >= G.target || G.score[1] >= G.target || G.left <= 0) finish(G, G.score[0] > G.score[1] ? 0 : G.score[1] > G.score[0] ? 1 : -1);
  } else if (!G.roundOver) {
    const alive = [0, 1].map((t) => G.ents.some((e) => e.team === t && e.alive));
    if (!alive[0] || !alive[1]) endRound(G, alive[0] ? 0 : 1);
    else if (G.left <= 0) { const z = G.zones[1]; endRound(G, z.owner >= 0 ? z.owner : z.prog > 0.05 ? 0 : z.prog < -0.05 ? 1 : (G.ents.filter((e) => e.team === 0 && e.alive).length >= G.ents.filter((e) => e.team === 1 && e.alive).length ? 0 : 1)); }
  }
  record(G);
  return G;
}

function endRound(G, t) {
  if (G.roundOver > 0 || G.over) return;
  G.rounds[t]++; ev(G, { k: 'round', team: t, rounds: G.rounds.slice() });
  for (const e of G.ents) if (e.team === t) e.score += 100;
  if (G.rounds[t] >= G.toWin) finish(G, t); else G.roundOver = 3;
}
function nextRound(G) {
  G.round++; G.left = G.time; G.charges = []; G.strikes = []; G.sentries = []; G.recon = [0, 0];
  for (const z of G.zones) { z.owner = -1; z.prog = 0; }
  for (const e of G.ents) { spawn(G, e, true); e.owned = []; }
  ev(G, { k: 'roundStart', round: G.round });
}
function finish(G, winner) {
  if (G.over) return; G.over = true; G.winner = winner;
  for (const e of G.ents) if (e.team === winner) e.score += 500;
  ev(G, { k: 'end', winner });
}

// ---------------------------------------------------------------- history (30 Hz) for kill-cams and replays
function record(G) {
  if (G.tick % 2) return;
  const s = new Float32Array(G.ents.length * HS);
  G.ents.forEach((e, i) => {
    const o = i * HS; s[o] = e.x; s[o + 1] = e.z; s[o + 2] = e.yaw; s[o + 3] = e.alive ? 1 : 0; s[o + 4] = e.moving; s[o + 5] = e.firing; s[o + 6] = e.hp / e.maxHp; s[o + 7] = e.dash > 0 ? 1 : 0; s[o + 8] = e.kick;
    s[o + 9] = e.y; s[o + 10] = e.pitch; s[o + 11] = e.crouch; s[o + 12] = e.slot + (e.reload > 0 ? 2 : 0) + e.ads * 0.5;
  });
  G.hist.push({ tick: G.tick, t: G.t, s, sentries: G.sentries.map((q) => [q.x, q.z, q.yaw, q.team, q.firing]), zones: G.zones.map((z) => [z.owner, z.prog]), charges: G.charges.map((c) => [c.x0, c.z0, c.x, c.z, c.t, c.fly, c.y0 || 1.5, c.y || 0]) });
}
/** History frame index at or after tick. */
export function histAt(G, tick) { let lo = 0, hi = G.hist.length - 1; while (lo < hi) { const m = (lo + hi) >> 1; if (G.hist[m].tick < tick) lo = m + 1; else hi = m; } return lo; }
/** Events from the history between two ticks (for replays). */
export function histEvents(G, t0, t1) { return G.histEv.filter((e) => e.tick > t0 && e.tick <= t1); }

/** The player's best moment: the window around their biggest multi-kill / streak (else the last kill they made). */
export function bestMoment(G, who = G.you) {
  if (!who) return null;
  const kills = G.histEv.filter((e) => e.k === 'kill' && e.by === who.id);
  if (!kills.length) return null;
  let best = kills[kills.length - 1], score = -1;
  for (const k of kills) { const s = k.multi * 10 + (k.streak >= 5 ? 6 : k.streak >= 3 ? 3 : 0) + (k.w === 'skyfall' ? 4 : 0) + (k.hs ? 2 : 0); if (s >= score) { score = s; best = k; } }
  const first = kills.filter((k) => k.tick <= best.tick && best.tick - k.tick < 60 * 4.5)[0] || best;
  return { t0: Math.max(0, first.tick - 60 * 2.2), t1: best.tick + 60 * 1.4, multi: best.multi, streak: best.streak, w: best.w, hs: !!best.hs };
}

/** Result summary for the player (score card, contract check, challenge links). */
export function result(G) {
  const y = G.you; if (!y) return null;
  const mates = G.ents.slice().sort((a, b) => b.score - a.score);
  return {
    mode: G.mode, map: G.map.id, win: G.winner === y.team, draw: G.winner < 0, score: Math.round(y.score), kills: y.kills, deaths: y.deaths, assists: y.assists, heads: y.heads,
    caps: y.caps, bestStreak: y.bestStreak, weapon: y.weapon, perk: y.perk, team: [Math.round(G.score[0]), Math.round(G.score[1])], rounds: G.rounds.slice(),
    mvp: mates[0].id === y.id, rank: mates.indexOf(y) + 1, board: mates.map((e) => ({ name: e.name, team: e.team, you: e.you, k: e.kills, d: e.deaths, s: Math.round(e.score) })),
  };
}
export { TEAMS };